/**
    * This file Copyright (c) 2008-2014 Magnolia International
    * Ltd.  (http://www.magnolia-cms.com). All rights reserved.
    *
    *
    * This file is dual-licensed under both the Magnolia
    * Network Agreement and the GNU General Public License.
    * You may elect to use one or the other of these licenses.
    *
   * This file is distributed in the hope that it will be
   * useful, but AS-IS and WITHOUT ANY WARRANTY; without even the
   * implied warranty of MERCHANTABILITY or FITNESS FOR A
   * PARTICULAR PURPOSE, TITLE, or NONINFRINGEMENT.
   * Redistribution, except as permitted by whichever of the GPL
   * or MNA you select, is prohibited.
   *
   * 1. For the GPL license (GPL), you can redistribute and/or
   * modify this file under the terms of the GNU General
   * Public License, Version 3, as published by the Free Software
   * Foundation.  You should have received a copy of the GNU
   * General Public License, Version 3 along with this program;
   * if not, write to the Free Software Foundation, Inc., 51
   * Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
   *
   * 2. For the Magnolia Network Agreement (MNA), this file
   * and the accompanying materials are made available under the
   * terms of the MNA which accompanies this distribution, and
   * is available at http://www.magnolia-cms.com/mna.html
   *
   * Any modifications to this file must keep this entire header
   * intact.
   *
   */
  package info.magnolia.module.templatingkit.functions;
  
  import info.magnolia.context.MgnlContext;
  import info.magnolia.dam.api.Asset;
  import info.magnolia.dam.api.AssetQuery;
  import info.magnolia.dam.api.AssetRendition;
  import info.magnolia.dam.asset.LegacyAssetWrapper;
  import info.magnolia.dam.asset.renderer.NoSuchRenditionException;
  import info.magnolia.dam.templating.functions.DamTemplatingFunctions;
  import info.magnolia.jcr.util.ContentMap;
  import info.magnolia.jcr.util.NodeTypes;
  import info.magnolia.jcr.util.NodeUtil;
  import info.magnolia.jcr.util.PropertyUtil;
  import info.magnolia.jcr.wrapper.I18nNodeWrapper;
  import info.magnolia.module.templatingkit.STKModule;
  import info.magnolia.module.templatingkit.categorization.CategorizationSupport;
  import info.magnolia.module.templatingkit.imaging.ImagingSupport;
  import info.magnolia.module.templatingkit.sites.Site;
  import info.magnolia.module.templatingkit.sites.SiteManager;
  import info.magnolia.module.templatingkit.style.CssSelectorBuilder;
  import info.magnolia.module.templatingkit.style.Theme;
  import info.magnolia.module.templatingkit.style.ThemeImpl;
  import info.magnolia.module.templatingkit.templates.AbstractSTKTemplateModel;
  import info.magnolia.module.templatingkit.templates.category.TemplateCategory;
  import info.magnolia.module.templatingkit.templates.category.TemplateCategoryUtil;
  import info.magnolia.rendering.template.TemplateDefinition;
  import info.magnolia.repository.RepositoryConstants;
  import info.magnolia.templating.functions.TemplatingFunctions;
  
  import java.util.ArrayList;
  import java.util.List;
  import java.util.Set;
  
  import javax.inject.Inject;
  import javax.inject.Provider;
  import javax.inject.Singleton;
  import javax.jcr.Node;
  import javax.jcr.RepositoryException;
  
  import org.apache.commons.lang.StringUtils;
  import org.apache.commons.lang.mutable.MutableInt;
  import org.slf4j.Logger;
  import org.slf4j.LoggerFactory;
  
  /**
   * This is an component exposing a couple of methods useful for STK templates.
   * It's exposed in templates as "stkfn".
   */
  @Singleton
  public class STKTemplatingFunctions {
  
      private static Logger log = LoggerFactory.getLogger(STKTemplatingFunctions.class);
  
      public static final String SITEROOT_TEMPLATE_CATEGORY = TemplateCategory.HOME;
  
      protected static final String TITLE_PROP_NAME = "title";
      protected static final String SITE_TITLE_PROP_NAME = "siteTitle";
  
      // Injected variables
      private CssSelectorBuilder cssSelectorBuilder;
      private CategorizationSupport categorizationSupport;
      private final SiteManager siteManager;
      private final TemplatingFunctions templatingFunctions;
      private final Provider<STKModule> moduleProvider;
      private final DamTemplatingFunctions damTemplatingFunctions;
  
     @Inject
     public STKTemplatingFunctions(TemplatingFunctions templatingFunctions, CssSelectorBuilder cssSelectorBuilder, CategorizationSupport categorizationSupport, SiteManager siteManager,
             Provider<STKModule> moduleProvider, DamTemplatingFunctions damTemplatingFunctions) {
         this.templatingFunctions = templatingFunctions;
         this.cssSelectorBuilder = cssSelectorBuilder;
         this.categorizationSupport = categorizationSupport;
         this.siteManager = siteManager;
         this.moduleProvider = moduleProvider;
         this.damTemplatingFunctions = damTemplatingFunctions;
     }
 
     /**
      * Method used to get the SearchPageLink. This Search page Link is defined
      * on the Main PageInfo/Site configuration (Search Page Path to search
      * result page). Method is used from a STKComponent and STKArea Model.
      *
      * @param content
      * : Current Content node.
      * @return relative path to the defined result page i.e.
      * '/magnolia-empty-webapp/demo-project/service/search-result.html'
      */
     public String searchPageLink(Node content) {
         String searchResultPageUUID = PropertyUtil.getString(siteRoot(content), "searchUUID");
         return (StringUtils.isEmpty(searchResultPageUUID)) ? null : templatingFunctions.link(RepositoryConstants.WEBSITE, searchResultPageUUID);
     }
 
     public String searchPageLink(ContentMap content) {
         return searchPageLink(content.getJCRNode());
     }
 
     /**
      * Return the Home Site Name = the physical node's object name.
      */
     public String homeName(Node content) {
         return NodeUtil.getName(siteRoot(content));
     }
 
     public String homeName(ContentMap content) {
         return homeName(content.getJCRNode());
     }
 
     /**
      * Return the HomeTitle value. Referred by the property 'name' of the root
      * Node
      */
     public String homeTitle(Node content) {
         return PropertyUtil.getString(siteRoot(content), TITLE_PROP_NAME);
     }
 
     public String homeTitle(ContentMap content) {
         return homeTitle(content.getJCRNode());
     }
 
     /**
      * Return the SiteTitle value. Referred by the property 'siteTitle' of the
      * root Node
      */
     public String siteTitle(Node content) {
         return PropertyUtil.getString(siteRoot(content), SITE_TITLE_PROP_NAME);
     }
 
     public String siteTitle(ContentMap content) {
         return siteTitle(content.getJCRNode());
     }
 
     /**
      * Return the home link of this site.
      */
     public String homeLink(Node content) {
         return templatingFunctions.link(siteRoot(content));
     }
 
     public String homeLink(ContentMap content) {
         return homeLink(content.getJCRNode());
     }
 
     public Site site() {
         return siteManager.getCurrentSite();
     }
 
     /**
      * Returns the according {@link Site} of the passed content {@link Node}.
      *
      * @param content
      * The {@link Node} to determine its {@link Site} from
      * @return {@link Site} The according {@link Site} of the passed @param
      * content
      */
     public Site site(Node content) {
         try {
             return (content == null) ? null : siteManager.getAssignedSite(content);
         } catch (IllegalStateException e) {
             log.error("Unable to access assigned site ({}) until following issue is resolved: {}", content.toString(), e.getMessage());
             return null;
         }
     }
 
     // TODO dlipp/had: is that a good place to keep that code - you might have
     // to access it from non-template related code. Maybe we shouldn't
     // completely drop STKUtil but
     // keep it for common stuff.
     public Theme theme(Site site) {
         final String theme = site.getTheme().getName();
         return StringUtils.isBlank(theme) ? new ThemeImpl() : moduleProvider.get().getTheme(theme);
 
     }
 
     /**
      * Returns the according {@link Site} of the passed content {@link ContentMap}.
      *
      * @param content
      * The {@link ContentMap} to determine its {@link Site} from
      * @return {@link Site} The according {@link Site} of the passed @param
      * content
      */
     public Site site(ContentMap content) {
         return site(content.getJCRNode());
     }
 
     /**
      * Returns the site's root {@link Node} of the @param content {@link Node}.
      * The root {@link Node} is defined as the page {@link Node} having template
      * category TemplateCategory.HOME. If no ancestor page exists with category
      * TemplateCategory.HOME, the JCR workspace root is returned.
      *
      * @param content
      * The {@link Node} to determine its site root
      * @return {@link Node} The site root {@link Node} of the passed content {@link Node}
      */
     public Node siteRoot(Node content) {
         return this.siteRoot(content, SITEROOT_TEMPLATE_CATEGORY);
     }
 
     /**
      * Returns the site's root {@link ContentMap} of the @param content {@link ContentMap}. The root {@link ContentMap} is defined as the page {@link Node} having template category TemplateCategory.HOME. If no
      * ancestor page exists with category TemplateCategory.HOME, the JCR
      * workspace root is returned.
      *
      * @param content
      * The {@link ContentMap} to determine its site root
      * @return {@link ContentMap} The site root {@link ContentMap} of the passed @param
      * content
      */
     public ContentMap siteRoot(ContentMap content) {
         return this.siteRoot(content, SITEROOT_TEMPLATE_CATEGORY);
     }
 
     /**
      * Returns the site's root {@link Node} of the passed @param content {@link Node}. The root {@link Node} is defined as the page {@link Node} with template its category as @param siteRootTemplateCategory. If no
      * ancestor page exists with category TemplateCategory.HOME, the JCR
      * workspace root is returned.
      *
      * @param content
      * The {@link Node} to determine its site root
      * @param siteRootTemplateCategory
      * The {@link TemplateCategory} value of the site root to detect.
      * If null or EMPTY is passed, the default value
      * SITEROOT_TEMPLATE_CATEGORY is used instead.
      * @return {@link Node} The site root {@link Node} of the passed content {@link Node}
      */
     public ContentMap siteRoot(ContentMap content, String siteRootTemplateCategory) {
         return templatingFunctions.asContentMap(siteRoot(content.getJCRNode(), siteRootTemplateCategory));
     }
 
     /**
      * Returns the site's root {@link Node} of the passed @param content {@link Node}. The root {@link Node} is defined as the page {@link Node} with template its category as @param siteRootTemplateCategory. If no
      * ancestor page exists with category TemplateCategory.HOME, the JCR
      * workspace root is returned.
      *
      * @param content
      * The {@link Node} to determine its site root
      * @param siteRootTemplateCategory
      * The {@link TemplateCategory} value of the site root to detect.
      * If null or EMPTY is passed, the default value
      * SITEROOT_TEMPLATE_CATEGORY is used instead.
      * @return {@link Node} The site root {@link Node} of the passed content {@link Node}
      */
     public Node siteRoot(Node content, String siteRootTemplateCategory) {
         if (StringUtils.isEmpty(siteRootTemplateCategory)) {
             siteRootTemplateCategory = SITEROOT_TEMPLATE_CATEGORY;
         }
         try {
             Node page = this.templatingFunctions.page(content);
             Node root = TemplateCategoryUtil.findParentWithTemplateCategory(page, siteRootTemplateCategory);
             return (root == null) ? (Node) page.getAncestor(0) : root;
         } catch (RepositoryException e) {
             throw new RuntimeException("Can't access site root.", e);
         }
     }
 
     public List<ContentMap> ancestorsInSite(ContentMap content) throws RepositoryException {
         return ancestorsInSite(content, null);
     }
 
     public List<Node> ancestorsInSite(Node content) throws RepositoryException {
         return ancestorsInSite(content, null);
     }
 
     public List<ContentMap> ancestorsInSite(ContentMap content, String nodeTypeName) throws RepositoryException {
         return templatingFunctions.asContentMapList(ancestorsInSite(content.getJCRNode(), nodeTypeName));
     }
 
     public List<Node> ancestorsInSite(Node content, String nodeTypeName) throws RepositoryException {
         List<Node> allAncestors = templatingFunctions.ancestors(content, nodeTypeName);
         Node siteRoot = siteRoot(content);
 
         List<Node> ancestoresInSite = new ArrayList<Node>();
         for (Node current : allAncestors) {
             if (current.getDepth() >= siteRoot.getDepth()) {
                 ancestoresInSite.add(current);
             }
         }
         return ancestoresInSite;
     }
 
     /**
      * @deprecated Since 2.5. Use {@link DamTemplatingFunctions#getAssetLinkForId(String)}
      */
     public String getAssetLink(Node content, String assetProperty) {
         return getAssetLink(content, assetProperty, ImagingSupport.VARIATION_ORIGINAL);
     }
 
     /**
      * @deprecated Since 2.5. Use {@link DamTemplatingFunctions#getAssetLinkForId(String)}
      */
     public String getAssetLink(ContentMap content, String assetProperty) {
         return getAssetLink(content.getJCRNode(), assetProperty);
     }
 
     /**
      * @deprecated Since 2.5. Use {@link DamTemplatingFunctions#getAssetLinkForId(String)
      * (String)}
      */
     public String getAssetLink(ContentMap content, String assetProperty, AbstractSTKTemplateModel<? extends TemplateDefinition> model) {
         return getAssetLink(content.getJCRNode(), assetProperty, resolveImageVariationName(model));
     }
 
     /**
      * @deprecated Since 2.5. Use {@link DamTemplatingFunctions#getAssetLinkForId(String, String)}
      */
     public String getAssetLink(ContentMap content, String assetProperty, String renditionName) {
         return getAssetLink(content.getJCRNode(), assetProperty, renditionName);
     }
 
     /**
      * @deprecated Since 2.5. Use {@link DamTemplatingFunctions#getAssetLinkForId(String, String)}
      */
     public String getAssetLink(Node content, String assetProperty, String renditionName) {
 
         String assetIdentifier = PropertyUtil.getString(content, assetProperty);
         if (StringUtils.isNotBlank(assetIdentifier)) {
             return damTemplatingFunctions.getAssetLinkForId(assetIdentifier, renditionName);
         }
         return null;
     }
 
     public String resolveImageVariationName(AbstractSTKTemplateModel<? extends TemplateDefinition> model) {
         final String cssSelector = cssSelectorBuilder.createCssSelector(model);
         try {
             return theme(site(model.getNode())).getImaging().resolveVariationName(cssSelector);
         } catch (NoSuchRenditionException e) {
             log.warn(e.getMessage());
             return ImagingSupport.VARIATION_ORIGINAL;
         }
     }
 
     /**
      * @deprecated Since 2.5. Use {@link DamTemplatingFunctions#getAssetRendition(Asset, String)}
      * @see info.magnolia.module.templatingkit.dam.STKAssetRenderer . This implementation of AssetRenderer return a STKAssetRendition that extends {@link AssetDecorator}.
      */
     public AssetRendition getAssetVariation(Asset asset, String renditionName) {
         return damTemplatingFunctions.getRendition(asset.getItemKey().asString(), renditionName);
     }
 
     /**
      * FIXME review: should this function be provided by this class? FIXME
      * I18nContentWrapper --> I18nNodeWrapper
      */
     public Node wrap(Node content) {
         return (content == null) ? null : templatingFunctions.encode(new I18nNodeWrapper(content));
     }
 
     /**
      * FIXME review: should this function be provided by this class?
      */
     public List<ContentMap> getCategories(Node page) {
         return categorizationSupport.getCategories(page);
     }
 
     /**
      * FIXME review: should this function be provided by this class?
      */
     public String getCategoryLink(Node page, String categoryName) {
         return categorizationSupport.getCategoryLink(page, categoryName);
     }
 
     /**
      * FIXME review: should this function be provided by this class?
      */
     public List<Node> getContentListByTemplateCategorySubCategory(Node siteRoot, String category, String subCategory) throws RepositoryException {
         return getContentListByTemplateCategorySubCategory(siteRoot, category, subCategory, Integer.MAX_VALUE, null, null);
     }
 
     /**
      * FIXME review: should this function be provided by this class?
      */
     public static List<Node> getContentListByTemplateCategorySubCategory(Node siteRoot, String category, String subCategory, int maxResultSize, String andClause, String orderBy)
             throws RepositoryException {
         return TemplateCategoryUtil.getContentListByTemplateCategorySubCategory(siteRoot, category, subCategory, maxResultSize, andClause, orderBy);
     }
 
     /**
      * FIXME review: should this function be provided by this class?
      */
     public Node getNearestContentByTemplateCategorySubCategory(Node siteRoot, String category, String subCategory, Node current) throws RepositoryException {
         return TemplateCategoryUtil.getNearestContentByTemplateCategorySubCategory(siteRoot, category, subCategory, current);
     }
 
     /**
      * FIXME review: should this function be provided by this class?
      */
     public static List<Node> getContentListByTemplateName(Node searchRoot, String templateName) throws RepositoryException {
         return TemplateCategoryUtil.getContentListByTemplateName(searchRoot, templateName);
     }
 
     /**
      * FIXME review: should this function be provided by this class?
      */
     public static List<Node> getContentListByTemplateName(Node searchRoot, String templateName, int maxResultSize, String andClause, String orderByClause) throws RepositoryException {
         return TemplateCategoryUtil.getContentListByTemplateName(searchRoot, templateName, maxResultSize, andClause, orderByClause);
     }
 
     /**
      * FIXME review: should this function be provided by this class?
      */
     public static List<Node> getContentListByTemplateNames(Node searchRoot, Set<String> templateIds, int maxResultSize, String andClause, String orderByClause) throws RepositoryException {
         return TemplateCategoryUtil.getContentListByTemplateNames(searchRoot, templateIds, maxResultSize, andClause, orderByClause);
     }
 
     /**
      * Returns a {@link Node} object which is referenced by its id, stored in
      * the @param propertyName.
      *
      * @param content
      * the node with a property containing the referenced id value.
      * @param idPropertyName
      * The name of the property which contains the id of the
      * referenced {@link Node}.
      * @param referencedWorkspace
      * The workspace in which the referenced {@link Node} exists.
      * @return the referenced {@link Node}
      */
     public Node getReferencedContent(Node content, String idPropertyName, String referencedWorkspace) throws RepositoryException {
         if (content.hasProperty(idPropertyName)) {
             String identifier = PropertyUtil.getString(content, idPropertyName);
             return wrap(NodeUtil.getNodeByIdentifier(referencedWorkspace, identifier));
         }
         return null;
     }
 
     /**
      * @deprecated Since 2.5. Use {@link DamTemplatingFunctions#getAssetRenditionForAssetId(String, String)} Get the Asset specified by 'nodeDataPrefix' property name
      * linked to 'node' for the specified 'rendition'.
      * @param node
      * Content Node
      * @param nodeDataPrefix
      * Property name of the node containing the Asset identifier
      * (composite key containing a reference of the Asset Provider)
      * @param renditionName
      * Name of the rendition. If not specified, the default rendition
      * will be applied.
      * @return The targeted Asset or null if not found or in case of Exception.
      */
     public Asset getAsset(Node node, String assetProperty, String renditionName) {
         try {
             if (node.hasProperty(assetProperty)) {
                 String assetNodeIdentifier = node.getProperty(assetProperty).getString();
                 return damTemplatingFunctions.getAssetRenditionForAssetId(assetNodeIdentifier, renditionName);
             }
         } catch (RepositoryException e) {
             log.warn("Could not find asset for '{}' at '{}'", new Object[] { assetProperty, NodeUtil.getNodePathIfPossible(node), e });
             return null;
         }
 
         return null;
     }
 
     /**
      * @deprecated Since 2.5. Use {@link DamTemplatingFunctions#getAsset(String)}
      */
     public Asset getAsset(Node content, String assetProperty) {
         try {
             if (content.hasProperty(assetProperty)) {
                 String assetNodeIdentifier = content.getProperty(assetProperty).getString();
                 return new LegacyAssetWrapper(damTemplatingFunctions.getAssetForId(assetNodeIdentifier));
             }
         } catch (RepositoryException e) {
             log.warn("Could not find asset for '{}' at '{}'", new Object[] { assetProperty, NodeUtil.getNodePathIfPossible(content), e });
         }
         return null;
     }
 
     /**
      * @deprecated Since 2.5. Use {@link DamTemplatingFunctions#getAsset(String)}
      */
     public Asset getAsset(ContentMap content, String assetProperty) {
         return getAsset(content.getJCRNode(), assetProperty);
     }
 
     /**
      * @deprecated Since 2.5. Use {@link DamTemplatingFunctions#getAssetRenditionForAssetId(String, String)}
      */
     public Asset getAsset(ContentMap content, String nodeDataPrefix, String variationName) {
         return getAsset(content.getJCRNode(), nodeDataPrefix, variationName);
     }
 
     /**
      * @deprecated Since 2.5. Use {@link DamTemplatingFunctions#getAssetsFromFolderId(String)}
      * @return A List of Assets found as element of the folder or an Empty list
      * in case of exception or if no Asset are found under this folder.
      */
     public List<Asset> getAssetsFromFolder(Node node, String assetProperty) {
 
         try {
             if (node.hasProperty(assetProperty)) {
                 String folderIdentifier = node.getProperty(assetProperty).getString();
                 final List<Asset> assets = damTemplatingFunctions.getAssetsFromFolderId(folderIdentifier);
                 for (int i = 0; i < assets.size(); i++) {
                     assets.set(i, new LegacyAssetWrapper(assets.get(i)));
                 }
                 return assets;
             }
         } catch (RepositoryException e) {
             log.warn("Failed to get assets from folder.", e);
         }
 
         return new ArrayList<Asset>();
     }
 
     /**
      * Only supports InternalAssets because only InternalAssets support JCR
      * queries.
      *
      * @deprecated Since 2.5. Use {@link DamTemplatingFunctions#getAssetsByQuery(String, boolean)}
      */
     public List<Asset> getAssetsByQuery(String statement) {
         AssetQuery assetQuery = new AssetQuery.Builder().withAdditionalQueryStatement(statement).build();
         final List<Asset> assets = damTemplatingFunctions.getAssetsForFilter(assetQuery);
         for (int i = 0; i < assets.size(); i++) {
             assets.set(i, new LegacyAssetWrapper(assets.get(i)));
         }
         return assets;
     }
 
     /**
      * Return a Node List with a maximum number or result less or equal to
      * maxResults.
      */
     public List<Node> cutList(List<Node> itemsList, final int maxResults) {
         if (itemsList.size() > maxResults) {
             return itemsList.subList(0, maxResults);
         }
         return itemsList;
     }
 
     // TODO : use WordUtils.abbreviate and/or add tests
     public String abbreviateString(String stringToCut, int size) {
         return abbreviateString(stringToCut, size, " ...");
     }
 
     public String abbreviateString(String stringToCut, int size, String closureString) {
         if (stringToCut.length() > size) {
             int sizeMinusClosure = size - closureString.length();
             String cutString = StringUtils.left(stringToCut, sizeMinusClosure);
 
             // If the character after the cut was a space, no word was cut ->
             // no cutting on last space needed.
             String firstCharAfterCut = stringToCut.substring(sizeMinusClosure, sizeMinusClosure + 1);
             if (!firstCharAfterCut.equals(" ")) {
                 cutString = StringUtils.substringBeforeLast(cutString, " ");
             }
 
             return cutString + closureString;
 
         }
         return stringToCut;
     }
 
     /**
      * Increases the context bound counter and returns the value. This is for
      * instance useful to create unique page wide ids.
      */
     public int count(String name) {
         String attributeName = STKTemplatingFunctions.class.getName() + name;
         if (!MgnlContext.hasAttribute(attributeName)) {
             MgnlContext.setAttribute(attributeName, new MutableInt(0));
         }
         MutableInt counter = (MutableInt) MgnlContext.getAttribute(attributeName);
         counter.increment();
         return counter.intValue();
     }
 
     public String getDivIdAbbreviation(String divID) {
         return getDivIdAbbreviation(divID, "-");
     }
 
     public String getDivIdAbbreviation(String divID, String delimiter) {
         String result = StringUtils.EMPTY;
         if (StringUtils.isNotEmpty(divID) && StringUtils.isNotEmpty(delimiter)) {
             String[] values = divID.split("\\" + delimiter);
             for (String value : values) {
                 result += value.substring(0, 1);
             }
         }
         return result;
     }
 
     /**
      * Return a property from the metaData of the node.
      */
     public String metaDataProperty(Node content, String property) {
         return templatingFunctions.metaData(content, property);
     }
 
     public String metaDataProperty(ContentMap content, String property) {
         return templatingFunctions.metaData(content, property);
     }
 
     /**
      * Return the template id associated with this content.
      */
 
     public String metaDataTemplate(Node content) {
         try {
             return NodeTypes.Renderable.getTemplate(content);
         } catch (RepositoryException e) {
             return null;
         }
     }
 
     public String metaDataTemplate(ContentMap content) {
         return metaDataTemplate(content.getJCRNode());
     }
 
     /**
      * For test purpose only.
      */
     public void setCssSelectorBuilder(CssSelectorBuilder cssSelectorBuilder) {
         this.cssSelectorBuilder = cssSelectorBuilder;
     }
 
     /**
      * For test purpose only.
      */
     public void setCategorizationSupport(CategorizationSupport categorizationSupport) {
         this.categorizationSupport = categorizationSupport;
     }
 
 }