rubygems-update 3.5.3 → 3.7.1

data/lib/rubygems/package/tar_writer.rb

@@ -95,10 +95,11 @@ class Gem::Package::TarWriter
   end
 
   ##
-  # Adds file +name+ with permissions +mode+, and yields an IO for writing the
-  # file to
+  # Adds file +name+ with permissions +mode+ and mtime +mtime+ (sets
+  # Gem.source_date_epoch if not specified), and yields an IO for
+  # writing the file to
 
-  def add_file(name, mode) # :yields: io
+  def add_file(name, mode, mtime=nil) # :yields: io
     check_closed
 
     name, prefix = split_name name
@@ -118,7 +119,7 @@ class Gem::Package::TarWriter
 
     header = Gem::Package::TarHeader.new name: name, mode: mode,
                                          size: size, prefix: prefix,
-                                         mtime: Gem.source_date_epoch
+                                         mtime: mtime || Gem.source_date_epoch
 
     @io.write header
     @io.pos = final_pos

data/lib/rubygems/package.rb

@@ -7,7 +7,6 @@
 
 # rubocop:enable Style/AsciiComments
 
-require_relative "../rubygems"
 require_relative "security"
 require_relative "user_interaction"
 
@@ -59,7 +58,7 @@ class Gem::Package
 
     def initialize(message, source = nil)
       if source
-        @path = source.path
+        @path = source.is_a?(String) ? source : source.path
 
         message += " in #{path}" if path
       end
@@ -295,7 +294,6 @@ class Gem::Package
 
     Gem.load_yaml
 
