librarian 0.0.25 → 0.0.26

data/lib/librarian/mock/source/mock.rb

@@ -1,32 +1,15 @@
 require 'librarian/manifest'
+require 'librarian/source/basic_api'
 require 'librarian/mock/source/mock/registry'
 
 module Librarian
   module Mock
     module Source
       class Mock
+        include Librarian::Source::BasicApi
 
-        class << self
-
-          LOCK_NAME = 'MOCK'
-
-          def lock_name
-            LOCK_NAME
-          end
-
-          def from_lock_options(environment, options)
-            new(environment, options[:remote], options.reject{|k, v| k == :remote})
-          end
-
-          def from_spec_args(environment, name, options)
-            recognized_options = []
-            unrecognized_options = options.keys - recognized_options
-            unrecognized_options.empty? or raise Error, "unrecognized options: #{unrecognized_options.join(", ")}"
-
-            new(environment, name, options)
-          end
-
-        end
+        lock_name 'MOCK'
+        spec_options []
 
         attr_accessor :environment
         private :environment=

data/lib/librarian/resolution.rb

@@ -25,7 +25,7 @@ module Librarian
     end
 
     def sources
-      manifests.map{|m| m.source}.uniq
+      manifests.map(&:source).uniq
     end
 
   private

data/lib/librarian/resolver.rb

@@ -13,19 +13,24 @@ module Librarian
     end
 
     def resolve(spec, partial_manifests = [])
-      implementation = Implementation.new(self, spec)
-      partial_manifests_index = Hash[partial_manifests.map{|m| [m.name, m]}]
-      manifests = implementation.resolve(spec.dependencies, partial_manifests_index)
-      enforce_consistency!(spec.dependencies, manifests) if manifests
-      manifests = sort(manifests) if manifests
-      Resolution.new(spec.dependencies, manifests)
+      manifests = implementation(spec).resolve(partial_manifests)
+      if manifests
+        enforce_consistency!(spec.dependencies, manifests)
+        manifests = sort(manifests)
+        Resolution.new(spec.dependencies, manifests)
+      end
+    end
+
+  private
+
+    def implementation(spec)
+      Implementation.new(self, spec)
     end
 
     def enforce_consistency!(dependencies, manifests)
-      return if dependencies.all?{|d|
-        m = manifests[d.name]
-        m && d.satisfied_by?(m)
-      } && ManifestSet.new(manifests).consistent?
+      manifest_set = ManifestSet.new(manifests)
+      return if manifest_set.in_compliance_with?(dependencies)
+      return if manifest_set.consistent?
 
       debug { "Resolver Malfunctioned!" }
       errors = []
@@ -68,8 +73,6 @@ module Librarian
       ManifestSet.sort(manifests)
     end
 
-  private
-
     def debug(*args, &block)
       environment.logger.debug(*args, &block)
     end

data/lib/librarian/resolver/implementation.rb

@@ -10,29 +10,114 @@ module Librarian
           self.sources = sources
         end
         def manifests(name)
-          sources.reverse.map{|source| source.manifests(name)}.flatten(1)
+          sources.reverse.map{|source| source.manifests(name)}.flatten(1).compact
+        end
+        def to_s
+          "(no source specified)"
         end
       end
 
-      attr_reader :resolver, :spec, :dependency_source_map
+      attr_accessor :resolver, :spec
+      private :resolver=, :spec=
 
       def initialize(resolver, spec)
-        @resolver = resolver
-        @spec = spec
-        @dependency_source_map = Hash[spec.dependencies.map{|d| [d.name, d.source]}]
+        self.resolver = resolver
+        self.spec = spec
         @level = 0
       end
 
