berkshelf 3.0.0.beta6 → 3.0.0.beta7

data/lib/berkshelf/cli.rb

@@ -139,8 +139,8 @@ module Berkshelf
         exit(1)
       end
 
-      berksfile = Berkshelf::Berksfile.from_file(options[:berksfile])
-      berksfile.install(options)
+      berksfile = Berksfile.from_options(options)
+      berksfile.install
     end
 
     method_option :berksfile,
@@ -159,13 +159,8 @@ module Berkshelf
       aliases: '-o'
     desc 'update [COOKBOOKS]', 'Update the cookbooks (and dependencies) specified in the Berksfile'
     def update(*cookbook_names)
-      berksfile = Berksfile.from_file(options[:berksfile])
-
-      update_options = {
-        cookbooks: cookbook_names
-      }.merge(options).symbolize_keys
-
-      berksfile.update(update_options)
+      berksfile = Berksfile.from_options(options)
+      berksfile.update(*cookbook_names)
     end
 
     method_option :berksfile,
@@ -205,7 +200,7 @@ 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 = Berksfile.from_options(options)
 
       options[:cookbooks] = cookbook_names
       options[:freeze]    = !options[:no_freeze]
@@ -230,7 +225,7 @@ module Berkshelf
         raise LockfileNotFound, "No lockfile found at #{options[:lockfile]}"
       end
 
-      lockfile     = Berkshelf::Lockfile.from_file(options[:lockfile])
+      lockfile     = Lockfile.from_file(options[:lockfile])
       lock_options = Hash[options].symbolize_keys
 
       lockfile.apply(environment_name, lock_options)
@@ -251,10 +246,9 @@ module Berkshelf
       desc: 'Only cookbooks that are in these groups.',
       aliases: '-o'
     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])
-      options[:cookbooks] = cookbook_names
-      outdated = berksfile.outdated(options.symbolize_keys)
+    def outdated(*names)
+      berksfile = Berksfile.from_options(options)
+      outdated  = berksfile.outdated(*names)
 
       if outdated.empty?
         Berkshelf.formatter.msg "All cookbooks up to date!"
@@ -281,9 +275,17 @@ module Berkshelf
       desc: 'Path to a Berksfile to operate off of.',
       aliases: '-b',
       banner: 'PATH'
-    desc 'list', 'List all cookbooks and their dependencies specified by your Berksfile'
+    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'
+    desc 'list', 'List cookbooks and their dependencies specified by your Berksfile'
     def list
-      berksfile = Berksfile.from_file(options[:berksfile])
+      berksfile = Berksfile.from_options(options)
       Berkshelf.formatter.list(berksfile.list)
     end
 
@@ -295,8 +297,8 @@ module Berkshelf
       banner: "PATH"
     desc "show [COOKBOOK]", "Display name, author, copyright, and dependency information about a cookbook"
     def show(name)
-      berksfile = Berksfile.from_file(options[:berksfile])
-      cookbook = berksfile.retrieve_locked(berksfile.find!(name))
+      berksfile = Berksfile.from_options(options)
+      cookbook  = berksfile.retrieve_locked(name)
       Berkshelf.formatter.show(cookbook)
     end
 
@@ -306,16 +308,17 @@ module Berkshelf
       desc: 'Path to a Berksfile to operate off of.',
       aliases: '-b',
       banner: 'PATH'
-    desc 'contingent COOKBOOK', 'List all cookbooks that depend on the given cookbook'
+    desc 'contingent COOKBOOK', 'List all cookbooks that depend on the given cookbook in your Berksfile'
     def contingent(name)
-      berksfile    = Berksfile.from_file(options[:berksfile])
-      dependencies = Berkshelf.ui.mute { berksfile.install }.sort
-      dependencies = dependencies.select { |cookbook| cookbook.dependencies.include?(name) }
+      berksfile    = Berksfile.from_options(options)
+      dependencies = berksfile.cookbooks.select do |cookbook|
+        cookbook.dependencies.include?(name)
+      end
 
       if dependencies.empty?
-        Berkshelf.formatter.msg "There are no cookbooks contingent upon '#{name}' defined in this Berksfile"
+        Berkshelf.formatter.msg "There are no cookbooks in this Berksfile contingent upon '#{name}'."
       else
-        Berkshelf.formatter.msg "Cookbooks in this Berksfile contingent upon #{name}:"
+        Berkshelf.formatter.msg "Cookbooks in this Berksfile contingent upon '#{name}':"
         print_list(dependencies)
       end
     end
