rubygems-update 1.3.1 → 1.3.2

data/test/test_gem_uninstaller.rb

@@ -13,6 +13,8 @@ class TestGemUninstaller < GemInstallerTestCase
     build_rake_in do
       use_ui ui do
         @installer.install
+        @user_installer.install
+        Gem::Uninstaller.new(@user_spec.name, :executables => false).uninstall
       end
     end
   end
@@ -50,7 +52,7 @@ class TestGemUninstaller < GemInstallerTestCase
   def test_path_ok_eh
     uninstaller = Gem::Uninstaller.new nil
 
-    assert_equal true, uninstaller.path_ok?(@spec)
+    assert_equal true, uninstaller.path_ok?(@gemhome, @spec)
   end
 
   def test_path_ok_eh_legacy
@@ -59,7 +61,13 @@ class TestGemUninstaller < GemInstallerTestCase
     @spec.loaded_from.gsub! @spec.full_name, '\&-legacy'
     @spec.platform = 'legacy'
 
-    assert_equal true, uninstaller.path_ok?(@spec)
+    assert_equal true, uninstaller.path_ok?(@gemhome, @spec)
+  end
+
+  def test_path_ok_eh_user
+    uninstaller = Gem::Uninstaller.new nil
+
+    assert_equal true, uninstaller.path_ok?(Gem.user_dir, @user_spec)
   end
 
   def test_uninstall
@@ -72,12 +80,34 @@ class TestGemUninstaller < GemInstallerTestCase
     end
 
     Gem.post_uninstall do
-      assert !File.exist?(gem_dir), 'gem_dir should not exist'
+      refute File.exist?(gem_dir), 'gem_dir should not exist'
+    end
+
+    uninstaller.uninstall
+
+    refute File.exist?(gem_dir)
+
+    assert_same uninstaller, @pre_uninstall_hook_arg
+    assert_same uninstaller, @post_uninstall_hook_arg
+  end
+
+  def test_uninstall_user
+    uninstaller = Gem::Uninstaller.new @user_spec.name, :executables => true,
+                  :user_install => true
+
+    gem_dir = File.join Gem.user_dir, 'gems', @user_spec.full_name
+
+    Gem.pre_uninstall do
+      assert File.exist?(gem_dir), 'gem_dir should exist'
+    end
+
+    Gem.post_uninstall do
+      refute File.exist?(gem_dir), 'gem_dir should not exist'
     end
 
     uninstaller.uninstall
 
-    assert !File.exist?(gem_dir)
+    refute File.exist?(gem_dir)
 
     assert_same uninstaller, @pre_uninstall_hook_arg
     assert_same uninstaller, @post_uninstall_hook_arg

data/test/test_gem_version.rb

@@ -12,9 +12,13 @@ class TestGemVersion < RubyGemTestCase
   def setup
     super
 
+    version = Object.new
+    def version.to_s() '1.4.0' end
+
     @v1_0 = Gem::Version.new '1.0'
     @v1_2 = Gem::Version.new '1.2'
     @v1_3 = Gem::Version.new '1.3'
+    @v1_4_0 = Gem::Version.new version
   end
 
   def test_class_create
@@ -64,6 +68,11 @@ class TestGemVersion < RubyGemTestCase
     assert_equal "5.3", v.bump.to_s
   end
 
+  def test_bump_alpha
+    v = Gem::Version.new("5.2.4.a")
+    assert_equal "5.3", v.bump.to_s
+  end
+
   def test_bump_one_level
     v = Gem::Version.new("5")
     assert_equal "6", v.bump.to_s
@@ -83,6 +92,20 @@ class TestGemVersion < RubyGemTestCase
     assert_equal false, @v1_3.eql?(@v1_2)
   end
 
+  def test_eql_eh4
+    v1_4   = Gem::Version.new '1.4'
+    v1_4_0 = Gem::Version.new "1.4.0"
+
+    assert_equal true, v1_4_0.eql?(@v1_4_0)
+    assert_equal true, @v1_4_0.eql?(v1_4_0)
+
+    assert_equal false, v1_4.eql?(@v1_4_0)
+    assert_equal false, @v1_4_0.eql?(v1_4)
+
+    assert_equal false, @v1_4_0.eql?(@v1_3)
+    assert_equal false, @v1_3.eql?(@v1_4_0)
+  end
+
   def test_equals2
     v = Gem::Version.new("1.2")
 
@@ -96,12 +119,17 @@ class TestGemVersion < RubyGemTestCase
   def test_hash
     v1_2   = Gem::Version.new "1.2"
     v1_2_0 = Gem::Version.new "1.2.0"