-    @spec.mark_version
     @spec.validate true, strict_validation unless skip_validation
 
     setup_signer(
@@ -454,7 +452,7 @@ EOM
 
         if entry.file?
           File.open(destination, "wb") {|out| copy_stream(entry, out) }
-          FileUtils.chmod file_mode(entry.header.mode), destination
+          FileUtils.chmod file_mode(entry.header.mode) & ~File.umask, destination
         end
 
         verbose destination
@@ -528,12 +526,13 @@ EOM
   # Loads a Gem::Specification from the TarEntry +entry+
 
   def load_spec(entry) # :nodoc:
+    limit = 10 * 1024 * 1024
     case entry.full_name
     when "metadata" then
-      @spec = Gem::Specification.from_yaml entry.read
+      @spec = Gem::Specification.from_yaml limit_read(entry, "metadata", limit)
     when "metadata.gz" then
       Zlib::GzipReader.wrap(entry, external_encoding: Encoding::UTF_8) do |gzio|
-        @spec = Gem::Specification.from_yaml gzio.read
+        @spec = Gem::Specification.from_yaml limit_read(gzio, "metadata.gz", limit)
       end
     end
   end
@@ -557,7 +556,7 @@ EOM
 
     @checksums = gem.seek "checksums.yaml.gz" do |entry|
       Zlib::GzipReader.wrap entry do |gz_io|
-        Gem::SafeYAML.safe_load gz_io.read
+        Gem::SafeYAML.safe_load limit_read(gz_io, "checksums.yaml.gz", 10 * 1024 * 1024)
       end
     end
   end
@@ -664,7 +663,7 @@ EOM
 
     case file_name
     when /\.sig$/ then
-      @signatures[$`] = entry.read if @security_policy
+      @signatures[$`] = limit_read(entry, file_name, 1024 * 1024) if @security_policy
       return
     else
       digest entry
@@ -724,6 +723,12 @@ EOM
       IO.copy_stream(src, dst)
     end
   end
+
+  def limit_read(io, name, limit)
+    bytes = io.read(limit + 1)
+    raise Gem::Package::FormatError, "#{name} is too big (over #{limit} bytes)" if bytes.size > limit
+    bytes
+  end
 end
 
 require_relative "package/digest_io"

data/lib/rubygems/platform.rb

@@ -12,9 +12,10 @@ class Gem::Platform
 
   attr_accessor :cpu, :os, :version
 
-  def self.local
-    @local ||= begin
-      arch = RbConfig::CONFIG["arch"]
+  def self.local(refresh: false)
+    return @local if @local && !refresh
+    @local = begin
+      arch = Gem.target_rbconfig["arch"]
       arch = "#{arch}_60" if /mswin(?:32|64)$/.match?(arch)
       new(arch)
     end
@@ -87,55 +88,45 @@ class Gem::Platform
     when Array then
       @cpu, @os, @version = arch
     when String then
-      arch = arch.split "-"
+      cpu, os = arch.sub(/-+$/, "").split("-", 2)
 
-      if arch.length > 2 && !arch.last.match?(/\d+(\.\d+)?$/) # reassemble x86-linux-{libc}
-        extra = arch.pop
-        arch.last << "-#{extra}"
-      end
-
-      cpu = arch.shift
-
-      @cpu = case cpu
-             when /i\d86/ then "x86"
-             else cpu
-      end
-
-      if arch.length == 2 && arch.last.match?(/^\d+(\.\d+)?$/) # for command-line
-        @os, @version = arch
-        return
+      @cpu = if cpu&.match?(/i\d86/)
+        "x86"
+      else
+        cpu
       end
 
-      os, = arch
       if os.nil?
         @cpu = nil
         os = cpu
       end # 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 /^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-?(\w+)?/ then         ["linux",     $1]
-                      when /mingw32/ then               ["mingw32",   nil]
-                      when /mingw-?(\w+)?/ then         ["mingw",     $1]
-                      when /(mswin\d+)(\_(\d+))?/ then
+                      when /aix-?(\d+)?/ then                ["aix",     $1]
+                      when /cygwin/ then                     ["cygwin",  nil]
+                      when /darwin-?(\d+)?/ then             ["darwin",  $1]
+                      when "macruby" then                    ["macruby", nil]
+                      when /^macruby-?(\d+(?:\.\d+)*)?/ then ["macruby", $1]
+                      when /freebsd-?(\d+)?/ then            ["freebsd", $1]
+                      when "java", "jruby" then              ["java",    nil]
+                      when /^java-?(\d+(?:\.\d+)*)?/ then    ["java",    $1]
+                      when /^dalvik-?(\d+)?$/ then           ["dalvik",  $1]
+                      when /^dotnet$/ then                   ["dotnet",  nil]
+                      when /^dotnet-?(\d+(?:\.\d+)*)?/ then  ["dotnet",  $1]
+                      when /linux-?(\w+)?/ then              ["linux",   $1]
+                      when /mingw32/ then                    ["mingw32", nil]
+                      when /mingw-?(\w+)?/ then              ["mingw",   $1]
+                      when /(mswin\d+)(?:[_-](\d+))?/ then
                         os = $1
-                        version = $3
-                        @cpu = "x86" if @cpu.nil? && os =~ /32$/
+                        version = $2
+                        @cpu = "x86" if @cpu.nil? && os.end_with?("32")
                         [os, version]
-                      when /netbsdelf/ then             ["netbsdelf", nil]
-                      when /openbsd(\d+\.\d+)?/ then    ["openbsd",   $1]
-                      when /solaris(\d+\.\d+)?/ then    ["solaris",   $1]
+                      when /netbsdelf/ then                  ["netbsdelf", nil]
+                      when /openbsd-?(\d+\.\d+)?/ then       ["openbsd",   $1]
+                      when /solaris-?(\d+\.\d+)?/ then       ["solaris",   $1]
+                      when /wasi/ then                       ["wasi",      nil]
                       # test
-                      when /^(\w+_platform)(\d+)?/ then [$1,          $2]
+                      when /^(\w+_platform)-?(\d+)?/ then    [$1,          $2]
                       else ["unknown", nil]
       end
     when Gem::Platform then
@@ -152,7 +143,7 @@ class Gem::Platform
   end
 
   def to_s
-    to_a.compact.join "-"
+    to_a.compact.join(@cpu.nil? ? "" : "-")
   end
 
   ##
@@ -175,7 +166,7 @@ class Gem::Platform
   # they have the same version, or either one has no version
   #
   # Additionally, the platform will match if the local CPU is 'arm' and the
-  # other CPU starts with "arm" (for generic ARM family support).
+  # other CPU starts with "armv" (for generic 32-bit ARM family support).
   #
   # Of note, this method is not commutative. Indeed the OS 'linux' has a
   # special case: the version is the libc name, yet while "no version" stands
@@ -196,7 +187,7 @@ class Gem::Platform
 
     # cpu
     ([nil,"universal"].include?(@cpu) || [nil, "universal"].include?(other.cpu) || @cpu == other.cpu ||
-    (@cpu == "arm" && other.cpu.start_with?("arm"))) &&
+    (@cpu == "arm" && other.cpu.start_with?("armv"))) &&
 
       # os
       @os == other.os &&
@@ -264,4 +255,118 @@ class Gem::Platform
   # This will be replaced with Gem::Platform::local.
 
   CURRENT = "current"
+
+  JAVA  = Gem::Platform.new("java") # :nodoc:
+  MSWIN = Gem::Platform.new("mswin32") # :nodoc:
+  MSWIN64 = Gem::Platform.new("mswin64") # :nodoc:
+  MINGW = Gem::Platform.new("x86-mingw32") # :nodoc:
+  X64_MINGW_LEGACY = Gem::Platform.new("x64-mingw32") # :nodoc:
+  X64_MINGW = Gem::Platform.new("x64-mingw-ucrt") # :nodoc:
+  UNIVERSAL_MINGW = Gem::Platform.new("universal-mingw") # :nodoc:
+  WINDOWS = [MSWIN, MSWIN64, UNIVERSAL_MINGW].freeze # :nodoc:
+  X64_LINUX = Gem::Platform.new("x86_64-linux") # :nodoc:
+  X64_LINUX_MUSL = Gem::Platform.new("x86_64-linux-musl") # :nodoc:
+
+  GENERICS = [JAVA, *WINDOWS].freeze # :nodoc:
+  private_constant :GENERICS
+
+  GENERIC_CACHE = GENERICS.each_with_object({}) {|g, h| h[g] = g } # :nodoc:
+  private_constant :GENERIC_CACHE
+
+  class << self
+    ##
+    # Returns the generic platform for the given platform.
+
+    def generic(platform)
+      return Gem::Platform::RUBY if platform.nil? || platform == Gem::Platform::RUBY
+
+      GENERIC_CACHE[platform] ||= begin
+        found = GENERICS.find do |match|
+          platform === match
+        end
+        found || Gem::Platform::RUBY
+      end
+    end
+
+    ##
+    # Returns the platform specificity match for the given spec platform and user platform.
+
+    def platform_specificity_match(spec_platform, user_platform)
+      return -1 if spec_platform == user_platform
+      return 1_000_000 if spec_platform.nil? || spec_platform == Gem::Platform::RUBY || user_platform == Gem::Platform::RUBY
+
+      os_match(spec_platform, user_platform) +
+        cpu_match(spec_platform, user_platform) * 10 +
+        version_match(spec_platform, user_platform) * 100
+    end
+
+    ##
+    # Sorts and filters the best platform match for the given matching specs and platform.
+
+    def sort_and_filter_best_platform_match(matching, platform)
+      return matching if matching.one?
+
+      exact = matching.select {|spec| spec.platform == platform }
+      return exact if exact.any?
+
+      sorted_matching = sort_best_platform_match(matching, platform)
+      exemplary_spec = sorted_matching.first
+
+      sorted_matching.take_while {|spec| same_specificity?(platform, spec, exemplary_spec) && same_deps?(spec, exemplary_spec) }
+    end
+
+    ##
+    # Sorts the best platform match for the given matching specs and platform.
+
+    def sort_best_platform_match(matching, platform)
+      matching.sort_by.with_index do |spec, i|
+        [
+          platform_specificity_match(spec.platform, platform),
+          i, # for stable sort
+        ]
+      end
+    end
+
+    private
+
+    def same_specificity?(platform, spec, exemplary_spec)
+      platform_specificity_match(spec.platform, platform) == platform_specificity_match(exemplary_spec.platform, platform)
+    end
+
+    def same_deps?(spec, exemplary_spec)
+      spec.required_ruby_version == exemplary_spec.required_ruby_version &&
+        spec.required_rubygems_version == exemplary_spec.required_rubygems_version &&
+        spec.dependencies.sort == exemplary_spec.dependencies.sort
+    end
+
+    def os_match(spec_platform, user_platform)
+      if spec_platform.os == user_platform.os
+        0
+      else
+        1
+      end
+    end
+
+    def cpu_match(spec_platform, user_platform)
+      if spec_platform.cpu == user_platform.cpu
+        0
+      elsif spec_platform.cpu == "arm" && user_platform.cpu.to_s.start_with?("arm")
+        0
+      elsif spec_platform.cpu.nil? || spec_platform.cpu == "universal"
+        1
+      else
+        2
+      end
+    end
+
+    def version_match(spec_platform, user_platform)
+      if spec_platform.version == user_platform.version
+        0
+      elsif spec_platform.version.nil?
+        1
+      else
+        2
+      end
+    end
+  end
 end

