bootsnap 1.4.0 → 1.4.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 40694ca2512ff7861584a4f9cee05e424c3d9319f3b36c7f4f45f9196d2d9f19
-  data.tar.gz: '087c4f2dafdd51a6a3d0a69d31aadabfe6ef90bf2ab12b861f2a288d7b16c04a'
+  metadata.gz: be54a60d54f32f824d5c2fdccf189cdcb5409d1848c55f6e654fe44ace1d3f21
+  data.tar.gz: c6239c30984a936b76e218c2b1292a7e72d817d3e4847a6c58f0121c1e3068dc
 SHA512:
-  metadata.gz: ecbabde06c5f871702a000128e4dbc15d60fe0e16ab7adb4a8bb40b1c3b5b5f54b39c6927dc5aea9e49242d7e7f5deb596c42c44f8c2b8f998f835ec5b058b47
-  data.tar.gz: d566ffe7c3048f57c3c4fcd925d5e8ff5a722fc2622628e26571361e7a0fbdb5cbe8c724d45f2fc8ba09d0de614c5fad87f1875ecc99a08a34aab3afa7665fe1
+  metadata.gz: c251990457406cd51726eec8d62e0e1028bbeade6e24f266cb743d6f00f53650841beed9ee8e1795c78febd18ea234691125920c16aa5a95031718a28619bb31
+  data.tar.gz: 554a885bf2264f088618c41864fb84069d0664b35af0ae4b619c8fbb1cf285c80fad564d36845161f8044c35c6b53a33e66f27eb75c6715f25869af2795c97f6

data/.github/CODEOWNERS

@@ -0,0 +1,2 @@
+# mvm:maintainer
+* @burke

data/.github/probots.yml

@@ -0,0 +1,2 @@
+enabled:
+  - cla

data/.travis.yml

@@ -17,8 +17,5 @@ matrix:
     - rvm: jruby
       os: linux
       env: MINIMAL_SUPPORT=1
-    - rvm: truffleruby
-      os: linux
-      env: MINIMAL_SUPPORT=1
 
 script: bin/ci

data/CHANGELOG.md

@@ -1,3 +1,25 @@
+# 1.4.5
+
+* MRI 2.7 support
+* Fixed concurrency bugs
+
+# 1.4.4
+
+* Disable ISeq cache in `bootsnap/setup` by default in Ruby 2.5
+
+# 1.4.3
+
+* Fix some cache permissions and umask issues after switch to mkstemp
+
+# 1.4.2
+
+* Fix bug when removing features loaded by relative path from `$LOADED_FEATURES`
+* Fix bug with propagation of `NameError` up from nested calls to `require`
+
+# 1.4.1
+
+* Don't register change observers to frozen objects.
+
 # 1.4.0
 
 * When running in development mode, always fall back to a full path scan on LoadError, making

data/README.md

