librarianp 0.1.2

data/lib/librarian/action/clean.rb

@@ -0,0 +1,44 @@
+require "librarian/action/base"
+
+module Librarian
+  module Action
+    class Clean < Base
+
+      def run
+        clean_cache_path
+        clean_install_path
+      end
+
+    private
+
+      def clean_cache_path
+        if cache_path.exist?
+          debug { "Deleting #{project_relative_path_to(cache_path)}" }
+          cache_path.rmtree
+        end
+      end
+
+      def clean_install_path
+        if install_path.exist?
+          install_path.children.each do |c|
+            debug { "Deleting #{project_relative_path_to(c)}" }
+            c.rmtree unless c.file?
+          end
+        end
+      end
+
+      def cache_path
+        environment.cache_path
+      end
+
+      def install_path
+        environment.install_path
+      end
+
+      def project_relative_path_to(path)
+        environment.project_relative_path_to(path)
+      end
+
+    end
+  end
+end

data/lib/librarian/action/ensure.rb

@@ -0,0 +1,24 @@
+require "librarian/error"
+require "librarian/action/base"
+
+module Librarian
+  module Action
+    class Ensure < Base
+
+      def run
+        raise Error, "Cannot find #{specfile_name}!" unless project_path
+      end
+
+    private
+
+      def specfile_name
+        environment.specfile_name
+      end
+
+      def project_path
+        environment.project_path
+      end
+
+    end
+  end
+end

data/lib/librarian/action/install.rb

@@ -0,0 +1,95 @@
+require "librarian/manifest_set"
+require "librarian/spec_change_set"
+require "librarian/action/base"
+
+module Librarian
+  module Action
+    class Install < Base
+
+      def run
+        check_preconditions
+
+        perform_installation
+      end
+
+    private
+
+      def check_preconditions
+        check_specfile
+        check_lockfile
+        check_consistent
+      end
+
+      def check_specfile
+        raise Error, "#{specfile_name} missing!" unless specfile_path.exist?
+      end
+
+      def check_lockfile
+        raise Error, "#{lockfile_name} missing!" unless lockfile_path.exist?
+      end
+
+      def check_consistent
+        raise Error, "#{specfile_name} and #{lockfile_name} are out of sync!" unless spec_consistent_with_lock?
+      end
+
+      def perform_installation
+        manifests = sorted_manifests
+
+        create_install_path
+        install_manifests(manifests)
+      end
+
+      def create_install_path
+        install_path.rmtree if install_path.exist?
+        install_path.mkpath
+      end
+
+      def install_manifests(manifests)
+        manifests.each do |manifest|
+          manifest.install!
+        end
+      end
+
+      def sorted_manifests
+        ManifestSet.sort(lock.manifests)
+      end
+
+      def specfile_name
+        environment.specfile_name
+      end
+
+      def specfile_path
+        environment.specfile_path
+      end
+
+      def lockfile_name
+        environment.lockfile_name
+      end
+
+      def lockfile_path
+        environment.lockfile_path
+      end
+
+      def spec
+        environment.spec
+      end
+
+      def lock
+        environment.lock
+      end
+
+      def spec_change_set(spec, lock)
+        SpecChangeSet.new(environment, spec, lock)
+      end
+
+      def spec_consistent_with_lock?
+        spec_change_set(spec, lock).same?
+      end
+
+      def install_path
+        environment.install_path
+      end
+
+    end
+  end
+end

data/lib/librarian/action/persist_resolution_mixin.rb

@@ -0,0 +1,51 @@
+require "librarian/error"
+require "librarian/spec_change_set"
+
+module Librarian
+  module Action
+    module PersistResolutionMixin
+
+    private
+
+      def persist_resolution(resolution)
+        resolution && resolution.correct? or raise Error,
+          "Could not resolve the dependencies."
+
+        lockfile_text = lockfile.save(resolution)
+        debug { "Bouncing #{lockfile_name}" }
+        bounced_lockfile_text = lockfile.save(lockfile.load(lockfile_text))
+        unless bounced_lockfile_text == lockfile_text
+          debug { "lockfile_text: \n#{lockfile_text}" }
+          debug { "bounced_lockfile_text: \n#{bounced_lockfile_text}" }
+          raise Error, "Cannot bounce #{lockfile_name}!"
+        end
+        lockfile_path.open('wb') { |f| f.write(lockfile_text) }
+      end
+
+      def specfile_name
+        environment.specfile_name
+      end
+
+      def lockfile_name
+        environment.lockfile_name
+      end
+
+      def specfile_path
+        environment.specfile_path
+      end
+
+      def lockfile_path
+        environment.lockfile_path
+      end
+
+      def specfile
+        environment.specfile
+      end
+
+      def lockfile
+        environment.lockfile
+      end
+
+    end
+  end
+end

