rb2exe 0.1.11 → 0.1.12

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

@@ -0,0 +1,182 @@
+require 'rubygems/command'
+require 'rubygems/installer'
+require 'rubygems/version_option'
+require 'rubygems/remote_fetcher'
+
+class Gem::Commands::UnpackCommand < Gem::Command
+
+  include Gem::VersionOption
+
+  def initialize
+    require 'fileutils'
+
+    super 'unpack', 'Unpack an installed gem to the current directory',
+          :version => Gem::Requirement.default,
+          :target  => Dir.pwd
+
+    add_option('--target=DIR',
+               'target directory for unpacking') do |value, options|
+      options[:target] = value
+    end
+
+    add_option('--spec', 'unpack the gem specification') do |value, options|
+      options[:spec] = true
+    end
+
+    add_version_option
+  end
+
+  def arguments # :nodoc:
+    "GEMNAME       name of gem to unpack"
+  end
+
+  def defaults_str # :nodoc:
+    "--version '#{Gem::Requirement.default}'"
+  end
+
+  def description
+    <<-EOF
+The unpack command allows you to examine the contents of a gem or modify
+them to help diagnose a bug.
+
+You can add the contents of the unpacked gem to the load path using the
+RUBYLIB environment variable or -I:
+
+  $ gem unpack my_gem
+  Unpacked gem: '.../my_gem-1.0'
+  [edit my_gem-1.0/lib/my_gem.rb]
+  $ ruby -Imy_gem-1.0/lib -S other_program
+
+You can repackage an unpacked gem using the build command.  See the build
+command help for an example.
+    EOF
+  end
+
+  def usage # :nodoc:
+    "#{program_name} GEMNAME"
+  end
+
+  #--
+  # TODO: allow, e.g., 'gem unpack rake-0.3.1'.  Find a general solution for
+  # this, so that it works for uninstall as well.  (And check other commands
+  # at the same time.)
+
+  def execute
+    get_all_gem_names.each do |name|
+      dependency = Gem::Dependency.new name, options[:version]
+      path = get_path dependency
+
+      unless path then
+        alert_error "Gem '#{name}' not installed nor fetchable."
+        next
+      end
+
+      if @options[:spec] then
+        spec, metadata = get_metadata path
+
+        if metadata.nil? then
+          alert_error "--spec is unsupported on '#{name}' (old format gem)"
+          next
+        end
+
+        spec_file = File.basename spec.spec_file
+
+        open spec_file, 'w' do |io|
+          io.write metadata
+        end
+      else
+        basename = File.basename path, '.gem'
+        target_dir = File.expand_path basename, options[:target]
+
+        package = Gem::Package.new path
+        package.extract_files target_dir
+
+        say "Unpacked gem: '#{target_dir}'"
+      end
+    end
+  end
+
+  ##
+  #
+  # Find cached filename in Gem.path. Returns nil if the file cannot be found.
+  #
+  #--
+  # TODO: see comments in get_path() about general service.
+
+  def find_in_cache(filename)
+    Gem.path.each do |path|
+      this_path = File.join(path, "cache", filename)
+      return this_path if File.exist? this_path
+    end
+
+    return nil
+  end
+
+  ##
+  # Return the full path to the cached gem file matching the given
+  # name and version requirement.  Returns 'nil' if no match.
+  #
+  # Example:
+  #
+  #   get_path 'rake', '> 0.4' # "/usr/lib/ruby/gems/1.8/cache/rake-0.4.2.gem"
+  #   get_path 'rake', '< 0.1' # nil
+  #   get_path 'rak'           # nil (exact name required)
+  #--
+  # TODO: This should be refactored so that it's a general service. I don't
+  # think any of our existing classes are the right place though.  Just maybe
+  # 'Cache'?
+  #
+  # TODO: It just uses Gem.dir for now.  What's an easy way to get the list of
+  # source directories?
+
+  def get_path dependency
+    return dependency.name if dependency.name =~ /\.gem$/i
+
+    specs = dependency.matching_specs
+
+    selected = specs.max_by { |s| s.version }
+
+    return Gem::RemoteFetcher.fetcher.download_to_cache(dependency) unless
+      selected
+
+    return unless dependency.name =~ /^#{selected.name}$/i
+
+    # We expect to find (basename).gem in the 'cache' directory.  Furthermore,
+    # the name match must be exact (ignoring case).
+
+    path = find_in_cache File.basename selected.cache_file
+
+    return Gem::RemoteFetcher.fetcher.download_to_cache(dependency) unless path
+
+    path
+  end
+
+  ##
+  # Extracts the Gem::Specification and raw metadata from the .gem file at
+  # +path+.
+  #--
+  # TODO move to Gem::Package as #raw_spec or something
+
+  def get_metadata path
+    format = Gem::Package.new path
+    spec = format.spec
+
+    metadata = nil
+
+    open path, Gem.binary_mode do |io|
+      tar = Gem::Package::TarReader.new io
+      tar.each_entry do |entry|
+        case entry.full_name
+        when 'metadata' then
+          metadata = entry.read
+        when 'metadata.gz' then
+          metadata = Gem.gunzip entry.read
+        end
+      end
+    end
+
+    return spec, metadata
+  end
+
+end
+

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

