rb2exe 0.1.11 → 0.1.12

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

@@ -0,0 +1,73 @@
+##
+# RubyGems adds the #gem method to allow activation of specific gem versions
+# and overrides the #require method on Kernel to make gems appear as if they
+# live on the <code>$LOAD_PATH</code>.  See the documentation of these methods
+# for further detail.
+
+module Kernel
+
+  # REFACTOR: This should be pulled out into some kind of hacks file.
+  remove_method :gem if 'method' == defined? gem # from gem_prelude.rb on 1.9
+
+  ##
+  # Use Kernel#gem to activate a specific version of +gem_name+.
+  #
+  # +requirements+ is a list of version requirements that the
+  # specified gem must match, most commonly "= example.version.number".  See
+  # Gem::Requirement for how to specify a version requirement.
+  #
+  # If you will be activating the latest version of a gem, there is no need to
+  # call Kernel#gem, Kernel#require will do the right thing for you.
+  #
+  # Kernel#gem returns true if the gem was activated, otherwise false.  If the
+  # gem could not be found, didn't match the version requirements, or a
+  # different version was already activated, an exception will be raised.
+  #
+  # Kernel#gem should be called *before* any require statements (otherwise
+  # RubyGems may load a conflicting library version).
+  #
+  # Kernel#gem only loads prerelease versions when prerelease +requirements+
+  # are given:
+  #
+  #   gem 'rake', '>= 1.1.a', '< 2'
+  #
+  # In older RubyGems versions, the environment variable GEM_SKIP could be
+  # used to skip activation of specified gems, for example to test out changes
+  # that haven't been installed yet.  Now RubyGems defers to -I and the
+  # RUBYLIB environment variable to skip activation of a gem.
+  #
+  # Example:
+  #
+  #   GEM_SKIP=libA:libB ruby -I../libA -I../libB ./mycode.rb
+
+  def gem(gem_name, *requirements) # :doc:
+    skip_list = (ENV['GEM_SKIP'] || "").split(/:/)
+    raise Gem::LoadError, "skipping #{gem_name}" if skip_list.include? gem_name
+
+    if gem_name.kind_of? Gem::Dependency
+      unless Gem::Deprecate.skip
+        warn "#{Gem.location_of_caller.join ':'}:Warning: Kernel.gem no longer "\
+          "accepts a Gem::Dependency object, please pass the name "\
+          "and requirements directly"
+      end
+
+      requirements = gem_name.requirement
+      gem_name = gem_name.name
+    end
+
+    dep = Gem::Dependency.new(gem_name, *requirements)
+
+    loaded = Gem.loaded_specs[gem_name]
+
+    return false if loaded && dep.matches_spec?(loaded)
+
+    spec = dep.to_spec
+
+    Gem::LOADED_SPECS_MUTEX.synchronize {
+      spec.activate
+    } if spec
+  end
+
+  private :gem
+
+end

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

