rb2exe 0.1.11 → 0.1.12

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

@@ -0,0 +1,64 @@
+##
+# IO wrapper that creates digests of contents written to the IO it wraps.
+
+class Gem::Package::DigestIO
+
+  ##
+  # Collected digests for wrapped writes.
+  #
+  #   {
+  #     'SHA1'   => #<OpenSSL::Digest: [...]>,
+  #     'SHA512' => #<OpenSSL::Digest: [...]>,
+  #   }
+
+  attr_reader :digests
+
+  ##
+  # Wraps +io+ and updates digest for each of the digest algorithms in
+  # the +digests+ Hash.  Returns the digests hash.  Example:
+  #
+  #   io = StringIO.new
+  #   digests = {
+  #     'SHA1'   => OpenSSL::Digest.new('SHA1'),
+  #     'SHA512' => OpenSSL::Digest.new('SHA512'),
+  #   }
+  #
+  #   Gem::Package::DigestIO.wrap io, digests do |digest_io|
+  #     digest_io.write "hello"
+  #   end
+  #
+  #   digests['SHA1'].hexdigest   #=> "aaf4c61d[...]"
+  #   digests['SHA512'].hexdigest #=> "9b71d224[...]"
+
+  def self.wrap io, digests
+    digest_io = new io, digests
+
+    yield digest_io
+
+    return digests
+  end
+
+  ##
+  # Creates a new DigestIO instance.  Using ::wrap is recommended, see the
+  # ::wrap documentation for documentation of +io+ and +digests+.
+
+  def initialize io, digests
+    @io = io
+    @digests = digests
+  end
+
+  ##
+  # Writes +data+ to the underlying IO and updates the digests
+
+  def write data
+    result = @io.write data
+
+    @digests.each do |_, digest|
+      digest << data
+    end
+
+    result
+  end
+
+end
+

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

@@ -0,0 +1,33 @@
+##
+# The primary source of gems is a file on disk, including all usages
+# internal to rubygems.
+#
+# This is a private class, do not depend on it directly. Instead, pass a path
+# object to `Gem::Package.new`.
+
+class Gem::Package::FileSource < Gem::Package::Source # :nodoc: all
+
+  attr_reader :path
+
+  def initialize path
+    @path = path
+  end
+
+  def start
+    @start ||= File.read path, 20
+  end
+
+  def present?
+    File.exist? path
+  end
+
+  def with_write_io &block
+    open path, 'wb', &block
+  end
+
+  def with_read_io &block
+    open path, 'rb', &block
+  end
+
+end
+

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

@@ -0,0 +1,45 @@
+##
+# Supports reading and writing gems from/to a generic IO object.  This is
+# useful for other applications built on top of rubygems, such as
+# rubygems.org.
+#
+# This is a private class, do not depend on it directly. Instead, pass an IO
+# object to `Gem::Package.new`.
+
+class Gem::Package::IOSource < Gem::Package::Source # :nodoc: all
+
+  attr_reader :io
+
+  def initialize io
+    @io = io
+  end
+
+  def start
+    @start ||= begin
+      if io.pos > 0
+        raise Gem::Package::Error, "Cannot read start unless IO is at start"
+      end
+
+      value = io.read 20
+      io.rewind
+      value
+    end
+  end
+
+  def present?
+    true
+  end
+
+  def with_read_io
+    yield io
+  end
+
+  def with_write_io
+    yield io
+  end
+
+  def path
+  end
+
+end
+

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

