bootsnap 0.2.0

data/lib/bootsnap/load_path_cache/change_observer.rb

@@ -0,0 +1,56 @@
+module Bootsnap
+  module LoadPathCache
+    module ChangeObserver
+      def self.register(observer, arr)
+        # Re-overriding these methods on an array that already has them would
+        # cause StackOverflowErrors
+        return if arr.respond_to?(:push_without_lpc)
+
+        # For each method that adds items to one end or another of the array
+        # (<<, push, unshift, concat), override that method to also notify the
+        # observer of the change.
+        sc = arr.singleton_class
+        sc.send(:alias_method, :shovel_without_lpc, :<<)
+        arr.define_singleton_method(:<<) do |entry|
+          observer.push_paths(self, entry)
+          shovel_without_lpc(entry)
+        end
+
+        sc.send(:alias_method, :push_without_lpc, :push)
+        arr.define_singleton_method(:push) do |*entries|
+          observer.push_paths(self, *entries)
+          push_without_lpc(*entries)
+        end
+
+        sc.send(:alias_method, :unshift_without_lpc, :unshift)
+        arr.define_singleton_method(:unshift) do |*entries|
+          observer.unshift_paths(self, *entries)
+          unshift_without_lpc(*entries)
+        end
+
+        sc.send(:alias_method, :concat_without_lpc, :concat)
+        arr.define_singleton_method(:concat) do |entries|
+          observer.push_paths(self, *entries)
+          concat_without_lpc(entries)
+        end
+
+        # For each method that modifies the array more aggressively, override
+        # the method to also have the observer completely reconstruct its state
+        # after the modification. Many of these could be made to modify the
+        # internal state of the LoadPathCache::Cache more efficiently, but the
+        # accounting cost would be greater than the hit from these, since we
+        # actively discourage calling them.
+        %i(
+          collect! compact! delete delete_at delete_if fill flatten! insert map!
+          reject! reverse! select! shuffle! shift slice! sort! sort_by!
+        ).each do |meth|
+          sc.send(:alias_method, :"#{meth}_without_lpc", meth)
+          arr.define_singleton_method(meth) do |*a|
+            send(:"#{meth}_without_lpc", *a)
+            observer.reinitialize
+          end
+        end
+      end
+    end
+  end
+end

data/lib/bootsnap/load_path_cache/core_ext/active_support.rb

@@ -0,0 +1,68 @@
+module Bootsnap
+  module LoadPathCache
+    module CoreExt
+      module ActiveSupport
+        def self.with_bootsnap_fallback(error)
+          yield
+        rescue error
+          without_bootsnap_cache { yield }
+        end
+
+        def self.without_bootsnap_cache
+          prev = Thread.current[:without_bootsnap_cache] || false
+          Thread.current[:without_bootsnap_cache] = true
+          yield
+        ensure
+          Thread.current[:without_bootsnap_cache] = prev
+        end
+
+        module ClassMethods
+          def autoload_paths=(o)
+            r = super
+            Bootsnap::LoadPathCache.autoload_paths_cache.reinitialize(o)
+            r
+          end
+
+          def search_for_file(path)
+            return super if Thread.current[:without_bootsnap_cache]
+            begin
+              Bootsnap::LoadPathCache.autoload_paths_cache.find(path)
+            rescue Bootsnap::LoadPathCache::ReturnFalse
+              nil # doesn't really apply here
+            end
+          end
+
+          def autoloadable_module?(path_suffix)
+            Bootsnap::LoadPathCache.autoload_paths_cache.has_dir?(path_suffix)
+          end
+
+          def remove_constant(const)
+            CoreExt::ActiveSupport.without_bootsnap_cache { super }
+          end
+
+          # If we can't find a constant using the patched implementation of
+          # search_for_file, try again with the default implementation.
+          #
+          # These methods call search_for_file, and we want to modify its
+          # behaviour.  The gymnastics here are a bit awkward, but it prevents
+          # 200+ lines of monkeypatches.
+          def load_missing_constant(from_mod, const_name)
+            CoreExt::ActiveSupport.with_bootsnap_fallback(NameError) { super }
+          end
+
+          def depend_on(file_name, message = "No such file to load -- %s.rb")
+            CoreExt::ActiveSupport.with_bootsnap_fallback(LoadError) { super }
+          end
+        end
+      end
+    end
+  end
+end
+
+module ActiveSupport
+  module Dependencies
+    class << self
+      prepend Bootsnap::LoadPathCache::CoreExt::ActiveSupport::ClassMethods
+    end
+  end
+end

