rubygems-update 0.9.4 → 0.9.5

data/lib/rubygems/commands/list_command.rb

@@ -1,7 +1,9 @@
+require 'rubygems/command'
+require 'rubygems/commands/query_command'
+
 module Gem
   module Commands
     class ListCommand < QueryCommand
-      include CommandAids
 
       def initialize
         super(
@@ -11,16 +13,16 @@ module Gem
         remove_option('--name-matches')
       end
 
-      def defaults_str
-        "--local --no-details"
+      def arguments # :nodoc:
+        "STRING        start of gem name to look for"
       end
 
-      def usage
-        "#{program_name} [STRING]"
+      def defaults_str # :nodoc:
+        "--local --no-details"
       end
 
-      def arguments
-        "STRING   start of gem name to look for"
+      def usage # :nodoc:
+        "#{program_name} [STRING]"
       end
 
       def execute
@@ -30,4 +32,4 @@ module Gem
       end
     end
   end
-end
+end

data/lib/rubygems/commands/lock_command.rb

@@ -0,0 +1,101 @@
+require 'rubygems/command'
+
+class Gem::Commands::LockCommand < Gem::Command
+
+  def initialize
+    super 'lock', 'Generate a lockdown list of gems',
+          :strict => false
+
+    add_option '-s', '--[no-]strict',
+               'fail if unable to satisfy a dependency' do |strict, options|
+      options[:strict] = strict
+    end
+  end
+
+  def arguments # :nodoc:
+    "GEMNAME       name of gem to lock\nVERSION       version of gem to lock"
+  end
+
+  def defaults_str # :nodoc:
+    "--no-strict"
+  end
+
+  def description # :nodoc:
+    <<-EOF
+The lock command will generate a list of +gem+ statements that will lock down
+the versions for the gem given in the command line.  It will specify exact
+versions in the requirements list to ensure that the gems loaded will always
+be consistent.  A full recursive search of all effected gems will be
+generated.
+
+Example:
+
+  gemlock rails-1.0.0 > lockdown.rb
+
+will produce in lockdown.rb:
+
+  require "rubygems"
+  gem 'rails', '= 1.0.0'
+  gem 'rake', '= 0.7.0.1'
+  gem 'activesupport', '= 1.2.5'
+  gem 'activerecord', '= 1.13.2'
+  gem 'actionpack', '= 1.11.2'
+  gem 'actionmailer', '= 1.1.5'
+  gem 'actionwebservice', '= 1.0.0'
+
+Just load lockdown.rb from your application to ensure that the current
+versions are loaded.  Make sure that lockdown.rb is loaded *before* any
+other require statements.
+
+Notice that rails 1.0.0 only requires that rake 0.6.2 or better be used.
+Rake-0.7.0.1 is the most recent version installed that satisfies that, so we
+lock it down to the exact version.
+    EOF
+  end
+
+  def usage # :nodoc:
+    "#{program_name} GEMNAME-VERSION [GEMNAME-VERSION ...]"
+  end
+
+  def complain(message)
+    if options.strict then
+      raise message
+    else
+      say "# #{message}"
+    end
+  end
+
+  def execute
+    say 'require "rubygems"'
+
+    locked = {}
+
+    pending = options[:args]
+
+    until pending.empty? do
+      full_name = pending.shift
+
+      spec = Gem::SourceIndex.load_specification spec_path(full_name)
+
+      say "gem '#{spec.name}', '= #{spec.version}'" unless locked[spec.name]
+      locked[spec.name] = true
+
+      spec.dependencies.each do |dep|
+        next if locked[dep.name]
+        candidates = Gem.source_index.search dep.name, dep.requirement_list
+
+        if candidates.empty? then
+          complain "Unable to satisfy '#{dep}' from currently installed gems."
+        else
+          pending << candidates.last.full_name
+        end
+      end
+    end
+  end
+
+  def spec_path(gem_full_name)
+    File.join Gem.path, "specifications", "#{gem_full_name }.gemspec"
+  end
+
+end
+

data/lib/rubygems/commands/mirror_command.rb

@@ -0,0 +1,105 @@
+require 'yaml'
+require 'zlib'
+
+require 'rubygems/command'
+require 'rubygems/gem_open_uri'
+
+class Gem::Commands::MirrorCommand < Gem::Command
+
+  def initialize
+    super 'mirror', 'Mirror a gem repository'
+  end
+
+  def description # :nodoc:
+    <<-EOF
+The mirror command uses the ~/.gemmirrorrc config file to mirror remote gem
+repositories to a local path. The config file is a YAML document that looks
+like this:
+
+  ---
+  - from: http://gems.example.com # source repository URI
+    to: /path/to/mirror           # destination directory
+
+Multiple sources and destinations may be specified.
+    EOF
+  end
+
+  def execute
+    config_file = File.join Gem.user_home, '.gemmirrorrc'
+
+    raise "Config file #{config_file} not found" unless File.exist? config_file
+
+    mirrors = YAML.load_file config_file
+
+    raise "Invalid config file #{config_file}" unless mirrors.respond_to? :each
+
+    mirrors.each do |mir|
+      raise "mirror missing 'from' field" unless mir.has_key? 'from'
+      raise "mirror missing 'to' field" unless mir.has_key? 'to'
+
+      get_from = mir['from']
+      save_to = File.expand_path mir['to']
+
+      raise "Directory not found: #{save_to}" unless File.exist? save_to
+      raise "Not a directory: #{save_to}" unless File.directory? save_to
+
+      gems_dir = File.join save_to, "gems"
+
+      if File.exist? gems_dir then
+        raise "Not a directory: #{gems_dir}" unless File.directory? gems_dir
+      else
+        Dir.mkdir gems_dir
+      end
+
+      sourceindex_data = ''
+
+      say "fetching: #{get_from}/Marshal.#{Gem.marshal_version}.Z"
+
+      get_from = URI.parse get_from
+
+      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]
+      end
+
+      open File.join(get_from, "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
+        end
+      end
+
+      sourceindex = Marshal.load(sourceindex_data)
+
+      progress = ui.progress_reporter sourceindex.size,
+                                      "Fetching #{sourceindex.size} gems"
+      sourceindex.each do |fullname, gem|
+        gem_file = "#{fullname}.gem"
+        gem_dest = File.join gems_dir, gem_file
+
+        unless File.exist? gem_dest then
+          begin
+            open "#{get_from}/gems/#{gem_file}", "rb" do |g|
+              contents = g.read
+              open gem_dest, "wb" do |out|
+                out.write contents
+              end
+            end
+          rescue
+            old_gf = gem_file
+            gem_file = gem_file.downcase
+            retry if old_gf != gem_file
+            alert_error $!
+          end
+        end
+
+        progress.updated gem_file
+      end
+
+      progress.done
+    end
+  end
+
+end
+

data/lib/rubygems/commands/outdated_command.rb

@@ -1,21 +1,30 @@
-module Gem
-  module Commands
+require 'rubygems/command'
+require 'rubygems/local_remote_options'
+require 'rubygems/source_info_cache'
+require 'rubygems/version_option'
 
-    class OutdatedCommand < Command
+class Gem::Commands::OutdatedCommand < Gem::Command
 
-      def initialize
-        super 'outdated', 'Display all gems that need updates'
-      end
+  include Gem::LocalRemoteOptions
+  include Gem::VersionOption
 
-      def execute
-        locals = Gem::SourceIndex.from_installed_gems
-        locals.outdated.each do |name|
-          local = locals.search(/^#{name}$/).last
-          remote = Gem::SourceInfoCache.search(/^#{name}$/).last
-          say "#{local.name} (#{local.version} < #{remote.version})"
-        end
-      end
+  def initialize
+    super 'outdated', 'Display all gems that need updates'
 
+    add_local_remote_options
+    add_platform_option
+  end
+
+  def execute
+    locals = Gem::SourceIndex.from_installed_gems
+
+    locals.outdated.sort.each do |name|
+      local = locals.search(/^#{name}$/).last
+      remotes = Gem::SourceInfoCache.search_with_source(/^#{name}$/, true)
+      remote = remotes.last.first
+      say "#{local.name} (#{local.version} < #{remote.version})"
     end
   end
-end
+
+end
+

data/lib/rubygems/commands/pristine_command.rb

@@ -1,103 +1,133 @@
-module Gem
-  module Commands
-    class PristineCommand < Command
-      include VersionOption
-      include CommandAids
-      def initialize
-        super('pristine',
-          'Restores gem directories to pristine condition from files located in the gem cache',
-          {
-            :version => "> 0.0.0"
-          })
-        add_option('--all',
-          'Restore all installed gems to pristine', 'condition'
-          ) do |value, options|
-          options[:all] = value
-        end
-        add_version_option('restore to', 'pristine condition')
-      end
+require 'fileutils'
+require 'rubygems/command'
+require 'rubygems/format'
+require 'rubygems/installer'
+require 'rubygems/version_option'
 
-      def defaults_str
-        "--all"
-      end
+class Gem::Commands::PristineCommand < Gem::Command
 
-      def usage
-        "#{program_name} [args]"
-      end
+  include Gem::VersionOption
 
-      def arguments
-        "GEMNAME          The gem to restore to pristine condition (unless --all)"
-      end
+  def initialize
+    super 'pristine',
+          'Restores installed gems to pristine condition from files located in the gem cache',
+          :version => Gem::Requirement.default
 
-      def execute
-        say "Restoring gem(s) to pristine condition..."
-        if options[:all]
-          all_gems = true
-          specs = Gem::SourceIndex.from_installed_gems.collect do |name, spec|
-            spec
-          end
-        else
-          all_gems = false
-          gem_name = get_one_gem_name
-          specs = Gem::SourceIndex.from_installed_gems.search(gem_name, options[:version])
-        end
+    add_option('--all',
+               'Restore all installed gems to pristine',
+               'condition') do |value, options|
+      options[:all] = value
+    end
 
-        if specs.empty?
-          fail "Failed to find gem #{gem_name} #{options[:version]} to restore to pristine condition"
-        end
-        install_dir = Gem.dir # TODO use installer option
-        raise Gem::FilePermissionError.new(install_dir) unless File.writable?(install_dir)
-
-        gems_were_pristine = true
-
-        specs.each do |spec|
-          installer = Gem::Installer.new nil, :wrappers => true # HACK ugly TODO use installer option
-
-          gem_file = File.join(install_dir, "cache", "#{spec.full_name}.gem")
-          security_policy = nil # TODO use installer option
-          format = Gem::Format.from_file_by_path(gem_file, security_policy)
-          target_directory = File.join(install_dir, "gems", format.spec.full_name).untaint
-          pristine_files = format.file_entries.collect {|data| data[0]["path"]}
-          file_map = {}
-          format.file_entries.each {|entry, file_data| file_map[entry["path"]] = file_data}
-          require 'fileutils'
-
-          Dir.chdir target_directory do
-            deployed_files = Dir.glob(File.join("**", "*")) +
-                             Dir.glob(File.join("**", ".*"))
-            to_redeploy = (pristine_files - deployed_files).collect {|path| path.untaint}
-            if to_redeploy.length > 0
-              gems_were_pristine = false
-              say "Restoring #{to_redeploy.length} file#{to_redeploy.length == 1 ? "" : "s"} to #{spec.full_name}..."
-              to_redeploy.each do |path|
-                say "  #{path}"
-                FileUtils.mkdir_p File.dirname(path)
-                File.open(path, "wb") do |out|
-                  out.write file_map[path]
-                end
+    add_version_option('restore to', 'pristine condition')
+  end
+
+  def arguments # :nodoc:
+    "GEMNAME       gem to restore to pristine condition (unless --all)"
+  end
+
+  def defaults_str # :nodoc:
+    "--all"
+  end
+
+  def description # :nodoc:
+    <<-EOF
+The pristine command compares the installed gems with the contents of the
+cached gem and restores any files that don't match the cached gem's copy.
+
+If you have made modifications to your installed gems, the pristine command
+will revert them.  After all the gem's files have been checked all bin stubs
+for the gem are regenerated.
+
+If the cached gem cannot be found, you will need to use `gem install` to
+revert the gem.
+    EOF
+  end
+
+  def usage # :nodoc:
+    "#{program_name} [args]"
+  end
+
+  def execute
+    gem_name = nil
+
+    specs = if options[:all] then
+              Gem::SourceIndex.from_installed_gems.map do |name, spec|
+                spec
               end
+            else
+              gem_name = get_one_gem_name
+              Gem::SourceIndex.from_installed_gems.search(gem_name,
+                                                          options[:version])
             end
-          end
 
-          installer.generate_bin spec, install_dir
-        end
+    if specs.empty? then
+      raise Gem::Exception,
+            "Failed to find gem #{gem_name} #{options[:version]}"
+    end
+
+    install_dir = Gem.dir # TODO use installer option
+
+    raise Gem::FilePermissionError.new(install_dir) unless
+      File.writable?(install_dir)
+
+    say "Restoring gem(s) to pristine condition..."
+
+    specs.each do |spec|
+      gem = Dir[File.join(Gem.dir, 'cache', "#{spec.full_name}.gem")].first
+
+      if gem.nil? then
+        alert_error "Cached gem for #{spec.full_name} not found, use `gem install` to restore"
+        next
+      end
+
+      # TODO use installer options
+      installer = Gem::Installer.new gem, :wrappers => true
+
+      gem_file = File.join install_dir, "cache", "#{spec.full_name}.gem"
+
+      security_policy = nil # TODO use installer option
+
+      format = Gem::Format.from_file_by_path gem_file, security_policy
+
+      target_directory = File.join(install_dir, "gems", format.spec.full_name)
+      target_directory.untaint
 
-        say "Rebuilt all bin stubs"
+      pristine_files = format.file_entries.collect { |data| data[0]["path"] }
+      file_map = {}
 
-        if gems_were_pristine
-          if all_gems
-            say "All installed gem files are already in pristine condition"
-          else
-            say "#{specs[0].full_name} is already in pristine condition"
+      format.file_entries.each do |entry, file_data|
+        file_map[entry["path"]] = file_data
+      end
+
+      Dir.chdir target_directory do
+        deployed_files = Dir.glob(File.join("**", "*")) +
+                         Dir.glob(File.join("**", ".*"))
+
+        pristine_files = pristine_files.map { |f| File.expand_path f }
+        deployed_files = deployed_files.map { |f| File.expand_path f }
+
+        to_redeploy = (pristine_files - deployed_files)
+        to_redeploy = to_redeploy.map { |path| path.untaint}
+
+        if to_redeploy.length > 0 then
+          say "Restoring #{to_redeploy.length} file#{to_redeploy.length == 1 ? "" : "s"} to #{spec.full_name}..."
+
+          to_redeploy.each do |path|
+            say "  #{path}"
+            FileUtils.mkdir_p File.dirname(path)
+            File.open(path, "wb") do |out|
+              out.write file_map[path]
+            end
           end
         else
-          if all_gems
-            say "All installed gem files restored to pristine condition"
-          else
-            say "#{specs[0].full_name} restored to pristine condition"
-          end
+          say "#{spec.full_name} is in pristine condition"
         end
       end
-    end    
+
+      installer.generate_bin
+    end
   end
-end
+
+end
+