berkshelf 3.0.0.beta3 → 3.0.0.beta4

data/lib/berkshelf/cli.rb

@@ -111,56 +111,6 @@ module Berkshelf
       aliases: '-d',
       default: false
 
-    method_option :force,
-      type: :boolean,
-      default: false,
-      desc: 'create a new configuration file even if one already exists.'
-    method_option :path,
-      type: :string,
-      default: Berkshelf.config.path,
-      desc: 'The path to save the configuration file'
-    desc 'configure', 'Create a new Berkshelf configuration file'
-    def configure
-      path = File.expand_path(options[:path])
-
-      if File.exist?(path) && !options[:force]
-        raise Berkshelf::ConfigExists, 'A configuration file already exists. Re-run with the --force flag if you wish to overwrite it.'
-      end
-
-      config = Berkshelf::Config.new(path)
-
-      [
-        'chef.chef_server_url',
-        'chef.node_name',
-        'chef.client_key',
-        'chef.validation_client_name',
-        'chef.validation_key_path',
-        'vagrant.vm.box',
-        'vagrant.vm.box_url',
-      ].each do |attribute|
-        default = config.get_attribute(attribute)
-
-        message = "Enter value for #{attribute}"
-        message << " (default: '#{default}')" if default
-        message << ": "
-
-        input = Berkshelf.ui.ask(message)
-
-        if input.present?
-          config.set_attribute(attribute, input)
-        end
-      end
-
-      unless config.valid?
-        raise InvalidConfiguration.new(config.errors)
-      end
-
-      config.save
-      Berkshelf.config = config
-
-      Berkshelf.formatter.msg "Config written to: '#{path}'"
-    end
-
     method_option :except,
       type: :array,
       desc: 'Exclude cookbooks that are in these groups.',
@@ -252,26 +202,31 @@ module Berkshelf
 
       options[:cookbooks] = cookbook_names
       options[:freeze]    = !options[:no_freeze]
+      options[:validate]  = false if options[:skip_syntax_check]
 
       berksfile.upload(options.symbolize_keys)
     end
 
-    method_option :berksfile,
+    method_option :lockfile,
       type: :string,
-      default: Berkshelf::DEFAULT_FILENAME,
-      desc: 'Path to a Berksfile to operate off of.',
+      default: Berkshelf::Lockfile::DEFAULT_FILENAME,
+      desc: 'Path to a Berksfile.lock to operate off of.',
       aliases: '-b',
       banner: 'PATH'
     method_option :ssl_verify,
       type: :boolean,
       default: nil,
       desc: 'Disable/Enable SSL verification when locking cookbooks.'
-    desc 'apply ENVIRONMENT', 'Apply the cookbook version locks from Berksfile.lock to a Chef environment'
+    desc 'apply ENVIRONMENT', 'Apply version locks from Berksfile.lock to a Chef environment'
     def apply(environment_name)
-      berksfile    = Berkshelf::Berksfile.from_file(options[:berksfile])
+      unless File.exist?(options[:lockfile])
+        raise LockfileNotFound, "No lockfile found at #{options[:lockfile]}"
+      end
+
+      lockfile     = Berkshelf::Lockfile.from_file(options[:lockfile])
       lock_options = Hash[options].symbolize_keys
 
-      berksfile.apply(environment_name, lock_options)
+      lockfile.apply(environment_name, lock_options)
     end
 
     method_option :berksfile,
@@ -321,15 +276,8 @@ module Berkshelf
       banner: 'PATH'
     desc 'list', 'List all cookbooks and their dependencies specified by your Berksfile'
     def list
-      berksfile    = Berksfile.from_file(options[:berksfile])
-      dependencies = Berkshelf.ui.mute { berksfile.install }.sort
-
-      if dependencies.empty?
-        Berkshelf.formatter.msg 'There are no cookbooks installed by your Berksfile'
-      else
-        Berkshelf.formatter.msg 'Cookbooks installed by your Berksfile:'
-        print_list(dependencies)
-      end
+      berksfile = Berksfile.from_file(options[:berksfile])
+      Berkshelf.formatter.list(berksfile.list)
     end
 
     method_option :berksfile,