@@ -0,0 +1,178 @@
+#--
+# Copyright 2006 by Chad Fowler, Rich Kilmer, Jim Weirich and others.
+# All rights reserved.
+# See LICENSE.txt for permissions.
+#++
+
+##
+# The format class knows the guts of the ancient .gem file format and provides
+# the capability to read such ancient gems.
+#
+# Please pretend this doesn't exist.
+
+class Gem::Package::Old < Gem::Package
+
+  undef_method :spec=
+
+  ##
+  # Creates a new old-format package reader for +gem+.  Old-format packages
+  # cannot be written.
+
+  def initialize gem
+    require 'fileutils'
+    require 'zlib'
+    Gem.load_yaml
+
+    @contents        = nil
+    @gem             = gem
+    @security_policy = nil
+    @spec            = nil
+  end
+
+  ##
+  # A list of file names contained in this gem
+
+  def contents
+    verify
+
+    return @contents if @contents
+
+    @gem.with_read_io do |io|
+      read_until_dashes io # spec
+      header = file_list io
+
+      @contents = header.map { |file| file['path'] }
+    end
+  end
+
+  ##
+  # Extracts the files in this package into +destination_dir+
+
+  def extract_files destination_dir
+    verify
+
+    errstr = "Error reading files from gem"
+
+    @gem.with_read_io do |io|
+      read_until_dashes io # spec
+      header = file_list io
+      raise Gem::Exception, errstr unless header
+
+      header.each do |entry|
+        full_name = entry['path']
+
+        destination = install_location full_name, destination_dir
+
+        file_data = ''
+
+        read_until_dashes io do |line|
+          file_data << line
+        end
+
+        file_data = file_data.strip.unpack("m")[0]
+        file_data = Zlib::Inflate.inflate file_data
+
+        raise Gem::Package::FormatError, "#{full_name} in #{@gem} is corrupt" if
+          file_data.length != entry['size'].to_i
+
+        FileUtils.rm_rf destination
+
+        FileUtils.mkdir_p File.dirname destination
+
+        open destination, 'wb', entry['mode'] do |out|
+          out.write file_data
+        end
+
+        verbose destination
+      end
+    end
+  rescue Zlib::DataError
+    raise Gem::Exception, errstr
+  end
+
+  ##
+  # Reads the file list section from the old-format gem +io+
+
+  def file_list io # :nodoc:
+    header = ''
+
+    read_until_dashes io do |line|
+      header << line
+    end
+
+    YAML.load header
+  end
+
+  ##
+  # Reads lines until a "---" separator is found
+
+  def read_until_dashes io # :nodoc:
+    while (line = io.gets) && line.chomp.strip != "---" do
+      yield line if block_given?
+    end
+  end
+
+  ##
+  # Skips the Ruby self-install header in +io+.
+
+  def skip_ruby io # :nodoc:
+    loop do
+      line = io.gets
+
+      return if line.chomp == '__END__'
+      break unless line
+    end
+
+    raise Gem::Exception, "Failed to find end of ruby script while reading gem"
+  end
+
+  ##
+  # The specification for this gem
+
+  def spec
+    verify
+
+    return @spec if @spec
+
+    yaml = ''
+
+    @gem.with_read_io do |io|
+      skip_ruby io
+      read_until_dashes io do |line|
+        yaml << line
+      end
+    end
+
+    yaml_error = if RUBY_VERSION < '1.9' then
+                   YAML::ParseError
+                 elsif YAML.const_defined?(:ENGINE) && YAML::ENGINE.yamler == 'syck' then
+                   YAML::ParseError
+                 else
+                   YAML::SyntaxError
+                 end
+
+    begin
+      @spec = Gem::Specification.from_yaml yaml
+    rescue yaml_error
+      raise Gem::Exception, "Failed to parse gem specification out of gem file"
+    end
+  rescue ArgumentError
+    raise Gem::Exception, "Failed to parse gem specification out of gem file"
+  end
+
+  ##
+  # Raises an exception if a security policy that verifies data is active.
+  # Old format gems cannot be verified as signed.
+
+  def verify
+    return true unless @security_policy
+
+    raise Gem::Security::Exception,
+          'old format gems do not contain signatures and cannot be verified' if
+      @security_policy.verify_data
+
+    true
+  end
+
+end
+

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

@@ -0,0 +1,3 @@
+class Gem::Package::Source # :nodoc:
+end
+

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

