alias_method :path, :paths
196526
def build_paths
      case @paths
      when String
        @paths = Path::Single.new(path: @paths)
      when Array
        tmp_paths = []
        @paths.each do |path|
          if path.is_a? Hash
            tmp_paths << Path::Single.new(path)
          elsif path.is_a? String
            tmp_paths << Path::Single.new(path: path)
          else
            raise 'Unknown path structure'
          end
        end
        @paths = Path::Sequence.new(tmp_paths)
      when Hash
        @paths = Path::Single.new(@paths)
      when Path::Single, Path::Sequence, Path::Weighted
      else
        raise 'Unknown path structure'
      end
    end
1158189
def paths_for_shell(paths, separator=' '):
    
    paths = filter(None, paths)
    paths = map(shlex.quote, paths)
    if separator is None:
        return paths
    return separator.join(paths)
514132
def route_and_method_from_enclosing_resource_method_and_name_prefix(method, name_prefix)
      if enclosing_resource
        enclosing_route = name_prefix.sub(/_$/,'')
        route_method = method.to_s.sub(/enclosing_resource(s)?/) { $1 ? enclosing_route.pluralize : enclosing_route }
        return [Rails.application.routes.named_routes.get(route_method.sub(/_(path|url)$/,'').to_sym), route_method]
      else
        raise NoMethodError, "Tried to map :#{method} but there is no enclosing_resource for this controller"
      end
    end
664843
def resolve_alias(self, path_str):
        """"""
        if path_str in self.aliases:
            return self.aliases[path_str]
        return path_str
1136588
def method_call_path(method_call_tag)
      # r method_call_tag.values_at(:name, :receiver)
      name, receiver, scope = method_call_tag.values_at(:name, :receiver, :scope)
      scope = scope.join("::")

      if receiver == :class
        scope = "Kernel" if scope.empty?
        new_method_path(scope, :class, name)
      elsif receiver == :instance
        scope = "Kernel" if scope.empty?
        new_method_path(scope, :instance, name)
      else
        receiver = receiver.join("::")
        new_method_path(Reflexive.constant_lookup(receiver, scope), :class, name)
      end

#    if receiver.last == :instance
#      new_method_path(receiver[0..-2].join("::"), :instance, name)
#    else
#      new_method_path(receiver.join("::"), :class, name)
#    end rescue(r(method_call_tag))
    end
79000
function(name, realpath) {
        if (regAlias.test(name)) {
            if ($.isUndefined(realpath)) {
                return mapAlias[name];
            }
            mapAlias[name] = String(realpath).split(',');
        } else if ($.isObject(name)) {
            realpath = name.path;
            name = name;
            _.alias(name, realpath);
        }
    }
915085
def class_reference_from_action_alias(method_sym)
      alias_found = find_alias(method_sym.to_s)
      return nil unless alias_found

      class_reference_from_action_name(alias_found.to_sym)
    end
245166
def path_dispatch_rename(rename_like_method):
        

        def _wrapper_method(self, old_path, new_path):
            old_path, _old_path, old_sentinel =  _split_path(old_path);
            new_path, _new_path, new_sentinel =  _split_path(new_path);

            if old_sentinel != new_sentinel:
                raise ValueError('Does not know how to move things across contents manager mountpoints')
            else:
                sentinel = new_sentinel


            man = self.managers.get(sentinel, None)
            if man is not None:
                rename_meth = getattr(man, rename_like_method.__name__)
                sub = rename_meth('/'.join(_old_path), '/'.join(_new_path))
                return sub
            else :
                return rename_meth(self, old_path, new_path)
        return _wrapper_method
1190503
function parseOn(cls, alias, method, joinTable, joinAlias, on) {
    cls[method](`${joinTable} as ${joinAlias}`, function () {
        for (let n in on) {
            if (n.toLowerCase() === 'or') {
                if (!helper.isArray(on[n])) {
                    continue;
                }
                on[n].map(item => {
                    for (let i in item) {
                        this.orOn(`${alias}.${i}`, '=', `${joinAlias}.${item[i]}`);
                    }
                });
            } else {
                this.on(`${alias}.${n}`, '=', `${joinAlias}.${on[n]}`);
            }
        }
    });
}
693705
def build_path_to(script_name = nil, *args)
    args.compact!
    query = args.pop if args.last.kind_of?(Hash)
    path  = map_path_to(script_name, *args)
    path << "?" << Rack::Utils::build_query(query) if query
    path
  end
611741
function (method, prefix, content) {
    return (
      /* The alias method implementation. */
      function () {
        if (prefix !== null) {
          P_ARRAY.unshift.call(arguments, prefix);
        }
        if (api.logTimestamps && content === null) {
          P_ARRAY.unshift.call(arguments, dateToIsoString(new Date()) + " ");
        }
        return (
          api[method].apply(api, content !== null ? [ content ] : arguments)
        );
      }
    );
  }
601974
def extract_paths(self, paths, *args, **kwargs):
        
        return self.provider.extract_paths(paths, *args, **kwargs)
958192
def handle_aliases_in_init_files(name, import_alias_mapping):
    
    for key, val in import_alias_mapping.items():
        # e.g. Foo == Foo
        # e.g. Foo.Bar startswith Foo.
        if name == val or \
                name.startswith(val + '.'):

            # Replace val with key in name
            # e.g. StarbucksVisitor.Tea -> Eataly.Tea because
            #   "from .nested_folder import StarbucksVisitor as Eataly"
            return name.replace(val, key)
    return None
452042
def define_inheritable_alias_method(new_method, original_method)
      define_method(new_method) do |*args, &block|
        public_send(original_method, *args, &block)
      end
    end
456582
def query_paths(self):
        
        output = self.namespace.alias_to_query_paths.get(self.name)
        if output:
            return output
        Log.error("Can not find index {{index|quote}}", index=self.name)
239785
function alias(path, aliases)
{
	// if it's a path to a file - don't interfere
	if (!is_package_path(path))
	{
		return
	}

	// extract module name from the path
	const slash_index = path.indexOf('/')
	const module_name = slash_index >= 0 ? path.substring(0, slash_index) : path
	const rest = slash_index >= 0 ? path.substring(slash_index) : ''

	// find an alias
	const alias = aliases[module_name]

	// if an alias is found, require() the correct path
	if (alias)
	{
		return alias + rest
	}
}
865916
def paths(arrs)
      arrs.inject([[]]) do |paths, arr|
        arr.map {|e| paths.map {|path| path + [e]}}.flatten(1)
      end
    end