berkshelf 0.4.0 → 0.5.0.rc1

data/berkshelf.gemspec

@@ -16,10 +16,14 @@ Gem::Specification.new do |s|
   s.version               = Berkshelf::VERSION
   s.required_ruby_version = ">= 1.9.1"
 
-  s.add_runtime_dependency 'solve',           '~> 0.2.1'
-  s.add_runtime_dependency 'chef',            '~> 10.12.0'
+  s.add_runtime_dependency 'ridley',  '>= 0.0.3'
+  s.add_runtime_dependency 'solve',   '~> 0.2.1'
+  s.add_runtime_dependency 'chef',    '~> 10.12.0'
   s.add_runtime_dependency 'minitar'
-  s.add_runtime_dependency 'thor',            '~> 0.16.0'
+  s.add_runtime_dependency 'thor',    '~> 0.16.0'
+  s.add_runtime_dependency 'vagrant', '~> 1.0.3'
+  s.add_runtime_dependency 'activesupport'
+  s.add_runtime_dependency 'multi_json'
 
   s.add_development_dependency 'redcarpet'
   s.add_development_dependency 'cucumber'
@@ -38,4 +42,5 @@ Gem::Specification.new do |s|
   s.add_development_dependency 'guard-spork'
   s.add_development_dependency 'guard-yard'
   s.add_development_dependency 'coolline'
+  s.add_development_dependency 'rb-fsevent', '~> 0.9.1'
 end

data/bin/berks

@@ -5,6 +5,6 @@ require 'berkshelf'
 begin
   Berkshelf::Cli.start
 rescue Berkshelf::BerkshelfError => e
-  Berkshelf.ui.fatal e
+  Berkshelf.ui.error e
   exit e.status_code
 end

data/features/groups_install.feature

@@ -0,0 +1,67 @@
+Feature: installing groups
+  As a user
+  I want to be able specify groups of cookbooks to include or exclude
+  So I don't install cookbooks that are part of a group that I do not want to install
+
+  Scenario: except groups
+    Given I write to "Berksfile" with:
+      """
+      group :notme do
+        cookbook "nginx", "= 0.101.2"
+      end
+      
+      cookbook "artifact", "= 0.10.0"
+
+      group :takeme do
+        cookbook "ntp", "= 1.1.8"
+      end
+      """
+    When I run the install command with flags:
+      | --except notme |
+    Then the cookbook store should have the cookbooks:
+      | artifact | 0.10.0 |
+      | ntp      | 1.1.8 |
+    And the cookbook store should not have the cookbooks:
+      | nginx | 0.101.2 |
+
+  Scenario: only groups
+    Given I write to "Berksfile" with:
+      """
+      group :notme do
+        cookbook "nginx", "= 0.101.2"
+      end
+      
+      cookbook "artifact", "= 0.10.0"
+
+      group :takeme do
+        cookbook "ntp", "= 1.1.8"
+      end
+      """
+    When I run the install command with flags:
+      | --only takeme |
+    Then the cookbook store should have the cookbooks:
+      | ntp | 1.1.8 |
+    And the cookbook store should not have the cookbooks:
+      | nginx    | 0.101.2 |
+      | artifact | 0.10.0 |
+
+  Scenario: attempting to provide an only and except option
+    Given I write to "Berksfile" with:
+      """
+      group :notme do
+        cookbook "nginx", "= 0.101.2"
+      end
+      
+      cookbook "artifact", "= 0.10.0"
+
+      group :takeme do
+        cookbook "ntp", "= 1.1.8"
+      end
+      """
+    When I run the install command with flags:
+      | --only takeme --except notme |
+    Then the output should contain:
+      """
+      Cannot specify both :except and :only
+      """
+    And the CLI should exit with the status code for error "ArgumentError"

data/features/install.feature

