librarian-puppet 0.9.10 → 0.9.11

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

@@ -1,15 +0,0 @@
-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

@@ -1,24 +0,0 @@
-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

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

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

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

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

@@ -1,103 +0,0 @@
-require 'librarian/manifest'
-require 'librarian/mock/source/mock/registry'
-
-module Librarian
-  module Mock
-    module Source
-      class Mock
-
-        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
-
-        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
-
-        alias :eql? :==
-
-        def hash
-          self.to_s.hash
-        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

@@ -1,83 +0,0 @@
-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

@@ -1,44 +0,0 @@
-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_reader :dependencies, :manifests, :manifests_index
-
-    def initialize(dependencies, manifests)
-      @dependencies, @manifests = dependencies, manifests
-      @manifests_index = build_manifests_index(manifests)
-    end
-
-    def correct?
-      manifests && manifests_consistent_with_dependencies? && manifests_internally_consistent?
-    end
-
-    def sources
-      manifests.map{|m| m.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

@@ -1,78 +0,0 @@
-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 = [])
-      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)
-    end
-
-    def enforce_consistency!(dependencies, manifests)
-      return if dependencies.all?{|d|
-        m = manifests[d.name]
-        m && d.satisfied_by?(m)
-      } && ManifestSet.new(manifests).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
-
-  private
-
-    def debug(*args, &block)
-      environment.logger.debug(*args, &block)
-    end
-
-  end
-end

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

@@ -1,118 +0,0 @@
-require 'librarian/dependency'
-
-module Librarian
-  class Resolver
-    class Implementation
-
-      attr_reader :resolver, :source, :dependency_source_map
-
-      def initialize(resolver, spec)
-        @resolver = resolver
-        @source = spec.source
-        @dependency_source_map = Hash[spec.dependencies.map{|d| [d.name, d.source]}]
-        @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
-      end
-
-      def sourced_dependency_for(dependency)
-        return dependency if dependency.source
-
-        s = dependency_source_map[dependency.name] || source
-        Dependency.new(dependency.name, dependency.requirement, s)
-      end
-
-      def recursive_resolve(dependencies, manifests, queue)
-        if dependencies.empty?
-          queue.each do |dependency|
-            debug { "Scheduling #{dependency}" }
-          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
-        end
-        failure ? nil : [dependencies, manifests, queue]
-      end
-
-    private
-
-      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