Optimize Gem::Text#format_text performance

lib/rubygems/text.rb

@@ -28,9 +28,10 @@ def format_text(text, wrap, indent = 0)
     while work.length > wrap do
       if work =~ /^(.{0,#{wrap}})[ \n]/
         result << $1.rstrip
-        work.slice!(0, $&.length)
+        work = work.slice($&.length..-1)
       else
-        result << work.slice!(0, wrap)
+        result << work.slice(0, wrap)
+        work = work.slice(wrap..-1)
       end
     end
 

lib/rubygems/version.rb

@@ -222,7 +222,6 @@ def initialize(version)
     end
     @version = -@version
     @segments = nil
-    @sort_key = compute_sort_key
   end
 
   ##
@@ -351,13 +350,43 @@ def <=>(other)
     end
 
     return unless Gem::Version === other
+    return 0 if @version == other.version || canonical_segments == other.canonical_segments
 
-    # Fast path for comparison when available.
-    if @sort_key && other.sort_key
-      return @sort_key <=> other.sort_key
-    end
+    lhsegments = _segments
+    rhsegments = other._segments
 
-    return 0 if @version == other.version || canonical_segments == other.canonical_segments
+    lhsize = lhsegments.size
+    rhsize = rhsegments.size
+    limit  = (lhsize > rhsize ? rhsize : lhsize)
+
+    i = 0
+
+    if limit <= 4 && !prerelease? && !other.prerelease?
+      # Fast path
+      lh0 = lhsegments[0] || 0
+      lh1 = lhsegments[1] || 0
+      lh2 = lhsegments[2] || 0
+      lh3 = lhsegments[3] || 0
+
+      rh0 = rhsegments[0] || 0
+      rh1 = rhsegments[1] || 0
+      rh2 = rhsegments[2] || 0
+      rh3 = rhsegments[3] || 0
+
+      res = (lh0 <=> rh0)
+      return res unless res.zero?
+
+      res = (lh1 <=> rh1)
+      return res unless res.zero?
+
+      res = (lh2 <=> rh2)
+      return res unless res.zero?
+
+      res = (lh3 <=> rh3)
+      return res unless res.zero?
+
+      return 0
+    end
 
     lhsegments = canonical_segments
     rhsegments = other.canonical_segments
@@ -366,8 +395,6 @@ def <=>(other)
     rhsize = rhsegments.size
     limit  = (lhsize > rhsize ? rhsize : lhsize)
 
-    i = 0
-
     while i < limit
       lhs = lhsegments[i]
       rhs = rhsegments[i]
@@ -422,21 +449,6 @@ def freeze
 
   protected
 
-  attr_reader :sort_key # :nodoc:
-
-  def compute_sort_key
-    segments = canonical_segments
-    return if segments.size > 4 || prerelease? || segments.any? {|segment| segment > 65_000 }
-
-    base = 1_000_000_000_000
-
-    segments.sum do |segment|
-      result = segment * base
-      base /= 10_000
-      result
-    end
-  end
-
   def _segments
     # segments is lazy so it can pick up version values that come from
     # old marshaled versions, which don't go through marshal_load.