yamlint 0.1.0 → 1.0.0

data/lib/yamlint/rules/base.rb

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+module Yamlint
+  module Rules
+    class Base
+      class << self
+        attr_reader :id, :description, :default_options
+
+        def rule_id(id)
+          @id = id
+        end
+
+        def desc(description)
+          @description = description
+        end
+
+        def defaults(options)
+          @default_options = options
+        end
+
+        def inherited(subclass)
+          super
+          subclass.instance_variable_set(:@default_options, {})
+        end
+      end
+
+      attr_reader :config, :level
+
+      def initialize(config = {})
+        @config = (self.class.default_options || {}).merge(config)
+        @level = @config[:level] || :error
+      end
+
+      def check(_context)
+        raise NotImplementedError, "#{self.class}#check must be implemented"
+      end
+
+      def fixable?
+        false
+      end
+
+      protected
+
+      def problem(line:, column:, message:, fixable: false)
+        Models::Problem.new(
+          line:,
+          column:,
+          rule: self.class.id,
+          level: @level,
+          message:,
+          fixable:
+        )
+      end
+    end
+
+    class LineRule < Base
+      def check(context)
+        problems = []
+        context.lines.each_with_index do |line, index|
+          line_number = index + 1
+          line_problems = check_line(line, line_number, context)
+          problems.concat(Array(line_problems))
+        end
+        problems
+      end
+
+      def check_line(_line, _line_number, _context)
+        raise NotImplementedError, "#{self.class}#check_line must be implemented"
+      end
+    end
+
+    class TokenRule < Base
+      def check(context)
+        problems = []
+        context.tokens.each do |token|
+          token_problems = check_token(token, context)
+          problems.concat(Array(token_problems))
+        end
+        problems
+      end
+
+      def check_token(_token, _context)
+        raise NotImplementedError, "#{self.class}#check_token must be implemented"
+      end
+    end
+
+    class CommentRule < Base
+      def check(context)
+        problems = []
+        context.comments.each do |comment|
+          comment_problems = check_comment(comment, context)
+          problems.concat(Array(comment_problems))
+        end
+        problems
+      end
+
+      def check_comment(_comment, _context)
+        raise NotImplementedError, "#{self.class}#check_comment must be implemented"
+      end
+    end
+  end
+end

data/lib/yamlint/rules/braces.rb

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+require 'English'
+module Yamlint
+  module Rules
+    class Braces < LineRule
+      rule_id 'braces'
+      desc 'Check spaces inside braces.'
+      defaults({
+                 forbid: false,
+                 'min-spaces-inside': 0,
+                 'max-spaces-inside': 0,
+                 'min-spaces-inside-empty': -1,
+                 'max-spaces-inside-empty': -1
+               })
+
+      def check_line(line, line_number, _context)
+        return if line.strip.empty?
+        return if line.strip.start_with?('#')
+
+        problems = []
+
+        if @config[:forbid] && line.include?('{')
+          problems << problem(
+            line: line_number,
+            column: line.index('{') + 1,
+            message: 'flow mapping (braces) forbidden',
+            fixable: false
+          )
+          return problems
+        end
+
+        problems.concat(check_opening_brace(line, line_number))
+        problems.concat(check_closing_brace(line, line_number))
+        problems
+      end
+
+      def fixable?
+        true
+      end
+
+      private
+
+      def check_opening_brace(line, line_number)
+        problems = []
+        min_spaces = @config[:'min-spaces-inside']
+        max_spaces = @config[:'max-spaces-inside']
+
+        line.scan(/\{(\s*)(?!\})/) do |match|
+          spaces = match[0]
+          pos = $LAST_MATCH_INFO.begin(0)
+
+          if spaces.length < min_spaces
+            problems << problem(
+              line: line_number,
+              column: pos + 2,
+              message: "too few spaces inside braces (#{spaces.length} < #{min_spaces})",
+              fixable: true
+            )
+          elsif spaces.length > max_spaces
+            problems << problem(
+              line: line_number,
+              column: pos + 2,
+              message: "too many spaces inside braces (#{spaces.length} > #{max_spaces})",
+              fixable: true
+            )
+          end
+        end
+
+        problems
+      end
+
+      def check_closing_brace(line, line_number)
+        problems = []
+        min_spaces = @config[:'min-spaces-inside']
+        max_spaces = @config[:'max-spaces-inside']
+
+        line.scan(/(?<!\{)(\s*)\}/) do |match|
+          spaces = match[0]
+          pos = $LAST_MATCH_INFO.begin(0)
+
+          if spaces.length < min_spaces
+            problems << problem(
+              line: line_number,
+              column: pos + 1,
+              message: "too few spaces inside braces (#{spaces.length} < #{min_spaces})",
+              fixable: true
+            )
+          elsif spaces.length > max_spaces
+            problems << problem(
+              line: line_number,
+              column: pos + 1,
+              message: "too many spaces inside braces (#{spaces.length} > #{max_spaces})",
+              fixable: true
+            )
+          end
+        end
+
+        problems
+      end
+    end
+
+    Registry.register(Braces)
+  end
+end

