rb2exe 0.1.11 → 0.1.12

data/bin/traveling-ruby-2.2.2/lib/ruby/2.2.0/rubygems/request.rb

@@ -0,0 +1,244 @@
+require 'net/http'
+require 'thread'
+require 'time'
+require 'rubygems/user_interaction'
+
+class Gem::Request
+
+  include Gem::UserInteraction
+
+  ###
+  # Legacy.  This is used in tests.
+  def self.create_with_proxy uri, request_class, last_modified, proxy # :nodoc:
+    cert_files = get_cert_files
+    proxy ||= get_proxy_from_env(uri.scheme)
+    pool       = ConnectionPools.new proxy_uri(proxy), cert_files
+
+    new(uri, request_class, last_modified, pool.pool_for(uri))
+  end
+
+  def self.proxy_uri proxy # :nodoc:
+    case proxy
+    when :no_proxy then nil
+    when URI::HTTP then proxy
+    else URI.parse(proxy)
+    end
+  end
+
+  def initialize(uri, request_class, last_modified, pool)
+    @uri = uri
+    @request_class = request_class
+    @last_modified = last_modified
+    @requests = Hash.new 0
+    @user_agent = user_agent
+
+    @connection_pool = pool
+  end
+
+  def proxy_uri; @connection_pool.proxy_uri; end
+  def cert_files; @connection_pool.cert_files; end
+
+  def self.get_cert_files
+    pattern = File.expand_path("./ssl_certs/*.pem", File.dirname(__FILE__))
+    Dir.glob(pattern)
+  end
+
+  def self.configure_connection_for_https(connection, cert_files)
+    require 'net/https'
+    connection.use_ssl = true
+    connection.verify_mode =
+      Gem.configuration.ssl_verify_mode || OpenSSL::SSL::VERIFY_PEER
+    store = OpenSSL::X509::Store.new
+
+    if Gem.configuration.ssl_client_cert then
+      pem = File.read Gem.configuration.ssl_client_cert
+      connection.cert = OpenSSL::X509::Certificate.new pem
+      connection.key = OpenSSL::PKey::RSA.new pem
+    end
+
+    store.set_default_paths
+    cert_files.each do |ssl_cert_file|
+      store.add_file ssl_cert_file
+    end
+    if Gem.configuration.ssl_ca_cert
+      if File.directory? Gem.configuration.ssl_ca_cert
+        store.add_path Gem.configuration.ssl_ca_cert
+      else
+        store.add_file Gem.configuration.ssl_ca_cert
+      end
+    end
+    connection.cert_store = store
+    connection
+  rescue LoadError => e
+    raise unless (e.respond_to?(:path) && e.path == 'openssl') ||
+                 e.message =~ / -- openssl$/
+
+    raise Gem::Exception.new(
+            'Unable to require openssl, install OpenSSL and rebuild ruby (preferred) or use non-HTTPS sources')
+  end
+
+  ##
+  # Creates or an HTTP connection based on +uri+, or retrieves an existing
+  # connection, using a proxy if needed.
+
+  def connection_for(uri)
+    @connection_pool.checkout
+  rescue defined?(OpenSSL::SSL) ? OpenSSL::SSL::SSLError : Errno::EHOSTDOWN,
+         Errno::EHOSTDOWN => e
+    raise Gem::RemoteFetcher::FetchError.new(e.message, uri)
+  end
+
+  def fetch
+    request = @request_class.new @uri.request_uri
+
+    unless @uri.nil? || @uri.user.nil? || @uri.user.empty? then
+      request.basic_auth Gem::UriFormatter.new(@uri.user).unescape,
+                         Gem::UriFormatter.new(@uri.password).unescape
+    end
+
+    request.add_field 'User-Agent', @user_agent
+    request.add_field 'Connection', 'keep-alive'
+    request.add_field 'Keep-Alive', '30'
+
+    if @last_modified then
+      request.add_field 'If-Modified-Since', @last_modified.httpdate
+    end
+
+    yield request if block_given?
+
+    perform_request request
+  end
+
+  ##
+  # Returns a proxy URI for the given +scheme+ if one is set in the
+  # environment variables.
+
+  def self.get_proxy_from_env scheme = 'http'
+    _scheme = scheme.downcase
+    _SCHEME = scheme.upcase
+    env_proxy = ENV["#{_scheme}_proxy"] || ENV["#{_SCHEME}_PROXY"]
+
+    no_env_proxy = env_proxy.nil? || env_proxy.empty?
+
+    return get_proxy_from_env 'http' if no_env_proxy and _scheme != 'http'
+    return :no_proxy                 if no_env_proxy
+
+    uri = URI(Gem::UriFormatter.new(env_proxy).normalize)
+
+    if uri and uri.user.nil? and uri.password.nil? then
+      user     = ENV["#{_scheme}_proxy_user"] || ENV["#{_SCHEME}_PROXY_USER"]
+      password = ENV["#{_scheme}_proxy_pass"] || ENV["#{_SCHEME}_PROXY_PASS"]
+
+      uri.user     = Gem::UriFormatter.new(user).escape
+      uri.password = Gem::UriFormatter.new(password).escape
+    end
+
+    uri
+  end
+
+  def perform_request request # :nodoc:
+    connection = connection_for @uri
+
+    retried = false
+    bad_response = false
+
+    begin
+      @requests[connection.object_id] += 1
+
+      verbose "#{request.method} #{@uri}"
+
+      file_name = File.basename(@uri.path)
+      # perform download progress reporter only for gems
+      if request.response_body_permitted? && file_name =~ /\.gem$/
+        reporter = ui.download_reporter
+        response = connection.request(request) do |incomplete_response|
+          if Net::HTTPOK === incomplete_response
+            reporter.fetch(file_name, incomplete_response.content_length)
+            downloaded = 0
+            data = ''
+
+            incomplete_response.read_body do |segment|
+              data << segment
+              downloaded += segment.length
+              reporter.update(downloaded)
+            end
+            reporter.done
+            if incomplete_response.respond_to? :body=
+              incomplete_response.body = data
+            else
+              incomplete_response.instance_variable_set(:@body, data)
+            end
+          end
+        end
+      else
+        response = connection.request request
+      end
+
+      verbose "#{response.code} #{response.message}"
+
+    rescue Net::HTTPBadResponse
+      verbose "bad response"
+
+      reset connection
+
+      raise Gem::RemoteFetcher::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, Timeout::Error,
+           Errno::ECONNABORTED, Errno::ECONNRESET, Errno::EPIPE
+
+      requests = @requests[connection.object_id]
+      verbose "connection reset after #{requests} requests, retrying"
+
+      raise Gem::RemoteFetcher::FetchError.new('too many connection resets', @uri) if retried
+
+      reset connection
+
+      retried = true
+      retry
+    end
+
+    response
+  ensure
+    @connection_pool.checkin connection
+  end
+
+  ##
+  # Resets HTTP connection +connection+.
+
+  def reset(connection)
+    @requests.delete connection.object_id
+
+    connection.finish
+    connection.start
+  end
+
+  def user_agent
+    ua = "RubyGems/#{Gem::VERSION} #{Gem::Platform.local}"
+
+    ruby_version = RUBY_VERSION
+    ruby_version += 'dev' if RUBY_PATCHLEVEL == -1
+
+    ua << " Ruby/#{ruby_version} (#{RUBY_RELEASE_DATE}"
+    if RUBY_PATCHLEVEL >= 0 then
+      ua << " patchlevel #{RUBY_PATCHLEVEL}"
+    elsif defined?(RUBY_REVISION) then
+      ua << " revision #{RUBY_REVISION}"
+    end
+    ua << ")"
+
+    ua << " #{RUBY_ENGINE}" if defined?(RUBY_ENGINE) and RUBY_ENGINE != 'ruby'
+
+    ua
+  end
+
+end
+
+require 'rubygems/request/http_pool'
+require 'rubygems/request/https_pool'
+require 'rubygems/request/connection_pools'
+