@@ -4,9 +4,14 @@ Bootsnap is a library that plugs into Ruby, with optional support for `ActiveSup
 to optimize and cache expensive computations. See [How Does This Work](#how-does-this-work).
 
 #### Performance
-- [Discourse](https://github.com/discourse/discourse) reports a boot time reduction of approximately 50%, from roughly 6 to 3 seconds on one machine;
+
+- [Discourse](https://github.com/discourse/discourse) reports a boot time reduction of approximately
+  50%, from roughly 6 to 3 seconds on one machine;
 - One of our smaller internal apps also sees a reduction of 50%, from 3.6 to 1.8 seconds;
-- The core Shopify platform -- a rather large monolithic application -- boots about 75% faster, dropping from around 25s to 6.5s.
+- The core Shopify platform -- a rather large monolithic application -- boots about 75% faster,
+  dropping from around 25s to 6.5s.
+* In Shopify core (a large app), about 25% of this gain can be attributed to `compile_cache_*`
+  features; 75% to path caching, and ~1% to `disable_trace`. This is fairly representative.
 
 ## Usage
 
@@ -24,6 +29,14 @@ If you are using Rails, add this to `config/boot.rb` immediately after `require
 require 'bootsnap/setup'
 ```
 
+Note that bootsnap writes to `tmp/cache`, and that directory *must* be writable. Rails will fail to
+boot if it is not. If this is unacceptable (e.g. you are running in a read-only container and
+unwilling to mount in a writable tmpdir), you should remove this line or wrap it in a conditional.
+
+**Note also that bootsnap will never clean up its own cache: this is left up to you. Depending on your
+deployment strategy, you may need to periodically purge `tmp/cache/bootsnap*`. If you notice deploys
+getting progressively slower, this is almost certainly the cause.**
+
 It's technically possible to simply specify `gem 'bootsnap', require: 'bootsnap/setup'`, but it's
 important to load Bootsnap as early as possible to get maximum performance improvement.
 
@@ -41,12 +54,14 @@ Bootsnap.setup(
   development_mode:     env == 'development', # Current working environment, e.g. RACK_ENV, RAILS_ENV, etc
   load_path_cache:      true,                 # Optimize the LOAD_PATH with a cache
   autoload_paths_cache: true,                 # Optimize ActiveSupport autoloads with cache
-  disable_trace:        true,                 # (Alpha) Set `RubyVM::InstructionSequence.compile_option = { trace_instruction: false }`
+  disable_trace:        true,                 # Set `RubyVM::InstructionSequence.compile_option = { trace_instruction: false }`
   compile_cache_iseq:   true,                 # Compile Ruby code into ISeq cache, breaks coverage reporting.
   compile_cache_yaml:   true                  # Compile YAML into a cache
 )
 ```
 
