yamlfmt 0.1.0

data/lib/yamlfmt/document.rb

@@ -0,0 +1,241 @@
+# frozen_string_literal: true
+
+require "date"
+require "psych/pure"
+
+module Yamlfmt
+  class Document
+    Line = Data.define(:text, :content, :ending, :number, :start_offset)
+
+    STANDARD_TAG_PREFIX = "tag:yaml.org,2002:"
+    BLOCK_SCALAR_STYLES = [Psych::Nodes::Scalar::LITERAL, Psych::Nodes::Scalar::FOLDED].freeze
+
+    attr_reader :source, :path, :ast, :lines
+
+    def initialize(source, path: "<unknown>")
+      @source = source.dup.freeze
+      @path = path.to_s
+      validate_encoding!
+      @lines = build_lines.freeze
+      @standard_stream = parse_standard
+      validate_supported!
+      @standard_document = @standard_stream.children.first
+      @ast = parse_pure
+      @node_ranges = build_node_ranges.freeze
+    end
+
+    def each_line(&block)
+      return enum_for(__method__) unless block
+
+      lines.each(&block)
+    end
+
+    def each_node(root = ast, &block)
+      return enum_for(__method__, root) unless block
+      return if root.nil? || root == false
+
+      yield root
+      root.children&.each { |child| each_node(child, &block) }
+    end
+
+    def range_for(node)
+      @node_ranges[node.object_id]
+    end
+
+    def scalar_ranges(style: nil)
+      @scalar_ranges ||= {}
+      @scalar_ranges[style] ||= each_node.filter_map do |node|
+        next unless node.is_a?(Psych::Nodes::Scalar)
+        next unless style.nil? || node.style == style
+
+        range_for(node)
+      end.freeze
+    end
+
+    def block_scalar?
+      standard_nodes.any? do |node|
+        node.is_a?(Psych::Nodes::Scalar) && BLOCK_SCALAR_STYLES.include?(node.style)
+      end
+    end
+
+    def empty_yaml?
+      @standard_document.nil?
+    end
+
+    def comment_values
+      return comment_only_values if empty_yaml?
+
+      seen = {}
+      values = each_node.flat_map do |node|
+        next [] unless node.respond_to?(:comments?) && node.comments?
+
+        (node.comments.leading + node.comments.trailing).filter_map do |comment|
+          next if seen[comment.object_id]
+
+          seen[comment.object_id] = true
+          normalize_comment(comment.value)
+        end
+      end
+
+      values.sort
+    end
+
+    def preferred_line_ending
+      endings = lines.filter_map { |line| line.ending unless line.ending.empty? }
+      return "\n" if endings.empty?
+
+      endings.tally.max_by { |ending, count| [count, -endings.index(ending)] }.first
+    end
+
+    def line_and_column(byte_offset)
+      raise ArgumentError, "offset is outside the source" unless byte_offset.between?(0, source.bytesize)
+
+      line = lines.reverse_each.find { |candidate| candidate.start_offset <= byte_offset }
+      return [1, 1] unless line
+
+      prefix = source.byteslice(line.start_offset, byte_offset - line.start_offset)
+      [line.number, prefix.length + 1]
+    end
+
+    private
+
+    def validate_encoding!
+      if source.start_with?("\uFEFF")
+        raise UnsupportedFileError, "byte order marks are not supported"
+      end
+
+      return if source.encoding == Encoding::UTF_8 && source.valid_encoding?
+
+      raise UnsupportedFileError, "only valid UTF-8 input is supported"
+    end
+
+    def parse_standard
+      Psych.parse_stream(source, filename: path)
+    rescue Psych::SyntaxError => error
+      raise ParseError, error.message
+    end
+
+    def parse_pure
+      return nil if empty_yaml?
+
+      Psych::Pure.parse(source, filename: path, comments: true)
+    rescue Psych::SyntaxError => error
+      raise ParseError, error.message
+    rescue Psych::Pure::InternalException, NoMethodError => error
+      raise UnsupportedFileError, "psych-pure could not parse this document: #{error.message}"
+    end
+
+    def validate_supported!
+      if @standard_stream.children.length > 1
+        raise UnsupportedFileError, "multiple YAML documents are not supported"
+      end
+
+      standard_nodes.each do |node|
+        if custom_tag?(node)
+          raise UnsupportedFileError, "custom YAML tags are not supported"
+        end
+
+        if node.is_a?(Psych::Nodes::Scalar) && node.anchor
+          raise UnsupportedFileError, "anchors on scalar values are not supported"
+        end
+      end
+    end
+
+    def custom_tag?(node)
+      return false unless node.respond_to?(:tag)
+
+      tag = node.tag
+      tag && tag != "!" && !tag.start_with?(STANDARD_TAG_PREFIX)
+    end
+
+    def standard_nodes
+      return [] unless @standard_stream
+
+      @standard_nodes ||= walk(@standard_stream).freeze
+    end
+
+    def walk(node, result = [])
+      result << node
+      node.children&.each { |child| walk(child, result) }
+      result
+    end
+
+    def build_node_ranges
+      return {} unless ast
+
+      pure_scalars = each_node.select { |node| node.is_a?(Psych::Nodes::Scalar) }
+      psych_scalars = standard_nodes.select { |node| node.is_a?(Psych::Nodes::Scalar) }
+      return {} unless pure_scalars.length == psych_scalars.length
+
+      pure_scalars.zip(psych_scalars).each_with_object({}) do |(pure_node, psych_node), ranges|
+        next unless pure_node.value == psych_node.value && pure_node.style == psych_node.style
+
+        range = range_from_location(psych_node)
+        next unless range
+        next unless source.byteslice(range.start_offset, range.length) == pure_node.source
+
+        ranges[pure_node.object_id] = range
+      end
+    end
+
+    def range_from_location(node)
+      start_offset = byte_offset(node.start_line, node.start_column)
+      end_offset = byte_offset(node.end_line, node.end_column)
+      SourceRange.new(start_offset:, end_offset:)
+    rescue ArgumentError, IndexError
+      nil
+    end
+
+    def byte_offset(line_index, character_column)
+      line = lines.fetch(line_index)
+      prefix = line.text[0, character_column]
+      raise ArgumentError, "column is outside the line" unless prefix
+
+      line.start_offset + prefix.bytesize
+    end
+
+    def build_lines
+      result = []
+      start_offset = 0
+      index = 0
+
+      while index < source.bytesize
+        byte = source.getbyte(index)
+        if byte == 13 || byte == 10
+          ending_length = (byte == 13 && source.getbyte(index + 1) == 10) ? 2 : 1
+          result << build_line(start_offset, index, ending_length, result.length + 1)
+          index += ending_length
+          start_offset = index
+        else
+          index += 1
+        end
+      end
+
+      result << build_line(start_offset, source.bytesize, 0, result.length + 1) if start_offset < source.bytesize
+      result
+    end
+
+    def build_line(start_offset, content_end, ending_length, number)
+      content = source.byteslice(start_offset, content_end - start_offset)
+      ending = source.byteslice(content_end, ending_length)
+      Line.new(
+        text: "#{content}#{ending}",
+        content:,
+        ending:,
+        number:,
+        start_offset:
+      )
+    end
+
+    def comment_only_values
+      lines.filter_map do |line|
+        content = line.content.lstrip
+        normalize_comment(content) if content.start_with?("#")
+      end.sort
+    end
+
+    def normalize_comment(value)
+      value.sub(/[ \t]+\z/, "")
+    end
+  end
+end

data/lib/yamlfmt/edit.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Yamlfmt
+  Edit = Data.define(:range, :replacement) do
+    def initialize(range:, replacement:)
+      raise ArgumentError, "range must be a SourceRange" unless range.is_a?(SourceRange)
+      raise ArgumentError, "replacement must be a String" unless replacement.is_a?(String)
+
+      super
+    end
+  end
+end

data/lib/yamlfmt/errors.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Yamlfmt
+  class Error < StandardError; end
+
+  class ParseError < Error; end
+  class UnsupportedFileError < Error; end
+  class ValidationError < Error; end
+  class ConfigError < Error; end
+  class PathError < Error; end
+
+  class ConflictError < Error
+    attr_reader :findings
+
+    def initialize(findings)
+      @findings = findings.freeze
+      rule_ids = findings.map(&:rule_id).uniq.join(", ")
+      super("overlapping edits from: #{rule_ids}")
+    end
+  end
+end

data/lib/yamlfmt/exclude_matcher.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+require "pathname"
+
+module Yamlfmt
+  class ExcludeMatcher
+    FLAGS = File::FNM_PATHNAME | File::FNM_DOTMATCH | File::FNM_EXTGLOB
+
+    def initialize(root:, patterns:)
+      @root = Pathname(File.expand_path(root))
+      @patterns = patterns
+    end
+
+    def excluded?(path)
+      relative = relative_path(path)
+      return false unless relative
+
+      components = relative.split("/")
+      @patterns.any? { |pattern| match?(pattern, relative, components) }
+    end
+
+    private
+
+    def relative_path(path)
+      relative = Pathname(File.expand_path(path)).relative_path_from(@root).to_s
+      return if relative == ".." || relative.start_with?("../")
+
+      relative
+    rescue ArgumentError
+      nil
+    end
+
+    def match?(pattern, relative, components)
+      if pattern.include?("/")
+        path_pattern_match?(pattern, relative)
+      elsif glob?(pattern)
+        components.any? { |component| File.fnmatch?(pattern, component, FLAGS) }
+      else
+        components.include?(pattern)
+      end
+    end
+
+    def path_pattern_match?(pattern, relative)
+      if pattern.end_with?("/**")
+        path_or_ancestor_match?(pattern.delete_suffix("/**"), relative)
+      elsif glob?(pattern)
+        path_or_ancestor_match?(pattern, relative)
+      else
+        relative == pattern || relative.start_with?("#{pattern}/")
+      end
+    end
+
+    def path_or_ancestor_match?(pattern, relative)
+      components = relative.split("/")
+      components.each_index.any? do |index|
+        ancestor = components.first(index + 1).join("/")
+        File.fnmatch?(pattern, ancestor, FLAGS)
+      end
+    end
+
+    def glob?(pattern)
+      pattern.match?(/[*?]/)
+    end
+  end
+end

data/lib/yamlfmt/file_finder.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+require "find"
+
+module Yamlfmt
+  class FileFinder
+    YAML_EXTENSIONS = %w[.yml .yaml].freeze
+
+    def initialize(cwd: Dir.pwd, exclude: [])
+      @cwd = File.expand_path(cwd)
+      @exclude_matcher = ExcludeMatcher.new(root: @cwd, patterns: exclude)
+    end
+
+    def call(paths = [])
+      roots = paths.empty? ? [@cwd] : paths.map { |path| File.expand_path(path, @cwd) }
+      files = {}
+
+      roots.each do |root|
+        validate_root!(root)
+        next if symlink_path?(root) || always_excluded?(root) || @exclude_matcher.excluded?(root)
+
+        if File.file?(root)
+          files[root] = true
+        elsif File.directory?(root)
+          find_yaml_files(root, files)
+        end
+      end
+
+      files.keys.sort
+    rescue SystemCallError => error
+      raise PathError, error.message
+    end
+
+    private
+
+    def validate_root!(root)
+      return if File.exist?(root)
+
+      raise PathError, "path does not exist: #{root}"
+    end
+
+    def find_yaml_files(root, files)
+      Find.find(root) do |path|
+        if path != root && (symlink?(path) || always_excluded?(path) || @exclude_matcher.excluded?(path))
+          Find.prune if File.directory?(path)
+          next
+        end
+
+        files[path] = true if File.file?(path) && YAML_EXTENSIONS.include?(File.extname(path))
+      end
+    end
+
+    def symlink?(path)
+      File.symlink?(path)
+    end
+
+    def symlink_path?(path)
+      relative = Pathname(path).relative_path_from(Pathname(@cwd))
+      current = @cwd
+
+      relative.each_filename do |component|
+        current = File.expand_path(component, current)
+        return true if symlink?(current)
+      end
+
+      false
+    rescue ArgumentError
+      symlink?(path)
+    end
+
+    def always_excluded?(path)
+      Pathname(path).each_filename.include?(".git")
+    end
+  end
+end

