berkshelf 0.4.0.rc4 → 0.4.0

data/lib/berkshelf/cached_cookbook.rb

@@ -94,7 +94,6 @@ module Berkshelf
     attr_reader :manifest
 
     def_delegator :@metadata, :version
-    def_delegator :@metadata, :dependencies
 
     def initialize(name, path, metadata)
       @cookbook_name = name
@@ -125,6 +124,11 @@ module Berkshelf
       "#{cookbook_name}-#{version}"
     end
 
+    # @return [Hash]
+    def dependencies
+      metadata.recommendations.merge(metadata.dependencies)
+    end
+
     # @return [Hash]
     #   an hash containing the checksums and expanded file paths of all of the
     #   files found in the instance of CachedCookbook

data/lib/berkshelf/cli.rb

@@ -59,6 +59,10 @@ module Berkshelf
       banner: "PATH"
     desc "install", "Install the Cookbooks specified by a Berksfile or a Berksfile.lock."
     def install
+      unless options[:shims].nil?
+        options[:shims] = File.expand_path(options[:shims])
+      end
+
       berksfile = ::Berkshelf::Berksfile.from_file(options[:berksfile])
       berksfile.install(options)
     end

data/lib/berkshelf/cookbook_source.rb

@@ -2,7 +2,7 @@ module Berkshelf
   # @author Jamie Winsor <jamie@vialstudios.com>
   class CookbookSource
     class << self
-      @@valid_options = [:group, :locked_version]
+      @@valid_options = [:constraint, :locations, :group, :locked_version]
       @@location_keys = Hash.new
 
       # Returns an array of valid options to pass to the initializer
@@ -48,83 +48,62 @@ module Berkshelf
 
         @@location_keys
       end
+
+      def validate_options(options)
+        invalid_options = (options.keys - valid_options)
+
+        unless invalid_options.empty?
+          invalid_options.collect! { |opt| "'#{opt}'" }
+          raise InternalError, "Invalid options for Cookbook Source: #{invalid_options.join(', ')}."
+        end
+
+        true
+      end
     end
 
     extend Forwardable
 
-    # JW TODO: Move locations out of CookbookSource namespace.
-    #   Move all locations into berkshelf/locations/*
-    #   Autorequire all items in berkshelf/locations/
-    require 'berkshelf/cookbook_source/location'
-    require 'berkshelf/cookbook_source/site_location'
-    require 'berkshelf/cookbook_source/git_location'
-    require 'berkshelf/cookbook_source/path_location'
-    require 'berkshelf/cookbook_source/chef_api_location'
-
     attr_reader :name
-    alias_method :to_s, :name
-
     attr_reader :version_constraint
     attr_reader :groups
     attr_reader :location
     attr_accessor :cached_cookbook
 
-    def_delegator :@location, :downloaded?
-
-    # @overload initialize(name, version_constraint, options = {})
-    #   @param [#to_s] name
-    #   @param [#to_s] version_constraint
-    #   @param [Hash] options
-    #
-    #   @option options [String] :git
-    #     the Git URL to clone
-    #   @option options [String] :site
-    #     a URL pointing to a community API endpoint
-    #   @option options [String] :path
-    #     a filepath to the cookbook on your local disk
-    #   @option options [Symbol, Array] :group
-    #     the group or groups that the cookbook belongs to
-    #   @option options [String] :ref
-    #     the commit hash or an alias to a commit hash to clone
-    #   @option options [String] :branch
-    #     same as ref
-    #   @option options [String] :tag
-    #     same as tag
-    #   @option options [String] :locked_version
-    # @overload initialize(name, options = {})
-    #   @param [#to_s] name
-    #   @param [Hash] options
+    #  @param [String] name
+    #  @param [Hash] options
     #
