bundler 4.1.0.beta2 → 4.1.0.beta3

data/lib/rubygems/yaml_serializer.rb

@@ -16,30 +16,27 @@ end
 
 module Gem
   module YAMLSerializer
-    Scalar = Struct.new(:value, :tag, :anchor, keyword_init: true)
-
-    Mapping = Struct.new(:pairs, :tag, :anchor, keyword_init: true) do
-      def initialize(pairs: [], tag: nil, anchor: nil)
-        super
-      end
-    end
-
-    Sequence = Struct.new(:items, :tag, :anchor, keyword_init: true) do
-      def initialize(items: [], tag: nil, anchor: nil)
-        super
-      end
-    end
-
-    AliasRef = Struct.new(:name, keyword_init: true)
+    Scalar = Struct.new(:value, :tag, :anchor)
+    Mapping = Struct.new(:pairs, :tag, :anchor)
+    Sequence = Struct.new(:items, :tag, :anchor)
+    AliasRef = Struct.new(:name)
 
     class Parser
       # A plain (unquoted) mapping key followed by ":". "#" inside a key is
       # literal unless preceded by a space (which would start a comment).
-      MAPPING_KEY_RE = /^((?:[^#:\s]|:[^ ])(?:[^#:]|:[^ ]|(?<=[^ ])#)*):(?:[ ]+(.*))?$/
+      MAPPING_KEY_RE = /\G((?:[^#:\s]|:[^ ])(?:[^#:]|:[^ ]|(?<=[^ ])#)*):(?:[ ]+(.*))?$/
       # A quoted mapping key followed by ":". A whole-line quoted scalar
       # cannot match because its closing quote is at the end of the line.
-      QUOTED_KEY_RE = /^("(?:[^"\\]|\\.)*"|'(?:[^']|'')*'):(?:[ ]+(.*))?$/
+      QUOTED_KEY_RE = /\G("(?:[^"\\]|\\.)*"|'(?:[^']|'')*'):(?:[ ]+(.*))?$/
+      # An entry of a flow sequence. A quoted entry may contain commas.
+      FLOW_SEQUENCE_ENTRY_RE = /"(?:[^"\\]|\\.)*"|'(?:[^']|'')*'|[^,\s](?:[^,]*[^,\s])?/
+      SEQUENCE_ENTRY_RE = /\G-(?: |\z)/
+      RUBY_OBJECT_TAG_RE = %r{\G!ruby/object:}
+      LSTRIP_BYTES = [0, 9, 10, 11, 12, 13, 32].freeze
       MAX_NESTING_DEPTH = 1_000
+      NULL_SCALARS = %w[~ null].freeze
+      BLANK_RE = /\A[\0\s]*\z/
+      BLANK_OR_COMMENT_RE = /\A[\0\s]*(?:#|\z)/
 
       STRING_UNESCAPES = {
         "\\\\" => "\\",
@@ -53,10 +50,14 @@ module Gem
         "\\f" => "\f",
         "\\r" => "\r",
         "\\e" => "\e",
+        "\\N" => "\u0085",
+        "\\_" => "\u00A0",
+        "\\L" => "\u2028",
+        "\\P" => "\u2029",
       }.freeze
 
       def initialize(source)
-        @lines = source.split(/\r?\n/)
+        @lines = source.split(/\r?\n/).each(&:freeze)
         @anchors = {}
         @depth = 0
         strip_document_prefix
@@ -101,37 +102,35 @@ module Gem
         return nil if @lines.empty?
 
         line = @lines[0]
-        stripped = line.lstrip
-        indent = line.size - stripped.size
+        indent = indent_of(line)
         return nil if indent < base_indent
 
-        return parse_alias_ref if stripped.start_with?("*")
+        return parse_alias_ref if /\G\*/.match?(line, indent)
 
-        anchor = consume_anchor
-
-        if anchor
+        pos = indent
+        if /\G&/.match?(line, indent) && (anchor = consume_anchor)
           line = @lines[0]
-          stripped = line.lstrip
+          pos = indent_of(line)
         end
 
-        if stripped.start_with?("- ") || stripped == "-"
+        if SEQUENCE_ENTRY_RE.match?(line, pos)
           parse_sequence(indent, anchor)
-        elsif QUOTED_KEY_RE.match?(stripped)
+        elsif QUOTED_KEY_RE.match?(line, pos)
           # A mapping whose key is quoted, e.g. '"have: colon": value'.
           parse_mapping(indent, anchor)
-        elsif (stripped.start_with?("\"") && stripped.end_with?("\"")) ||
-              (stripped.start_with?("'") && stripped.end_with?("'"))
+        elsif (/\G"/.match?(line, pos) && line.end_with?("\"")) ||
+              (/\G'/.match?(line, pos) && line.end_with?("'"))
           # A whole-line quoted scalar, e.g. '"system: foo: bar"'. It may
           # contain ": ", so it must be checked before MAPPING_KEY_RE.
           parse_plain_scalar(indent, anchor)
-        elsif stripped =~ MAPPING_KEY_RE && !stripped.start_with?("!ruby/object:")
+        elsif MAPPING_KEY_RE.match?(line, pos) && !RUBY_OBJECT_TAG_RE.match?(line, pos)
           parse_mapping(indent, anchor)
-        elsif stripped.start_with?("!ruby/object:")
+        elsif RUBY_OBJECT_TAG_RE.match?(line, pos)
           parse_tagged_node(indent, anchor)
-        elsif stripped.start_with?("|")
-          modifier = stripped[1..].to_s.strip
+        elsif /\G\|/.match?(line, pos)
+          modifier = line[pos + 1, line.size].strip
           @lines.shift
-          register_anchor(anchor, Scalar.new(value: parse_block_scalar(indent, modifier)))
+          register_anchor(anchor, Scalar.new(parse_block_scalar(indent, modifier)))
         else
           parse_plain_scalar(indent, anchor)
         end
@@ -142,22 +141,26 @@ module Gem
       def parse_sequence(indent, anchor)
         items = []
         while @lines.any?
+          skip_blank_and_comments
+          break if @lines.empty?
           line = @lines[0]
-          stripped = line.lstrip
-          break unless line.size - stripped.size == indent &&
-                       (stripped.start_with?("- ") || stripped == "-")
-          content = @lines.shift.lstrip[1..].strip
-          item_anchor, content = extract_item_anchor(content)
+          break unless indent_of(line) == indent && SEQUENCE_ENTRY_RE.match?(line, indent)
+          @lines.shift
+          content = line[indent + 1, line.size]
+          content.strip!
+          item_anchor = nil
+          item_anchor, content = extract_item_anchor(content) if content.start_with?("&")
           item = parse_sequence_item(content, indent)
           items << register_anchor(item_anchor, item)
         end
-        register_anchor(anchor, Sequence.new(items: items))
+        register_anchor(anchor, Sequence.new(items))
       end
 
       def parse_sequence_item(content, indent)
         if content.start_with?("*")
           parse_inline_alias(content)
         elsif content.empty?
+          skip_blank_and_comments
           @lines.any? && current_indent > indent ? parse_node(indent) : nil
         elsif content.start_with?("!ruby/object:")
           parse_tagged_content(content.strip, indent)
@@ -167,11 +170,11 @@ module Gem
           @lines.unshift("#{" " * (indent + 2)}#{content}")
           parse_node(indent)
         elsif QUOTED_KEY_RE.match?(content) ||
-              (content =~ MAPPING_KEY_RE && !content.start_with?("!ruby/object:"))
+              (MAPPING_KEY_RE.match?(content) && !content.start_with?("!ruby/object:"))
           @lines.unshift("#{" " * (indent + 2)}#{content}")
           parse_node(indent)
         elsif content.start_with?("|")
-          Scalar.new(value: parse_block_scalar(indent, content[1..].to_s.strip))
+          Scalar.new(parse_block_scalar(indent, content[1..].to_s.strip))
         else
           parse_inline_scalar(content, indent)
         end
@@ -180,28 +183,33 @@ module Gem
       def parse_mapping(indent, anchor)
         pairs = []
         while @lines.any?
+          skip_blank_and_comments
+          break if @lines.empty?
           line = @lines[0]
-          stripped = line.lstrip
-          break unless line.size - stripped.size == indent
+          break unless indent_of(line) == indent
 
-          if (match = QUOTED_KEY_RE.match(stripped))
+          if (match = QUOTED_KEY_RE.match(line, indent))
             key = coerce(match[1])
-          elsif (match = MAPPING_KEY_RE.match(stripped)) && !stripped.start_with?("!ruby/object:")
-            key = match[1].strip
+          elsif (match = MAPPING_KEY_RE.match(line, indent)) && !RUBY_OBJECT_TAG_RE.match?(line, indent)
+            key = match[1]
+            key.strip!
             key = decode_binary_tag(key) if key.start_with?("!binary ")
           else
             break
           end
           @lines.shift
-          val = strip_comment(match[2].to_s.strip)
+          val = match[2]
+          val&.strip!
+          val = strip_comment(val || "")
 
-          val_anchor, val = consume_value_anchor(val)
+          val_anchor = nil
+          val_anchor, val = consume_value_anchor(val) if val.start_with?("&")
           value = parse_mapping_value(val, indent)
           value = register_anchor(val_anchor, value) if val_anchor
 
-          pairs << [Scalar.new(value: key), value]
+          pairs << key << value
         end
-        register_anchor(anchor, Mapping.new(pairs: pairs))
+        register_anchor(anchor, Mapping.new(pairs))
       end
 
       def parse_mapping_value(val, indent)
@@ -212,25 +220,19 @@ module Gem
         elsif val.start_with?("!binary ")
           parse_binary_value(val, indent)
         elsif val.empty?
-          next_stripped = nil
-          next_indent = nil
-          if @lines.any?
-            next_stripped = @lines[0].lstrip
-            next_indent = @lines[0].size - next_stripped.size
-          end
-          if next_stripped &&
-             (next_stripped.start_with?("- ") || next_stripped == "-") &&
-             next_indent == indent
+          skip_blank_and_comments
+          line = @lines[0]
+          if line && indent_of(line) == indent && SEQUENCE_ENTRY_RE.match?(line, indent)
             parse_node(indent)
           else
             parse_node(indent + 1)
           end
         elsif val == "[]"
-          Sequence.new
+          Sequence.new([])
         elsif val == "{}"
-          Mapping.new
+          Mapping.new([])
         elsif val.start_with?("|")
-          Scalar.new(value: parse_block_scalar(indent, val[1..].to_s.strip))
+          Scalar.new(parse_block_scalar(indent, val[1..].to_s.strip))
         else
           parse_inline_scalar(val, indent)
         end
@@ -253,21 +255,24 @@ module Gem
           node.anchor = anchor
           node
         else
-          Mapping.new(pairs: [[Scalar.new(value: "value"), node]], tag: tag, anchor: anchor)
+          Mapping.new(["value", node], tag, anchor)
         end
       end
 
       def parse_block_scalar(base_indent, modifier)
         parts = []
-        block_indent = nil
+        indentation = modifier[/\A[+-]?([1-9])/, 1]
+        chomping = modifier[/\A[1-9]?([+-])/, 1]
+        block_indent = indentation && base_indent + indentation.to_i
 
         while @lines.any?
           line = @lines[0]
-          if line.strip.empty?
+          if BLANK_RE.match?(line)
+            parts << line[block_indent..] if block_indent && line.size > block_indent
             parts << "\n"
             @lines.shift
           else
-            line_indent = line.size - line.lstrip.size
+            line_indent = indent_of(line)
             break if line_indent <= base_indent
             block_indent ||= line_indent
             parts << @lines.shift[block_indent..].to_s << "\n"
@@ -275,30 +280,35 @@ module Gem
         end
 
         res = parts.join
-        res.chomp! if modifier == "-" && res.end_with?("\n")
+        res.delete_suffix!("\n") while chomping == "-" && res.end_with?("\n")
         res
       end
 
       def parse_plain_scalar(indent, anchor)
-        result = coerce(@lines.shift.strip)
+        val = @lines.shift.strip
+        result = coerce(val)
         return register_anchor(anchor, result) if result.is_a?(Mapping) || result.is_a?(Sequence)
 
-        while result.is_a?(String) && @lines.any? &&
-              !@lines[0].strip.empty? && current_indent > indent
-          result << " " << @lines.shift.strip
-        end
-        register_anchor(anchor, Scalar.new(value: result))
+        fold_continuation_lines(result, val, indent)
+        register_anchor(anchor, Scalar.new(result))
       end
 
       def parse_inline_scalar(val, indent)
         result = coerce(val)
         return result if result.is_a?(Mapping) || result.is_a?(Sequence)
 
-        while result.is_a?(String) && @lines.any? &&
-              !@lines[0].strip.empty? && current_indent > indent
+        fold_continuation_lines(result, val, indent)
+        Scalar.new(result)
+      end
+
+      def fold_continuation_lines(result, val, indent)
+        return unless result.is_a?(String)
+
+        # "#" does not start a comment inside a quoted scalar that runs onto the next lines.
+        stop = val.start_with?("'", "\"") && result == val ? BLANK_RE : BLANK_OR_COMMENT_RE
+        while @lines.any? && !stop.match?(@lines[0]) && current_indent > indent
           result << " " << @lines.shift.strip
         end
-        Scalar.new(value: result)
       end
 
       def coerce(val, depth = 0)
@@ -306,25 +316,30 @@ module Gem
 
         val = val.sub(/^! /, "") if val.start_with?("! ")
 
-        if val =~ /^"(.*)"$/
-          $1.gsub(/\\(?:["\\0abtnvfre]|x\h{2})/) do |m|
-            STRING_UNESCAPES[m] || m[2..].to_i(16).chr(Encoding::UTF_8)
+        if val.size >= 2 && val.start_with?("\"") && val.end_with?("\"")
+          inner = val[1..-2]
+          return inner unless inner.include?("\\")
+          inner.gsub(/\\(?:["\\0abtnvfreN_LP]|x\h{2}|u\h{4}|U\h{8})/) do |m|
+            char = STRING_UNESCAPES[m] || unescape_code_point(m)
+            # Metadata is read as binary, where non-ASCII text stays as UTF-8 bytes.
+            Encoding.compatible?(inner, char) ? char : char.b
           end
-        elsif val =~ /^'(.*)'$/
-          $1.gsub(/''/, "'")
+        elsif val.size >= 2 && val.start_with?("'") && val.end_with?("'")
+          inner = val[1..-2]
+          inner.include?("''") ? inner.gsub("''", "'") : inner
         elsif val == "true"
           true
         elsif val == "false"
           false
-        elsif ["~", "null"].include?(val)
+        elsif NULL_SCALARS.include?(val)
           nil
         elsif val == "{}"
-          Mapping.new
+          Mapping.new([])
         elsif val =~ /^\[(.*)\]$/
           inner = $1.strip
-          return Sequence.new if inner.empty?
-          items = inner.split(/\s*,\s*/).reject(&:empty?).map {|e| Scalar.new(value: coerce(e, depth + 1)) }
-          Sequence.new(items: items)
+          return Sequence.new([]) if inner.empty?
+          items = inner.scan(FLOW_SEQUENCE_ENTRY_RE).map {|e| Scalar.new(coerce(e, depth + 1)) }
+          Sequence.new(items)
         elsif /\A\d{4}-\d{2}-\d{2}([ T]\d{2}:\d{2}:\d{2})?/.match?(val)
           begin
             Time.new(val)
@@ -343,6 +358,12 @@ module Gem
         end
       end
 
+      def unescape_code_point(escape)
+        code = escape[2..].hex
+        return escape if code > 0x10FFFF || code.between?(0xD800, 0xDFFF)
+        code.chr(Encoding::UTF_8)
+      end
+
       def decode_binary_tag(str)
         content = str.sub(/\A!binary\s+/, "")
         content = $1 if content =~ /\A"(.*)"\z/ || content =~ /\A'(.*)'\z/
@@ -353,23 +374,28 @@ module Gem
         rest = val.sub(/\A!binary\s+/, "")
         if rest.start_with?("|")
           content = parse_block_scalar(indent, rest[1..].to_s.strip)
-          Scalar.new(value: content.unpack1("m"))
+          Scalar.new(content.unpack1("m"))
         else
-          Scalar.new(value: decode_binary_tag(val))
+          Scalar.new(decode_binary_tag(val))
         end
       end
 
       def parse_alias_ref
-        AliasRef.new(name: @lines.shift.lstrip[1..].strip)
+        AliasRef.new(@lines.shift.lstrip[1..].strip)
       end
 
       def parse_inline_alias(content)
-        AliasRef.new(name: content[1..].strip)
+        AliasRef.new(content[1..].strip)
       end
 
       def current_indent
-        line = @lines[0]
-        line.size - line.lstrip.size
+        indent_of(@lines[0])
+      end
+
+      def indent_of(line)
+        i = 0
+        i += 1 while LSTRIP_BYTES.include?(line.getbyte(i))
+        i
       end
 
       def consume_anchor
@@ -414,12 +440,7 @@ module Gem
       end
 
       def skip_blank_and_comments
-        while @lines.any?
-          line = @lines[0]
-          stripped = line.lstrip
-          break unless stripped.empty? || stripped.start_with?("#")
-          @lines.shift
-        end
+        @lines.shift while @lines.any? && BLANK_OR_COMMENT_RE.match?(@lines[0])
       end
 
       def strip_comment(val)
@@ -542,8 +563,7 @@ module Gem
 
       def build_hash(node)
         result = {}
-        node.pairs.each do |key_node, value_node|
-          key = key_node.is_a?(Scalar) ? key_node.value.to_s : build_node(key_node).to_s
+        each_pair(node) do |key, value_node|
           value = build_node(value_node)
 
           if ARRAY_FIELDS.include?(key)
@@ -643,13 +663,21 @@ module Gem
 
       def pairs_to_hash(node)
         result = {}
-        node.pairs.each do |key_node, value_node|
-          key = key_node.is_a?(Scalar) ? key_node.value.to_s : build_node(key_node).to_s
+        each_pair(node) do |key, value_node|
           result[key] = build_node(value_node)
         end
         result
       end
 
+      def each_pair(node)
+        pairs = node.pairs
+        i = 0
+        while i < pairs.size
+          yield pairs[i], pairs[i + 1]
+          i += 2
+        end
+      end
+
       def validate_tag!(tag)
         return if @permitted_classes.include?(tag)
         raise_disallowed_class!(tag)

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: bundler
 version: !ruby/object:Gem::Version
-  version: 4.1.0.beta2
+  version: 4.1.0.beta3
 platform: ruby
 authors:
   - Yehuda Katz
@@ -411,7 +411,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       - !ruby/object:Gem::Version
         version: 3.4.1
 requirements: []
-rubygems_version: 4.1.0.beta2
+rubygems_version: 4.1.0.beta3
 specification_version: 4
 summary: The best way to manage your application's dependencies
 test_files: []