data/bin/traveling-ruby-2.2.2/lib/ruby/2.2.0/rubygems/request/connection_pools.rb

@@ -0,0 +1,83 @@
+require 'thread'
+
+class Gem::Request::ConnectionPools # :nodoc:
+
+  @client = Net::HTTP
+
+  class << self
+    attr_accessor :client
+  end
+
+  def initialize proxy_uri, cert_files
+    @proxy_uri  = proxy_uri
+    @cert_files = cert_files
+    @pools      = {}
+    @pool_mutex = Mutex.new
+  end
+
+  def pool_for uri
+    http_args = net_http_args(uri, @proxy_uri)
+    key       = http_args + [https?(uri)]
+    @pool_mutex.synchronize do
+      @pools[key] ||=
+        if https? uri then
+          Gem::Request::HTTPSPool.new(http_args, @cert_files, @proxy_uri)
+        else
+          Gem::Request::HTTPPool.new(http_args, @cert_files, @proxy_uri)
+        end
+    end
+  end
+
+  def close_all
+    @pools.each_value {|pool| pool.close_all}
+  end
+
+  private
+
+  ##
+  # Returns list of no_proxy entries (if any) from the environment
+
+  def get_no_proxy_from_env
+    env_no_proxy = ENV['no_proxy'] || ENV['NO_PROXY']
+
+    return [] if env_no_proxy.nil?  or env_no_proxy.empty?
+
+    env_no_proxy.split(/\s*,\s*/)
+  end
+
+  def https? uri
+    uri.scheme.downcase == 'https'
+  end
+
+  def no_proxy? host, env_no_proxy
+    host = host.downcase
+
+    env_no_proxy.any? do |pattern|
+      pattern = pattern.downcase
+
+      host[-pattern.length, pattern.length] == pattern or
+        (pattern.start_with? '.' and pattern[1..-1] == host)
+    end
+  end
+
+  def net_http_args uri, proxy_uri
+    net_http_args = [uri.host, uri.port]
+
+    no_proxy = get_no_proxy_from_env
+
+    if proxy_uri and not no_proxy?(uri.host, no_proxy) then
+      net_http_args + [
+        proxy_uri.host,
+        proxy_uri.port,
+        Gem::UriFormatter.new(proxy_uri.user).unescape,
+        Gem::UriFormatter.new(proxy_uri.password).unescape,
+      ]
+    elsif no_proxy? uri.host, no_proxy then
+      net_http_args + [nil, nil]
+    else
+      net_http_args
+    end
+  end
+
+end
+