data/lib/yamlint/rules/brackets.rb

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+require 'English'
+module Yamlint
+  module Rules
+    class Brackets < LineRule
+      rule_id 'brackets'
+      desc 'Check spaces inside brackets.'
+      defaults({
+                 forbid: false,
+                 'min-spaces-inside': 0,
+                 'max-spaces-inside': 0,
+                 'min-spaces-inside-empty': -1,
+                 'max-spaces-inside-empty': -1
+               })
+
+      def check_line(line, line_number, _context)
+        return if line.strip.empty?
+        return if line.strip.start_with?('#')
+
+        problems = []
+
+        if @config[:forbid] && line.include?('[')
+          problems << problem(
+            line: line_number,
+            column: line.index('[') + 1,
+            message: 'flow sequence (brackets) forbidden',
+            fixable: false
+          )
+          return problems
+        end
+
+        problems.concat(check_opening_bracket(line, line_number))
+        problems.concat(check_closing_bracket(line, line_number))
+        problems
+      end
+
+      def fixable?
+        true
+      end
+
+      private
+
+      def check_opening_bracket(line, line_number)
+        problems = []
+        min_spaces = @config[:'min-spaces-inside']
+        max_spaces = @config[:'max-spaces-inside']
+
+        line.scan(/\[(\s*)(?!\])/) do |match|
+          spaces = match[0]
+          pos = $LAST_MATCH_INFO.begin(0)
+
+          if spaces.length < min_spaces
+            problems << problem(
+              line: line_number,
+              column: pos + 2,
+              message: "too few spaces inside brackets (#{spaces.length} < #{min_spaces})",
+              fixable: true
+            )
+          elsif spaces.length > max_spaces
+            problems << problem(
+              line: line_number,
+              column: pos + 2,
+              message: "too many spaces inside brackets (#{spaces.length} > #{max_spaces})",
+              fixable: true
+            )
+          end
+        end
+
+        problems
+      end
+
+      def check_closing_bracket(line, line_number)
+        problems = []
+        min_spaces = @config[:'min-spaces-inside']
+        max_spaces = @config[:'max-spaces-inside']
+
+        line.scan(/(?<!\[)(\s*)\]/) do |match|
+          spaces = match[0]
+          pos = $LAST_MATCH_INFO.begin(0)
+
+          if spaces.length < min_spaces
+            problems << problem(
+              line: line_number,
+              column: pos + 1,
+              message: "too few spaces inside brackets (#{spaces.length} < #{min_spaces})",
+              fixable: true
+            )
+          elsif spaces.length > max_spaces
+            problems << problem(
+              line: line_number,
+              column: pos + 1,
+              message: "too many spaces inside brackets (#{spaces.length} > #{max_spaces})",
+              fixable: true
+            )
+          end
+        end
+
+        problems
+      end
+    end
+
+    Registry.register(Brackets)
+  end
+end