-    #   @option options [String] :git
-    #     the Git URL to clone
-    #   @option options [String] :site
-    #     a URL pointing to a community API endpoint
-    #   @option options [String] :path
-    #     a filepath to the cookbook on your local disk
-    #   @option options [Symbol, Array] :group
-    #     the group or groups that the cookbook belongs to
-    #   @option options [String] :ref
-    #     the commit hash or an alias to a commit hash to clone
-    #   @option options [String] :branch
-    #     same as ref
-    #   @option options [String] :tag
-    #     same as tag
-    #   @option options [String] :locked_version
-    def initialize(*args)
-      options = args.last.is_a?(Hash) ? args.pop : {}
-      name, constraint = args
-
+    #  @option options [String, Solve::Constraint] constraint
+    #    version constraint to resolve for this source
+    #  @option options [String] :git
+    #    the Git URL to clone
+    #  @option options [String] :site
+    #    a URL pointing to a community API endpoint
+    #  @option options [String] :path
+    #    a filepath to the cookbook on your local disk
+    #  @option options [Symbol, Array] :group
+    #    the group or groups that the cookbook belongs to
+    #  @option options [String] :ref
+    #    the commit hash or an alias to a commit hash to clone
+    #  @option options [String] :branch
+    #    same as ref
+    #  @option options [String] :tag
+    #    same as tag
+    #  @option options [String] :locked_version
+    def initialize(name, options = {})
       @name = name
-      @version_constraint = Solve::Constraint.new(constraint || ">= 0.0.0")
+      @version_constraint = Solve::Constraint.new(options[:constraint] || ">= 0.0.0")
       @groups = []
       @cached_cookbook = nil
+      @location = nil
 
-      validate_options(options)
+      self.class.validate_options(options)
 
-      @location = Location.init(name, version_constraint, options)
+      unless (options.keys & self.class.location_keys.keys).empty?
+        @location = Location.init(name, version_constraint, options)
+      end
 
       if @location.is_a?(PathLocation)
-        @cached_cookbook = CachedCookbook.from_path(@location.path)
+        @cached_cookbook = CachedCookbook.from_path(location.path)
       end
       
       @locked_version = Solve::Version.new(options[:locked_version]) if options[:locked_version]
@@ -141,22 +120,12 @@ module Berkshelf
       end
     end
 
-    # @param [String] destination
-    #   destination to download to
-    #
-    # @return [Array]
-    #   An array containing the status at index 0 and local path or error message in index 1
+    # Returns true if the cookbook source has already been downloaded. A cookbook
+    # source is downloaded when a cached cookbooked is present.
     #
-    #   Example:
-    #     [ :ok, "/tmp/nginx" ]
-    #     [ :error, "Cookbook 'sparkle_motion' not found at site: http://cookbooks.opscode.com/api/v1/cookbooks" ]
-    def download(destination)
-      self.cached_cookbook = location.download(destination)
-
-      [ :ok, self.cached_cookbook ]
-    rescue CookbookNotFound => e
-      self.cached_cookbook = nil
-      [ :error, e.message ]
+    # @return [Boolean]
+    def downloaded?
+      !self.cached_cookbook.nil?
     end
 
     def has_group?(group)
@@ -167,21 +136,10 @@ module Berkshelf
       @locked_version || cached_cookbook.version
     end
 
-    private
-
-      def set_local_path(path)
-        @local_path = path
-      end
-
-      def validate_options(options)
-        invalid_options = options.keys - self.class.valid_options
-
-        unless invalid_options.empty?
-          invalid_options.collect! { |opt| "'#{opt}'" }
-          raise InternalError, "Invalid options for Cookbook Source: #{invalid_options.join(', ')}."
-        end
-
-        true
-      end
+    def to_s
+      msg = "#{self.name} (#{self.version_constraint}) groups: #{self.groups}"
+      msg << " location: #{self.location}" if self.location
+      msg
+    end
   end
 end

data/lib/berkshelf/cookbook_store.rb

@@ -3,6 +3,8 @@ require 'fileutils'
 module Berkshelf
   # @author Jamie Winsor <jamie@vialstudios.com>
   class CookbookStore
+    # @return [String]
+    #   filepath to where cookbooks are stored
     attr_reader :storage_path
 
     # Create a new instance of CookbookStore with the given

data/lib/berkshelf/downloader.rb

@@ -3,80 +3,100 @@ module Berkshelf
   class Downloader
     extend Forwardable
 