@@ -342,8 +345,8 @@ module Berkshelf
         path = File.expand_path(path)
       end
 
-      berksfile = Berkshelf::Berksfile.from_file(options[:berksfile])
-      berksfile.package(path, options)
+      berksfile = Berksfile.from_options(options)
+      berksfile.package(path)
     end
 
     method_option :except,
@@ -362,8 +365,8 @@ module Berkshelf
       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)
+      berksfile = Berkshelf::Berksfile.from_options(options)
+      berksfile.vendor(path)
     end
 
     desc 'version', 'Display version and copyright information'
@@ -387,7 +390,7 @@ module Berkshelf
       # @param [Array<CachedCookbook>] cookbooks
       #
       def print_list(cookbooks)
-        Array(cookbooks).each do |cookbook|
+        Array(cookbooks).sort.each do |cookbook|
           Berkshelf.formatter.msg "  * #{cookbook.cookbook_name} (#{cookbook.version})"
         end
       end

data/lib/berkshelf/cookbook_generator.rb

@@ -68,6 +68,7 @@ module Berkshelf
       template 'metadata.rb.erb', target.join('metadata.rb')
       template license_file, target.join('LICENSE')
       template 'README.md.erb', target.join('README.md')
+      template 'CHANGELOG.md.erb', target.join('CHANGELOG.md')
 
       Berkshelf::InitGenerator.new([target], options.merge(default_options)).invoke_all
     end

data/lib/berkshelf/dependency.rb

@@ -63,6 +63,21 @@ module Berkshelf
 
         true
       end
+
+      # Returns the name of this cookbook (because it's the key in hash tables).
+      #
+      # @param [Dependency, #to_s] dependency
+      #   the dependency to find the name from
+      #
+      # @return [String]
+      #   the name of the cookbook
+      def name(dependency)
+        if dependency.is_a?(Dependency)
+          dependency.name.to_s
+        else
+          dependency.to_s
+        end
+      end
     end
 
     DEFAULT_CONSTRAINT = '>= 0.0.0'.freeze
@@ -77,9 +92,11 @@ module Berkshelf
     # @return [Berkshelf::Location]
     attr_reader :location
     # @return [Solve::Version]
-    attr_accessor :locked_version
+    attr_reader :locked_version
     # @return [Solve::Constraint]
-    attr_accessor :version_constraint
+    attr_reader :version_constraint
+    # @return [Source]
+    attr_accessor :source
     # @return [Berkshelf::CachedCookbook]
     attr_accessor :cached_cookbook
 
@@ -127,6 +144,22 @@ module Berkshelf
       !!@metadata
     end
 
+    # Set this dependency's locked version.
+    #
+    # @param [#to_s] version
+    #   the version to set
+    def locked_version=(version)
+      @locked_version = Solve::Version.new(version.to_s)
+    end
+
+    # Set this dependency's constraint(s).
+    #
+    # @param [#to_s] constraint
+    #   the constraint to set
+    def version_constraint=(constraint)
+      @version_constraint = Solve::Constraint.new(constraint.to_s)
+    end
+
     def add_group(*local_groups)
       local_groups = local_groups.first if local_groups.first.is_a?(Array)
 
@@ -136,31 +169,37 @@ module Berkshelf
       end
     end
 
-    # @return [Berkshelf::CachedCookbook]
-    def cached_cookbook
-      @cached_cookbook ||= if location
-        download
+    # The cached (downloaded) cookbook for this dependency.
+    #
+    # @return [CachedCookbook, nil]
+    def download
+      @cached_cookbook = if location
+        location.download
       else
         if locked_version
           CookbookStore.instance.cookbook(name, locked_version)
         else
-          Berkshelf::CookbookStore.instance.satisfy(name, version_constraint)
+          CookbookStore.instance.satisfy(name, version_constraint)
         end
       end
-    end
-
-    # @return [Berkshelf::CachedCookbook]
-    def download
-      @cached_cookbook = location.download
 
       if scm_location? || path_location?
-        @locked_version = Solve::Version.new(@cached_cookbook.version)
-        @version_constraint = Solve::Constraint.new(@cached_cookbook.version)
+        self.locked_version     = @cached_cookbook.version
+        self.version_constraint = @cached_cookbook.version
       end
 
       @cached_cookbook
     end
 
+    # Download the dependency. If this dependency is an SCM location or Path
+    # location, the constraints are also updated to correspond to the cookbook
+    # on disk.
+    #
+    # @return [CachedCookbook, nil]
+    def cached_cookbook
+      @cached_cookbook ||= download
+    end
+
     # Returns true if the dependency has already been downloaded. A dependency is downloaded when a
     # cached cookbook is present.
     #
