-required_version = Gem::Requirement.new "> 1.8.3"

- abort "Expected Ruby Version #{required_version}, was #{Gem.ruby_version}"

-# We need to preserve the original ARGV to use for passing gem options

-# to source gems. If there is a -- in the line, strip all options after

-# it...its for the source building process.

-args = !ARGV.include?("--") ? ARGV.clone : ARGV[0...ARGV.index("--")]

-# NOTICE: Ruby is during initialization here.

-# * Encoding.default_external does not reflects -E.

-# * Should not expect Encoding.default_internal.

-# * Locale encoding is available.

- class LoadError < ::LoadError

- end

-

- :sitedir => RbConfig::CONFIG["sitedir"],

- :ruby_version => RbConfig::CONFIG["ruby_version"],

- :rubylibprefix => RbConfig::CONFIG["rubylibprefix"],

- :libdir => RbConfig::CONFIG["libdir"],

- :sitelibdir => RbConfig::CONFIG["sitelibdir"],

- :arch => RbConfig::CONFIG["arch"],

- :bindir => RbConfig::CONFIG["bindir"],

- :EXEEXT => RbConfig::CONFIG["EXEEXT"],

- :RUBY_SO_NAME => RbConfig::CONFIG["RUBY_SO_NAME"],

- :ruby_install_name => RbConfig::CONFIG["ruby_install_name"]

- ensure_gem_subdirectories(@gem_home)

- @gem_path.uniq!

- @gem_path.each do |gp| ensure_gem_subdirectories(gp) end

- end

- def self.ensure_gem_subdirectories(path)

- ConfigMap[:sitelibdir].sub(%r'/site_ruby/(?=[^/]+)', '/gems/')

- [user_dir, default_dir]

- baseruby = ConfigMap[:BASERUBY] || 'ruby'

- ConfigMap[:RUBY_INSTALL_NAME].sub(baseruby, '%s') rescue '%s'

- $DEBUG = $VERBOSE = nil

- unless GemPaths.has_key?(gem_name)

- raise Gem::LoadError.new("Could not find RubyGem #{gem_name} (>= 0)\n")

- if version_requirements.length > 1

- if loaded_version = GemVersions[gem_name]

- when ">", ">="

- if (loaded_version <=> Gem.calculate_integers_for_gem_version(version)) >= 0

- return false

- end

- when "~>"

- required_version = Gem.calculate_integers_for_gem_version(version)

- if (loaded_version[0] == required_version[0])

- return false

- end

- gem(gem_name, *version_requirements)

- def calculate_integers_for_gem_version(gem_version)

- if File.exist?(gems_directory)

- new_version = calculate_integers_for_gem_version(gem_directory_name[dash+1..-1])

- if current_version

- if (current_version <=> new_version) == -1

- unless require_paths.empty?

- if Gem.const_defined?(constant)

- Gem.const_get(constant)

- $" << File.join(Gem::ConfigMap[:rubylibprefix],

-

- # Only define datadir if it doesn't already exist.

- unless RbConfig.respond_to?(:datadir)

- # Return the path to the data directory associated with the given

- # package name. Normally this is just

- # "#{RbConfig::CONFIG['datadir']}/#{package_name}", but may be

- # modified by packages like RubyGems to handle versioned data

- # directories.

- def RbConfig.datadir(package_name)

- File.join(CONFIG['datadir'], package_name)

- end

- end

- attr_accessor :name, :version_requirement

-# Main module to hold all RubyGem classes/modules.

- RbConfig = Config unless defined? ::RbConfig

- :BASERUBY => RbConfig::CONFIG["BASERUBY"],

- :RUBY_INSTALL_NAME => RbConfig::CONFIG["RUBY_INSTALL_NAME"],

- raise Gem::Exception,

- "can't activate #{gem}, already activated #{existing_spec.full_name}"

- activate dep_gem

- # find_files does not search $LOAD_PATH for files, only gems.

- specs.map do |spec|

- File.expand_path("~")

- caller[1] =~ /(.*?):(\d+)$/i

- # manage_gems is useless and deprecated. Don't call it anymore.

-

- def self.manage_gems # :nodoc:

- file, lineno = location_of_caller

-

- warn "#{file}:#{lineno}:Warning: Gem::manage_gems is deprecated and will be removed on or after March 2009."

- end

-

- ##

- def self.required_location(gemname, libfile, *version_constraints)

- version_constraints = Gem::Requirement.default if version_constraints.empty?

- matches = Gem.source_index.find_name(gemname, version_constraints)

- result = File.join(spec.full_gem_path, path, libfile)

- return result if File.exist?(result)

- version << ".#{RUBY_LEVEL}" if defined? RUBY_LEVEL

- home = home.gsub(File::ALT_SEPARATOR, File::SEPARATOR) if File::ALT_SEPARATOR

-module RbConfig

- # :stopdoc:

- class << self

- # Return the path to the data directory associated with the named

- # package. If the package is loaded as a gem, return the gem

- # specific data directory. Otherwise return a path to the share

- # area as define by "#{ConfigMap[:datadir]}/#{package_name}".

- def datadir(package_name)

- Gem.datadir(package_name) ||

- File.join(Gem::ConfigMap[:datadir], package_name)

- end

- end

- # :startdoc:

-module Gem

- # The Builder class processes RubyGem specification files

- # to produce a .gem file.

- class Builder

-

- include UserInteraction

- ##

- # Constructs a builder instance for the provided specification

- #

- # spec:: [Gem::Specification] The specification instance

- #

- def initialize(spec)

- require "yaml"

- require "rubygems/package"

- require "rubygems/security"

-

- @spec = spec

- end

- ##

- # Builds the gem from the specification. Returns the name of the file

- # written.

- #

- def build

- @spec.mark_version

- @spec.validate

- @signer = sign

- write_package

- say success

- @spec.file_name

- end

- def success

- <<-EOM

- end

- private

-

- def sign

- # if the signing key was specified, then load the file, and swap

- # to the public key (TODO: we should probably just omit the

- # signing key in favor of the signing certificate, but that's for

- # the future, also the signature algorithm should be configurable)

- signer = nil

- if @spec.respond_to?(:signing_key) && @spec.signing_key

- signer = Gem::Security::Signer.new(@spec.signing_key, @spec.cert_chain)

- @spec.signing_key = nil

- @spec.cert_chain = signer.cert_chain.map { |cert| cert.to_s }

- end

- signer

- def write_package

- open @spec.file_name, 'wb' do |gem_io|

- Gem::Package.open gem_io, 'w', @signer do |pkg|

- pkg.metadata = @spec.to_yaml

- @spec.files.each do |file|

- next if File.directory? file

- stat = File.stat file

- mode = stat.mode & 0777

- size = stat.size

- pkg.add_file_simple file, mode, size do |tar_io|

- tar_io.write open(file, "rb") { |f| f.read }

- end

-

-module Gem

- # Base class for all Gem commands. When creating a new gem command, define

- # #arguments, #defaults_str, #description and #usage (as appropriate).

- class Command

- include UserInteraction

- # The name of the command.

- attr_reader :command

- # The options for the command.

- attr_reader :options

- # The default options for the command.

- attr_accessor :defaults

- # The name of the command for command-line invocation.

- attr_accessor :program_name

- # A short description of the command.

- attr_accessor :summary

- # Initializes a generic gem command named +command+. +summary+ is a short

- # description displayed in `gem help commands`. +defaults+ are the

- # default options. Defaults should be mirrored in #defaults_str, unless

- # there are none.

- #

- # Use add_option to add command-line switches.

- def initialize(command, summary=nil, defaults={})

- @command = command

- @summary = summary

- @program_name = "gem #{command}"

- @defaults = defaults

- @options = defaults.dup

- @option_groups = Hash.new { |h,k| h[k] = [] }

- @parser = nil

- @when_invoked = nil

- end

- # True if +long+ begins with the characters from +short+.

- def begins?(long, short)

- return false if short.nil?

- long[0, short.length] == short

- end

- # Override to provide command handling.

- def execute

- fail "Generic command has no actions"

- end

- # Get all gem names from the command line.

- def get_all_gem_names

- args = options[:args]

- if args.nil? or args.empty? then

- raise Gem::CommandLineError,

- "Please specify at least one gem name (e.g. gem build GEMNAME)"

- end

- gem_names = args.select { |arg| arg !~ /^-/ }

- end

- # Get the single gem name from the command line. Fail if there is no gem

- # name or if there is more than one gem name given.

- def get_one_gem_name

- args = options[:args]

- if args.nil? or args.empty? then

- raise Gem::CommandLineError,

- "Please specify a gem name on the command line (e.g. gem build GEMNAME)"

- end

- if args.size > 1 then

- raise Gem::CommandLineError,

- "Too many gem names (#{args.join(', ')}); please specify only one"

- end

- args.first

- end

- # Get a single optional argument from the command line. If more than one

- # argument is given, return only the first. Return nil if none are given.

- def get_one_optional_argument

- args = options[:args] || []

- args.first

- # Override to provide details of the arguments a command takes.

- # It should return a left-justified string, one argument per line.

- def arguments

- ""

- end

- # Override to display the default values of the command

- # options. (similar to +arguments+, but displays the default

- # values).

- def defaults_str

- ""

- end

- # Override to display a longer description of what this command does.

- def description

- nil

- end

- # Override to display the usage for an individual gem command.

- def usage

- program_name

- end

- # Display the help message for the command.

- def show_help

- parser.program_name = usage

- say parser

- end

- # Invoke the command with the given list of arguments.

- def invoke(*args)

- handle_options(args)

- if options[:help]

- show_help

- elsif @when_invoked

- @when_invoked.call(options)

- else

- execute

- end

-

- # Call the given block when invoked.

- #

- # Normal command invocations just executes the +execute+ method of

- # the command. Specifying an invocation block allows the test

- # methods to override the normal action of a command to determine

- # that it has been invoked correctly.

- def when_invoked(&block)

- @when_invoked = block

- # Add a command-line option and handler to the command.

- #

- # See OptionParser#make_switch for an explanation of +opts+.

- #

- # +handler+ will be called with two values, the value of the argument and

- # the options hash.

- def add_option(*opts, &handler) # :yields: value, options

- group_name = Symbol === opts.first ? opts.shift : :options

- @option_groups[group_name] << [opts, handler]

- end

- # Remove previously defined command-line argument +name+.

- def remove_option(name)

- @option_groups.each do |_, option_list|

