berkshelf 0.4.0 → 0.5.0.rc1

data/lib/berkshelf/vagrant/action/clean.rb

@@ -0,0 +1,24 @@
+module Berkshelf
+  module Vagrant
+    module Action
+      # @author Jamie Winsor <jamie@vialstudios.com>
+      class Clean
+        attr_reader :shelf
+
+        def initialize(app, env)
+          @app = app
+          @shelf = Berkshelf::Vagrant.shelf_for(env)
+        end
+
+        def call(env)
+          if Berkshelf::Vagrant.chef_solo?(env[:global_config])
+            Berkshelf.formatter.msg "cleaning Vagrant's shelf"
+            FileUtils.remove_dir(self.shelf, fore: true)
+          end
+
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

data/lib/berkshelf/vagrant/action/install.rb

@@ -0,0 +1,47 @@
+module Berkshelf
+  module Vagrant
+    module Action
+      # @author Jamie Winsor <jamie@vialstudios.com>
+      # @author Andrew Garson <andrew.garson@gmail.com>
+      class Install
+        attr_reader :config
+        attr_reader :shelf
+        attr_reader :berksfile
+
+        def initialize(app, env)
+          @app                  = app
+          @shelf                = Berkshelf::Vagrant.shelf_for(env)
+          @config               = env[:global_config].berkshelf
+          Berkshelf.config_path = @config.config_path
+          Berkshelf.load_config
+          @berksfile            = Berksfile.from_file(@config.berksfile_path)
+        end
+
+        def call(env)
+          if Berkshelf::Vagrant.chef_solo?(env[:global_config])
+            configure_cookbooks_path(env)
+            install(env)
+          end
+
+          @app.call(env)
+        end
+
+        private
+
+          def install(env)
+            Berkshelf.formatter.msg "installing cookbooks..."
+            opts = {
+              path: self.shelf
+            }.merge(self.config.to_hash).symbolize_keys!
+            berksfile.install(opts)
+          end
+
+          def configure_cookbooks_path(env)
+            Berkshelf::Vagrant.provisioners(:chef_solo, env[:global_config]).each do |provisioner|
+              provisioner.config.cookbooks_path.unshift(self.shelf)
+            end
+          end
+      end
+    end
+  end
+end

data/lib/berkshelf/vagrant/action/set_ui.rb

@@ -0,0 +1,17 @@
+module Berkshelf
+  module Vagrant
+    module Action
+      # @author Jamie Winsor <jamie@vialstudios.com>
+      class SetUI
+        def initialize(app, env)
+          @app = app
+        end
+
+        def call(env)
+          Berkshelf.ui = ::Vagrant::UI::Colored.new("Berkshelf")
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

data/lib/berkshelf/vagrant/action/upload.rb

@@ -0,0 +1,40 @@
+module Berkshelf
+  module Vagrant
+    module Action
+      # @author Jamie Winsor <jamie@vialstudios.com>
+      class Upload
+        attr_reader :berksfile
+        attr_reader :node_name
+        attr_reader :client_key
+
+        def initialize(app, env)
+          @app = app
+          @node_name  = env[:global_config].berkshelf.node_name
+          @client_key = env[:global_config].berkshelf.client_key
+          @berksfile  = Berksfile.from_file(env[:global_config].berkshelf.berksfile_path)
+        end
+
+        def call(env)
+          if Berkshelf::Vagrant.chef_client?(env[:global_config])
+            upload(env)
+          end
+
+          @app.call(env)
+        end
+
+        private
+
+          def upload(env)
+            Berkshelf::Vagrant.provisioners(:chef_client, env[:global_config]).each do |provisioner|
+              Berkshelf.formatter.msg "uploading cookbooks to '#{provisioner.config.chef_server_url}'"
+              berksfile.upload(
+                provisioner.config.chef_server_url,
+                node_name: self.node_name,
+                client_key: self.client_key
+              )
+            end
+          end
+      end
+    end
+  end
+end

data/lib/berkshelf/vagrant/config.rb