@@ -65,21 +65,6 @@ Feature: install cookbooks from a Berksfile
       """
     And the exit status should be 0
 
-  @no_run
-  Scenario: installing a Berksfile that contains a path location which contains a broken symlink
-    Given a Berksfile with path location sources to fixtures:
-      | example_cookbook_broken_link | example_cookbook_broken_link |
-    When I run the install command with flags:
-      | --shims |
-    Then the following directories should exist:
-      | cookbooks                  |
-      | cookbooks/example_cookbook |
-    And the output should contain:
-      """
-      Shims written to: 
-      """
-    And the exit status should be 0
-
   Scenario: installing a Berksfile that contains a Git location
     Given I write to "Berksfile" with:
       """
@@ -146,61 +131,6 @@ Feature: install cookbooks from a Berksfile
       """
     And the CLI should exit with the status code for error "CookbookNotFound"
 
-  Scenario: running install command with the --shims flag to create a directory of shims
-    Given I write to "Berksfile" with:
-      """
-      cookbook "mysql", "1.2.4"
-      """
-    When I run the install command with flags:
-      | --shims |
-    Then the following directories should exist:
-      | cookbooks       |
-      | cookbooks/mysql |
-    And the output should contain:
-      """
-      Shims written to: 
-      """
-    And the exit status should be 0
-
-  Scenario: running install command with the --shims flag and a relative path
-    Given I write to "Berksfile" with:
-      """
-      cookbook "mysql", "1.2.4"
-      """
-    When I run the install command with flags:
-      | --shims relativepath |
-    Then the following directories should exist:
-      | relativepath       |
-      | relativepath/mysql |
-    And the output should contain:
-      """
-      Shims written to: 
-      """
-    And the exit status should be 0
-
-  Scenario: running install with --shims when current project is a cookbook and the 'metadata' is specified
-    Given a cookbook named "sparkle_motion"
-    And the cookbook "sparkle_motion" has the file "Berksfile" with:
-      """
-      metadata
-      """
-    When I cd to "sparkle_motion"
-    And I run the install command with flags:
-      | --shims |
-    Then the following directories should exist:
-      | cookbooks                |
-      | cookbooks/sparkle_motion |
-    And the output should contain:
-      """
-      Shims written to: 
-      """
-    And the output should contain:
-      """
-      Using sparkle_motion (0.0.0) at path:
-      """
-    And the exit status should be 0
-
-
   Scenario: installing a Berksfile that has a Git location source with an invalid Git URI
     Given I write to "Berksfile" with:
       """
@@ -267,7 +197,7 @@ Feature: install cookbooks from a Berksfile
   Scenario: with a cookbook definition containing a chef_api source location
     Given I write to "Berksfile" with:
       """
-      cookbook "artifact", chef_api: :knife
+      cookbook "artifact", "= 0.10.2", chef_api: :knife
       """
     And the Chef server has cookbooks:
       | artifact | 0.10.2 |

data/features/json_formatter.feature

@@ -43,20 +43,3 @@ Feature: --format json
     And the JSON should have "cookbooks/0/uploaded_to"
     And the Chef server should have the cookbooks:
       | example_cookbook | 0.5.0 |
-
-  Scenario: JSON output when running install command with the --shims flag
-    Given I write to "Berksfile" with:
-      """
-      cookbook "mysql", "1.2.4"
-      """
-    When I run the install command with flags:
-      | --shims |
-      | --format json|
-    Then the following directories should exist:
-      | cookbooks       |
-      | cookbooks/mysql |
-    And the output should be JSON
-    And the JSON should have "shims_dir"
-
-
-

data/features/step_definitions/filesystem_steps.rb

@@ -107,11 +107,9 @@ Then /^I should have a new cookbook skeleton "(.*?)" with Vagrant support$/ do |
       contains "gem 'vagrant'"
     end
     file "Vagrantfile" do
+      contains "require 'berkshelf/vagrant'"
       contains "recipe[#{name}::default]"
     end
-    directory "cookbooks" do
-      directory name
-    end
   }
 end
 

data/features/update.feature

