openvox-lint 1.0.0

data/lib/openvox-lint/cli.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+require 'optparse'
+
+module OpenvoxLint
+  # Command-line interface for openvox-lint.
+  class CLI
+    def initialize(args = ARGV)
+      @args   = args
+      @config = OpenvoxLint.configuration
+    end
+
+    def run
+      parse_options
+      load_rc_file
+      if @list_checks
+        list_checks; return 0
+      end
+      files = @args.empty? ? ['.'] : @args
+      linter = Linter.new(configuration: @config)
+      linter.run(*files)
+      Report.new(@config).format(linter.problems)
+      print_summary(linter) unless @config.log_format == 'json'
+      linter.exit_code
+    end
+
+    private
+
+    def parse_options # rubocop:disable Metrics/MethodLength
+      @parser = OptionParser.new do |opts|
+        opts.banner = "Usage: openvox-lint [options] [file|directory ...]"
+        opts.separator ''; opts.separator 'Options:'
+        opts.on('--version', 'Display version') { puts "openvox-lint #{VERSION}"; exit 0 }
+        opts.on('-f', '--format FORMAT', 'Output format: text json csv github codeclimate') { |f| @config.log_format = f }
+        opts.on('--log-format FORMAT', 'Custom log format string') { |f| @config.custom_log_format = f; @config.log_format = 'custom' }
+        opts.on('--fix', 'Automatically fix problems') { @config.fix = true }
+        opts.on('--fail-on-warnings', 'Exit 1 on warnings') { @config.fail_on_warnings = true }
+        opts.on('--no-filename', 'Suppress filename') { @config.with_filename = false }
+        opts.on('--no-column', 'Suppress column') { @config.column = false }
+        opts.on('--relative', 'Relative paths') { @config.relative = true }
+        opts.on('--only-checks CHECKS', 'Comma-separated checks') { |c| @config.only_checks = c.split(',').map { |s| s.strip.to_sym } }
+        opts.on('--ignore-paths PATHS', 'Comma-separated globs') { |p| @config.ignore_paths = p.split(',').map(&:strip) }
+        opts.on('--list-checks', 'List available checks') { @list_checks = true }
+        opts.on('-c', '--config FILE', 'Config file path') { |f| @config.config_file = f }
+      end
+      remaining = []
+      begin
+        @parser.order!(@args) { |a| remaining << a }
+      rescue OptionParser::InvalidOption => e
+        flag = e.args.first
+        if flag =~ /\A--no-(.+)-check\z/
+          @config.disabled_checks << Regexp.last_match(1).tr('-', '_').to_sym
+        else
+          $stderr.puts e.message; exit 1
+        end
+        retry
+      end
+      @args.replace(remaining)
+    end
+
+    def load_rc_file
+      ['.openvox-lint.rc', @config.config_file, File.expand_path('~/.openvox-lint.rc')].each do |path|
+        next unless path && File.exist?(path)
+        @config.load_from_rc(path); break
+      end
+    end
+
+    def list_checks
+      puts "Available checks (#{OpenvoxLint.checks.size} total):"; puts ''
+      OpenvoxLint.checks.keys.sort.each do |name|
+        puts "  #{@config.check_enabled?(name) ? '✓' : '✗'}  #{name}"
+      end
+    end
+
+    def print_summary(linter)
+      w = linter.problems.count { |p| p[:kind] == :warning }
+      e = linter.problems.count { |p| p[:kind] == :error }
+      t = linter.problems.size; f = linter.file_count
+      $stderr.puts ''
+      if t == 0
+        $stderr.puts "✓ #{f} file(s) checked — no problems found."
+      else
+        $stderr.puts "#{f} file(s) checked — #{t} problem(s) found (#{e} error(s), #{w} warning(s))."
+      end
+    end
+  end
+end