data/lib/bootsnap/load_path_cache/core_ext/kernel_require.rb

@@ -0,0 +1,88 @@
+module Bootsnap
+  module LoadPathCache
+    module CoreExt
+      def self.make_load_error(path)
+        err = LoadError.new("cannot load such file -- #{path}")
+        err.define_singleton_method(:path) { path }
+        err
+      end
+    end
+  end
+end
+
+module Kernel
+  alias_method :require_without_cache, :require
+  def require(path)
+    if resolved = Bootsnap::LoadPathCache.load_path_cache.find(path)
+      require_without_cache(resolved)
+    else
+      raise Bootsnap::LoadPathCache::CoreExt.make_load_error(path)
+    end
+  rescue Bootsnap::LoadPathCache::ReturnFalse
+    return false
+  rescue Bootsnap::LoadPathCache::FallbackScan
+    require_without_cache(path)
+  end
+
+  alias_method :load_without_cache, :load
+  def load(path, wrap = false)
+    if resolved = Bootsnap::LoadPathCache.load_path_cache.find(path)
+      load_without_cache(resolved, wrap)
+    else
+      # load also allows relative paths from pwd even when not in $:
+      relative = File.expand_path(path)
+      if File.exist?(File.expand_path(path))
+        return load_without_cache(relative, wrap)
+      end
+      raise Bootsnap::LoadPathCache::CoreExt.make_load_error(path)
+    end
+  rescue Bootsnap::LoadPathCache::ReturnFalse
+    return false
+  rescue Bootsnap::LoadPathCache::FallbackScan
+    load_without_cache(path, wrap)
+  end
+end
+
+class << Kernel
+  alias_method :require_without_cache, :require
+  def require(path)
+    if resolved = Bootsnap::LoadPathCache.load_path_cache.find(path)
+      require_without_cache(resolved)
+    else
+      raise Bootsnap::LoadPathCache::CoreExt.make_load_error(path)
+    end
+  rescue Bootsnap::LoadPathCache::ReturnFalse
+    return false
+  rescue Bootsnap::LoadPathCache::FallbackScan
+    require_without_cache(path)
+  end
+
+  alias_method :load_without_cache, :load
+  def load(path, wrap = false)
+    if resolved = Bootsnap::LoadPathCache.load_path_cache.find(path)
+      load_without_cache(resolved, wrap)
+    else
+      # load also allows relative paths from pwd even when not in $:
+      relative = File.expand_path(path)
+      if File.exist?(relative)
+        return load_without_cache(relative, wrap)
+      end
+      raise Bootsnap::LoadPathCache::CoreExt.make_load_error(path)
+    end
+  rescue Bootsnap::LoadPathCache::ReturnFalse
+    return false
+  rescue Bootsnap::LoadPathCache::FallbackScan
+    load_without_cache(path, wrap)
+  end
+end
+
+class Module
+  alias_method :autoload_without_cache, :autoload
+  def autoload(const, path)
+    autoload_without_cache(const, Bootsnap::LoadPathCache.load_path_cache.find(path) || path)
+  rescue Bootsnap::LoadPathCache::ReturnFalse
+    return false
+  rescue Bootsnap::LoadPathCache::FallbackScan
+    autoload_without_cache(const, path)
+  end
+end

data/lib/bootsnap/load_path_cache/path.rb

