parse api method reference as "apiname:mywidget"
@param  {[type]} env  [description]
@param  {[type]} path [description]
@return {[type]}      [description]
541963
function(path) {
			if (!path.forEach)
				path = path.split(':');
			if (path.length !== 2)
				throw new Error('yamvish method call badly formatted : ' + path.join(':'));
			var Cl = this.classes[path[0]];
			if (!Cl)
				throw new Error('no api found with "' + path.join(':') + '"');
			var method = Cl.prototype[path[1]];
			if (!method)
				throw new Error('no API method found with "' + path.join(':') + '"');
			return method;
		}
1263731
function mkpath(path) {
    var dirs = path.split(PATH.sep);
    var _path = '';
    var winDisk = /^\w{1}:\\$/;

    dirs.forEach(function(dir) {
        dir = dir || PATH.sep;
        if (dir) {
            _path = _path ? PATH.join(_path, dir) : dir;
            // fs.mkdirSync('/') raises EISDIR (invalid operation) exception on OSX 10.8.4/node 0.10
            // fs.mkdirSync('D:\\') raises EPERM (operation not permitted) exception on Windows 7/node 0.10
            // not tested in other configurations
            if (_path === '/' || winDisk.test(PATH.resolve(dir))) {
                return;
            }
            // @see https://github.com/veged/borschik/issues/90
            try {
                fs.mkdirSync(_path);
            } catch(e) {
                // ignore EEXIST error
                if (e.code !== 'EEXIST') {
                    throw new Error(e)
                }
            }
        }
    });
}
842110
function(obj, env, keypath) {
    if (!_.isObject(obj) || _.isArray(obj)) { return; }

    if (hasKeyPath(obj, ['options', 'reconfigureOverrides', env])) {
      var options = obj.options,
          overrides = obj.options.reconfigureOverrides[env];

      for (var key in overrides) {
        var update = { 
          key: keypath+'.options.'+key,
          oldVal: (typeof options[key] === 'undefined') ? 'undefined' : util.inspect(options[key]),
        };

        if (_.isObject(options[key]) && _.isObject(overrides[key])) { 
          var newVal = _.extend(options[key], overrides[key]);
          update.newVal = util.inspect(newVal);
        } else {
          options[key] = overrides[key];
          update.newVal = util.inspect(overrides[key]);
        }

        updates.push(update);
      }
    }
    
    for (var objKey in obj) {
      updateOptions(obj[objKey], env, keypath+'.'+objKey);
    }
  }
636544
private static Map<String, String> getConfServerBasePathMap(String app, String version, String env, String key) {

        Map<String, String> parameterMap = new LinkedHashMap<String, String>();

        parameterMap.put(Constants.VERSION, version);
        parameterMap.put(Constants.APP, app);
        parameterMap.put(Constants.ENV, env);
        parameterMap.put(Constants.KEY, key);

        return parameterMap;
    }
1374448
function(path) {
		var output = {},
			obj = path ? utils.getProp(this.data, path) : this.data;
		if (!obj)
			return null;
		for (var i in obj)
			if (!outputFiler.test(i))
				output[i] = obj[i];
		return output;
	}
961086
private function _parseInterceptMap($env)
    {
        // Set up authN/authZ if an URL mapping was given.
        if (isset($env['auth.interceptUrlMap']) && is_array($env['auth.interceptUrlMap'])) {
            // We may need to modify the intercept map, so make a copy of it
            $interceptMap = $env['auth.interceptUrlMap'];

            // Always allow HEAD requests unless the user specifically blocked them
            if (!array_key_exists('HEAD', $interceptMap)) {
                $interceptMap['HEAD'] = ['/**' => ['authN' => 'permitAll', 'authZ' => 'permitAll']];
            }

            // If the request method is not in the Intercept Map, throw an exception
            if (!array_key_exists($env['REQUEST_METHOD'], $interceptMap)) {
                throw new \Exception(
                    "Request Type: " . $env['REQUEST_METHOD'] . " does not exist in Auth Intercept Map"
                );
            }

            $antPathMatcher = new AntPathMatcher();
            foreach ($interceptMap[$env['REQUEST_METHOD']] as $pattern => $auth_array) {
                // Break out of the foreach loop if this URL matches the pattern.
                if ($antPathMatcher->match($pattern, $env['PATH_INFO'])) {
                    $this->authN_type = $auth_array['authN'];
                    $this->authZ_roles = $auth_array['authZ'];
                    break;
                }
            }
        }
    }
1363729
function parse(path) {
  if (t.Array.is(path)) {
    return path.map(parse).filter(Boolean);
  }
  var component = getComponent(require(path));
  if (component) {
    var comments = getComments(path);
    var descriptions = getDescriptions(comments);
    var type = toObject(getPropsType(component));
    var props = type.kind === 'refinement' ? type.type.props : type.props;
    var defaultProps = getDefaultProps(component);
    var name = getComponentName(component);
    for (var prop in props) {
      if (props.hasOwnProperty(prop)) {
        if (defaultProps.hasOwnProperty(prop)) {
          props[prop].defaultValue = defaultProps[prop];
        }
        if (descriptions.props.hasOwnProperty(prop)) {
          props[prop].description = descriptions.props[prop];
        }
      }
    }
    return {
      name: name,
      description: descriptions.component,
      props: props
    };
  }
}
1094172
function parseIndexedPaths(path) {
                var opensb = path.lastIndexOf('[');
                info.entityPath = path.substring(0, opensb);  // path to entity is before last [
                var propertyPath = path.substring(opensb + 1, path.length - 1); // property is between [ ]
                // eval it, in case it's an angular expression
                try { var evalPath = info.scope.$eval(propertyPath); }
                catch (_) { }
                info.propertyPath = evalPath ? evalPath : propertyPath;
            }
