From 8289771e326006cc4e15a667e3eff3a72cfb3327 Mon Sep 17 00:00:00 2001 From: drbrain Date: Thu, 20 Dec 2007 08:39:12 +0000 Subject: Import RubyGems 1.0.0, r1575 git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@14361 b2dd03c8-39d4-4d8f-98ff-823fe69b080e --- ChangeLog | 4 + gem_prelude.rb | 13 +- lib/rubygems.rb | 48 +-- lib/rubygems/commands/install_command.rb | 2 + lib/rubygems/commands/mirror_command.rb | 10 +- lib/rubygems/commands/query_command.rb | 4 +- lib/rubygems/commands/server_command.rb | 6 +- lib/rubygems/commands/unpack_command.rb | 15 +- lib/rubygems/commands/update_command.rb | 222 +++++----- lib/rubygems/defaults.rb | 46 ++ lib/rubygems/dependency_installer.rb | 15 +- lib/rubygems/indexer.rb | 2 +- lib/rubygems/install_update_options.rb | 7 + lib/rubygems/installer.rb | 72 +++- lib/rubygems/package.rb | 1 + lib/rubygems/platform.rb | 45 +- lib/rubygems/remote_fetcher.rb | 10 +- lib/rubygems/remote_installer.rb | 195 --------- lib/rubygems/rubygems_version.rb | 2 +- lib/rubygems/security.rb | 2 +- lib/rubygems/server.rb | 21 +- lib/rubygems/source_index.rb | 43 +- lib/rubygems/source_info_cache.rb | 6 +- lib/rubygems/specification.rb | 95 +++-- lib/rubygems/uninstaller.rb | 2 +- lib/rubygems/validator.rb | 5 +- lib/rubygems/version.rb | 13 +- test/rubygems/gemutilities.rb | 21 +- test/rubygems/test_gem.rb | 122 ++---- test/rubygems/test_gem_commands_build_command.rb | 24 +- .../test_gem_commands_dependency_command.rb | 20 +- test/rubygems/test_gem_commands_mirror_command.rb | 13 +- test/rubygems/test_gem_commands_query_command.rb | 10 +- test/rubygems/test_gem_commands_server_command.rb | 27 ++ test/rubygems/test_gem_commands_unpack_command.rb | 22 +- test/rubygems/test_gem_format.rb | 2 +- test/rubygems/test_gem_indexer.rb | 10 +- test/rubygems/test_gem_install_update_options.rb | 2 +- test/rubygems/test_gem_installer.rb | 198 ++++++--- test/rubygems/test_gem_platform.rb | 17 + test/rubygems/test_gem_remote_fetcher.rb | 21 +- test/rubygems/test_gem_remote_installer.rb | 161 ------- test/rubygems/test_gem_server.rb | 45 +- test/rubygems/test_gem_source_index.rb | 4 +- test/rubygems/test_gem_specification.rb | 468 +++++++++++++-------- test/rubygems/test_gem_version.rb | 15 + test/rubygems/test_kernel.rb | 38 +- 47 files changed, 1153 insertions(+), 993 deletions(-) create mode 100644 lib/rubygems/defaults.rb delete mode 100644 lib/rubygems/remote_installer.rb create mode 100644 test/rubygems/test_gem_commands_server_command.rb delete mode 100644 test/rubygems/test_gem_remote_installer.rb diff --git a/ChangeLog b/ChangeLog index 19d679642f..a62f86d02f 100644 --- a/ChangeLog +++ b/ChangeLog @@ -1,3 +1,7 @@ +Thu Dec 20 17:36:01 2007 Eric Hodel + + * lib/rubygems*: Import RubyGems 1.0.0, r1575. + Thu Dec 20 17:18:38 2007 Koichi Sasada * proc.c: support Proc#binding. diff --git a/gem_prelude.rb b/gem_prelude.rb index 997dae4699..88ffe17538 100644 --- a/gem_prelude.rb +++ b/gem_prelude.rb @@ -131,6 +131,7 @@ module Gem 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]) @@ -167,6 +168,7 @@ module Gem def method_missing(method, *args, &block) QuickLoader.load_full_rubygems_library + super unless Gem.respond_to?(method) Gem.send(method, *args, &block) end end @@ -174,9 +176,14 @@ module Gem extend QuickLoader end - -Gem.push_all_highest_version_gems_on_load_path -$".unshift File.join(Gem::ConfigMap[:libdir], "ruby", Gem::ConfigMap[:ruby_version], "rubygems.rb") +begin + Gem.push_all_highest_version_gems_on_load_path + $".unshift File.join(Gem::ConfigMap[:libdir], "ruby", 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 #puts "Gem load in #{Time.now - t} seconds" end # Gem::Enable \ No newline at end of file diff --git a/lib/rubygems.rb b/lib/rubygems.rb index f233b520f1..72f735ce50 100644 --- a/lib/rubygems.rb +++ b/lib/rubygems.rb @@ -6,6 +6,7 @@ #++ require 'rubygems/rubygems_version' +require 'rubygems/defaults' require 'thread' module Gem @@ -29,8 +30,8 @@ module Kernel # version). # # You can define the environment variable GEM_SKIP as a way to not - # load specified gems. you might do this to test out changes that - # haven't been intsalled yet. Example: + # load specified gems. You might do this to test out changes that + # haven't been installed yet. Example: # # GEM_SKIP=libA:libB ruby-I../libA -I../libB ./mycode.rb # @@ -49,17 +50,6 @@ module Kernel active_gem_with_options(gem_name, version_requirements) end - # Same as the +gem+ command, but will also require a file if the gem - # provides an auto-required file name. - # - # DEPRECATED! Use +gem+ instead. - # - def require_gem(gem_name, *version_requirements) - file, lineno = location_of_caller - warn "#{file}:#{lineno}:Warning: require_gem is obsolete. Use gem instead." - active_gem_with_options(gem_name, version_requirements, :auto_require=>true) - end - # Return the file name (string) and line number (integer) of the caller of # the caller of this method. def location_of_caller @@ -84,15 +74,17 @@ module Gem ConfigMap = {} unless defined?(ConfigMap) require 'rbconfig' ConfigMap.merge!( - :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"], + :BASERUBY => RbConfig::CONFIG["BASERUBY"], :EXEEXT => RbConfig::CONFIG["EXEEXT"], + :RUBY_INSTALL_NAME => RbConfig::CONFIG["RUBY_INSTALL_NAME"], :RUBY_SO_NAME => RbConfig::CONFIG["RUBY_SO_NAME"], - :ruby_install_name => RbConfig::CONFIG["ruby_install_name"] + :arch => RbConfig::CONFIG["arch"], + :bindir => RbConfig::CONFIG["bindir"], + :libdir => RbConfig::CONFIG["libdir"], + :ruby_install_name => RbConfig::CONFIG["ruby_install_name"], + :ruby_version => RbConfig::CONFIG["ruby_version"], + :sitedir => RbConfig::CONFIG["sitedir"], + :sitelibdir => RbConfig::CONFIG["sitelibdir"] ) MUTEX = Mutex.new @@ -207,10 +199,6 @@ module Gem @sources end - # An Array of the default sources that come with RubyGems. - def default_sources - %w[http://gems.rubyforge.org] - end # Provide an alias for the old name. alias cache source_index @@ -536,18 +524,6 @@ module Gem end end - public - - # Default home directory path to be used if an alternate value is - # not specified in the environment. - def default_dir - if defined? RUBY_FRAMEWORK_VERSION - return File.join(File.dirname(ConfigMap[:sitedir]), "Gems", ConfigMap[:ruby_version]) - else - File.join(ConfigMap[:libdir], 'ruby', 'gems', ConfigMap[:ruby_version]) - end - end - end end diff --git a/lib/rubygems/commands/install_command.rb b/lib/rubygems/commands/install_command.rb index 4c67c0487b..aa9f480c2a 100644 --- a/lib/rubygems/commands/install_command.rb +++ b/lib/rubygems/commands/install_command.rb @@ -17,6 +17,7 @@ class Gem::Commands::InstallCommand < Gem::Command :generate_rdoc => true, :generate_ri => true, :install_dir => Gem.dir, + :format_executable => false, :test => false, :version => Gem::Requirement.default, }) @@ -56,6 +57,7 @@ class Gem::Commands::InstallCommand < Gem::Command :env_shebang => options[:env_shebang], :domain => options[:domain], :force => options[:force], + :format_executable => options[:format_executable], :ignore_dependencies => options[:ignore_dependencies], :install_dir => options[:install_dir], :security_policy => options[:security_policy], diff --git a/lib/rubygems/commands/mirror_command.rb b/lib/rubygems/commands/mirror_command.rb index 74f6970e9e..fc4f086ad3 100644 --- a/lib/rubygems/commands/mirror_command.rb +++ b/lib/rubygems/commands/mirror_command.rb @@ -60,10 +60,16 @@ Multiple sources and destinations may be specified. if get_from.scheme.nil? then get_from = get_from.to_s elsif get_from.scheme == 'file' then - get_from = get_from.to_s[5..-1] + # check if specified URI contains a drive letter (file:/D:/Temp) + get_from = get_from.to_s + get_from = if get_from =~ /^file:.*[a-z]:/i then + get_from[6..-1] + else + get_from[5..-1] + end end - open File.join(get_from, "Marshal.#{Gem.marshal_version}.Z"), "rb" do |y| + open File.join(get_from.to_s, "Marshal.#{Gem.marshal_version}.Z"), "rb" do |y| sourceindex_data = Zlib::Inflate.inflate y.read open File.join(save_to, "Marshal.#{Gem.marshal_version}"), "wb" do |out| out.write sourceindex_data diff --git a/lib/rubygems/commands/query_command.rb b/lib/rubygems/commands/query_command.rb index 581d4bb734..4f957625ee 100644 --- a/lib/rubygems/commands/query_command.rb +++ b/lib/rubygems/commands/query_command.rb @@ -82,8 +82,10 @@ class Gem::Commands::QueryCommand < Gem::Command end entry = gem_name.dup + if options[:versions] then - entry << " (#{list_of_matching.map{|gem| gem.version.to_s}.join(", ")})" + versions = list_of_matching.map { |s| s.version }.uniq + entry << " (#{versions.join ', '})" end entry << "\n" << format_text(list_of_matching[0].summary, 68, 4) if diff --git a/lib/rubygems/commands/server_command.rb b/lib/rubygems/commands/server_command.rb index 34e5e46fec..992ae1c8f8 100644 --- a/lib/rubygems/commands/server_command.rb +++ b/lib/rubygems/commands/server_command.rb @@ -7,17 +7,17 @@ class Gem::Commands::ServerCommand < Gem::Command super 'server', 'Documentation and gem repository HTTP server', :port => 8808, :gemdir => Gem.dir, :daemon => false - add_option '-p', '--port=PORT', + add_option '-p', '--port=PORT', Integer, 'port to listen on' do |port, options| options[:port] = port end add_option '-d', '--dir=GEMDIR', 'directory from which to serve gems' do |gemdir, options| - options[:gemdir] = gemdir + options[:gemdir] = File.expand_path gemdir end - add_option '--[no]-daemon', 'run as a daemon' do |daemon, options| + add_option '--[no-]daemon', 'run as a daemon' do |daemon, options| options[:daemon] = daemon end end diff --git a/lib/rubygems/commands/unpack_command.rb b/lib/rubygems/commands/unpack_command.rb index ece24745a2..23ebabc21a 100644 --- a/lib/rubygems/commands/unpack_command.rb +++ b/lib/rubygems/commands/unpack_command.rb @@ -9,7 +9,13 @@ class Gem::Commands::UnpackCommand < Gem::Command def initialize super 'unpack', 'Unpack an installed gem to the current directory', - :version => Gem::Requirement.default + :version => Gem::Requirement.default, + :target => Dir.pwd + + add_option('--target', 'target directory for unpacking') do |value, options| + options[:target] = value + end + add_version_option end @@ -32,10 +38,11 @@ class Gem::Commands::UnpackCommand < Gem::Command def execute gemname = get_one_gem_name path = get_path(gemname, options[:version]) - if path - target_dir = File.basename(path).sub(/\.gem$/, '') + if path then + basename = File.basename(path).sub(/\.gem$/, '') + target_dir = File.expand_path File.join(options[:target], basename) FileUtils.mkdir_p target_dir - Gem::Installer.new(path).unpack(File.expand_path(target_dir)) + Gem::Installer.new(path).unpack target_dir say "Unpacked gem: '#{target_dir}'" else alert_error "Gem '#{gemname}' not installed." diff --git a/lib/rubygems/commands/update_command.rb b/lib/rubygems/commands/update_command.rb index e17ba2516a..7a11ec9554 100644 --- a/lib/rubygems/commands/update_command.rb +++ b/lib/rubygems/commands/update_command.rb @@ -4,146 +4,152 @@ require 'rubygems/local_remote_options' require 'rubygems/source_info_cache' require 'rubygems/version_option' -module Gem - module Commands - class UpdateCommand < Command +class Gem::Commands::UpdateCommand < Gem::Command - include Gem::InstallUpdateOptions - include Gem::LocalRemoteOptions - include Gem::VersionOption + include Gem::InstallUpdateOptions + include Gem::LocalRemoteOptions + include Gem::VersionOption - def initialize - super( - 'update', + def initialize + super 'update', 'Update the named gems (or all installed gems) in the local repository', - { - :generate_rdoc => true, - :generate_ri => true, - :force => false, - :test => false, - :install_dir => Gem.dir - }) - - add_install_update_options - - add_option('--system', - 'Update the RubyGems system software') do |value, options| - options[:system] = value - end + :generate_rdoc => true, + :generate_ri => true, + :force => false, + :test => false, + :install_dir => Gem.dir - add_local_remote_options + add_install_update_options - add_platform_option - end + add_option('--system', + 'Update the RubyGems system software') do |value, options| + options[:system] = value + end - def arguments # :nodoc: - "GEMNAME name of gem to update" - end + add_local_remote_options - def defaults_str # :nodoc: - "--rdoc --ri --no-force --no-test\n" + - "--install-dir #{Gem.dir}" - end + add_platform_option + end + + def arguments # :nodoc: + "GEMNAME name of gem to update" + end - def usage # :nodoc: - "#{program_name} GEMNAME [GEMNAME ...]" + def defaults_str # :nodoc: + "--rdoc --ri --no-force --no-test --install-dir #{Gem.dir}" + end + + def usage # :nodoc: + "#{program_name} GEMNAME [GEMNAME ...]" + end + + def execute + if options[:system] then + say "Updating RubyGems..." + + unless options[:args].empty? then + fail "No gem names are allowed with the --system option" end - def execute - if options[:system] then - say "Updating RubyGems..." + options[:args] = ["rubygems-update"] + else + say "Updating installed gems..." + end - unless options[:args].empty? then - fail "No gem names are allowed with the --system option" - end + hig = highest_installed_gems = {} - options[:args] = ["rubygems-update"] - else - say "Updating installed gems..." - end + Gem::SourceIndex.from_installed_gems.each do |name, spec| + if hig[spec.name].nil? or hig[spec.name].version < spec.version then + hig[spec.name] = spec + end + end - hig = highest_installed_gems = {} + remote_gemspecs = Gem::SourceInfoCache.search(//) - Gem::SourceIndex.from_installed_gems.each do |name, spec| - if hig[spec.name].nil? or hig[spec.name].version < spec.version - hig[spec.name] = spec - end - end + gems_to_update = if options[:args].empty? then + which_to_update(highest_installed_gems, remote_gemspecs) + else + options[:args] + end - remote_gemspecs = Gem::SourceInfoCache.search(//) + options[:domain] = :remote # install from remote source - gems_to_update = if options[:args].empty? then - which_to_update(highest_installed_gems, remote_gemspecs) - else - options[:args] - end + # HACK use the real API + install_command = Gem::CommandManager.instance['install'] - options[:domain] = :remote # install from remote source + gems_to_update.uniq.sort.each do |name| + say "Attempting remote update of #{name}" + options[:args] = [name] + options[:ignore_dependencies] = true # HACK skip seen gems instead + install_command.merge_options(options) + install_command.execute + end - # HACK use the real API - install_command = Gem::CommandManager.instance['install'] + if gems_to_update.include? "rubygems-update" then + latest_ruby_gem = remote_gemspecs.select do |s| + s.name == 'rubygems-update' + end - gems_to_update.uniq.sort.each do |name| - say "Attempting remote update of #{name}" - options[:args] = [name] - options[:ignore_dependencies] = true # HACK skip seen gems instead - install_command.merge_options(options) - install_command.execute - end + latest_ruby_gem = latest_ruby_gem.sort_by { |s| s.version }.last - if gems_to_update.include?("rubygems-update") then - latest_ruby_gem = remote_gemspecs.select { |s| - s.name == 'rubygems-update' - }.sort_by { |s| - s.version - }.last + say "Updating version of RubyGems to #{latest_ruby_gem.version}" + installed = do_rubygems_update latest_ruby_gem.version - say "Updating version of RubyGems to #{latest_ruby_gem.version}" - installed = do_rubygems_update(latest_ruby_gem.version.to_s) + say "RubyGems system software updated" if installed + else + updated = gems_to_update.uniq.sort.collect { |g| g.to_s } - say "RubyGems system software updated" if installed - else - say "Gems: [#{gems_to_update.uniq.sort.collect{|g| g.to_s}.join(', ')}] updated" - end + if updated.empty? then + say "Nothing to update" + else + say "Gems updated: #{updated.join ', '}" end + end + end - def do_rubygems_update(version_string) - args = [] - args.push '--prefix', Gem.prefix unless Gem.prefix.nil? - args << '--no-rdoc' unless options[:generate_rdoc] - args << '--no-ri' unless options[:generate_ri] + def do_rubygems_update(version) + args = [] + args.push '--prefix', Gem.prefix unless Gem.prefix.nil? + args << '--no-rdoc' unless options[:generate_rdoc] + args << '--no-ri' unless options[:generate_ri] - update_dir = File.join(Gem.dir, 'gems', - "rubygems-update-#{version_string}") + update_dir = File.join Gem.dir, 'gems', "rubygems-update-#{version}" - success = false + success = false - Dir.chdir update_dir do - say "Installing RubyGems #{version_string}" - setup_cmd = "#{Gem.ruby} setup.rb #{args.join ' '}" + Dir.chdir update_dir do + say "Installing RubyGems #{version}" + setup_cmd = "#{Gem.ruby} setup.rb #{args.join ' '}" - # Make sure old rubygems isn't loaded - if Gem.win_platform? then - system "set RUBYOPT= & #{setup_cmd}" - else - system "RUBYOPT=\"\" #{setup_cmd}" - end - end + # Make sure old rubygems isn't loaded + if Gem.win_platform? then + system "set RUBYOPT= & #{setup_cmd}" + else + system "RUBYOPT=\"\" #{setup_cmd}" end + end + end + + def which_to_update(highest_installed_gems, remote_gemspecs) + result = [] - def which_to_update(highest_installed_gems, remote_gemspecs) - result = [] - highest_installed_gems.each do |l_name, l_spec| - highest_remote_gem = - remote_gemspecs.select { |spec| spec.name == l_name }. - sort_by { |spec| spec.version }. - last - if highest_remote_gem and l_spec.version < highest_remote_gem.version - result << l_name - end + highest_installed_gems.each do |l_name, l_spec| + matching_gems = remote_gemspecs.select do |spec| + spec.name == l_name and Gem.platforms.any? do |platform| + platform == spec.platform end - result + end + + highest_remote_gem = matching_gems.sort_by { |spec| spec.version }.last + + if highest_remote_gem and + l_spec.version < highest_remote_gem.version then + result << l_name end end + + result end + end + diff --git a/lib/rubygems/defaults.rb b/lib/rubygems/defaults.rb new file mode 100644 index 0000000000..3a6229511b --- /dev/null +++ b/lib/rubygems/defaults.rb @@ -0,0 +1,46 @@ +module Gem + + # An Array of the default sources that come with RubyGems. + def self.default_sources + %w[http://gems.rubyforge.org] + end + + # Default home directory path to be used if an alternate value is not + # specified in the environment. + def self.default_dir + if defined? RUBY_FRAMEWORK_VERSION then + File.join File.dirname(ConfigMap[:sitedir]), 'Gems', + ConfigMap[:ruby_version] + else + File.join ConfigMap[:libdir], 'ruby', 'gems', ConfigMap[:ruby_version] + end + end + + # Default gem path. + def self.default_path + default_dir + end + + # Deduce Ruby's --program-prefix and --program-suffix from its install name. + def self.default_exec_format + baseruby = ConfigMap[:BASERUBY] || 'ruby' + ConfigMap[:RUBY_INSTALL_NAME].sub(baseruby, '%s') rescue '%s' + end + + # The default directory for binaries + def self.default_bindir + Config::CONFIG['bindir'] + end + + # The default system-wide source info cache directory. + def self.default_system_source_cache_dir + File.join Gem.dir, 'source_cache' + end + + # The default user-specific source info cache directory. + def self.default_user_source_cache_dir + File.join Gem.user_home, '.gem', 'source_cache' + end + +end + diff --git a/lib/rubygems/dependency_installer.rb b/lib/rubygems/dependency_installer.rb index e189e800a0..ec8a50d912 100644 --- a/lib/rubygems/dependency_installer.rb +++ b/lib/rubygems/dependency_installer.rb @@ -15,8 +15,9 @@ class Gem::DependencyInstaller :env_shebang => false, :domain => :both, # HACK dup :force => false, + :format_executable => false, # HACK dup :ignore_dependencies => false, - :security_policy => Gem::Security::NoSecurity, # HACK AlmostNo? Low? + :security_policy => nil, # HACK NoSecurity requires OpenSSL. AlmostNo? Low? :wrappers => true } @@ -30,6 +31,7 @@ class Gem::DependencyInstaller # current directory. :remote searches only gems in Gem::sources. # :both searches both. # :force:: See Gem::Installer#install. + # :format_executable:: See Gem::Installer#initialize. # :ignore_dependencies: Don't install any dependencies. # :install_dir: See Gem::Installer#install. # :security_policy: See Gem::Installer::new and Gem::Security. @@ -39,6 +41,7 @@ class Gem::DependencyInstaller @env_shebang = options[:env_shebang] @domain = options[:domain] @force = options[:force] + @format_executable = options[:format_executable] @ignore_dependencies = options[:ignore_dependencies] @install_dir = options[:install_dir] || Gem.dir @security_policy = options[:security_policy] @@ -48,7 +51,14 @@ class Gem::DependencyInstaller spec_and_source = nil - local_gems = Dir["#{gem_name}*"].sort.reverse + glob = if File::ALT_SEPARATOR then + gem_name.gsub File::ALT_SEPARATOR, File::SEPARATOR + else + gem_name + end + + local_gems = Dir["#{glob}*"].sort.reverse + unless local_gems.empty? then local_gems.each do |gem_file| next unless gem_file =~ /gem$/ @@ -217,6 +227,7 @@ class Gem::DependencyInstaller inst = Gem::Installer.new local_gem_path, :env_shebang => @env_shebang, :force => @force, + :format_executable => @format_executable, :ignore_dependencies => @ignore_dependencies, :install_dir => @install_dir, :security_policy => @security_policy, diff --git a/lib/rubygems/indexer.rb b/lib/rubygems/indexer.rb index dc94f51b1a..272cee3fd3 100644 --- a/lib/rubygems/indexer.rb +++ b/lib/rubygems/indexer.rb @@ -98,7 +98,7 @@ class Gem::Indexer files = @master_index.files + @quick_index.files + @marshal_index.files files.each do |file| - relative_name = file[/\A#{@directory}.(.*)/, 1] + relative_name = file[/\A#{Regexp.escape @directory}.(.*)/, 1] dest_name = File.join @dest_directory, relative_name FileUtils.rm_rf dest_name, :verbose => verbose diff --git a/lib/rubygems/install_update_options.rb b/lib/rubygems/install_update_options.rb index 01c3a8af27..b93e21551c 100644 --- a/lib/rubygems/install_update_options.rb +++ b/lib/rubygems/install_update_options.rb @@ -76,6 +76,13 @@ module Gem::InstallUpdateOptions 'dependent gems') do |value, options| options[:include_dependencies] = value end + + add_option(:"Install/Update", '--[no-]format-executable', + 'Make installed executable names match ruby.', + 'If ruby is ruby18, foo_exec will be', + 'foo_exec18') do |value, options| + options[:format_executable] = value + end end # Default options for the gem install command. diff --git a/lib/rubygems/installer.rb b/lib/rubygems/installer.rb index 46d0144a88..e652ac9c6d 100644 --- a/lib/rubygems/installer.rb +++ b/lib/rubygems/installer.rb @@ -28,9 +28,20 @@ class Gem::Installer class ExtensionBuildError < Gem::InstallError; end include Gem::UserInteraction - + include Gem::RequirePathsBuilder + class << self + + attr_writer :exec_format + + # Defaults to use Ruby's program prefix and suffix. + def exec_format + @exec_format ||= Gem.default_exec_format + end + + end + ## # Constructs an Installer instance that will install the gem located at # +gem+. +options+ is a Hash with the following keys: @@ -40,18 +51,26 @@ class Gem::Installer # for a signed-gems-only policy. # :ignore_dependencies:: Don't raise if a dependency is missing. # :install_dir:: The directory to install the gem into. + # :format_executable:: Format the executable the same as the ruby executable. + # If your ruby is ruby18, foo_exec will be installed as + # foo_exec18. # :security_policy:: Use the specified security policy. See Gem::Security # :wrappers:: Install wrappers if true, symlinks if false. def initialize(gem, options={}) @gem = gem - options = { :force => false, :install_dir => Gem.dir }.merge options + options = { + :force => false, + :install_dir => Gem.dir, + :exec_format => false, + }.merge options @env_shebang = options[:env_shebang] @force = options[:force] gem_home = options[:install_dir] @gem_home = Pathname.new(gem_home).expand_path @ignore_dependencies = options[:ignore_dependencies] + @format_executable = options[:format_executable] @security_policy = options[:security_policy] @wrappers = options[:wrappers] @@ -114,7 +133,7 @@ class Gem::Installer generate_bin build_extensions write_spec - + write_require_paths_file_if_needed # HACK remove? Isn't this done in multiple places? @@ -190,9 +209,12 @@ class Gem::Installer def generate_windows_script(bindir, filename) if Gem.win_platform? then script_name = filename + ".bat" - File.open(File.join(bindir, File.basename(script_name)), "w") do |file| + script_path = File.join bindir, File.basename(script_name) + File.open script_path, 'w' do |file| file.puts windows_stub_script(bindir, filename) end + + say script_path if Gem.configuration.really_verbose end end @@ -209,7 +231,7 @@ class Gem::Installer @spec.executables.each do |filename| filename.untaint - bin_path = File.join @gem_dir, 'bin', filename + bin_path = File.expand_path File.join(@gem_dir, @spec.bindir, filename) mode = File.stat(bin_path).mode | 0111 File.chmod mode, bin_path @@ -229,10 +251,24 @@ class Gem::Installer # http://blade.nagaokaut.ac.jp/cgi-bin/scat.rb/ruby/ruby-talk/193379 # def generate_bin_script(filename, bindir) - File.open(File.join(bindir, File.basename(filename)), "w", 0755) do |file| - file.print app_script_text(filename) - end - generate_windows_script bindir, filename + bin_script_path = File.join bindir, formatted_program_filename(filename) + + exec_path = File.join @gem_dir, @spec.bindir, filename + + # HACK some gems don't have #! in their executables, restore 2008/06 + #if File.read(exec_path, 2) == '#!' then + File.open bin_script_path, 'w', 0755 do |file| + file.print app_script_text(filename) + end + + say bin_script_path if Gem.configuration.really_verbose + + generate_windows_script bindir, filename + #else + # FileUtils.rm_f bin_script_path + # FileUtils.cp exec_path, bin_script_path, + # :verbose => Gem.configuration.really_verbose + #end end ## @@ -247,7 +283,7 @@ class Gem::Installer end src = File.join @gem_dir, 'bin', filename - dst = File.join bindir, File.basename(filename) + dst = File.join bindir, formatted_program_filename(filename) if File.exist? dst then if File.symlink? dst then @@ -258,7 +294,7 @@ class Gem::Installer File.unlink dst end - File.symlink src, dst + FileUtils.symlink src, dst, :verbose => Gem.configuration.really_verbose end ## @@ -351,6 +387,9 @@ TEXT begin Dir.chdir File.join(@gem_dir, File.dirname(extension)) results = builder.build(extension, @gem_dir, dest_path, results) + + say results.join("\n") if Gem.configuration.really_verbose + rescue => ex results = results.join "\n" @@ -402,6 +441,17 @@ Results logged to #{File.join(Dir.pwd, 'gem_make.out')} File.open(path, "wb") do |out| out.write file_data end + + say path if Gem.configuration.really_verbose + end + end + + # Prefix and suffix the program filename the same as ruby. + def formatted_program_filename(filename) + if @format_executable then + self.class.exec_format % File.basename(filename) + else + filename end end diff --git a/lib/rubygems/package.rb b/lib/rubygems/package.rb index b613b7fa05..ee136b6267 100644 --- a/lib/rubygems/package.rb +++ b/lib/rubygems/package.rb @@ -142,6 +142,7 @@ module Gem::Package end def calculate_checksum(hdr) + #hdr.split('').map { |c| c[0] }.inject { |a, b| a + b } # HACK rubinius hdr.unpack("C*").inject{|a,b| a+b} end diff --git a/lib/rubygems/platform.rb b/lib/rubygems/platform.rb index 496c4b1fb8..7abc15ef94 100644 --- a/lib/rubygems/platform.rb +++ b/lib/rubygems/platform.rb @@ -12,6 +12,23 @@ class Gem::Platform attr_accessor :version + DEPRECATED_CONSTS = [ + :DARWIN, + :LINUX_586, + :MSWIN32, + :PPC_DARWIN, + :WIN32, + :X86_LINUX + ] + + def self.const_missing(name) # TODO remove six months from 2007/12 + if DEPRECATED_CONSTS.include? name then + raise NameError, "#{name} has been removed, use CURRENT instead" + else + super + end + end + def self.local arch = Gem::ConfigMap[:arch] arch = "#{arch}_60" if arch =~ /mswin32$/ @@ -160,33 +177,5 @@ class Gem::Platform CURRENT = 'current' - ## - # A One Click Installer-compatible gem, built with VC6 for 32 bit Windows. - # - # CURRENT is preferred over this constant, avoid its use at all costs. - - MSWIN32 = new ['x86', 'mswin32', '60'] - - ## - # An x86 Linux-compatible gem - # - # CURRENT is preferred over this constant, avoid its use at all costs. - - X86_LINUX = new ['x86', 'linux', nil] - - ## - # A PowerPC Darwin-compatible gem - # - # CURRENT is preferred over this constant, avoid its use at all costs. - - PPC_DARWIN = new ['ppc', 'darwin', nil] - - # :stopdoc: - # Here lie legacy constants. These are deprecated. - WIN32 = 'mswin32' - LINUX_586 = 'i586-linux' - DARWIN = 'powerpc-darwin' - # :startdoc: - end diff --git a/lib/rubygems/remote_fetcher.rb b/lib/rubygems/remote_fetcher.rb index eac4ccaf01..cb22e1f1b1 100644 --- a/lib/rubygems/remote_fetcher.rb +++ b/lib/rubygems/remote_fetcher.rb @@ -16,7 +16,7 @@ class Gem::RemoteFetcher # Cached RemoteFetcher instance. def self.fetcher - @fetcher ||= new Gem.configuration[:http_proxy] + @fetcher ||= self.new Gem.configuration[:http_proxy] end # Initialize a remote fetcher using the source URI and possible proxy @@ -45,8 +45,12 @@ class Gem::RemoteFetcher end rescue Timeout::Error raise FetchError, "timed out fetching #{uri}" - rescue OpenURI::HTTPError, IOError, SocketError, SystemCallError => e + rescue IOError, SocketError, SystemCallError => e raise FetchError, "#{e.class}: #{e} reading #{uri}" + rescue OpenURI::HTTPError => e + body = e.io.readlines.join "\n\t" + message = "#{e.class}: #{e} reading #{uri}\n\t#{body}" + raise FetchError, message end # Returns the size of +uri+ in bytes. @@ -79,7 +83,7 @@ class Gem::RemoteFetcher end rescue SocketError, SystemCallError, Timeout::Error => e - raise FetchError, "#{e.message} (#{e.class})" + raise FetchError, "#{e.message} (#{e.class})\n\tgetting size of #{uri}" end private diff --git a/lib/rubygems/remote_installer.rb b/lib/rubygems/remote_installer.rb deleted file mode 100644 index e33fd548f2..0000000000 --- a/lib/rubygems/remote_installer.rb +++ /dev/null @@ -1,195 +0,0 @@ -#-- -# Copyright 2006 by Chad Fowler, Rich Kilmer, Jim Weirich and others. -# All rights reserved. -# See LICENSE.txt for permissions. -#++ - -require 'fileutils' - -require 'rubygems' -require 'rubygems/installer' -require 'rubygems/source_info_cache' - -module Gem - - class RemoteInstaller - - include UserInteraction - - # options[:http_proxy]:: - # * [String]: explicit specification of proxy; overrides any - # environment variable setting - # * nil: respect environment variables (HTTP_PROXY, HTTP_PROXY_USER, HTTP_PROXY_PASS) - # * :no_proxy: ignore environment variables and _don't_ - # use a proxy - # - # * :cache_dir: override where downloaded gems are cached. - def initialize(options={}) - @options = options - @source_index_hash = nil - end - - # This method will install package_name onto the local system. - # - # gem_name:: - # [String] Name of the Gem to install - # - # version_requirement:: - # [default = ">= 0"] Gem version requirement to install - # - # Returns:: - # an array of Gem::Specification objects, one for each gem installed. - # - def install(gem_name, version_requirement = Gem::Requirement.default, - force = false, install_dir = Gem.dir) - unless version_requirement.respond_to?(:satisfied_by?) - version_requirement = Gem::Requirement.new [version_requirement] - end - installed_gems = [] - begin - spec, source = find_gem_to_install(gem_name, version_requirement) - dependencies = find_dependencies_not_installed(spec.dependencies) - - installed_gems << install_dependencies(dependencies, force, install_dir) - - cache_dir = @options[:cache_dir] || File.join(install_dir, "cache") - destination_file = File.join(cache_dir, spec.full_name + ".gem") - - download_gem(destination_file, source, spec) - - installer = new_installer(destination_file) - installed_gems.unshift installer.install(force, install_dir) - rescue RemoteInstallationSkipped => e - alert_error e.message - end - installed_gems.flatten - end - - # Return a hash mapping the available source names to the source - # index of that source. - def source_index_hash - return @source_index_hash if @source_index_hash - @source_index_hash = {} - Gem::SourceInfoCache.cache_data.each do |source_uri, sic_entry| - @source_index_hash[source_uri] = sic_entry.source_index - end - @source_index_hash - end - - # Finds the Gem::Specification objects and the corresponding source URI - # for gems matching +gem_name+ and +version_requirement+ - def specs_n_sources_matching(gem_name, version_requirement) - specs_n_sources = [] - - source_index_hash.each do |source_uri, source_index| - specs = source_index.search(/^#{Regexp.escape gem_name}$/i, - version_requirement) - # TODO move to SourceIndex#search? - ruby_version = Gem::Version.new RUBY_VERSION - specs = specs.select do |spec| - spec.required_ruby_version.nil? or - spec.required_ruby_version.satisfied_by? ruby_version - end - specs.each { |spec| specs_n_sources << [spec, source_uri] } - end - - if specs_n_sources.empty? then - raise GemNotFoundException, "Could not find #{gem_name} (#{version_requirement}) in any repository" - end - - specs_n_sources = specs_n_sources.sort_by { |gs,| gs.version }.reverse - - specs_n_sources - end - - # Find a gem to be installed by interacting with the user. - def find_gem_to_install(gem_name, version_requirement) - specs_n_sources = specs_n_sources_matching gem_name, version_requirement - - top_3_versions = specs_n_sources.map{|gs| gs.first.version}.uniq[0..3] - specs_n_sources.reject!{|gs| !top_3_versions.include?(gs.first.version)} - - binary_gems = specs_n_sources.reject { |item| - item[0].platform.nil? || item[0].platform==Platform::RUBY - } - - # only non-binary gems...return latest - return specs_n_sources.first if binary_gems.empty? - - list = specs_n_sources.collect { |spec, source_uri| - "#{spec.name} #{spec.version} (#{spec.platform})" - } - - list << "Skip this gem" - list << "Cancel installation" - - string, index = choose_from_list( - "Select which gem to install for your platform (#{RUBY_PLATFORM})", - list) - - if index.nil? or index == (list.size - 1) then - raise RemoteInstallationCancelled, "Installation of #{gem_name} cancelled." - end - - if index == (list.size - 2) then - raise RemoteInstallationSkipped, "Installation of #{gem_name} skipped." - end - - specs_n_sources[index] - end - - def find_dependencies_not_installed(dependencies) - to_install = [] - dependencies.each do |dependency| - srcindex = Gem::SourceIndex.from_installed_gems - matches = srcindex.find_name(dependency.name, dependency.requirement_list) - to_install.push dependency if matches.empty? - end - to_install - end - - # Install all the given dependencies. Returns an array of - # Gem::Specification objects, one for each dependency installed. - # - # TODO: For now, we recursively install, but this is not the right - # 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 |dep| - if @options[:include_dependencies] || - ask_yes_no("Install required dependency #{dep.name}?", true) - remote_installer = RemoteInstaller.new @options - installed_gems << remote_installer.install(dep.name, - dep.version_requirements, - force, install_dir) - elsif force then - # ignore - else - raise DependencyError, "Required dependency #{dep.name} not installed" - end - end - installed_gems - end - - def download_gem(destination_file, source, spec) - return if File.exist? destination_file - uri = source + "/gems/#{spec.full_name}.gem" - response = Gem::RemoteFetcher.fetcher.fetch_path uri - write_gem_to_file response, destination_file - end - - def write_gem_to_file(body, destination_file) - FileUtils.mkdir_p(File.dirname(destination_file)) unless File.exist?(destination_file) - File.open(destination_file, 'wb') do |out| - out.write(body) - end - end - - def new_installer(gem) - return Installer.new(gem, @options) - end - end - -end diff --git a/lib/rubygems/rubygems_version.rb b/lib/rubygems/rubygems_version.rb index d08789baf6..85e18d48a4 100644 --- a/lib/rubygems/rubygems_version.rb +++ b/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.9.5' + RubyGemsVersion = '1.0.0' end diff --git a/lib/rubygems/security.rb b/lib/rubygems/security.rb index 6f6586e9cf..415e98ffc0 100644 --- a/lib/rubygems/security.rb +++ b/lib/rubygems/security.rb @@ -318,7 +318,7 @@ require 'rubygems/gem_openssl' module Gem::Security - class Exception < Exception; end + class Exception < Gem::Exception; end # # default options for most of the methods below diff --git a/lib/rubygems/server.rb b/lib/rubygems/server.rb index 212ccc5f7e..ed957dd38a 100644 --- a/lib/rubygems/server.rb +++ b/lib/rubygems/server.rb @@ -368,19 +368,34 @@ div.method-source-code pre { color: #ffdead; overflow: hidden; } when '/quick/index.rz' then index = @source_index.map { |name,_| name }.join("\n") res.body << Zlib::Deflate.deflate(index) - when %r|^/quick/(.*)-([0-9.]+)\.gemspec(\.marshal)?\.rz$| then - specs = @source_index.search $1, $2 + when %r|^/quick/(Marshal.#{Regexp.escape Gem.marshal_version}/)?(.*?)-([0-9.]+)(-.*?)?\.gemspec\.rz$| then + dep = Gem::Dependency.new $2, $3 + specs = @source_index.search dep + + selector = [$2, $3, $4].map { |s| s.inspect }.join ' ' + + platform = if $4 then + Gem::Platform.new $4.sub(/^-/, '') + else + Gem::Platform::RUBY + end + + specs = specs.select { |s| s.platform == platform } + if specs.empty? then res.status = 404 + res.body = "No gems found matching #{selector}" elsif specs.length > 1 then res.status = 500 - elsif $3 # marshal quickindex instead of YAML + res.body = "Multiple gems found matching #{selector}" + elsif $1 then # marshal quickindex instead of YAML res.body << Zlib::Deflate.deflate(Marshal.dump(specs.first)) else # deprecated YAML format res.body << Zlib::Deflate.deflate(specs.first.to_yaml) end else res.status = 404 + res.body = "#{req.request_uri} not found" end end diff --git a/lib/rubygems/source_index.rb b/lib/rubygems/source_index.rb index 759718d45c..2df28d9561 100644 --- a/lib/rubygems/source_index.rb +++ b/lib/rubygems/source_index.rb @@ -4,8 +4,6 @@ # See LICENSE.txt for permissions. #++ -require 'forwardable' - require 'rubygems' require 'rubygems/user_interaction' require 'rubygems/specification' @@ -23,7 +21,6 @@ module Gem # YAMLized source index objects to load properly. # class SourceIndex - extend Forwardable include Enumerable @@ -186,40 +183,40 @@ module Gem Gem::SHA256.new.hexdigest(@gems[gem_full_name].to_yaml).to_s end - def_delegators :@gems, :size, :length + def size + @gems.size + end + alias length size # Find a gem by an exact match on the short name. def find_name(gem_name, version_requirement = Gem::Requirement.default) search(/^#{gem_name}$/, version_requirement) end - # Search for a gem by short name pattern and optional version - # - # gem_name:: - # [String] a partial for the (short) name of the gem, or - # [Regex] a pattern to match against the short name - # version_requirement:: - # [String | default=Gem::Requirement.default] version to - # find - # return:: - # [Array] list of Gem::Specification objects in sorted (version) - # order. Empty if not found. + # Search for a gem by Gem::Dependency +gem_pattern+. If +only_platform+ + # is true, only gems matching Gem::Platform.local will be returned. An + # Array of matching Gem::Specification objects is returned. # - def search(gem_pattern, platform_only_or_version_req = false) + # For backwards compatibility, a String or Regexp pattern may be passed as + # +gem_pattern+, and a Gem::Requirement for +platform_only+. This + # behavior is deprecated and will be removed. + def search(gem_pattern, platform_only = false) version_requirement = nil only_platform = false - case gem_pattern + case gem_pattern # TODO warn after 2008/03, remove three months after when Regexp then - version_requirement = platform_only_or_version_req || - Gem::Requirement.default + version_requirement = platform_only || Gem::Requirement.default when Gem::Dependency then - only_platform = platform_only_or_version_req + only_platform = platform_only version_requirement = gem_pattern.version_requirements - gem_pattern = gem_pattern.name.empty? ? // : /^#{gem_pattern.name}$/ + gem_pattern = if gem_pattern.name.empty? then + // + else + /^#{Regexp.escape gem_pattern.name}$/ + end else - version_requirement = platform_only_or_version_req || - Gem::Requirement.default + version_requirement = platform_only || Gem::Requirement.default gem_pattern = /#{gem_pattern}/i end diff --git a/lib/rubygems/source_info_cache.rb b/lib/rubygems/source_info_cache.rb index 0498e895a4..c84868a5f5 100644 --- a/lib/rubygems/source_info_cache.rb +++ b/lib/rubygems/source_info_cache.rb @@ -176,7 +176,7 @@ class Gem::SourceInfoCache # The name of the system cache file. (class method) def self.system_cache_file - @system_cache_file ||= File.join(Gem.dir, "source_cache") + @system_cache_file ||= Gem.default_system_source_cache_dir end # The name of the user cache file. @@ -187,7 +187,7 @@ class Gem::SourceInfoCache # The name of the user cache file. (class method) def self.user_cache_file @user_cache_file ||= - ENV['GEMCACHE'] || File.join(Gem.user_home, ".gem", "source_cache") + ENV['GEMCACHE'] || Gem.default_user_source_cache_dir end # Write data to the proper cache. @@ -217,7 +217,7 @@ class Gem::SourceInfoCache unless File.exist? dir then begin FileUtils.mkdir_p(dir) - rescue RuntimeError + rescue RuntimeError, SystemCallError return nil end end diff --git a/lib/rubygems/specification.rb b/lib/rubygems/specification.rb index 4a785fa600..35f2ffdffe 100644 --- a/lib/rubygems/specification.rb +++ b/lib/rubygems/specification.rb @@ -4,17 +4,18 @@ # See LICENSE.txt for permissions. #++ -require 'time' require 'rubygems' require 'rubygems/version' require 'rubygems/platform' # :stopdoc: # Time::today has been deprecated in 0.9.5 and will be removed. -def Time.today - t = Time.now - t - ((t.to_i + t.gmt_offset) % 86400) -end unless defined? Time.today +if RUBY_VERSION < '1.9' then + def Time.today + t = Time.now + t - ((t.to_i + t.gmt_offset) % 86400) + end unless defined? Time.today +end # :startdoc: module Gem @@ -239,7 +240,7 @@ module Gem @specification_version, @name, @version, - (Time === @date ? @date : Time.parse(@date.to_s)), + (Time === @date ? @date : (require 'time'; Time.parse(@date.to_s))), @summary, @required_ruby_version, @required_rubygems_version, @@ -293,14 +294,9 @@ module Gem spec end - def warn_deprecated(old, new) - # How (if at all) to implement this? We only want to warn when - # a gem is being built, I should think. - end - # REQUIRED gemspec attributes ------------------------------------ - required_attribute :rubygems_version, RubyGemsVersion + required_attribute :rubygems_version, Gem::RubyGemsVersion required_attribute :specification_version, CURRENT_SPECIFICATION_VERSION required_attribute :name required_attribute :version @@ -349,12 +345,12 @@ module Gem # DEPRECATED gemspec attributes ---------------------------------- def test_suite_file - warn_deprecated(:test_suite_file, :test_files) + warn 'test_suite_file deprecated, use test_files' test_files.first end def test_suite_file=(val) - warn_deprecated(:test_suite_file, :test_files) + warn 'test_suite_file= deprecated, use test_files=' @test_files = [] unless defined? @test_files @test_files << val end @@ -386,6 +382,7 @@ module Gem case platform when Gem::Platform::CURRENT then @new_platform = Gem::Platform.local + @original_platform = @new_platform.to_s when Gem::Platform then @new_platform = platform @@ -393,14 +390,14 @@ module Gem # legacy constants when nil, Gem::Platform::RUBY then @new_platform = Gem::Platform::RUBY - when Gem::Platform::WIN32 then - @new_platform = Gem::Platform::MSWIN32 - when Gem::Platform::LINUX_586 then - @new_platform = Gem::Platform::X86_LINUX - when Gem::Platform::DARWIN then - @new_platform = Gem::Platform::PPC_DARWIN + when 'mswin32' then # was Gem::Platform::WIN32 + @new_platform = Gem::Platform.new 'x86-mswin32' + when 'i586-linux' then # was Gem::Platform::LINUX_586 + @new_platform = Gem::Platform.new 'x86-linux' + when 'powerpc-darwin' then # was Gem::Platform::DARWIN + @new_platform = Gem::Platform.new 'ppc-darwin' else - @new_platform = platform + @new_platform = Gem::Platform.new platform end @platform = @new_platform.to_s @@ -422,11 +419,16 @@ module Gem # way to do it. case date when String then - @date = Time.parse date + @date = if /\A(\d{4})-(\d{2})-(\d{2})\Z/ =~ date then + Time.local($1.to_i, $2.to_i, $3.to_i) + else + require 'time' + Time.parse date + end when Time then - @date = Time.parse date.strftime("%Y-%m-%d") + @date = Time.local(date.year, date.month, date.day) when Date then - @date = Time.parse date.to_s + @date = Time.local(date.year, date.month, date.day) else @date = TODAY end @@ -751,7 +753,10 @@ module Gem out.map taguri, to_yaml_style do |map| map.add 'name', @name map.add 'version', @version - platform = if String === @original_platform then + platform = case @original_platform + when nil, '' then + 'ruby' + when String then @original_platform else @original_platform.to_s @@ -801,13 +806,14 @@ module Gem :version, ] - attributes = @@attributes.sort_by { |name,| name.to_s } + attributes = @@attributes.sort_by { |attr_name,| attr_name.to_s } - attributes.each do |name, default| - next if handled.include? name - current_value = self.send(name) - if current_value != default or self.class.required_attribute? name then - result << " s.#{name} = #{ruby_code current_value}" + attributes.each do |attr_name, default| + next if handled.include? attr_name + current_value = self.send(attr_name) + if current_value != default or + self.class.required_attribute? attr_name then + result << " s.#{attr_name} = #{ruby_code current_value}" end end @@ -832,6 +838,8 @@ module Gem # Raises InvalidSpecificationException if the spec does not pass # the checks.. def validate + extend Gem::UserInteraction + normalize if rubygems_version != RubyGemsVersion then @@ -858,6 +866,31 @@ module Gem "invalid platform #{platform.inspect}, see Gem::Platform" end + unless Array === authors and + authors.all? { |author| String === author } then + raise Gem::InvalidSpecificationException, + 'authors must be Array of Strings' + end + + # Warnings + + %w[author email homepage rubyforge_project summary].each do |attribute| + value = self.send attribute + alert_warning "no #{attribute} specified" if value.nil? or value.empty? + end + + alert_warning "RDoc will not be generated (has_rdoc == false)" unless + has_rdoc + + alert_warning "deprecated autorequire specified" if autorequire + + executables.each do |executable| + executable_path = File.join bindir, executable + shebang = File.read(executable_path, 2) == '#!' + + alert_warning "#{executable_path} is missing #! line" unless shebang + end + true end diff --git a/lib/rubygems/uninstaller.rb b/lib/rubygems/uninstaller.rb index f26de152dd..268c0b3b83 100644 --- a/lib/rubygems/uninstaller.rb +++ b/lib/rubygems/uninstaller.rb @@ -144,7 +144,7 @@ class Gem::Uninstaller cache_dir = File.join spec.installation_path, 'cache' gem = File.join cache_dir, "#{spec.full_name}.gem" - unless File.exist? gemspec then + unless File.exist? gem then gem = File.join cache_dir, "#{original_platform_name}.gem" end diff --git a/lib/rubygems/validator.rb b/lib/rubygems/validator.rb index 8130f49bc8..41c457c3cf 100755 --- a/lib/rubygems/validator.rb +++ b/lib/rubygems/validator.rb @@ -157,8 +157,9 @@ module Gem # XXX: why do we need this gem_spec when we've already got 'spec'? test_files = gem_spec.test_files if test_files.empty? - say "There are no unit tests to run for #{gem_spec.name}-#{gem_spec.version}" - return + say "There are no unit tests to run for #{gem_spec.full_name}" + require 'test/unit/ui/console/testrunner' + return Test::Unit::TestResult.new end gem gem_spec.name, "= #{gem_spec.version.version}" test_files.each do |f| require f end diff --git a/lib/rubygems/version.rb b/lib/rubygems/version.rb index 35dd60a74a..87a1bc72ed 100644 --- a/lib/rubygems/version.rb +++ b/lib/rubygems/version.rb @@ -75,7 +75,7 @@ class Gem::Version # Strip ignored trailing zeros. def normalize - @ints = @version.to_s.scan(/\d+/).map { |s| s.to_i } + @ints = build_array_from_version_string return if @ints.length == 1 @@ -127,19 +127,26 @@ class Gem::Version @ints <=> other.ints end - def hash + alias eql? == # :nodoc: + + def hash # :nodoc: to_ints.inject { |hash_code, n| hash_code + n } end # Return a new version object where the next to the last revision # number is one greater. (e.g. 5.3.1 => 5.4) def bump - ints = @ints.dup + ints = build_array_from_version_string ints.pop if ints.size > 1 ints[-1] += 1 self.class.new(ints.join(".")) end + def build_array_from_version_string + @version.to_s.scan(/\d+/).map { |s| s.to_i } + end + private :build_array_from_version_string + #:stopdoc: require 'rubygems/requirement' diff --git a/test/rubygems/gemutilities.rb b/test/rubygems/gemutilities.rb index bb54ff6362..460d8f2080 100644 --- a/test/rubygems/gemutilities.rb +++ b/test/rubygems/gemutilities.rb @@ -89,6 +89,9 @@ class RubyGemTestCase < Test::Unit::TestCase @gem_repo = "http://gems.example.com" Gem.sources.replace [@gem_repo] + @orig_BASERUBY = Gem::ConfigMap[:BASERUBY] + Gem::ConfigMap[:BASERUBY] = Gem::ConfigMap[:RUBY_INSTALL_NAME] + @orig_arch = Gem::ConfigMap[:arch] if win_platform? @@ -101,6 +104,7 @@ class RubyGemTestCase < Test::Unit::TestCase end def teardown + Gem::ConfigMap[:BASERUBY] = @orig_BASERUBY Gem::ConfigMap[:arch] = @orig_arch if defined? Gem::RemoteFetcher then @@ -153,7 +157,7 @@ class RubyGemTestCase < Test::Unit::TestCase path end - def quick_gem(gemname, version='0.0.2') + def quick_gem(gemname, version='2') require 'rubygems/specification' spec = Gem::Specification.new do |s| @@ -166,6 +170,7 @@ class RubyGemTestCase < Test::Unit::TestCase s.has_rdoc = true s.summary = "this is a summary" s.description = "This is a test description" + yield(s) if block_given? end @@ -205,9 +210,9 @@ class RubyGemTestCase < Test::Unit::TestCase s.require_paths = %w[lib] end - @a0_0_1 = quick_gem('a', '0.0.1', &spec) - @a0_0_2 = quick_gem('a', '0.0.2', &spec) - @b0_0_2 = quick_gem('b', '0.0.2', &spec) + @a1 = quick_gem('a', '1', &spec) + @a2 = quick_gem('a', '2', &spec) + @b2 = quick_gem('b', '2', &spec) @c1_2 = quick_gem('c', '1.2', &spec) @pl1 = quick_gem 'pl', '1' do |s| # l for legacy s.files = %w[lib/code.rb] @@ -216,13 +221,13 @@ class RubyGemTestCase < Test::Unit::TestCase s.instance_variable_set :@original_platform, 'i386-linux' end - write_file File.join(*%W[gems #{@a0_0_1.original_name} lib code.rb]) do end - write_file File.join(*%W[gems #{@a0_0_2.original_name} lib code.rb]) do end - write_file File.join(*%W[gems #{@b0_0_2.original_name} lib code.rb]) do end + write_file File.join(*%W[gems #{@a1.original_name} lib code.rb]) do end + write_file File.join(*%W[gems #{@a2.original_name} lib code.rb]) do end + write_file File.join(*%W[gems #{@b2.original_name} lib code.rb]) do end write_file File.join(*%W[gems #{@c1_2.original_name} lib code.rb]) do end write_file File.join(*%W[gems #{@pl1.original_name} lib code.rb]) do end - [@a0_0_1, @a0_0_2, @b0_0_2, @c1_2, @pl1].each { |spec| util_build_gem spec } + [@a1, @a2, @b2, @c1_2, @pl1].each { |spec| util_build_gem spec } FileUtils.rm_r File.join(@gemhome, 'gems', @pl1.original_name) diff --git a/test/rubygems/test_gem.rb b/test/rubygems/test_gem.rb index 4fe5e8661c..c5ed86a489 100644 --- a/test/rubygems/test_gem.rb +++ b/test/rubygems/test_gem.rb @@ -2,6 +2,7 @@ require 'test/unit' require File.join(File.expand_path(File.dirname(__FILE__)), 'gemutilities') require 'rubygems' require 'rubygems/gem_openssl' +require 'rubygems/installer' require 'pathname' class TestGem < RubyGemTestCase @@ -17,9 +18,9 @@ class TestGem < RubyGemTestCase util_make_gems expected = [ - File.join(@gemhome, *%W[gems #{@a0_0_1.full_name} lib]), - File.join(@gemhome, *%W[gems #{@a0_0_2.full_name} lib]), - File.join(@gemhome, *%W[gems #{@b0_0_2.full_name} lib]), + File.join(@gemhome, *%W[gems #{@a1.full_name} lib]), + File.join(@gemhome, *%W[gems #{@a2.full_name} lib]), + File.join(@gemhome, *%W[gems #{@b2.full_name} lib]), File.join(@gemhome, *%W[gems #{@c1_2.full_name} lib]), File.join(@gemhome, *%W[gems #{@pl1.full_name} lib]), ] @@ -89,6 +90,42 @@ class TestGem < RubyGemTestCase assert_match @default_dir_re, Gem.default_dir end + def test_self_default_exec_format + orig_BASERUBY = Gem::ConfigMap[:BASERUBY] + orig_RUBY_INSTALL_NAME = Gem::ConfigMap[:RUBY_INSTALL_NAME] + Gem::ConfigMap[:BASERUBY] = 'ruby' + Gem::ConfigMap[:RUBY_INSTALL_NAME] = 'ruby' + + assert_equal '%s', Gem.default_exec_format + ensure + Gem::ConfigMap[:BASERUBY] = orig_BASERUBY + Gem::ConfigMap[:RUBY_INSTALL_NAME] = orig_RUBY_INSTALL_NAME + end + + def test_self_default_exec_format_18 + orig_BASERUBY = Gem::ConfigMap[:BASERUBY] + orig_RUBY_INSTALL_NAME = Gem::ConfigMap[:RUBY_INSTALL_NAME] + Gem::ConfigMap[:BASERUBY] = 'ruby' + Gem::ConfigMap[:RUBY_INSTALL_NAME] = 'ruby18' + + assert_equal '%s18', Gem.default_exec_format + ensure + Gem::ConfigMap[:BASERUBY] = orig_BASERUBY + Gem::ConfigMap[:RUBY_INSTALL_NAME] = orig_RUBY_INSTALL_NAME + end + + def test_self_default_exec_format_jruby + orig_BASERUBY = Gem::ConfigMap[:BASERUBY] + orig_RUBY_INSTALL_NAME = Gem::ConfigMap[:RUBY_INSTALL_NAME] + Gem::ConfigMap[:BASERUBY] = 'ruby' + Gem::ConfigMap[:RUBY_INSTALL_NAME] = 'jruby' + + assert_equal 'j%s', Gem.default_exec_format + ensure + Gem::ConfigMap[:BASERUBY] = orig_BASERUBY + Gem::ConfigMap[:RUBY_INSTALL_NAME] = orig_RUBY_INSTALL_NAME + end + def test_self_default_sources assert_equal %w[http://gems.rubyforge.org], Gem.default_sources end @@ -174,8 +211,8 @@ class TestGem < RubyGemTestCase util_make_gems expected = [ - File.join(@gemhome, *%W[gems #{@a0_0_2.full_name} lib]), - File.join(@gemhome, *%W[gems #{@b0_0_2.full_name} lib]), + File.join(@gemhome, *%W[gems #{@a2.full_name} lib]), + File.join(@gemhome, *%W[gems #{@b2.full_name} lib]), File.join(@gemhome, *%W[gems #{@c1_2.full_name} lib]), File.join(@gemhome, *%W[gems #{@pl1.full_name} lib]), ] @@ -251,10 +288,10 @@ class TestGem < RubyGemTestCase assert_equal File.join(@tempdir, *%w[gemhome gems c-1.2 lib code.rb]), Gem.required_location("c", "code.rb") - assert_equal File.join(@tempdir, *%w[gemhome gems a-0.0.1 lib code.rb]), - Gem.required_location("a", "code.rb", "<0.0.2") - assert_equal File.join(@tempdir, *%w[gemhome gems a-0.0.2 lib code.rb]), - Gem.required_location("a", "code.rb", "=0.0.2") + assert_equal File.join(@tempdir, *%w[gemhome gems a-1 lib code.rb]), + Gem.required_location("a", "code.rb", "< 2") + assert_equal File.join(@tempdir, *%w[gemhome gems a-2 lib code.rb]), + Gem.required_location("a", "code.rb", "= 2") end def test_self_searcher @@ -298,73 +335,6 @@ class TestGem < RubyGemTestCase end end - def test_require_gem_autorequire - name = "AutorequireArray" - files = %w(a.rb b.rb) - gem = quick_gem(name) do |s| - s.files = files.map { |f| File.join("lib", f) } - s.autorequire = files - end - - fullname = gem.full_name - - write_file "gems/#{fullname}/lib/a.rb" do |io| - io.puts "$LOADED_A = true" - end - - write_file "gems/#{fullname}/lib/b.rb" do |io| - io.puts "$LOADED_B = true" - end - - Gem.source_index = nil - - old_loaded = $".dup - old_verbose = $VERBOSE - $VERBOSE = nil - require_gem name - $VERBOSE = old_verbose - new_loaded = $".dup - - if RUBY_VERSION > "1.9" then - files = files.map do |file| - File.join @gemhome, 'gems', gem.full_name, 'lib', file - end - end - - assert_equal files, (new_loaded - old_loaded) - assert defined?($LOADED_A) - assert defined?($LOADED_B) - end - - def test_require_gem_autorequire_string - name = "AutorequireString" - file = "c.rb" - gem = quick_gem(name) do |s| - s.files = File.join("lib", file) - s.autorequire = file - end - - fullname = gem.full_name - - write_file("gems/#{fullname}/lib/c.rb") do |io| - io.puts "$LOADED_C = true" - end - - old_loaded = $".dup - old_verbose = $VERBOSE - $VERBOSE = nil - require_gem name - $VERBOSE = old_verbose - new_loaded = $".dup - - if RUBY_VERSION > "1.9" then - file = File.join @gemhome, 'gems', gem.full_name, 'lib', file - end - - assert_equal(Array(file), (new_loaded - old_loaded)) - assert(defined? $LOADED_C) - end - def util_ensure_gem_dirs Gem.ensure_gem_subdirectories @gemhome @additional.each do |dir| diff --git a/test/rubygems/test_gem_commands_build_command.rb b/test/rubygems/test_gem_commands_build_command.rb index f1fd1503ba..a49b6777bd 100644 --- a/test/rubygems/test_gem_commands_build_command.rb +++ b/test/rubygems/test_gem_commands_build_command.rb @@ -8,31 +8,31 @@ class TestGemCommandsBuildCommand < RubyGemTestCase def setup super + @gem = quick_gem 'some_gem' do |s| + s.rubyforge_project = 'example' + end + @cmd = Gem::Commands::BuildCommand.new end def test_execute - gem = quick_gem 'some_gem' - - gemspec_file = File.join(@tempdir, "#{gem.full_name}.gemspec") + gemspec_file = File.join(@tempdir, "#{@gem.full_name}.gemspec") File.open gemspec_file, 'w' do |gs| - gs.write gem.to_ruby + gs.write @gem.to_ruby end - util_test_build_gem gem, gemspec_file + util_test_build_gem @gem, gemspec_file end def test_execute_yaml - gem = quick_gem 'some_gem' - - gemspec_file = File.join(@tempdir, "#{gem.full_name}.gemspec") + gemspec_file = File.join(@tempdir, "#{@gem.full_name}.gemspec") File.open gemspec_file, 'w' do |gs| - gs.write gem.to_yaml + gs.write @gem.to_yaml end - util_test_build_gem gem, gemspec_file + util_test_build_gem @gem, gemspec_file end def test_execute_bad_gem @@ -57,8 +57,8 @@ class TestGemCommandsBuildCommand < RubyGemTestCase output = @ui.output.split "\n" assert_equal " Successfully built RubyGem", output.shift assert_equal " Name: some_gem", output.shift - assert_equal " Version: 0.0.2", output.shift - assert_equal " File: some_gem-0.0.2.gem", output.shift + assert_equal " Version: 2", output.shift + assert_equal " File: some_gem-2.gem", output.shift assert_equal [], output assert_equal '', @ui.error diff --git a/test/rubygems/test_gem_commands_dependency_command.rb b/test/rubygems/test_gem_commands_dependency_command.rb index 9bf59537fd..0f0d95695d 100644 --- a/test/rubygems/test_gem_commands_dependency_command.rb +++ b/test/rubygems/test_gem_commands_dependency_command.rb @@ -13,7 +13,7 @@ class TestGemCommandsDependencyCommand < RubyGemTestCase def test_execute quick_gem 'foo' do |gem| - gem.add_dependency 'bar', '> 1.0.0' + gem.add_dependency 'bar', '> 1' end @cmd.options[:args] = %w[foo] @@ -22,7 +22,7 @@ class TestGemCommandsDependencyCommand < RubyGemTestCase @cmd.execute end - assert_equal "Gem foo-0.0.2\n bar (> 1.0.0)\n\n", @ui.output + assert_equal "Gem foo-2\n bar (> 1)\n\n", @ui.output assert_equal '', @ui.error end @@ -41,7 +41,7 @@ class TestGemCommandsDependencyCommand < RubyGemTestCase def test_execute_pipe_format quick_gem 'foo' do |gem| - gem.add_dependency 'bar', '> 1.0.0' + gem.add_dependency 'bar', '> 1' end @cmd.options[:args] = %w[foo] @@ -51,13 +51,13 @@ class TestGemCommandsDependencyCommand < RubyGemTestCase @cmd.execute end - assert_equal "bar --version '> 1.0.0'\n", @ui.output + assert_equal "bar --version '> 1'\n", @ui.output assert_equal '', @ui.error end def test_execute_reverse quick_gem 'foo' do |gem| - gem.add_dependency 'bar', '> 1.0.0' + gem.add_dependency 'bar', '> 1' end quick_gem 'baz' do |gem| @@ -72,10 +72,10 @@ class TestGemCommandsDependencyCommand < RubyGemTestCase end expected = <<-EOF -Gem foo-0.0.2 - bar (> 1.0.0) +Gem foo-2 + bar (> 1) Used by - baz-0.0.2 (foo (>= 0)) + baz-2 (foo (>= 0)) EOF @@ -85,7 +85,7 @@ Gem foo-0.0.2 def test_execute_remote foo = quick_gem 'foo' do |gem| - gem.add_dependency 'bar', '> 1.0.0' + gem.add_dependency 'bar', '> 1' end util_setup_source_info_cache foo @@ -100,7 +100,7 @@ Gem foo-0.0.2 @cmd.execute end - assert_equal "Gem foo-0.0.2\n bar (> 1.0.0)\n\n", @ui.output + assert_equal "Gem foo-2\n bar (> 1)\n\n", @ui.output assert_equal '', @ui.error end diff --git a/test/rubygems/test_gem_commands_mirror_command.rb b/test/rubygems/test_gem_commands_mirror_command.rb index 7ddc8b92f8..359ba5481e 100644 --- a/test/rubygems/test_gem_commands_mirror_command.rb +++ b/test/rubygems/test_gem_commands_mirror_command.rb @@ -34,7 +34,12 @@ class TestGemCommandsMirrorCommand < RubyGemTestCase File.open File.join(Gem.user_home, '.gemmirrorrc'), 'w' do |fp| fp.puts "---" - fp.puts "- from: file://#{@tempdir}" + # tempdir could be a drive+path (under windows) + if @tempdir.match(/[a-z]:/i) + fp.puts "- from: file:///#{@tempdir}" + else + fp.puts "- from: file://#{@tempdir}" + end fp.puts " to: #{mirror}" end @@ -42,9 +47,9 @@ class TestGemCommandsMirrorCommand < RubyGemTestCase @cmd.execute end - assert File.exist?(File.join(mirror, 'gems', "#{@a0_0_1.full_name}.gem")) - assert File.exist?(File.join(mirror, 'gems', "#{@a0_0_2.full_name}.gem")) - assert File.exist?(File.join(mirror, 'gems', "#{@b0_0_2.full_name}.gem")) + assert File.exist?(File.join(mirror, 'gems', "#{@a1.full_name}.gem")) + assert File.exist?(File.join(mirror, 'gems', "#{@a2.full_name}.gem")) + assert File.exist?(File.join(mirror, 'gems', "#{@b2.full_name}.gem")) assert File.exist?(File.join(mirror, 'gems', "#{@c1_2.full_name}.gem")) assert File.exist?(File.join(mirror, "Marshal.#{@marshal_version}")) ensure diff --git a/test/rubygems/test_gem_commands_query_command.rb b/test/rubygems/test_gem_commands_query_command.rb index e2b6a45e92..4430ccfd33 100644 --- a/test/rubygems/test_gem_commands_query_command.rb +++ b/test/rubygems/test_gem_commands_query_command.rb @@ -10,13 +10,17 @@ class TestGemCommandsQueryCommand < RubyGemTestCase @foo_gem = quick_gem 'foo' do |spec| spec.summary = 'This is a lot of text. ' * 5 end + @foo_gem_p = quick_gem 'foo' do |spec| + spec.summary = 'This is a lot of text. ' * 5 + spec.platform = Gem::Platform::CURRENT + end @bar_gem = quick_gem 'bar' @cmd = Gem::Commands::QueryCommand.new end def test_execute - util_setup_source_info_cache @foo_gem + util_setup_source_info_cache @foo_gem, @foo_gem_p @cmd.handle_options %w[-r] @@ -28,7 +32,7 @@ class TestGemCommandsQueryCommand < RubyGemTestCase *** REMOTE GEMS *** -foo (0.0.2) +foo (2) EOF assert_equal expected, @ui.output @@ -48,7 +52,7 @@ foo (0.0.2) *** REMOTE GEMS *** -foo (0.0.2) +foo (2) This is a lot of text. This is a lot of text. This is a lot of text. This is a lot of text. This is a lot of text. EOF diff --git a/test/rubygems/test_gem_commands_server_command.rb b/test/rubygems/test_gem_commands_server_command.rb new file mode 100644 index 0000000000..3e6af2e11c --- /dev/null +++ b/test/rubygems/test_gem_commands_server_command.rb @@ -0,0 +1,27 @@ +require 'test/unit' +require File.join(File.expand_path(File.dirname(__FILE__)), 'gemutilities') +require 'rubygems/commands/server_command' + +class TestGemCommandsServerCommand < RubyGemTestCase + + def setup + super + + @cmd = Gem::Commands::ServerCommand.new + end + + def test_handle_options + @cmd.send :handle_options, %w[-p 8808 --no-daemon] + + assert_equal false, @cmd.options[:daemon] + assert_equal @gemhome, @cmd.options[:gemdir] + assert_equal 8808, @cmd.options[:port] + + @cmd.send :handle_options, %w[-p 9999 -d /nonexistent --daemon] + + assert_equal true, @cmd.options[:daemon] + assert_equal '/nonexistent', @cmd.options[:gemdir] + assert_equal 9999, @cmd.options[:port] + end +end + diff --git a/test/rubygems/test_gem_commands_unpack_command.rb b/test/rubygems/test_gem_commands_unpack_command.rb index ff3d4e0eae..427f9403c3 100644 --- a/test/rubygems/test_gem_commands_unpack_command.rb +++ b/test/rubygems/test_gem_commands_unpack_command.rb @@ -7,7 +7,9 @@ class TestGemCommandsUnpackCommand < RubyGemTestCase def setup super - @cmd = Gem::Commands::UnpackCommand.new + Dir.chdir @tempdir do + @cmd = Gem::Commands::UnpackCommand.new + end end def test_execute @@ -15,13 +17,29 @@ class TestGemCommandsUnpackCommand < RubyGemTestCase @cmd.options[:args] = %w[a] + use_ui @ui do + Dir.chdir @tempdir do + @cmd.execute + end + end + + assert File.exist?(File.join(@tempdir, 'a-2')) + end + + def test_execute_with_target_option + util_make_gems + + target = 'with_target' + @cmd.options[:args] = %w[a] + @cmd.options[:target] = target + use_ui @ui do Dir.chdir @tempdir do @cmd.execute end end - assert File.exist?(File.join(@tempdir, 'a-0.0.2')) + assert File.exist?(File.join(@tempdir, target, 'a-2')) end def test_execute_exact_match diff --git a/test/rubygems/test_gem_format.rb b/test/rubygems/test_gem_format.rb index 6bc7a42e81..35eee6bae2 100644 --- a/test/rubygems/test_gem_format.rb +++ b/test/rubygems/test_gem_format.rb @@ -22,7 +22,7 @@ class TestGemFormat < RubyGemTestCase gems = Dir[File.join(@gemhome, 'cache', '*.gem')] - names = [@a0_0_1, @a0_0_2, @b0_0_2, @c1_2, @pl1].map do |spec| + names = [@a1, @a2, @b2, @c1_2, @pl1].map do |spec| spec.original_name end diff --git a/test/rubygems/test_gem_indexer.rb b/test/rubygems/test_gem_indexer.rb index 116a29c562..9eb78500c9 100644 --- a/test/rubygems/test_gem_indexer.rb +++ b/test/rubygems/test_gem_indexer.rb @@ -53,16 +53,16 @@ class TestGemIndexer < RubyGemTestCase assert_indexed quickdir, "index" assert_indexed quickdir, "index.rz" - assert_indexed quickdir, "#{@a0_0_1.full_name}.gemspec.rz" - assert_indexed quickdir, "#{@a0_0_2.full_name}.gemspec.rz" - assert_indexed quickdir, "#{@b0_0_2.full_name}.gemspec.rz" + assert_indexed quickdir, "#{@a1.full_name}.gemspec.rz" + assert_indexed quickdir, "#{@a2.full_name}.gemspec.rz" + assert_indexed quickdir, "#{@b2.full_name}.gemspec.rz" assert_indexed quickdir, "#{@c1_2.full_name}.gemspec.rz" assert_indexed quickdir, "#{@pl1.original_name}.gemspec.rz" deny_indexed quickdir, "#{@pl1.full_name}.gemspec.rz" - assert_indexed marshal_quickdir, "#{@a0_0_1.full_name}.gemspec.rz" - assert_indexed marshal_quickdir, "#{@a0_0_2.full_name}.gemspec.rz" + assert_indexed marshal_quickdir, "#{@a1.full_name}.gemspec.rz" + assert_indexed marshal_quickdir, "#{@a2.full_name}.gemspec.rz" deny_indexed quickdir, "#{@c1_2.full_name}.gemspec" deny_indexed marshal_quickdir, "#{@c1_2.full_name}.gemspec" diff --git a/test/rubygems/test_gem_install_update_options.rb b/test/rubygems/test_gem_install_update_options.rb index dafdf65920..8c7a5ce3f7 100644 --- a/test/rubygems/test_gem_install_update_options.rb +++ b/test/rubygems/test_gem_install_update_options.rb @@ -16,7 +16,7 @@ class TestGemInstallUpdateOptions < RubyGemTestCase @cmd.add_install_update_options args = %w[-i /install_to --rdoc --ri -E -f -t -w -P HighSecurity - --ignore-dependencies --include-dependencies] + --ignore-dependencies --format-exec --include-dependencies] assert @cmd.handles?(args) end diff --git a/test/rubygems/test_gem_installer.rb b/test/rubygems/test_gem_installer.rb index 9a091a291e..442ed6cfc3 100644 --- a/test/rubygems/test_gem_installer.rb +++ b/test/rubygems/test_gem_installer.rb @@ -9,11 +9,13 @@ require File.join(File.expand_path(File.dirname(__FILE__)), 'gemutilities') require 'rubygems/installer' class Gem::Installer + attr_accessor :gem_dir + attr_writer :format - attr_writer :gem_dir attr_writer :gem_home attr_writer :env_shebang attr_writer :ignore_dependencies + attr_writer :format_executable attr_writer :security_policy attr_writer :spec attr_writer :wrappers @@ -37,11 +39,11 @@ class TestGemInstaller < RubyGemTestCase @installer.spec = @spec end - def util_gem_dir(version = '0.0.2') + def util_gem_dir(version = '2') File.join @gemhome, "gems", "a-#{version}" # HACK end - def util_gem_bindir(version = '0.0.2') + def util_gem_bindir(version = '2') File.join util_gem_dir(version), "bin" end @@ -49,18 +51,19 @@ class TestGemInstaller < RubyGemTestCase File.join @gemhome, "bin" end - def util_make_exec(version = '0.0.2', shebang = "#!/usr/bin/ruby") + def util_make_exec(version = '2', shebang = "#!/usr/bin/ruby") @spec.executables = ["my_exec"] FileUtils.mkdir_p util_gem_bindir(version) - exec_file = File.join(util_gem_bindir(version), "my_exec") - File.open exec_file, 'w' do |f| + exec_file = @installer.formatted_program_filename "my_exec" + exec_path = File.join util_gem_bindir(version), exec_file + File.open exec_path, 'w' do |f| f.puts shebang end end def test_app_script_text - util_make_exec '0.0.2', '' + util_make_exec '2', '' expected = <<-EOF #!#{Gem.ruby} @@ -144,15 +147,15 @@ load 'my_exec' end def test_ensure_dependency - dep = Gem::Dependency.new 'a', '>= 0.0.2' + dep = Gem::Dependency.new 'a', '>= 2' assert @installer.ensure_dependency(@spec, dep) - dep = Gem::Dependency.new 'b', '> 0.0.2' + dep = Gem::Dependency.new 'b', '> 2' e = assert_raise Gem::InstallError do @installer.ensure_dependency @spec, dep end - assert_equal 'a requires b (> 0.0.2)', e.message + assert_equal 'a requires b (> 2)', e.message end def test_expand_and_validate_gem_dir @@ -226,7 +229,32 @@ load 'my_exec' "You may need to remove this file if you broke the test once" end - def test_generate_bin_scripts + def test_generate_bin_bindir + @installer.wrappers = true + + @spec.executables = ["my_exec"] + @spec.bindir = '.' + + exec_file = @installer.formatted_program_filename "my_exec" + exec_path = File.join util_gem_dir(@spec.version), exec_file + File.open exec_path, 'w' do |f| + f.puts '#!/usr/bin/ruby' + end + + @installer.gem_dir = util_gem_dir + + @installer.generate_bin + + assert_equal true, File.directory?(util_inst_bindir) + installed_exec = File.join(util_inst_bindir, "my_exec") + assert_equal true, File.exist?(installed_exec) + assert_equal(0100755, File.stat(installed_exec).mode) unless win_platform? + + wrapper = File.read installed_exec + assert_match %r|generated by RubyGems|, wrapper + end + + def test_generate_bin_script @installer.wrappers = true util_make_exec @installer.gem_dir = util_gem_dir @@ -241,7 +269,36 @@ load 'my_exec' assert_match %r|generated by RubyGems|, wrapper end - def test_generate_bin_scripts_install_dir + def test_generate_bin_script_format + @installer.format_executable = true + @installer.wrappers = true + util_make_exec + @installer.gem_dir = util_gem_dir + + Gem::Installer.exec_format = 'foo-%s-bar' + @installer.generate_bin + assert_equal true, File.directory?(util_inst_bindir) + installed_exec = File.join util_inst_bindir, 'foo-my_exec-bar' + assert_equal true, File.exist?(installed_exec) + ensure + Gem::Installer.exec_format = nil + end + + def test_generate_bin_script_format_disabled + @installer.wrappers = true + util_make_exec + @installer.gem_dir = util_gem_dir + + Gem::Installer.exec_format = 'foo-%s-bar' + @installer.generate_bin + assert_equal true, File.directory?(util_inst_bindir) + installed_exec = File.join util_inst_bindir, 'my_exec' + assert_equal true, File.exist?(installed_exec) + ensure + Gem::Installer.exec_format = nil + end + + def test_generate_bin_script_install_dir @installer.wrappers = true @spec.executables = ["my_exec"] @@ -265,13 +322,13 @@ load 'my_exec' assert_match %r|generated by RubyGems|, wrapper end - def test_generate_bin_scripts_no_execs + def test_generate_bin_script_no_execs @installer.wrappers = true @installer.generate_bin assert_equal false, File.exist?(util_inst_bindir) end - def test_generate_bin_scripts_no_perms + def test_generate_bin_script_no_perms @installer.wrappers = true util_make_exec @@ -286,7 +343,30 @@ load 'my_exec' File.chmod 0700, util_inst_bindir unless $DEBUG end - def test_generate_bin_symlinks + def test_generate_bin_script_no_shebang + @installer.wrappers = true + @spec.executables = ["my_exec"] + + gem_dir = File.join @gemhome, 'gems', @spec.full_name + gem_bindir = File.join gem_dir, 'bin' + FileUtils.mkdir_p gem_bindir + File.open File.join(gem_bindir, "my_exec"), 'w' do |f| + f.puts "blah blah blah" + end + + @installer.generate_bin + + installed_exec = File.join @gemhome, 'bin', 'my_exec' + assert_equal true, File.exist?(installed_exec) + assert_equal 0100755, File.stat(installed_exec).mode unless win_platform? + + wrapper = File.read installed_exec + assert_match %r|generated by RubyGems|, wrapper + # HACK some gems don't have #! in their executables, restore 2008/06 + #assert_no_match %r|generated by RubyGems|, wrapper + end + + def test_generate_bin_symlink return if win_platform? #Windows FS do not support symlinks @installer.wrappers = false @@ -301,13 +381,13 @@ load 'my_exec' File.readlink(installed_exec)) end - def test_generate_bin_symlinks_no_execs + def test_generate_bin_symlink_no_execs @installer.wrappers = false @installer.generate_bin assert_equal false, File.exist?(util_inst_bindir) end - def test_generate_bin_symlinks_no_perms + def test_generate_bin_symlink_no_perms @installer.wrappers = false util_make_exec @installer.gem_dir = util_gem_dir @@ -323,7 +403,7 @@ load 'my_exec' File.chmod 0700, util_inst_bindir unless $DEBUG end - def test_generate_bin_symlinks_update_newer + def test_generate_bin_symlink_update_newer return if win_platform? #Windows FS do not support symlinks @installer.wrappers = false @@ -338,22 +418,22 @@ load 'my_exec' @spec = Gem::Specification.new do |s| s.files = ['lib/code.rb'] s.name = "a" - s.version = "0.0.3" + s.version = "3" s.summary = "summary" s.description = "desc" s.require_path = 'lib' end - util_make_exec '0.0.3' - @installer.gem_dir = File.join util_gem_dir('0.0.3') + util_make_exec '3' + @installer.gem_dir = File.join util_gem_dir('3') @installer.generate_bin installed_exec = File.join(util_inst_bindir, "my_exec") - assert_equal(File.join(util_gem_bindir('0.0.3'), "my_exec"), + assert_equal(File.join(util_gem_bindir('3'), "my_exec"), File.readlink(installed_exec), "Ensure symlink moved to latest version") end - def test_generate_bin_symlinks_update_older + def test_generate_bin_symlink_update_older return if win_platform? #Windows FS do not support symlinks @installer.wrappers = false @@ -368,25 +448,25 @@ load 'my_exec' spec = Gem::Specification.new do |s| s.files = ['lib/code.rb'] s.name = "a" - s.version = "0.0.1" + s.version = "1" s.summary = "summary" s.description = "desc" s.require_path = 'lib' end - util_make_exec '0.0.1' - @installer.gem_dir = util_gem_dir('0.0.1') + util_make_exec '1' + @installer.gem_dir = util_gem_dir('1') @installer.spec = spec @installer.generate_bin installed_exec = File.join(util_inst_bindir, "my_exec") - assert_equal(File.join(util_gem_dir('0.0.2'), "bin", "my_exec"), + assert_equal(File.join(util_gem_dir('2'), "bin", "my_exec"), File.readlink(installed_exec), "Ensure symlink not moved") end - def test_generate_bin_symlinks_update_remove_wrapper + def test_generate_bin_symlink_update_remove_wrapper return if win_platform? #Windows FS do not support symlinks @installer.wrappers = true @@ -400,23 +480,23 @@ load 'my_exec' @spec = Gem::Specification.new do |s| s.files = ['lib/code.rb'] s.name = "a" - s.version = "0.0.3" + s.version = "3" s.summary = "summary" s.description = "desc" s.require_path = 'lib' end @installer.wrappers = false - util_make_exec '0.0.3' - @installer.gem_dir = util_gem_dir '0.0.3' + util_make_exec '3' + @installer.gem_dir = util_gem_dir '3' @installer.generate_bin installed_exec = File.join(util_inst_bindir, "my_exec") - assert_equal(File.join(util_gem_dir('0.0.3'), "bin", "my_exec"), + assert_equal(File.join(util_gem_dir('3'), "bin", "my_exec"), File.readlink(installed_exec), "Ensure symlink moved to latest version") end - def test_generate_bin_symlinks_win32 + def test_generate_bin_symlink_win32 old_win_platform = Gem.win_platform? Gem.win_platform = true @installer.wrappers = false @@ -454,6 +534,19 @@ load 'my_exec' assert_match(/#{default_shebang}/, shebang_line) end + def test_initialize + spec = quick_gem 'a' do |s| s.platform = Gem::Platform.new 'mswin32' end + gem = File.join @tempdir, "#{spec.full_name}.gem" + + util_build_gem spec + FileUtils.mv File.join(@gemhome, 'cache', "#{spec.full_name}.gem"), + @tempdir + + installer = Gem::Installer.new gem + + assert_equal File.join(@gemhome, 'gems', spec.full_name), installer.gem_dir + end + def test_install util_setup_gem @@ -518,7 +611,7 @@ load 'my_exec' installer.install end - gem_dir = File.join(@gemhome, 'gems', 'old_ruby_required-0.0.1') + gem_dir = File.join(@gemhome, 'gems', 'old_ruby_required-1') assert File.exist?(gem_dir) end @@ -605,8 +698,8 @@ load 'my_exec' end def test_install_wrong_rubygems_version - spec = quick_gem 'old_rubygems_required', '0.0.1' do |s| - s.required_rubygems_version = '< 0.0.0' + spec = quick_gem 'old_rubygems_required', '1' do |s| + s.required_rubygems_version = '< 0' end util_build_gem spec @@ -618,21 +711,21 @@ load 'my_exec' e = assert_raise Gem::InstallError do @installer.install end - assert_equal 'old_rubygems_required requires RubyGems version < 0.0.0', + assert_equal 'old_rubygems_required requires RubyGems version < 0', e.message end end def test_installation_satisfies_dependency_eh - dep = Gem::Dependency.new 'a', '>= 0.0.2' + dep = Gem::Dependency.new 'a', '>= 2' assert @installer.installation_satisfies_dependency?(dep) - dep = Gem::Dependency.new 'a', '> 0.0.2' + dep = Gem::Dependency.new 'a', '> 2' assert ! @installer.installation_satisfies_dependency?(dep) end def test_shebang - util_make_exec '0.0.2', "#!/usr/bin/ruby" + util_make_exec '2', "#!/usr/bin/ruby" shebang = @installer.shebang 'my_exec' @@ -640,7 +733,7 @@ load 'my_exec' end def test_shebang_arguments - util_make_exec '0.0.2', "#!/usr/bin/ruby -ws" + util_make_exec '2', "#!/usr/bin/ruby -ws" shebang = @installer.shebang 'my_exec' @@ -648,14 +741,14 @@ load 'my_exec' end def test_shebang_empty - util_make_exec '0.0.2', '' + util_make_exec '2', '' shebang = @installer.shebang 'my_exec' assert_equal "#!#{Gem.ruby}", shebang end def test_shebang_env - util_make_exec '0.0.2', "#!/usr/bin/env ruby" + util_make_exec '2', "#!/usr/bin/env ruby" shebang = @installer.shebang 'my_exec' @@ -663,7 +756,7 @@ load 'my_exec' end def test_shebang_env_arguments - util_make_exec '0.0.2', "#!/usr/bin/env ruby -ws" + util_make_exec '2', "#!/usr/bin/env ruby -ws" shebang = @installer.shebang 'my_exec' @@ -671,7 +764,7 @@ load 'my_exec' end def test_shebang_env_shebang - util_make_exec '0.0.2', '' + util_make_exec '2', '' @installer.env_shebang = true shebang = @installer.shebang 'my_exec' @@ -679,7 +772,7 @@ load 'my_exec' end def test_shebang_nested - util_make_exec '0.0.2', "#!/opt/local/ruby/bin/ruby" + util_make_exec '2', "#!/opt/local/ruby/bin/ruby" shebang = @installer.shebang 'my_exec' @@ -687,7 +780,7 @@ load 'my_exec' end def test_shebang_nested_arguments - util_make_exec '0.0.2', "#!/opt/local/ruby/bin/ruby -ws" + util_make_exec '2', "#!/opt/local/ruby/bin/ruby -ws" shebang = @installer.shebang 'my_exec' @@ -695,7 +788,7 @@ load 'my_exec' end def test_shebang_version - util_make_exec '0.0.2', "#!/usr/bin/ruby18" + util_make_exec '2', "#!/usr/bin/ruby18" shebang = @installer.shebang 'my_exec' @@ -703,7 +796,7 @@ load 'my_exec' end def test_shebang_version_arguments - util_make_exec '0.0.2', "#!/usr/bin/ruby18 -ws" + util_make_exec '2', "#!/usr/bin/ruby18 -ws" shebang = @installer.shebang 'my_exec' @@ -711,7 +804,7 @@ load 'my_exec' end def test_shebang_version_env - util_make_exec '0.0.2', "#!/usr/bin/env ruby18" + util_make_exec '2', "#!/usr/bin/env ruby18" shebang = @installer.shebang 'my_exec' @@ -719,7 +812,7 @@ load 'my_exec' end def test_shebang_version_env_arguments - util_make_exec '0.0.2', "#!/usr/bin/env ruby18 -ws" + util_make_exec '2', "#!/usr/bin/env ruby18 -ws" shebang = @installer.shebang 'my_exec' @@ -753,7 +846,7 @@ load 'my_exec' end def old_ruby_required - spec = quick_gem 'old_ruby_required', '0.0.1' do |s| + spec = quick_gem 'old_ruby_required', '1' do |s| s.required_ruby_version = '= 1.4.6' end @@ -790,4 +883,3 @@ load 'my_exec' end - diff --git a/test/rubygems/test_gem_platform.rb b/test/rubygems/test_gem_platform.rb index a1462d4dcd..648c2a9f36 100644 --- a/test/rubygems/test_gem_platform.rb +++ b/test/rubygems/test_gem_platform.rb @@ -5,6 +5,19 @@ require 'rbconfig' class TestGemPlatform < RubyGemTestCase + def test_self_const_missing + consts = [:DARWIN, :LINUX_586, :MSWIN32, :PPC_DARWIN, :WIN32, :X86_LINUX] + + consts.each do |const| + e = assert_raise NameError do + Gem::Platform.const_missing const + end + + assert_equal "#{const} has been removed, use CURRENT instead", + e.message + end + end + def test_self_local util_set_arch 'i686-darwin8.10.1' @@ -60,6 +73,10 @@ class TestGemPlatform < RubyGemTestCase 'i386-mingw32' => ['x86', 'mingw32', nil], 'i386-mswin32' => ['x86', 'mswin32', nil], 'i386-mswin32_80' => ['x86', 'mswin32', '80'], + 'i386-mswin32-80' => ['x86', 'mswin32', '80'], + 'x86-mswin32' => ['x86', 'mswin32', nil], + 'x86-mswin32_60' => ['x86', 'mswin32', '60'], + 'x86-mswin32-60' => ['x86', 'mswin32', '60'], 'i386-netbsdelf' => ['x86', 'netbsdelf', nil], 'i386-openbsd4.0' => ['x86', 'openbsd', '4.0'], 'i386-solaris2.10' => ['x86', 'solaris', '2.10'], diff --git a/test/rubygems/test_gem_remote_fetcher.rb b/test/rubygems/test_gem_remote_fetcher.rb index 83865e8033..fd3843851a 100644 --- a/test/rubygems/test_gem_remote_fetcher.rb +++ b/test/rubygems/test_gem_remote_fetcher.rb @@ -140,11 +140,12 @@ gems: raise SocketError end + uri = 'http://gems.example.com/yaml' e = assert_raise Gem::RemoteFetcher::FetchError do - fetcher.fetch_size 'http://gems.example.com/yaml' + fetcher.fetch_size uri end - assert_equal 'SocketError (SocketError)', e.message + assert_equal "SocketError (SocketError)\n\tgetting size of #{uri}", e.message end def test_no_proxy @@ -231,6 +232,22 @@ gems: assert_equal 'EOFError: EOFError reading uri', e.message end + def test_fetch_path_open_uri_http_error + fetcher = Gem::RemoteFetcher.new nil + + def fetcher.open_uri_or_path(uri) + io = StringIO.new 'went boom' + err = OpenURI::HTTPError.new 'error', io + raise err + end + + e = assert_raise Gem::RemoteFetcher::FetchError do + fetcher.fetch_path 'uri' + end + + assert_equal "OpenURI::HTTPError: error reading uri\n\twent boom", e.message + end + def test_fetch_path_socket_error fetcher = Gem::RemoteFetcher.new nil diff --git a/test/rubygems/test_gem_remote_installer.rb b/test/rubygems/test_gem_remote_installer.rb deleted file mode 100644 index 90d94843bd..0000000000 --- a/test/rubygems/test_gem_remote_installer.rb +++ /dev/null @@ -1,161 +0,0 @@ -#-- -# Copyright 2006 by Chad Fowler, Rich Kilmer, Jim Weirich and others. -# All rights reserved. -# See LICENSE.txt for permissions. -#++ - -require 'test/unit' -require File.join(File.expand_path(File.dirname(__FILE__)), 'gemutilities') -require 'rubygems/remote_installer' - -class MockFetcher - def initialize(uri, proxy) - @uri = uri - @proxy = proxy - end - - def size - 1000 - end - - def source_index - if @uri =~ /non.existent.url/ - fail Gem::RemoteSourceException, - "Error fetching remote gem cache: Mock Socket Exception" - end - result = { - 'foo-1.2.3' => Gem::Specification.new do |s| - s.name = 'foo' - s.version = "1.2.3" - s.summary = "This is a cool package" - end, - 'foo-tools-2.0.0' => Gem::Specification.new do |s| - s.name = 'foo-tools' - s.version = "2.0.0" - s.summary = "This is an even cooler package" - end, - 'foo-2-2.0.0' => Gem::Specification.new do |s| - s.name = 'foo-2' - s.version = "2.0.0" - s.summary = "This is the coolest package evar!~!" - end, - } - result - end - - def fetch_path(path) - end - - def self.finish - end -end - -class TestGemRemoteInstaller < RubyGemTestCase - - def setup - super - - util_setup_fake_fetcher - - util_setup_source_info_cache @gem1, @gem4 - - @installer = Gem::RemoteInstaller.new - @installer.instance_variable_set("@fetcher_class", MockFetcher) - end - - def teardown - FileUtils.rm "dest_file" rescue nil - end - - def test_find_gem_to_install - future_gem = quick_gem @gem1.name, '9.9.9' do |spec| - spec.required_ruby_version = '> 999.999.999' # HACK - end - - util_setup_source_info_cache @gem1, future_gem - version = Gem::Version::Requirement.new "> 0.0.0" - gems = @installer.find_gem_to_install(@gem1.name, version) - - assert_equal @gem1.full_name, gems.first.full_name - end - - def test_source_index_hash - source_hash = @installer.source_index_hash - - assert_equal 1, source_hash.size - assert source_hash.has_key?('http://gems.example.com') - assert_equal [@gem1, @gem4], - source_hash['http://gems.example.com'].search(@gem1.name) - end - - def test_specs_n_sources_matching - version = Gem::Version::Requirement.new "> 0.0.0" - specs_n_sources = @installer.specs_n_sources_matching @gem1.name, version - - gems = specs_n_sources.map { |g,| g.full_name } - - assert_equal [@gem1.full_name], gems, - "Gems with longer names and higher versions must not match" - end - -end - -# This test suite has a number of TODOs in the test cases. The -# TestRemoteInstaller test suite is a reworking of this class from -# scratch. -class RemoteInstallerTest #< RubyGemTestCase # HACK disabled - class RInst < Gem::RemoteInstaller - include Test::Unit::Assertions - - attr_accessor :expected_destination_files - attr_accessor :expected_bodies - attr_accessor :caches - attr_accessor :responses - - def source_index_hash - @caches - end - - def fetch(uri) - @reponses ||= {} - @responses[uri] - end - - def write_gem_to_file(body, destination_file) - expected_destination_file = expected_destination_files.pop - expected_body = expected_bodies.pop - assert_equal expected_body, body, "Unexpected body" - assert_equal expected_destination_file, destination_file, "Unexpected destination file" - end - - def new_installer(gem) - return MockInstaller.new(gem) - end - end - - def setup - Gem.clear_paths - @remote_installer = Gem::RemoteInstaller.new - @remote_installer.instance_eval { @fetcher_class = MockFetcher } - end - - SAMPLE_SPEC = Gem::Specification.new do |s| - s.name = 'foo' - s.version = "1.2.3" - s.platform = Gem::Platform::RUBY - s.summary = "This is a cool package" - s.files = [] - end - SAMPLE_CACHE = { 'foo-1.2.3' => SAMPLE_SPEC } - SAMPLE_CACHE_YAML = SAMPLE_CACHE.to_yaml - - FOO_GEM = '' # TODO - CACHE_DIR = File.join(Gem.dir, 'cache') - - def test_install - result = @remote_installer.install('foo') - assert_equal [nil], result - end - -end - diff --git a/test/rubygems/test_gem_server.rb b/test/rubygems/test_gem_server.rb index 98c8ba5543..c283e661dc 100644 --- a/test/rubygems/test_gem_server.rb +++ b/test/rubygems/test_gem_server.rb @@ -4,6 +4,7 @@ require 'rubygems/server' require 'stringio' class Gem::Server + attr_accessor :source_index attr_reader :server end @@ -25,6 +26,7 @@ class TestGemServer < RubyGemTestCase @server.quick @req, @res + assert_equal 200, @res.status, @res.body assert_match %r| \d\d:\d\d:\d\d |, @res['date'] assert_equal 'text/plain', @res['content-type'] assert_equal "a-1", @res.body @@ -36,6 +38,7 @@ class TestGemServer < RubyGemTestCase @server.quick @req, @res + assert_equal 200, @res.status, @res.body assert_match %r| \d\d:\d\d:\d\d |, @res['date'] assert_equal 'text/plain', @res['content-type'] assert_equal "a-1", Zlib::Inflate.inflate(@res.body) @@ -47,6 +50,7 @@ class TestGemServer < RubyGemTestCase @server.quick @req, @res + assert_equal 200, @res.status, @res.body assert @res['date'] assert_equal 'text/plain', @res['content-type'] yaml = Zlib::Inflate.inflate(@res.body) @@ -55,15 +59,54 @@ class TestGemServer < RubyGemTestCase assert_match %r|version: "1"|, yaml end + def test_quick_a_1_mswin32_gemspec_rz + a1_p = quick_gem 'a', '1' do |s| s.platform = Gem::Platform.local end + si = Gem::SourceIndex.new @a1.full_name => @a1, a1_p.full_name => a1_p + @server.source_index = si + + data = StringIO.new "GET /quick/a-1-#{Gem::Platform.local}.gemspec.rz HTTP/1.0\r\n\r\n" + @req.parse data + + @server.quick @req, @res + + assert_equal 200, @res.status, @res.body + assert @res['date'] + assert_equal 'text/plain', @res['content-type'] + yaml = Zlib::Inflate.inflate(@res.body) + assert_match %r|Gem::Specification|, yaml + assert_match %r|name: a|, yaml + assert_match %r|version: "1"|, yaml + end + + def test_quick_common_substrings + ab1 = quick_gem 'ab', '1' + si = Gem::SourceIndex.new @a1.full_name => @a1, ab1.full_name => ab1 + @server.source_index = si + + data = StringIO.new "GET /quick/a-1.gemspec.rz HTTP/1.0\r\n\r\n" + @req.parse data + + @server.quick @req, @res + + assert_equal 200, @res.status, @res.body + assert @res['date'] + assert_equal 'text/plain', @res['content-type'] + yaml = Zlib::Inflate.inflate @res.body + assert_match %r|Gem::Specification|, yaml + assert_match %r|name: a$|, yaml + assert_match %r|version: "1"|, yaml + end + def test_quick_z_9_gemspec_rz data = StringIO.new "GET /quick/z-9.gemspec.rz HTTP/1.0\r\n\r\n" @req.parse data @server.quick @req, @res + assert_equal 404, @res.status, @res.body assert_match %r| \d\d:\d\d:\d\d |, @res['date'] assert_equal 'text/plain', @res['content-type'] - assert_equal '', @res.body + assert_equal 'No gems found matching "z" "9" nil', @res.body assert_equal 404, @res.status end diff --git a/test/rubygems/test_gem_source_index.rb b/test/rubygems/test_gem_source_index.rb index befbbe6f67..45f59f2430 100644 --- a/test/rubygems/test_gem_source_index.rb +++ b/test/rubygems/test_gem_source_index.rb @@ -178,7 +178,7 @@ class TestGemSourceIndex < RubyGemTestCase end def test_latest_specs - spec = quick_gem @gem1.name, '0.0.1' + spec = quick_gem @gem1.name, '1' @source_index.add_spec spec expected = [ @@ -223,7 +223,7 @@ class TestGemSourceIndex < RubyGemTestCase def test_search assert_equal [@gem1, @gem4], @source_index.search("gem_one") - assert_equal [@gem1], @source_index.search("gem_one", "= 0.0.2") + assert_equal [@gem1], @source_index.search("gem_one", "= 2") assert_equal [], @source_index.search("bogusstring") assert_equal [], @source_index.search("gem_one", "= 3.2.1") diff --git a/test/rubygems/test_gem_specification.rb b/test/rubygems/test_gem_specification.rb index 69d625ceb6..723e566a24 100644 --- a/test/rubygems/test_gem_specification.rb +++ b/test/rubygems/test_gem_specification.rb @@ -47,12 +47,13 @@ end def setup super - @a0_0_1 = quick_gem 'a', '0.0.1' do |s| + @a1 = quick_gem 'a', '1' do |s| s.executable = 'exec' s.extensions << 'ext/a/extconf.rb' s.has_rdoc = 'true' s.test_file = 'test/suite.rb' s.requirements << 'A working computer' + s.rubyforge_project = 'example' s.add_dependency 'rake', '> 0.4' s.add_dependency 'jabber4r', '> 0.0.0' @@ -62,9 +63,14 @@ end s.files = %w[lib/code.rb] end - @a0_0_2 = quick_gem 'a', '0.0.2' do |s| + @a2 = quick_gem 'a', '2' do |s| s.files = %w[lib/code.rb] end + + FileUtils.mkdir_p File.join(@tempdir, 'bin') + File.open File.join(@tempdir, 'bin', 'exec'), 'w' do |fp| + fp.puts "#!#{Gem.ruby}" + end end def test_self_attribute_names @@ -107,10 +113,10 @@ end end def test_self_load - spec = File.join @gemhome, 'specifications', "#{@a0_0_2.full_name}.gemspec" + spec = File.join @gemhome, 'specifications', "#{@a2.full_name}.gemspec" gs = Gem::Specification.load spec - assert_equal @a0_0_2, gs + assert_equal @a2, gs end def test_self_load_legacy_ruby @@ -119,7 +125,7 @@ end assert_equal '0.4.0', s.version.to_s assert_equal true, s.has_rdoc? assert_equal Gem::Specification::TODAY, s.date - assert s.required_ruby_version.satisfied_by?(Gem::Version.new('0.0.1')) + assert s.required_ruby_version.satisfied_by?(Gem::Version.new('1')) assert_equal false, s.has_unit_tests? end @@ -129,7 +135,7 @@ end assert_equal '0.4.0', s.version.to_s assert_equal true, s.has_rdoc? #assert_equal Date.today, s.date - #assert s.required_ruby_version.satisfied_by?(Gem::Version.new('0.0.1')) + #assert s.required_ruby_version.satisfied_by?(Gem::Version.new('1')) assert_equal false, s.has_unit_tests? end @@ -197,10 +203,10 @@ end end def test__dump - @a0_0_2.platform = Gem::Platform.local - @a0_0_2.instance_variable_set :@original_platform, 'old_platform' + @a2.platform = Gem::Platform.local + @a2.instance_variable_set :@original_platform, 'old_platform' - data = Marshal.dump @a0_0_2 + data = Marshal.dump @a2 same_spec = Marshal.load data @@ -208,64 +214,64 @@ end end def test_author - assert_equal 'A User', @a0_0_1.author + assert_equal 'A User', @a1.author end def test_authors - assert_equal ['A User'], @a0_0_1.authors + assert_equal ['A User'], @a1.authors end def test_bindir_equals - @a0_0_1.bindir = 'apps' + @a1.bindir = 'apps' - assert_equal 'apps', @a0_0_1.bindir + assert_equal 'apps', @a1.bindir end def test_bindir_equals_nil - @a0_0_2.bindir = nil - @a0_0_2.executable = 'app' + @a2.bindir = nil + @a2.executable = 'app' - assert_equal nil, @a0_0_2.bindir - assert_equal %w[lib/code.rb app], @a0_0_2.files + assert_equal nil, @a2.bindir + assert_equal %w[lib/code.rb app], @a2.files end def test_date - assert_equal Gem::Specification::TODAY, @a0_0_1.date + assert_equal Gem::Specification::TODAY, @a1.date end def test_date_equals_date - @a0_0_1.date = Date.new(2003, 9, 17) - assert_equal Time.local(2003, 9, 17, 0,0,0), @a0_0_1.date + @a1.date = Date.new(2003, 9, 17) + assert_equal Time.local(2003, 9, 17, 0,0,0), @a1.date end def test_date_equals_string - @a0_0_1.date = '2003-09-17' - assert_equal Time.local(2003, 9, 17, 0,0,0), @a0_0_1.date + @a1.date = '2003-09-17' + assert_equal Time.local(2003, 9, 17, 0,0,0), @a1.date end def test_date_equals_time - @a0_0_1.date = Time.local(2003, 9, 17, 0,0,0) - assert_equal Time.local(2003, 9, 17, 0,0,0), @a0_0_1.date + @a1.date = Time.local(2003, 9, 17, 0,0,0) + assert_equal Time.local(2003, 9, 17, 0,0,0), @a1.date end def test_date_equals_time_local # HACK PDT - @a0_0_1.date = Time.local(2003, 9, 17, 19,50,0) - assert_equal Time.local(2003, 9, 17, 0,0,0), @a0_0_1.date + @a1.date = Time.local(2003, 9, 17, 19,50,0) + assert_equal Time.local(2003, 9, 17, 0,0,0), @a1.date end def test_date_equals_time_utc # HACK PDT - @a0_0_1.date = Time.local(2003, 9, 17, 19,50,0) - assert_equal Time.local(2003, 9, 17, 0,0,0), @a0_0_1.date + @a1.date = Time.local(2003, 9, 17, 19,50,0) + assert_equal Time.local(2003, 9, 17, 0,0,0), @a1.date end def test_default_executable - assert_equal 'exec', @a0_0_1.default_executable + assert_equal 'exec', @a1.default_executable - @a0_0_1.default_executable = nil - @a0_0_1.instance_variable_set :@executables, nil - assert_equal nil, @a0_0_1.default_executable + @a1.default_executable = nil + @a1.instance_variable_set :@executables, nil + assert_equal nil, @a1.default_executable end def test_dependencies @@ -273,11 +279,11 @@ end jabber = Gem::Dependency.new 'jabber4r', '> 0.0.0' pqa = Gem::Dependency.new 'pqa', ['> 0.4', '<= 0.6'] - assert_equal [rake, jabber, pqa], @a0_0_1.dependencies + assert_equal [rake, jabber, pqa], @a1.dependencies end def test_description - assert_equal 'This is a test description', @a0_0_1.description + assert_equal 'This is a test description', @a1.description end def test_eql_eh @@ -290,10 +296,10 @@ end end def test_equals2 - assert_equal @a0_0_1, @a0_0_1 - assert_equal @a0_0_1, @a0_0_1.dup - assert_not_equal @a0_0_1, @a0_0_2 - assert_not_equal @a0_0_1, Object.new + assert_equal @a1, @a1 + assert_equal @a1, @a1.dup + assert_not_equal @a1, @a2 + assert_not_equal @a1, Object.new end # The cgikit specification was reported to be causing trouble in at least @@ -322,42 +328,42 @@ end end def test_equals2_default_executable - spec = @a0_0_1.dup + spec = @a1.dup spec.default_executable = 'xx' - assert_not_equal @a0_0_1, spec - assert_not_equal spec, @a0_0_1 + assert_not_equal @a1, spec + assert_not_equal spec, @a1 end def test_equals2_extensions - spec = @a0_0_1.dup + spec = @a1.dup spec.extensions = 'xx' - assert_not_equal @a0_0_1, spec - assert_not_equal spec, @a0_0_1 + assert_not_equal @a1, spec + assert_not_equal spec, @a1 end def test_executables - @a0_0_1.executable = 'app' - assert_equal %w[app], @a0_0_1.executables + @a1.executable = 'app' + assert_equal %w[app], @a1.executables end def test_executable_equals - @a0_0_2.executable = 'app' - assert_equal 'app', @a0_0_2.executable - assert_equal %w[lib/code.rb bin/app], @a0_0_2.files + @a2.executable = 'app' + assert_equal 'app', @a2.executable + assert_equal %w[lib/code.rb bin/app], @a2.files end def test_extensions - assert_equal ['ext/a/extconf.rb'], @a0_0_1.extensions + assert_equal ['ext/a/extconf.rb'], @a1.extensions end def test_files - @a0_0_1.files = %w(files bin/common) - @a0_0_1.test_files = %w(test_files bin/common) - @a0_0_1.executables = %w(executables common) - @a0_0_1.extra_rdoc_files = %w(extra_rdoc_files bin/common) - @a0_0_1.extensions = %w(extensions bin/common) + @a1.files = %w(files bin/common) + @a1.test_files = %w(test_files bin/common) + @a1.executables = %w(executables common) + @a1.extra_rdoc_files = %w(extra_rdoc_files bin/common) + @a1.extensions = %w(extensions bin/common) expected = %w[ bin/common @@ -367,113 +373,123 @@ end files test_files ] - assert_equal expected, @a0_0_1.files.sort + assert_equal expected, @a1.files.sort end def test_files_duplicate - @a0_0_2.files = %w[a b c d b] - @a0_0_2.extra_rdoc_files = %w[x y z x] - @a0_0_2.normalize + @a2.files = %w[a b c d b] + @a2.extra_rdoc_files = %w[x y z x] + @a2.normalize - assert_equal %w[a b c d x y z], @a0_0_2.files - assert_equal %w[x y z], @a0_0_2.extra_rdoc_files + assert_equal %w[a b c d x y z], @a2.files + assert_equal %w[x y z], @a2.extra_rdoc_files end def test_files_extra_rdoc_files - @a0_0_2.files = %w[a b c d] - @a0_0_2.extra_rdoc_files = %w[x y z] - @a0_0_2.normalize - assert_equal %w[a b c d x y z], @a0_0_2.files + @a2.files = %w[a b c d] + @a2.extra_rdoc_files = %w[x y z] + @a2.normalize + assert_equal %w[a b c d x y z], @a2.files end def test_files_non_array - @a0_0_1.files = "F" - @a0_0_1.test_files = "TF" - @a0_0_1.executables = "X" - @a0_0_1.extra_rdoc_files = "ERF" - @a0_0_1.extensions = "E" + @a1.files = "F" + @a1.test_files = "TF" + @a1.executables = "X" + @a1.extra_rdoc_files = "ERF" + @a1.extensions = "E" - assert_equal %w[E ERF F TF bin/X], @a0_0_1.files.sort + assert_equal %w[E ERF F TF bin/X], @a1.files.sort end def test_files_non_array_pathological - @a0_0_1.instance_variable_set :@files, "F" - @a0_0_1.instance_variable_set :@test_files, "TF" - @a0_0_1.instance_variable_set :@extra_rdoc_files, "ERF" - @a0_0_1.instance_variable_set :@extensions, "E" - @a0_0_1.instance_variable_set :@executables, "X" + @a1.instance_variable_set :@files, "F" + @a1.instance_variable_set :@test_files, "TF" + @a1.instance_variable_set :@extra_rdoc_files, "ERF" + @a1.instance_variable_set :@extensions, "E" + @a1.instance_variable_set :@executables, "X" + + assert_equal %w[E ERF F TF bin/X], @a1.files.sort + assert_kind_of Integer, @a1.hash + end - assert_equal %w[E ERF F TF bin/X], @a0_0_1.files.sort - assert_kind_of Integer, @a0_0_1.hash + def test_full_gem_path + assert_equal File.join(@gemhome, 'gems', @a1.full_name), + @a1.full_gem_path + + @a1.original_platform = 'mswin32' + + assert_equal File.join(@gemhome, 'gems', @a1.original_name), + @a1.full_gem_path end def test_full_name - assert_equal 'a-0.0.1', @a0_0_1.full_name + assert_equal 'a-1', @a1.full_name - @a0_0_1.platform = Gem::Platform.new ['universal', 'darwin', nil] - assert_equal 'a-0.0.1-universal-darwin', @a0_0_1.full_name + @a1.platform = Gem::Platform.new ['universal', 'darwin', nil] + assert_equal 'a-1-universal-darwin', @a1.full_name - @a0_0_1.instance_variable_set :@new_platform, 'mswin32' - assert_equal 'a-0.0.1-mswin32', @a0_0_1.full_name, 'legacy' + @a1.instance_variable_set :@new_platform, 'mswin32' + assert_equal 'a-1-mswin32', @a1.full_name, 'legacy' return if win_platform? - @a0_0_1.platform = 'current' - assert_equal 'a-0.0.1-x86-darwin-8', @a0_0_1.full_name + @a1.platform = 'current' + assert_equal 'a-1-x86-darwin-8', @a1.full_name end def test_full_name_windows test_cases = { - 'i386-mswin32' => 'a-0.0.1-x86-mswin32-60', - 'i386-mswin32_80' => 'a-0.0.1-x86-mswin32-80', - 'i386-mingw32' => 'a-0.0.1-x86-mingw32' + 'i386-mswin32' => 'a-1-x86-mswin32-60', + 'i386-mswin32_80' => 'a-1-x86-mswin32-80', + 'i386-mingw32' => 'a-1-x86-mingw32' } test_cases.each do |arch, expected| util_set_arch arch - @a0_0_1.platform = 'current' - assert_equal expected, @a0_0_1.full_name + @a1.platform = 'current' + assert_equal expected, @a1.full_name end end def test_has_rdoc_eh - assert_equal true, @a0_0_1.has_rdoc? + assert_equal true, @a1.has_rdoc? end def test_hash - assert_equal @a0_0_1.hash, @a0_0_1.hash - assert_equal @a0_0_1.hash, @a0_0_1.dup.hash - assert_not_equal @a0_0_1.hash, @a0_0_2.hash + assert_equal @a1.hash, @a1.hash + assert_equal @a1.hash, @a1.dup.hash + assert_not_equal @a1.hash, @a2.hash end def test_lib_files - @a0_0_1.files = %w[lib/foo.rb Rakefile] + @a1.files = %w[lib/foo.rb Rakefile] - assert_equal %w[lib/foo.rb], @a0_0_1.lib_files + assert_equal %w[lib/foo.rb], @a1.lib_files end def test_name - assert_equal 'a', @a0_0_1.name + assert_equal 'a', @a1.name end def test_original_name - assert_equal 'a-0.0.1', @a0_0_1.full_name + assert_equal 'a-1', @a1.full_name - @a0_0_1.platform = 'i386-linux' - @a0_0_1.instance_variable_set :@original_platform, 'i386-linux' - assert_equal 'a-0.0.1-i386-linux', @a0_0_1.original_name + @a1.platform = 'i386-linux' + @a1.instance_variable_set :@original_platform, 'i386-linux' + assert_equal 'a-1-i386-linux', @a1.original_name end def test_platform - assert_equal Gem::Platform::RUBY, @a0_0_1.platform + assert_equal Gem::Platform::RUBY, @a1.platform end def test_platform_equals - @a0_0_1.platform = nil - assert_equal Gem::Platform::RUBY, @a0_0_1.platform + @a1.platform = nil + assert_equal Gem::Platform::RUBY, @a1.platform - @a0_0_1.platform = Gem::Platform::RUBY - assert_equal Gem::Platform::RUBY, @a0_0_1.platform + @a1.platform = Gem::Platform::RUBY + assert_equal Gem::Platform::RUBY, @a1.platform test_cases = { 'i386-mswin32' => ['x86', 'mswin32', '60'], @@ -484,29 +500,35 @@ end test_cases.each do |arch, expected| util_set_arch arch - @a0_0_1.platform = Gem::Platform::CURRENT - assert_equal Gem::Platform.new(expected), @a0_0_1.platform + @a1.platform = Gem::Platform::CURRENT + assert_equal Gem::Platform.new(expected), @a1.platform end end + def test_platform_equals_current + @a1.platform = Gem::Platform::CURRENT + assert_equal Gem::Platform.local, @a1.platform + assert_equal Gem::Platform.local.to_s, @a1.original_platform + end + def test_platform_equals_legacy - @a0_0_1.platform = Gem::Platform::WIN32 - assert_equal Gem::Platform::MSWIN32, @a0_0_1.platform + @a1.platform = 'mswin32' + assert_equal Gem::Platform.new('x86-mswin32'), @a1.platform - @a0_0_1.platform = Gem::Platform::LINUX_586 - assert_equal Gem::Platform::X86_LINUX, @a0_0_1.platform + @a1.platform = 'i586-linux' + assert_equal Gem::Platform.new('x86-linux'), @a1.platform - @a0_0_1.platform = Gem::Platform::DARWIN - assert_equal Gem::Platform::PPC_DARWIN, @a0_0_1.platform + @a1.platform = 'powerpc-darwin' + assert_equal Gem::Platform.new('ppc-darwin'), @a1.platform end def test_require_paths - @a0_0_1.require_path = 'lib' - assert_equal %w[lib], @a0_0_1.require_paths + @a1.require_path = 'lib' + assert_equal %w[lib], @a1.require_paths end def test_requirements - assert_equal ['A working computer'], @a0_0_1.requirements + assert_equal ['A working computer'], @a1.requirements end def test_spaceship_name @@ -539,28 +561,22 @@ end end def test_summary - assert_equal 'this is a summary', @a0_0_1.summary + assert_equal 'this is a summary', @a1.summary end def test_test_files - @a0_0_1.test_file = 'test/suite.rb' - assert_equal ['test/suite.rb'], @a0_0_1.test_files - end - - def test_test_suite_file - @a0_0_2.test_suite_file = 'test/suite.rb' - assert_equal ['test/suite.rb'], @a0_0_2.test_files - # XXX: what about the warning? + @a1.test_file = 'test/suite.rb' + assert_equal ['test/suite.rb'], @a1.test_files end def test_to_ruby - @a0_0_2.required_rubygems_version = Gem::Requirement.new '> 0' + @a2.required_rubygems_version = Gem::Requirement.new '> 0' - ruby_code = @a0_0_2.to_ruby + ruby_code = @a2.to_ruby expected = "Gem::Specification.new do |s| s.name = %q{a} - s.version = \"0.0.2\" + s.version = \"2\" s.specification_version = #{Gem::Specification::CURRENT_SPECIFICATION_VERSION} if s.respond_to? :specification_version= @@ -582,17 +598,20 @@ end same_spec = eval ruby_code - assert_equal @a0_0_2, same_spec + assert_equal @a2, same_spec end def test_to_ruby_fancy - @a0_0_1.platform = Gem::Platform::PPC_DARWIN - ruby_code = @a0_0_1.to_ruby + @a1.platform = Gem::Platform.local + ruby_code = @a1.to_ruby + + local = Gem::Platform.local + expected_platform = "[#{local.cpu.inspect}, #{local.os.inspect}, #{local.version.inspect}]" expected = "Gem::Specification.new do |s| s.name = %q{a} - s.version = \"0.0.1\" - s.platform = Gem::Platform.new([\"ppc\", \"darwin\", nil]) + s.version = \"1\" + s.platform = Gem::Platform.new(#{expected_platform}) s.specification_version = 2 if s.respond_to? :specification_version= @@ -609,6 +628,7 @@ end s.homepage = %q{http://example.com} s.require_paths = [\"lib\"] s.requirements = [\"A working computer\"] + s.rubyforge_project = %q{example} s.rubygems_version = %q{#{Gem::RubyGemsVersion}} s.summary = %q{this is a summary} s.test_files = [\"test/suite.rb\"] @@ -623,7 +643,7 @@ end same_spec = eval ruby_code - assert_equal @a0_0_1, same_spec + assert_equal @a1, same_spec end def test_to_ruby_legacy @@ -635,10 +655,10 @@ end end def test_to_ruby_platform - @a0_0_2.platform = Gem::Platform.local - @a0_0_2.instance_variable_set :@original_platform, 'old_platform' + @a2.platform = Gem::Platform.local + @a2.instance_variable_set :@original_platform, 'old_platform' - ruby_code = @a0_0_2.to_ruby + ruby_code = @a2.to_ruby same_spec = eval ruby_code @@ -646,28 +666,34 @@ end end def test_to_yaml - yaml_str = @a0_0_1.to_yaml + yaml_str = @a1.to_yaml same_spec = YAML.load(yaml_str) - assert_equal @a0_0_1, same_spec + assert_equal @a1, same_spec end def test_to_yaml_fancy - @a0_0_1.platform = Gem::Platform::PPC_DARWIN - yaml_str = @a0_0_1.to_yaml + @a1.platform = Gem::Platform.local + yaml_str = @a1.to_yaml same_spec = YAML.load(yaml_str) - assert_equal Gem::Platform::PPC_DARWIN, same_spec.platform + assert_equal Gem::Platform.local, same_spec.platform - assert_equal @a0_0_1, same_spec + assert_equal @a1, same_spec end - def test_to_yaml_legacy_platform - @a0_0_1.platform = 'powerpc-darwin7.9.0' - @a0_0_1.instance_variable_set :@original_platform, 'powerpc-darwin7.9.0' + def test_to_yaml_platform_empty_string + @a1.instance_variable_set :@original_platform, '' - yaml_str = @a0_0_1.to_yaml + assert_match %r|^platform: ruby$|, @a1.to_yaml + end + + def test_to_yaml_platform_legacy + @a1.platform = 'powerpc-darwin7.9.0' + @a1.instance_variable_set :@original_platform, 'powerpc-darwin7.9.0' + + yaml_str = @a1.to_yaml same_spec = YAML.load(yaml_str) @@ -675,8 +701,61 @@ end assert_equal 'powerpc-darwin7.9.0', same_spec.original_platform end + def test_to_yaml_platform_nil + @a1.instance_variable_set :@original_platform, nil + + assert_match %r|^platform: ruby$|, @a1.to_yaml + end + def test_validate - assert @a0_0_1.validate + Dir.chdir @tempdir do + assert @a1.validate + end + end + + def test_validate_authors + Dir.chdir @tempdir do + @a1.authors = [] + + use_ui @ui do + @a1.validate + end + + assert_equal "WARNING: no author specified\n", @ui.error, 'error' + + @a1.authors = [Object.new] + + e = assert_raise Gem::InvalidSpecificationException do + @a1.validate + end + + assert_equal 'authors must be Array of Strings', e.message + end + end + + def test_validate_autorequire + Dir.chdir @tempdir do + @a1.autorequire = 'code' + + use_ui @ui do + @a1.validate + end + + assert_equal "WARNING: deprecated autorequire specified\n", + @ui.error, 'error' + end + end + + def test_validate_email + Dir.chdir @tempdir do + @a1.email = '' + + use_ui @ui do + @a1.validate + end + + assert_equal "WARNING: no email specified\n", @ui.error, 'error' + end end def test_validate_empty @@ -687,51 +766,104 @@ end assert_equal 'missing value for attribute name', e.message end + def test_validate_executables + FileUtils.mkdir_p File.join(@tempdir, 'bin') + File.open File.join(@tempdir, 'bin', 'exec'), 'w' do end + + use_ui @ui do + Dir.chdir @tempdir do + assert @a1.validate + end + end + + assert_equal '', @ui.output, 'output' + assert_equal "WARNING: bin/exec is missing #! line\n", @ui.error, 'error' + end + def test_validate_empty_require_paths - @a0_0_1.require_paths = [] + @a1.require_paths = [] e = assert_raise Gem::InvalidSpecificationException do - @a0_0_1.validate + @a1.validate end assert_equal 'specification must have at least one require_path', e.message end - def test_validate_platform_bad - @a0_0_1.platform = Object.new - assert_raise Gem::InvalidSpecificationException do @a0_0_1.validate end + def test_validate_homepage + Dir.chdir @tempdir do + @a1.homepage = '' - @a0_0_1.platform = "my-custom-platform" - e = assert_raise Gem::InvalidSpecificationException do - @a0_0_1.validate + use_ui @ui do + @a1.validate + end + + assert_equal "WARNING: no homepage specified\n", @ui.error, 'error' end + end - assert_equal 'invalid platform "my-custom-platform", see Gem::Platform', - e.message + def test_validate_has_rdoc + Dir.chdir @tempdir do + @a1.has_rdoc = false + + use_ui @ui do + @a1.validate + end + + assert_equal "WARNING: RDoc will not be generated (has_rdoc == false)\n", + @ui.error, 'error' + end end def test_validate_platform_legacy - @a0_0_1.platform = Gem::Platform::WIN32 - assert @a0_0_1.validate + Dir.chdir @tempdir do + @a1.platform = 'mswin32' + assert @a1.validate + + @a1.platform = 'i586-linux' + assert @a1.validate + + @a1.platform = 'powerpc-darwin' + assert @a1.validate + end + end - @a0_0_1.platform = Gem::Platform::LINUX_586 - assert @a0_0_1.validate + def test_validate_rubyforge_project + Dir.chdir @tempdir do + @a1.rubyforge_project = '' - @a0_0_1.platform = Gem::Platform::DARWIN - assert @a0_0_1.validate + use_ui @ui do + @a1.validate + end + + assert_equal "WARNING: no rubyforge_project specified\n", + @ui.error, 'error' + end end def test_validate_rubygems_version - @a0_0_1.rubygems_version = "3" + @a1.rubygems_version = "3" e = assert_raise Gem::InvalidSpecificationException do - @a0_0_1.validate + @a1.validate end assert_equal "expected RubyGems version #{Gem::RubyGemsVersion}, was 3", e.message end + def test_validate_summary + Dir.chdir @tempdir do + @a1.summary = '' + + use_ui @ui do + @a1.validate + end + + assert_equal "WARNING: no summary specified\n", @ui.error, 'error' + end + end + def test_version - assert_equal Gem::Version.new('0.0.1'), @a0_0_1.version + assert_equal Gem::Version.new('1'), @a1.version end end diff --git a/test/rubygems/test_gem_version.rb b/test/rubygems/test_gem_version.rb index 95f37ddd23..99dd49933d 100644 --- a/test/rubygems/test_gem_version.rb +++ b/test/rubygems/test_gem_version.rb @@ -55,6 +55,11 @@ class TestGemVersion < RubyGemTestCase assert_inadequate( "1.0.0.1", "= 1.0") end + def test_bump_trailing_zeros + v = Gem::Version.new("5.0.0") + assert_equal "5.1", v.bump.to_s + end + def test_bump v = Gem::Version.new("5.2.4") assert_equal "5.3", v.bump.to_s @@ -65,6 +70,16 @@ class TestGemVersion < RubyGemTestCase assert_equal "6", v.bump.to_s end + def test_eql_eh + v = Gem::Version.new("1.2") + + assert_equal true, v.eql?(@v1_2) + assert_equal true, @v1_2.eql?(v) + + assert_equal false, @v1_2.eql?(@v1_3) + assert_equal false, @v1_3.eql?(@v1_2) + end + def test_equals2 v = Gem::Version.new("1.2") diff --git a/test/rubygems/test_kernel.rb b/test/rubygems/test_kernel.rb index d7d5eaaee2..e06a78e32a 100644 --- a/test/rubygems/test_kernel.rb +++ b/test/rubygems/test_kernel.rb @@ -25,39 +25,39 @@ class TestKernel < RubyGemTestCase end def test_gem - assert gem('a', '= 0.0.1'), "Should load" - assert $:.any? { |p| %r{a-0.0.1/lib} =~ p } - assert $:.any? { |p| %r{a-0.0.1/bin} =~ p } + assert gem('a', '= 1'), "Should load" + assert $:.any? { |p| %r{a-1/lib} =~ p } + assert $:.any? { |p| %r{a-1/bin} =~ p } end def test_gem_redundent - assert gem('a', '= 0.0.1'), "Should load" - assert ! gem('a', '= 0.0.1'), "Should not load" - assert_equal 1, $:.select { |p| %r{a-0.0.1/lib} =~ p }.size - assert_equal 1, $:.select { |p| %r{a-0.0.1/bin} =~ p }.size + assert gem('a', '= 1'), "Should load" + assert ! 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', '= 0.0.1'), "Should load" - assert ! gem('a', '>= 0.0.1'), "Should not load" - assert_equal 1, $:.select { |p| %r{a-0.0.1/lib} =~ p }.size - assert_equal 1, $:.select { |p| %r{a-0.0.1/bin} =~ p }.size + assert gem('a', '= 1'), "Should load" + assert ! 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_conflicting - assert gem('a', '= 0.0.1'), "Should load" + assert gem('a', '= 1'), "Should load" ex = assert_raise Gem::Exception do - gem 'a', '= 0.0.2' + gem 'a', '= 2' end - assert_match(/activate a \(= 0\.0\.2\)/, ex.message) - assert_match(/activated a-0\.0\.1/, ex.message) + assert_match(/activate a \(= 2\)/, ex.message) + assert_match(/activated a-1/, ex.message) - assert $:.any? { |p| %r{a-0.0.1/lib} =~ p } - assert $:.any? { |p| %r{a-0.0.1/bin} =~ p } - assert ! $:.any? { |p| %r{a-0.0.2/lib} =~ p } - assert ! $:.any? { |p| %r{a-0.0.2/bin} =~ p } + 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 } end end -- cgit v1.2.3