@@ -0,0 +1,70 @@
+module Berkshelf
+  module Vagrant
+    # @author Jamie Winsor <jamie@vialstudios.com>
+    # @author Andrew Garson <andrew.garson@gmail.com>
+    class Config < ::Vagrant::Config::Base
+      # return [String]
+      #   path to a knife configuration file
+      attr_reader :config_path
+
+      # @return [String]
+      #   path to the Berksfile to use with Vagrant
+      attr_reader :berksfile_path
+
+      # @return [String]
+      #   A path to a client key on disk to use with the Chef Client provisioner to
+      #   upload cookbooks installed by Berkshelf.
+      attr_reader :client_key
+
+      # @return [String]
+      #   A client name (node_name) to use with the Chef Client provisioner to upload
+      #   cookbooks installed by Berkshelf.
+      attr_accessor :node_name
+
+      # @return [Array<Symbol>]
+      #   cookbooks in all other groups except for these will be installed
+      #   and copied to Vagrant's shelf
+      attr_accessor :except
+
+      # @return [Array<Symbol>]
+      #   only cookbooks in these groups will be installed and copied to
+      #   Vagrant's shelf
+      attr_accessor :only
+
+      def initialize
+        @config_path = Berkshelf::DEFAULT_CONFIG
+        @berksfile_path = File.join(Dir.pwd, Berkshelf::DEFAULT_FILENAME)
+        @only = Array.new
+        @except = Array.new
+      end
+
+      def config_path=(value)
+        @config_path = File.expand_path(value)
+      end
+
+      def berksfile_path=(value)
+        @berksfile_path = File.expand_path(value)
+      end
+
+      def client_key=(value)
+        @client_key = File.expand_path(value)
+      end
+
+      def validate(env, errors)
+        if !except.empty? && !only.empty?
+          errors.add("A value for berkshelf.empty and berkshelf.only cannot both be defined.")
+        end
+
+        if Berkshelf::Vagrant.chef_client?(env.config.global)
+          if node_name.nil?
+            errors.add("A value for berkshelf.node_name is required when using the chef_client provisioner.")
+          end
+
+          if client_key.nil?
+            errors.add("A value for berkshelf.client_key is required when using the chef_client provisioner.")
+          end
+        end
+      end
+    end
+  end
+end

data/lib/berkshelf/vagrant/middleware.rb

@@ -0,0 +1,52 @@
+module Berkshelf
+  module Vagrant
+    # @author Jamie Winsor <jamie@vialstudios.com>
+    #
+    # Middleware stacks for use with Vagrant
+    module Middleware
+      class << self
+        # Return the Berkshelf install middleware stack. When placed in the action chain
+        # this stack will find retrieve and resolve the cookbook dependencies describe
+        # in your configured Berksfile.
+        #
+        # Cookbooks will installed into a temporary directory, called a Shelf, and mounted
+        # into the VM. This mounted path will be appended to the chef_solo.cookbooks_path value.
+        #
+        # @return [::Vagrant::Action::Builder]
+        def install
+          @install ||= ::Vagrant::Action::Builder.new do
+            use Berkshelf::Vagrant::Action::SetUI
+            use Berkshelf::Vagrant::Action::Install
+          end
+        end
+
+        # Return the Berkshelf upload middleware stack. When placed in the action chain
+        # this stack will upload cookbooks to a Chef Server if the Chef-Client provisioner
+        # is used. The Chef Server where the cookbooks will be uploaded to is the same Chef
+        # Server used in the Chef-Client provisioner.
+        #
+        # Nothing will be done if the Chef-Solo provisioner is used.
+        #
+        # @return [::Vagrant::Action::Builder]
+        def upload
+          @upload ||= ::Vagrant::Action::Builder.new do
+            use Berkshelf::Vagrant::Action::SetUI
+            use Berkshelf::Vagrant::Action::Upload
+          end
+        end
+
+        # Return the Berkshelf clean middleware stack. When placed in the action chain
+        # this stack will clean up any temporary directories or files created by the other
+        # middleware stacks.
+        #
+        # @return [::Vagrant::Action::Builder]
+        def clean
+          @clean ||= ::Vagrant::Action::Builder.new do
+            use Berkshelf::Vagrant::Action::SetUI
+            use Berkshelf::Vagrant::Action::Clean
+          end
+        end
+      end      
+    end
+  end
+end

data/lib/berkshelf/version.rb

@@ -1,3 +1,3 @@
 module Berkshelf
-  VERSION = "0.4.0"
+  VERSION = "0.5.0.rc1"
 end

data/lib/thor/monkies.rb

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

data/lib/thor/monkies/hash_with_indifferent_access.rb