@@ -227,6 +266,17 @@ module Berkshelf
       ].join(', ')
     end
 
+    def to_lock
+      out = if path_location? || scm_location? || version_constraint.to_s == '>= 0.0.0'
+        "  #{name}\n"
+      else
+        "  #{name} (#{version_constraint})\n"
+      end
+
+      out << location.to_lock if location
+      out
+    end
+
     def to_hash
       {}.tap do |h|
         h[:locked_version] = locked_version.to_s

data/lib/berkshelf/downloader.rb

@@ -1,7 +1,6 @@
 require 'net/http'
 require 'zlib'
 require 'archive/tar/minitar'
-require 'octokit'
 
 module Berkshelf
   class Downloader
@@ -30,17 +29,13 @@ module Berkshelf
       options = args.last.is_a?(Hash) ? args.pop : Hash.new
       dependency, version = args
 
-      if dependency.is_a?(Berkshelf::Dependency)
-        dependency.download
-      else
-        sources.each do |source|
-          if result = try_download(source, dependency, version)
-            return result
-          end
+      sources.each do |source|
+        if result = try_download(source, dependency, version)
+          return result
         end
-
-        raise CookbookNotFound, "#{dependency} (#{version}) not found in any sources"
       end
+
+      raise CookbookNotFound, "#{dependency} (#{version}) not found in any sources"
     end
 
     # @param [Berkshelf::Source] source
@@ -71,6 +66,8 @@ module Berkshelf
         Celluloid.logger = nil unless ENV["DEBUG_CELLULOID"]
         Ridley.open(credentials) { |r| r.cookbook.download(name, version) }
       when :github
+        require 'octokit' unless defined?(Octokit)
+
         tmp_dir      = Dir.mktmpdir
         archive_path = File.join(tmp_dir, "#{name}-#{version}.tar.gz")
         unpack_dir   = File.join(tmp_dir, "#{name}-#{version}")

data/lib/berkshelf/errors.rb

@@ -272,9 +272,17 @@ module Berkshelf
     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?"
+      list = @cookbooks.collect { |cookbook| "'#{cookbook}'" }.join(', ')
+
+      if @cookbooks.size == 1
+        "Could not find cookbook #{list}. Make sure it is in your " \
+        "Berksfile, then run `berks install` to download and install the " \
+        "missing dependencies."
+      else
+        "Could not find cookbooks #{list}. Make sure they are in your " \
+        "Berksfile, then run `berks install` to download and install the " \
+        "missing dependencies."
+      end
     end
   end
 
@@ -325,9 +333,9 @@ module Berkshelf
     #   the locked dependency
     # @param [Berkshelf::Dependency] dependency
     #   the dependency that is outdated
-    def initialize(locked_dependency, dependency)
-      @locked_dependency = locked_dependency
-      @dependency        = dependency
+    def initialize(locked, dependency)
+      @locked     = locked
+      @dependency = dependency
     end
 
     def to_s
@@ -335,7 +343,7 @@ module Berkshelf
       "  In Berksfile:\n" +
       "    #{@dependency.name} (#{@dependency.version_constraint})\n\n" +
       "  In Berksfile.lock:\n" +
-      "    #{@locked_dependency.name} (#{@locked_dependency.locked_version})\n\n" +
+      "    #{@locked.name} (#{@locked.version})\n\n" +
       "Try running `berks update #{@dependency.name}`, which will try to find '#{@dependency.name}' matching " +
         "'#{@dependency.version_constraint}'."
     end
@@ -459,13 +467,13 @@ module Berkshelf
     #   the path to the Lockfile
     # @param [~Exception] original
     #   the original exception class
-    def initialize(lockfile, original)
-      @lockfile = Pathname.new(lockfile.to_s).basename.to_s
+    def initialize(original)
       @original = original
     end
 
     def to_s
-      "Error reading the Berkshelf lockfile `#{@lockfile}` (#{@original.class})"
+      "Error reading the Berkshelf lockfile:\n\n" \
+      "  #{@original.class}: #{@original.message}"
     end
   end
 
@@ -487,7 +495,13 @@ module Berkshelf
 
   class DuplicateDemand < BerkshelfError; status_code(138); end
   class VendorError < BerkshelfError; status_code(139); end
-  class LockfileNotFound < BerkshelfError; status_code(140); end
+  class LockfileNotFound < BerkshelfError
+    status_code(140)
+
+    def to_s
+      'Lockfile not found! Run `berks install` to create the lockfile.'
+    end
+  end
 
   class NotACookbook < BerkshelfError
     status_code(141)
