librarian-puppet-lmco 0.9.8.2

data/vendor/librarian/lib/librarian/mock.rb

@@ -0,0 +1 @@
+require 'librarian/mock/extension'

data/vendor/librarian/lib/librarian/mock/cli.rb

@@ -0,0 +1,19 @@
+require 'librarian/cli'
+require 'librarian/mock'
+
+module Librarian
+  module Mock
+    class Cli < Librarian::Cli
+
+      module Particularity
+        def root_module
+          Mock
+        end
+      end
+
+      include Particularity
+      extend Particularity
+
+    end
+  end
+end

data/vendor/librarian/lib/librarian/mock/dsl.rb

@@ -0,0 +1,15 @@
+require 'librarian/dsl'
+require 'librarian/mock/source'
+
+module Librarian
+  module Mock
+    class Dsl < Librarian::Dsl
+
+      dependency :dep
+
+      source :src => Source::Mock
+
+      shortcut :a, :src => 'source-a'
+    end
+  end
+end

data/vendor/librarian/lib/librarian/mock/environment.rb

@@ -0,0 +1,24 @@
+require "librarian/environment"
+require "librarian/mock/dsl"
+
+module Librarian
+  module Mock
+    class Environment < Environment
+
+      def adapter_name
+        "mock"
+      end
+
+      def install_path
+        nil
+      end
+
+      def registry(options = nil, &block)
+        @registry ||= Source::Mock::Registry.new
+        @registry.merge!(options, &block)
+        @registry
+      end
+    end
+
+  end
+end

data/vendor/librarian/lib/librarian/mock/extension.rb

@@ -0,0 +1,9 @@
+require 'librarian/mock/environment'
+
+module Librarian
+  module Mock
+    extend self
+    extend Librarian
+
+  end
+end

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

@@ -0,0 +1 @@
+require 'librarian/mock/source/mock'

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

@@ -0,0 +1,80 @@
+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
+
+        lock_name 'MOCK'
+        spec_options []
+
+        attr_accessor :environment
+        private :environment=
+        attr_reader :name
+
+        def initialize(environment, name, options)
+          self.environment = environment
+          @name = name
+        end
+
+        def to_s
+          name
+        end
+
+        def ==(other)
+          other &&
+          self.class  == other.class &&
+          self.name   == other.name
+        end
+
+        def to_spec_args
+          [name, {}]
+        end
+
+        def to_lock_options
+          {:remote => name}
+        end
+
+        def registry
+          environment.registry[name]
+        end
+
+        def manifest(name, version, dependencies)
+          manifest = Manifest.new(self, name)
+          manifest.version = version
+          manifest.dependencies = dependencies
+          manifest
+        end
+
+        def manifests(name)
+          if d = registry[name]
+            d.map{|v| manifest(name, v[:version], v[:dependencies])}
+          else
+            nil
+          end
+        end
+
+        def install!(manifest)
+        end
+
+        def to_s
+          name
+        end
+
+        def fetch_version(name, extra)
+          extra
+        end
+
+        def fetch_dependencies(name, version, extra)
+          d = registry[name]
+          m = d.find{|v| v[:version] == version.to_s}
+          m[:dependencies]
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,83 @@
+module Librarian
+  module Mock
+    module Source
+      class Mock
+        class Registry
+
+          module Dsl
+
+            class Top
+              def initialize(sources)
+                @sources = sources
+              end
+              def source(name, &block)
+                @sources[name] ||= {}
+                Source.new(@sources[name]).instance_eval(&block) if block
+              end
+            end
+
+            class Source
+              def initialize(source)
+                @source = source
+              end
+              def spec(name, version = nil, &block)
+                @source[name] ||= []
+                unless version
+                  Spec.new(@source[name]).instance_eval(&block) if block
+                else
+                  Spec.new(@source[name]).version(version, &block)
+                end
+                @source[name] = @source[name].sort_by{|a| Manifest::Version.new(a[:version])}.reverse
+              end
+            end
+
+            class Spec
+              def initialize(spec)
+                @spec = spec
+              end
+              def version(name, &block)
+                @spec << { :version => name, :dependencies => {} }
+                Version.new(@spec.last[:dependencies]).instance_eval(&block) if block
+              end
+            end
+
+            class Version
+              def initialize(version)
+                @version = version
+              end
+              def dependency(name, *requirement)
+                @version[name] = requirement
+              end
+            end
+
+            class << self
+              def run!(sources, &block)
+                Top.new(sources).instance_eval(&block) if block
+              end
+            end
+
+          end
+
+          def initialize
+            clear!
+          end
+          def clear!
+            self.sources = { }
+          end
+          def merge!(options = nil, &block)
+            clear! if options && options[:clear]
+            Dsl.run!(sources, &block) if block
+          end
+          def [](name)
+            sources[name] ||= {}
+          end
+
+        private
+
+          attr_accessor :sources
+
+        end
+      end
+    end
+  end
+end

