berkshelf 1.4.6 → 2.0.0.beta

data/lib/berkshelf/formatters.rb

@@ -69,28 +69,22 @@ module Berkshelf
         end
       end
 
-      def cleanup_hook
-        # run after the task is finished
-      end
-
-      def install(cookbook, version, location)
-        raise AbstractFunction, "#install must be implemented on #{self.class}"
-      end
-
-      def use(cookbook, version, path = nil)
-        raise AbstractFunction, "#install must be implemented on #{self.class}"
-      end
-
-      def upload(cookbook, version, chef_server_url)
-        raise AbstractFunction, "#upload must be implemented on #{self.class}"
+      class << self
+        private
+
+        def formatter_methods(*args)
+          args.each do |meth|
+            define_method(meth.to_sym) do |*args|
+              raise AbstractFunction, "##{meth} must be implemented on #{self.class}"
+            end unless respond_to?(meth.to_sym)
+          end
+        end
       end
 
-      def msg(message)
-        raise AbstractFunction, "#msg must be implemented on #{self.class}"
-      end
+      formatter_methods :install, :use, :upload, :msg, :error, :package
 
-      def error(message)
-        raise AbstractFunction, "#error must be implemented on #{self.class}"
+      def cleanup_hook
+        # run after the task is finished
       end
 
       private

data/lib/berkshelf/formatters/human_readable.rb

@@ -33,6 +33,14 @@ module Berkshelf
         Berkshelf.ui.info "Uploading #{cookbook} (#{version}) to: '#{chef_api_url}'"
       end
 
+      # Output a Cookbook package message using {Berkshelf.ui}
+      #
+      # @param [String] cookbook
+      # @param [String] destination
+      def package(cookbook, destination)
+        Berkshelf.ui.info "Cookbook '#{cookbook}' saved to #{destination}!"
+      end
+
       # Output a generic message using {Berkshelf.ui}
       #
       # @param [String] message

data/lib/berkshelf/formatters/json.rb

@@ -7,6 +7,8 @@ module Berkshelf
       register_formatter :json
 
       def initialize