data/lib/librarian/action/resolve.rb

@@ -0,0 +1,46 @@
+require "librarian/resolver"
+require "librarian/spec_change_set"
+require "librarian/action/base"
+require "librarian/action/persist_resolution_mixin"
+
+module Librarian
+  module Action
+    class Resolve < Base
+      include PersistResolutionMixin
+
+      def run
+        if force? || !lockfile_path.exist?
+          spec = specfile.read
+          manifests = []
+        else
+          lock = lockfile.read
+          spec = specfile.read(lock.sources)
+          changes = spec_change_set(spec, lock)
+          if changes.same?
+            debug { "The specfile is unchanged: nothing to do." }
+            return
+          end
+          manifests = changes.analyze
+        end
+
+        resolution = resolver.resolve(spec, manifests)
+        persist_resolution(resolution)
+      end
+
+    private
+
+      def force?
+        options[:force]
+      end
+
+      def resolver
+        Resolver.new(environment)
+      end
+
+      def spec_change_set(spec, lock)
+        SpecChangeSet.new(environment, spec, lock)
+      end
+
+    end
+  end
+end

data/lib/librarian/action/update.rb

@@ -0,0 +1,44 @@
+require "librarian/manifest_set"
+require "librarian/resolver"
+require "librarian/spec_change_set"
+require "librarian/action/base"
+require "librarian/action/persist_resolution_mixin"
+
+module Librarian
+  module Action
+    class Update < Base
+      include PersistResolutionMixin
+
+      def run
+        unless lockfile_path.exist?
+          raise Error, "Lockfile missing!"
+        end
+        previous_resolution = lockfile.load(lockfile_path.read)
+        spec = specfile.read(previous_resolution.sources)
+        changes = spec_change_set(spec, previous_resolution)
+        manifests = changes.same? ? previous_resolution.manifests : changes.analyze
+        partial_manifests = ManifestSet.deep_strip(manifests, dependency_names)
+        unpinnable_sources = previous_resolution.sources - partial_manifests.map(&:source)
+        unpinnable_sources.each(&:unpin!)
+
+        resolution = resolver.resolve(spec, partial_manifests)
+        persist_resolution(resolution)
+      end
+
+    private
+
+      def dependency_names
+        options[:names]
+      end
+
+      def resolver
+        Resolver.new(environment)
+      end
+
+      def spec_change_set(spec, lock)
+        SpecChangeSet.new(environment, spec, lock)
+      end
+
+    end
+  end
+end

data/lib/librarian/action.rb

@@ -0,0 +1,5 @@
+require "librarian/action/clean"
+require "librarian/action/ensure"
+require "librarian/action/install"
+require "librarian/action/resolve"
+require "librarian/action/update"

data/lib/librarian/algorithms.rb