- option_list.reject! { |args, _| args.any? { |x| x =~ /^#{name}/ } }

- end

- end

- # Merge a set of command options with the set of default options

- # (without modifying the default option hash).

- def merge_options(new_options)

- @options = @defaults.clone

- new_options.each do |k,v| @options[k] = v end

- # True if the command handles the given argument list.

- def handles?(args)

- begin

- parser.parse!(args.dup)

- return true

- rescue

- return false

- end

- # Handle the given list of arguments by parsing them and recording

- # the results.

- def handle_options(args)

- args = add_extra_args(args)

- @options = @defaults.clone

- parser.parse!(args)

- @options[:args] = args

-

- def add_extra_args(args)

- result = []

- s_extra = Command.specific_extra_args(@command)

- extra = Command.extra_args + s_extra

- while ! extra.empty?

- ex = []

- ex << extra.shift

- ex << extra.shift if extra.first.to_s =~ /^[^-]/

- result << ex if handles?(ex)

- end

- result.flatten!

- result.concat(args)

- result

-

- private

-

- # Create on demand parser.

- def parser

- create_option_parser if @parser.nil?

- @parser

- def create_option_parser

- @parser = OptionParser.new

-

- @parser.separator("")

- regular_options = @option_groups.delete :options

-

- configure_options "", regular_options

-

- @option_groups.sort_by { |n,_| n.to_s }.each do |group_name, option_list|

- configure_options group_name, option_list

- end

-

- configure_options "Common", Command.common_options

- @parser.separator("")

- unless arguments.empty?

- @parser.separator(" Arguments:")

- arguments.split(/\n/).each do |arg_desc|

- @parser.separator(" #{arg_desc}")

- end

- @parser.separator("")

- end

- @parser.separator(" Summary:")

- wrap(@summary, 80 - 4).split("\n").each do |line|

- @parser.separator(" #{line.strip}")

- end

- if description then

- formatted = description.split("\n\n").map do |chunk|

- wrap(chunk, 80 - 4)

- end.join("\n")

- @parser.separator ""

- @parser.separator " Description:"

- formatted.split("\n").each do |line|

- @parser.separator " #{line.rstrip}"

- end

- end

- unless defaults_str.empty?

- @parser.separator("")

- @parser.separator(" Defaults:")

- defaults_str.split(/\n/).each do |line|

- @parser.separator(" #{line}")

- end

- end

- def configure_options(header, option_list)

- return if option_list.nil? or option_list.empty?

- header = header.to_s.empty? ? '' : "#{header} "

- @parser.separator " #{header}Options:"

- option_list.each do |args, handler|

- dashes = args.select { |arg| arg =~ /^-/ }

- @parser.on(*args) do |value|

- handler.call(value, @options)

- end

- end

- @parser.separator ''

- end

- # Wraps +text+ to +width+

- def wrap(text, width)

- text.gsub(/(.{1,#{width}})( +|$\n?)|(.{1,#{width}})/, "\\1\\3\n")

- end

-

- ##################################################################

- # Class methods for Command.

- class << self

- def common_options

- @common_options ||= []

- end

- def add_common_option(*args, &handler)

- Gem::Command.common_options << [args, handler]

- end

- def extra_args

- @extra_args ||= []

- end

-

- def extra_args=(value)

- case value

- when Array

- @extra_args = value

- when String

- @extra_args = value.split

- end

- end

- # Return an array of extra arguments for the command. The extra

- # arguments come from the gem configuration file read at program

- # startup.

- def specific_extra_args(cmd)

- specific_extra_args_hash[cmd]

- end

- # Add a list of extra arguments for the given command. +args+

- # may be an array or a string to be split on white space.

- def add_specific_extra_args(cmd,args)

- args = args.split(/\s+/) if args.kind_of? String

- specific_extra_args_hash[cmd] = args

- end

- # Accessor for the specific extra args hash (self initializing).

- def specific_extra_args_hash

- @specific_extra_args_hash ||= Hash.new do |h,k|

- h[k] = Array.new

- end

- # ----------------------------------------------------------------

- # Add the options common to all commands.

-

- add_common_option('-h', '--help',

- 'Get help on this command') do

- |value, options|

- options[:help] = true

- add_common_option('-V', '--[no-]verbose',

- 'Set the verbose level of output') do |value, options|

- # Set us to "really verbose" so the progress meter works

- if Gem.configuration.verbose and value then

- Gem.configuration.verbose = 1

- else

- Gem.configuration.verbose = value

- add_common_option('-q', '--quiet', 'Silence commands') do |value, options|

- Gem.configuration.verbose = false

- # Backtrace and config-file are added so they show up in the help

- # commands. Both options are actually handled before the other

- # options get parsed.

- add_common_option('--config-file FILE',

- "Use this config file instead of default") do

- end

- add_common_option('--backtrace',

- 'Show stack backtrace on errors') do

- add_common_option('--debug',

- 'Turn on Ruby debugging') do

- end

- # :stopdoc:

- HELP = %{

- RubyGems is a sophisticated package manager for Ruby. This is a

- basic help message containing pointers to more information.

- Usage:

- gem -h/--help

- gem -v/--version

- gem command [arguments...] [options...]

- Examples:

- gem install rake

- gem list --local

- gem build package.gemspec

- gem help install

- Further help:

- gem help commands list all 'gem' commands

- gem help examples show some examples of usage

- gem help platforms show information about platforms

- gem help <COMMAND> show help on COMMAND

- (e.g. 'gem help install')

- Further information:

- http://rubygems.rubyforge.org

- }.gsub(/^ /, "")

- # :startdoc:

- end # class

- # This is where Commands will be placed in the namespace

- module Commands; end

-module Gem

- ####################################################################

- # The command manager registers and installs all the individual

- # sub-commands supported by the gem command.

- class CommandManager

- include UserInteraction

- # Return the authoritative instance of the command manager.

- def self.instance

- @command_manager ||= CommandManager.new

- end

- # Register all the subcommands supported by the gem command.

- def initialize

- @commands = {}

- register_command :build

- register_command :cert

- register_command :check

- register_command :cleanup

- register_command :contents

- register_command :dependency

- register_command :environment

- register_command :fetch

- register_command :generate_index

- register_command :help

- register_command :install

- register_command :list

- register_command :lock

- register_command :mirror

- register_command :outdated

- register_command :pristine

- register_command :query

- register_command :rdoc

- register_command :search

- register_command :server

- register_command :sources

- register_command :specification

- register_command :stale

- register_command :uninstall

- register_command :unpack

- register_command :update

- register_command :which

- end

- # Register the command object.

- def register_command(command_obj)

- @commands[command_obj] = false

- end

- # Return the registered command from the command name.

- def [](command_name)

- command_name = command_name.intern

- return nil if @commands[command_name].nil?

- @commands[command_name] ||= load_and_instantiate(command_name)

- end

- # Return a list of all command names (as strings).

- def command_names

- @commands.keys.collect {|key| key.to_s}.sort

- end

- # Run the config specified by +args+.

- def run(args)

- process_args(args)

- rescue StandardError, Timeout::Error => ex

- alert_error "While executing gem ... (#{ex.class})\n #{ex.to_s}"

- ui.errs.puts "\t#{ex.backtrace.join "\n\t"}" if

- Gem.configuration.backtrace

- rescue Interrupt

- alert_error "Interrupted"

- def process_args(args)

- args = args.to_str.split(/\s+/) if args.respond_to?(:to_str)

- if args.size == 0

- say Gem::Command::HELP

- terminate_interaction(1)

- end

- case args[0]

- when '-h', '--help'

- say Gem::Command::HELP

- terminate_interaction(0)

- when '-v', '--version'

- say Gem::RubyGemsVersion

- terminate_interaction(0)

- when /^-/

- alert_error "Invalid option: #{args[0]}. See 'gem --help'."

- terminate_interaction(1)

- else

- cmd_name = args.shift.downcase

- cmd = find_command(cmd_name)

- cmd.invoke(*args)

- end

- def find_command(cmd_name)

- possibilities = find_command_possibilities(cmd_name)

- if possibilities.size > 1

- raise "Ambiguous command #{cmd_name} matches [#{possibilities.join(', ')}]"

- end

- if possibilities.size < 1

- raise "Unknown command #{cmd_name}"

- end

- self[possibilities.first]

- end

- def find_command_possibilities(cmd_name)

- len = cmd_name.length

- self.command_names.select { |n| cmd_name == n[0,len] }

- end

- private

-

- def load_and_instantiate(command_name)

- command_name = command_name.to_s

- retried = false

-

- begin

- const_name = command_name.capitalize.gsub(/_(.)/) { $1.upcase }

- Gem::Commands.const_get("#{const_name}Command").new

- rescue NameError

- if retried then

- raise

- else

- retried = true

- require "rubygems/commands/#{command_name}_command"

- retry

- end

- Gem::Validator.new.alien.each do |key, val|

- if(val.size > 0)

- say "\t#{error_entry.path}:"

- say "\t#{error_entry.problem}"

- say

- say "#{key} is error-free"

- specs = Gem.cache.search(/^#{gem_name}$/i)

- uninstall_command = Gem::CommandManager.instance['uninstall']

- options[:version] = "= #{spec.version}"

- options[:executables] = false

- uninstaller = Gem::Uninstaller.new spec.name, options

- rescue Gem::DependencyRemovalException,

- "--no-lib-only"

- "#{program_name} GEMNAME"

- gem = get_one_gem_name

- s = options[:specdirs].map do |i|

- path_kind = if s.empty? then

- s = Gem::SourceIndex.installed_spec_directories

- si = Gem::SourceIndex.from_gems_in(*s)

- gem_spec = si.find_name(gem, version).last

- unless gem_spec then

- say "Unable to find gem '#{gem}' in #{path_kind}"

- if Gem.configuration.verbose then

- say "\nDirectories searched:"

- s.each { |dir| say dir }

- terminate_interaction

- end

- files = options[:lib_only] ? gem_spec.lib_files : gem_spec.files

- files.each do |f|

- say File.join(gem_spec.full_gem_path, f)

- :directory => '.'

- "--directory ."

-the --directory option. When done, it will generate a set of files like this:

- gems/ # .gem files you want to index

- quick/<gemname>.gemspec.rz # legacy YAML quick index file

- quick/Marshal.<version>/<gemname>.gemspec.rz # Marshal quick index file

- Marshal.<version>.Z # Marshal full index

- yaml.Z # legacy YAML full index

-The .Z and .rz extension files are compressed with the inflate algorithm. The

-Marshal version number comes from ruby's Marshal::MAJOR_VERSION and

-Marshal::MINOR_VERSION constants. It is used to ensure compatibility. The

-yaml indexes exist for legacy RubyGems clients and fallback in case of Marshal

-version changes.

- indexer = Gem::Indexer.new options[:directory]

- indexer.generate_index

- :generate_rdoc => true,

- :generate_ri => true,

- :test => false,

- :version => Gem::Requirement.default,

-directory by deault. This can be overridden with the --no-wrappers option.

- install_options = {

- :env_shebang => options[:env_shebang],

- :domain => options[:domain],

- :force => options[:force],

- :format_executable => options[:format_executable],

- :ignore_dependencies => options[:ignore_dependencies],

- :install_dir => options[:install_dir],

- :security_policy => options[:security_policy],

- :wrappers => options[:wrappers],

- :bin_dir => options[:bin_dir],

- :development => options[:development],

- }

-

- inst = Gem::DependencyInstaller.new install_options

-# rescue => e

-# # TODO: Fix this handle to allow the error to propagate to

-# # the top level handler. Examine the other errors as

-# # well. This implementation here looks suspicious to me --

-# # JimWeirich (4/Jan/05)

-# alert_error "Error installing gem #{gem_name}: #{e.message}"

-# return

- end

- # NOTE: *All* of the RI documents must be generated first.

- # For some reason, RI docs cannot be generated after any RDoc

- # documents are generated.

- if options[:generate_ri] then

- installed_gems.each do |gem|

- Gem::DocManager.new(gem, options[:rdoc_args]).generate_ri

- end

- Gem::DocManager.update_ri_cache

- end

- if options[:generate_rdoc] then

- installed_gems.each do |gem|

- Gem::DocManager.new(gem, options[:rdoc_args]).generate_rdoc

- end

- if options[:test] then

- installed_gems.each do |spec|

- gem_spec = Gem::SourceIndex.from_installed_gems.search(spec.name, spec.version.version).first

- result = Gem::Validator.new.unit_test(gem_spec)

- if result and not result.passed?

- unless ask_yes_no("...keep Gem?", true) then

- Gem::Uninstaller.new(spec.name, :version => spec.version.version).uninstall

- spec_tuples = fetcher.find_matching dep, all, false

- ##

- # Used for wrapping and indenting text

-

- def format_text(text, wrap, indent=0)

- result = []

- work = text.dup

-

- while work.length > wrap

- if work =~ /^(.{0,#{wrap}})[ \n]/o then

- result << $1

- work.slice!(0, $&.length)

- else

- result << work.slice!(0, wrap)

- end

- end

-

- result << work if work.length.nonzero?

- result.join("\n").gsub(/^/, " " * indent)

- end

-

-module Gem

- module Commands

- class RdocCommand < Command

- include VersionOption

-

- def initialize

- super('rdoc',

- 'Generates RDoc for pre-installed gems',

- {

- :version => Gem::Requirement.default,

- :include_rdoc => true,

- :include_ri => true,

- })

- add_option('--all',

- 'Generate RDoc/RI documentation for all',

- 'installed gems') do |value, options|

- options[:all] = value

- end

- add_option('--[no-]rdoc',

- 'Include RDoc generated documents') do

- |value, options|

- options[:include_rdoc] = value

- end

- add_option('--[no-]ri',

- 'Include RI generated documents'

- ) do |value, options|

- options[:include_ri] = value

- end

- add_version_option

- end

- def arguments # :nodoc:

- "GEMNAME gem to generate documentation for (unless --all)"

- end

- def defaults_str # :nodoc:

- "--version '#{Gem::Requirement.default}' --rdoc --ri"

- end

- def usage # :nodoc:

- "#{program_name} [args]"

- def execute

- if options[:all]

- specs = Gem::SourceIndex.from_installed_gems.collect { |name, spec|

- spec

- }

- else

- gem_name = get_one_gem_name

- specs = Gem::SourceIndex.from_installed_gems.search(

- gem_name, options[:version])

- end

-

- if specs.empty?

- fail "Failed to find gem #{gem_name} to generate RDoc for #{options[:version]}"

- end

-

- if options[:include_ri]

- specs.each do |spec|

- Gem::DocManager.new(spec).generate_ri

- end

-

- Gem::DocManager.update_ri_cache

- end

-

- if options[:include_rdoc]

- specs.each do |spec|

- Gem::DocManager.new(spec).generate_rdoc

- end

- end

-

- true

-module Gem

- module Commands

-

- class SearchCommand < QueryCommand

-

- def initialize

- super(

- 'search',

- 'Display all gems whose name contains STRING'

- )

- remove_option('--name-matches')

- end

-

- def arguments # :nodoc:

- "STRING fragment of gem name to search for"

- end

-

- def defaults_str # :nodoc:

- "--local --no-details"

- end

-

- def usage # :nodoc:

- "#{program_name} [STRING]"

- end

-

- def execute

- string = get_one_optional_argument

- options[:name] = /#{string}/i

- super

- end

- end

- add_option '-p', '--port=PORT', Integer,

- :domain => :local, :version => Gem::Requirement.default

- "GEMFILE name of gem to show the gemspec for"

- "--local --version '#{Gem::Requirement.default}'"

- "#{program_name} [GEMFILE]"

- gem = get_one_gem_name

- output = lambda { |s| say s.to_yaml; say "\n" }

-module Gem

- module Commands

- class UninstallCommand < Command

-

- include VersionOption

-

- def initialize

- super 'uninstall', 'Uninstall gems from the local repository',

- :version => Gem::Requirement.default

-

- add_option('-a', '--[no-]all',

- 'Uninstall all matching versions'

- ) do |value, options|

- options[:all] = value

- end

-

- add_option('-I', '--[no-]ignore-dependencies',

- 'Ignore dependency requirements while',

- 'uninstalling') do |value, options|

- options[:ignore] = value

- end

-

- add_option('-x', '--[no-]executables',

- 'Uninstall applicable executables without',

- 'confirmation') do |value, options|

- options[:executables] = value

- end

-

- add_option('-i', '--install-dir DIR',

- 'Directory to uninstall gem from') do |value, options|

- options[:install_dir] = File.expand_path(value)

- end

-

- add_option('-n', '--bindir DIR',

- 'Directory to remove binaries from') do |value, options|

- options[:bin_dir] = File.expand_path(value)

- end

-

- add_version_option

- add_platform_option

- end

- def arguments # :nodoc:

- "GEMNAME name of gem to uninstall"

- end

- def defaults_str # :nodoc:

- "--version '#{Gem::Requirement.default}' --no-force " \

- "--install-dir #{Gem.dir}"

- end

- def usage # :nodoc:

- "#{program_name} GEMNAME [GEMNAME ...]"

- end

- def execute

- get_all_gem_names.each do |gem_name|

- begin

- Gem::Uninstaller.new(gem_name, options).uninstall

- rescue Gem::GemNotInHomeException => e

- spec = e.spec

- alert("In order to remove #{spec.name}, please execute:\n" \

- "\tgem uninstall #{spec.name} --install-dir=#{spec.installation_path}")

- end

- end

- add_option('--target', 'target directory for unpacking') do |value, options|

- gemname = get_one_gem_name

- path = get_path(gemname, options[:version])

-

- if path then

- basename = File.basename(path).sub(/\.gem$/, '')

- target_dir = File.expand_path File.join(options[:target], basename)

- FileUtils.mkdir_p target_dir

- Gem::Installer.new(path, :unpack => true).unpack target_dir

- say "Unpacked gem: '#{target_dir}'"

- else

- alert_error "Gem '#{gemname}' not installed."

- :generate_ri => true,

- :force => false,

- :test => false

- installer.install name

- say "Successfully installed #{spec.full_name}"

- update_gems = Gem.source_index.search 'rubygems-update'

- Gem.configuration.verbose

-require 'rubygems'

- SHGetFolderPath = Win32API.new 'shell32', 'SHGetFolderPath', 'PLPLP', 'L', :stdcall

- ConfigMap[:sitelibdir].sub(%r'/site_ruby/(?=[^/]+)', '/gems/')

- [user_dir, default_dir]

- baseruby = ConfigMap[:BASERUBY] || 'ruby'

- ConfigMap[:RUBY_INSTALL_NAME].sub(baseruby, '%s') rescue '%s'

-require 'rubygems'

-

- ver = @version_requirement.instance_eval { @version }

- # Uses this dependency as a pattern to compare to the dependency +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.

- return false unless self.class === other

- pattern = /\A#{@name}\Z/ unless Regexp === pattern

- def hash # :nodoc:

- :wrappers => true

- all = requirements.length > 1 ||

- (requirements.first != ">=" and requirements.first != ">")

- found = Gem::SpecFetcher.fetcher.fetch dep, all

- # Return a list of the specifications in the dependency list,

- # sorted in order so that no spec in the list depends on a gem

- # earlier in the list.

- # This is useful when removing gems from a set of installed gems.

- # By removing them in the returned order, you don't get into as

- # many dependency issues.

- # If there are circular dependencies (yuck!), then gems will be

- # returned in order until only the circular dependents and anything

- # they reference are left. Then arbitrary gemspecs will be returned

- # until the circular dependency is broken, after which gems will be

- # returned in dependency order again.

- # If removing the gemspec creates breaks a currently ok dependency,

- # then it is NOT ok to remove the gem.

- # Return a hash of predecessors. <tt>result[spec]</tt> is an

- # Array of gemspecs that have a dependency satisfied by the named

- # spec.

- "ERROR: RDoc documentation generator not installed!"

- if @spec.has_rdoc then

- setup_rdoc

- install_ri # RDoc bug, ri goes first

- end

- if @spec.has_rdoc then

- setup_rdoc

- install_rdoc

- end

- doc_dir = File.join @spec.installation_path, 'doc', @spec.full_name

- unless File.directory? doc_dir then

- doc_dir = File.join @spec.installation_path, 'doc', original_name

- end

- FileUtils.rm_rf doc_dir

- ri_dir = File.join @spec.installation_path, 'ri', @spec.full_name

- unless File.directory? ri_dir then

- ri_dir = File.join @spec.installation_path, 'ri', original_name

- end

- FileUtils.rm_rf ri_dir

-require 'rubygems'

-

-require 'rubygems/ext'

-

- raise Gem::InstallError, "Makefile not found:\n\n#{results.join "\n"}"

- cmd << " #{ARGV.join ' '}" unless ARGV.empty?

- cmd << " #{ARGV.join " "}" unless ARGV.empty?

- cmd = ENV['rake'] || 'rake'

-module Gem

- # The format class knows the guts of the RubyGem .gem file format

- # and provides the capability to read gem files

- class Format

- attr_accessor :spec, :file_entries, :gem_path

- extend Gem::UserInteraction

-

- ##

- # Constructs an instance of a Format object, representing the gem's

- # data structure.

- #

- # gem:: [String] The file name of the gem

- #

- def initialize(gem_path)

- @gem_path = gem_path

- ##

- # Reads the named gem file and returns a Format object, representing

- # the data from the gem file

- #

- # file_path:: [String] Path to the gem file

- #

- def self.from_file_by_path(file_path, security_policy = nil)

- format = nil

-

- unless File.exist?(file_path)

- raise Gem::Exception, "Cannot load gem at [#{file_path}] in #{Dir.pwd}"

- # check for old version gem

- if File.read(file_path, 20).include?("MD5SUM =")

- require 'rubygems/old_format'

- format = OldFormat.from_file_by_path(file_path)

- else

- open file_path, Gem.binary_mode do |io|

- format = from_io io, file_path, security_policy

- end

- end

- return format

- end

- ##

- # Reads a gem from an io stream and returns a Format object, representing

- # the data from the gem file

- #

- # io:: [IO] Stream from which to read the gem

- #

- def self.from_io(io, gem_path="(io)", security_policy = nil)

- format = new gem_path

-

- Package.open io, 'r', security_policy do |pkg|

- format.spec = pkg.metadata

- format.file_entries = []

-

- pkg.each do |entry|

- size = entry.header.size

- mode = entry.header.mode

-

- format.file_entries << [{

- "size" => size, "mode" => mode, "path" => entry.full_name,

- },

- entry.read

- ]

- end

- end

- format

- require 'rubygems/gem_openssl'

- # Set the value of the ssl_available flag.

- #

-require 'rubygems'

-

- # in reverse version order.

- Gem.source_index.map { |_, spec| spec }.sort { |a,b|

- (a.name <=> b.name).nonzero? || (b.version <=> a.version)

-module Gem

- ####################################################################

- # Run an instance of the gem program.

- #

- class GemRunner

- def initialize(options={})

- @command_manager_class = options[:command_manager] || Gem::CommandManager

- @config_file_class = options[:config_file] || Gem::ConfigFile

- @doc_manager_class = options[:doc_manager] || Gem::DocManager

- # Run the gem command with the following arguments.

- def run(args)

- start_time = Time.now

- do_configuration(args)

- cmd = @command_manager_class.instance

- cmd.command_names.each do |command_name|

- config_args = Gem.configuration[command_name]

- config_args = case config_args

- when String

- config_args.split ' '

- else

- Array(config_args)

- end

- Command.add_specific_extra_args command_name, config_args

- end

- cmd.run(Gem.configuration.args)

- end_time = Time.now

- if Gem.configuration.benchmark

- printf "\nExecution time: %0.2f seconds.\n", end_time-start_time

- puts "Press Enter to finish"

- STDIN.gets

- end

- private

- def do_configuration(args)

- Gem.configuration = @config_file_class.new(args)

- Gem.use_paths(Gem.configuration[:gemhome], Gem.configuration[:gempath])

- Gem::Command.extra_args = Gem.configuration[:gem]

- @doc_manager_class.configured_args = Gem.configuration[:rdoc]

- end # class

-end # module

- def initialize(directory)

- files = [

- @specs_index,

- "#{@specs_index}.gz",

- @latest_specs_index,

- "#{@latest_specs_index}.gz",

- @quick_dir,

- @master_index,

- "#{@master_index}.Z",

- @marshal_index,

- "#{@marshal_index}.Z",

- ]

-

- @files = files.map do |path|

- path.sub @directory, ''

- end

- "Generating quick index gemspecs for #{index.size} gems",

- index.each do |original_name, spec|

- spec_file_name = "#{original_name}.gemspec.rz"

- yaml_name = File.join @quick_dir, spec_file_name

- marshal_name = File.join @quick_marshal_dir, spec_file_name

- yaml_zipped = Gem.deflate spec.to_yaml

- open yaml_name, 'wb' do |io| io.write yaml_zipped end

- marshal_zipped = Gem.deflate Marshal.dump(spec)

- open marshal_name, 'wb' do |io| io.write marshal_zipped end

- progress.updated original_name

- progress.done

-

- say "Generating specs index"

- open @specs_index, 'wb' do |io|

- specs = index.sort.map do |_, spec|

- platform = spec.original_platform

- platform = Gem::Platform::RUBY if platform.nil? or platform.empty?

- [spec.name, spec.version, platform]

-

- specs = compact_specs specs

-

- Marshal.dump specs, io

- say "Generating latest specs index"

- open @latest_specs_index, 'wb' do |io|

- specs = index.latest_specs.sort.map do |spec|

- platform = spec.original_platform

- platform = Gem::Platform::RUBY if platform.nil? or platform.empty?

- [spec.name, spec.version, platform]

- specs = compact_specs specs

- Marshal.dump specs, io

- say "Generating quick index"

- quick_index = File.join @quick_dir, 'index'

- open quick_index, 'wb' do |io|

- io.puts index.sort.map { |_, spec| spec.original_name }

- end

- say "Generating latest index"

- latest_index = File.join @quick_dir, 'latest_index'

- open latest_index, 'wb' do |io|

- io.puts index.latest_specs.sort.map { |spec| spec.original_name }

- say "Generating Marshal master index"

- open @marshal_index, 'wb' do |io|

- io.write index.dump

- end

- "Generating YAML master index for #{index.size} gems (this may take a while)",

- open @master_index, 'wb' do |io|

- io.puts "--- !ruby/object:#{index.class}"

- io.puts "gems:"

- gems = index.sort_by { |name, gemspec| gemspec.sort_obj }

- gems.each do |original_name, gemspec|

- yaml = gemspec.to_yaml.gsub(/^/, ' ')

- yaml = yaml.sub(/\A ---/, '') # there's a needed extra ' ' here

- io.print " #{original_name}:"

- io.puts yaml

- progress.done

- say "Compressing indicies"

- # use gzip for future files.

- compress quick_index, 'rz'

- paranoid quick_index, 'rz'

- compress latest_index, 'rz'

- paranoid latest_index, 'rz'

- compress @marshal_index, 'Z'

- paranoid @marshal_index, 'Z'

- compress @master_index, 'Z'

- paranoid @master_index, 'Z'

- gzip @specs_index

- gzip @latest_specs_index

- def collect_specs

- progress = ui.progress_reporter gem_file_list.size,

- "Loading #{gem_file_list.size} gems from #{@dest_directory}",

- gem_file_list.each do |gemfile|

- if File.size(gemfile.to_s) == 0 then

- alert_warning "Skipping zero-length gem: #{gemfile}"

- next

- end

-

- begin

- spec = Gem::Format.from_file_by_path(gemfile).spec

-

- unless gemfile =~ /\/#{Regexp.escape spec.original_name}.*\.gem\z/i then

- alert_warning "Skipping misnamed gem: #{gemfile} => #{spec.full_name} (#{spec.original_name})"

- abbreviate spec

- sanitize spec

- index.gems[spec.original_name] = spec

- progress.updated spec.original_name

- rescue SignalException => e

- alert_error "Received signal, exiting"

- raise

- rescue Exception => e

- alert_error "Unable to process #{gemfile}\n#{e.message} (#{e.class})\n\t#{e.backtrace.join "\n\t"}"

- end

- progress.done

- # Builds and installs indexicies.

- @files.each do |file|

- 'of GEM_HOME. Defaults to using home directory',

-# The installer class processes RubyGem .gem files and installs the

-# files contained in the .gem into the Gem.path.

- ENV_PATHS = %w[/usr/bin/env /bin/env]

-

- @env_shebang = options[:env_shebang]

- @force = options[:force]

- gem_home = options[:install_dir]

- @gem_home = Pathname.new(gem_home).expand_path

- @format_executable = options[:format_executable]

- @security_policy = options[:security_policy]

- @wrappers = options[:wrappers]

- @bin_dir = options[:bin_dir]

- @development = options[:development]

- @source_index = options[:source_index]

- # We'll divert to ~/.gem below

- unless self.class.home_install_warning then

- if !ruby_name

- elsif opts

- %{#!/bin/sh\n'exec' #{ruby_name.dump} '-x' "$0" "$@"\n#{shebang}}

- @env_path ||= ENV_PATHS.find {|path| File.executable?(path)}

-load '#{bin_file_name}'

-@"#{File.basename(Gem.ruby)}" "#{File.join(bindir, bin_file_name)}" %1 %2 %3 %4 %5 %6 %7 %8 %9

-@"#{File.basename(Gem.ruby)}" "%~dpn0" %*

- raise OptionParser::InvalidArgument, value unless uri.scheme == 'http'

- Gem.sources << source

- # Add the --update-source option

-

-module Gem

- # The format class knows the guts of the RubyGem .gem file format

- # and provides the capability to read gem files

- class OldFormat

- attr_accessor :spec, :file_entries, :gem_path

-

- ##

- # Constructs an instance of a Format object, representing the gem's

- # data structure.

- #

- # gem:: [String] The file name of the gem

- #

- def initialize(gem_path)

- @gem_path = gem_path

- end

- ##

- # Reads the named gem file and returns a Format object, representing

- # the data from the gem file

- #

- # file_path:: [String] Path to the gem file

- #

- def self.from_file_by_path(file_path)

- unless File.exist?(file_path)

- raise Gem::Exception, "Cannot load gem file [#{file_path}]"

- end

- File.open(file_path, 'rb') do |file|

- from_io(file, file_path)

- end

- ##

- # Reads a gem from an io stream and returns a Format object, representing

- # the data from the gem file

- #

- # io:: [IO] Stream from which to read the gem

- #

- def self.from_io(io, gem_path="(io)")

- format = self.new(gem_path)

- skip_ruby(io)

- format.spec = read_spec(io)

- format.file_entries = []

- read_files_from_gem(io) do |entry, file_data|

- format.file_entries << [entry, file_data]

- end

- format

- private

- ##

- # Skips the Ruby self-install header. After calling this method, the

- # IO index will be set after the Ruby code.

- #

- # file:: [IO] The IO to process (skip the Ruby code)

- #

- def self.skip_ruby(file)

- end_seen = false

- loop {

- line = file.gets

- if(line == nil || line.chomp == "__END__") then

- end_seen = true

- break

- end

- }

- if(end_seen == false) then

- raise Gem::Exception.new("Failed to find end of ruby script while reading gem")

- end

- ##

- # Reads the specification YAML from the supplied IO and constructs

- # a Gem::Specification from it. After calling this method, the

- # IO index will be set after the specification header.

- #

- # file:: [IO] The IO to process

- #

- def self.read_spec(file)

- yaml = ''

- begin

- read_until_dashes(file) do |line|

- yaml << line

- end

- Specification.from_yaml(yaml)

- rescue YAML::Error => e

- raise Gem::Exception.new("Failed to parse gem specification out of gem file")

- rescue ArgumentError => e

- raise Gem::Exception.new("Failed to parse gem specification out of gem file")

- ##

- # Reads lines from the supplied IO until a end-of-yaml (---) is

- # reached

- #

- # file:: [IO] The IO to process

- # block:: [String] The read line

- #

- def self.read_until_dashes(file)

- while((line = file.gets) && line.chomp.strip != "---") do

- yield line

- end

- ##

- # Reads the embedded file data from a gem file, yielding an entry

- # containing metadata about the file and the file contents themselves

- # for each file that's archived in the gem.

- # NOTE: Many of these methods should be extracted into some kind of

- # Gem file read/writer

- #

- # gem_file:: [IO] The IO to process

- #

- def self.read_files_from_gem(gem_file)

- errstr = "Error reading files from gem"

- header_yaml = ''

- begin

- header_yaml << line

- end

- header = YAML.load(header_yaml)

- raise Gem::Exception.new(errstr) unless header

- header.each do |entry|

- file_data = ''

- self.read_until_dashes(gem_file) do |line|

- file_data << line

- end

- yield [entry, Zlib::Inflate.inflate(file_data.strip.unpack("m")[0])]

- rescue Exception,Zlib::DataError => e

- raise Gem::Exception.new(errstr)

-require 'rubygems/package'

-

-require 'rubygems/package'

-

- def ==(other)

- def to_s

-require 'rubygems/package'

-

- if Gem::Security::Policy.key? security_policy then

- security_policy = Gem::Security::Policy[security_policy]

- dest = File.join(destdir, entry.full_name)

- if File.dir? dest then

- @fileops.chmod entry.header.mode, dest, :verbose=>false

-require 'rubygems/package'

-

-require 'rubygems/package'

-require 'rubygems/package'

-require 'rubygems/package'

- attr_reader :limit, :written

- def add_file(name, mode)

- def add_file_simple(name, mode, size)

- raise Gem::Package::TooLongFileName

-require 'rubygems'

-

- when /^i686-darwin(\d)/ then ['x86', 'darwin', $1]

- when /^i\d86-linux/ then ['x86', 'linux', nil]

- when 'java', 'jruby' then [nil, 'java', nil]

- when /mswin32(\_(\d+))?/ then ['x86', 'mswin32', $2]

- when 'powerpc-darwin' then ['powerpc', 'darwin', nil]

- when /powerpc-darwin(\d)/ then ['powerpc', 'darwin', $1]

- when /sparc-solaris2.8/ then ['sparc', 'solaris', '2.8']

- when /universal-darwin(\d)/ then ['universal', 'darwin', $1]

- def initialize(proxy)

- source_uri = URI.parse source_uri unless URI::Generic === source_uri

- gem = Gem::RemoteFetcher.fetcher.fetch_path remote_gem_path

- gem = Gem::RemoteFetcher.fetcher.fetch_path remote_gem_path

- when nil, 'file' then # TODO test for local overriding cache

- FileUtils.cp source_uri.to_s, local_gem_path

- uri = URI.parse env_proxy

- return open(get_file_uri_path(uri)) if file_uri? uri

-

- raise ArgumentError, 'uri is not an HTTP URI' unless URI::HTTP === uri

- ##

- # Checks if the provided string is a file:// URI.

-

- def file_uri?(uri)

- uri =~ %r{\Afile://}

- end

-

- ##

- # Given a file:// URI, returns its local path.

-

- def get_file_uri_path(uri)

- uri.sub(%r{\Afile://}, '')

- end

-

-module Gem

- module RequirePathsBuilder

- def write_require_paths_file_if_needed(spec = @spec, gem_home = @gem_home)

- return if spec.require_paths == ["lib"] && (spec.bindir.nil? || spec.bindir == "bin")

- file_name = File.join(gem_home, 'gems', "#{@spec.full_name}", ".require_paths")

- file_name.untaint

- File.open(file_name, "w") do |file|

- spec.require_paths.each do |path|

- file.puts path

- end

- file.puts spec.bindir if spec.bindir

-end \ No newline at end of file

-require 'rubygems/version'

-

- "~>" => lambda { |v, r| v >= r && v < r.bump }

- OP_RE = /#{OPS.keys.map{ |k| Regexp.quote k }.join '|'}/o

- # Gem::Version, or an Array of those. See parse for details on the

- @requirements.collect { |req|

- "#{req[0]} #{req[1]}"

- }

- # operator (<, <=, =, =>, >, !=, ~>), a version number, or both, operator

- when /^\s*(#{OP_RE})\s*([0-9.]+)\s*$/o then

- when /^\s*([0-9.]+)\s*$/ then

- RubyGemsVersion = '1.3.1'

-#

-#

-#

- DOC_TEMPLATE = <<-'WEBPAGE'

- WEBPAGE

- RDOC_CSS = <<-RDOCCSS

- RDOCCSS

-require 'rubygems'

- autoload(:SpecFetcher, 'rubygems/spec_fetcher')

- attr_reader :gems # :nodoc:

- begin

- spec_code = if RUBY_VERSION < '1.9' then

- File.read file_name

- else

- File.read file_name, :encoding => 'UTF-8'

- end.untaint

- # Constructs a source index instance from the provided

- # specifications

- #

- # specifications::

- # [Hash] hash of [Gem name, Gem::Specification] pairs

- @gems = specifications

- def add_spec(gem_spec)

- @gems[gem_spec.full_name] = gem_spec

- @gems.delete(full_name)

- require 'rubygems/digest/sha2'

- Gem::SHA256.new.hexdigest(@gems.keys.sort.join(',')).to_s

- require 'rubygems/digest/sha2'

- Gem::SHA256.new.hexdigest(@gems[gem_full_name].to_yaml).to_s

- dep = Gem::Dependency.new(/^#{gem_name}$/, version_requirement)

- warn "#{Gem.location_of_caller.join ':'}:Warning: Gem::SourceIndex#search support for #{gem_pattern.class} patterns is deprecated"

- specs = @gems.values.select do |spec|

- self.class === other and @gems == other.gems

- # :stopdoc:

-

- Cache = SourceIndex

- # :startdoc:

- pattern = Gem::Dependency.new(pattern, Gem::Requirement.default)

- pattern = Gem::Dependency.new(pattern, Gem::Requirement.default)

- # The size of the of the source entry. Used to determine if the

- # source index has changed.

-require 'rubygems'

- # returned.

- def fetch(dependency, all = false, matching_platform = true)

- specs_and_sources = find_matching dependency, all, matching_platform

- def find_matching(dependency, all = false, matching_platform = true)

- list(all).each do |source_uri, specs|

- # +all+ is true, all versions are returned instead of only latest versions.

- def list(all = false)

- file = all ? 'specs' : 'latest_specs'

- if all and @specs.include? source_uri then

- list[source_uri] = @specs[source_uri]

- elsif not all and @latest_specs.include? source_uri then

- list[source_uri] = @latest_specs[source_uri]

- else

- specs = load_specs source_uri, file

-

- cache = all ? @specs : @latest_specs

-

- cache[source_uri] = specs

- list[source_uri] = specs

- specs = Marshal.load spec_dump

-require 'rubygems'

-# Time::today has been deprecated in 0.9.5 and will be removed.

-if RUBY_VERSION < '1.9' then

- def Time.today

- t = Time.now

- t - ((t.to_f + t.gmt_offset) % 86400)

- end unless defined? Time.today

-end

-

-

-module Gem

- # == Gem::Specification

- #

- # The Specification class contains the metadata for a Gem. Typically

- # defined in a .gemspec file or a Rakefile, and looks like this:

- # spec = Gem::Specification.new do |s|

- # s.name = 'rfoo'

- # s.version = '1.0'

- # s.summary = 'Example gem specification'

- # ...

- # end

- # There are many <em>gemspec attributes</em>, and the best place to learn

- # about them in the "Gemspec Reference" linked from the RubyGems wiki.

-

- class Specification

-

- ##

- # Allows deinstallation of gems with legacy platforms.

-

- attr_accessor :original_platform # :nodoc:

-

- ##

- # The the version number of a specification that does not specify one

- # (i.e. RubyGems 0.7 or earlier).

-

- NONEXISTENT_SPECIFICATION_VERSION = -1

-

- ##

- # The specification version applied to any new Specification instances

- # created. This should be bumped whenever something in the spec format

- # changes.

- #--

- # When updating this number, be sure to also update #to_ruby.

- #

- # NOTE RubyGems < 1.2 cannot load specification versions > 2.

-

- CURRENT_SPECIFICATION_VERSION = 2

-

- ##

- # An informal list of changes to the specification. The highest-valued

- # key should be equal to the CURRENT_SPECIFICATION_VERSION.

-

- SPECIFICATION_VERSION_HISTORY = {

- -1 => ['(RubyGems versions up to and including 0.7 did not have versioned specifications)'],

- 1 => [

- 'Deprecated "test_suite_file" in favor of the new, but equivalent, "test_files"',

- '"test_file=x" is a shortcut for "test_files=[x]"'

- ],

- 2 => [

- 'Added "required_rubygems_version"',

- 'Now forward-compatible with future versions',

- ],

- }

- # :stopdoc:

- MARSHAL_FIELDS = { -1 => 16, 1 => 16, 2 => 16 }

- now = Time.at(Time.now.to_i)

- TODAY = now - ((now.to_i + now.gmt_offset) % 86400)

- # :startdoc:

- ##

- # List of Specification instances.

- @@list = []

- ##

- # Optional block used to gather newly defined instances.

- @@gather = nil

- ##

- # List of attribute names: [:name, :version, ...]

- @@required_attributes = []

- ##

- # List of _all_ attributes and default values:

- #

- # [[:name, nil],

- # [:bindir, 'bin'],

- # ...]

- @@attributes = []

- @@nil_attributes = []

- @@non_nil_attributes = [:@original_platform]

- ##

- # List of array attributes

- @@array_attributes = []

- ##

- # Map of attribute names to default values.

- @@default_value = {}

- ##

- # Names of all specification attributes

- def self.attribute_names

- @@attributes.map { |name, default| name }

- end

- ##

- # Default values for specification attributes

- def self.attribute_defaults

- @@attributes.dup

- end

- ##

- # The default value for specification attribute +name+

- def self.default_value(name)

- @@default_value[name]

- ##

- # Required specification attributes

- def self.required_attributes

- @@required_attributes.dup

- end

- ##

- # Is +name+ a required attribute?

- def self.required_attribute?(name)

- @@required_attributes.include? name.to_sym

- end

- ##

- # Specification attributes that are arrays (appendable and so-forth)

- def self.array_attributes

- @@array_attributes.dup

- ##

- # A list of Specification instances that have been defined in this Ruby

- # instance.

- def self.list

- @@list

- ##

- # Specifies the +name+ and +default+ for a specification attribute, and

- # creates a reader and writer method like Module#attr_accessor.

- #

- # The reader method returns the default if the value hasn't been set.

- def self.attribute(name, default=nil)

- ivar_name = "@#{name}".intern

- if default.nil? then

- @@nil_attributes << ivar_name

- else

- @@non_nil_attributes << [ivar_name, default]

- end

- @@attributes << [name, default]

- @@default_value[name] = default

- attr_accessor(name)

- end

- ##

- # Same as :attribute, but ensures that values assigned to the attribute

- # are array values by applying :to_a to the value.

- def self.array_attribute(name)

- @@non_nil_attributes << ["@#{name}".intern, []]

- @@array_attributes << name

- @@attributes << [name, []]

- @@default_value[name] = []

- code = %{

- def #{name}

- @#{name} ||= []

- end

- def #{name}=(value)

- @#{name} = Array(value)

- end

- }

- module_eval code, __FILE__, __LINE__ - 9

- end

- ##

- # Same as attribute above, but also records this attribute as mandatory.

- def self.required_attribute(*args)

- @@required_attributes << args.first

- attribute(*args)

- end

- ##

- # Sometimes we don't want the world to use a setter method for a

- # particular attribute.

- #

- # +read_only+ makes it private so we can still use it internally.

- def self.read_only(*names)

- names.each do |name|

- private "#{name}="

- end

- # Shortcut for creating several attributes at once (each with a default

- # value of +nil+).

- def self.attributes(*args)

- args.each do |arg|

- attribute(arg, nil)

- ##

- # Some attributes require special behaviour when they are accessed. This

- # allows for that.

- def self.overwrite_accessor(name, &block)

- remove_method name

- define_method(name, &block)

- end

- ##

- # Defines a _singular_ version of an existing _plural_ attribute (i.e. one

- # whose value is expected to be an array). This means just creating a

- # helper method that takes a single value and appends it to the array.

- # These are created for convenience, so that in a spec, one can write

- #

- # s.require_path = 'mylib'

- #

- # instead of:

- #

- # s.require_paths = ['mylib']

- #

- # That above convenience is available courtesy of:

- #

- # attribute_alias_singular :require_path, :require_paths

-

- def self.attribute_alias_singular(singular, plural)

- define_method("#{singular}=") { |val|

- send("#{plural}=", [val])

- }

- define_method("#{singular}") {

- val = send("#{plural}")

- val.nil? ? nil : val.first

- }

- end

- ##

- # Dump only crucial instance variables.

- #--

- # MAINTAIN ORDER!

-

- def _dump(limit)

- Marshal.dump [

- @rubygems_version,

- @specification_version,

- @name,

- @version,

- (Time === @date ? @date : (require 'time'; Time.parse(@date.to_s))),

- @summary,

- @required_ruby_version,

- @required_rubygems_version,

- @original_platform,

- @dependencies,

- @rubyforge_project,

- @email,

- @authors,

- @description,

- @homepage,

- @has_rdoc,

- @new_platform,

- ]

- end

- ##

- # Load custom marshal format, re-initializing defaults as needed

- def self._load(str)

- array = Marshal.load str

- spec = Gem::Specification.new

- spec.instance_variable_set :@specification_version, array[1]

- current_version = CURRENT_SPECIFICATION_VERSION

- field_count = if spec.specification_version > current_version then

- spec.instance_variable_set :@specification_version,

- current_version

- MARSHAL_FIELDS[current_version]

- else

- MARSHAL_FIELDS[spec.specification_version]

- end

- if array.size < field_count then

- raise TypeError, "invalid Gem::Specification format #{array.inspect}"

- end

- spec.instance_variable_set :@rubygems_version, array[0]

- # spec version

- spec.instance_variable_set :@name, array[2]

- spec.instance_variable_set :@version, array[3]

- spec.instance_variable_set :@date, array[4]

- spec.instance_variable_set :@summary, array[5]

- spec.instance_variable_set :@required_ruby_version, array[6]

- spec.instance_variable_set :@required_rubygems_version, array[7]

- spec.instance_variable_set :@original_platform, array[8]

- spec.instance_variable_set :@dependencies, array[9]

- spec.instance_variable_set :@rubyforge_project, array[10]

- spec.instance_variable_set :@email, array[11]

- spec.instance_variable_set :@authors, array[12]

- spec.instance_variable_set :@description, array[13]

- spec.instance_variable_set :@homepage, array[14]

- spec.instance_variable_set :@has_rdoc, array[15]

- spec.instance_variable_set :@new_platform, array[16]

- spec.instance_variable_set :@platform, array[16].to_s

- spec.instance_variable_set :@loaded, false

-

- spec

- ##

- # List of depedencies that will automatically be activated at runtime.

- def runtime_dependencies

- dependencies.select { |d| d.type == :runtime || d.type == nil }

- ##

- # List of dependencies that are used for development

- def development_dependencies

- dependencies.select { |d| d.type == :development }

- def test_suite_file # :nodoc:

- warn 'test_suite_file deprecated, use test_files'

- test_files.first

- def test_suite_file=(val) # :nodoc:

- warn 'test_suite_file= deprecated, use test_files='

- @test_files = [] unless defined? @test_files

- @test_files << val

- ##

- # true when this gemspec has been loaded from a specifications directory.

- # This attribute is not persisted.

- attr_accessor :loaded

- ##

- # Path this gemspec was loaded from. This attribute is not persisted.

- attr_accessor :loaded_from

- ##

- # Returns an array with bindir attached to each executable in the

- # executables list

- def add_bindir(executables)

- return nil if executables.nil?

- if @bindir then

- Array(executables).map { |e| File.join(@bindir, e) }

- else

- executables

- end

- rescue

- return nil

- end

- ##

- # Files in the Gem under one of the require_paths

- def lib_files

- @files.select do |file|

- require_paths.any? do |path|

- file.index(path) == 0

- end

- end

- ##

- # True if this gem was loaded from disk

- alias :loaded? :loaded

- ##

- # True if this gem has files in test_files

- def has_unit_tests?

- not test_files.empty?

- end

- alias has_test_suite? has_unit_tests? # :nodoc: deprecated

- ##

- # Specification constructor. Assigns the default values to the

- # attributes, adds this spec to the list of loaded specs (see

- # Specification.list), and yields itself for further initialization.

- def initialize

- @new_platform = nil

- assign_defaults

- @loaded = false

- @loaded_from = nil

- @@list << self

- yield self if block_given?

- @@gather.call(self) if @@gather

- ##

- # Each attribute has a default value (possibly nil). Here, we initialize

- # all attributes to their default value. This is done through the

- # accessor methods, so special behaviours will be honored. Furthermore,

- # we take a _copy_ of the default so each specification instance has its

- # own empty arrays, etc.

- def assign_defaults

- @@nil_attributes.each do |name|

- instance_variable_set name, nil

- end

- @@non_nil_attributes.each do |name, default|

- value = case default

- when Time, Numeric, Symbol, true, false, nil then default

- else default.dup

- end

- instance_variable_set name, value

- end

- # HACK

- instance_variable_set :@new_platform, Gem::Platform::RUBY

- ##

- # Special loader for YAML files. When a Specification object is loaded

- # from a YAML file, it bypasses the normal Ruby object initialization

- # routine (#initialize). This method makes up for that and deals with

- # gems of different ages.

- #

- # 'input' can be anything that YAML.load() accepts: String or IO.

- def self.from_yaml(input)

- input = normalize_yaml_input input

- spec = YAML.load input

- if spec && spec.class == FalseClass then

- raise Gem::EndOfYAMLException

- end

- unless Gem::Specification === spec then

- raise Gem::Exception, "YAML data doesn't evaluate to gem specification"

- end

- unless (spec.instance_variables.include? '@specification_version' or

- spec.instance_variables.include? :@specification_version) and

- spec.instance_variable_get :@specification_version

- spec.instance_variable_set :@specification_version,

- NONEXISTENT_SPECIFICATION_VERSION

- end

- spec

- end

- ##

- # Loads ruby format gemspec from +filename+

-

- def self.load(filename)

- gemspec = nil

- fail "NESTED Specification.load calls not allowed!" if @@gather

- @@gather = proc { |gs| gemspec = gs }

- data = File.read(filename)

- eval(data)

- gemspec

- ensure

- @@gather = nil

- end

- ##

- # Make sure the YAML specification is properly formatted with dashes

- def self.normalize_yaml_input(input)

- result = input.respond_to?(:read) ? input.read : input

- result = "--- " + result unless result =~ /^--- /

- result

- end

- ##

- # Sets the rubygems_version to the current RubyGems version

- def mark_version

- @rubygems_version = RubyGemsVersion

- ##

- # Ignore unknown attributes while loading

- def method_missing(sym, *a, &b) # :nodoc:

- if @specification_version > CURRENT_SPECIFICATION_VERSION and

- sym.to_s =~ /=$/ then

- warn "ignoring #{sym} loading #{full_name}" if $DEBUG

- else

- super

- ##

- # Adds a development dependency named +gem+ with +requirements+ to this

- # Gem. For example:

- #

- # spec.add_development_dependency 'jabber4r', '> 0.1', '<= 0.5'

- #

- # Development dependencies aren't installed by default and aren't

- # activated when a gem is required.

-

- def add_development_dependency(gem, *requirements)

- add_dependency_with_type(gem, :development, *requirements)

- ##

- # Adds a runtime dependency named +gem+ with +requirements+ to this Gem.

- # For example:

- #

- # spec.add_runtime_dependency 'jabber4r', '> 0.1', '<= 0.5'

- def add_runtime_dependency(gem, *requirements)

- add_dependency_with_type(gem, :runtime, *requirements)

- ##

- # Adds a runtime dependency

-

- alias add_dependency add_runtime_dependency

- ##

- # Returns the full name (name-version) of this Gem. Platform information

- # is included (name-version-platform) if it is specified and not the

- # default Ruby platform.

- def full_name

- if platform == Gem::Platform::RUBY or platform.nil? then

- "#{@name}-#{@version}"

- else

- "#{@name}-#{@version}-#{platform}"

- ##

- # Returns the full name (name-version) of this gemspec using the original

- # platform. For use with legacy gems.

- def original_name # :nodoc:

- if platform == Gem::Platform::RUBY or platform.nil? then

- "#{@name}-#{@version}"

- else

- "#{@name}-#{@version}-#{@original_platform}"

- ##

- # The full path to the gem (install path + full name).

- def full_gem_path

- path = File.join installation_path, 'gems', full_name

- return path if File.directory? path

- File.join installation_path, 'gems', original_name

- end

- ##

- # The default (generated) file name of the gem.

- def file_name

- full_name + ".gem"

- end

- ##

- # The directory that this gem was installed into.

- def installation_path

- path = File.dirname(@loaded_from).split(File::SEPARATOR)[0..-2]

- path = path.join File::SEPARATOR

- File.expand_path path

- ##

- # Checks if this specification meets the requirement of +dependency+.

- def satisfies_requirement?(dependency)

- return @name == dependency.name &&

- dependency.version_requirements.satisfied_by?(@version)

- ##

- # Returns an object you can use to sort specifications in #sort_by.

- def sort_obj

- [@name, @version.to_ints, @new_platform == Gem::Platform::RUBY ? -1 : 1]

- def <=>(other) # :nodoc:

- sort_obj <=> other.sort_obj

- ##

- # Tests specs for equality (across all attributes).

- def ==(other) # :nodoc:

- self.class === other && same_attributes?(other)

- alias eql? == # :nodoc:

- ##

- # True if this gem has the same attributes as +other+.

- def same_attributes?(other)

- @@attributes.each do |name, default|

- return false unless self.send(name) == other.send(name)

- true

- end

- private :same_attributes?

- def hash # :nodoc:

- @@attributes.inject(0) { |hash_code, (name, default_value)|

- n = self.send(name).hash

- hash_code + n

- }

- def to_yaml(opts = {}) # :nodoc:

- mark_version

-

- attributes = @@attributes.map { |name,| name.to_s }.sort

- attributes = attributes - %w[name version platform]

-

- yaml = YAML.quick_emit object_id, opts do |out|

- out.map taguri, to_yaml_style do |map|

- map.add 'name', @name

- map.add 'version', @version

- platform = case @original_platform

- when nil, '' then

- 'ruby'

- when String then

- @original_platform

- else

- @original_platform.to_s

- end

- map.add 'platform', platform

-

- attributes.each do |name|

- map.add name, instance_variable_get("@#{name}")

- end

- end

- end

- def yaml_initialize(tag, vals) # :nodoc:

- vals.each do |ivar, val|

- instance_variable_set "@#{ivar}", val

- end

- @original_platform = @platform # for backwards compatibility

- self.platform = Gem::Platform.new @platform

- ##

- # Returns a Ruby code representation of this specification, such that it

- # can be eval'ed and reconstruct the same specification later. Attributes

- # that still have their default values are omitted.

-

- def to_ruby

- mark_version

- result = []

- result << "# -*- encoding: utf-8 -*-"

- result << nil

- result << "Gem::Specification.new do |s|"

-

- result << " s.name = #{ruby_code name}"

- result << " s.version = #{ruby_code version}"

- unless platform.nil? or platform == Gem::Platform::RUBY then

- result << " s.platform = #{ruby_code original_platform}"

- end

- result << ""

- result << " s.required_rubygems_version = #{ruby_code required_rubygems_version} if s.respond_to? :required_rubygems_version="

-

- handled = [

- :dependencies,

- :name,

- :platform,

- :required_rubygems_version,

- :specification_version,

- :version,

- ]

- attributes = @@attributes.sort_by { |attr_name,| attr_name.to_s }

- attributes.each do |attr_name, default|

- next if handled.include? attr_name

- current_value = self.send(attr_name)

- if current_value != default or

- self.class.required_attribute? attr_name then

- result << " s.#{attr_name} = #{ruby_code current_value}"

- end

- end

- result << nil

- result << " if s.respond_to? :specification_version then"

- result << " current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION"

- result << " s.specification_version = #{specification_version}"

- result << nil

- result << " if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then"

- unless dependencies.empty? then

- dependencies.each do |dep|

- version_reqs_param = dep.requirements_list.inspect

- dep.instance_variable_set :@type, :runtime if dep.type.nil? # HACK

- result << " s.add_#{dep.type}_dependency(%q<#{dep.name}>, #{version_reqs_param})"

- end

- end

- result << " else"

- unless dependencies.empty? then

- dependencies.each do |dep|

- version_reqs_param = dep.requirements_list.inspect

- result << " s.add_dependency(%q<#{dep.name}>, #{version_reqs_param})"

- end

- end

- result << ' end'

- result << " else"

- dependencies.each do |dep|

- version_reqs_param = dep.requirements_list.inspect

- result << " s.add_dependency(%q<#{dep.name}>, #{version_reqs_param})"

- result << " end"

- result << "end"

- result << nil

- result.join "\n"

- end

- ##

- # Checks that the specification contains all required fields, and does a

- # very basic sanity check.

- #

- # Raises InvalidSpecificationException if the spec does not pass the

- # checks..

- def validate

- extend Gem::UserInteraction

- normalize

- if rubygems_version != RubyGemsVersion then

- raise Gem::InvalidSpecificationException,

- "expected RubyGems version #{RubyGemsVersion}, was #{rubygems_version}"

- end

- @@required_attributes.each do |symbol|

- unless self.send symbol then

- raise Gem::InvalidSpecificationException,

- "missing value for attribute #{symbol}"

- end

- end

- if require_paths.empty? then

- raise Gem::InvalidSpecificationException,

- "specification must have at least one require_path"

- end

- case platform

- when Gem::Platform, Platform::RUBY then # ok

- else

- raise Gem::InvalidSpecificationException,

- "invalid platform #{platform.inspect}, see Gem::Platform"

- unless Array === authors and

- authors.all? { |author| String === author } then

- raise Gem::InvalidSpecificationException,

- 'authors must be Array of Strings'

- end

- # Warnings

- %w[author email homepage rubyforge_project summary].each do |attribute|

- value = self.send attribute

- alert_warning "no #{attribute} specified" if value.nil? or value.empty?

- end

- alert_warning "RDoc will not be generated (has_rdoc == false)" unless

- has_rdoc

- alert_warning "deprecated autorequire specified" if autorequire

- executables.each do |executable|

- executable_path = File.join bindir, executable

- shebang = File.read(executable_path, 2) == '#!'

- alert_warning "#{executable_path} is missing #! line" unless shebang

- end

- true

- ##

- # Normalize the list of files so that:

- # * All file lists have redundancies removed.

- # * Files referenced in the extra_rdoc_files are included in the package

- # file list.

- #

- # Also, the summary and description are converted to a normal format.

-

- def normalize

- if defined?(@extra_rdoc_files) and @extra_rdoc_files then

- @extra_rdoc_files.uniq!

- @files ||= []

- @files.concat(@extra_rdoc_files)

- end

- @files.uniq! if @files

- end

- ##

- # Return a list of all gems that have a dependency on this gemspec. The

- # list is structured with entries that conform to:

- #

- # [depending_gem, dependency, [list_of_gems_that_satisfy_dependency]]

-

- def dependent_gems

- out = []

- Gem.source_index.each do |name,gem|

- gem.dependencies.each do |dep|

- if self.satisfies_requirement?(dep) then

- sats = []

- find_all_satisfiers(dep) do |sat|

- sats << sat

- end

- out << [gem, dep, sats]

- end

- end

- end

- out

- def to_s

- "#<Gem::Specification name=#{@name} version=#{@version}>"

- end

- def add_dependency_with_type(dependency, type, *requirements)

- requirements = if requirements.empty? then

- Gem::Requirement.default

- else

- requirements.flatten

- end

- unless dependency.respond_to?(:name) &&

- dependency.respond_to?(:version_requirements)

- dependency = Dependency.new(dependency, requirements, type)

- end

- dependencies << dependency

- end

- private :add_dependency_with_type

- def find_all_satisfiers(dep)

- Gem.source_index.each do |name,gem|

- if(gem.satisfies_requirement?(dep)) then

- yield gem

- end

- end

- end

- private :find_all_satisfiers

-

- ##

- # Return a string containing a Ruby code representation of the given

- # object.

-

- def ruby_code(obj)

- case obj

- when String then '%q{' + obj + '}'

- when Array then obj.inspect

- when Gem::Version then obj.to_s.inspect

- when Date then '%q{' + obj.strftime('%Y-%m-%d') + '}'

- when Time then '%q{' + obj.strftime('%Y-%m-%d') + '}'

- when Numeric then obj.inspect

- when true, false, nil then obj.inspect

- when Gem::Platform then "Gem::Platform.new(#{obj.to_a.inspect})"

- when Gem::Requirement then "Gem::Requirement.new(#{obj.to_s.inspect})"

- else raise Exception, "ruby_code case not handled: #{obj.class}"

- end

- end

- private :ruby_code

- # :section: Required gemspec attributes

- ##

- # The version of RubyGems used to create this gem

- required_attribute :rubygems_version, Gem::RubyGemsVersion

- ##

- # The Gem::Specification version of this gemspec

- required_attribute :specification_version, CURRENT_SPECIFICATION_VERSION

- ##

- # This gem's name

- required_attribute :name

- ##

- # This gem's version

- required_attribute :version

- ##

- # The date this gem was created

- required_attribute :date, TODAY

- ##

- # A short summary of this gem's description. Displayed in `gem list -d`.

- required_attribute :summary

- ##

- # Paths in the gem to add to $LOAD_PATH when this gem is activated

- required_attribute :require_paths, ['lib']

- # :section: Optional gemspec attributes

- ##

- # A contact email for this gem

- attribute :email

- ##

- # The URL of this gem's home page

- attribute :homepage

- ##

- # The rubyforge project this gem lives under. i.e. RubyGems'

- # rubyforge_project is "rubygems".

- attribute :rubyforge_project

- ##

- # A long description of this gem

- attribute :description

- ##

- # Autorequire was used by old RubyGems to automatically require a file.

- # It no longer is supported.

- attribute :autorequire

- ##

- # The default executable for this gem.

- attribute :default_executable

- ##

- # The path in the gem for executable scripts

- attribute :bindir, 'bin'

- ##

- # True if this gem is RDoc-compliant

- attribute :has_rdoc, false

- ##

- # True if this gem supports RDoc

- alias :has_rdoc? :has_rdoc

- ##

- # The ruby of version required by this gem

- attribute :required_ruby_version, Gem::Requirement.default

- ##

- # The RubyGems version required by this gem

- attribute :required_rubygems_version, Gem::Requirement.default

- ##

- # The platform this gem runs on. See Gem::Platform for details.

- attribute :platform, Gem::Platform::RUBY

- ##

- # The key used to sign this gem. See Gem::Security for details.

- attribute :signing_key, nil

- ##

- # The certificate chain used to sign this gem. See Gem::Security for

- # details.

- attribute :cert_chain, []

- ##

- # A message that gets displayed after the gem is installed

- attribute :post_install_message, nil

- ##

- # The list of authors who wrote this gem

- array_attribute :authors

- ##

- # Files included in this gem

- array_attribute :files

- ##

- # Test files included in this gem

- array_attribute :test_files

- ##

- # An ARGV-style array of options to RDoc

- array_attribute :rdoc_options

- ##

- # Extra files to add to RDoc

- array_attribute :extra_rdoc_files

- ##

- # Executables included in the gem

- array_attribute :executables

- ##

- # Extensions to build when installing the gem. See

- # Gem::Installer#build_extensions for valid values.

- array_attribute :extensions

- ##

- # An array or things required by this gem. Not used by anything

- # presently.

- array_attribute :requirements

- ##

- # A list of Gem::Dependency objects this gem depends on. Only appendable.

- array_attribute :dependencies

- read_only :dependencies

- # :section: Aliased gemspec attributes

- ##

- # Singular accessor for executables

- attribute_alias_singular :executable, :executables

- ##

- # Singular accessor for authors

- attribute_alias_singular :author, :authors

- ##

- # Singular accessor for require_paths

- attribute_alias_singular :require_path, :require_paths

- ##

- # Singular accessor for test_files

- attribute_alias_singular :test_file, :test_files

- overwrite_accessor :version= do |version|

- @version = Version.create(version)

- end

- overwrite_accessor :platform do

- @new_platform

- overwrite_accessor :platform= do |platform|

- if @original_platform.nil? or

- @original_platform == Gem::Platform::RUBY then

- @original_platform = platform

- end

-

- case platform

- when Gem::Platform::CURRENT then

- @new_platform = Gem::Platform.local

- @original_platform = @new_platform.to_s

-

- when Gem::Platform then

- @new_platform = platform

-

- # legacy constants

- when nil, Gem::Platform::RUBY then

- @new_platform = Gem::Platform::RUBY

- when 'mswin32' then # was Gem::Platform::WIN32

- @new_platform = Gem::Platform.new 'x86-mswin32'

- when 'mswin64' then

- @new_platform = Gem::Platform.new 'x86-mswin64'

- when 'i586-linux' then # was Gem::Platform::LINUX_586

- @new_platform = Gem::Platform.new 'x86-linux'

- when 'powerpc-darwin' then # was Gem::Platform::DARWIN

- @new_platform = Gem::Platform.new 'ppc-darwin'

- else

- @new_platform = Gem::Platform.new platform

- end

- @platform = @new_platform.to_s

- @new_platform

- overwrite_accessor :required_ruby_version= do |value|

- @required_ruby_version = Gem::Requirement.create(value)

- end

- overwrite_accessor :required_rubygems_version= do |value|

- @required_rubygems_version = Gem::Requirement.create(value)

- end

- overwrite_accessor :date= do |date|

- # We want to end up with a Time object with one-day resolution.

- # This is the cleanest, most-readable, faster-than-using-Date

- # way to do it.

- case date

- when String then

- @date = if /\A(\d{4})-(\d{2})-(\d{2})\Z/ =~ date then

- Time.local($1.to_i, $2.to_i, $3.to_i)

- else

- require 'time'

- Time.parse date

- end

- when Time then

- @date = Time.local(date.year, date.month, date.day)

- when Date then

- @date = Time.local(date.year, date.month, date.day)

- else

- @date = TODAY

- end

- end

- overwrite_accessor :date do

- self.date = nil if @date.nil? # HACK Sets the default value for date

- @date

- end

- overwrite_accessor :summary= do |str|

- @summary = if str then

- str.strip.

- gsub(/(\w-)\n[ \t]*(\w)/, '\1\2').

- gsub(/\n[ \t]*/, " ")

- end

- overwrite_accessor :description= do |str|

- @description = if str then

- str.strip.

- gsub(/(\w-)\n[ \t]*(\w)/, '\1\2').

- gsub(/\n[ \t]*/, " ")

- end

- end

- overwrite_accessor :default_executable do

- begin

- if defined?(@default_executable) and @default_executable

- result = @default_executable

- elsif @executables and @executables.size == 1

- result = Array(@executables).first

- else

- result = nil

- end

- result

- rescue

- nil

- end

- end

- overwrite_accessor :test_files do

- # Handle the possibility that we have @test_suite_file but not

- # @test_files. This will happen when an old gem is loaded via

- # YAML.

- if defined? @test_suite_file then

- @test_files = [@test_suite_file].flatten

- @test_suite_file = nil

- end

- if defined?(@test_files) and @test_files then

- @test_files

- @test_files = []

- overwrite_accessor :files do

- result = []

- result.push(*@files) if defined?(@files)

- result.push(*@test_files) if defined?(@test_files)

- result.push(*(add_bindir(@executables)))

- result.push(*@extra_rdoc_files) if defined?(@extra_rdoc_files)

- result.push(*@extensions) if defined?(@extensions)

- result.uniq.compact

-#

-#

-# This file defines a $log variable for logging, and a time() method for recording timing

-# information.

-def $log.debug(str)

- STDERR.puts str

-def time(msg, width=25)

- t = Time.now

- return_value = yield

- elapsed = Time.now.to_f - t.to_f

- elapsed = sprintf("%3.3f", elapsed)

- $log.debug "#{msg.ljust(width)}: #{elapsed}s"

- return_value

- raise Gem::InstallError, "Unknown gem #{@gem} #{@version}"

- specs.each { |s| remove_executables s }

- remove spec, specs

- def remove_executables(gemspec)

- return if gemspec.nil?

- if gemspec.executables.size > 0 then

- bindir = @bin_dir ? @bin_dir : (Gem.bindir @gem_home)

- list = @source_index.find_name(gemspec.name).delete_if { |spec|

- spec.version == gemspec.version

- executables = gemspec.executables.clone

- list.each do |spec|

- spec.executables.each do |exe_name|

- executables.delete(exe_name)

- return if executables.size == 0

- "\t#{gemspec.executables.join(", ")}\n\nin addition to the gem?",

- gemspec.executables.each do |exe_name|

- unless path_ok? spec then

- def path_ok?(spec)

- full_path = File.join @gem_home, 'gems', spec.full_name

- original_path = File.join @gem_home, 'gems', spec.original_name

-module Gem

- ##

- # Module that defines the default UserInteraction. Any class including this

- # module will have access to the +ui+ method that returns the default UI.

- module DefaultUserInteraction

- ##

- # The default UI is a class variable of the singleton class for this

- # module.

- @ui = nil

- ##

- # Return the default UI.

- def self.ui

- @ui ||= Gem::ConsoleUI.new

- end

- ##

- # Set the default UI. If the default UI is never explicitly set, a simple

- # console based UserInteraction will be used automatically.

- def self.ui=(new_ui)

- @ui = new_ui

- end

- ##

- # Use +new_ui+ for the duration of +block+.

-

- def self.use_ui(new_ui)

- old_ui = @ui

- @ui = new_ui

- yield

- ensure

- @ui = old_ui

- end

- ##

- # See DefaultUserInteraction::ui

- def ui

- DefaultUserInteraction.ui

- end

- ##

- # See DefaultUserInteraction::ui=

- def ui=(new_ui)

- DefaultUserInteraction.ui = new_ui

- end

- ##

- # See DefaultUserInteraction::use_ui

- def use_ui(new_ui, &block)

- DefaultUserInteraction.use_ui(new_ui, &block)

- end

- end

- # Make the default UI accessable without the "ui." prefix. Classes

- # including this module may use the interaction methods on the default UI

- # directly. Classes may also reference the ui and ui= methods.

- #

- # Example:

- #

- # class X

- # include Gem::UserInteraction

- #

- # def get_answer

- # n = ask("What is the meaning of life?")

- # end

- # end

-

- module UserInteraction

-

- include DefaultUserInteraction

-

- [:alert,

- :alert_error,

- :alert_warning,

- :ask,

- :ask_yes_no,

- :choose_from_list,

- :say,

- :terminate_interaction ].each do |methname|

- class_eval %{

- def #{methname}(*args)

- ui.#{methname}(*args)

- end

- }, __FILE__, __LINE__

- end

- end

- # StreamUI implements a simple stream based user interface.

- class StreamUI

- attr_reader :ins, :outs, :errs

- def initialize(in_stream, out_stream, err_stream=STDERR)

- @ins = in_stream

- @outs = out_stream

- @errs = err_stream

- end

- ##

- # Choose from a list of options. +question+ is a prompt displayed above

- # the list. +list+ is a list of option strings. Returns the pair

- # [option_name, option_index].

- def choose_from_list(question, list)

- @outs.puts question

- list.each_with_index do |item, index|

- @outs.puts " #{index+1}. #{item}"

- @outs.print "> "

- @outs.flush

- result = @ins.gets

- return nil, nil unless result

- result = result.strip.to_i - 1

- return list[result], result

- ##

- # Ask a question. Returns a true for yes, false for no. If not connected

- # to a tty, raises an exception if default is nil, otherwise returns

- # default.

-

- def ask_yes_no(question, default=nil)

- unless @ins.tty? then

- if default.nil? then

- raise Gem::OperationNotSupportedError,

- "Not connected to a tty and no default specified"

- else

- return default

- end

- end

- qstr = case default

- when nil

- 'yn'

- when true

- 'Yn'

- else

- 'yN'

- end

-

- result = nil

-

- while result.nil?

- result = ask("#{question} [#{qstr}]")

- result = case result

- when /^[Yy].*/

- true

- when /^[Nn].*/

- false

- when /^$/

- default

- else

- nil

- end

- return result

- ##

- # Ask a question. Returns an answer if connected to a tty, nil otherwise.

- def ask(question)

- return nil if not @ins.tty?

- @outs.print(question + " ")

- @outs.flush

- result = @ins.gets

- result.chomp! if result

- result

- end

- ##

- # Display a statement.

- def say(statement="")

- @outs.puts statement

- end

- ##

- # Display an informational alert. Will ask +question+ if it is not nil.

- def alert(statement, question=nil)

- @outs.puts "INFO: #{statement}"

- ask(question) if question

- end

- ##

- # Display a warning in a location expected to get error messages. Will

- # ask +question+ if it is not nil.

- def alert_warning(statement, question=nil)

- @errs.puts "WARNING: #{statement}"

- ask(question) if question

- end

- ##

- # Display an error message in a location expected to get error messages.

- # Will ask +question+ if it is not nil.

- def alert_error(statement, question=nil)

- @errs.puts "ERROR: #{statement}"

- ask(question) if question

- end

- ##

- # Terminate the application with exit code +status+, running any exit

- # handlers that might have been defined.

- def terminate_interaction(status = 0)

- raise Gem::SystemExitException, status

- end

- ##

- # Return a progress reporter object chosen from the current verbosity.

-

- def progress_reporter(*args)

- case Gem.configuration.verbose

- when nil, false

- SilentProgressReporter.new(@outs, *args)

- when true

- SimpleProgressReporter.new(@outs, *args)

- else

- VerboseProgressReporter.new(@outs, *args)

- end

- end

- ##

- # An absolutely silent progress reporter.

- class SilentProgressReporter

- attr_reader :count

- def initialize(out_stream, size, initial_message, terminal_message = nil)

- end

- def updated(message)

- end

- def done

- end

- ##

- # A basic dotted progress reporter.

- class SimpleProgressReporter

- include DefaultUserInteraction

- attr_reader :count

- def initialize(out_stream, size, initial_message,

- terminal_message = "complete")

- @out = out_stream

- @total = size

- @count = 0

- @terminal_message = terminal_message

- @out.puts initial_message

- end

- ##

- # Prints out a dot and ignores +message+.

- def updated(message)

- @count += 1

- @out.print "."

- @out.flush

- end

- ##

- # Prints out the terminal message.

- def done

- @out.puts "\n#{@terminal_message}"

- end

- # A progress reporter that prints out messages about the current progress.

- class VerboseProgressReporter

- include DefaultUserInteraction

- attr_reader :count

- def initialize(out_stream, size, initial_message,

- terminal_message = 'complete')

- @out = out_stream

- @total = size

- @count = 0

- @terminal_message = terminal_message

- @out.puts initial_message

- end

- ##

- # Prints out the position relative to the total and the +message+.

- def updated(message)

- @count += 1

- @out.puts "#{@count}/#{@total}: #{message}"

- end

- ##

- # Prints out the terminal message.

- def done

- @out.puts @terminal_message

- end

- end

- ##

- # Subclass of StreamUI that instantiates the user interaction using STDIN,

- # STDOUT, and STDERR.

- class ConsoleUI < StreamUI

- def initialize

- super(STDIN, STDOUT, STDERR)

- end

- ##

- # SilentUI is a UI choice that is absolutely silent.

- class SilentUI

- def method_missing(sym, *args, &block)

- self

-require 'rubygems/digest/md5'

- unless Gem::MD5.hexdigest(sum_data) == $1.to_s then

- rescue Errno::ENOENT

- Find.find(gem_directory) {|file_name|

- fn = file_name.slice((gem_directory.size)..(file_name.size-1)).sub(/^\//, "")

- if(!(fn =~ /CVS/ || File.directory?(fn) || fn == "")) then

- installed_files << fn

- end

-

- }

- def alien

- errors = {}

- errors[gem_name] ||= []

-

- gem_path = File.join(Gem.dir, "cache", gem_spec.full_name) + ".gem"

- spec_path = File.join(Gem.dir, "specifications", gem_spec.full_name) + ".gemspec"

- gem_directory = File.join(Gem.dir, "gems", gem_spec.full_name)

-

- installed_files = find_files_for_gem(gem_directory)

- errors[gem_name] << ErrorData.new(spec_path, "Spec file doesn't exist for installed gem")

- format.file_entries.each do |entry, data|

- # Found this file. Delete it from list

- installed_files.delete remove_leading_dot_dir(entry['path'])

- next unless data # HACK `gem check -a mkrf`

- open File.join(gem_directory, entry['path']), Gem.binary_mode do |f|

- unless Gem::MD5.hexdigest(f.read).to_s ==

- Gem::MD5.hexdigest(data).to_s then

- errors[gem_name] << ErrorData.new(entry['path'], "installed file doesn't match original from gem")

- errors[gem_name] << ErrorData.new(gem_path, e.message)

- # Clean out directories that weren't explicitly included in the gemspec

- # FIXME: This still allows arbitrary incorrect directories.

- installed_files.delete_if {|potential_directory|

- File.directory?(File.join(gem_directory, potential_directory))

- }

- if(installed_files.size > 0) then

- errors[gem_name] << ErrorData.new(gem_path, "Unmanaged files in gem: #{installed_files.inspect}")

- end

- $: << File.join(Gem.dir, "gems", gem_spec.full_name)

- private

-require 'rubygems'

-

-# The Version class processes string versions into comparable values

- attr_reader :ints

- ##

- # Returns true if +version+ is a valid version string.

-

- case version

- when Integer, /\A\s*(\d+(\.-?\d+)*)*\s*\z/ then true

- else false

- end

- # series of digits separated by dots.

- @ints = build_array_from_version_string

-

- return if @ints.length == 1

-

- @ints.pop while @ints.last == 0

-

- @ints = [0] if @ints.empty?

- #

- # return:: [String] version as string

- #

- ##

- # Returns an integer array representation of this Version.

-

- def to_ints

- normalize unless @ints

- @ints

- end

-

- @ints <=> other.ints

- # Return a new version object where the next to the last revision

- # number is one greater. (e.g. 5.3.1 => 5.4)

- ints = build_array_from_version_string

- ints.pop if ints.size > 1

- ints[-1] += 1

- self.class.new(ints.join("."))

- def build_array_from_version_string

- @version.to_s.scan(/\d+/).map { |s| s.to_i }

- private :build_array_from_version_string

-require 'minitest/unit'

- @spec = quick_gem "a"

- util_build_gem @spec

- FileUtils.mv File.join(@gemhome, 'cache', "#{@spec.full_name}.gem"),

- @tempdir

- @installer = Gem::Installer.new @gem

- @installer.gem_dir = util_gem_dir

- @installer.gem_home = @gemhome

- @installer.spec = @spec

- exec_file = @installer.formatted_program_filename "my_exec"

- exec_path = File.join util_gem_bindir(version), exec_file

-class File

-

- # straight from setup.rb

- def self.dir?(path)

- # for corrupted windows stat()

- File.directory?((path[-1,1] == '/') ? path : path + '/')

- end

-

- def self.read_b(name)

- File.open(name, "rb") { |f| f.read }

- end

-

-end

-

- uname 32

- assert_equal expected[offset, length], actual[offset, length],

-require 'rubygems'

-rescue LoadError

- warn "Install minitest gem"

- @ruby = ENV['RUBY']

-

- Gem::ConfigMap[:BASERUBY] = Gem::ConfigMap[:RUBY_INSTALL_NAME]

- cache_dir = File.join(@gemhome, 'cache')

- FileUtils.mkdir_p cache_dir

- File.join(cache_dir, "#{spec.original_name}.gem")

- def util_make_gems

- @a1 = quick_gem('a', '1', &init)

- [@a1, @a2, @a_evil9, @b2, @c1_2, @pl1].each { |spec| util_build_gem spec }

- def util_setup_fake_fetcher

- util_make_gems

- @all_gems = [@a1, @a2, @a_evil9, @b2, @c1_2].sort

- gem_names = [@a1.full_name, @a2.full_name, @b2.full_name]

- si.gems.sort_by { |_,spec| spec }.each do |_, spec|

- puts

- raise TermError

- MD5SUM = "954df67d9475aa2f4fbba20aa33649c8"

-

- opts.on('--dir=DIRNAME', "Installation directory for the Gem") {|x|

- options[:directory] = x

- }

- opts.on('--force', "Force Gem to intall, bypassing dependency checks") {|x|

- options[:force] = x

- }

- opts.on('--gen-rdoc', "Generate RDoc documentation for the Gem") {|x|

- options[:gen_rdoc] = x

- }

- require 'rubygems/installer'

-

- gem = Gem::Installer.new(__FILE__, options).install

- end

---- !ruby/object:Gem::Specification

-version: !ruby/object:Gem::Version

-platform:

-require_paths:

-files:

-requirements:

----

--

--

--

- orig_BASERUBY = Gem::ConfigMap[:BASERUBY]

- orig_RUBY_INSTALL_NAME = Gem::ConfigMap[:RUBY_INSTALL_NAME]

- Gem::ConfigMap[:BASERUBY] = 'ruby'

- Gem::ConfigMap[:RUBY_INSTALL_NAME] = 'ruby'

- Gem::ConfigMap[:BASERUBY] = orig_BASERUBY

- Gem::ConfigMap[:RUBY_INSTALL_NAME] = orig_RUBY_INSTALL_NAME

- orig_BASERUBY = Gem::ConfigMap[:BASERUBY]

- orig_RUBY_INSTALL_NAME = Gem::ConfigMap[:RUBY_INSTALL_NAME]

- Gem::ConfigMap[:BASERUBY] = 'ruby'

- Gem::ConfigMap[:RUBY_INSTALL_NAME] = 'ruby18'

- Gem::ConfigMap[:BASERUBY] = orig_BASERUBY

- Gem::ConfigMap[:RUBY_INSTALL_NAME] = orig_RUBY_INSTALL_NAME

- orig_BASERUBY = Gem::ConfigMap[:BASERUBY]

- orig_RUBY_INSTALL_NAME = Gem::ConfigMap[:RUBY_INSTALL_NAME]

- Gem::ConfigMap[:BASERUBY] = 'ruby'

- Gem::ConfigMap[:RUBY_INSTALL_NAME] = 'jruby'

- Gem::ConfigMap[:BASERUBY] = orig_BASERUBY

- Gem::ConfigMap[:RUBY_INSTALL_NAME] = orig_RUBY_INSTALL_NAME

- assert !File.exist?(File.join(@tempdir, 'a')),

- assert !File.exist?(gemdir), "manually remove #{gemdir}, tests are broken"

- assert !File.exist?("#{gemdir}/cache")

- assert !File.exist?(parent), "manually remove #{parent}, tests are broken"

- assert !File.exist?("#{gemdir}/cache")

- s.files << 'lib/foo/discover.rb'

- s.files << 'lib/foo/discover.rb'

- path = File.join 'gems', foo1.full_name, 'lib', 'foo', 'discover.rb'

- path = File.join 'gems', foo2.full_name, 'lib', 'foo', 'discover.rb'

- File.join(foo1.full_gem_path, 'lib', 'foo', 'discover.rb'),

- File.join(foo2.full_gem_path, 'lib', 'foo', 'discover.rb'),

- assert_equal expected, Gem.find_files('foo/discover').sort

- File.join(@gemhome, *%W[gems #{@a2.full_name} lib]),

- assert Gem.path.include?(apple_gem_home)

- assert !Gem.path.include?(apple_gem_home)

- a1_spec = File.join @gemhome, "specifications", "#{@a1.full_name}.gemspec"

- assert !Gem.source_index.gems.include?(@a1.full_name)

- assert Gem.source_index.gems.include?(@a1.full_name)

- def test_self_ruby_version

- version = RUBY_VERSION.dup

- version << ".#{RUBY_LEVEL}" if defined? RUBY_LEVEL

- assert_equal Gem::Version.new(version), Gem.ruby_version

- path = Gem.path

- assert_equal path[0], @userhome

- assert_equal path[1], other

- refute File.exist?(File.join(other, 'gems'))

- def test_add_option_overlapping_common_and_local_options

- @cmd.add_option('-x', '--zip', 'BAD!') do end

- @cmd.add_option('-z', '--exe', 'BAD!') do end

- @cmd.add_option('-x', '--exe', 'BAD!') do end

-

- assert_match %r|-x, --exe|, @cmd.parser.to_s

- refute_match %r|-z, --exe|, @cmd.parser.to_s

- refute_match %r|-x, --zip|, @cmd.parser.to_s

- end

-

- assert ! @cmd.handles?(['-z'])

- assert ! @cmd.handles?(['-f'])

- assert ! @cmd.handles?(['--toothpaste'])

-class InterruptCommand < Gem::Command

-

- def initialize

- super('interrupt', 'Raises an Interrupt Exception', {})

- end

-

- def execute

- raise Interrupt, "Interrupt exception"

- end

-

-end

-

- @command_manager = Gem::CommandManager.new

- @command_manager.register_command :interrupt

- assert !File.exist?(@cert_file_name)

- assert_match %r|RUBY EXECUTABLE:.*#{Gem::ConfigMap[:RUBY_INSTALL_NAME]}|,

-require 'minitest/unit'