rubygems-update 3.3.5 → 3.3.8

data/lib/rubygems/installer.rb

@@ -201,8 +201,8 @@ class Gem::Installer
   #
   # If +@force+ is set +filename+ is overwritten.
   #
-  # If +filename+ exists and is a RubyGems wrapper for different gem the user
-  # is consulted.
+  # If +filename+ exists and it is a RubyGems wrapper for a different gem, then
+  # the user is consulted.
   #
   # If +filename+ exists and +@bin_dir+ is Gem.default_bindir (/usr/local) the
   # user is consulted.
@@ -220,7 +220,17 @@ class Gem::Installer
     existing = nil
 
     File.open generated_bin, 'rb' do |io|
-      next unless io.gets =~ /^#!/ # shebang
+      line = io.gets
+      shebang = /^#!.*ruby/
+
+      if load_relative_enabled?
+        until line.nil? || line =~ shebang do
+          line = io.gets
+        end
+      end
+
+      next unless line =~ shebang
+
       io.gets # blankline
 
       # TODO detect a specially formatted comment instead of trying
@@ -585,7 +595,6 @@ class Gem::Installer
   #
 
   def shebang(bin_file_name)
-    ruby_name = RbConfig::CONFIG['ruby_install_name'] if @env_shebang
     path = File.join gem_dir, spec.bindir, bin_file_name
     first_line = File.open(path, "rb") {|file| file.gets } || ""
 
@@ -598,7 +607,7 @@ class Gem::Installer
 
     if which = Gem.configuration[:custom_shebang]
       # replace bin_file_name with "ruby" to avoid endless loops
