diff options
Diffstat (limited to 'lib/rubygems/specification.rb')
| -rw-r--r-- | lib/rubygems/specification.rb | 1468 |
1 files changed, 654 insertions, 814 deletions
diff --git a/lib/rubygems/specification.rb b/lib/rubygems/specification.rb index 7b2f031d27..51729d755b 100644 --- a/lib/rubygems/specification.rb +++ b/lib/rubygems/specification.rb @@ -1,24 +1,21 @@ # frozen_string_literal: true -# -*- coding: utf-8 -*- + +# #-- # Copyright 2006 by Chad Fowler, Rich Kilmer, Jim Weirich and others. # All rights reserved. # See LICENSE.txt for permissions. #++ +require_relative "basic_specification" +require_relative "stub_specification" +require_relative "platform" +require_relative "specification_record" -require 'rubygems/version' -require 'rubygems/requirement' -require 'rubygems/platform' -require 'rubygems/deprecate' -require 'rubygems/basic_specification' -require 'rubygems/stub_specification' -require 'rubygems/specification_policy' -require 'rubygems/util/list' -require 'stringio' +require "rbconfig" ## -# The Specification class contains the information for a Gem. Typically +# The Specification class contains the information for a gem. Typically # defined in a .gemspec file or a Rakefile, and looks like this: # # Gem::Specification.new do |s| @@ -37,11 +34,17 @@ require 'stringio' # Starting in RubyGems 2.0, a Specification can hold arbitrary # metadata. See #metadata for restrictions on the format and size of metadata # items you may add to a specification. +# +# Specifications must be deterministic, as in the example above. For instance, +# you cannot define attributes conditionally: +# +# # INVALID: do not do this. +# unless RUBY_ENGINE == "jruby" +# s.extensions << "ext/example/extconf.rb" +# end +# class Gem::Specification < Gem::BasicSpecification - - extend Gem::Deprecate - # REFACTOR: Consider breaking out this version stuff into a separate # module. There's enough special stuff around it that it may justify # a separate class. @@ -80,39 +83,36 @@ class Gem::Specification < Gem::BasicSpecification # key should be equal to the CURRENT_SPECIFICATION_VERSION. SPECIFICATION_VERSION_HISTORY = { # :nodoc: - -1 => ['(RubyGems versions up to and including 0.7 did not have versioned specifications)'], - 1 => [ + -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]"' + '"test_file=x" is a shortcut for "test_files=[x]"', ], - 2 => [ + 2 => [ 'Added "required_rubygems_version"', - 'Now forward-compatible with future versions', + "Now forward-compatible with future versions", ], - 3 => [ - 'Added Fixnum validation to the specification_version' + 3 => [ + "Added Fixnum validation to the specification_version", + ], + 4 => [ + "Added sandboxed freeform metadata to the specification version.", ], - 4 => [ - 'Added sandboxed freeform metadata to the specification version.' - ] }.freeze MARSHAL_FIELDS = { # :nodoc: -1 => 16, - 1 => 16, - 2 => 16, - 3 => 17, - 4 => 18, + 1 => 16, + 2 => 16, + 3 => 17, + 4 => 18, }.freeze today = Time.now.utc TODAY = Time.utc(today.year, today.month, today.day) # :nodoc: - # rubocop:disable Style/MutableConstant - LOAD_CACHE = {} # :nodoc: - # rubocop:enable Style/MutableConstant - - private_constant :LOAD_CACHE if defined? private_constant + @load_cache = {} # :nodoc: + @load_cache_mutex = Thread::Mutex.new VALID_NAME_PATTERN = /\A[a-zA-Z0-9\.\-\_]+\z/ # :nodoc: @@ -133,40 +133,39 @@ class Gem::Specification < Gem::BasicSpecification # Map of attribute names to default values. @@default_value = { - :authors => [], - :autorequire => nil, - :bindir => 'bin', - :cert_chain => [], - :date => nil, - :dependencies => [], - :description => nil, - :email => nil, - :executables => [], - :extensions => [], - :extra_rdoc_files => [], - :files => [], - :homepage => nil, - :licenses => [], - :metadata => {}, - :name => nil, - :platform => Gem::Platform::RUBY, - :post_install_message => nil, - :rdoc_options => [], - :require_paths => ['lib'], - :required_ruby_version => Gem::Requirement.default, - :required_rubygems_version => Gem::Requirement.default, - :requirements => [], - :rubyforge_project => nil, - :rubygems_version => Gem::VERSION, - :signing_key => nil, - :specification_version => CURRENT_SPECIFICATION_VERSION, - :summary => nil, - :test_files => [], - :version => nil, + authors: [], + autorequire: nil, + bindir: "bin", + cert_chain: [], + date: nil, + dependencies: [], + description: nil, + email: nil, + executables: [], + extensions: [], + extra_rdoc_files: [], + files: [], + homepage: nil, + licenses: [], + metadata: {}, + name: nil, + platform: Gem::Platform::RUBY, + post_install_message: nil, + rdoc_options: [], + require_paths: ["lib"], + required_ruby_version: Gem::Requirement.default, + required_rubygems_version: Gem::Requirement.default, + requirements: [], + rubygems_version: Gem::VERSION, + signing_key: nil, + specification_version: CURRENT_SPECIFICATION_VERSION, + summary: nil, + test_files: [], + version: nil, }.freeze # rubocop:disable Style/MutableConstant - INITIALIZE_CODE_FOR_DEFAULTS = { } # :nodoc: + INITIALIZE_CODE_FOR_DEFAULTS = {} # :nodoc: # rubocop:enable Style/MutableConstant @@default_value.each do |k,v| @@ -175,25 +174,26 @@ class Gem::Specification < Gem::BasicSpecification v.inspect when String v.dump - when Numeric - "default_value(:#{k})" else "default_value(:#{k}).dup" - end + end end - @@attributes = @@default_value.keys.sort_by { |s| s.to_s } - @@array_attributes = @@default_value.reject { |k,v| v != [] }.keys - @@nil_attributes, @@non_nil_attributes = @@default_value.keys.partition { |k| + @@attributes = @@default_value.keys.sort_by(&:to_s) + @@array_attributes = @@default_value.select {|_k,v| v.is_a?(Array) }.keys + @@nil_attributes, @@non_nil_attributes = @@default_value.keys.partition do |k| @@default_value[k].nil? - } - - @@stubs_by_name = {} + end # Sentinel object to represent "not found" stubs NOT_FOUND = Struct.new(:to_spec, :this).new # :nodoc: - @@spec_with_requirable_file = {} - @@active_stub_with_requirable_file = {} + deprecate_constant :NOT_FOUND + + # Tracking removed method calls to warn users during build time. + REMOVED_METHODS = [:rubyforge_project=, :mark_version].freeze # :nodoc: + def removed_method_calls + @removed_method_calls ||= [] + end ###################################################################### # :section: Required gemspec attributes @@ -221,7 +221,7 @@ class Gem::Specification < Gem::BasicSpecification attr_reader :version ## - # A short summary of this gem's description. Displayed in `gem list -d`. + # A short summary of this gem's description. Displayed in <tt>gem list -d</tt>. # # The #description should be more detailed than the summary. # @@ -245,12 +245,11 @@ class Gem::Specification < Gem::BasicSpecification # require 'rake' # spec.files = FileList['lib/**/*.rb', # 'bin/*', - # '[A-Z]*', - # 'test/**/*'].to_a + # '[A-Z]*'].to_a # # # or without Rake... # spec.files = Dir['lib/**/*.rb'] + Dir['bin/*'] - # spec.files += Dir['[A-Z]*'] + Dir['test/**/*'] + # spec.files += Dir['[A-Z]*'] # spec.files.reject! { |fn| fn.include? "CVS" } def files @@ -260,21 +259,20 @@ class Gem::Specification < Gem::BasicSpecification @test_files, add_bindir(@executables), @extra_rdoc_files, - @extensions, - ].flatten.compact.uniq.sort + @extensions].flatten.compact.uniq.sort end ## # A list of authors for this gem. # # Alternatively, a single author can be specified by assigning a string to - # `spec.author` + # +spec.author+ # # Usage: # # spec.authors = ['John Jones', 'Mary Smith'] - def authors= value + def authors=(value) @authors = Array(value).flatten.grep(String) end @@ -282,6 +280,15 @@ class Gem::Specification < Gem::BasicSpecification # :section: Recommended gemspec attributes ## + # The version of Ruby required by this gem + # + # Usage: + # + # spec.required_ruby_version = '>= 2.7.0' + + attr_reader :required_ruby_version + + ## # A long description of this gem # # The description should be more detailed than the summary but not @@ -290,7 +297,7 @@ class Gem::Specification < Gem::BasicSpecification # # Usage: # - # spec.description = <<-EOF + # spec.description = <<~EOF # Rake is a Make-like program implemented in Ruby. Tasks and # dependencies are specified in standard Ruby syntax. # EOF @@ -324,17 +331,21 @@ class Gem::Specification < Gem::BasicSpecification # This should just be the name of your license. The full text of the license # should be inside of the gem (at the top level) when you build it. # - # The simplest way, is to specify the standard SPDX ID + # The simplest way is to specify the standard SPDX ID # https://spdx.org/licenses/ for the license. - # Ideally you should pick one that is OSI (Open Source Initiative) - # http://opensource.org/licenses/alphabetical approved. + # Ideally, you should pick one that is OSI (Open Source Initiative) + # https://opensource.org/licenses/ approved. + # + # The most commonly used OSI-approved licenses are MIT and Apache-2.0. + # GitHub also provides a license picker at https://choosealicense.com/. # - # The most commonly used OSI approved licenses are MIT and Apache-2.0. - # GitHub also provides a license picker at http://choosealicense.com/. + # You can also use a custom license file along with your gemspec and specify + # a LicenseRef-<idstring>, where idstring is the name of the file containing + # the license text. # # You should specify a license for your gem so that people know how they are - # permitted to use it, and any restrictions you're placing on it. Not - # specifying a license means all rights are reserved; others have no rights + # permitted to use it and any restrictions you're placing on it. Not + # specifying a license means all rights are reserved; others have no right # to use the code for any purpose. # # You can set multiple licenses with #licenses= @@ -342,7 +353,7 @@ class Gem::Specification < Gem::BasicSpecification # Usage: # spec.license = 'MIT' - def license=o + def license=(o) self.licenses = [o] end @@ -359,14 +370,13 @@ class Gem::Specification < Gem::BasicSpecification # Usage: # spec.licenses = ['MIT', 'GPL-2.0'] - def licenses= licenses + def licenses=(licenses) @licenses = Array licenses end ## # The metadata holds extra data for this gem that may be useful to other - # consumers and is settable by gem authors without requiring an update to - # the rubygems software. + # consumers and is settable by gem authors. # # Metadata items have the following restrictions: # @@ -386,7 +396,8 @@ class Gem::Specification < Gem::BasicSpecification # "homepage_uri" => "https://bestgemever.example.io", # "mailing_list_uri" => "https://groups.example.com/bestgemever", # "source_code_uri" => "https://example.com/user/bestgemever", - # "wiki_uri" => "https://example.com/user/bestgemever/wiki" + # "wiki_uri" => "https://example.com/user/bestgemever/wiki", + # "funding_uri" => "https://example.com/donate" # } # # These links will be used on your gem's page on rubygems.org and must pass @@ -406,16 +417,16 @@ class Gem::Specification < Gem::BasicSpecification # # spec.author = 'John Jones' - def author= o + def author=(o) self.authors = [o] end ## - # The path in the gem for executable scripts. Usually 'bin' + # The path in the gem for executable scripts. Usually 'exe' # # Usage: # - # spec.bindir = 'bin' + # spec.bindir = 'exe' attr_accessor :bindir @@ -457,11 +468,8 @@ class Gem::Specification < Gem::BasicSpecification # # spec.platform = Gem::Platform.local - def platform= platform - if @original_platform.nil? or - @original_platform == Gem::Platform::RUBY then - @original_platform = platform - end + def platform=(platform) + @original_platform = platform case platform when Gem::Platform::CURRENT then @@ -474,21 +482,17 @@ class Gem::Specification < Gem::BasicSpecification # 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 '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' + when "mswin32" then # was Gem::Platform::WIN32 + @new_platform = Gem::Platform.new "x86-mswin32" + 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 - - invalidate_memoized_attributes - - @new_platform end ## @@ -513,23 +517,11 @@ class Gem::Specification < Gem::BasicSpecification end ## - # The version of Ruby required by this gem - - attr_reader :required_ruby_version - - ## # The RubyGems version required by this gem attr_reader :required_rubygems_version ## - # The version of RubyGems used to create this gem. - # - # Do not set this, it is set automatically when the gem is packaged. - - attr_accessor :rubygems_version - - ## # The key used to sign this gem. See Gem::Security for details. attr_accessor :signing_key @@ -554,16 +546,20 @@ class Gem::Specification < Gem::BasicSpecification # # Usage: # - # spec.add_runtime_dependency 'example', '~> 1.1', '>= 1.1.4' + # spec.add_dependency 'example', '~> 1.1', '>= 1.1.4' + + def add_dependency(gem, *requirements) + if requirements.uniq.size != requirements.size + warn "WARNING: duplicated #{gem} dependency #{requirements}" + end - def add_runtime_dependency(gem, *requirements) add_dependency_with_type(gem, :runtime, requirements) end ## # Executables included in the gem. # - # For example, the rake gem has rake as an executable. You don’t specify the + # For example, the rake gem has rake as an executable. You don't specify the # full path (as in bin/rake); all application-style files are expected to be # found in bindir. These files must be executable Ruby files. Files that # use bash or other interpreters will not work. @@ -584,7 +580,7 @@ class Gem::Specification < Gem::BasicSpecification # extconf.rb-style files used to compile extensions. # # These files will be run when the gem is installed, causing the C (or - # whatever) code to be compiled on the user’s machine. + # whatever) code to be compiled on the user's machine. # # Usage: # @@ -625,7 +621,7 @@ class Gem::Specification < Gem::BasicSpecification # Sets the version of RubyGems that installed this gem. See also # #installed_by_version. - def installed_by_version= version # :nodoc: + def installed_by_version=(version) # :nodoc: @installed_by_version = Gem::Version.new version end @@ -642,6 +638,8 @@ class Gem::Specification < Gem::BasicSpecification @rdoc_options ||= [] end + LATEST_RUBY_WITHOUT_PATCH_VERSIONS = Gem::Version.new("2.1") + ## # The version of Ruby required by this gem. The ruby version can be # specified to the patch-level: @@ -650,29 +648,38 @@ class Gem::Specification < Gem::BasicSpecification # ruby 2.0.0p247 (2013-06-27 revision 41674) [x86_64-darwin12.4.0] # #<Gem::Version "2.0.0.247"> # - # Because patch-level is taken into account, be very careful specifying using - # `<=`: `<= 2.2.2` will not match any patch-level of 2.2.2 after the `p0` - # release. It is much safer to specify `< 2.2.3` instead + # Prereleases can also be specified. # # Usage: # # # This gem will work with 1.8.6 or greater... # spec.required_ruby_version = '>= 1.8.6' # - # # Only with ruby 2.0.x - # spec.required_ruby_version = '~> 2.0' + # # Only with final releases of major version 2 where minor version is at least 3 + # spec.required_ruby_version = '~> 2.3' + # + # # Only prereleases or final releases after 2.6.0.preview2 + # spec.required_ruby_version = '> 2.6.0.preview2' # - # # Only with ruby between 2.2.0 and 2.2.2 - # spec.required_ruby_version = ['>= 2.2.0', '< 2.2.3'] + # # This gem will work with 2.3.0 or greater, including major version 3, but lesser than 4.0.0 + # spec.required_ruby_version = '>= 2.3', '< 4' - def required_ruby_version= req + def required_ruby_version=(req) @required_ruby_version = Gem::Requirement.create req + + @required_ruby_version.requirements.map! do |op, v| + if v >= LATEST_RUBY_WITHOUT_PATCH_VERSIONS && v.release.segments.size == 4 + [op == "~>" ? "=" : op, Gem::Version.new(v.segments.tap {|s| s.delete_at(3) }.join("."))] + else + [op, v] + end + end end ## # The RubyGems version required by this gem - def required_rubygems_version= req + def required_rubygems_version=(req) @required_rubygems_version = Gem::Requirement.create req end @@ -697,11 +704,26 @@ class Gem::Specification < Gem::BasicSpecification # spec.test_files = Dir.glob('test/tc_*.rb') # spec.test_files = ['tests/test-suite.rb'] - def test_files= files # :nodoc: + def test_files=(files) # :nodoc: @test_files = Array files end ###################################################################### + # :section: Read-only attributes + + ## + # The version of RubyGems used to create this gem. + + attr_accessor :rubygems_version + + ## + # The path where this gem installs its extensions. + + def extensions_dir + @extensions_dir ||= super + end + + ###################################################################### # :section: Specification internals ## @@ -709,7 +731,7 @@ class Gem::Specification < Gem::BasicSpecification attr_accessor :activated - alias :activated? :activated + alias_method :activated?, :activated ## # Autorequire was used by old RubyGems to automatically require a file. @@ -719,27 +741,11 @@ class Gem::Specification < Gem::BasicSpecification attr_accessor :autorequire # :nodoc: ## - # Sets the default executable for this gem. - # - # Deprecated: You must now specify the executable name to Gem.bin_path. - - attr_writer :default_executable - deprecate :default_executable=, :none, 2018, 12 - - ## # Allows deinstallation of gems with legacy platforms. attr_writer :original_platform # :nodoc: ## - # The rubyforge project this gem lives under. i.e. RubyGems' - # rubyforge_project is "rubygems". - # - # This option is deprecated. - - attr_accessor :rubyforge_project - - ## # The Gem::Specification version of this gemspec. # # Do not set this, it is set automatically when the gem is packaged. @@ -747,72 +753,32 @@ class Gem::Specification < Gem::BasicSpecification attr_accessor :specification_version def self._all # :nodoc: - unless defined?(@@all) && @@all then - @@all = stubs.map(&:to_spec) - if @@all.any?(&:nil?) # TODO: remove once we're happy - raise "pid: #{$$} nil spec! included in #{stubs.inspect}" - end + specification_record.all + end - # After a reset, make sure already loaded specs - # are still marked as activated. - specs = {} - Gem.loaded_specs.each_value{|s| specs[s] = true} - @@all.each{|s| s.activated = true if specs[s]} + def self.clear_load_cache # :nodoc: + @load_cache_mutex.synchronize do + @load_cache.clear end - @@all end + private_class_method :clear_load_cache - def self._clear_load_cache # :nodoc: - LOAD_CACHE.clear + def self.gem_path # :nodoc: + Gem.path end + private_class_method :gem_path def self.each_gemspec(dirs) # :nodoc: dirs.each do |dir| Gem::Util.glob_files_in_dir("*.gemspec", dir).each do |path| - yield path.untaint + yield path end end end - def self.gemspec_stubs_in dir, pattern - Gem::Util.glob_files_in_dir(pattern, dir).map { |path| yield path }.select(&:valid?) - end - private_class_method :gemspec_stubs_in - - def self.default_stubs pattern - base_dir = Gem.default_dir - gems_dir = File.join base_dir, "gems" - gemspec_stubs_in(default_specifications_dir, pattern) do |path| - Gem::StubSpecification.default_gemspec_stub(path, base_dir, gems_dir) - end - end - private_class_method :default_stubs - - def self.installed_stubs dirs, pattern - map_stubs(dirs, pattern) do |path, base_dir, gems_dir| - Gem::StubSpecification.gemspec_stub(path, base_dir, gems_dir) - end - end - private_class_method :installed_stubs - - def self.map_stubs(dirs, pattern) # :nodoc: - dirs.flat_map { |dir| - base_dir = File.dirname dir - gems_dir = File.join base_dir, "gems" - gemspec_stubs_in(dir, pattern) { |path| yield path, base_dir, gems_dir } - } - end - private_class_method :map_stubs - - def self.uniq_by(list, &block) # :nodoc: - list.uniq(&block) + def self.gemspec_stubs_in(dir, pattern) # :nodoc: + Gem::Util.glob_files_in_dir(pattern, dir).map {|path| yield path }.select(&:valid?) end - private_class_method :uniq_by - - def self.sort_by! list, &block - list.sort_by!(&block) - end - private_class_method :sort_by! def self.each_spec(dirs) # :nodoc: each_gemspec(dirs) do |path| @@ -825,51 +791,55 @@ class Gem::Specification < Gem::BasicSpecification # Returns a Gem::StubSpecification for every installed gem def self.stubs - @@stubs ||= begin - pattern = "*.gemspec" - stubs = Gem.loaded_specs.values + default_stubs(pattern) + installed_stubs(dirs, pattern) - stubs = uniq_by(stubs) { |stub| stub.full_name } - - _resort!(stubs) - @@stubs_by_name = stubs.select { |s| Gem::Platform.match s.platform }.group_by(&:name) - stubs - end + specification_record.stubs end - EMPTY = [].freeze # :nodoc: + ## + # Returns a Gem::StubSpecification for default gems + + def self.default_stubs(pattern = "*.gemspec") + base_dir = Gem.default_dir + gems_dir = File.join base_dir, "gems" + gemspec_stubs_in(Gem.default_specifications_dir, pattern) do |path| + Gem::StubSpecification.default_gemspec_stub(path, base_dir, gems_dir) + end + end ## # Returns a Gem::StubSpecification for installed gem named +name+ # only returns stubs that match Gem.platforms - def self.stubs_for name - if @@stubs - @@stubs_by_name[name] || [] - else - pattern = "#{name}-*.gemspec" - stubs = Gem.loaded_specs.values + default_stubs(pattern) + - installed_stubs(dirs, pattern).select { |s| Gem::Platform.match s.platform } - stubs = uniq_by(stubs) { |stub| stub.full_name }.group_by(&:name) - stubs.each_value { |v| _resort!(v) } - - @@stubs_by_name.merge! stubs - @@stubs_by_name[name] ||= EMPTY - end + def self.stubs_for(name) + specification_record.stubs_for(name) + end + + ## + # Finds stub specifications matching a pattern from the standard locations, + # optionally filtering out specs not matching the current platform + # + def self.stubs_for_pattern(pattern, match_platform = true) # :nodoc: + specification_record.stubs_for_pattern(pattern, match_platform) end def self._resort!(specs) # :nodoc: - specs.sort! { |a, b| + specs.sort! do |a, b| names = a.name <=> b.name next names if names.nonzero? - b.version <=> a.version - } + versions = b.version <=> a.version + next versions if versions.nonzero? + platforms = Gem::Platform.sort_priority(b.platform) <=> Gem::Platform.sort_priority(a.platform) + next platforms if platforms.nonzero? + default_gem = a.default_gem_priority <=> b.default_gem_priority + next default_gem if default_gem.nonzero? + a.base_dir_priority(gem_path) <=> b.base_dir_priority(gem_path) + end end ## # Loads the default specifications. It should be called only once. def self.load_defaults - each_spec([default_specifications_dir]) do |spec| + each_spec([Gem.default_specifications_dir]) do |spec| # #load returns nil if the spec is bad, so we just ignore # it at this stage Gem.register_default_spec(spec) @@ -880,45 +850,15 @@ class Gem::Specification < Gem::BasicSpecification # Adds +spec+ to the known specifications, keeping the collection # properly sorted. - def self.add_spec spec - warn "Gem::Specification.add_spec is deprecated and will be removed in RubyGems 3.0" unless Gem::Deprecate.skip - # TODO: find all extraneous adds - # puts - # p :add_spec => [spec.full_name, caller.reject { |s| s =~ /minitest/ }] - - # TODO: flush the rest of the crap from the tests - # raise "no dupes #{spec.full_name} in #{all_names.inspect}" if - # _all.include? spec - - raise "nil spec!" unless spec # TODO: remove once we're happy with tests - - return if _all.include? spec - - _all << spec - stubs << spec - (@@stubs_by_name[spec.name] ||= []) << spec - sort_by!(@@stubs_by_name[spec.name]) { |s| s.version } - _resort!(_all) - _resort!(stubs) + def self.add_spec(spec) + specification_record.add_spec(spec) end ## - # Adds multiple specs to the known specifications. - - def self.add_specs *specs - warn "Gem::Specification.add_specs is deprecated and will be removed in RubyGems 3.0" unless Gem::Deprecate.skip - - raise "nil spec!" if specs.any?(&:nil?) # TODO: remove once we're happy - - # TODO: this is much more efficient, but we need the extra checks for now - # _all.concat specs - # _resort! + # Removes +spec+ from the known specs. - Gem::Deprecate.skip_during do - specs.each do |spec| # TODO: slow - add_spec spec - end - end + def self.remove_spec(spec) + specification_record.remove_spec(spec) end ## @@ -926,34 +866,23 @@ class Gem::Specification < Gem::BasicSpecification # You probably want to use one of the Enumerable methods instead. def self.all - warn "NOTE: Specification.all called from #{caller.first}" unless + warn "NOTE: Specification.all called from #{caller(1, 1).first}" unless Gem::Deprecate.skip _all end ## - # Sets the known specs to +specs+. Not guaranteed to work for you in - # the future. Use at your own risk. Caveat emptor. Doomy doom doom. - # Etc etc. - # - #-- - # Makes +specs+ the known specs - # Listen, time is a river - # Winter comes, code breaks - # - # -- wilsonb + # Sets the known specs to +specs+. - def self.all= specs - raise "nil spec!" if specs.any?(&:nil?) # TODO: remove once we're happy - @@stubs_by_name = specs.group_by(&:name) - @@all = @@stubs = specs + def self.all=(specs) + specification_record.all = specs end ## # Return full names of all specs in sorted order. def self.all_names - self._all.map(&:full_name) + specification_record.all_names end ## @@ -978,19 +907,17 @@ class Gem::Specification < Gem::BasicSpecification # Return the directories that Specification uses to find specs. def self.dirs - @@dirs ||= Gem.path.collect { |dir| - File.join dir.dup.untaint, "specifications" - } + @@dirs ||= Gem::SpecificationRecord.dirs_from(gem_path) end ## # Set the directories that Specification uses to find specs. Setting # this resets the list of known specs. - def self.dirs= dirs - self.reset + def self.dirs=(dirs) + reset - @@dirs = Array(dirs).map { |dir| File.join dir, "specifications" } + @@dirs = Gem::SpecificationRecord.dirs_from(Array(dirs)) end extend Enumerable @@ -999,23 +926,15 @@ class Gem::Specification < Gem::BasicSpecification # Enumerate every known spec. See ::dirs= and ::add_spec to set the list of # specs. - def self.each - return enum_for(:each) unless block_given? - - self._all.each do |x| - yield x - end + def self.each(&block) + specification_record.each(&block) end ## # Returns every spec that matches +name+ and optional +requirements+. - def self.find_all_by_name name, *requirements - requirements = Gem::Requirement.default if requirements.empty? - - # TODO: maybe try: find_all { |s| spec === dep } - - Gem::Dependency.new(name, *requirements).matching_specs + def self.find_all_by_name(name, *requirements) + specification_record.find_all_by_name(name, *requirements) end ## @@ -1029,66 +948,65 @@ class Gem::Specification < Gem::BasicSpecification # Find the best specification matching a +name+ and +requirements+. Raises # if the dependency doesn't resolve to a valid specification. - def self.find_by_name name, *requirements + def self.find_by_name(name, *requirements) requirements = Gem::Requirement.default if requirements.empty? - # TODO: maybe try: find { |s| spec === dep } - Gem::Dependency.new(name, *requirements).to_spec end ## + # Find the best specification matching a +full_name+. + def self.find_by_full_name(full_name) + stubs.find {|s| s.full_name == full_name }&.to_spec + end + + ## # Return the best specification that contains the file matching +path+. - def self.find_by_path path - path = path.dup.freeze - spec = @@spec_with_requirable_file[path] ||= (stubs.find { |s| - next unless Gem::BundlerVersionFinder.compatible?(s) - s.contains_requirable_file? path - } || NOT_FOUND) - spec.to_spec + def self.find_by_path(path) + specification_record.find_by_path(path) + end + + ## + # Return the best specification that contains the file matching +path+ + # amongst the specs that are not loaded. This method is different than + # +find_inactive_by_path+ as it will filter out loaded specs by their name. + + def self.find_unloaded_by_path(path) + specification_record.find_unloaded_by_path(path) end ## # Return the best specification that contains the file matching +path+ # amongst the specs that are not activated. - def self.find_inactive_by_path path - stub = stubs.find { |s| - next if s.activated? - next unless Gem::BundlerVersionFinder.compatible?(s) - s.contains_requirable_file? path - } - stub && stub.to_spec + def self.find_inactive_by_path(path) + specification_record.find_inactive_by_path(path) end - def self.find_active_stub_by_path path - stub = @@active_stub_with_requirable_file[path] ||= (stubs.find { |s| - s.activated? and s.contains_requirable_file? path - } || NOT_FOUND) - stub.this + ## + # Return the best specification that contains the file matching +path+, among + # those already activated. + + def self.find_active_stub_by_path(path) + specification_record.find_active_stub_by_path(path) end ## # Return currently unresolved specs that contain the file matching +path+. - def self.find_in_unresolved path - # TODO: do we need these?? Kill it - specs = unresolved_deps.values.map { |dep| dep.to_specs }.flatten - - specs.find_all { |spec| spec.contains_requirable_file? path } + def self.find_in_unresolved(path) + unresolved_specs.find_all {|spec| spec.contains_requirable_file? path } end ## # Search through all unresolved deps and sub-dependencies and return # specs that contain the file matching +path+. - def self.find_in_unresolved_tree path - specs = unresolved_deps.values.map { |dep| dep.to_specs }.flatten - - specs.each do |spec| - spec.traverse do |from_spec, dep, to_spec, trail| - if to_spec.has_conflicts? || to_spec.conficts_when_loaded_with?(trail) + def self.find_in_unresolved_tree(path) + unresolved_specs.each do |spec| + spec.traverse do |_from_spec, _dep, to_spec, trail| + if to_spec.has_conflicts? || to_spec.conflicts_when_loaded_with?(trail) :next else return trail.reverse if to_spec.contains_requirable_file? path @@ -1099,6 +1017,11 @@ class Gem::Specification < Gem::BasicSpecification [] end + def self.unresolved_specs + unresolved_deps.values.flat_map(&:to_specs) + end + private_class_method :unresolved_specs + ## # Special loader for YAML files. When a Specification object is loaded # from a YAML file, it bypasses the normal Ruby object initialization @@ -1113,16 +1036,17 @@ class Gem::Specification < Gem::BasicSpecification input = normalize_yaml_input input spec = Gem::SafeYAML.safe_load input - if spec && spec.class == FalseClass then + if spec && spec.class == FalseClass raise Gem::EndOfYAMLException end - unless Gem::Specification === spec then + unless Gem::Specification === spec raise Gem::Exception, "YAML data doesn't evaluate to gem specification" end spec.specification_version ||= NONEXISTENT_SPECIFICATION_VERSION spec.reset_nil_attributes_to_default + spec.flatten_require_paths spec end @@ -1131,56 +1055,64 @@ class Gem::Specification < Gem::BasicSpecification # Return the latest specs, optionally including prerelease specs if # +prerelease+ is true. - def self.latest_specs prerelease = false - _latest_specs Gem::Specification._all, prerelease + def self.latest_specs(prerelease = false) + specification_record.latest_specs(prerelease) + end + + ## + # Return the latest installed spec for gem +name+. + + def self.latest_spec_for(name) + specification_record.latest_spec_for(name) end - def self._latest_specs specs, prerelease = false # :nodoc: - result = Hash.new { |h,k| h[k] = {} } - native = {} + def self._latest_specs(specs, prerelease = false) # :nodoc: + result = {} specs.reverse_each do |spec| - next if spec.version.prerelease? unless prerelease + unless prerelease + next if spec.version.prerelease? + end - native[spec.name] = spec.version if spec.platform == Gem::Platform::RUBY - result[spec.name][spec.platform] = spec + result[spec.name] = spec end - result.map(&:last).map(&:values).flatten.reject { |spec| - minimum = native[spec.name] - minimum && spec.version < minimum - }.sort_by{ |tup| tup.name } + result.flat_map(&:last).sort_by(&:name) end ## # Loads Ruby format gemspec from +file+. - def self.load file + def self.load(file) return unless file - _spec = LOAD_CACHE[file] - return _spec if _spec + spec = @load_cache_mutex.synchronize { @load_cache[file] } + return spec if spec - file = file.dup.untaint return unless File.file?(file) - code = File.read file, :mode => 'r:UTF-8:-' - - code.untaint + code = Gem.open_file(file, "r:UTF-8:-", &:read) begin - _spec = eval code, binding, file - - if Gem::Specification === _spec - _spec.loaded_from = File.expand_path file.to_s - LOAD_CACHE[file] = _spec - return _spec + spec = eval code, binding, file + + if Gem::Specification === spec + spec.loaded_from = File.expand_path file.to_s + @load_cache_mutex.synchronize do + prev = @load_cache[file] + if prev + spec = prev + else + @load_cache[file] = spec + end + end + return spec end - warn "[#{file}] isn't a Gem::Specification (#{_spec.class} instead)." + warn "[#{file}] isn't a Gem::Specification (#{spec.class} instead)." rescue SignalException, SystemExit raise - rescue SyntaxError, Exception => e + rescue SyntaxError, StandardError => e warn "Invalid gemspec in [#{file}]: #{e}" end @@ -1199,7 +1131,7 @@ class Gem::Specification < Gem::BasicSpecification def self.normalize_yaml_input(input) result = input.respond_to?(:read) ? input.read : input - result = "--- " + result unless result =~ /\A--- / + result = "--- " + result unless result.start_with?("--- ") result = result.dup result.gsub!(/ !!null \n/, " \n") # date: 2011-04-26 00:00:00.000000000Z @@ -1216,7 +1148,7 @@ class Gem::Specification < Gem::BasicSpecification # version as well. def self.outdated - outdated_and_latest_version.map { |local, _| local.name } + outdated_and_latest_version.map {|local, _| local.name } end ## @@ -1237,29 +1169,18 @@ class Gem::Specification < Gem::BasicSpecification Gem::Dependency.new local_spec.name, ">= #{local_spec.version}" remotes, = fetcher.search_for_dependency dependency - remotes = remotes.map { |n, _| n.version } + remotes = remotes.map {|n, _| n.version } latest_remote = remotes.sort.last yield [local_spec, latest_remote] if - latest_remote and local_spec.version < latest_remote + latest_remote && local_spec.version < latest_remote end nil end ## - # Removes +spec+ from the known specs. - - def self.remove_spec spec - warn "Gem::Specification.remove_spec is deprecated and will be removed in RubyGems 3.0" unless Gem::Deprecate.skip - _all.delete spec - stubs.delete_if { |s| s.full_name == spec.full_name } - (@@stubs_by_name[spec.name] || []).delete_if { |s| s.full_name == spec.full_name } - reset - end - - ## # Is +name+ a required attribute? def self.required_attribute?(name) @@ -1279,66 +1200,116 @@ class Gem::Specification < Gem::BasicSpecification def self.reset @@dirs = nil - Gem.pre_reset_hooks.each { |hook| hook.call } - @@all = nil - @@stubs = nil - @@stubs_by_name = {} - @@spec_with_requirable_file = {} - @@active_stub_with_requirable_file = {} - _clear_load_cache - unresolved = unresolved_deps - unless unresolved.empty? then - w = "W" + "ARN" - warn "#{w}: Unresolved or ambigious specs during Gem::Specification.reset:" - unresolved.values.each do |dep| - warn " #{dep}" - - versions = find_all_by_name(dep.name) - unless versions.empty? - warn " Available/installed versions of this gem:" - versions.each { |s| warn " - #{s.version}" } + Gem.pre_reset_hooks.each(&:call) + @specification_record = nil + clear_load_cache + + unless unresolved_deps.empty? + unresolved = unresolved_deps.filter_map do |name, dep| + matching_versions = find_all_by_name(name) + next if dep.latest_version? && matching_versions.any?(&:default_gem?) + + [dep, matching_versions.uniq(&:full_name)] + end.to_h + + unless unresolved.empty? + warn "WARN: Unresolved or ambiguous specs during Gem::Specification.reset:" + unresolved.each do |dep, versions| + warn " #{dep}" + + unless versions.empty? + warn " Available/installed versions of this gem:" + versions.each {|s| warn " - #{s.version}" } + end end + warn "WARN: Clearing out unresolved specs. Try 'gem cleanup <gem>'" + warn "Please report a bug if this causes problems." end - warn "#{w}: Clearing out unresolved specs. Try 'gem cleanup <gem>'" - warn "Please report a bug if this causes problems." - unresolved.clear + + unresolved_deps.clear end - Gem.post_reset_hooks.each { |hook| hook.call } + Gem.post_reset_hooks.each(&:call) + end + + ## + # Keeps track of all currently known specifications + + def self.specification_record + @specification_record ||= Gem::SpecificationRecord.new(dirs) end # DOC: This method needs documented or nodoc'd def self.unresolved_deps - @unresolved_deps ||= Hash.new { |h, n| h[n] = Gem::Dependency.new n } + @unresolved_deps ||= Hash.new {|h, n| h[n] = Gem::Dependency.new n } end ## # Load custom marshal format, re-initializing defaults as needed def self._load(str) - array = Marshal.load str + Gem.load_yaml + Gem.load_safe_marshal + + yaml_set = false + retry_count = 0 + + array = begin + Gem::SafeMarshal.safe_load str + rescue ArgumentError => e + # Avoid an infinite retry loop when the argument error has nothing to do + # with the classes not being defined. + # 1 retry each allowed in case all 3 of + # - YAML + # - YAML::Syck::DefaultKey + # - YAML::PrivateType + # need to be defined + raise if retry_count >= 3 + + # + # Some very old marshaled specs included references to `YAML::PrivateType` + # and `YAML::Syck::DefaultKey` constants due to bugs in the old emitter + # that generated them. Workaround the issue by defining the necessary + # constants and retrying. + # + message = e.message + raise unless message.include?("YAML::") + + unless Object.const_defined?(:YAML) + Object.const_set "YAML", Module.new + yaml_set = true + end + + if message.include?("YAML::Syck::") + YAML.const_set "Syck", YAML unless YAML.const_defined?(:Syck) + + YAML::Syck.const_set "DefaultKey", Class.new if message.include?("YAML::Syck::DefaultKey") && !YAML::Syck.const_defined?(:DefaultKey) + elsif message.include?("YAML::PrivateType") && !YAML.const_defined?(:PrivateType) + YAML.const_set "PrivateType", Class.new { attr_accessor :type_id, :value } + end + + retry_count += 1 + retry + ensure + Object.__send__(:remove_const, "YAML") if yaml_set + end 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 + field_count = if spec.specification_version > current_version + 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 + if array.size < field_count raise TypeError, "invalid Gem::Specification format #{array.inspect}" end - # Cleanup any YAML::PrivateType. They only show up for an old bug - # where nil => null, so just convert them to nil based on the type. - - array.map! { |e| e.kind_of?(YAML::PrivateType) ? nil : e } - spec.instance_variable_set :@rubygems_version, array[0] # spec version spec.instance_variable_set :@name, array[2] @@ -1347,17 +1318,15 @@ class Gem::Specification < Gem::BasicSpecification 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.platform = array[8] spec.instance_variable_set :@dependencies, array[9] - spec.instance_variable_set :@rubyforge_project, array[10] + # offset due to rubyforge_project removal 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 :@license, array[17] + # offset due to has_rdoc removal + spec.instance_variable_set :@licenses, array[17] spec.instance_variable_set :@metadata, array[18] spec.instance_variable_set :@loaded, false spec.instance_variable_set :@activated, false @@ -1369,7 +1338,7 @@ class Gem::Specification < Gem::BasicSpecification sort_obj <=> other.sort_obj end - def == other # :nodoc: + def ==(other) # :nodoc: self.class === other && name == other.name && version == other.version && @@ -1394,7 +1363,7 @@ class Gem::Specification < Gem::BasicSpecification @required_rubygems_version, @original_platform, @dependencies, - @rubyforge_project, + "", # rubyforge_project @email, @authors, @description, @@ -1402,7 +1371,7 @@ class Gem::Specification < Gem::BasicSpecification true, # has_rdoc @new_platform, @licenses, - @metadata + @metadata, ] end @@ -1413,8 +1382,8 @@ class Gem::Specification < Gem::BasicSpecification # there are conflicts upon activation. def activate - other = Gem.loaded_specs[self.name] - if other then + other = Gem.loaded_specs[name] + if other check_version_conflict other return false end @@ -1424,11 +1393,11 @@ class Gem::Specification < Gem::BasicSpecification activate_dependencies add_self_to_load_path - Gem.loaded_specs[self.name] = self + Gem.loaded_specs[name] = self @activated = true @loaded = true - return true + true end ## @@ -1439,7 +1408,7 @@ class Gem::Specification < Gem::BasicSpecification def activate_dependencies unresolved = Gem::Specification.unresolved_deps - self.runtime_dependencies.each do |spec_dep| + runtime_dependencies.each do |spec_dep| if loaded = Gem.loaded_specs[spec_dep.name] next if spec_dep.matches_spec? loaded @@ -1450,9 +1419,11 @@ class Gem::Specification < Gem::BasicSpecification raise e end - specs = spec_dep.to_specs + specs = spec_dep.matching_specs(true).uniq(&:full_name) - if specs.size == 1 then + if specs.size == 0 + raise Gem::MissingSpecError.new(spec_dep.name, spec_dep.requirement, "at: #{spec_file}") + elsif specs.size == 1 specs.first.activate else name = spec_dep.name @@ -1486,7 +1457,7 @@ class Gem::Specification < Gem::BasicSpecification self.summary = sanitize_string(summary) self.description = sanitize_string(description) self.post_install_message = sanitize_string(post_install_message) - self.authors = authors.collect { |a| sanitize_string(a) } + self.authors = authors.collect {|a| sanitize_string(a) } end ## @@ -1495,16 +1466,10 @@ class Gem::Specification < Gem::BasicSpecification def sanitize_string(string) return string unless string - # HACK the #to_s is in here because RSpec has an Array of Arrays of + # HACK: the #to_s is in here because RSpec has an Array of Arrays of # Strings for authors. Need a way to disallow bad values on gemspec # generation. (Probably won't happen.) - string = string.to_s - - begin - Builder::XChar.encode string - rescue NameError, NoMethodError - string.to_xs - end + string.to_s end ## @@ -1514,13 +1479,13 @@ class Gem::Specification < Gem::BasicSpecification def add_bindir(executables) return nil if executables.nil? - if @bindir then - Array(executables).map { |e| File.join(@bindir, e) } + if @bindir + Array(executables).map {|e| File.join(@bindir, e) } else executables end - rescue - return nil + rescue StandardError + nil end ## @@ -1529,11 +1494,11 @@ class Gem::Specification < Gem::BasicSpecification # <tt>:development</tt>. def add_dependency_with_type(dependency, type, requirements) - requirements = if requirements.empty? then - Gem::Requirement.default - else - requirements.flatten - end + requirements = if requirements.empty? + Gem::Requirement.default + else + requirements.flatten + end unless dependency.respond_to?(:name) && dependency.respond_to?(:requirement) @@ -1545,7 +1510,7 @@ class Gem::Specification < Gem::BasicSpecification private :add_dependency_with_type - alias add_dependency add_runtime_dependency + alias_method :add_runtime_dependency, :add_dependency ## # Adds this spec's require paths to LOAD_PATH, in the proper location. @@ -1555,23 +1520,14 @@ class Gem::Specification < Gem::BasicSpecification paths = full_require_paths - # gem directories must come after -I and ENV['RUBYLIB'] - insert_index = Gem.load_path_insert_index - - if insert_index then - # gem directories must come after -I and ENV['RUBYLIB'] - $LOAD_PATH.insert(insert_index, *paths) - else - # we are probably testing in core, -I and RUBYLIB don't apply - $LOAD_PATH.unshift(*paths) - end + Gem.add_to_load_path(*paths) end ## # Singular reader for #authors. Returns the first author in the list def author - val = authors and val.first + (val = authors) && val.first end ## @@ -1590,13 +1546,13 @@ class Gem::Specification < Gem::BasicSpecification # a full path. def bin_dir - @bin_dir ||= File.join gem_dir, bindir # TODO: this is unfortunate + @bin_dir ||= File.join gem_dir, bindir end ## # Returns the full path to an executable named +name+ in this gem. - def bin_file name + def bin_file(name) File.join bin_dir, name end @@ -1606,7 +1562,7 @@ class Gem::Specification < Gem::BasicSpecification def build_args if File.exist? build_info_file build_info = File.readlines build_info_file - build_info = build_info.map { |x| x.strip } + build_info = build_info.map(&:strip) build_info.delete "" build_info else @@ -1619,12 +1575,13 @@ class Gem::Specification < Gem::BasicSpecification # the gem.build_complete file is missing. def build_extensions # :nodoc: - return if default_gem? return if extensions.empty? - return if installed_by_version < Gem::Version.new('2.2.0.preview.2') + return if default_gem? + # we need to fresh build when same name and version of default gems + return if self.class.find_by_full_name(full_name)&.default_gem? return if File.exist? gem_build_complete_path - return if !File.writable?(base_dir) - return if !File.exist?(File.join(base_dir, 'extensions')) + return unless File.writable?(base_dir) + return unless File.exist?(File.join(base_dir, "extensions")) begin # We need to require things in $LOAD_PATH without looking for the @@ -1632,9 +1589,9 @@ class Gem::Specification < Gem::BasicSpecification unresolved_deps = Gem::Specification.unresolved_deps.dup Gem::Specification.unresolved_deps.clear - require 'rubygems/config_file' - require 'rubygems/ext' - require 'rubygems/user_interaction' + require_relative "config_file" + require_relative "ext" + require_relative "user_interaction" ui = Gem::SilentUI.new Gem::DefaultUserInteraction.use_ui ui do @@ -1642,7 +1599,7 @@ class Gem::Specification < Gem::BasicSpecification builder.build_extensions end ensure - ui.close if ui + ui&.close Gem::Specification.unresolved_deps.replace unresolved_deps end end @@ -1663,28 +1620,18 @@ class Gem::Specification < Gem::BasicSpecification end ## - # Used to detect if the gem is bundled in older version of Ruby, but not - # detectable as default gem (see BasicSpecification#default_gem?). - - def bundled_gem_in_old_ruby? - !default_gem? && - RUBY_VERSION < "2.0.0" && - summary == "This #{name} is bundled with Ruby" - end - - ## # Returns the full path to the cache directory containing this # spec's cached gem. def cache_dir - @cache_dir ||= File.join base_dir, "cache" + File.join base_dir, "cache" end ## # Returns the full path to the cached gem for this spec. def cache_file - @cache_file ||= File.join cache_dir, "#{full_name}.gem" + File.join cache_dir, "#{full_name}.gem" end ## @@ -1692,12 +1639,12 @@ class Gem::Specification < Gem::BasicSpecification def conflicts conflicts = {} - self.runtime_dependencies.each { |dep| + runtime_dependencies.each do |dep| spec = Gem.loaded_specs[dep.name] - if spec and not spec.satisfies_requirement? dep + if spec && !spec.satisfies_requirement?(dep) (conflicts[spec] ||= []) << dep end - } + end env_req = Gem.env_requirement(name) (conflicts[self] ||= []) << env_req unless env_req.satisfied_by? version conflicts @@ -1706,10 +1653,10 @@ class Gem::Specification < Gem::BasicSpecification ## # return true if there will be conflict when spec if loaded together with the list of specs. - def conficts_when_loaded_with?(list_of_specs) # :nodoc: - result = list_of_specs.any? { |spec| - spec.dependencies.any? { |dep| dep.runtime? && (dep.name == name) && !satisfies_requirement?(dep) } - } + def conflicts_when_loaded_with?(list_of_specs) # :nodoc: + result = list_of_specs.any? do |spec| + spec.runtime_dependencies.any? {|dep| (dep.name == name) && !satisfies_requirement?(dep) } + end result end @@ -1718,14 +1665,12 @@ class Gem::Specification < Gem::BasicSpecification def has_conflicts? return true unless Gem.env_requirement(name).satisfied_by?(version) - self.dependencies.any? { |dep| - if dep.runtime? then - spec = Gem.loaded_specs[dep.name] - spec and not spec.satisfies_requirement? dep - else - false - end - } + runtime_dependencies.any? do |dep| + spec = Gem.loaded_specs[dep.name] + spec && !spec.satisfies_requirement?(dep) + end + rescue ArgumentError => e + raise e, "#{name} #{version}: #{e.message}" end # The date this gem was created. @@ -1737,12 +1682,12 @@ class Gem::Specification < Gem::BasicSpecification # https://reproducible-builds.org/specs/source-date-epoch/ def date - @date ||= ENV["SOURCE_DATE_EPOCH"] ? Time.utc(*Time.at(ENV["SOURCE_DATE_EPOCH"].to_i).utc.to_a[3..5].reverse) : TODAY + @date ||= Time.utc(*Gem.source_date_epoch.utc.to_a[3..5].reverse) end DateLike = Object.new # :nodoc: def DateLike.===(obj) # :nodoc: - defined?(::Date) and Date === obj + defined?(::Date) && Date === obj end DateTimeFormat = # :nodoc: @@ -1756,19 +1701,13 @@ class Gem::Specification < Gem::BasicSpecification # # DO NOT set this, it is set automatically when the gem is packaged. - def date= date + def date=(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. @date = case date when String then - if DateTimeFormat =~ date then - Time.utc($1.to_i, $2.to_i, $3.to_i) - - # Workaround for where the date format output from psych isn't - # parsed as a Time object by syck and thus comes through as a - # string. - elsif /\A(\d{4})-(\d{2})-(\d{2}) \d{2}:\d{2}:\d{2}\.\d+?Z\z/ =~ date then + if DateTimeFormat =~ date Time.utc($1.to_i, $2.to_i, $3.to_i) else raise(Gem::InvalidSpecificationException, @@ -1778,31 +1717,13 @@ class Gem::Specification < Gem::BasicSpecification Time.utc(date.year, date.month, date.day) else TODAY - end - end - - ## - # The default executable for this gem. - # - # Deprecated: The name of the gem is assumed to be the name of the - # executable now. See Gem.bin_path. - - def default_executable # :nodoc: - 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 end - deprecate :default_executable, :none, 2018, 12 ## # The default value for specification attribute +name+ - def default_value name + def default_value(name) @@default_value[name] end @@ -1822,17 +1743,17 @@ class Gem::Specification < Gem::BasicSpecification # # [depending_gem, dependency, [list_of_gems_that_satisfy_dependency]] - def dependent_gems + def dependent_gems(check_dev = true) out = [] Gem::Specification.each do |spec| - spec.dependencies.each do |dep| - if self.satisfies_requirement?(dep) then - sats = [] - find_all_satisfiers(dep) do |sat| - sats << sat - end - out << [spec, dep, sats] + deps = check_dev ? spec.dependencies : spec.runtime_dependencies + deps.each do |dep| + next unless satisfies_requirement?(dep) + sats = [] + find_all_satisfiers(dep) do |sat| + sats << sat end + out << [spec, dep, sats] end end out @@ -1842,13 +1763,13 @@ class Gem::Specification < Gem::BasicSpecification # Returns all specs that matches this spec's runtime dependencies. def dependent_specs - runtime_dependencies.map { |dep| dep.to_specs }.flatten + runtime_dependencies.flat_map(&:to_specs) end ## # A detailed description of this gem. See also #summary - def description= str + def description=(str) @description = str.to_s end @@ -1856,7 +1777,7 @@ class Gem::Specification < Gem::BasicSpecification # List of dependencies that are used for development def development_dependencies - dependencies.select { |d| d.type == :development } + dependencies.select {|d| d.type == :development } end ## @@ -1867,38 +1788,30 @@ class Gem::Specification < Gem::BasicSpecification # # spec.doc_dir 'ri' # => "/path/to/gem_repo/doc/a-1/ri" - def doc_dir type = nil - @doc_dir ||= File.join base_dir, 'doc', full_name + def doc_dir(type = nil) + @doc_dir ||= File.join base_dir, "doc", full_name - if type then + if type File.join @doc_dir, type else @doc_dir end end - def encode_with coder # :nodoc: - mark_version - - coder.add 'name', @name - coder.add 'version', @version - platform = case @original_platform - when nil, '' then - 'ruby' - when String then - @original_platform - else - @original_platform.to_s - end - coder.add 'platform', platform + def encode_with(coder) # :nodoc: + coder.add "name", @name + coder.add "version", @version + coder.add "platform", platform.to_s + coder.add "original_platform", original_platform.to_s if platform.to_s != original_platform.to_s attributes = @@attributes.map(&:to_s) - %w[name version platform] attributes.each do |name| - coder.add name, instance_variable_get("@#{name}") + value = instance_variable_get("@#{name}") + coder.add name, value unless value.nil? end end - def eql? other # :nodoc: + def eql?(other) # :nodoc: self.class === other && same_attributes?(other) end @@ -1906,40 +1819,34 @@ class Gem::Specification < Gem::BasicSpecification # Singular accessor for #executables def executable - val = executables and val.first + (val = executables) && val.first end ## # Singular accessor for #executables - def executable=o + def executable=(o) self.executables = [o] end ## - # Sets executables to +value+, ensuring it is an array. Don't - # use this, push onto the array instead. + # Sets executables to +value+, ensuring it is an array. - def executables= value - # TODO: warn about setting instead of pushing + def executables=(value) @executables = Array(value) end ## - # Sets extensions to +extensions+, ensuring it is an array. Don't - # use this, push onto the array instead. + # Sets extensions to +extensions+, ensuring it is an array. - def extensions= extensions - # TODO: warn about setting instead of pushing + def extensions=(extensions) @extensions = Array extensions end ## - # Sets extra_rdoc_files to +files+, ensuring it is an array. Don't - # use this, push onto the array instead. + # Sets extra_rdoc_files to +files+, ensuring it is an array. - def extra_rdoc_files= files - # TODO: warn about setting instead of pushing + def extra_rdoc_files=(files) @extra_rdoc_files = Array files end @@ -1955,14 +1862,14 @@ class Gem::Specification < Gem::BasicSpecification ## # Sets files to +files+, ensuring it is an array. - def files= files + def files=(files) @files = Array files end ## # Finds all gems that satisfy +dep+ - def find_all_satisfiers dep + def find_all_satisfiers(dep) Gem::Specification.each do |spec| yield spec if spec.satisfies_requirement? dep end @@ -1982,68 +1889,41 @@ class Gem::Specification < Gem::BasicSpecification spec end - def full_name - @full_name ||= super - end - ## - # Work around bundler removing my methods + # Work around old bundler versions removing my methods + # Can be removed once RubyGems can no longer install Bundler 2.5 def gem_dir # :nodoc: super end def gems_dir - # TODO: this logic seems terribly broken, but tests fail if just base_dir - @gems_dir ||= File.join(loaded_from && base_dir || Gem.dir, "gems") - end - - ## - # Deprecated and ignored, defaults to true. - # - # Formerly used to indicate this gem was RDoc-capable. - - def has_rdoc # :nodoc: - true + @gems_dir ||= File.join(base_dir, "gems") end - deprecate :has_rdoc, :none, 2018, 12 - - ## - # Deprecated and ignored. - # - # Formerly used to indicate this gem was RDoc-capable. - - def has_rdoc= ignored # :nodoc: - @has_rdoc = true - end - deprecate :has_rdoc=, :none, 2018, 12 - - alias :has_rdoc? :has_rdoc # :nodoc: - deprecate :has_rdoc?, :none, 2018, 12 ## # True if this gem has files in test_files def has_unit_tests? # :nodoc: - not test_files.empty? + !test_files.empty? end # :stopdoc: - alias has_test_suite? has_unit_tests? + alias_method :has_test_suite?, :has_unit_tests? # :startdoc: def hash # :nodoc: name.hash ^ version.hash end - def init_with coder # :nodoc: + def init_with(coder) # :nodoc: @installed_by_version ||= nil yaml_initialize coder.tag, coder.map end + eval <<-RUBY, binding, __FILE__, __LINE__ + 1 + # frozen_string_literal: true - - eval <<-RB, binding, __FILE__, __LINE__ + 1 def set_nil_attributes_to_nil #{@@nil_attributes.map {|key| "@#{key} = nil" }.join "; "} end @@ -2053,14 +1933,14 @@ class Gem::Specification < Gem::BasicSpecification #{@@non_nil_attributes.map {|key| "@#{key} = #{INITIALIZE_CODE_FOR_DEFAULTS[key]}" }.join ";"} end private :set_not_nil_attributes_to_default_values - RB + RUBY ## # Specification constructor. Assigns the default values to the attributes # and yields itself for further initialization. Optionally takes +name+ and # +version+. - def initialize name = nil, version = nil + def initialize(name = nil, version = nil) super() @gems_dir = nil @base_dir = nil @@ -2078,20 +1958,25 @@ class Gem::Specification < Gem::BasicSpecification self.name = name if name self.version = version if version + if (platform = Gem.platforms.last) && platform != Gem::Platform::RUBY && platform != Gem::Platform.local + self.platform = platform + end + yield self if block_given? end ## - # Duplicates array_attributes from +other_spec+ so state isn't shared. + # Duplicates Array and Gem::Requirement attributes from +other_spec+ so state isn't shared. + # - def initialize_copy other_spec + def initialize_copy(other_spec) self.class.array_attributes.each do |name| name = :"@#{name}" next unless other_spec.instance_variable_defined? name begin val = other_spec.instance_variable_get(name) - if val then + if val instance_variable_set name, val.dup elsif Gem.configuration.really_verbose warn "WARNING: #{full_name} has an invalid nil value for #{name}" @@ -2104,28 +1989,20 @@ class Gem::Specification < Gem::BasicSpecification raise e end end + + @required_ruby_version = other_spec.required_ruby_version.dup + @required_rubygems_version = other_spec.required_rubygems_version.dup end def base_dir return Gem.dir unless loaded_from - @base_dir ||= if default_gem? then - File.dirname File.dirname File.dirname loaded_from - else - File.dirname File.dirname loaded_from - end - end - - ## - # Expire memoized instance variables that can incorrectly generate, replace - # or miss files due changes in certain attributes used to compute them. - - def invalidate_memoized_attributes - @full_name = nil - @cache_file = nil + @base_dir ||= if default_gem? + File.dirname File.dirname File.dirname loaded_from + else + File.dirname File.dirname loaded_from + end end - private :invalidate_memoized_attributes - def inspect # :nodoc: if $DEBUG super @@ -2164,8 +2041,6 @@ class Gem::Specification < Gem::BasicSpecification def internal_init # :nodoc: super @bin_dir = nil - @cache_dir = nil - @cache_file = nil @doc_dir = nil @ri_dir = nil @spec_dir = nil @@ -2173,18 +2048,17 @@ class Gem::Specification < Gem::BasicSpecification end ## - # Sets the rubygems_version to the current RubyGems version. - - def mark_version - @rubygems_version = Gem::VERSION - end - - ## + # Track removed method calls to warn about during build time. # Warn about unknown attributes while loading a spec. def method_missing(sym, *a, &b) # :nodoc: - if @specification_version > CURRENT_SPECIFICATION_VERSION and - sym.to_s =~ /=$/ then + if REMOVED_METHODS.include?(sym) + removed_method_calls << sym + return + end + + if @specification_version > CURRENT_SPECIFICATION_VERSION && + sym.to_s.end_with?("=") warn "ignoring #{sym} loading #{full_name}" if $DEBUG else super @@ -2196,9 +2070,9 @@ class Gem::Specification < Gem::BasicSpecification # probably want to build_extensions def missing_extensions? - return false if default_gem? + return false if RUBY_ENGINE == "jruby" return false if extensions.empty? - return false if installed_by_version < Gem::Version.new('2.2.0.preview.2') + return false if default_gem? return false if File.exist? gem_build_complete_path true @@ -2211,17 +2085,17 @@ class Gem::Specification < Gem::BasicSpecification # file list. def normalize - if defined?(@extra_rdoc_files) and @extra_rdoc_files then + if defined?(@extra_rdoc_files) && @extra_rdoc_files @extra_rdoc_files.uniq! @files ||= [] @files.concat(@extra_rdoc_files) end - @files = @files.uniq if @files - @extensions = @extensions.uniq if @extensions - @test_files = @test_files.uniq if @test_files - @executables = @executables.uniq if @executables - @extra_rdoc_files = @extra_rdoc_files.uniq if @extra_rdoc_files + @files = @files.uniq.sort if @files + @extensions = @extensions.uniq.sort if @extensions + @test_files = @test_files.uniq.sort if @test_files + @executables = @executables.uniq.sort if @executables + @extra_rdoc_files = @extra_rdoc_files.uniq.sort if @extra_rdoc_files end ## @@ -2236,7 +2110,7 @@ class Gem::Specification < Gem::BasicSpecification # platform. For use with legacy gems. def original_name # :nodoc: - if platform == Gem::Platform::RUBY or platform.nil? then + if platform == Gem::Platform::RUBY || platform.nil? "#{@name}-#{@version}" else "#{@name}-#{@version}-#{@original_platform}" @@ -2254,11 +2128,11 @@ class Gem::Specification < Gem::BasicSpecification # The platform this gem runs on. See Gem::Platform for details. def platform - @new_platform ||= Gem::Platform::RUBY + @new_platform ||= Gem::Platform::RUBY # rubocop:disable Naming/MemoizedInstanceVariableName end def pretty_print(q) # :nodoc: - q.group 2, 'Gem::Specification.new do |s|', 'end' do + q.group 2, "Gem::Specification.new do |s|", "end" do q.breakable attributes = @@attributes - [:name, :version] @@ -2267,22 +2141,22 @@ class Gem::Specification < Gem::BasicSpecification attributes.unshift :name attributes.each do |attr_name| - current_value = self.send attr_name - if current_value != default_value(attr_name) or - self.class.required_attribute? attr_name then + current_value = send attr_name + current_value = current_value.sort if [:files, :test_files].include? attr_name + next unless current_value != default_value(attr_name) || + self.class.required_attribute?(attr_name) - q.text "s.#{attr_name} = " + q.text "s.#{attr_name} = " - if attr_name == :date then - current_value = current_value.utc + if attr_name == :date + current_value = current_value.utc - q.text "Time.utc(#{current_value.year}, #{current_value.month}, #{current_value.day})" - else - q.pp current_value - end - - q.breakable + q.text "Time.utc(#{current_value.year}, #{current_value.month}, #{current_value.day})" + else + q.pp current_value end + + q.breakable end end end @@ -2291,8 +2165,8 @@ class Gem::Specification < Gem::BasicSpecification # Raise an exception if the version of this spec conflicts with the one # that is already loaded (+other+) - def check_version_conflict other # :nodoc: - return if self.version == other.version + def check_version_conflict(other) # :nodoc: + return if version == other.version # This gem is already loaded. If the currently loaded gem is not in the # list of candidate gems, then we have a version conflict. @@ -2300,8 +2174,7 @@ class Gem::Specification < Gem::BasicSpecification msg = "can't activate #{full_name}, already activated #{other.full_name}" e = Gem::LoadError.new msg - e.name = self.name - # TODO: e.requirement = dep.requirement + e.name = name raise e end @@ -2312,44 +2185,43 @@ class Gem::Specification < Gem::BasicSpecification # Check the spec for possible conflicts and freak out if there are any. def raise_if_conflicts # :nodoc: - if has_conflicts? then + if has_conflicts? raise Gem::ConflictError.new self, conflicts end end ## - # Sets rdoc_options to +value+, ensuring it is an array. Don't - # use this, push onto the array instead. + # Sets rdoc_options to +value+, ensuring it is a flat array of strings. + # Handles malformed gemspecs where rdoc_options may be a Hash or contain Hashes. - def rdoc_options= options - # TODO: warn about setting instead of pushing - @rdoc_options = Array options + def rdoc_options=(options) + @rdoc_options = Array(options).flat_map do |opt| + opt.is_a?(Hash) ? opt.to_a.flatten.map(&:to_s) : opt + end end ## # Singular accessor for #require_paths def require_path - val = require_paths and val.first + (val = require_paths) && val.first end ## # Singular accessor for #require_paths - def require_path= path + def require_path=(path) self.require_paths = Array(path) end ## - # Set requirements to +req+, ensuring it is an array. Don't - # use this, push onto the array instead. + # Set requirements to +req+, ensuring it is an array. - def requirements= req - # TODO: warn about setting instead of pushing + def requirements=(req) @requirements = Array req end - def respond_to_missing? m, include_private = false # :nodoc: + def respond_to_missing?(m, include_private = false) # :nodoc: false end @@ -2357,7 +2229,7 @@ class Gem::Specification < Gem::BasicSpecification # Returns the full path to this spec's ri directory. def ri_dir - @ri_dir ||= File.join base_dir, 'ri', full_name + @ri_dir ||= File.join base_dir, "ri", full_name end ## @@ -2366,18 +2238,18 @@ class Gem::Specification < Gem::BasicSpecification def ruby_code(obj) case obj - when String then obj.dump + ".freeze" - when Array then '[' + obj.map { |x| ruby_code x }.join(", ") + ']' - when Hash then - seg = obj.keys.sort.map { |k| "#{k.to_s.dump} => #{obj[k].to_s.dump}" } - "{ #{seg.join(', ')} }" - when Gem::Version then obj.to_s.dump - when DateLike then obj.strftime('%Y-%m-%d').dump - when Time then obj.strftime('%Y-%m-%d').dump - 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 + when String then obj.dump + ".freeze" + when Array then "[" + obj.map {|x| ruby_code x }.join(", ") + "]" + when Hash then + seg = obj.keys.sort.map {|k| "#{k.to_s.dump} => #{obj[k].to_s.dump}" } + "{ #{seg.join(", ")} }" + when Gem::Version then ruby_code(obj.to_s) + when DateLike then obj.strftime("%Y-%m-%d").dump + when Time then obj.strftime("%Y-%m-%d").dump + when Numeric then obj.inspect + when true, false, nil then obj.inspect + when Gem::Platform then "Gem::Platform.new(#{ruby_code obj.to_a})" + when Gem::Requirement then list = obj.as_list "Gem::Requirement.new(#{ruby_code(list.size == 1 ? obj.to_s : list)})" else raise Gem::Exception, "ruby_code case not handled: #{obj.class}" @@ -2396,8 +2268,8 @@ class Gem::Specification < Gem::BasicSpecification ## # True if this gem has the same attributes as +other+. - def same_attributes? spec - @@attributes.all? { |name, default| self.send(name) == spec.send(name) } + def same_attributes?(spec) + @@attributes.all? {|name, _default| send(name) == spec.send(name) } end private :same_attributes? @@ -2405,8 +2277,8 @@ class Gem::Specification < Gem::BasicSpecification ## # Checks if this specification meets the requirement of +dependency+. - def satisfies_requirement? dependency - return @name == dependency.name && + def satisfies_requirement?(dependency) + @name == dependency.name && dependency.requirement.satisfied_by?(@version) end @@ -2414,7 +2286,7 @@ class Gem::Specification < Gem::BasicSpecification # Returns an object you can use to sort specifications in #sort_by. def sort_obj - [@name, @version, @new_platform == Gem::Platform::RUBY ? -1 : 1] + [@name, @version, Gem::Platform.sort_priority(@new_platform)] end ## @@ -2452,7 +2324,7 @@ class Gem::Specification < Gem::BasicSpecification ## # A short summary of this gem's description. - def summary= str + def summary=(str) @summary = str.to_s.strip. gsub(/(\w-)\n[ \t]*(\w)/, '\1\2').gsub(/\n[ \t]*/, " ") # so. weird. end @@ -2461,13 +2333,13 @@ class Gem::Specification < Gem::BasicSpecification # Singular accessor for #test_files def test_file # :nodoc: - val = test_files and val.first + (val = test_files) && val.first end ## # Singular mutator for #test_files - def test_file= file # :nodoc: + def test_file=(file) # :nodoc: self.test_files = [file] end @@ -2479,11 +2351,11 @@ class Gem::Specification < Gem::BasicSpecification # 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 + if defined? @test_suite_file @test_files = [@test_suite_file].flatten @test_suite_file = nil end - if defined?(@test_files) and @test_files then + if defined?(@test_files) && @test_files @test_files else @test_files = [] @@ -2496,7 +2368,6 @@ class Gem::Specification < Gem::BasicSpecification # still have their default values are omitted. def to_ruby - mark_version result = [] result << "# -*- encoding: utf-8 -*-" result << "#{Gem::StubSpecification::PREFIX}#{name} #{version} #{platform} #{raw_require_paths.join("\0")}" @@ -2507,13 +2378,13 @@ class Gem::Specification < Gem::BasicSpecification result << " s.name = #{ruby_code name}" result << " s.version = #{ruby_code version}" - unless platform.nil? or platform == Gem::Platform::RUBY then + unless platform.nil? || platform == Gem::Platform::RUBY 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=" - if metadata and !metadata.empty? + if metadata && !metadata.empty? result << " s.metadata = #{ruby_code metadata} if s.respond_to? :metadata=" end result << " s.require_paths = #{ruby_code raw_require_paths}" @@ -2526,54 +2397,36 @@ class Gem::Specification < Gem::BasicSpecification :required_rubygems_version, :specification_version, :version, - :has_rdoc, - :default_executable, - :metadata + :metadata, + :signing_key, ] @@attributes.each do |attr_name| next if handled.include? attr_name - current_value = self.send(attr_name) - if current_value != default_value(attr_name) or - self.class.required_attribute? attr_name then + current_value = send(attr_name) + if current_value != default_value(attr_name) || self.class.required_attribute?(attr_name) result << " s.#{attr_name} = #{ruby_code current_value}" end end - if @installed_by_version then + if String === signing_key + result << " s.signing_key = #{ruby_code signing_key}" + end + + if @installed_by_version result << nil - result << " s.installed_by_version = \"#{Gem::VERSION}\" if s.respond_to? :installed_by_version" + result << " s.installed_by_version = #{ruby_code Gem::VERSION}" end - unless dependencies.empty? then + unless dependencies.empty? result << nil - result << " if s.respond_to? :specification_version then" - result << " s.specification_version = #{specification_version}" + result << " s.specification_version = #{specification_version}" result << nil - result << " if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then" - dependencies.each do |dep| - req = dep.requirements_list.inspect dep.instance_variable_set :@type, :runtime if dep.type.nil? # HACK - result << " s.add_#{dep.type}_dependency(%q<#{dep.name}>.freeze, #{req})" + result << " s.add_#{dep.type}_dependency(%q<#{dep.name}>.freeze, #{ruby_code dep.requirements_list})" end - - result << " else" - - dependencies.each do |dep| - version_reqs_param = dep.requirements_list.inspect - result << " s.add_dependency(%q<#{dep.name}>.freeze, #{version_reqs_param})" - end - - result << ' end' - - result << " else" - dependencies.each do |dep| - version_reqs_param = dep.requirements_list.inspect - result << " s.add_dependency(%q<#{dep.name}>.freeze, #{version_reqs_param})" - end - result << " end" end result << "end" @@ -2604,36 +2457,42 @@ class Gem::Specification < Gem::BasicSpecification end def to_yaml(opts = {}) # :nodoc: - # Because the user can switch the YAML engine behind our - # back, we have to check again here to make sure that our - # psych code was properly loaded, and load it if not. - unless Gem.const_defined?(:NoAliasYAMLTree) - require 'rubygems/psych_tree' - end + Gem.load_yaml + + if Gem.use_psych? + # Because the user can switch the YAML engine behind our + # back, we have to check again here to make sure that our + # psych code was properly loaded, and load it if not. + unless Gem.const_defined?(:NoAliasYAMLTree) + require_relative "psych_tree" + end - builder = Gem::NoAliasYAMLTree.create - builder << self - ast = builder.tree + builder = Gem::NoAliasYAMLTree.create + builder << self + ast = builder.tree - io = StringIO.new - io.set_encoding Encoding::UTF_8 + require "stringio" + io = StringIO.new + io.set_encoding Encoding::UTF_8 - Psych::Visitors::Emitter.new(io).accept(ast) + Psych::Visitors::Emitter.new(io).accept(ast) - io.string.gsub(/ !!null \n/, " \n") + io.string.gsub(/ !!null \n/, " \n") + else + Gem::YAMLSerializer.dump(self) + end end ## # Recursively walk dependencies of this spec, executing the +block+ for each # hop. - def traverse trail = [], visited = {}, &block + def traverse(trail = [], visited = {}, &block) trail.push(self) begin - dependencies.each do |dep| - next unless dep.runtime? - dep.to_specs.each do |dep_spec| - next if visited.has_key?(dep_spec) + runtime_dependencies.each do |dep| + dep.matching_specs(true).each do |dep_spec| + next if visited.key?(dep_spec) visited[dep_spec] = true trail.push(dep_spec) begin @@ -2641,11 +2500,10 @@ class Gem::Specification < Gem::BasicSpecification ensure trail.pop end - unless result == :next - spec_name = dep_spec.name - dep_spec.traverse(trail, visited, &block) unless - trail.any? { |s| s.name == spec_name } - end + next if result == :next + spec_name = dep_spec.name + dep_spec.traverse(trail, visited, &block) unless + trail.any? {|s| s.name == spec_name } end end ensure @@ -2660,9 +2518,7 @@ class Gem::Specification < Gem::BasicSpecification # Raises InvalidSpecificationException if the spec does not pass the # checks.. - def validate packaging = true, strict = false - require 'rubygems/user_interaction' - extend Gem::UserInteraction + def validate(packaging = true, strict = false) normalize validation_policy = Gem::SpecificationPolicy.new(self) @@ -2671,46 +2527,22 @@ class Gem::Specification < Gem::BasicSpecification end def keep_only_files_and_directories - @executables.delete_if { |x| File.directory?(File.join(@bindir, x)) } - @extensions.delete_if { |x| File.directory?(x) && !File.symlink?(x) } - @extra_rdoc_files.delete_if { |x| File.directory?(x) && !File.symlink?(x) } - @files.delete_if { |x| File.directory?(x) && !File.symlink?(x) } - @test_files.delete_if { |x| File.directory?(x) && !File.symlink?(x) } - end - - def validate_metadata - Gem::SpecificationPolicy.new(self).validate_metadata + @executables.delete_if {|x| File.directory?(File.join(@bindir, x)) } + @extensions.delete_if {|x| File.directory?(x) && !File.symlink?(x) } + @extra_rdoc_files.delete_if {|x| File.directory?(x) && !File.symlink?(x) } + @files.delete_if {|x| File.directory?(x) && !File.symlink?(x) } + @test_files.delete_if {|x| File.directory?(x) && !File.symlink?(x) } end - ## - # Checks that dependencies use requirements as we recommend. Warnings are - # issued when dependencies are open-ended or overly strict for semantic - # versioning. - def validate_dependencies - Gem::SpecificationPolicy.new(self).validate_dependencies - end - - ## - # Checks to see if the files to be packaged are world-readable. - def validate_permissions - Gem::SpecificationPolicy.new(self).validate_permissions + def validate_for_resolution + Gem::SpecificationPolicy.new(self).validate_for_resolution end ## - # Set the version to +version+, potentially also setting - # required_rubygems_version if +version+ indicates it is a - # prerelease. + # Set the version to +version+. - def version= version - @version = Gem::Version.create(version) - # skip to set required_ruby_version when pre-released rubygems. - # It caused to raise CircularDependencyError - if @version.prerelease? && @name.strip != "rubygems" - self.required_rubygems_version = '> 1.3.1' - end - invalidate_memoized_attributes - - return @version + def version=(version) + @version = version.nil? ? version : Gem::Version.create(version) end def stubbed? @@ -2722,14 +2554,17 @@ class Gem::Specification < Gem::BasicSpecification case ivar when "date" # Force Date to go through the extra coerce logic in date= - self.date = val.untaint + self.date = val + when "platform" + self.platform = val + when "rdoc_options" + self.rdoc_options = val + when "requirements" + self.requirements = val else - instance_variable_set "@#{ivar}", val.untaint + instance_variable_set "@#{ivar}", val end end - - @original_platform = @platform # for backwards compatibility - self.platform = Gem::Platform.new @platform end ## @@ -2741,24 +2576,29 @@ class Gem::Specification < Gem::BasicSpecification end nil_attributes.each do |attribute| - default = self.default_value attribute + default = default_value attribute value = case default when Time, Numeric, Symbol, true, false, nil then default else default.dup - end + end instance_variable_set "@#{attribute}", value end @installed_by_version ||= nil + + nil + end + + def flatten_require_paths # :nodoc: + return unless raw_require_paths.first.is_a?(Array) + + warn "#{name} #{version} includes a gemspec with `require_paths` set to an array of arrays. Newer versions of this gem might've already fixed this" + raw_require_paths.flatten! end def raw_require_paths # :nodoc: @require_paths end - end - -# DOC: What is this and why is it here, randomly, at the end of this file? -Gem.clear_paths |