data/lib/rubygems/psych_tree.rb

@@ -14,6 +14,10 @@ module Gem
         @emitter.scalar str, nil, nil, false, true, quote
       end
 
+      def visit_Hash(o)
+        super(o.compact)
+      end
+
       # Noop this out so there are no anchors
       def register(target, obj)
       end

data/lib/rubygems/query_utils.rb

@@ -132,7 +132,7 @@ module Gem::QueryUtils
       version_matches = show_prereleases? || !s.version.prerelease?
 
       name_matches && version_matches
-    end
+    end.uniq(&:full_name)
 
     spec_tuples = specs.map do |spec|
       [spec.name_tuple, spec]
@@ -311,7 +311,7 @@ module Gem::QueryUtils
       label = "Installed at"
       specs.each do |s|
         version = s.version.to_s
-        default = ", default" if s.default_gem?
+        default = s.default_gem? ? ", default" : ""
         entry << "\n" << "    #{label} (#{version}#{default}): #{s.base_dir}"
         label = " " * label.length
       end

data/lib/rubygems/rdoc.rb

@@ -5,9 +5,22 @@ require_relative "../rubygems"
 begin
   require "rdoc/rubygems_hook"
   module Gem
-    RDoc = ::RDoc::RubygemsHook
-  end
+    ##
+    # Returns whether RDoc defines its own install hooks through a RubyGems
+    # plugin. This and whatever is guarded by it can be removed once no
+    # supported Ruby ships with RDoc older than 6.9.0.
+
+    def self.rdoc_hooks_defined_via_plugin?
+      Gem::Version.new(::RDoc::VERSION) >= Gem::Version.new("6.9.0")
+    end
 
-  Gem.done_installing(&Gem::RDoc.method(:generation_hook))
+    if rdoc_hooks_defined_via_plugin?
+      RDoc = ::RDoc::RubyGemsHook
+    else
+      RDoc = ::RDoc::RubygemsHook
+
+      Gem.done_installing(&Gem::RDoc.method(:generation_hook))
+    end
+  end
 rescue LoadError
 end

data/lib/rubygems/remote_fetcher.rb

@@ -74,9 +74,8 @@ class Gem::RemoteFetcher
 
   def initialize(proxy=nil, dns=nil, headers={})
     require_relative "core_ext/tcpsocket_init" if Gem.configuration.ipv4_fallback_enabled
-    require_relative "net/http"
-    require "stringio"
-    require "uri"
+    require_relative "vendored_net_http"
+    require_relative "vendor/uri/lib/uri"
 
     Socket.do_not_reverse_lookup = true
 
@@ -135,7 +134,7 @@ class Gem::RemoteFetcher
 
     scheme = source_uri.scheme
 
-    # URI.parse gets confused by MS Windows paths with forward slashes.
+    # Gem::URI.parse gets confused by MS Windows paths with forward slashes.
     scheme = nil if /^[a-z]$/i.match?(scheme)
 
     # REFACTOR: split this up and dispatch on scheme (eg download_http)
@@ -268,7 +267,7 @@ class Gem::RemoteFetcher
 
   def fetch_s3(uri, mtime = nil, head = false)
     begin
-      public_uri = s3_uri_signer(uri).sign
+      public_uri = s3_uri_signer(uri, head ? "HEAD" : "GET").sign
     rescue Gem::S3URISigner::ConfigurationError, Gem::S3URISigner::InstanceProfileError => e
       raise FetchError.new(e.message, "s3://#{uri.host}")
     end
@@ -276,8 +275,8 @@ class Gem::RemoteFetcher
   end
 
   # we have our own signing code here to avoid a dependency on the aws-sdk gem
-  def s3_uri_signer(uri)
-    Gem::S3URISigner.new(uri)
+  def s3_uri_signer(uri, method)
+    Gem::S3URISigner.new(uri, method)
   end
 
   ##

data/lib/rubygems/request.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require_relative "net/http"
+require_relative "vendored_net_http"
 require_relative "user_interaction"
 
 class Gem::Request
