librarian 0.1.1 → 0.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: e028910687d6a6448f8f51929c7048701c10c768
-  data.tar.gz: f3d3ea0d6bffa41369b7bd224a2a93d5fe314fc8
+  metadata.gz: fddbebc33025412f23b5f1eb199eb9dafb89ee8c
+  data.tar.gz: 6c39767d153ee125b535f620aa70a8b7af1bc00c
 SHA512:
-  metadata.gz: b5b069d30eb1d8a067d7f7cd95d04e92570776e4ee7f08f9a6c4d572b0f3bc25026f5324d5686933bafed0e96247e23bea499f90c49a7c93397abc14241ddc9d
-  data.tar.gz: 02c8c5b25f217db0d2188cc2e4f48675fce74f9ff29ceb1fc30ea894c5ca511fd61c4e59a9e40a76c863c3307eeea5fa2f8344f281db086b3a4ce7d2ae158383
+  metadata.gz: 734712ab6b294554583731f8c7a023ac1414ab548166f7908eca04262887880e98a1e75e8e3a37d80a9ae0420ac955c44f8b642b45355408a4bc351195d39463
+  data.tar.gz: c1dc05cf757f64da608313b4aab5f7b29afaaf056015fc910b3efe3467c81f05df386f58368cec2fbc04b7540dca6afae86c2da40fddfedaf42fbf8885d1f17a

data/.travis.yml

@@ -5,8 +5,7 @@ rvm:
   - 1.9.2
   - 1.9.3
   - 2.0.0
-  - rbx-18mode
-  - rbx-19mode
+  - rbx-2.2
   - jruby-18mode
   - jruby-19mode
   - ruby-head

data/CHANGELOG.md

@@ -1,5 +1,20 @@
 # Change Log
 
+## 0.1.2
+
+* \#153. Mark the license in the gemspec.
+
+* \#158, \#160, \#159. Handle cyclic dependencies for adapters which opt in to
+  cyclic dependencies.
+
+* \#154. Cache git repository sources which are identical but for their :path
+  attributes (where to look inside the repository for the manifest). Thanks
+  @bcatlin.
+
+* \#161. Fix JRuby exception in posix run! method. Thanks @justenwalker.
+
+* \#163. Don't fetch git repositories multiple times per run. Thanks @njam.
+
 ## 0.1.1
 
 * \#147. Handle the case where HOME is not in the environment. Thanks @bradleyd.

data/Gemfile

@@ -4,3 +4,5 @@ source "http://rubygems.org"
 gemspec
 
 gem "fakefs"
+
+gem "rubysl", :platforms => %w[rbx]

data/VERSION

@@ -0,0 +1 @@
+0.1.2

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

@@ -66,11 +66,7 @@ module Librarian
 
       def say(string)
         cli.say "  " * scope_level << string
-        if block_given?
-          scope do
-            yield
-          end
-        end
+        scope { yield } if block_given?
       end
 
       def scope

data/lib/librarian/dependency.rb

@@ -26,6 +26,10 @@ module Librarian
         to_gem_requirement.to_s
       end
 
