rb2exe 0.1.11 → 0.1.12

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

@@ -0,0 +1,234 @@
+require 'uri'
+require 'fileutils'
+
+##
+# A Source knows how to list and fetch gems from a RubyGems marshal index.
+#
+# There are other Source subclasses for installed gems, local gems, the
+# bundler dependency API and so-forth.
+
+class Gem::Source
+
+  include Comparable
+
+  FILES = { # :nodoc:
+    :released   => 'specs',
+    :latest     => 'latest_specs',
+    :prerelease => 'prerelease_specs',
+  }
+
+  ##
+  # The URI this source will fetch gems from.
+
+  attr_reader :uri
+
+  ##
+  # Creates a new Source which will use the index located at +uri+.
+
+  def initialize(uri)
+    begin
+      unless uri.kind_of? URI
+        uri = URI.parse(uri.to_s)
+      end
+    rescue URI::InvalidURIError
+      raise if Gem::Source == self.class
+    end
+
+    @uri = uri
+    @api_uri = nil
+  end
+
+  ##
+  # Use an SRV record on the host to look up the true endpoint for the index.
+
+  def api_uri # :nodoc:
+    require 'rubygems/remote_fetcher'
+    @api_uri ||= Gem::RemoteFetcher.fetcher.api_endpoint uri
+  end
+
+  ##
+  # Sources are ordered by installation preference.
+
+  def <=>(other)
+    case other
+    when Gem::Source::Installed,
+         Gem::Source::Local,
+         Gem::Source::Lock,
+         Gem::Source::SpecificFile,
+         Gem::Source::Git,
+         Gem::Source::Vendor then
+      -1
+    when Gem::Source then
+      if !@uri
+        return 0 unless other.uri
+        return 1
+      end
+
+      return -1 if !other.uri
+
+      @uri.to_s <=> other.uri.to_s
+    else
+      nil
+    end
+  end
+
+  def == other # :nodoc:
+    self.class === other and @uri == other.uri
+  end
+
+  alias_method :eql?, :== # :nodoc:
+
+  ##
+  # Returns a Set that can fetch specifications from this source.
+
+  def dependency_resolver_set # :nodoc:
+    return Gem::Resolver::IndexSet.new self if 'file' == api_uri.scheme
+
+    bundler_api_uri = api_uri + './api/v1/dependencies'
+
+    begin
+      fetcher = Gem::RemoteFetcher.fetcher
+      response = fetcher.fetch_path bundler_api_uri, nil, true
+    rescue Gem::RemoteFetcher::FetchError
+      Gem::Resolver::IndexSet.new self
+    else
+      if response.respond_to? :uri then
+        Gem::Resolver::APISet.new response.uri
+      else
+        Gem::Resolver::APISet.new bundler_api_uri
+      end
+    end
+  end
+
+  def hash # :nodoc:
+    @uri.hash
+  end
+
+  ##
+  # Returns the local directory to write +uri+ to.
+
+  def cache_dir(uri)
+    # Correct for windows paths
+    escaped_path = uri.path.sub(/^\/([a-z]):\//i, '/\\1-/')
+    escaped_path.untaint
+
+    File.join Gem.spec_cache_dir, "#{uri.host}%#{uri.port}", File.dirname(escaped_path)
+  end
+
+  ##
+  # Returns true when it is possible and safe to update the cache directory.
+
+  def update_cache?
+    @update_cache ||=
+      begin
+        File.stat(Gem.user_home).uid == Process.uid
+      rescue Errno::ENOENT
+        false
+      end
+  end
+
+  ##
+  # Fetches a specification for the given +name_tuple+.
+
+  def fetch_spec name_tuple
+    fetcher = Gem::RemoteFetcher.fetcher
+
+    spec_file_name = name_tuple.spec_name
+
+    uri = api_uri + "#{Gem::MARSHAL_SPEC_DIR}#{spec_file_name}"
+
+    cache_dir = cache_dir uri
+
+    local_spec = File.join cache_dir, spec_file_name
+
+    if File.exist? local_spec then
+      spec = Gem.read_binary local_spec
+      spec = Marshal.load(spec) rescue nil
+      return spec if spec
+    end
+
+    uri.path << '.rz'
+
+    spec = fetcher.fetch_path uri
+    spec = Gem.inflate spec
+
+    if update_cache? then
+      FileUtils.mkdir_p cache_dir
+
+      open local_spec, 'wb' do |io|
+        io.write spec
+      end
+    end
+
+    # TODO: Investigate setting Gem::Specification#loaded_from to a URI
+    Marshal.load spec
+  end
+
+  ##
+  # Loads +type+ kind of specs fetching from +@uri+ if the on-disk cache is
+  # out of date.
+  #
+  # +type+ is one of the following:
+  #
+  # :released   => Return the list of all released specs
+  # :latest     => Return the list of only the highest version of each gem
+  # :prerelease => Return the list of all prerelease only specs
+  #
+
+  def load_specs(type)
+    file       = FILES[type]
+    fetcher    = Gem::RemoteFetcher.fetcher
+    file_name  = "#{file}.#{Gem.marshal_version}"
+    spec_path  = api_uri + "#{file_name}.gz"
+    cache_dir  = cache_dir spec_path
+    local_file = File.join(cache_dir, file_name)
+    retried    = false
+
+    FileUtils.mkdir_p cache_dir if update_cache?
+
+    spec_dump = fetcher.cache_update_path spec_path, local_file, update_cache?
+
+    begin
+      Gem::NameTuple.from_list Marshal.load(spec_dump)
+    rescue ArgumentError
+      if update_cache? && !retried
+        FileUtils.rm local_file
+        retried = true
+        retry
+      else
+        raise Gem::Exception.new("Invalid spec cache file in #{local_file}")
+      end
+    end
+  end
+
+  ##
+  # Downloads +spec+ and writes it to +dir+.  See also
+  # Gem::RemoteFetcher#download.
+
+  def download(spec, dir=Dir.pwd)
+    fetcher = Gem::RemoteFetcher.fetcher
+    fetcher.download spec, api_uri.to_s, dir
+  end
+
+  def pretty_print q # :nodoc:
+    q.group 2, '[Remote:', ']' do
+      q.breakable
+      q.text @uri.to_s
+
+      if api = api_uri
+        q.breakable
+        q.text 'API URI: '
+        q.text api.to_s
+      end
+    end
+  end
+
+end
+
+require 'rubygems/source/git'
+require 'rubygems/source/installed'
+require 'rubygems/source/specific_file'
+require 'rubygems/source/local'
+require 'rubygems/source/lock'
+require 'rubygems/source/vendor'
+

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

@@ -0,0 +1,240 @@
+require 'digest'
+require 'rubygems/util'
+
+##
+# A git gem for use in a gem dependencies file.
+#
+# Example:
+#
+#   source =
+#     Gem::Source::Git.new 'rake', 'git@example:rake.git', 'rake-10.1.0', false
+#
+#   source.specs
+
+class Gem::Source::Git < Gem::Source
+
+  ##
+  # The name of the gem created by this git gem.
+
+  attr_reader :name
+
+  ##
+  # The commit reference used for checking out this git gem.
+
+  attr_reader :reference
+
+  ##
+  # When false the cache for this repository will not be updated.
+
+  attr_accessor :remote
+
+  ##
+  # The git repository this gem is sourced from.
+
+  attr_reader :repository
+
+  ##
+  # The directory for cache and git gem installation
+
+  attr_accessor :root_dir
+
+  ##
+  # Does this repository need submodules checked out too?
+
+  attr_reader :need_submodules
+
+  ##
+  # Creates a new git gem source for a gems from loaded from +repository+ at
+  # the given +reference+.  The +name+ is only used to track the repository
+  # back to a gem dependencies file, it has no real significance as a git
+  # repository may contain multiple gems.  If +submodules+ is true, submodules
+  # will be checked out when the gem is installed.
+
+  def initialize name, repository, reference, submodules = false
+    super repository
+
+    @name            = name
+    @repository      = repository
+    @reference       = reference
+    @need_submodules = submodules
+
+    @remote   = true
+    @root_dir = Gem.dir
+    @git      = ENV['git'] || 'git'
+  end
+
+  def <=> other
+    case other
+    when Gem::Source::Git then
+      0
+    when Gem::Source::Vendor,
+         Gem::Source::Lock then
+      -1
+    when Gem::Source then
+      1
+    else
+      nil
+    end
+  end
+
+  def == other # :nodoc:
+    super and
+      @name            == other.name and
+      @repository      == other.repository and
+      @reference       == other.reference and
+      @need_submodules == other.need_submodules
+  end
+
+  ##
+  # Checks out the files for the repository into the install_dir.
+
+  def checkout # :nodoc:
+    cache
+
+    return false unless File.exist? repo_cache_dir
+
+    unless File.exist? install_dir then
+      system @git, 'clone', '--quiet', '--no-checkout',
+             repo_cache_dir, install_dir
+    end
+
+    Dir.chdir install_dir do
+      system @git, 'fetch', '--quiet', '--force', '--tags', install_dir
+
+      success = system @git, 'reset', '--quiet', '--hard', rev_parse
+
+      success &&=
+        Gem::Util.silent_system @git, 'submodule', 'update',
+               '--quiet', '--init', '--recursive' if @need_submodules
+
+      success
+    end
+  end
+
+  ##
+  # Creates a local cache repository for the git gem.
+
+  def cache # :nodoc:
+    return unless @remote
+
+    if File.exist? repo_cache_dir then
+      Dir.chdir repo_cache_dir do
+        system @git, 'fetch', '--quiet', '--force', '--tags',
+               @repository, 'refs/heads/*:refs/heads/*'
+      end
+    else
+      system @git, 'clone', '--quiet', '--bare', '--no-hardlinks',
+             @repository, repo_cache_dir
+    end
+  end
+
+  ##
+  # Directory where git gems get unpacked and so-forth.
+
+  def base_dir # :nodoc:
+    File.join @root_dir, 'bundler'
+  end
+
+  ##
+  # A short reference for use in git gem directories
+
+  def dir_shortref # :nodoc:
+    rev_parse[0..11]
+  end
+
+  ##
+  # Nothing to download for git gems
+
+  def download full_spec, path # :nodoc:
+  end
+
+  ##
+  # The directory where the git gem will be installed.
+
+  def install_dir # :nodoc:
+    return unless File.exist? repo_cache_dir
+
+    File.join base_dir, 'gems', "#{@name}-#{dir_shortref}"
+  end
+
+  def pretty_print q # :nodoc:
+    q.group 2, '[Git: ', ']' do
+      q.breakable
+      q.text @repository
+
+      q.breakable
+      q.text @reference
+    end
+  end
+
+  ##
+  # The directory where the git gem's repository will be cached.
+
+  def repo_cache_dir # :nodoc:
+    File.join @root_dir, 'cache', 'bundler', 'git', "#{@name}-#{uri_hash}"
+  end
+
+  ##
+  # Converts the git reference for the repository into a commit hash.
+
+  def rev_parse # :nodoc:
+    hash = nil
+
+    Dir.chdir repo_cache_dir do
+      hash = Gem::Util.popen(@git, 'rev-parse', @reference).strip
+    end
+
+    raise Gem::Exception,
+          "unable to find reference #{@reference} in #{@repository}" unless
+            $?.success?
+
+    hash
+  end
+
+  ##
+  # Loads all gemspecs in the repository
+
+  def specs
+    checkout
+
+    return [] unless install_dir
+
+    Dir.chdir install_dir do
+      Dir['{,*,*/*}.gemspec'].map do |spec_file|
+        directory = File.dirname spec_file
+        file      = File.basename spec_file
+
+        Dir.chdir directory do
+          spec = Gem::Specification.load file
+          if spec then
+            spec.base_dir = base_dir
+
+            spec.extension_dir =
+              File.join base_dir, 'extensions', Gem::Platform.local.to_s,
+                Gem.extension_api_version, "#{name}-#{dir_shortref}"
+
+            spec.full_gem_path = File.dirname spec.loaded_from if spec
+          end
+          spec
+        end
+      end.compact
+    end
+  end
+
+  ##
+  # A hash for the git gem based on the git repository URI.
+
+  def uri_hash # :nodoc:
+    normalized =
+      if @repository =~ %r%^\w+://(\w+@)?% then
+        uri = URI(@repository).normalize.to_s.sub %r%/$%,''
+        uri.sub(/\A(\w+)/) { $1.downcase }
+      else
+        @repository
+      end
+
+    Digest::SHA1.hexdigest normalized
+  end
+
+end
+