Configures the prefix prepended to asset paths before fetching them from the app directory.
Note that you specify path components as an array, <em>not</em> a single string that contains
multiple components with embedded path separators.
760516
public void setPathPrefix(String... components) {
    assert components.length > 0;
    for (String component : components) {
      assert !component.contains("/") && !component.contains("\\") :
        "Path components must not contain path separators: " + component;
    }
    pathPrefix = Path.Combine(components);
  }
1100179
private function prepareDirectories()
	{
		if ($this->hasAdmin)
		{
			$this->_mkdir($this->getBuildFolder() . "/administrator/components/com_" . $this->getExtensionName());
		}

		if ($this->hasFront)
		{
			$this->_mkdir($this->getBuildFolder() . "/components/com_" . $this->getExtensionName());
		}
	}
197566
private List<String> preparePrefixes() {
        // Prepare prefixes for all schemas
        List<String> prefixes = new ArrayList<String>(Schema.values().length + (local ? 3 : 0));
        for (Schema schema : Schema.values()) {
            prefixes.add(schema.getPrefix());
        }

        // For local URls prefixes are "./", "../", "/"
        if (local) {
            Collections.addAll(prefixes, LOCAL_PREFIXES);
        }
        return prefixes;
    }
245422
protected void initBundlePrefixes() {
		bundlePrefixes = new CopyOnWriteArrayList<>();
		for (JoinableResourceBundle bundle : globalBundles) {
			if (StringUtils.isNotEmpty(bundle.getBundlePrefix())) {
				bundlePrefixes.add(bundle.getBundlePrefix());
			}
		}
		for (JoinableResourceBundle bundle : contextBundles) {
			if (StringUtils.isNotEmpty(bundle.getBundlePrefix())) {
				bundlePrefixes.add(bundle.getBundlePrefix());
			}
		}
	}
1258409
public static Path pathFromComponents(String[] components) {
        if (null == components || components.length == 0) {
            return null;
        }
        return new PathImpl(pathStringFromComponents(components));
    }
1137939
def register_prefix(self, path):
        
        if path not in self._prefixes:
            LOG.debug('%r: registering prefix %r', self, path)
            self._prefixes.add(path)
93502
public void addPath(String path) {
        if (path == null) {
            return;
        }
        String[] pathComponents = path.split("/");
        TrieNode parent = rootNode;
        String part = null;
        if (pathComponents.length <= 1) {
            throw new IllegalArgumentException("Invalid path " + path);
        }
        for (int i=1; i<pathComponents.length; i++) {
            part = pathComponents[i];
            if (parent.getChild(part) == null) {
                parent.addChild(part, new TrieNode(parent));
            }
            parent = parent.getChild(part);
        }
        parent.setProperty(true);
    }
958064
function resolveDependencyPaths(options) {
  function init(items) {
    // Invalid if not Array
    if (Array.isArray(items)) {
      items.forEach((item, idx, items) => {
        const isArray = Array.isArray(item);
        const id = isArray ? item[0] : item;

        // Ignore already resolved
        if ('string' == typeof id) {
          const filepath = dependencies.find(id);

          if (!filepath) return warn(`unable to load plugin ${strong(id)}`, 1);

          if (isArray) {
            item[0] = require(filepath);
          } else {
            items[idx] = require(filepath);
          }
        }
      });
    }
  }

  if (options.plugins) init(options.plugins);
  if (options.presets) init(options.presets);
}
306173
def path_to_url
      prefix = Jammit.asset_roots.map{ |path| Regexp.escape(path) }.uniq.join("|")
      @path_to_url ||= /\A(#{prefix})(\/?#{Regexp.escape(Jammit.public_root.sub(/#{prefix}/, ''))})?/
    end
179647
function (component) {
            var pathParts = component === 'app' ? ['app'] : ['components'];
            if (component !== 'app') {
                pathParts.push(component);
            }
            pathParts.push('assets');

            return path.resolve(LAZO.FILE_REPO_PATH + path.sep + path.join.apply(this, pathParts));
        }
1177411
function preprocessMatchPath(segments) {
    const merged = mergeConsecutive(segments, '**');
    if (merged.length !== segments.length) {
        warn(`Consecutive '**' globs found
              (${segments.length - merged.length} excess).`);
    }
    segments = isolateGlobstarPattern(segments);
    segments = appendGlobstarIfTrailingSlash(segments);
    return mergeConsecutive([ ...segments,
                              ...(last(segments) === '**' ? ['*'] : []) ],
                            '**');
}
1120636
public static void setInputPaths(JobConf conf, String commaSeparatedPaths) {
    setInputPaths(conf, StringUtils.stringToPath(
                        getPathStrings(commaSeparatedPaths)));
  }
939718
protected void setupMavenPaths() {

		if (getAddCompileSourceRoot()) {
			getProject().addCompileSourceRoot(getGenerateDirectory().getPath());
		}
		if (getAddTestCompileSourceRoot()) {
			getProject().addTestCompileSourceRoot(getGenerateDirectory().getPath());
		}
		if (getEpisode() && getEpisodeFile() != null) {
			final String episodeFilePath = getEpisodeFile().getAbsolutePath();
			final String generatedDirectoryPath = getGenerateDirectory().getAbsolutePath();

			if (episodeFilePath.startsWith(generatedDirectoryPath + File.separator)) {
				final String path = episodeFilePath.substring(generatedDirectoryPath.length() + 1);

				final Resource resource = new Resource();
				resource.setDirectory(generatedDirectoryPath);
				resource.addInclude(path);
				if (getAddCompileSourceRoot()) {
					getProject().addResource(resource);
				}
				if (getAddTestCompileSourceRoot()) {
					getProject().addTestResource(resource);

				}
			}
		}
	}
497646
private void addFilePathMapping(BundlePathMapping bundlePathMapping, Set<String> paths) {
		for (String path : paths) {
			addFilePathMapping(bundlePathMapping, path);
		}
	}
700854
public static void before(@NotNull String path, @NotNull Handler handler) {
        staticInstance().before(prefixPath(path), handler);
    }
1292294
function setResourcePaths( root){
  rootPath = root;
  router.setPathToContent       ( root + '/app/content');
  renderer.setPathToTemplates   ( root + '/app/templates');
  renderer.setPathToModules     ( root + '/app/modules');
  renderer.setPathToStaticFiles ( root + '/app/static');
  console.info( 'running from %s', root);
}
306374
private function initializeForPrefix(): void
    {
        $keys = AdapterUtil::getPropertyValue($this, 'keys');
        $values = AdapterUtil::getPropertyValue($this, 'values');

        if (null === $values) {
            $file = AdapterUtil::getPropertyValue($this, 'file');
            $values = @(include $file) ?: [];

            AdapterUtil::setPropertyValue($this, 'keys', $keys);
            AdapterUtil::setPropertyValue($this, 'values', $values);
        }
    }