rubygems-update 2.0.17 → 2.1.0.rc.1

data/lib/rubygems/commands/dependency_command.rb

@@ -42,85 +42,106 @@ class Gem::Commands::DependencyCommand < Gem::Command
     "#{program_name} GEMNAME"
   end
 
-  def execute
-    if options[:reverse_dependencies] and remote? and not local? then
-      alert_error 'Only reverse dependencies for local gems are supported.'
-      terminate_interaction 1
-    end
+  def fetch_remote_specs dependency # :nodoc:
+    fetcher = Gem::SpecFetcher.fetcher
+
+    ss, = fetcher.spec_for_dependency dependency
+
+    ss.map { |spec, _| spec }
+  end
+
+  def fetch_specs dependency # :nodoc:
+    specs = []
+
+    specs.concat dependency.matching_specs     if local?
+    specs.concat fetch_remote_specs dependency if remote?
+
+    ensure_specs specs
+
+    specs.uniq.sort
+  end
 
-    options[:args] << '' if options[:args].empty?
+  def gem_dependency args, version, prerelease # :nodoc:
+    args << '' if args.empty?
 
-    pattern = if options[:args].length == 1 and
-                 options[:args].first =~ /\A\/(.*)\/(i)?\z/m then
+    pattern = if args.length == 1 and args.first =~ /\A\/(.*)\/(i)?\z/m then
                 flags = $2 ? Regexp::IGNORECASE : nil
                 Regexp.new $1, flags
               else
-                /\A#{Regexp.union(*options[:args])}/
+                /\A#{Regexp.union(*args)}/
               end
 
-    # TODO: deprecate for real damnit
     dependency = Gem::Deprecate.skip_during {
-      Gem::Dependency.new pattern, options[:version]
+      Gem::Dependency.new pattern, version
     }
-    dependency.prerelease = options[:prerelease]
 
-    specs = []
+    dependency.prerelease = prerelease
 
-    specs.concat dependency.matching_specs if local?
+    dependency
+  end
 
-    if remote? and not options[:reverse_dependencies] then
-      fetcher = Gem::SpecFetcher.fetcher
+  def display_pipe specs # :nodoc:
+    specs.each do |spec|
+      unless spec.dependencies.empty? then
+        spec.dependencies.sort_by { |dep| dep.name }.each do |dep|
+          say "#{dep.name} --version '#{dep.requirement}'"
+        end
+      end
+    end
+  end
 
-      ss, _ = fetcher.spec_for_dependency dependency
+  def display_readable specs, reverse # :nodoc:
+    response = ''
 
-      ss.each { |s,o| specs << s }
+    specs.each do |spec|
+      response << print_dependencies(spec)
+      unless reverse[spec.full_name].empty? then
+        response << "  Used by\n"
+        reverse[spec.full_name].each do |sp, dep|
+          response << "    #{sp} (#{dep})\n"
+        end
+      end
+      response << "\n"
     end
 
-    if specs.empty? then
-      patterns = options[:args].join ','
-      say "No gems found matching #{patterns} (#{options[:version]})" if
-        Gem.configuration.verbose
+    say response
+  end
 
-      terminate_interaction 1
-    end
+  def execute
+    ensure_local_only_reverse_dependencies
 
-    specs = specs.uniq.sort
+    dependency =
+      gem_dependency options[:args], options[:version], options[:prerelease]
 
-    reverse = Hash.new { |h, k| h[k] = [] }
+    specs = fetch_specs dependency
 
-    if options[:reverse_dependencies] then
-      specs.each do |spec|
-        reverse[spec.full_name] = find_reverse_dependencies spec
-      end
-    end
+    reverse = reverse_dependencies specs
 
     if options[:pipe_format] then
-      specs.each do |spec|
-        unless spec.dependencies.empty?
-          spec.dependencies.sort_by { |dep| dep.name }.each do |dep|
-            say "#{dep.name} --version '#{dep.requirement}'"
-          end
-        end
-      end
+      display_pipe specs
     else
-      response = ''
-
-      specs.each do |spec|
-        response << print_dependencies(spec)
-        unless reverse[spec.full_name].empty? then
-          response << "  Used by\n"
-          reverse[spec.full_name].each do |sp, dep|
-            response << "    #{sp} (#{dep})\n"
-          end
-        end
-        response << "\n"
-      end
+      display_readable specs, reverse
+    end
+  end
 
-      say response
+  def ensure_local_only_reverse_dependencies # :nodoc:
+    if options[:reverse_dependencies] and remote? and not local? then
+      alert_error 'Only reverse dependencies for local gems are supported.'
+      terminate_interaction 1
     end
   end
 
