berkshelf 2.0.18 → 3.0.0.beta1

data/lib/berkshelf/logger.rb

@@ -1,12 +1,9 @@
 module Berkshelf
-  Logger = Ridley.logger
+  Logger = Celluloid::Logger.dup
 
-  Logger.class_eval do
-    alias_method :fatal, :error
-
-    def deprecate(message)
-      trace = caller.join("\n\t")
-      warn "DEPRECATION WARNING: #{message}\n\t#{trace}"
+  Logger.module_eval do
+    def self.fatal(string)
+      error(string)
     end
   end
 end

data/lib/berkshelf/mixin/config.rb

@@ -6,6 +6,9 @@ module Berkshelf
       end
 
       module ClassMethods
+        # @return [String, nil]
+        attr_reader :default_location
+
         # Load a Chef configuration from the given path.
         #
         # @raise [Berkshelf::ConfigNotFound]
@@ -16,10 +19,15 @@ module Berkshelf
           raise Berkshelf::ConfigNotFound.new(self.class.name, filepath)
         end
 
+        # @return [Berkshelf::Mixin::Config]
+        def instance
+          @instance ||= load
+        end
+
         # Load the contents of the most probable Chef config. See {location}
         # for more information on how this logic is decided.
         def load
-          self.new(location)
+          new(location)
         end
 
         # Class method for defining a default option.
@@ -47,9 +55,6 @@ module Berkshelf
           @default_location = File.expand_path(path)
         end
 
-        # @return [String, nil]
-        attr_reader :default_location
-
         # Converts a path to a path usable for your current platform
         #
         # @param [String] path
@@ -64,7 +69,19 @@ module Berkshelf
           path
         end
 
+        # @return [Berkshelf::Mixin::Config]
+        def reload
+          @instance = nil
+          instance
+        end
+
+        # @param [Berkshelf::Mixin::Config]
+        def set_config(config)
+          @instance = config
+        end
+
         private
+
           # @abstract
           #   include and override {location} in your class to define the
           #   default location logic

data/lib/berkshelf/resolver.rb

@@ -1,189 +1,99 @@
 module Berkshelf
   class Resolver
-    require_relative 'cookbook_source'
-    require_relative 'locations/git_location'
-    require_relative 'locations/path_location'
+    require_relative 'resolver/graph'
 
     extend Forwardable
 
     # @return [Berkshelf::Berksfile]
     attr_reader :berksfile
 
-    # @return [Solve::Graph]
+    # @return [Resolver::Graph]
     attr_reader :graph
 
-    # @param [Berkshelf::Berksfile] berksfile
-    # @param [Hash] options
-    #
-    # @option options [Array<CookbookSource>, CookbookSource] sources
-    def initialize(berksfile, options = {})
-      @berksfile  = berksfile
-      @downloader = berksfile.downloader
-      @graph      = Solve::Graph.new
-      @sources    = Hash.new
-
-      # Dependencies need to be added AFTER the sources. If they are
-      # not, then one of the dependencies of a source that is added
-      # may take precedence over an explicitly set source that appears
-      # later in the iterator.
-      Array(options[:sources]).each do |source|
-        add_source(source, false)
-      end
+    # @return [Array<Berkshelf::Dependency>]
+    #   an array of dependencies that must be satisfied
+    attr_reader :demands
 
-      unless options[:skip_dependencies]
-        Array(options[:sources]).each do |source|
-          add_source_dependencies(source)
-        end
-      end
+    # @param [Berkshelf::Berksfile] berksfile
+    # @param [Array<Berkshelf::Dependency>, Berkshelf::Dependency] demands
+    #   a dependency, or array of dependencies, which must be satisfied
+    def initialize(berksfile, demands = [])
+      @berksfile = berksfile
+      @graph     = Graph.new
+      @demands   = Array.new
+
+      Array(demands).each { |demand| add_demand(demand) }
     end
 
-    # Add the given source to the collection of sources for this instance
-    # of Resolver. By default the dependencies of the given source will also
-    # be added as sources to the collection.
+    # Add the given dependency to the collection of demands
+    #
+    # @param [Berkshelf::Dependency] demand
+    #   add a dependency that must be satisfied to the graph
     #
-    # @param [Berkshelf::CookbookSource] source
-    #   source to add
-    # @param [Boolean] include_dependencies
-    #   adds the dependencies of the given source as sources to the collection of
-    #   if true. Dependencies will be ignored if false.
+    # @raise [DuplicateDemand]
     #
-    # @return [Array<CookbookSource>]
-    def add_source(source, include_dependencies = true)
-      if has_source?(source)
-        raise DuplicateSourceDefined, "A source named '#{source.name}' is already present."
+    # @return [Array<Berkshelf::Dependency>]
+    def add_demand(demand)
+      if has_demand?(demand)
+        raise DuplicateDemand, "A demand named '#{demand.name}' is already present."
       end
 