@@ -0,0 +1,13 @@
+class Thor
+  module CoreExt #:nodoc:
+    class HashWithIndifferentAccess < ::Hash
+      def has_key?(key)
+        super(convert_key(key))
+      end
+
+      def fetch(key, default = nil)
+        super(convert_key(key), default)
+      end
+    end
+  end
+end

data/lib/vagrant_init.rb

@@ -0,0 +1,2 @@
+# This file is automatically loaded by Vagrant
+require 'berkshelf/vagrant'

data/spec/spec_helper.rb

@@ -46,6 +46,11 @@ Spork.prefork do
     config.before(:each) do
       clean_tmp_path
       Berkshelf.cookbook_store = Berkshelf::CookbookStore.new(tmp_path.join("downloader_tmp"))
+      Berkshelf.ui.mute!
+    end
+
+    config.after(:each) do
+      Berkshelf.ui.unmute!
     end
   end
 

data/spec/support/chef_api.rb

@@ -100,7 +100,12 @@ EOF
         end
 
         def uploader
-          @uploader ||= Berkshelf::Uploader.new(Chef::Config[:chef_server_url])
+          @uploader ||= Berkshelf::Uploader.new(
+            server_url: Chef::Config[:chef_server_url],
+            client_name: Chef::Config[:node_name],
+            client_key: Chef::Config[:client_key],
+            organization: Berkshelf::ChefAPILocation.extract_organization(Chef::Config[:chef_server_url])
+          )
         end
     end
   end

data/spec/unit/berkshelf/berksfile_spec.rb

@@ -14,7 +14,7 @@ EOF
     describe "ClassMethods" do
       subject { Berksfile }
 
-      describe "#from_file" do
+      describe "::from_file" do
         let(:cookbook_file) { fixtures_path.join('lockfile_spec', 'with_lock', 'Berksfile') }
 
         it "reads a Berksfile and returns an instance Berksfile" do
@@ -32,29 +32,12 @@ EOF
         end
       end
 
-      describe "#filter_sources" do
-        context "given one of the sources is a member of one of the excluded groups" do
-          let(:excluded_groups) { [:nautilus, :skarner] }
-          let(:source_one) { double('source_one') }
-          let(:source_two) { double('source_two') }
-
-          before(:each) do
-            source_one.stub(:groups) { [:nautilus] }
-            source_two.stub(:groups) { [:riven] }
-            @sources = [source_one, source_two]
-          end
-
-          it "returns an array without sources that were members of the excluded groups" do
-            result = subject.filter_sources(@sources, excluded_groups)
-
-            result.should_not include(source_one)
-          end
-
-          it "does not remove sources that were not a member of the excluded groups" do
-            result = subject.filter_sources(@sources, excluded_groups)
-
-            result.should include(source_two)
-          end
+      describe "::vendor" do
+        it "returns the expanded filepath of the vendor directory" do
+          cached_cookbooks = Array.new
+          tmpdir = Dir.mktmpdir(nil, tmp_path)
+          
+          subject.vendor(cached_cookbooks, tmpdir).should eql(tmpdir)
         end
       end
     end
@@ -174,6 +157,13 @@ EOF
     end
 
     describe "#sources" do
+      let(:groups) do
+        [
+          :nautilus,
+          :skarner
+        ]
+      end
+
       it "returns all CookbookSources added to the instance of Berksfile" do
         subject.add_source(source_one.name)
         subject.add_source(source_two.name)
@@ -183,11 +173,43 @@ EOF
         subject.should have_source(source_two.name)
       end
 
-      context "given the option :exclude" do
-        it "filters the sources before returning them" do
-          subject.class.should_receive(:filter_sources).with(subject.sources, :nautilus)
+      context "given the option :except" do
+        before(:each) do
+          source_one.stub(:groups) { [:default, :skarner] }
+          source_two.stub(:groups) { [:default, :nautilus] }
+        end
+
+        it "returns all of the sources except the ones in the given groups" do
+          subject.add_source(source_one.name, nil, group: [:default, :skarner])
+          subject.add_source(source_two.name, nil, group: [:default, :nautilus])
+          filtered = subject.sources(except: :nautilus)
+
+          filtered.should have(1).item
+          filtered.first.name.should eql(source_one.name)
+        end
+      end
+
+      context "given the option :only" do
+        before(:each) do
+          source_one.stub(:groups) { [:default, :skarner] }
+          source_two.stub(:groups) { [:default, :nautilus] }
+        end
+
+        it "returns only the sources in the givne groups" do
+          subject.add_source(source_one.name, nil, group: [:default, :skarner])
+          subject.add_source(source_two.name, nil, group: [:default, :nautilus])
+          filtered = subject.sources(only: :nautilus)
 