+    v1_4_0 = Gem::Version.new "1.4.0"
 
     assert_equal v1_2.hash, @v1_2.hash
 
     refute_equal v1_2_0.hash, @v1_2.hash
 
+    assert_equal v1_4_0.hash, @v1_4_0.hash
+
     refute_equal @v1_2.hash, @v1_3.hash
+
+    refute_equal @v1_2.hash, @v1_4_0.hash
   end
 
   def test_illformed_requirements
@@ -113,9 +141,12 @@ class TestGemVersion < RubyGemTestCase
   end
 
   def test_normalize
-    assert_equal [1],    Gem::Version.new("1").to_ints
-    assert_equal [1],    Gem::Version.new("1.0").to_ints
-    assert_equal [1, 1], Gem::Version.new("1.1").to_ints
+    assert_equal [0],         Gem::Version.new("").normalize.map { |part| part.value }
+    assert_equal [0],         Gem::Version.new("0").normalize.map { |part| part.value }
+    assert_equal [1],         Gem::Version.new("1").normalize.map { |part| part.value }
+    assert_equal [1],         Gem::Version.new("1.0").normalize.map { |part| part.value }
+    assert_equal [1, 1],      Gem::Version.new("1.1").normalize.map { |part| part.value }
+    assert_equal [1, 1, "a"], Gem::Version.new("1.1.a").normalize.map { |part| part.value }
   end
 
   def test_ok
@@ -139,9 +170,34 @@ class TestGemVersion < RubyGemTestCase
     assert_adequate( "",            "< 0.1")
     assert_adequate( "  ",          "< 0.1 ")
     assert_adequate( "",            " <  0.1")
+    assert_adequate( "  ",          "> 0.a ")
+    assert_adequate( "",            " >  0.a")
     assert_adequate( "0",           "=")
     assert_adequate( "0",           ">=")
     assert_adequate( "0",           "<=")
+    assert_adequate( "3.1",         "< 3.2.rc1")
+    assert_adequate( "3.2.0",       "> 3.2.0.rc1")
+    assert_adequate( "3.2.0.rc2",   "> 3.2.0.rc1")
+    assert_adequate( "3.0.rc2",     "< 3.0")
+    assert_adequate( "3.0.rc2",     "< 3.0.0")
+    assert_adequate( "3.0.rc2",     "< 3.0.1")
+  end
+
+  def test_parse_parts_from_version_string
+    assert_equal [], part_values(Gem::Version.new("").parse_parts_from_version_string)
+    assert_equal [1], part_values(Gem::Version.new("1").parse_parts_from_version_string)
+    assert_equal [1, 0], part_values(Gem::Version.new("1.0").parse_parts_from_version_string)
+    assert_equal [1, 0, "a"], part_values(Gem::Version.new("1.0.a").parse_parts_from_version_string)
+  end
+
+  def test_prerelease
+    assert Gem::Version.new('1.2.0.a').prerelease?
+    assert Gem::Version.new('2.9.b').prerelease?
+    assert Gem::Version.new('22.1.50.0.d').prerelease?
+
+    refute Gem::Version.new('1.2.0').prerelease?
+    refute Gem::Version.new('2.9').prerelease?
+    refute Gem::Version.new('22.1.50.0').prerelease?
   end
 
   def test_satisfied_by_eh_boxed
@@ -169,7 +225,12 @@ class TestGemVersion < RubyGemTestCase
   end
 
   def test_spaceship
+    assert_equal 0, Gem::Version.new('1.0') <=> Gem::Version.new('1.0.0')
+    assert_equal 1, Gem::Version.new('1.0') <=> Gem::Version.new('1.0.a')
     assert_equal 1, Gem::Version.new('1.8.2') <=> Gem::Version.new('0.0.0')
+    assert_equal 1, Gem::Version.new('1.8.2') <=> Gem::Version.new('1.8.2.a')
+    assert_equal 1, Gem::Version.new('1.8.2.b') <=> Gem::Version.new('1.8.2.a')
+    assert_equal 0, Gem::Version.new('') <=> Gem::Version.new('0')
   end
 
   def test_boxed
@@ -201,7 +262,7 @@ class TestGemVersion < RubyGemTestCase
   def assert_inadequate(version, requirement)
     ver = Gem::Version.new(version)
     req = Gem::Version::Requirement.new(requirement)
-    assert ! req.satisfied_by?(ver),
+    refute req.satisfied_by?(ver),
       "Version #{version} should not be adequate for Requirement #{requirement}"
   end
 