+      def inspect
+        "#<#{self.class} #{to_s}>"
+      end
+
       COMPATS_TABLE = {
         %w(=  = ) => lambda{|s, o| s == o},
         %w(=  !=) => lambda{|s, o| s != o},
@@ -140,7 +144,9 @@ module Librarian
   private
 
     def assert_name_valid!(name)
-      raise ArgumentError, "name (#{name.inspect}) must be sensible" unless name =~ /\A\S(?:.*\S)?\z/
+      name =~ /\A\S(?:.*\S)?\z/ and return
+
+      raise ArgumentError, "name (#{name.inspect}) must be sensible"
     end
 
   end

data/lib/librarian/environment.rb

@@ -3,6 +3,7 @@ require 'net/http'
 require "uri"
 require "etc"
 
+require "librarian/helpers"
 require "librarian/support/abstract_method"
 
 require "librarian/error"
@@ -14,6 +15,7 @@ require "librarian/resolver"
 require "librarian/dsl"
 require "librarian/source"
 require "librarian/version"
+require "librarian/environment/runtime_cache"
 
 module Librarian
   class Environment
@@ -21,6 +23,7 @@ module Librarian
     include Support::AbstractMethod
 
     attr_accessor :ui
+    attr_reader :runtime_cache
 
     abstract_method :specfile_name, :dsl_class, :install_path
 
@@ -29,6 +32,7 @@ module Librarian
       @env = options.fetch(:env) { ENV.to_hash }
       @home = options.fetch(:home) { default_home }
       @project_path = options[:project_path]
+      @runtime_cache = RuntimeCache.new
     end
 
     def logger
@@ -101,8 +105,18 @@ module Librarian
       Lockfile.new(self, nil)
     end
 
-    def resolver
-      Resolver.new(self)
+    def resolver(options = { })
+      Resolver.new(self, resolver_options.merge(options))
+    end
+
+    def resolver_options
+      {
+        :cyclic => resolver_permit_cyclic_reslutions?,
+      }
+    end
+
+    def resolver_permit_cyclic_reslutions?
+      false
     end
 
     def tmp_path
@@ -174,6 +188,10 @@ module Librarian
       no_proxy?(host) ? Net::HTTP : net_http_default_class
     end
 
+    def inspect
+      "#<#{self.class}:0x#{__id__.to_s(16)}>"
+    end
+
   private
 
     def environment

data/lib/librarian/environment/runtime_cache.rb

@@ -0,0 +1,101 @@
+require "librarian/error"
+
+module Librarian
+  class Environment
+    class RuntimeCache
+
+      class KeyspaceCache
+
+        class << self
+          private
+
+          def delegate_to_backing_cache(*methods)
+            methods.each do |method|
+              define_method "#{method}" do |*args, &block|
+                # TODO: When we drop ruby-1.8.7 support, use #public_send.
+                runtime_cache.send(method, keyspace, *args, &block)
+              end
+            end
+          end
+        end
+
+        attr_reader :runtime_cache, :keyspace
+
+        def initialize(runtime_cache, keyspace)
+          self.runtime_cache = runtime_cache
+          self.keyspace = keyspace
+        end
+
+        delegate_to_backing_cache *[
+          :include?,
+          :get,
+          :put,
+          :delete,
+          :memo,
+          :once,
+          :[],
+          :[]=,
+        ]
+
+        private
+
+        attr_writer :runtime_cache, :keyspace
+
+      end
+
+      def initialize
+        self.data = {}
+      end
+
+      def include?(keyspace, key)
+        data.include?(combined_key(keyspace, key))
+      end
+
+      def get(keyspace, key)
+        data[combined_key(keyspace, key)]
+      end
+
+      def put(keyspace, key, value = nil)
+        data[combined_key(keyspace, key)] = block_given? ? yield : value
+      end
+
+      def delete(keyspace, key)
+        data.delete(combined_key(keyspace, key))
+      end
+
+      def memo(keyspace, key)
+        put(keyspace, key, yield) unless include?(keyspace, key)
+        get(keyspace, key)
+      end
+
+      def once(keyspace, key)
+        memo(keyspace, key) { yield ; nil }
+      end
+
+      def [](keyspace, key)
+        get(keyspace, key)
+      end
+
+      def []=(keyspace, key, value)
+        put(keyspace, key, value)
+      end
+
+      def keyspace(keyspace)
+        KeyspaceCache.new(self, keyspace)
+      end
+
+      private
+
+      attr_accessor :data
+
+      def combined_key(keyspace, key)
+        keyspace.kind_of?(String) or raise Error, "keyspace must be a string"
+        keyspace.size > 0 or raise Error, "keyspace must not be empty"
+        keyspace.size < 2**16 or raise Error, "keyspace must not be too large"
+        key.kind_of?(String) or raise Error, "key must be a string"
+        [keyspace.size.to_s(16).rjust(4, "0"), keyspace, key].join
+      end
+
+    end
+  end
+end

data/lib/librarian/manifest.rb

@@ -24,6 +24,10 @@ module Librarian
         to_gem_version.to_s
       end
 
+      def inspect
+        "#<#{self.class} #{to_s}>"
+      end
+
       private
 
       def initialize_normalize_args(args)
@@ -133,7 +137,9 @@ module Librarian
     end
 
     def assert_name_valid!(name)
-      raise ArgumentError, "name (#{name.inspect}) must be sensible" unless name =~ /\A\S(?:.*\S)?\z/
+      name =~ /\A\S(?:.*\S)?\z/ and return
+
+      raise ArgumentError, "name (#{name.inspect}) must be sensible"
     end
 
   end

data/lib/librarian/manifest_set.rb

@@ -1,17 +1,8 @@
-require 'set'
-require 'tsort'
+require "librarian/algorithms"
 
 module Librarian
   class ManifestSet
 
-    class GraphHash < Hash
-      include TSort
-      alias tsort_each_node each_key
-      def tsort_each_child(node, &block)
-        self[node].each(&block)
-      end
-    end
-
     class << self
       def shallow_strip(manifests, names)
         new(manifests).shallow_strip!(names).send(method_for(manifests))
@@ -25,10 +16,15 @@ module Librarian
       def deep_keep(manifests, names)
         new(manifests).deep_keep!(names).send(method_for(manifests))
       end
+      def cyclic?(manifests)
+        manifests = Hash[manifests.map{|m| [m.name, m]}] if Array === manifests
+        manifest_pairs = Hash[manifests.map{|k, m| [k, m.dependencies.map{|d| d.name}]}]
+        adj_algs.cyclic?(manifest_pairs)
+      end
       def sort(manifests)
         manifests = Hash[manifests.map{|m| [m.name, m]}] if Array === manifests
-        manifest_pairs = GraphHash[manifests.map{|k, m| [k, m.dependencies.map{|d| d.name}]}]
-        manifest_names = manifest_pairs.tsort
+        manifest_pairs = Hash[manifests.map{|k, m| [k, m.dependencies.map{|d| d.name}]}]
+        manifest_names = adj_algs.tsort_cyclic(manifest_pairs)
         manifest_names.map{|n| manifests[n]}
       end
     private
@@ -40,6 +36,9 @@ module Librarian
           :to_a
         end
       end
+      def adj_algs
+        Algorithms::AdjacencyListDirectedGraph
+      end
     end
 
     def initialize(manifests)