+    DEFAULT_LOCATIONS = [
+      {
+        type: :site,
+        value: Location::OPSCODE_COMMUNITY_API,
+        options: Hash.new
+      }
+    ]
+
+    # @return [String]
+    #   a filepath to download cookbook sources to
     attr_reader :cookbook_store
-    attr_reader :queue
 
     def_delegators :@cookbook_store, :storage_path
 
-    def initialize(cookbook_store)
+    # @option options [Array<Hash>] locations
+    def initialize(cookbook_store, options = {})
       @cookbook_store = cookbook_store
-      @queue = []
+      @locations = options.fetch(:locations, Array.new)
     end
 
-    # Add a CookbookSource to the downloader's queue
-    #
-    # @param [Berkshelf::CookbookSource] source
-    # 
-    # @return [Array<Berkshelf::CookbookSource>]
-    #   the queue - an array of Berkshelf::CookbookSources
-    def enqueue(source)
-      unless validate_source(source)
-        raise ArgumentError, "Invalid CookbookSource: can only enqueue valid instances of CookbookSource."
-      end
-
-      @queue << source
+    # @return [Array<Hash>]
+    #   an Array of Hashes representing each default location that can be used to attempt
+    #   to download cookbook sources which do not have an explicit location. An array of default locations will
+    #   be used if no locations are explicitly added by the {#add_location} function.
+    def locations
+      @locations.empty? ? DEFAULT_LOCATIONS : @locations
     end
 
-    # Remove a CookbookSource from the downloader's queue
+    # Create a location hash and add it to the end of the array of locations.
     #
-    # @param [Berkshelf::CookbookSource] source
+    # subject.add_location(:chef_api, "http://chef:8080", node_name: "reset", client_key: "/Users/reset/.chef/reset.pem") =>
+    #   [ { type: :chef_api, value: "http://chef:8080/", node_name: "reset", client_key: "/Users/reset/.chef/reset.pem" } ]
     #
-    # @return [Berkshelf::CookbookSource]
-    #   the CookbookSource removed from the queue
-    def dequeue(source)
-      @queue.delete(source)
-    end
-
-    # Download each CookbookSource in the queue. Upon successful download
-    # of a CookbookSource it is removed from the queue. If a CookbookSource
-    # fails to download it remains in the queue.
+    # @param [Symbol] type
+    # @param [String, Symbol] value
+    # @param [Hash] options
     #
-    # @return [TXResultSet]
-    def download_all
-      results = TXResultSet.new
-
-      queue.each do |source|
-        results.add_result download(source)
+    # @return [Hash]
+    def add_location(type, value, options = {})
+      if has_location?(type, value)
+        raise DuplicateLocationDefined, "A default '#{type}' location with the value '#{value}' is already defined"
       end
-
-      results.success.each { |result| dequeue(result.source) }
       
-      results
+      @locations.push(type: type, value: value, options: options)
     end
 
-    # Downloads the given CookbookSource
-    #
-    # @param [CookbookSource] source
-    #   the source to download
+    # Checks the list of default locations if a location of the given type and value has already
+    # been added and returns true or false.
     #
-    # @return [TXResult]
-    def download(source)
-      status, message = source.download(storage_path)
-      TXResult.new(status, message, source)
+    # @return [Boolean]
+    def has_location?(type, value)
+      !@locations.select { |loc| loc[:type] == type && loc[:value] == value }.empty?
     end
 
-    # Downloads the given CookbookSource. Raises a DownloadFailure error
-    # if the download was not successful.
+    # Downloads the given CookbookSource. If the given source does not contain a value for {CookbookSource#location}
+    # the default locations of this downloader will be used to attempt to retrieve the source.
     #
     # @param [CookbookSource] source
     #   the source to download
     #
-    # @return [TXResult]
-    def download!(source)
-      result = download(source)
-      raise DownloadFailure, result.message if result.failed?
-      
-      result
+    # @return [Array]
+    #   an array containing the downloaded CachedCookbook and the Location used to download the cookbook
+    def download(source)
+      cached_cookbook, location = if source.location
+        [ source.location.download(storage_path), source.location ]
+      else
+        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
+            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 ]
+      end
+
+      source.cached_cookbook = cached_cookbook
+
+      [ cached_cookbook, location ]
     end
 
     private

