librarianp 0.1.2

data/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/lib/librarian/resolver/implementation.rb

@@ -0,0 +1,238 @@
+require 'set'
+
+require 'librarian/algorithms'
+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
+
+      class State
+        attr_accessor :manifests, :dependencies, :queue
+        private :manifests=, :dependencies=, :queue=
+        def initialize(manifests, dependencies, queue)
+          self.manifests = manifests
+          self.dependencies = dependencies # resolved
+          self.queue = queue # scheduled
+        end
+      end
+
+      attr_accessor :resolver, :spec, :cyclic
+      private :resolver=, :spec=, :cyclic=
+
+      def initialize(resolver, spec, options = { })
+        unrecognized_options = options.keys - [:cyclic]
+        unrecognized_options.empty? or raise Error,
+          "unrecognized options: #{unrecognized_options.join(", ")}"
+        self.resolver = resolver
+        self.spec = spec
+        self.cyclic = !!options[:cyclic]
+        @level = 0
+      end
+
+      def resolve(manifests)
+        manifests = index_by(manifests, &:name) if manifests.kind_of?(Array)
+        queue = spec.dependencies + sourced_dependencies_for_manifests(manifests)
+        state = State.new(manifests.dup, [], queue)
+        recursive_resolve(state)
+      end
+
+    private
+
+      def recursive_resolve(state)
+        shift_resolved_enqueued_dependencies(state) or return
+        state.queue.empty? and return state.manifests
+
+        state.dependencies << state.queue.shift
+        dependency = state.dependencies.last
+
+        resolving_dependency_map_find_manifests(dependency) do |manifest|
+          check_manifest(state, manifest) or next
+          check_manifest_for_cycles(state, manifest) or next unless cyclic
+
+          m = state.manifests.merge(dependency.name => manifest)
+          a = sourced_dependencies_for_manifest(manifest)
+          s = State.new(m, state.dependencies.dup, state.queue + a)
+
+          recursive_resolve(s)
+        end
+      end
+
+      def find_inconsistency(state, dependency)
+        m = state.manifests[dependency.name]
+        dependency.satisfied_by?(m) or return m if m
+        violation = lambda{|d| !dependency.consistent_with?(d)}
+        state.dependencies.find(&violation) || state.queue.find(&violation)
+      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(state)
+        while (d = state.queue.first) && state.manifests[d.name]
+          if q = find_inconsistency(state, d)
+            debug_conflict d, q
+            return false
+          end
+          state.dependencies << state.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(state, manifest)
+        violation = lambda{|d| d.name == manifest.name && !d.satisfied_by?(manifest)}
+        if q = state.dependencies.find(&violation) || state.queue.find(&violation)
+          debug_conflict manifest, q
+          return false
+        end
+        true
+      end
+
+      # When using this method, you are required to check the return value.
+      # Returns +true+ if the manifest does not introduce a cycle.
+      # Returns +false+ if the manifest introduces a cycle.
+      def check_manifest_for_cycles(state, manifest)
+        manifests = state.manifests.merge(manifest.name => manifest)
+        known = manifests.keys
+        graph = Hash[manifests.map{|n, m| [n, m.dependencies.map(&:name) & known]}]
+        if Algorithms::AdjacencyListDirectedGraph.cyclic?(graph)
+          debug_cycle manifest
+          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 debug_cycle(manifest)
+        debug { "Cycle with #{manifest}" }
+      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

data/lib/librarian/resolver.rb

@@ -0,0 +1,94 @@
+require 'librarian/error'
+require 'librarian/resolver/implementation'
+require 'librarian/manifest_set'
+require 'librarian/resolution'
+
+module Librarian
+  class Resolver
+
+    attr_accessor :environment, :cyclic
+    private :environment=, :cyclic=
+
+    # Options:
+    #   cyclic: truthy if the resolver should permit cyclic resolutions
+    def initialize(environment, options = { })
+      unrecognized_options = options.keys - [:cyclic]
+      unrecognized_options.empty? or raise Error,
+        "unrecognized options: #{unrecognized_options.join(", ")}"
+      self.environment = environment
+      self.cyclic = !!options[:cyclic]
+    end
+
+    def resolve(spec, partial_manifests = [])
+      manifests = implementation(spec).resolve(partial_manifests)
+      manifests or return
+      enforce_consistency!(spec.dependencies, manifests)
+      enforce_acyclicity!(manifests) unless cyclic
+      manifests = sort(manifests)
+      Resolution.new(spec.dependencies, manifests)
+    end
+
+  private
+
+    def implementation(spec)
+      Implementation.new(self, spec, :cyclic => cyclic)
+    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 enforce_acyclicity!(manifests)
+      ManifestSet.cyclic?(manifests) or return
+      debug { "Resolver Malfunctioned!" }
+      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/lib/librarian/rspec/support/cli_macro.rb

