berkshelf 3.0.0.beta7 → 3.0.0.beta8

data/lib/berkshelf/formatters/null.rb

@@ -1,22 +1,12 @@
 module Berkshelf
-  module Formatters
-    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
+  class NullFormatter < BaseFormatter
+    # The base 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.
+    BaseFormatter.instance_methods(false).each do |name|
+      class_eval <<-EOH, __FILE__, __LINE__ + 1
+        def #{name}(*args); end
+      EOH
     end
   end
 end

data/lib/berkshelf/init_generator.rb

@@ -150,7 +150,7 @@ module Berkshelf
       # @return [nil]
       def validate_configuration
         unless Berkshelf.config.valid?
-          raise InvalidConfiguration.new Berkshelf.config.errors
+          raise InvalidConfiguration.new(Berkshelf.config.errors)
         end
       end
 

data/lib/berkshelf/installer.rb

@@ -29,134 +29,145 @@ module Berkshelf
 
     # @return [Array<Berkshelf::CachedCookbook>]
     def run
-      reduce_lockfile!
+      lockfile.reduce!
 
-      cookbooks = if lockfile.trusted?
-        install_from_lockfile
-      else
-        install_from_universe
+      Berkshelf.formatter.msg('Resolving cookbook dependencies...')
+
+      dependencies, cookbooks = if lockfile.trusted?
+                                  install_from_lockfile
+                                else
+                                  install_from_universe
+                                end
+
+      Berkshelf.log.debug "  Finished resolving, calculating locks"
+
+      to_lock = dependencies.select do |dependency|
+        berksfile.has_dependency?(dependency)
+      end
+
+      Berkshelf.log.debug "  New locks"
+      to_lock.each do |lock|
+        Berkshelf.log.debug "    #{lock}"
       end
 
       lockfile.graph.update(cookbooks)
-      lockfile.update(berksfile.dependencies)
+      lockfile.update(to_lock)
       lockfile.save
 
       cookbooks
     end
 
-    # Install all the dependencies from the lockfile graph.
-    #
-    # @return [Array<CachedCookbook>]
-    #   the list of installed cookbooks
-    def install_from_lockfile
-      locks = lockfile.graph.locks
+    private
 
-      # Only construct the universe if we are going to download things
-      unless locks.all? { |_, dependency| dependency.downloaded? }
-        build_universe
-      end
+      # Install a specific dependency.
+      #
+      # @param [Dependency]
+      #   the dependency to install
+      # @return [CachedCookbook]
+      #   the installed cookbook
+      def install(dependency)
+        Berkshelf.log.info "Installing #{dependency}"
 
-      locks.sort.collect do |name, dependency|
-        install(dependency)
-      end
-    end
+        if dependency.installed?
+          Berkshelf.log.debug "  Already installed - skipping install"
 
-    # Resolve and install the dependencies from the "universe", updating the
-    # lockfile appropiately.
-    #
-    # @return [Array<CachedCookbook>]
-    #   the list of installed cookbooks
-    def install_from_universe
-      dependencies = lockfile.graph.locks.values + berksfile.dependencies
-      dependencies = dependencies.inject({}) do |hash, dependency|
-        # Fancy way of ensuring no duplicate dependencies are used...
-        hash[dependency.name] ||= dependency
-        hash
-      end.values
-
-      resolver = Resolver.new(berksfile, dependencies)
-
-      # Download all SCM locations first, since they might have additional
-      # constraints that we don't yet know about
-      dependencies.select(&:scm_location?).each do |dependency|
-        Berkshelf.formatter.fetch(dependency)
-        dependency.download
-      end
+          Berkshelf.formatter.use(dependency)
+          dependency.cached_cookbook
+        else
+          name, version = dependency.name, dependency.locked_version.to_s
+          source = berksfile.source_for(name, version)
+
+          Berkshelf.log.debug "  Downloading #{dependency.name} (#{dependency.locked_version}) from #{source}"
+
+          cookbook = source.cookbook(name, version)
 
-      # Unlike when installing from the lockfile, we _always_ need to build
-      # the universe when installing from the universe... duh
-      build_universe
+          Berkshelf.log.debug "    => #{cookbook.inspect}"
 
-      # Add any explicit dependencies for already-downloaded cookbooks (like
-      # path locations)
-      dependencies.each do |dependency|
-        if cookbook = dependency.cached_cookbook
-          resolver.add_explicit_dependencies(cookbook)
+          Berkshelf.formatter.install(source, cookbook)
+
+          stash = downloader.download(name, version)
+          CookbookStore.import(name, version, stash)
         end
       end
 
