rubygems-update 2.6.1 → 3.5.0

data/lib/rubygems/request_set/lockfile/parser.rb

@@ -1,9 +1,10 @@
 # frozen_string_literal: true
+
 class Gem::RequestSet::Lockfile::Parser
   ###
   # Parses lockfiles
 
-  def initialize tokenizer, set, platforms, filename = nil
+  def initialize(tokenizer, set, platforms, filename = nil)
     @tokens    = tokenizer
     @filename  = filename
     @set       = set
@@ -19,18 +20,18 @@ class Gem::RequestSet::Lockfile::Parser
         @tokens.skip :newline
 
         case token.value
-        when 'DEPENDENCIES' then
+        when "DEPENDENCIES" then
           parse_DEPENDENCIES
-        when 'GIT' then
+        when "GIT" then
           parse_GIT
-        when 'GEM' then
+        when "GEM" then
           parse_GEM
-        when 'PATH' then
+        when "PATH" then
           parse_PATH
-        when 'PLATFORMS' then
+        when "PLATFORMS" then
           parse_PLATFORMS
         else
-          token = get until @tokens.empty? or peek.first == :section
+          token = get until @tokens.empty? || peek.first == :section
         end
       else
         raise "BUG: unhandled token #{token.type} (#{token.value.inspect}) at line #{token.line} column #{token.column}"
@@ -41,23 +42,23 @@ class Gem::RequestSet::Lockfile::Parser
   ##
   # Gets the next token for a Lockfile
 
-  def get expected_types = nil, expected_value = nil # :nodoc:
+  def get(expected_types = nil, expected_value = nil) # :nodoc:
     token = @tokens.shift
 
-    if expected_types and not Array(expected_types).include? token.type then
+    if expected_types && !Array(expected_types).include?(token.type)
       unget token
 
-      message = "unexpected token [#{token.type.inspect}, #{token.value.inspect}], " +
+      message = "unexpected token [#{token.type.inspect}, #{token.value.inspect}], " \
                 "expected #{expected_types.inspect}"
 
       raise Gem::RequestSet::Lockfile::ParseError.new message, token.column, token.line, @filename
     end
 
-    if expected_value and expected_value != token.value then
+    if expected_value && expected_value != token.value
       unget token
 
-      message = "unexpected token [#{token.type.inspect}, #{token.value.inspect}], " +
-                "expected [#{expected_types.inspect}, " +
+      message = "unexpected token [#{token.type.inspect}, #{token.value.inspect}], " \
+                "expected [#{expected_types.inspect}, " \
                 "#{expected_value.inspect}]"
 
       raise Gem::RequestSet::Lockfile::ParseError.new message, token.column, token.line, @filename
@@ -67,7 +68,7 @@ class Gem::RequestSet::Lockfile::Parser
   end
 
   def parse_DEPENDENCIES # :nodoc:
-    while not @tokens.empty? and :text == peek.type do
+    while !@tokens.empty? && peek.type == :text do
       token = get :text
 
       requirements = []
@@ -93,7 +94,7 @@ class Gem::RequestSet::Lockfile::Parser
 
         get :r_paren
 
-        if peek[0] == :bang then
+        if peek[0] == :bang
           requirements.clear
           requirements << pinned_requirement(token.value)
 
@@ -110,8 +111,8 @@ class Gem::RequestSet::Lockfile::Parser
   def parse_GEM # :nodoc:
     sources = []
 
-    while [:entry, 'remote'] == peek.first(2) do
-      get :entry, 'remote'
+    while peek.first(2) == [:entry, "remote"] do
+      get :entry, "remote"
       data = get(:text).value
       skip :newline
 
@@ -120,14 +121,14 @@ class Gem::RequestSet::Lockfile::Parser
 
     sources << Gem::Source.new(Gem::DEFAULT_HOST) if sources.empty?
 
-    get :entry, 'specs'
+    get :entry, "specs"
 
     skip :newline
 
     set = Gem::Resolver::LockSet.new sources
     last_specs = nil
 