data/vendor/librarian/lib/librarian/resolution.rb

@@ -0,0 +1,46 @@
+module Librarian
+  #
+  # Represents the output of the resolution process. Captures the declared
+  # dependencies plus the full set of resolved manifests. The sources are
+  # already known by the dependencies and by the resolved manifests, so they do
+  # not need to be captured explicitly.
+  #
+  # This representation may be produced by the resolver, may be serialized into
+  # a lockfile, and may be deserialized from a lockfile. It is expected that the
+  # lockfile is a direct representation in text of this representation, so that
+  # the serialization-deserialization process is just the identity function.
+  #
+  class Resolution
+    attr_accessor :dependencies, :manifests, :manifests_index
+    private :dependencies=, :manifests=, :manifests_index=
+
+    def initialize(dependencies, manifests)
+      self.dependencies = dependencies
+      self.manifests = manifests
+      self.manifests_index = build_manifests_index(manifests)
+    end
+
+    def correct?
+      manifests && manifests_consistent_with_dependencies? && manifests_internally_consistent?
+    end
+
+    def sources
+      manifests.map(&:source).uniq
+    end
+
+  private
+
+    def build_manifests_index(manifests)
+      Hash[manifests.map{|m| [m.name, m]}] if manifests
+    end
+
+    def manifests_consistent_with_dependencies?
+      ManifestSet.new(manifests).in_compliance_with?(dependencies)
+    end
+
+    def manifests_internally_consistent?
+      ManifestSet.new(manifests).consistent?
+    end
+
+  end
+end

data/vendor/librarian/lib/librarian/resolver.rb

@@ -0,0 +1,81 @@
+require 'librarian/resolver/implementation'
+require 'librarian/manifest_set'
+require 'librarian/resolution'
+
+module Librarian
+  class Resolver
+
+    attr_accessor :environment
+    private :environment=
+
+    def initialize(environment)
+      self.environment = environment
+    end
+
+    def resolve(spec, partial_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)
+      manifest_set = ManifestSet.new(manifests)
+      return if manifest_set.in_compliance_with?(dependencies)
+      return if manifest_set.consistent?
+
+      debug { "Resolver Malfunctioned!" }
+      errors = []
+      dependencies.sort_by(&:name).each do |d|
+        m = manifests[d.name]
+        if !m
+          errors << ["Depends on #{d}", "Missing!"]
+        elsif !d.satisfied_by?(m)
+          errors << ["Depends on #{d}", "Found: #{m}"]
+        end
+      end
+      unless errors.empty?
+        errors.each do |a, b|
+          debug { "  #{a}" }
+          debug { "    #{b}" }
+        end
+      end
+      manifests.values.sort_by(&:name).each do |manifest|
+        errors = []
+        manifest.dependencies.sort_by(&:name).each do |d|
+          m = manifests[d.name]
+          if !m
+            errors << ["Depends on: #{d}", "Missing!"]
+          elsif !d.satisfied_by?(m)
+            errors << ["Depends on: #{d}", "Found: #{m}"]
+          end
+        end
+        unless errors.empty?
+          debug { "  #{manifest}" }
+          errors.each do |a, b|
+            debug { "    #{a}" }
+            debug { "      #{b}" }
+          end
+        end
+      end
+      raise Error, "Resolver Malfunctioned!"
+    end
+
+    def sort(manifests)
+      ManifestSet.sort(manifests)
+    end
+
+    def debug(*args, &block)
+      environment.logger.debug(*args, &block)
+    end
+
+  end
+end

data/vendor/librarian/lib/librarian/resolver/implementation.rb

@@ -0,0 +1,223 @@
+require 'librarian/dependency'
+
+module Librarian
+  class Resolver
+    class Implementation
+
+      class MultiSource
+        attr_accessor :sources
+        def initialize(sources)
+          self.sources = sources
+        end
+        def manifests(name)
+          sources.reverse.map{|source| source.manifests(name)}.flatten(1).compact
+        end
+        def to_s
+          "(no source specified)"
+        end
+      end
+
+      attr_accessor :resolver, :spec
+      private :resolver=, :spec=
+
+      def initialize(resolver, spec)
+        self.resolver = resolver
+        self.spec = spec
+        @level = 0
+      end
+
+      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
+        @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)
+        return dependency if dependency.source
+
+        source = dependency_source_map[dependency.name] || default_source
+        Dependency.new(dependency.name, dependency.requirement, source)
+      end
+
+      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
+      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
+        resolution
+      end
+
+      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
+        yield
+      ensure
+        @level -= 1
+      end
+
+      def debug
+        environment.logger.debug { '  ' * @level + yield }
+      end
+
+      def environment
+        resolver.environment
+      end
+
+    end
+  end
+end