berkshelf 2.0.1 → 2.0.3

data/CHANGELOG.md

@@ -1,3 +1,14 @@
+# 2.0.3
+
+* Fix issue where groups defined in the Berksfile would not be evaluated
+
+# 2.0.2
+
+* Fix issue with shellout on Windows. This would effect uploads and downloads of cookbooks using the Git location.
+* The Berksfile DSL now evaluates in a clean room to prevent end-users from calling restricted methods.
+* Fix issue with `berks upload -D` not properly skipping dependencies
+* Added friendly error message when an unknown license is chosen during cookbook generation
+
 # 2.0.1
 
 * Improve performance of `berks upload`. It will now properly respect the Lockfile

data/berkshelf.gemspec

@@ -38,7 +38,7 @@ Gem::Specification.new do |s|
   s.add_dependency 'hashie',            '>= 2.0.2'
   s.add_dependency 'minitar',           '~> 0.5.4'
   s.add_dependency 'retryable',         '~> 1.3.3'
-  s.add_dependency 'ridley',            '~> 1.0.0'
+  s.add_dependency 'ridley',            '~> 1.0.2'
   s.add_dependency 'solve',             '>= 0.4.4'
   s.add_dependency 'test-kitchen',      '>= 1.0.0.alpha7'
   s.add_dependency 'thor',              '~> 0.18.0'

data/features/upload_command.feature