@@ -341,7 +289,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 = berksfile.retrieve_locked(name)
+      cookbook = berksfile.retrieve_locked(berksfile.find!(name))
       Berkshelf.formatter.show(cookbook)
     end
 
@@ -381,7 +329,7 @@ module Berkshelf
       type: :boolean,
       desc: 'Do not apply the chefignore to the packaged contents',
       default: false
-    desc "package [COOKBOOK]", "Package a cookbook and it's dependencies as a tarball"
+    desc "package [COOKBOOK]", "Package a cookbook and its dependencies as a tarball"
     def package(name = nil)
       berksfile = Berkshelf::Berksfile.from_file(options[:berksfile])
       berksfile.package(name, options)

data/lib/berkshelf/community_rest.rb

@@ -111,7 +111,7 @@ module Berkshelf
       end
     end
 
-    # Returns the latest version of the cookbook and it's download link.
+    # Returns the latest version of the cookbook and its download link.
     #
     # @return [String]
     def latest_version(name)
@@ -166,7 +166,7 @@ module Berkshelf
       local.binmode
 
       retryable(tries: retries, on: OpenURI::HTTPError, sleep: retry_interval) do
-        open(target, 'rb', headers) do |remote|
+        open(target, 'rb', open_uri_options) do |remote|
           local.write(remote.read)
         end
       end
@@ -175,5 +175,21 @@ module Berkshelf
     ensure
       local.close(false) unless local.nil?
     end
+
+    private
+
+      def open_uri_options
+        options = {}
+        options.merge!(headers)
+        options.merge!(open_uri_proxy_options)
+      end
+
+      def open_uri_proxy_options
+        if proxy && proxy[:user] && proxy[:password]
+          {proxy_http_basic_authentication: [ proxy[:uri], proxy[:user], proxy[:password] ]}
+        else
+          {}
+        end
+      end
   end
 end

data/lib/berkshelf/dependency.rb

@@ -203,8 +203,12 @@ module Berkshelf
       SCM_LOCATIONS.include?(location.class.location_key)
     end
 
+    def <=>(other)
+      [self.name, self.version_constraint] <=> [other.name, other.version_constraint]
+    end
+
     def to_s
-      "#{name} (#{version_constraint})"
+      "#{name} (#{locked_version || version_constraint})"
     end
 
     def inspect
@@ -218,9 +222,7 @@ module Berkshelf
 
     def to_hash
       {}.tap do |h|
-        unless location.kind_of?(PathLocation)
-          h[:locked_version] = locked_version.to_s
-        end
+        h[:locked_version] = locked_version.to_s
 
         if location.kind_of?(PathLocation)
           h[:path] = location.relative_path(berksfile.filepath)

data/lib/berkshelf/downloader.rb

@@ -61,6 +61,9 @@ module Berkshelf
             verify: Berkshelf::Config.instance.ssl.verify
           }
         }
+        # @todo  Something scary going on here - getting an instance of Kitchen::Logger from test-kitchen
+        # https://github.com/opscode/test-kitchen/blob/master/lib/kitchen.rb#L99
+        Celluloid.logger = nil unless ENV["DEBUG_CELLULOID"]
         Ridley.open(credentials) { |r| r.cookbook.download(name, version) }
       else
         raise RuntimeError, "unknown location type #{remote_cookbook.location_type}"

data/lib/berkshelf/errors.rb

@@ -144,6 +144,19 @@ module Berkshelf
     end
   end
 
+  class InvalidGitHubIdentifier < BerkshelfError
+    status_code(110)
+
+    # @param [String] repo_identifier
+    def initialize(repo_identifier)
+      @repo_identifier = repo_identifier
+    end
+
+    def to_s
+      "'#{@repo_identifier}' is not a valid GitHub identifier - should not end in '.git'"
+    end
+  end
+
   class UnknownGitHubProtocol < BerkshelfError
     status_code(110)
 
@@ -489,4 +502,6 @@ module Berkshelf
       "#{@path} does not appear to be a valid cookbook. Does it have a `metadata.rb`?"
     end
   end
+
+  class InvalidLockFile < BerkshelfError; status_code(142); end
 end

data/lib/berkshelf/formatters.rb

