librarian 0.0.1

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

@@ -0,0 +1,79 @@
+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
+
+          class << self
+            def clear!
+              @sources = nil
+            end
+            def merge!(&block)
+              @sources ||= {}
+              Dsl.run!(@sources, &block) if block
+            end
+            def [](name)
+              @sources ||= {}
+              @sources[name] ||= {}
+            end
+          end
+
+        end
+      end
+    end
+  end
+end

data/lib/librarian/particularity.rb

@@ -0,0 +1,7 @@
+module Librarian
+  module Particularity
+    def root_module
+      nil
+    end
+  end
+end

data/lib/librarian/resolution.rb

@@ -0,0 +1,36 @@
+module Librarian
+  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?
+      dependencies.all? do |dependency|
+        manifest = manifests_index[dependency.name]
+        dependency.satisfied_by?(manifest)
+      end
+    end
+
+    def manifests_internally_consistent?
+      ManifestSet.new(manifests).consistent?
+    end
+
+  end
+end

data/lib/librarian/resolver.rb

@@ -0,0 +1,139 @@
+require 'librarian/helpers/debug'
+
+require 'librarian/dependency'
+require 'librarian/manifest_set'
+require 'librarian/resolution'
+
+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 = {})
+        resolution = recursive_resolve([], manifests, dependencies.dup)
+        resolution ? resolution[1] : nil
+      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|
+                    unless 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|
+                            d.source ? d :
+                            !dependency_source_map.key?(d.name) ?
+                            Dependency.new(d.name, d.requirement, source) :
+                            Dependency.new(d.name, d.requirement, dependency_source_map[d.name])
+                          }
+                          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
+                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 root_module
+        resolver.root_module
+      end
+    end
+
+    include Helpers::Debug
+
+    attr_reader :root_module
+
+    def initialize(root_module)
+      @root_module = root_module
+    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)
+      manifests = sort(manifests) if manifests
+      Resolution.new(spec.dependencies, manifests)
+    end
+
+    def sort(manifests)
+      ManifestSet.sort(manifests)
+    end
+
+  end
+end

data/lib/librarian/source.rb

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

data/lib/librarian/source/git.rb

@@ -0,0 +1,91 @@
+require 'fileutils'
+require 'pathname'
+require 'digest'
+
+require 'librarian/particularity'
+require 'librarian/source/git/repository'
+require 'librarian/source/local'
+
+module Librarian
+  module Source
+    class Git
+
+      include Particularity
+      include Local
+
+      class << self
+        LOCK_NAME = 'GIT'
+        def lock_name
+          LOCK_NAME
+        end
+        def from_lock_options(options)
+          new(options[:remote], options.reject{|k, v| k == :remote})
+        end
+      end
+
+      DEFAULTS = {
+        :ref => 'master'
+      }
+
+      attr_reader :uri, :ref, :sha
+
+      def initialize(uri, options = {})
+        @uri = uri
+        @ref = options[:ref] || DEFAULTS[:ref]
+        @sha = options[:sha]
+        @repository = nil
+        @repository_cache_path = nil
+      end
+
+      def to_s
+        "#{uri}##{ref}"
+      end
+
+      def ==(other)
+        other &&
+        self.class  == other.class  &&
+        self.uri    == other.uri    &&
+        self.ref    == other.ref    &&
+        (self.sha.nil? || other.sha.nil? || self.sha == other.sha)
+      end
+
+      def to_spec_args
+        [uri, {:ref => ref}]
+      end
+
+      def to_lock_options
+        {:remote => uri, :ref => ref, :sha => sha}
+      end
+
+      def cache!(dependencies)
+        unless repository.git?
+          repository.path.rmtree if repository.path.exist?
+          repository.path.mkpath
+          repository.clone!(uri)
+        end
+        unless sha == repository.current_commit_hash
+          repository.checkout!(sha || ref)
+          @sha ||= repository.current_commit_hash
+        end
+      end
+
+      def repository_cache_path
+        @repository_cache_path ||= begin
+          dir = Digest::MD5.hexdigest(uri)
+          root_module.cache_path.join("source/git/#{dir}")
+        end
+      end
+
+      def repository
+        @repository ||= begin
+          Repository.new(root_module, repository_cache_path)
+        end
+      end
+
+      def path
+        @path ||= repository.path
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,82 @@
+require 'open3'
+
+require 'librarian/helpers/debug'
+
+module Librarian
+  module Source
+    class Git
+      class Repository
+
+        class << self
+          def clone!(root_module, path, repository_url)
+            path = Pathname.new(path)
+            path.mkpath
+            git = new(root_module, path)
+            git.clone!(repository_url)
+            git
+          end
+        end
+
+        include Helpers::Debug
+
+        attr_reader :root_module, :path
+
+        def initialize(root_module, path)
+          path = Pathname.new(path)
+          @root_module = root_module
+          @path = path
+        end
+
+        def git?
+          path.join('.git').exist?
+        end
+
+        def clone!(repository_url)
+          within do
+            command = "clone #{repository_url} ."
+            run!(command)
+          end
+        end
+
+        def checkout!(reference)
+          within do
+            command = "checkout #{reference}"
+            run!(command)
+          end
+        end
+
+        def hash_from(reference)
+          within do
+            command = "rev-parse #{reference}"
+            run!(command)
+          end
+        end
+
+        def current_commit_hash
+          within do
+            command = "rev-parse HEAD"
+            run!(command).strip!
+          end
+        end
+
+      private
+
+        def run!(text)
+          text = "git #{text} --quiet"
+          debug { "Running `#{text}` in #{relative_path_to(Dir.pwd)}" }
+          out = Open3.popen3(text) do |i, o, e, t|
+            raise StandardError, e.read unless (t ? t.value : $?).success?
+            o.read
+          end
+          debug { "    ->  #{out}" } if out.size > 0
+          out
+        end
+
+        def within
+          Dir.chdir(path) { yield }
+        end
+
+      end
+    end
+  end
+end

data/lib/librarian/source/local.rb

@@ -0,0 +1,33 @@
+require 'librarian/support/abstract_method'
+
+module Librarian
+  module Source
+    # Requires that the including source class have methods:
+    #   #path
+    #   #root_module
+    module Local
+
+      include Support::AbstractMethod
+
+      abstract_method :path
+
+      def manifests(dependency)
+        manifest = manifest_class.create(self, dependency, path)
+        [manifest].compact
+      end
+
+      def manifest(name, version, dependencies)
+        manifest = manifest_class.create(self, Dependency.new(name, nil, nil), path)
+        manifest.version = version
+        manifest.dependencies = dependencies
+        manifest
+      end
+
+      def manifest_search_paths(dependency)
+        paths = [path, path.join(dependency.name)]
+        paths.select{|s| s.exist?}
+      end
+
+    end
+  end
+end