350427
function Env(data, parent, path) {
	Context.call(this, data, parent, path);
	delete this.env;
}
731002
function getPaths(path) {
        var appPath = path;
        if (/dev\/temp\.ts$/.test(path)) // hack used when debugging.
            appPath = 'pargv';
        var appName = path_1.basename(appPath); // get the basename from path.
        var completionsDir = path_1.join(env.HOME_PATH, "." + appName);
        if (/\.(ts|js)$/.test(appPath)) {
            appPath = "./" + appPath; // not installed as bin.
            var parsedPath = path_1.parse(appPath);
            completionsDir = parsedPath.dir; // store completions.sh at executable file path.
        }
        var bashPath = !/^win/.test(env.PLATFORM) ? /^darwin/.test(env.PLATFORM) ? '.bash_profile' : '.bashrc' : false;
        if (bashPath)
            bashPath = path_1.join(env.HOME_PATH, bashPath);
        var completionsPath = path_1.join(completionsDir, 'completions.sh');
        return {
            appName: appName,
            appPath: appPath,
            bashPath: bashPath,
            completionsDir: completionsDir,
            completionsPath: completionsPath // the completions path.
        };
    }
65696
function getNameForPath(path: Path): string {
  const {node, parent, parentPath} = path;
  if (t.isProgram(node)) {
    return '<global>';
  }
  let {id} = path;
  // has an `id` so we don't need to infer one
  if (node.id) {
    return node.id.name;
  }
  let propertyPath;
  let kind = '';
  if (t.isObjectMethod(node) || t.isClassMethod(node)) {
    id = node.key;
    if (node.kind !== 'method') {
      kind = node.kind;
    }
    propertyPath = path;
  } else if (t.isObjectProperty(parent) || t.isClassProperty(parent)) {
    // { foo() {} };
    id = parent.key;
    propertyPath = parentPath;
  } else if (t.isVariableDeclarator(parent)) {
    // let foo = function () {};
    id = parent.id;
  } else if (t.isAssignmentExpression(parent)) {
    // foo = function () {};
    id = parent.left;
  } else if (t.isJSXExpressionContainer(parent)) {
    if (t.isJSXElement(parentPath.parentPath.node)) {
      // <foo>{function () {}}</foo>
      const openingElement = parentPath.parentPath.node.openingElement;
      id = t.JSXMemberExpression(
        t.JSXMemberExpression(openingElement.name, t.JSXIdentifier('props')),
        t.JSXIdentifier('children'),
      );
    } else if (t.isJSXAttribute(parentPath.parentPath.node)) {
      // <foo bar={function () {}} />
      const openingElement = parentPath.parentPath.parentPath.node;
      const prop = parentPath.parentPath.node;
      id = t.JSXMemberExpression(
        t.JSXMemberExpression(openingElement.name, t.JSXIdentifier('props')),
        prop.name,
      );
    }
  }

  let name = getNameFromId(id);

  if (name == null) {
    if (t.isCallExpression(parent)) {
      // foo(function () {})
      const argIndex = parent.arguments.indexOf(node);
      if (argIndex !== -1) {
        const calleeName = getNameFromId(parent.callee);
        if (calleeName) {
          return `${calleeName}$argument_${argIndex}`;
        }
      }
    }
    return ANONYMOUS_NAME;
  }

  if (kind) {
    name = kind + '__' + name;
  }

  if (propertyPath) {
    if (t.isClassBody(propertyPath.parent)) {
      const className = getNameForPath(propertyPath.parentPath.parentPath);
      if (className !== ANONYMOUS_NAME) {
        const separator = propertyPath.node.static ? '.' : '#';
        name = className + separator + name;
      }
    } else if (t.isObjectExpression(propertyPath.parent)) {
      const objectName = getNameForPath(propertyPath.parentPath);
      if (objectName !== ANONYMOUS_NAME) {
        name = objectName + '.' + name;
      }
    }
  }

  return name;
}
705421
function getReferences(path, variableName) {
  const bindings = path.scope.getBinding(variableName);
  const references = bindings.referencePaths;
  return references;
}
366174
function extendWithDotEnv(inputEnv, dotEnvPath = '.env') {
    let dotEnvBuffer = null
    try {
        dotEnvBuffer = fs.readFileSync(dotEnvPath)
    } catch (err) {
        if (err.code === 'ENOENT') return inputEnv
        throw err
    }
    const parsed = dotenv.parse(dotEnvBuffer)
    return extend(parsed, inputEnv)
}
1010224
function(path_config) {

		var widget = this._widget.locateViewByPathConfig(path_config);
		if (Lava.schema.DEBUG && !widget.isWidget) Lava.t("Tried to call a modifier from non-widget view");

		return /** @type {Lava.widget.Standard} */ widget;

	}
284786
def recognize(env)
      env["lita.robot"] = robot
      recognized_routes_for(env).map { |match| match.route.name }
    end
699031
def addEnvPath(env, name, value):
    
    try:
        oldval = env[name]
        if not oldval.endswith(';'):
            oldval = oldval + ';'
    except KeyError:
        oldval = ""
    if not value.endswith(';'):
        value = value + ';'
    env[name] = oldval + value
564791
function(...path) {
      path = pathify(path);
      return noUndef(path)
        ? model.getValueSync(path)
        : undefined;
    }