librarian 0.0.20 → 0.0.21

data/lib/librarian/cli.rb

@@ -9,6 +9,8 @@ require "librarian/ui"
 module Librarian
   class Cli < Thor
 
+    autoload :ManifestPresenter, "librarian/cli/manifest_presenter"
+
     include Thor::Actions
 
     module Particularity
@@ -50,17 +52,17 @@ module Librarian
     end
 
     desc "clean", "Cleans out the cache and install paths."
-    method_option "verbose"
-    method_option "line-numbers"
+    option "verbose"
+    option "line-numbers"
     def clean
       ensure!
       clean!
     end
 
     desc "install", "Resolves and installs all of the dependencies you specify."
-    method_option "verbose"
-    method_option "line-numbers"
-    method_option "clean"
+    option "verbose"
+    option "line-numbers"
+    option "clean"
     def install
       ensure!
       clean! if options["clean"]
@@ -69,8 +71,8 @@ module Librarian
     end
 
     desc "update", "Updates and installs the dependencies you specify."
-    method_option "verbose"
-    method_option "line-numbers"
+    option "verbose"
+    option "line-numbers"
     def update(*names)
       ensure!
       if names.empty?
@@ -82,8 +84,8 @@ module Librarian
     end
 
     desc "outdated", "Lists outdated dependencies."
-    method_option "verbose"
-    method_option "line-numbers"
+    option "verbose"
+    option "line-numbers"
     def outdated
       ensure!
       resolution = environment.lock
@@ -96,6 +98,15 @@ module Librarian
       end
     end
 
+    desc "show", "Shows dependencies"
+    option "verbose"
+    option "line-numbers"
+    option "detailed", :type => :boolean
+    def show(*names)
+      ensure!
+      manifest_presenter.present(names, :detailed => options["detailed"])
+    end
+
     desc "init", "Initializes the current directory."
     def init
       puts "Nothing to do."
@@ -127,5 +138,9 @@ module Librarian
       Action::Update.new(environment, options).run
     end
 
+    def manifest_presenter
+      ManifestPresenter.new(self, environment.lock.manifests)
+    end
+
   end
 end

data/lib/librarian/cli/manifest_presenter.rb

@@ -0,0 +1,79 @@
+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?
+
+        if names.empty?
+          names = manifests.map(&:name).sort if names.empty?
+        else
+          missing_names = names.reject{|name| manifest(name)}
+          unless missing_names.empty?
+            raise Error, "not found: #{missing_names.map(&:inspect).join(', ')}"
+          end
+        end
+
+        names.each do |name|
+          manifest = manifest(name)
+          present_one(manifest, :detailed => full)
+        end
+      end
+
+      def present_one(manifest, options = { })
+        full = options[:detailed]
+
+        say "#{manifest.name} (#{manifest.version})" do
+          if full
+            say "source: #{manifest.source}"
+            unless manifest.dependencies.empty?
+              say "dependencies:" do
+                manifest.dependencies.sort_by(&:name).each do |dependency|
+                  say "#{dependency.name} (#{dependency.requirement})"
+                end
+              end
+            end
+          end
+        end
+      end
+
+      private
+
+      attr_accessor :scope_level, :manifests_index
+
+      def manifest(name)
+        manifests_index[name]
+      end
+
+      def say(string)
+        cli.say "  " * scope_level << string
+        if block_given?
+          scope do
+            yield
+          end
+        end
+      end
+
+      def scope
+        original_scope_level = scope_level
+        self.scope_level = scope_level + 1
+        yield
+      ensure
+        self.scope_level = original_scope_level
+      end
+
+    end
+  end
+end

data/lib/librarian/dependency.rb

@@ -60,8 +60,8 @@ module Librarian
     end
 
     def cache_manifests!
-      source.cache!([self])
-      source.manifests(self)
+      source.cache!([name])
+      source.manifests(name)
     end
 
     def satisfied_by?(manifest)