@@ -6,17 +6,14 @@ Feature: update
   Scenario: knife berkshelf update
     Given I write to "Berksfile" with:
       """
-      cookbook "mysql", "1.3.0"
+      cookbook "artifact", "0.10.0"
       """
     Given I write to "Berksfile.lock" with:
       """
-      cookbook 'mysql', :locked_version => '0.0.1'
-      cookbook 'openssl', :locked_version => '0.0.1'
+      cookbook 'artifact', :locked_version => '0.0.1'
       """
     When I run the update command
     Then the file "Berksfile.lock" should contain exactly:
       """
-      cookbook 'mysql', :locked_version => '1.3.0'
-      cookbook 'openssl', :locked_version => '1.0.0'
-      cookbook 'build-essential', :locked_version => '1.1.0'
+      cookbook 'artifact', :locked_version => '0.10.0'
       """

data/features/vendor_install.feature

@@ -0,0 +1,20 @@
+Feature: install cookbooks to a given vendor path
+  As a user of Berkshelf
+  I want to be able to install cookbooks to a specific directory
+  So I vendor my cookbooks and package them with my application
+
+  Scenario: default
+    Given I write to "Berksfile" with:
+      """
+      site :opscode
+
+      cookbook "artifact", "0.10.0"
+      """
+    When I run the install command with flags:
+      | --path vendor/cookbooks |
+    Then the cookbook store should have the cookbooks:
+      | artifact | 0.10.0 |
+    Then the following directories should exist:
+      | vendor/cookbooks          |
+      | vendor/cookbooks/artifact |
+    And the exit status should be 0

data/generator_files/Vagrantfile.erb

@@ -1,8 +1,32 @@
+require 'berkshelf/vagrant'
+
 Vagrant::Config.run do |config|
   # All Vagrant configuration is done here. The most common configuration
   # options are documented and commented below. For a complete reference,
   # please see the online documentation at vagrantup.com.
 
+  # The path to the Berksfile to use with Vagrant Berkshelf
+  # config.berkshelf.berksfile_path = "./Berksfile"
+
+  # The path to the Knife config to use with Vagrant Berkshelf
+  # config.berkshelf.config_path = "~/.chef/knife.rb"
+
+  # A client name (node_name) to use with the Chef Client provisioner to upload
+  # cookbooks installed by Berkshelf.
+  # config.berkshelf.node_name = "reset"
+
+  # A path to a client key on disk to use with the Chef Client provisioner to
+  # upload cookbooks installed by Berkshelf.
+  # config.berkshelf.client_key = "~/.chef/reset.pem"
+
+  # An array of symbols representing groups of cookbook described in the Vagrantfile
+  # to skip installing and copying to Vagrant's shelf.
+  # config.berkshelf.only = []
+
+  # An array of symbols representing groups of cookbook described in the Vagrantfile
+  # to skip installing and copying to Vagrant's shelf.
+  # config.berkshelf.except = []
+
   config.vm.host_name = "<%= cookbook_name %>-berkshelf"
 
   # CentOS 6.3
@@ -35,9 +59,7 @@ Vagrant::Config.run do |config|
   config.ssh.max_tries = 40
   config.ssh.timeout   = 120
 