-      @sources[source.name] = source
-      use_source(source) || install_source(source)
-
-      graph.artifacts(source.name, source.cached_cookbook.version)
+      demands.push(demand)
+    end
 
-      if include_dependencies
-        add_source_dependencies(source)
+    def add_explicit_dependencies(dependency)
+      unless cookbook = dependency.cached_cookbook
+        return nil
       end
 
-      sources
+      graph.populate_local(cookbook)
     end
 
-    # Add the dependencies of the given source as sources in the collection of sources
-    # on this instance of Resolver. Any dependencies which already have a source in the
-    # collection of sources of the same name will not be added to the collection a second
-    # time.
+    # An array of arrays containing the name and constraint of each demand
     #
-    # @param [CookbookSource] source
-    #   source to convert dependencies into sources
+    # @note this is the format that Solve uses to determine a solution for the graph
     #
-    # @return [Array<CookbookSource>]
-    def add_source_dependencies(source)
-      source.cached_cookbook.dependencies.each do |name, constraint|
-        next if has_source?(name)
-
-        add_source(CookbookSource.new(berksfile, name, constraint: constraint))
-      end
+    # @return [Array<String, String>]
+    def demand_array
+      demands.collect { |demand| [ demand.name, demand.version_constraint ] }
     end
 
-    # @return [Array<Berkshelf::CookbookSource>]
-    #   an array of CookbookSources that are currently added to this resolver
-    def sources
-      @sources.values
-    end
-
-    # Finds a solution for the currently added sources and their dependencies and
+    # Finds a solution for the currently added dependencies and their dependencies and
     # returns an array of CachedCookbooks.
     #
-    # @return [Array<Berkshelf::CachedCookbook>]
+    # @raise [Berkshelf::NoSolutionError] when a solution could not be found for the given demands
+    #
+    # @return [Array<Array<String, String, Dependency>>]
     def resolve
-      demands = [].tap do |l_demands|
-        graph.artifacts.each do |artifact|
-          l_demands << [ artifact.name, artifact.version ]
-        end
-      end
-
-      solution = Solve.it!(graph, demands)
+      graph.populate_store
+      graph.populate(berksfile.sources)
 
-      [].tap do |cached_cookbooks|
-        solution.each do |name, version|
-          cached_cookbooks << get_source(name).cached_cookbook
-        end
+      Solve.it!(graph, demand_array).collect do |name, version|
+        dependency = get_demand(name) || Dependency.new(berksfile, name, locked_version: version)
+        [ name, version, dependency ]
       end
+    rescue Solve::Errors::NoSolutionError
+      raise Berkshelf::NoSolutionError.new(demands)
     end
 
-    # @param [CookbookSource, #to_s] source
-    #   name of the source to return
+    # Retrieve the given demand from the resolver
     #
-    # @return [Berkshelf::CookbookSource]
-    def [](source)
-      if source.is_a?(CookbookSource)
-        source = source.name
-      end
-      @sources[source.to_s]
+    # @param [Berkshelf::Dependency, #to_s] demand
+    #   name of the dependency to return
+    #
+    # @return [Berkshelf::Dependency]
+    def [](demand)
+      name = demand.respond_to?(:name) ? demand.name : demand.to_s
+      demands.find { |demand| demand.name == name }
     end
-    alias_method :get_source, :[]
+    alias_method :get_demand, :[]
 
-    # @param [CoobookSource, #to_s] source
-    #   the source to test if the resolver has added
-    def has_source?(source)
-      !get_source(source).nil?
+    # Check if the given demand has been added to the resolver
+    #
+    # @param [Berkshelf::Dependency, #to_s] demand
+    #   the demand or the name of the demand to check for
+    def has_demand?(demand)
+      !get_demand(demand).nil?
     end
-
-    private
-
-      attr_reader :downloader
-
-      # @param [Berkshelf::CookbookSource] source
-      #
-      # @return [Boolean]
-      def install_source(source)
-        cached_cookbook, location = downloader.download(source)
-        Berkshelf.formatter.install(source.name, cached_cookbook.version, location)
-      end
-
-      # Use the given source to create a constraint solution if the source has been downloaded or can
-      # be satisfied by a cached cookbook that is already present in the cookbook store.
-      #
-      # @note Git location sources which have not yet been downloaded will not be satisfied by a
-      #   cached cookbook from the cookbook store.
-      #
-      # @param [Berkshelf::CookbookSource] source
-      #
-      # @raise [ConstraintNotSatisfied] if the CachedCookbook does not satisfy the version constraint of
-      #   this instance of Location.
-      #   contain a cookbook that satisfies the given version constraint of this instance of
-      #   CookbookSource.
-      #
-      # @return [Boolean]
-      def use_source(source)
-        name       = source.name
-        locked     = source.locked_version
-        location   = source.location
-
-        # Lock the version constraint if a locked version was supplied
-        source.version_constraint = Solve::Constraint.new(locked.to_s) if locked
-        constraint = source.version_constraint
-
-        if source.downloaded?
-          cached = source.cached_cookbook
-          location.validate_cached(cached) if location
-          Berkshelf.formatter.use(name, cached.version, location)
-          true
-        elsif location.is_a?(GitLocation)
-          false
-        else
-          # If a locked version if specified, it must exist
-          if locked
-            cached = downloader.cookbook_store.cookbook(name, locked)
-          else
-            cached = downloader.cookbook_store.satisfy(name, constraint)
-          end
-
-          if cached
-            get_source(source).cached_cookbook = cached
-            Berkshelf.formatter.use(name, cached.version)
-            true
-          else
-            false
-          end
-        end
-      end
   end
 end

