yaml-janitor 20260406.1 → 20260406.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: abcc9adc3f21f808aab705842175693a36722392d5da69757579bfaaef0c0f1a
-  data.tar.gz: 31249485c56fda0ed92b0fed092b0b864fcb82cccd643e71a0ffbec382777cf2
+  metadata.gz: fb223767d0b5e017b8970002eb29b3ebc595d920d7dc09e9e872b1aa606eef5f
+  data.tar.gz: 214424d3a8d3544d23e00af3a4a5d666cbc641409681aabec7293082d9240a74
 SHA512:
-  metadata.gz: 8d8fabe90ec71b5c5921078194ab313dfb458e7f84ca64ac58ac13720209c92008c443fda49093bc2bef934c8f7ef387b8215cf730776769995498413df7ee86
-  data.tar.gz: d397efb992b5ab7c7569bf76c0b02aceb320c46a5f788ccf6898c2ddd23ca689c3cfb0bd6d19bb634787e3728f14ea84e31a53a235c8dc898bb01b8e714d8c54
+  metadata.gz: 9eb25e96054a887664b893c5a4395d81385bb931ee04dfe79b2438d5a7099bcad05d22637673e056556cb4392a515de45eb686c99ef8e083f18d8a3afa0548d1
+  data.tar.gz: 118d8f81448af12f8fc0a852ec55e52798cbae4935ae08c9a13ee9e21a42fce1dcadbd4ac3fc273e58f1010a286f53e99140b5048a8a366e1ecefd1cfb356255

data/lib/yaml_janitor/emitter.rb

@@ -5,44 +5,60 @@ module YamlJanitor
   # according to configuration rules. Unlike Psych::Pure.dump, we have
   # complete control over formatting choices.
   class Emitter
-    def initialize(node, config)
+    def initialize(node, config, ast: nil)
       @node = node
       @config = config
       @output = []
+      @ast = ast
+      @ast_root = extract_ast_root(ast)
     end
 
     def emit
       # Emit any leading comments on the root document
       emit_comments(get_comments(@node, :leading), 0)
 
-      emit_document(@node)
+      emit_document(@node, ast_node: @ast_root)
       @output.join("\n") + "\n"
     end
 
     private
 
-    def emit_document(node, indent: 0)
+    def emit_document(node, indent: 0, ast_node: nil)
       case node
       when Psych::Pure::LoadedHash
-        emit_mapping(node, indent)
+        emit_mapping(node, indent, ast_node: ast_node)
       when Hash
-        emit_mapping(node, indent)
+        emit_mapping(node, indent, ast_node: ast_node)
       when Psych::Pure::LoadedObject
         # Check if it wraps an array
         inner = node.__getobj__
         if inner.is_a?(Array)
-          emit_sequence(inner, indent, loaded_object: node)
+          emit_sequence(inner, indent, loaded_object: node, ast_node: ast_node)
         else
-          emit_node(inner, indent)
+          emit_node(inner, indent, ast_node: ast_node)
         end
       when Array
-        emit_sequence(node, indent)
+        emit_sequence(node, indent, ast_node: ast_node)
       else
         emit_scalar(node, indent)
       end
     end
 
-    def emit_mapping(hash, indent)
+    def emit_mapping(hash, indent, ast_node: nil)
+      ast_pairs = ast_mapping_pairs(ast_node)
+
+      # If the AST has anchors or aliases, use AST-driven emission
+      # because the loaded hash may have already expanded the aliases
+      has_anchors_or_aliases = ast_pairs.any? do |_, v|
+        v.is_a?(Psych::Nodes::Alias) ||
+          (v.respond_to?(:anchor) && v.anchor) ||
+          (v.is_a?(Psych::Nodes::Mapping) && v.children.each_slice(2).any? { |_, cv| cv.is_a?(Psych::Nodes::Alias) })
+      end
+      if has_anchors_or_aliases
+        emit_mapping_from_ast(ast_pairs, indent)
+        return
+      end
+
       # Use psych_keys if available (LoadedHash), otherwise fall back to regular iteration
       entries = if hash.respond_to?(:psych_keys)
         hash.psych_keys.map { |pk| [pk.key_node, pk.value_node] }
@@ -51,6 +67,8 @@ module YamlJanitor
       end
 
       entries.each_with_index do |(key, value), index|
+        _ast_key, ast_value = ast_pairs[index] || [nil, nil]
+
         # Add blank line between top-level keys if configured
         actual_value = value.is_a?(Psych::Pure::LoadedObject) ? value.__getobj__ : value
         @output << "" if index > 0 && indent == 0 && should_add_blank_line?(actual_value)
@@ -61,13 +79,26 @@ module YamlJanitor
         # Emit the key-value pair
         key_str = scalar_to_string(key.is_a?(Psych::Pure::LoadedObject) ? key.__getobj__ : key)
 