data/lib/openvox-lint/configuration.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module OpenvoxLint
+  # Holds all runtime configuration.
+  class Configuration
+    DEFAULTS = {
+      log_format: 'text', with_filename: true, fail_on_warnings: false,
+      fix: false, only_checks: [], disabled_checks: [],
+      ignore_paths: %w[vendor/**/*.pp pkg/**/*.pp spec/**/*.pp],
+      config_file: '.openvox-lint.rc', relative: false, column: true,
+      custom_log_format: nil,
+    }.freeze
+
+    attr_accessor :log_format, :with_filename, :fail_on_warnings,
+                  :fix, :only_checks, :disabled_checks, :ignore_paths,
+                  :config_file, :relative, :column, :custom_log_format
+
+    def initialize
+      DEFAULTS.each do |k, v|
+        send(:"#{k}=", v.is_a?(Array) ? v.dup : v)
+      end
+    end
+
+    def load_from_rc(path)
+      return unless File.exist?(path)
+      File.readlines(path).each do |line|
+        line = line.strip
+        next if line.empty? || line.start_with?('#')
+        flag, value = line.split(/\s+/, 2)
+        apply_flag(flag, value)
+      end
+    end
+
+    def check_enabled?(name)
+      name = name.to_sym
+      return false if disabled_checks.include?(name)
+      return only_checks.include?(name) unless only_checks.empty?
+      true
+    end
+
+    private
+
+    def apply_flag(flag, value)
+      case flag
+      when '--fix'              then self.fix = true
+      when '--no-fix'           then self.fix = false
+      when '--fail-on-warnings' then self.fail_on_warnings = true
+      when /\A--no-(.+)-check\z/
+        disabled_checks << Regexp.last_match(1).tr('-', '_').to_sym
+      when '--only-checks'
+        self.only_checks = (value || '').split(',').map { |c| c.strip.to_sym }
+      when '--log-format'
+        self.log_format = value&.strip || 'text'
+      when '--ignore-paths'
+        self.ignore_paths = (value || '').split(',').map(&:strip)
+      end
+    end
+  end
+end

data/lib/openvox-lint/lexer.rb

