yamlfmt 0.1.0

data/lib/yamlfmt/rule/line_based.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module Yamlfmt
+  module Rule
+    class LineBased < Base
+      Context = Data.define(:line, :index, :lines, :document) do
+        def previous_line
+          index.positive? ? lines[index - 1] : nil
+        end
+
+        def next_line
+          lines[index + 1]
+        end
+
+        def first?
+          index.zero?
+        end
+
+        def last?
+          index == lines.length - 1
+        end
+      end
+
+      def call(document)
+        return [] if document.block_scalar?
+
+        each_context(document).flat_map do |context|
+          Array(check_line(context))
+        end
+      end
+
+      def check_line(_context)
+        raise NotImplementedError
+      end
+
+      private
+
+      def each_context(document, &block)
+        return enum_for(__method__, document) unless block
+
+        lines = document.lines
+        lines.each_with_index do |line, index|
+          yield Context.new(line:, index:, lines:, document:)
+        end
+      end
+    end
+  end
+end

data/lib/yamlfmt/rule/registry.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Yamlfmt
+  module Rule
+    module Registry
+      class << self
+        def register(rule_class)
+          id = rule_class.rule_id
+          raise ArgumentError, "rule must define an id" if id.nil? || id.empty?
+          raise ArgumentError, "rule #{id.inspect} is already registered" if rules_by_id.key?(id)
+
+          rules_by_id[id] = rule_class
+        end
+
+        def fetch(id)
+          rules_by_id.fetch(id)
+        end
+
+        def rules
+          rules_by_id.values.sort_by { |rule| [rule.priority, rule.rule_id] }
+        end
+
+        def ids
+          rules_by_id.keys.freeze
+        end
+
+        def clear
+          @rules_by_id = {}
+        end
+
+        private
+
+        def rules_by_id
+          @rules_by_id ||= {}
+        end
+      end
+    end
+  end
+end

data/lib/yamlfmt/rule/trailing_whitespace.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module Yamlfmt
+  module Rule
+    class TrailingWhitespace < LineBased
+      rule_id "trailing-whitespace"
+      priority 100
+
+      def check_line(context)
+        line = context.line
+        whitespace = line.content[/[ \t]+\z/]
+        return unless whitespace
+
+        ws_start = line.content.bytesize - whitespace.bytesize
+        removable_start = removable_trailing_start(line, ws_start, double_quoted_scalar_ranges(context.document))
+        return if removable_start >= line.content.bytesize
+
+        range = SourceRange.new(
+          start_offset: line.start_offset + removable_start,
+          end_offset: line.start_offset + line.content.bytesize
+        )
+        correction(range, "trailing whitespace detected", "")
+      end
+
+      private
+
+      def double_quoted_scalar_ranges(document)
+        document.scalar_ranges(style: Psych::Nodes::Scalar::DOUBLE_QUOTED)
+      end
+
+      def removable_trailing_start(line, ws_start, scalar_ranges)
+        removable_start = ws_start
+        while removable_start < line.content.bytesize
+          byte = line.content.getbyte(removable_start)
+          break unless byte == 32 || byte == 9
+
+          offset = line.start_offset + removable_start
+          inside_scalar = scalar_ranges.any? { |range| range.start_offset <= offset && offset < range.end_offset }
+          break unless inside_scalar && escaped_whitespace?(line.content, removable_start)
+
+          removable_start += 1
+        end
+        removable_start
+      end
+
+      def escaped_whitespace?(content, byte_index)
+        backslashes = 0
+        position = byte_index - 1
+        while position >= 0 && content.getbyte(position) == 92
+          backslashes += 1
+          position -= 1
+        end
+        backslashes.odd?
+      end
+    end
+
+    Registry.register(TrailingWhitespace)
+  end
+end

