The static cache path that will be used for this system + options, used if static cache is enabled
@param  {Object} options
@return {string}
198941
function getUserCachePath(options) {
  // If we've manually set the static cache location
  if (options && options.cacheLocation) {
    return path.resolve(options.cacheLocation);
  }

  // Otherwise, find/use the python-ey appdirs cache location
  const dirs = new Appdir({
    appName: 'serverless-python-requirements',
    appAuthor: 'UnitedIncome'
  });
  return dirs.userCache();
}
939326
private static Path locateFileInCache(Configuration conf, String filename) throws IOException {
    return new Path(getInstancesFolder(FileSystem.get(conf), conf), filename);
  }
630443
public function getCache()
    {
        if (!$this->cache) {
            $options = isset($this->options['cache']) ? $this->options['cache'] : [];
            foreach (static::defaultOptions()['cache'] as $k=>$v) {
                if (!isset($options[$k])) {
                    $options[$k] = $v;
                }
            }
            if (!file_exists($options['path'])) {
                $options['path'] = Config::getStoragePath() . trim($options['path'], '\\/');
            }
            
            $this->cache = new Cache($options); 
        }
        
        return $this->cache;
    }
908360
function shouldCache(options) {
    options = options || {};
    return (options.hasOwnProperty('cache') && !options.cache) || !self.options.cache;
  }
556466
public static File getPath(){
		if (path==null) {
			UserConfiguration config = new UserConfiguration();
			path = new File(config.getCacheFilePath());
		}
		return path;
	}
825434
function getSourceMap(options) {
  var sourceMap = options.sourceMap;

  if (sourceMap && typeof sourceMap !== 'string' && options.outFile) {
    sourceMap = options.outFile + '.map';
  }

  return sourceMap && typeof sourceMap === 'string' ? path.resolve(sourceMap) : null;
}
1108069
function (options) {
  var git_repo_path = ((options && options['gcwd']) || process.cwd()) + '/.git';

  return fs.statAsync(git_repo_path)
    .call('isDirectory')
    .then(function (exist) {
      return exist && git_repo_path
    })
}
768668
function(options){
        this.type = options.type || EJS.type;
		this.cache = options.cache != null ? options.cache : EJS.cache;
		this.text = options.text || null;
		this.name =  options.name || null;
		this.ext = options.ext || EJS.ext;
		this.extMatch = new RegExp(this.ext.replace(/\./, '\.'));
	}
1293975
protected static function _getCachePath()
    {
        $_cachePath = DIRECTORY_SEPARATOR . '.kisma' . DIRECTORY_SEPARATOR . 'cache';
        $_path = null;

        //  Build a list of potential paths
        $_paths = array(
            //  /path/to/kisma/cache... user set
            getenv( 'KISMA_CACHE_PATH' ),
            //  ~/.kisma/cache (linux $HOME)
            getenv( 'HOME' ) . $_cachePath,
            //  /path/to/kisma/.cache
            dirname( __DIR__ ) . DIRECTORY_SEPARATOR . '.cache',
        );

        //  ~/.kisma/cache (Windows $HOME) if posix_*
        if ( function_exists( 'posix_getpwuid' ) && function_exists( 'posix_getuid' ) )
        {
            $_user = posix_getpwuid( posix_getuid() );

            if ( $_user && isset( $_user['dir'] ) )
            {
                $_paths[] = $_user['dir'] . $_cachePath;
            }
        }

            //  defaults to /tmp/.kisma/cache
        $_paths[] = sys_get_temp_dir() . $_cachePath;

        foreach ( $_paths as $_path )
        {
            if ( !empty( $_path ) )
            {
                if ( FileSystem::ensurePath( $_path ) )
                {
                    break;
                }

                $_path = false;
            }
        }

        if ( empty( $_path ) )
        {
            return false;
        }

        return $_path;
    }