+        # Check if this value is an alias in the AST
+        if ast_value&.is_a?(Psych::Nodes::Alias)
+          @output << "#{' ' * indent}#{key_str}: *#{ast_value.anchor}"
+          emit_comments(get_comments(key, :trailing), indent)
+          next
+        end
+
+        # Check if the value has an anchor
+        anchor_suffix = ""
+        if ast_value&.respond_to?(:anchor) && ast_value.anchor
+          anchor_suffix = " &#{ast_value.anchor}"
+        end
+
         # Unwrap LoadedObject to check the actual type
         actual_value = value.is_a?(Psych::Pure::LoadedObject) ? value.__getobj__ : value
 
         case actual_value
         when Hash, Psych::Pure::LoadedHash, Array
           # Complex value - put on next line
-          line = "#{' ' * indent}#{key_str}:"
+          line = "#{' ' * indent}#{key_str}:#{anchor_suffix}"
 
           # Check for inline comment on the value
           if (trailing = get_comments(value, :trailing))
@@ -79,14 +110,14 @@ module YamlJanitor
           end
 
           @output << line
-          emit_node(value, indent + indentation)
+          emit_node(value, indent + indentation, ast_node: ast_value)
 
           # Emit any non-inline trailing comments
           emit_comments(trailing, indent) if trailing&.any?
         else
           # Simple value - same line
           value_str = scalar_to_string(actual_value)
-          line = "#{' ' * indent}#{key_str}: #{value_str}"
+          line = "#{' ' * indent}#{key_str}:#{anchor_suffix} #{value_str}"
 
           # Check for inline comment on the value
           if (trailing = get_comments(value, :trailing))
@@ -102,7 +133,7 @@ module YamlJanitor
       end
     end
 
-    def emit_sequence(array, indent, loaded_object: nil)
+    def emit_sequence(array, indent, loaded_object: nil, ast_node: nil)
       array.each_with_index do |item, index|
         # Emit any leading comments (check both the item and the LoadedObject wrapper)
         comments = get_comments(item, :leading) || (loaded_object ? get_comments(loaded_object, :leading) : nil)
@@ -188,14 +219,14 @@ module YamlJanitor
       end
     end
 
-    def emit_node(node, indent)
+    def emit_node(node, indent, ast_node: nil)
       case node
       when Psych::Pure::LoadedHash, Hash
-        emit_mapping(node, indent)
+        emit_mapping(node, indent, ast_node: ast_node)
       when Psych::Pure::LoadedObject
-        emit_node(node.__getobj__, indent)
+        emit_node(node.__getobj__, indent, ast_node: ast_node)
       when Array
-        emit_sequence(node, indent)
+        emit_sequence(node, indent, ast_node: ast_node)
       else
         @output << "#{' ' * indent}#{scalar_to_string(node)}"
       end
@@ -282,8 +313,125 @@ module YamlJanitor
       value.is_a?(Hash) || value.is_a?(Array)
     end
 