@@ -210,5 +271,34 @@ class TestGemVersion < RubyGemTestCase
     assert_equal @v1_0.version, actual.version
   end
 
+  def part_values(*parts)
+    parts.flatten.map { |part| part.value }
+  end
+end
+
+class TestGemVersionPart < RubyGemTestCase
+  def test_initialize
+    assert_equal 1, Gem::Version::Part.new(1).value
+    assert_equal 1, Gem::Version::Part.new("1").value
+    assert_equal "a", Gem::Version::Part.new("a").value
+  end
+
+  def test_spaceship
+    assert_equal(-1, Gem::Version::Part.new(1) <=> Gem::Version::Part.new(2))
+    assert_equal( 0, Gem::Version::Part.new(2) <=> Gem::Version::Part.new(2))
+    assert_equal( 1, Gem::Version::Part.new(2) <=> Gem::Version::Part.new(1))
+
+    assert_equal(-1, Gem::Version::Part.new("a") <=> Gem::Version::Part.new("b"))
+    assert_equal( 0, Gem::Version::Part.new("b") <=> Gem::Version::Part.new("b"))
+    assert_equal( 1, Gem::Version::Part.new("b") <=> Gem::Version::Part.new("a"))
+
+    assert_equal(-1, Gem::Version::Part.new("a") <=> Gem::Version::Part.new(1))
+    assert_equal( 1, Gem::Version::Part.new(1)   <=> Gem::Version::Part.new("a"))
+  end
+
+  def test_succ
+    assert_equal 2, Gem::Version::Part.new(1).succ.value
+    assert_equal "b", Gem::Version::Part.new("a").succ.value
+  end
 end
 

data/test/test_gem_version_option.rb

@@ -23,6 +23,19 @@ class TestGemVersionOption < RubyGemTestCase
     assert @cmd.handles?(%w[--version >1])
   end
 
+  def test_enables_prerelease
+    @cmd.add_version_option
+
+    @cmd.handle_options %w[mygem -v 0.2.0.a]
+    assert @cmd.options[:prerelease]
+
+    @cmd.handle_options %w[mygem -v 0.2.0]
+    refute @cmd.options[:prerelease]
+
+    @cmd.handle_options %w[mygem]
+    refute @cmd.options[:prerelease]
+  end
+
   def test_platform_option
     @cmd.add_platform_option
 

data/test/test_kernel.rb

@@ -31,14 +31,14 @@ class TestKernel < RubyGemTestCase
 
   def test_gem_redundent
     assert gem('a', '= 1'), "Should load"
-    assert ! gem('a', '= 1'), "Should not load"
+    refute gem('a', '= 1'), "Should not load"
     assert_equal 1, $:.select { |p| %r{a-1/lib} =~ p }.size
     assert_equal 1, $:.select { |p| %r{a-1/bin} =~ p }.size
   end
 
   def test_gem_overlapping
     assert gem('a', '= 1'), "Should load"
-    assert ! gem('a', '>= 1'), "Should not load"
+    refute gem('a', '>= 1'), "Should not load"
     assert_equal 1, $:.select { |p| %r{a-1/lib} =~ p }.size
     assert_equal 1, $:.select { |p| %r{a-1/bin} =~ p }.size
   end
@@ -55,8 +55,8 @@ class TestKernel < RubyGemTestCase
 
     assert $:.any? { |p| %r{a-1/lib} =~ p }
     assert $:.any? { |p| %r{a-1/bin} =~ p }
-    assert ! $:.any? { |p| %r{a-2/lib} =~ p }
-    assert ! $:.any? { |p| %r{a-2/bin} =~ p }
+    refute $:.any? { |p| %r{a-2/lib} =~ p }
+    refute $:.any? { |p| %r{a-2/bin} =~ p }
   end
 
 end

data/util/CL2notes