@@ -263,3 +263,34 @@ Feature: Uploading cookbooks to a Chef Server
       The cookbook 'cookbook with spaces' has invalid filenames:
       """
     And the CLI should exit with the status code for error "InvalidCookbookFiles"
+
+    @chef_server @slow_process
+  Scenario: With the --skip-dependencies flag
+    Given the cookbook store has the cookbooks:
+      | fake  | 1.0.0 |
+      | ekaf  | 2.0.0 |
+    And the cookbook store contains a cookbook "reset" "3.4.5" with dependencies:
+      | fake | ~> 1.0.0 |
+    And I write to "Berksfile" with:
+      """
+      cookbook 'fake', '1.0.0'
+      cookbook 'ekaf', '2.0.0'
+      cookbook 'reset', '3.4.5'
+      """
+    And the Chef server does not have the cookbooks:
+      | fake  | 1.0.0 |
+      | ekaf  | 2.0.0 |
+      | reset | 3.4.5 |
+    When I successfully run `berks upload reset -D`
+    Then the output should contain:
+      """
+      Uploading reset (3.4.5) to: 'http://localhost:4000/'
+      Uploading fake (1.0.0) to: 'http://localhost:4000/'
+      """
+    And the Chef server should have the cookbooks:
+      | reset | 3.4.5 |
+      | fake  | 1.0.0 |
+    And the Chef server should not have the cookbooks:
+      | ekaf  | 2.0.0 |
+    And the exit status should be 0
+

data/lib/berkshelf.rb

@@ -14,9 +14,10 @@ require 'tmpdir'
 require 'uri'
 require 'zlib'
 
-require 'berkshelf/core_ext'
-require 'berkshelf/errors'
-require 'thor/monkies'
+require_relative 'berkshelf/core_ext'
+require_relative 'berkshelf/errors'
+require_relative 'berkshelf/mixin'
+require_relative 'berkshelf/thor_ext'
 
 JSON.create_id = nil
 
@@ -24,7 +25,6 @@ module Berkshelf
   DEFAULT_FILENAME = 'Berksfile'.freeze
 
   class << self
-    require 'berkshelf/mixin/logging'
     include Berkshelf::Mixin::Logging
 
     attr_accessor :ui
@@ -160,4 +160,4 @@ require_relative 'berkshelf/ui'
 require_relative 'berkshelf/version'
 
 Ridley.logger = Celluloid.logger = Berkshelf.logger = Logger.new(STDOUT)
-Berkshelf.logger.level = Logger::WARN
+Berkshelf.logger.level = Logger::WARN

data/lib/berkshelf/berksfile.rb

@@ -1,21 +1,16 @@
 module Berkshelf
   class Berksfile
-    require 'berkshelf/mixin/logging'
-    include Berkshelf::Mixin::Logging
-
-    extend Forwardable
-
     class << self
-      # @param [String] file
+      # @param [#to_s] file
       #   a path on disk to a Berksfile to instantiate from
       #
       # @return [Berksfile]
       def from_file(file)
-        content = File.read(file)
-        object = new(file)
-        object.load(content)
-      rescue Errno::ENOENT => e
+        new(file).dsl_eval_file(file)
+      rescue Errno::ENOENT => ex
         raise BerksfileNotFound, "No Berksfile or Berksfile.lock found at: #{file}"
+      rescue => ex
+        raise BerksfileReadError.new(ex)
       end
 
       # Copy all cached_cookbooks to the given directory. Each cookbook will be contained in
@@ -60,6 +55,16 @@ module Berkshelf
       end
     end
 
+    include Berkshelf::Mixin::Logging
+    include Berkshelf::Mixin::DSLEval
+    extend Forwardable
+
+    expose_method :metadata
+    expose_method :group
+    expose_method :site
+    expose_method :chef_api
+    expose_method :cookbook
+
     @@active_group = nil
 
     # @return [String]
@@ -549,7 +554,7 @@ module Berkshelf
       end
 
       if options[:skip_dependencies]
-        missing_cookbooks = options.fetch(:cookbooks, nil) - solution.map(&:cookbook_name)
+        missing_cookbooks = options.fetch(:cookbooks, nil) - cached_cookbooks.map(&:cookbook_name)
         unless missing_cookbooks.empty?
           msg = "Unable to upload cookbooks: #{missing_cookbooks.sort.join(', ')}\n"
           msg << "Specified cookbooks must be defined within the Berkshelf file when using the"
@@ -681,23 +686,6 @@ module Berkshelf
       { solution: resolver.resolve, sources: resolver.sources }
     end
 
-    # Reload this instance of Berksfile with the given content. The content
-    # is a string that may contain terms from the included DSL.
-    #
-    # @param [String] content
-    #
-    # @raise [BerksfileReadError] if Berksfile contains bad content
-    #
-    # @return [Berksfile]
-    def load(content)
-      begin
-        instance_eval(content)
-      rescue => e
-        raise BerksfileReadError.new(e)
-      end
-      self
-    end
-
     # Get the lockfile corresponding to this Berksfile. This is necessary because
     # the user can specify a different path to the Berksfile. So assuming the lockfile
     # is named "Berksfile.lock" is a poor assumption.

data/lib/berkshelf/cookbook_generator.rb

@@ -2,6 +2,14 @@ module Berkshelf
   class CookbookGenerator < BaseGenerator
     require_relative 'config'
 
+    LICENSES = [
+      "apachev2",
+      "gplv2",
+      "gplv3",
+      "mit",
+      "reserved"
+    ].freeze
+
     argument :name,
       type: :string,
       required: true
@@ -79,7 +87,7 @@ module Berkshelf
         when 'mit'; 'MIT'
         when 'reserved'; 'All rights reserved'
         else
-          raise Berkshelf::InternalError, "Unknown license: '#{options[:license]}'"
+          raise Berkshelf::LicenseNotFound.new(options[:license])
         end
       end
 
@@ -95,7 +103,7 @@ module Berkshelf
         when 'mit'; 'licenses/mit.erb'
         when 'reserved'; 'licenses/reserved.erb'
         else
-          raise Berkshelf::InternalError, "Unknown license: '#{options[:license]}'"
+          raise Berkshelf::LicenseNotFound.new(options[:license])
         end
       end
 

data/lib/berkshelf/errors.rb

@@ -185,7 +185,6 @@ module Berkshelf
 
   class ConfigExists < BerkshelfError; status_code(116); end
   class ConfigurationError < BerkshelfError; status_code(117); end
-  class CommandUnsuccessful < BerkshelfError; status_code(118); end
   class InsufficientPrivledges < BerkshelfError; status_code(119); end
   class ExplicitCookbookNotFound < BerkshelfError; status_code(120); end
   class ValidationFailed < BerkshelfError; status_code(121); end
@@ -340,10 +339,25 @@ module Berkshelf
     end
   end
 
+  class LicenseNotFound < BerkshelfError
+    status_code(134)
+
+    attr_reader :license
+
+    def initialize(license)
+      @license = license
+    end
+
+    def to_s
+      "Unknown license: '#{license}'\n" +
+      "Available licenses: #{Berkshelf::CookbookGenerator::LICENSES.join(', ')}"
+    end
+  end
+
   # Raised when a cookbook or its recipes contain a space or invalid
   # character in the path.
   class ConfigNotFound < BerkshelfError
-    status_code(133)
+    status_code(135)
 
     # @param [String] type
     #   the type of config that was not found (Berkshelf, Chef, etc)

data/lib/berkshelf/git.rb

@@ -2,9 +2,6 @@ require 'uri'
 
 module Berkshelf
   class Git
-    require 'berkshelf/mixin/shellout'
-    extend Berkshelf::Mixin::Shellout
-
     GIT_REGEXP = URI.regexp(%w(http https ssh git+ssh git rsync))
     SCP_REGEXP = /^(.+@)?[\w\d\.-]+:.*$/
 
@@ -12,6 +9,8 @@ module Berkshelf
     HAS_SPACE_RE = %r{\s}.freeze
 
     class << self
+      include Ridley::Mixin::ShellOut
+
       # @overload git(commands)
       #   Shellout to the Git executable on your system with the given commands.
       #
@@ -22,13 +21,13 @@ module Berkshelf
       def git(*command)
         command.unshift(git_cmd)
         command_str = command.map { |p| quote_cmd_arg(p) }.join(' ')
-        result = shellout(command_str)
+        response    = shell_out(command_str)
 
-        unless result.success?
-          raise GitError.new(result.stderr)
+        unless response.success?
+          raise GitError.new(response.stderr.strip)
         end
 
-        result.stdout
+        response.stdout.strip
       end
 
       # Clone a remote Git repository to disk

data/lib/berkshelf/mixin.rb

@@ -0,0 +1,7 @@
+module Berkshelf
+  module Mixin; end
+end
+
+Dir["#{File.dirname(__FILE__)}/mixin/*.rb"].sort.each do |path|
+  require_relative "mixin/#{File.basename(path, '.rb')}"
+end

data/lib/berkshelf/mixin/dsl_eval.rb

@@ -0,0 +1,58 @@
+module Berkshelf
+  module Mixin
+    module DSLEval
+      class CleanRoom
+        attr_reader :instance
+
+        def initialize(instance)
+          @instance = instance
+        end
+      end
+
+      class << self
+        def included(base)
+          base.send(:extend, ClassMethods)
+        end
+      end
+
+      module ClassMethods
+        def clean_room
+          @clean_room ||= begin
+            exposed_methods = self.exposed_methods
+
+            Class.new(DSLEval::CleanRoom) do
+              exposed_methods.each do |exposed_method|
+                define_method(exposed_method) do |*args, &block|
+                  instance.send(exposed_method, *args, &block)
+                end
+              end
+            end
+          end
+        end
+
+        def expose_method(method)
+          exposed_methods << method.to_sym
+        end
+
+        def exposed_methods
+          @exposed_methods ||= Array.new
+        end
+      end
+
+      # @return [Object]
+      def dsl_eval(&block)
+        self.class.clean_room.new(self).instance_eval(&block)
+        self
+      end
+
+      # @param [String] filepath
+      #
+      # @return [Object]
+      def dsl_eval_file(filepath)
+        filepath = filepath.to_s
+        contents = File.read(filepath)
+        dsl_eval { eval(contents, binding, filepath, 1) }
+      end
+    end
+  end
+end

data/lib/berkshelf/thor_ext.rb

@@ -0,0 +1,3 @@
+Dir["#{File.dirname(__FILE__)}/thor_ext/*.rb"].sort.each do |path|
+  require_relative "thor_ext/#{File.basename(path, '.rb')}"
+end

data/lib/berkshelf/version.rb

@@ -1,3 +1,3 @@
 module Berkshelf
-  VERSION = '2.0.1'
+  VERSION = "2.0.3"
 end

data/spec/unit/berkshelf/berksfile_spec.rb

@@ -2,10 +2,27 @@ require 'spec_helper'
 
 describe Berkshelf::Berksfile do
   describe '.from_file' do
-    let(:cookbook_file) { fixtures_path.join('lockfile_spec', 'with_lock', 'Berksfile') }
+    let(:content) do
+      <<-EOF.strip
+      cookbook 'ntp', '<= 1.0.0'
+      cookbook 'mysql'
+      cookbook 'nginx', '< 0.101.2'
+      cookbook 'ssh_known_hosts2', :git => 'https://github.com/erikh/chef-ssh_known_hosts2.git'
+      EOF
+    end
+    let(:berksfile) { tmp_path.join('Berksfile') }
 
-    it 'reads a Berksfile and returns an instance Berksfile' do
-      expect(Berkshelf::Berksfile.from_file(cookbook_file)).to be_a(Berkshelf::Berksfile)
+    before { File.open(berksfile, 'w+') { |f| f.write(content) } }
+    subject(:from_file) { described_class.from_file(berksfile) }
+
+    it "reads the content of the Berksfile and binds them to a new instance" do
+      %w(ntp mysql nginx ssh_known_hosts2).each do |name|
+        expect(subject).to have_source(name)
+      end
+    end
+
+    it "returns an instance of Berkshelf::Berksfile" do
+      expect(subject).to be_a(described_class)
     end
 
     context 'when Berksfile does not exist at given path' do
@@ -340,29 +357,6 @@ describe Berkshelf::Berksfile do
     end
   end
 
-  describe '#load' do
-    let(:content) do
-      <<-EOF.strip
-      cookbook 'ntp', '<= 1.0.0'
-      cookbook 'mysql'
-      cookbook 'nginx', '< 0.101.2'
-      cookbook 'ssh_known_hosts2', :git => 'https://github.com/erikh/chef-ssh_known_hosts2.git'
-      EOF
-    end
-
-    it 'reads the content of a Berksfile and adds the sources to the Shelf' do
-      subject.load(content)
-
-      %w(ntp mysql nginx ssh_known_hosts2).each do |name|
-        expect(subject).to have_source(name)
-      end
-    end
-
-    it 'returns an instance of Berksfile' do
-      expect(subject.load(content)).to be_a(Berkshelf::Berksfile)
-    end
-  end
-
   describe '#add_source' do
     let(:name) { 'cookbook_one' }
     let(:constraint) { '= 1.2.0' }

data/spec/unit/berkshelf/cookbook_generator_spec.rb

@@ -77,4 +77,14 @@ describe Berkshelf::CookbookGenerator do
       }
     end
   end
+
+  context "given an invalid option for :license" do
+    subject(:run) do
+      capture(:stdout) { described_class.new([target, name], license: 'not-there').invoke_all }
+    end
+
+    it "raises a LicenseNotFound error" do
+      expect { run }.to raise_error(Berkshelf::LicenseNotFound)
+    end
+  end
 end

data/spec/unit/berkshelf/mixin/dsl_eval_spec.rb

@@ -0,0 +1,55 @@
+require 'spec_helper'
+
+describe Berkshelf::Mixin::DSLEval do
+  let(:klass) do
+    klass = Class.new
+    klass.send(:include, described_class)
+    klass
+  end
+
+  describe "ClassMethods" do
+    describe "::clean_room" do
+      subject { klass.clean_room }
+
+      it "returns an anonymous class inheriting from DSLEval::CleanRoom" do
+        expect(subject.superclass).to eql(described_class::CleanRoom)
+      end
+    end
+
+    describe "::expose_method" do
+      subject { klass }
+
+      it "adds a method to the exposed methods" do
+        klass.expose_method(:something)
+        expect(subject.exposed_methods).to have(1).item
+      end
+    end
+
+    describe "::exposed_methods" do
+      it "returns an array" do
+        expect(klass.exposed_methods).to be_a(Array)
+      end
+    end
+  end
+
+  describe "#dsl_eval" do
+    subject do
+      klass.new.dsl_eval { }
+    end
+
+    it "returns an instance of the including class" do
+      expect(subject).to be_a(klass)
+    end
+  end
+
+  describe "#dsl_eval_file" do
+    let(:filepath) { tmp_path.join('somefile') }
+    before { FileUtils.touch(filepath) }
+
+    subject { klass.new.dsl_eval_file(filepath) }
+
+    it "returns an instance of the including class" do
+      expect(subject).to be_a(klass)
+    end
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: berkshelf
 version: !ruby/object:Gem::Version
-  version: 2.0.1
+  version: 2.0.3
   prerelease: 
 platform: ruby
 authors:
@@ -13,7 +13,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-06-07 00:00:00.000000000 Z
+date: 2013-06-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -150,7 +150,7 @@ dependencies:
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: 1.0.0
+        version: 1.0.2
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -158,7 +158,7 @@ dependencies:
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: 1.0.0
+        version: 1.0.2
 - !ruby/object:Gem::Dependency
   name: solve
   requirement: !ruby/object:Gem::Requirement
@@ -579,7 +579,6 @@ files:
 - lib/berkshelf/chef/cookbook.rb
 - lib/berkshelf/chef/cookbook/chefignore.rb
 - lib/berkshelf/cli.rb
-- lib/berkshelf/command.rb
 - lib/berkshelf/commands/shelf.rb
 - lib/berkshelf/commands/test_command.rb
 - lib/berkshelf/community_rest.rb
@@ -608,17 +607,18 @@ files:
 - lib/berkshelf/locations/site_location.rb
 - lib/berkshelf/lockfile.rb
 - lib/berkshelf/logger.rb
+- lib/berkshelf/mixin.rb
 - lib/berkshelf/mixin/config.rb
+- lib/berkshelf/mixin/dsl_eval.rb
 - lib/berkshelf/mixin/logging.rb
-- lib/berkshelf/mixin/shellout.rb
 - lib/berkshelf/resolver.rb
 - lib/berkshelf/test.rb
 - lib/berkshelf/thor.rb
+- lib/berkshelf/thor_ext.rb
+- lib/berkshelf/thor_ext/hash_with_indifferent_access.rb
+- lib/berkshelf/thor_ext/shell.rb
 - lib/berkshelf/ui.rb
 - lib/berkshelf/version.rb
-- lib/thor/monkies.rb
-- lib/thor/monkies/hash_with_indifferent_access.rb
-- lib/thor/monkies/shell.rb
 - spec/config/berkshelf.pem
 - spec/config/knife.rb
 - spec/config/validator.pem
@@ -693,6 +693,7 @@ files:
 - spec/unit/berkshelf/locations/site_location_spec.rb
 - spec/unit/berkshelf/lockfile_spec.rb
 - spec/unit/berkshelf/logger_spec.rb
+- spec/unit/berkshelf/mixin/dsl_eval_spec.rb
 - spec/unit/berkshelf/mixin/logging_spec.rb
 - spec/unit/berkshelf/resolver_spec.rb
 - spec/unit/berkshelf/ui_spec.rb
@@ -830,6 +831,7 @@ test_files:
 - spec/unit/berkshelf/locations/site_location_spec.rb
 - spec/unit/berkshelf/lockfile_spec.rb
 - spec/unit/berkshelf/logger_spec.rb
+- spec/unit/berkshelf/mixin/dsl_eval_spec.rb
 - spec/unit/berkshelf/mixin/logging_spec.rb
 - spec/unit/berkshelf/resolver_spec.rb
 - spec/unit/berkshelf/ui_spec.rb

data/lib/berkshelf/command.rb

@@ -1,116 +0,0 @@
-module Berkshelf
-  # This superclass is responsible for handling common command methods and options.
-  module Command
-    # Initialize a new instance of the parent class
-    #
-    # @param [Hash] options
-    #   the list of options to pass to the installer
-    def initialize(options = {})
-      @options = options
-    end
-
-    private
-
-      # Validate the options hash, ensuring there are no conflicting arguments
-      #
-      # @raise [Berkshelf::ArgumentError]
-      #   if there are conflicting or invalid options
-      def validate_options!
-        if options[:except] && options[:only]
-          raise Berkshelf::ArgumentError, 'Cannot specify both :except and :only'
-        end
-
-        if options[:cookbooks] && (options[:except] || options[:only])
-          Berkshelf.ui.warn ':cookbooks were supplied to update(), so :except and :only are ignored...'
-        end
-      end
-
-      # Ensure the berkshelf directory is created and accessible.
-      def ensure_berkshelf_directory!
-        unless File.exists?(Berkshelf.berkshelf_path)
-          FileUtils.mkdir_p(Berkshelf.berkshelf_path)
-        end
-      end
-
-      # Check for the presence of a Berksfile. Berkshelf cannot do anything
-      # without the presence of a Berksfile.lock.
-      def ensure_berksfile!
-        unless File.exists?(options[:berksfile])
-          raise Berkshelf::BerksfileNotFound, "No #{options[:berksfile]} was found at ."
-        end
-      end
-
-      # Check that the Berksfile has content. If the Berksfile is empty, raise
-      # an exception to require at least one definition.
-      def ensure_berksfile_content!
-        begin
-          unless File.read(options[:berksfile]).size > 1
-            raise Berkshelf::BerksfileNotFound, "Your #{options[:berksfile]} is empty! You need at least one cookbook definition."
-          end
-        rescue Errno::ENOENT
-          ensure_berksfile!
-        end
-      end
-
-      # @return [Hash]
-      #   the options for this installer
-      def options
-        @options ||= {}
-      end
-
-      # Attempt to load and parse the lockfile associated with this berksfile.
-      #
-      # @return [Berkshelf::Lockfile, nil]
-      #   the lockfile for the current berksfile
-      def lockfile
-        @lockfile ||= berksfile.lockfile
-      end
-
-      # Load the Berksfile for the current project.
-      #
-      # @raise [Berkshelf::BerksfileNotFound]
-      #   if the file is not found
-      #
-      # @return [Berkshelf::Berksfile]
-      #   the current Berksfile
-      def berksfile
-        @berksfile ||= Berkshelf::Berksfile.from_file(options[:berksfile])
-      end
-
-      # Filter the list of sources from the options passed to the installer.
-      #
-      # @param [Array<Berkshelf::CookbookSource>] sources
-      #   the list of sources to resolve
-      #
-      # @raise [Berkshelf::ArgumentError]
-      #   if a value for both :except and :only is provided
-      #
-      # @raise [Berkshelf::CookbookNotFound]
-      #   if a cookbook name is specified that does not exist
-      #
-      # @return [Array<Berkshelf::CookbookSource>]
-      def filter(sources)
-        cookbooks = Array(options[:cookbooks]).map(&:to_s)
-        except    = Array(options[:except]).map(&:to_sym)
-        only      = Array(options[:only]).map(&:to_sym)
-
-        case
-        when !cookbooks.empty?
-          missing_cookbooks = (cookbooks - sources.map(&:name))
-
-          unless missing_cookbooks.empty?
-            raise Berkshelf::CookbookNotFound, "Could not find cookbooks #{missing_cookbooks.collect{|cookbook| "'#{cookbook}'"}.join(', ')} in any of the sources. #{missing_cookbooks.size == 1 ? 'Is it' : 'Are they' } in your Berksfile?"
-          end
-
-          sources.select { |source| options[:cookbooks].include?(source.name) }
-        when !except.empty?
-          sources.select { |source| (except & source.groups).empty? }
-        when !only.empty?
-          sources.select { |source| !(only & source.groups).empty? }
-        else
-          sources
-        end
-      end
-
-  end
-end

data/lib/berkshelf/mixin/shellout.rb

@@ -1,71 +0,0 @@
-require 'hashie'
-
-module Berkshelf
-  module Mixin
-    module Shellout
-      # Perform a cross-platform shell command, returning the process result.
-      # This uses Process.spawn under the hood for Ruby 1.9, so see
-      # {Process.spawn} for more information.
-      #
-      # On JRuby, a system command is used and $stdout and $stderr are captured.
-      #
-      # @param [String] command
-      # @param [Hash] options
-      #   a list of options to send to {Process.spawn}
-      # @return [Hashie::Mash]
-      #   information about the command including:
-      #     - stderr
-      #     - stdout
-      #     - exitstatus
-      #     - pid
-      #     - success?
-      #     - failure?
-      def shellout(command)
-        if defined?(RUBY_PLATFORM) && RUBY_PLATFORM == 'java' # jruby
-          out, err, e = capture do
-            system(command)
-          end
-        else
-          begin
-            out_file, err_file = Tempfile.new('berkshelf.stdout'), Tempfile.new('berkshelf.stderr')
-            pid = Process.spawn({}, command, out: out_file.to_i, err: err_file.to_i)
-            Process.waitpid(pid)
-
-            out, err = File.read(out_file), File.read(err_file)
-            e = $?
-          rescue Errno::ENOENT
-            out, err = "", "command not found: #{command}"
-            e = $?
-          end
-        end
-
-        Hashie::Mash.new({
-          stdout:         out.strip,
-          stderr:         err.strip,
-          exitstatus:     e.exitstatus,
-          pid:            e.pid,
-          success?:       e.success?,
-          failure?:       !e.success?
-        })
-      end
-
-      private
-        # Execute the given block, capturing $stdout, $stderr, and the returned process.
-        #
-        # @return [Array<StringIO, StringIO, Process>]
-        #   a tuple of $stdout, $stderr, and the Process
-        def capture(&block)
-          out, err = StringIO.new, StringIO.new
-          $stdout, $stderr = out, err
-
-          yield
-
-          out.rewind
-          err.rewind
-          return out.read, err.read, $?
-        ensure
-          $stdout, $stderr = STDOUT, STDERR
-        end
-    end
-  end
-end

data/lib/thor/monkies.rb

@@ -1,3 +0,0 @@
-Dir["#{File.dirname(__FILE__)}/monkies/*.rb"].sort.each do |path|
-  require "thor/monkies/#{File.basename(path, '.rb')}"
-end