berkshelf 2.0.18 → 3.0.0.beta1

data/lib/berkshelf/locations/git_location.rb

@@ -1,5 +1,5 @@
 module Berkshelf
-  class GitLocation
+  class GitLocation < Location::Base
     class << self
       # Create a temporary directory for the cloned repository within Berkshelf's
       # temporary directory
@@ -11,8 +11,6 @@ module Berkshelf
       end
     end
 
-    include Location
-
     set_location_key :git
     set_valid_options :ref, :branch, :tag, :rel
 
@@ -24,7 +22,6 @@ module Berkshelf
 
     alias_method :tag, :branch
 
-    # @param [#to_s] name
     # @param [Solve::Constraint] version_constraint
     # @param [Hash] options
     #
@@ -38,9 +35,8 @@ module Berkshelf
     #   same as tag
     # @option options [String] :rel
     #   the path within the repository to find the cookbook
-    def initialize(name, version_constraint, options = {})
-      @name               = name
-      @version_constraint = version_constraint
+    def initialize(dependency, options = {})
+      super
       @uri                = options[:git]
       @branch             = options[:branch] || options[:tag] || 'master'
       @ref                = options[:ref]
@@ -52,7 +48,9 @@ module Berkshelf
     # @param [#to_s] destination
     #
     # @return [Berkshelf::CachedCookbook]
-    def download(destination)
+    def do_download
+      destination = Berkshelf::CookbookStore.instance.storage_path
+
       if cached?(destination)
         @ref ||= Berkshelf::Git.rev_parse(revision_path(destination))
         return local_revision(destination)
@@ -63,14 +61,14 @@ module Berkshelf
 
       tmp_path = rel ? File.join(clone, rel) : clone
       unless File.chef_cookbook?(tmp_path)
-        msg = "Cookbook '#{name}' not found at git: #{uri}"
+        msg = "Cookbook '#{dependency.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}-#{ref}")
+      cb_path = File.join(destination, "#{dependency.name}-#{ref}")
       FileUtils.rm_rf(cb_path)
       FileUtils.mv(tmp_path, cb_path)
 
@@ -123,7 +121,7 @@ module Berkshelf
 
       def revision_path(destination)
         return unless ref
-        File.join(destination, "#{name}-#{ref}")
+        File.join(destination, "#{dependency.name}-#{ref}")
       end
   end
 end

data/lib/berkshelf/locations/github_location.rb

@@ -17,7 +17,7 @@ module Berkshelf
     #   the GitHub repo identifier to clone
     # @option options [#to_sym] :protocol
     #   the protocol with which to communicate with GitHub
-    def initialize(name, version_constraint, options = {})
+    def initialize(dependency, options = {})
       @repo_identifier = options.delete(:github)
       @protocol        = (options.delete(:protocol) || DEFAULT_PROTOCOL).to_sym
       options[:git]    = github_url

data/lib/berkshelf/locations/path_location.rb

@@ -1,5 +1,5 @@
 module Berkshelf
-  class PathLocation
+  class PathLocation < Location::Base
     class << self
       # Expand and return a string representation of the given path if it is
       # absolute or a path in the users home directory.
@@ -19,15 +19,12 @@ module Berkshelf
       end
     end
 
-    include Location
-
     set_location_key :path
     set_valid_options :path, :metadata
 
     attr_accessor :path
-    attr_reader :name
 
-    # @param [#to_s] name
+    # @param [#to_s] dependency
     # @param [Solve::Constraint] version_constraint
     # @param [Hash] options
     #
@@ -35,19 +32,14 @@ module Berkshelf
     #   a filepath to the cookbook on your local disk
     # @option options [Boolean] :metadata
     #   true if this is a metadata source
-    def initialize(name, version_constraint, options = {})
-      @name               = name
-      @version_constraint = version_constraint
-      @path               = options[:path].to_s
-      @metadata           = options[:metadata]
+    def initialize(dependency, options = {})
+      super
+      @path     = options[:path].to_s
+      @metadata = options[:metadata]
     end
 
-    # The cookbook associated with this path location.
-    #
-    # @return [Berkshelf::CachedCookbook]
-    #   the cached cookbook for this location
-    def cookbook
-      @cookbook ||= CachedCookbook.from_path(path, name: name)
+    def do_download
+      CachedCookbook.from_path(path, name: name)
     end
 
     # Returns true if the location is a metadata location. By default, no
@@ -80,23 +72,14 @@ 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)
+    # The string representation of this PathLocation
     #
     # @example
     #   loc.to_s #=> artifact (1.4.0) at path: '/Users/Seth/Dev/artifact'
     #
     # @return [String]
     def to_s