@@ -0,0 +1,93 @@
+require_relative 'path_scanner'
+
+module Bootsnap
+  module LoadPathCache
+    class Path
+      # A path is considered 'stable' if it is part of a Gem.path or the ruby
+      # distribution. When adding or removing files in these paths, the cache
+      # must be cleared before the change will be noticed.
+      def stable?
+        stability == STABLE
+      end
+
+      # A path is considered volatile if it doesn't live under a Gem.path or
+      # the ruby distribution root. These paths are scanned for new additions
+      # more frequently.
+      def volatile?
+        stability == VOLATILE
+      end
+
+      attr_reader :path
+
+      def initialize(path)
+        @path = path
+      end
+
+      # Return a list of all the requirable files and all of the subdirectories
+      # of this +Path+.
+      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(path)
+          return [entries, dirs] if entries # cache hit
+          entries, dirs = scan!
+          store.set(path, [0, entries, dirs])
+          return [entries, dirs]
+        end
+
+        cached_mtime, entries, dirs = store.get(path)
+
+        current_mtime = latest_mtime(path, dirs || [])
+        return [[], []]        if current_mtime == -1 # path does not exist
+        return [entries, dirs] if cached_mtime == current_mtime
+
+        entries, dirs = scan!
+        store.set(path, [current_mtime, entries, dirs])
+        [entries, dirs]
+      end
+
+      private
+
+      def scan! # (expensive) returns [entries, dirs]
+        PathScanner.call(path)
+      end
+
+      # last time a directory was modified in this subtree. +dirs+ should be a
+      # list of relative paths to directories under +path+. e.g. for /a/b and
+      # /a/b/c, pass ('/a/b', ['c'])
+      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
+
+      # a Path can be either stable of volatile, depending on how frequently we
+      # expect its contents may change. Stable paths aren't rescanned nearly as
+      # often.
+      STABLE   = :stable
+      VOLATILE = :volatile
+
+      RUBY_PREFIX = RbConfig::CONFIG['prefix']
+
+      def stability
+        @stability ||= begin
+          if Gem.path.detect { |p| path.start_with?(p) }
+            STABLE
+          elsif path.start_with?(RUBY_PREFIX)
+            STABLE
+          else
+            VOLATILE
+          end
+        end
+      end
+    end
+  end
+end

data/lib/bootsnap/load_path_cache/path_scanner.rb

@@ -0,0 +1,44 @@
+require_relative '../load_path_cache'
+
+module Bootsnap
+  module LoadPathCache
+    module PathScanner
+      RelativePathNotSupported = Class.new(StandardError)
+
+      REQUIRABLES_AND_DIRS = "/**/*{#{DOT_RB},#{DL_EXTENSIONS.join(',')},/}"
+      IS_DIR = %r{(.*)/\z}
+      NORMALIZE_NATIVE_EXTENSIONS = !DL_EXTENSIONS.include?(LoadPathCache::DOT_SO)
+      ALTERNATIVE_NATIVE_EXTENSIONS_PATTERN = /\.(o|bundle|dylib)\z/
+      BUNDLE_PATH = (Bundler.bundle_path.cleanpath.to_s << LoadPathCache::SLASH).freeze
+
+      def self.call(path)
+        raise RelativePathNotSupported unless path.start_with?(SLASH)
+
+        relative_slice = (path.size + 1)..-1
+        # If the bundle path is a descendent of this path, we do additional
+        # checks to prevent recursing into the bundle path as we recurse
+        # through this path. We don't want to scan the bundle path because
+        # anything useful in it will be present on other load path items.
+        #
+        # This can happen if, for example, the user adds '.' to the load path,
+        # and the bundle path is '.bundle'.
+        contains_bundle_path = BUNDLE_PATH.start_with?(path)
+
+        dirs = []
+        requirables = []
+
+        Dir.glob(path + REQUIRABLES_AND_DIRS).each do |absolute_path|
+          next if contains_bundle_path && absolute_path.start_with?(BUNDLE_PATH)
+          relative_path = absolute_path.slice!(relative_slice)
+
+          if md = relative_path.match(IS_DIR)
+            dirs << md[1]
+          else
+            requirables << relative_path
+          end
+        end
+        [requirables, dirs]
+      end
+    end
+  end
+end

data/lib/bootsnap/load_path_cache/store.rb