-      def resolve(dependencies, manifests = {})
-        dependencies += manifests.values.map { |m|
-          m.dependencies.map { |d| sourced_dependency_for(d) }
-        }.flatten(1)
-        resolution = recursive_resolve([], manifests, dependencies)
-        resolution ? resolution[1] : nil
+      def resolve(manifests)
+        manifests = index_by(manifests, &:name) if manifests.kind_of?(Array)
+        addtl = spec.dependencies + sourced_dependencies_for_manifests(manifests)
+        recursive_resolve([], manifests, [], addtl)
+      end
+
+    private
+
+      def find_inconsistency(dep, deps, mans)
+        m = mans[dep.name]
+        dep.satisfied_by?(m) or return m if m
+        deps.find{|d| !dep.consistent_with?(d)}
+      end
+
+      def recursive_resolve(dependencies, manifests, queue, addtl)
+        dependencies = dependencies.dup
+        manifests = manifests.dup
+        queue = queue.dup
+
+        return unless enqueue_dependencies(queue, addtl, dependencies, manifests)
+        return unless shift_resolved_enqueued_dependencies(dependencies, manifests, queue)
+        return manifests if queue.empty?
+
+        dependency = queue.shift
+        dependencies << dependency
+        all_deps = dependencies + queue
+
+        resolving_dependency_map_find_manifests(dependency) do |manifest|
+          next unless check_manifest(manifest, all_deps)
+
+          m = manifests.merge(dependency.name => manifest)
+          a = sourced_dependencies_for_manifest(manifest)
+
+          recursive_resolve(dependencies, m, queue, a)
+        end
+      end
+
+      # When using this method, you are required to check the return value.
+      # Returns +true+ if the enqueueables could all be enqueued.
+      # Returns +false+ if there was an inconsistency when trying to enqueue one
+      # or more of them.
+      # This modifies +queue+ but does not modify any other arguments.
+      def enqueue_dependencies(queue, enqueueables, dependencies, manifests)
+        enqueueables.each do |d|
+          if q = find_inconsistency(d, dependencies + queue, manifests)
+            debug_conflict d, q
+            return false
+          end
+          debug_schedule d
+          queue << d
+        end
+        true
+      end
+
+      # When using this method, you are required to check the return value.
+      # Returns +true+ if the resolved enqueued dependencies at the front of the
+      # queue could all be moved to the resolved dependencies list.
+      # Returns +false+ if there was an inconsistency when trying to move one or
+      # more of them.
+      # This modifies +queue+ and +dependencies+.
+      def shift_resolved_enqueued_dependencies(dependencies, manifests, queue)
+        all_deps = dependencies + queue
+        while (dependency = queue.first) && manifests[dependency.name]
+          if q = find_inconsistency(dependency, all_deps, manifests)
+            debug_conflict dependency, q
+            return false
+          end
+          dependencies << queue.shift
+        end
+        true
+      end
+
+      # When using this method, you are required to check the return value.
+      # Returns +true+ if the manifest satisfies all of the dependencies.
+      # Returns +false+ if there was a dependency that the manifest does not
+      # satisfy.
+      def check_manifest(manifest, all_deps)
+        related = all_deps.select{|d| d.name == manifest.name}
+        if q = related.find{|d| !d.satisfied_by?(manifest)}
+          debug_conflict manifest, q
+          return false
+        end
+        true
       end
 
       def default_source
-        MultiSource.new(spec.sources)
+        @default_source ||= MultiSource.new(spec.sources)
+      end
+
+      def dependency_source_map
+        @dependency_source_map ||=
+          Hash[spec.dependencies.map{|d| [d.name, d.source]}]
       end
 
       def sourced_dependency_for(dependency)
@@ -42,75 +127,81 @@ module Librarian
         Dependency.new(dependency.name, dependency.requirement, source)
       end
 
-      def recursive_resolve(dependencies, manifests, queue)
-        if dependencies.empty?
-          queue.each do |dependency|
-            debug { "Scheduling #{dependency}" }
+      def sourced_dependencies_for_manifest(manifest)
+        manifest.dependencies.map{|d| sourced_dependency_for(d)}
+      end
+
+      def sourced_dependencies_for_manifests(manifests)
+        manifests = manifests.values if manifests.kind_of?(Hash)
+        manifests.map{|m| sourced_dependencies_for_manifest(m)}.flatten(1)
+      end
+
+      def resolving_dependency_map_find_manifests(dependency)
+        scope_resolving_dependency dependency do
+          map_find(dependency.manifests) do |manifest|
+            scope_checking_manifest dependency, manifest do
+              yield manifest
+            end
           end
         end