data/lib/yamlfmt/rule/unnecessary_quotes.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module Yamlfmt
+  module Rule
+    class UnnecessaryQuotes < AstBased
+      QUOTED_STYLES = [Psych::Nodes::Scalar::SINGLE_QUOTED, Psych::Nodes::Scalar::DOUBLE_QUOTED].freeze
+      FLOW_INDICATORS = /[\[\]{},]/
+
+      rule_id "unnecessary-quotes"
+      priority 400
+
+      def check_node(context)
+        node = context.node
+        return unless node.is_a?(Psych::Nodes::Scalar)
+        return unless QUOTED_STYLES.include?(node.style)
+        return unless can_unquote?(node.value, in_flow: context.flow?)
+
+        range = context.document.range_for(node)
+        return unless range
+        return if multiline?(context.document.source, range)
+        return if context.flow_mapping_key? && missing_flow_key_separation?(context.document.source, range)
+
+        correction(range, "unnecessary quotes detected", node.value)
+      end
+
+      private
+
+      def can_unquote?(value, in_flow:)
+        return false unless value.is_a?(String) && Psych.dump(value) == "--- #{value}\n"
+
+        !in_flow || !value.match?(FLOW_INDICATORS)
+      end
+
+      def multiline?(source, range)
+        source.byteslice(range.start_offset, range.length).match?(/[\r\n]/)
+      end
+
+      def missing_flow_key_separation?(source, range)
+        offset = range.end_offset
+        offset += 1 while [9, 32].include?(source.getbyte(offset))
+        return false unless source.getbyte(offset) == 58
+
+        following = source.getbyte(offset + 1)
+        following && ![9, 10, 13, 32].include?(following)
+      end
+    end
+
+    Registry.register(UnnecessaryQuotes)
+  end
+end

data/lib/yamlfmt/rule_plan.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Yamlfmt
+  class RulePlan
+    def call(config)
+      Rule::Registry.rules.filter_map do |rule_class|
+        options = config.options_for(rule_class)
+        rule_class.new(options) if options
+      end
+    end
+  end
+end

data/lib/yamlfmt/safety_validator.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+module Yamlfmt
+  class SafetyValidator
+    PERMITTED_CLASSES = [Date, Time, Symbol].freeze
+
+    def call(original_document, candidate_source)
+      candidate = Document.new(candidate_source, path: original_document.path)
+      validate_values!(original_document, candidate)
+      validate_comments!(original_document, candidate)
+      candidate
+    rescue ParseError, UnsupportedFileError => error
+      raise ValidationError, "formatted source could not be parsed safely: #{error.message}"
+    end
+
+    private
+
+    def validate_values!(original, candidate)
+      original_values = load_values(original)
+      candidate_values = load_values(candidate)
+      return if equivalent?(original_values, candidate_values)
+
+      raise ValidationError, "formatting changed the YAML value"
+    rescue Psych::Exception => error
+      raise ValidationError, "YAML value could not be loaded safely: #{error.message}"
+    end
+
+    def validate_comments!(original, candidate)
+      return if original.comment_values == candidate.comment_values
+
+      raise ValidationError, "formatting changed YAML comments"
+    end
+
+    def load_values(document)
+      Psych.safe_load_stream(
+        document.source,
+        filename: document.path,
+        permitted_classes: PERMITTED_CLASSES,
+        aliases: true
+      )
+    end
+
+    def equivalent?(left, right, seen = {})
+      return true if left.equal?(right)
+      return false unless left.instance_of?(right.class)
+
+      pair = [left.object_id, right.object_id]
+      return true if seen[pair]
+
+      seen[pair] = true
+
+      case left
+      when Array
+        left.length == right.length && left.zip(right).all? { |left_item, right_item| equivalent?(left_item, right_item, seen) }
+      when Hash
+        equivalent_hash?(left, right, seen)
+      when Float
+        (left.nan? && right.nan?) || left == right
+      else
+        left == right
+      end
+    end
+
+    def equivalent_hash?(left, right, seen)
+      return false unless left.length == right.length
+
+      left.to_a.zip(right.to_a).all? do |(left_key, left_value), (right_key, right_value)|
+        equivalent?(left_key, right_key, seen) && equivalent?(left_value, right_value, seen)
+      end
+    end
+  end
+end

data/lib/yamlfmt/source_range.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module Yamlfmt
+  SourceRange = Data.define(:start_offset, :end_offset) do
+    def initialize(start_offset:, end_offset:)
+      unless start_offset.is_a?(Integer) && end_offset.is_a?(Integer) &&
+          start_offset >= 0 && end_offset >= start_offset
+        raise ArgumentError, "source range must be a non-negative half-open byte range"
+      end
+
+      super
+    end
+
+    def length
+      end_offset - start_offset
+    end
+
+    def empty?
+      length.zero?
+    end
+
+    def cover?(other)
+      start_offset <= other.start_offset && end_offset >= other.end_offset
+    end
+
+    def overlaps?(other)
+      if empty? && other.empty?
+        start_offset == other.start_offset
+      elsif empty?
+        start_offset > other.start_offset && start_offset < other.end_offset
+      elsif other.empty?
+        other.start_offset > start_offset && other.start_offset < end_offset
+      else
+        start_offset < other.end_offset && other.start_offset < end_offset
+      end
+    end
+  end
+end

