librarian-puppet-maestrodev 0.9.7.5 → 0.9.8.1

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

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

@@ -1,2 +0,0 @@
-require 'librarian/source/git'
-require 'librarian/source/path'

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

@@ -1,150 +0,0 @@
-require 'fileutils'
-require 'pathname'
-require 'digest'
-
-require 'librarian/source/git/repository'
-require 'librarian/source/local'
-
-module Librarian
-  module Source
-    class Git
-
-      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
-
-      DEFAULTS = {
-        :ref => 'master'
-      }
-
-      attr_accessor :environment
-      private :environment=
-
-      attr_accessor :uri, :ref, :sha, :path
-      private :uri=, :ref=, :sha=, :path=
-
-      def initialize(environment, uri, options)
-        self.environment = environment
-        self.uri = uri
-        self.ref = options[:ref] || DEFAULTS[:ref]
-        self.sha = options[:sha]
-        self.path = options[:path]
-
-        @repository = nil
-        @repository_cache_path = nil
-      end
-
-      def to_s
-        path ? "#{uri}##{ref}(#{path})" : "#{uri}##{ref}"
-      end
-
-      def ==(other)
-        other &&
-        self.class  == other.class  &&
-        self.uri    == other.uri    &&
-        self.ref    == other.ref    &&
-        self.path   == other.path   &&
-        (self.sha.nil? || other.sha.nil? || self.sha == other.sha)
-      end
-
-      def to_spec_args
-        options = {}
-        options.merge!(:ref => ref) if ref != DEFAULTS[:ref]
-        options.merge!(:path => path) if path
-        [uri, options]
-      end
-
-      def to_lock_options
-        options = {:remote => uri, :ref => ref, :sha => sha}
-        options.merge!(:path => path) if path
-        options
-      end
-
-      def pinned?
-        !!sha
-      end
-
-      def unpin!
-        @sha = nil
-      end
-
-      def cache!
-        repository_cached? and return or repository_cached!
-
-        unless repository.git?
-          repository.path.rmtree if repository.path.exist?
-          repository.path.mkpath
-          repository.clone!(uri)
-        end
-        repository.reset_hard!
-        repository.clean!
-        unless repository.checked_out?(sha)
-          remote = repository.default_remote
-          repository.fetch!(remote)
-          repository.fetch!(remote, :tags => true)
-
-          self.sha = repository.hash_from(remote, ref) unless sha
-          repository.checkout!(sha) unless repository.checked_out?(sha)
-
-          raise Error, "failed to checkout #{sha}" unless repository.checked_out?(sha)
-        end
-      end
-
-    private
-
-      attr_accessor :repository_cached
-      alias repository_cached? repository_cached
-
-      def repository_cached!
-        self.repository_cached = true
-      end
-
-      def repository_cache_path
-        @repository_cache_path ||= begin
-          environment.cache_path.join("source/git/#{cache_key}")
-        end
-      end
-
-      def repository
-        @repository ||= begin
-          Repository.new(environment, repository_cache_path)
-        end
-      end
-
-      def filesystem_path
-        @filesystem_path ||= path ? repository.path.join(path) : repository.path
-      end
-
-      def cache_key
-        @cache_key ||= begin
-          uri_part = uri
-          path_part = "/#{path}" if path
-          ref_part = "##{ref}"
-          key_source = [uri_part, path_part, ref_part].join
-          Digest::MD5.hexdigest(key_source)
-        end
-      end
-
-    end
-  end
-end