+        Berkshelf.ui.mute!
+
         @output = {
           cookbooks: Array.new,
           errors: Array.new,
@@ -22,7 +24,7 @@ module Berkshelf
           output[:cookbooks] << details
         end
 
-        print MultiJson.dump(output)
+        print ::JSON.pretty_generate(output)
       end
 
       # Add a Cookbook installation entry to delayed output
@@ -58,6 +60,15 @@ module Berkshelf
         cookbooks[cookbook][:uploaded_to] = chef_api_url
       end
 
+      # Add a Cookbook package entry to delayed output
+      #
+      # @param [String] cookbook
+      # @param [String] destination
+      def package(cookbook, destination)
+        cookbooks[cookbook] ||= {}
+        cookbooks[cookbook][:destination] = destination
+      end
+
       # Add a generic message entry to delayed output
       #
       # @param [String] message

data/lib/berkshelf/formatters/null.rb

@@ -0,0 +1,23 @@
+module Berkshelf
+  module Formatters
+    # @author Seth Vargo <sethvargo@gmail.com>
+    class Null
+      include AbstractFormatter
+
+      register_formatter :null
+
+      # The abstract formatter dynamically defines methods that raise an
+      # AbstractFunction error. We need to define all of those on our class,
+      # otherwise they will be inherited by the Ruby object model.
+      AbstractFormatter.instance_methods.each do |meth|
+        define_method(meth) do |*args|
+          # intentionally do nothing
+        end
+      end
+
+      def method_missing(meth, *args, &block)
+        # intentionally do nothing
+      end
+    end
+  end
+end

data/lib/berkshelf/init_generator.rb

@@ -19,15 +19,18 @@ module Berkshelf
 
     class_option :skip_vagrant,
       type: :boolean,
-      default: false
+      default: false,
+      desc: "Skips adding a Vagrantfile and adding supporting gems to the Gemfile"
 
     class_option :skip_git,
       type: :boolean,
-      default: false
+      default: false,
+      desc: "Skips adding a .gitignore and running git init in the cookbook directory"
 
     class_option :foodcritic,
       type: :boolean,
-      default: false
+      default: false,
+      desc: "Creates a Thorfile with Foodcritic support to lint test your cookbook"
 
     class_option :chef_minitest,
       type: :boolean,
@@ -35,20 +38,22 @@ module Berkshelf
 
     class_option :scmversion,
       type: :boolean,
-      default: false
+      default: false,
+      desc: "Creates a Thorfile with SCMVersion support to manage versions for continuous integration"
 
     class_option :no_bundler,
       type: :boolean,
-      default: false
+      default: false,
+      desc: "Skips generation of a Gemfile and other Bundler specific support"
 
     class_option :cookbook_name,
       type: :string
 
-    class_option :berkshelf_config,
-      type: :hash,
-      default: Config.instance
+    class_option :skip_test_kitchen,
+      type: :boolean,
+      default: false,
+      desc: "Skip adding a testing environment to your cookbook"
 
-    # Generate the cookbook
     def generate
       validate_configuration
       check_option_support
@@ -87,6 +92,10 @@ module Berkshelf
         template "Gemfile.erb", target.join("Gemfile")
       end
 
+      unless options[:skip_test_kitchen]
+        Kitchen::Generator::Init.new([], options).invoke_all
+      end
+
       unless options[:skip_vagrant]
         template "Vagrantfile.erb", target.join("Vagrantfile")
         ::Berkshelf::Cli.new([], berksfile: target.join("Berksfile")).invoke(:install)
@@ -95,6 +104,10 @@ module Berkshelf
 
     private
 
+      def berkshelf_config
+        Berkshelf::Config.instance
+      end
+
       # Read the cookbook name from the metadata.rb
       #
       # @return [String]
@@ -119,7 +132,6 @@ module Berkshelf
         end
       end
 
-
       # Check for supporting gems for provided options
       #
       # @return [Boolean]
@@ -127,7 +139,6 @@ module Berkshelf
         assert_option_supported(:foodcritic) &&
         assert_option_supported(:scmversion, 'thor-scmversion') &&
         assert_default_supported(:no_bundler, 'bundler')
-        # Vagrant is a dependency of Berkshelf; it will always appear available to the Berkshelf process.
       end
 
       # Warn if the supporting gem for an option is not installed

data/lib/berkshelf/location.rb

@@ -145,19 +145,17 @@ module Berkshelf
     #
     # @raise [CookbookValidationFailure] if given CachedCookbook does not satisfy the constraint of the location
     #
+    # @todo Change MismatchedCookbookName to raise instead of warn
+    #
     # @return [Boolean]
     def validate_cached(cached_cookbook)
       unless version_constraint.satisfies?(cached_cookbook.version)
-        msg = "Cookbook downloaded for '#{self.name}' from #{self} does not satisfy the version constraint"
-        msg << " (#{self.version_constraint}). This usually happens if the Chef server contains a cookbook that"
-        msg << " contains a metadata file with a missing or mis-matched version number."
-        raise CookbookValidationFailure, msg
+        raise CookbookValidationFailure.new(self, cached_cookbook)
       end
 
-      # JW TODO: Safe to uncomment when when Opscode makes the 'name' a required attribute in Cookbook metadata
-      # unless self.name == cached_cookbook.cookbook_name
-      #   raise AmbiguousCookbookName, "Expected a cookbook at #{self} to be named '#{self.name}'. Did you set the 'name' attribute in your Cookbooks metadata? If you didn't, the name of the directory will be used as the name of your Cookbook (awful, right?)."
-      # end
+      unless self.name == cached_cookbook.cookbook_name
+        Berkshelf.ui.warn(MismatchedCookbookName.new(self, cached_cookbook).to_s)
+      end
 
       true
     end
@@ -168,8 +166,8 @@ module Berkshelf
       }
     end
 
-    def to_json
-      MultiJson.dump(self.to_hash, pretty: true)
+    def to_json(options = {})
+      JSON.pretty_generate(to_hash, options)
     end
 
     private

data/lib/berkshelf/locations/chef_api_location.rb

@@ -4,7 +4,7 @@ module Berkshelf
     class << self
       # @return [Proc]
       def finalizer
-        proc { conn.terminate if conn.alive? }
+        proc { conn.terminate if defined?(conn) && conn.alive? }
       end
 
       # @param [String] node_name
@@ -150,7 +150,7 @@ module Berkshelf
     # @return [Berkshelf::CachedCookbook]
     def download(destination)
       berks_path = File.join(destination, "#{name}-#{target_cookbook.version}")
-      
+
       temp_path = target_cookbook.download
       FileUtils.mv(temp_path, berks_path)
 
@@ -174,14 +174,13 @@ module Berkshelf
         else
           conn.cookbook.latest_version(name)
         end