-    while not @tokens.empty? and :text == peek.type do
+    while !@tokens.empty? && peek.type == :text do
       token = get :text
       name = token.value
       column = token.column
@@ -144,8 +145,8 @@ class Gem::RequestSet::Lockfile::Parser
         type = token.type
         data = token.value
 
-        if type == :text and column == 4 then
-          version, platform = data.split '-', 2
+        if type == :text && column == 4
+          version, platform = data.split "-", 2
 
           platform =
             platform ? Gem::Platform.new(platform) : Gem::Platform::RUBY
@@ -171,26 +172,26 @@ class Gem::RequestSet::Lockfile::Parser
   end
 
   def parse_GIT # :nodoc:
-    get :entry, 'remote'
+    get :entry, "remote"
     repository = get(:text).value
 
     skip :newline
 
-    get :entry, 'revision'
+    get :entry, "revision"
     revision = get(:text).value
 
     skip :newline
 
     type = peek.type
     value = peek.value
-    if type == :entry and %w[branch ref tag].include? value then
+    if type == :entry && %w[branch ref tag].include?(value)
       get
       get :text
 
       skip :newline
     end
 
-    get :entry, 'specs'
+    get :entry, "specs"
 
     skip :newline
 
@@ -199,7 +200,7 @@ class Gem::RequestSet::Lockfile::Parser
 
     last_spec = nil
 
-    while not @tokens.empty? and :text == peek.type do
+    while !@tokens.empty? && peek.type == :text do
       token = get :text
       name = token.value
       column = token.column
@@ -214,7 +215,7 @@ class Gem::RequestSet::Lockfile::Parser
         type = token.type
         data = token.value
 
-        if type == :text and column == 4 then
+        if type == :text && column == 4
           last_spec = set.add_git_spec name, data, repository, revision, true
         else
           dependency = parse_dependency name, data
@@ -234,19 +235,19 @@ class Gem::RequestSet::Lockfile::Parser
   end
 
   def parse_PATH # :nodoc:
-    get :entry, 'remote'
+    get :entry, "remote"
     directory = get(:text).value
 
     skip :newline
 
-    get :entry, 'specs'
+    get :entry, "specs"
 
     skip :newline
 
     set = Gem::Resolver::VendorSet.new
     last_spec = nil
 
-    while not @tokens.empty? and :text == peek.first do
+    while !@tokens.empty? && peek.first == :text do
       token = get :text
       name = token.value
       column = token.column
@@ -261,7 +262,7 @@ class Gem::RequestSet::Lockfile::Parser
         type = token.type
         data = token.value
 
-        if type == :text and column == 4 then
+        if type == :text && column == 4
           last_spec = set.add_vendor_gem name, directory
         else
           dependency = parse_dependency name, data
@@ -281,7 +282,7 @@ class Gem::RequestSet::Lockfile::Parser
   end
 
   def parse_PLATFORMS # :nodoc:
-    while not @tokens.empty? and :text == peek.first do
+    while !@tokens.empty? && peek.first == :text do
       name = get(:text).value
 
       @platforms << name
@@ -294,7 +295,7 @@ class Gem::RequestSet::Lockfile::Parser
   # Parses the requirements following the dependency +name+ and the +op+ for
   # the first token of the requirements and returns a Gem::Dependency object.
 
-  def parse_dependency name, op # :nodoc:
+  def parse_dependency(name, op) # :nodoc:
     return Gem::Dependency.new name, op unless peek[0] == :text
 
     version = get(:text).value
@@ -314,7 +315,7 @@ class Gem::RequestSet::Lockfile::Parser
 
   private
 
-  def skip type # :nodoc:
+  def skip(type) # :nodoc:
     @tokens.skip type
   end
 
@@ -325,30 +326,19 @@ class Gem::RequestSet::Lockfile::Parser
     @tokens.peek
   end
 
-  if [].respond_to? :flat_map
-    def pinned_requirement name # :nodoc:
-      requirement = Gem::Dependency.new name
-      specification = @set.sets.flat_map { |set|
-        set.find_all(requirement)
-      }.compact.first
+  def pinned_requirement(name) # :nodoc:
+    requirement = Gem::Dependency.new name
+    specification = @set.sets.flat_map do |set|
+      set.find_all(requirement)
+    end.compact.first
 