@@ -0,0 +1,77 @@
+require_relative '../explicit_require'
+
+Bootsnap::ExplicitRequire.with_gems('snappy')  { require 'snappy' }
+Bootsnap::ExplicitRequire.with_gems('msgpack') { require 'msgpack' }
+Bootsnap::ExplicitRequire.from_rubylibdir('fileutils')
+
+module Bootsnap
+  module LoadPathCache
+    class Store
+      NestedTransactionError = Class.new(StandardError)
+      SetOutsideTransactionNotAllowed = Class.new(StandardError)
+
+      def initialize(store_path)
+        @store_path = store_path
+        load_data
+      end
+
+      def get(key)
+        @data[key]
+      end
+
+      def fetch(key)
+        raise SetOutsideTransactionNotAllowed unless @in_txn
+        v = get(key)
+        unless v
+          @dirty = true
+          v = yield
+          @data[key] = v
+        end
+        v
+      end
+
+      def set(key, value)
+        raise SetOutsideTransactionNotAllowed unless @in_txn
+        if value != @data[key]
+          @dirty = true
+          @data[key] = value
+        end
+      end
+
+      def transaction
+        raise NestedTransactionError if @in_txn
+        @in_txn = true
+        yield
+      ensure
+        commit_transaction
+        @in_txn = false
+      end
+
+      private
+
+      def commit_transaction
+        if @dirty
+          dump_data
+          @dirty = false
+        end
+      end
+
+      def load_data
+        @data = begin
+          MessagePack.load(Snappy.inflate(File.binread(@store_path)))
+        rescue Errno::ENOENT, Snappy::Error
+          {}
+        end
+      end
+
+      def dump_data
+        # Change contents atomically so other processes can't get invalid
+        # caches if they read at an inopportune time.
+        tmp = "#{@store_path}.#{(rand * 100000).to_i}.tmp"
+        FileUtils.mkpath(File.dirname(tmp))
+        File.binwrite(tmp, Snappy.deflate(MessagePack.dump(@data)))
+        FileUtils.mv(tmp, @store_path)
+      end
+    end
+  end
+end

data/lib/bootsnap/version.rb

@@ -0,0 +1,3 @@
+module Bootsnap
+  VERSION = "0.2.0"
+end

metadata

@@ -0,0 +1,172 @@
+--- !ruby/object:Gem::Specification
+name: bootsnap
+version: !ruby/object:Gem::Version
+  version: 0.2.0
+platform: ruby
+authors:
+- Burke Libbey
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2017-03-31 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rake-compiler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+- !ruby/object:Gem::Dependency
+  name: mocha
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.2'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.2'
+- !ruby/object:Gem::Dependency
+  name: msgpack
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: snappy
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.0.15
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.0.15
+description: wip.
+email:
+- burke.libbey@shopify.com
+executables: []
+extensions:
+- ext/bootsnap/extconf.rb
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rubocop.yml"
+- CONTRIBUTING.md
+- Gemfile
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- bin/testunit
+- bootsnap.gemspec
+- dev.yml
+- ext/bootsnap/bootsnap.c
+- ext/bootsnap/bootsnap.h
+- ext/bootsnap/crc32.c
+- ext/bootsnap/extconf.rb
+- lib/bootsnap.rb
+- lib/bootsnap/compile_cache.rb
+- lib/bootsnap/compile_cache/iseq.rb
+- lib/bootsnap/compile_cache/yaml.rb
+- lib/bootsnap/explicit_require.rb
+- lib/bootsnap/load_path_cache.rb
+- lib/bootsnap/load_path_cache/cache.rb
+- lib/bootsnap/load_path_cache/change_observer.rb
+- lib/bootsnap/load_path_cache/core_ext/active_support.rb
+- lib/bootsnap/load_path_cache/core_ext/kernel_require.rb
+- lib/bootsnap/load_path_cache/path.rb
+- lib/bootsnap/load_path_cache/path_scanner.rb
+- lib/bootsnap/load_path_cache/store.rb
+- lib/bootsnap/version.rb
+homepage: https://github.com/Shopify/bootsnap
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.6.10
+signing_key: 
+specification_version: 4
+summary: wip
+test_files: []