data/lib/yamlfmt/finding.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Yamlfmt
+  Finding = Data.define(:rule_id, :range, :message, :edit) do
+    def initialize(rule_id:, range:, message:, edit: nil)
+      raise ArgumentError, "range must be a SourceRange" unless range.is_a?(SourceRange)
+      raise ArgumentError, "edit must be an Edit or nil" unless edit.nil? || edit.is_a?(Edit)
+
+      super
+    end
+
+    def autocorrectable?
+      !edit.nil?
+    end
+  end
+end

data/lib/yamlfmt/processor.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Yamlfmt
+  class Processor
+    Result = Data.define(:document, :source, :formatted_source, :findings, :warnings) do
+      def changed?
+        source != formatted_source
+      end
+    end
+
+    def initialize(corrector: Corrector.new, validator: SafetyValidator.new)
+      @corrector = corrector
+      @validator = validator
+    end
+
+    def call(source, path: "<unknown>", rules: default_rules)
+      document = Document.new(source, path:)
+      findings = rules.flat_map { |rule| rule.call(document) }.freeze
+      formatted_source = @corrector.call(source, findings)
+      @validator.call(document, formatted_source) if formatted_source != source
+      warnings = block_scalar_warnings(document, rules).freeze
+
+      Result.new(document:, source:, formatted_source:, findings:, warnings:)
+    end
+
+    private
+
+    def default_rules
+      Rule::Registry.rules.map(&:new)
+    end
+
+    def block_scalar_warnings(document, rules)
+      return [] unless document.block_scalar?
+      return [] unless rules.any? { |rule| rule.is_a?(Rule::LineBased) }
+
+      ["line-based rules were skipped because the file contains a block scalar"]
+    end
+  end
+end

data/lib/yamlfmt/rule/ast_based.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module Yamlfmt
+  module Rule
+    class AstBased < Base
+      Context = Data.define(:node, :document, :parent, :in_flow, :flow_mapping_key) do
+        def flow?
+          in_flow
+        end
+
+        def flow_mapping_key?
+          flow_mapping_key
+        end
+      end
+
+      def call(document)
+        each_context(document).flat_map do |context|
+          Array(check_node(context))
+        end
+      end
+
+      def check_node(_context)
+        raise NotImplementedError
+      end
+
+      private
+
+      def each_context(document, node = document.ast, parent: nil, in_flow: false, flow_mapping_key: false, &block)
+        return enum_for(__method__, document, node, parent:, in_flow:, flow_mapping_key:) unless block
+        return if node.nil? || node == false
+
+        yield Context.new(node:, document:, parent:, in_flow:, flow_mapping_key:)
+
+        child_in_flow = in_flow || flow_collection?(node)
+        Array(node.children).each_with_index do |child, index|
+          each_context(
+            document,
+            child,
+            parent: node,
+            in_flow: child_in_flow,
+            flow_mapping_key: flow_mapping?(node) && index.even?,
+            &block
+          )
+        end
+      end
+
+      def flow_collection?(node)
+        (node.is_a?(Psych::Nodes::Sequence) && node.style == Psych::Nodes::Sequence::FLOW) ||
+          flow_mapping?(node)
+      end
+
+      def flow_mapping?(node)
+        node.is_a?(Psych::Nodes::Mapping) && node.style == Psych::Nodes::Mapping::FLOW
+      end
+    end
+  end
+end

