bundle_hack 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 9b7e2f08fc8c5f36bb61d5a8e8627d57140b2018
-  data.tar.gz: 96738bd9fffcc7f8a79280771c838db1d6a45595
+SHA256:
+  metadata.gz: e3c07038f47d540e8eab90ea819c3a85e5672af8de6aca3e61e388cde3654406
+  data.tar.gz: 91dde30d342fee125343b625d3d7f5a4349cb6d6679208403de4b44fc81f7bf1
 SHA512:
-  metadata.gz: 79c4ad0fd7c2c7d23480e80e9e9d4cfa5725700413c652b91da692a5fa70e5d5d32325f15c86685afba9e88df0e3446ff7602cd2f39da55a4839c02505ba72ed
-  data.tar.gz: cf1e9f8f73b90d5f4874949d0c4db42039aba54feebfd3683684793e7615be8d1e008bad53cd6a1603b110ea7185a5f033e30bad8c5e9fdaccba5d4850acb2cf
+  metadata.gz: 8ae6b9769b44c75e47f67c6d72fe1a7286eeb2a21c89f14884742bf6f6eb1d3b5bcdae0798aeabb1394ba84efb06b07edb6a92a4312968bf82f823575e938e3d
+  data.tar.gz: 4b10042cc4bffe5271747702bb36fa5f66b0e0ae31e2536f26bf3852c3aa1c96557f325e46809b0bd43a80db1b5d80b13683ebff99adbce1fa6bd140cce1e70d

data/.gitignore

@@ -14,3 +14,8 @@ Gemfile.lock
 
 *.swo
 *.swp
+
+.byebug_history
+spec/dummy/Gemfile.hack
+spec/dummy/Gemfile.hack.lock
+spec/dummy/hack/dummy_gem/dummy_gem.gemspec

data/.rubocop.yml

@@ -1,4 +1,3 @@
-# Don't require top-level comment for all modules and classes
 Style/Documentation:
   Enabled: false
 
@@ -6,8 +5,9 @@ Metrics/BlockLength:
   Exclude:
     - 'spec/**/*'
 
-# We don't care about the auto-generated dummy Rails app
 AllCops:
   Exclude:
     - 'bin/**/*'
-    - 'db/schema.rb'
+    - 'spec/dummy/**/*'
+    - 'spec/fixtures/**/*'
+    - 'config/header.rb'

data/.ruby-version

@@ -0,0 +1 @@
+2.5.3

data/Gemfile

@@ -4,5 +4,14 @@ source 'https://rubygems.org'
 
 git_source(:github) { |repo_name| "https://github.com/#{repo_name}" }
 
-# Specify your gem's dependencies in bundle_hack.gemspec
+# These gems are only used by tests - we need to have these gems available in
+# the current Bundler context (i.e. the context used when running tests) to
+# allow us to use Bundler to locate gem sources etc., otherwise we would need to
+# stub Bundler to hell. With Bundler being so integral to BundleHack I don't
+# think that's an option.
+gem 'another_dummy_gem',
+    git: 'https://github.com/bobf/another_dummy_gem', ref: 'ed0e5d21f1ff'
+gem 'dummy_gem', '1.0.0'
+gem 'noop', '0.0.2'
+
 gemspec

data/Makefile

@@ -0,0 +1,5 @@
+.PHONY: test
+
+test:
+	bin/rspec
+	bin/rubocop

data/README.md