-      if path.to_s.include?(Berkshelf.berkshelf_path.to_s)
-        "#{self.class.location_key}"
-      else
-        "#{self.class.location_key}: '#{path}'"
-      end
+      "#{self.class.location_key}: '#{File.expand_path(path)}'"
     end
   end
 end

data/lib/berkshelf/lockfile.rb

@@ -1,10 +1,10 @@
+require_relative 'dependency'
+
 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.
   class Lockfile
-    require_relative 'cookbook_source'
-
     # @return [Pathname]
     #   the path to this Lockfile
     attr_reader :filepath
@@ -20,9 +20,9 @@ module Berkshelf
     # @param berksfile [Berkshelf::Berksfile]
     #   the Berksfile associated with this Lockfile
     def initialize(berksfile)
-      @berksfile = berksfile
-      @filepath  = File.expand_path("#{berksfile.filepath}.lock")
-      @sources   = {}
+      @berksfile    = berksfile
+      @filepath     = File.expand_path("#{berksfile.filepath}.lock")
+      @dependencies = {}
 
       load! if File.exists?(@filepath)
     end
@@ -30,14 +30,14 @@ module Berkshelf
     # Load the lockfile from file system.
     def load!
       contents = File.read(filepath).strip
-      hash = parse(contents)
+      hash     = parse(contents)
 
-      hash[:sources].each do |name, options|
+      hash[:dependencies].each do |name, options|
         # Dynamically calculate paths relative to the Berksfile if a path is given
         options[:path] &&= File.expand_path(options[:path], File.dirname(filepath))
 
         begin
-          add(CookbookSource.new(berksfile, name.to_s, options))
+          add(Berkshelf::Dependency.new(berksfile, name.to_s, options))
         rescue Berkshelf::CookbookNotFound
           # It's possible that a source is locked that contains a path location, and
           # that path location was renamed or no longer exists. When loading the
@@ -49,71 +49,70 @@ module Berkshelf
 
     # The list of sources constrained in this lockfile.
     #
-    # @return [Array<Berkshelf::CookbookSource>]
-    #   the list of sources in this lockfile
-    def sources
-      @sources.values
+    # @return [Array<Berkshelf::Dependency>]
+    #   the list of dependencies in this lockfile
+    def dependencies
+      @dependencies.values
     end
 
-    # Find the given source in this lockfile. This method accepts a source
+    # Find the given dependency in this lockfile. This method accepts a dependency
     # attribute which may either be the name of a cookbook (String) or an
-    # actual cookbook source.
+    # actual cookbook dependency.
     #
-    # @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]
+    # @param [String, Berkshelf::Dependency] dependency
+    #   the cookbook dependency/name to find
+    # @return [Berkshelf::Dependency, nil]
+    #   the cookbook dependency from this lockfile or nil if one was not found
+    def find(dependency)
+      @dependencies[cookbook_name(dependency).to_s]
     end
 
-    # Determine if this lockfile contains the given source.
+    # Determine if this lockfile contains the given dependency.
     #
-    # @param [String, Berkshelf::CookbookSource] source
-    #   the cookbook source/name to determine existence of
+    # @param [String, Berkshelf::Dependency] dependency
+    #   the cookbook dependency/name to determine existence of
     # @return [Boolean]
-    #   true if the source exists, false otherwise
-    def has_source?(source)
-      !find(source).nil?
+    #   true if the dependency exists, false otherwise
+    def has_dependency?(dependency)
+      !find(dependency).nil?
     end
 
-    # Replace the current list of sources with `sources`. This method does
+    # Replace the current list of dependencies with `dependencies`. 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)
-      reset_sources!
-      sources.each { |source| append(source) }
+    # @param [Array<Berkshelf::Dependency>] dependencies
+    #   the list of dependencies to update
+    def update(dependencies)
+      reset_dependencies!
+
+      dependencies.each { |dependency| append(dependency) }
       save
     end
 
-    # Add the given source to the `sources` list, if it doesn't already exist.
+    # Add the given dependency to the `dependencies` 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
+    # @param [Berkshelf::Dependency] dependency
+    #   the dependency to append to the dependencies list
+    def add(dependency)
+      @dependencies[cookbook_name(dependency)] = dependency
     end
     alias_method :append, :add
 
-    # Remove the given source from this lockfile. This method accepts a source
+    # Remove the given dependency from this lockfile. This method accepts a dependency
     # attribute which may either be the name of a cookbook (String) or an
-    # actual cookbook source.
+    # actual cookbook dependency.
     #