data/lib/librarian/dsl/target.rb

@@ -146,7 +146,7 @@ module Librarian
       def source_from_params(name, param, options)
         source_cache[[name, param, options]] ||= begin
           type = source_types_map[name]
-          type.new(environment, param, options)
+          type.from_spec_args(environment, param, options)
         end
       end
 

data/lib/librarian/environment.rb

@@ -8,6 +8,7 @@ require "librarian/lockfile"
 require "librarian/specfile"
 require "librarian/resolver"
 require "librarian/dsl"
+require "librarian/source"
 
 module Librarian
   class Environment
@@ -106,12 +107,12 @@ module Librarian
       lockfile.read
     end
 
-    def dsl(&block)
-      dsl_class.run(self, &block)
+    def dsl(*args, &block)
+      dsl_class.run(self, *args, &block)
     end
 
     def dsl_class
-      self.class.name.split("::")[0 ... -1].inject(Object) { |constant, fragment| constant.const_get(fragment) }::Dsl
+      self.class.name.split("::")[0 ... -1].inject(Object, &:const_get)::Dsl
     end
 
   private

data/lib/librarian/manifest.rb

@@ -42,22 +42,17 @@ module Librarian
     include Support::AbstractMethod
     include Helpers::Debug
 
-    attr_accessor :source, :name
-    private :source=, :name=
+    attr_accessor :source, :name, :extra
+    private :source=, :name=, :extra=
 
     abstract_method :fetch_version!, :fetch_dependencies!
-    abstract_method :install!
 
-    def initialize(source, name)
+    def initialize(source, name, extra = nil)
       assert_name_valid! name
 
       self.source = source
       self.name = name
-
-      @fetched_version = nil
-      @defined_version = nil
-      @fetched_dependencies = nil
-      @defined_dependencies = nil
+      self.extra = extra
     end
 
     def to_s
@@ -65,35 +60,32 @@ module Librarian
     end
 
     def version
-      @defined_version || @fetched_version ||= _normalize_version(fetch_version!)
+      defined_version || fetched_version
     end
 
     def version=(version)
-      @defined_version = _normalize_version(version)
+      self.defined_version = _normalize_version(version)
     end
 
     def version?
-      if @defined_version
-        @fetched_version ||= _normalize_version(fetch_version!)
-        @defined_version == @fetched_version
-      end
+      return unless defined_version
+
+      defined_version == fetched_version
     end
 
     def dependencies
-      @defined_dependencies || @fetched_dependencies ||= _normalize_dependencies(fetch_dependencies!)
+      defined_dependencies || fetched_dependencies
     end
 
     def dependencies=(dependencies)
-      @defined_dependencies = _normalize_dependencies(dependencies)
+      self.defined_dependencies = _normalize_dependencies(dependencies)
     end
 
     def dependencies?
-      if @defined_dependencies
-        @fetched_dependencies ||= _normalize_dependencies(fetch_dependencies!)
-        @defined_dependencies.zip(@fetched_dependencies).all? do |pair|
-          a, b = *pair
-          a.name == b.name && a.requirement == b.requirement
-        end
+      return unless defined_dependencies
+
+      defined_dependencies.zip(fetched_dependencies).all? do |(a, b)|
+        a.name == b.name && a.requirement == b.requirement
       end
     end
 
@@ -101,12 +93,34 @@ module Librarian
       dependency.requirement.satisfied_by?(version)
     end
 
+    def install!
+      source.install!(self)
+    end
+
   private
 
+    attr_accessor :defined_version, :defined_dependencies
+
     def environment
       source.environment
     end
 
+    def fetched_version
+      @fetched_version ||= _normalize_version(fetch_version!)
+    end
+
+    def fetched_dependencies
+      @fetched_dependencies ||= _normalize_dependencies(fetch_dependencies!)
+    end
+
+    def fetch_version!
+      source.fetch_version(name, extra)
+    end
+
+    def fetch_dependencies!
+      source.fetch_dependencies(name, version, extra)
+    end
+
     def _normalize_version(version)
       Version.new(version)
     end