@@ -0,0 +1,229 @@
+# -*- coding: utf-8 -*-
+#--
+# Copyright (C) 2004 Mauricio Julio Fernández Pradier
+# See LICENSE.txt for additional licensing information.
+#++
+
+##
+#--
+# struct tarfile_entry_posix {
+#   char name[100];     # ASCII + (Z unless filled)
+#   char mode[8];       # 0 padded, octal, null
+#   char uid[8];        # ditto
+#   char gid[8];        # ditto
+#   char size[12];      # 0 padded, octal, null
+#   char mtime[12];     # 0 padded, octal, null
+#   char checksum[8];   # 0 padded, octal, null, space
+#   char typeflag[1];   # file: "0"  dir: "5"
+#   char linkname[100]; # ASCII + (Z unless filled)
+#   char magic[6];      # "ustar\0"
+#   char version[2];    # "00"
+#   char uname[32];     # ASCIIZ
+#   char gname[32];     # ASCIIZ
+#   char devmajor[8];   # 0 padded, octal, null
+#   char devminor[8];   # o padded, octal, null
+#   char prefix[155];   # ASCII + (Z unless filled)
+# };
+#++
+# A header for a tar file
+
+class Gem::Package::TarHeader
+
+  ##
+  # Fields in the tar header
+
+  FIELDS = [
+    :checksum,
+    :devmajor,
+    :devminor,
+    :gid,
+    :gname,
+    :linkname,
+    :magic,
+    :mode,
+    :mtime,
+    :name,
+    :prefix,
+    :size,
+    :typeflag,
+    :uid,
+    :uname,
+    :version,
+  ]
+
+  ##
+  # Pack format for a tar header
+
+  PACK_FORMAT = 'a100' + # name
+                'a8'   + # mode
+                'a8'   + # uid
+                'a8'   + # gid
+                'a12'  + # size
+                'a12'  + # mtime
+                'a7a'  + # chksum
+                'a'    + # typeflag
+                'a100' + # linkname
+                'a6'   + # magic
+                'a2'   + # version
+                'a32'  + # uname
+                'a32'  + # gname
+                'a8'   + # devmajor
+                'a8'   + # devminor
+                'a155'   # prefix
+
+  ##
+  # Unpack format for a tar header
+
+  UNPACK_FORMAT = 'A100' + # name
+                  'A8'   + # mode
+                  'A8'   + # uid
+                  'A8'   + # gid
+                  'A12'  + # size
+                  'A12'  + # mtime
+                  'A8'   + # checksum
+                  'A'    + # typeflag
+                  'A100' + # linkname
+                  'A6'   + # magic
+                  'A2'   + # version
+                  'A32'  + # uname
+                  'A32'  + # gname
+                  'A8'   + # devmajor
+                  'A8'   + # devminor
+                  'A155'   # prefix
+
+  attr_reader(*FIELDS)
+
+  ##
+  # Creates a tar header from IO +stream+
+
+  def self.from(stream)
+    header = stream.read 512
+    empty = (header == "\0" * 512)
+
+    fields = header.unpack UNPACK_FORMAT
+
+    new :name     => fields.shift,
+        :mode     => fields.shift.oct,
+        :uid      => fields.shift.oct,
+        :gid      => fields.shift.oct,
+        :size     => fields.shift.oct,
+        :mtime    => fields.shift.oct,
+        :checksum => fields.shift.oct,
+        :typeflag => fields.shift,
+        :linkname => fields.shift,
+        :magic    => fields.shift,
+        :version  => fields.shift.oct,
+        :uname    => fields.shift,
+        :gname    => fields.shift,
+        :devmajor => fields.shift.oct,
+        :devminor => fields.shift.oct,
+        :prefix   => fields.shift,
+
+        :empty => empty
+  end
+
+  ##
+  # Creates a new TarHeader using +vals+
+
+  def initialize(vals)
+    unless vals[:name] && vals[:size] && vals[:prefix] && vals[:mode] then
+      raise ArgumentError, ":name, :size, :prefix and :mode required"
+    end
+
+    vals[:uid] ||= 0
+    vals[:gid] ||= 0
+    vals[:mtime] ||= 0
+    vals[:checksum] ||= ""
+    vals[:typeflag] = "0" if vals[:typeflag].nil? || vals[:typeflag].empty?
+    vals[:magic] ||= "ustar"
+    vals[:version] ||= "00"
+    vals[:uname] ||= "wheel"
+    vals[:gname] ||= "wheel"
+    vals[:devmajor] ||= 0
+    vals[:devminor] ||= 0
+
+    FIELDS.each do |name|
+      instance_variable_set "@#{name}", vals[name]
+    end
+
+    @empty = vals[:empty]
+  end
+
+  ##
+  # Is the tar entry empty?
+
+  def empty?
+    @empty
+  end
+
+  def ==(other) # :nodoc:
+    self.class === other and
+    @checksum == other.checksum and
+    @devmajor == other.devmajor and
+    @devminor == other.devminor and
+    @gid      == other.gid      and
+    @gname    == other.gname    and
+    @linkname == other.linkname and
+    @magic    == other.magic    and
+    @mode     == other.mode     and
+    @mtime    == other.mtime    and
+    @name     == other.name     and
+    @prefix   == other.prefix   and
+    @size     == other.size     and
+    @typeflag == other.typeflag and
+    @uid      == other.uid      and
+    @uname    == other.uname    and
+    @version  == other.version
+  end
+
+  def to_s # :nodoc:
+    update_checksum
+    header
+  end
+
+  ##
+  # Updates the TarHeader's checksum
+
+  def update_checksum
+    header = header " " * 8
+    @checksum = oct calculate_checksum(header), 6
+  end
+
+  private
+
+  def calculate_checksum(header)
+    header.unpack("C*").inject { |a, b| a + b }
+  end
+
+  def header(checksum = @checksum)
+    header = [
+      name,
+      oct(mode, 7),
+      oct(uid, 7),
+      oct(gid, 7),
+      oct(size, 11),
+      oct(mtime, 11),
+      checksum,
+      " ",
+      typeflag,
+      linkname,
+      magic,
+      oct(version, 2),
+      uname,
+      gname,
+      oct(devmajor, 7),
+      oct(devminor, 7),
+      prefix
+    ]
+
+    header = header.pack PACK_FORMAT
+
+    header << ("\0" * ((512 - header.size) % 512))
+  end
+
+  def oct(num, len)
+    "%0#{len}o" % num
+  end
+
+end
+