990449
function outputPath(options, source) {
    var DEBUG = false;
    if (DEBUG)
        console.log('sourceFolder: ' + options.sourceFolder);
    var globBase = options.sourceFolder.replace(/\*.*/, '');
    if (globBase.endsWith('.sol')) // single file
        globBase = path.join(globBase, '../');
    if (DEBUG)
        console.log('globBase: ' + globBase);
    var optDestination = options.destinationFolder ? options.destinationFolder : globBase;
    if (DEBUG)
        console.log('optDestination: ' + optDestination);
    var destinationFolder = path.join(globBase, optDestination);
    if (optDestination === globBase)
        destinationFolder = globBase;
    if (DEBUG)
        console.log('destinationFolder: ' + destinationFolder);
    // destination-folder is absolut
    if (options.destinationFolder && options.destinationFolder.startsWith('/'))
        destinationFolder = path.join(options.destinationFolder, './');
    var fileNameRelative = source.filename.replace(globBase, '');
    if (DEBUG)
        console.log('fileNameRelative: ' + fileNameRelative);
    var goalPath = path.join(destinationFolder, fileNameRelative);
    return goalPath;
}
1193605
function staticViews (router, options) {
  if (!options) {
    return
  }

  Object.keys(options).filter(urlPath => options[urlPath]).forEach((urlPath) => {
    const filePath = options[urlPath]

    router.get(urlPath, (req, res) => {
      res.render(filePath)
    })
  })
}
481296
def cache_path(self):
        
        cache_path = os.path.join(os.path.dirname(__file__), '..', 'cache')
        if not os.path.exists(cache_path):
            os.mkdir(cache_path)
        return cache_path
1062719
function getParentPath(moduleMeta, options) {
  var referrer = moduleMeta.referrer;
  return (referrer && moduleMeta !== referrer) ? referrer.path : options.baseUrl;
}
1097132
function loadPartials (options) {
    // return cached partials if caching enabled
    if (options.cache && GLOBAL.partials) {
        return GLOBAL.partials
    }
    // load partials
    GLOBAL.partials = loadTemplates(GLOBAL.partialDirs, options)
    // return promise that will be resolved with partials
    return GLOBAL.partials
}
272232
def static_url(redis, path):
    """"""
    file_hash = get_cache_buster(redis, path)
    return "%s/%s?v=%s" % (oz.settings["static_host"], path, file_hash)
1320149
static function cachePath( $keyString, $nodeID = false )
    {
        $filename = md5( $keyString ) . ".cache";

        $phpDir = eZTemplateCacheBlock::templateBlockCacheDir();
        if ( is_numeric( $nodeID ) )
        {
            $phpDir .= eZTemplateCacheBlock::calculateSubtreeCacheDir( $nodeID, $filename );
        }
        else
        {
            $phpDir .= $filename[0] . '/' . $filename[1] . '/' . $filename[2];
        }

        $phpPath = $phpDir . '/' . $filename;
        return $phpPath;
    }
541507
function getTransformCacheKey(opts: {|
  +cacheVersion: string,
  +projectRoot: string,
  +transformerConfig: TransformerConfig,
|}): string {
  const {transformerPath, transformerConfig} = opts.transformerConfig;

  // eslint-disable-next-line lint/flow-no-fixme
  /* $FlowFixMe: dynamic requires prevent static typing :'(  */
  const Transformer = require(transformerPath);
  const transformerInstance = new Transformer(
    opts.projectRoot,
    transformerConfig,
  );

  const transformerKey =
    typeof transformerInstance.getCacheKey !== 'undefined'
      ? transformerInstance.getCacheKey()
      : '';

  const cacheKeyParts = [
    'metro-cache',
    VERSION,
    opts.cacheVersion,
    path.relative(path.join(__dirname, '../../../..'), opts.projectRoot),
    getKeyFromFiles([require.resolve(transformerPath)]),
    transformerKey,
  ];

  return crypto
    .createHash('sha1')
    .update(cacheKeyParts.join('$'))
    .digest('hex');
}