psych-pure 0.1.2 → 0.1.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0fb90297ca479adfe033c6d8db3544ec41c8e8083f23884e990de4ee2d8eb402
-  data.tar.gz: 8f895282ff5733903665ddcd0d1be2a28696dce0380242f8804ad42ce45123fe
+  metadata.gz: f1767eb97091e21f83527221b9ef4f156d9db40998b9008422b3dc017ff4ada6
+  data.tar.gz: b7e1d3b11886a31fda7fd7aed9937e2c26eaafa6d5e242a65bb89c8a02b00be7
 SHA512:
-  metadata.gz: 4ad4470231f6587e40da0fe271ef65a1ba441f70ecc87bd7900f4fcc17a2da4be63396b73d15a131359977b62e53cfbd9d333969dbd920e984c6647741bfab34
-  data.tar.gz: 17965e31133a24c3f14c9d452884665f0d40e0c2e3edbf573fc59db5888471fb934caed61b9bed836287253061e549e540e4b79085360f9ec7a9a8082f4b7107
+  metadata.gz: 7103d8ceae77bf15b2f21f9462f65fe495bf6e90206749fded264d192beb1caee6ae1a0585703ce914d7268a1e57f498f4cc1b824c21b3c5fe95edfb1dc1e320
+  data.tar.gz: 570ba899c74d5873ba243771ae3ff71605b59f81b1567f5f0712314aa2f8efbbdfab659c4e9bde63609ce2ef5ccce46352624c0f458ef6a8ddd31826edcfa9da

data/CHANGELOG.md

