librarian 0.0.25 → 0.0.26

data/lib/librarian/cli.rb

@@ -23,18 +23,20 @@ module Librarian
 
     class << self
       def bin!
-        with_environment do |environment|
-          begin
-            start
-          rescue Librarian::Error => e
-            environment.ui.error e.message
-            environment.ui.debug e.backtrace.join("\n")
-            exit (e.respond_to?(:status_code) ? e.status_code : 1)
-          rescue Interrupt => e
-            environment.ui.error "\nQuitting..."
-            exit 1
-          end
-        end
+        status = with_environment { returning_status { start } }
+        exit status
+      end
+
+      def returning_status
+        yield
+        0
+      rescue Librarian::Error => e
+        environment.ui.error e.message
+        environment.ui.debug e.backtrace.join("\n")
+        e.respond_to?(:status_code) && e.status_code || 1
+      rescue Interrupt => e
+        environment.ui.error "\nQuitting..."
+        1
       end
 
       attr_accessor :environment
@@ -74,16 +76,13 @@ module Librarian
       if key
         raise Error, "cannot set both value and delete" if value && options["delete"]
         if options["delete"]
-          raise Error, "must set either global or local" unless options["global"] ^ options["local"]
-          scope = options["global"] ? :global : options["local"] ? :local : nil
+          scope = config_scope(true)
           environment.config_db[key, scope] = nil
         elsif value
-          raise Error, "must set either global or local" unless options["global"] ^ options["local"]
-          scope = options["global"] ? :global : options["local"] ? :local : nil
+          scope = config_scope(true)
           environment.config_db[key, scope] = value
         else
-          raise Error, "cannot set both global and local" if options["global"] && options["local"]
-          scope = options["global"] ? :global : options["local"] ? :local : nil
+          scope = config_scope(false)
           if value = environment.config_db[key, scope]
             prefix = scope ? "#{key} (#{scope})" : key
             say "#{prefix}: #{value}"
@@ -123,11 +122,9 @@ module Librarian
     def outdated
       ensure!
       resolution = environment.lock
-      resolution.manifests.sort_by(&:name).each do |manifest|
-        source = manifest.source
-        source_manifest = source.manifests(manifest.name).first
-        next if manifest.version == source_manifest.version
-        say "#{manifest.name} (#{manifest.version} -> #{source_manifest.version})"
+      manifests = resolution.manifests.sort_by(&:name)
+      manifests.select(&:outdated?).each do |manifest|
+        say "#{manifest.name} (#{manifest.version} -> #{manifest.latest.version})"
       end
     end
 
@@ -211,5 +208,16 @@ module Librarian
       environment.logger.relative_path_to(path)
     end
 
+    def config_scope(exclusive)
+      g, l = "global", "local"
+      if exclusive
+        options[g] ^ options[l] or raise Error, "must set either #{g} or #{l}"
+      else
+        options[g] && options[l] and raise Error, "cannot set both #{g} and #{l}"
+      end
+
+      options[g] ? :global : options[l] ? :local : nil
+    end
+
   end
 end

data/lib/librarian/cli/manifest_presenter.rb

@@ -17,40 +17,47 @@ module Librarian
         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 = manifests.map(&:name).sort if names.empty?
+        assert_no_manifests_missing!(names)
 
-        names.each do |name|
-          manifest = manifest(name)
-          present_one(manifest, :detailed => full)
-        end
+        present_each(names, :detailed => full)
       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
+          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)
@@ -74,6 +81,13 @@ module Librarian
         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

data/lib/librarian/dependency.rb

@@ -26,6 +26,51 @@ module Librarian
         to_gem_requirement.to_s
       end
 