-  config.vm.provision :chef_solo do |chef|
-    chef.cookbooks_path = ["cookbooks"]
-    
+  config.vm.provision :chef_solo do |chef|    
     chef.json = {
       :mysql => {
         :server_root_password => 'rootpass',

data/lib/berkshelf.rb

@@ -1,14 +1,16 @@
 require 'forwardable'
 require 'uri'
 require 'pathname'
+require 'tmpdir'
 require 'zlib'
 require 'archive/tar/minitar'
 require 'solve'
+require 'ridley'
 require 'chef/knife'
-require 'chef/rest'
 require 'chef/platform'
 require 'chef/cookbook/metadata'
 require 'chef/cookbook_version'
+require 'active_support/core_ext'
 
 require 'berkshelf/version'
 require 'berkshelf/core_ext'
@@ -21,6 +23,7 @@ module Berkshelf
   DEFAULT_STORE_PATH = File.expand_path("~/.berkshelf").freeze
   DEFAULT_FILENAME = 'Berksfile'.freeze
 
+  autoload :UI, 'berkshelf/ui'
   autoload :Cli, 'berkshelf/cli'
   autoload :Git, 'berkshelf/git'
   autoload :Berksfile, 'berkshelf/berksfile'
@@ -43,12 +46,14 @@ module Berkshelf
     attr_writer :config_path
     attr_writer :cookbook_store
 
+    # @return [Pathname]
     def root
       @root ||= Pathname.new(File.expand_path('../', File.dirname(__FILE__)))
     end
 
+    # @return [Berkshelf::UI]
     def ui
-      @ui ||= Chef::Knife::UI.new(null_stream, null_stream, STDIN, {})
+      @ui ||= Berkshelf::UI.new
     end
 
     # Returns the filepath to the location Berskhelf will use for
@@ -62,18 +67,30 @@ module Berkshelf
       ENV["BERKSHELF_PATH"] || DEFAULT_STORE_PATH
     end
 
+    # @return [String]
     def tmp_dir
       File.join(berkshelf_path, "tmp")
     end
 
+    # Creates a temporary directory within the Berkshelf path
+    #
+    # @return [String]
+    #   path to the created temporary directory
+    def mktmpdir
+      FileUtils.mkdir_p(File.join(berkshelf_path, "tmp"))
+      Dir.mktmpdir(nil, File.join(berkshelf_path, "tmp"))
+    end
+
     def cookbooks_dir
       File.join(berkshelf_path, "cookbooks")
     end
 
+    # @return [Berkshelf::CookbookStore]
     def cookbook_store
       @cookbook_store ||= CookbookStore.new(cookbooks_dir)
     end
 
+    # @return [String]
     def config_path
       @config_path ||= DEFAULT_CONFIG
     end
@@ -108,26 +125,19 @@ module Berkshelf
     #
     # @return [~Formatter]
     def formatter
-      @formatter ||= (formatters.has_key?(@_format) ? formatters[@_format] : Formatters::HumanReadable).new
+      @formatter ||= Formatters::HumanReadable.new
     end
 
-    # Specify a formatter identifier
+    # Specify the format for output
     #
-    # @param [String] format
-    #   which formatter to use
+    # @param [#to_sym] format_id
+    #   the ID of the registered formatter to use
     #
-    # @example Berkshelf.set_format "json"
-    def set_format(format)
-      @_format = format
-      @formatter = nil
-    end
-
-    # Access the formatters map that links string symbols to Formatter
-    # implementations
+    # @example Berkshelf.set_format :json
     #
-    # @return [Hash]
-    def formatters
-      @formatters ||= {}
+    # @return [~Formatter]
+    def set_format(format_id)
+      @formatter = Formatters[format_id].new
     end
 
     private

data/lib/berkshelf/base_generator.rb

@@ -11,6 +11,11 @@ module Berkshelf
     
     include Thor::Actions
 
+    def initialize(*args)
+      super(*args)
+      self.shell = Berkshelf.ui
+    end
+
     private
 
       def target

data/lib/berkshelf/berksfile.rb

@@ -16,19 +16,29 @@ module Berkshelf
         raise BerksfileNotFound, "No Berksfile or Berksfile.lock found at: #{file}"
       end
 
-      # @param [Array] sources
-      #   an array of sources to filter
-      # @param [Array, Symbol] excluded
-      #   an array of symbols or a symbol representing the group or group(s)
-      #   to exclude
+      # Copy all cached_cookbooks to the given directory. Each cookbook will be contained in
+      # a directory named after the name of the cookbook.
       #
-      # @return [Array<Berkshelf::CookbookSource>]
-      #   an array of sources that are not members of the excluded group(s)
-      def filter_sources(sources, excluded)
-        excluded = Array(excluded)
-        excluded.collect!(&:to_sym)
+      # @param [Array<CachedCookbook>] cookbooks
+      #   an array of CachedCookbooks to be copied to a vendor directory
+      # @param [String] path
+      #   filepath to vendor cookbooks to
+      #
+      # @return [String]
+      #   expanded filepath to the vendor directory
+      def vendor(cookbooks, path)
+        path = File.expand_path(path)
+        FileUtils.mkdir_p(path)
+        
+        scratch = Berkshelf.mktmpdir
+        cookbooks.each do |cb|
+          FileUtils.cp_r(cb.path, File.join(scratch, cb.cookbook_name))
+        end
 
-        sources.select { |source| (excluded & source.groups).empty? }
+        FileUtils.remove_dir(path, force: true)
+        File.rename(scratch, path)
+
+        path
       end
     end
 
@@ -41,6 +51,9 @@ module Berkshelf
     # @return [Berkshelf::Downloader]
     attr_reader :downloader
 
+    # @return [Array<Berkshelf::CachedCookbook>]
+    attr_reader :cached_cookbooks
+
     def_delegator :downloader, :add_location
     def_delegator :downloader, :locations
 
@@ -48,6 +61,7 @@ module Berkshelf
       @filepath = path
       @sources = Hash.new
       @downloader = Downloader.new(Berkshelf.cookbook_store)
+      @cached_cookbooks = nil
     end
 
     # Add a cookbook source to the Berksfile to be retrieved and have it's dependencies recurisvely retrieved
@@ -130,7 +144,6 @@ module Berkshelf
       add_source(name, constraint, options)
     end
 
-
     def group(*args)
       @@active_group = args
       yield
@@ -245,16 +258,29 @@ module Berkshelf
       @sources.has_key?(source.to_s)
     end
 
-    # @option options [Symbol, Array] :exclude 
+    # @option options [Symbol, Array] :except 
     #   Group(s) to exclude to exclude from the returned Array of sources
     #   group to not be installed
+    # @option options [Symbol, Array] :only
+    #   Group(s) to include which will cause any sources marked as a member of the
+    #   group to be installed and all others to be ignored
+    #
+    # @raise [Berkshelf::ArgumentError] if a value for both :except and :only is provided
     #
     # @return [Array<Berkshelf::CookbookSource>]
     def sources(options = {})
       l_sources = @sources.collect { |name, source| source }.flatten
 
-      if options[:exclude]
-        self.class.filter_sources(l_sources, options[:exclude])
+      except = Array(options.fetch(:except, nil)).collect(&:to_sym)
+      only   = Array(options.fetch(:only, nil)).collect(&:to_sym)
+
+      case
+      when !except.empty? && !only.empty?
+        raise Berkshelf::ArgumentError, "Cannot specify both :except and :only"
+      when !except.empty?
+        l_sources.select { |source| (except & source.groups).empty? }
+      when !only.empty?
+        l_sources.select { |source| !(only & source.groups).empty? }
       else
         l_sources
       end
@@ -294,101 +320,80 @@ module Berkshelf
     end
     alias_method :get_source, :[]
 
-    # @option options [Symbol, Array] :without 
+    # @option options [Symbol, Array] :except 
     #   Group(s) to exclude which will cause any sources marked as a member of the 
     #   group to not be installed
-    # @option options [String, Pathname] :shims
-    #   Path to a directory of shims each pointing to a Cookbook Version that is
-    #   part of the dependency solution. Each shim is a hard link on disk.
+    # @option options [Symbol, Array] :only
+    #   Group(s) to include which will cause any sources marked as a member of the
+    #   group to be installed and all others to be ignored
+    # @option options [String] :path
+    #   a path to "vendor" the cached_cookbooks resolved by the resolver. Vendoring
+    #   is a technique for packaging all cookbooks resolved by a Berksfile.
+    #
+    # @return [Array<Berkshelf::CachedCookbook>]
     def install(options = {})
       resolver = Resolver.new(
         self.downloader,
-        sources: sources(exclude: options[:without])
+        sources: sources(options)
       )
 
-      solution = resolver.resolve
-      if options[:shims]
-        write_shims(options[:shims], solution)
-        Berkshelf.formatter.shims_written options[:shims]
-      end
+      @cached_cookbooks = resolver.resolve
       write_lockfile(resolver.sources) unless lockfile_present?
+
+      if options[:path]
+        self.class.vendor(@cached_cookbooks, options[:path])
+      end
+
+      self.cached_cookbooks
     end
 
-    # @param [String] chef_server_url
-    #   the full URL to the Chef Server to upload to
-    #
-    #     "https://api.opscode.com/organizations/vialstudios"
-    #
-    # @option options [Symbol, Array] :without 
-    #   Group(s) to exclude which will cause any sources marked as a member of the 
-    #   group to not be installed
-    # @option options [String] :node_name
-    #   the name of the client used to sign REST requests to the Chef Server
+    # @option options [String] :server_url
+    #   URL to the Chef API
+    # @option options [String] :client_name
+    #   name of the client used to authenticate with the Chef API
     # @option options [String] :client_key
-    #   the filepath location for the client's key used to sign REST requests
-    #   to the Chef Server
+    #   filepath to the client's private key used to authenticate with
+    #   the Chef API
+    # @option options [String] :organization
+    #   the Organization to connect to. This is only used if you are connecting to
+    #   private Chef or hosted Chef
     # @option options [Boolean] :force Upload the Cookbook even if the version 
     #   already exists and is frozen on the target Chef Server
     # @option options [Boolean] :freeze Freeze the uploaded Cookbook on the Chef 
     #   Server so that it cannot be overwritten
-    def upload(chef_server_url, options = {})
-      uploader = Uploader.new(chef_server_url, options)
+    # @option options [Symbol, Array] :except 
+    #   Group(s) to exclude which will cause any sources marked as a member of the 
+    #   group to not be installed
+    # @option options [Symbol, Array] :only
+    #   Group(s) to include which will cause any sources marked as a member of the
+    #   group to be installed and all others to be ignored
+    def upload(options = {})
+      uploader = Uploader.new(options)
       solution = resolve(options)
 
       solution.each do |cb|
-        Berkshelf.formatter.upload cb.cookbook_name, cb.version, chef_server_url
+        Berkshelf.formatter.upload cb.cookbook_name, cb.version, options[:server_url]
         uploader.upload(cb, options)
       end
     end
 
     # Finds a solution for the Berksfile and returns an array of CachedCookbooks.
     #
-    # @option options [Symbol, Array] :without 
+    # @option options [Symbol, Array] :except 
     #   Group(s) to exclude which will cause any sources marked as a member of the 
-    #   group to not be resolved
+    #   group to not be installed
+    # @option options [Symbol, Array] :only
+    #   Group(s) to include which will cause any sources marked as a member of the
+    #   group to be installed and all others to be ignored
     #
     # @return [Array<Berkshelf::CachedCookbooks]
     def resolve(options = {})
       Resolver.new(
         self.downloader,
-        sources: sources(exclude: options[:without])
+        sources: sources(options)
       ).resolve
     end
 
-    # Write a collection of hard links to the given path representing the given
-    # CachedCookbooks. Useful for getting Cookbooks in a single location for 
-    # consumption by Vagrant, or another tool that expect this structure.
-    #
-    # @example 
-    #   Given the path: '/Users/reset/code/pvpnet/cookbooks'
-    #   And a CachedCookbook: 'nginx' verison '0.100.5' at '/Users/reset/.berkshelf/nginx-0.100.5'
-    #
-    #   A hardlink will be created at: '/Users/reset/code/pvpnet/cookbooks/nginx'
-    #
-    # @param [Pathname, String] path
-    # @param [Array<Berkshelf::CachedCookbook>] cached_cookbooks
-    def write_shims(path, cached_cookbooks)
-      path        = File.expand_path(path)
-      actual_path = nil
-
-      if descendant_directory?(path, Dir.pwd)
-        actual_path = path
-        FileUtils.rm_rf(actual_path)
-        path = File.join(Berkshelf.tmp_dir, "shims")
-      end
-
-      FileUtils.mkdir_p(path)
-      cached_cookbooks.each do |cached_cookbook|
-        destination = File.expand_path(File.join(path, cached_cookbook.cookbook_name))
-        FileUtils.rm_rf(destination)
-        FileUtils.ln_r(cached_cookbook.path, destination, force: true)
-      end
-
-      if actual_path
-        FileUtils.mv(path, actual_path)
-      end
-    end
-
     # Reload this instance of Berksfile with the given content. The content
     # is a string that may contain terms from the included DSL.
     #