data/lib/berkshelf/resolver/graph.rb

@@ -0,0 +1,44 @@
+module Berkshelf
+  class Resolver
+    class Graph < Solve::Graph
+      # @param [Berkshelf::CookbookStore] store
+      def populate_store(store = nil)
+        store ||= Berkshelf::CookbookStore.instance
+
+        store.cookbooks.each do |cookbook|
+          artifacts(cookbook.cookbook_name, cookbook.version)
+        end
+      end
+
+      def populate_local(cookbook)
+        name    = cookbook.cookbook_name
+        version = cookbook.version
+
+        artifacts(name, version)
+        cookbook.dependencies.each do |dependency, constraint|
+          artifacts(name, version).depends(dependency, constraint)
+        end
+      end
+
+      # @param [Array<Berkshelf::Source>, Berkshelf::Source] sources
+      def populate(sources)
+        universe(sources).each do |cookbook|
+          artifacts(cookbook.name, cookbook.version)
+
+          cookbook.dependencies.each do |dependency, constraint|
+            artifacts(cookbook.name, cookbook.version).depends(dependency, constraint)
+          end
+        end
+      end
+
+      # @param [Array<Berkshelf::Source>, Berkshelf::Source] sources
+      #
+      # @return [Array<Berkshelf::RemoteCookbook>]
+      def universe(sources)
+        cookbooks = []
+        Array(sources).each { |source| cookbooks = cookbooks | source.universe }
+        cookbooks
+      end
+    end
+  end
+end

data/lib/berkshelf/source.rb

@@ -0,0 +1,55 @@
+module Berkshelf
+  class Source
+    include Comparable
+
+    # @return [Berkshelf::SourceURI]
+    attr_reader :uri
+
+    # @param [String, Berkshelf::SourceURI] uri
+    def initialize(uri)
+      @uri        = SourceURI.parse(uri)
+      @api_client = APIClient.new(uri)
+    end
+
+    # @return [Hash]
+    def universe
+      @universe ||= api_client.universe
+    end
+
+    # @param [String] name
+    # @param [String] version
+    #
+    # @return [APIClient::RemoteCookbook]
+    def cookbook(name, version)
+      universe.find { |cookbook| cookbook.name == name && cookbook.version == version }
+    end
+
+    # @param [String] name
+    #
+    # @return [APIClient::RemoteCookbook]
+    def latest(name)
+      versions(name).sort.last
+    end
+
+    # @param [String] name
+    #
+    # @return [Array<APIClient::RemoteCookbook>]
+    def versions(name)
+      universe.select { |cookbook| cookbook.name == name }
+    end
+
+    def to_s
+      uri.to_s
+    end
+
+    def ==(other)
+      return false unless other.is_a?(self.class)
+      uri == other.uri
+    end
+
+    private
+
+      # @return [Berkshelf::APIClient]
+      attr_reader :api_client
+  end
+end

data/lib/berkshelf/source_uri.rb

@@ -0,0 +1,38 @@
+require 'addressable/uri'
+
+module Berkshelf
+  class SourceURI < Addressable::URI
+    class << self
+      # Returns a URI object based on the parsed string.
+      #
+      # @param [String, Addressable::URI, #to_str] uri
+      #   The URI string to parse.
+      #   No parsing is performed if the object is already an
+      #   <code>Addressable::URI</code>.
+      #
+      # @raise [Berkshelf::InvalidSourceURI]
+      #
+      # @return [Berkshelf::SourceURI]
+      def parse(uri)
+        parsed_uri = super(uri)
+        parsed_uri.send(:validate)
+        parsed_uri
+      rescue TypeError, ArgumentError => ex
+        raise InvalidSourceURI.new(uri, ex)
+      end
+    end
+
+    VALID_SCHEMES = [ "http", "https" ].freeze
+
+    # @raise [Berkshelf::InvalidSourceURI]
+    def validate
+      super
+
+      unless VALID_SCHEMES.include?(self.scheme)
+        raise InvalidSourceURI.new(self, "invalid URI scheme '#{self.scheme}'. Valid schemes: #{VALID_SCHEMES}")
+      end
+    rescue Addressable::URI::InvalidURIError => ex
+      raise InvalidSourceURI.new(self, ex)
+    end
+  end
+end