rubygems-update 0.8.6 → 0.8.8

data/lib/rubygems/cmd_manager.rb

@@ -37,10 +37,12 @@ module Gem
       register_command UninstallCommand.new
       register_command CheckCommand.new
       register_command BuildCommand.new
+      register_command DependencyCommand.new
       register_command QueryCommand.new
       register_command ListCommand.new
       register_command SearchCommand.new
       register_command UpdateCommand.new
+      register_command CleanupCommand.new
       register_command RDocCommand.new
       register_command EnvironmentCommand.new
       register_command SpecificationCommand.new
@@ -111,7 +113,7 @@ module Gem
     #  - if it's specified multiple times, the first one wins 
     #  - there is a default config file location HOME/.gemrc
     def load_config_file_options(args)
-      config_file = File.join(ENV['HOME'], ".gemrc")
+      config_file = Gem.config_file
       if args.index("--config-file")
         config_file = args[args.index("--config-file")+1]
       end

data/lib/rubygems/command.rb

@@ -78,6 +78,10 @@ module Gem
 
     private
 
+    def command_manager
+      Gem::CommandManager.instance
+    end
+
     def handle_options(args)
       args = add_extra_args(args)
       @options = @defaults.clone

data/lib/rubygems/config_file.rb

@@ -13,13 +13,13 @@ module Gem
       rescue ArgumentError
         warn "Failed to load #{config_file_name}"
       rescue Errno::ENOENT
-        warn "Config file #{config_file_name} does not exist"
+        # Ignore missing config file error.
       end
       @hash ||= {}
     end
 
     def config_file_name
-      @config_file_name || default_config_file_name
+      @config_file_name || Gem.config_file
     end
 
     def [](key)
@@ -51,10 +51,6 @@ module Gem
 	end
       end
     end
-
-    def default_config_file_name
-      File.join(ENV['HOME'], '.gemrc')
-    end
   end
 
 end

data/lib/rubygems/custom_require.rb

@@ -93,8 +93,8 @@ module Gem
     # Return a list of all installed gemspecs, sorted by alphabetical order and in reverse
     # version order.
     def init_gemspecs
