yamlint 0.1.0 → 1.0.0

data/lib/yamlint/rules/empty_lines.rb

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+module Yamlint
+  module Rules
+    class EmptyLines < Base
+      rule_id 'empty-lines'
+      desc 'Limit the number of consecutive blank lines.'
+      defaults({
+                 max: 2,
+                 'max-start': 0,
+                 'max-end': 0
+               })
+
+      def check(context)
+        return [] if context.empty?
+
+        problems = []
+        problems.concat(check_start_empty_lines(context))
+        problems.concat(check_end_empty_lines(context))
+        problems.concat(check_consecutive_empty_lines(context))
+        problems
+      end
+
+      def fixable?
+        true
+      end
+
+      private
+
+      def check_start_empty_lines(context)
+        max_start = @config[:'max-start']
+        count = 0
+
+        context.lines.each do |line|
+          break unless blank_line?(line)
+
+          count += 1
+        end
+
+        return [] if count <= max_start
+
+        [problem(
+          line: 1,
+          column: 1,
+          message: "too many blank lines at the beginning of file (#{count} > #{max_start})",
+          fixable: true
+        )]
+      end
+
+      def check_end_empty_lines(context)
+        max_end = @config[:'max-end']
+        count = 0
+        lines = context.lines
+
+        lines.reverse_each do |line|
+          break unless blank_line?(line)
+
+          count += 1
+        end
+
+        return [] if count <= max_end
+
+        [problem(
+          line: context.line_count - count + 1,
+          column: 1,
+          message: "too many blank lines at the end of file (#{count} > #{max_end})",
+          fixable: true
+        )]
+      end
+
+      def check_consecutive_empty_lines(context)
+        max = @config[:max]
+        problems = []
+        consecutive_count = 0
+        first_blank_line = nil
+
+        context.lines.each_with_index do |line, index|
+          line_number = index + 1
+
+          if blank_line?(line)
+            first_blank_line ||= line_number
+            consecutive_count += 1
+          else
+            if consecutive_count > max
+              problems << problem(
+                line: first_blank_line,
+                column: 1,
+                message: "too many blank lines (#{consecutive_count} > #{max})",
+                fixable: true
+              )
+            end
+            consecutive_count = 0
+            first_blank_line = nil
+          end
+        end
+
+        problems
+      end
+
+      def blank_line?(line)
+        line.strip.empty?
+      end
+    end
+
+    Registry.register(EmptyLines)
+  end
+end

data/lib/yamlint/rules/empty_values.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module Yamlint
+  module Rules
+    class EmptyValues < LineRule
+      rule_id 'empty-values'
+      desc 'Forbid empty values in mappings.'
+      defaults({
+                 'forbid-in-block-mappings': true,
+                 'forbid-in-flow-mappings': true
+               })
+
+      def check_line(line, line_number, _context)
+        return if line.strip.empty?
+        return if line.strip.start_with?('#')
+
+        problems = []
+
+        if @config[:'forbid-in-block-mappings'] && line.match?(/:\s*$/) && !line.match?(/[|>]/)
+          problems << problem(
+            line: line_number,
+            column: line.index(':') + 1,
+            message: 'empty value in block mapping',
+            fixable: false
+          )
+        end
+
+        if @config[:'forbid-in-flow-mappings'] && line.match?(/:\s*[,}]/)
+          problems << problem(
+            line: line_number,
+            column: line.index(':') + 1,
+            message: 'empty value in flow mapping',
+            fixable: false
+          )
+        end
+
+        problems
+      end
+    end
+
+    Registry.register(EmptyValues)
+  end
+end

data/lib/yamlint/rules/float_values.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module Yamlint
+  module Rules
+    class FloatValues < LineRule
+      rule_id 'float-values'
+      desc 'Check float value formatting.'
+      defaults({
+                 'forbid-scientific-notation': false,
+                 'forbid-nan': false,
+                 'forbid-inf': false,
+                 'require-numeral-before-decimal': false
+               })
+
+      def check_line(line, line_number, _context)
+        return if line.strip.empty?
+        return if line.strip.start_with?('#')
+
+        problems = []
+
+        if @config[:'forbid-scientific-notation'] && line.match?(/:\s*[\d.]+[eE][+-]?\d+/)
+          problems << problem(
+            line: line_number,
+            column: line.index(':') + 1,
+            message: 'scientific notation forbidden',
+            fixable: false
+          )
+        end
+
+        if @config[:'forbid-nan'] && line.match?(/:\s*\.nan\s*(?:#.*)?$/i)
+          problems << problem(
+            line: line_number,
+            column: line.index(':') + 1,
+            message: '.nan value forbidden',
+            fixable: false
+          )
+        end
+
+        if @config[:'forbid-inf'] && line.match?(/:\s*[+-]?\.inf\s*(?:#.*)?$/i)
+          problems << problem(
+            line: line_number,
+            column: line.index(':') + 1,
+            message: '.inf value forbidden',
+            fixable: false
+          )
+        end
+
+        if @config[:'require-numeral-before-decimal'] && line.match?(/:\s*\.\d+/)
+          problems << problem(
+            line: line_number,
+            column: line.index(':') + 1,
+            message: 'numeral required before decimal point',
+            fixable: true
+          )
+        end
+
+        problems
+      end
+
+      def fixable?
+        @config[:'require-numeral-before-decimal']
+      end
+    end
+
+    Registry.register(FloatValues)
+  end
+end

data/lib/yamlint/rules/hyphens.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require 'English'
+module Yamlint
+  module Rules
+    class Hyphens < LineRule
+      rule_id 'hyphens'
+      desc 'Check space after hyphens.'
+      defaults({
+                 'max-spaces-after': 1
+               })
+
+      def check_line(line, line_number, _context)
+        return if line.strip.empty?
+        return if line.strip.start_with?('#')
+
+        problems = []
+        max_after = @config[:'max-spaces-after']
+
+        line.scan(/^(\s*)-(\s+)/) do |_indent, spaces|
+          next if spaces.length <= max_after
+
+          pos = $LAST_MATCH_INFO.begin(2)
+          problems << problem(
+            line: line_number,
+            column: pos + 1,
+            message: "too many spaces after hyphen (#{spaces.length} > #{max_after})",
+            fixable: true
+          )
+        end
+
+        problems
+      end
+
+      def fixable?
+        true
+      end
+    end
+
+    Registry.register(Hyphens)
+  end
+end

data/lib/yamlint/rules/indentation.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Yamlint
+  module Rules
+    class Indentation < LineRule
+      rule_id 'indentation'
+      desc 'Enforce consistent indentation.'
+      defaults({
+                 spaces: 2,
+                 'indent-sequences': true,
+                 'check-multi-line-strings': false
+               })
+
+      def check_line(line, line_number, _context)
+        return if line.strip.empty?
+        return if line.start_with?('#')
+
+        expected_spaces = @config[:spaces]
+        leading_spaces = line[/\A */].length
+
+        return if leading_spaces.zero?
+        return if (leading_spaces % expected_spaces).zero?
+
+        problem(
+          line: line_number,
+          column: 1,
+          message: "wrong indentation: expected #{expected_spaces}n spaces",
+          fixable: true
+        )
+      end
+
+      def fixable?
+        true
+      end
+    end
+
+    Registry.register(Indentation)
+  end
+end

data/lib/yamlint/rules/key_duplicates.rb

@@ -0,0 +1,127 @@
+# frozen_string_literal: true
+
+require 'yaml'
+
+module Yamlint
+  module Rules
+    class KeyDuplicates < Base
+      rule_id 'key-duplicates'
+      desc 'Forbid duplicated keys in mappings.'
+      defaults({})
+
+      def check(context)
+        handler = DuplicateKeyHandler.new
+        parser = Psych::Parser.new(handler)
+        handler.parser = parser
+
+        begin
+          parser.parse(context.content)
+        rescue Psych::SyntaxError
+          return []
+        end
+
+        handler.problems.map do |prob|
+          problem(
+            line: prob[:line],
+            column: prob[:column],
+            message: "duplicate key \"#{prob[:key]}\"",
+            fixable: false
+          )
+        end
+      end
+
+      class DuplicateKeyHandler < Psych::Handler
+        attr_reader :problems
+
+        def initialize
+          super
+          @stack = []
+          @problems = []
+          @parser = nil
+        end
+
+        attr_writer :parser
+
+        def start_mapping(*)
+          parent = current_mapping_frame
+          @stack << {
+            type: :mapping,
+            keys: {},
+            expecting_key: true,
+            close_parent: capture_close_parent(parent)
+          }
+        end
+
+        def end_mapping
+          frame = @stack.pop
+          close_parent_value(frame)
+        end
+
+        def start_sequence(*)
+          parent = current_mapping_frame
+          @stack << {
+            type: :sequence,
+            close_parent: capture_close_parent(parent)
+          }
+        end
+
+        def end_sequence
+          frame = @stack.pop
+          close_parent_value(frame)
+        end
+
+        def scalar(value, _anchor, _tag, _plain, _quoted, _style)
+          frame = @stack.last
+          return unless frame && frame[:type] == :mapping
+
+          if frame[:expecting_key]
+            current_keys = frame[:keys]
+            mark = @parser&.mark
+
+            if current_keys.key?(value)
+              @problems << {
+                key: value,
+                line: mark ? mark.line + 1 : 1,
+                column: mark ? mark.column + 1 : 1
+              }
+            else
+              current_keys[value] = true
+            end
+
+            frame[:expecting_key] = false
+          else
+            frame[:expecting_key] = true
+          end
+        end
+
+        private
+
+        def current_mapping_frame
+          frame = @stack.last
+          return frame if frame && frame[:type] == :mapping
+
+          nil
+        end
+
+        def capture_close_parent(parent)
+          return nil unless parent
+
+          if parent[:expecting_key]
+            { parent:, expecting_key: false }
+          else
+            { parent:, expecting_key: true }
+          end
+        end
+
+        def close_parent_value(frame)
+          close = frame[:close_parent]
+          return unless close
+
+          close[:parent][:expecting_key] = close[:expecting_key]
+        end
+      end
+    end
+
+    Registry.register(KeyDuplicates)
+  end
+end

data/lib/yamlint/rules/key_ordering.rb

@@ -0,0 +1,126 @@
+# frozen_string_literal: true
+
+require 'yaml'
+
+module Yamlint
+  module Rules
+    class KeyOrdering < Base
+      rule_id 'key-ordering'
+      desc 'Enforce alphabetical ordering of keys.'
+      defaults({})
+
+      def check(context)
+        handler = KeyOrderHandler.new
+        parser = Psych::Parser.new(handler)
+        handler.parser = parser
+
+        begin
+          parser.parse(context.content)
+        rescue Psych::SyntaxError
+          return []
+        end
+
+        handler.problems.map do |prob|
+          problem(
+            line: prob[:line],
+            column: prob[:column],
+            message: "wrong ordering of key \"#{prob[:key]}\" (should be before \"#{prob[:prev_key]}\")",
+            fixable: false
+          )
+        end
+      end
+
+      class KeyOrderHandler < Psych::Handler
+        attr_reader :problems
+        attr_accessor :parser
+
+        def initialize
+          super
+          @stack = []
+          @problems = []
+          @parser = nil
+        end
+
+        def start_mapping(*)
+          parent = current_mapping_frame
+          @stack << {
+            type: :mapping,
+            keys: [],
+            expecting_key: true,
+            close_parent: capture_close_parent(parent)
+          }
+        end
+
+        def end_mapping
+          frame = @stack.pop
+          close_parent_value(frame)
+        end
+
+        def start_sequence(*)
+          parent = current_mapping_frame
+          @stack << {
+            type: :sequence,
+            close_parent: capture_close_parent(parent)
+          }
+        end
+
+        def end_sequence
+          frame = @stack.pop
+          close_parent_value(frame)
+        end
+
+        def scalar(value, _anchor, _tag, _plain, _quoted, _style)
+          frame = @stack.last
+          return unless frame && frame[:type] == :mapping
+
+          if frame[:expecting_key]
+            current_keys = frame[:keys]
+            mark = @parser&.mark
+
+            if current_keys.any? && value < current_keys.last
+              @problems << {
+                key: value,
+                prev_key: current_keys.last,
+                line: mark ? mark.line + 1 : 1,
+                column: mark ? mark.column + 1 : 1
+              }
+            end
+
+            current_keys << value
+            frame[:expecting_key] = false
+          else
+            frame[:expecting_key] = true
+          end
+        end
+
+        private
+
+        def current_mapping_frame
+          frame = @stack.last
+          return frame if frame && frame[:type] == :mapping
+
+          nil
+        end
+
+        def capture_close_parent(parent)
+          return nil unless parent
+
+          if parent[:expecting_key]
+            { parent:, expecting_key: false }
+          else
+            { parent:, expecting_key: true }
+          end
+        end
+
+        def close_parent_value(frame)
+          close = frame[:close_parent]
+          return unless close
+
+          close[:parent][:expecting_key] = close[:expecting_key]
+        end
+      end
+    end
+
+    Registry.register(KeyOrdering)
+  end
+end

data/lib/yamlint/rules/line_length.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module Yamlint
+  module Rules
+    class LineLength < LineRule
+      rule_id 'line-length'
+      desc 'Limit the line length.'
+      defaults({
+                 max: 80,
+                 'allow-non-breakable-words': true,
+                 'allow-non-breakable-inline-mappings': true
+               })
+
+      def check_line(line, line_number, _context)
+        max_length = @config[:max]
+        actual_length = line.chomp.length
+
+        return if actual_length <= max_length
+        return if allow_non_breakable_words? && non_breakable_word?(line)
+        return if allow_non_breakable_inline_mappings? && inline_mapping?(line)
+
+        problem(
+          line: line_number,
+          column: max_length + 1,
+          message: "line too long (#{actual_length} > #{max_length} characters)",
+          fixable: false
+        )
+      end
+
+      private
+
+      def allow_non_breakable_words?
+        @config[:'allow-non-breakable-words']
+      end
+
+      def allow_non_breakable_inline_mappings?
+        @config[:'allow-non-breakable-inline-mappings']
+      end
+
+      def non_breakable_word?(line)
+        stripped = line.strip
+        return false if stripped.empty?
+
+        # Check if the line contains a URL or a very long word
+        stripped.match?(%r{https?://\S+}) ||
+          stripped.split.any? { |word| word.length > @config[:max] }
+      end
+
+      def inline_mapping?(line)
+        stripped = line.strip
+        stripped.match?(/^\{.*\}$/)
+      end
+    end
+
+    Registry.register(LineLength)
+  end
+end

data/lib/yamlint/rules/new_line_at_end_of_file.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Yamlint
+  module Rules
+    class NewLineAtEndOfFile < Base
+      rule_id 'new-line-at-end-of-file'
+      desc 'Require a new line character at the end of files.'
+      defaults({})
+
+      def check(context)
+        return [] if context.empty?
+
+        last_char = context.content[-1]
+        return [] if last_char == "\n"
+
+        [problem(
+          line: context.line_count,
+          column: (context.lines.last&.length || 0) + 1,
+          message: 'no new line character at the end of file',
+          fixable: true
+        )]
+      end
+
+      def fixable?
+        true
+      end
+    end
+
+    Registry.register(NewLineAtEndOfFile)
+  end
+end

data/lib/yamlint/rules/new_lines.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module Yamlint
+  module Rules
+    class NewLines < Base
+      rule_id 'new-lines'
+      desc 'Use consistent line endings throughout the file.'
+      defaults({ type: 'unix' })
+
+      def check(context)
+        return [] if context.empty?
+
+        expected_type = @config[:type]
+        problems = []
+
+        context.lines.each_with_index do |line, index|
+          line_number = index + 1
+          problem = check_line_ending(line, line_number, expected_type)
+          problems << problem if problem
+        end
+
+        problems
+      end
+
+      def fixable?
+        true
+      end
+
+      private
+
+      def check_line_ending(line, line_number, expected_type)
+        case expected_type
+        when 'unix'
+          if line.end_with?("\r\n")
+            problem(
+              line: line_number,
+              column: line.length - 1,
+              message: 'wrong new line character: expected unix',
+              fixable: true
+            )
+          end
+        when 'dos'
+          if line.end_with?("\n") && !line.end_with?("\r\n")
+            problem(
+              line: line_number,
+              column: line.length,
+              message: 'wrong new line character: expected dos',
+              fixable: true
+            )
+          end
+        when 'platform'
+          nil
+        end
+      end
+    end
+
+    Registry.register(NewLines)
+  end
+end