@@ -0,0 +1,120 @@
+require "json"
+require "pathname"
+require "securerandom"
+require "stringio"
+require "thor"
+
+require "librarian/helpers"
+
+module Librarian
+  module RSpec
+    module Support
+      module CliMacro
+
+        class FakeShell < Thor::Shell::Basic
+          def stdout
+            @stdout ||= StringIO.new
+          end
+          def stderr
+            @stderr ||= StringIO.new
+          end
+          def stdin
+            raise "unsupported"
+          end
+        end
+
+        class FileMatcher
+          attr_accessor :rel_path, :content, :type, :base_path
+          def initialize(rel_path, content, options = { })
+            self.rel_path = rel_path
+            self.content = content
+            self.type = options[:type]
+          end
+          def full_path
+            @full_path ||= base_path + rel_path
+          end
+          def actual_content
+            @actual_content ||= begin
+              s = full_path.read
+              s = JSON.parse(s) if type == :json
+              s
+            end
+          end
+          def matches?(base_path)
+            base_path = Pathname(base_path) unless Pathname === base_path
+            self.base_path = base_path
+
+            full_path.file? && (!content || actual_content == content)
+          end
+        end
+
+        def self.included(base)
+          base.instance_exec do
+            let(:project_path) do
+              project_path = Pathname.new(__FILE__).expand_path
+              project_path = project_path.dirname until project_path.join("Rakefile").exist?
+              project_path
+            end
+            let(:tmp) { project_path.join("tmp/spec/cli") }
+            let(:pwd) { tmp + SecureRandom.hex(8) }
+
+            before { tmp.mkpath }
+            before { pwd.mkpath }
+
+            after  { tmp.rmtree }
+          end
+        end
+
+        def cli!(*args)
+          @shell = FakeShell.new
+          @exit_status = Dir.chdir(pwd) do
+            described_class.with_environment do
+              described_class.returning_status do
+                described_class.start args, :shell => @shell
+              end
+            end
+          end
+        end
+
+        def write_file!(path, content)
+          path = pwd.join(path)
+          path.dirname.mkpath
+          path.open("wb"){|f| f.write(content)}
+        end
+
+        def write_json_file!(path, content)
+          write_file! path, JSON.dump(content)
+        end
+
+        def strip_heredoc(text)
+          Librarian::Helpers.strip_heredoc(text)
+        end
+
+        def shell
+          @shell
+        end
+
+        def stdout
+          shell.stdout.string
+        end
+
+        def stderr
+          shell.stderr.string
+        end
+
+        def exit_status
+          @exit_status
+        end
+
+        def have_file(rel_path, content = nil)
+          FileMatcher.new(rel_path, content)
+        end
+
+        def have_json_file(rel_path, content)
+          FileMatcher.new(rel_path, content, :type => :json)
+        end
+
+      end
+    end
+  end
+end

data/lib/librarian/source/basic_api.rb

@@ -0,0 +1,45 @@
+module Librarian
+  module Source
+    module BasicApi
+
+      def self.included(base)
+        base.extend ClassMethods
+        class << base
+          def lock_name(name)
+            def_sclass_prop(:lock_name, name)
+          end
+
+          def spec_options(keys)
+            def_sclass_prop(:spec_options, keys)
+          end
+
+        private
+
+          def def_sclass_prop(name, arg)
+            sclass = class << self ; self ; end
+            sclass.module_exec do
+              remove_method(name)
+              define_method(name) { arg }
+            end
+          end
+        end
+      end
+
+      module ClassMethods
+        def from_lock_options(environment, options)
+          new(environment, options[:remote], options.reject{|k, v| k == :remote})
+        end
+
+        def from_spec_args(environment, param, options)
+          recognized_options = spec_options
+          unrecognized_options = options.keys - recognized_options
+          unrecognized_options.empty? or raise Error,
+            "unrecognized options: #{unrecognized_options.join(", ")}"
+
+          new(environment, param, options)
+        end
+      end
+
+    end
+  end
+end