-    # @param [String, Berkshelf::CookbookSource] source
-    #   the cookbook source/name to remove
+    # @param [String, Berkshelf::Dependency] dependency
+    #   the cookbook dependency/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!"
+    #   if the provided dependency does not exist
+    def remove(dependency)
+      unless has_dependency?(dependency)
+        raise Berkshelf::CookbookNotFound, "'#{cookbook_name(dependency)}' does not exist in this lockfile!"
       end
 
-      @sources.delete(cookbook_name(source))
+      @dependencies.delete(cookbook_name(dependency))
     end
     alias_method :unlock, :remove
 
@@ -126,17 +125,17 @@ module Berkshelf
     # @return [String]
     #   the detailed string representation of the lockfile
     def inspect
-      "#<Berkshelf::Lockfile #{Pathname.new(filepath).basename}, sources: #{sources.inspect}>"
+      "#<Berkshelf::Lockfile #{Pathname.new(filepath).basename}, dependencies: #{dependencies.inspect}>"
     end
 
     # Write the current lockfile to a hash
     #
     # @return [Hash]
     #   the hash representation of this lockfile
-    #   * :sources [Array<Berkshelf::CookbookSource>] the list of sources
+    #   * :dependencies [Array<Berkshelf::Dependency>] the list of dependencies
     def to_hash
       {
-        sources: @sources
+        dependencies: @dependencies
       }
     end
 
@@ -159,12 +158,23 @@ module Berkshelf
       # @return [Hash]
       def parse(contents)
         # Ruby's JSON.parse cannot handle an empty string/file
-        return { sha: nil, sources: [] } if contents.strip.empty?
+        return { dependencies: [] } if contents.strip.empty?
+
+        hash = JSON.parse(contents, symbolize_names: true)
 
-        JSON.parse(contents, symbolize_names: true)
+        # Legacy support for 2.0 lockfiles
+        # @todo Remove in 4.0
+        if hash[:sources]
+          LockfileLegacy.warn!
+          hash[:dependencies] = hash.delete(:sources)
+        end
+
+        return hash
       rescue Exception => e
+        # Legacy support for 1.0 lockfiles
+        # @todo Remove in 4.0
         if e.class == JSON::ParserError && contents =~ /^cookbook ["'](.+)["']/
-          Berkshelf.ui.warn 'You are using the old lockfile format. Attempting to convert...'
+          LockfileLegacy.warn!
           return LockfileLegacy.parse(berksfile, contents)
         else
           raise Berkshelf::LockfileParserError.new(filepath, e)
@@ -178,29 +188,26 @@ module Berkshelf
         end
       end
 
-      # Clear the sources array
-      def reset_sources!
-        @sources = {}
+      def reset_dependencies!
+        @dependencies = {}
       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
+      # @param [Berkshelf::Dependency, #to_s] dependency
+      #   the dependency 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
+      def cookbook_name(dependency)
+        dependency.is_a?(Berkshelf::Dependency) ? dependency.name : dependency.to_s
       end
 
       # Legacy support for old lockfiles
       #
       # @todo Remove this class in Berkshelf 3.0.0
       class LockfileLegacy
-        require 'pathname'
-
         class << self
           # Read the old lockfile content and instance eval in context.
           #
@@ -209,19 +216,34 @@ module Berkshelf
           # @param [String] content
           #   the string content read from a legacy lockfile
           def parse(berksfile, content)
-            sources = {}.tap do |hash|
+            dependencies = {}.tap do |hash|
               content.split("\n").each do |line|
                 next if line.empty?
-
-                source = self.new(berksfile, line)
+                source            = new(berksfile, line)
                 hash[source.name] = source.options
               end
             end
 
             {
-              sources: sources,
+              dependencies: dependencies,
             }
           end
+
+          # Warn the user they he/she is using an old Lockfile format.
+          #
+          # This automatically outputs to the {Berkshelf.ui}; nothing is
+          # returned.
+          #
+          # @return [nil]
+          def warn!
+            Berkshelf.ui.warn(warning_message)
+          end
+
+          private
+            # @return [String]
+            def warning_message
+              'You are using the old lockfile format. Attempting to convert...'
+            end
         end
 
         # @return [Hash]
@@ -245,19 +267,19 @@ module Berkshelf
           instance_eval(content).to_hash
         end
 
-        # Method defined in legacy lockfiles (since we are using
-        # instance_eval).
+        # 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
+          @name    = name
           @options = manipulate(options)
         end
 
         private
+
           # Perform various manipulations on the hash.
           #
           # @param [Hash] options