+**Note that `disable_trace` will break debuggers and tracing.**
+
 **Protip:** You can replace `require 'bootsnap'` with `BootLib::Require.from_gem('bootsnap',
 'bootsnap')` using [this trick](https://github.com/Shopify/bootsnap/wiki/Bootlib::Require). This
 will help optimize boot time further if you have an extremely large `$LOAD_PATH`.
@@ -278,3 +293,12 @@ open    /c/nope.bundle -> -1
 ```
 # (nothing!)
 ```
+
+## When not to use Bootsnap
+
+*Alternative engines*: Bootsnap is pretty reliant on MRI features, and parts are disabled entirely on alternative ruby
+engines.
+
+*Non-local filesystems*: Bootsnap depends on `tmp/cache` (or whatever you set its cache directory
+to) being on a relatively fast filesystem. If you put it on a network mount, bootsnap is very likely
+to slow your application down quite a lot.

data/ext/bootsnap/bootsnap.c

@@ -74,6 +74,8 @@ static uint32_t current_ruby_platform;
 static uint32_t current_ruby_revision;
 /* Invalidates cache when RubyVM::InstructionSequence.compile_option changes */
 static uint32_t current_compile_option_crc32 = 0;
+/* Current umask */
+static mode_t current_umask;
 
 /* Bootsnap::CompileCache::{Native, Uncompilable} */
 static VALUE rb_mBootsnap;
@@ -94,6 +96,7 @@ 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 uint32_t get_ruby_revision(void);
 static uint32_t get_ruby_platform(void);
 
 /*
@@ -134,7 +137,7 @@ Init_bootsnap(void)
   rb_mBootsnap_CompileCache_Native = rb_define_module_under(rb_mBootsnap_CompileCache, "Native");
   rb_eBootsnap_CompileCache_Uncompilable = rb_define_class_under(rb_mBootsnap_CompileCache, "Uncompilable", rb_eStandardError);
 
-  current_ruby_revision = FIX2INT(rb_const_get(rb_cObject, rb_intern("RUBY_REVISION")));
+  current_ruby_revision = get_ruby_revision();
   current_ruby_platform = get_ruby_platform();
 
   uncompilable = rb_intern("__bootsnap_uncompilable__");
@@ -142,6 +145,9 @@ Init_bootsnap(void)
   rb_define_module_function(rb_mBootsnap_CompileCache_Native, "coverage_running?", bs_rb_coverage_running, 0);
   rb_define_module_function(rb_mBootsnap_CompileCache_Native, "fetch", bs_rb_fetch, 3);
   rb_define_module_function(rb_mBootsnap_CompileCache_Native, "compile_option_crc32=", bs_compile_option_crc32_set, 1);
+
+  current_umask = umask(0777);
+  umask(current_umask);
 }
 
 /*
@@ -191,6 +197,26 @@ fnv1a_64(const char *str)
   return fnv1a_64_iter(h, str);
 }
 
+/*
+ * Ruby's revision may be Integer or String. CRuby 2.7 or later uses
+ * Git commit ID as revision. It's String.
+ */
+static uint32_t
+get_ruby_revision(void)
+{
+  VALUE ruby_revision;
+
+  ruby_revision = rb_const_get(rb_cObject, rb_intern("RUBY_REVISION"));
+  if (RB_TYPE_P(ruby_revision, RUBY_T_FIXNUM)) {
+    return FIX2INT(ruby_revision);
+  } else {
+    uint64_t hash;
+
+    hash = fnv1a_64(StringValueCStr(ruby_revision));
+    return (uint32_t)(hash >> 32);
+  }
+}
+
 /*
  * When ruby's version doesn't change, but it's recompiled on a different OS
  * (or OS version), we need to invalidate the cache.
@@ -468,18 +494,17 @@ static int
 atomic_write_cache_file(char * path, struct bs_cache_key * key, VALUE data, char ** errno_provenance)
 {
   char template[MAX_CACHEPATH_SIZE + 20];
-  char * dest;
   char * tmp_path;
   int fd, ret;
   ssize_t nwrite;
 
-  dest = strncpy(template, path, MAX_CACHEPATH_SIZE);
-  strcat(dest, ".tmp.XXXXXX");
+  tmp_path = strncpy(template, path, MAX_CACHEPATH_SIZE);
+  strcat(tmp_path, ".tmp.XXXXXX");
 
-  tmp_path = mktemp(template);
-  fd = open(tmp_path, O_WRONLY | O_CREAT, 0664);
+  // mkstemp modifies the template to be the actual created path
+  fd = mkstemp(tmp_path);
   if (fd < 0) {
-    if (mkpath(path, 0775) < 0) {
+    if (mkpath(tmp_path, 0775) < 0) {
       *errno_provenance = (char *)"bs_fetch:atomic_write_cache_file:mkpath";
       return -1;
     }
@@ -517,6 +542,11 @@ atomic_write_cache_file(char * path, struct bs_cache_key * key, VALUE data, char
   ret = rename(tmp_path, path);
   if (ret < 0) {
     *errno_provenance = (char *)"bs_fetch:atomic_write_cache_file:rename";
+    return -1;
+  }
+  ret = chmod(path, 0664 & ~current_umask);
+  if (ret < 0) {
+    *errno_provenance = (char *)"bs_fetch:atomic_write_cache_file:chmod";
   }
   return ret;
 }

data/lib/bootsnap/compile_cache/iseq.rb

@@ -39,6 +39,8 @@ module Bootsnap
             path.to_s,
             Bootsnap::CompileCache::ISeq
           )
+        rescue Errno::EACCES
+          Bootsnap::CompileCache.permission_error(path)
         rescue RuntimeError => e
           if e.message =~ /unmatched platform/
             puts("unmatched platform for file #{path}")

data/lib/bootsnap/compile_cache/yaml.rb

@@ -46,11 +46,15 @@ module Bootsnap
 
         klass = class << ::YAML; self; end
         klass.send(:define_method, :load_file) do |path|
-          Bootsnap::CompileCache::Native.fetch(
-            cache_dir,
-            path,
-            Bootsnap::CompileCache::YAML
-          )
+          begin
+            Bootsnap::CompileCache::Native.fetch(
+              cache_dir,
+              path,
+              Bootsnap::CompileCache::YAML
+            )
+          rescue Errno::EACCES
+            Bootsnap::CompileCache.permission_error(path)
+          end
         end
       end
     end

data/lib/bootsnap/compile_cache.rb

@@ -1,5 +1,8 @@
 module Bootsnap
   module CompileCache
+    Error           = Class.new(StandardError)
+    PermissionError = Class.new(Error)
+
     def self.setup(cache_dir:, iseq:, yaml:)
       if iseq
         if supported?
@@ -20,6 +23,15 @@ module Bootsnap
       end
     end
 
+    def self.permission_error(path)
+      cpath = Bootsnap::CompileCache::ISeq.cache_dir
+      raise(
+        PermissionError,
+        "bootsnap doesn't have permission to write cache entries in '#{cpath}' " \
+        "(or, less likely, doesn't have permission to read '#{path}')",
+      )
+    end
+
     def self.supported?
       # only enable on 'ruby' (MRI), POSIX (darwin, linux, *bsd), and >= 2.3.0
       RUBY_ENGINE == 'ruby' &&

data/lib/bootsnap/load_path_cache/cache.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require_relative('../explicit_require')
 
 module Bootsnap
@@ -46,7 +48,7 @@ module Bootsnap
         reinitialize if (@has_relative_paths && dir_changed?) || stale?
         feature = feature.to_s
         return feature if absolute_path?(feature)
-        return File.expand_path(feature) if feature.start_with?('./')
+        return expand_path(feature) if feature.start_with?('./')
         @mutex.synchronize do
           x = search_index(feature)
           return x if x
@@ -162,6 +164,10 @@ module Bootsnap
         end
       end
 
+      def expand_path(feature)
+        maybe_append_extension(File.expand_path(feature))
+      end
+
       def stale?
         @development_mode && @generated_at + AGE_THRESHOLD < now
       end
@@ -174,10 +180,18 @@ module Bootsnap
         def search_index(f)
           try_index(f + DOT_RB) || try_index(f + DLEXT) || try_index(f + DLEXT2) || try_index(f)
         end
+
+        def maybe_append_extension(f)
+          try_ext(f + DOT_RB) || try_ext(f + DLEXT) || try_ext(f + DLEXT2) || f
+        end
       else
         def search_index(f)
           try_index(f + DOT_RB) || try_index(f + DLEXT) || try_index(f)
         end
+
+        def maybe_append_extension(f)
+          try_ext(f + DOT_RB) || try_ext(f + DLEXT) || f
+        end
       end
 
       def try_index(f)
@@ -185,6 +199,10 @@ module Bootsnap
           p + '/' + f
         end
       end
+
+      def try_ext(f)
+        f if File.exist?(f)
+      end
     end
   end
 end

data/lib/bootsnap/load_path_cache/change_observer.rb

@@ -53,6 +53,7 @@ module Bootsnap
       end
 
       def self.register(observer, arr)
+        return if arr.frozen? # can't register observer, but no need to.
         arr.instance_variable_set(:@lpc_observer, observer)
         arr.extend(ArrayMixin)
       end

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

@@ -60,19 +60,22 @@ module Bootsnap
               super
             end
           rescue NameError => e
+            raise(e) if e.instance_variable_defined?(Bootsnap::LoadPathCache::ERROR_TAG_IVAR)
+            e.instance_variable_set(Bootsnap::LoadPathCache::ERROR_TAG_IVAR, true)
+
             # This function can end up called recursively, we only want to
             # retry at the top-level.
-            raise if Thread.current[:without_bootsnap_retry]
+            raise(e) if Thread.current[:without_bootsnap_retry]
             # If we already had cache disabled, there's no use retrying
-            raise if Thread.current[:without_bootsnap_cache]
+            raise(e) if Thread.current[:without_bootsnap_cache]
             # NoMethodError is a NameError, but we only want to handle actual
             # NameError instances.
-            raise unless e.class == NameError
+            raise(e) unless e.class == NameError
             # We can only confidently handle cases when *this* constant fails
             # to load, not other constants referred to by it.
-            raise unless e.name == const_name
+            raise(e) unless e.name == const_name
             # If the constant was actually loaded, something else went wrong?
-            raise if from_mod.const_defined?(const_name)
+            raise(e) if from_mod.const_defined?(const_name)
             CoreExt::ActiveSupport.without_bootsnap_cache { super }
           end
 
@@ -80,9 +83,12 @@ module Bootsnap
           # reiterate it with version polymorphism here...
           def depend_on(*)
             super
-          rescue LoadError
+          rescue LoadError => e
+            raise(e) if e.instance_variable_defined?(Bootsnap::LoadPathCache::ERROR_TAG_IVAR)
+            e.instance_variable_set(Bootsnap::LoadPathCache::ERROR_TAG_IVAR, true)
+
             # If we already had cache disabled, there's no use retrying
-            raise if Thread.current[:without_bootsnap_cache]
+            raise(e) if Thread.current[:without_bootsnap_cache]
             CoreExt::ActiveSupport.without_bootsnap_cache { super }
           end
         end

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

@@ -3,6 +3,7 @@ module Bootsnap
     module CoreExt
       def self.make_load_error(path)
         err = LoadError.new("cannot load such file -- #{path}")
+        err.instance_variable_set(Bootsnap::LoadPathCache::ERROR_TAG_IVAR, true)
         err.define_singleton_method(:path) { path }
         err
       end
@@ -30,6 +31,9 @@ module Kernel
     end
 
     raise(Bootsnap::LoadPathCache::CoreExt.make_load_error(path))
+  rescue LoadError => e
+    e.instance_variable_set(Bootsnap::LoadPathCache::ERROR_TAG_IVAR, true)
+    raise(e)
   rescue Bootsnap::LoadPathCache::ReturnFalse
     false
   rescue Bootsnap::LoadPathCache::FallbackScan
@@ -56,6 +60,9 @@ module Kernel
     end
 
     raise(Bootsnap::LoadPathCache::CoreExt.make_load_error(path))
+  rescue LoadError => e
+    e.instance_variable_set(Bootsnap::LoadPathCache::ERROR_TAG_IVAR, true)
+    raise(e)
   rescue Bootsnap::LoadPathCache::ReturnFalse
     false
   rescue Bootsnap::LoadPathCache::FallbackScan
@@ -74,6 +81,9 @@ class Module
     # 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 LoadError => e
+    e.instance_variable_set(Bootsnap::LoadPathCache::ERROR_TAG_IVAR, true)
+    raise(e)
   rescue Bootsnap::LoadPathCache::ReturnFalse
     false
   rescue Bootsnap::LoadPathCache::FallbackScan

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

@@ -4,4 +4,14 @@ class << $LOADED_FEATURES
     Bootsnap::LoadPathCache.loaded_features_index.purge(key)
     delete_without_bootsnap(key)
   end
+
+  alias_method(:reject_without_bootsnap!, :reject!)
+  def reject!(&block)
+    backup = dup
+
+    # FIXME: if no block is passed we'd need to return a decorated iterator
+    reject_without_bootsnap!(&block)
+
+    Bootsnap::LoadPathCache.loaded_features_index.purge_multi(backup - self)
+  end
 end

data/lib/bootsnap/load_path_cache/loaded_features_index.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Bootsnap
   module LoadPathCache
     # LoadedFeaturesIndex partially mirrors an internal structure in ruby that
@@ -55,6 +57,13 @@ module Bootsnap
         end
       end
 
+      def purge_multi(features)
+        rejected_hashes = features.map(&:hash).to_set
+        @mutex.synchronize do
+          @lfi.reject! { |_, hash| rejected_hashes.include?(hash) }
+        end
+      end
+
       def key?(feature)
         @mutex.synchronize { @lfi.key?(feature) }
       end

data/lib/bootsnap/load_path_cache/path_scanner.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require_relative('../explicit_require')
 
 module Bootsnap
@@ -11,7 +13,7 @@ module Bootsnap
       BUNDLE_PATH = if Bootsnap.bundler?
         (Bundler.bundle_path.cleanpath.to_s << LoadPathCache::SLASH).freeze
       else
-        ''.freeze
+        ''
       end
 
       def self.call(path)

data/lib/bootsnap/load_path_cache/store.rb

@@ -11,7 +11,8 @@ module Bootsnap
 
       def initialize(store_path)
         @store_path = store_path
-        @in_txn = false
+        # TODO: Remove conditional once Ruby 2.2 support is dropped.
+        @txn_mutex =  defined?(::Mutex) ? ::Mutex.new : ::Thread::Mutex.new
         @dirty = false
         load_data
       end
@@ -21,7 +22,7 @@ module Bootsnap
       end
 
       def fetch(key)
-        raise(SetOutsideTransactionNotAllowed) unless @in_txn
+        raise(SetOutsideTransactionNotAllowed) unless @txn_mutex.owned?
         v = get(key)
         unless v
           @dirty = true
@@ -32,7 +33,7 @@ module Bootsnap
       end
 
       def set(key, value)
-        raise(SetOutsideTransactionNotAllowed) unless @in_txn
+        raise(SetOutsideTransactionNotAllowed) unless @txn_mutex.owned?
         if value != @data[key]
           @dirty = true
           @data[key] = value
@@ -40,12 +41,14 @@ module Bootsnap
       end
 
       def transaction
-        raise(NestedTransactionError) if @in_txn
-        @in_txn = true
-        yield
-      ensure
-        commit_transaction
-        @in_txn = false
+        raise(NestedTransactionError) if @txn_mutex.owned?
+        @txn_mutex.synchronize do
+          begin
+            yield
+          ensure
+            commit_transaction
+          end
+        end
       end
 
       private
@@ -60,9 +63,11 @@ module Bootsnap
       def load_data
         @data = begin
           MessagePack.load(File.binread(@store_path))
-                # handle malformed data due to upgrade incompatability
-                rescue Errno::ENOENT, MessagePack::MalformedFormatError, MessagePack::UnknownExtTypeError, EOFError
-                  {}
+          # handle malformed data due to upgrade incompatability
+        rescue Errno::ENOENT, MessagePack::MalformedFormatError, MessagePack::UnknownExtTypeError, EOFError
+          {}
+        rescue ArgumentError => e
+          e.message =~ /negative array size/ ? {} : raise
         end
       end
 

data/lib/bootsnap/load_path_cache.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Bootsnap
   module LoadPathCache
     ReturnFalse = Class.new(StandardError)
@@ -7,6 +9,11 @@ module Bootsnap
     DOT_SO = '.so'
     SLASH  = '/'
 
+    # If a NameError happens several levels deep, don't re-handle it
+    # all the way up the chain: mark it once and bubble it up without
+    # more retries.
+    ERROR_TAG_IVAR = :@__bootsnap_rescued
+
     DL_EXTENSIONS = ::RbConfig::CONFIG
       .values_at('DLEXT', 'DLEXT2')
       .reject { |ext| !ext || ext.empty? }

data/lib/bootsnap/setup.rb

@@ -24,12 +24,15 @@ unless cache_dir
   cache_dir = File.join(app_root, 'tmp', 'cache')
 end
 
+ruby_version = Gem::Version.new(RUBY_VERSION)
+iseq_cache_enabled = ruby_version < Gem::Version.new('2.5.0') || ruby_version >= Gem::Version.new('2.6.0')
+
 Bootsnap.setup(
   cache_dir:            cache_dir,
   development_mode:     development_mode,
   load_path_cache:      true,
   autoload_paths_cache: true, # assume rails. open to PRs to impl. detection
   disable_trace:        false,
-  compile_cache_iseq:   true,
+  compile_cache_iseq:   iseq_cache_enabled,
   compile_cache_yaml:   true,
 )

data/lib/bootsnap/version.rb

@@ -1,3 +1,3 @@
 module Bootsnap
-  VERSION = "1.4.0"
+  VERSION = "1.4.5"
 end

data/shipit.rubygems.yml

@@ -1,4 +0,0 @@
-dependencies:
-  bundler:
-    without:
-      - development

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: bootsnap
 version: !ruby/object:Gem::Version
-  version: 1.4.0
+  version: 1.4.5
 platform: ruby
 authors:
 - Burke Libbey
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-02-11 00:00:00.000000000 Z
+date: 2019-08-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -102,6 +102,8 @@ extensions:
 - ext/bootsnap/extconf.rb
 extra_rdoc_files: []
 files:
+- ".github/CODEOWNERS"
+- ".github/probots.yml"
 - ".gitignore"
 - ".rubocop.yml"
 - ".travis.yml"