-      rescue Ridley::Errors::HTTPNotFound,
-             Ridley::Errors::ResourceNotFound
+      rescue Ridley::Errors::HTTPNotFound
         @target_cookbook = nil
       end
 
       if @target_cookbook.nil?
         msg = "Cookbook '#{name}' found at #{self}"
-        msg << " that would satisfy constraint (#{version_constraint}" if version_constraint
+        msg << " that would satisfy constraint (#{version_constraint})" if version_constraint
         raise CookbookNotFound, msg
       end
 

data/lib/berkshelf/locations/git_location.rb

@@ -20,10 +20,9 @@ module Berkshelf
     attr_accessor :uri
     attr_accessor :branch
     attr_accessor :rel
-    attr_accessor :branch_name
+    attr_accessor :ref
     attr_reader :options
 
-    alias_method :ref, :branch
     alias_method :tag, :branch
 
     # @param [#to_s] name
@@ -44,9 +43,9 @@ module Berkshelf
       @name               = name
       @version_constraint = version_constraint
       @uri                = options[:git]
-      @branch             = options[:branch] || options[:ref] || options[:tag] || "master"
+      @branch             = options[:branch] || options[:tag] || 'master'
+      @ref                = options[:ref]
       @rel                = options[:rel]
-      @branch_name        = @branch.gsub("-", "_").gsub("/", "__")  # In case the remote is specified
 
       Git.validate_uri!(@uri)
     end
@@ -55,22 +54,24 @@ module Berkshelf
     #
     # @return [Berkshelf::CachedCookbook]
     def download(destination)
-      return local_revision(destination) if cached?(destination)
-
-      ::Berkshelf::Git.checkout(clone, branch) if branch
-      unless branch
-        self.branch = ::Berkshelf::Git.rev_parse(clone)
+      if cached?(destination)
+        @ref = Berkshelf::Git.rev_parse(revision_path(destination))
+        return local_revision(destination)
       end
 
+      Berkshelf::Git.checkout(clone, ref || branch) if ref || branch
+      @ref = Berkshelf::Git.rev_parse(clone)
+
       tmp_path = rel ? File.join(clone, rel) : clone
       unless File.chef_cookbook?(tmp_path)
         msg = "Cookbook '#{name}' not found at git: #{uri}"
         msg << " with branch '#{branch}'" if branch
+        msg << " with ref '#{ref}'" if ref
         msg << " at path '#{rel}'" if rel
         raise CookbookNotFound, msg
       end
 
-      cb_path = File.join(destination, "#{name}-#{branch_name}")
+      cb_path = File.join(destination, "#{name}-#{ref}")
       FileUtils.rm_rf(cb_path)
       FileUtils.mv(tmp_path, cb_path)
 
@@ -91,6 +92,7 @@ module Berkshelf
     def to_s
       s = "#{self.class.location_key}: '#{uri}'"
       s << " with branch: '#{branch}'" if branch
+      s << " at ref: '#{ref}'" if ref
       s
     end
 
@@ -122,8 +124,8 @@ module Berkshelf
       end
 
       def revision_path(destination)
-        return unless branch
-        File.join(destination, "#{name}-#{branch_name}")
+        return unless ref
+        File.join(destination, "#{name}-#{ref}")
       end
   end
 end

data/lib/berkshelf/locations/path_location.rb

@@ -57,8 +57,23 @@ module Berkshelf
       super.merge(value: self.path)
     end
 
+    # The string representation of this PathLocation. If the path
+    # is the default cookbook store, just leave it out, because
+    # it's probably just cached.
+    #
+    # @example
+    #   loc.to_s #=> artifact (1.4.0)
+    #
+    # @example
+    #   loc.to_s #=> artifact (1.4.0) at path: '/Users/Seth/Dev/artifact'
+    #
+    # @return [String]
     def to_s
-      "#{self.class.location_key}: '#{path}'"
+      if path.to_s.include?(Berkshelf.berkshelf_path.to_s)
+        "#{self.class.location_key}"
+      else
+        "#{self.class.location_key}: '#{path}'"
+      end
     end
   end
 end

data/lib/berkshelf/locations/site_location.rb

@@ -22,9 +22,7 @@ module Berkshelf
       @name               = name
       @version_constraint = version_constraint
 
-      api_uri = if options[:site].nil?
-        SHORTNAMES[:opscode]
-      elsif SHORTNAMES.has_key?(options[:site])
+      api_uri = if options[:site].nil? || SHORTNAMES.has_key?(options[:site])
         SHORTNAMES[options[:site]]
       elsif options[:site].kind_of?(Symbol)
         raise InvalidSiteShortnameError.new(options[:site])