+      COMPATS_TABLE = {
+        %w(=  = ) => lambda{|s, o| s == o},
+        %w(=  !=) => lambda{|s, o| s != o},
+        %w(=  > ) => lambda{|s, o| s >  o},
+        %w(=  < ) => lambda{|s, o| s <  o},
+        %w(=  >=) => lambda{|s, o| s >= o},
+        %w(=  <=) => lambda{|s, o| s <= o},
+        %w(=  ~>) => lambda{|s, o| s >= o && s.release < o.bump},
+        %w(!= !=) => true,
+        %w(!= > ) => true,
+        %w(!= < ) => true,
+        %w(!= >=) => true,
+        %w(!= <=) => true,
+        %w(!= ~>) => true,
+        %w(>  > ) => true,
+        %w(>  < ) => lambda{|s, o| s < o},
+        %w(>  >=) => true,
+        %w(>  <=) => lambda{|s, o| s < o},
+        %w(>  ~>) => lambda{|s, o| s < o.bump},
+        %w(<  < ) => true,
+        %w(<  >=) => lambda{|s, o| s > o},
+        %w(<  <=) => true,
+        %w(<  ~>) => lambda{|s, o| s > o},
+        %w(>= >=) => true,
+        %w(>= <=) => lambda{|s, o| s <= o},
+        %w(>= ~>) => lambda{|s, o| s < o.bump},
+        %w(<= <=) => true,
+        %w(<= ~>) => lambda{|s, o| s >= o},
+        %w(~> ~>) => lambda{|s, o| s < o.bump && s.bump > o},
+      }
+
+      def consistent_with?(other)
+        sgreq, ogreq = to_gem_requirement, other.to_gem_requirement
+        sreqs, oreqs = sgreq.requirements, ogreq.requirements
+        sreqs.all? do |sreq|
+          oreqs.all? do |oreq|
+            compatible?(sreq, oreq)
+          end
+        end
+      end
+
+      def inconsistent_with?(other)
+        !consistent_with?(other)
+      end
+
       protected
 
       attr_accessor :backing
@@ -38,6 +83,13 @@ module Librarian
           arg
         end
       end
+
+      def compatible?(a, b)
+        a, b = b, a unless COMPATS_TABLE.include?([a.first, b.first])
+        r = COMPATS_TABLE[[a.first, b.first]]
+        r = r.call(a.last, b.last) if r.respond_to?(:call)
+        r
+      end
     end
 
     attr_accessor :name, :requirement, :source
@@ -77,6 +129,14 @@ module Librarian
       self.source       == other.source
     end
 
+    def consistent_with?(other)
+      name != other.name || requirement.consistent_with?(other.requirement)
+    end
+
+    def inconsistent_with?(other)
+      !consistent_with?(other)
+    end
+
   private
 
     def assert_name_valid!(name)

data/lib/librarian/environment.rb

@@ -153,7 +153,9 @@ module Librarian
       end
     end
 
-    def net_http_class
+    def net_http_class(host)
+      return Net::HTTP if no_proxy?(host)
+
       @net_http_class ||= begin
         p = http_proxy_uri
         p ? Net::HTTP::Proxy(p.host, p.port, p.user, p.password) : Net::HTTP
@@ -166,5 +168,15 @@ module Librarian
       self
     end
 
+    def no_proxy?(host)
+      @no_proxy ||= begin
+        list = ENV['NO_PROXY'] || ENV['no_proxy'] || ""
+        list.split(/\s*,\s*/) + %w(localhost 127.0.0.1)
+      end
+      @no_proxy.any? do |host_addr|
+        host.match(Regexp.quote(host_addr)+'$')
+      end
+    end
+
   end
 end

data/lib/librarian/linter/source_linter.rb

@@ -0,0 +1,55 @@
+module Librarian
+  module Linter
+    class SourceLinter
+
+      class << self
+        def lint!(klass)
+          new(klass).lint!
+        end
+      end
+
+      attr_accessor :klass
+      private :klass=
+
+      def initialize(klass)
+        self.klass = klass
+      end
+
+      def lint!
+        lint_class_responds_to! *[
+          :lock_name,
+          :from_spec_args,
+          :from_lock_options,
+        ]
+
+        lint_instance_responds_to! *[
+          :to_spec_args,
+          :to_lock_options,
+          :manifests,
+          :fetch_version,
+          :fetch_dependencies,
+          :pinned?,
+          :unpin!,
+          :install!,
+        ]
+      end
+
+    private
+
+      def lint_class_responds_to!(*names)
+        missing = names.reject{|name| klass.respond_to?(name)}
+        return if missing.empty?
+
+        raise "class must respond to #{missing.join(', ')}"
+      end
+
+      def lint_instance_responds_to!(*names)
+        missing = names - klass.public_instance_methods.map(&:to_sym)
+        return if missing.empty?
+
+        raise "instance must respond to #{missing.join(', ')}"
+      end
+
+    end
+  end
+end

data/lib/librarian/lockfile/parser.rb

@@ -21,10 +21,18 @@ module Librarian
       end
 
       def parse(string)