@@ -82,6 +82,7 @@ module Berkshelf
       formatter_methods :error,
                         :fetch,
                         :install,
+                        :list,
                         :msg,
                         :outdated,
                         :package,

data/lib/berkshelf/formatters/human_readable.rb

@@ -19,9 +19,18 @@ module Berkshelf
       #
       # @param [String] cookbook
       # @param [String] version
-      # @param [Berkshelf::Dependency] dependency
-      def install(cookbook, version, dependency)
-        Berkshelf.ui.info "Installing #{cookbook} (#{version})"
+      # @option options [String] :api_source
+      #   the berkshelf-api source url
+      # @option options [String] :location_path
+      #   the chef server url for a cookbook's location
+      def install(cookbook, version, options = {})
+        info_message = "Installing #{cookbook} (#{version})"
+
+        if options.has_key?(:api_source) && options.has_key?(:location_path)
+          api_source = options[:api_source]
+          info_message << " from #{options[:location_path]} (via #{URI(api_source).host})" unless api_source == Berkshelf::Berksfile::DEFAULT_API_URL
+        end
+        Berkshelf.ui.info info_message
       end
 
       # Output a Cookbook use message using {Berkshelf.ui}
@@ -48,7 +57,7 @@ module Berkshelf
       # @param [Berkshelf::CachedCookbook] cookbook
       # @param [Ridley::Connection] conn
       def skip(cookbook, conn)
-        Berkshelf.ui.info "Skipping #{cookbook.cookbook_name} (#{cookbook.version}) (already uploaded)"
+        Berkshelf.ui.info "Skipping #{cookbook.cookbook_name} (#{cookbook.version}) (frozen)"
       end
 
       # Output a list of outdated cookbooks and the most recent version
@@ -77,6 +86,20 @@ module Berkshelf
         Berkshelf.ui.info "Cookbook(s) packaged to #{destination}!"
       end
 
+      # 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
+        end
+      end
+
       # Output Cookbook info message using {Berkshelf.ui}
       #
       # @param [CachedCookbook] cookbook

data/lib/berkshelf/formatters/json.rb

@@ -41,14 +41,17 @@ module Berkshelf
       #
       # @param [String] cookbook
       # @param [String] version
-      # @param [~Location] location
-      def install(cookbook, version, location)
+      # @option options [String] :api_source
+      #   the berkshelf-api source url
+      # @option options [String] :location_path
+      #   the chef server url for a cookbook's location
+      def install(cookbook, version, options = {})
         cookbooks[cookbook] ||= {}
         cookbooks[cookbook][:version] = version
 
-        if location && location.is_a?(PathLocation)
-          cookbooks[cookbook][:metadata] = true if location.metadata?
-          cookbooks[cookbook][:location] = location.relative_path
+        if options.has_key?(:api_source) && options.has_key?(:location_path)
+          cookbooks[cookbook][:api_source] = options[:api_source] unless options[:api_source] == Berkshelf::Berksfile::DEFAULT_API_URL
+          cookbooks[cookbook][:location_path] = options[:location_path] unless options[:api_source] == Berkshelf::Berksfile::DEFAULT_API_URL
         end
       end
 
@@ -115,6 +118,19 @@ module Berkshelf
         cookbooks[cookbook][:destination] = destination
       end
 
+      # Output a list of cookbooks to delayed output
+      #
+      # @param [Hash<Dependency, CachedCookbook>] list
+      def list(list)
+        list.each do |dependency, cookbook|
+          cookbooks[cookbook.cookbook_name] ||= {}
+          cookbooks[cookbook.cookbook_name][:version] = cookbook.version
+          if dependency.location
+            cookbooks[cookbook.cookbook_name][:location] = dependency.location
+          end
+        end
+      end
+
       # Output Cookbook info entry to delayed output
       #
       # @param [CachedCookbook] cookbook

data/lib/berkshelf/git.rb

@@ -41,6 +41,10 @@ module Berkshelf
       # @return [String]
       #   the destination the URI was cloned to
       def clone(uri, destination = Dir.mktmpdir)
+        if File::ALT_SEPARATOR
+          destination = destination.to_s.gsub(File::SEPARATOR, File::ALT_SEPARATOR)
+        end
+
         git('clone', uri, destination.to_s)
 
         destination

