rubygems-update 0.9.4 → 0.9.5

data/lib/rubygems/dependency.rb

@@ -0,0 +1,65 @@
+#--
+# Copyright 2006 by Chad Fowler, Rich Kilmer, Jim Weirich and others.
+# All rights reserved.
+# See LICENSE.txt for permissions.
+#++
+
+require 'rubygems'
+
+##
+# The Dependency class holds a Gem name and a Gem::Requirement
+class Gem::Dependency
+
+  attr_accessor :name
+
+  attr_writer :version_requirements
+
+  def <=>(other)
+    [@name] <=> [other.name]
+  end
+
+  ##
+  # Constructs the dependency
+  #
+  # name:: [String] name of the Gem
+  # version_requirements:: [String Array] version requirement (e.g. ["> 1.2"])
+  #
+  def initialize(name, version_requirements)
+    @name = name
+    @version_requirements = Gem::Requirement.create version_requirements
+    @version_requirement = nil   # Avoid warnings.
+  end
+
+  def version_requirements
+    normalize if defined? @version_requirement and @version_requirement
+    @version_requirements
+  end
+
+  def requirement_list
+    version_requirements.as_list
+  end
+
+  alias requirements_list requirement_list
+
+  def normalize
+    ver = @version_requirement.instance_eval { @version }
+    @version_requirements = Gem::Requirement.new([ver])
+    @version_requirement = nil
+  end
+
+  def to_s # :nodoc:
+    "#{name} (#{version_requirements})"
+  end
+
+  def ==(other) # :nodoc:
+    self.class === other &&
+      self.name == other.name &&
+      self.version_requirements == other.version_requirements
+  end
+
+  def hash
+    name.hash + version_requirements.hash
+  end
+
+end
+

data/lib/rubygems/dependency_installer.rb

@@ -0,0 +1,232 @@
+require 'rubygems'
+require 'rubygems/dependency_list'
+require 'rubygems/installer'
+require 'rubygems/source_info_cache'
+require 'rubygems/user_interaction'
+
+class Gem::DependencyInstaller
+
+  include Gem::UserInteraction
+
+  attr_reader :gems_to_install
+  attr_reader :installed_gems
+
+  DEFAULT_OPTIONS = {
+    :env_shebang => false,
+    :domain => :both, # HACK dup
+    :force => false,
+    :ignore_dependencies => false,
+    :security_policy => Gem::Security::NoSecurity, # HACK AlmostNo? Low?
+    :wrappers => true
+  }
+
+  ##
+  # Creates a new installer instance that will install +gem_name+ using
+  # version requirement +version+ and +options+.
+  #
+  # Options are:
+  # :env_shebang:: See Gem::Installer::new.
+  # :domain:: :local, :remote, or :both.  :local only searches gems in the
+  #           current directory.  :remote searches only gems in Gem::sources.
+  #           :both searches both.
+  # :force:: See Gem::Installer#install.
+  # :ignore_dependencies: Don't install any dependencies.
+  # :install_dir: See Gem::Installer#install.
+  # :security_policy: See Gem::Installer::new and Gem::Security.
+  # :wrappers: See Gem::Installer::new
+  def initialize(gem_name, version = nil, options = {})
+    options = DEFAULT_OPTIONS.merge options
+    @env_shebang = options[:env_shebang]
+    @domain = options[:domain]
+    @force = options[:force]
+    @ignore_dependencies = options[:ignore_dependencies]
+    @install_dir = options[:install_dir] || Gem.dir
+    @security_policy = options[:security_policy]
+    @wrappers = options[:wrappers]
+
+    @installed_gems = []
+
+    spec_and_source = nil
+
+    local_gems = Dir["#{gem_name}*"].sort.reverse
+    unless local_gems.empty? then
+      local_gems.each do |gem_file|
+        next unless gem_file =~ /gem$/
+        begin
+          spec = Gem::Format.from_file_by_path(gem_file).spec
+          spec_and_source = [spec, gem_file]
+          break
+        rescue SystemCallError, Gem::Package::FormatError
+        end
+      end
+    end
+
+    if spec_and_source.nil? then
+      version ||= Gem::Requirement.default
+      @dep = Gem::Dependency.new gem_name, version
+      spec_and_sources = find_gems_with_sources(@dep).reverse
+
+      spec_and_source = spec_and_sources.find do |spec, source|
+        Gem::Platform.match spec.platform
+      end
+    end
+
+    if spec_and_source.nil? then
+      raise Gem::GemNotFoundException,
+        "could not find #{gem_name} locally or in a repository"
+    end
+
+    @specs_and_sources = [spec_and_source]
+
+    gather_dependencies
+  end
+
+  ##
+  # Returns a list of pairs of gemspecs and source_uris that match
+  # Gem::Dependency +dep+ from both local (Dir.pwd) and remote (Gem.sources)
+  # sources.  Gems are sorted with newer gems prefered over older gems, and
+  # local gems prefered over remote gems.
+  def find_gems_with_sources(dep)
+    gems_and_sources = []
+
+    if @domain == :both or @domain == :local then
+      Dir[File.join(Dir.pwd, "#{dep.name}-[0-9]*.gem")].each do |gem_file|
+        spec = Gem::Format.from_file_by_path(gem_file).spec
+        gems_and_sources << [spec, gem_file] if spec.name == dep.name
+      end
+    end
+
+    if @domain == :both or @domain == :remote then
+      gems_and_sources.push(*Gem::SourceInfoCache.search_with_source(dep, true))
+    end
+
+    gems_and_sources.sort_by do |gem, source|
+      [gem, source !~ /^http:\/\// ? 1 : 0] # local gems win
+    end
+  end
+
+  ##
+  # Moves the gem +spec+ from +source_uri+ to the cache dir unless it is
+  # already there.  If the source_uri is local the gem cache dir copy is
+  # always replaced.
+  def download(spec, source_uri)
+    gem_file_name = "#{spec.full_name}.gem"
+    local_gem_path = File.join @install_dir, 'cache', gem_file_name
+
+    Gem.ensure_gem_subdirectories @install_dir
+
+    source_uri = URI.parse source_uri unless URI::Generic === source_uri
+    scheme = source_uri.scheme
+
+    # URI.parse gets confused by MS Windows paths with forward slashes.
+    scheme = nil if scheme =~ /^[a-z]$/i
+
+    case scheme
+    when 'http' then
+      unless File.exist? local_gem_path then
+        begin
+          say "Downloading gem #{gem_file_name}" if
+            Gem.configuration.really_verbose
+
+          remote_gem_path = source_uri + "gems/#{gem_file_name}"
+
+          gem = Gem::RemoteFetcher.fetcher.fetch_path remote_gem_path
+        rescue Gem::RemoteFetcher::FetchError
+          raise if spec.original_platform == spec.platform
+
+          alternate_name = "#{spec.name}-#{spec.version}-#{spec.original_platform}.gem"
+
+          say "Failed, downloading gem #{alternate_name}" if
+            Gem.configuration.really_verbose
+
+          remote_gem_path = source_uri + "gems/#{alternate_name}"
+
+          gem = Gem::RemoteFetcher.fetcher.fetch_path remote_gem_path
+        end
+
+        File.open local_gem_path, 'wb' do |fp|
+          fp.write gem
+        end
+      end
+    when nil, 'file' then # TODO test for local overriding cache
+      begin
+        FileUtils.cp source_uri.to_s, local_gem_path
+      rescue Errno::EACCES
+        local_gem_path = source_uri.to_s
+      end
+
+      say "Using local gem #{local_gem_path}" if
+        Gem.configuration.really_verbose
+    else
+      raise Gem::InstallError, "unsupported URI scheme #{source_uri.scheme}"
+    end
+
+    local_gem_path
+  end
+
+  ##
+  # Gathers all dependencies necessary for the installation from local and
+  # remote sources unless the ignore_dependencies was given.
+  def gather_dependencies
+    specs = @specs_and_sources.map { |spec,_| spec }
+
+    dependency_list = Gem::DependencyList.new
+    dependency_list.add(*specs)
+
+    unless @ignore_dependencies then
+      to_do = specs.dup
+      seen = {}
+
+      until to_do.empty? do
+        spec = to_do.shift
+        next if spec.nil? or seen[spec.name]
+        seen[spec.name] = true
+
+        spec.dependencies.each do |dep|
+          results = find_gems_with_sources(dep).reverse # local gems first
+
+          results.each do |dep_spec, source_uri|
+            next if seen[dep_spec.name]
+            @specs_and_sources << [dep_spec, source_uri]
+            dependency_list.add dep_spec
+            to_do.push dep_spec
+          end
+        end
+      end
+    end
+
+    @gems_to_install = dependency_list.dependency_order.reverse
+  end
+
+  ##
+  # Installs the gem and all its dependencies.
+  def install
+    spec_dir = File.join @install_dir, 'specifications'
+    source_index = Gem::SourceIndex.from_gems_in spec_dir
+
+    @gems_to_install.each do |spec|
+      last = spec == @gems_to_install.last
+      # HACK is this test for full_name acceptable?
+      next if source_index.any? { |n,_| n == spec.full_name } and not last
+
+      say "Installing gem #{spec.full_name}" if Gem.configuration.really_verbose
+
+      _, source_uri = @specs_and_sources.assoc spec
+      local_gem_path = download spec, source_uri
+
+      inst = Gem::Installer.new local_gem_path,
+                                :env_shebang => @env_shebang,
+                                :force => @force,
+                                :ignore_dependencies => @ignore_dependencies,
+                                :install_dir => @install_dir,
+                                :security_policy => @security_policy,
+                                :wrappers => @wrappers
+
+      spec = inst.install
+
+      @installed_gems << spec
+    end
+  end
+
+end
+

data/lib/rubygems/dependency_list.rb

@@ -1,137 +1,165 @@
-#!/usr/bin/env ruby
 #--
 # Copyright 2006 by Chad Fowler, Rich Kilmer, Jim Weirich and others.
 # All rights reserved.
 # See LICENSE.txt for permissions.
 #++
 
+require 'tsort'
 
-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
+class Gem::DependencyList
 
-    def initialize
-      @specs = []
-    end
+  include TSort
 
-    # 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
+  def self.from_source_index(src_index)
+    deps = new
 
-    # Add a gemspec to the dependency list.
-    def add(gemspec)
-      @specs << gemspec
+    src_index.each do |full_name, spec|
+      deps.add spec
     end
 
-    def find_name(full_name)
-      @specs.find { |spec| spec.full_name == full_name }
-    end
+    deps
+  end
 
-    def remove_by_name(full_name)
-      @specs.delete_if { |spec| spec.full_name == full_name }
-    end
+  def initialize
+    @specs = []
+  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)
+  # Adds +gemspecs+ to the dependency list.
+  def add(*gemspecs)
+    @specs.push(*gemspecs)
+  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
+    sorted = strongly_connected_components.flatten
+
+    result = []
+    seen = {}
+
+    sorted.each do |spec|
+      if index = seen[spec.name] then
+        if result[index].version < spec.version then
+          result[index] = spec
         end