-      which = which.gsub(/ #{bin_file_name}$/," #{RbConfig::CONFIG['ruby_install_name']}")
+      which = which.gsub(/ #{bin_file_name}$/," #{ruby_install_name}")
 
       which = which.gsub(/\$(\w+)/) do
         case $1
@@ -614,14 +623,12 @@ class Gem::Installer
       end
 
       "#!#{which}"
-    elsif not ruby_name
-      "#!#{Gem.ruby}#{opts}"
-    elsif opts
-      "#!/bin/sh\n'exec' #{ruby_name.dump} '-x' \"$0\" \"$@\"\n#{shebang}"
-    else
+    elsif @env_shebang
       # Create a plain shebang line.
       @env_path ||= ENV_PATHS.find {|env_path| File.executable? env_path }
-      "#!#{@env_path} #{ruby_name}"
+      "#!#{@env_path} #{ruby_install_name}"
+    else
+      "#{bash_prolog_script}#!#{Gem.ruby}#{opts}"
     end
   end
 
@@ -805,7 +812,6 @@ TEXT
   # return the stub script text used to launch the true Ruby script
 
   def windows_stub_script(bindir, bin_file_name)
-    rb_config = RbConfig::CONFIG
     rb_topdir = RbConfig::TOPDIR || File.dirname(rb_config["bindir"])
 
     # get ruby executable file name from RbConfig
@@ -973,4 +979,37 @@ TEXT
                       Gem::Command.build_args
                     end
   end
+
+  def rb_config
+    RbConfig::CONFIG
+  end
+
+  def ruby_install_name
+    rb_config["ruby_install_name"]
+  end
+
+  def load_relative_enabled?
+    rb_config["LIBRUBY_RELATIVE"] == 'yes'
+  end
+
+  def bash_prolog_script
+    if load_relative_enabled?
+      script = +<<~EOS
+        bindir="${0%/*}"
+      EOS
+
+      script << %Q(exec "$bindir/#{ruby_install_name}" "-x" "$0" "$@"\n)
+
+      <<~EOS
+        #!/bin/sh
+        # -*- ruby -*-
+        _=_\\
+        =begin
+        #{script.chomp}
+        =end
+      EOS
+    else
+      ""
+    end
+  end
 end

data/lib/rubygems/package.rb

@@ -146,12 +146,12 @@ class Gem::Package
 
   def self.new(gem, security_policy = nil)
     gem = if gem.is_a?(Gem::Package::Source)
-            gem
-          elsif gem.respond_to? :read
-            Gem::Package::IOSource.new gem
-          else
-            Gem::Package::FileSource.new gem
-          end
+      gem
+    elsif gem.respond_to? :read
+      Gem::Package::IOSource.new gem
+    else
+      Gem::Package::FileSource.new gem
+    end
 
     return super unless Gem::Package == self
     return super unless gem.present?
@@ -353,10 +353,10 @@ EOM
 
   def digest(entry) # :nodoc:
     algorithms = if @checksums
-                   @checksums.keys
-                 else
-                   [Gem::Security::DIGEST_NAME].compact
-                 end
+      @checksums.keys
+    else
+      [Gem::Security::DIGEST_NAME].compact
+    end
 
     algorithms.each do |algorithm|
       digester = Gem::Security.create_digest(algorithm)

data/lib/rubygems/platform.rb

@@ -78,9 +78,9 @@ class Gem::Platform
       cpu = arch.shift
 
       @cpu = case cpu
-             when /i\d86/ then 'x86'
-             else cpu
-             end
+      when /i\d86/ then 'x86'
+      else cpu
+      end
 
       if arch.length == 2 and arch.last =~ /^\d+(\.\d+)?$/ # for command-line
         @os, @version = arch
@@ -91,32 +91,32 @@ class Gem::Platform
       @cpu, os = nil, cpu if os.nil? # legacy jruby
 
       @os, @version = case os
-                      when /aix(\d+)?/ then             [ 'aix',       $1  ]
-                      when /cygwin/ then                [ 'cygwin',    nil ]
-                      when /darwin(\d+)?/ then          [ 'darwin',    $1  ]
-                      when /^macruby$/ then             [ 'macruby',   nil ]
-                      when /freebsd(\d+)?/ then         [ 'freebsd',   $1  ]
-                      when /hpux(\d+)?/ then            [ 'hpux',      $1  ]
-                      when /^java$/, /^jruby$/ then     [ 'java',      nil ]
-                      when /^java([\d.]*)/ then         [ 'java',      $1  ]
-                      when /^dalvik(\d+)?$/ then        [ 'dalvik',    $1  ]
-                      when /^dotnet$/ then              [ 'dotnet',    nil ]
-                      when /^dotnet([\d.]*)/ then       [ 'dotnet',    $1  ]
-                      when /linux-?((?!gnu)\w+)?/ then  [ 'linux',     $1  ]
-                      when /mingw32/ then               [ 'mingw32',   nil ]
-                      when /mingw-?(\w+)?/ then         [ 'mingw',     $1  ]
-                      when /(mswin\d+)(\_(\d+))?/ then
-                        os, version = $1, $3
-                        @cpu = 'x86' if @cpu.nil? and os =~ /32$/
-                        [os, version]
-                      when /netbsdelf/ then             [ 'netbsdelf', nil ]
-                      when /openbsd(\d+\.\d+)?/ then    [ 'openbsd',   $1  ]
-                      when /bitrig(\d+\.\d+)?/ then     [ 'bitrig',    $1  ]
-                      when /solaris(\d+\.\d+)?/ then    [ 'solaris',   $1  ]
-                      # test
-                      when /^(\w+_platform)(\d+)?/ then [ $1,          $2  ]
-                      else                              [ 'unknown',   nil ]
-                      end
+      when /aix(\d+)?/ then             [ 'aix',       $1  ]
+      when /cygwin/ then                [ 'cygwin',    nil ]
+      when /darwin(\d+)?/ then          [ 'darwin',    $1  ]
+      when /^macruby$/ then             [ 'macruby',   nil ]
+      when /freebsd(\d+)?/ then         [ 'freebsd',   $1  ]
+      when /hpux(\d+)?/ then            [ 'hpux',      $1  ]
+      when /^java$/, /^jruby$/ then     [ 'java',      nil ]
+      when /^java([\d.]*)/ then         [ 'java',      $1  ]
+      when /^dalvik(\d+)?$/ then        [ 'dalvik',    $1  ]
+      when /^dotnet$/ then              [ 'dotnet',    nil ]
+      when /^dotnet([\d.]*)/ then       [ 'dotnet',    $1  ]
+      when /linux-?((?!gnu)\w+)?/ then  [ 'linux',     $1  ]
+      when /mingw32/ then               [ 'mingw32',   nil ]
+      when /mingw-?(\w+)?/ then         [ 'mingw',     $1  ]
+      when /(mswin\d+)(\_(\d+))?/ then
+        os, version = $1, $3
+        @cpu = 'x86' if @cpu.nil? and os =~ /32$/
+        [os, version]
+      when /netbsdelf/ then             [ 'netbsdelf', nil ]
+      when /openbsd(\d+\.\d+)?/ then    [ 'openbsd',   $1  ]
+      when /bitrig(\d+\.\d+)?/ then     [ 'bitrig',    $1  ]
+      when /solaris(\d+\.\d+)?/ then    [ 'solaris',   $1  ]
+      # test
+      when /^(\w+_platform)(\d+)?/ then [ $1,          $2  ]
+      else                              [ 'unknown',   nil ]
+      end
     when Gem::Platform then
       @cpu = arch.cpu
       @os = arch.os
@@ -180,19 +180,19 @@ class Gem::Platform
     when String then
       # This data is from http://gems.rubyforge.org/gems/yaml on 19 Aug 2007
       other = case other
-              when /^i686-darwin(\d)/     then ['x86',       'darwin',  $1    ]
-              when /^i\d86-linux/         then ['x86',       'linux',   nil   ]
-              when 'java', 'jruby'        then [nil,         'java',    nil   ]
-              when /^dalvik(\d+)?$/       then [nil,         'dalvik',  $1    ]
-              when /dotnet(\-(\d+\.\d+))?/ then ['universal','dotnet',  $2    ]
-              when /mswin32(\_(\d+))?/    then ['x86',       'mswin32', $2    ]
-              when /mswin64(\_(\d+))?/    then ['x64',       'mswin64', $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    ]
-              else                             other
-              end
+      when /^i686-darwin(\d)/     then ['x86',       'darwin',  $1    ]
+      when /^i\d86-linux/         then ['x86',       'linux',   nil   ]
+      when 'java', 'jruby'        then [nil,         'java',    nil   ]
+      when /^dalvik(\d+)?$/       then [nil,         'dalvik',  $1    ]
+      when /dotnet(\-(\d+\.\d+))?/ then ['universal','dotnet',  $2    ]
+      when /mswin32(\_(\d+))?/    then ['x86',       'mswin32', $2    ]
+      when /mswin64(\_(\d+))?/    then ['x64',       'mswin64', $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    ]
+      else                             other
+      end
 
       other = Gem::Platform.new other
     else

data/lib/rubygems/query_utils.rb

@@ -54,14 +54,14 @@ module Gem::QueryUtils
   end
 
   def defaults_str # :nodoc:
-    "--local --name-matches // --no-details --versions --no-installed"
+    "--local --no-details --versions --no-installed"
   end
 
   def execute
-    gem_names = Array(options[:name])
-
-    if !args.empty?
-      gem_names = options[:exact] ? args.map{|arg| /\A#{Regexp.escape(arg)}\Z/ } : args.map{|arg| /#{arg}/i }
+    gem_names = if args.empty?
+      [options[:name]]
+    else
+      options[:exact] ? args.map{|arg| /\A#{Regexp.escape(arg)}\Z/ } : args.map{|arg| /#{arg}/i }
     end
 
     terminate_interaction(check_installed_gems(gem_names)) if check_installed_gems?
@@ -96,7 +96,7 @@ module Gem::QueryUtils
   end
 
   def gem_name?
-    !options[:name].source.empty?
+    !options[:name].nil?
   end
 
   def prerelease
@@ -129,12 +129,10 @@ module Gem::QueryUtils
     display_header("LOCAL")
 
     specs = Gem::Specification.find_all do |s|
-      s.name =~ name and req =~ s.version
-    end
+      name_matches = name ? s.name =~ name : true
+      version_matches = show_prereleases? || !s.version.prerelease?
 
-    dep = Gem::Deprecate.skip_during { Gem::Dependency.new name, req }
-    specs.select! do |s|
-      dep.match?(s.name, s.version, show_prereleases?)
+      name_matches and version_matches
     end
 
     spec_tuples = specs.map do |spec|
@@ -149,13 +147,13 @@ module Gem::QueryUtils
 
     fetcher = Gem::SpecFetcher.fetcher
 
-    spec_tuples = if name.respond_to?(:source) && name.source.empty?
-                    fetcher.detect(specs_type) { true }
-                  else
-                    fetcher.detect(specs_type) do |name_tuple|
-                      name === name_tuple.name
-                    end
-                  end
+    spec_tuples = if name.nil?
+      fetcher.detect(specs_type) { true }
+    else
+      fetcher.detect(specs_type) do |name_tuple|
+        name === name_tuple.name
+      end
+    end
 
     output_query_results(spec_tuples)
   end

data/lib/rubygems/remote_fetcher.rb

@@ -172,10 +172,10 @@ class Gem::RemoteFetcher
     when nil then # TODO test for local overriding cache
       source_path = if Gem.win_platform? && source_uri.scheme &&
                        !source_uri.path.include?(':')
-                      "#{source_uri.scheme}:#{source_uri.path}"
-                    else
-                      source_uri.path
-                    end
+        "#{source_uri.scheme}:#{source_uri.path}"
+      else
+        source_uri.path
+      end
 
       source_path = Gem::UriFormatter.new(source_path).unescape
 

data/lib/rubygems/request_set/lockfile.rb

@@ -56,10 +56,10 @@ class Gem::RequestSet::Lockfile
 
       deps[name] = if [Gem::Resolver::VendorSpecification,
                        Gem::Resolver::GitSpecification].include? spec.class
-                     Gem::Requirement.source_set
-                   else
-                     requirement
-                   end
+        Gem::Requirement.source_set
+      else
+        requirement
+      end
     end
 
     deps

data/lib/rubygems/source.rb

@@ -81,12 +81,12 @@ class Gem::Source
     return Gem::Resolver::IndexSet.new self if 'file' == uri.scheme
 
     fetch_uri = if uri.host == "rubygems.org"
-                  index_uri = uri.dup
-                  index_uri.host = "index.rubygems.org"
-                  index_uri
-                else
-                  uri
-                end
+      index_uri = uri.dup
+      index_uri.host = "index.rubygems.org"
+      index_uri
+    else
+      uri
+    end
 
     bundler_api_uri = enforce_trailing_slash(fetch_uri)
 

data/lib/rubygems/source_list.rb

@@ -51,13 +51,13 @@ class Gem::SourceList
     require "uri"
 
     src = case obj
-          when URI
-            Gem::Source.new(obj)
-          when Gem::Source
-            obj
-          else
-            Gem::Source.new(URI.parse(obj))
-          end
+    when URI
+      Gem::Source.new(obj)
+    when Gem::Source
+      obj
+    else
+      Gem::Source.new(URI.parse(obj))
+    end
 
     @sources << src unless @sources.include?(src)
     src

data/lib/rubygems/spec_fetcher.rb

@@ -191,10 +191,10 @@ class Gem::SpecFetcher
     end
 
     matches = if matches.empty? && type != :prerelease
-                suggest_gems_from_name gem_name, :prerelease
-              else
-                matches.uniq.sort_by {|name, dist| dist }
-              end
+      suggest_gems_from_name gem_name, :prerelease
+    else
+      matches.uniq.sort_by {|name, dist| dist }
+    end
 
     matches.map {|name, dist| name }.uniq.first(num_results)
   end
@@ -216,27 +216,27 @@ class Gem::SpecFetcher
     @sources.each_source do |source|
       begin
         names = case type
-                when :latest
-                  tuples_for source, :latest
-                when :released
-                  tuples_for source, :released
-                when :complete
-                  names =
-                    tuples_for(source, :prerelease, true) +
-                    tuples_for(source, :released)
-
-                  names.sort
-                when :abs_latest
-                  names =
-                    tuples_for(source, :prerelease, true) +
-                    tuples_for(source, :latest)
-
-                  names.sort
-                when :prerelease
-                  tuples_for(source, :prerelease)
-                else
-                  raise Gem::Exception, "Unknown type - :#{type}"
-                end
+        when :latest
+          tuples_for source, :latest
+        when :released
+          tuples_for source, :released
+        when :complete
+          names =
+            tuples_for(source, :prerelease, true) +
+            tuples_for(source, :released)
+
+          names.sort
+        when :abs_latest
+          names =
+            tuples_for(source, :prerelease, true) +
+            tuples_for(source, :latest)
+
+          names.sort
+        when :prerelease
+          tuples_for(source, :prerelease)
+        else
+          raise Gem::Exception, "Unknown type - :#{type}"
+        end
       rescue Gem::RemoteFetcher::FetchError => e
         errors << Gem::SourceFetchProblem.new(source, e)
       else

data/lib/rubygems/specification.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
-# -*- coding: utf-8 -*-
+#
 #--
 # Copyright 2006 by Chad Fowler, Rich Kilmer, Jim Weirich and others.
 # All rights reserved.
@@ -162,15 +162,15 @@ class Gem::Specification < Gem::BasicSpecification
 
   @@default_value.each do |k,v|
     INITIALIZE_CODE_FOR_DEFAULTS[k] = case v
-                                      when [], {}, true, false, nil, Numeric, Symbol
-                                        v.inspect
-                                      when String
-                                        v.dump
-                                      when Numeric
-                                        "default_value(:#{k})"
-                                      else
-                                        "default_value(:#{k}).dup"
-                                      end
+    when [], {}, true, false, nil, Numeric, Symbol
+      v.inspect
+    when String
+      v.dump
+    when Numeric
+      "default_value(:#{k})"
+    else
+      "default_value(:#{k}).dup"
+    end
   end
 
   @@attributes = @@default_value.keys.sort_by {|s| s.to_s }
@@ -1115,7 +1115,7 @@ class Gem::Specification < Gem::BasicSpecification
     file = file.dup.tap(&Gem::UNTAINT)
     return unless File.file?(file)
 
-    code = Gem.open_with_flock(file, 'r:UTF-8:-', &:read)
+    code = Gem.open_file(file, 'r:UTF-8:-', &:read)
 
     code.tap(&Gem::UNTAINT)
 
@@ -1268,12 +1268,12 @@ class Gem::Specification < Gem::BasicSpecification
     current_version = CURRENT_SPECIFICATION_VERSION
 
     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
+      spec.instance_variable_set :@specification_version,
+                                 current_version
+      MARSHAL_FIELDS[current_version]
+    else
+      MARSHAL_FIELDS[spec.specification_version]
+    end
 
     if array.size < field_count
       raise TypeError, "invalid Gem::Specification format #{array.inspect}"
@@ -1473,10 +1473,10 @@ class Gem::Specification < Gem::BasicSpecification
 
   def add_dependency_with_type(dependency, type, requirements)
     requirements = if requirements.empty?
-                     Gem::Requirement.default
-                   else
-                     requirements.flatten
-                   end
+      Gem::Requirement.default
+    else
+      requirements.flatten
+    end
 
     unless dependency.respond_to?(:name) &&
            dependency.respond_to?(:requirement)
@@ -1684,18 +1684,18 @@ class Gem::Specification < Gem::BasicSpecification
     # This is the cleanest, most-readable, faster-than-using-Date
     # way to do it.
     @date = case date
-            when String then
-              if DateTimeFormat =~ date
-                Time.utc($1.to_i, $2.to_i, $3.to_i)
-              else
-                raise(Gem::InvalidSpecificationException,
-                      "invalid date format in specification: #{date.inspect}")
-              end
-            when Time, DateLike then
-              Time.utc(date.year, date.month, date.day)
-            else
-              TODAY
-            end
+    when String then
+      if DateTimeFormat =~ date
+        Time.utc($1.to_i, $2.to_i, $3.to_i)
+      else
+        raise(Gem::InvalidSpecificationException,
+              "invalid date format in specification: #{date.inspect}")
+      end
+    when Time, DateLike then
+      Time.utc(date.year, date.month, date.day)
+    else
+      TODAY
+    end
   end
 
   ##
@@ -1801,13 +1801,13 @@ class Gem::Specification < Gem::BasicSpecification
     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
+    when nil, '' then
+      'ruby'
+    when String then
+      @original_platform
+    else
+      @original_platform.to_s
+    end
     coder.add 'platform', platform
 
     attributes = @@attributes.map(&:to_s) - %w[name version platform]
@@ -2024,10 +2024,10 @@ class Gem::Specification < Gem::BasicSpecification
   def base_dir
     return Gem.dir unless loaded_from
     @base_dir ||= if default_gem?
-                    File.dirname File.dirname File.dirname loaded_from
-                  else
-                    File.dirname File.dirname loaded_from
-                  end
+      File.dirname File.dirname File.dirname loaded_from
+    else
+      File.dirname File.dirname loaded_from
+    end
   end
 
   ##
@@ -2654,9 +2654,9 @@ class Gem::Specification < Gem::BasicSpecification
       default = self.default_value attribute
 
       value = case default
-              when Time, Numeric, Symbol, true, false, nil then default
-              else default.dup
-              end
+      when Time, Numeric, Symbol, true, false, nil then default
+      else default.dup
+      end
 
       instance_variable_set "@#{attribute}", value
     end

data/lib/rubygems/specification_policy.rb

@@ -199,17 +199,17 @@ duplicate dependency on #{dep}, (#{prev.requirement}) use:
         base = segments.first 2
 
         recommendation = if (op == '>' || op == '>=') && segments == [0]
-                           "  use a bounded requirement, such as '~> x.y'"
-                         else
-                           bugfix = if op == '>'
-                                      ", '> #{dep_version}'"
-                                    elsif op == '>=' and base != segments
-                                      ", '>= #{dep_version}'"
-                                    end
-
-                           "  if #{dep.name} is semantically versioned, use:\n" \
-                           "    add_#{dep.type}_dependency '#{dep.name}', '~> #{base.join '.'}'#{bugfix}"
-                         end
+          "  use a bounded requirement, such as '~> x.y'"
+        else
+          bugfix = if op == '>'
+            ", '> #{dep_version}'"
+          elsif op == '>=' and base != segments
+            ", '>= #{dep_version}'"
+          end
+
+          "  if #{dep.name} is semantically versioned, use:\n" \
+          "    add_#{dep.type}_dependency '#{dep.name}', '~> #{base.join '.'}'#{bugfix}"
+        end
 
         warning_messages << ["open-ended dependency on #{dep} is not recommended", recommendation].join("\n") + "\n"
       end
@@ -332,11 +332,11 @@ duplicate dependency on #{dep}, (#{prev.requirement}) use:
   def validate_array_attribute(field)
     val = @specification.send(field)
     klass = case field
-            when :dependencies then
-              Gem::Dependency
-            else
-              String
-            end
+    when :dependencies then
+      Gem::Dependency
+    else
+      String
+    end
 
     unless Array === val and val.all? {|x| x.kind_of?(klass) }
       error "#{field} must be an Array of #{klass}"