-      resolver.resolve.sort.collect do |dependency|
-        install(dependency)
-      end
-    end
+      # Install all the dependencies from the lockfile graph.
+      #
+      # @return [Array<Array<Dependency> Array<CachedCookbook>>]
+      #   the list of installed dependencies and cookbooks
+      def install_from_lockfile
+        Berkshelf.log.info "Installing from lockfile"
+
+        dependencies = lockfile.graph.locks.values
+
+        Berkshelf.log.debug "  Dependencies"
+        dependencies.map do |dependency|
+          Berkshelf.log.debug "    #{dependency}"
+        end
+
+        download_locations(dependencies)
 
-    # Install a specific dependency.
-    #
-    # @param [Dependency]
-    #   the dependency to install
-    # @return [CachedCookbook]
-    #   the installed cookbook
-    def install(dependency)
-      if dependency.downloaded?
-        Berkshelf.formatter.use(dependency)
-        dependency.cached_cookbook
-      else
-        name, version = dependency.name, dependency.locked_version.to_s
-        source   = berksfile.source_for(name, version)
-        cookbook = source.cookbook(name, version)
-
-        Berkshelf.formatter.install(source, cookbook)
-
-        stash = downloader.download(name, version)
-        CookbookStore.import(name, version, stash)
+        # Only construct the universe if we are going to install things
+        unless dependencies.all?(&:installed?)
+          Berkshelf.log.debug "  Not all dependencies are installed"
+          build_universe
+        end
+
+        cookbooks = dependencies.sort.collect do |dependency|
+          install(dependency)
+        end
+
+        [dependencies, cookbooks]
       end
-    end
 
-    private
+      # Resolve and install the dependencies from the "universe", updating the
+      # lockfile appropiately.
+      #
+      # @return [Array<Array<Dependency> Array<CachedCookbook>>]
+      #   the list of installed dependencies and cookbooks
+      def install_from_universe
+        Berkshelf.log.info "Installing from universe"
+
+        dependencies = lockfile.graph.locks.values + berksfile.dependencies
+        dependencies = dependencies.inject({}) do |hash, dependency|
+          # Fancy way of ensuring no duplicate dependencies are used...
+          hash[dependency.name] ||= dependency
+          hash
+        end.values
+
+        download_locations(dependencies)
+
+        Berkshelf.log.debug "  Creating a resolver"
+        resolver = Resolver.new(berksfile, dependencies)
+
+        # Unlike when installing from the lockfile, we _always_ need to build
+        # the universe when installing from the universe... duh
+        build_universe
 
-    # Iterate over each top-level dependency defined in the lockfile and
-    # check if that dependency is still defined in the Berksfile.
-    #
-    # If the dependency is no longer present in the Berksfile, it is "safely"
-    # removed using {Lockfile#unlock} and {Lockfile#remove}. This prevents
-    # the lockfile from "leaking" dependencies when they have been removed
-    # from the Berksfile, but still remained locked in the lockfile.
-    #
-    # If the dependency exists, a constraint comparison is conducted to verify
-    # that the locked dependency still satisifes the original constraint. This
-    # handles the edge case where a user has updated or removed a constraint
-    # on a dependency that already existed in the lockfile.
-    #
-    # @raise [OutdatedDependency]
-    #   if the constraint exists, but is no longer satisifed by the existing
-    #   locked version
-    #
-    # @return [Array<Dependency>]
-    def reduce_lockfile!
-      lockfile.dependencies.each do |dependency|
-        if berksfile.dependencies.map(&:name).include?(dependency.name)
-          locked = lockfile.graph.find(dependency)
-          next if locked.nil?
-
-          unless dependency.version_constraint.satisfies?(locked.version)
-            raise OutdatedDependency.new(locked, dependency)
+        # Add any explicit dependencies for already-downloaded cookbooks (like
+        # path locations)
+        dependencies.each do |dependency|
+          if cookbook = dependency.cached_cookbook
+            Berkshelf.log.debug "  Adding explicit dependency on #{cookbook}"
+            resolver.add_explicit_dependencies(cookbook)
           end
-        else
-          lockfile.unlock(dependency)
         end
+
+        Berkshelf.log.debug "  Starting resolution..."
+
+        cookbooks = resolver.resolve.sort.collect do |dependency|
+          install(dependency)
+        end
+
+        [dependencies, cookbooks]
       end
 
-      lockfile.save
-    end
+      def download_locations(dependencies)
+        dependencies.select(&:location).each do |dependency|
+          unless dependency.location.installed?
+            Berkshelf.formatter.fetch(dependency)
+            dependency.location.install
+          end
+        end
+      end
   end
 end

data/lib/berkshelf/location.rb

@@ -1,146 +1,47 @@
 module Berkshelf
-  module Location
+  class Location
     class << self