data/lib/berkshelf/lockfile.rb

@@ -1,54 +1,251 @@
 module Berkshelf
+  # The object representation of the Berkshelf lockfile. The lockfile is useful
+  # when working in teams where the same cookbook versions are desired across
+  # multiple workstations.
+  #
+  # @author Seth Vargo <sethvargo@gmail.com>
   class Lockfile
-    class << self
-      def remove!
-        FileUtils.rm_f DEFAULT_FILENAME
-      end
+    # @return [Pathname]
+    #   the path to this Lockfile
+    attr_reader :filepath
 
-      # @param [Array<CookbookSource>] sources
-      def update!(sources)
-        contents = File.readlines(DEFAULT_FILENAME)
-        contents.delete_if do |line|
-          line =~ /cookbook '(#{sources.map(&:name).join('|')})'/
-        end
+    # @return [Berkshelf::Berksfile]
+    #   the Berksfile for this Lockfile
+    attr_reader :berksfile
 
-        contents += sources.map { |source| definition(source) }
-        File.open(DEFAULT_FILENAME, 'wb') { |f| f.write(contents.join("\n").squeeze("\n")) }
-      end
+    # @return [String]
+    #   the last known SHA of the Berksfile
+    attr_accessor :sha
 
-      # @param [CookbookSource] source
-      #
-      # @return [String]
-      def definition(source)
-        definition = "cookbook '#{source.name}'"
+    # Create a new lockfile instance associated with the given Berksfile. If a
+    # Lockfile exists, it is automatically loaded. Otherwise, an empty instance is
+    # created and ready for use.
+    #
+    # @param berksfile [Berkshelf::Berksfile]
+    #   the Berksfile associated with this Lockfile
+    def initialize(berksfile)
+      @berksfile = berksfile
+      @filepath  = File.expand_path("#{berksfile.filepath}.lock")
+      @sources   = {}
+
+      load! if File.exists?(@filepath)
+    end
 
