private IEnumerable <MutableString> /*!*/ GetPathsToTestLoaded(string /*!*/ path, string fullPath, LoadFlags flags, string[] /*!*/ sourceFileExtensions) { List <MutableString> paths = new List <MutableString>(); paths.Add(_context.EncodePath(path)); if (fullPath != null) { paths.Add(_context.EncodePath(path)); } if ((flags & LoadFlags.AppendExtensions) != 0 && RubyUtils.GetExtension(path).Length == 0) { foreach (var extension in sourceFileExtensions) { paths.Add(_context.EncodePath(path + extension)); } foreach (var extension in _LibraryExtensions) { paths.Add(_context.EncodePath(path + extension)); } } return(paths); }
/// <summary> /// Searches file in load directories and then appends extensions. /// </summary> private ResolvedFile FindFile(string /*!*/ path, bool appendExtensions, string[] sourceFileExtensions) { Assert.NotNull(path); bool isAbsolutePath; #if SILVERLIGHT { #else if (path.StartsWith("~/", StringComparison.Ordinal) || path.StartsWith("~\\", StringComparison.Ordinal)) { path = RubyUtils.ExpandPath(_context.Platform, path); isAbsolutePath = true; } else { #endif try { isAbsolutePath = Platform.IsAbsolutePath(path); } catch (ArgumentException e) { throw RubyExceptions.CreateLoadError(e); } } string extension = RubyUtils.GetExtension(path); // Absolute path -> load paths not consulted. if (isAbsolutePath) { return(ResolveFile(path, extension, appendExtensions, sourceFileExtensions)); } string[] loadPaths = GetLoadPathStrings(); if (loadPaths.Length == 0) { return(null); } // If load paths are non-empty and the path starts with .\ or ..\ then MRI also ignores the load paths. if (path.StartsWith("./", StringComparison.Ordinal) || path.StartsWith("../", StringComparison.Ordinal) || path.StartsWith(".\\", StringComparison.Ordinal) || path.StartsWith("..\\", StringComparison.Ordinal)) { return(ResolveFile(path, extension, appendExtensions, sourceFileExtensions)); } foreach (var dir in loadPaths) { ResolvedFile result = ResolveFile(RubyUtils.CombinePaths(dir, path), extension, appendExtensions, sourceFileExtensions); if (result != null) { return(result); } } return(null); }
private bool AlreadyLoaded(string /*!*/ path, string fullPath, LoadFlags flags, string[] /*!*/ sourceFileExtensions) { Debug.Assert(fullPath == null || RubyUtils.GetExtension(path) == RubyUtils.GetExtension(fullPath)); IEnumerable <string> appendExtensions = (flags & LoadFlags.AppendExtensions) != 0 && RubyUtils.GetExtension(path).Length == 0 ? sourceFileExtensions.Concat(_LibraryExtensions) : null; return((flags & LoadFlags.LoadOnce) != 0 && IsFileLoaded(path, fullPath, appendExtensions)); }
/// <summary> /// Appends extensions if applicable. /// </summary> private ResolvedFile ResolveFile(string /*!*/ path, string /*!*/ extension, bool appendExtensions, string[] /*!*/ knownExtensions) { Debug.Assert(RubyUtils.GetExtension(path) == extension); string expandedPath = RubyUtils.ExpandPath(_context.Platform, path); // MRI doesn't load file w/o .rb extension: if (IsKnownExtension(extension, knownExtensions)) { return(GetSourceUnit(path, expandedPath, extension, false)); } if (_LibraryExtensions.IndexOf(extension, DlrConfiguration.FileExtensionComparer) != -1) { if (Platform.FileExists(expandedPath)) { return(new ResolvedFile(expandedPath, null)); } } else if (!appendExtensions) { return(GetSourceUnit(path, expandedPath, extension, false)); } if (appendExtensions) { List <string> matchingExtensions = GetExtensionsOfExistingFiles(expandedPath, knownExtensions); if (matchingExtensions.Count == 1) { return(GetSourceUnit(path + matchingExtensions[0], expandedPath + matchingExtensions[0], matchingExtensions[0], true)); } else if (matchingExtensions.Count > 1) { Exception e = new AmbiguousFileNameException(expandedPath + matchingExtensions[0], expandedPath + matchingExtensions[1]); throw RubyExceptions.CreateLoadError(e); } foreach (string libExtension in _LibraryExtensions) { if (Platform.FileExists(expandedPath + libExtension)) { return(new ResolvedFile(expandedPath + libExtension, libExtension)); } } } return(null); }
private bool AlreadyLoaded(string /*!*/ path, string fullPath, LoadFlags flags, string[] /*!*/ sourceFileExtensions) { Debug.Assert(fullPath == null || RubyUtils.GetExtension(path) == RubyUtils.GetExtension(fullPath)); return((flags & LoadFlags.LoadOnce) != 0 && AnyFileLoaded(GetPathsToTestLoaded(path, fullPath, flags, sourceFileExtensions))); }
private ResolvedFile FindFile(string /*!*/ path, bool appendExtensions, string[] sourceFileExtensions) { Assert.NotNull(path); bool isAbsolutePath; string extension; string home = null; #if !SILVERLIGHT if (path.StartsWith("~/", StringComparison.Ordinal) || path.StartsWith("~\\", StringComparison.Ordinal)) { try { home = Environment.GetEnvironmentVariable("HOME"); } catch (SecurityException) { home = null; } if (home == null) { throw RubyExceptions.CreateArgumentError(String.Format("couldn't find HOME environment -- expanding `{0}'", path)); } } #endif try { if (home != null) { path = RubyUtils.CombinePaths(home, path.Substring(2)); } isAbsolutePath = Platform.IsAbsolutePath(path); extension = RubyUtils.GetExtension(path); } catch (ArgumentException e) { throw RubyExceptions.CreateLoadError(e); } // Absolute path -> load paths not consulted. if (isAbsolutePath) { return(ResolveFile(path, extension, appendExtensions, sourceFileExtensions)); } string[] loadPaths = GetLoadPathStrings(); if (loadPaths.Length == 0) { return(null); } // If load paths are non-empty and the path starts with .\ or ..\ then MRI also ignores the load paths. if (path.StartsWith("./", StringComparison.Ordinal) || path.StartsWith("../", StringComparison.Ordinal) || path.StartsWith(".\\", StringComparison.Ordinal) || path.StartsWith("..\\", StringComparison.Ordinal)) { return(ResolveFile(path, extension, appendExtensions, sourceFileExtensions)); } foreach (var dir in loadPaths) { try { ResolvedFile result = ResolveFile(RubyUtils.CombinePaths(dir, path), extension, appendExtensions, sourceFileExtensions); if (result != null) { return(result); } } catch (ArgumentException) { // invalid characters in path } } return(null); }