data/lib/yamlint/rules/colons.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+require 'English'
+module Yamlint
+  module Rules
+    class Colons < LineRule
+      rule_id 'colons'
+      desc 'Check spaces before and after colons.'
+      defaults({
+                 'max-spaces-before': 0,
+                 'max-spaces-after': 1
+               })
+
+      def check_line(line, line_number, _context)
+        return if line.strip.empty?
+        return if line.strip.start_with?('#')
+
+        problems = []
+        problems.concat(check_spaces_before_colon(line, line_number))
+        problems.concat(check_spaces_after_colon(line, line_number))
+        problems
+      end
+
+      def fixable?
+        true
+      end
+
+      private
+
+      def check_spaces_before_colon(line, line_number)
+        problems = []
+        max_before = @config[:'max-spaces-before']
+
+        line.scan(/(\s+):/) do |match|
+          spaces = match[0]
+          next unless spaces.length > max_before
+
+          pos = $LAST_MATCH_INFO.begin(0)
+          problems << problem(
+            line: line_number,
+            column: pos + 1,
+            message: "too many spaces before colon (#{spaces.length} > #{max_before})",
+            fixable: true
+          )
+        end
+
+        problems
+      end
+
+      def check_spaces_after_colon(line, line_number)
+        problems = []
+        max_after = @config[:'max-spaces-after']
+
+        line.scan(/:(\s{2,})/) do |match|
+          spaces = match[0]
+          next if spaces.include?("\n")
+
+          pos = $LAST_MATCH_INFO.begin(0)
+          problems << problem(
+            line: line_number,
+            column: pos + 2,
+            message: "too many spaces after colon (#{spaces.length} > #{max_after})",
+            fixable: true
+          )
+        end
+
+        problems
+      end
+    end
+
+    Registry.register(Colons)
+  end
+end

data/lib/yamlint/rules/commas.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+require 'English'
+module Yamlint
+  module Rules
+    class Commas < LineRule
+      rule_id 'commas'
+      desc 'Check spaces before and after commas.'
+      defaults({
+                 'max-spaces-before': 0,
+                 'min-spaces-after': 1,
+                 'max-spaces-after': 1
+               })
+
+      def check_line(line, line_number, _context)
+        return if line.strip.empty?
+        return if line.strip.start_with?('#')
+
+        problems = []
+        problems.concat(check_spaces_before_comma(line, line_number))
+        problems.concat(check_spaces_after_comma(line, line_number))
+        problems
+      end
+
+      def fixable?
+        true
+      end
+
+      private
+
+      def check_spaces_before_comma(line, line_number)
+        problems = []
+        max_before = @config[:'max-spaces-before']
+
+        line.scan(/(\s+),/) do |match|
+          spaces = match[0]
+          next unless spaces.length > max_before
+
+          pos = $LAST_MATCH_INFO.begin(0)
+          problems << problem(
+            line: line_number,
+            column: pos + 1,
+            message: "too many spaces before comma (#{spaces.length} > #{max_before})",
+            fixable: true
+          )
+        end
+
+        problems
+      end
+
+      def check_spaces_after_comma(line, line_number)
+        problems = []
+        min_after = @config[:'min-spaces-after']
+        max_after = @config[:'max-spaces-after']
+
+        line.scan(/,(\s*)/) do |match|
+          spaces = match[0]
+          next if spaces.include?("\n")
+
+          pos = $LAST_MATCH_INFO.begin(0)
+
+          if spaces.length < min_after
+            problems << problem(
+              line: line_number,
+              column: pos + 2,
+              message: "too few spaces after comma (#{spaces.length} < #{min_after})",
+              fixable: true
+            )
+          elsif spaces.length > max_after
+            problems << problem(
+              line: line_number,
+              column: pos + 2,
+              message: "too many spaces after comma (#{spaces.length} > #{max_after})",
+              fixable: true
+            )
+          end
+        end
+
+        problems
+      end
+    end
+
+    Registry.register(Commas)
+  end
+end

