berkshelf 2.0.3 → 2.0.4

data/features/step_definitions/json_steps.rb

@@ -20,7 +20,7 @@ Then /^the file "(.*?)" should contain JSON:$/ do |file, data|
 end
 
 Then /^the output should contain JSON:$/ do |data|
-  target = JSON.pretty_generate(JSON.parse(ERB.new(data).result(binding)).sort_by_key)
+  target = JSON.pretty_generate(JSON.parse(data).sort_by_key)
   actual = JSON.pretty_generate(JSON.parse(all_output).sort_by_key)
 
   expect(actual).to eq(target)

data/features/update_command.feature

@@ -44,7 +44,7 @@ Feature: Updating a cookbook defined by a Berksfile
     And I write to "Berksfile.lock" with:
       """
       {
-        "sha":"9d10199aa2652f9e965149c4346db20c78e97553",
+        "sha":"69b2e00e970d2bb6a9b1d09aeb3e6a17ef3df955",
         "sources":{
           "berkshelf-cookbook-fixture":{
             "locked_version":"0.1.0",
@@ -89,7 +89,7 @@ Feature: Updating a cookbook defined by a Berksfile
     And I write to "Berksfile.lock" with:
       """
       {
-        "sha":"9d10199aa2652f9e965149c4346db20c78e97553",
+        "sha":"69b2e00e970d2bb6a9b1d09aeb3e6a17ef3df955",
         "sources":{
           "berkshelf-cookbook-fixture":{
             "locked_version":"0.1.0",

data/features/upload_command.feature

@@ -293,4 +293,3 @@ Feature: Uploading cookbooks to a Chef Server
     And the Chef server should not have the cookbooks:
       | ekaf  | 2.0.0 |
     And the exit status should be 0
-

data/lib/berkshelf.rb

@@ -13,6 +13,7 @@ require 'thor'
 require 'tmpdir'
 require 'uri'
 require 'zlib'
+require 'rbzip2'
 
 require_relative 'berkshelf/core_ext'
 require_relative 'berkshelf/errors'
@@ -89,21 +90,6 @@ module Berkshelf
       @cookbook_store ||= CookbookStore.new(cookbooks_dir)
     end
 
-    # Ascend the directory structure from the given path to find a
-    # metadata.rb file of a Chef Cookbook. If no metadata.rb file
-    # was found, nil is returned.
-    #
-    # @return [Pathname]
-    #   path to metadata.rb
-    def find_metadata(path = Dir.pwd)
-      path = Pathname.new(path)
-      path.ascend do |potential_root|
-        if potential_root.entries.collect(&:to_s).include?('metadata.rb')
-          return potential_root.join('metadata.rb')
-        end
-      end
-    end
-
     # Get the appropriate Formatter object based on the formatter
     # classes that have been registered.
     #

data/lib/berkshelf/berksfile.rb

@@ -90,9 +90,9 @@ module Berkshelf
     end
 
     # @return [String]
-    #   the shasum for the Berksfile
+    #   the shasum for the sources in the Berksfile (or metadata/path locations)
     def sha
-      @sha ||= Digest::SHA1.hexdigest File.read(filepath.to_s)
+      @sha ||= Digest::SHA1.hexdigest(shaable_contents.join("\n"))
     end
 
     # Add a cookbook source to the Berksfile to be retrieved and have it's dependencies recursively retrieved
@@ -193,23 +193,14 @@ module Berkshelf
     def metadata(options = {})
       path = options[:path] || File.dirname(filepath)
 
-      metadata_file = Berkshelf.find_metadata(path)
+      metadata_path = File.expand_path(File.join(path, 'metadata.rb'))
+      metadata = Ridley::Chef::Cookbook::Metadata.from_file(metadata_path)
 
-      unless metadata_file
-        raise CookbookNotFound, "No 'metadata.rb' found at #{path}"
-      end
-
-      metadata = Ridley::Chef::Cookbook::Metadata.from_file(metadata_file.to_s)
-
-      name = if metadata.name.empty? || metadata.name.nil?
-        File.basename(File.dirname(metadata_file))
-      else
-        metadata.name
-      end
+      shaable_contents << File.read(metadata_path)
 
-      constraint = "= #{metadata.version}"
+      name = metadata.name.presence || File.basename(File.expand_path(path))
 
-      add_source(name, constraint, path: File.dirname(metadata_file))
+      add_source(name, nil, { path: path, metadata: true })
     end
 
     # Add a 'Site' default location which will be used to resolve cookbook sources that do not
@@ -274,6 +265,11 @@ module Berkshelf
         end
       end
 
+      if options[:path]
+        metadata_file = File.expand_path(File.join(options[:path], 'metadata.rb'))
+        shaable_contents << File.read(metadata_file)
+      end
+
       options[:constraint] = constraint
 
       @sources[name] = CookbookSource.new(self, name, options)
@@ -389,10 +385,11 @@ module Berkshelf
     #    sources are considered to be "unlocked". If a lockfile is specified, a
     #    definition is created via the following algorithm:
     #
-    #    - Compare the SHA of the current Berksfile with the last-known SHA.
-    #    - If the SHAs match, the Berksfile has not been updated, so we rely
-    #      solely on the locked sources.
-    #    - If the SHAs don't match, then the Berksfile has diverged from the
+    #    - Compare the SHA of the current sources (as JSON) with the last-known
+    #      SHA of the sources.
+    #    - If the SHAs match, the sources have not been updated, so we can rely
+    #      solely on the locked ones.
+    #    - If the SHAs don't match, then the sources have diverged from the
     #      lockfile, which means some sources are outdated. For each unlocked
     #      source, see if there exists a locked version that still satisfies
     #      the version constraint in the Berksfile. If there exists such a
@@ -791,7 +788,8 @@ module Berkshelf
         path = cookbook.path.to_s
 
         files = Dir.glob(File.join(path, '**', '*.rb')).select do |f|
-          f =~ /[[:space:]]/
+          parent = Pathname.new(path).dirname.to_s
+          f.gsub(parent, '') =~ /[[:space:]]/
         end
 
         raise Berkshelf::InvalidCookbookFiles.new(cookbook, files) unless files.empty?
@@ -824,5 +822,13 @@ module Berkshelf
           end
         end
       end
+
+      # The contents of the files that we want to SHA for caching against
+      # the lockfile.
+      #
+      # @return [Array<String>]
+      def shaable_contents
+        @shaable_contents ||= [File.read(self.filepath)]
+      end
   end
 end

data/lib/berkshelf/cli.rb

@@ -2,9 +2,8 @@ require 'berkshelf'
 require_relative 'config'
 require_relative 'init_generator'
 require_relative 'cookbook_generator'
-
-require 'berkshelf/commands/test_command'
-require 'berkshelf/commands/shelf'
+require_relative 'commands/shelf'
+require_relative 'commands/test_command'
 
 module Berkshelf
   class Cli < Thor

data/lib/berkshelf/commands/test_command.rb

@@ -1,4 +1,6 @@
-require 'kitchen/cli'
+begin
+  require 'kitchen/cli'
+rescue LoadError; end
 
 module Berkshelf
   class TestCommand < Kitchen::CLI
@@ -8,4 +10,4 @@ module Berkshelf
   class Cli < Thor
     register(Berkshelf::TestCommand, 'test', 'test [COMMAND]', 'Testing tasks for your cookbook', hide: true)
   end
-end
+end if defined?(Kitchen::CLI)

data/lib/berkshelf/community_rest.rb

@@ -16,6 +16,8 @@ module Berkshelf
           Archive::Tar::Minitar.unpack(Zlib::GzipReader.new(File.open(target, 'rb')), destination)
         elsif is_tar_file(target)
           Archive::Tar::Minitar.unpack(target, destination)
+        elsif is_bzip2_file(target)
+          Archive::Tar::Minitar.unpack(RBzip2::Decompressor.new(File.open(target, 'rb')), destination)
         else
           raise Berkshelf::UnknownCompressionType.new(target)
         end
@@ -46,6 +48,10 @@ module Berkshelf
         def is_tar_file(path)
           IO.binread(path, 8, 257).to_s == "ustar\x0000"
         end
+
+        def is_bzip2_file(path)
+          IO.binread(path, 3) == 'BZh'
+        end
     end
 
     V1_API = 'http://cookbooks.opscode.com/api/v1/cookbooks'.freeze

data/lib/berkshelf/cookbook_source.rb

@@ -93,6 +93,8 @@ module Berkshelf
     #   a URL pointing to a community API endpoint
     # @option options [String] :path
     #   a filepath to the cookbook on your local disk
+    # @option options [String] :metadata
+    #   use the metadata at the given pat
     # @option options [Symbol, Array] :group
     #   the group or groups that the cookbook belongs to
     # @option options [String] :ref
@@ -131,7 +133,7 @@ module Berkshelf
     #
     # @return [Array<CachedCookbook, Location>]
     def cached_and_location(options = {})
-      from_path(options) || from_cache(options) || from_default(options)
+      from_path(options) || from_default(options)
     end
 
     # Returns true if the cookbook source has already been downloaded. A cookbook
@@ -192,14 +194,20 @@ module Berkshelf
 
     def to_hash
       {}.tap do |h|
-        h[:locked_version]  = locked_version.to_s
+        unless location.kind_of?(PathLocation)
+          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?(SiteLocation) && location.api_uri != CommunityREST::V1_API
-          h[:site] = location.api_uri
+        if location.kind_of?(SiteLocation)
+          h[:site] = location.api_uri if location.api_uri != CommunityREST::V1_API
+        end
+
+        if location.kind_of?(PathLocation)
+          h[:path] = location.relative_path(berksfile.filepath)
         end
 
         if location.kind_of?(GitLocation)
@@ -207,11 +215,6 @@ module Berkshelf
           h[:ref] = location.ref
           h[:rel] = location.rel if location.rel
         end
-
-        # Path is intentionally left relative here for cross-team compatibility
-        if @options[:path]
-          h[:path] = @options[:path].to_s
-        end
       end.reject { |k,v| v.blank? }
     end
 
@@ -220,42 +223,24 @@ module Berkshelf
     end
 
     private
-
       # Attempt to load a CachedCookbook from a local file system path (if the :path
       # option was given). If one is found, the location and cached_cookbook is
       # updated. Otherwise, this method will raise a CookbookNotFound exception.
       #
-      # @raises [Berkshelf::CookbookNotFound]
+      # @raise [Berkshelf::CookbookNotFound]
       #   if no CachedCookbook exists at the given path
       #
       # @return [Berkshelf::CachedCookbook]
       def from_path(options = {})
         return nil unless options[:path]
 
-        path     = File.expand_path(PathLocation.normalize_path(options[:path]), File.dirname(berksfile.filepath))
-        location = PathLocation.new(name, version_constraint, path: path)
-        cached   = CachedCookbook.from_path(location.path)
+        location = PathLocation.new(name, version_constraint, options)
 
-        [ cached, location ]
+        [ location.cookbook, location ]
       rescue IOError => ex
         raise Berkshelf::CookbookNotFound, ex
       end
 
-      # Attempt to load a CachedCookbook from the local CookbookStore. This will save
-      # the need to make an http request to download a cookbook we already have cached
-      # locally.
-      #
-      # @return [Berkshelf::CachedCookbook, nil]
-      def from_cache(options = {})
-        path = File.join(Berkshelf.cookbooks_dir, filename(options))
-        return nil unless File.exists?(path)
-
-        location = PathLocation.new(name, version_constraint, path: path)
-        cached   = CachedCookbook.from_path(path, name: name)
-
-        [ cached, location ]
-      end
-
       # Use the default location, and a nil CachedCookbook. If there is no location
       # specified,
       #
@@ -269,12 +254,5 @@ module Berkshelf
 
         [ nil, location ]
       end
-
-      # The hypothetical location of this CachedCookbook, if it were to exist.
-      #
-      # @return [String]
-      def filename(options = {})
-        "#{name}-#{options[:locked_version]}"
-      end
   end
 end

data/lib/berkshelf/core_ext/rbzip2.rb

@@ -0,0 +1,8 @@
+class RBzip2::Decompressor
+  def pos ; end
+  def pos=(*args) ; end
+  
+  def eof?
+    @io.eof?
+  end
+end

data/lib/berkshelf/downloader.rb

@@ -60,7 +60,7 @@ module Berkshelf
       @locations.select { |loc| loc[:type] == type && loc[:value] == value }.any?
     end
 
-    # Downloads the given CookbookSource.
+    # Download the given CookbookSource.
     #
     # @param [CookbookSource] source
     #   the source to download
@@ -69,69 +69,78 @@ module Berkshelf
     #   an array containing the downloaded CachedCookbook and the Location used
     #   to download the cookbook
     def download(source)
-      cached_cookbook, location = if source.location
+      if source.location
         begin
-          [source.location.download(storage_path), source.location]
-        rescue CookbookValidationFailure; raise
-        rescue
+          location = source.location
+          cached   = download_location(source, location, true)
+          source.cached_cookbook = cached
+
+          return [cached, location]
+        rescue => e
+          raise if e.kind_of?(CookbookValidationFailure)
           Berkshelf.formatter.error "Failed to download '#{source.name}' from #{source.location}"
-          raise
         end
       else
-        search_locations(source)
-      end
+        locations.each do |loc|
+          options = loc[:options].merge(loc[:type] => loc[:value])
+          location = Location.init(source.name, source.version_constraint, options)
 
-      source.cached_cookbook = cached_cookbook
+          cached = download_location(source, location)
+          if cached
+            source.cached_cookbook = cached
+            return [cached, location]
+          end
+        end
+      end
 
-      [cached_cookbook, location]
+      raise CookbookNotFound, "Cookbook '#{source.name}' not found in any of the default locations"
     end
 
     private
 
-      # Searches locations for a CookbookSource. If the source does not contain a
-      # value for {CookbookSource#location}, the default locations of this
-      # downloader will be used to attempt to retrieve the source.
+      # Attempt to download the the given source from the given location, #
+      # raising an error if `raise_if_not_found` is specified.
+      #
+      # @raise [Bershelf::CookbookNotFound]
+      #   if `raise_if_not_found` is true and the source could not be
+      #   downloaded
       #
-      # @param [CookbookSource] source
+      # @param [Berkshelf::CookbookSource] source
       #   the source to download
+      # @param [~Berkshelf::Location] location
+      #   the location to download from
+      # @param [Boolean] raise_if_not_found
+      #   raise a {Berkshelf::CookbookNotFound} error if true, otherwise,
+      #   return nil
       #
-      # @return [Array]
-      #   an array containing the downloaded CachedCookbook and the Location used
-      #   to download the cookbook
-      def search_locations(source)
-        cached_cookbook = nil
-        location = nil
-
-        locations.each do |loc|
-          location = Location.init(
-            source.name,
-            source.version_constraint,
-            loc[:options].merge(loc[:type] => loc[:value])
-          )
-          begin
-            cached_cookbook = location.download(storage_path)
-            break
-          rescue Berkshelf::CookbookNotFound
-            cached_cookbook, location = nil
-            next
-          end
-        end
-
-        if cached_cookbook.nil?
-          raise CookbookNotFound, "Cookbook '#{source.name}' not found in any of the default locations"
-        end
-
-        [ cached_cookbook, location ]
+      # @return [Berkshelf::CachedCookbook, nil]
+      #   the downloaded cached cookbook, or nil if one was not found
+      def download_location(source, location, raise_if_not_found = false)
+        from_cache(source) || location.download(storage_path)
+      rescue Berkshelf::CookbookNotFound
+        raise if raise_if_not_found
+        nil
       end
 
-
-      # Validates that a source is an instance of CookbookSource
+      # Load the cached cookbook from the cookbook store.
       #
-      # @param [CookbookSource] source
+      # @param [Berkshelf::CookbookSource] source
+      #   the source to find in the cache
       #
-      # @return [Boolean]
-      def validate_source(source)
-        source.is_a?(Berkshelf::CookbookSource)
+      # @return [Berkshelf::CachedCookbook, nil]
+      def from_cache(source)
+        # Can't safely read a git location from cache
+        return nil if source.location.kind_of?(Berkshelf::GitLocation)
+
+        if source.locked_version
+          cookbook = cookbook_store.cookbook_path(source.name, source.locked_version)
+          path = File.expand_path(File.join(storage_path, cookbook))
+
+          return nil unless File.exists?(path)
+          return Berkshelf::CachedCookbook.from_path(path, name: source.name)
+        end
+
+        cookbook_store.satisfy(source.name, source.version_constraint)
       end
   end
 end