@@ -18,11 +18,11 @@ class Gem::Request
   end
 
   def self.proxy_uri(proxy) # :nodoc:
-    require "uri"
+    require_relative "vendor/uri/lib/uri"
     case proxy
     when :no_proxy then nil
-    when URI::HTTP then proxy
-    else URI.parse(proxy)
+    when Gem::URI::HTTP then proxy
+    else Gem::URI.parse(proxy)
     end
   end
 
@@ -176,7 +176,7 @@ class Gem::Request
     end
 
     require "uri"
-    uri = URI(Gem::UriFormatter.new(env_proxy).normalize)
+    uri = Gem::URI(Gem::UriFormatter.new(env_proxy).normalize)
 
     if uri && uri.user.nil? && uri.password.nil?
       user     = ENV["#{downcase_scheme}_proxy_user"] || ENV["#{upcase_scheme}_PROXY_USER"]

data/lib/rubygems/request_set/gem_dependency_api.rb

@@ -330,7 +330,7 @@ class Gem::RequestSet::GemDependencyAPI
   # git: ::
   #   Install this dependency from a git repository:
   #
-  #     gem 'private_gem', git: git@my.company.example:private_gem.git'
+  #     gem 'private_gem', git: 'git@my.company.example:private_gem.git'
   #
   # gist: ::
   #   Install this dependency from the gist ID:

data/lib/rubygems/request_set.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require_relative "tsort"
+require_relative "vendored_tsort"
 
 ##
 # A RequestSet groups a request to activate a set of dependencies.
@@ -181,13 +181,10 @@ class Gem::RequestSet
 
     # Install requested gems after they have been downloaded
     sorted_requests.each do |req|
-      if req.installed?
+      if req.installed? && @always_install.none? {|spec| spec == req.spec.spec }
         req.spec.spec.build_extensions
-
-        if @always_install.none? {|spec| spec == req.spec.spec }
-          yield req, nil if block_given?
-          next
-        end
+        yield req, nil if block_given?
+        next
       end
 
       spec =

data/lib/rubygems/requirement.rb

