librarian-puppet 0.0.1.pre

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,97 @@
+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
+
+        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,44 @@
+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

@@ -0,0 +1,73 @@
+require 'librarian/resolver/implementation'
+require 'librarian/manifest_set'
+require 'librarian/resolution'
+
+module Librarian
+  class Resolver
+    include Helpers::Debug
+
+    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
+
+  end
+end

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

@@ -0,0 +1,122 @@
+require 'librarian/helpers/debug'
+
+require 'librarian/dependency'
+
+module Librarian
+  class Resolver
+    class Implementation
+
+      include Helpers::Debug
+
+      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
+        super { '  ' * @level + yield }
+      end
+
+      def environment
+        resolver.environment
+      end
+
+    end
+  end
+end

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

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

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

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