shoesgem 0.1424.0

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

@@ -0,0 +1,178 @@
+require 'rubygems'
+
+##
+# Available list of platforms for targeting Gem installations.
+
+class Gem::Platform
+
+  @local = nil
+
+  attr_accessor :cpu
+
+  attr_accessor :os
+
+  attr_accessor :version
+
+  def self.local
+    arch = Gem::ConfigMap[:arch]
+    arch = "#{arch}_60" if arch =~ /mswin32$/
+    @local ||= new(arch)
+  end
+
+  def self.match(platform)
+    Gem.platforms.any? do |local_platform|
+      platform.nil? or local_platform == platform or
+        (local_platform != Gem::Platform::RUBY and local_platform =~ platform)
+    end
+  end
+
+  def self.new(arch) # :nodoc:
+    case arch
+    when Gem::Platform::CURRENT then
+      Gem::Platform.local
+    when Gem::Platform::RUBY, nil, '' then
+      Gem::Platform::RUBY
+    else
+      super
+    end
+  end
+
+  def initialize(arch)
+    case arch
+    when Array then
+      @cpu, @os, @version = arch
+    when String then
+      arch = arch.split '-'
+
+      if arch.length > 2 and arch.last !~ /\d/ then # reassemble x86-linux-gnu
+        extra = arch.pop
+        arch.last << "-#{extra}"
+      end
+
+      cpu = arch.shift
+
+      @cpu = case cpu
+             when /i\d86/ then 'x86'
+             else cpu
+             end
+
+      if arch.length == 2 and arch.last =~ /^\d+(\.\d+)?$/ then # for command-line
+        @os, @version = arch
+        return
+      end
+
+      os, = arch
+      @cpu, os = nil, cpu if os.nil? # legacy jruby
+
+      @os, @version = case os
+                      when /aix(\d+)/ then             [ 'aix',       $1  ]
+                      when /cygwin/ then               [ 'cygwin',    nil ]
+                      when /darwin(\d+)?/ then         [ 'darwin',    $1  ]
+                      when /freebsd(\d+)/ then         [ 'freebsd',   $1  ]
+                      when /hpux(\d+)/ then            [ 'hpux',      $1  ]
+                      when /^java$/, /^jruby$/ then    [ 'java',      nil ]
+                      when /^java([\d.]*)/ then        [ 'java',      $1  ]
+                      when /linux/ then                [ 'linux',     $1  ]
+                      when /mingw32/ then              [ 'mingw32',   nil ]
+                      when /(mswin\d+)(\_(\d+))?/ then
+                        os, version = $1, $3
+                        @cpu = 'x86' if @cpu.nil? and os =~ /32$/
+                        [os, version]
+                      when /netbsdelf/ then            [ 'netbsdelf', nil ]
+                      when /openbsd(\d+\.\d+)/ then    [ 'openbsd',   $1  ]
+                      when /solaris(\d+\.\d+)/ then    [ 'solaris',   $1  ]
+                      # test
+                      when /^(\w+_platform)(\d+)/ then [ $1,          $2  ]
+                      else                             [ 'unknown',   nil ]
+                      end
+    when Gem::Platform then
+      @cpu = arch.cpu
+      @os = arch.os
+      @version = arch.version
+    else
+      raise ArgumentError, "invalid argument #{arch.inspect}"
+    end
+  end
+
+  def inspect
+    "#<%s:0x%x @cpu=%p, @os=%p, @version=%p>" % [self.class, object_id, *to_a]
+  end
+
+  def to_a
+    [@cpu, @os, @version]
+  end
+
+  def to_s
+    to_a.compact.join '-'
+  end
+
+  ##
+  # Is +other+ equal to this platform?  Two platforms are equal if they have
+  # the same CPU, OS and version.
+
+  def ==(other)
+    self.class === other and
+      @cpu == other.cpu and @os == other.os and @version == other.version
+  end
+
+  ##
+  # Does +other+ match this platform?  Two platforms match if they have the
+  # same CPU, or either has a CPU of 'universal', they have the same OS, and
+  # they have the same version, or either has no version.
+
+  def ===(other)
+    return nil unless Gem::Platform === other
+
+    # cpu
+    (@cpu == 'universal' or other.cpu == 'universal' or @cpu == other.cpu) and
+
+    # os
+    @os == other.os and
+
+    # version
+    (@version.nil? or other.version.nil? or @version == other.version)
+  end
+
+  ##
+  # Does +other+ match this platform?  If +other+ is a String it will be
+  # converted to a Gem::Platform first.  See #=== for matching rules.
+
+  def =~(other)
+    case other
+    when Gem::Platform then # nop
+    when String then
+      # This data is from http://gems.rubyforge.org/gems/yaml on 19 Aug 2007
+      other = case other
+              when /^i686-darwin(\d)/ then     ['x86',       'darwin',  $1]
+              when /^i\d86-linux/ then         ['x86',       'linux',   nil]
+              when 'java', 'jruby' then        [nil,         'java',    nil]
+              when /mswin32(\_(\d+))?/ then    ['x86',       'mswin32', $2]
+              when 'powerpc-darwin' then       ['powerpc',   'darwin',  nil]
+              when /powerpc-darwin(\d)/ then   ['powerpc',   'darwin',  $1]
+              when /sparc-solaris2.8/ then     ['sparc',     'solaris', '2.8']
+              when /universal-darwin(\d)/ then ['universal', 'darwin',  $1]
+              else                             other
+              end
+
+      other = Gem::Platform.new other
+    else
+      return nil
+    end
+
+    self === other
+  end
+
+  ##
+  # A pure-ruby gem that may use Gem::Specification#extensions to build
+  # binary files.
+
+  RUBY = 'ruby'
+
+  ##
+  # A platform-specific gem that is built for the packaging ruby's platform.
+  # This will be replaced with Gem::Platform::local.
+
+  CURRENT = 'current'
+
+end
+

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

@@ -0,0 +1,344 @@
+require 'net/http'
+require 'stringio'
+require 'time'
+require 'uri'
+
+require 'rubygems'
+
+##
+# RemoteFetcher handles the details of fetching gems and gem information from
+# a remote source.
+
+class Gem::RemoteFetcher
+
+  include Gem::UserInteraction
+
+  ##
+  # A FetchError exception wraps up the various possible IO and HTTP failures
+  # that could happen while downloading from the internet.
+
+  class FetchError < Gem::Exception
+
+    ##
+    # The URI which was being accessed when the exception happened.
+
+    attr_accessor :uri
+
+    def initialize(message, uri)
+      super message
+      @uri = uri
+    end
+
+    def to_s # :nodoc:
+      "#{super} (#{uri})"
+    end
+
+  end
+
+  @fetcher = nil
+
+  ##
+  # Cached RemoteFetcher instance.
+
+  def self.fetcher
+    @fetcher ||= self.new Gem.configuration[:http_proxy]
+  end
+
+  ##
+  # Initialize a remote fetcher using the source URI and possible proxy
+  # information.
+  #
+  # +proxy+
+  # * [String]: explicit specification of proxy; overrides any environment
+  #             variable setting
+  # * nil: respect environment variables (HTTP_PROXY, HTTP_PROXY_USER,
+  #        HTTP_PROXY_PASS)
+  # * <tt>:no_proxy</tt>: ignore environment variables and _don't_ use a proxy
+
+  def initialize(proxy)
+    Socket.do_not_reverse_lookup = true
+
+    @connections = {}
+    @requests = Hash.new 0
+    @proxy_uri =
+      case proxy
+      when :no_proxy then nil
+      when nil then get_proxy_from_env
+      when URI::HTTP then proxy
+      else URI.parse(proxy)
+      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, install_dir = Gem.dir)
+    if File.writable?(install_dir)
+      cache_dir = File.join install_dir, 'cache'
+    else
+      cache_dir = File.join(Gem.user_dir, 'cache')
+    end
+
+    gem_file_name = "#{spec.full_name}.gem"
+    local_gem_path = File.join cache_dir, gem_file_name
+
+    FileUtils.mkdir_p cache_dir rescue nil unless File.exist? cache_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', 'https' 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.original_name}.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
+
+  ##
+  # Downloads +uri+ and returns it as a String.
+
+  def fetch_path(uri, mtime = nil, head = false)
+    data = open_uri_or_path uri, mtime, head
+    data = Gem.gunzip data if data and not head and uri.to_s =~ /gz$/
+    data
+  rescue FetchError
+    raise
+  rescue Timeout::Error
+    raise FetchError.new('timed out', uri)
+  rescue IOError, SocketError, SystemCallError => e
+    raise FetchError.new("#{e.class}: #{e}", uri)
+  end
+
+  ##
+  # Returns the size of +uri+ in bytes.
+
+  def fetch_size(uri) # TODO: phase this out
+    response = fetch_path(uri, nil, true)
+
+    response['content-length'].to_i
+  end
+
+  def escape(str)
+    return unless str
+    URI.escape(str)
+  end
+
+  def unescape(str)
+    return unless str
+    URI.unescape(str)
+  end
+
+  ##
+  # Returns an HTTP proxy URI if one is set in the environment variables.
+
+  def get_proxy_from_env
+    env_proxy = ENV['http_proxy'] || ENV['HTTP_PROXY']
+
+    return nil if env_proxy.nil? or env_proxy.empty?
+
+    uri = URI.parse env_proxy
+
+    if uri and uri.user.nil? and uri.password.nil? then
+      # Probably we have http_proxy_* variables?
+      uri.user = escape(ENV['http_proxy_user'] || ENV['HTTP_PROXY_USER'])
+      uri.password = escape(ENV['http_proxy_pass'] || ENV['HTTP_PROXY_PASS'])
+    end
+
+    uri
+  end
+
+  ##
+  # Normalize the URI by adding "http://" if it is missing.
+
+  def normalize_uri(uri)
+    (uri =~ /^(https?|ftp|file):/) ? uri : "http://#{uri}"
+  end
+
+  ##
+  # Creates or an HTTP connection based on +uri+, or retrieves an existing
+  # connection, using a proxy if needed.
+
+  def connection_for(uri)
+    net_http_args = [uri.host, uri.port]
+
+    if @proxy_uri then
+      net_http_args += [
+        @proxy_uri.host,
+        @proxy_uri.port,
+        @proxy_uri.user,
+        @proxy_uri.password
+      ]
+    end
+
+    connection_id = net_http_args.join ':'
+    @connections[connection_id] ||= Net::HTTP.new(*net_http_args)
+    connection = @connections[connection_id]
+
+    if uri.scheme == 'https' and not connection.started? then
+      require 'net/https'
+      connection.use_ssl = true
+      connection.verify_mode = OpenSSL::SSL::VERIFY_NONE
+    end
+
+    connection.start unless connection.started?
+
+    connection
+  end
+
+  ##
+  # Read the data from the (source based) URI, but if it is a file:// URI,
+  # read from the filesystem instead.
+
+  def open_uri_or_path(uri, last_modified = nil, head = false, depth = 0)
+    raise "block is dead" if block_given?
+
+    return open(get_file_uri_path(uri)) if file_uri? uri
+
+    uri = URI.parse uri unless URI::Generic === uri
+    raise ArgumentError, 'uri is not an HTTP URI' unless URI::HTTP === uri
+
+    fetch_type = head ? Net::HTTP::Head : Net::HTTP::Get
+    response   = request uri, fetch_type, last_modified
+
+    case response
+    when Net::HTTPOK, Net::HTTPNotModified then
+      head ? response : response.body
+    when Net::HTTPMovedPermanently, Net::HTTPFound, Net::HTTPSeeOther,
+         Net::HTTPTemporaryRedirect then
+      raise FetchError.new('too many redirects', uri) if depth > 10
+
+      open_uri_or_path(response['Location'], last_modified, head, depth + 1)
+    else
+      raise FetchError.new("bad response #{response.message} #{response.code}", uri)
+    end
+  end
+
+  ##
+  # Performs a Net::HTTP request of type +request_class+ on +uri+ returning
+  # a Net::HTTP response object.  request maintains a table of persistent
+  # connections to reduce connect overhead.
+
+  def request(uri, request_class, last_modified = nil)
+    request = request_class.new uri.request_uri
+
+    unless uri.nil? || uri.user.nil? || uri.user.empty? then
+      request.basic_auth uri.user, uri.password
+    end
+
+    ua = "RubyGems/#{Gem::RubyGemsVersion} #{Gem::Platform.local}"
+    ua << " Ruby/#{RUBY_VERSION} (#{RUBY_RELEASE_DATE}"
+    ua << " patchlevel #{RUBY_PATCHLEVEL}" if defined? RUBY_PATCHLEVEL
+    ua << ")"
+
+    request.add_field 'User-Agent', ua
+    request.add_field 'Connection', 'keep-alive'
+    request.add_field 'Keep-Alive', '30'
+
+    if last_modified then
+      last_modified = last_modified.utc
+      request.add_field 'If-Modified-Since', last_modified.rfc2822
+    end
+
+    connection = connection_for uri
+
+    retried = false
+    bad_response = false
+
+    begin
+      @requests[connection.object_id] += 1
+      response = connection.request request
+      say "#{request.method} #{response.code} #{response.message}: #{uri}" if
+        Gem.configuration.really_verbose
+    rescue Net::HTTPBadResponse
+      reset connection
+
+      raise FetchError.new('too many bad responses', uri) if bad_response
+
+      bad_response = true
+      retry
+    # HACK work around EOFError bug in Net::HTTP
+    # NOTE Errno::ECONNABORTED raised a lot on Windows, and make impossible
+    # to install gems.
+    rescue EOFError, Errno::ECONNABORTED, Errno::ECONNRESET
+      requests = @requests[connection.object_id]
+      say "connection reset after #{requests} requests, retrying" if
+        Gem.configuration.really_verbose
+
+      raise FetchError.new('too many connection resets', uri) if retried
+
+      reset connection
+
+      retried = true
+      retry
+    end
+
+    response
+  end
+
+  ##
+  # Resets HTTP connection +connection+.
+
+  def reset(connection)
+    @requests.delete connection.object_id
+
+    connection.finish
+    connection.start
+  end
+
+  ##
+  # Checks if the provided string is a file:// URI.
+
+  def file_uri?(uri)
+    uri =~ %r{\Afile://}
+  end
+
+  ##
+  # Given a file:// URI, returns its local path.
+
+  def get_file_uri_path(uri)
+    uri.sub(%r{\Afile://}, '')
+  end
+
+end
+

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

@@ -0,0 +1,15 @@
+module Gem
+  module RequirePathsBuilder
+    def write_require_paths_file_if_needed(spec = @spec, gem_home = @gem_home)
+      return if spec.require_paths == ["lib"] && (spec.bindir.nil? || spec.bindir == "bin")
+      file_name = File.join(gem_home, 'gems', "#{@spec.full_name}", ".require_paths")
+      file_name.untaint
+      File.open(file_name, "w") do |file|
+        spec.require_paths.each do |path|
+          file.puts path
+        end
+        file.puts spec.bindir if spec.bindir
+      end
+    end
+  end
+end

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

@@ -0,0 +1,163 @@
+#--
+# Copyright 2006 by Chad Fowler, Rich Kilmer, Jim Weirich and others.
+# All rights reserved.
+# See LICENSE.txt for permissions.
+#++
+
+require 'rubygems/version'
+
+##
+# Requirement version includes a prefaced comparator in addition
+# to a version number.
+#
+# A Requirement object can actually contain multiple, er,
+# requirements, as in (> 1.2, < 2.0).
+
+class Gem::Requirement
+
+  include Comparable
+
+  attr_reader :requirements
+
+  OPS = {
+    "="  =>  lambda { |v, r| v == r },
+    "!=" =>  lambda { |v, r| v != r },
+    ">"  =>  lambda { |v, r| v > r },
+    "<"  =>  lambda { |v, r| v < r },
+    ">=" =>  lambda { |v, r| v >= r },
+    "<=" =>  lambda { |v, r| v <= r },
+    "~>" =>  lambda { |v, r| v >= r && v < r.bump }
+  }
+
+  OP_RE = /#{OPS.keys.map{ |k| Regexp.quote k }.join '|'}/o
+
+  ##
+  # Factory method to create a Gem::Requirement object.  Input may be a
+  # Version, a String, or nil.  Intended to simplify client code.
+  #
+  # If the input is "weird", the default version requirement is returned.
+
+  def self.create(input)
+    case input
+    when Gem::Requirement then
+      input
+    when Gem::Version, Array then
+      new input
+    else
+      if input.respond_to? :to_str then
+        self.new [input.to_str]
+      else
+        self.default
+      end
+    end
+  end
+
+  ##
+  # A default "version requirement" can surely _only_ be '>= 0'.
+  #--
+  # This comment once said:
+  #
+  # "A default "version requirement" can surely _only_ be '> 0'."
+
+  def self.default
+    self.new ['>= 0']
+  end
+
+  ##
+  # Constructs a Requirement from +requirements+ which can be a String, a
+  # Gem::Version, or an Array of those.  See parse for details on the
+  # formatting of requirement strings.
+
+  def initialize(requirements)
+    @requirements = case requirements
+                    when Array then
+                      requirements.map do |requirement|
+                        parse(requirement)
+                      end
+                    else
+                      [parse(requirements)]
+                    end
+    @version = nil   # Avoid warnings.
+  end
+
+  ##
+  # Marshal raw requirements, rather than the full object
+
+  def marshal_dump # :nodoc:
+    [@requirements]
+  end
+
+  ##
+  # Load custom marshal format
+
+  def marshal_load(array) # :nodoc:
+    @requirements = array[0]
+    @version = nil
+  end
+
+  def to_s # :nodoc:
+    as_list.join(", ")
+  end
+
+  def as_list
+    normalize
+    @requirements.collect { |req|
+      "#{req[0]} #{req[1]}"
+    }
+  end
+
+  def normalize
+    return if not defined? @version or @version.nil?
+    @requirements = [parse(@version)]
+    @nums = nil
+    @version = nil
+    @op = nil
+  end
+
+  ##
+  # True if this requirement satisfied by the Gem::Version +version+.
+
+  def satisfied_by?(version)
+    normalize
+    @requirements.all? { |op, rv| satisfy?(op, version, rv) }
+  end
+
+  ##
+  # Is "+version+ +op+ +required_version+" satisfied?
+
+  def satisfy?(op, version, required_version)
+    OPS[op].call(version, required_version)
+  end
+
+  ##
+  # Parse the version requirement obj returning the operator and version.
+  #
+  # The requirement can be a String or a Gem::Version.  A String can be an
+  # operator (<, <=, =, =>, >, !=, ~>), a version number, or both, operator
+  # first.
+
+  def parse(obj)
+    case obj
+    when /^\s*(#{OP_RE})\s*([0-9.]+)\s*$/o then
+      [$1, Gem::Version.new($2)]
+    when /^\s*([0-9.]+)\s*$/ then
+      ['=', Gem::Version.new($1)]
+    when /^\s*(#{OP_RE})\s*$/o then
+      [$1, Gem::Version.new('0')]
+    when Gem::Version then
+      ['=', obj]
+    else
+      fail ArgumentError, "Illformed requirement [#{obj.inspect}]"
+    end
+  end
+
+  def <=>(other) # :nodoc:
+    to_s <=> other.to_s
+  end
+
+  def hash # :nodoc:
+    to_s.hash
+  end
+
+end
+

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

@@ -0,0 +1,6 @@
+# DO NOT EDIT
+# This file is auto-generated by build scripts.
+# See:  rake update_version
+module Gem
+  RubyGemsVersion = '1.3.1'
+end