@@ -13,8 +13,8 @@ class Gem::Requirement
   OPS = { # :nodoc:
     "=" => lambda {|v, r| v == r },
     "!=" => lambda {|v, r| v != r },
-    ">" => lambda {|v, r| v >  r },
-    "<" => lambda {|v, r| v <  r },
+    ">" => lambda {|v, r| v > r },
+    "<" => lambda {|v, r| v < r },
     ">=" => lambda {|v, r| v >= r },
     "<=" => lambda {|v, r| v <= r },
     "~>" => lambda {|v, r| v >= r && v.release < r.bump },
@@ -22,7 +22,7 @@ class Gem::Requirement
 
   SOURCE_SET_REQUIREMENT = Struct.new(:for_lockfile).new "!" # :nodoc:
 
-  quoted = OPS.keys.map {|k| Regexp.quote k }.join "|"
+  quoted = Regexp.union(OPS.keys)
   PATTERN_RAW = "\\s*(#{quoted})?\\s*(#{Gem::Version::VERSION_PATTERN})\\s*".freeze # :nodoc:
 
   ##
@@ -106,13 +106,15 @@ class Gem::Requirement
     unless PATTERN =~ obj.to_s
       raise BadRequirementError, "Illformed requirement [#{obj.inspect}]"
     end
+    op = -($1 || "=")
+    version = -$2
 
-    if $1 == ">=" && $2 == "0"
+    if op == ">=" && version == "0"
       DefaultRequirement
-    elsif $1 == ">=" && $2 == "0.a"
+    elsif op == ">=" && version == "0.a"
       DefaultPrereleaseRequirement
     else
-      [-($1 || "="), Gem::Version.new($2)]
+      [op, Gem::Version.new(version)]
     end
   end
 
@@ -201,7 +203,8 @@ class Gem::Requirement
   def marshal_load(array) # :nodoc:
     @requirements = array[0]
 
-    raise TypeError, "wrong @requirements" unless Array === @requirements
+    raise TypeError, "wrong @requirements" unless Array === @requirements &&
+                                                  @requirements.all? {|r| r.size == 2 && (r.first.is_a?(String) || r[0] = "=") && r.last.is_a?(Gem::Version) }
   end
 
   def yaml_initialize(tag, vals) # :nodoc:
@@ -214,10 +217,6 @@ class Gem::Requirement
     yaml_initialize coder.tag, coder.map
   end
 
-  def to_yaml_properties # :nodoc:
-    ["@requirements"]
-  end
-
   def encode_with(coder) # :nodoc:
     coder.add "requirements", @requirements
   end
@@ -242,7 +241,7 @@ class Gem::Requirement
   def satisfied_by?(version)
     raise ArgumentError, "Need a Gem::Version: #{version.inspect}" unless
       Gem::Version === version
-    requirements.all? {|op, rv| OPS[op].call version, rv }
+    requirements.all? {|op, rv| OPS.fetch(op).call version, rv }
   end
 
   alias_method :===, :satisfied_by?
@@ -284,6 +283,11 @@ class Gem::Requirement
   def _tilde_requirements
     @_tilde_requirements ||= _sorted_requirements.select {|r| r.first == "~>" }
   end
+
+  def initialize_copy(other) # :nodoc:
+    @requirements = other.requirements.dup
+    super
+  end
 end
 
 class Gem::Version

data/lib/rubygems/resolver/activation_request.rb

@@ -106,7 +106,7 @@ class Gem::Resolver::ActivationRequest
       this_spec = full_spec
 
       Gem::Specification.any? do |s|
-        s == this_spec
+        s == this_spec && s.base_dir == this_spec.base_dir
       end
     end
   end

data/lib/rubygems/resolver/api_set/gem_parser.rb

@@ -1,15 +1,12 @@
 # frozen_string_literal: true
 
 class Gem::Resolver::APISet::GemParser
-  EMPTY_ARRAY = [].freeze
-  private_constant :EMPTY_ARRAY
-
   def parse(line)
     version_and_platform, rest = line.split(" ", 2)
     version, platform = version_and_platform.split("-", 2)
     dependencies, requirements = rest.split("|", 2).map! {|s| s.split(",") } if rest
-    dependencies = dependencies ? dependencies.map! {|d| parse_dependency(d) } : EMPTY_ARRAY
-    requirements = requirements ? requirements.map! {|d| parse_dependency(d) } : EMPTY_ARRAY
+    dependencies = dependencies ? dependencies.map! {|d| parse_dependency(d) } : []
+    requirements = requirements ? requirements.map! {|d| parse_dependency(d) } : []
     [version, platform, dependencies, requirements]
   end
 

data/lib/rubygems/resolver/api_set.rb

@@ -30,7 +30,7 @@ class Gem::Resolver::APISet < Gem::Resolver::Set
   def initialize(dep_uri = "https://index.rubygems.org/info/")
     super()
 
-    dep_uri = URI dep_uri unless URI === dep_uri
+    dep_uri = Gem::URI dep_uri unless Gem::URI === dep_uri
 
     @dep_uri = dep_uri
     @uri     = dep_uri + ".."
@@ -104,16 +104,21 @@ class Gem::Resolver::APISet < Gem::Resolver::Set
     end
 
     uri = @dep_uri + name
-    str = Gem::RemoteFetcher.fetcher.fetch_path uri
 
-    lines(str).each do |ver|
-      number, platform, dependencies, requirements = parse_gem(ver)
+    begin
+      str = Gem::RemoteFetcher.fetcher.fetch_path uri
+    rescue Gem::RemoteFetcher::FetchError
+      @data[name] = []
+    else
+      lines(str).each do |ver|
+        number, platform, dependencies, requirements = parse_gem(ver)
 
-      platform ||= "ruby"
-      dependencies = dependencies.map {|dep_name, reqs| [dep_name, reqs.join(", ")] }
-      requirements = requirements.map {|req_name, reqs| [req_name.to_sym, reqs] }.to_h
+        platform ||= "ruby"
+        dependencies = dependencies.map {|dep_name, reqs| [dep_name, reqs.join(", ")] }
+        requirements = requirements.map {|req_name, reqs| [req_name.to_sym, reqs] }.to_h
 
-      @data[name] << { name: name, number: number, platform: platform, dependencies: dependencies, requirements: requirements }
+        @data[name] << { name: name, number: number, platform: platform, dependencies: dependencies, requirements: requirements }
+      end
     end
 
     @data[name]