@@ -0,0 +1,56 @@
+#!/usr/bin/env ruby
+
+$:.unshift 'lib'
+
+require 'rubygems'
+
+def format_text(text, wrap, indent=0)
+  result = []
+  work = text.dup
+
+  while work.length > wrap
+    if work =~ /^(.{0,#{wrap}})[ \n]/o then
+      result << $1
+      work.slice!(0, $&.length)
+    else
+      result << work.slice!(0, wrap)
+    end
+  end
+
+  result << work if work.length.nonzero?
+  result.join("\n").gsub(/^/, " " * indent)
+end
+
+version = ARGV.shift || Gem::RubyGemsVersion
+
+entries = Hash.new { |h,file| h[file] = [] }
+entry = []
+file = nil
+
+IO.foreach 'ChangeLog' do |line|
+  case line
+  when /^\s*$/,
+       /^#/,
+       /^\d{4}-\d{2}-\d{2}/ then
+    next
+  when /^\s+\*\s+([^:]+?):\s+#{version}/ then
+    entries[file] << entry.join(' ') unless entry.empty?
+    break
+  when /^\s+\*\s+([^:]+?):\s+/ then
+    entries[file] << entry.join(' ') unless entry.empty?
+    file = $1
+    entry = [$'.strip]
+  when /^\s+/ then
+    entry << $'.strip
+  end
+end
+
+entries.sort_by { |file, | file }.each do |file, file_entries|
+  puts "* #{file}"
+  file_entries.each do |file_entry|
+    file_entry = format_text file_entry, 74, 4
+    file_entry.sub! '    ', '  * '
+    puts file_entry
+  end
+end
+

data/util/gem_prelude.rb.template

@@ -0,0 +1,251 @@
+# depends on: array.rb dir.rb env.rb file.rb hash.rb module.rb regexp.rb
+# vim: filetype=ruby
+# WARN
+
+if defined?(Gem) then
+
+  module Kernel
+
+    def gem(gem_name, *version_requirements)
+      Gem.push_gem_version_on_load_path(gem_name, *version_requirements)
+    end
+
+  end
+
+  module Gem
+
+    ConfigMap = {
+      :BASERUBY => RbConfig::CONFIG["BASERUBY"],
+      :sitedir => RbConfig::CONFIG["sitedir"],
+      :ruby_version => RbConfig::CONFIG["ruby_version"],
+      :libdir => RbConfig::CONFIG["libdir"],
+      :sitelibdir => RbConfig::CONFIG["sitelibdir"],
+      :arch => RbConfig::CONFIG["arch"],
+      :bindir => RbConfig::CONFIG["bindir"],
+      :EXEEXT => RbConfig::CONFIG["EXEEXT"],
+      :RUBY_SO_NAME => RbConfig::CONFIG["RUBY_SO_NAME"],
+      :ruby_install_name => RbConfig::CONFIG["ruby_install_name"]
+    }
+
+    def self.dir
+      @gem_home ||= nil
+      set_home(ENV['GEM_HOME'] || default_dir) unless @gem_home
+      @gem_home
+    end
+
+    def self.path
+      @gem_path ||= nil
+      unless @gem_path
+        paths = [ENV['GEM_PATH']]
+        paths << APPLE_GEM_HOME if defined? APPLE_GEM_HOME
+        set_paths(paths.compact.join(File::PATH_SEPARATOR))
+      end
+      @gem_path
+    end
+
+    def self.post_install(&hook)
+      @post_install_hooks << hook
+    end
+
+    def self.post_uninstall(&hook)
+      @post_uninstall_hooks << hook
+    end
+
+    def self.pre_install(&hook)
+      @pre_install_hooks << hook
+    end
+
+    def self.pre_uninstall(&hook)
+      @pre_uninstall_hooks << hook
+    end
+
+    def self.set_home(home)
+      @gem_home = home
+      ensure_gem_subdirectories(@gem_home)
+    end
+
+    def self.set_paths(gpaths)
+      if gpaths
+        @gem_path = gpaths.split(File::PATH_SEPARATOR)
+        @gem_path << Gem.dir
+      else
+        @gem_path = [Gem.dir]
+      end
+      @gem_path.uniq!
+      @gem_path.each do |gp| ensure_gem_subdirectories(gp) end
+    end
+
+    def self.ensure_gem_subdirectories(path)
+    end
+
+    # INCLUDE rubygems/defaults
+
+    # Methods before this line will be removed when QuickLoader is replaced
+    # with the real RubyGems
+
+    GEM_PRELUDE_METHODS = Gem.methods(false)
+
+    begin
+      verbose, debug = $VERBOSE, $DEBUG
+      $VERBOSE = $DEBUG = nil
+
+      begin
+        require 'rubygems/defaults/operating_system'
+      rescue LoadError
+      end
+
+      if defined?(RUBY_ENGINE) then
+        begin
+          require "rubygems/defaults/#{RUBY_ENGINE}"
+        rescue LoadError
+        end
+      end
+    ensure
+      $VERBOSE, $DEBUG = verbose, debug
+    end
+
+    module QuickLoader
+
+      def self.load_full_rubygems_library
+        class << Gem
+          Gem::GEM_PRELUDE_METHODS.each do |method_name|
+            undef_method method_name
+          end
+        end
+
+        Kernel.module_eval do
+          undef_method :gem if method_defined? :gem
+        end
+
+        $".delete File.join(Gem::ConfigMap[:libdir],
+                            Gem::ConfigMap[:ruby_install_name],
+                            Gem::ConfigMap[:ruby_version], 'rubygems.rb')
+
+        require 'rubygems'
+      end
+
+      GemPaths = {}
+      GemVersions = {}
+
+      def push_gem_version_on_load_path(gem_name, *version_requirements)
+        if version_requirements.empty?
+          unless GemPaths.has_key?(gem_name)
+            raise LoadError.new("Could not find RubyGem #{gem_name} (>= 0)\n")
+          end
+
+          # highest version gems already active
+          return false
+        else
+          if version_requirements.length > 1
+            QuickLoader.load_full_rubygems_library
+            return gem(gem_name, *version_requirements)
+          end
+
+          requirement, version = version_requirements[0].split
+          requirement.strip!
+
+          if requirement == ">" || requirement == ">="
+            if (GemVersions[gem_name] <=> Gem.calculate_integers_for_gem_version(version)) >= 0
+              return false
+            end
+          elsif requirement == "~>"
+            loaded_version = GemVersions[gem_name]
+            required_version = Gem.calculate_integers_for_gem_version(version)
+            if loaded_version && (loaded_version[0] == required_version[0])
+              return false
+            end
+          end
+
+          QuickLoader.load_full_rubygems_library
+          gem(gem_name, *version_requirements)
+        end
+      end
+
+      def calculate_integers_for_gem_version(gem_version)
+        numbers = gem_version.split(".").collect {|n| n.to_i}
+        numbers.pop while numbers.last == 0
+        numbers << 0 if numbers.empty?
+        numbers
+      end
+
+      def push_all_highest_version_gems_on_load_path
+        Gem.path.each do |path|
+          gems_directory = File.join(path, "gems")
+          if File.exist?(gems_directory)
+            Dir.entries(gems_directory).each do |gem_directory_name|
+              next if gem_directory_name == "." || gem_directory_name == ".."
+              dash = gem_directory_name.rindex("-")
+              next if dash.nil?
+              gem_name = gem_directory_name[0...dash]
+              current_version = GemVersions[gem_name]
+              new_version = calculate_integers_for_gem_version(gem_directory_name[dash+1..-1])
+              if current_version
+                if (current_version <=> new_version) == -1
+                  GemVersions[gem_name] = new_version
+                  GemPaths[gem_name] = File.join(gems_directory, gem_directory_name)
+                end
+              else
+                GemVersions[gem_name] = new_version
+                GemPaths[gem_name] = File.join(gems_directory, gem_directory_name)
+              end
+            end
+          end
+        end
+
+        require_paths = []
+
+        GemPaths.each_value do |path|
+          if File.exist?(file = File.join(path, ".require_paths")) then
+            paths = File.read(file).split.map do |require_path|
+              File.join path, require_path
+            end
+
+            require_paths.concat paths
+          else
+            require_paths << file if File.exist?(file = File.join(path, "bin"))
+            require_paths << file if File.exist?(file = File.join(path, "lib"))
+          end
+        end
+
+        # "tag" the first require_path inserted into the $LOAD_PATH to enable
+        # indexing correctly with rubygems proper when it inserts an explicitly
+        # gem version
+        unless require_paths.empty?
+          require_paths.first.instance_variable_set(:@gem_prelude_index, true)
+        end
+        # gem directories must come after -I and ENV['RUBYLIB']
+        $:[$:.index(ConfigMap[:sitelibdir]),0] = require_paths
+      end
+
+      def const_missing(constant)
+        QuickLoader.load_full_rubygems_library
+        if Gem.const_defined?(constant)
+          Gem.const_get(constant)
+        else
+          super
+        end
+      end
+
+      def method_missing(method, *args, &block)
+        QuickLoader.load_full_rubygems_library
+        super unless Gem.respond_to?(method)
+        Gem.send(method, *args, &block)
+      end
+    end
+
+    extend QuickLoader
+
+  end
+
+  begin
+    Gem.push_all_highest_version_gems_on_load_path
+    $" << File.join(Gem::ConfigMap[:libdir], Gem::ConfigMap[:ruby_install_name],
+                    Gem::ConfigMap[:ruby_version], "rubygems.rb")
+  rescue Exception => e
+    puts "Error loading gem paths on load path in gem_prelude"
+    puts e
+    puts e.backtrace.join("\n")
+  end
+
+end
+