slimgems 1.3.8

data/lib/rubygems/custom_require.rb

@@ -0,0 +1,44 @@
+#--
+# Copyright 2006 by Chad Fowler, Rich Kilmer, Jim Weirich and others.
+# All rights reserved.
+# See LICENSE.txt for permissions.
+#++
+
+module Kernel
+
+  ##
+  # The Kernel#require from before SlimGems was loaded.
+
+  alias gem_original_require require
+
+  ##
+  # When SlimGems is required, Kernel#require is replaced with our own which
+  # is capable of loading gems on demand.
+  #
+  # When you call <tt>require 'x'</tt>, this is what happens:
+  # * If the file can be loaded from the existing Ruby loadpath, it
+  #   is.
+  # * Otherwise, installed gems are searched for a file that matches.
+  #   If it's found in gem 'y', that gem is activated (added to the
+  #   loadpath).
+  #
+  # The normal <tt>require</tt> functionality of returning false if
+  # that file has already been loaded is preserved.
+
+  def require(path) # :doc:
+    gem_original_require path
+  rescue LoadError => load_error
+    if load_error.message.end_with?(path)
+      if Gem.try_activate(path)
+        return gem_original_require(path)
+      end
+    end
+
+    raise load_error
+  end
+
+  private :require
+  private :gem_original_require
+
+end unless Kernel.private_method_defined?(:gem_original_require)
+

data/lib/rubygems/defaults.rb

@@ -0,0 +1,101 @@
+module Gem
+
+  @post_install_hooks   ||= []
+  @post_uninstall_hooks ||= []
+  @pre_uninstall_hooks  ||= []
+  @pre_install_hooks    ||= []
+
+  ##
+  # An Array of the default sources that come with SlimGems
+
+  def self.default_sources
+    %w[http://rubygems.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]
+    elsif ConfigMap[:rubylibprefix] then
+      File.join(ConfigMap[:rubylibprefix], 'gems',
+                ConfigMap[:ruby_version])
+    else
+      File.join(ConfigMap[:libdir], ruby_engine, 'gems',
+                ConfigMap[:ruby_version])
+    end
+  end
+
+  ##
+  # Path for gems in the user's home directory
+
+  def self.user_dir
+    File.join Gem.user_home, '.gem', ruby_engine, ConfigMap[:ruby_version]
+  end
+
+  ##
+  # Default gem load path
+
+  def self.default_path
+    if File.exist? Gem.user_home then
+      [user_dir, default_dir]
+    else
+      [default_dir]
+    end
+  end
+
+  ##
+  # Deduce Ruby's --program-prefix and --program-suffix from its install name
+
+  def self.default_exec_format
+    exec_format = ConfigMap[:ruby_install_name].sub('ruby', '%s') rescue '%s'
+
+    unless exec_format =~ /%s/ then
+      raise Gem::Exception,
+        "[BUG] invalid exec_format #{exec_format.inspect}, no %s"
+    end
+
+    exec_format
+  end
+
+  ##
+  # The default directory for binaries
+
+  def self.default_bindir
+    if defined? RUBY_FRAMEWORK_VERSION then # mac framework support
+      '/usr/bin'
+    else # generic install
+      ConfigMap[:bindir]
+    end
+  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
+
+  ##
+  # A wrapper around RUBY_ENGINE const that may not be defined
+
+  def self.ruby_engine
+    if defined? RUBY_ENGINE then
+      RUBY_ENGINE
+    else
+      'ruby'
+    end
+  end
+
+end
+

data/lib/rubygems/dependency.rb

@@ -0,0 +1,227 @@
+require "rubygems/requirement"
+
+##
+# The Dependency class holds a Gem name and a Gem::Requirement.
+
+class Gem::Dependency
+
+  # :stopdoc:
+  @warned_version_requirement = false
+
+  def self.warned_version_requirement
+    @warned_version_requirement
+  end
+
+  def self.warned_version_requirement= value
+    @warned_version_requirement = value
+  end
+  # :startdoc:
+
+  ##
+  # Valid dependency types.
+  #--
+  # When this list is updated, be sure to change
+  # Gem::Specification::CURRENT_SPECIFICATION_VERSION as well.
+
+  TYPES = [
+           :development,
+           :runtime,
+          ]
+
+  ##
+  # Dependency name or regular expression.
+
+  attr_accessor :name
+
+  ##
+  # Allows you to force this dependency to be a prerelease.
+
+  attr_writer :prerelease
+
+  ##
+  # Dependency type.
+
+  attr_reader :type
+
+  ##
+  # Constructs a dependency with +name+ and +requirements+. The last
+  # argument can optionally be the dependency type, which defaults to
+  # <tt>:runtime</tt>.
+
+  def initialize name, *requirements
+    type         = Symbol === requirements.last ? requirements.pop : :runtime
+    requirements = requirements.first if 1 == requirements.length # unpack
+
+    unless TYPES.include? type
+      raise ArgumentError, "Valid types are #{TYPES.inspect}, "
+        + "not #{type.inspect}"
+    end
+
+    @name        = name
+    @requirement = Gem::Requirement.create requirements
+    @type        = type
+    @prerelease  = false
+
+    # This is for Marshal backwards compatability. See the comments in
+    # +requirement+ for the dirty details.
+
+    @version_requirements = @requirement
+  end
+
+  ##
+  # A dependency's hash is the XOR of the hashes of +name+, +type+,
+  # and +requirement+.
+
+  def hash # :nodoc:
+    name.hash ^ type.hash ^ requirement.hash
+  end
+
+  def inspect # :nodoc:
+    "<%s type=%p name=%p requirements=%p>" %
+      [self.class, @type, @name, requirement.to_s]
+  end
+
+  ##
+  # Does this dependency require a prerelease?
+
+  def prerelease?
+    @prerelease || requirement.prerelease?
+  end
+
+  def pretty_print(q) # :nodoc:
+    q.group 1, 'Gem::Dependency.new(', ')' do
+      q.pp name
+      q.text ','
+      q.breakable
+
+      q.pp requirement
+
+      q.text ','
+      q.breakable
+
+      q.pp type
+    end
+  end
+
+  ##
+  # What does this dependency require?
+
+  def requirement
+    return @requirement if defined?(@requirement) and @requirement
+
+    # @version_requirements and @version_requirement are legacy ivar
+    # names, and supported here because older gems need to keep
+    # working and Dependency doesn't implement marshal_dump and
+    # marshal_load. In a happier world, this would be an
+    # attr_accessor. The horrifying instance_variable_get you see
+    # below is also the legacy of some old restructurings.
+    #
+    # Note also that because of backwards compatibility (loading new
+    # gems in an old SlimGems installation), we can't add explicit
+    # marshaling to this class until we want to make a big
+    # break. Maybe 2.0.
+    #
+    # Children, define explicit marshal and unmarshal behavior for
+    # public classes. Marshal formats are part of your public API.
+
+    if defined?(@version_requirement) && @version_requirement
+      version = @version_requirement.instance_variable_get :@version
+      @version_requirement  = nil
+      @version_requirements = Gem::Requirement.new version
+    end
+
+    @requirement = @version_requirements if defined?(@version_requirements)
+  end
+
+  ##
+  # Rails subclasses Gem::Dependency and uses this method, so we'll hack
+  # around it.
+
+  alias __requirement requirement # :nodoc:
+
+  def requirements_list
+    requirement.as_list
+  end
+
+  def to_s # :nodoc:
+    "#{name} (#{requirement}, #{type})"
+  end
+
+  def version_requirements # :nodoc:
+    unless Gem::Dependency.warned_version_requirement then
+      warn "#{Gem.location_of_caller.join ':'}:Warning: " \
+           "Gem::Dependency#version_requirements is deprecated " \
+           "and will be removed on or after August 2010.  " \
+           "Use #requirement"
+
+      Gem::Dependency.warned_version_requirement = true
+    end
+
+    __requirement
+  end
+
+  alias version_requirement version_requirements # :nodoc:
+
+  def version_requirements= requirements # :nodoc:
+    warn "#{Gem.location_of_caller.join ':'}:Warning: " \
+         "Gem::Dependency#version_requirements= is deprecated " \
+         "and will be removed on or after August 2010.  " \
+         "Use Gem::Dependency.new."
+
+    @requirement = Gem::Requirement.create requirements
+  end
+
+  def == other # :nodoc:
+    Gem::Dependency === other &&
+      self.name        == other.name &&
+      self.type        == other.type &&
+      self.requirement == other.requirement
+  end
+
+  ##
+  # Dependencies are ordered by name.
+
+  def <=> other
+    @name <=> other.name
+  end
+
+  ##
+  # Uses this dependency as a pattern to compare to +other+. This
+  # dependency will match if the name matches the other's name, and
+  # other has only an equal version requirement that satisfies this
+  # dependency.
+
+  def =~ other
+    unless Gem::Dependency === other
+      return unless other.respond_to?(:name) && other.respond_to?(:version)
+      other = Gem::Dependency.new other.name, other.version
+    end
+
+    return false unless name === other.name
+
+    reqs = other.requirement.requirements
+
+    return false unless reqs.length == 1
+    return false unless reqs.first.first == '='
+
+    version = reqs.first.last
+
+    requirement.satisfied_by? version
+  end
+
+  def match?(spec_name, spec_version)
+    return false unless name === spec_name
+    return true if requirement.none?
+
+    requirement.satisfied_by? Gem::Version.new(spec_version)
+  end
+
+  def matches_spec?(spec)
+    return false unless name === spec.name # name can be a Regexp, so use ===
+    return true  if requirement.none?
+
+    requirement.satisfied_by?(spec.version)
+  end
+
+end
+

data/lib/rubygems/dependency_installer.rb

@@ -0,0 +1,286 @@
+require 'rubygems'
+require 'rubygems/dependency_list'
+require 'rubygems/installer'
+require 'rubygems/spec_fetcher'
+require 'rubygems/user_interaction'
+
+##
+# Installs a gem along with all its dependencies from local and remote gems.
+
+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,
+    :format_executable => false, # HACK dup
+    :ignore_dependencies => false,
+    :prerelease => false,
+    :security_policy => nil, # HACK NoSecurity requires OpenSSL.  AlmostNo? Low?
+    :wrappers => true,
+  }
+
+  ##
+  # Creates a new installer instance.
+  #
+  # Options are:
+  # :cache_dir:: Alternate repository path to store .gem files in.
+  # :domain:: :local, :remote, or :both.  :local only searches gems in the
+  #           current directory.  :remote searches only gems in Gem::sources.
+  #           :both searches both.
+  # :env_shebang:: See Gem::Installer::new.
+  # :force:: See Gem::Installer#install.
+  # :format_executable:: See Gem::Installer#initialize.
+  # :ignore_dependencies:: Don't install any dependencies.
+  # :install_dir:: See Gem::Installer#install.
+  # :prerelease:: Allow prerelease versions.  See #install.
+  # :security_policy:: See Gem::Installer::new and Gem::Security.
+  # :user_install:: See Gem::Installer.new
+  # :wrappers:: See Gem::Installer::new
+
+  def initialize(options = {})
+    if options[:install_dir] then
+      spec_dir = options[:install_dir], 'specifications'
+      @source_index = Gem::SourceIndex.from_gems_in spec_dir
+    else
+      @source_index = Gem.source_index
+    end
+
+    options = DEFAULT_OPTIONS.merge options
+
+    @bin_dir = options[:bin_dir]
+    @development = options[:development]
+    @domain = options[:domain]
+    @env_shebang = options[:env_shebang]
+    @force = options[:force]
+    @format_executable = options[:format_executable]
+    @ignore_dependencies = options[:ignore_dependencies]
+    @prerelease = options[:prerelease]
+    @security_policy = options[:security_policy]
+    @user_install = options[:user_install]
+    @wrappers = options[:wrappers]
+
+    @installed_gems = []
+
+    @install_dir = options[:install_dir] || Gem.dir
+    @cache_dir = options[:cache_dir] || @install_dir
+
+    # Set with any errors that SpecFetcher finds while search through
+    # gemspecs for a dep
+    @errors = nil
+  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 preferred over remote gems.
+
+  def find_gems_with_sources(dep)
+    # Reset the errors
+    @errors = nil
+    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
+      begin
+        requirements = dep.requirement.requirements.map do |req, ver|
+          req
+        end
+
+        all = !dep.prerelease? &&
+              # we only need latest if there's one requirement and it is
+              # guaranteed to match the newest specs
+              (requirements.length > 1 or
+                (requirements.first != ">=" and requirements.first != ">"))
+
+        found, @errors = Gem::SpecFetcher.fetcher.fetch_with_errors dep, all, true, dep.prerelease?
+
+        gems_and_sources.push(*found)
+
+      rescue Gem::RemoteFetcher::FetchError => e
+        if Gem.configuration.really_verbose then
+          say "Error fetching remote data:\t\t#{e.message}"
+          say "Falling back to local-only install"
+        end
+        @domain = :local
+      end
+    end
+
+    gems_and_sources.sort_by do |gem, source|
+      [gem, source =~ /^http:\/\// ? 0 : 1] # local gems win
+    end
+  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 @development
+    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
+
+        deps = spec.runtime_dependencies
+        deps |= spec.development_dependencies if @development
+
+        deps.each do |dep|
+          results = find_gems_with_sources(dep).reverse
+
+          results.reject! do |dep_spec,|
+            to_do.push dep_spec
+
+            @source_index.any? do |_, installed_spec|
+              dep.name == installed_spec.name and
+                dep.requirement.satisfied_by? installed_spec.version
+            end
+          end
+
+          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
+          end
+        end
+      end
+    end
+
+    @gems_to_install = dependency_list.dependency_order.reverse
+  end
+
+  ##
+  # Finds a spec and the source_uri it came from for gem +gem_name+ and
+  # +version+.  Returns an Array of specs and sources required for
+  # installation of the gem.
+
+  def find_spec_by_name_and_version(gem_name,
+                                    version = Gem::Requirement.default,
+                                    prerelease = false)
+    spec_and_source = nil
+
+    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$/
+        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
+      dep = Gem::Dependency.new gem_name, version
+      dep.prerelease = true if prerelease
+      spec_and_sources = find_gems_with_sources(dep).reverse
+
+      spec_and_source = spec_and_sources.find { |spec, source|
+        Gem::Platform.match spec.platform
+      }
+    end
+
+    if spec_and_source.nil? then
+      raise Gem::GemNotFoundException.new(
+        "Could not find a valid gem '#{gem_name}' (#{version}) locally or in a repository",
+        gem_name, version, @errors)
+    end
+
+    @specs_and_sources = [spec_and_source]
+  end
+
+  ##
+  # Installs the gem +dep_or_name+ and all its dependencies.  Returns an Array
+  # of installed gem specifications.
+  #
+  # If the +:prerelease+ option is set and there is a prerelease for
+  # +dep_or_name+ the prerelease version will be installed.
+  #
+  # Unless explicitly specified as a prerelease dependency, prerelease gems
+  # that +dep_or_name+ depend on will not be installed.
+  #
+  # If c-1.a depends on b-1 and a-1.a and there is a gem b-1.a available then
+  # c-1.a, b-1 and a-1.a will be installed.  b-1.a will need to be installed
+  # separately.
+
+  def install dep_or_name, version = Gem::Requirement.default
+    if String === dep_or_name then
+      find_spec_by_name_and_version dep_or_name, version, @prerelease
+    else
+      dep_or_name.prerelease = @prerelease
+      @specs_and_sources = [find_gems_with_sources(dep_or_name).last]
+    end
+
+    @installed_gems = []
+
+    gather_dependencies
+
+    @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
+
+      # TODO: make this sorta_verbose so other users can benefit from it
+      say "Installing gem #{spec.full_name}" if Gem.configuration.really_verbose
+
+      _, source_uri = @specs_and_sources.assoc spec
+      begin
+        local_gem_path = Gem::RemoteFetcher.fetcher.download spec, source_uri,
+                                                             @cache_dir
+      rescue Gem::RemoteFetcher::FetchError
+        next if @force
+        raise
+      end
+
+      inst = Gem::Installer.new local_gem_path,
+                                :bin_dir             => @bin_dir,
+                                :development         => @development,
+                                :env_shebang         => @env_shebang,
+                                :force               => @force,
+                                :format_executable   => @format_executable,
+                                :ignore_dependencies => @ignore_dependencies,
+                                :install_dir         => @install_dir,
+                                :security_policy     => @security_policy,
+                                :source_index        => @source_index,
+                                :user_install        => @user_install,
+                                :wrappers            => @wrappers
+
+      spec = inst.install
+
+      @installed_gems << spec
+    end
+
+    @installed_gems
+  end
+
+end
+