-      Gem.source_index.map { |_, spec| spec }.sort_by { |spec|
-        [spec.name, spec.version.to_ints.map { |n| -n } ]
+      Gem.source_index.map { |_, spec| spec }.sort { |a,b|
+	(a.name <=> b.name).nonzero? || (b.version <=> a.version)
       }
     end
 

data/lib/rubygems/dependency_list.rb

@@ -0,0 +1,131 @@
+#!/usr/bin/env ruby
+
+module Gem
+  class DependencyList
+    def self.from_source_index(src_index)
+      deps = DependencyList.new
+      src_index.each do |full_name, spec|
+	deps.add(spec)
+      end
+      deps
+    end
+
+    def initialize
+      @specs = []
+    end
+
+    # Are all the dependencies in the list satisfied?
+    def ok?
+      @specs.all? { |spec|
+	spec.dependencies.all? { |dep|
+	  @specs.find { |s| s.satisfies_requirement?(dep) }
+	}
+      }
+    end
+
+    # Add a gemspec to the dependency list.
+    def add(gemspec)
+      @specs << gemspec
+    end
+
+    def find_name(full_name)
+      @specs.find { |spec| spec.full_name == full_name }
+    end
+
+    def remove_by_name(full_name)
+      @specs.delete_if { |spec| spec.full_name == full_name }
+    end
+
+    # Is is ok to remove a gem from the dependency list?
+    #
+    # If removing the gemspec creates breaks a currently ok dependency,
+    # then it is NOT ok to remove the gem.
+    def ok_to_remove?(full_name)
+      gem_to_remove = find_name(full_name)
+      siblings = @specs.find_all { |s|
+	s.name == gem_to_remove.name &&
+	  s.full_name != gem_to_remove.full_name	
+      }
+      deps = []
+      @specs.each do |spec|
+	spec.dependencies.each do |dep|
+	  deps << dep if gem_to_remove.satisfies_requirement?(dep)
+	end
+      end
+      deps.all? { |dep|
+	siblings.any? { |s| 
+	  s.satisfies_requirement?(dep)
+	}
+      }
+    end
+
+    # Return a list of the specifications in the dependency list,
+    # sorted in order so that no spec in the list depends on a gem
+    # earlier in the list.
+    #
+    # This is useful when removing gems from a set of installed gems.
+    # By removing them in the returned order, you don't get into as
+    # many dependency issues.
+    #
+    # If there are circular dependencies (yuck!), then gems will be
+    # returned in order until only the circular dependents and anything
+    # they reference are left.  Then arbitrary gemspecs will be returned
+    # until the circular dependency is broken, after which gems will be
+    # returned in dependency order again.  
+    def dependency_order
+      result = []
+      disabled = {}
+      predecessors = build_predecessors
+      while disabled.size < @specs.size
+	candidate = @specs.find { |spec|
+	  ! disabled[spec.full_name] &&
+	    active_count(predecessors[spec.full_name], disabled) == 0
+	}
+	if candidate
+	  disabled[candidate.full_name] = true
+	  result << candidate
+	elsif candidate = @specs.find { |spec| ! disabled[spec.full_name] }
+	  # This case handles circular dependencies.  Just choose a
+	  # candidate and move on.
+	  disabled[candidate.full_name] = true
+	  result << candidate
+	else
+	  # We should never get here, but just in case we will terminate 
+	  # the loop.
+	  break
+	end
+      end
+      result
+    end
+
+    private
+
+    # Count the number of gemspecs in the list +specs+ that are still
+    # active (e.g. not listed in the ignore hash).
+    def active_count(specs, ignored)
+      result = 0
+      specs.each do |spec|
+	result += 1 unless ignored[spec.full_name]
+      end
+      result
+    end
+
+    # Return a hash of predecessors.  E.g. results[spec.full_name] is a
+    # list of gemspecs that have a dependency satisfied by spec.
+    def build_predecessors
+      result = Hash.new { |h,k| h[k] = [] }
+      @specs.each do |spec|
+	@specs.each do |other|
+	  next if spec.full_name == other.full_name
+	  other.dependencies.each do |dep|
+	    if spec.satisfies_requirement?(dep)
+	      result[spec.full_name] << other
+	    end
+	  end
+	end
+      end
+      result
+    end
+
+  end
+end

data/lib/rubygems/deployment.rb

@@ -0,0 +1,265 @@
+# The following is borrowed from setup.rb
+
+def File.binread(fname)
+  open(fname, 'rb') {|f|
+    return f.read
+  }
+end
+
+# for corrupted windows stat(2)
+def File.dir?(path)
+  File.directory?((path[-1,1] == '/') ? path : path + '/')
+end
+
+
+module Gem
+  
+  module Deployment
+
+    # The following is borrowed from setup.rb
+    module FileOperations
+
+      def mkdir_p(dirname, prefix = nil)
+        dirname = prefix + File.expand_path(dirname) if prefix
+        $stderr.puts "mkdir -p #{dirname}" if verbose?
+        return if no_harm?
+
+        # does not check '/'... it's too abnormal case
+        dirs = File.expand_path(dirname).split(%r<(?=/)>)
+        if /\A[a-z]:\z/i =~ dirs[0]
+          disk = dirs.shift
+          dirs[0] = disk + dirs[0]
+        end
+        dirs.each_index do |idx|
+          path = dirs[0..idx].join('')
+          Dir.mkdir path unless File.dir?(path)
+        end
+      end
+
+      def rm_f(fname)
+        $stderr.puts "rm -f #{fname}" if verbose?
+        return if no_harm?
+
+        if File.exist?(fname) or File.symlink?(fname)
+          File.chmod 0777, fname
+          File.unlink fname
+        end
+      end
+
+      def rm_rf(dn)
+        $stderr.puts "rm -rf #{dn}" if verbose?
+        return if no_harm?
+
+        Dir.chdir dn
+        Dir.foreach('.') do |fn|
+          next if fn == '.'
+          next if fn == '..'
+          if File.dir?(fn)
+            verbose_off {
+              rm_rf fn
+            }
+          else
+            verbose_off {
+              rm_f fn
+            }
+          end
+        end
+        Dir.chdir '..'
+        Dir.rmdir dn
+      end
+
+      def no_harm?
+        false
+      end
+
+      def verbose?
+        false
+      end
+
+      def verbose_off(&block)
+        block.call
+      end
+
+    end
+  
+    class Manager
+    
+      DEPLOYMENTS_DIR = "."
+      DEPLOYMENTS_DB = "deployments.yaml"
+      
+      attr_reader :deployments
+    
+      def initialize(dir = DEPLOYMENTS_DIR, db = DEPLOYMENTS_DB)
+        require 'yaml'
+        require 'digest/sha1'
+        @db_file = File.expand_path(File.join(dir, db))
+        if File.exist?(@db_file)
+          @deployments = YAML.load(File.binread(@db_file))
+          @deployments.each {|deployment| deployment.manager = self}
+        else
+          @deployments = []
+        end
+      end
+      
+      def new_deployment(target_dir = nil)
+        unless target_dir
+          require 'rbconfig'
+          target_dir = Config::CONFIG['sitelibdir']
+        end
+        target_dir = File.expand_path(target_dir)
+        deployment = self[target_dir]
+        unless deployment
+          deployment = ActiveDeployment.new(target_dir)
+          deployment.manager = self
+          @deployments << deployment
+        end
+        deployment
+      end
+    
+      def persist
+        File.open(@db_file, "wb") {|f| f.puts @deployments.to_yaml}
+      end
+    
+      def [](target_dir)
+        target_dir = File.expand_path(target_dir)
+        @deployments.each {|deployment| return deployment if deployment.target_directory == target_dir}
+        nil
+      end
+    end
+  
+    class ActiveDeployment
+      attr_reader :target_directory, :deployed_gems
+      attr_accessor :manager
+    
+      def initialize(target_directory)
+        @target_directory = target_directory
+        @deployed_gems = []
+      end
+
+      def to_yaml_properties
+        ['@target_directory', '@deployed_gems']
+      end
+
+      def prepare
+        @deployed_gems.each {|gem| gem.prepare}
+      end
+    
+      def deploy
+        @deployed_gems.each {|gem| gem.deploy}
+        if fully_deployed?
+          @manager.persist
+        else
+          raise "ERROR: Did not fully deploy"
+        end
+      end
+
+      def fully_deployed?
+        @deployed_gems.each {|gem| return false unless gem.deployed?}
+        return true
+      end
+    
+      def add_all_gems
+        Gem.source_index.each do |name, spec|
+          @deployed_gems << DeployedGem.new(spec, @target_directory)
+        end
+        self
+      end
+    
+      def add_gem(gem_to_add)
+        @deployed_gems.each {|dg| return if gem_to_add.full_name == dg.gem_name}
+        @deployed_gems << DeployedGem.new(gem_to_add, @target_directory)
+        return self if gem_to_add.dependencies.size == 0
+        # must fulfill dependencies
+        sats = {}
+        Gem.source_index.each do |name, gem|
+          gem_to_add.dependencies.each do |dependency|
+            (sats[dependency] ||= []) << gem if gem.satisfies_requirement?(dependency)
+          end
+        end
+        sats.each_value {|list| add_gem list.sort.last}
+        self
+      end
+    end
+
+    class DeployedGem
+      attr_reader :specification, :gem_name, :gem_path, :deployed_files
+      
+      def initialize(spec, target_directory)
+        @gem_name = spec.full_name
+        @gem_path = spec.full_gem_path
+        @lib_paths = spec.require_paths
+        @target_directory = target_directory
+        @deployed_files = []
+      end
+
+      def to_yaml_properties
+        ['@gem_name', '@gem_path', '@lib_paths', '@target_directory', '@deployed_files']
+      end
+      
+      def prepare
+        paths = @lib_paths.collect {|lib_path| File.expand_path(File.join(gem_path, lib_path))}
+        paths.each do |path|
+          Dir.glob("#{path}/**/*").each do |file|
+            unless File.directory?(file)
+              @deployed_files << DeployedFile.new(file, File.join(@target_directory, file[(path.size+1)..-1]))
+            end
+          end
+        end
+        @deployed_files.each {|df| df.prepare}
+      end
+      
+      def deploy
+        @deployed_files.each {|file| file.deploy}
+      end
+      
+      def deployed?
+        @deployed_files.each {|file| return false unless file.deployed?}
+        return true
+      end
+    end
+    
+    class DeployedFile
+      
+      include FileOperations
+      
+      attr_reader :source_path, :destination_path, :checksum
+      
+      def initialize(source_path, destination_path)
+        @source_path = source_path
+        @destination_path = destination_path
+      end
+      
+      def to_yaml_properties
+        ['@source_path', '@destination_path', '@checksum']
+      end
+      
+      def prepare
+        @checksum ||= Digest::SHA1.new(File.binread(@source_path)).hexdigest
+      end
+      
+      def deploy
+        return if deployed?
+        File.open(@source_path, "rb") do |source| 
+          mkdir_p(File.dirname(@destination_path))
+          File.open(@destination_path, "wb") do |destination|
+            destination.write(source.read)
+          end
+        end
+      end
+
+      def deployed?
+        return false unless File.exist?(@destination_path)
+        return false if File.size(@source_path) != File.size(@destination_path)
+        new_checksum = nil
+        begin
+          new_checksum = Digest::SHA1.new(File.binread(@destination_path)).hexdigest
+        rescue
+          puts $!
+          puts $!.backtrace.join("\n")
+        end
+        new_checksum == @checksum
+      end
+    end
+    
+  end
+end