data/lib/yamlfmt/rule/base.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module Yamlfmt
+  module Rule
+    class Base
+      UNSET = Object.new.freeze
+
+      class << self
+        def rule_id(value = UNSET)
+          return @rule_id if value.equal?(UNSET)
+
+          @rule_id = value.to_s.freeze
+        end
+
+        def default_config(value = UNSET)
+          return @default_config || {} if value.equal?(UNSET)
+
+          @default_config = value.freeze
+        end
+
+        def priority(value = UNSET)
+          return @priority || 100 if value.equal?(UNSET)
+
+          @priority = Integer(value)
+        end
+
+        def autocorrectable?
+          true
+        end
+
+        def validate_config(_config)
+        end
+      end
+
+      attr_reader :config
+
+      def initialize(config = {})
+        @config = self.class.default_config.merge(config).freeze
+        self.class.validate_config(@config)
+      end
+
+      def call(_document)
+        raise NotImplementedError
+      end
+
+      private
+
+      def correction(range, message, replacement)
+        edit = Edit.new(range:, replacement:)
+        Finding.new(rule_id: self.class.rule_id, range:, message:, edit:)
+      end
+    end
+  end
+end

data/lib/yamlfmt/rule/blank_lines.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+module Yamlfmt
+  module Rule
+    class BlankLines < LineBased
+      rule_id "blank-lines"
+      priority 200
+      default_config max: 1
+
+      def self.validate_config(config)
+        max = config.fetch(:max)
+        return if max.is_a?(Integer) && max >= 0
+
+        raise ConfigError, "blank-lines.max must be a non-negative integer"
+      end
+
+      def check_line(context)
+        ranges = context.document.scalar_ranges
+        line = context.line
+        return unless blank?(line) && !inside_scalar?(line, ranges)
+
+        following = context.next_line
+        return if following.nil?
+        return if blank?(following) && !inside_scalar?(following, ranges)
+
+        finding_for_run(context.lines, run_start(context, ranges), context.index + 1)
+      end
+
+      private
+
+      def blank?(line)
+        line.content.match?(/\A[ \t]*\z/)
+      end
+
+      def inside_scalar?(line, ranges)
+        ranges.any? do |range|
+          range.start_offset < line.start_offset && line.start_offset < range.end_offset
+        end
+      end
+
+      def run_start(context, ranges)
+        start = context.index
+        while start.positive?
+          previous = context.lines[start - 1]
+          break unless blank?(previous) && !inside_scalar?(previous, ranges)
+
+          start -= 1
+        end
+        start
+      end
+
+      def finding_for_run(lines, run_start, run_end)
+        delete_start = run_start + config.fetch(:max)
+        return if delete_start >= run_end
+
+        range = SourceRange.new(
+          start_offset: lines.fetch(delete_start).start_offset,
+          end_offset: lines.fetch(run_end).start_offset
+        )
+        correction(range, "too many consecutive blank lines", "")
+      end
+    end
+
+    Registry.register(BlankLines)
+  end
+end

data/lib/yamlfmt/rule/final_newline.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module Yamlfmt
+  module Rule
+    class FinalNewline < LineBased
+      rule_id "final-newline"
+      priority 300
+
+      def check_line(context)
+        return unless context.last?
+
+        last_content_line = context.lines.reverse_each.find { |line| line.content.match?(/[^ \t]/) }
+        return remove_whitespace_only_source(context.document) unless last_content_line
+
+        if last_content_line.ending.empty?
+          add_final_newline(context.document)
+        else
+          remove_extra_lines(context.document, last_content_line)
+        end
+      end
+
+      private
+
+      def remove_whitespace_only_source(document)
+        range = SourceRange.new(start_offset: 0, end_offset: document.source.bytesize)
+        correction(range, "whitespace-only file detected", "")
+      end
+
+      def add_final_newline(document)
+        offset = document.source.bytesize
+        range = SourceRange.new(start_offset: offset, end_offset: offset)
+        correction(range, "final newline missing", document.preferred_line_ending)
+      end
+
+      def remove_extra_lines(document, last_content_line)
+        start_offset = last_content_line.start_offset + last_content_line.text.bytesize
+        return if start_offset == document.source.bytesize
+
+        range = SourceRange.new(start_offset:, end_offset: document.source.bytesize)
+        correction(range, "extra final newlines detected", "")
+      end
+    end
+
+    Registry.register(FinalNewline)
+  end
+end