Returns the reflection corresponding to the given path.
488341
def reflection_for(path, for_join_table_only = false)
      @join_table_joins << path if for_join_table_only and !reflections[path]
      reflections[path] ||= map_reflection_for( path )
    end
1230338
private static String filePathToKey(String path) {

        try {
            return FileUtil.getDefaultInstance().canonicalPath(path);
        } catch (Exception e) {
            return path;
        }
    }
477394
private String parsePath(String path) {
        path = PathKit.fixPath(path);
        try {
            URI uri = new URI(path);
            return uri.getPath();
        } catch (URISyntaxException e) {
            //log.error("parse [" + path + "] error", e);
            return path;
        }
    }
1144601
function(path) {
  if (path.indexOf('url') === 0) return path;

  var options_ = options
    , token_ = token
    , tokens_ = tokens
    , variables_ = variables
    , traits_ = traits
    , depth_ = depth;

  var path = path.replace(/['"]/g, '')
    , css = fs.readFileSync(path, 'utf8');

  path = join(options.dir, path);

  css = parse(lex(css), {
    __proto__: options,
    dir: dirname(path)
  });

  options = options_;
  token = token_;
  tokens = tokens_;
  variables = variables_;
  traits = traits_;
  depth = depth_;

  return css;
}
1257895
def get(path)
      path = path.split(/\./) if path.is_a?(String)
      candidate = self
      while !path.empty?
        key = path.shift
        if candidate[key]
          candidate = candidate[key]
        else
          candidate = nil
          last
        end
      end
      candidate
    end
1093136
public InputStream getResourceAsStream( String path ) {
        Object in = null;
        if ( externalClassLoader != null )
            // classloader wants no leading slash
            in = externalClassLoader.getResourceAsStream( path.substring(1) );
        if ( in == null )
            return Interpreter.class.getResourceAsStream( path );

        return (InputStream) in;
    }
207201
function getFromPath(obj, path){
		path = path.split('.');

		for(var i = 0, l = path.length; i < l; i++){
			if (hasOwnProperty.call(obj, path[i]))
				obj = obj[path[i]];
			
			else
				return undefined;
		}
		
		return obj;
	}
442519
def get_object(self, path):
        """"""
        key = self.native_container.get_key(path)
        return self.obj_cls.from_key(self, key)
577440
function getWatcherByPath(path) {
        var rlt = undefined;

        watchers.forEach(function(watcher) {
            if (watcher.path == path)
                rlt = watcher;
        });

        return rlt;
    }
812050
public URL getResource( String path ) {
        URL url = null;
        if ( externalClassLoader != null )
            // classloader wants no leading slash
            url = externalClassLoader.getResource( path.substring(1) );
        if ( url == null )
            return Interpreter.class.getResource( path );

        return url;
    }
410666
def get_by_scheme(path, lookup, default):
    
    parsed = urlparse(path)
    class_name = lookup.get(parsed.scheme, default)
    if class_name is None:
        raise NotImplementedError("No implementation for scheme " + parsed.scheme)
    return class_name
1288353
private static String getFileNameInPath(String path) {
        String fName;
        if (path.indexOf('/') != -1) {
            fName = path.substring(path.lastIndexOf('/') + 1);
        } else {
            fName = path;
        }
        return fName;
    }
895426
@SuppressWarnings("unchecked")
    public <A extends Comparable<?>> ComparablePath<A> get(ComparablePath<A> path) {
        ComparablePath<A> newPath = getComparable(toString(path), (Class<A>) path.getType());
        return addMetadataOf(newPath, path);
    }
312611
function(path) {
		this.assertNotDestroyed('get', path);
		path = parsePath(path);

		switch (path[0]) {
			case '$this':
				if (path.length === 1)
					return this.data;
				break;
			case '$parent':
				this.assertHasParent(path);
				return this.parent.get(path.slice(1));
				break;
			case '$env':
				return this.env.get(path.slice(1));
		}
		return utils.getProp(this.data, path);
	}
410681
private static String[] getPathStack(String path) {
        String normalizedPath = path.replace(File.separatorChar, '/');

        return normalizedPath.split("/");
    }
1786
def get_object_from_path(path):
    
    try:
        return sys.IMPORT_CACHE[path]
    except KeyError:
        _path = path.split('.')
        module_path = '.'.join(_path[:-1])
        class_name = _path[-1]
        module = importlib.import_module(module_path)
        sys.IMPORT_CACHE[path] = getattr(module, class_name)
        return sys.IMPORT_CACHE[path]
1000116
def getRelativePath(basepath, path):
    """"""
    basepath = splitpath(os.path.abspath(basepath))
    path = splitpath(os.path.abspath(path))
    afterCommon = False
    for c in basepath:
        if afterCommon or path[0] != c:
            path.insert(0, os.path.pardir)
            afterCommon = True
        else:
            del path[0]
    return os.path.join(*path)