bootsnap 1.1.8 → 1.2.0.pre

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: a6f66d96dbadca08e5c50985c45319350f1e85ca
-  data.tar.gz: c1227f8f8c6ed542abe582c221ccf45318655e87
+SHA256:
+  metadata.gz: ae101ea55aec450002c9322cc752960c5b6367c3a4bbddd32241919291adc1dc
+  data.tar.gz: 617173fa3e608e774f3730e6a8c3ca2d10030e2ec419a96ff8e90b84979dc736
 SHA512:
-  metadata.gz: fa366476bf324d6eda9415e7170d67e31eb4a01d08758ff51d9e83c7661db8160cfa334ef9df67777ef059887de24a3f8a7da49b1675f3a1b0bf7704ecf42620
-  data.tar.gz: '06758fb4f8445d041816330983799684a3b79e6ec82ac1e21cf087544d377744b0bb8bc20012146d529876fac6398e1053821eea2468be60c8194c6c07855312'
+  metadata.gz: f7488865e503a7f1d7feadcd05b54e0718531c3ec36923db9c6dd7fc1dcea3bbdc112ed8cd0ce75688185554ae256ed8a304c14f83f87125c3bcb31ae57f6036
+  data.tar.gz: af929fd81f41657a17e0710c2fc3403d5e37a943f968f363a12b9c4c5326dc1405fed0f02caa0104619846688dd3d59b15cb171b8119cec39c3e49fc72517493

data/.travis.yml

@@ -1,4 +1,8 @@
 language: ruby
-rvm: ruby-2.4.1
+
+rvm:
+  - ruby-2.4
+  - ruby-2.5
+
 before_script: rake
-script: bin/testunit
+script: bundle exec bin/testunit

data/README.jp.md

