src/main/java/org/apache/sling/scripting/sightly/impl/engine/extension/URIManipulationFilterExtension.java - sling-org-apache-sling-scripting-sightly - Git at Google

 /*******************************************************************************
  * Licensed to the Apache Software Foundation (ASF) under one
  * or more contributor license agreements.  See the NOTICE file
  * distributed with this work for additional information
  * regarding copyright ownership.  The ASF licenses this file
  * to you under the Apache License, Version 2.0 (the
  * "License"); you may not use this file except in compliance
  * with the License.  You may obtain a copy of the License at
  *
  *  http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing,
  * software distributed under the License is distributed on an
  * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
  * KIND, either express or implied.  See the License for the
  * specific language governing permissions and limitations
  * under the License.
  ******************************************************************************/
 package org.apache.sling.scripting.sightly.impl.engine.extension;

 import java.io.UnsupportedEncodingException;
 import java.net.URI;
 import java.net.URISyntaxException;
 import java.net.URLEncoder;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Collection;
 import java.util.LinkedHashMap;
 import java.util.LinkedHashSet;
 import java.util.Map;
 import java.util.Set;

 import org.apache.commons.io.FilenameUtils;
 import org.apache.commons.lang.StringUtils;
 import org.apache.sling.scripting.sightly.SightlyException;
 import org.apache.sling.scripting.sightly.compiler.RuntimeFunction;
 import org.apache.sling.scripting.sightly.extension.RuntimeExtension;
 import org.apache.sling.scripting.sightly.render.RenderContext;
 import org.apache.sling.scripting.sightly.render.RuntimeObjectModel;
 import org.osgi.service.component.annotations.Component;

 @Component(
         service = RuntimeExtension.class,
         property = {
                 RuntimeExtension.NAME + "=" + RuntimeFunction.URI_MANIPULATION
         }
 )
 public class URIManipulationFilterExtension implements RuntimeExtension {

     public static final String SCHEME = "scheme";
     public static final String DOMAIN = "domain";
     public static final String PATH = "path";
     public static final String APPEND_PATH = "appendPath";
     public static final String PREPEND_PATH = "prependPath";
     public static final String SELECTORS = "selectors";
     public static final String ADD_SELECTORS = "addSelectors";
     public static final String REMOVE_SELECTORS = "removeSelectors";
     public static final String EXTENSION = "extension";
     public static final String SUFFIX = "suffix";
     public static final String PREPEND_SUFFIX = "prependSuffix";
     public static final String APPEND_SUFFIX = "appendSuffix";
     public static final String FRAGMENT = "fragment";
     public static final String QUERY = "query";
     public static final String ADD_QUERY = "addQuery";
     public static final String REMOVE_QUERY = "removeQuery";


     @Override
     @SuppressWarnings("unchecked")
     public Object call(RenderContext renderContext, Object... arguments) {
         ExtensionUtils.checkArgumentCount(RuntimeFunction.URI_MANIPULATION, arguments, 2);
         RuntimeObjectModel runtimeObjectModel = renderContext.getObjectModel();
         String uriString = runtimeObjectModel.toString(arguments[0]);
         Map<String, Object> options = runtimeObjectModel.toMap(arguments[1]);
         StringBuilder sb = new StringBuilder();
         PathInfo pathInfo = new PathInfo(uriString);
         uriAppender(sb, SCHEME, options, pathInfo.getScheme());
         if (sb.length() > 0) {
             sb.append(":");
             sb.append(StringUtils.defaultIfEmpty(pathInfo.getBeginPathSeparator(), "//"));
         }
         if (sb.length() > 0) {
             uriAppender(sb, DOMAIN, options, pathInfo.getHost());
         } else {
             String domain = getOption(DOMAIN, options, pathInfo.getHost());
             if (StringUtils.isNotEmpty(domain)) {
                 sb.append("//").append(domain);
             }
         }
         if (pathInfo.getPort() > -1) {
             sb.append(":").append(pathInfo.getPort());
         }
         String prependPath = getOption(PREPEND_PATH, options, StringUtils.EMPTY);
         if (prependPath == null) {
             prependPath = StringUtils.EMPTY;
         }
         String path = getOption(PATH, options, pathInfo.getPath());
         if (StringUtils.isEmpty(path)) {
             // if the path is forced to be empty don't remove the path
             path = pathInfo.getPath();
         }
         if (StringUtils.isNotEmpty(path) && !"/".equals(path)) {
             if (StringUtils.isNotEmpty(prependPath)) {
                 if (sb.length() > 0 && !prependPath.startsWith("/")) {
                     prependPath = "/" + prependPath;
                 }
                 if (!prependPath.endsWith("/")) {
                     prependPath += "/";
                 }
             }


             String appendPath = getOption(APPEND_PATH, options, StringUtils.EMPTY);
             if (appendPath == null) {
                 appendPath = StringUtils.EMPTY;
             }
             if (StringUtils.isNotEmpty(appendPath)) {
                 if (!appendPath.startsWith("/")) {
                     appendPath = "/" + appendPath;
                 }
             }
             String newPath;
             try {
                 newPath = new URI(prependPath + path + appendPath).normalize().getPath();
             } catch (URISyntaxException e) {
                 newPath = prependPath + path + appendPath;
             }
             if (sb.length() > 0 && sb.lastIndexOf("/") != sb.length() - 1 && StringUtils.isNotEmpty(newPath) && !newPath.startsWith("/")) {
                 sb.append("/");
             }
             sb.append(newPath);
             Set<String> selectors = pathInfo.getSelectors();
             handleSelectors(runtimeObjectModel, selectors, options);
             for (String selector : selectors) {
                 if (StringUtils.isNotBlank(selector) && !selector.contains(" ")) {
                     // make sure not to append empty or invalid selectors
                     sb.append(".").append(selector);
                 }
             }
             String extension = getOption(EXTENSION, options, pathInfo.getExtension());
             if (StringUtils.isNotEmpty(extension)) {
                 sb.append(".").append(extension);
             }

             String prependSuffix = getOption(PREPEND_SUFFIX, options, StringUtils.EMPTY);
             if (StringUtils.isNotEmpty(prependSuffix)) {
                 if (!prependSuffix.startsWith("/")) {
                     prependSuffix = "/" + prependSuffix;
                 }
                 if (!prependSuffix.endsWith("/")) {
                     prependSuffix += "/";
                 }
             }
             String pathInfoSuffix = pathInfo.getSuffix();
             String suffix = getOption(SUFFIX, options, pathInfoSuffix == null ? StringUtils.EMPTY : pathInfoSuffix);
             if (suffix == null) {
                 suffix = StringUtils.EMPTY;
             }
             String appendSuffix = getOption(APPEND_SUFFIX, options, StringUtils.EMPTY);
             if (StringUtils.isNotEmpty(appendSuffix)) {
                 appendSuffix = "/" + appendSuffix;
             }
             String newSuffix = FilenameUtils.normalize(prependSuffix + suffix + appendSuffix, true);
             if (StringUtils.isNotEmpty(newSuffix)) {
                 if (!newSuffix.startsWith("/")) {
                     sb.append("/");
                 }
                 sb.append(newSuffix);
             }

         } else if ("/".equals(path)) {
             sb.append(path);
         }
         Map<String, Collection<String>> parameters = pathInfo.getParameters();
         handleParameters(runtimeObjectModel, parameters, options);
         if (sb.length() > 0 && !parameters.isEmpty()) {
             if (StringUtils.isEmpty(path)) {
                 sb.append("/");
             }
             sb.append("?");
             for (Map.Entry<String, Collection<String>> entry : parameters.entrySet()) {
                 for (String value : entry.getValue()) {
                     sb.append(entry.getKey()).append("=").append(value).append("&");
                 }
             }
             // delete the last &
             sb.deleteCharAt(sb.length() - 1);
         }
         String fragment = getOption(FRAGMENT, options, pathInfo.getFragment());
         if (StringUtils.isNotEmpty(fragment)) {
             sb.append("#").append(fragment);
         }
         return sb.toString();
     }

     private void uriAppender(StringBuilder stringBuilder, String option, Map<String, Object> options, String defaultValue) {
         String value = (String) options.get(option);
         if (StringUtils.isNotEmpty(value)) {
             stringBuilder.append(value);
         } else {
             if (StringUtils.isNotEmpty(defaultValue)) {
                 stringBuilder.append(defaultValue);
             }
         }
     }

     private String getOption(String option, Map<String, Object> options, String defaultValue) {
         if (options.containsKey(option)) {
             return (String) options.get(option);

         }
         return defaultValue;
     }

     private void handleSelectors(RuntimeObjectModel runtimeObjectModel, Set<String> selectors, Map<String, Object> options) {
         if (options.containsKey(SELECTORS)) {
             Object selectorsOption = options.get(SELECTORS);
             if (selectorsOption == null) {
                 // we want to remove all selectors
                 selectors.clear();
             } else if (selectorsOption instanceof String) {
                 String selectorString = (String) selectorsOption;
                 String[] selectorsArray = selectorString.split("\\.");
                 replaceSelectors(selectors, selectorsArray);
             } else if (selectorsOption instanceof Object[]) {
                 Object[] selectorsURIArray = (Object[]) selectorsOption;
                 String[] selectorsArray = new String[selectorsURIArray.length];
                 int index = 0;
                 for (Object selector : selectorsURIArray) {
                     selectorsArray[index++] = runtimeObjectModel.toString(selector);
                 }
                 replaceSelectors(selectors, selectorsArray);
             }
         }
         Object addSelectorsOption = options.get(ADD_SELECTORS);
         if (addSelectorsOption instanceof String) {
             String selectorString = (String) addSelectorsOption;
             String[] selectorsArray = selectorString.split("\\.");
             addSelectors(selectors, selectorsArray);
         } else if (addSelectorsOption instanceof Object[]) {
             Object[] selectorsURIArray = (Object[]) addSelectorsOption;
             String[] selectorsArray = new String[selectorsURIArray.length];
             int index = 0;
             for (Object selector : selectorsURIArray) {
                 selectorsArray[index++] = runtimeObjectModel.toString(selector);
             }
             addSelectors(selectors, selectorsArray);
         }
         Object removeSelectorsOption = options.get(REMOVE_SELECTORS);
         if (removeSelectorsOption instanceof String) {
             String selectorString = (String) removeSelectorsOption;
             String[] selectorsArray = selectorString.split("\\.");
             removeSelectors(selectors, selectorsArray);
         } else if (removeSelectorsOption instanceof Object[]) {
             Object[] selectorsURIArray = (Object[]) removeSelectorsOption;
             String[] selectorsArray = new String[selectorsURIArray.length];
             int index = 0;
             for (Object selector : selectorsURIArray) {
                 selectorsArray[index++] = runtimeObjectModel.toString(selector);
             }
             removeSelectors(selectors, selectorsArray);
         }

     }

     private void replaceSelectors(Set<String> selectors, String[] selectorsArray) {
         selectors.clear();
         selectors.addAll(Arrays.asList(selectorsArray));
     }

     private void addSelectors(Set<String> selectors, String[] selectorsArray) {
         selectors.addAll(Arrays.asList(selectorsArray));
     }

     private void removeSelectors(Set<String> selectors, String[] selectorsArray) {
         selectors.removeAll(Arrays.asList(selectorsArray));
     }

     @SuppressWarnings("unchecked")
     private void handleParameters(RuntimeObjectModel runtimeObjectModel, Map<String, Collection<String>> parameters, Map<String, Object>
             options) {
         if (options.containsKey(QUERY)) {
             Object queryOption = options.get(QUERY);
             parameters.clear();
             Map<String, Object> queryParameters = runtimeObjectModel.toMap(queryOption);
             addQueryParameters(runtimeObjectModel, parameters, queryParameters);
         }
         Object addQueryOption = options.get(ADD_QUERY);
         if (addQueryOption != null) {
             Map<String, Object> addParams = runtimeObjectModel.toMap(addQueryOption);
             addQueryParameters(runtimeObjectModel, parameters, addParams);
         }
         Object removeQueryOption = options.get(REMOVE_QUERY);
         if (removeQueryOption != null) {
             if (removeQueryOption instanceof String) {
                 parameters.remove(removeQueryOption);
             } else if (removeQueryOption instanceof Object[]) {
                 Object[] removeQueryParamArray = (Object[]) removeQueryOption;
                 for (Object param : removeQueryParamArray) {
                     String paramString = runtimeObjectModel.toString(param);
                     if (paramString != null) {
                         parameters.remove(paramString);
                     }
                 }
             }
         }
     }

     private void addQueryParameters(RuntimeObjectModel runtimeObjectModel, Map<String, Collection<String>> parameters, Map<String, Object>
             queryParameters) {
         for (Map.Entry<String, Object> entry : queryParameters.entrySet()) {
             Object entryValue = entry.getValue();
             try {
                 if (runtimeObjectModel.isCollection(entryValue)) {
                     Collection<Object> collection = runtimeObjectModel.toCollection(entryValue);
                     Collection<String> values = new ArrayList<>(collection.size());
                     for (Object o : collection) {
                         values.add(URLEncoder.encode(runtimeObjectModel.toString(o), "UTF-8"));
                     }
                     parameters.put(entry.getKey(), values);
                 } else {
                     Collection<String> values = new ArrayList<>(1);
                     values.add(URLEncoder.encode(runtimeObjectModel.toString(entryValue), "UTF-8"));
                     parameters.put(entry.getKey(), values);
                 }
             } catch (UnsupportedEncodingException e) {
                 throw new SightlyException(e);
             }
         }
     }

     public static class PathInfo {

         private URI uri;
         private String path;
         private Set<String> selectors;
         private String selectorString;
         private String extension;
         private String suffix;
         private Map<String, Collection<String>> parameters = new LinkedHashMap<>();

         /**
          * Creates a {@code PathInfo} object based on a request path.
          *
          * @param path the full normalized path (no '.', '..', or double slashes8) of the request, including the query parameters
          * @throws NullPointerException if the supplied {@code path} is null
          */
         public PathInfo(String path) {
             if (path == null) {
                 throw new NullPointerException("The path parameter cannot be null.");
             }
             try {
                 uri = new URI(path);
             } catch (URISyntaxException e) {
                 throw new SightlyException("The provided path does not represent a valid URI: " + path);
             }
             selectors = new LinkedHashSet<>();
             String processingPath = path;
             if (uri.getPath() != null) {
                 processingPath = uri.getPath();
             }
             int lastDot = processingPath.lastIndexOf('.');
             if (lastDot > -1) {
                 String afterLastDot = processingPath.substring(lastDot + 1);
                 String[] parts = afterLastDot.split("/");
                 extension = parts[0];
                 if (parts.length > 1) {
                     // we have a suffix
                     StringBuilder suffixSB = new StringBuilder();
                     for (int i = 1; i < parts.length; i++) {
                         suffixSB.append("/").append(parts[i]);
                     }
                     int hashIndex = suffixSB.indexOf("#");
                     if (hashIndex > -1) {
                         suffix = suffixSB.substring(0, hashIndex);
                     } else {
                         suffix = suffixSB.toString();
                     }
                 }
             }
             int firstDot = processingPath.indexOf('.');
             if (firstDot < lastDot) {
                 selectorString = processingPath.substring(firstDot + 1, lastDot);
                 String[] selectorsArray = selectorString.split("\\.");
                 selectors.addAll(Arrays.asList(selectorsArray));
             }
             int pathLength = processingPath.length() - (selectorString == null ? 0 : selectorString.length() + 1) - (extension == null ? 0:
                     extension.length() + 1) - (suffix == null ? 0 : suffix.length());
             if (pathLength == processingPath.length()) {
                 this.path = processingPath;
             } else {
                 this.path = processingPath.substring(0, pathLength);
             }
             String query = uri.getRawQuery();
             if (StringUtils.isNotEmpty(query)) {
                 String[] keyValuePairs = query.split("&");
                 for (String keyValuePair : keyValuePairs) {
                     String[] pair = keyValuePair.split("=");
                     if (pair.length == 2) {
                         String param = pair[0];
                         String value = pair[1];
                         Collection<String> values = parameters.get(param);
                         if (values == null) {
                             values = new ArrayList<>();
                             parameters.put(param, values);
                         }
                         values.add(value);
                     }
                 }
             }
         }

         /**
          * Returns the scheme of this path if the path corresponds to a URI and if the URI provides scheme information.
          *
          * @return the scheme or {@code null} if the path does not contain a scheme
          */
         public String getScheme() {
             return uri.getScheme();
         }

         /**
          * Returns the path separator ("//") if the path defines an absolute URI.
          *
          * @return the path separator if the path is an absolute URI, {@code null} otherwise
          */
         public String getBeginPathSeparator() {
             if (uri.isAbsolute()) {
                 return "//";
             }
             return null;
         }

         /**
          * Returns the host part of the path, if the path defines a URI.
          *
          * @return the host if the path defines a URI, {@code null} otherwise
          */
         public String getHost() {
             return uri.getHost();
         }

         /**
          * Returns the port if the path defines a URI and if it contains port information.
          *
          * @return the port or -1 if no port is defined
          */
         public int getPort() {
             return uri.getPort();
         }

         /**
          * Returns the path from which <i>{@code this}</i> object was built.
          *
          * @return the original path
          */
         public String getFullPath() {
             return uri.toString();
         }

         /**
          * Returns the path identifying the resource, without any selectors, extension or query parameters.
          *
          * @return the path of the resource
          */
         public String getPath() {
             return path;
         }

         /**
          * Returns the selectors set.
          *
          * @return the selectors set; if there are no selectors the set will be empty
          */
         public Set<String> getSelectors() {
             return selectors;
         }

         /**
          * Returns the extension.
          *
          * @return the extension, if one exists, otherwise {@code null}
          */
         public String getExtension() {
             return extension;
         }

         /**
          * Returns the selector string.
          *
          * @return the selector string, if the path has selectors, otherwise {@code null}
          */
         public String getSelectorString() {
             return selectorString;
         }

         /**
          * Returns the suffix appended to the path. The suffix represents the path segment between the path's extension and the path's fragment.
          *
          * @return the suffix if the path contains one, {@code null} otherwise
          */
         public String getSuffix() {
             return suffix;
         }

         /**
          * Returns the fragment is this path defines a URI and it contains a fragment.
          *
          * @return the fragment, or {@code null} if one doesn't exist
          */
         public String getFragment() {
             return uri.getFragment();
         }

         /**
          * Returns the URI parameters if the provided path defines a URI.
          * @return the parameters map; can be empty if there are no parameters of if the path doesn't identify a URI
          */
         public Map<String, Collection<String>> getParameters() {
             return parameters;
         }
     }

 }
	/*******************************************************************************
	* Licensed to the Apache Software Foundation (ASF) under one
	* or more contributor license agreements. See the NOTICE file
	* distributed with this work for additional information
	* regarding copyright ownership. The ASF licenses this file
	* to you under the Apache License, Version 2.0 (the
	* "License"); you may not use this file except in compliance
	* with the License. You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing,
	* software distributed under the License is distributed on an
	* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
	* KIND, either express or implied. See the License for the
	* specific language governing permissions and limitations
	* under the License.
	******************************************************************************/
	package org.apache.sling.scripting.sightly.impl.engine.extension;

	import java.io.UnsupportedEncodingException;
	import java.net.URI;
	import java.net.URISyntaxException;
	import java.net.URLEncoder;
	import java.util.ArrayList;
	import java.util.Arrays;
	import java.util.Collection;
	import java.util.LinkedHashMap;
	import java.util.LinkedHashSet;
	import java.util.Map;
	import java.util.Set;

	import org.apache.commons.io.FilenameUtils;
	import org.apache.commons.lang.StringUtils;
	import org.apache.sling.scripting.sightly.SightlyException;
	import org.apache.sling.scripting.sightly.compiler.RuntimeFunction;
	import org.apache.sling.scripting.sightly.extension.RuntimeExtension;
	import org.apache.sling.scripting.sightly.render.RenderContext;
	import org.apache.sling.scripting.sightly.render.RuntimeObjectModel;
	import org.osgi.service.component.annotations.Component;

	@Component(
	service = RuntimeExtension.class,
	property = {
	RuntimeExtension.NAME + "=" + RuntimeFunction.URI_MANIPULATION
	}
	)
	public class URIManipulationFilterExtension implements RuntimeExtension {

	public static final String SCHEME = "scheme";
	public static final String DOMAIN = "domain";
	public static final String PATH = "path";
	public static final String APPEND_PATH = "appendPath";
	public static final String PREPEND_PATH = "prependPath";
	public static final String SELECTORS = "selectors";
	public static final String ADD_SELECTORS = "addSelectors";
	public static final String REMOVE_SELECTORS = "removeSelectors";
	public static final String EXTENSION = "extension";
	public static final String SUFFIX = "suffix";
	public static final String PREPEND_SUFFIX = "prependSuffix";
	public static final String APPEND_SUFFIX = "appendSuffix";
	public static final String FRAGMENT = "fragment";
	public static final String QUERY = "query";
	public static final String ADD_QUERY = "addQuery";
	public static final String REMOVE_QUERY = "removeQuery";


	@Override
	@SuppressWarnings("unchecked")
	public Object call(RenderContext renderContext, Object... arguments) {
	ExtensionUtils.checkArgumentCount(RuntimeFunction.URI_MANIPULATION, arguments, 2);
	RuntimeObjectModel runtimeObjectModel = renderContext.getObjectModel();
	String uriString = runtimeObjectModel.toString(arguments[0]);
	Map<String, Object> options = runtimeObjectModel.toMap(arguments[1]);
	StringBuilder sb = new StringBuilder();
	PathInfo pathInfo = new PathInfo(uriString);
	uriAppender(sb, SCHEME, options, pathInfo.getScheme());
	if (sb.length() > 0) {
	sb.append(":");
	sb.append(StringUtils.defaultIfEmpty(pathInfo.getBeginPathSeparator(), "//"));
	}
	if (sb.length() > 0) {
	uriAppender(sb, DOMAIN, options, pathInfo.getHost());
	} else {
	String domain = getOption(DOMAIN, options, pathInfo.getHost());
	if (StringUtils.isNotEmpty(domain)) {
	sb.append("//").append(domain);
	}
	}
	if (pathInfo.getPort() > -1) {
	sb.append(":").append(pathInfo.getPort());
	}
	String prependPath = getOption(PREPEND_PATH, options, StringUtils.EMPTY);
	if (prependPath == null) {
	prependPath = StringUtils.EMPTY;
	}
	String path = getOption(PATH, options, pathInfo.getPath());
	if (StringUtils.isEmpty(path)) {
	// if the path is forced to be empty don't remove the path
	path = pathInfo.getPath();
	}
	if (StringUtils.isNotEmpty(path) && !"/".equals(path)) {
	if (StringUtils.isNotEmpty(prependPath)) {
	if (sb.length() > 0 && !prependPath.startsWith("/")) {
	prependPath = "/" + prependPath;
	}
	if (!prependPath.endsWith("/")) {
	prependPath += "/";
	}
	}


	String appendPath = getOption(APPEND_PATH, options, StringUtils.EMPTY);
	if (appendPath == null) {
	appendPath = StringUtils.EMPTY;
	}
	if (StringUtils.isNotEmpty(appendPath)) {
	if (!appendPath.startsWith("/")) {
	appendPath = "/" + appendPath;
	}
	}
	String newPath;
	try {
	newPath = new URI(prependPath + path + appendPath).normalize().getPath();
	} catch (URISyntaxException e) {
	newPath = prependPath + path + appendPath;
	}
	if (sb.length() > 0 && sb.lastIndexOf("/") != sb.length() - 1 && StringUtils.isNotEmpty(newPath) && !newPath.startsWith("/")) {
	sb.append("/");
	}
	sb.append(newPath);
	Set<String> selectors = pathInfo.getSelectors();
	handleSelectors(runtimeObjectModel, selectors, options);
	for (String selector : selectors) {
	if (StringUtils.isNotBlank(selector) && !selector.contains(" ")) {
	// make sure not to append empty or invalid selectors
	sb.append(".").append(selector);
	}
	}
	String extension = getOption(EXTENSION, options, pathInfo.getExtension());
	if (StringUtils.isNotEmpty(extension)) {
	sb.append(".").append(extension);
	}

	String prependSuffix = getOption(PREPEND_SUFFIX, options, StringUtils.EMPTY);
	if (StringUtils.isNotEmpty(prependSuffix)) {
	if (!prependSuffix.startsWith("/")) {
	prependSuffix = "/" + prependSuffix;
	}
	if (!prependSuffix.endsWith("/")) {
	prependSuffix += "/";
	}
	}
	String pathInfoSuffix = pathInfo.getSuffix();
	String suffix = getOption(SUFFIX, options, pathInfoSuffix == null ? StringUtils.EMPTY : pathInfoSuffix);
	if (suffix == null) {
	suffix = StringUtils.EMPTY;
	}
	String appendSuffix = getOption(APPEND_SUFFIX, options, StringUtils.EMPTY);
	if (StringUtils.isNotEmpty(appendSuffix)) {
	appendSuffix = "/" + appendSuffix;
	}
	String newSuffix = FilenameUtils.normalize(prependSuffix + suffix + appendSuffix, true);
	if (StringUtils.isNotEmpty(newSuffix)) {
	if (!newSuffix.startsWith("/")) {
	sb.append("/");
	}
	sb.append(newSuffix);
	}

	} else if ("/".equals(path)) {
	sb.append(path);
	}
	Map<String, Collection<String>> parameters = pathInfo.getParameters();
	handleParameters(runtimeObjectModel, parameters, options);
	if (sb.length() > 0 && !parameters.isEmpty()) {
	if (StringUtils.isEmpty(path)) {
	sb.append("/");
	}
	sb.append("?");
	for (Map.Entry<String, Collection<String>> entry : parameters.entrySet()) {
	for (String value : entry.getValue()) {
	sb.append(entry.getKey()).append("=").append(value).append("&");
	}
	}
	// delete the last &
	sb.deleteCharAt(sb.length() - 1);
	}
	String fragment = getOption(FRAGMENT, options, pathInfo.getFragment());
	if (StringUtils.isNotEmpty(fragment)) {
	sb.append("#").append(fragment);
	}
	return sb.toString();
	}

	private void uriAppender(StringBuilder stringBuilder, String option, Map<String, Object> options, String defaultValue) {
	String value = (String) options.get(option);
	if (StringUtils.isNotEmpty(value)) {
	stringBuilder.append(value);
	} else {
	if (StringUtils.isNotEmpty(defaultValue)) {
	stringBuilder.append(defaultValue);
	}
	}
	}

	private String getOption(String option, Map<String, Object> options, String defaultValue) {
	if (options.containsKey(option)) {
	return (String) options.get(option);

	}
	return defaultValue;
	}

	private void handleSelectors(RuntimeObjectModel runtimeObjectModel, Set<String> selectors, Map<String, Object> options) {
	if (options.containsKey(SELECTORS)) {
	Object selectorsOption = options.get(SELECTORS);
	if (selectorsOption == null) {
	// we want to remove all selectors
	selectors.clear();
	} else if (selectorsOption instanceof String) {
	String selectorString = (String) selectorsOption;
	String[] selectorsArray = selectorString.split("\\.");
	replaceSelectors(selectors, selectorsArray);
	} else if (selectorsOption instanceof Object[]) {
	Object[] selectorsURIArray = (Object[]) selectorsOption;
	String[] selectorsArray = new String[selectorsURIArray.length];
	int index = 0;
	for (Object selector : selectorsURIArray) {
	selectorsArray[index++] = runtimeObjectModel.toString(selector);
	}
	replaceSelectors(selectors, selectorsArray);
	}
	}
	Object addSelectorsOption = options.get(ADD_SELECTORS);
	if (addSelectorsOption instanceof String) {
	String selectorString = (String) addSelectorsOption;
	String[] selectorsArray = selectorString.split("\\.");
	addSelectors(selectors, selectorsArray);
	} else if (addSelectorsOption instanceof Object[]) {
	Object[] selectorsURIArray = (Object[]) addSelectorsOption;
	String[] selectorsArray = new String[selectorsURIArray.length];
	int index = 0;
	for (Object selector : selectorsURIArray) {
	selectorsArray[index++] = runtimeObjectModel.toString(selector);
	}
	addSelectors(selectors, selectorsArray);
	}
	Object removeSelectorsOption = options.get(REMOVE_SELECTORS);
	if (removeSelectorsOption instanceof String) {
	String selectorString = (String) removeSelectorsOption;
	String[] selectorsArray = selectorString.split("\\.");
	removeSelectors(selectors, selectorsArray);
	} else if (removeSelectorsOption instanceof Object[]) {
	Object[] selectorsURIArray = (Object[]) removeSelectorsOption;
	String[] selectorsArray = new String[selectorsURIArray.length];
	int index = 0;
	for (Object selector : selectorsURIArray) {
	selectorsArray[index++] = runtimeObjectModel.toString(selector);
	}
	removeSelectors(selectors, selectorsArray);
	}

	}

	private void replaceSelectors(Set<String> selectors, String[] selectorsArray) {
	selectors.clear();
	selectors.addAll(Arrays.asList(selectorsArray));
	}

	private void addSelectors(Set<String> selectors, String[] selectorsArray) {
	selectors.addAll(Arrays.asList(selectorsArray));
	}

	private void removeSelectors(Set<String> selectors, String[] selectorsArray) {
	selectors.removeAll(Arrays.asList(selectorsArray));
	}

	@SuppressWarnings("unchecked")
	private void handleParameters(RuntimeObjectModel runtimeObjectModel, Map<String, Collection<String>> parameters, Map<String, Object>
	options) {
	if (options.containsKey(QUERY)) {
	Object queryOption = options.get(QUERY);
	parameters.clear();
	Map<String, Object> queryParameters = runtimeObjectModel.toMap(queryOption);
	addQueryParameters(runtimeObjectModel, parameters, queryParameters);
	}
	Object addQueryOption = options.get(ADD_QUERY);
	if (addQueryOption != null) {
	Map<String, Object> addParams = runtimeObjectModel.toMap(addQueryOption);
	addQueryParameters(runtimeObjectModel, parameters, addParams);
	}
	Object removeQueryOption = options.get(REMOVE_QUERY);
	if (removeQueryOption != null) {
	if (removeQueryOption instanceof String) {
	parameters.remove(removeQueryOption);
	} else if (removeQueryOption instanceof Object[]) {
	Object[] removeQueryParamArray = (Object[]) removeQueryOption;
	for (Object param : removeQueryParamArray) {
	String paramString = runtimeObjectModel.toString(param);
	if (paramString != null) {
	parameters.remove(paramString);
	}
	}
	}
	}
	}

	private void addQueryParameters(RuntimeObjectModel runtimeObjectModel, Map<String, Collection<String>> parameters, Map<String, Object>
	queryParameters) {
	for (Map.Entry<String, Object> entry : queryParameters.entrySet()) {
	Object entryValue = entry.getValue();
	try {
	if (runtimeObjectModel.isCollection(entryValue)) {
	Collection<Object> collection = runtimeObjectModel.toCollection(entryValue);
	Collection<String> values = new ArrayList<>(collection.size());
	for (Object o : collection) {
	values.add(URLEncoder.encode(runtimeObjectModel.toString(o), "UTF-8"));
	}
	parameters.put(entry.getKey(), values);
	} else {
	Collection<String> values = new ArrayList<>(1);
	values.add(URLEncoder.encode(runtimeObjectModel.toString(entryValue), "UTF-8"));
	parameters.put(entry.getKey(), values);
	}
	} catch (UnsupportedEncodingException e) {
	throw new SightlyException(e);
	}
	}
	}

	public static class PathInfo {

	private URI uri;
	private String path;
	private Set<String> selectors;
	private String selectorString;
	private String extension;
	private String suffix;
	private Map<String, Collection<String>> parameters = new LinkedHashMap<>();

	/**
	* Creates a {@code PathInfo} object based on a request path.
	*
	* @param path the full normalized path (no '.', '..', or double slashes8) of the request, including the query parameters
	* @throws NullPointerException if the supplied {@code path} is null
	*/
	public PathInfo(String path) {
	if (path == null) {
	throw new NullPointerException("The path parameter cannot be null.");
	}
	try {
	uri = new URI(path);
	} catch (URISyntaxException e) {
	throw new SightlyException("The provided path does not represent a valid URI: " + path);
	}
	selectors = new LinkedHashSet<>();
	String processingPath = path;
	if (uri.getPath() != null) {
	processingPath = uri.getPath();
	}
	int lastDot = processingPath.lastIndexOf('.');
	if (lastDot > -1) {
	String afterLastDot = processingPath.substring(lastDot + 1);
	String[] parts = afterLastDot.split("/");
	extension = parts[0];
	if (parts.length > 1) {
	// we have a suffix
	StringBuilder suffixSB = new StringBuilder();
	for (int i = 1; i < parts.length; i++) {
	suffixSB.append("/").append(parts[i]);
	}
	int hashIndex = suffixSB.indexOf("#");
	if (hashIndex > -1) {
	suffix = suffixSB.substring(0, hashIndex);
	} else {
	suffix = suffixSB.toString();
	}
	}
	}
	int firstDot = processingPath.indexOf('.');
	if (firstDot < lastDot) {
	selectorString = processingPath.substring(firstDot + 1, lastDot);
	String[] selectorsArray = selectorString.split("\\.");
	selectors.addAll(Arrays.asList(selectorsArray));
	}
	int pathLength = processingPath.length() - (selectorString == null ? 0 : selectorString.length() + 1) - (extension == null ? 0:
	extension.length() + 1) - (suffix == null ? 0 : suffix.length());
	if (pathLength == processingPath.length()) {
	this.path = processingPath;
	} else {
	this.path = processingPath.substring(0, pathLength);
	}
	String query = uri.getRawQuery();
	if (StringUtils.isNotEmpty(query)) {
	String[] keyValuePairs = query.split("&");
	for (String keyValuePair : keyValuePairs) {
	String[] pair = keyValuePair.split("=");
	if (pair.length == 2) {
	String param = pair[0];
	String value = pair[1];
	Collection<String> values = parameters.get(param);
	if (values == null) {
	values = new ArrayList<>();
	parameters.put(param, values);
	}
	values.add(value);
	}
	}
	}
	}

	/**
	* Returns the scheme of this path if the path corresponds to a URI and if the URI provides scheme information.
	*
	* @return the scheme or {@code null} if the path does not contain a scheme
	*/
	public String getScheme() {
	return uri.getScheme();
	}

	/**
	* Returns the path separator ("//") if the path defines an absolute URI.
	*
	* @return the path separator if the path is an absolute URI, {@code null} otherwise
	*/
	public String getBeginPathSeparator() {
	if (uri.isAbsolute()) {
	return "//";
	}
	return null;
	}

	/**
	* Returns the host part of the path, if the path defines a URI.
	*
	* @return the host if the path defines a URI, {@code null} otherwise
	*/
	public String getHost() {
	return uri.getHost();
	}

	/**
	* Returns the port if the path defines a URI and if it contains port information.
	*
	* @return the port or -1 if no port is defined
	*/
	public int getPort() {
	return uri.getPort();
	}

	/**
	* Returns the path from which <i>{@code this}</i> object was built.
	*
	* @return the original path
	*/
	public String getFullPath() {
	return uri.toString();
	}

	/**
	* Returns the path identifying the resource, without any selectors, extension or query parameters.
	*
	* @return the path of the resource
	*/
	public String getPath() {
	return path;
	}

	/**
	* Returns the selectors set.
	*
	* @return the selectors set; if there are no selectors the set will be empty
	*/
	public Set<String> getSelectors() {
	return selectors;
	}

	/**
	* Returns the extension.
	*
	* @return the extension, if one exists, otherwise {@code null}
	*/
	public String getExtension() {
	return extension;
	}

	/**
	* Returns the selector string.
	*
	* @return the selector string, if the path has selectors, otherwise {@code null}
	*/
	public String getSelectorString() {
	return selectorString;
	}

	/**
	* Returns the suffix appended to the path. The suffix represents the path segment between the path's extension and the path's fragment.
	*
	* @return the suffix if the path contains one, {@code null} otherwise
	*/
	public String getSuffix() {
	return suffix;
	}

	/**
	* Returns the fragment is this path defines a URI and it contains a fragment.
	*
	* @return the fragment, or {@code null} if one doesn't exist
	*/
	public String getFragment() {
	return uri.getFragment();
	}

	/**
	* Returns the URI parameters if the provided path defines a URI.
	* @return the parameters map; can be empty if there are no parameters of if the path doesn't identify a URI
	*/
	public Map<String, Collection<String>> getParameters() {
	return parameters;
	}
	}

	}