data/lib/berkshelf/errors.rb

@@ -12,11 +12,15 @@ module Berkshelf
   end
 
   class InternalError < BerkshelfError; status_code(99); end
-  class MethodNotImplmentedError < ::Berkshelf::InternalError ; end
-  
+  class AbstractFunction < InternalError
+    def to_s
+      "Function must be implemented on includer"
+    end
+  end
+
   class BerksfileNotFound < BerkshelfError; status_code(100); end
   class NoVersionForConstraints < BerkshelfError; status_code(101); end
-  class DownloadFailure < BerkshelfError; status_code(102); end
+  class DuplicateLocationDefined < BerkshelfError; status_code(102); end
   class CookbookNotFound < BerkshelfError; status_code(103); end
   class GitError < BerkshelfError
     status_code(104)

data/lib/berkshelf/formatters.rb

@@ -10,27 +10,27 @@ module Berkshelf
       end
 
       def install(cookbook, version, location)
-        raise MethodNotImplmentedError, "#install must be implemented on #{self.class}"
+        raise AbstractFunction, "#install must be implemented on #{self.class}"
       end
 
       def use(cookbook, version, path = nil)
-        raise MethodNotImplmentedError, "#install must be implemented on #{self.class}"
+        raise AbstractFunction, "#install must be implemented on #{self.class}"
       end
 
       def upload(cookbook, version, chef_server_url)
-        raise MethodNotImplmentedError, "#upload must be implemented on #{self.class}"
+        raise AbstractFunction, "#upload must be implemented on #{self.class}"
       end
 
       def shims_written(directory)
-        raise MethodNotImplmentedError, "#shims_written must be implemented on #{self.class}"
+        raise AbstractFunction, "#shims_written must be implemented on #{self.class}"
       end
 
       def msg(message)
-        raise MethodNotImplmentedError, "#msg must be implemented on #{self.class}"
+        raise AbstractFunction, "#msg must be implemented on #{self.class}"
       end
 
       def error(message)
-        raise MethodNotImplmentedError, "#error must be implemented on #{self.class}"
+        raise AbstractFunction, "#error must be implemented on #{self.class}"
       end
     end
   end

data/lib/berkshelf/location.rb

