Class: Bootsnap::LoadPathCache::Cache

Inherits:
Object
  • Object
show all
Defined in:
lib/bootsnap/load_path_cache/cache.rb

Constant Summary collapse

AGE_THRESHOLD =

seconds

30
BUILTIN_FEATURES =

{ ‘enumerator’ => nil, ‘enumerator.so’ => nil, … }

$LOADED_FEATURES.each_with_object({}) do |feat, features|
  # Builtin features are of the form 'enumerator.so'.
  # All others include paths.
  next unless feat.size < 20 && !feat.include?('/')

  base = File.basename(feat, '.*') # enumerator.so -> enumerator
  ext  = File.extname(feat) # .so

  features[feat] = nil # enumerator.so
  features[base] = nil # enumerator

  next unless [DOT_SO, *DL_EXTENSIONS].include?(ext)
  DL_EXTENSIONS.each do |dl_ext|
    features["#{base}#{dl_ext}"] = nil # enumerator.bundle
  end
end.freeze

Instance Method Summary collapse

Constructor Details

#initialize(store, path_obj, development_mode: false) ⇒ Cache

Returns a new instance of Cache.



10
11
12
13
14
15
16
17
 
# File 'lib/bootsnap/load_path_cache/cache.rb', line 10

def initialize(store, path_obj, development_mode: false)
  @development_mode = development_mode
  @store = store
  @mutex = defined?(::Mutex) ? ::Mutex.new : ::Thread::Mutex.new # TODO: Remove once Ruby 2.2 support is dropped.
  @path_obj = path_obj.map! { |f| File.exist?(f) ? File.realpath(f) : f }
  @has_relative_paths = nil
  reinitialize
end

Instance Method Details

#absolute_path?(path) ⇒ Boolean

Returns:

  • (Boolean) 


96
97
98
 
# File 'lib/bootsnap/load_path_cache/cache.rb', line 96

def absolute_path?(path)
  path[1] == ':'
end

#find(feature) ⇒ Object

Try to resolve this feature to an absolute path without traversing the loadpath.

Raises:



47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
 
# File 'lib/bootsnap/load_path_cache/cache.rb', line 47

def find(feature)
  reinitialize if (@has_relative_paths && dir_changed?) || stale?
  feature = feature.to_s.freeze
  return feature if absolute_path?(feature)
  return expand_path(feature) if feature.start_with?('./')
  @mutex.synchronize do
    x = search_index(feature)
    return x if x

    # Ruby has some built-in features that require lies about.
    # For example, 'enumerator' is built in. If you require it, ruby
    # returns false as if it were already loaded; however, there is no
    # file to find on disk. We've pre-built a list of these, and we
    # return false if any of them is loaded.
    raise(LoadPathCache::ReturnFalse, '', []) if BUILTIN_FEATURES.key?(feature)

    # The feature wasn't found on our preliminary search through the index.
    # We resolve this differently depending on what the extension was.
    case File.extname(feature)
    # If the extension was one of the ones we explicitly cache (.rb and the
    # native dynamic extension, e.g. .bundle or .so), we know it was a
    # failure and there's nothing more we can do to find the file.
    # no extension, .rb, (.bundle or .so)
    when '', *CACHED_EXTENSIONS
      nil
    # Ruby allows specifying native extensions as '.so' even when DLEXT
    # is '.bundle'. This is where we handle that case.
    when DOT_SO
      x = search_index(feature[0..-4] + DLEXT)
      return x if x
      if DLEXT2
        x = search_index(feature[0..-4] + DLEXT2)
        return x if x
      end
    else
      # other, unknown extension. For example, `.rake`. Since we haven't
      # cached these, we legitimately need to run the load path search.
      raise(LoadPathCache::FallbackScan, '', [])
    end
  end

  # In development mode, we don't want to confidently return failures for
  # cases where the file doesn't appear to be on the load path. We should
  # be able to detect newly-created files without rebooting the
  # application.
  raise(LoadPathCache::FallbackScan, '', []) if @development_mode
end

#load_dir(dir) ⇒ Object

What is the path item that contains the dir as child? e.g. given “/a/b/c/d” exists, and the path is [“/a/b”], load_dir(“c/d”) is “/a/b”.



22
23
24
25
 
# File 'lib/bootsnap/load_path_cache/cache.rb', line 22

def load_dir(dir)
  reinitialize if stale?
  @mutex.synchronize { @dirs[dir] }
end

#push_paths(sender, *paths) ⇒ Object 



110
111
112
113
 
# File 'lib/bootsnap/load_path_cache/cache.rb', line 110

def push_paths(sender, *paths)
  return unless sender == @path_obj
  @mutex.synchronize { push_paths_locked(*paths) }
end

#reinitialize(path_obj = @path_obj) ⇒ Object 



115
116
117
118
119
120
121
122
123
124
 
# File 'lib/bootsnap/load_path_cache/cache.rb', line 115

def reinitialize(path_obj = @path_obj)
  @mutex.synchronize do
    @path_obj = path_obj
    ChangeObserver.register(self, @path_obj)
    @index = {}
    @dirs = {}
    @generated_at = now
    push_paths_locked(*@path_obj)
  end
end

#unshift_paths(sender, *paths) ⇒ Object 



105
106
107
108
 
# File 'lib/bootsnap/load_path_cache/cache.rb', line 105

def unshift_paths(sender, *paths)
  return unless sender == @path_obj
  @mutex.synchronize { unshift_paths_locked(*paths) }
end