-  def print_dependencies(spec, level = 0)
+  def ensure_specs specs # :nodoc:
+    return unless specs.empty?
+
+    patterns = options[:args].join ','
+    say "No gems found matching #{patterns} (#{options[:version]})" if
+      Gem.configuration.verbose
+
+    terminate_interaction 1
+  end
+
+  def print_dependencies(spec, level = 0) # :nodoc:
     response = ''
     response << '  ' * level + "Gem #{spec.full_name}\n"
     unless spec.dependencies.empty? then
@@ -131,10 +152,30 @@ class Gem::Commands::DependencyCommand < Gem::Command
     response
   end
 
+  def remote_specs dependency # :nodoc:
+    fetcher = Gem::SpecFetcher.fetcher
+
+    ss, _ = fetcher.spec_for_dependency dependency
+
+    ss.map { |s,o| s }
+  end
+
+  def reverse_dependencies specs # :nodoc:
+    reverse = Hash.new { |h, k| h[k] = [] }
+
+    return reverse unless options[:reverse_dependencies]
+
+    specs.each do |spec|
+      reverse[spec.full_name] = find_reverse_dependencies spec
+    end
+
+    reverse
+  end
+
   ##
   # Returns an Array of [specification, dep] that are satisfied by +spec+.
 
-  def find_reverse_dependencies(spec)
+  def find_reverse_dependencies spec # :nodoc:
     result = []
 
     Gem::Specification.each do |sp|

data/lib/rubygems/commands/environment_command.rb

@@ -69,66 +69,83 @@ lib/rubygems/defaults/operating_system.rb
   def execute
     out = ''
     arg = options[:args][0]
-    case arg
-    when /^packageversion/ then
-      out << Gem::RubyGemsPackageVersion
-    when /^version/ then
-      out << Gem::VERSION
-    when /^gemdir/, /^gemhome/, /^home/, /^GEM_HOME/ then
-      out << Gem.dir
-    when /^gempath/, /^path/, /^GEM_PATH/ then
-      out << Gem.path.join(File::PATH_SEPARATOR)
-    when /^remotesources/ then
-      out << Gem.sources.to_a.join("\n")
-    when /^platform/ then
-      out << Gem.platforms.join(File::PATH_SEPARATOR)
-    when nil then
-      out = "RubyGems Environment:\n"
-
-      out << "  - RUBYGEMS VERSION: #{Gem::VERSION}\n"
-
-      out << "  - RUBY VERSION: #{RUBY_VERSION} (#{RUBY_RELEASE_DATE}"
-      out << " patchlevel #{RUBY_PATCHLEVEL}" if defined? RUBY_PATCHLEVEL
-      out << ") [#{RUBY_PLATFORM}]\n"
-
-      out << "  - INSTALLATION DIRECTORY: #{Gem.dir}\n"
-
-      out << "  - RUBYGEMS PREFIX: #{Gem.prefix}\n" unless Gem.prefix.nil?
-
-      out << "  - RUBY EXECUTABLE: #{Gem.ruby}\n"
-
-      out << "  - EXECUTABLE DIRECTORY: #{Gem.bindir}\n"
-
-      out << "  - RUBYGEMS PLATFORMS:\n"
-      Gem.platforms.each do |platform|
-        out << "    - #{platform}\n"
+    out <<
+      case arg
+      when /^packageversion/ then
+        Gem::RubyGemsPackageVersion
+      when /^version/ then
+        Gem::VERSION
+      when /^gemdir/, /^gemhome/, /^home/, /^GEM_HOME/ then
+        Gem.dir
+      when /^gempath/, /^path/, /^GEM_PATH/ then
+        Gem.path.join(File::PATH_SEPARATOR)
+      when /^remotesources/ then
+        Gem.sources.to_a.join("\n")
+      when /^platform/ then
+        Gem.platforms.join(File::PATH_SEPARATOR)
+      when nil then
+        show_environment
+      else
+        raise Gem::CommandLineError, "Unknown environment option [#{arg}]"
       end
+    say out
+    true
+  end
 
-      out << "  - GEM PATHS:\n"
-      out << "     - #{Gem.dir}\n"
+  def add_path out, path
+    path.each do |component|
+      out << "     - #{component}\n"
+    end
+  end
 
-      path = Gem.path.dup
-      path.delete Gem.dir
-      path.each do |p|
-        out << "     - #{p}\n"
-      end
+  def show_environment # :nodoc:
+    out = "RubyGems Environment:\n"
 
-      out << "  - GEM CONFIGURATION:\n"
-      Gem.configuration.each do |name, value|
-        value = value.gsub(/./, '*') if name == 'gemcutter_key'
-        out << "     - #{name.inspect} => #{value.inspect}\n"
-      end
+    out << "  - RUBYGEMS VERSION: #{Gem::VERSION}\n"
 