@@ -32,10 +32,14 @@ The gem is copied to `hack/rake/` (relative to the same directory as your `Gemfi
 
 When you're done, you can restore a specific gem:
 
+# TODO:
+
 ``` bash
 $ bundle hack:restore rake
 ```
 
+# TODO:
+
 Or restore all hacked gems:
 ```
 $ bundle hack:restore:all

data/bin/rake

@@ -0,0 +1,29 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+#
+# This file was generated by Bundler.
+#
+# The application 'rake' is installed as part of a gem, and
+# this file is here to facilitate running it.
+#
+
+require "pathname"
+ENV["BUNDLE_GEMFILE"] ||= File.expand_path("../../Gemfile",
+  Pathname.new(__FILE__).realpath)
+
+bundle_binstub = File.expand_path("../bundle", __FILE__)
+
+if File.file?(bundle_binstub)
+  if File.read(bundle_binstub, 300) =~ /This file was generated by Bundler/
+    load(bundle_binstub)
+  else
+    abort("Your `bin/bundle` was not generated by Bundler, so this binstub cannot run.
+Replace `bin/bundle` by running `bundle binstubs bundler --force`, then run this command again.")
+  end
+end
+
+require "rubygems"
+require "bundler/setup"
+
+load Gem.bin_path("rake", "rake")

data/bin/rspec

@@ -0,0 +1,29 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+#
+# This file was generated by Bundler.
+#
+# The application 'rspec' is installed as part of a gem, and
+# this file is here to facilitate running it.
+#
+
+require "pathname"
+ENV["BUNDLE_GEMFILE"] ||= File.expand_path("../../Gemfile",
+  Pathname.new(__FILE__).realpath)
+
+bundle_binstub = File.expand_path("../bundle", __FILE__)
+
+if File.file?(bundle_binstub)
+  if File.read(bundle_binstub, 300) =~ /This file was generated by Bundler/
+    load(bundle_binstub)
+  else
+    abort("Your `bin/bundle` was not generated by Bundler, so this binstub cannot run.
+Replace `bin/bundle` by running `bundle binstubs bundler --force`, then run this command again.")
+  end
+end
+
+require "rubygems"
+require "bundler/setup"
+
+load Gem.bin_path("rspec-core", "rspec")

data/bin/rubocop

@@ -0,0 +1,29 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+#
+# This file was generated by Bundler.
+#
+# The application 'rubocop' is installed as part of a gem, and
+# this file is here to facilitate running it.
+#
+
+require "pathname"
+ENV["BUNDLE_GEMFILE"] ||= File.expand_path("../../Gemfile",
+  Pathname.new(__FILE__).realpath)
+
+bundle_binstub = File.expand_path("../bundle", __FILE__)
+
+if File.file?(bundle_binstub)
+  if File.read(bundle_binstub, 300) =~ /This file was generated by Bundler/
+    load(bundle_binstub)
+  else
+    abort("Your `bin/bundle` was not generated by Bundler, so this binstub cannot run.
+Replace `bin/bundle` by running `bundle binstubs bundler --force`, then run this command again.")
+  end
+end
+
+require "rubygems"
+require "bundler/setup"
+
+load Gem.bin_path("rubocop", "rubocop")

data/bundle_hack.gemspec

@@ -20,11 +20,16 @@ Gem::Specification.new do |spec|
     end
   end
   spec.bindir        = 'bin'
-  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.executables   = []
   spec.require_paths = ['lib']
 
-  spec.add_development_dependency 'bundler', '~> 1.16'
+  spec.add_dependency 'i18n', '>= 0.5'
+  spec.add_dependency 'parser', '~> 2.5'
+
+  spec.add_development_dependency 'byebug', '~> 10.0'
   spec.add_development_dependency 'rake', '~> 10.0'
   spec.add_development_dependency 'rspec', '~> 3.0'
-  spec.add_development_dependency 'rubocop', '~> 0.59.2'
+  spec.add_development_dependency 'rspec-its', '~> 1.2'
+  spec.add_development_dependency 'rubocop', '~> 0.60.0'
+  spec.add_development_dependency 'webmock', '~> 3.4'
 end

data/config/header.rb

@@ -0,0 +1,4 @@
+
+#
+# BundleHack gems:
+#

data/config/locales/en.yml

@@ -0,0 +1,6 @@
+en:
+  errors:
+    missing_gem: "Requested gem '%{gem}' not found in Gemfile"
+    missing_spec: "Unable to locate .gemspec for '%{gem}'"
+    parsing: "Error parsing Gemfile: unable to locate '%{gem}'. Please file a bug report."
+    type: "Unknown type: %{type}"

data/lib/bundle_hack.rb

@@ -1,7 +1,37 @@
 # frozen_string_literal: true
 
+require 'pathname'
+require 'yaml'
+
+require 'i18n'
+require 'parser/current'
+
+require 'bundle_hack/command'
+require 'bundle_hack/config_writer'
+require 'bundle_hack/errors'
+require 'bundle_hack/gem'
+require 'bundle_hack/gem_cloner'
+require 'bundle_hack/gem_locator'
+require 'bundle_hack/gemfile_parser'
+require 'bundle_hack/gemfile_writer'
+require 'bundle_hack/gemspec_cloner'
+require 'bundle_hack/sandbox'
+require 'bundle_hack/gemspec_sources/base'
+require 'bundle_hack/gemspec_sources/cache'
+require 'bundle_hack/gemspec_sources/path'
+require 'bundle_hack/gemspec_sources/rubygems'
 require 'bundle_hack/version'
 
+I18n.config.available_locales = :en
+I18n.load_path += Dir[
+  File.join(File.expand_path('..', __dir__), 'config', 'locales', '**', '*.yml')
+]
+
 module BundleHack
-  # Your code goes here...
+  GEMFILE = 'Gemfile.hack'
+  HACK_DIR = 'hack'
+
+  def self.root
+    Pathname.new(File.dirname(__dir__))
+  end
 end

data/lib/bundle_hack/command.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module BundleHack
+  class Command < Bundler::Plugin::API
+    command 'hack'
+    command 'hack:restore'
+    command 'hack:restore:all'
+
+    def exec(command, args)
+      Sandbox.new(args.first).create if command == 'hack'
+    end
+  end
+end

data/lib/bundle_hack/config_writer.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module BundleHack
+  class ConfigWriter
+    def initialize(root_path)
+      @root_path = root_path
+      @config_path = File.join(@root_path, '.bundle', 'config')
+    end
+
+    def create_or_update
+      return create_config unless File.exist?(@config_path)
+
+      update_config
+    end
+
+    private
+
+    def create_config
+      FileUtils.mkdir_p(File.join(@root_path, '.bundle'))
+      write_config(config_settings)
+    end
+
+    def update_config
+      write_config(YAML.load_file(@config_path).merge(config_settings))
+    end
+
+    def write_config(config)
+      File.write(@config_path, config.to_yaml)
+    end
+
+    def config_settings
+      {
+        'BUNDLE_GEMFILE' => GEMFILE
+      }
+    end
+  end
+end

data/lib/bundle_hack/errors.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module BundleHack
+  class BundleHackError < StandardError; end
+  class MissingGemError < BundleHackError; end
+  class MissingSpecError < BundleHackError; end
+  class ParsingError < BundleHackError; end
+end

data/lib/bundle_hack/gem.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module BundleHack
+  class Gem
+    attr_reader :name, :full_name, :version, :path
+
+    def initialize(definitions, options = {})
+      @definitions = definitions
+      @name = options.fetch(:name)
+      @full_name = options.fetch(:full_name)
+      @version = normalized_version(options.fetch(:version))
+      @path = Pathname.new(options.fetch(:path))
+    end
+
+    def locations
+      @definitions.map { |definition| definition[:locations] }.flatten
+    end
+
+    def params
+      find_params || {}
+    end
+
+    private
+
+    def find_params
+      # Because we don't know how the bundle was built (e.g. if it was built
+      # with `--without development test`) we have to take a guess at which
+      # definition to use for our parameters. In most cases the definition will
+      # be in the main block, otherwise we use the `development` definition and,
+      # failing that, we take the definition nearest to the end of the Gemfile.
+      # This is very much an edge case as this will only be a problem if we pick
+      # the wrong one AND the parameters are different to the "real" gem we're
+      # using.
+      return primary_definition[:params] unless primary_definition.nil?
+      return development_definition[:params] unless development_definition.nil?
+
+      any_definition[:params]
+    end
+
+    def primary_definition
+      @definitions.reverse_each.find do |definition|
+        definition.fetch(:groups).nil?
+      end
+    end
+
+    def development_definition
+      @definitions.reverse_each.find do |definition|
+        definition.fetch(:groups).include?(:development)
+      end
+    end
+
+    def any_definition
+      @definitions.last
+    end
+
+    def normalized_version(version)
+      # Ruby >= 2.3.0: `version` is a `Gem::Version`
+      # Ruby < 2.3.0: `version` is a `String`
+      version.respond_to?(:version) ? version.version : version
+    end
+  end
+end

data/lib/bundle_hack/gem_cloner.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module BundleHack
+  class GemCloner
+    def initialize(gem, root_path)
+      @gem = gem
+      @root_path = root_path
+    end
+
+    def clone
+      hack_dir = @root_path.join(HACK_DIR)
+
+      FileUtils.mkdir_p(hack_dir)
+      # Sadly there is no `FileUtils.cp_R` so we copy and rename instead
+      FileUtils.cp_r(@gem.path, hack_dir)
+      FileUtils.mv(hack_dir.join(@gem.full_name), hack_dir.join(@gem.name))
+    end
+  end
+end

data/lib/bundle_hack/gem_locator.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module BundleHack
+  class GemLocator
+    def initialize(gemfile_path, gemfile_lock_path)
+      @gemfile_path = gemfile_path
+      @gemfile_lock_path = gemfile_lock_path
+    end
+
+    def locate(gem_name)
+      gem = gems.find { |spec| spec[:name] == gem_name }
+      missing_gem_error(gem_name) if gem.nil?
+
+      gem
+    end
+
+    private
+
+    def gems
+      bundler_specs.map do |spec|
+        filtered_spec(spec)
+      end
+    end
+
+    def missing_gem_error(gem_name)
+      raise MissingGemError, I18n.t('errors.missing_gem', gem: gem_name)
+    end
+
+    def filtered_spec(spec)
+      {
+        name: spec.name,
+        full_name: spec.full_name,
+        path: spec.full_gem_path,
+        version: spec.version
+      }
+    end
+
+    def bundler_specs
+      @bundler_specs ||= Bundler::Definition.build(
+        @gemfile_path, @gemfile_lock_path, nil
+      ).specs
+    end
+  end
+end

data/lib/bundle_hack/gemfile_parser.rb

@@ -0,0 +1,134 @@
+# frozen_string_literal: true
+
+module BundleHack
+  class GemfileParser
+    def initialize(gemfile)
+      @gemfile = gemfile
+    end
+
+    def definitions_for(gem_name)
+      definitions(by_name(gem_name))
+    end
+
+    private
+
+    def by_name(gem_name)
+      sexps = gems.select do |gem|
+        gem[:sexp].children[2].to_sexp_array[1] == gem_name
+      end
+
+      parsing_error(gem_name) if sexps.empty?
+
+      sexps
+    end
+
+    def gems
+      top_level_gems + group_gems
+    end
+
+    def top_level_gems
+      gem_sexps_from_children(parsed_gemfile.children).map do |sexp|
+        { groups: nil, sexp: sexp }
+      end
+    end
+
+    def group_gems
+      parsed_gemfile.children.map do |child|
+        next unless group?(child)
+
+        gem_sexps_from_children(child.children[2..-1]).map do |sexp|
+          { groups: group_names(child.to_sexp_array), sexp: sexp }
+        end
+      end.compact.flatten(1)
+    end
+
+    def group_names(sexp_array)
+      # sexp_array[1] looks like:
+      # [:send, nil, :group, [:sym, :development], [:sym, :test]]
+      _send, _, _group, *group_pairs = sexp_array[1]
+      group_pairs.map { |_sym, group| group }
+    end
+
+    def group?(sexp)
+      sexp_array = sexp.to_sexp_array
+      sexp_array[0] == :block && sexp_array[1][2] == :group
+    end
+
+    def gem_sexps_from_children(children)
+      children.select do |child|
+        sexp_array = child.to_sexp_array
+        sexp_array[0] == :send && sexp_array[2] == :gem
+      end
+    end
+
+    def parsed_gemfile
+      @parsed_gemfile ||= begin
+        @gemfile.rewind
+        Parser::CurrentRuby.parse(@gemfile.read)
+      end
+    end
+
+    def definitions(gems)
+      gems.map do |gem|
+        {
+          groups: gem[:groups],
+          locations: location(gem[:sexp]),
+          params: hash_params(gem[:sexp])
+        }
+      end
+    end
+
+    def location(sexp)
+      (sexp.location.first_line..sexp.location.last_line).to_a
+    end
+
+    def hash_params(sexp)
+      last_arg_sexp = sexp.children.last
+      return nil unless last_arg_sexp.to_sexp_array.first == :hash
+
+      _, *pairs = last_arg_sexp.to_sexp_array
+
+      Hash[key_value_pairs(pairs)]
+    end
+
+    def key_value_pairs(pairs)
+      pairs.map do |_pair_sym, (_type, key), value|
+        [key, nested_value(*value)]
+      end
+    end
+
+    def nested_value(type, *values)
+      return primitive(type) if values.empty?
+      return array(values) if type == :array
+      return hash(values) if type == :hash
+      return values.first if %i[sym str].include?(type)
+
+      raise ParsingError, I18n.t('errors.type', type: type)
+    end
+
+    def array(values)
+      values.map { |type, value_array| nested_value(type, value_array) }
+    end
+
+    def hash(values)
+      Hash[array(values)]
+    end
+
+    def primitive(type)
+      # rubocop:disable Lint/BooleanSymbol
+      case type
+      when :false
+        false
+      when :true
+        true
+      when :nil
+        nil
+      end
+      # rubocop:enable Lint/BooleanSymbol
+    end
+
+    def parsing_error(gem_name)
+      raise ParsingError, I18n.t('errors.parsing', gem: gem_name)
+    end
+  end
+end

data/lib/bundle_hack/gemfile_writer.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module BundleHack
+  class GemfileWriter
+    FILTERED_PARAMS = %i[git path].freeze
+
+    def initialize(root_path, gemfile_path, gems)
+      @root_path = root_path
+      @gemfile_path = gemfile_path
+      @hacked_gems = gems
+      @hacked_gemfile_path = @root_path.join(GEMFILE)
+    end
+
+    def create
+      comment_existing_gems
+      append_hacked_gems
+    end
+
+    private
+
+    def comment_existing_gems
+      File.write(@hacked_gemfile_path, commented_gemfile)
+    end
+
+    def commented_gemfile
+      File.readlines(@gemfile_path).to_enum.with_index(1).map do |line, index|
+        next line.chomp unless comment_lines.include?(index)
+
+        "# #{line.chomp} # managed by BundleHack"
+      end.join("\n")
+    end
+
+    def append_hacked_gems
+      File.write(
+        @hacked_gemfile_path,
+        File.read(@hacked_gemfile_path) + header + hacked_gem_definitions
+      )
+    end
+
+    def hacked_gem_definitions
+      @hacked_gems.map do |gem|
+        params = filtered_params(gem.params).merge(path: "hack/#{gem.name}")
+        "gem '#{gem.name}', #{params.inspect}"
+      end.join("\n")
+    end
+
+    def header
+      File.read(BundleHack.root.join('config', 'header.rb'))
+    end
+
+    def comment_lines
+      @hacked_gems.map(&:locations).flatten
+    end
+
+    def filtered_params(params)
+      params.reject { |key, _value| FILTERED_PARAMS.include?(key) }
+    end
+  end
+end

data/lib/bundle_hack/gemspec_cloner.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module BundleHack
+  class GemspecCloner
+    def initialize(gem, root_path, options = {})
+      @use_cache = options.fetch(:use_cache, true)
+      @use_rubygems = options.fetch(:use_rubygems, true)
+      @gem = gem
+      @root_path = root_path
+      @spec_path = @root_path.join(HACK_DIR, @gem.name, "#{@gem.name}.gemspec")
+    end
+
+    def clone
+      FileUtils.mkdir_p(@root_path.join(HACK_DIR, @gem.name))
+      File.write(@spec_path, find_spec)
+    end
+
+    private
+
+    def find_spec
+      return path_spec unless path_spec.nil?
+      return cache_spec unless cache_spec.nil?
+      return rubygems_spec unless rubygems_spec.nil?
+
+      raise MissingSpecError, I18n.t('errors.missing_spec', gem: @gem.name)
+    end
+
+    def spec_from(source)
+      source.new(@gem).spec
+    end
+
+    def rubygems_spec
+      return nil unless @use_rubygems
+
+      @rubygems_spec ||= spec_from(GemspecSources::Rubygems)
+    end
+
+    def path_spec
+      @path_spec ||= spec_from(GemspecSources::Path)
+    end
+
+    def cache_spec
+      return nil unless @use_cache
+
+      @cache_spec ||= spec_from(GemspecSources::Cache)
+    end
+  end
+end

data/lib/bundle_hack/gemspec_sources/base.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module BundleHack
+  module GemspecSources
+    class Base
+      def initialize(gem)
+        @gem = gem
+      end
+
+      def spec
+        raise NotImplementedError
+      end
+    end
+  end
+end

data/lib/bundle_hack/gemspec_sources/cache.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module BundleHack
+  module GemspecSources
+    # I couldn't figure out how to do this with `Gem` directly so I've
+    # implemented it myself instead - if this can be collapsed into something
+    # along the lines of `Gem.from_cache(gem_name, gem_version)` then that would
+    # mean all of this code can go away.
+    class Cache < Base
+      def spec
+        path = cache_file_path
+        return nil if path.nil?
+
+        # rubocop:disable Security/MarshalLoad
+        Marshal.load(File.read(cache_file_path)).to_ruby
+        # rubocop:enable Security/MarshalLoad
+      end
+
+      private
+
+      def cache_file_path
+        cache_dirs.each do |cache_dir|
+          cache_file_path = cache_dir.join("#{@gem.full_name}.gemspec")
+          return cache_file_path if File.exist?(cache_file_path)
+        end
+
+        nil
+      end
+
+      def cache_dirs
+        Dir.entries(base_dir)
+           .select { |path| File.directory?(quick_cache(path)) }
+           .reject { |path| %w[. ..].include?(path) }
+           .map { |path| quick_cache(path) }
+      end
+
+      def quick_cache(path)
+        # I think the `4.8` versioning is highly stable. The lead dev of
+        # Bundler references it in this post from nearly 5 years ago:
+        # https://www.engineyard.com/blog/new-rubygems-index-format
+        # So I think # it's okay to make this a hard requirement.
+        base_dir.join(path, 'quick', 'Marshal.4.8')
+      end
+
+      def base_dir
+        @base_dir ||= Pathname.new(::Gem.spec_cache_dir)
+      end
+    end
+  end
+end

data/lib/bundle_hack/gemspec_sources/path.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module BundleHack
+  module GemspecSources
+    class Path < Base
+      def spec
+        # If the gem comes from a path (including git) then we will have the
+        # gemspec available in the gem directory (unlike when it comes from
+        # rubygems)
+        gemspec_path = @gem.path.join("#{@gem.name}.gemspec")
+        return nil unless File.exist?(gemspec_path)
+
+        File.read(gemspec_path)
+      end
+    end
+  end
+end

data/lib/bundle_hack/gemspec_sources/rubygems.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module BundleHack
+  module GemspecSources
+    class Rubygems < Base
+      def spec
+        dependency = ::Gem::Dependency.new(@gem.name, @gem.version)
+
+        # Borrowed from:
+        # https://ruby-doc.org/stdlib-2.5.3/libdoc/rubygems/rdoc/Gem.html#method-c-latest_spec_for
+        spec_tuples, = ::Gem::SpecFetcher.fetcher.spec_for_dependency(
+          dependency
+        )
+        spec, = spec_tuples.first
+        return nil if spec.nil?
+
+        spec.to_ruby
+      end
+    end
+  end
+end

data/lib/bundle_hack/sandbox.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module BundleHack
+  class Sandbox
+    def initialize(gem_name, gemfile_path = nil)
+      @gem_name = gem_name
+      @gemfile_path = gemfile_path || Bundler.default_gemfile
+      @gemfile_lock_path = lock_path(gemfile_path)
+      @root_path = Pathname.new(File.dirname(@gemfile_path))
+    end
+
+    def build
+      parser = GemfileParser.new(File.open(@gemfile_path))
+      gems = locate_gems(parser)
+      ConfigWriter.new(@root_path).create_or_update
+      GemfileWriter.new(@root_path, @gemfile_path, gems).create
+      gems.each do |gem|
+        GemCloner.new(gem, @root_path).clone
+        GemspecCloner.new(gem, @root_path).clone
+      end
+    end
+
+    private
+
+    def locate_gems(parser)
+      # TODO: Read from .bundle_hack.yml
+      [@gem_name].map { |gem_name| locate_gem(gem_name, parser) }
+    end
+
+    def locate_gem(gem_name, parser)
+      spec = GemLocator.new(@gemfile_path, @gemfile_lock_path)
+                       .locate(gem_name)
+      Gem.new(parser.definitions_for(gem_name), spec)
+    end
+
+    def lock_path(gemfile_path)
+      gemfile_path.nil? ? Bundler.default_lockfile : "#{gemfile_path}.lock"
+    end
+  end
+end

data/lib/bundle_hack/version.rb

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

data/plugins.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+require 'bundle_hack'

metadata

@@ -1,29 +1,57 @@
 --- !ruby/object:Gem::Specification
 name: bundle_hack
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Bob Farrell
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-10-26 00:00:00.000000000 Z
+date: 2018-12-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: bundler
+  name: i18n
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0.5'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0.5'
+- !ruby/object:Gem::Dependency
+  name: parser
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.16'
+        version: '2.5'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.5'
+- !ruby/object:Gem::Dependency
+  name: byebug
+  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: '1.16'
+        version: '10.0'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -52,41 +80,89 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: rspec-its
+  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: rubocop
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.59.2
+        version: 0.60.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.60.0
+- !ruby/object:Gem::Dependency
+  name: webmock
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.4'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.59.2
+        version: '3.4'
 description: Debug fearlessly and restore when you're done
 email:
 - robertanthonyfarrell@gmail.com
-executables:
-- console
-- setup
+executables: []
 extensions: []
 extra_rdoc_files: []
 files:
 - ".gitignore"
 - ".rspec"
 - ".rubocop.yml"
+- ".ruby-version"
 - ".travis.yml"
 - Gemfile
+- Makefile
 - README.md
 - Rakefile
 - bin/console
+- bin/rake
+- bin/rspec
+- bin/rubocop
 - bin/setup
 - bundle_hack.gemspec
+- config/header.rb
+- config/locales/en.yml
 - lib/bundle_hack.rb
+- lib/bundle_hack/command.rb
+- lib/bundle_hack/config_writer.rb
+- lib/bundle_hack/errors.rb
+- lib/bundle_hack/gem.rb
+- lib/bundle_hack/gem_cloner.rb
+- lib/bundle_hack/gem_locator.rb
+- lib/bundle_hack/gemfile_parser.rb
+- lib/bundle_hack/gemfile_writer.rb
+- lib/bundle_hack/gemspec_cloner.rb
+- lib/bundle_hack/gemspec_sources/base.rb
+- lib/bundle_hack/gemspec_sources/cache.rb
+- lib/bundle_hack/gemspec_sources/path.rb
+- lib/bundle_hack/gemspec_sources/rubygems.rb
+- lib/bundle_hack/sandbox.rb
 - lib/bundle_hack/version.rb
+- plugins.rb
 homepage: http://github.com/bobf/bundle_hack
 licenses: []
 metadata: {}
@@ -106,7 +182,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.5.2.2
+rubygems_version: 2.7.6
 signing_key: 
 specification_version: 4
 summary: Safely hack gems in your bundle