berkshelf 3.0.0.beta1 → 3.0.0.beta2

data/lib/berkshelf/chef.rb

@@ -2,7 +2,6 @@ module Berkshelf
   # Classes and modules used for integrating with a Chef Server, the Chef community
   # site, and Chef Cookbooks
   module Chef
-    require_relative 'chef/config'
     require_relative 'chef/cookbook'
   end
 end

data/lib/berkshelf/cli.rb

@@ -182,7 +182,7 @@ module Berkshelf
       banner: 'PATH'
     desc 'install', 'Install the cookbooks specified in the Berksfile'
     def install
-      berksfile = ::Berkshelf::Berksfile.from_file(options[:berksfile])
+      berksfile = Berkshelf::Berksfile.from_file(options[:berksfile])
       berksfile.install(options)
     end
 
@@ -248,13 +248,12 @@ module Berkshelf
       desc: 'Halt uploading and exit if the Chef Server has a frozen version of the cookbook(s).'
     desc 'upload [COOKBOOKS]', 'Upload the cookbook specified in the Berksfile to the Chef Server'
     def upload(*cookbook_names)
-      berksfile = ::Berkshelf::Berksfile.from_file(options[:berksfile])
+      berksfile = Berkshelf::Berksfile.from_file(options[:berksfile])
 
-      upload_options             = Hash[options.except(:no_freeze, :berksfile)].symbolize_keys
-      upload_options[:cookbooks] = cookbook_names
-      upload_options[:freeze]    = false if options[:no_freeze]
+      options[:cookbooks] = cookbook_names
+      options[:freeze]    = !options[:no_freeze]
 
-      berksfile.upload(upload_options)
+      berksfile.upload(options.symbolize_keys)
     end
 
     method_option :berksfile,
@@ -269,7 +268,7 @@ module Berkshelf
       desc: 'Disable/Enable SSL verification when locking cookbooks.'
     desc 'apply ENVIRONMENT', 'Apply the cookbook version locks from Berksfile.lock to a Chef environment'
     def apply(environment_name)
-      berksfile    = ::Berkshelf::Berksfile.from_file(options[:berksfile])
+      berksfile    = Berkshelf::Berksfile.from_file(options[:berksfile])
       lock_options = Hash[options].symbolize_keys
 
       berksfile.apply(environment_name, lock_options)
@@ -292,10 +291,16 @@ module Berkshelf
     desc 'outdated [COOKBOOKS]', 'List dependencies that have new versions available that satisfy their constraints'
     def outdated(*cookbook_names)
       berksfile = Berkshelf::Berksfile.from_file(options[:berksfile])
-      Berkshelf.formatter.msg 'Listing outdated cookbooks with newer versions available...'
+      options[:cookbooks] = cookbook_names
+      outdated = berksfile.outdated(options.symbolize_keys)
+
+      if outdated.empty?
+        Berkshelf.formatter.msg "All cookbooks up to date!"
+      else
+        Berkshelf.formatter.msg "The following cookbooks have newer versions:"
+      end
 
-      outdated_options = { cookbooks: cookbook_names }.merge(options).symbolize_keys
-      berksfile.outdated(outdated_options)
+      Berkshelf.formatter.outdated(outdated)
     end
 
     desc 'init [PATH]', 'Initialize Berkshelf in the given directory'
@@ -308,9 +313,9 @@ module Berkshelf
         options[:metadata_entry] = true
       end
 
-      ::Berkshelf::InitGenerator.new([path], options).invoke_all
+      Berkshelf::InitGenerator.new([path], options).invoke_all
 
-      ::Berkshelf.formatter.msg 'Successfully initialized'
+      Berkshelf.formatter.msg 'Successfully initialized'
     end
 
     method_option :berksfile,
@@ -341,12 +346,7 @@ module Berkshelf
     desc "show [COOKBOOK]", "Display name, author, copyright, and dependency information about a cookbook"
     def show(name)
       berksfile = Berksfile.from_file(options[:berksfile])
-      cookbook  = Berkshelf.ui.mute { berksfile.install(cookbooks: name) }.first
-
-      unless cookbook
-        raise CookbookNotFound, "Cookbook '#{name}' is not installed by your Berksfile"
-      end
-
+      cookbook = berksfile.retrieve_locked(name)
       Berkshelf.formatter.show(cookbook)
     end
 
@@ -392,11 +392,29 @@ module Berkshelf
       berksfile.package(name, options)
     end
 