data/bin/traveling-ruby-2.2.2/lib/ruby/2.2.0/rubygems/request/http_pool.rb

@@ -0,0 +1,47 @@
+##
+# A connection "pool" that only manages one connection for now.  Provides
+# thread safe `checkout` and `checkin` methods.  The pool consists of one
+# connection that corresponds to `http_args`.  This class is private, do not
+# use it.
+
+class Gem::Request::HTTPPool # :nodoc:
+  attr_reader :cert_files, :proxy_uri
+
+  def initialize http_args, cert_files, proxy_uri
+    @http_args  = http_args
+    @cert_files = cert_files
+    @proxy_uri  = proxy_uri
+    @queue      = SizedQueue.new 1
+    @queue << nil
+  end
+
+  def checkout
+    @queue.pop || make_connection
+  end
+
+  def checkin connection
+    @queue.push connection
+  end
+
+  def close_all
+    until @queue.empty?
+      if connection = @queue.pop(true) and connection.started?
+        connection.finish
+      end
+    end
+    @queue.push(nil)
+  end
+
+  private
+
+  def make_connection
+    setup_connection Gem::Request::ConnectionPools.client.new(*@http_args)
+  end
+
+  def setup_connection connection
+    connection.start
+    connection
+  end
+
+end
+

data/bin/traveling-ruby-2.2.2/lib/ruby/2.2.0/rubygems/request/https_pool.rb