data/lib/yamlfmt/unified_diff.rb

@@ -0,0 +1,127 @@
+# frozen_string_literal: true
+
+module Yamlfmt
+  class UnifiedDiff
+    CONTEXT_LINES = 3
+    MAX_LCS_CELLS = 1_000_000
+
+    Record = Data.define(:type, :line)
+
+    def call(before, after, path:)
+      return "" if before == after
+
+      records = diff_records(split_lines(before), split_lines(after))
+      hunks = hunk_ranges(records)
+
+      output = "--- #{path}\n+++ #{path}\n"
+      hunks.each { |range| append_hunk(output, records, range) }
+      output
+    end
+
+    private
+
+    def split_lines(source)
+      source.lines(chomp: false)
+    end
+
+    def diff_records(before, after)
+      return fallback_records(before, after) if before.length * after.length > MAX_LCS_CELLS
+
+      table = lcs_table(before, after)
+      records = []
+      before_index = 0
+      after_index = 0
+
+      while before_index < before.length && after_index < after.length
+        if before[before_index] == after[after_index]
+          records << Record.new(type: :equal, line: before[before_index])
+          before_index += 1
+          after_index += 1
+        elsif table[before_index + 1][after_index] >= table[before_index][after_index + 1]
+          records << Record.new(type: :delete, line: before[before_index])
+          before_index += 1
+        else
+          records << Record.new(type: :insert, line: after[after_index])
+          after_index += 1
+        end
+      end
+
+      before.drop(before_index).each { |line| records << Record.new(type: :delete, line:) }
+      after.drop(after_index).each { |line| records << Record.new(type: :insert, line:) }
+      records
+    end
+
+    def lcs_table(before, after)
+      table = Array.new(before.length + 1) { Array.new(after.length + 1, 0) }
+
+      (before.length - 1).downto(0) do |before_index|
+        (after.length - 1).downto(0) do |after_index|
+          table[before_index][after_index] = if before[before_index] == after[after_index]
+            table[before_index + 1][after_index + 1] + 1
+          else
+            [table[before_index + 1][after_index], table[before_index][after_index + 1]].max
+          end
+        end
+      end
+
+      table
+    end
+
+    def fallback_records(before, after)
+      prefix_length = common_prefix_length(before, after)
+      suffix_length = common_suffix_length(before.drop(prefix_length), after.drop(prefix_length))
+
+      prefix = before.first(prefix_length).map { |line| Record.new(type: :equal, line:) }
+      deleted = before[prefix_length, before.length - prefix_length - suffix_length].map { |line| Record.new(type: :delete, line:) }
+      inserted = after[prefix_length, after.length - prefix_length - suffix_length].map { |line| Record.new(type: :insert, line:) }
+      suffix = before.last(suffix_length).map { |line| Record.new(type: :equal, line:) }
+      prefix + deleted + inserted + suffix
+    end
+
+    def common_prefix_length(before, after)
+      limit = [before.length, after.length].min
+      (0...limit).find { |index| before[index] != after[index] } || limit
+    end
+
+    def common_suffix_length(before, after)
+      limit = [before.length, after.length].min
+      (0...limit).find { |index| before[-index - 1] != after[-index - 1] } || limit
+    end
+
+    def hunk_ranges(records)
+      changes = records.each_index.reject { |index| records[index].type == :equal }
+      ranges = changes.map do |index|
+        [index - CONTEXT_LINES, 0].max..[index + CONTEXT_LINES, records.length - 1].min
+      end
+
+      ranges.each_with_object([]) do |range, merged|
+        if merged.last && range.begin <= merged.last.end + 1
+          merged[-1] = merged.last.begin..[merged.last.end, range.end].max
+        else
+          merged << range
+        end
+      end
+    end
+
+    def append_hunk(output, records, range)
+      before_start = 1 + records.first(range.begin).count { |record| record.type != :insert }
+      after_start = 1 + records.first(range.begin).count { |record| record.type != :delete }
+      hunk = records[range]
+      before_count = hunk.count { |record| record.type != :insert }
+      after_count = hunk.count { |record| record.type != :delete }
+      before_start -= 1 if before_count.zero?
+      after_start -= 1 if after_count.zero?
+
+      output << "@@ -#{before_start},#{before_count} +#{after_start},#{after_count} @@\n"
+      hunk.each { |record| append_record(output, record) }
+    end
+
+    def append_record(output, record)
+      prefix = {equal: " ", delete: "-", insert: "+"}.fetch(record.type)
+      terminated = record.line.end_with?("\n", "\r")
+      content = record.line.delete_suffix("\n")
+      output << prefix << content << "\n"
+      output << "\\n" unless terminated
+    end
+  end
+end

