shoesgem 0.1424.0

data/shoes/ruby/lib/rubygems/custom_require.rb

@@ -0,0 +1,46 @@
+#--
+# Copyright 2006 by Chad Fowler, Rich Kilmer, Jim Weirich and others.
+# All rights reserved.
+# See LICENSE.txt for permissions.
+#++
+
+require 'rubygems'
+
+module Kernel
+
+  ##
+  # The Kernel#require from before RubyGems was loaded.
+
+  alias gem_original_require require
+
+  ##
+  # When RubyGems 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 =~ /#{Regexp.escape path}\z/ and
+       spec = Gem.searcher.find(path) then
+      Gem.activate(spec.name, "= #{spec.version}")
+      gem_original_require path
+    else
+      raise load_error
+    end
+  end
+
+  private :require
+  private :gem_original_require
+
+end
+

data/shoes/ruby/lib/rubygems/defaults.rb

@@ -0,0 +1,89 @@
+module Gem
+
+  @post_install_hooks   ||= []
+  @post_uninstall_hooks ||= []
+  @pre_uninstall_hooks  ||= []
+  @pre_install_hooks    ||= []
+
+  ##
+  # An Array of the default sources that come with RubyGems
+
+  def self.default_sources
+    %w[http://gems.rubyforge.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]
+    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
+    [user_dir, default_dir]
+  end
+
+  ##
+  # Deduce Ruby's --program-prefix and --program-suffix from its install name
+
+  def self.default_exec_format
+    baseruby = ConfigMap[:BASERUBY] || 'ruby'
+    ConfigMap[:RUBY_INSTALL_NAME].sub(baseruby, '%s') rescue '%s'
+  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/shoes/ruby/lib/rubygems/dependency.rb

@@ -0,0 +1,119 @@
+#--
+# 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
+
+  ##
+  # 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
+
+  ##
+  # Dependency type.
+
+  attr_reader :type
+
+  ##
+  # Dependent versions.
+
+  attr_writer :version_requirements
+
+  ##
+  # Orders dependencies by name only.
+
+  def <=>(other)
+    [@name] <=> [other.name]
+  end
+
+  ##
+  # Constructs a dependency with +name+ and +requirements+.
+
+  def initialize(name, version_requirements, type=:runtime)
+    @name = name
+
+    unless TYPES.include? type
+      raise ArgumentError, "Valid types are #{TYPES.inspect}, not #{@type.inspect}"
+    end
+
+    @type = type
+
+    @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}, #{@type || :runtime})"
+  end
+
+  def ==(other) # :nodoc:
+    self.class === other &&
+      self.name == other.name &&
+      self.type == other.type &&
+      self.version_requirements == other.version_requirements
+  end
+
+  ##
+  # Uses this dependency as a pattern to compare to the dependency +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)
+    return false unless self.class === other
+
+    pattern = @name
+    pattern = /\A#{@name}\Z/ unless Regexp === pattern
+
+    return false unless pattern =~ other.name
+
+    reqs = other.version_requirements.requirements
+
+    return false unless reqs.length == 1
+    return false unless reqs.first.first == '='
+
+    version = reqs.first.last
+
+    version_requirements.satisfied_by? version
+  end
+
+  def hash # :nodoc:
+    name.hash + type.hash + version_requirements.hash
+  end
+
+end
+

data/shoes/ruby/lib/rubygems/dependency_installer.rb

@@ -0,0 +1,258 @@
+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,
+    :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.
+  # :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]
+    @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
+  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)
+    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.version_requirements.requirements.map do |req, ver|
+          req
+        end
+
+        all = requirements.length > 1 ||
+                (requirements.first != ">=" and requirements.first != ">")
+
+        found = Gem::SpecFetcher.fetcher.fetch dep, all
+        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
+    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.version_requirements.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
+    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
+      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,
+        "could not find gem #{gem_name} locally or in a repository"
+    end
+
+    @specs_and_sources = [spec_and_source]
+  end
+
+  ##
+  # Installs the gem and all its dependencies.  Returns an Array of installed
+  # gems specifications.
+
+  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
+    else
+      @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
+

data/shoes/ruby/lib/rubygems/dependency_list.rb

@@ -0,0 +1,165 @@
+#--
+# Copyright 2006 by Chad Fowler, Rich Kilmer, Jim Weirich and others.
+# All rights reserved.
+# See LICENSE.txt for permissions.
+#++
+
+require 'tsort'
+
+class Gem::DependencyList
+
+  include TSort
+
+  def self.from_source_index(src_index)
+    deps = new
+
+    src_index.each do |full_name, spec|
+      deps.add spec
+    end
+
+    deps
+  end
+
+  def initialize
+    @specs = []
+  end
+
+  # 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
+    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.runtime_dependencies.all? do |dep|
+        @specs.find { |s| s.satisfies_requirement? dep }
+      end
+    end
+  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
+
+  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
+    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
+

data/shoes/ruby/lib/rubygems/digest/digest_adapter.rb

@@ -0,0 +1,40 @@
+#!/usr/bin/env ruby
+#--
+# Copyright 2006 by Chad Fowler, Rich Kilmer, Jim Weirich and others.
+# All rights reserved.
+# See LICENSE.txt for permissions.
+#++
+
+module Gem
+  
+  # There is an incompatibility between the way Ruby 1.8.5 and 1.8.6 
+  # handles digests. This DigestAdapter will take a pre-1.8.6 digest 
+  # and adapt it to the 1.8.6 API.
+  #
+  # Note that only the digest and hexdigest methods are adapted, 
+  # since these are the only functions used by Gems.
+  #
+  class DigestAdapter
+
+    # Initialize a digest adapter.
+    def initialize(digest_class)
+      @digest_class = digest_class
+    end
+
+    # Return a new digester.  Since we are only implementing the stateless
+    # methods, we will return ourself as the instance.
+    def new
+      self
+    end
+
+    # Return the digest of +string+ as a hex string.
+    def hexdigest(string)
+      @digest_class.new(string).hexdigest
+    end
+
+    # Return the digest of +string+ as a binary string.
+    def digest(string)
+      @digest_class.new(string).digest
+    end
+  end
+end