data/lib/yamlint/rules/comments.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+require 'English'
+module Yamlint
+  module Rules
+    class Comments < LineRule
+      rule_id 'comments'
+      desc 'Check comments formatting.'
+      defaults({
+                 'require-starting-space': true,
+                 'ignore-shebangs': true,
+                 'min-spaces-from-content': 2
+               })
+
+      def check_line(line, line_number, _context)
+        return unless line.include?('#')
+
+        problems = []
+
+        return problems if @config[:'ignore-shebangs'] && line_number == 1 && line.start_with?('#!')
+
+        problems.concat(check_starting_space(line, line_number))
+        problems.concat(check_spaces_from_content(line, line_number))
+        problems
+      end
+
+      def fixable?
+        true
+      end
+
+      private
+
+      def check_starting_space(line, line_number)
+        return [] unless @config[:'require-starting-space']
+
+        problems = []
+
+        line.scan(/#([^\s#])/) do |match|
+          next if match[0] == '!'
+
+          pos = $LAST_MATCH_INFO.begin(0)
+          problems << problem(
+            line: line_number,
+            column: pos + 1,
+            message: 'missing starting space in comment',
+            fixable: true
+          )
+        end
+
+        problems
+      end
+
+      def check_spaces_from_content(line, line_number)
+        return [] if line.strip.start_with?('#')
+
+        problems = []
+        min_spaces = @config[:'min-spaces-from-content']
+
+        if (match = line.match(/(\S)(\s*)#/))
+          spaces = match[2].length
+          if spaces < min_spaces
+            problems << problem(
+              line: line_number,
+              column: match.begin(0) + 2,
+              message: "too few spaces before comment (#{spaces} < #{min_spaces})",
+              fixable: true
+            )
+          end
+        end
+
+        problems
+      end
+    end
+
+    Registry.register(Comments)
+  end
+end

data/lib/yamlint/rules/comments_indentation.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+module Yamlint
+  module Rules
+    class CommentsIndentation < Base
+      rule_id 'comments-indentation'
+      desc 'Check comments indentation.'
+      defaults({})
+
+      def check(context)
+        problems = []
+
+        context.lines.each_with_index do |line, index|
+          line_number = index + 1
+
+          next unless line.strip.start_with?('#')
+
+          current_indent = line[/\A */].length
+          expected_indent = expected_indent_for_comment(context.lines, index)
+
+          next unless expected_indent && current_indent != expected_indent
+
+          problems << problem(
+            line: line_number,
+            column: 1,
+            message: "comment not indented correctly (expected #{expected_indent}, found #{current_indent})",
+            fixable: true
+          )
+        end
+
+        problems
+      end
+
+      def fixable?
+        true
+      end
+
+      private
+
+      def expected_indent_for_comment(lines, index)
+        next_indent = find_indent(lines, (index + 1)...lines.length)
+        return next_indent unless next_indent.nil?
+
+        previous_indent = find_indent(lines, (index - 1).downto(0))
+        return previous_indent unless previous_indent.nil?
+
+        0
+      end
+
+      def find_indent(lines, range)
+        range.each do |i|
+          line = lines[i]
+          next if line.nil?
+
+          stripped = line.strip
+          next if stripped.empty? || stripped.start_with?('#')
+
+          return line[/\A */].length
+        end
+        nil
+      end
+    end
+
+    Registry.register(CommentsIndentation)
+  end
+end

data/lib/yamlint/rules/document_end.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Yamlint
+  module Rules
+    class DocumentEnd < Base
+      rule_id 'document-end'
+      desc 'Require or forbid document end marker.'
+      defaults({
+                 present: false
+               })
+
+      def check(context)
+        return [] if context.empty?
+
+        has_end = context.lines.any? { |line| line.strip == '...' }
+        required = @config[:present]
+
+        if required && !has_end
+          [problem(
+            line: context.line_count,
+            column: 1,
+            message: 'missing document end "..."',
+            fixable: true
+          )]
+        elsif !required && has_end
+          line_number = context.lines.index { |line| line.strip == '...' } + 1
+          [problem(
+            line: line_number,
+            column: 1,
+            message: 'found forbidden document end "..."',
+            fixable: true
+          )]
+        else
+          []
+        end
+      end
+
+      def fixable?
+        true
+      end
+    end
+
+    Registry.register(DocumentEnd)
+  end
+end

data/lib/yamlint/rules/document_start.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Yamlint
+  module Rules
+    class DocumentStart < Base
+      rule_id 'document-start'
+      desc 'Require or forbid document start marker.'
+      defaults({
+                 present: true
+               })
+
+      def check(context)
+        return [] if context.empty?
+
+        has_start = context.lines.any? { |line| line.strip == '---' }
+        required = @config[:present]
+
+        if required && !has_start
+          [problem(
+            line: 1,
+            column: 1,
+            message: 'missing document start "---"',
+            fixable: true
+          )]
+        elsif !required && has_start
+          line_number = context.lines.index { |line| line.strip == '---' } + 1
+          [problem(
+            line: line_number,
+            column: 1,
+            message: 'found forbidden document start "---"',
+            fixable: true
+          )]
+        else
+          []
+        end
+      end
+
+      def fixable?
+        true
+      end
+    end
+
+    Registry.register(DocumentStart)
+  end
+end