-      specification && specification.version
-    end
-  else # FIXME: remove when 1.8 is dropped
-    def pinned_requirement name # :nodoc:
-      requirement = Gem::Dependency.new name
-      specification = @set.sets.map { |set|
-        set.find_all(requirement)
-      }.flatten(1).compact.first
-
-      specification && specification.version
-    end
+    specification&.version
   end
 
   ##
   # Ungets the last token retrieved by #get
 
-  def unget token # :nodoc:
+  def unget(token) # :nodoc:
     @tokens.unshift token
   end
 end

data/lib/rubygems/request_set/lockfile/tokenizer.rb

@@ -1,16 +1,17 @@
 # frozen_string_literal: true
-require 'strscan'
-require 'rubygems/request_set/lockfile/parser'
+
+# ) frozen_string_literal: true
+require_relative "parser"
 
 class Gem::RequestSet::Lockfile::Tokenizer
   Token = Struct.new :type, :value, :column, :line
   EOF   = Token.new :EOF
 
-  def self.from_file file
+  def self.from_file(file)
     new File.read(file), file
   end
 
-  def initialize input, filename = nil, line = 0, pos = 0
+  def initialize(input, filename = nil, line = 0, pos = 0)
     @line     = line
     @line_pos = pos
     @tokens   = []
@@ -18,23 +19,23 @@ class Gem::RequestSet::Lockfile::Tokenizer
     tokenize input
   end
 
-  def make_parser set, platforms
+  def make_parser(set, platforms)
     Gem::RequestSet::Lockfile::Parser.new self, set, platforms, @filename
   end
 
   def to_a
-    @tokens.map { |token| [token.type, token.value, token.column, token.line] }
+    @tokens.map {|token| [token.type, token.value, token.column, token.line] }
   end
 
-  def skip type
-    @tokens.shift while not @tokens.empty? and peek.type == type
+  def skip(type)
+    @tokens.shift while !@tokens.empty? && peek.type == type
   end
 
   ##
   # Calculates the column (by byte) and the line of the current token based on
   # +byte_offset+.
 
-  def token_pos byte_offset # :nodoc:
+  def token_pos(byte_offset) # :nodoc:
     [byte_offset - @line_pos, @line]
   end
 
@@ -42,14 +43,14 @@ class Gem::RequestSet::Lockfile::Tokenizer
     @tokens.empty?
   end
 
-  def unshift token
+  def unshift(token)
     @tokens.unshift token
   end
 
   def next_token
     @tokens.shift
   end
-  alias :shift :next_token
+  alias_method :shift, :next_token
 
   def peek
     @tokens.first || EOF
@@ -57,7 +58,8 @@ class Gem::RequestSet::Lockfile::Tokenizer
 
   private
 
-  def tokenize input
+  def tokenize(input)
+    require "strscan"
     s = StringScanner.new input
 
     until s.eos? do
@@ -65,7 +67,7 @@ class Gem::RequestSet::Lockfile::Tokenizer
 
       pos = s.pos if leading_whitespace = s.scan(/ +/)
 
-      if s.scan(/[<|=>]{7}/) then
+      if s.scan(/[<|=>]{7}/)
         message = "your #{@filename} contains merge conflict markers"
         column, line = token_pos pos
 
@@ -73,34 +75,42 @@ class Gem::RequestSet::Lockfile::Tokenizer
       end
 
       @tokens <<
-        case
-        when s.scan(/\r?\n/) then
+        if s.scan(/\r?\n/)
+
           token = Token.new(:newline, nil, *token_pos(pos))
           @line_pos = s.pos
           @line += 1
           token
-        when s.scan(/[A-Z]+/) then
-          if leading_whitespace then
+        elsif s.scan(/[A-Z]+/)
+
+          if leading_whitespace
             text = s.matched
             text += s.scan(/[^\s)]*/).to_s # in case of no match
             Token.new(:text, text, *token_pos(pos))
           else
             Token.new(:section, s.matched, *token_pos(pos))
           end
-        when s.scan(/([a-z]+):\s/) then
+        elsif s.scan(/([a-z]+):\s/)
+
           s.pos -= 1 # rewind for possible newline
           Token.new(:entry, s[1], *token_pos(pos))
-        when s.scan(/\(/) then
+        elsif s.scan(/\(/)
+
           Token.new(:l_paren, nil, *token_pos(pos))
-        when s.scan(/\)/) then
+        elsif s.scan(/\)/)
+
           Token.new(:r_paren, nil, *token_pos(pos))
-        when s.scan(/<=|>=|=|~>|<|>|!=/) then
+        elsif s.scan(/<=|>=|=|~>|<|>|!=/)
+
           Token.new(:requirement, s.matched, *token_pos(pos))
-        when s.scan(/,/) then
+        elsif s.scan(/,/)
+
           Token.new(:comma, nil, *token_pos(pos))
-        when s.scan(/!/) then
+        elsif s.scan(/!/)
+
           Token.new(:bang, nil, *token_pos(pos))
-        when s.scan(/[^\s),!]*/) then
+        elsif s.scan(/[^\s),!]*/)
+
           Token.new(:text, s.matched, *token_pos(pos))
         else
           raise "BUG: can't create token for: #{s.string[s.pos..-1].inspect}"

data/lib/rubygems/request_set/lockfile.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 ##
 # Parses a gem.deps.rb.lock file and constructs a LockSet containing the
 # dependencies found inside.  If the lock file is missing no LockSet is
@@ -9,7 +10,6 @@ class Gem::RequestSet::Lockfile
   # Raised when a lockfile cannot be parsed
 
   class ParseError < Gem::Exception
-
     ##
     # The column where the error was encountered
 
@@ -29,7 +29,7 @@ class Gem::RequestSet::Lockfile
     # Raises a ParseError with the given +message+ which was encountered at a
     # +line+ and +column+ while parsing.
 
-    def initialize message, column, line, path
+    def initialize(message, column, line, path)
       @line   = line
       @column = column
       @path   = path
@@ -41,13 +41,13 @@ class Gem::RequestSet::Lockfile
   # Creates a new Lockfile for the given +request_set+ and +gem_deps_file+
   # location.
 
-  def self.build request_set, gem_deps_file, dependencies = nil
+  def self.build(request_set, gem_deps_file, dependencies = nil)
     request_set.resolve
     dependencies ||= requests_to_deps request_set.sorted_requests
     new request_set, gem_deps_file, dependencies
   end
 
-  def self.requests_to_deps requests # :nodoc:
+  def self.requests_to_deps(requests) # :nodoc:
     deps = {}
 
     requests.each do |request|
@@ -56,11 +56,11 @@ class Gem::RequestSet::Lockfile
       requirement = request.request.dependency.requirement
 
       deps[name] = if [Gem::Resolver::VendorSpecification,
-                       Gem::Resolver::GitSpecification].include? spec.class then
-                     Gem::Requirement.source_set
-                   else
-                     requirement
-                   end
+                       Gem::Resolver::GitSpecification].include? spec.class
+        Gem::Requirement.source_set
+      else
+        requirement
+      end
     end
 
     deps
@@ -71,43 +71,40 @@ class Gem::RequestSet::Lockfile
 
   attr_reader :platforms
 
-  def initialize request_set, gem_deps_file, dependencies
+  def initialize(request_set, gem_deps_file, dependencies)
     @set           = request_set
     @dependencies  = dependencies
     @gem_deps_file = File.expand_path(gem_deps_file)
     @gem_deps_dir  = File.dirname(@gem_deps_file)
-
-    @gem_deps_file.untaint unless gem_deps_file.tainted?
-
-    @platforms      = []
+    @platforms = []
   end
 
-  def add_DEPENDENCIES out # :nodoc:
+  def add_DEPENDENCIES(out) # :nodoc:
     out << "DEPENDENCIES"
 