data/lib/yamlfmt/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Yamlfmt
+  VERSION = "0.1.0"
+end

data/lib/yamlfmt.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require_relative "yamlfmt/version"
+require_relative "yamlfmt/errors"
+require_relative "yamlfmt/source_range"
+require_relative "yamlfmt/edit"
+require_relative "yamlfmt/finding"
+require_relative "yamlfmt/config"
+require_relative "yamlfmt/exclude_matcher"
+require_relative "yamlfmt/file_finder"
+require_relative "yamlfmt/document"
+require_relative "yamlfmt/corrector"
+require_relative "yamlfmt/safety_validator"
+require_relative "yamlfmt/processor"
+require_relative "yamlfmt/unified_diff"
+require_relative "yamlfmt/rule/base"
+require_relative "yamlfmt/rule/registry"
+require_relative "yamlfmt/rule/line_based"
+require_relative "yamlfmt/rule/ast_based"
+require_relative "yamlfmt/rule/trailing_whitespace"
+require_relative "yamlfmt/rule/blank_lines"
+require_relative "yamlfmt/rule/final_newline"
+require_relative "yamlfmt/rule/unnecessary_quotes"
+require_relative "yamlfmt/rule_plan"
+require_relative "yamlfmt/cli"
+
+module Yamlfmt
+end

metadata

@@ -0,0 +1,112 @@
+--- !ruby/object:Gem::Specification
+name: yamlfmt
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- zeronosu77108
+autorequire:
+bindir: exe
+cert_chain: []
+date: 2026-09-06 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: psych
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 5.2.5
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '6'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 5.2.5
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '6'
+- !ruby/object:Gem::Dependency
+  name: psych-pure
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.3.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.3.0
+description: Applies targeted edits while preserving comments and untouched formatting.
+email:
+- mail@zeronosu77108.com
+executables:
+- yamlfmt
+extensions: []
+extra_rdoc_files: []
+files:
+- ".ruby-version"
+- ".standard.yml"
+- LICENSE
+- README.md
+- Rakefile
+- exe/yamlfmt
+- lib/yamlfmt.rb
+- lib/yamlfmt/cli.rb
+- lib/yamlfmt/config.rb
+- lib/yamlfmt/corrector.rb
+- lib/yamlfmt/document.rb
+- lib/yamlfmt/edit.rb
+- lib/yamlfmt/errors.rb
+- lib/yamlfmt/exclude_matcher.rb
+- lib/yamlfmt/file_finder.rb
+- lib/yamlfmt/finding.rb
+- lib/yamlfmt/processor.rb
+- lib/yamlfmt/rule/ast_based.rb
+- lib/yamlfmt/rule/base.rb
+- lib/yamlfmt/rule/blank_lines.rb
+- lib/yamlfmt/rule/final_newline.rb
+- lib/yamlfmt/rule/line_based.rb
+- lib/yamlfmt/rule/registry.rb
+- lib/yamlfmt/rule/trailing_whitespace.rb
+- lib/yamlfmt/rule/unnecessary_quotes.rb
+- lib/yamlfmt/rule_plan.rb
+- lib/yamlfmt/safety_validator.rb
+- lib/yamlfmt/source_range.rb
+- lib/yamlfmt/unified_diff.rb
+- lib/yamlfmt/version.rb
+homepage: https://github.com/zeronosu77108/yamlfmt
+licenses:
+- MIT
+metadata:
+  allowed_push_host: https://rubygems.org
+  homepage_uri: https://github.com/zeronosu77108/yamlfmt
+  source_code_uri: https://github.com/zeronosu77108/yamlfmt
+  rubygems_mfa_required: 'true'
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.3'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.5.16
+signing_key:
+specification_version: 4
+summary: A comment-preserving, minimal-diff YAML formatter for Ruby
+test_files: []