@@ -0,0 +1,10 @@
+class Gem::Request::HTTPSPool < Gem::Request::HTTPPool # :nodoc:
+  private
+
+  def setup_connection connection
+    Gem::Request.configure_connection_for_https(connection, @cert_files)
+    super
+  end
+end
+
+

data/bin/traveling-ruby-2.2.2/lib/ruby/2.2.0/rubygems/request_set.rb

@@ -0,0 +1,413 @@
+require 'tsort'
+
+##
+# A RequestSet groups a request to activate a set of dependencies.
+#
+#   nokogiri = Gem::Dependency.new 'nokogiri', '~> 1.6'
+#   pg = Gem::Dependency.new 'pg', '~> 0.14'
+#
+#   set = Gem::RequestSet.new nokogiri, pg
+#
+#   requests = set.resolve
+#
+#   p requests.map { |r| r.full_name }
+#   #=> ["nokogiri-1.6.0", "mini_portile-0.5.1", "pg-0.17.0"]
+
+class Gem::RequestSet
+
+  include TSort
+
+  ##
+  # Array of gems to install even if already installed
+
+  attr_accessor :always_install
+
+  attr_reader :dependencies
+
+  attr_accessor :development
+
+  ##
+  # Errors fetching gems during resolution.
+
+  attr_reader :errors
+
+  ##
+  # Set to true if you want to install only direct development dependencies.
+
+  attr_accessor :development_shallow
+
+  ##
+  # The set of git gems imported via load_gemdeps.
+
+  attr_reader :git_set # :nodoc:
+
+  ##
+  # When true, dependency resolution is not performed, only the requested gems
+  # are installed.
+
+  attr_accessor :ignore_dependencies
+
+  attr_reader :install_dir # :nodoc:
+
+  ##
+  # If true, allow dependencies to match prerelease gems.
+
+  attr_accessor :prerelease
+
+  ##
+  # When false no remote sets are used for resolving gems.
+
+  attr_accessor :remote
+
+  attr_reader :resolver # :nodoc:
+
+  ##
+  # Sets used for resolution
+
+  attr_reader :sets # :nodoc:
+
+  ##
+  # Treat missing dependencies as silent errors
+
+  attr_accessor :soft_missing
+
+  ##
+  # The set of vendor gems imported via load_gemdeps.
+
+  attr_reader :vendor_set # :nodoc:
+
+  ##
+  # Creates a RequestSet for a list of Gem::Dependency objects, +deps+.  You
+  # can then #resolve and #install the resolved list of dependencies.
+  #
+  #   nokogiri = Gem::Dependency.new 'nokogiri', '~> 1.6'
+  #   pg = Gem::Dependency.new 'pg', '~> 0.14'
+  #
+  #   set = Gem::RequestSet.new nokogiri, pg
+
+  def initialize *deps
+    @dependencies = deps
+
+    @always_install      = []
+    @conservative        = false
+    @dependency_names    = {}
+    @development         = false
+    @development_shallow = false
+    @errors              = []
+    @git_set             = nil
+    @ignore_dependencies = false
+    @install_dir         = Gem.dir
+    @prerelease          = false
+    @remote              = true
+    @requests            = []
+    @sets                = []
+    @soft_missing        = false
+    @sorted              = nil
+    @specs               = nil
+    @vendor_set          = nil
+
+    yield self if block_given?
+  end
+
+  ##
+  # Declare that a gem of name +name+ with +reqs+ requirements is needed.
+
+  def gem name, *reqs
+    if dep = @dependency_names[name] then
+      dep.requirement.concat reqs
+    else
+      dep = Gem::Dependency.new name, reqs
+      @dependency_names[name] = dep
+      @dependencies << dep
+    end
+  end
+
+  ##
+  # Add +deps+ Gem::Dependency objects to the set.
+
+  def import deps
+    @dependencies.concat deps
+  end
+
+  ##
+  # Installs gems for this RequestSet using the Gem::Installer +options+.
+  #
+  # If a +block+ is given an activation +request+ and +installer+ are yielded.
+  # The +installer+ will be +nil+ if a gem matching the request was already
+  # installed.
+
+  def install options, &block # :yields: request, installer
+    if dir = options[:install_dir]
+      requests = install_into dir, false, options, &block
+      return requests
+    end
+
+    cache_dir = options[:cache_dir] || Gem.dir
+    @prerelease = options[:prerelease]
+
+    requests = []
+
+    sorted_requests.each do |req|
+      if req.installed? then
+        req.spec.spec.build_extensions
+
+        if @always_install.none? { |spec| spec == req.spec.spec } then
+          yield req, nil if block_given?
+          next
+        end
+      end
+
+      path = req.download cache_dir
+
+      inst = Gem::Installer.new path, options
+
+      yield req, inst if block_given?
+
+      requests << inst.install
+    end
+
+    requests
+  ensure
+    raise if $!
+    return requests if options[:gemdeps]
+
+    specs = requests.map do |request|
+      case request
+      when Gem::Resolver::ActivationRequest then
+        request.spec.spec
+      else
+        request
+      end
+    end
+
+    require 'rubygems/dependency_installer'
+    inst = Gem::DependencyInstaller.new options
+    inst.installed_gems.replace specs
+
+    Gem.done_installing_hooks.each do |hook|
+      hook.call inst, specs
+    end unless Gem.done_installing_hooks.empty?
+  end
+
+  ##
+  # Installs from the gem dependencies files in the +:gemdeps+ option in
+  # +options+, yielding to the +block+ as in #install.
+  #
+  # If +:without_groups+ is given in the +options+, those groups in the gem
+  # dependencies file are not used.  See Gem::Installer for other +options+.
+
+  def install_from_gemdeps options, &block
+    gemdeps = options[:gemdeps]
+
+    @install_dir = options[:install_dir] || Gem.dir
+    @prerelease  = options[:prerelease]
+    @remote      = options[:domain] != :local
+    @conservative = true if options[:conservative]
+
+    gem_deps_api = load_gemdeps gemdeps, options[:without_groups], true
+
+    resolve
+
+    if options[:explain]
+      puts "Gems to install:"
+
+      sorted_requests.each do |spec|
+        puts "  #{spec.full_name}"
+      end
+
+      if Gem.configuration.really_verbose
+        @resolver.stats.display
+      end
+    else
+      installed = install options, &block
+
+      if options.fetch :lock, true then
+        lockfile =
+          Gem::RequestSet::Lockfile.new self, gemdeps, gem_deps_api.dependencies
+        lockfile.write
+      end
+
+      installed
+    end
+  end
+
+  def install_into dir, force = true, options = {}
+    gem_home, ENV['GEM_HOME'] = ENV['GEM_HOME'], dir
+
+    existing = force ? [] : specs_in(dir)
+    existing.delete_if { |s| @always_install.include? s }
+
+    dir = File.expand_path dir
+
+    installed = []
+
+    options[:development] = false
+    options[:install_dir] = dir
+    options[:only_install_dir] = true
+    @prerelease = options[:prerelease]
+
+    sorted_requests.each do |request|
+      spec = request.spec
+
+      if existing.find { |s| s.full_name == spec.full_name } then
+        yield request, nil if block_given?
+        next
+      end
+
+      spec.install options do |installer|
+        yield request, installer if block_given?
+      end
+
+      installed << request
+    end
+
+    installed
+  ensure
+    ENV['GEM_HOME'] = gem_home
+  end
+
+  ##
+  # Load a dependency management file.
+
+  def load_gemdeps path, without_groups = [], installing = false
+    @git_set    = Gem::Resolver::GitSet.new
+    @vendor_set = Gem::Resolver::VendorSet.new
+
+    @git_set.root_dir = @install_dir
+
+    lockfile = Gem::RequestSet::Lockfile.new self, path
+    lockfile.parse
+
+    gf = Gem::RequestSet::GemDependencyAPI.new self, path
+    gf.installing = installing
+    gf.without_groups = without_groups if without_groups
+    gf.load
+  end
+
+  def pretty_print q # :nodoc:
+    q.group 2, '[RequestSet:', ']' do
+      q.breakable
+
+      if @remote then
+        q.text 'remote'
+        q.breakable
+      end
+
+      if @prerelease then
+        q.text 'prerelease'
+        q.breakable
+      end
+
+      if @development_shallow then
+        q.text 'shallow development'
+        q.breakable
+      elsif @development then
+        q.text 'development'
+        q.breakable
+      end
+
+      if @soft_missing then
+        q.text 'soft missing'
+      end
+
+      q.group 2, '[dependencies:', ']' do
+        q.breakable
+        @dependencies.map do |dep|
+          q.text dep.to_s
+          q.breakable
+        end
+      end
+
+      q.breakable
+      q.text 'sets:'
+
+      q.breakable
+      q.pp @sets.map { |set| set.class }
+    end
+  end
+
+  ##
+  # Resolve the requested dependencies and return an Array of Specification
+  # objects to be activated.
+
+  def resolve set = Gem::Resolver::BestSet.new
+    @sets << set
+    @sets << @git_set
+    @sets << @vendor_set
+
+    set = Gem::Resolver.compose_sets(*@sets)
+    set.remote = @remote
+    set.prerelease = @prerelease
+
+    resolver = Gem::Resolver.new @dependencies, set
+    resolver.development         = @development
+    resolver.development_shallow = @development_shallow
+    resolver.ignore_dependencies = @ignore_dependencies
+    resolver.soft_missing        = @soft_missing
+
+    if @conservative
+      installed_gems = {}
+      Gem::Specification.find_all do |spec|
+        (installed_gems[spec.name] ||= []) << spec
+      end
+      resolver.skip_gems = installed_gems
+    end
+
+    @resolver = resolver
+
+    @requests = resolver.resolve
+
+    @errors = set.errors
+
+    @requests
+  end
+
+  ##
+  # Resolve the requested dependencies against the gems available via Gem.path
+  # and return an Array of Specification objects to be activated.
+
+  def resolve_current
+    resolve Gem::Resolver::CurrentSet.new
+  end
+
+  def sorted_requests
+    @sorted ||= strongly_connected_components.flatten
+  end
+
+  def specs
+    @specs ||= @requests.map { |r| r.full_spec }
+  end
+
+  def specs_in dir
+    Dir["#{dir}/specifications/*.gemspec"].map do |g|
+      Gem::Specification.load g
+    end
+  end
+
+  def tsort_each_node &block # :nodoc:
+    @requests.each(&block)
+  end
+
+  def tsort_each_child node # :nodoc:
+    node.spec.dependencies.each do |dep|
+      next if dep.type == :development and not @development
+
+      match = @requests.find { |r|
+        dep.match? r.spec.name, r.spec.version, @prerelease
+      }
+
+      unless match then
+        next if dep.type == :development and @development_shallow
+        next if @soft_missing
+        raise Gem::DependencyError,
+              "Unresolved dependency found during sorting - #{dep} (requested by #{node.spec.full_name})"
+      end
+
+      yield match
+    end
+  end
+
+end
+
+require 'rubygems/request_set/gem_dependency_api'
+require 'rubygems/request_set/lockfile'