-        if source.location.is_a?(GitLocation)
-          definition += ", :git => '#{source.location.uri}', :ref => '#{source.location.branch || 'HEAD'}'"
-        elsif source.location.is_a?(PathLocation)
-          definition += ", :path => '#{source.location.path}'"
+    # Load the lockfile from file system.
+    def load!
+      contents = File.read(filepath)
+
+      begin
+        hash = JSON.parse(contents, symbolize_names: true)
+      rescue JSON::ParserError
+        if contents =~ /^cookbook ["'](.+)["']/
+          Berkshelf.ui.warn "You are using the old lockfile format. Attempting to convert..."
+          hash = LockfileLegacy.parse(contents)
         else
-          definition += ", :locked_version => '#{source.locked_version}'"
+          raise
         end
+      end
+
+      @sha = hash[:sha]
 
-        definition
+      hash[:sources].each do |name, options|
+        add(CookbookSource.new(berksfile, name.to_s, options))
       end
     end
 
-    DEFAULT_FILENAME = "#{Berkshelf::DEFAULT_FILENAME}.lock".freeze
+    # Set the sha value to nil to mark that the lockfile is not out of
+    # sync with the Berksfile.
+    def reset_sha!
+      @sha = nil
+    end
+
+    # The list of sources constrained in this lockfile.
+    #
+    # @return [Array<Berkshelf::CookbookSource>]
+    #   the list of sources in this lockfile
+    def sources
+      @sources.values
+    end
+
+    # Find the given source in this lockfile. This method accepts a source
+    # attribute which may either be the name of a cookbook (String) or an
+    # actual cookbook source.
+    #
+    # @param [String, Berkshelf::CookbookSource] source
+    #   the cookbook source/name to find
+    # @return [CookbookSource, nil]
+    #   the cookbook source from this lockfile or nil if one was not found
+    def find(source)
+      @sources[cookbook_name(source).to_s]
+    end
+
+    # Determine if this lockfile contains the given source.
+    #
+    # @param [String, Berkshelf::CookbookSource] source
+    #   the cookbook source/name to determine existence of
+    # @return [Boolean]
+    #   true if the source exists, false otherwise
+    def has_source?(source)
+      !find(source).nil?
+    end
+
+    # Replace the current list of sources with `sources`. This method does
+    # not write out the lockfile - it only changes the state of the object.
+    #
+    # @param [Array<Berkshelf::CookbookSource>] sources
+    #   the list of sources to update
+    # @option options [String] :sha
+    #   the sha of the Berksfile updating the sources
+    def update(sources, options = {})
+      reset_sources!
+      @sha = options[:sha]
+
+      sources.each { |source| append(source) }
+      save
+    end
+
+    # Add the given source to the `sources` list, if it doesn't already exist.
+    #
+    # @param [Berkshelf::CookbookSource] source
+    #   the source to append to the sources list
+    def add(source)
+      @sources[cookbook_name(source)] = source
+    end
+    alias_method :append, :add
+
+    # Remove the given source from this lockfile. This method accepts a source
+    # attribute which may either be the name of a cookbook (String) or an
+    # actual cookbook source.
+    #
+    # @param [String, Berkshelf::CookbookSource] source
+    #   the cookbook source/name to remove
+    #
+    # @raise [Berkshelf::CookbookNotFound]
+    #   if the provided source does not exist
+    def remove(source)
+      unless has_source?(source)
+        raise Berkshelf::CookbookNotFound, "'#{cookbook_name(source)}' does not exist in this lockfile!"
+      end
+
+      @sources.delete(cookbook_name(source))
+    end
+    alias_method :unlock, :remove
 
-    attr_reader :sources
+    # @return [String]
+    #   the string representation of the lockfile
+    def to_s
+      "#<Berkshelf::Lockfile #{Pathname.new(filepath).basename}>"
+    end
 
-    def initialize(sources)
-      @sources = Array(sources)
+    # @return [String]
+    #   the detailed string representation of the lockfile
+    def inspect
+      "#<Berkshelf::Lockfile #{Pathname.new(filepath).basename}, sources: #{sources.inspect}>"
     end
 
-    def write(filename = DEFAULT_FILENAME)
-      content = sources.map { |source| self.class.definition(source) }.join("\n")
-      File.open(filename, "wb") { |f| f.write content }
+    # Write the current lockfile to a hash
+    #
+    # @return [Hash]
+    #   the hash representation of this lockfile
+    #   * :sha [String] the last-known sha for the berksfile
+    #   * :sources [Array<Berkshelf::CookbookSource>] the list of sources
+    def to_hash
+      {
+        sha: sha,
+        sources: @sources
+      }
     end
 
-    def remove!
-      self.class.remove!
+    # The JSON representation of this lockfile
+    #
+    # Relies on {#to_hash} to generate the json
+    #
+    # @return [String]
+    #   the JSON representation of this lockfile
+    def to_json(options = {})
+      JSON.pretty_generate(to_hash, options)
     end
+
+    private
+
+      # Save the contents of the lockfile to disk.
+      def save
+        File.open(filepath, 'w') do |file|
+          file.write to_json + "\n"
+        end
+      end
+
+      # Clear the sources array
+      def reset_sources!
+        @sources = {}
+      end
+
+      # Return the name of this cookbook (because it's the key in our
+      # table).
+      #
+      # @param [Berkshelf::CookbookSource, #to_s] source
+      #   the source to find the name from
+      #
+      # @return [String]
+      #   the name of the cookbook
+      def cookbook_name(source)
+        source.is_a?(CookbookSource) ? source.name : source.to_s
+      end
+
+      # Legacy support for old lockfiles
+      #
+      # @author Seth Vargo <sethvargo@gmail.com>
+      # @todo Remove this class in the next major release.
+      class LockfileLegacy
+        class << self
+          # Read the old lockfile content and instance eval in context.
+          #
+          # @param [String] content
+          #   the string content read from a legacy lockfile
+          def parse(content)
+            sources = {}.tap do |hash|
+              content.split("\n").each do |line|
+                next if line.empty?
+
+                source = self.new(line)
+                hash[source.name] = source.options
+              end
+            end
+
+            {
+              sha: nil,
+              sources: sources
+            }
+          end
+        end
+
+        # @return [Hash]
+        #   the hash of options
+        attr_reader :options
+
+        # @return [String]
+        #   the name of this cookbook
+        attr_reader :name
+
+        # Create a new legacy lockfile for processing
+        #
+        # @param [String] content
+        #   the content to parse out and convert to a hash
+        def initialize(content)
+          instance_eval(content).to_hash
+        end
+
+        # Method defined in legacy lockfiles (since we are using
+        # instance_eval).
+        #
+        # @param [String] name
+        #   the name of this cookbook
+        # @option options [String] :locked_version
+        #   the locked version of this cookbook
+        def cookbook(name, options = {})
+          @name = name
+          @options = options
+        end
+      end
   end
 end