class Bootsnap::LoadPathCache::Path

def entries_and_dirs(store)

of this +Path+.
Return a list of all the requirable files and all of the subdirectories 
def entries_and_dirs(store)
  if stable?
    # the cached_mtime field is unused for 'stable' paths, but is
    # set to zero anyway, just in case we change the stability heuristics.
    _, entries, dirs = store.get(expanded_path)
    return [entries, dirs] if entries # cache hit
    entries, dirs = scan!
    store.set(expanded_path, [0, entries, dirs])
    return [entries, dirs]
  end
  cached_mtime, entries, dirs = store.get(expanded_path)
  current_mtime = latest_mtime(expanded_path, dirs || [])
  return [[], []]        if current_mtime == -1 # path does not exist
  return [entries, dirs] if cached_mtime == current_mtime
  entries, dirs = scan!
  store.set(expanded_path, [current_mtime, entries, dirs])
  [entries, dirs]
end

def expanded_path 

def expanded_path
  File.expand_path(path)
end

def initialize(path) 

def initialize(path)
  @path = path.to_s
end

def latest_mtime(path, dirs)

/a/b/c, pass ('/a/b', ['c'])
list of relative paths to directories under +path+. e.g. for /a/b and
last time a directory was modified in this subtree. +dirs+ should be a 
def latest_mtime(path, dirs)
  max = -1
  ["", *dirs].each do |dir|
    curr = begin
      File.mtime("#{path}/#{dir}").to_i
    rescue Errno::ENOENT
      -1
    end
    max = curr if curr > max
  end
  max
end

def non_directory?

True if the path exists, but represents a non-directory object 
def non_directory?
  !File.stat(path).directory?
rescue Errno::ENOENT
  false
end

def relative? 

def relative?
  !path.start_with?(SLASH)
end

def scan! # (expensive) returns [entries, dirs]

(expensive) returns [entries, dirs] 
def scan! # (expensive) returns [entries, dirs]
  PathScanner.call(expanded_path)
end

def stability 

def stability
  @stability ||= begin
    if Gem.path.detect { |p| expanded_path.start_with?(p.to_s) }
      STABLE
    elsif Bootsnap.bundler? && expanded_path.start_with?(Bundler.bundle_path.to_s)
      STABLE
    elsif expanded_path.start_with?(RUBY_LIBDIR) && !expanded_path.start_with?(RUBY_SITEDIR)
      STABLE
    else
      VOLATILE
    end
  end
end

def stable?

must be cleared before the change will be noticed.
distribution. When adding or removing files in these paths, the cache
A path is considered 'stable' if it is part of a Gem.path or the ruby 
def stable?
  stability == STABLE
end

def volatile?

more frequently.
the ruby distribution root. These paths are scanned for new additions
A path is considered volatile if it doesn't live under a Gem.path or 
def volatile?
  stability == VOLATILE
end