@@ -0,0 +1,342 @@
+# frozen_string_literal: true
+
+module OpenvoxLint
+  # Tokenises a Puppet / OpenVox manifest string into an Array of Token
+  # objects.  The lexer recognises all Puppet 8 / OpenVox 8.x language
+  # constructs including heredocs, EPP tags, Deferred/Sensitive types,
+  # type aliases, and the full operator set.
+  class Lexer
+    KEYWORDS = {
+      'and' => :AND, 'application' => :APPLICATION, 'attr' => :ATTR,
+      'case' => :CASE, 'class' => :CLASS, 'consumes' => :CONSUMES,
+      'default' => :DEFAULT, 'define' => :DEFINE, 'else' => :ELSE,
+      'elsif' => :ELSIF, 'false' => :FALSE, 'function' => :FUNCTION,
+      'if' => :IF, 'import' => :IMPORT, 'in' => :IN,
+      'inherits' => :INHERITS, 'node' => :NODE, 'not' => :NOT,
+      'or' => :OR, 'private' => :PRIVATE, 'produces' => :PRODUCES,
+      'site' => :SITE, 'true' => :TRUE, 'type' => :TYPE,
+      'undef' => :UNDEF, 'unless' => :UNLESS,
+    }.freeze
+
+    OPERATORS = [
+      ['<<|', :LLCOLLECT], ['|>>', :RRCOLLECT],
+      ['<=', :LESSEQUAL], ['>=', :GREATEREQUAL],
+      ['==', :ISEQUAL], ['!=', :NOTEQUAL],
+      ['=~', :MATCH], ['!~', :NOMATCH],
+      ['=>', :FARROW], ['+=', :APPENDS],
+      ['+>', :PARROW], ['->', :IN_EDGE],
+      ['<-', :OUT_EDGE], ['~>', :IN_EDGE_SUB],
+      ['<~', :OUT_EDGE_SUB], ['<<', :LSHIFT],
+      ['>>', :RSHIFT], ['<|', :LCOLLECT],
+      ['|>', :RCOLLECT],
+    ].freeze
+
+    SINGLE_CHAR = {
+      '{' => :LBRACE, '}' => :RBRACE, '(' => :LPAREN, ')' => :RPAREN,
+      '[' => :LBRACK, ']' => :RBRACK, ';' => :SEMIC, ',' => :COMMA,
+      '.' => :DOT, '@' => :AT, '|' => :PIPE, '+' => :PLUS,
+      '-' => :MINUS, '*' => :TIMES, '%' => :MODULO, '!' => :NOT,
+      '?' => :QMARK, '\\' => :BACKSLASH, ':' => :COLON,
+      '=' => :EQUALS, '>' => :GREATERTHAN, '<' => :LESSTHAN,
+    }.freeze
+
+    REGEX_PREV = %i[
+      NODE LBRACE LBRACK LPAREN COMMA EQUALS ISEQUAL NOTEQUAL
+      MATCH NOMATCH AND OR NOT IF ELSIF CASE RETURN IN
+    ].freeze
+
+    attr_reader :tokens, :manifest_lines
+
+    def initialize(code)
+      @code = code
+      @manifest_lines = code.lines.map(&:chomp)
+      @tokens = []
+      @line   = 1
+      @column = 1
+      @pos    = 0
+      tokenise
+      link_tokens
+    end
+
+    private
+
+    def tokenise # rubocop:disable Metrics/CyclomaticComplexity,Metrics/MethodLength
+      until @pos >= @code.length
+        case @code[@pos]
+        when "\n"
+          emit(:NEWLINE, "\n"); @line += 1; @column = 1
+        when "\r"
+          if @code[@pos + 1] == "\n"
+            emit(:NEWLINE, "\r\n", 2); @line += 1; @column = 1
+          else
+            emit(:NEWLINE, "\r"); @line += 1; @column = 1
+          end
+        when ' ', "\t" then scan_whitespace
+        when '#'       then scan_comment
+        when '/'       then scan_slash
+        when "'"       then scan_single_quoted_string
+        when '"'       then scan_double_quoted_string
+        when '$'       then scan_variable
+        when '@'
+          if @code[@pos + 1] == '(' || @code[@pos + 1] == '"'
+            scan_heredoc
+          else
+            emit(:AT, '@')
+          end
+        else
+          scan_other
+        end
+      end
+    end
+
+    def scan_whitespace
+      start = @pos; start_col = @column
+      @pos += 1; @column += 1
+      while @pos < @code.length && (@code[@pos] == ' ' || @code[@pos] == "\t")
+        @pos += 1; @column += 1
+      end
+      tok = prev_non_ws_type == :NEWLINE || @tokens.empty? ? :INDENT : :WHITESPACE
+      add_token(tok, @code[start...@pos], @line, start_col)
+    end
+
+    def scan_comment
+      start = @pos; start_col = @column
+      @pos += 1; @column += 1
+      while @pos < @code.length && @code[@pos] != "\n"
+        @pos += 1; @column += 1
+      end
+      add_token(:COMMENT, @code[start...@pos], @line, start_col)
+    end
+
+    def scan_slash
+      if @code[@pos + 1] == '*'    then scan_ml_comment
+      elsif @code[@pos + 1] == '/' then scan_slash_comment
+      elsif regex_possible?        then scan_regex
+      else emit(:DIV, '/')
+      end
+    end
+
+    def scan_ml_comment
+      start = @pos; start_line = @line; start_col = @column
+      @pos += 2; @column += 2
+      until @pos >= @code.length
+        if @code[@pos] == '*' && @code[@pos + 1] == '/'
+          @pos += 2; @column += 2; break
+        end
+        if @code[@pos] == "\n" then @line += 1; @column = 1
+        else @column += 1; end
+        @pos += 1
+      end
+      add_token(:MLCOMMENT, @code[start...@pos], start_line, start_col)
+    end
+
+    def scan_slash_comment
+      start = @pos; start_col = @column
+      @pos += 2; @column += 2
+      while @pos < @code.length && @code[@pos] != "\n"
+        @pos += 1; @column += 1
+      end
+      add_token(:SLASH_COMMENT, @code[start...@pos], @line, start_col)
+    end
+
+    def scan_regex
+      start = @pos; start_col = @column
+      @pos += 1; @column += 1
+      while @pos < @code.length && @code[@pos] != '/'
+        if @code[@pos] == '\\'
+          @pos += 2; @column += 2
+        else
+          @pos += 1; @column += 1
+        end
+      end
+      @pos += 1; @column += 1
+      add_token(:REGEX, @code[start...@pos], @line, start_col)
+    end
+
+    def scan_single_quoted_string
+      start = @pos; start_col = @column
+      @pos += 1; @column += 1
+      while @pos < @code.length
+        if @code[@pos] == '\\'
+          @pos += 2; @column += 2
+        elsif @code[@pos] == "'"
+          @pos += 1; @column += 1; break
+        elsif @code[@pos] == "\n"
+          @line += 1; @column = 1; @pos += 1
+        else
+          @pos += 1; @column += 1
+        end
+      end
+      add_token(:SSTRING, @code[start...@pos], @line, start_col)
+    end
+
+    def scan_double_quoted_string
+      start = @pos; start_col = @column
+      @pos += 1; @column += 1
+      has_interp = false
+      while @pos < @code.length
+        if @code[@pos] == '\\'
+          @pos += 2; @column += 2
+        elsif @code[@pos] == '$' && @code[@pos + 1] =~ /[a-zA-Z_{:]/
+          has_interp = true
+          @pos += 1; @column += 1
+          while @pos < @code.length && @code[@pos] =~ /[a-zA-Z0-9_:{}]/
+            @pos += 1; @column += 1
+          end
+        elsif @code[@pos] == '"'
+          @pos += 1; @column += 1; break
+        elsif @code[@pos] == "\n"
+          @line += 1; @column = 1; @pos += 1
+        else
+          @pos += 1; @column += 1
+        end
+      end
+      type = has_interp ? :DQSTRING : :STRING
+      add_token(type, @code[start...@pos], @line, start_col)
+    end
+
+    def scan_variable
+      start = @pos; start_col = @column
+      @pos += 1; @column += 1
+      while @pos < @code.length && @code[@pos] =~ /[a-zA-Z0-9_:]/
+        @pos += 1; @column += 1
+      end
+      add_token(:VARIABLE, @code[start...@pos], @line, start_col)
+    end
+
+    def scan_heredoc
+      start_col = @column
+      tag_match = @code[@pos..].match(/\A@\(("?)(\w+)\1\s*([\/\-|:tsnLru]*)\)/)
+      unless tag_match
+        emit(:AT, '@'); return
+      end
+      tag = tag_match[2]; tag_len = tag_match[0].length
+      add_token(:HEREDOC_OPEN, @code[@pos, tag_len], @line, start_col)
+      @pos += tag_len; @column += tag_len
+      # Skip rest of current line
+      while @pos < @code.length && @code[@pos] != "\n"
+        @pos += 1; @column += 1
+      end
+      @pos += 1; @line += 1; @column = 1
+      # Read heredoc body
+      heredoc_content = +''
+      until @pos >= @code.length
+        line_start = @pos
+        while @pos < @code.length && @code[@pos] != "\n"
+          @pos += 1; @column += 1
+        end
+        current_line = @code[line_start...@pos]
+        if current_line.strip =~ /\A[-|]?\s*#{Regexp.escape(tag)}\s*\z/
+          @pos += 1 if @pos < @code.length; @line += 1; @column = 1; break
+        end
+        heredoc_content << current_line << "\n"
+        @pos += 1; @line += 1; @column = 1
+      end
+      add_token(:HEREDOC, heredoc_content, @line, start_col)
+    end
+
+    def scan_other # rubocop:disable Metrics/CyclomaticComplexity,Metrics/MethodLength
+      OPERATORS.each do |op, type|
+        if @code[@pos, op.length] == op
+          emit(type, op, op.length); return
+        end
+      end
+      ch = @code[@pos]
+      if SINGLE_CHAR.key?(ch)
+        emit(SINGLE_CHAR[ch], ch); return
+      end
+      if ch =~ /[0-9]/
+        scan_number; return
+      end
+      if ch =~ /[a-zA-Z_]/ || (ch == ':' && @code[@pos + 1] == ':')
+        scan_name; return
+      end
+      emit(:OTHER, ch)
+    end
+
+    def scan_number
+      start = @pos; start_col = @column
+      if @code[@pos] == '0' && @code[@pos + 1] =~ /[xX]/
+        @pos += 2; @column += 2
+        while @pos < @code.length && @code[@pos] =~ /[0-9a-fA-F_]/
+          @pos += 1; @column += 1
+        end
+      elsif @code[@pos] == '0' && @code[@pos + 1] =~ /[0-7]/
+        @pos += 1; @column += 1
+        while @pos < @code.length && @code[@pos] =~ /[0-7_]/
+          @pos += 1; @column += 1
+        end
+      else
+        while @pos < @code.length && @code[@pos] =~ /[0-9_]/
+          @pos += 1; @column += 1
+        end
+        if @pos < @code.length && @code[@pos] == '.' && @code[@pos + 1] =~ /[0-9]/
+          @pos += 1; @column += 1
+          while @pos < @code.length && @code[@pos] =~ /[0-9_]/
+            @pos += 1; @column += 1
+          end
+        end
+        if @pos < @code.length && @code[@pos] =~ /[eE]/
+          @pos += 1; @column += 1
+          if @pos < @code.length && @code[@pos] =~ /[+\-]/
+            @pos += 1; @column += 1
+          end
+          while @pos < @code.length && @code[@pos] =~ /[0-9]/
+            @pos += 1; @column += 1
+          end
+        end
+      end
+      add_token(:NUMBER, @code[start...@pos], @line, start_col)
+    end
+
+    def scan_name
+      start = @pos; start_col = @column
+      if @code[@pos] == ':' && @code[@pos + 1] == ':'
+        @pos += 2; @column += 2
+      end
+      while @pos < @code.length && @code[@pos] =~ /[a-zA-Z0-9_]/
+        @pos += 1; @column += 1
+        if @pos + 1 < @code.length && @code[@pos] == ':' && @code[@pos + 1] == ':'
+          @pos += 2; @column += 2
+        end
+      end
+      word = @code[start...@pos]
+      if KEYWORDS.key?(word)
+        add_token(KEYWORDS[word], word, @line, start_col)
+      elsif word =~ /\A[A-Z]/
+        add_token(:CLASSREF, word, @line, start_col)
+      else
+        add_token(:NAME, word, @line, start_col)
+      end
+    end
+
+    def emit(type, value, length = nil)
+      length ||= value.length
+      add_token(type, value, @line, @column)
+      @pos += length; @column += length
+    end
+
+    def add_token(type, value, line, column)
+      @tokens << Token.new(type, value, line, column)
+    end
+
+    def link_tokens
+      @tokens.each_with_index do |tok, i|
+        tok.prev_token = i > 0 ? @tokens[i - 1] : nil
+        tok.next_token = @tokens[i + 1]
+      end
+    end
+
+    def prev_non_ws_type
+      @tokens.reverse_each do |t|
+        return t.type unless t.type == :WHITESPACE || t.type == :INDENT
+      end
+      nil
+    end
+
+    def regex_possible?
+      return true if @tokens.empty?
+      REGEX_PREV.include?(prev_non_ws_type)
+    end
+  end
+end

data/lib/openvox-lint/linter.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+module OpenvoxLint
+  # Orchestrates the linting of one or more manifest files.
+  class Linter
+    attr_reader :problems, :file_count
+
+    def initialize(configuration: OpenvoxLint.configuration)
+      @config     = configuration
+      @problems   = []
+      @file_count = 0
+    end
+
+    def run(*fileargs)
+      files = expand_files(fileargs.flatten)
+      files.each { |f| lint_file(f) }
+      @problems.sort_by! { |p| [p[:path] || '', p[:line] || 0, p[:column] || 0] }
+    end
+
+    def errors?
+      @problems.any? { |p| p[:kind] == :error }
+    end
+
+    def warnings?
+      @problems.any? { |p| p[:kind] == :warning }
+    end
+
+    def exit_code
+      return 1 if errors?
+      return 1 if warnings? && @config.fail_on_warnings
+      0
+    end
+
+    private
+
+    def lint_file(filepath)
+      @file_count += 1
+      code = File.read(filepath)
+      lexer = Lexer.new(code)
+      checker = Checks.new(
+        tokens: lexer.tokens, manifest_lines: lexer.manifest_lines,
+        fullpath: filepath, configuration: @config,
+      )
+      @problems.concat(checker.run)
+    rescue StandardError => e
+      @problems << {
+        path: filepath, line: 0, column: 0, kind: :error,
+        check: :syntax, message: "Could not parse file: #{e.message}",
+      }
+    end
+
+    def expand_files(fileargs)
+      files = []
+      fileargs.each do |arg|
+        if File.directory?(arg)
+          files.concat(Dir.glob(File.join(arg, '**', '*.pp')))
+        elsif arg.include?('*')
+          files.concat(Dir.glob(arg))
+        elsif File.file?(arg)
+          files << arg
+        end
+      end
+      files.reject { |f| ignored?(f) }.uniq
+    end
+
+    def ignored?(filepath)
+      @config.ignore_paths.any? do |pat|
+        File.fnmatch?(pat, filepath, File::FNM_PATHNAME | File::FNM_DOTMATCH)
+      end
+    end
+  end
+end

data/lib/openvox-lint/plugins/checks/arrow_alignment.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+# Hash rockets (=>) should be aligned within a resource body.
+OpenvoxLint.new_check(:arrow_alignment) do
+  def check
+    # Group FARROW tokens by resource (consecutive lines)
+    arrows = tokens.select { |t| t.type == :FARROW }
+    return if arrows.empty?
+
+    # Group arrows by their enclosing brace block
+    groups = group_arrows(arrows)
+    groups.each do |group|
+      next if group.size <= 1
+      columns = group.map(&:column)
+      max_col = columns.max
+      group.each do |arrow|
+        next if arrow.column == max_col
+        notify :warning,
+          message: "arrow (=>) on line #{arrow.line} not aligned (column #{arrow.column} vs #{max_col})",
+          line: arrow.line,
+          column: arrow.column
+      end
+    end
+  end
+
+  private
+
+  def group_arrows(arrows)
+    groups = []
+    current = [arrows.first]
+    arrows[1..].each do |arrow|
+      if arrow.line - current.last.line <= 2
+        current << arrow
+      else
+        groups << current
+        current = [arrow]
+      end
+    end
+    groups << current unless current.empty?
+    groups
+  end
+end

data/lib/openvox-lint/plugins/checks/autoloader_layout.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+# Class/define names should match the autoloader file path.
+# e.g. class foo::bar::baz should be in foo/manifests/bar/baz.pp
+OpenvoxLint.new_check(:autoloader_layout) do
+  def check
+    sem = semantic_tokens
+    sem.each_with_index do |tok, i|
+      next unless tok.type == :CLASS || tok.type == :DEFINE
+      j = i + 1
+      next if j >= sem.length
+      name_tok = sem[j]
+      next unless name_tok.type == :NAME || name_tok.type == :CLASSREF
+      name = name_tok.value
+      parts = name.split('::')
+      next if parts.empty?
+      expected_path = if parts.length == 1
+                        "#{parts[0]}/manifests/init.pp"
+                      else
+                        "#{parts[0]}/manifests/#{parts[1..].join('/')}.pp"
+                      end
+      next if fullpath.end_with?(expected_path)
+      # Also check with just the filename portion
+      expected_file = parts.length == 1 ? 'init.pp' : "#{parts.last}.pp"
+      next if filename == expected_file
+      notify :warning,
+        message: "#{tok.value} '#{name}' not in expected autoloader path '#{expected_path}'",
+        line: name_tok.line, column: name_tok.column
+    end
+  end
+end

data/lib/openvox-lint/plugins/checks/case_without_default.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+# Case statements should have a default case.
+OpenvoxLint.new_check(:case_without_default) do
+  def check
+    sem = semantic_tokens
+    sem.each_with_index do |tok, i|
+      next unless tok.type == :CASE
+      # Find the matching brace block
+      j = i + 1
+      j += 1 while j < sem.length && sem[j].type != :LBRACE
+      next if j >= sem.length
+      depth = 1; k = j + 1; has_default = false
+      while k < sem.length && depth > 0
+        case sem[k].type
+        when :LBRACE  then depth += 1
+        when :RBRACE  then depth -= 1
+        when :DEFAULT then has_default = true if depth == 1
+        end
+        k += 1
+      end
+      next if has_default
+      notify :warning,
+        message: 'case statement without a default case',
+        line: tok.line, column: tok.column
+    end
+  end
+end

data/lib/openvox-lint/plugins/checks/class_inherits_params.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+# Class inheritance is discouraged. Prefer composition (include/contain/require).
+OpenvoxLint.new_check(:class_inherits_params) do
+  def check
+    tokens.each do |tok|
+      next unless tok.type == :INHERITS
+      notify :warning,
+        message: 'class inheritance is discouraged; use composition (include, contain, require) instead',
+        line: tok.line, column: tok.column
+    end
+  end
+end