rubygems-update 1.3.1 → 1.3.2

data/lib/rubygems/validator.rb

@@ -10,6 +10,13 @@ require 'rubygems/digest/md5'
 require 'rubygems/format'
 require 'rubygems/installer'
 
+# Load test-unit 2.x if it's a gem
+begin
+   Gem.activate('test-unit')
+rescue Gem::LoadError
+   # Ignore - use the test-unit library that's part of the standard library
+end   
+
 ##
 # Validator performs various gem file and gem database validation
 
@@ -48,7 +55,7 @@ class Gem::Validator
       gem_data = file.read
       verify_gem gem_data
     end
-  rescue Errno::ENOENT
+  rescue Errno::ENOENT, Errno::EINVAL
     raise Gem::VerificationError, "missing gem file #{gem_path}"
   end
 
@@ -56,13 +63,11 @@ class Gem::Validator
 
   def find_files_for_gem(gem_directory)
     installed_files = []
-    Find.find(gem_directory) {|file_name|
-      fn = file_name.slice((gem_directory.size)..(file_name.size-1)).sub(/^\//, "")
-      if(!(fn =~ /CVS/ || File.directory?(fn) || fn == "")) then
-        installed_files << fn
-      end
-
-    }
+    Find.find gem_directory do |file_name|
+      fn = file_name[gem_directory.size..file_name.size-1].sub(/^\//, "")
+      installed_files << fn unless
+        fn =~ /CVS/ || fn.empty? || File.directory?(file_name)
+    end
     installed_files
   end
 
@@ -81,53 +86,82 @@ class Gem::Validator
   #
   # returns a hash of ErrorData objects, keyed on the problem gem's name.
 
-  def alien
-    errors = {}
+  def alien(gems=[])
+    errors = Hash.new { |h,k| h[k] = {} }
 
     Gem::SourceIndex.from_installed_gems.each do |gem_name, gem_spec|
-      errors[gem_name] ||= []
-
-      gem_path = File.join(Gem.dir, "cache", gem_spec.full_name) + ".gem"
-      spec_path = File.join(Gem.dir, "specifications", gem_spec.full_name) + ".gemspec"
-      gem_directory = File.join(Gem.dir, "gems", gem_spec.full_name)
-
-      installed_files = find_files_for_gem(gem_directory)
+      next unless gems.include? gem_spec.name unless gems.empty?
+
+      install_dir = gem_spec.installation_path
+      gem_path = File.join(install_dir, "cache", gem_spec.full_name) + ".gem"
+      spec_path = File.join(install_dir, "specifications",
+                            gem_spec.full_name) + ".gemspec"
+      gem_directory = gem_spec.full_gem_path
+
+      unless File.directory? gem_directory then
+        errors[gem_name][gem_spec.full_name] =
+          "Gem registered but doesn't exist at #{gem_directory}"
+        next
+      end
 
       unless File.exist? spec_path then
-        errors[gem_name] << ErrorData.new(spec_path, "Spec file doesn't exist for installed gem")
+        errors[gem_name][spec_path] = "Spec file missing for installed gem"
       end
 
       begin
         verify_gem_file(gem_path)
 
+        good, gone, unreadable = nil, nil, nil, nil
+
         open gem_path, Gem.binary_mode do |file|
           format = Gem::Format.from_file_by_path(gem_path)
-          format.file_entries.each do |entry, data|
-            # Found this file.  Delete it from list
-            installed_files.delete remove_leading_dot_dir(entry['path'])
 
-            next unless data # HACK `gem check -a mkrf`
+          good, gone = format.file_entries.partition { |entry, _|
+            File.exist? File.join(gem_directory, entry['path'])
+          }
+
+          gone.map! { |entry, _| entry['path'] }
+          gone.sort.each do |path|
+            errors[gem_name][path] = "Missing file"
+          end
 
-            open File.join(gem_directory, entry['path']), Gem.binary_mode do |f|
-              unless Gem::MD5.hexdigest(f.read).to_s ==
-                Gem::MD5.hexdigest(data).to_s then
-                errors[gem_name] << ErrorData.new(entry['path'], "installed file doesn't match original from gem")
+          good, unreadable = good.partition { |entry, _|
+            File.readable? File.join(gem_directory, entry['path'])
+          }
+
+          unreadable.map! { |entry, _| entry['path'] }
+          unreadable.sort.each do |path|
+            errors[gem_name][path] = "Unreadable file"
+          end
+
+          good.each do |entry, data|
+            begin
+              next unless data # HACK `gem check -a mkrf`
+
+              open File.join(gem_directory, entry['path']), Gem.binary_mode do |f|
+                unless Gem::MD5.hexdigest(f.read).to_s ==
+                    Gem::MD5.hexdigest(data).to_s then
+                  errors[gem_name][entry['path']] = "Modified from original"
+                end
               end
             end
           end
         end
+
+        installed_files = find_files_for_gem(gem_directory)
+        good.map! { |entry, _| entry['path'] }
+        extras = installed_files - good - unreadable
+
+        extras.each do |extra|
+          errors[gem_name][extra] = "Extra file"
+        end
       rescue Gem::VerificationError => e
-        errors[gem_name] << ErrorData.new(gem_path, e.message)
+        errors[gem_name][gem_path] = e.message
       end
+    end
 
-      # Clean out directories that weren't explicitly included in the gemspec
-      # FIXME: This still allows arbitrary incorrect directories.
-      installed_files.delete_if {|potential_directory|
-        File.directory?(File.join(gem_directory, potential_directory))
-      }
-      if(installed_files.size > 0) then
-        errors[gem_name] << ErrorData.new(gem_path, "Unmanaged files in gem: #{installed_files.inspect}")
-      end
+    errors.each do |name, subhash|
+      errors[name] = subhash.map { |path, msg| ErrorData.new(path, msg) }
     end
 
     errors
@@ -167,7 +201,7 @@ class Gem::Validator
   def unit_test(gem_spec)
     start_dir = Dir.pwd
     Dir.chdir(gem_spec.full_gem_path)
-    $: << File.join(Gem.dir, "gems", gem_spec.full_name)
+    $: << gem_spec.full_gem_path
     # XXX: why do we need this gem_spec when we've already got 'spec'?
     test_files = gem_spec.test_files
 

data/lib/rubygems/version.rb

@@ -7,24 +7,74 @@
 require 'rubygems'
 
 ##
-# The Version class processes string versions into comparable values
+# The Version class processes string versions into comparable
+# values. A version string should normally be a series of numbers
+# separated by periods. Each part (digits separated by periods) is
+# considered its own number, and these are used for sorting. So for
+# instance, 3.10 sorts higher than 3.2 because ten is greater than
+# two.
+#
+# If any part contains letters (currently only a-z are supported) then
+# that version is considered prerelease. Versions with a prerelease
+# part in the Nth part sort less than versions with N-1 parts. Prerelease
+# parts are sorted alphabetically using the normal Ruby string sorting
+# rules.
+#
 
 class Gem::Version
+  
+  class Part
+    include Comparable
+
+    attr_reader :value
+
+    def initialize(value)
+      @value = (value =~ /\A\d+\z/) ? value.to_i : value
+    end
+
+    def to_s
+      self.value.to_s
+    end
+
+    def inspect
+      @value
+    end
+    
+    def alpha?
+      String === value
+    end
+
+    def numeric?
+      Fixnum === value
+    end
+
+    def <=>(other)
+      if    self.numeric? && other.alpha? then
+        1
+      elsif self.alpha? && other.numeric? then
+        -1
+      else
+        self.value <=> other.value
+      end
+    end
+
+    def succ
+      self.class.new(self.value.succ)
+    end
+  end
 
   include Comparable
 
-  attr_reader :ints
+  VERSION_PATTERN = '[0-9]+(\.[0-9a-z]+)*'
 
   attr_reader :version
 
-  ##
-  # Returns true if +version+ is a valid version string.
-
   def self.correct?(version)
-    case version
-    when Integer, /\A\s*(\d+(\.\d+)*)*\s*\z/ then true
-    else false
-    end
+    pattern = /\A\s*(#{VERSION_PATTERN})*\s*\z/
+
+    version.is_a? Integer or
+      version =~ pattern or
+      version.to_s =~ pattern
   end
 
   ##
@@ -47,7 +97,7 @@ class Gem::Version
 
   ##
   # Constructs a Version from the +version+ string.  A version string is a
-  # series of digits separated by dots.
+  # series of digits or ASCII letters separated by dots.
 
   def initialize(version)
     raise ArgumentError, "Malformed version number string #{version}" unless
@@ -70,17 +120,20 @@ class Gem::Version
     self.version = array[0]
   end
 
+  def parts
+    @parts ||= normalize
+  end
+
   ##
   # Strip ignored trailing zeros.
 
   def normalize
-    @ints = build_array_from_version_string
-
-    return if @ints.length == 1
-
-    @ints.pop while @ints.last == 0
-
-    @ints = [0] if @ints.empty?
+    parts_arr = parse_parts_from_version_string
+    if parts_arr.length != 1
+      parts_arr.pop while parts_arr.last && parts_arr.last.value == 0
+      parts_arr = [Part.new(0)] if parts_arr.empty?
+    end
+    parts_arr
   end
 
   ##
@@ -92,14 +145,6 @@ class Gem::Version
     @version
   end
 
-  ##
-  # Returns an integer array representation of this Version.
-
-  def to_ints
-    normalize unless @ints
-    @ints
-  end
-
   def to_yaml_properties
     ['@version']
   end
@@ -109,6 +154,13 @@ class Gem::Version
     normalize
   end
 
+  ##
+  # A version is considered a prerelease if any part contains a letter.
+  
+  def prerelease?
+    parts.any? { |part| part.alpha? }
+  end
+
   def yaml_initialize(tag, values)
     self.version = values['version']
   end
@@ -120,7 +172,14 @@ class Gem::Version
   def <=>(other)
     return nil unless self.class === other
     return 1 unless other
-    @ints <=> other.ints
+    mine, theirs = balance(self.parts.dup, other.parts.dup)
+    mine <=> theirs
+  end
+
+  def balance(a, b)
+    a << Part.new(0) while a.size < b.size
+    b << Part.new(0) while b.size < a.size
+    [a, b]
   end
 
   ##
@@ -137,17 +196,22 @@ class Gem::Version
 
   # Return a new version object where the next to the last revision
   # number is one greater. (e.g.  5.3.1 => 5.4)
+  # Pre-release (alpha) parts are ignored. (e.g 5.3.1.b2 => 5.4)
   def bump
-    ints = build_array_from_version_string
-    ints.pop if ints.size > 1
-    ints[-1] += 1
-    self.class.new(ints.join("."))
+    parts = parse_parts_from_version_string
+    parts.pop while parts.any? { |part| part.alpha? }
+    parts.pop if parts.size > 1
+    parts[-1] = parts[-1].succ
+    self.class.new(parts.join("."))
+  end
+
+  def parse_parts_from_version_string # :nodoc:
+    @version.to_s.scan(/[0-9a-z]+/i).map { |s| Part.new(s) }
   end
 
-  def build_array_from_version_string
-    @version.to_s.scan(/\d+/).map { |s| s.to_i }
+  def pretty_print(q) # :nodoc:
+    q.text "Gem::Version.new(#{@version.inspect})"
   end
-  private :build_array_from_version_string
 
   #:stopdoc:
 

data/lib/rubygems/version_option.rb

@@ -41,6 +41,7 @@ module Gem::VersionOption
                "Specify version of gem to #{task}", *wrap) do
                  |value, options|
       options[:version] = value
+      options[:prerelease] = true if value.prerelease?
     end
   end
 

data/setup.rb

@@ -18,317 +18,22 @@ if ENV['RUBYOPT'] and defined? Gem then
   exec(ruby, 'setup.rb', *ARGV)
 end
 
+Dir.chdir File.dirname(__FILE__)
+
 $:.unshift 'lib'
 require 'rubygems'
-require 'getoptlong'
-
-opts = GetoptLong.new(
-    [ '--help',                   '-h', GetoptLong::NO_ARGUMENT ],
-    [ '--prefix',                       GetoptLong::REQUIRED_ARGUMENT ],
-    [ '--no-format-executable',         GetoptLong::NO_ARGUMENT ],
-    [ '--no-rdoc',                      GetoptLong::NO_ARGUMENT ],
-    [ '--no-ri',                        GetoptLong::NO_ARGUMENT ],
-    [ '--vendor',                       GetoptLong::NO_ARGUMENT ],
-    [ '--destdir',                      GetoptLong::REQUIRED_ARGUMENT ]
-)
-
-prefix = ''
-format_executable = true
-rdoc = true
-ri = true
-site_or_vendor = :sitelibdir
-install_destdir = ''
-
-opts.each do | opt, arg |
-  case opt
-  when '--help'
-    puts <<HELP
-ruby setup.rb [options]:
-
-RubyGems will install the gem command with a name matching ruby's
-prefix and suffix.  If ruby was installed as `ruby18`, gem will be
-installed as `gem18`.
+require 'rubygems/gem_runner'
+require 'rubygems/exceptions'
 
-By default, this RubyGems will install gem as:
-  #{Gem.default_exec_format % 'gem'}
+Gem::CommandManager.instance.register_command :setup
 
-Options:
-  --help                 Print this message
-  --prefix=DIR           Prefix path for installing RubyGems
-                         Will not affect gem repository location
-  --no-format-executable Force installation as `gem`
-  --no-rdoc              Don't build RDoc for RubyGems
-  --no-ri                Don't build ri for RubyGems
-  --vendor               Install into vendorlibdir not sitelibdir
-                         (Requires Ruby 1.8.7)
-  --destdir              Root directory to install rubygems into
-                         Used mainly for packaging RubyGems
-HELP
-    exit 0
+args = ARGV.clone
 
-  when '--no-rdoc'
-    rdoc = false
+args.unshift 'setup'
 
-  when '--no-ri'
-    ri = false
-
-  when '--no-format-executable'
-    format_executable = false
-
-  when '--prefix'
-    prefix = File.expand_path(arg)
-
-  when '--vendor'
-    vendor_dir_version = Gem::Version::Requirement.create('>= 1.8.7')
-    unless vendor_dir_version.satisfied_by? Gem.ruby_version then
-      abort "To use --vendor you need ruby #{vendor_dir_version}, current #{Gem.ruby_version}"
-    end
-    site_or_vendor = :vendorlibdir
-
-  when '--destdir'
-    install_destdir = File.expand_path(arg)
-  end
+begin
+  Gem::GemRunner.new.run args
+rescue Gem::SystemExitException => e
+  exit e.exit_code
 end
 
-require 'fileutils'
-require 'rbconfig'
-require 'tmpdir'
-require 'pathname'
-
-unless install_destdir.empty? then
-  default_dir = Pathname.new(Gem.default_dir)
-  top_dir = Pathname.new(RbConfig::TOPDIR)
-  ENV['GEM_HOME'] ||= File.join(install_destdir,
-                                default_dir.relative_path_from(top_dir))
-end
-
-include FileUtils::Verbose
-
-# check ruby version
-
-required_version = Gem::Version::Requirement.create("> 1.8.3")
-
-unless required_version.satisfied_by? Gem.ruby_version then
-  abort "Expected Ruby version #{required_version}, was #{Gem.ruby_version}"
-end
-
-# install stuff
-
-lib_dir = nil
-bin_dir = nil
-
-if prefix.empty?
-  lib_dir = Gem::ConfigMap[site_or_vendor]
-  bin_dir = Gem::ConfigMap[:bindir]
-else
-  # Apple installed RubyGems into libdir, and RubyGems <= 1.1.0 gets confused
-  # about installation location, so switch back to sitelibdir/vendorlibdir.
-  if defined?(APPLE_GEM_HOME) and
-      # just in case Apple and RubyGems don't get this patched up proper.
-     (prefix == Gem::ConfigMap[:libdir] or
-      # this one is important
-      prefix == File.join(Gem::ConfigMap[:libdir], 'ruby')) then
-    lib_dir = Gem::ConfigMap[site_or_vendor]
-    bin_dir = Gem::ConfigMap[:bindir]
-  else
-    lib_dir = File.join prefix, 'lib'
-    bin_dir = File.join prefix, 'bin'
-  end
-end
-
-unless install_destdir.empty?
-  top_dir = Pathname.new(RbConfig::TOPDIR)
-  lib_dir_p = Pathname.new(lib_dir)
-  bin_dir_p = Pathname.new(bin_dir)
-
-  lib_dir = File.join install_destdir, lib_dir_p.relative_path_from(top_dir)
-  bin_dir = File.join install_destdir, bin_dir_p.relative_path_from(top_dir)
-end
-
-mkdir_p lib_dir
-mkdir_p bin_dir
-
-Dir.chdir 'lib' do
-  lib_files = Dir[File.join('**', '*rb')]
-
-  lib_files.each do |lib_file|
-    dest_file = File.join lib_dir, lib_file
-    dest_dir = File.dirname dest_file
-    mkdir_p dest_dir unless File.directory? dest_dir
-
-    install lib_file, dest_file, :mode => 0644
-  end
-end
-
-bin_file_names = []
-
-Dir.chdir 'bin' do
-  bin_files = Dir['*']
-
-  bin_files.delete 'update_rubygems'
-
-  bin_files.each do |bin_file|
-    bin_file_formatted = if format_executable then
-                           Gem.default_exec_format % bin_file
-                         else
-                           bin_file
-                         end
-
-    dest_file = File.join bin_dir, bin_file_formatted
-    bin_tmp_file = File.join Dir.tmpdir, bin_file
-
-    begin
-      cp bin_file, bin_tmp_file
-      bin = File.readlines bin_tmp_file
-      bin[0] = "#!#{Gem.ruby}\n"
-
-      File.open bin_tmp_file, 'w' do |fp|
-        fp.puts bin.join
-      end
-
-      install bin_tmp_file, dest_file, :mode => 0755
-      bin_file_names << dest_file
-    ensure
-      rm bin_tmp_file
-    end
-
-    next unless Gem.win_platform?
-
-    begin
-      bin_cmd_file = File.join Dir.tmpdir, "#{bin_file}.bat"
-
-      File.open bin_cmd_file, 'w' do |file|
-        file.puts <<-TEXT
-@ECHO OFF
-IF NOT "%~f0" == "~f0" GOTO :WinNT
-@"#{File.basename(Gem.ruby)}" "#{dest_file}" %1 %2 %3 %4 %5 %6 %7 %8 %9
-GOTO :EOF
-:WinNT
-@"#{File.basename(Gem.ruby)}" "%~dpn0" %*
-TEXT
-      end
-
-      install bin_cmd_file, "#{dest_file}.bat", :mode => 0755
-    ensure
-      rm bin_cmd_file
-    end
-  end
-end
-
-# Replace old bin files with ones that abort.
-
-old_bin_files = {
-  'gem_mirror' => 'gem mirror',
-  'gem_server' => 'gem server',
-  'gemlock' => 'gem lock',
-  'gemri' => 'ri',
-  'gemwhich' => 'gem which',
-  'index_gem_repository.rb' => 'gem generate_index',
-}
-
-old_bin_files.each do |old_bin_file, new_name|
-  old_bin_path = File.join bin_dir, old_bin_file
-  next unless File.exist? old_bin_path
-
-  deprecation_message = "`#{old_bin_file}` has been deprecated.  Use `#{new_name}` instead."
-
-  File.open old_bin_path, 'w' do |fp|
-    fp.write <<-EOF
-#!#{Gem.ruby}
-
-abort "#{deprecation_message}"
-    EOF
-  end
-
-  next unless Gem.win_platform?
-
-  File.open "#{old_bin_path}.bat", 'w' do |fp|
-    fp.puts %{@ECHO.#{deprecation_message}}
-  end
-end
-
-# Remove source caches
-if install_destdir.empty?
-  require 'rubygems/source_info_cache'
-
-  user_cache_file = File.join(install_destdir,
-                              Gem::SourceInfoCache.user_cache_file)
-  system_cache_file = File.join(install_destdir,
-                                Gem::SourceInfoCache.system_cache_file)
-
-  rm_f user_cache_file if File.writable? File.dirname(user_cache_file)
-  rm_f system_cache_file if File.writable? File.dirname(system_cache_file)
-end
-
-# install RDoc
-
-gem_doc_dir = File.join Gem.dir, 'doc'
-rubygems_name = "rubygems-#{Gem::RubyGemsVersion}"
-rubygems_doc_dir = File.join gem_doc_dir, rubygems_name
-
-if File.writable? gem_doc_dir and
-   (not File.exist? rubygems_doc_dir or
-    File.writable? rubygems_doc_dir) then
-  puts "Removing old RubyGems RDoc and ri"
-  Dir[File.join(Gem.dir, 'doc', 'rubygems-[0-9]*')].each do |dir|
-    rm_rf dir
-  end
-
-  def run_rdoc(*args)
-    begin
-      gem 'rdoc'
-    rescue Gem::LoadError
-    end
-
-    require 'rdoc/rdoc'
-
-    args << '--quiet'
-    args << '--main' << 'README'
-    args << '.' << 'README' << 'LICENSE.txt' << 'GPL.txt'
-
-    r = RDoc::RDoc.new
-    r.document args
-  end
-
-  if ri then
-    ri_dir = File.join rubygems_doc_dir, 'ri'
-    puts "Installing #{rubygems_name} ri into #{ri_dir}"
-    run_rdoc '--ri', '--op', ri_dir
-  end
-
-  if rdoc then
-    rdoc_dir = File.join rubygems_doc_dir, 'rdoc'
-    puts "Installing #{rubygems_name} rdoc into #{rdoc_dir}"
-    run_rdoc '--op', rdoc_dir
-  end
-else
-  puts "Skipping RDoc generation, #{gem_doc_dir} not writable"
-  puts "Set the GEM_HOME environment variable if you want RDoc generated"
-end
-
-puts
-puts "-" * 78
-puts
-
-release_notes = File.join File.dirname(__FILE__), 'doc', 'release_notes',
-                          "rel_#{Gem::RubyGemsVersion.gsub '.', '_'}.rdoc"
-
-if File.exist? release_notes then
-  puts File.read(release_notes)
-else
-  puts "Oh-no! Unable to find release notes in:\n\t#{release_notes}"
-end
-
-puts
-puts "-" * 78
-puts
-
-puts "RubyGems installed the following executables:"
-puts bin_file_names.map { |name| "\t#{name}\n" }
-puts
-
-puts "If `gem` was installed by a previous RubyGems installation, you may need"
-puts "to remove it by hand."
-puts
-
-