class Opal::Hike::Index
‘Index` is an internal cached variant of `Trail`. It assumes the file system does not change between `find` calls. All `stat` and `entries` calls are cached for the lifetime of the `Index` object.
Attributes
‘Index#extensions` is an immutable collection of extensions.
‘Index#paths` is an immutable collection of `Pathname`s.
Public Class Methods
‘Index.new` is an internal method. Instead of constructing it directly, create a `Trail` and call `Trail#index`.
# File lib/opal/hike.rb, line 41 def initialize(root, paths, extensions) @root = root # Freeze is used here so an error is throw if a mutator method # is called on the array. Mutating `@paths`, `@extensions` # would have unpredictable results. @paths = paths.dup.freeze @extensions = extensions.dup.freeze @pathnames = paths.map { |path| Pathname.new(path) } @stats = {} @entries = {} @patterns = {} end
Public Instance Methods
A cached version of ‘Dir.entries` that filters out `.` files and `~` swap files. Returns an empty `Array` if the directory does not exist.
# File lib/opal/hike.rb, line 86 def entries(path) @entries[path.to_s] ||= begin pathname = Pathname.new(path) if pathname.directory? pathname.entries.reject { |entry| entry.to_s =~ /^\.|~$|^\#.*\#$/ }.sort else [] end end end
The real implementation of ‘find`. `Trail#find` generates a one time index and delegates here.
See ‘Trail#find` for usage.
# File lib/opal/hike.rb, line 70 def find(logical_path) base_path = Pathname.new(@root) logical_path = Pathname.new(logical_path.sub(/^\//, '')) if logical_path.to_s =~ %r{^\.\.?/} find_in_base_path(logical_path, base_path) { |path| return path } else find_in_paths(logical_path) { |path| return path } end nil end
‘Index#index` returns `self` to be compatable with the `Trail` interface.
# File lib/opal/hike.rb, line 62 def index self end
‘Index#root` returns root path as a `String`. This attribute is immutable.
# File lib/opal/hike.rb, line 57 def root @root.to_s end
A cached version of ‘File.stat`. Returns nil if the file does not exist.
# File lib/opal/hike.rb, line 99 def stat(path) key = path.to_s if @stats.key?(key) @stats[key] elsif File.exist?(path) @stats[key] = File.stat(path) else @stats[key] = nil end end
Protected Instance Methods
Returns a ‘Regexp` that matches the allowed extensions.
pattern_for("index.html") #=> /^index(.html|.htm)(.builder|.erb)*$/
# File lib/opal/hike.rb, line 167 def build_pattern_for(basename) extension_pattern = extensions.map { |e| Regexp.escape(e) }.join('|') /^#{basename}(?:#{extension_pattern})*$/ end
# File lib/opal/hike.rb, line 112 def extract_options!(arguments) arguments.last.is_a?(Hash) ? arguments.pop.dup : {} end
Finds relative logical path, ‘../test/test_trail`. Requires a `base_path` for reference.
# File lib/opal/hike.rb, line 126 def find_in_base_path(logical_path, base_path, &block) candidate = base_path.join(logical_path) dirname, basename = candidate.split match(dirname, basename, &block) if paths_contain?(dirname) end
Finds logical path across all ‘paths`
# File lib/opal/hike.rb, line 117 def find_in_paths(logical_path, &block) dirname, basename = logical_path.split @pathnames.each do |base_path| match(base_path.join(dirname), basename, &block) end end
Checks if the path is actually on the file system and performs any syscalls if necessary.
# File lib/opal/hike.rb, line 134 def match(dirname, basename) # Potential `entries` syscall matches = entries(dirname) pattern = pattern_for(basename) matches = matches.select { |m| m.to_s =~ pattern } sort_matches(matches, basename).each do |path| pathname = dirname.join(path) # Potential `stat` syscall stat = stat(pathname) # Exclude directories if stat && stat.file? yield pathname.to_s end end end
Returns true if ‘dirname` is a subdirectory of any of the `paths`
# File lib/opal/hike.rb, line 155 def paths_contain?(dirname) paths.any? { |path| dirname.to_s[0, path.length] == path } end
Cache
results of ‘build_pattern_for`
# File lib/opal/hike.rb, line 160 def pattern_for(basename) @patterns[basename] ||= build_pattern_for(basename) end
Sorts candidate matches by their extension priority. Extensions in the front of the ‘extensions` carry more weight.
# File lib/opal/hike.rb, line 175 def sort_matches(matches, basename) matches.sort_by do |match| extnames = match.sub(basename.to_s, '').to_s.scan(/\.[^.]+/) extnames.inject(0) do |sum, ext| index = extensions.index(ext) if index sum + index + 1 else sum end end end end