@@ -0,0 +1,139 @@
+#--
+# Copyright 2006 by Chad Fowler, Rich Kilmer, Jim Weirich and others.
+# All rights reserved.
+# See LICENSE.txt for permissions.
+#++
+
+require 'monitor'
+
+module Kernel
+
+  RUBYGEMS_ACTIVATION_MONITOR = Monitor.new # :nodoc:
+
+  if defined?(gem_original_require) then
+    # Ruby ships with a custom_require, override its require
+    remove_method :require
+  else
+    ##
+    # The Kernel#require from before RubyGems was loaded.
+
+    alias gem_original_require require
+    private :gem_original_require
+  end
+
+  ##
+  # 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
+    RUBYGEMS_ACTIVATION_MONITOR.enter
+
+    path = path.to_path if path.respond_to? :to_path
+
+    spec = Gem.find_unresolved_default_spec(path)
+    if spec
+      Gem.remove_unresolved_default_spec(spec)
+      gem(spec.name)
+    end
+
+    # If there are no unresolved deps, then we can use just try
+    # normal require handle loading a gem from the rescue below.
+
+    if Gem::Specification.unresolved_deps.empty? then
+      RUBYGEMS_ACTIVATION_MONITOR.exit
+      return gem_original_require(path)
+    end
+
+    # If +path+ is for a gem that has already been loaded, don't
+    # bother trying to find it in an unresolved gem, just go straight
+    # to normal require.
+    #--
+    # TODO request access to the C implementation of this to speed up RubyGems
+
+    spec = Gem::Specification.stubs.find { |s|
+      s.activated? and s.contains_requirable_file? path
+    }
+
+    begin
+      RUBYGEMS_ACTIVATION_MONITOR.exit
+      return gem_original_require(spec.to_fullpath(path) || path)
+    end if spec
+
+    # Attempt to find +path+ in any unresolved gems...
+
+    found_specs = Gem::Specification.find_in_unresolved path
+
+    # If there are no directly unresolved gems, then try and find +path+
+    # in any gems that are available via the currently unresolved gems.
+    # For example, given:
+    #
+    #   a => b => c => d
+    #
+    # If a and b are currently active with c being unresolved and d.rb is
+    # requested, then find_in_unresolved_tree will find d.rb in d because
+    # it's a dependency of c.
+    #
+    if found_specs.empty? then
+      found_specs = Gem::Specification.find_in_unresolved_tree path
+
+      found_specs.each do |found_spec|
+        found_spec.activate
+      end
+
+    # We found +path+ directly in an unresolved gem. Now we figure out, of
+    # the possible found specs, which one we should activate.
+    else
+
+      # Check that all the found specs are just different
+      # versions of the same gem
+      names = found_specs.map(&:name).uniq
+
+      if names.size > 1 then
+        RUBYGEMS_ACTIVATION_MONITOR.exit
+        raise Gem::LoadError, "#{path} found in multiple gems: #{names.join ', '}"
+      end
+
+      # Ok, now find a gem that has no conflicts, starting
+      # at the highest version.
+      valid = found_specs.select { |s| s.conflicts.empty? }.last
+
+      unless valid then
+        le = Gem::LoadError.new "unable to find a version of '#{names.first}' to activate"
+        le.name = names.first
+        RUBYGEMS_ACTIVATION_MONITOR.exit
+        raise le
+      end
+
+      valid.activate
+    end
+
+    RUBYGEMS_ACTIVATION_MONITOR.exit
+    return gem_original_require(path)
+  rescue LoadError => load_error
+    RUBYGEMS_ACTIVATION_MONITOR.enter
+
+    if load_error.message.start_with?("Could not find") or
+        (load_error.message.end_with?(path) and Gem.try_activate(path)) then
+      RUBYGEMS_ACTIVATION_MONITOR.exit
+      return gem_original_require(path)
+    else
+      RUBYGEMS_ACTIVATION_MONITOR.exit
+    end
+
+    raise load_error
+  end
+
+  private :require
+
+end
+

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