-      out << "  - REMOTE SOURCES:\n"
-      Gem.sources.each do |s|
-        out << "     - #{s}\n"
-      end
+    out << "  - RUBY VERSION: #{RUBY_VERSION} (#{RUBY_RELEASE_DATE}"
+    out << " patchlevel #{RUBY_PATCHLEVEL}" if defined? RUBY_PATCHLEVEL
+    out << ") [#{RUBY_PLATFORM}]\n"
+
+    out << "  - INSTALLATION DIRECTORY: #{Gem.dir}\n"
+
+    out << "  - RUBYGEMS PREFIX: #{Gem.prefix}\n" unless Gem.prefix.nil?
+
+    out << "  - RUBY EXECUTABLE: #{Gem.ruby}\n"
+
+    out << "  - EXECUTABLE DIRECTORY: #{Gem.bindir}\n"
 
-    else
-      raise Gem::CommandLineError, "Unknown environment option [#{arg}]"
+    out << "  - SPEC CACHE DIRECTORY: #{Gem.spec_cache_dir}\n"
+
+    out << "  - RUBYGEMS PLATFORMS:\n"
+    Gem.platforms.each do |platform|
+      out << "    - #{platform}\n"
     end
-    say out
-    true
+
+    out << "  - GEM PATHS:\n"
+    out << "     - #{Gem.dir}\n"
+
+    gem_path = Gem.path.dup
+    gem_path.delete Gem.dir
+    add_path out, gem_path
+
+    out << "  - GEM CONFIGURATION:\n"
+    Gem.configuration.each do |name, value|
+      value = value.gsub(/./, '*') if name == 'gemcutter_key'
+      out << "     - #{name.inspect} => #{value.inspect}\n"
+    end
+
+    out << "  - REMOTE SOURCES:\n"
+    Gem.sources.each do |s|
+      out << "     - #{s}\n"
+    end
+
+    out << "  - SHELL PATH:\n"
+
+    shell_path = ENV['PATH'].split(File::PATH_SEPARATOR)
+    add_path out, shell_path
+
+    out
   end
 
 end

data/lib/rubygems/commands/fetch_command.rb

@@ -43,13 +43,12 @@ class Gem::Commands::FetchCommand < Gem::Command
       dep.prerelease = options[:prerelease]
 
       specs_and_sources, errors = Gem::SpecFetcher.fetcher.spec_for_dependency dep
-
       if platform then
         filtered = specs_and_sources.select { |s,| s.platform == platform }
         specs_and_sources = filtered unless filtered.empty?
       end
 
-      spec, source = specs_and_sources.max_by { |s,| s.version }
+      spec, source = specs_and_sources.sort_by { |s,| s.version }.first
 
       if spec.nil? then
         show_lookup_failure gem_name, version, errors, options[:domain]

data/lib/rubygems/commands/help_command.rb

@@ -46,6 +46,10 @@ Some examples of 'gem' usage.
 * Update all gems on your system:
 
     gem update
+
+* Update your local version of RubyGems
+
+    gem update --system
   EOF
 
   PLATFORMS = <<-'EOF'
@@ -55,8 +59,9 @@ your current platform by running `gem environment`.
 
 RubyGems matches platforms as follows:
 
-  * The CPU must match exactly, unless one of the platforms has
-    "universal" as the CPU.
+  * The CPU must match exactly unless one of the platforms has
+    "universal" as the CPU or the local CPU starts with "arm" and the gem's
+    CPU is exactly "arm" (for gems that support generic ARM architecture).
   * The OS must match exactly.
   * The versions must match exactly unless one of the versions is nil.
 
@@ -66,11 +71,20 @@ you pass must match "#{cpu}-#{os}" or "#{cpu}-#{os}-#{version}".  On mswin
 platforms, the version is the compiler version, not the OS version.  (Ruby
 compiled with VC6 uses "60" as the compiler version, VC8 uses "80".)
 
+For the ARM architecture, gems with a platform of "arm-linux" should run on a
+reasonable set of ARM CPUs and not depend on instructions present on a limited
+subset of the architecture.  For example, the binary should run on platforms
+armv5, armv6hf, armv6l, armv7, etc.  If you use the "arm-linux" platform
+please test your gem on a variety of ARM hardware before release to ensure it
+functions correctly.
+
 Example platforms:
 
   x86-freebsd        # Any FreeBSD version on an x86 CPU
   universal-darwin-8 # Darwin 8 only gems that run on any CPU
   x86-mswin32-80     # Windows gems compiled with VC8