-        string = string.dup
-        source_type_names_map = Hash[dsl_class.source_types.map{|t| [t[1].lock_name, t[1]]}]
-        source_type_names = dsl_class.source_types.map{|t| t[1].lock_name}
-        lines = string.split(/(\r|\n|\r\n)+/).select{|l| l =~ /\S/}
+        lines = string.lines.map{|l| l.sub(/\s+\z/, '')}.reject(&:empty?)
+        sources = extract_and_parse_sources(lines)
+        manifests = compile(sources)
+        manifests_index = Hash[manifests.map{|m| [m.name, m]}]
+        raise StandardError, "Expected DEPENDENCIES topic!" unless lines.shift == "DEPENDENCIES"
+        dependencies = extract_and_parse_dependencies(lines, manifests_index)
+        Resolution.new(dependencies, manifests)
+      end
+
+    private
+
+      def extract_and_parse_sources(lines)
         sources = []
         while source_type_names.include?(lines.first)
           source = {}
@@ -50,21 +58,20 @@ module Librarian
           source[:manifests] = manifests
           sources << source
         end
-        manifests = compile(sources)
-        manifests_index = Hash[manifests.map{|m| [m.name, m]}]
-        raise StandardError, "Expected DEPENDENCIES topic!" unless lines.shift == "DEPENDENCIES"
+        sources
+      end
+
+      def extract_and_parse_dependencies(lines, manifests_index)
         dependencies = []
         while lines.first =~ /^ {2}([\w-]+)(?: \((.*)\))?$/
           lines.shift
           name, requirement = $1, $2.split(/,\s*/)
           dependencies << Dependency.new(name, requirement, manifests_index[name].source)
         end
-        Resolution.new(dependencies, manifests)
+        dependencies
       end
 
-    private
-
-      def compile(sources_ast)
+      def compile_placeholder_manifests(sources_ast)
         manifests = {}
         sources_ast.each do |source_ast|
           source_type = source_ast[:type]
@@ -78,15 +85,19 @@ module Librarian
             )
           end
         end
+        manifests
+      end
+
+      def compile(sources_ast)
+        manifests = compile_placeholder_manifests(sources_ast)
         manifests = manifests.map do |name, manifest|
           dependencies = manifest.dependencies.map do |d|
             Dependency.new(d.name, d.requirement, manifests[d.name].source)
           end
-          manifest.source.manifest(
-            manifest.name,
-            manifest.version,
-            dependencies
-          )
+          real = Manifest.new(manifest.source, manifest.name)
+          real.version = manifest.version
+          real.dependencies = manifest.dependencies
+          real
         end
         ManifestSet.sort(manifests)
       end
@@ -95,6 +106,18 @@ module Librarian
         environment.dsl_class
       end
 
+      def source_type_names_map
+        @source_type_names_map ||= begin
+          Hash[dsl_class.source_types.map{|t| [t[1].lock_name, t[1]]}]
+        end
+      end
+
+      def source_type_names
+        @source_type_names ||= begin
+          dsl_class.source_types.map{|t| t[1].lock_name}
+        end
+      end
+
     end
   end
 end

data/lib/librarian/manifest.rb

@@ -65,6 +65,14 @@ module Librarian
       defined_version == fetched_version
     end
 
+    def latest
+      @latest ||= source.manifests(name).first
+    end
+
+    def outdated?
+      latest.version > version
+    end
+
     def dependencies
       defined_dependencies || fetched_dependencies
     end

data/lib/librarian/manifest_set.rb

@@ -43,7 +43,7 @@ module Librarian
     end
 
     def initialize(manifests)
-      self.index = Hash === manifests ? manifests.dup : Hash[manifests.map{|m| [m.name, m]}]
+      self.index = Hash === manifests ? manifests.dup : index_by(manifests, &:name)
     end
 
     def to_a
@@ -76,9 +76,6 @@ module Librarian
     end
 
     def deep_strip!(names)
-      names = Array === names ? names.dup : names.to_a
-      assert_strings!(names)
-
       strippables = dependencies_of(names)
       shallow_strip!(strippables)
 
@@ -102,9 +99,6 @@ module Librarian
     end
 
     def deep_keep!(names)
-      names = Array === names ? names.dup : names.to_a
-      assert_strings!(names)
-
       keepables = dependencies_of(names)
       shallow_keep!(keepables)
 
@@ -149,5 +143,9 @@ module Librarian
       deps.to_a
     end
 
+    def index_by(enum)
+      Hash[enum.map{|obj| [yield(obj), obj]}]
+    end
+
   end
 end