rubygems-update 0.8.6 → 0.8.8

data/lib/rubygems/remote_installer.rb

@@ -16,7 +16,7 @@ module Gem
     # Initialize a remote fetcher using the source URI (and possible
     # proxy information).
     def initialize(source_uri, proxy)
-      @uri = source_uri
+      @uri = normalize_uri(source_uri)
       @http_proxy = proxy
       if @http_proxy == true
 	@http_proxy = ENV['http_proxy'] || ENV['HTTP_PROXY']
@@ -61,6 +61,11 @@ module Gem
 
     private
 
+    # Normalize the URI by adding "http://" if it is missing.
+    def normalize_uri(uri)
+      (uri =~ /^(https?|ftp):/) ? uri : "http://#{uri}"
+    end
+
     # Connect to the source host/port, using a proxy if needed.
     def connect_to(host, port)
       if @http_proxy
@@ -169,7 +174,7 @@ module Gem
     # Write data to the proper cache.
     def write_cache
       data = cache_data
-      open(writable_file, "w") do |f|
+      open(writable_file, "wb") do |f|
 	f.puts Marshal.dump(data)
       end
     end
@@ -207,7 +212,7 @@ module Gem
     def read_cache
       @cache_file = select_cache_file
       begin
-	open(@cache_file) { |f| load_local_cache(f) } || {}
+	open(@cache_file, "rb") { |f| load_local_cache(f) } || {}
       rescue StandardError => ex
 	{}
       end
@@ -457,7 +462,10 @@ module Gem
       to_install = []
       dependencies.each do |dependency|
         begin
-          require_gem(dependency.name, *dependency.requirement_list)
+          require_gem_with_options(
+	    dependency.name,
+	    dependency.requirement_list,
+	    :auto_require=>false)
         rescue LoadError => e
           to_install.push dependency
         end
@@ -472,9 +480,11 @@ module Gem
     # way to do things (e.g.  if a package fails to download, we
     # shouldn't install anything).
     def install_dependencies(dependencies, force, install_dir)
+      return if @options[:ignore_dependencies]
       installed_gems = []
       dependencies.each do |dependency|
