devpack 0.1.0 → 0.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: '0853562f5cbb43d560d36d6913f3e1a7bc44ffb49561183146b65a6c69c2f6bb'
-  data.tar.gz: 63cb7a8c6d3bed3bb8806c7a2b3dcd12a82728cfe177c7e7c8f4f6f64112b071
+  metadata.gz: 9502f5bb5412be236b272450cf30b9410a37676ce9a8ff7a769e01e08ebedc0f
+  data.tar.gz: f96bfcfbd97d530ee6a93ff54a8fef02066e5206c468d50d0ef0e4e8501055bc
 SHA512:
-  metadata.gz: b814b628151622a7780f74356d77e94528a1053eb14cac5334faa5fb2784ec0114773d0c641cde3091ba0b12dde8010ed74efbed2f457cea5581abb9fc95fbb1
-  data.tar.gz: 0cea088ec5ba97520eab7734813d972b03cab7332447e3ff3b375716c54bfa87ddcee5168e06fc99c5f469fc4d79a15b599b26d8488e0c8c926ad1871322d62c
+  metadata.gz: b94fee5740d2a0a57db65fdb9533d63397f0a1200babc95ea48104789084eab958570d0e659ba76cae1bbfc65e00839ab822ba9ebe300e8edc66d7490d28f266
+  data.tar.gz: 8d05d1b3839e26b658357613fa6f5a3f2c2251aa939aa6ac68b509cc9733530dddf21024933c11b84e52894bd48c7290fc713307b1e1882c04bd1d0b477d7eb6

data/.gitignore

@@ -10,3 +10,5 @@
 # rspec failure tracking
 .rspec_status
 Gemfile.lock
+
+devpack-*.gem

data/.rubocop.yml

@@ -2,6 +2,10 @@ Metrics/BlockLength:
   Exclude:
     - "spec/**/*"
 
+AllCops:
+  Exclude:
+  - "spec/fixtures/**/*"
+
 Layout/EmptyLinesAroundAttributeAccessor:
   Enabled: true
 Layout/SpaceAroundMethodCallOperator:
@@ -30,3 +34,21 @@ Style/RedundantRegexpEscape:
   Enabled: true
 Style/SlicingWithRange:
   Enabled: true
+Lint/DuplicateElsifCondition:
+  Enabled: true
+Style/AccessorGrouping:
+  Enabled: true
+Style/ArrayCoercion:
+  Enabled: true
+Style/BisectedAttrAccessor:
+  Enabled: true
+Style/CaseLikeIf:
+  Enabled: true
+Style/HashAsLastArrayItem:
+  Enabled: true
+Style/HashLikeCase:
+  Enabled: true
+Style/RedundantAssignment:
+  Enabled: true
+Style/RedundantFileExtensionInRequire:
+  Enabled: true

data/CHANGELOG.md