-    out.concat @dependencies.sort_by { |name,| name }.map { |name, requirement|
+    out.concat @dependencies.sort.map {|name, requirement|
       "  #{name}#{requirement.for_lockfile}"
     }
 
     out << nil
   end
 
-  def add_GEM out, spec_groups # :nodoc:
+  def add_GEM(out, spec_groups) # :nodoc:
     return if spec_groups.empty?
 
     source_groups = spec_groups.values.flatten.group_by do |request|
       request.spec.source.uri
     end
 
-    source_groups.sort_by { |group,| group.to_s }.map do |group, requests|
+    source_groups.sort_by {|group,| group.to_s }.map do |group, requests|
       out << "GEM"
       out << "  remote: #{group}"
       out << "  specs:"
 
-      requests.sort_by { |request| request.name }.each do |request|
-        next if request.spec.name == 'bundler'
+      requests.sort_by(&:name).each do |request|
+        next if request.spec.name == "bundler"
         platform = "-#{request.spec.platform}" unless
-          Gem::Platform::RUBY == request.spec.platform
+          request.spec.platform == Gem::Platform::RUBY
 
         out << "    #{request.name} (#{request.version}#{platform})"
 
@@ -122,7 +119,7 @@ class Gem::RequestSet::Lockfile
     end
   end
 
-  def add_GIT out, git_requests
+  def add_GIT(out, git_requests)
     return if git_requests.empty?
 
     by_repository_revision = git_requests.group_by do |request|
@@ -136,10 +133,10 @@ class Gem::RequestSet::Lockfile
       out << "  revision: #{revision}"
       out << "  specs:"
 
-      requests.sort_by { |request| request.name }.each do |request|
+      requests.sort_by(&:name).each do |request|
         out << "    #{request.name} (#{request.version})"
 
-        dependencies = request.spec.dependencies.sort_by { |dep| dep.name }
+        dependencies = request.spec.dependencies.sort_by(&:name)
         dependencies.each do |dep|
           out << "      #{dep.name}#{dep.requirement.for_lockfile}"
         end
@@ -148,14 +145,14 @@ class Gem::RequestSet::Lockfile
     end
   end
 
-  def relative_path_from dest, base # :nodoc:
+  def relative_path_from(dest, base) # :nodoc:
     dest = File.expand_path(dest)
     base = File.expand_path(base)
 
-    if dest.index(base) == 0 then
-      offset = dest[base.size+1..-1]
+    if dest.index(base) == 0
+      offset = dest[base.size + 1..-1]
 
-      return '.' unless offset
+      return "." unless offset
 
       offset
     else
@@ -163,7 +160,7 @@ class Gem::RequestSet::Lockfile
     end
   end
 
-  def add_PATH out, path_requests # :nodoc:
+  def add_PATH(out, path_requests) # :nodoc:
     return if path_requests.empty?
 
     out << "PATH"
@@ -178,12 +175,12 @@ class Gem::RequestSet::Lockfile
     out << nil
   end
 
-  def add_PLATFORMS out # :nodoc:
+  def add_PLATFORMS(out) # :nodoc:
     out << "PLATFORMS"
 
-    platforms = requests.map { |request| request.spec.platform }.uniq
+    platforms = requests.map {|request| request.spec.platform }.uniq
 
-    platforms = platforms.sort_by { |platform| platform.to_s }
+    platforms = platforms.sort_by(&:to_s)
 
     platforms.each do |platform|
       out << "  #{platform}"
@@ -193,7 +190,7 @@ class Gem::RequestSet::Lockfile
   end
 
   def spec_groups
-    requests.group_by { |request| request.spec.class }
+    requests.group_by {|request| request.spec.class }
   end
 
   ##
@@ -223,7 +220,7 @@ class Gem::RequestSet::Lockfile
   def write
     content = to_s
 
-    open "#{@gem_deps_file}.lock", 'w' do |io|
+    File.open "#{@gem_deps_file}.lock", "w" do |io|
       io.write content
     end
   end
@@ -235,4 +232,4 @@ class Gem::RequestSet::Lockfile
   end
 end
 
-require 'rubygems/request_set/lockfile/tokenizer'
+require_relative "lockfile/tokenizer"