-          subject.sources(exclude: :nautilus)
+          filtered.should have(1).item
+          filtered.first.name.should eql(source_two.name)
+        end
+      end
+
+      context "when a value for :only and :except is given" do
+        it "raises an ArgumentError" do
+          lambda {
+            subject.sources(only: [:default], except: [:other])
+          }.should raise_error(Berkshelf::ArgumentError, "Cannot specify both :except and :only")
         end
       end
     end
@@ -233,6 +255,26 @@ EOF
           resolver.should_receive(:sources).and_return([])
         end
 
+        let(:cached_cookbooks) do
+          [
+            double('cached_one'),
+            double('cached_two')
+          ]
+        end
+
+        it "returns the result from sending the message resolve to resolver" do
+          resolver.should_receive(:resolve).and_return(cached_cookbooks)
+
+          subject.install.should eql(cached_cookbooks)
+        end
+
+        it "sets a value for self.cached_cookbooks equivalent to the return value" do
+          resolver.should_receive(:resolve).and_return(cached_cookbooks)
+          subject.install
+
+          subject.cached_cookbooks.should eql(cached_cookbooks)
+        end
+
         it "creates a new resolver and finds a solution by calling resolve on the resolver" do
           resolver.should_receive(:resolve)
 
@@ -258,42 +300,38 @@ EOF
         end
       end
 
-      context "when given a value for :shims pointing to a valid path"do
-        let(:cached_one) { double('cached_one', cookbook_name: 'nginx', path: fixtures_path.join("cookbooks", "nginx-0.100.5")) }
-        let(:cached_two) { double('cached_two', cookbook_name: 'example_cookbook', path: fixtures_path.join("cookbooks", "example_cookbook-0.5.0")) }
-        let(:shims_path) { tmp_path.join("cookbook_shims") }
+      context "when a value for :path is given" do
+        before(:each) { resolver.should_receive(:resolve) }
 
-        before(:each) do
-          resolver.stub(:resolve).and_return([cached_one, cached_two])
-        end
+        it "sends the message 'vendor' to Berksfile with the value for :path" do
+          path = double('path')
+          subject.class.should_receive(:vendor).with(subject.cached_cookbooks, path)
 
-        it "sends a message to write_shims with the given directory and the resolver's solution" do
-          subject.should_receive(:write_shims).with(shims_path, [cached_one, cached_two])
-          subject.install(shims: shims_path)
+          subject.install(path: path)
         end
       end
-    end
 
-    describe "#write_shims" do
-      let(:cached_one) { double('cached_one', cookbook_name: 'nginx', path: fixtures_path.join("cookbooks", "nginx-0.100.5")) }
-      let(:cached_two) { double('cached_two', cookbook_name: 'example_cookbook', path: fixtures_path.join("cookbooks", "example_cookbook-0.5.0")) }
-      let(:shims_path) { tmp_path.join("cookbook_shims") }
+      context "when a value for :except is given" do
+        before(:each) { resolver.should_receive(:resolve) }
 
-      before(:each) { subject.write_shims(shims_path, [cached_one, cached_two]) }
+        it "filters the sources and gives the results to the Resolver initializer" do
+          filtered = double('sources')
+          subject.should_receive(:sources).with(except: [:skip_me]).and_return(filtered)
+          Resolver.should_receive(:new).with(anything, sources: filtered)
 
-      it "writes a directory at the given path" do
-        shims_path.should exist
-        shims_path.should be_directory
+          subject.install(except: [:skip_me])
+        end
       end
 
-      it "writes a symlink of the name of each source within the given directory" do
-        linked_path_one = shims_path.join(cached_one.cookbook_name)
-        linked_path_two = shims_path.join(cached_two.cookbook_name)
-        
-        linked_path_one.should exist
-        linked_path_one.should be_cookbook
-        linked_path_two.should exist
-        linked_path_two.should be_cookbook
+      context "when a value for :only is given" do
+        before(:each) { resolver.should_receive(:resolve) }
+
+        it "filters the sources and gives the results to the Resolver initializer" do
+          filtered = double('sources')
+          subject.should_receive(:sources).with(only: [:skip_me]).and_return(filtered)
+
+          subject.install(only: [:skip_me])
+        end
       end
     end