@@ -0,0 +1,277 @@
+require 'rubygems/command'
+require 'rubygems/command_manager'
+require 'rubygems/dependency_installer'
+require 'rubygems/install_update_options'
+require 'rubygems/local_remote_options'
+require 'rubygems/spec_fetcher'
+require 'rubygems/version_option'
+require 'rubygems/install_message' # must come before rdoc for messaging
+require 'rubygems/rdoc'
+
+class Gem::Commands::UpdateCommand < Gem::Command
+
+  include Gem::InstallUpdateOptions
+  include Gem::LocalRemoteOptions
+  include Gem::VersionOption
+
+  attr_reader :installer # :nodoc:
+
+  attr_reader :updated # :nodoc:
+
+  def initialize
+    super 'update', 'Update installed gems to the latest version',
+      :document => %w[rdoc ri],
+      :force    => false
+
+    add_install_update_options
+
+    OptionParser.accept Gem::Version do |value|
+      Gem::Version.new value
+
+      value
+    end
+
+    add_option('--system [VERSION]', Gem::Version,
+               'Update the RubyGems system software') do |value, options|
+      value = true unless value
+
+      options[:system] = value
+    end
+
+    add_local_remote_options
+    add_platform_option
+    add_prerelease_option "as update targets"
+
+    @updated   = []
+    @installer = nil
+  end
+
+  def arguments # :nodoc:
+    "REGEXP        regexp to search for in gem name"
+  end
+
+  def defaults_str # :nodoc:
+    "--document --no-force --install-dir #{Gem.dir}"
+  end
+
+  def description # :nodoc:
+    <<-EOF
+The update command will update your gems to the latest version.
+
+The update command does not remove the previous version. Use the cleanup
+command to remove old versions.
+    EOF
+  end
+
+  def usage # :nodoc:
+    "#{program_name} REGEXP [REGEXP ...]"
+  end
+
+  def check_latest_rubygems version # :nodoc:
+    if Gem.rubygems_version == version then
+      say "Latest version currently installed. Aborting."
+      terminate_interaction
+    end
+
+    options[:user_install] = false
+  end
+
+  def check_update_arguments # :nodoc:
+    unless options[:args].empty? then
+      alert_error "Gem names are not allowed with the --system option"
+      terminate_interaction 1
+    end
+  end
+
+  def execute
+    if options[:system] then
+      update_rubygems
+      return
+    end
+
+    say "Updating installed gems"
+
+    hig = highest_installed_gems
+
+    gems_to_update = which_to_update hig, options[:args].uniq
+
+    updated = update_gems gems_to_update
+
+    updated_names = updated.map { |spec| spec.name }
+    not_updated_names = options[:args].uniq - updated_names
+
+    if updated.empty? then
+      say "Nothing to update"
+    else
+      say "Gems updated: #{updated_names.join(' ')}"
+      say "Gems already up-to-date: #{not_updated_names.join(' ')}" unless not_updated_names.empty?
+    end
+  end
+
+  def fetch_remote_gems spec # :nodoc:
+    dependency = Gem::Dependency.new spec.name, "> #{spec.version}"
+    dependency.prerelease = options[:prerelease]
+
+    fetcher = Gem::SpecFetcher.fetcher
+
+    spec_tuples, errors = fetcher.search_for_dependency dependency
+
+    error = errors.find { |e| e.respond_to? :exception }
+
+    raise error if error
+
+    spec_tuples
+  end
+
+  def highest_installed_gems # :nodoc:
+    hig = {} # highest installed gems
+
+    Gem::Specification.each do |spec|
+      if hig[spec.name].nil? or hig[spec.name].version < spec.version then
+        hig[spec.name] = spec
+      end
+    end
+
+    hig
+  end
+
+  def highest_remote_version spec # :nodoc:
+    spec_tuples = fetch_remote_gems spec
+
+    matching_gems = spec_tuples.select do |g,_|
+      g.name == spec.name and g.match_platform?
+    end
+
+    highest_remote_gem = matching_gems.max_by { |g,_| g.version }
+
+    highest_remote_gem ||= [Gem::NameTuple.null]
+
+    highest_remote_gem.first.version
+  end
+
+  def install_rubygems version # :nodoc:
+    args = update_rubygems_arguments
+
+    update_dir = File.join Gem.dir, 'gems', "rubygems-update-#{version}"
+
+    Dir.chdir update_dir do
+      say "Installing RubyGems #{version}"
+
+      # Make sure old rubygems isn't loaded
+      old = ENV["RUBYOPT"]
+      ENV.delete("RUBYOPT") if old
+      installed = system Gem.ruby, 'setup.rb', *args
+      say "RubyGems system software updated" if installed
+      ENV["RUBYOPT"] = old if old
+    end
+  end
+
+  def rubygems_target_version
+    version = options[:system]
+    update_latest = version == true
+
+    if update_latest then
+      version     = Gem::Version.new     Gem::VERSION
+      requirement = Gem::Requirement.new ">= #{Gem::VERSION}"
+    else
+      version     = Gem::Version.new     version
+      requirement = Gem::Requirement.new version
+    end
+
+    rubygems_update         = Gem::Specification.new
+    rubygems_update.name    = 'rubygems-update'
+    rubygems_update.version = version
+
+    hig = {
+      'rubygems-update' => rubygems_update
+    }
+
+    gems_to_update = which_to_update hig, options[:args], :system
+    _, up_ver   = gems_to_update.first
+
+    target = if update_latest then
+               up_ver
+             else
+               version
+             end
+
+    return target, requirement
+  end
+
+  def update_gem name, version = Gem::Requirement.default
+    return if @updated.any? { |spec| spec.name == name }
+
+    update_options = options.dup
+    update_options[:prerelease] = version.prerelease?
+
+    @installer = Gem::DependencyInstaller.new update_options
+
+    say "Updating #{name}"
+    begin
+      @installer.install name, Gem::Requirement.new(version)
+    rescue Gem::InstallError, Gem::DependencyError => e
+      alert_error "Error installing #{name}:\n\t#{e.message}"
+    end
+
+    @installer.installed_gems.each do |spec|
+      @updated << spec
+    end
+  end
+
+  def update_gems gems_to_update
+    gems_to_update.uniq.sort.each do |(name, version)|
+      update_gem name, version
+    end
+
+    @updated
+  end
+
+  ##
+  # Update RubyGems software to the latest version.
+
+  def update_rubygems
+    check_update_arguments
+
+    version, requirement = rubygems_target_version
+
+    check_latest_rubygems version
+
+    update_gem 'rubygems-update', version
+
+    installed_gems = Gem::Specification.find_all_by_name 'rubygems-update', requirement
+    version        = installed_gems.last.version
+
+    install_rubygems version
+  end
+
+  def update_rubygems_arguments # :nodoc:
+    args = []
+    args << '--prefix' << Gem.prefix if Gem.prefix
+    # TODO use --document for >= 1.9 , --no-rdoc --no-ri < 1.9
+    args << '--no-rdoc' unless options[:document].include? 'rdoc'
+    args << '--no-ri'   unless options[:document].include? 'ri'
+    args << '--no-format-executable' if options[:no_format_executable]
+    args << '--previous-version' << Gem::VERSION if
+      options[:system] == true or
+        Gem::Version.new(options[:system]) >= Gem::Version.new(2)
+    args
+  end
+
+  def which_to_update highest_installed_gems, gem_names, system = false
+    result = []
+
+    highest_installed_gems.each do |l_name, l_spec|
+      next if not gem_names.empty? and
+              gem_names.none? { |name| name == l_spec.name }
+
+      highest_remote_ver = highest_remote_version l_spec
+
+      if system or (l_spec.version < highest_remote_ver) then
+        result << [l_spec.name, [l_spec.version, highest_remote_ver].max]
+      end
+    end
+
+    result
+  end
+
+end