@@ -0,0 +1,218 @@
+# Bootsnap [![Build Status](https://travis-ci.org/Shopify/bootsnap.svg?branch=master)](https://travis-ci.org/Shopify/bootsnap)
+
+Bootsnap は RubyVM におけるバイトコード生成やファイルルックアップ等の時間のかかる処理を最適化するためのライブラリです。ActiveSupport や YAML もサポートしています。
+
+注意書き: このライブラリは英語話者によって管理されています。この README は日本語ですが、日本語でのサポートはしておらず、リクエストにお答えすることもできません。バイリンガルの方がサポートをサポートしてくださる場合はお知らせください！:)
+
+## パフォーマンス
+
+Discourse では、約6秒から3秒まで、約50%の起動時間短縮が確認されています。小さなアプリケーションでも、50%の改善（3.6秒から1.8秒）が確認されています。非常に巨大でモノリシックなアプリである Shopify のプラットフォームでは、約25秒から6.5秒へと約75％短縮されました。
+
+## 使用方法
+
+この gem は MacOS と Linux で作動します。まずは、`bootsnap` を `Gemfile` に追加します:
+
+```ruby
+gem 'bootsnap', require: false
+```
+
+Rails を使用している場合は、以下のコードを、`config/boot.rb` 内にある `require 'bundler/setup'` の後に追加してください。
+
+```ruby
+require 'bootsnap/setup'
+```
+
+Rails を使用していない場合、または、より多くの設定を変更したい場合は、以下のコードを `require 'bundler/setup'` の直後に追加してください(早く読み込まれるほど、より多くのものを最適化することができます）。
+
+```ruby
+require 'bootsnap'
+env = ENV['RAILS_ENV'] || "development"
+Bootsnap.setup(
+  cache_dir:            'tmp/cache',          # キャッシュファイルを保存する path
+  development_mode:     env == 'development', # 現在の作業環境、例えば RACK_ENV, RAILS_ENV など。
+  load_path_cache:      true,                 # キャッシュで LOAD_PATH を最適化する。
+  autoload_paths_cache: true,                 # キャッシュで ActiveSupport による autoload を行う。
+  disable_trace:        true,                 # (アルファ) `RubyVM::InstructionSequence.compile_option = { trace_instruction: false }`をセットする。
+  compile_cache_iseq:   true,                 # ISeq キャッシュをコンパイルする
+  compile_cache_yaml:   true                  # YAML キャッシュをコンパイルする
+)
+```
+
+ヒント: `require 'bootsnap'` を `BootLib::Require.from_gem('bootsnap', 'bootsnap')` で、 [こちらのトリック](https://github.com/Shopify/bootsnap/wiki/Bootlib::Require)を使って置き換えることができます。こうすると、巨大な`$LOAD_PATH`がある場合でも、起動時間を最短化するのに役立ちます。
+
+## Bootsnap の内部動作
+
+Bootsnap は、処理に時間のかかるメソッドの結果をキャッシュすることで最適化しています。これには、大きく分けて2つのカテゴリに分けられます。
+
+* [Path Pre-Scanning](#path-pre-scanning)
+    *  `Kernel#require` と `Kernel#load` を `$LOAD_PATH` のフルスキャンを行わないようにオーバーライドします。
+    *  `ActiveSupport::Dependencies.{autoloadable_module?,load_missing_constant,depend_on}` を `ActiveSupport::Dependencies.autoload_paths` のフルスキャンを行わないようにオーバーライドします。
+* [Compilation caching](#compilation-caching)
+    *  Ruby バイトコードのコンパイル結果をキャッシュするためのメソッド `RubyVM::InstructionSequence.load_iseq` が実装されています。
+    *  `YAML.load_file` を YAML オブジェクトのロード結果を MessagePack でキャッシュするようにオーバーライドします。 MessagePack でサポートされていないタイプが使われている場合は Marshal が使われます。
+
+### Path Pre-Scanning
+
+_(このライブラリは [bootscale](https://github.com/byroot/bootscale) という別のライブラリを元に開発されました)_
+
+Bootsnap の始動時、あるいはパス(例えば、`$LOAD_PATH`)の変更時に、`Bootsnap::LoadPathCache` がキャッシュから必要なエントリーのリストを読み込みます。または、必要に応じてフルスキャンを実行し結果をキャッシュします。
+その後、たとえば `require 'foo'` を評価する場合, Ruby は `$LOAD_PATH` `['x', 'y', ...]` のすべてのエントリーを繰り返し評価することで `x/foo.rb`, `y/foo.rb` などを探索します。これに対して Bootsnap は、キャッシュされた reuiqre 可能なファイルと `$LOAD_PATH` を見ることで、Rubyが最終的に選択するであろうパスで置き換えます。
+
+この動作によって生成された syscall を見ると、最終的な結果は以前なら次のようになります。
+
+```
+open  x/foo.rb # (fail)
+# (imagine this with 500 $LOAD_PATH entries instead of two)
+open  y/foo.rb # (success)
+close y/foo.rb
+open  y/foo.rb
+...
+```
+
+これが、次のようになります:
+
+```
+open y/foo.rb
+...
+```
+
+`autoload_paths_cache` オプションが `Bootsnap.setup` に与えられている場合、`ActiveSupport::Dependencies.autoload_paths` をトラバースするメソッドにはまったく同じ最適化が使用されます。
+
+`*_path_cache` 機能を埋め込むオーバーライドを図にすると、次のようになります。
+
+![Bootsnapの説明図](https://cloud.githubusercontent.com/assets/3074765/24532120/eed94e64-158b-11e7-9137-438d759b2ac8.png)
+
+Bootsnap は、 `$LOAD_PATH` エントリを安定エントリと不安定エントリの2つのカテゴリに分類します。不安定エントリはアプリケーションが起動するたびにスキャンされ、そのキャッシュは30秒間だけ有効になります。安定エントリーに期限切れはありません。コンテンツがスキャンされると、決して変更されないものとみなされます。
+
+安定していると考えられる唯一のディレクトリは、Rubyのインストールプレフィックス (`RbConfig::CONFIG['prefix']`, または `/usr/local/ruby` や `~/.rubies/x.y.z`)下にあるものと、`Gem.path` (たとえば　`~/.gem/ruby/x.y.z`) や `Bundler.bundle_path` 下にあるものです。他のすべては不安定エントリと分類されます。
+
+[`Bootsnap::LoadPathCache::Cache`](https://github.com/Shopify/bootsnap/blob/master/lib/bootsnap/load_path_cache/cache.rb) に加えて次の図では、エントリの解決がどのように機能するかを理解するのに役立つかもしれません。経路探索は以下のようになります。
+
+![パス探索の仕組み](https://cloud.githubusercontent.com/assets/3074765/25388270/670b5652-299b-11e7-87fb-975647f68981.png)
+
+また、`LoadError` のスキャンがどれほど重いかに注意を払うことも大切です。もし Ruby が `require 'something'` を評価し、そのファイルが `$LOAD_PATH` にない場合は、それを知るために `2 * $LOAD_PATH.length` のファイルシステムアスセスが必要になります。Bootsnap は、ファイルシステムにまったく触れずに `LoadError` を投げ、この結果をキャッシュします。
+
+## Compilation Caching
+
+このコンセプトのより分かりやすい解説は [yomikomu](https://github.com/ko1/yomikomu) をお読み下さい。
+
+Ruby には複雑な文法が実装されており、構文解析は簡単なオペレーションではありません。1.9以降、Ruby は Ruby ソースを内部のバイトコードに変換した後、Ruby VM によって実行してきました。2.3.0 以降、[RubyはAPIを公開し](https://ruby-doc.org/core-2.3.0/RubyVM/InstructionSequence.html)、そのバイトコードをキャッシュすることができるようになりました。これにより、同じファイルが複数ロードされた時の、比較的時間のかかる部分をバイパスすることができます。
+
+また、Shopify のアプリケーションでは、アプリケーションの起動時に YAML ドキュメントの読み込みに多くの時間を費やしていることを発見しました。そして、 MessagePack と Marshal は deserialization にあたって YAML よりもはるかに高速であるということに気付きました。そこで、YAML ドキュメントを、Ruby バイトコードと同じコンパイルキャッシングの最適化を施すことで、高速化しています。Ruby の "バイトコード" フォーマットに相当するものは MessagePack ドキュメント (あるいは、MessagePack をサポートしていないタイプの YAML ドキュメントの場合は、Marshal stream)になります。
+
+これらのコンパイル結果は、入力ファイル（FNV1a-64）のフルパスのハッシュを取って生成されたファイル名で、キャッシュディレクトリに保存されます。
+
+Bootsnap 無しでは、ファイルを `require` するために生成された syscall の順序は次のようになっていました:
+
+```
+open    /c/foo.rb -> m
+fstat64 m
+close   m
+open    /c/foo.rb -> o
+fstat64 o
+fstat64 o
+read    o
+read    o
+...
+close   o
+```
+
+しかし Bootsnap では、次のようになります:
+
+```
+open      /c/foo.rb -> n
+fstat64   n
+close     n
+open      /c/foo.rb -> n
+fstat64   n
+open      (cache) -> m
+read      m
+read      m
+close     m
+close     n
+```
+
+これは一目見るだけでは劣化していると思われるかもしれませんが、性能に大きな違いがあります。
+
+（両方のリストの最初の3つの syscalls -- `open`, `fstat64`, `close` -- は本質的に有用ではありません。[このRubyパッチ](https://bugs.ruby-lang.org/issues/13378)は、Boosnap と組み合わせることによって、それらを最適化しています）
+
+Bootsnap は、64バイトのヘッダーとそれに続くキャッシュの内容を含んだキャッシュファイルを書き込みます。ヘッダーは、次のいくつかのフィールドで構成されるキャッシュキーです。
+
+- `version`、Bootsnapにハードコードされる基本的なスキーマのバージョン
+- `os_version`、(macOS, BSDの) 現在のカーネルバージョンか 、(Linuxの) glibc のバージョンのハッシュ
+- `compile_option`、`RubyVM::InstructionSequence.compile_option` の返り値
+- `ruby_revision`、コンパイルされたRubyのバージョン
+- `size`、ソースファイルのサイズ
+- `mtime`、コンパイル時のソースファイルの最終変更タイムスタンプ
+- `data_size`、バッファに読み込む必要のあるヘッダーに続くバイト数。
+
+キーが有効な場合、キャッシュがファイルからロードされます。そうでない場合、キャッシュは再生成され、現在のキャッシュを破棄します。
+
+# 最終的なキャッシュ結果
+
+次のファイル構造があるとします。
+
+```
+/
+├── a
+├── b
+└── c
+    └── foo.rb
+```
+
+そして、このような `$LOAD_PATH` があるとします。
+
+```
+["/a", "/b", "/c"]
+```
+
+Bootsnap なしで `require 'foo'` を呼び出すと、Ruby は次の順序で syscalls を生成します:
+
+```
+open    /a/foo.rb -> -1
+open    /b/foo.rb -> -1
+open    /c/foo.rb -> n
+close   n
+open    /c/foo.rb -> m
+fstat64 m
+close   m
+open    /c/foo.rb -> o
+fstat64 o
+fstat64 o
+read    o
+read    o
+...
+close   o
+```
+
+しかし Bootsnap では、次のようになります:
+
+```
+open      /c/foo.rb -> n
+fstat64   n
+close     n
+open      /c/foo.rb -> n
+fstat64   n
+open      (cache) -> m
+read      m
+read      m
+close     m
+close     n
+```
+
+Bootsnap なしで `require 'nope'` を呼び出すと、次のようになります:
+
+```
+open    /a/nope.rb -> -1
+open    /b/nope.rb -> -1
+open    /c/nope.rb -> -1
+open    /a/nope.bundle -> -1
+open    /b/nope.bundle -> -1
+open    /c/nope.bundle -> -1
+```
+
+...そして、Bootsnap で `require 'nope'` を呼び出すと、次のようになります...
+
+```
+# (nothing!)
+```

data/ext/bootsnap/bootsnap.c

@@ -94,7 +94,6 @@ static int cache_key_equal(struct bs_cache_key * k1, struct bs_cache_key * k2);
 static VALUE bs_fetch(char * path, VALUE path_v, char * cache_path, VALUE handler);
 static int open_current_file(char * path, struct bs_cache_key * key, char ** errno_provenance);
 static int fetch_cached_data(int fd, ssize_t data_size, VALUE handler, VALUE * output_data, int * exception_tag, char ** errno_provenance);
-static VALUE prot_exception_for_errno(VALUE err);
 static uint32_t get_ruby_platform(void);
 
 /*
@@ -520,22 +519,6 @@ atomic_write_cache_file(char * path, struct bs_cache_key * key, VALUE data, char
   return ret;
 }
 
-/*
- * Given an errno value (converted to a ruby Fixnum), return the corresponding
- * Errno::* constant. If none is found, return StandardError instead.
- */
-static VALUE
-prot_exception_for_errno(VALUE err)
-{
-  if (err != INT2FIX(0)) {
-    VALUE mErrno = rb_const_get(rb_cObject, rb_intern("Errno"));
-    VALUE constants = rb_funcall(mErrno, rb_intern("constants"), 0);
-    VALUE which = rb_funcall(constants, rb_intern("[]"), 1, err);
-    return rb_funcall(mErrno, rb_intern("const_get"), 1, which);
-  }
-  return rb_eStandardError;
-}
-
 
 /* Read contents from an fd, whose contents are asserted to be +size+ bytes
  * long, into a buffer */
@@ -689,11 +672,7 @@ succeed:
   return output_data;
 fail_errno:
   CLEANUP;
-  exception = rb_protect(prot_exception_for_errno, INT2FIX(errno), &res);
-  if (res) exception = rb_eStandardError;
-  if (errno_provenance != NULL) {
-    exception = rb_exc_new_str(exception, rb_str_new2(errno_provenance));
-  }
+  exception = rb_syserr_new(errno, errno_provenance);
   rb_exc_raise(exception);
   __builtin_unreachable();
 raise:

data/lib/bootsnap/load_path_cache.rb

@@ -21,11 +21,13 @@ module Bootsnap
     CACHED_EXTENSIONS = DLEXT2 ? [DOT_RB, DLEXT, DLEXT2] : [DOT_RB, DLEXT]
 
     class << self
-      attr_reader :load_path_cache, :autoload_paths_cache
+      attr_reader :load_path_cache, :autoload_paths_cache, :loaded_features_index
 
       def setup(cache_path:, development_mode:, active_support: true)
         store = Store.new(cache_path)
 
+        @loaded_features_index = LoadedFeaturesIndex.new
+
         @load_path_cache = Cache.new(store, $LOAD_PATH, development_mode: development_mode)
         require_relative 'load_path_cache/core_ext/kernel_require'
 
@@ -50,3 +52,4 @@ require_relative 'load_path_cache/path'
 require_relative 'load_path_cache/cache'
 require_relative 'load_path_cache/store'
 require_relative 'load_path_cache/change_observer'
+require_relative 'load_path_cache/loaded_features_index'

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

@@ -11,78 +11,104 @@ module Bootsnap
 end
 
 module Kernel
-  alias_method :require_without_cache, :require
+  alias_method :require_without_bootsnap, :require
+
+  # Note that require registers to $LOADED_FEATURES while load does not.
+  def require_with_bootsnap_lfi(path, resolved = nil)
+    Bootsnap::LoadPathCache.loaded_features_index.register(path, resolved) do
+      require_without_bootsnap(resolved || path)
+    end
+  end
+
   def require(path)
+    return false if Bootsnap::LoadPathCache.loaded_features_index.key?(path)
+
     if resolved = Bootsnap::LoadPathCache.load_path_cache.find(path)
-      require_without_cache(resolved)
-    else
-      raise Bootsnap::LoadPathCache::CoreExt.make_load_error(path)
+      return require_with_bootsnap_lfi(path, resolved)
     end
+
+    raise Bootsnap::LoadPathCache::CoreExt.make_load_error(path)
   rescue Bootsnap::LoadPathCache::ReturnFalse
     return false
   rescue Bootsnap::LoadPathCache::FallbackScan
-    require_without_cache(path)
+    require_with_bootsnap_lfi(path)
   end
 
-  alias_method :load_without_cache, :load
+  alias_method :load_without_bootsnap, :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)
+      return load_without_bootsnap(resolved, wrap)
     end
+
+    # load also allows relative paths from pwd even when not in $:
+    if File.exist?(relative = File.expand_path(path))
+      return load_without_bootsnap(relative, wrap)
+    end
+
+    raise Bootsnap::LoadPathCache::CoreExt.make_load_error(path)
   rescue Bootsnap::LoadPathCache::ReturnFalse
     return false
   rescue Bootsnap::LoadPathCache::FallbackScan
-    load_without_cache(path, wrap)
+    load_without_bootsnap(path, wrap)
   end
 end
 
 class << Kernel
-  alias_method :require_without_cache, :require
+  alias_method :require_without_bootsnap, :require
+
+  def require_with_bootsnap_lfi(path, resolved = nil)
+    Bootsnap::LoadPathCache.loaded_features_index.register(path, resolved) do
+      require_without_bootsnap(resolved || path)
+    end
+  end
+
   def require(path)
+    return false if Bootsnap::LoadPathCache.loaded_features_index.key?(path)
+
     if resolved = Bootsnap::LoadPathCache.load_path_cache.find(path)
-      require_without_cache(resolved)
-    else
-      raise Bootsnap::LoadPathCache::CoreExt.make_load_error(path)
+      return require_with_bootsnap_lfi(path, resolved)
     end
+
+    raise Bootsnap::LoadPathCache::CoreExt.make_load_error(path)
   rescue Bootsnap::LoadPathCache::ReturnFalse
     return false
   rescue Bootsnap::LoadPathCache::FallbackScan
-    require_without_cache(path)
+    require_with_bootsnap_lfi(path)
   end
 
-  alias_method :load_without_cache, :load
+  alias_method :load_without_bootsnap, :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)
+      return load_without_bootsnap(resolved, wrap)
     end
+
+    # load also allows relative paths from pwd even when not in $:
+    if File.exist?(relative = File.expand_path(path))
+      return load_without_bootsnap(relative, wrap)
+    end
+
+    raise Bootsnap::LoadPathCache::CoreExt.make_load_error(path)
   rescue Bootsnap::LoadPathCache::ReturnFalse
     return false
   rescue Bootsnap::LoadPathCache::FallbackScan
-    load_without_cache(path, wrap)
+    load_without_bootsnap(path, wrap)
   end
 end
 
 class Module
-  alias_method :autoload_without_cache, :autoload
+  alias_method :autoload_without_bootsnap, :autoload
   def autoload(const, path)
-    autoload_without_cache(const, Bootsnap::LoadPathCache.load_path_cache.find(path) || path)
+    # NOTE: This may defeat LoadedFeaturesIndex, but it's not immediately
+    # obvious how to make it work. This feels like a pretty niche case, unclear
+    # if it will ever burn anyone.
+    #
+    # The challenge is that we don't control the point at which the entry gets
+    # added to $LOADED_FEATURES and won't be able to hook that modification
+    # since it's done in C-land.
+    autoload_without_bootsnap(const, Bootsnap::LoadPathCache.load_path_cache.find(path) || path)
   rescue Bootsnap::LoadPathCache::ReturnFalse
     return false
   rescue Bootsnap::LoadPathCache::FallbackScan
-    autoload_without_cache(const, path)
+    autoload_without_bootsnap(const, path)
   end
 end

data/lib/bootsnap/load_path_cache/loaded_features_index.rb

@@ -0,0 +1,95 @@
+module Bootsnap
+  module LoadPathCache
+    # LoadedFeaturesIndex partially mirrors an internal structure in ruby that
+    # we can't easily obtain an interface to.
+    #
+    # This works around an issue where, without bootsnap, *ruby* knows that it
+    # has already required a file by its short name (e.g. require 'bundler') if
+    # a new instance of bundler is added to the $LOAD_PATH which resolves to a
+    # different absolute path. This class makes bootsnap smart enough to
+    # realize that it has already loaded 'bundler', and not just
+    # '/path/to/bundler'.
+    #
+    # If you disable LoadedFeaturesIndex, you can see the problem this solves by:
+    #
+    # 1. `require 'a'`
+    # 2. Prepend a new $LOAD_PATH element containing an `a.rb`
+    # 3. `require 'a'`
+    #
+    # Ruby returns false from step 3.
+    # With bootsnap but with no LoadedFeaturesIndex, this loads two different
+    #   `a.rb`s.
+    # With bootsnap and with LoadedFeaturesIndex, this skips the second load,
+    #   returning false like ruby.
+    class LoadedFeaturesIndex
+      def initialize
+        @lfi = {}
+        @mutex = defined?(::Mutex) ? ::Mutex.new : ::Thread::Mutex.new # TODO: Remove once Ruby 2.2 support is dropped.
+
+        # In theory the user could mutate $LOADED_FEATURES and invalidate our
+        # cache. If this ever comes up in practice — or if you, the
+        # enterprising reader, feels inclined to solve this problem — we could
+        # parallel the work done with ChangeObserver on $LOAD_PATH to mirror
+        # updates to our @lfi.
+        $LOADED_FEATURES.each do |feat|
+          $LOAD_PATH.each do |lpe|
+            next unless feat.start_with?(lpe)
+            # /a/b/lib/my/foo.rb
+            #          ^^^^^^^^^
+            short = feat[(lpe.length + 1)..-1]
+            @lfi[short] = true
+            @lfi[strip_extension(short)] = true
+          end
+        end
+      end
+
+      def key?(feature)
+        @mutex.synchronize { @lfi.key?(feature) }
+      end
+
+      # There is a relatively uncommon case where we could miss adding an
+      # entry:
+      #
+      # If the user asked for e.g. `require 'bundler'`, and we went through the
+      # `FallbackScan` pathway in `kernel_require.rb` and therefore did not
+      # pass `long` (the full expanded absolute path), then we did are not able
+      # to confidently add the `bundler.rb` form to @lfi.
+      #
+      # We could either:
+      #
+      # 1. Just add `bundler.rb`, `bundler.so`, and so on, which is close but
+      #    not quite right; or
+      # 2. Inspect $LOADED_FEATURES upon return from yield to find the matching
+      #    entry.
+      def register(short, long = nil)
+        ret = yield
+
+        # do we have 'bundler' or 'bundler.rb'?
+        altname = if File.extname(short) != ''
+          # strip the path from 'bundler.rb' -> 'bundler'
+          strip_extension(short)
+        elsif long && ext = File.extname(long)
+          # get the extension from the expanded path if given
+          # 'bundler' + '.rb'
+          short + ext
+        end
+
+        @mutex.synchronize do
+          @lfi[short] = true
+          (@lfi[altname] = true) if altname
+        end
+
+        ret
+      end
+
+      private
+
+      STRIP_EXTENSION = /\..*?$/
+      private_constant :STRIP_EXTENSION
+
+      def strip_extension(f)
+        f.sub(STRIP_EXTENSION, '')
+      end
+    end
+  end
+end

data/lib/bootsnap/version.rb

@@ -1,3 +1,3 @@
 module Bootsnap
-  VERSION = "1.1.8"
+  VERSION = "1.2.0.pre"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: bootsnap
 version: !ruby/object:Gem::Version
-  version: 1.1.8
+  version: 1.2.0.pre
 platform: ruby
 authors:
 - Burke Libbey
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-01-05 00:00:00.000000000 Z
+date: 2018-03-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -110,6 +110,7 @@ files:
 - CONTRIBUTING.md
 - Gemfile
 - LICENSE.txt
+- README.jp.md
 - README.md
 - Rakefile
 - bin/console
@@ -131,6 +132,7 @@ files:
 - 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/loaded_features_index.rb
 - lib/bootsnap/load_path_cache/path.rb
 - lib/bootsnap/load_path_cache/path_scanner.rb
 - lib/bootsnap/load_path_cache/store.rb
@@ -151,12 +153,12 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: 2.0.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - ">"
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.3.1
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.6.14
+rubygems_version: 2.7.6
 signing_key: 
 specification_version: 4
 summary: Boot large ruby/rails apps faster