@@ -0,0 +1,177 @@
+module Gem
+  DEFAULT_HOST = "https://rubygems.org"
+
+  @post_install_hooks   ||= []
+  @done_installing_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[https://rubygems.org/]
+  end
+
+  ##
+  # Default spec directory path to be used if an alternate value is not
+  # specified in the environment
+
+  def self.default_spec_cache_dir
+    File.join Gem.user_home, '.gem', 'specs'
+  end
+
+  ##
+  # Default home directory path to be used if an alternate value is not
+  # specified in the environment
+
+  def self.default_dir
+    path = if defined? RUBY_FRAMEWORK_VERSION then
+             [
+               File.dirname(RbConfig::CONFIG['sitedir']),
+               'Gems',
+               RbConfig::CONFIG['ruby_version']
+             ]
+           elsif RbConfig::CONFIG['rubylibprefix'] then
+             [
+              RbConfig::CONFIG['rubylibprefix'],
+              'gems',
+              RbConfig::CONFIG['ruby_version']
+             ]
+           else
+             [
+               RbConfig::CONFIG['libdir'],
+               ruby_engine,
+               'gems',
+               RbConfig::CONFIG['ruby_version']
+             ]
+           end
+
+    @default_dir ||= File.join(*path)
+  end
+
+  ##
+  # Returns binary extensions dir for specified RubyGems base dir or nil
+  # if such directory cannot be determined.
+  #
+  # By default, the binary extensions are located side by side with their
+  # Ruby counterparts, therefore nil is returned
+
+  def self.default_ext_dir_for base_dir
+    nil
+  end
+
+  ##
+  # Paths where RubyGems' .rb files and bin files are installed
+
+  def self.default_rubygems_dirs
+    nil # default to standard layout
+  end
+
+  ##
+  # Path for gems in the user's home directory
+
+  def self.user_dir
+    parts = [Gem.user_home, '.gem', ruby_engine]
+    parts << RbConfig::CONFIG['ruby_version'] unless RbConfig::CONFIG['ruby_version'].empty?
+    File.join parts
+  end
+
+  ##
+  # How String Gem paths should be split.  Overridable for esoteric platforms.
+
+  def self.path_separator
+    File::PATH_SEPARATOR
+  end
+
+  ##
+  # Default gem load path
+
+  def self.default_path
+    path = []
+    path << user_dir if user_home && File.exist?(user_home)
+    path << default_dir
+    path << vendor_dir if vendor_dir and File.directory? vendor_dir
+    path
+  end
+
+  ##
+  # Deduce Ruby's --program-prefix and --program-suffix from its install name
+
+  def self.default_exec_format
+    exec_format = RbConfig::CONFIG['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
+      RbConfig::CONFIG['bindir']
+    end
+  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
+
+  ##
+  # The default signing key path
+
+  def self.default_key_path
+    File.join Gem.user_home, ".gem", "gem-private_key.pem"
+  end
+
+  ##
+  # The default signing certificate chain path
+
+  def self.default_cert_path
+    File.join Gem.user_home, ".gem", "gem-public_cert.pem"
+  end
+
+  ##
+  # Whether to expect full paths in default gems - true for non-MRI
+  # ruby implementations
+  def self.default_gems_use_full_paths?
+    ruby_engine != 'ruby'
+  end
+
+  ##
+  # Install extensions into lib as well as into the extension directory.
+
+  def self.install_extension_in_lib # :nodoc:
+    true
+  end
+
+  ##
+  # Directory where vendor gems are installed.
+
+  def self.vendor_dir # :nodoc:
+    if vendor_dir = ENV['GEM_VENDOR'] then
+      return vendor_dir.dup
+    end
+
+    return nil unless RbConfig::CONFIG.key? 'vendordir'
+
+    File.join RbConfig::CONFIG['vendordir'], 'gems',
+              RbConfig::CONFIG['ruby_version']
+  end
+
+end

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

@@ -0,0 +1,334 @@
+##
+# The Dependency class holds a Gem name and a Gem::Requirement.
+
+require "rubygems/requirement"
+
+class Gem::Dependency
+
+  ##
+  # Valid dependency types.
+  #--
+  # When this list is updated, be sure to change
+  # Gem::Specification::CURRENT_SPECIFICATION_VERSION as well.
+  #
+  # REFACTOR: This type of constant, TYPES, indicates we might want
+  # two classes, used via inheritance or duck typing.
+
+  TYPES = [
+    :development,
+    :runtime,
+  ]
+
+  ##
+  # Dependency name or regular expression.
+
+  attr_accessor :name
+
+  ##
+  # Allows you to force this dependency to be a prerelease.
+
+  attr_writer :prerelease
+
+  ##
+  # 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
+    case name
+    when String then # ok
+    when Regexp then
+      msg = ["NOTE: Dependency.new w/ a regexp is deprecated.",
+             "Dependency.new called from #{Gem.location_of_caller.join(":")}"]
+      warn msg.join("\n") unless Gem::Deprecate.skip
+    else
+      raise ArgumentError,
+            "dependency name must be a String, was #{name.inspect}"
+    end
+
+    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 compatibility. 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:
+    if prerelease? then
+      "<%s type=%p name=%p requirements=%p prerelease=ok>" %
+        [self.class, self.type, self.name, requirement.to_s]
+    else
+      "<%s type=%p name=%p requirements=%p>" %
+        [self.class, self.type, self.name, requirement.to_s]
+    end
+  end
+
+  ##
+  # Does this dependency require a prerelease?
+
+  def prerelease?
+    @prerelease || requirement.prerelease?
+  end
+
+  ##
+  # Is this dependency simply asking for the latest version
+  # of a gem?
+
+  def latest_version?
+    @requirement.none?
+  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 RubyGems 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.
+
+    # REFACTOR: See above
+
+    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
+
+  def requirements_list
+    requirement.as_list
+  end
+
+  def to_s # :nodoc:
+    if type != :runtime then
+      "#{name} (#{requirement}, #{type})"
+    else
+      "#{name} (#{requirement})"
+    end
+  end
+
+  ##
+  # Dependency type.
+
+  def type
+    @type ||= :runtime
+  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
+    self.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
+
+  alias === =~
+
+  ##
+  # :call-seq:
+  #   dep.match? name          => true or false
+  #   dep.match? name, version => true or false
+  #   dep.match? spec          => true or false
+  #
+  # Does this dependency match the specification described by +name+ and
+  # +version+ or match +spec+?
+  #
+  # NOTE:  Unlike #matches_spec? this method does not return true when the
+  # version is a prerelease version unless this is a prerelease dependency.
+
+  def match? obj, version=nil, allow_prerelease=false
+    if !version
+      name = obj.name
+      version = obj.version
+    else
+      name = obj
+    end
+
+    return false unless self.name === name
+
+    version = Gem::Version.new version
+
+    return true if requirement.none? and not version.prerelease?
+    return false if version.prerelease? and
+                    not allow_prerelease and
+                    not prerelease?
+
+    requirement.satisfied_by? version
+  end
+
+  ##
+  # Does this dependency match +spec+?
+  #
+  # NOTE:  This is not a convenience method.  Unlike #match? this method
+  # returns true when +spec+ is a prerelease version even if this dependency
+  # is not a prerelease dependency.
+
+  def matches_spec? spec
+    return false unless name === spec.name
+    return true  if requirement.none?
+
+    requirement.satisfied_by?(spec.version)
+  end
+
+  ##
+  # Merges the requirements of +other+ into this dependency
+
+  def merge other
+    unless name == other.name then
+      raise ArgumentError,
+            "#{self} and #{other} have different names"
+    end
+
+    default = Gem::Requirement.default
+    self_req  = self.requirement
+    other_req = other.requirement
+
+    return self.class.new name, self_req  if other_req == default
+    return self.class.new name, other_req if self_req  == default
+
+    self.class.new name, self_req.as_list.concat(other_req.as_list)
+  end
+
+  def matching_specs platform_only = false
+    matches = Gem::Specification.stubs.find_all { |spec|
+      self.name === spec.name and # TODO: == instead of ===
+        requirement.satisfied_by? spec.version
+    }.map(&:to_spec)
+
+    if platform_only
+      matches.reject! { |spec|
+        not Gem::Platform.match spec.platform
+      }
+    end
+
+    matches.sort_by { |s| s.sort_obj } # HACK: shouldn't be needed
+  end
+
+  ##
+  # True if the dependency will not always match the latest version.
+
+  def specific?
+    @requirement.specific?
+  end
+
+  def to_specs
+    matches = matching_specs true
+
+    # TODO: check Gem.activated_spec[self.name] in case matches falls outside
+
+    if matches.empty? then
+      specs = Gem::Specification.find_all { |s|
+                s.name == name
+              }.map { |x| x.full_name }
+
+      if specs.empty?
+        total = Gem::Specification.to_a.size
+        msg   = "Could not find '#{name}' (#{requirement}) among #{total} total gem(s)\n"
+      else
+        msg   = "Could not find '#{name}' (#{requirement}) - did find: [#{specs.join ','}]\n"
+      end
+      msg << "Checked in 'GEM_PATH=#{Gem.path.join(File::PATH_SEPARATOR)}', execute `gem env` for more information"
+
+      error = Gem::LoadError.new(msg)
+      error.name        = self.name
+      error.requirement = self.requirement
+      raise error
+    end
+
+    # TODO: any other resolver validations should go here
+
+    matches
+  end
+
+  def to_spec
+    matches = self.to_specs
+
+    active = matches.find { |spec| spec.activated? }
+
+    return active if active
+
+    matches.delete_if { |spec| spec.version.prerelease? } unless prerelease?
+
+    matches.last
+  end
+end