@@ -115,7 +129,7 @@ module Librarian
       if Hash === dependencies
         dependencies = dependencies.map{|k, v| Dependency.new(k, v, nil)}
       end
-      dependencies.sort_by{|d| d.name}
+      dependencies.sort_by(&:name)
     end
 
     def assert_name_valid!(name)

data/lib/librarian/manifest_set.rb

@@ -63,6 +63,8 @@ module Librarian
     end
 
     def shallow_strip!(names)
+      assert_strings!(names)
+
       names.each do |name|
         index.delete(name)
       end
@@ -75,15 +77,11 @@ module Librarian
 
     def deep_strip!(names)
       names = Array === names ? names.dup : names.to_a
-      until names.empty?
-        name = names.shift
-        manifest = index.delete(name)
-        if manifest
-          manifest.dependencies.each do |dependency|
-            names << dependency.name
-          end
-        end
-      end
+      assert_strings!(names)
+
+      strippables = dependencies_of(names)
+      shallow_strip!(strippables)
+
       self
     end
 
@@ -92,6 +90,8 @@ module Librarian
     end
 
     def shallow_keep!(names)
+      assert_strings!(names)
+
       names = Set.new(names) unless Set === names
       index.reject! { |k, v| !names.include?(k) }
       self
@@ -103,17 +103,12 @@ module Librarian
 
     def deep_keep!(names)
       names = Array === names ? names.dup : names.to_a
-      marks = Set.new
-      until names.empty?
-        keep = names.shift
-        unless marks.include?(keep)
-          marks << keep
-          index[keep].dependencies.each do |d|
-            names << d.name
-          end
-        end
-      end
-      shallow_keep!(marks)
+      assert_strings!(names)
+
+      keepables = dependencies_of(names)
+      shallow_keep!(keepables)
+
+      self
     end
 
     def consistent?
@@ -129,5 +124,26 @@ module Librarian
 
     attr_accessor :index
 
+    def assert_strings!(names)
+      non_strings = names.reject{|name| String === name}
+      non_strings.empty? or raise TypeError, "names must all be strings"
+    end
+
+    # Straightforward breadth-first graph traversal algorithm.
+    def dependencies_of(names)
+      names = Array === names ? names.dup : names.to_a
+      assert_strings!(names)
+
+      deps = Set.new
+      until names.empty?
+        name = names.shift
+        next if deps.include?(name)
+
+        deps << name
+        names.concat index[name].dependencies.map(&:name)
+      end
+      deps.to_a
+    end
+
   end
 end

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

@@ -6,30 +6,26 @@ module Librarian
     module Source
       class Mock
 
-        class Manifest < Manifest
-          attr_reader :manifest
-          def initialize(source, name, manifest)
-            super(source, name)
-            @manifest = manifest
-          end
-          def fetch_version!
-            manifest[:version]
-          end
-          def fetch_dependencies!
-            manifest[:dependencies]
-          end
-          def install!
-          end
-        end
-
         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
@@ -64,24 +60,40 @@ module Librarian
         end
 
         def manifest(name, version, dependencies)
-          Manifest.new(self, name, {:version => version, :dependencies => dependencies})
+          manifest = Manifest.new(self, name)
+          manifest.version = version
+          manifest.dependencies = dependencies
+          manifest
         end
 
-        def manifests(dependency)
-          if d = registry[dependency.name]
-            d.map{|v| Manifest.new(self, dependency.name, v)}
+        def manifests(name)
+          if d = registry[name]
+            d.map{|v| manifest(name, v[:version], v[:dependencies])}
           else
             nil
           end
         end
 
-        def cache!(dependencies)
+        def cache!(names)
+        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