@@ -6,6 +6,18 @@ The format is based on [Keep a Changelog](http://keepachangelog.com/en/1.0.0/) a
 
 ## [Unreleased]
 
+## [0.1.4] - 2025-11-10
+
+- Fix up comment handling preceding sequence elements.
+- Properly update hashes in mutation methods that are loaded through `Psych::Pure.load`.
+- Properly raise syntax errors when the parser does not finish.
+
+## [0.1.3] - 2025-10-24
+
+- Fix up roundtripping when using `<<` inside mappings.
+- Fix up roundtripping when using duplicate keys inside mappings.
+- Fix up comment handling when using duplicate keys inside mappings.
+
 ## [0.1.2] - 2025-03-04
 
 - Fix up comment dumping to not drift around objects.
@@ -25,7 +37,8 @@ The format is based on [Keep a Changelog](http://keepachangelog.com/en/1.0.0/) a
 
 - 🎉 Initial release. 🎉
 
-[unreleased]: https://github.com/kddnewton/psych-pure/compare/v0.1.2...HEAD
+[unreleased]: https://github.com/kddnewton/psych-pure/compare/v0.1.3...HEAD
+[0.1.3]: https://github.com/kddnewton/psych-pure/compare/v0.1.2...v0.1.3
 [0.1.2]: https://github.com/kddnewton/psych-pure/compare/v0.1.1...v0.1.2
 [0.1.1]: https://github.com/kddnewton/psych-pure/compare/v0.1.0...v0.1.1
 [0.1.0]: https://github.com/kddnewton/psych-pure/compare/24de62...v0.1.0

data/lib/psych/pure/version.rb

@@ -2,6 +2,6 @@
 
 module Psych
   module Pure
-    VERSION = "0.1.2"
+    VERSION = "0.1.4"
   end
 end

data/lib/psych/pure.rb

@@ -7,6 +7,14 @@ require "strscan"
 require "stringio"
 
 module Psych
+  module Nodes
+    class Scalar
+      # The source of the scalar, as it was found in the input. This may be set
+      # in order to be reused when dumping the object.
+      attr_accessor :source
+    end
+  end
+
   # A YAML parser written in Ruby.
   module Pure
     # An internal exception is an exception that should not have occurred. It is
@@ -17,7 +25,7 @@ module Psych
       end
     end
 
-    # A source is wraps the input string and provides methods to access line and
+    # A source wraps the input string and provides methods to access line and
     # column information from a byte offset.
     class Source
       def initialize(string)
@@ -27,7 +35,13 @@ module Psych
         offset = 0
         string.each_line do |line|
           @line_offsets << offset
-          @trimmable_lines << line.match?(/\A(?: *#.*)?\n\z/)
+          @trimmable_lines <<
+            case line
+            when /\A *#.*\n\z/ then :comment
+            when /\A *\n\z/ then :blank
+            else false
+            end
+
           offset += line.bytesize
         end
 
@@ -43,6 +57,14 @@ module Psych
         offset
       end
 
+      def trim_comments(offset)
+        while (l = line(offset)) != 0 && (offset == @line_offsets[l]) && @trimmable_lines[l - 1] == :comment
+          offset = @line_offsets[l - 1]
+        end
+
+        offset
+      end
+
       def line(offset)
         index = @line_offsets.bsearch_index { |line_offset| line_offset > offset }
         return @line_offsets.size - 1 if index.nil?
@@ -64,6 +86,10 @@ module Psych
         @pos_end = pos_end
       end
 
+      def range
+        @pos_start...@pos_end
+      end
+
       def start_line
         @source.line(@pos_start)
       end
@@ -89,6 +115,11 @@ module Psych
         Location.new(@source, @pos_start, @source.trim(@pos_end))
       end
 
+      # Trim trailing comments from this location.
+      def trim_comments
+        Location.new(@source, @pos_start, @source.trim_comments(@pos_end))
+      end
+
       def to_a
         [start_line, start_column, end_line, end_column]
       end
@@ -145,6 +176,20 @@ module Psych
       def trailing_comment(comment)
         @trailing << comment
       end
+
+      # Execute the given block without the leading comments being visible. This
+      # is used when a node has already handled its child nodes' leading
+      # comments, so they should not be processed again.
+      def without_leading
+        leading = @leading
+
+        begin
+          @leading = []
+          yield
+        ensure
+          @leading = leading
+        end
+      end
     end
 
     # Wraps a Ruby object with its node from the source input.
@@ -161,32 +206,274 @@ module Psych
         @psych_node = psych_node
         @dirty = dirty
       end
+
+      def replace(psych_node)
+        @psych_node = psych_node
+        @dirty = true
+      end
     end
 
     # Wraps a Ruby hash with its node from the source input.
     class LoadedHash < SimpleDelegator
+      class PsychKey
+        attr_reader :key_node, :value_node
+
+        def initialize(key_node, value_node)
+          @key_node = key_node
+          @value_node = value_node
+        end
+
+        def replace_key(key_node)
+          @key_node = key_node
+        end
+
+        def replace_value(value_node)
+          @value_node = value_node
+        end
+      end
+
       # The node associated with the hash.
       attr_reader :psych_node
 
-      # The nodes associated with the keys of the hash.
-      attr_reader :psych_node_keys
+      # The list of key/value pairs within the hash.
+      attr_reader :psych_keys
 
-      def initialize(object, psych_node, psych_node_keys = {})
+      def initialize(object, psych_node)
         super(object)
         @psych_node = psych_node
-        @psych_node_keys = psych_node_keys
+        @psych_keys = []
+      end
+
+      def set!(key_node, value_node)
+        @psych_keys << PsychKey.new(key_node, value_node)
+        __getobj__[key_node.__getobj__] = value_node
+      end
+
+      def join!(key_node, value_node)
+        @psych_keys << PsychKey.new(key_node, value_node)
+        merge!(value_node)
+      end
+
+      def psych_assocs
+        @psych_keys.map { |psych_key| [psych_key.key_node, psych_key.value_node] }
+      end
+
+      # Override Hash mutation methods to keep @psych_keys in sync.
+
+      def initialize_clone(obj, freeze: nil)
+        super
+        @psych_keys = obj.psych_keys.map(&:dup)
+      end
+
+      def initialize_dup(obj)
+        super
+        @psych_keys = obj.psych_keys.map(&:dup)
       end
 
       def []=(key, value)
-        if (previous = self[key])
-          if previous.is_a?(LoadedObject)
-            value = LoadedObject.new(value, previous.psych_node, true)
-          elsif previous.is_a?(LoadedHash)
-            value = LoadedHash.new(value, previous.psych_node, previous.psych_node_keys)
+        super(key, value)
+
+        if (psych_key = @psych_keys.reverse_each.find { |psych_key| psych_compare?(psych_key.key_node, key) })
+          psych_key.replace_value(value)
+        else
+          @psych_keys << PsychKey.new(key, value)
+        end
+
+        value
+      end
+
+      alias store []=
+
+      def clear
+        super
+        @psych_keys.clear
+
+        self
+      end
+
+      def compact!
+        mutated = false
+        @psych_keys.each do |psych_key|
+          if psych_unwrap(psych_key.value_node).nil?
+            mutated = true
+            delete(psych_unwrap(psych_key.key_node))
           end
         end
 
-        super(key, value)
+        self if mutated
+      end
+
+      def compact
+        dup.compact!
+      end
+
+      def delete(key)
+        result = super
+        psych_delete(key)
+
+        result
+      end
+
+      def delete_if(&block)
+        super do |key, value|
+          yield(key, psych_unwrap(value)).tap do |result|
+            psych_delete(key) if result
+          end
+        end
+
+        self
+      end
+
+      def except(*keys)
+        dup.delete_if { |key, _| keys.include?(key) }
+      end
+
+      def filter!(&block)
+        mutated = false
+        super do |key, value|
+          yield(key, psych_unwrap(value)).tap do |result|
+            unless result
+              psych_delete(key)
+              mutated = true
+            end
+          end
+        end
+
+        self if mutated
+      end
+
+      def filter(&block)
+        dup.filter!(&block)
+      end
+
+      def invert
+        result = LoadedHash.new({}, @psych_node)
+        each { |key, value| result[psych_unwrap(value)] = key }
+        result
+      end
+
+      def keep_if(&block)
+        super do |key, value|
+          yield(key, psych_unwrap(value)).tap do |result|
+            psych_delete(key) unless result
+          end
+        end
+
+        self
+      end
+
+      alias select! keep_if
+
+      def merge!(*others)
+        super
+        others.each do |other|
+          other.each do |key, value|
+            psych_delete(key)
+            @psych_keys << PsychKey.new(key, value)
+          end
+        end
+
+        self
+      end
+
+      alias update merge!
+
+      def merge(*others)
+        dup.merge!(*others)
+      end
+
+      def reject!(&block)
+        mutated = false
+        super do |key, value|
+          yield(key, psych_unwrap(value)).tap do |result|
+            if result
+              psych_delete(key)
+              mutated = true
+            end
+          end
+        end
+
+        self if mutated
+      end
+
+      def reject(&block)
+        dup.reject!(&block)
+      end
+
+      def replace(other)
+        super
+
+        @psych_keys.clear
+        other.each { |key, value| @psych_keys << PsychKey.new(key, value) }
+
+        self
+      end
+
+      def shift
+        unless empty?
+          key, value = super
+          psych_delete(key)
+
+          [key, value]
+        end
+      end
+
+      def slice(*keys)
+        dup.select! { |key, _| keys.include?(key) }
+      end
+
+      def transform_keys!(&block)
+        super do |key|
+          yield(key).tap do |result|
+            @psych_keys
+              .reverse_each
+              .find { |psych_key| psych_compare?(psych_key.key_node, key) }
+              &.replace_key(result)
+          end
+        end
+
+        self
+      end
+
+      def transform_keys(&block)
+        dup.transform_keys!(&block)
+      end
+
+      def transform_values!(&block)
+        super do |value|
+          yield(psych_unwrap(value)).tap do |result|
+            @psych_keys
+              .reverse_each
+              .find { |psych_key| psych_compare?(psych_key.value_node, value) }
+              &.replace_value(result)
+          end
+        end
+      end
+
+      def transform_values(&block)
+        dup.transform_values!(&block)
+      end
+
+      private
+
+      def psych_compare?(psych_node, value)
+        if compare_by_identity?
+          psych_unwrap(psych_node).equal?(value)
+        else
+          psych_unwrap(psych_node).eql?(value)
+        end
+      end
+
+      def psych_delete(key)
+        @psych_keys.reject! { |psych_key| psych_compare?(psych_key.key_node, key) }
+      end
+
+      def psych_unwrap(node)
+        if node.is_a?(LoadedHash) || node.is_a?(LoadedObject)
+          node.__getobj__
+        else
+          node
+        end
       end
     end
 
@@ -349,8 +636,6 @@ module Psych
         def initialize(ss, class_loader, symbolize_names: false, freeze: false, comments: false)
           super(ss, class_loader, symbolize_names: symbolize_names, freeze: freeze)
           @comments = comments
-          @nodeless_objs = {}.compare_by_identity
-          @nodeless_keys = {}.compare_by_identity
         end
 
         def accept(node)
@@ -360,31 +645,66 @@ module Psych
             case result
             when LoadedObject, LoadedHash
               # skip
-            when Hash
-              if !@nodeless_objs.key?(result)
-                nodeless_obj = {}
-                nodeless_key = {}
-
-                result.each do |key, value|
-                  if key.is_a?(LoadedObject) || key.is_a?(LoadedHash)
-                    nodeless_obj[key.__getobj__] = value
-                    nodeless_key[key.__getobj__] = key
-                  else
-                    nodeless_obj[key] = value
+            else
+              result = LoadedObject.new(result, node)
+            end
+          end
+
+          result
+        end
+
+        private
+
+        def revive_hash(hash, node, tagged = false)
+          return super unless @comments
+
+          revived = LoadedHash.new(hash, node)
+          node.children.each_slice(2) do |key_node, value_node|
+            key = accept(key_node)
+            value = accept(value_node)
+
+            if key == "<<" && key_node.tag != "tag:yaml.org,2002:str"
+              case value_node
+              when Nodes::Alias, Nodes::Mapping
+                begin
+                  # h1:
+                  #   <<: *h2
+                  #   <<: { k: v }
+                  revived.join!(key, value)
+                rescue TypeError
+                  # a: &a [1, 2, 3]
+                  # h: { <<: *a }
+                  revived.set!(key, value)
+                end
+              when Nodes::Sequence
+                # h1:
+                #   <<: [*h2, *h3]
+                begin
+                  temporary = {}
+                  value.reverse_each { |value| temporary.merge!(value) }
+                rescue TypeError
+                  revived.set!(key, value)
+                else
+                  value_node.children.zip(value).reverse_each do |(child_value_node, child_value)|
+                    revived.join!(key, child_value)
                   end
                 end
-
-                @nodeless_objs[result] = nodeless_obj
-                @nodeless_keys[result] = nodeless_key
+              else
+                # k: v
+                revived.set!(key, value)
               end
-
-              result = LoadedHash.new(@nodeless_objs.fetch(result), node, @nodeless_keys.fetch(result))
             else
-              result = LoadedObject.new(result, node)
+              if !tagged && @symbolize_names && key.is_a?(String)
+                key = key.to_sym
+              elsif !@freeze
+                key = deduplicate(key)
+              end
+
+              revived.set!(key, value)
             end
           end
 
-          result
+          revived
         end
       end
 
@@ -493,11 +813,12 @@ module Psych
     # A scalar event represents a single value in the YAML document. It can be
     # many different types.
     class Scalar
-      attr_reader :location, :value, :style
+      attr_reader :location, :source, :value, :style
       attr_accessor :anchor, :tag
 
-      def initialize(location, value, style)
+      def initialize(location, source, value, style)
         @location = location
+        @source = source
         @value = value
         @anchor = nil
         @tag = nil
@@ -506,14 +827,19 @@ module Psych
 
       def accept(handler)
         handler.event_location(*@location.trim)
-        handler.scalar(
-          @value,
-          @anchor,
-          @tag,
-          (!@tag || @tag == "!") && (@style == Nodes::Scalar::PLAIN),
-          (!@tag || @tag == "!") && (@style != Nodes::Scalar::PLAIN),
-          @style
-        )
+
+        event =
+          handler.scalar(
+            @value,
+            @anchor,
+            @tag,
+            (!@tag || @tag == "!") && (@style == Nodes::Scalar::PLAIN),
+            (!@tag || @tag == "!") && (@style != Nodes::Scalar::PLAIN),
+            @style
+          )
+
+        event.source = source if event.is_a?(Nodes::Scalar)
+        event
       end
     end
 
@@ -650,9 +976,7 @@ module Psych
         @source = Source.new(yaml)
         @comments = {} if comments
 
-        raise_syntax_error("Parser failed to complete") unless parse_l_yaml_stream
-        raise_syntax_error("Parser finished before end of input") unless @scanner.eos?
-
+        parse_l_yaml_stream
         @comments = nil if comments
         true
       end
@@ -1149,11 +1473,8 @@ module Psych
       #   b-comment
       def parse_s_b_comment
         try do
-          try do
-            if parse_s_separate_in_line
-              parse_c_nb_comment_text(true)
-              true
-            end
+          if parse_s_separate_in_line
+            parse_c_nb_comment_text(true)
           end
 
           parse_b_comment
@@ -1453,7 +1774,7 @@ module Psych
       # e-scalar ::=
       #   <empty>
       def parse_e_scalar
-        events_push_flush_properties(Scalar.new(Location.point(@source, @scanner.pos), "", Nodes::Scalar::PLAIN))
+        events_push_flush_properties(Scalar.new(Location.point(@source, @scanner.pos), "", "", Nodes::Scalar::PLAIN))
         true
       end
 
@@ -1557,7 +1878,7 @@ module Psych
             end
           end
 
-          events_push_flush_properties(Scalar.new(Location.new(@source, pos_start, @scanner.pos), value, Nodes::Scalar::DOUBLE_QUOTED))
+          events_push_flush_properties(Scalar.new(Location.new(@source, pos_start, @scanner.pos), from(pos_start), value, Nodes::Scalar::DOUBLE_QUOTED))
           true
         end
       end
@@ -1701,7 +2022,7 @@ module Psych
           value.gsub!(/(?:[\ \t]*\r?\n[\ \t]*)/, "\n")
           value.gsub!(/\n(\n*)/) { $1.empty? ? " " : $1 }
           value.gsub!("''", "'")
-          events_push_flush_properties(Scalar.new(Location.new(@source, pos_start, @scanner.pos), value, Nodes::Scalar::SINGLE_QUOTED))
+          events_push_flush_properties(Scalar.new(Location.new(@source, pos_start, @scanner.pos), from(pos_start), value, Nodes::Scalar::SINGLE_QUOTED))
           true
         end
       end
@@ -1952,12 +2273,9 @@ module Psych
           if parse_ns_flow_seq_entry(n, c)
             parse_s_separate(n, c)
 
-            try do
-              if match(",")
-                parse_s_separate(n, c)
-                parse_ns_s_flow_seq_entries(n, c)
-                true
-              end
+            if match(",")
+              parse_s_separate(n, c)
+              parse_ns_s_flow_seq_entries(n, c)
             end
 
             true
@@ -2241,10 +2559,13 @@ module Psych
           end
 
         if result
-          value = from(pos_start)
+          source = from(pos_start)
+
+          value = source.dup
           value.gsub!(/(?:[\ \t]*\r?\n[\ \t]*)/, "\n")
           value.gsub!(/\n(\n*)/) { $1.empty? ? " " : $1 }
-          events_push_flush_properties(Scalar.new(Location.new(@source, pos_start, @scanner.pos), value, Nodes::Scalar::PLAIN))
+
+          events_push_flush_properties(Scalar.new(Location.new(@source, pos_start, @scanner.pos), source, value, Nodes::Scalar::PLAIN))
         end
 
         result
@@ -2470,8 +2791,7 @@ module Psych
           parse_l_literal_content(n + m, t)
         } then
           @in_scalar = false
-          lines = events_cache_pop
-          value = lines.map { |line| "#{line}\n" }.join
+          value = events_cache_pop.map { |line| "#{line}\n" }.join
 
           case t
           when :clip
@@ -2484,7 +2804,8 @@ module Psych
             raise InternalException, t.inspect
           end
 
-          events_push_flush_properties(Scalar.new(Location.new(@source, pos_start, @scanner.pos), value, Nodes::Scalar::LITERAL))
+          location = Location.new(@source, pos_start, @scanner.pos).trim_comments
+          events_push_flush_properties(Scalar.new(location, @scanner.string.byteslice(location.range).chomp, value, Nodes::Scalar::LITERAL))
           true
         else
           @in_scalar = false
@@ -2582,7 +2903,8 @@ module Psych
             raise InternalException, t.inspect
           end
 
-          events_push_flush_properties(Scalar.new(Location.new(@source, pos_start, @scanner.pos), value, Nodes::Scalar::FOLDED))
+          location = Location.new(@source, pos_start, @scanner.pos).trim_comments
+          events_push_flush_properties(Scalar.new(location, @scanner.string.byteslice(location.range).chomp, value, Nodes::Scalar::FOLDED))
           true
         else
           @in_scalar = false
@@ -3079,34 +3401,32 @@ module Psych
       def parse_l_yaml_stream
         events_push_flush_properties(StreamStart.new(Location.point(@source, @scanner.pos)))
 
-        if try {
-          if parse_l_document_prefix
-            @document_start_event = DocumentStart.new(Location.point(@source, @scanner.pos))
-            @tag_directives = @document_start_event.tag_directives
-            @document_end_event = nil
+        star { parse_l_document_prefix }
+        @document_start_event = DocumentStart.new(Location.point(@source, @scanner.pos))
+        @tag_directives = @document_start_event.tag_directives
+        @document_end_event = nil
+        parse_l_any_document
 
-            parse_l_any_document
-            star do
-              try do
-                if parse_l_document_suffix
-                  star { parse_l_document_prefix }
-                  parse_l_any_document
-                  true
-                end
-              end ||
-              try do
-                if parse_l_document_prefix
-                  parse_l_explicit_document
-                  true
-                end
-              end
+        star do
+          try do
+            if parse_l_document_suffix
+              star { parse_l_document_prefix }
+              parse_l_any_document
+              true
+            end
+          end ||
+          try do
+            if parse_l_document_prefix
+              parse_l_explicit_document
+              true
             end
           end
-        } then
-          document_end_event_flush
-          events_push_flush_properties(StreamEnd.new(Location.point(@source, @scanner.pos)))
-          true
         end
+
+        raise_syntax_error("Parser finished before end of input") unless @scanner.eos?
+        document_end_event_flush
+        events_push_flush_properties(StreamEnd.new(Location.point(@source, @scanner.pos)))
+        true
       end
 
       # ------------------------------------------------------------------------
@@ -3182,6 +3502,9 @@ module Psych
 
       # Represents the nil value.
       class NilNode < Node
+        def accept(visitor)
+          raise "Visiting NilNode is not supported"
+        end
       end
 
       # Represents a generic object that is not matched by any of the other node
@@ -3220,8 +3543,14 @@ module Psych
 
       # Represents a string object.
       class StringNode < Node
+        # The explicit tag associated with the object.
         attr_accessor :tag
 
+        # Whether or not this object was modified after being loaded. In this
+        # case we cannot rely on the source formatting, and need to instead
+        # format the value ourselves.
+        attr_accessor :dirty
+
         def accept(visitor)
           visitor.visit_string(self)
         end
@@ -3264,13 +3593,17 @@ module Psych
         # Visit an ObjectNode.
         def visit_object(node)
           with_comments(node) do |value|
-            if (tag = node.tag)
-              @q.text("#{tag} ")
-            end
-
             if !node.dirty && (psych_node = node.psych_node)
-              @q.text(psych_node.value)
+              if (tag = node.tag)
+                @q.text("#{tag} ")
+              end
+
+              @q.text(psych_node.source || psych_node.value)
             else
+              if (tag = node.tag) && tag != "tag:yaml.org,2002:binary"
+                @q.text("#{tag} ")
+              end
+
               @q.text(dump_object(value))
             end
           end
@@ -3293,11 +3626,19 @@ module Psych
         # Visit a StringNode.
         def visit_string(node)
           with_comments(node) do |value|
-            if (tag = node.tag)
-              @q.text("#{tag} ")
-            end
+            if !node.dirty && (psych_node = node.psych_node)
+              if (tag = node.tag)
+                @q.text("#{tag} ")
+              end
 
-            @q.text(dump_object(value))
+              @q.text(psych_node.source || psych_node.value)
+            else
+              if (tag = node.tag) && tag != "tag:yaml.org,2002:binary"
+                @q.text("#{tag} ")
+              end
+
+              @q.text(dump_object(value))
+            end
           end
         end
 
@@ -3334,12 +3675,38 @@ module Psych
             @q.breakable
           end
 
-          @q.seplist(contents, -> { @q.breakable }) do |element|
+          current_line = nil
+          contents.each_with_index do |element, index|
+            psych_node = element.psych_node
+            leading = psych_node&.comments&.leading
+
+            if index > 0
+              @q.breakable
+
+              if current_line && psych_node
+                start_line = (leading&.first || psych_node).start_line
+                @q.breakable if start_line - current_line >= 2
+              end
+            end
+
+            current_line = psych_node&.end_line
+            visit_leading_comments(leading) if leading&.any?
+
+            if psych_node && (trailing = psych_node.comments.trailing).any?
+              current_line = trailing.last.end_line
+            end
+
             @q.text("-")
             next if element.is_a?(NilNode)
 
             @q.text(" ")
-            @q.nest(2) { visit(element) }
+            @q.nest(2) do
+              if psych_node
+                psych_node.comments.without_leading { visit(element) }
+              else
+                visit(element)
+              end
+            end
           end
 
           @q.current_group.break
@@ -3447,9 +3814,26 @@ module Psych
             @q.breakable
           end
 
+          current_line = nil
           ((0...children.length) % 2).each do |index|
-            @q.breakable if index != 0
-            visit_hash_key_value(children[index], children[index + 1])
+            key = children[index]
+            value = children[index + 1]
+
+            if index > 0
+              @q.breakable
+
+              if current_line && (psych_node = key.psych_node)
+                start_line = psych_node.start_line
+                if (leading = key.psych_node.comments.leading).any?
+                  start_line = leading.first.start_line
+                end
+
+                @q.breakable if start_line - current_line >= 2
+              end
+            end
+
+            current_line = (psych_node = value.psych_node) ? psych_node.end_line : nil
+            visit_hash_key_value(key, value)
           end
 
           @q.current_group.break
@@ -3478,23 +3862,29 @@ module Psych
           end
         end
 
+        # Visit the leading comments for a node, printing them out with proper
+        # line breaks.
+        def visit_leading_comments(comments)
+          line = nil
+
+          comments.each do |comment|
+            while line && line < comment.start_line
+              @q.breakable
+              line += 1
+            end
+
+            @q.text(comment.value)
+            line = comment.end_line
+          end
+
+          @q.breakable
+        end
+
         # Print out the leading and trailing comments of a node, as well as
         # yielding the value of the node to the block.
         def with_comments(node)
           if (comments = node.psych_node&.comments) && (leading = comments.leading).any?
-            line = nil
-
-            leading.each do |comment|
-              while line && line < comment.start_line
-                @q.breakable
-                line += 1
-              end
-
-              @q.text(comment.value)
-              line = comment.end_line
-            end
-
-            @q.breakable
+            visit_leading_comments(leading)
           end
 
           yield node.value
@@ -3576,6 +3966,7 @@ module Psych
         # Very rare circumstance here that there are leading comments attached
         # to the root object of a document that occur before the --- marker. In
         # this case we want to output them first here, then dump the object.
+        reload_comments = nil
         if (object.is_a?(LoadedObject) || object.is_a?(LoadedHash)) && (psych_node = object.psych_node).comments? && (leading = psych_node.comments.leading).any?
           leading = [*leading]
           line = psych_node.start_line - 1
@@ -3598,6 +3989,8 @@ module Psych
 
             line = comment.start_line
           end
+
+          reload_comments = leading.concat(psych_node.comments.leading)
         end
 
         @io << "---"
@@ -3620,6 +4013,12 @@ module Psych
 
           @io << q.output
         end
+
+        # If we initially split up the leading comments, then we need to reload
+        # them back to their original state here.
+        unless reload_comments.nil?
+          object.psych_node.comments.leading.replace(reload_comments)
+        end
       end
 
       private
@@ -3627,8 +4026,6 @@ module Psych
       # Dump the tag value for a given node.
       def dump_tag(value)
         case value
-        when nil, "tag:yaml.org,2002:binary"
-          nil
         when /\Atag:yaml.org,2002:(.+)\z/
           "!!#{$1}"
         else
@@ -3655,7 +4052,14 @@ module Psych
           end
 
           if @object_nodes.key?(object)
-            AliasNode.new(@object_nodes[object].anchor = (@object_anchors[object] ||= (@object_anchor += 1)), nil)
+            @object_anchors[object] ||=
+              if psych_node.is_a?(Nodes::Alias)
+                psych_node.anchor
+              else
+                @object_anchor += 1
+              end
+
+            AliasNode.new(@object_nodes[object].anchor = @object_anchors[object], psych_node)
           else
             case object
             when Psych::Omap
@@ -3670,8 +4074,7 @@ module Psych
             when Hash
               contents =
                 if base_object.is_a?(LoadedHash)
-                  psych_node_keys = base_object.psych_node_keys    
-                  object.flat_map { |key, value| [dump(psych_node_keys.fetch(key, key)), dump(value)] }
+                  base_object.psych_assocs.flat_map { |(key, value)| [dump(key), dump(value)] }
                 else
                   object.flat_map { |key, value| [dump(key), dump(value)] }
                 end
@@ -3683,13 +4086,12 @@ module Psych
             when String
               dumped = StringNode.new(object, psych_node)
               dumped.tag = dump_tag(psych_node&.tag)
-
+              dumped.dirty = dirty
               dumped
             else
               dumped = ObjectNode.new(object, psych_node)
               dumped.tag = dump_tag(psych_node&.tag)
               dumped.dirty = dirty
-
               dumped
             end
           end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: psych-pure
 version: !ruby/object:Gem::Version
-  version: 0.1.2
+  version: 0.1.4
 platform: ruby
 authors:
 - Kevin Newton
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2025-03-04 00:00:00.000000000 Z
+date: 2025-11-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: psych
@@ -113,7 +113,7 @@ licenses:
 - MIT
 metadata:
   bug_tracker_uri: https://github.com/kddnewton/psych-pure/issues
-  changelog_uri: https://github.com/kddnewton/psych-pure/blob/v0.1.2/CHANGELOG.md
+  changelog_uri: https://github.com/kddnewton/psych-pure/blob/v0.1.4/CHANGELOG.md
   source_code_uri: https://github.com/kddnewton/psych-pure
   rubygems_mfa_required: 'true'
 post_install_message: