yamlint 0.1.0 → 1.0.0

data/lib/yamlint/models/problem.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module Yamlint
+  module Models
+    class Problem
+      attr_reader :line, :column, :rule, :level, :message, :fixable
+
+      LEVELS = %i[error warning info].freeze
+
+      def initialize(line:, column:, rule:, level:, message:, fixable: false)
+        @line = line
+        @column = column
+        @rule = rule
+        @level = validate_level(level)
+        @message = message
+        @fixable = fixable
+      end
+
+      def error?
+        @level == :error
+      end
+
+      def warning?
+        @level == :warning
+      end
+
+      def fixable?
+        @fixable
+      end
+
+      def to_s
+        "#{line}:#{column} [#{level}] #{message} (#{rule})"
+      end
+
+      private
+
+      def validate_level(level)
+        return level if LEVELS.include?(level)
+
+        raise ArgumentError, "Invalid level: #{level}. Must be one of #{LEVELS.join(', ')}"
+      end
+    end
+  end
+end

data/lib/yamlint/models/token.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Yamlint
+  module Models
+    class Token
+      attr_reader :type, :value, :start_line, :start_column, :end_line, :end_column
+
+      def initialize(type:, start_line:, start_column:, value: nil, end_line: nil, end_column: nil)
+        @type = type
+        @value = value
+        @start_line = start_line
+        @start_column = start_column
+        @end_line = end_line || start_line
+        @end_column = end_column || start_column
+      end
+
+      def to_s
+        "#{type}(#{start_line}:#{start_column})"
+      end
+    end
+  end
+end

data/lib/yamlint/models.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Yamlint
+  module Models
+    autoload :Problem, 'yamlint/models/problem'
+    autoload :Token, 'yamlint/models/token'
+    autoload :LintContext, 'yamlint/models/lint_context'
+  end
+end

data/lib/yamlint/output/base.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Yamlint
+  module Output
+    class Base
+      def format(filepath, problems)
+        raise NotImplementedError, "#{self.class}#format must be implemented"
+      end
+
+      def format_summary(total_files, total_problems)
+        raise NotImplementedError, "#{self.class}#format_summary must be implemented"
+      end
+    end
+  end
+end

data/lib/yamlint/output/colored.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module Yamlint
+  module Output
+    class Colored < Base
+      COLORS = {
+        reset: "\e[0m",
+        bold: "\e[1m",
+        red: "\e[31m",
+        yellow: "\e[33m",
+        cyan: "\e[36m",
+        dim: "\e[2m"
+      }.freeze
+
+      def format(filepath, problems)
+        return '' if problems.empty?
+
+        lines = ["#{COLORS[:bold]}#{filepath}#{COLORS[:reset]}"]
+        problems.each do |problem|
+          lines << format_problem(problem)
+        end
+        lines.join("\n")
+      end
+
+      def format_summary(total_files, total_problems)
+        if total_problems.zero?
+          format_success_summary(total_files)
+        else
+          format_failure_summary(total_files, total_problems)
+        end
+      end
+
+      private
+
+      def format_problem(problem)
+        color = problem.error? ? COLORS[:red] : COLORS[:yellow]
+        pos = "#{COLORS[:dim]}#{problem.line}:#{problem.column}#{COLORS[:reset]}"
+        level = "#{color}#{problem.level}#{COLORS[:reset]}"
+        rule = "#{COLORS[:cyan]}(#{problem.rule})#{COLORS[:reset]}"
+        "  #{pos}      #{level}   #{problem.message}  #{rule}"
+      end
+
+      def format_success_summary(total_files)
+        "#{COLORS[:bold]}#{total_files}#{COLORS[:reset]} file(s) checked, " \
+          "#{COLORS[:bold]}no problems found#{COLORS[:reset]}"
+      end
+
+      def format_failure_summary(total_files, total_problems)
+        "#{COLORS[:bold]}#{total_files}#{COLORS[:reset]} file(s) checked, " \
+          "#{COLORS[:red]}#{total_problems} problem(s) found#{COLORS[:reset]}"
+      end
+    end
+  end
+end

data/lib/yamlint/output/github.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Yamlint
+  module Output
+    class Github < Base
+      def format(filepath, problems)
+        return '' if problems.empty?
+
+        problems.map do |problem|
+          type = problem.error? ? 'error' : 'warning'
+          "::#{type} file=#{filepath},line=#{problem.line},col=#{problem.column}::#{problem.message} (#{problem.rule})"
+        end.join("\n")
+      end
+
+      def format_summary(_total_files, _total_problems)
+        ''
+      end
+    end
+  end
+end

data/lib/yamlint/output/parsable.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Yamlint
+  module Output
+    class Parsable < Base
+      def format(filepath, problems)
+        return '' if problems.empty?
+
+        problems.map do |problem|
+          "#{filepath}:#{problem.line}:#{problem.column}: [#{problem.level}] #{problem.message} (#{problem.rule})"
+        end.join("\n")
+      end
+
+      def format_summary(_total_files, _total_problems)
+        ''
+      end
+    end
+  end
+end

data/lib/yamlint/output/standard.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Yamlint
+  module Output
+    class Standard < Base
+      def format(filepath, problems)
+        return '' if problems.empty?
+
+        lines = [filepath]
+        problems.each do |problem|
+          lines << "  #{problem.line}:#{problem.column}      #{problem.level}   #{problem.message}  (#{problem.rule})"
+        end
+        lines.join("\n")
+      end
+
+      def format_summary(total_files, total_problems)
+        if total_problems.zero?
+          "#{total_files} file(s) checked, no problems found"
+        else
+          "#{total_files} file(s) checked, #{total_problems} problem(s) found"
+        end
+      end
+    end
+  end
+end

data/lib/yamlint/output.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Yamlint
+  module Output
+    autoload :Base, 'yamlint/output/base'
+    autoload :Standard, 'yamlint/output/standard'
+    autoload :Parsable, 'yamlint/output/parsable'
+    autoload :Colored, 'yamlint/output/colored'
+    autoload :Github, 'yamlint/output/github'
+
+    def self.get(format)
+      case format.to_s
+      when 'standard'
+        Standard.new
+      when 'parsable'
+        Parsable.new
+      when 'colored', 'auto'
+        Colored.new
+      when 'github'
+        Github.new
+      else
+        raise ArgumentError, "Unknown output format: #{format}"
+      end
+    end
+  end
+end

data/lib/yamlint/parser/comment_extractor.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+module Yamlint
+  module Parser
+    class Comment
+      attr_reader :line_number, :column, :text, :inline
+
+      def initialize(line_number:, column:, text:, inline: false)
+        @line_number = line_number
+        @column = column
+        @text = text
+        @inline = inline
+      end
+
+      def inline?
+        @inline
+      end
+
+      def disable_directive?
+        @text.match?(/yamllint\s+disable(-line)?/)
+      end
+
+      def enable_directive?
+        @text.match?(/yamllint\s+enable/)
+      end
+
+      def disabled_rules
+        if (match = @text.match(/yamllint\s+disable(-line)?\s+(.+)/))
+          match[2].split(/[,\s]+/).map(&:strip).reject(&:empty?)
+        else
+          []
+        end
+      end
+    end
+
+    class CommentExtractor
+      COMMENT_PATTERN = /#(.*)$/
+
+      def initialize(content)
+        @content = content
+      end
+
+      def extract
+        comments = []
+        @content.lines.each_with_index do |line, index|
+          line_number = index + 1
+          extract_comments_from_line(line, line_number, comments)
+        end
+        comments
+      end
+
+      private
+
+      def extract_comments_from_line(line, line_number, comments)
+        return if in_string?(line)
+
+        if (match = line.match(COMMENT_PATTERN))
+          column = match.begin(0) + 1
+          text = match[1].strip
+          inline = column > 1 && !line[0...(column - 1)].strip.empty?
+
+          comments << Comment.new(
+            line_number:,
+            column:,
+            text:,
+            inline:
+          )
+        end
+      end
+
+      def in_string?(_line)
+        # Simple heuristic: skip lines that start with quotes
+        # A more complete implementation would track string state
+        false
+      end
+    end
+  end
+end

data/lib/yamlint/parser/line_parser.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Yamlint
+  module Parser
+    class LineParser
+      def initialize(content)
+        @content = content
+      end
+
+      def parse
+        @content.lines
+      end
+
+      def line_at(line_number)
+        lines = parse
+        lines[line_number - 1]
+      end
+
+      def line_count
+        parse.length
+      end
+
+      def each_line_with_number(&)
+        parse.each_with_index do |line, index|
+          yield(line, index + 1)
+        end
+      end
+    end
+  end
+end

data/lib/yamlint/parser/token_parser.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+require 'yaml'
+
+module Yamlint
+  module Parser
+    class TokenParser
+      class Handler < Psych::Handler
+        attr_reader :tokens
+
+        def initialize
+          super
+          @tokens = []
+          @parser = nil
+        end
+
+        attr_writer :parser
+
+        def start_stream(encoding)
+          add_token(:stream_start, encoding:)
+        end
+
+        def end_stream
+          add_token(:stream_end)
+        end
+
+        def start_document(version, tag_directives, implicit)
+          add_token(:document_start, version:, tag_directives:, implicit:)
+        end
+
+        def end_document(implicit)
+          add_token(:document_end, implicit:)
+        end
+
+        def start_mapping(anchor, tag, implicit, style)
+          add_token(:mapping_start, anchor:, tag:, implicit:, style:)
+        end
+
+        def end_mapping
+          add_token(:mapping_end)
+        end
+
+        def start_sequence(anchor, tag, implicit, style)
+          add_token(:sequence_start, anchor:, tag:, implicit:, style:)
+        end
+
+        def end_sequence
+          add_token(:sequence_end)
+        end
+
+        def scalar(value, anchor, tag, plain, quoted, style)
+          add_token(:scalar, value:, anchor:, tag:, plain:, quoted:, style:)
+        end
+
+        def alias(anchor)
+          add_token(:alias, anchor:)
+        end
+
+        private
+
+        def add_token(type, **attrs)
+          mark = @parser&.mark
+          token = Models::Token.new(
+            type:,
+            value: attrs[:value],
+            start_line: mark ? mark.line + 1 : 1,
+            start_column: mark ? mark.column + 1 : 1
+          )
+          @tokens << token
+        end
+      end
+
+      def initialize(content)
+        @content = content
+      end
+
+      def parse
+        handler = Handler.new
+        parser = Psych::Parser.new(handler)
+        handler.parser = parser
+
+        begin
+          parser.parse(@content)
+        rescue Psych::SyntaxError
+          # Syntax errors will be handled separately
+        end
+
+        handler.tokens
+      end
+    end
+  end
+end

data/lib/yamlint/parser.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module Yamlint
+  module Parser
+    autoload :LineParser, 'yamlint/parser/line_parser'
+    autoload :TokenParser, 'yamlint/parser/token_parser'
+    autoload :CommentExtractor, 'yamlint/parser/comment_extractor'
+    autoload :Comment, 'yamlint/parser/comment_extractor'
+  end
+end

data/lib/yamlint/presets/default.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Yamlint
+  module Presets
+    DEFAULT = {
+      rules: {
+        'anchors' => { 'forbid-undeclared-aliases' => true, 'forbid-duplicated-anchors' => true,
+                       'forbid-unused-anchors' => true },
+        'braces' => { 'forbid' => false, 'min-spaces-inside' => 0, 'max-spaces-inside' => 0 },
+        'brackets' => { 'forbid' => false, 'min-spaces-inside' => 0, 'max-spaces-inside' => 0 },
+        'colons' => { 'max-spaces-before' => 0, 'max-spaces-after' => 1 },
+        'commas' => { 'max-spaces-before' => 0, 'min-spaces-after' => 1, 'max-spaces-after' => 1 },
+        'comments' => { 'require-starting-space' => true, 'ignore-shebangs' => true, 'min-spaces-from-content' => 2 },
+        'comments-indentation' => {},
+        'document-end' => 'disable',
+        'document-start' => 'disable',
+        'empty-lines' => { 'max' => 2, 'max-start' => 0, 'max-end' => 0 },
+        'empty-values' => { 'forbid-in-block-mappings' => true, 'forbid-in-flow-mappings' => true },
+        'float-values' => 'disable',
+        'hyphens' => { 'max-spaces-after' => 1 },
+        'indentation' => { 'spaces' => 2, 'indent-sequences' => true },
+        'key-duplicates' => {},
+        'key-ordering' => 'disable',
+        'line-length' => { 'max' => 80, 'allow-non-breakable-words' => true,
+                           'allow-non-breakable-inline-mappings' => true },
+        'new-line-at-end-of-file' => {},
+        'new-lines' => { 'type' => 'unix' },
+        'octal-values' => { 'forbid-implicit-octal' => true, 'forbid-explicit-octal' => false },
+        'quoted-strings' => 'disable',
+        'trailing-spaces' => {},
+        'truthy' => { 'allowed-values' => %w[true false], 'check-keys' => true }
+      }
+    }.freeze
+  end
+end

data/lib/yamlint/presets/relaxed.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Yamlint
+  module Presets
+    RELAXED = {
+      rules: {
+        'anchors' => 'disable',
+        'braces' => { 'forbid' => false, 'min-spaces-inside' => 0, 'max-spaces-inside' => 1 },
+        'brackets' => { 'forbid' => false, 'min-spaces-inside' => 0, 'max-spaces-inside' => 1 },
+        'colons' => { 'max-spaces-before' => 1, 'max-spaces-after' => 1 },
+        'commas' => { 'max-spaces-before' => 1, 'min-spaces-after' => 1, 'max-spaces-after' => 1 },
+        'comments' => 'disable',
+        'comments-indentation' => 'disable',
+        'document-end' => 'disable',
+        'document-start' => 'disable',
+        'empty-lines' => 'disable',
+        'empty-values' => 'disable',
+        'float-values' => 'disable',
+        'hyphens' => 'disable',
+        'indentation' => 'disable',
+        'key-duplicates' => {},
+        'key-ordering' => 'disable',
+        'line-length' => { 'max' => 120, 'allow-non-breakable-words' => true,
+                           'allow-non-breakable-inline-mappings' => true },
+        'new-line-at-end-of-file' => 'disable',
+        'new-lines' => { 'type' => 'unix' },
+        'octal-values' => 'disable',
+        'quoted-strings' => 'disable',
+        'trailing-spaces' => 'disable',
+        'truthy' => 'disable'
+      }
+    }.freeze
+  end
+end

data/lib/yamlint/presets.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require_relative 'presets/default'
+require_relative 'presets/relaxed'
+
+module Yamlint
+  module Presets
+    def self.get(name)
+      case name.to_s
+      when 'default'
+        DEFAULT
+      when 'relaxed'
+        RELAXED
+      else
+        raise ArgumentError, "Unknown preset: #{name}"
+      end
+    end
+  end
+end

data/lib/yamlint/rules/anchors.rb

@@ -0,0 +1,133 @@
+# frozen_string_literal: true
+
+require 'yaml'
+
+module Yamlint
+  module Rules
+    class Anchors < Base
+      rule_id 'anchors'
+      desc 'Check anchors are defined before use and are not duplicated.'
+      defaults({
+                 'forbid-undeclared-aliases': true,
+                 'forbid-duplicated-anchors': true,
+                 'forbid-unused-anchors': true
+               })
+
+      def check(context)
+        handler = AnchorHandler.new
+        parser = Psych::Parser.new(handler)
+        handler.parser = parser
+
+        begin
+          parser.parse(context.content)
+        rescue Psych::SyntaxError
+          return []
+        end
+
+        problems = []
+
+        if @config[:'forbid-undeclared-aliases']
+          handler.undeclared_aliases.each do |alias_info|
+            problems << problem(
+              line: alias_info[:line],
+              column: alias_info[:column],
+              message: "found undefined alias \"#{alias_info[:name]}\"",
+              fixable: false
+            )
+          end
+        end
+
+        if @config[:'forbid-duplicated-anchors']
+          handler.duplicated_anchors.each do |anchor_info|
+            problems << problem(
+              line: anchor_info[:line],
+              column: anchor_info[:column],
+              message: "found duplicate anchor \"#{anchor_info[:name]}\"",
+              fixable: false
+            )
+          end
+        end
+
+        if @config[:'forbid-unused-anchors']
+          handler.unused_anchors.each do |anchor_info|
+            problems << problem(
+              line: anchor_info[:line],
+              column: anchor_info[:column],
+              message: "found undefined anchor \"#{anchor_info[:name]}\"",
+              fixable: false
+            )
+          end
+        end
+
+        problems
+      end
+
+      class AnchorHandler < Psych::Handler
+        attr_accessor :parser
+
+        def initialize
+          super
+          @anchors = {}
+          @aliases = []
+          @parser = nil
+        end
+
+        def scalar(_value, anchor, _tag, _plain, _quoted, _style)
+          record_anchor(anchor) if anchor
+        end
+
+        def start_mapping(anchor, _tag, _implicit, _style)
+          record_anchor(anchor) if anchor
+        end
+
+        def start_sequence(anchor, _tag, _implicit, _style)
+          record_anchor(anchor) if anchor
+        end
+
+        def alias(anchor)
+          mark = @parser&.mark
+          @aliases << {
+            name: anchor,
+            line: mark ? mark.line + 1 : 1,
+            column: mark ? mark.column + 1 : 1
+          }
+        end
+
+        def undeclared_aliases
+          @aliases.reject { |a| @anchors.key?(a[:name]) }
+        end
+
+        def duplicated_anchors
+          @anchors.values.select { |v| v.is_a?(Array) && v.length > 1 }.flatten
+        end
+
+        def unused_anchors
+          used_names = @aliases.map { |a| a[:name] }
+          @anchors.except(*used_names).map do |_, info|
+            info.is_a?(Array) ? info.first : info
+          end
+        end
+
+        private
+
+        def record_anchor(anchor)
+          mark = @parser&.mark
+          info = {
+            name: anchor,
+            line: mark ? mark.line + 1 : 1,
+            column: mark ? mark.column + 1 : 1
+          }
+
+          if @anchors.key?(anchor)
+            existing = @anchors[anchor]
+            @anchors[anchor] = existing.is_a?(Array) ? existing + [info] : [existing, info]
+          else
+            @anchors[anchor] = info
+          end
+        end
+      end
+    end
+
+    Registry.register(Anchors)
+  end
+end