@@ -0,0 +1,133 @@
+require "set"
+require "tsort"
+
+module Librarian
+  module Algorithms
+
+    class GraphHash < Hash
+      include TSort
+      def tsort_each_node(&block)
+        keys.sort.each(&block) # demand determinism
+      end
+      def tsort_each_child(node, &block)
+        children = self[node]
+        children && children.sort.each(&block) # demand determinism
+      end
+      class << self
+        def from(hash)
+          o = new
+          hash.each{|k, v| o[k] = v}
+          o
+        end
+      end
+    end
+
+    module AdjacencyListDirectedGraph
+      extend self
+
+      def cyclic?(graph)
+        each_cyclic_strongly_connected_component_set(graph).any?
+      end
+
+      # Topological sort of the graph with an approximately minimal feedback arc
+      # set removed.
+      def tsort_cyclic(graph)
+        fag = feedback_arc_graph(graph)
+        reduced_graph = subtract_edges_graph(graph, fag)
+        GraphHash.from(reduced_graph).tsort
+      end
+
+      # Returns an approximately minimal feedback arc set, lifted into a graph.
+      def feedback_arc_graph(graph)
+        edges_to_graph(feedback_arc_set(graph))
+      end
+
+      # Returns an approximately minimal feedback arc set.
+      def feedback_arc_set(graph)
+        fas = feedback_arc_set_step0(graph)
+        feedback_arc_set_step1(graph, fas)
+      end
+
+      private
+
+      def edges_to_graph(edges)
+        graph = {}
+        edges.each do |(u, v)|
+          graph[u] ||= []
+          graph[u] << v
+          graph[v] ||= nil
+        end
+        graph
+      end
+
+      def subtract_edges_graph(graph, edges_graph)
+        xgraph = {}
+        graph.each do |n, vs|
+          dests = edges_graph[n]
+          xgraph[n] = !vs ? vs : !dests ? vs : vs - dests
+        end
+        xgraph
+      end
+
+      def each_cyclic_strongly_connected_component_set(graph)
+        return enum_for(__method__, graph) unless block_given?
+        GraphHash.from(graph).each_strongly_connected_component do |scc|
+          if scc.size == 1
+            n = scc.first
+            vs = graph[n] or next
+            vs.include?(n) or next
+          end
+          yield scc
+        end
+      end
+
+      # Partitions the graph into its strongly connected component subgraphs,
+      # removes the acyclic single-vertex components (multi-vertex components
+      # are guaranteed to be cyclic), and yields each cyclic strongly connected
+      # component.
+      def each_cyclic_strongly_connected_component_graph(graph)
+        return enum_for(__method__, graph) unless block_given?
+        each_cyclic_strongly_connected_component_set(graph) do |scc|
+          sccs = scc.to_set
+          sccg = GraphHash.new
+          scc.each do |n|
+            vs = graph[n]
+            sccg[n] = vs && vs.select{|v| sccs.include?(v)}
+          end
+          yield sccg
+        end
+      end
+
+      # The 0th step of computing a feedback arc set: pick out vertices whose
+      # removals will make the graph acyclic.
+      def feedback_arc_set_step0(graph)
+        fas = []
+        each_cyclic_strongly_connected_component_graph(graph) do |scc|
+          scc.keys.sort.each do |n| # demand determinism
+            vs = scc[n] or next
+            vs.size > 0 or next
+            vs.sort! # demand determinism
+            fas << [n, vs.shift]
+            break
+          end
+        end
+        fas
+      end
+
+      # The 1st step of computing a feedback arc set: pick out vertices from the
+      # 0th step whose removals turn out to be unnecessary.
+      def feedback_arc_set_step1(graph, fas)
+        reduced_graph = subtract_edges_graph(graph, edges_to_graph(fas))
+        fas.select do |(u, v)|
+          reduced_graph[u] ||= []
+          reduced_graph[u] << v
+          cyclic = cyclic?(reduced_graph)
+          reduced_graph[u].pop if cyclic
+          cyclic
+        end
+      end
+
+    end
+
+  end
+end

data/lib/librarian/cli/manifest_presenter.rb

@@ -0,0 +1,89 @@
+module Librarian
+  class Cli
+    class ManifestPresenter
+
+      attr_accessor :cli, :manifests
+      private :cli=, :manifests=
+
+      def initialize(cli, manifests)
+        self.cli = cli or raise ArgumentError, "cli required"
+        self.manifests = manifests or raise ArgumentError, "manifests required"
+        self.manifests_index = Hash[manifests.map{|m| [m.name, m]}]
+
+        self.scope_level = 0
+      end
+
+      def present(names = [], options = { })
+        full = options[:detailed]
+        full = !names.empty? if full.nil?
+
+        names = manifests.map(&:name).sort if names.empty?
+        assert_no_manifests_missing!(names)
+
+        present_each(names, :detailed => full)
+      end
+
+      def present_one(manifest, options = { })
+        full = options[:detailed]
+
+        say "#{manifest.name} (#{manifest.version})" do
+          full or next
+
+          present_one_source(manifest)
+          present_one_dependencies(manifest)
+        end
+      end
+
+      private
+
+      def present_each(names, options)
+        names.each do |name|
+          manifest = manifest(name)
+          present_one(manifest, options)
+        end
+      end
+
+      def present_one_source(manifest)
+        say "source: #{manifest.source}"
+      end
+
+      def present_one_dependencies(manifest)
+        manifest.dependencies.empty? and return
+
+        say "dependencies:" do
+          deps = manifest.dependencies.sort_by(&:name)
+          deps.each do |dependency|
+            say "#{dependency.name} (#{dependency.requirement})"
+          end
+        end
+      end
+
+      attr_accessor :scope_level, :manifests_index
+
+      def manifest(name)
+        manifests_index[name]
+      end
+
+      def say(string)
+        cli.say "  " * scope_level << string
+        scope { yield } if block_given?
+      end
+
+      def scope
+        original_scope_level = scope_level
+        self.scope_level = scope_level + 1
+        yield
+      ensure
+        self.scope_level = original_scope_level
+      end
+
+      def assert_no_manifests_missing!(names)
+        missing_names = names.reject{|name| manifest(name)}
+        unless missing_names.empty?
+          raise Error, "not found: #{missing_names.map(&:inspect).join(', ')}"
+        end
+      end
+
+    end
+  end
+end