-      # 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
-      # Berkshelf::Dependency. 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 nil will be returned.
+      # Create a new instance of a Location class given dependency and options.
+      # The type of class is determined by the values in the given +options+
+      # Hash.
       #
-      # @example
-      #   Location.init('nginx', '>= 0.0.0', git: 'git://github.com/RiotGames/artifact-cookbook.git') =>
-      #     instantiates a GitLocation
+      # If you do not provide an option with a matching location id, +nil+
+      # is returned.
       #
-      #   Location.init('nginx', '>= 0.0.0', hg: 'http://hghub.com/RiotGames/') =>
-      #     instantiates a MercurialLocation
+      # @example Create a git location
+      #   Location.init(dependency, git: 'git://github.com/berkshelf/berkshelf.git')
       #
-      #   Location.init('nginx', '>= 0.0.0', path: '/Users/reset/code/nginx-cookbook') =>
-      #     instantiates a PathLocation
+      # @example Create a GitHub location
+      #   Location.init(dependency, github: 'berkshelf/berkshelf')
       #
       # @param [Dependency] dependency
       # @param [Hash] options
       #
-      # @return [~Location::Base, nil]
+      # @return [~BaseLocation, nil]
       def init(dependency, options = {})
         if klass = klass_from_options(options)
           klass.new(dependency, options)
+        else
+          nil
         end
       end
 
       private
 
-        def klass_from_options(options)
-          location_keys = (options.keys & Berkshelf::Dependency.location_keys.keys)
-          if location_keys.length > 1
-            location_keys.collect! { |opt| "'#{opt}'" }
-            raise InternalError, "Only one location key (#{Berkshelf::Dependency.location_keys.keys.join(', ')}) " +
-              "may be specified. You gave #{location_keys.join(', ')}."
-          end
-
-          if location_key = location_keys.first
-            Berkshelf::Dependency.location_keys[location_key]
-          end
-        end
-    end
-
-    class Base
-      class << self
-        # Returns the location identifier key for the class
-        #
-        # @return [Symbol]
-        attr_reader :location_key
-
-        # Register the location key for the including source location with Berkshelf::Dependency
+        # Load the correct location from the given options.
         #
-        # @param [Symbol] key
-        def set_location_key(key)
-          Berkshelf::Dependency.add_location_key(key, self)
-          @location_key = key
-        end
+        # @return [Class, nil]
+        def klass_from_options(options)
+          options.each do |key, _|
+            id = key.to_s.capitalize
 
-        # Register a valid option or multiple options with the Berkshelf::Dependency class
-        #
-        # @param [Symbol] opts
-        def set_valid_options(*opts)
-          Array(opts).each do |opt|
-            Berkshelf::Dependency.add_valid_option(opt)
+            begin
+              return Berkshelf.const_get("#{id}Location")
+            rescue NameError; end
           end
-        end
-      end
-
-      extend Forwardable
-
-      attr_reader :dependency
-      def_delegator :dependency, :name
-
-      # @param [Berkshelf::Dependency] dependency
-      # @param [Hash] options
-      def initialize(dependency, options = {})
-        @dependency       = dependency
-        @@cached_cookbook = nil
-      end
-
-      # @param [#to_s] destination
-      #
-      # @return [Berkshelf::CachedCookbook]
-      def download
-        return @cached_cookbook if @cached_cookbook
-
-        cached_cookbook = do_download
-        validate_cached(cached_cookbook)
-        @cached_cookbook = cached_cookbook
-      end
-
-      # @param [#to_s] destination
-      #
-      # @return [Berkshelf::CachedCookbook]
-      def do_download
-        raise AbstractFunction
-      end
 
-      # Ensure the retrieved CachedCookbook is valid
-      #
-      # @param [CachedCookbook] cached_cookbook
-      #   the downloaded cookbook to validate
-      #
-      # @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 dependency.version_constraint.satisfies?(cached_cookbook.version)
-          raise CookbookValidationFailure.new(dependency, cached_cookbook)
+          nil
         end
-
-        unless dependency.name == cached_cookbook.cookbook_name
-          Berkshelf.ui.warn(MismatchedCookbookName.new(dependency, cached_cookbook).to_s)
-        end
-
-        true
-      end
-
-      # Determines if the location is well formed and points to an accessible location
-      #
-      # @return [Boolean]
-      def valid?
-        true
-      end
-
-      def to_hash
-        { type: self.class.location_key }
-      end
-
-      def to_json(options = {})
-        JSON.pretty_generate(to_hash, options)
-      end
     end
-
-    class ScmLocation < Location::Base; end
   end
 end
-
-Dir["#{File.dirname(__FILE__)}/locations/*.rb"].sort.each do |path|
-  require_relative "locations/#{File.basename(path, '.rb')}"
-end