+  armv7-linux        # Gem complied for an ARMv7 CPU running linux
+  arm-linux          # Gem compiled for any ARM CPU running linux
 
 When building platform gems, set the platform in the gem specification to
 Gem::Platform::CURRENT.  This will correctly mark the gem with your ruby's
@@ -80,6 +94,8 @@ platform.
 
   def initialize
     super 'help', "Provide help on the 'gem' command"
+
+    @command_manager = Gem::CommandManager.instance
   end
 
   def arguments # :nodoc:
@@ -96,46 +112,10 @@ platform.
   end
 
   def execute
-    command_manager = Gem::CommandManager.instance
     arg = options[:args][0]
 
     if begins? "commands", arg then
-      out = []
-      out << "GEM commands are:"
-      out << nil
-
-      margin_width = 4
-
-      desc_width = command_manager.command_names.map { |n| n.size }.max + 4
-
-      summary_width = 80 - margin_width - desc_width
-      wrap_indent = ' ' * (margin_width + desc_width)
-      format = "#{' ' * margin_width}%-#{desc_width}s%s"
-
-      command_manager.command_names.each do |cmd_name|
-        command = command_manager[cmd_name]
-
-        summary =
-          if command then
-            command.summary
-          else
-            "[No command found for #{cmd_name}, bug?]"
-          end
-
-        summary = wrap(summary, summary_width).split "\n"
-        out << sprintf(format, cmd_name, summary.shift)
-        until summary.empty? do
-          out << "#{wrap_indent}#{summary.shift}"
-        end
-      end
-
-      out << nil
-      out << "For help on a particular command, use 'gem help COMMAND'."
-      out << nil
-      out << "Commands may be abbreviated, so long as they are unambiguous."
-      out << "e.g. 'gem i rake' is short for 'gem install rake'."
-
-      say out.join("\n")
+      show_commands
 
     elsif begins? "options", arg then
       say Gem::Command::HELP
@@ -147,29 +127,79 @@ platform.
       say PLATFORMS
 
     elsif options[:help] then
-      command = command_manager[options[:help]]
-      if command
-        # help with provided command
-        command.invoke("--help")
-      else
-        alert_error "Unknown command #{options[:help]}.  Try 'gem help commands'"
-      end
+      show_help
 
     elsif arg then
-      possibilities = command_manager.find_command_possibilities(arg.downcase)
-      if possibilities.size == 1
-        command = command_manager[possibilities.first]
-        command.invoke("--help")
-      elsif possibilities.size > 1
-        alert_warning "Ambiguous command #{arg} (#{possibilities.join(', ')})"
-      else
-        alert_warning "Unknown command #{arg}. Try gem help commands"
-      end
+      show_command_help arg
 
     else
       say Gem::Command::HELP
     end
   end
 
+  def show_commands # :nodoc:
+    out = []
+    out << "GEM commands are:"
+    out << nil
+
+    margin_width = 4
+
+    desc_width = @command_manager.command_names.map { |n| n.size }.max + 4
+
+    summary_width = 80 - margin_width - desc_width
+    wrap_indent = ' ' * (margin_width + desc_width)
+    format = "#{' ' * margin_width}%-#{desc_width}s%s"
+
+    @command_manager.command_names.each do |cmd_name|
+      command = @command_manager[cmd_name]
+
+      summary =
+        if command then
+          command.summary
+        else
+          "[No command found for #{cmd_name}]"
+        end
+
+      summary = wrap(summary, summary_width).split "\n"
+      out << sprintf(format, cmd_name, summary.shift)
+      until summary.empty? do
+        out << "#{wrap_indent}#{summary.shift}"
+      end
+    end
+
+    out << nil
+    out << "For help on a particular command, use 'gem help COMMAND'."
+    out << nil
+    out << "Commands may be abbreviated, so long as they are unambiguous."
+    out << "e.g. 'gem i rake' is short for 'gem install rake'."
+
+    say out.join("\n")
+  end
+
+  def show_command_help command_name # :nodoc:
+    command_name = command_name.downcase
+
+    possibilities = @command_manager.find_command_possibilities command_name
+
+    if possibilities.size == 1 then
+      command = @command_manager[possibilities.first]
+      command.invoke("--help")
+    elsif possibilities.size > 1 then
+      alert_warning "Ambiguous command #{command_name} (#{possibilities.join(', ')})"
+    else
+      alert_warning "Unknown command #{command_name}.  Try: gem help commands"
+    end
+  end
+
+  def show_help # :nodoc:
+    command = @command_manager[options[:help]]
+    if command then
+      # help with provided command
+      command.invoke("--help")
+    else
+      alert_error "Unknown command #{options[:help]}.  Try 'gem help commands'"
+    end
+  end
+
 end