-        failure = false
-        until failure || queue.empty?
-          dependency = queue.shift
-          dependencies << dependency
-          debug { "Resolving #{dependency}" }
-          scope do
-            if manifests.key?(dependency.name)
-              unless dependency.satisfied_by?(manifests[dependency.name])
-                debug { "Conflicts with #{manifests[dependency.name]}" }
-                failure = true
-              else
-                debug { "Accords with all prior constraints" }
-                # nothing left to do
-              end
-            else
-              debug { "No known prior constraints" }
-              resolution = nil
-              related_dependencies = dependencies.select{|d| d.name == dependency.name}
-              unless dependency.manifests && dependency.manifests.first
-                debug { "No known manifests" }
-              else
-                debug { "Checking manifests" }
-                scope do
-                  dependency.manifests.each do |manifest|
-                    break if resolution
-
-                    debug { "Checking #{manifest}" }
-                    scope do
-                      if related_dependencies.all?{|d| d.satisfied_by?(manifest)}
-                        m = manifests.merge(dependency.name => manifest)
-                        a = manifest.dependencies.map { |d| sourced_dependency_for(d) }
-                        a.each do |d|
-                          debug { "Scheduling #{d}" }
-                        end
-                        q = queue + a
-                        resolution = recursive_resolve(dependencies.dup, m, q)
-                      end
-                      if resolution
-                        debug { "Resolved #{dependency} at #{manifest}" }
-                      else
-                        debug { "Backtracking from #{manifest}" }
-                      end
-                    end
-                  end
-                end
-                if resolution
-                  debug { "Resolved #{dependency}" }
-                else
-                  debug { "Failed to resolve #{dependency}" }
-                end
-              end
-              unless resolution
-                failure = true
-              else
-                dependencies, manifests, queue = *resolution
-              end
-            end
+      end
+
+      def scope_resolving_dependency(dependency)
+        debug { "Resolving #{dependency}" }
+        resolution = nil
+        scope do
+          scope_checking_manifests do
+            resolution = yield
+          end
+          if resolution
+            debug { "Resolved #{dependency}" }
+          else
+            debug { "Failed to resolve #{dependency}" }
           end
         end
-        failure ? nil : [dependencies, manifests, queue]
+        resolution
       end
 
-    private
+      def scope_checking_manifests
+        debug { "Checking manifests" }
+        scope do
+          yield
+        end
+      end
+
+      def scope_checking_manifest(dependency, manifest)
+        debug { "Checking #{manifest}" }
+        resolution = nil
+        scope do
+          resolution = yield
+          if resolution
+            debug { "Resolved #{dependency} at #{manifest}" }
+          else
+            debug { "Backtracking from #{manifest}" }
+          end
+        end
+        resolution
+      end
+
+      def debug_schedule(dependency)
+        debug { "Scheduling #{dependency}" }
+      end
+
+      def debug_conflict(dependency, conflict)
+        debug { "Conflict between #{dependency} and #{conflict}" }
+      end
+
+      def map_find(enum)
+        enum.each do |obj|
+          res = yield(obj)
+          res.nil? or return res
+        end
+        nil
+      end
+
+      def index_by(enum)
+        Hash[enum.map{|obj| [yield(obj), obj]}]
+      end
 
       def scope
         @level += 1

data/lib/librarian/source/basic_api.rb

@@ -0,0 +1,45 @@
+module Librarian
+  module Source
+    module BasicApi
+
+      def self.included(base)
+        base.extend ClassMethods
+        class << base
+          def lock_name(name)
+            def_sclass_prop(:lock_name, name)
+          end
+
+          def spec_options(keys)
+            def_sclass_prop(:spec_options, keys)
+          end
+
+        private
+
+          def def_sclass_prop(name, arg)
+            sclass = class << self ; self ; end
+            sclass.module_exec do
+              remove_method(name)
+              define_method(name) { arg }
+            end
+          end
+        end
+      end
+
+      module ClassMethods
+        def from_lock_options(environment, options)
+          new(environment, options[:remote], options.reject{|k, v| k == :remote})
+        end
+
+        def from_spec_args(environment, param, options)
+          recognized_options = spec_options
+          unrecognized_options = options.keys - recognized_options
+          unrecognized_options.empty? or raise Error,
+            "unrecognized options: #{unrecognized_options.join(", ")}"
+
+          new(environment, param, options)
+        end
+      end
+
+    end
+  end
+end

data/lib/librarian/source/git.rb

@@ -2,36 +2,18 @@ require 'fileutils'
 require 'pathname'
 require 'digest'
 
+require 'librarian/source/basic_api'
 require 'librarian/source/git/repository'
 require 'librarian/source/local'
 
 module Librarian
   module Source
     class Git
-
+      include BasicApi
       include Local
 
-      class << self
-
-        LOCK_NAME = 'GIT'
-
-        def lock_name
-          LOCK_NAME
-        end
-
-        def from_lock_options(environment, options)
-          new(environment, options[:remote], options.reject{|k, v| k == :remote})
-        end
-
-        def from_spec_args(environment, uri, options)
-          recognized_options = [:ref, :path]
-          unrecognized_options = options.keys - recognized_options
-          unrecognized_options.empty? or raise Error, "unrecognized options: #{unrecognized_options.join(", ")}"
-
-          new(environment, uri, options)
-        end
-
-      end
+      lock_name 'GIT'
+      spec_options [:ref, :path]
 
       DEFAULTS = {
         :ref => 'master'