data/lib/berkshelf/installer.rb

@@ -47,7 +47,9 @@ module Berkshelf
           Berkshelf.formatter.use(dependency.name, dependency.cached_cookbook.version, dependency.location)
           dependency.cached_cookbook
         else
-          Berkshelf.formatter.install(name, version, dependency)
+          source = berksfile.sources.find { |source| source.cookbook(name, version) }
+          remote_cookbook = source.cookbook(name, version)
+          Berkshelf.formatter.install(name, version, api_source: source.to_s, location_path: remote_cookbook.location_path)
           temp_filepath = downloader.download(name, version)
           CookbookStore.import(name, version, temp_filepath)
         end

data/lib/berkshelf/locations/git_location.rb

@@ -28,13 +28,23 @@ module Berkshelf
     def initialize(dependency, options = {})
       super
       @uri    = options[:git]
-      @branch = options[:branch] || options[:tag] || 'master'
       @ref    = options[:ref]
+      @branch = options[:branch] || options[:tag] || "master" unless ref
+      @sha    = ref
       @rel    = options[:rel]
 
       Git.validate_uri!(@uri)
     end
 
+    def checkout_info
+      if @sha
+        kind, rev = "ref", @sha
+      else
+        kind, rev = "branch", branch
+      end
+      { :kind => kind, :rev => rev }
+    end
+
     # @param [#to_s] destination
     #
     # @return [Berkshelf::CachedCookbook]
@@ -46,14 +56,12 @@ module Berkshelf
         return local_revision(destination)
       end
 
-      Berkshelf::Git.checkout(clone, ref || branch) if ref || branch
+      Berkshelf::Git.checkout(clone, ref || checkout_info[:rev])
       @ref = Berkshelf::Git.rev_parse(clone)
 
       tmp_path = rel ? File.join(clone, rel) : clone
       unless File.chef_cookbook?(tmp_path)
-        msg = "Cookbook '#{dependency.name}' not found at git: #{uri}"
-        msg << " with branch '#{branch}'" if branch
-        msg << " with ref '#{ref}'" if ref
+        msg = "Cookbook '#{dependency.name}' not found at git: #{to_display}"
         msg << " at path '#{rel}'" if rel
         raise CookbookNotFound, msg
       end
@@ -76,21 +84,25 @@ module Berkshelf
     end
 
     def to_s
-      s = "#{self.class.location_key}: '#{uri}'"
-      s << " with branch: '#{branch}'" if branch
-      s << " at ref: '#{ref}'" if ref
-      s
+      "#{self.class.location_key}: #{to_display}"
     end
 
     private
 
+      def to_display
+        info = checkout_info
+        s = "'#{uri}' with #{info[:kind]}: '#{info[:rev]}'"
+        s << " at ref: '#{ref}'" if ref && (info[:kind] != "ref" || ref != info[:rev])
+        s
+      end
+
       def git
         @git ||= Berkshelf::Git.new(uri)
       end
 
       def clone
         tmp_clone = File.join(self.class.tmpdir, uri.gsub(/[\/:]/,'-'))
-
+        FileUtils.mkdir_p(File.join(File.split(tmp_clone).shift))
         unless File.exists?(tmp_clone)
           Berkshelf::Git.clone(uri, tmp_clone)
         end

data/lib/berkshelf/locations/github_location.rb

@@ -19,6 +19,9 @@ module Berkshelf
     #   the protocol with which to communicate with GitHub
     def initialize(dependency, options = {})
       @repo_identifier = options.delete(:github)
+      if repo_identifier.end_with?(".git")
+        raise InvalidGitHubIdentifier.new(repo_identifier)
+      end
       @protocol        = (options.delete(:protocol) || DEFAULT_PROTOCOL).to_sym
       options[:git]    = github_url
       super
@@ -43,13 +46,6 @@ module Berkshelf
       end
     end
 
-    def to_s
-      s = "#{self.class.location_key}: '#{repo_identifier}'"
-      s << " with branch: '#{branch}'" if branch
-      s << " over protocol: '#{protocol}'"
-      s
-    end
-
     private
 
       def default_protocol?