+    # Emit a mapping by walking the AST directly.
+    # Used when the mapping contains aliases that got expanded in the loaded data.
+    def emit_mapping_from_ast(ast_pairs, indent)
+      ast_pairs.each_with_index do |(ast_key, ast_value), index|
+        key_str = ast_key.value rescue ast_key.to_s
+
+        if ast_value.is_a?(Psych::Nodes::Alias)
+          # Emit alias reference
+          @output << "#{' ' * indent}#{key_str}: *#{ast_value.anchor}"
+        elsif ast_value.is_a?(Psych::Nodes::Mapping)
+          anchor_suffix = ast_value.anchor ? " &#{ast_value.anchor}" : ""
+          @output << "#{' ' * indent}#{key_str}:#{anchor_suffix}"
+          # Recurse into the mapping's AST children
+          child_pairs = ast_value.children.each_slice(2).to_a
+          if child_pairs.any? { |_, v| v.is_a?(Psych::Nodes::Alias) }
+            emit_mapping_from_ast(child_pairs, indent + indentation)
+          else
+            child_pairs.each do |ck, cv|
+              ck_str = ck.value rescue ck.to_s
+              if cv.is_a?(Psych::Nodes::Scalar)
+                @output << "#{' ' * (indent + indentation)}#{ck_str}: #{format_ast_scalar(cv)}"
+              elsif cv.is_a?(Psych::Nodes::Alias)
+                @output << "#{' ' * (indent + indentation)}#{ck_str}: *#{cv.anchor}"
+              elsif cv.is_a?(Psych::Nodes::Mapping)
+                anchor_suffix = cv.anchor ? " &#{cv.anchor}" : ""
+                @output << "#{' ' * (indent + indentation)}#{ck_str}:#{anchor_suffix}"
+                emit_mapping_from_ast(cv.children.each_slice(2).to_a, indent + indentation * 2)
+              elsif cv.is_a?(Psych::Nodes::Sequence)
+                anchor_suffix = cv.anchor ? " &#{cv.anchor}" : ""
+                @output << "#{' ' * (indent + indentation)}#{ck_str}:#{anchor_suffix}"
+                emit_sequence_from_ast(cv.children, indent + indentation * 2)
+              end
+            end
+          end
+        elsif ast_value.is_a?(Psych::Nodes::Scalar)
+          anchor_suffix = ast_value.anchor ? " &#{ast_value.anchor}" : ""
+          @output << "#{' ' * indent}#{key_str}:#{anchor_suffix} #{format_ast_scalar(ast_value)}"
+        elsif ast_value.is_a?(Psych::Nodes::Sequence)
+          anchor_suffix = ast_value.anchor ? " &#{ast_value.anchor}" : ""
+          @output << "#{' ' * indent}#{key_str}:#{anchor_suffix}"
+          emit_sequence_from_ast(ast_value.children, indent + indentation)
+        end
+      end
+    end
+
+    # Emit a sequence from AST nodes
+    def emit_sequence_from_ast(children, indent)
+      children.each do |child|
+        if child.is_a?(Psych::Nodes::Scalar)
+          @output << "#{' ' * indent}- #{format_ast_scalar(child)}"
+        elsif child.is_a?(Psych::Nodes::Alias)
+          @output << "#{' ' * indent}- *#{child.anchor}"
+        elsif child.is_a?(Psych::Nodes::Mapping)
+          pairs = child.children.each_slice(2).to_a
+          pairs.each_with_index do |(k, v), i|
+            prefix = i == 0 ? "#{' ' * indent}- " : "#{' ' * (indent + indentation)}"
+            k_str = k.value rescue k.to_s
+            if v.is_a?(Psych::Nodes::Scalar)
+              @output << "#{prefix}#{k_str}: #{format_ast_scalar(v)}"
+            elsif v.is_a?(Psych::Nodes::Alias)
+              @output << "#{prefix}#{k_str}: *#{v.anchor}"
+            end
+          end
+        end
+      end
+    end
+
+    # Format an AST scalar value, preserving its original type.
+    # The AST node knows its tag (int, bool, null, etc.) so we
+    # can emit without spurious quoting.
+    def format_ast_scalar(node)
+      return "null" if node.tag == "tag:yaml.org,2002:null" || node.value.nil?
+
+      case node.tag
+      when "tag:yaml.org,2002:int", "tag:yaml.org,2002:float"
+        node.value
+      when "tag:yaml.org,2002:bool"
+        node.value
+      else
+        # For plain scalars, use the raw value if it was unquoted in the original
+        if node.plain
+          node.value
+        else
+          scalar_to_string(node.value)
+        end
+      end
+    end
+
     def indentation
       @config.indentation
     end
+
+    # Extract the root mapping node from a parsed AST
+    def extract_ast_root(ast)
+      return nil unless ast
+      return nil unless ast.respond_to?(:children)
+
+      case ast
+      when Psych::Nodes::Document
+        # Document -> Mapping
+        ast.children&.each do |child|
+          return child if child.is_a?(Psych::Nodes::Mapping)
+        end
+      when Psych::Nodes::Stream
+        # Stream -> Document -> Mapping
+        ast.children&.each do |doc|
+          next unless doc.is_a?(Psych::Nodes::Document)
+          doc.children&.each do |child|
+            return child if child.is_a?(Psych::Nodes::Mapping)
+          end
+        end
+      end
+      nil
+    end
+
+    # Get key/value AST node pairs from a mapping node
+    def ast_mapping_pairs(ast_node)
+      return [] unless ast_node.is_a?(Psych::Nodes::Mapping)
+      ast_node.children.each_slice(2).to_a
+    end
   end
 end

data/lib/yaml_janitor/linter.rb

@@ -22,11 +22,14 @@ module YamlJanitor
     def lint(yaml_content, fix: false, file: nil)
       violations = []
 
+      # Parse AST for anchor/alias tracking
+      ast = Psych::Pure.parse(yaml_content)
+
       # Load with comments
       loaded = Psych::Pure.load(yaml_content, comments: true, permitted_classes: [Date, Time, DateTime, Symbol, Regexp], aliases: true)
 
-      # Format using our custom emitter
-      formatted = Emitter.new(loaded, @config).emit
+      # Format using our custom emitter (pass AST for anchor/alias preservation)
+      formatted = Emitter.new(loaded, @config, ast: ast).emit
 
       # Check if formatting would change the file
       if yaml_content != formatted

data/lib/yaml_janitor/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module YamlJanitor
-  VERSION = "20260406.1"
+  VERSION = "20260406.3"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: yaml-janitor
 version: !ruby/object:Gem::Version
-  version: '20260406.1'
+  version: '20260406.3'
 platform: ruby
 authors:
 - ducks