+    method_option :except,
+      type: :array,
+      desc: 'Exclude cookbooks that are in these groups.',
+      aliases: '-e'
+    method_option :only,
+      type: :array,
+      desc: 'Only cookbooks that are in these groups.',
+      aliases: '-o'
+    method_option :berksfile,
+      type: :string,
+      default: Berkshelf::DEFAULT_FILENAME,
+      desc: 'Path to a Berksfile to operate off of.',
+      aliases: '-b',
+      banner: 'PATH'
+    desc "vendor [PATH]", "Vendor the cookbooks specified by the Berksfile into a directory"
+    def vendor(path = File.join(Dir.pwd, "berks-cookbooks"))
+      berksfile = Berkshelf::Berksfile.from_file(options[:berksfile])
+      berksfile.vendor(path, options)
+    end
+
     desc 'version', 'Display version and copyright information'
     def version
-      Berkshelf.formatter.msg version_header
-      Berkshelf.formatter.msg "\n"
-      Berkshelf.formatter.msg license
+      Berkshelf.formatter.version
     end
 
     desc 'cookbook NAME', 'Create a skeleton for a new cookbook'
@@ -404,20 +422,11 @@ module Berkshelf
       Berkshelf.formatter.deprecation '--git is now the default' if options[:git]
       Berkshelf.formatter.deprecation '--vagrant is now the default' if options[:vagrant]
 
-      ::Berkshelf::CookbookGenerator.new([File.join(Dir.pwd, name), name], options).invoke_all
+      Berkshelf::CookbookGenerator.new([File.join(Dir.pwd, name), name], options).invoke_all
     end
     tasks['cookbook'].options = Berkshelf::CookbookGenerator.class_options
 
     private
-
-      def version_header
-        "Berkshelf (#{Berkshelf::VERSION})"
-      end
-
-      def license
-        File.read(Berkshelf.root.join('LICENSE'))
-      end
-
       # Print a list of the given cookbooks. This is used by various
       # methods like {list} and {contingent}.
       #

data/lib/berkshelf/dependency.rb

@@ -109,6 +109,7 @@ module Berkshelf
       @options            = options
       @berksfile          = berksfile
       @name               = name
+      @metadata           = options[:metadata]
       @location           = Location.init(self, options)
       @locked_version     = Solve::Version.new(options[:locked_version]) if options[:locked_version]
       @version_constraint = Solve::Constraint.new(options[:constraint] || DEFAULT_CONSTRAINT)
@@ -117,6 +118,13 @@ module Berkshelf
       add_group(:default) if groups.empty?
     end
 
+    # Return true if this is a metadata location.
+    #
+    # @return [Boolean]
+    def metadata?
+      !!@metadata
+    end
+
     def add_group(*local_groups)
       local_groups = local_groups.first if local_groups.first.is_a?(Array)
 
@@ -211,14 +219,16 @@ module Berkshelf
           h[:locked_version] = locked_version.to_s
         end
 
-        unless version_constraint.to_s == DEFAULT_CONSTRAINT
-          h[:constraint] = version_constraint.to_s
-        end
-
         if location.kind_of?(PathLocation)
           h[:path] = location.relative_path(berksfile.filepath)
         end
 
+        if location.kind_of?(MercurialLocation)
+          h[:hg] = location.uri
+          h[:rev] = location.rev
+          h[:rel] = location.rel if location.rel
+        end
+
         if location.kind_of?(GitLocation)
           h[:git] = location.uri
           h[:ref] = location.ref

data/lib/berkshelf/errors.rb

@@ -20,10 +20,24 @@ module Berkshelf
     end
   end
 
-  class BerksfileNotFound < BerkshelfError; status_code(100); end
+  class BerksfileNotFound < BerkshelfError
+    status_code(100)
+
+    # @param [#to_s] filepath
+    #   the path where a Berksfile was not found
+    def initialize(filepath)
+      @filepath = File.dirname(File.expand_path(filepath)) rescue filepath
+    end
+
+    def to_s
+      "No Berksfile or Berksfile.lock found at '#{@filepath}'!"
+    end
+  end
+
   class NoVersionForConstraints < BerkshelfError; status_code(101); end
   class DuplicateLocationDefined < BerkshelfError; status_code(102); end
   class CookbookNotFound < BerkshelfError; status_code(103); end
+
   class GitError < BerkshelfError
     status_code(104)
 
@@ -100,6 +114,23 @@ module Berkshelf
 
   class CookbookSyntaxError < BerkshelfError; status_code(107); end
 
+  class MercurialError < BerkshelfError
+    status_code(108);
+  end
+
+  class InvalidHgURI < BerkshelfError
+    status_code(110)
+
+    # @param [String] uri
+    def initialize(uri)
+      @uri = uri
+    end
+
+    def to_s
+      "'#{@uri}' is not a valid Mercurial URI"
+    end
+  end
+
   class InvalidGitURI < BerkshelfError
     status_code(110)
 
@@ -126,6 +157,14 @@ module Berkshelf
     end
   end
 
+  class MercurialNotFound < BerkshelfError
+    status_code(111)
+
+    def to_s
+      'Could not find a Mercurial executable in your path - please add it and try again'
+    end
+  end
+
   class GitNotFound < BerkshelfError
     status_code(110)
 
@@ -209,7 +248,23 @@ module Berkshelf
   class ConfigExists < BerkshelfError; status_code(116); end
   class ConfigurationError < BerkshelfError; status_code(117); end
   class InsufficientPrivledges < BerkshelfError; status_code(119); end
-  class DependencyNotFound < BerkshelfError; status_code(120); end
+
+  class DependencyNotFound < BerkshelfError
+    status_code(120)
+
+    # @param [String, Array<String>] cookbooks
+    #   the list of cookbooks that were not defined
+    def initialize(cookbooks)
+      @cookbooks = Array(cookbooks)
+    end
+
+    def to_s
+      list = @cookbooks.collect {|c| "'#{c}'" }
+      "Could not find cookbook(s) #{list.join(', ')} in any of the configured" <<
+      " dependencies. #{list.size == 1 ? 'Is it' : 'Are they' } in your Berksfile?"
+    end
+  end
+
   class ValidationFailed < BerkshelfError; status_code(121); end
   class InvalidVersionConstraint < BerkshelfError; status_code(122); end
   class CommunitySiteError < BerkshelfError; status_code(123); end
@@ -234,7 +289,21 @@ module Berkshelf
   class ClientKeyFileNotFound < BerkshelfError; status_code(125); end
 
   class UploadFailure < BerkshelfError; end
-  class FrozenCookbook < UploadFailure; status_code(126); end
+
+  class FrozenCookbook < UploadFailure
+    status_code(126)
+
+    # @param [CachedCookbook] cookbook
+    def initialize(cookbook)
+      @cookbook = cookbook
+    end
+
+    def to_s
+      "The cookbook #{@cookbook.cookbook_name} (#{@cookbook.version})" <<
+        " already exists and is frozen on the Chef Server. Use the --force" <<
+        " option to override."
+    end
+  end
 
   class OutdatedDependency < BerkshelfError
     status_code(128)
@@ -404,4 +473,6 @@ module Berkshelf
   end
 
   class DuplicateDemand < BerkshelfError; status_code(138); end
+  class VendorError < BerkshelfError; status_code(139); end
+  class LockfileNotFound < BerkshelfError; status_code(140); end
 end

data/lib/berkshelf/formatters.rb

@@ -79,7 +79,18 @@ module Berkshelf
           end
       end
 
-      formatter_methods :fetch, :install, :use, :upload, :msg, :error, :package, :show
+      formatter_methods :error,
+                        :fetch,
+                        :install,
+                        :msg,
+                        :outdated,
+                        :package,
+                        :skip,
+                        :show,
+                        :upload,
+                        :use,
+                        :vendor,
+                        :version
 
       def cleanup_hook
         # run after the task is finished

data/lib/berkshelf/formatters/human_readable.rb

@@ -5,6 +5,11 @@ module Berkshelf
 
       register_formatter :human
 
+      # Output the version of Berkshelf
+      def version
+        Berkshelf.ui.info Berkshelf::VERSION
+      end
+
       # @param [Berkshelf::Dependency] dependency
       def fetch(dependency)
         Berkshelf.ui.info "Fetching '#{dependency.name}' from #{dependency.location}"
@@ -32,11 +37,36 @@ module Berkshelf
 
       # Output a Cookbook upload message using {Berkshelf.ui}
       #
-      # @param [String] cookbook
-      # @param [String] version
-      # @param [String] chef_api_url
-      def upload(cookbook, version, chef_api_url)
-        Berkshelf.ui.info "Uploading #{cookbook} (#{version}) to: '#{chef_api_url}'"
+      # @param [Berkshelf::CachedCookbook] cookbook
+      # @param [Ridley::Connection] conn
+      def upload(cookbook, conn)
+        Berkshelf.ui.info "Uploading #{cookbook.cookbook_name} (#{cookbook.version}) to: '#{conn.server_url}'"
+      end
+
+      # Output a Cookbook skip message using {Berkshelf.ui}
+      #
+      # @param [Berkshelf::CachedCookbook] cookbook
+      # @param [Ridley::Connection] conn
+      def skip(cookbook, conn)
+        Berkshelf.ui.info "Skipping #{cookbook.cookbook_name} (#{cookbook.version}) (already uploaded)"
+      end
+
+      # Output a list of outdated cookbooks and the most recent version
+      # using {Berkshelf.ui}
+      #
+      # @param [Hash] hash
+      #   the list of outdated cookbooks in the format
+      #   { 'cookbook' => { 'api.berkshelf.com' => #<Cookbook> } }
+      def outdated(hash)
+        hash.keys.each do |name|
+          hash[name].each do |source, newest|
+            string = "  * #{newest.name} (#{newest.version})"
+            unless Berksfile.default_sources.map { |s| s.uri.to_s }.include?(source)
+              string << " [#{source}]"
+            end
+            Berkshelf.ui.info string
+          end
+        end
       end
 
       # Output a Cookbook package message using {Berkshelf.ui}
@@ -54,6 +84,15 @@ module Berkshelf
         Berkshelf.ui.info(cookbook.pretty_print)
       end
 
+      # Output Cookbook vendor info message using {Berkshelf.ui}
+      #
+      # @param [CachedCookbook] cookbook
+      # @param [String] destination
+      def vendor(cookbook, destination)
+        cookbook_destination = File.join(destination, cookbook.cookbook_name)
+        Berkshelf.ui.info "Vendoring #{cookbook.cookbook_name} (#{cookbook.version}) to #{cookbook_destination}"
+      end
+
       # Output a generic message using {Berkshelf.ui}
       #
       # @param [String] message

data/lib/berkshelf/formatters/json.rb

@@ -5,6 +5,11 @@ module Berkshelf
 
       register_formatter :json
 
+      # Output the version of Berkshelf
+      def version
+        @output = { version: Berkshelf::VERSION }
+      end
+
       def initialize
         @output = {
           cookbooks: Array.new,
@@ -22,7 +27,7 @@ module Berkshelf
           output[:cookbooks] << details
         end
 
-        print ::JSON.pretty_generate(output)
+        puts ::JSON.pretty_generate(output)
       end
 
       # @param [Berkshelf::Dependency] dependency
@@ -64,13 +69,41 @@ module Berkshelf
 
       # Add a Cookbook upload entry to delayed output
       #
-      # @param [String] cookbook
-      # @param [String] version
-      # @param [String] chef_api_url
-      def upload(cookbook, version, chef_api_url)
-        cookbooks[cookbook] ||= {}
-        cookbooks[cookbook][:version] = version
-        cookbooks[cookbook][:uploaded_to] = chef_api_url
+      # @param [Berkshelf::CachedCookbook] cookbook
+      # @param [Ridley::Connection] conn
+      def upload(cookbook, conn)
+        name = cookbook.cookbook_name
+        cookbooks[name] ||= {}
+        cookbooks[name][:version] = cookbook.version
+        cookbooks[name][:uploaded_to] = conn.server_url
+      end
+
+      # Add a Cookbook skip entry to delayed output
+      #
+      # @param [Berkshelf::CachedCookbook] cookbook
+      # @param [Ridley::Connection] conn
+      def skip(cookbook, conn)
+        name = cookbook.cookbook_name
+        cookbooks[name] ||= {}
+        cookbooks[name][:version] = cookbook.version
+        cookbooks[name][:skipped] = true
+      end
+
+      # Output a list of outdated cookbooks and the most recent version
+      # to delayed output
+      #
+      # @param [Hash] hash
+      #   the list of outdated cookbooks in the format
+      #   { 'cookbook' => { 'api.berkshelf.com' => #<Cookbook> } }
+      def outdated(hash)
+        hash.keys.each do |name|
+          hash[name].each do |source, cookbook|
+            cookbooks[name] ||= {}
+            cookbooks[name][:version] = cookbook.version
+            cookbooks[name][:sources] ||= {}
+            cookbooks[name][:sources][source] = cookbook
+          end
+        end
       end
 
       # Add a Cookbook package entry to delayed output
@@ -89,6 +122,15 @@ module Berkshelf
         cookbooks[cookbook.cookbook_name] = cookbook.pretty_hash
       end
 
+      # Add a vendor message to delayed output
+      #
+      # @param [CachedCookbook] cookbook
+      # @param [String] destination
+      def vendor(cookbook, destination)
+        cookbook_destination = File.join(destination, cookbook.cookbook_name)
+        msg("Vendoring #{cookbook.cookbook_name} (#{cookbook.version}) to #{cookbook_destination}")
+      end
+
       # Add a generic message entry to delayed output
       #
       # @param [String] message