@@ -0,0 +1,41 @@
+# Changelog
+
+## 0.1.0
+
+Core functionality implemented. Load a `.devpack` configuration file from current directory or, if not present, from a parent directory. Attempt to locate and `require` all listed gems.
+
+## 0.1.1
+
+Use `GEM_PATH` instead of `GEM_HOME` to locate gems.
+
+Optimise load time by searching non-recursively in `/gems` directory (for each path listed in `GEM_PATH`).
+
+Load latest version of gem by default. Allow specifying version with rubygems syntax `example:0.1.0`.
+
+Permit comments in config file.
+
+Use `Gem::Specification` to load "rendered" gemspec (i.e. the file created by rubygems when the gem is installed).  This version of the gemspec will load very quickly so no need to do custom gemspec parsing any more. This also accounts for "missing" gemspecs.
+
+## 0.1.2
+
+Recursively include gem dependencies in `$LOAD_PATH` rather than assuming that any dependencies are already loaded.
+
+Include original error message when warning that a gem was unable to be loaded.
+
+## 0.1.3
+
+Use a more appropriate method of identifying the latest version of a gem (use `Gem::Version` to sort matched gem paths).
+
+Fix edge case where e.g. `pry-rails-0.1.0` was matching for `pry` due to naive match logic. Split on last dash instead of first (i.e. don't assume gems will not have a dash in their name; last dash separates gem name from version in directory name).
+
+## 0.2.0
+
+Add support for initializers. Files located in a `.devpack_initializers` directory will be loaded after gems configured in `.devpack` have been loaded. When using _Rails_ these files will be loaded using the `after_initialize` hook. Thanks to @joshmn for this idea: https://github.com/bobf/devpack/issues/1
+
+Show full tracebacks of load errors when `DEVPACK_DEBUG` is set in environment.
+
+Rename `DISABLE_DEVPACK` environment variable to `DEVPACK_DISABLE` for consistency.
+
+## 0.2.1
+
+Fully activate gem on load: add gem spec to `Gem.loaded_specs` and set instance variables `@loaded` and `@activated` to `true`. This mimics `Gem::Specification#activate` to ensure that anything that depends on these characteristics will function as normal.

data/Makefile

@@ -3,3 +3,7 @@ test:
 	bundle exec rspec
 	bundle exec rubocop
 	bundle exec strong_versions
+
+.PHONY: build
+build: test
+	bundle exec gem build devpack.gemspec

data/README.md

@@ -1,6 +1,6 @@
 # Devpack
 
-Conveniently load a set of gems to tailor your development environment without modifying your application's _Gemfile_. Configurable globally or per-project.
+Include a single gem in your `Gemfile` to allow developers to optionally include their preferred set of development gems without cluttering the `Gemfile`. Configurable globally or per-project.
 
 ## Installation
 
@@ -8,7 +8,7 @@ Add the gem to your `Gemfile`:
 
 ```ruby
 group :development, :test do
-  gem 'devpack', '~> 0.1.0'
+  gem 'devpack', '~> 0.2.1'
 end
 ```
 
@@ -20,27 +20,71 @@ $ bundle install
 
 ## Usage
 
-Create a file named `.devpack` in your project's directory (or any parent directory) containing a list of gems you wish to load:
+Create a file named `.devpack` in your project's directory:
 
 ```
 # .devpack
 awesome_print
 byebug
 better_errors
+
+# Optionally specify a version:
+pry:0.13.1
+```
+
+All listed gems will be automatically required when _Devpack_ is loaded.
+
+If your gems are not auto-loaded (e.g. by _Rails_) then you must require the gem:
+```ruby
+require 'devpack'
+```
+
+Any gems that fail to load (due to `LoadError`) will generate a warning.
+
+It is recommended that `.devpack` is added to your `.gitignore`.
+
+### Initializers
+
+Custom initializers can be loaded by creating a directory named `.devpack_initializers` containing a set of `.rb` files.
+
+Initializers will be loaded in alphabetical order after all gems listed in the `.devpack` configuration file have been loaded.
+
+Initializers that fail to load (for any reason) will generate a warning.
+
+```ruby
+# .devpack_initializers/pry.rb
+
+Pry.config.pager = false
 ```
 
-All listed gems will be automatically required.
+#### Rails
 
-It is recommended that the `.devpack` file is added to your `.gitignore`:
+If _Rails_ is detected then files in the `.devpack_initializers` directory will be loaded using the _Rails_ `after_initialize` hook (i.e. after all other frameworks have been initialized).
 
+```ruby
+# .devpack_initializers/bullet.rb
+
+Bullet.enable = true
 ```
-# .gitignore
-.devpack
+
+### Global Configuration
+
+To configure globally simply save your `.devpack` configuration file to any parent directory of your project directory, e.g. `~/.devpack`.
+
+This strategy also applies to `.devpack_initializers`.
+
+### Disabling
+
+To disable _Devpack_ set the environment variable `DEVPACK_DISABLE` to any value:
+```bash
+DEVPACK_DISABLE=1 bundle exec ruby myapp.rb
 ```
 
-To disable _Devpack_ set the environment variable `DISABLE_DEVPACK` to any value:
+### Debugging
+
+To see the full traceback of any errors encountered at load time set the environment variable `DEVPACK_DEBUG` to any value:
 ```bash
-DISABLE_DEVPACK=1 bundle exec ruby myapp.rb
+DEVPACK_DEBUG=1 bundle exec ruby myapp.rb
 ```
 
 ## License

data/devpack.gemspec

@@ -9,7 +9,7 @@ Gem::Specification.new do |spec|
   spec.email         = ['git@bob.frl']
 
   spec.summary       = 'Conveniently tailor your development environment'
-  spec.description   = 'Provide a list of gems to load in your own environment'
+  spec.description   = 'Allow developers to optionally include a set of development gems without adding to the Gemfile.'
   spec.homepage      = 'https://github.com/bobf/devpack'
   spec.license       = 'MIT'
   spec.required_ruby_version = Gem::Requirement.new('>= 2.3.0')
@@ -28,6 +28,6 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency 'byebug', '~> 11.1'
   spec.add_development_dependency 'rspec', '~> 3.9'
   spec.add_development_dependency 'rspec-its', '~> 1.3'
-  spec.add_development_dependency 'rubocop', '~> 0.86.0'
+  spec.add_development_dependency 'rubocop', '~> 0.88.0'
   spec.add_development_dependency 'strong_versions', '~> 0.4.4'
 end

data/lib/devpack.rb

@@ -3,12 +3,46 @@
 require 'rubygems'
 require 'pathname'
 
-require 'devpack/version'
+require 'devpack/timeable'
+require 'devpack/config'
 require 'devpack/gems'
-require 'devpack/gem_specification_context'
+require 'devpack/gem_glob'
+require 'devpack/gem_spec'
+require 'devpack/initializers'
+require 'devpack/messages'
+require 'devpack/version'
 
+# Provides helper method for writing warning messages.
 module Devpack
   class Error < StandardError; end
+
+  class << self
+    def warn(message)
+      prefixed = message.split("\n").map { |line| "[devpack] #{line}" }.join("\n")
+      Kernel.warn(prefixed)
+    end
+
+    def debug?
+      ENV.key?('DEVPACK_DEBUG')
+    end
+
+    def disabled?
+      ENV.key?('DEVPACK_DISABLE')
+    end
+
+    def rails?
+      defined?(Rails::Railtie)
+    end
+
+    def config
+      @config ||= Devpack::Config.new(Dir.pwd)
+    end
+  end
 end
 
-Devpack::Gems.new('.').load unless ENV.key?('DISABLE_DEVPACK')
+unless Devpack.disabled?
+  require 'devpack/railtie' if Devpack.rails?
+
+  Devpack::Gems.new(Devpack.config).load
+  Devpack::Initializers.new(Devpack.config).load unless Devpack.rails?
+end

data/lib/devpack/config.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module Devpack
+  # Locates and parses .devpack config file
+  class Config
+    FILENAME = '.devpack'
+    INITIALIZERS_DIRECTORY_NAME = '.devpack_initializers'
+    MAX_PARENTS = 100 # Avoid infinite loops (symlinks/weird file systems)
+
+    def initialize(pwd)
+      @pwd = Pathname.new(pwd)
+    end
+
+    def requested_gems
+      return nil if devpack_path.nil?
+
+      File.readlines(devpack_path)
+          .map(&filter_comments)
+          .compact
+    end
+
+    def devpack_path
+      @devpack_path ||= located_path(@pwd, FILENAME, :file)
+    end
+
+    def devpack_initializers_path
+      @devpack_initializers_path ||= located_path(@pwd, INITIALIZERS_DIRECTORY_NAME, :directory)
+    end
+
+    def devpack_initializer_paths
+      devpack_initializers_path&.glob(File.join('**', '*.rb'))&.map(&:to_s)&.sort || []
+    end
+
+    private
+
+    def located_path(next_parent, filename, type)
+      loop.with_index(1) do |_, index|
+        return nil if index > MAX_PARENTS
+
+        path = next_parent.join(filename)
+        next_parent = next_parent.parent
+        next unless File.exist?(path) && File.public_send("#{type}?", path)
+
+        return path
+      end
+    end
+
+    def filter_comments
+      proc do |line|
+        stripped = line.strip
+        next nil if stripped.empty?
+        next nil if stripped.start_with?('#')
+
+        stripped.gsub(/\s*#.*$/, '') # Remove inline comments (like this one)
+      end
+    end
+  end
+end

data/lib/devpack/gem_glob.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module Devpack
+  # Locates gems by searching in paths listed in GEM_PATH
+  class GemGlob
+    def find(name)
+      matched_paths(name).max { |a, b| version(a) <=> version(b) }
+    end
+
+    private
+
+    def glob
+      @glob ||= gem_paths.map { |path| Dir.glob(path.join('gems', '*')) }.flatten
+    end
+
+    def gem_paths
+      return [] unless ENV.key?('GEM_PATH')
+
+      ENV.fetch('GEM_PATH').split(':').map { |path| Pathname.new(path) }
+    end
+
+    def match?(name_with_version, basename)
+      name, _, version = name_with_version.partition(':')
+      return true if version.empty? && basename.rpartition('-').first == name
+      return true if !version.empty? && basename == "#{name}-#{version}"
+
+      false
+    end
+
+    def matched_paths(name)
+      glob.select do |path|
+        pathname = Pathname.new(path)
+        next unless pathname.directory?
+
+        basename = pathname.basename.to_s
+        match?(name, basename)
+      end
+    end
+
+    def version(path)
+      Gem::Version.new(File.split(path).last.rpartition('-').last)
+    end
+  end
+end

data/lib/devpack/gem_spec.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+module Devpack
+  # Locates relevant gemspec for a given gem and provides a full list of paths
+  # for all `require_paths` listed in gemspec.
+  class GemSpec
+    def initialize(glob, name)
+      @name = name
+      @glob = glob
+    end
+
+    def require_paths(visited = Set.new)
+      return [] unless gemspec_path&.exist? && gem_path&.exist?
+
+      (immediate_require_paths + dependency_require_paths(visited))
+        .compact.flatten.uniq
+    end
+
+    def gemspec
+      @gemspec ||= Gem::Specification.load(gemspec_path.to_s)
+    end
+
+    private
+
+    def dependency_require_paths(visited)
+      dependencies.map do |dependency|
+        next nil if visited.include?(dependency)
+
+        visited << dependency
+        GemSpec.new(@glob, name_with_version(dependency)).require_paths(visited)
+      end
+    end
+
+    def dependencies
+      gemspec.runtime_dependencies
+    end
+
+    def gem_path
+      return nil if located_gem.nil?
+
+      Pathname.new(located_gem)
+    end
+
+    def gemspec_path
+      return nil if gem_path.nil?
+
+      gem_path.join('..', '..', 'specifications', "#{gem_path.basename}.gemspec")
+              .expand_path
+    end
+
+    def immediate_require_paths
+      gemspec
+        .require_paths
+        .map { |path| gem_path.join(path).to_s }
+    end
+
+    def name_with_version(dependency)
+      spec = dependency.to_spec
+      "#{spec.name}:#{spec.version}"
+    rescue Gem::MissingSpecError
+      dependency.name
+    end
+
+    def located_gem
+      @located_gem ||= @glob.find(@name)
+    end
+  end
+end

data/lib/devpack/gems.rb

@@ -1,135 +1,62 @@
 # frozen_string_literal: true
 
 module Devpack
-  # Parses .devpack file and provides/loads a list of specified gems
+  # Loads requested gems from configuration
   class Gems
-    FILENAME = '.devpack'
-    MAX_PARENTS = 100 # Avoid infinite loops (symlinks/weird file systems)
+    include Timeable
 
-    def initialize(path)
-      @load_path = $LOAD_PATH
-      @gem_home = Pathname.new(ENV['GEM_HOME'])
-      @path = Pathname.new(path)
+    def initialize(config)
+      @config = config
     end
 
     def load
-      path = devpack_path
-      return [] if path.nil?
+      return [] if @config.requested_gems.nil?
 
-      gems, time = timed { load_devpack(path) }
+      gems, time = timed { load_devpack }
       names = gems.map(&:first)
-      warn(loaded_message(path, gems, time))
+      warn(Messages.loaded(@config.devpack_path, gems, time.round(2)))
       names
     end
 
     private
 
-    def timed
-      start = Time.now.utc
-      result = yield
-      [result, Time.now.utc - start]
-    end
-
-    def load_devpack(path)
-      gem_list(path).map { |name| load_gem(name) }.compact
-    end
-
-    def devpack_path
-      return default_devpack_path if File.exist?(default_devpack_path)
-      return parent_devpack_path unless parent_devpack_path.nil?
-
-      nil
-    end
-
-    def default_devpack_path
-      @path.join(FILENAME)
-    end
-
-    def gem_list(path)
-      File.readlines(path).map(&:chomp)
+    def load_devpack
+      @config.requested_gems.map { |name| load_gem(name) }.compact
     end
 
     def load_gem(name)
-      # TODO: Decide what to do when Bundler is not defined.
-      # Do we want to support this scenario ?
-      update_load_path(name) if defined?(Bundler)
-      [name, Kernel.require(name)]
-    rescue LoadError
-      warn(failure_message(name))
+      [name, activate(name)]
+    rescue LoadError => e
+      warn(Messages.failure(name, load_error_message(e)))
       nil
     end
 
-    def parent_devpack_path
-      next_parent = @path.parent
-      loop.with_index(1) do |_, index|
-        break if index >= MAX_PARENTS
-
-        next_parent = next_parent.parent
-        break if next_parent == next_parent.parent
-
-        path = next_parent.join(FILENAME)
-        next unless File.exist?(path)
-
-        return path
-      end
+    def activate(name)
+      spec = GemSpec.new(gem_glob, name)
+      update_load_path(spec.require_paths)
+      loaded = Kernel.require(name)
+      Gem.loaded_specs[name] = spec.gemspec
+      spec.gemspec&.activated = true
+      spec.gemspec&.instance_variable_set(:@loaded, true)
+      loaded
     end
 
     def warn(message)
-      Kernel.warn("[devpack] #{message}")
+      Devpack.warn(message)
     end
 
-    def gems_glob
-      @gems_glob ||= Dir.glob(@gem_home.join('gems', '**', '*'))
-    end
-
-    def gem_path(name)
-      found = gems_glob.find do |path|
-        pathname = Pathname.new(path)
-        next unless pathname.directory?
-
-        # TODO: We should allow optionally specifying a version and default to loading
-        # the latest version available.
-        pathname.basename.to_s.start_with?("#{name}-")
-      end
-
-      found.nil? ? nil : Pathname.new(found)
-    end
-
-    def update_load_path(name)
-      path = gem_path(name)
-      return if path.nil?
+    def load_error_message(error)
+      return "(#{error.message})" unless Devpack.debug?
 
-      $LOAD_PATH.concat(require_paths(path, name))
+      %[(#{error.message})\n#{error.backtrace.join("\n")}]
     end
 
-    def require_paths(gem_path, name)
-      gemspec_path = gem_path.join("#{name}.gemspec")
-      lib_path = gem_path.join('lib')
-      # REVIEW: Some gems don't have a .gemspec - need to understand how they are loaded.
-      # Use `/lib` for now if it exists as this will work for vast majority of cases.
-      return [lib_path] if !gemspec_path.exist? && lib_path.exist?
-
-      gemspec = File.read(gemspec_path.to_s)
-      GemSpecificationContext.class_eval(gemspec)
-      full_require_paths(gem_path)
-    end
-
-    def full_require_paths(base_path)
-      GemSpecificationContext.require_paths.map { |path| base_path.join(path) }
+    def gem_glob
+      @gem_glob ||= GemGlob.new
     end
 
-    def failure_message(name)
-      base = "Failed to load `#{name}`"
-      install = (defined?(Bundler) ? 'bundle exec ' : '') + "gem install #{name}"
-      "#{base}. Try `#{install}`"
-    end
-
-    def loaded_message(path, gems, time)
-      already_loaded = gems.size - gems.reject { |_, loaded| loaded }.size
-      base = "Loaded #{already_loaded} development gem(s) from '#{path}' in #{time} seconds"
-      return "#{base}." if already_loaded == gems.size
-
-      "#{base} (#{gems.size - already_loaded} gem(s) were already loaded by environment)."
+    def update_load_path(paths)
+      $LOAD_PATH.concat(paths)
     end
   end
 end

data/lib/devpack/initializers.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Devpack
+  # Loads requested initializers from configuration
+  class Initializers
+    include Timeable
+
+    def initialize(config)
+      @config = config
+    end
+
+    def load
+      initializers, time = timed { load_initializers }
+      path = @config.devpack_initializers_path
+      return if path.nil?
+
+      args = path, initializers, time.round(2)
+      Devpack.warn(Messages.loaded_initializers(*args))
+    end
+
+    private
+
+    def load_initializers
+      @config.devpack_initializer_paths.map { |path| load_initializer(path) }
+    end
+
+    def load_initializer(path)
+      require path
+    rescue ScriptError, StandardError => e
+      Devpack.warn(Messages.initializer_failure(path, message(e)))
+      nil
+    end
+
+    def message(error)
+      return "(#{error.class.name} - #{error.message&.split("\n")&.first})" unless Devpack.debug?
+
+      %[(#{error.class.name})\n#{error.message}\n#{error.backtrace.join("\n")}]
+    end
+  end
+end

data/lib/devpack/messages.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Devpack
+  # Generates output messages.
+  class Messages
+    class << self
+      def failure(name, error_message)
+        base = "Failed to load `#{name}`"
+        install = "bundle exec gem install #{name}"
+        "#{base}. Try `#{install}` #{error_message}"
+      end
+
+      def initializer_failure(path, error_message)
+        "Failed to load initializer `#{path}`: #{error_message}"
+      end
+
+      def loaded(path, gems, time)
+        already_loaded = gems.size - gems.reject { |_, loaded| loaded }.size
+        base = "Loaded #{already_loaded} development gem(s) from '#{path}' in #{time} seconds"
+        return "#{base}." if already_loaded == gems.size
+
+        "#{base} (#{gems.size - already_loaded} gem(s) were already loaded by environment)."
+      end
+
+      def loaded_initializers(path, initializers, time)
+        "Loaded #{initializers.compact.size} initializer(s) from '#{path}' in #{time} seconds"
+      end
+
+      private
+
+      def indented(message)
+        message.split("\n").map { |line| "  #{line}" }.join("\n")
+      end
+    end
+  end
+end

data/lib/devpack/railtie.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module Devpack
+  # Loads Devpack initializers after standard Rails initializers have been loaded.
+  class Railtie < Rails::Railtie
+    config.after_initialize { Devpack::Initializers.new(Devpack.config).load }
+  end
+end

data/lib/devpack/timeable.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+# Provides result and run time of a given block.
+module Timeable
+  def timed
+    start = Time.now.utc
+    result = yield
+    [result, Time.now.utc - start]
+  end
+end

data/lib/devpack/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Devpack
-  VERSION = '0.1.0'
+  VERSION = '0.2.1'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: devpack
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.1
 platform: ruby
 authors:
 - Bob Farrell
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-07-04 00:00:00.000000000 Z
+date: 2020-08-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: byebug
@@ -58,14 +58,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.86.0
+        version: 0.88.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.86.0
+        version: 0.88.0
 - !ruby/object:Gem::Dependency
   name: strong_versions
   requirement: !ruby/object:Gem::Requirement
@@ -80,7 +80,8 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: 0.4.4
-description: Provide a list of gems to load in your own environment
+description: Allow developers to optionally include a set of development gems without
+  adding to the Gemfile.
 email:
 - git@bob.frl
 executables: []
@@ -90,6 +91,7 @@ files:
 - ".gitignore"
 - ".rspec"
 - ".rubocop.yml"
+- CHANGELOG.md
 - Gemfile
 - LICENSE.txt
 - Makefile
@@ -99,8 +101,14 @@ files:
 - bin/setup
 - devpack.gemspec
 - lib/devpack.rb
-- lib/devpack/gem_specification_context.rb
+- lib/devpack/config.rb
+- lib/devpack/gem_glob.rb
+- lib/devpack/gem_spec.rb
 - lib/devpack/gems.rb
+- lib/devpack/initializers.rb
+- lib/devpack/messages.rb
+- lib/devpack/railtie.rb
+- lib/devpack/timeable.rb
 - lib/devpack/version.rb
 homepage: https://github.com/bobf/devpack
 licenses:

data/lib/devpack/gem_specification_context.rb

@@ -1,65 +0,0 @@
-# frozen_string_literal: true
-
-module Devpack
-  # Stubbed instance_eval context to evaluate a .gemspec file and extract required_paths
-  # Avoids doing expensive operations (e.g. attempting to run `git ls-files`) which are
-  # typically invoked when using `Gem::Specification.load`.
-  class GemSpecificationContext
-    def initialize(*_); end
-
-    class << self
-      attr_accessor :require_paths
-
-      @require_paths = []
-
-      def require(*_); end
-
-      def __dir__
-        '.'
-      end
-
-      def require_relative(*_); end
-    end
-
-    module Gem
-      # Stubbed Rubygems Gem::Specification. Everything except `require_paths=` is a no-op.
-      # Catches errors for missing constants and attempts to set them in the class_eval context.
-      # Constants are set recursively by setting each constant to GemSpecificationContext.
-      class Specification
-        def initialize(*_)
-          GemSpecificationContext.require_paths = []
-          begin
-            yield self
-          rescue NameError => e
-            __devpack_resolved_receiver(e).const_set(e.name, GemSpecificationContext)
-            retry
-          end
-        end
-
-        def require_paths=(paths)
-          GemSpecificationContext.require_paths.concat(paths)
-        end
-
-        private
-
-        def __devpack_resolved_receiver(error)
-          error.receiver
-        rescue ArgumentError
-          GemSpecificationContext
-        end
-
-        # rubocop:disable Style/MethodMissingSuper
-        def method_missing(method_name, *args)
-          return self unless Kernel.respond_to?(method_name)
-
-          Kernel.public_send(method_name, *args)
-        end
-        # rubocop:enable Style/MethodMissingSuper
-
-        def respond_to_missing?(*_)
-          true
-        end
-      end
-    end
-  end
-end