@@ -505,4 +519,38 @@ module Berkshelf
 
   class InvalidLockFile < BerkshelfError; status_code(142); end
   class PackageError < BerkshelfError; status_code(143); end
+
+  class LockfileOutOfSync < BerkshelfError
+    status_code(144)
+
+    def to_s
+      'The lockfile is out of sync! Run `berks install` to sync the lockfile.'
+    end
+  end
+
+  class DependencyNotInstalled < BerkshelfError
+    status_code(145)
+
+    def initialize(dependency)
+      name    = dependency.name
+      version = dependency.locked_version
+
+      super "The cookbook '#{name} (#{version})' is not installed. Please " \
+            "run `berks install` to download and install the missing " \
+            "dependency."
+    end
+  end
+
+  class NoAPISourcesDefined < BerkshelfError
+    status_code(146)
+
+    def initialize
+      super "Your Berksfile does not define any API sources! You must define " \
+        "at least one source in order to download cookbooks. To add the " \
+        "default Berkshelf API server, add the following code to the top of " \
+        "your Berksfile:" \
+        "\n\n" \
+        "    source 'https://api.berkshelf.com'"
+    end
+  end
 end

data/lib/berkshelf/formatters/human_readable.rb

@@ -17,38 +17,27 @@ module Berkshelf
 
       # Output a Cookbook installation message using {Berkshelf.ui}
       #
-      # @param [String] cookbook
-      # @param [String] version
-      # @option options [#to_s] :api_source
-      #   the berkshelf-api source url
-      # @option options [#to_s] :location_path
-      #   endpoint location for the remote cookbook provided by the api server
-      # @option options [#to_s] :location_type
-      #   type of the location provided by the api server for the remote cookbook
-      def install(cookbook, version, options = {})
-        info_message = "Installing #{cookbook} (#{version})"
-
-        if options.has_key?(:api_source) && options.has_key?(:location_path) && options.has_key?(:location_type)
-          api_source    = options[:api_source].to_s
-          location_path = options[:location_path].to_s
-          location_type = options[:location_type].to_s
-
-          unless api_source == Berkshelf::Berksfile::DEFAULT_API_URL
-            info_message << " from [api: #{URI(api_source)}] ([#{location_type}] #{location_path})"
-          end
+      # @param [Source] source
+      #   the source the dependency is being downloaded from
+      # @param [RemoteCookbook] cookbook
+      #   the cookbook to be downloaded
+      def install(source, cookbook)
+        message = "Installing #{cookbook.name} (#{cookbook.version})"
+
+        unless source.default?
+          message << " from #{source}"
+          message << " ([#{cookbook.location_type}] #{cookbook.location_path})"
         end
 
-        Berkshelf.ui.info info_message
+        Berkshelf.ui.info(message)
       end
 
       # Output a Cookbook use message using {Berkshelf.ui}
       #
-      # @param [String] cookbook
-      # @param [String] version
-      # @param [~Location] location
-      def use(cookbook, version, location = nil)
-        message = "Using #{cookbook} (#{version})"
-        message += " #{location}" if location
+      # @param [Dependency] dependency
+      def use(dependency)
+        message =  "Using #{dependency.name} (#{dependency.locked_version})"
+        message << " from #{dependency.location}" if dependency.location
         Berkshelf.ui.info message
       end
 
@@ -78,7 +67,7 @@ module Berkshelf
         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)
+            unless source == Berksfile::DEFAULT_API_URL
               string << " [#{source}]"
             end
             Berkshelf.ui.info string
@@ -95,15 +84,13 @@ module Berkshelf
 
       # Output a list of cookbooks using {Berkshelf.ui}
       #
-      # @param [Hash<Dependency, CachedCookbook>] list
-      def list(list)
-        if list.empty?
-          Berkshelf.ui.info "There are no cookbooks installed by your Berksfile"
-        else
-          Berkshelf.ui.info "Cookbooks installed by your Berksfile:"
-          list.each do |dependency, cookbook|
-            Berkshelf.ui.info("  * #{cookbook.cookbook_name} (#{cookbook.version})")
-          end
+      # @param [Array<Dependency>] list
+      def list(dependencies)
+        Berkshelf.ui.info "Cookbooks installed by your Berksfile:"
+        dependencies.each do |dependency|
+          out =  "  * #{dependency}"
+          out << " from #{dependency.location}" if dependency.location
+          Berkshelf.ui.info(out)
         end
       end