-        if ask_yes_no("Install required dependency #{dependency.name}?", true)
+        if @options[:include_dependencies] ||
+	    ask_yes_no("Install required dependency #{dependency.name}?", true)
           remote_installer =  RemoteInstaller.new(@options)
           installed_gems << remote_installer.install(
 	    dependency.name,
@@ -503,7 +513,7 @@ module Gem
     end
     
     def new_installer(gem)
-      return Installer.new(gem)
+      return Installer.new(gem, @options)
     end
   end
 

data/lib/rubygems/rubygems_version.rb

@@ -2,5 +2,5 @@
 # This file is auto-generated by build scripts.
 # See:  rake update_version
 module Gem
-  RubyGemsVersion = '0.8.6'
+  RubyGemsVersion = '0.8.8'
 end

data/lib/rubygems/source_index.rb

@@ -89,10 +89,16 @@ module Gem
 
     def_delegators :@gems, :size, :length
 
-    # Search for a gem by name and optional version
+    # Find a gem by an exact match on the short name.
+    def find_name(gem_name, version_requirement=Version::Requirement.new(">= 0"))
+      search(/^#{gem_name}$/, version_requirement)
+    end
+
+    # Search for a gem by short name pattern and optional version
     #
     # gem_name::
-    #   [String] the (short) name of the gem
+    #   [String] a partial for the (short) name of the gem, or
+    #   [Regex] a pattern to match against the short name
     # version_requirement::
     #   [String | default=Version::Requirement.new(">= 0")] version to
     #   find
@@ -100,13 +106,13 @@ module Gem
     #   [Array] list of Gem::Specification objects in sorted (version)
     #   order.  Empty if not found.
     #
-    def search(gem_name, version_requirement=Version::Requirement.new(">= 0"))
+    def search(gem_pattern, version_requirement=Version::Requirement.new(">= 0"))
       #FIXME - remove duplication between this and RemoteInstaller.search
-      gem_name = /#{ gem_name }/i if String === gem_name
+      gem_pattern = /#{ gem_pattern }/i if String === gem_pattern
       version_requirement = Gem::Version::Requirement.create(version_requirement)
       result = []
       @gems.each do |full_spec_name, spec|
-        next unless spec.name =~ gem_name
+        next unless spec.name =~ gem_pattern
         result << spec if version_requirement.satisfied_by?(spec.version)
       end
       result = result.sort

data/lib/rubygems/specification.rb

@@ -559,6 +559,11 @@ module Gem
     # ------------------------- Dependency methods.
     
     ##
+    # Return a list of all gems that have a dependency on this
+    # gemspec.  The list is structured with entries that conform to:
+    #
+    #   [depending_gem, dependency, [list_of_gems_that_satisfy_dependency]]
+    #
     # return:: [Array] [[dependent_gem, dependency, [list_of_satisfiers]]]
     #
     def dependent_gems

data/lib/rubygems/version.rb

@@ -1,6 +1,6 @@
 module Gem
   
-  ##
+  ####################################################################
   # The Dependency class holds a Gem name and Version::Requirement
   #
   class Dependency
@@ -50,16 +50,22 @@ module Gem
     end
   end
   
-  ##
+  ####################################################################
   # The Version class processes string versions into comparable values
   #
   class Version
     include Comparable
 
+    # The originating definition of Requirement is left nested in
+    # Version for compatibility.  The full definition is given in
+    # Gem::Requirement.
+    class Requirement
+    end
+    
     attr_accessor :version
-
+    
     NUM_RE = /\s*(\d+(\.\d+)*)*\s*/
-
+    
     ##
     # Checks if version string is valid format
     #
@@ -147,137 +153,148 @@ module Gem
       self.class.new(ints.join("."))
     end
     
+  end
+
+  # Class Requirement's original definition is nested in Version.
+  # Although an probably inappropriate place, current gems specs
+  # reference the nested class name explicitly.  To remain compatible
+  # with old software loading gemspecs, we leave the original
+  # definition in Version, but define an alias Gem::Requirement for
+  # use everywhere else.
+  Requirement = ::Gem::Version::Requirement
+
+  ##################################################################
+  # Requirement version includes a prefaced comparator in addition
+  # to a version number.
+  #
+  # A Requirement object can actually contain multiple, er,
+  # requirements, as in (> 1.2, < 2.0).
+  #
+  class Requirement
+    include Comparable
+    
+    OPS = {
+      "="  =>  lambda { |v, r| v == r },
+      "!=" =>  lambda { |v, r| v != r },
+      ">"  =>  lambda { |v, r| v > r },
+      "<"  =>  lambda { |v, r| v < r },
+      ">=" =>  lambda { |v, r| v >= r },
+      "<=" =>  lambda { |v, r| v <= r },
+      "~>" =>  lambda { |v, r| v >= r && v < r.bump }
+    }
+    
+    OP_RE = Regexp.new(OPS.keys.collect{|k| Regexp.quote(k)}.join("|"))
+    REQ_RE = /\s*(#{OP_RE})\s*/
+    
     ##
-    # Requirement version includes a prefaced comparator in addition
-    # to a version number.
+    # Factory method to create a Version::Requirement object.  Input may be a
+    # Version, a String, or nil.  Intended to simplify client code.
     #
-    # A Requirement object can actually contain multiple, er, requirements, as
-    # in (> 1.2, < 2.0).
+    # If the input is "weird", the default version requirement is returned.
     #
-    class Requirement
-      include Comparable
-
-      OPS = {
-        "="  =>  lambda { |v, r| v == r },
-        "!=" =>  lambda { |v, r| v != r },
-        ">"  =>  lambda { |v, r| v > r },
-        "<"  =>  lambda { |v, r| v < r },
-        ">=" =>  lambda { |v, r| v >= r },
-        "<=" =>  lambda { |v, r| v <= r },
-        "~>" =>  lambda { |v, r| v >= r && v < r.bump }
-      }
-        
-      OP_RE = Regexp.new(OPS.keys.collect{|k| Regexp.quote(k)}.join("|"))
-      REQ_RE = /\s*(#{OP_RE})\s*/
-
-      ##
-      # Factory method to create a Version::Requirement object.  Input may be a
-      # Version, a String, or nil.  Intended to simplify client code.
-      #
-      # If the input is "weird", the default version requirement is returned.
-      #
-      def self.create(input)
-        if input.kind_of?(Requirement)
-          return input
-	elsif input.kind_of?(Array)
-	  return self.new(input)
-        elsif input.respond_to? :to_str
-          return self.new([input.to_str])
-        else
-          return self.default
-        end
-      end
-
-      ##
-      # A default "version requirement" can surely _only_ be '> 0'.
-      #
-      def self.default
-        self.new(['> 0.0.0'])
-      end
-
-      ##
-      # Constructs a version requirement instance
-      #
-      # str:: [String Array] the version requirement string (e.g. ["> 1.23"])
-      #
-      def initialize(reqs)
-        @requirements = reqs.collect do |rq|
-          op, version_string = parse(rq)
-          [op, Version.new(version_string)]
-        end
-        @version = nil   # Avoid warnings.
-      end
-      
-      ##
-      # Overrides to check for comparator
-      #
-      # str:: [String] the version requirement string
-      # return:: [Boolean] true if the string format is correct, otherwise false
-      #
-      def correct?(str)
-        /^#{REQ_RE}#{NUM_RE}$/.match(str)
-      end
-      
-      def to_s
-        as_list.join(", ")
-      end
-
-      def as_list
-        normalize
-        @requirements.collect { |req|
-                "#{req[0]} #{req[1]}"
-        }
-      end
-      
-      def normalize
-        return if @version.nil?
-        @requirements = [parse(@version)]
-        @nums = nil
-        @version = nil
-        @op = nil
-      end
-      
-      ##
-      # Is the requirement satifised by +version+.
-      #
-      # version:: [Gem::Version] the version to compare against
-      # return:: [Boolean] true if this requirement is satisfied by
-      #          the version, otherwise false 
-      #
-      def satisfied_by?(version)
-        normalize
-        @requirements.all? { |op, rv| satisfy?(op, version, rv) }
-      end
-  
-      private
-       
-      ##
-      # Is "version op required_version" satisfied?
-      #
-      def satisfy?(op, version, required_version)
-        OPS[op].call(version, required_version)
+    def self.create(input)
+      if input.kind_of?(Requirement)
+	return input
+      elsif input.kind_of?(Array)
+	return self.new(input)
+      elsif input.respond_to? :to_str
+	return self.new([input.to_str])
+      else
+	return self.default
       end
-
-      ##
-      # Parse the version requirement string. Return the operator and
-      # version strings.
-      #
-      def parse(str)
-        if md = /^\s*(#{OP_RE})\s*([0-9.]+)\s*$/.match(str)
-          [md[1], md[2]]
-        elsif md = /^\s*([0-9.]+)\s*$/.match(str)
-          ["=", md[1]]
-        elsif md = /^\s*(#{OP_RE})\s*$/.match(str)
-          [md[1], "0"]
-        else
-          fail ArgumentError, "Illformed requirement [#{str}]"
-        end
+    end
+    
+    ##
+    # A default "version requirement" can surely _only_ be '> 0'.
+    #
+    def self.default
+      self.new(['> 0.0.0'])
+    end
+    
+    ##
+    # Constructs a version requirement instance
+    #
+    # str:: [String Array] the version requirement string (e.g. ["> 1.23"])
+    #
+    def initialize(reqs)
+      @requirements = reqs.collect do |rq|
+	op, version_string = parse(rq)
+	[op, Version.new(version_string)]
       end
-
-      def <=>(other)
-        to_s <=> other.to_s
+      @version = nil   # Avoid warnings.
+    end
+    
+    ##
+    # Overrides to check for comparator
+    #
+    # str:: [String] the version requirement string
+    # return:: [Boolean] true if the string format is correct, otherwise false
+    #
+    # NOTE: Commented out because I don't think it is used.
+    #       def correct?(str)
+    #         /^#{REQ_RE}#{NUM_RE}$/.match(str)
+    #       end
+    
+    def to_s
+      as_list.join(", ")
+    end
+    
+    def as_list
+      normalize
+      @requirements.collect { |req|
+	"#{req[0]} #{req[1]}"
+      }
+    end
+    
+    def normalize
+      return if @version.nil?
+      @requirements = [parse(@version)]
+      @nums = nil
+      @version = nil
+      @op = nil
+    end
+    
+    ##
+    # Is the requirement satifised by +version+.
+    #
+    # version:: [Gem::Version] the version to compare against
+    # return:: [Boolean] true if this requirement is satisfied by
+    #          the version, otherwise false 
+    #
+    def satisfied_by?(version)
+      normalize
+      @requirements.all? { |op, rv| satisfy?(op, version, rv) }
+    end
+    
+    private
+    
+    ##
+    # Is "version op required_version" satisfied?
+    #
+    def satisfy?(op, version, required_version)
+      OPS[op].call(version, required_version)
+    end
+    
+    ##
+    # Parse the version requirement string. Return the operator and
+    # version strings.
+    #
+    def parse(str)
+      if md = /^\s*(#{OP_RE})\s*([0-9.]+)\s*$/.match(str)
+	[md[1], md[2]]
+      elsif md = /^\s*([0-9.]+)\s*$/.match(str)
+	["=", md[1]]
+      elsif md = /^\s*(#{OP_RE})\s*$/.match(str)
+	[md[1], "0"]
+      else
+	fail ArgumentError, "Illformed requirement [#{str}]"
       end
-
     end
+    
+    def <=>(other)
+      to_s <=> other.to_s
+    end
+    
   end
+  
 end

data/test/test_configfile.rb

@@ -10,7 +10,7 @@ class TestArgPreprocessor < Test::Unit::TestCase
   def test_create
     @cfg = Gem::ConfigFile.new([])
     assert ! @cfg.backtrace
-    assert_equal File.join(ENV['HOME'], '.gemrc'), @cfg.config_file_name
+    assert_equal File.join(Gem.user_home, '.gemrc'), @cfg.config_file_name
   end
 
   def test_backtrace

data/test/test_dependency_list.rb

@@ -0,0 +1,163 @@
+#!/usr/bin/env ruby
+
+require 'test/unit'
+require 'rubygems/dependency_list'
+require 'rubygems/specification'
+
+class TestDependencyList < Test::Unit::TestCase
+  def setup
+    @deplist = Gem::DependencyList.new
+  end
+
+  def test_create
+    assert @deplist.ok?, "all dependencies should be satisfied"
+  end
+
+  def test_one_unsatisfied_gem
+    @deplist.add(bspec)
+    assert ! @deplist.ok?
+  end
+
+  def test_one_satisfied_gem
+    @deplist.add(create_spec("a", "1.1"))
+    assert @deplist.ok?
+  end
+
+  def test_two_gems_with_dependency
+    @deplist.add(create_spec("a", "1.1"))
+    @deplist.add(bspec)
+    assert @deplist.ok?
+  end
+
+  def test_removing_required_gem
+    @deplist.add(create_spec("a", "1.1"))
+    @deplist.add(bspec)
+    a = @deplist.remove_by_name("a-1.1")
+    assert ! @deplist.ok?
+  end
+
+  def test_removing_redundent_gem
+    @deplist.add(create_spec("a", "1.1"))
+    @deplist.add(create_spec("a", "1.3"))
+    @deplist.add(bspec)
+    a = @deplist.remove_by_name("a-1.1")
+    assert @deplist.ok?
+  end
+
+  def test_finding_gems
+    @deplist.add(create_spec("a", "1.1"))
+    @deplist.add(bspec)
+    assert_equal "a-1.1", @deplist.find_name("a-1.1").full_name
+    assert_equal "b-1.2", @deplist.find_name("b-1.2").full_name
+    assert_nil @deplist.find_name("c-1.2")
+  end
+
+  def test_ok_to_remove
+    @deplist.add(create_spec("a", "1.1"))
+    assert @deplist.ok_to_remove?("a-1.1")
+  end
+
+  def test_not_ok_to_remove
+    @deplist.add(create_spec("a", "1.1"))
+    @deplist.add(bspec)
+    assert ! @deplist.ok_to_remove?("a-1.1")
+  end
+
+  def test_ok_to_remove_with_extras
+    @deplist.add(create_spec("a", "1.1"))
+    @deplist.add(create_spec("a", "1.2"))
+    @deplist.add(bspec)
+    assert @deplist.ok_to_remove?("a-1.1")
+    assert @deplist.ok_to_remove?("a-1.2")
+    assert @deplist.ok_to_remove?("b-1.2")
+  end
+
+  def test_not_ok_to_remove_after_sibling_removed
+    @deplist.add(create_spec("a", "1.1"))
+    @deplist.add(create_spec("a", "1.2"))
+    @deplist.add(bspec)
+    assert @deplist.ok_to_remove?("a-1.1")
+    assert @deplist.ok_to_remove?("a-1.2")
+    @deplist.remove_by_name("a-1.1")
+    assert ! @deplist.ok_to_remove?("a-1.2")
+  end
+
+  def test_sorting
+    @deplist.add(create_spec("a", "1.1"))
+    @deplist.add(bspec)
+    @deplist.add(create_spec("a", "1.3"))
+    order = @deplist.dependency_order
+    assert_equal "b-1.2", order.first.full_name
+  end
+
+  def test_sorting_four_with_out_ambiguities
+    @deplist.add(Gem::Specification.new do |s|
+	s.name = "a"
+	s.version = '1.1'
+      end)
+    @deplist.add(Gem::Specification.new do |s|
+	s.name = "b"
+	s.version = '1.1'
+	s.add_dependency("a", ">= 1.1")
+      end)
+    @deplist.add(Gem::Specification.new do |s|
+	s.name = "c"
+	s.version = '1.1'
+	s.add_dependency("b", ">= 1.1")
+      end)
+    @deplist.add(Gem::Specification.new do |s|
+	s.name = "d"
+	s.version = '1.1'
+	s.add_dependency("c", ">= 1.1")
+      end)
+    order = @deplist.dependency_order
+    assert_equal ['d', 'c', 'b', 'a'], order.collect { |s| s.name }
+  end
+
+  def test_sorting_with_circular_dependency
+    @deplist.add(Gem::Specification.new do |s|
+	s.name = "a"
+	s.version = '1.1'
+	s.add_dependency("c", ">= 1.1")
+      end)
+    @deplist.add(Gem::Specification.new do |s|
+	s.name = "b"
+	s.version = '1.1'
+	s.add_dependency("a", ">= 1.1")
+      end)
+    @deplist.add(Gem::Specification.new do |s|
+	s.name = "c"
+	s.version = '1.1'
+	s.add_dependency("b", ">= 1.1")
+      end)
+    order = @deplist.dependency_order
+  end
+
+  def test_from_source_index
+    hash = {
+      'a-1.1' => create_spec("a", "1.1"),
+      'b-1.2' => bspec,
+    }
+    si = Gem::SourceIndex.new(hash)
+    deps = Gem::DependencyList.from_source_index(si)
+    assert_equal ['b-1.2', 'a-1.1'],
+      deps.dependency_order.collect { |s| s.full_name }
+  end
+
+  # ------------------------------------------------------------------
+
+  def bspec
+    Gem::Specification.new do |s|
+      s.name = "b"
+      s.version = "1.2"
+      s.add_dependency("a", ">= 1.1")
+    end
+  end
+
+  def create_spec(name, version)
+    Gem::Specification.new do |s|
+      s.name = name
+      s.version = version
+    end
+  end
+end