@@ -0,0 +1,171 @@
+module Berkshelf
+  # @author Jamie Winsor <jamie@vialstudios.com>
+  module Location
+    OPSCODE_COMMUNITY_API = 'http://cookbooks.opscode.com/api/v1/cookbooks'.freeze
+    
+    module ClassMethods
+      # Register the location key for the including source location with CookbookSource
+      #
+      # @param [Symbol] key
+      def location_key(key)
+        CookbookSource.add_location_key(key, self)
+      end
+
+      # Register a valid option or multiple options with the CookbookSource class
+      #
+      # @param [Symbol] opts
+      def valid_options(*opts)
+        Array(opts).each do |opt|
+          CookbookSource.add_valid_option(opt)
+        end
+      end
+
+      # Returns an array where the first element is string representing the best version
+      # for the given constraint and the second element is the URI to where the corresponding
+      # version of the Cookbook can be downloaded from
+      #
+      # @example:
+      #   constraint = Solve::Constraint.new("~> 0.101.2")
+      #   versions = { 
+      #     "1.0.0" => "http://cookbooks.opscode.com/api/v1/cookbooks/nginx/versions/1_0_0",
+      #     "2.0.0" => "http://cookbooks.opscode.com/api/v1/cookbooks/nginx/versions/2_0_0"
+      #   }
+      #
+      #   subject.solve_for_constraint(versions, constraint) =>
+      #     [ "2.0.0", "http://cookbooks.opscode.com/api/v1/cookbooks/nginx/versions/2_0_0" ]
+      #
+      # @param [String, Solve::Constraint] constraint
+      #   version constraint to solve for
+      #
+      # @param [Hash] versions
+      #   a hash where the keys are a string representing a cookbook version and the values
+      #   are the download URL for the cookbook version.
+      #
+      # @return [Array, nil]
+      def solve_for_constraint(constraint, versions)
+        graph = Solve::Graph.new
+        name = "none"
+
+        versions.each do |version, uri|
+          graph.artifacts(name, version)
+        end
+
+        graph.demands(name, constraint)
+        result = Solve.it(graph)
+
+        return nil if result.nil?
+
+        version = result[name]
+
+        [ version, versions[version] ]
+      end
+    end
+
+    class << self
+      def included(base)
+        base.send :extend, ClassMethods
+      end
+
+      # Creates a new instance of a Class implementing Location with the given name and
+      # constraint. Which Class to instantiated is determined by the values in the given
+      # options Hash. Source Locations have an associated location_key registered with
+      # CookbookSource. If your options Hash contains a key matching one of these location_keys
+      # then the Class who registered that location_key will be instantiated. If you do not
+      # provide an option with a matching location_key a SiteLocation class will be
+      # instantiated.
+      #
+      # @example
+      #   Location.init("nginx", ">= 0.0.0", git: "git://github.com/RiotGames/artifact-cookbook.git") =>
+      #     instantiates a GitLocation
+      #
+      #   Location.init("nginx", ">= 0.0.0", path: "/Users/reset/code/nginx-cookbook") =>
+      #     instantiates a PathLocation
+      #
+      #   Location.init("nginx", ">= 0.0.0", site: "http://cookbooks.opscode.com/api/v1/cookbooks") =>
+      #     instantiates a SiteLocation
+      #
+      #   Location.init("nginx", ">= 0.0.0", chef_api: "https://api.opscode.com/organizations/vialstudios") =>
+      #     instantiates a ChefAPILocation
+      #
+      #   Location.init("nginx", ">= 0.0.0") =>
+      #     instantiates a SiteLocation
+      #
+      # @param [String] name
+      # @param [String, Solve::Constraint] constraint
+      # @param [Hash] options
+      #
+      # @return [SiteLocation, PathLocation, GitLocation, ChefAPILocation]
+      def init(name, constraint, options = {})
+        klass = klass_from_options(options)
+
+        klass.new(name, constraint, options)
+      end
+
+      private
+
+        def klass_from_options(options)
+          location_keys = (options.keys & CookbookSource.location_keys.keys)
+          if location_keys.length > 1
+            location_keys.collect! { |opt| "'#{opt}'" }
+            raise InternalError, "Only one location key (#{CookbookSource.location_keys.keys.join(', ')}) may be specified. You gave #{location_keys.join(', ')}."
+          end
+
+          if location_keys.empty?
+            SiteLocation
+          else
+            CookbookSource.location_keys[location_keys.first]
+          end
+        end
+    end
+
+    attr_reader :name
+    attr_reader :version_constraint
+
+    # @param [#to_s] name
+    # @param [Solve::Constraint] version_constraint
+    # @param [Hash] options
+    def initialize(name, version_constraint, options = {})
+      @name = name
+      @version_constraint = version_constraint
+      @downloaded_status = false
+    end
+
+    # @param [#to_s] destination
+    #
+    # @return [Berkshelf::CachedCookbook]
+    def download(destination)
+      raise AbstractFunction
+    end
+
+    # @return [Boolean]
+    def downloaded?
+      @downloaded_status
+    end
+
+    # Ensures that the given CachedCookbook satisfies the constraint
+    #
+    # @param [CachedCookbook] cached_cookbook
+    #
+    # @raise [ConstraintNotSatisfied] if the CachedCookbook does not satisfy the version constraint of
+    #   this instance of Location.
+    #
+    # @return [Boolean]
+    def validate_cached(cached_cookbook)
+      unless version_constraint.satisfies?(cached_cookbook.version)
+        raise ConstraintNotSatisfied, "A cookbook satisfying '#{name}' (#{version_constraint}) not found at #{self}"
+      end
+
+      true
+    end
+
+    private
+
+      def set_downloaded_status(state)
+        @downloaded_status = state
+      end
+  end
+end
+
+Dir["#{File.dirname(__FILE__)}/locations/*.rb"].sort.each do |path|
+  require "berkshelf/locations/#{File.basename(path, '.rb')}"
+end