+      else
+        seen[spec.name] = result.length
+        result << spec
       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
+    result.reverse
+  end
+
+  def find_name(full_name)
+    @specs.find { |spec| spec.full_name == full_name }
+  end
+
+  # Are all the dependencies in the list satisfied?
+  def ok?
+    @specs.all? do |spec|
+      spec.dependencies.all? do |dep|
+        @specs.find { |s| s.satisfies_requirement? dep }
       end
-      result
     end
+  end
 
-    private
+  # 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
 
-    # 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]
+    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
-      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
+    deps.all? { |dep|
+      siblings.any? { |s|
+        s.satisfies_requirement? dep
+      }
+    }
+  end
+
+  def remove_by_name(full_name)
+    @specs.delete_if { |spec| spec.full_name == full_name }
+  end
+
+  # Return a hash of predecessors.  <tt>result[spec]</tt> is an
+  # Array of gemspecs that have a dependency satisfied by the named
+  # spec.
+  def spec_predecessors
+    result = Hash.new { |h,k| h[k] = [] }
+
+    specs = @specs.sort.reverse
+
+    specs.each do |spec|
+      specs.each do |other|
+        next if spec == other
+
+        other.dependencies.each do |dep|
+          if spec.satisfies_requirement? dep then
+            result[spec] << other
           end
         end
       end
-      result
     end
 
+    result
+  end
+
+  def tsort_each_node(&block)
+    @specs.each(&block)
   end
+
+  def tsort_each_child(node, &block)
+    specs = @specs.sort.reverse
+
+    node.dependencies.each do |dep|
+      specs.each do |spec|
+        if spec.satisfies_requirement? dep then
+          begin
+            yield spec
+          rescue TSort::Cyclic
+          end
+          break
+        end
+      end
+    end
+  end
+
+  private
+
+  # Count the number of gemspecs in the list +specs+ that are not in
+  # +ignored+.
+  def active_count(specs, ignored)
+    result = 0
+    specs.each do |spec|
+      result += 1 unless ignored[spec.full_name]
+    end
+    result
+  end
+
 end
+