rubocop-metz 0.5.3

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 38eb7e859b0bf45c9f80e8838678713d2aaedb5f18409eb802f53c0489fec544
+  data.tar.gz: 2972b51623d4c6027735b8a3cd9a1b85bb575a1778dd444f661e7f1bc7c37bf1
+SHA512:
+  metadata.gz: 68746f49ee4469e0f23e22eb8020ac3a6cdfbc5e117d6f524fcb6f1c88c95e6f6362bed07d6bf2e5f8896c4e3ea6f6b0ad8f02461366bd045b83348aadb54140
+  data.tar.gz: 7a242eacde2feca2b19fb116391f42923b59e64b0273432cfc7022eb33e94c5164cb8e1a3e0a122faca561c086d94aabc10cd3f2e12bd7848fa9e47252d2e302

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Salvador Fuentes Jr
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/config/default.yml

@@ -0,0 +1,76 @@
+# Default configuration for the rubocop-metz plugin.
+
+Metrics/ClassLength:
+  Enabled: false
+
+Metrics/MethodLength:
+  Enabled: false
+
+Metrics/ParameterLists:
+  Enabled: false
+
+Metz/ClassesTooLong:
+  Description: 'Flags classes longer than the configured Max line count; the Metz default is stricter than core RuboCop.'
+  Enabled: true
+  Severity: refactor
+  Max: 100
+  CountComments: false
+  CountAsOne: []
+
+Metz/MethodsTooLong:
+  Description: 'Flags methods longer than the configured Max line count; the Metz default is stricter than core RuboCop.'
+  Enabled: true
+  Severity: refactor
+  Max: 5
+  CountComments: false
+  CountAsOne: []
+  AllowedMethods: []
+  AllowedPatterns: []
+
+Metz/MethodsTooManyParameters:
+  Description: 'Flags methods whose parameter list exceeds Max; the Metz default is stricter than core RuboCop.'
+  Enabled: true
+  Severity: refactor
+  Max: 4
+
+Metz/DemeterTrainWreck:
+  Description: 'Detects Law-of-Demeter-violating object-graph traversal chains.'
+  Enabled: true
+  Severity: refactor
+  Max: 4
+  AllowedReceivers:
+    - Rails
+    - Arel
+    - Time
+    - Date
+    - DateTime
+  AllowedValueObjects:
+    - String
+    - Integer
+    - Float
+    - Symbol
+    - Array
+    - Hash
+    - Set
+  Exclude:
+    - 'spec/**/*'
+    - 'db/migrate/**/*'
+  VersionAdded: '0.1'
+
+Metz/ControllersTooManyDirectCollaborators:
+  Description: 'Flags Rails controller actions that reach into more than MaxCollaborators distinct collaborator constants.'
+  Enabled: true
+  Severity: refactor
+  MaxCollaborators: 1
+  Include:
+    - 'app/controllers/**/*.rb'
+  VersionAdded: '0.1'
+
+Metz/ViewsDeepNavigation:
+  Description: 'Flags Rails view templates whose ERB/HAML/SLIM expressions traverse the object graph deeper than MaxChainLength.'
+  Enabled: true
+  Severity: refactor
+  MaxChainLength: 3
+  Include:
+    - 'app/views/**/*.{erb,haml,slim}'
+  VersionAdded: '0.1'

data/lib/metz/cop_metadata.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module Metz
+  # Metadata DSL for Metz cops. Provides class-level setter/reader macros for
+  # `why_it_matters`, `fix_safety`, and `suggested_next_moves`. Works whether
+  # `include`d (instance-style sub-modules) or `extend`ed onto the class.
+  #
+  # Public contract for a cop class that never invokes any setter:
+  #   - why_it_matters         -> ""        (empty string)
+  #   - fix_safety             -> :manual   (the safest, no-autocorrect tier)
+  #   - suggested_next_moves   -> []        (empty, frozen array)
+  module CopMetadata
+    UNSET = Object.new.freeze
+    private_constant :UNSET
+
+    DEFAULT_WHY_IT_MATTERS = ""
+    DEFAULT_FIX_SAFETY = :manual
+    DEFAULT_SUGGESTED_NEXT_MOVES = [].freeze
+
+    def self.included(base)
+      base.extend(self)
+    end
+
+    def why_it_matters(value = UNSET)
+      return @metz_why_it_matters = value unless UNSET.equal?(value)
+
+      defined?(@metz_why_it_matters) ? @metz_why_it_matters : DEFAULT_WHY_IT_MATTERS
+    end
+
+    def fix_safety(value = UNSET)
+      return @metz_fix_safety = value unless UNSET.equal?(value)
+
+      defined?(@metz_fix_safety) ? @metz_fix_safety : DEFAULT_FIX_SAFETY
+    end
+
+    def suggested_next_moves(value = UNSET)
+      return @metz_suggested_next_moves = value unless UNSET.equal?(value)
+
+      defined?(@metz_suggested_next_moves) ? @metz_suggested_next_moves : DEFAULT_SUGGESTED_NEXT_MOVES
+    end
+
+    def metz_metadata
+      {
+        why_it_matters: why_it_matters,
+        fix_safety: fix_safety,
+        suggested_next_moves: suggested_next_moves
+      }
+    end
+  end
+end

data/lib/metz/erb_ruby_extractor.rb

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+require_relative "file_classifier"
+
+module Metz
+  # Ruby extractor for ERB / HAML / SLIM view templates. Registered with
+  # `RuboCop::Runner.ruby_extractors` so that view-aware Metz cops (currently
+  # `Metz/ViewsDeepNavigation`) can run against ERB content. RuboCop's parser
+  # would otherwise emit `Lint/Syntax` for any `.erb` file because the raw
+  # template is not a valid Ruby program.
+  #
+  # The extractor scans for ERB tags, hands each `<% ... %>` / `<%= ... %>`
+  # body to RuboCop as its own `ProcessedSource`, and records the byte offset
+  # of the body inside the original template. RuboCop adds that offset back
+  # to every offense location, so reported line / column numbers point at
+  # the original `.erb` file -- not the synthetic snippet.
+  #
+  # Control-flow openers such as `<% if ... %>` are reduced to the condition
+  # expression. Other invalid fragments are skipped to avoid `Lint/Syntax`
+  # noise. ERB comments (`<%# ... %>`) are skipped as well.
+  module ErbRubyExtractor
+    ERB_TAG = /<%(?<kind>[-=#]?)(?<body>.*?)-?%>/m
+    CONTROL_CONDITION = /\A(?<prefix>\s*(?:if|unless|while|until|elsif|case)\b\s*)(?<expr>.*?)(?:\s+then)?\s*\z/m
+    TRAILING_DO_BLOCK = /\A(?<expr>.*?)(?<suffix>\s+do\b(?:\s*\|[^|]*\|)?\s*)\z/m
+    MAGIC_COMMENT = "# frozen_string_literal: true\n\n"
+
+    module_function
+
+    def call(processed_source)
+      path = processed_source.path
+      return nil unless path && handles?(path)
+
+      snippets = extract_snippets(processed_source)
+      snippets << empty_snippet(processed_source) if snippets.empty?
+      snippets
+    end
+
+    def handles?(path)
+      File.extname(path.to_s) == ".erb" && ::Metz::FileClassifier.view?(path)
+    end
+
+    def install!
+      extractors = RuboCop::Runner.ruby_extractors
+      extractor = method(:call)
+      extractors.unshift(extractor) unless extractors.include?(extractor)
+    end
+
+    def extract_snippets(processed_source)
+      enumerate_matches(processed_source.raw_source).filter_map do |match|
+        snippet_for(match, processed_source)
+      end
+    end
+
+    def enumerate_matches(raw, pos: 0, matches: [])
+      while (match = raw.match(ERB_TAG, pos))
+        matches << match
+        pos = match.end(0)
+      end
+      matches
+    end
+
+    def snippet_for(match, processed_source)
+      return if match[:kind] == "#"
+
+      ruby_version = processed_source.ruby_version || RUBY_VERSION.to_f
+      ps, offset = source_and_offset(match, ruby_version, processed_source.path)
+      return unless ps
+
+      { offset: offset, processed_source: ps }
+    end
+
+    def source_and_offset(match, ruby_version, path)
+      body = match[:body]
+      ps = RuboCop::ProcessedSource.new(body, ruby_version, path)
+      return [ps, match.begin(:body)] if ps.valid_syntax?
+      return unless code_tag?(match[:kind])
+
+      expression_source(body, ruby_version, path, match.begin(:body))
+    end
+
+    def code_tag?(kind)
+      kind.empty? || kind == "-"
+    end
+
+    def expression_source(body, ruby_version, path, body_offset)
+      match = body.match(CONTROL_CONDITION) || body.match(TRAILING_DO_BLOCK)
+      return unless match
+
+      ps = RuboCop::ProcessedSource.new(control_expression(match[:expr]), ruby_version, path)
+      [ps, expression_offset(body_offset, match)] if ps.valid_syntax?
+    end
+
+    def control_expression(expr)
+      "#{MAGIC_COMMENT}#{expr}\n"
+    end
+
+    def expression_offset(body_offset, match)
+      body_offset + match.begin(:expr) - MAGIC_COMMENT.bytesize
+    end
+
+    def empty_snippet(processed_source)
+      ruby_version = processed_source.ruby_version || RUBY_VERSION.to_f
+      ps = RuboCop::ProcessedSource.new("", ruby_version, processed_source.path)
+      { offset: 0, processed_source: ps }
+    end
+  end
+end

data/lib/metz/file_classifier.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module Metz
+  # Path-based classifier for Rails-shaped source files. Used by the
+  # Rails-aware cops (`Metz/ControllersTooManyDirectCollaborators`,
+  # `Metz/ViewsDeepNavigation`) to decide whether a file is in scope for
+  # those cops. Predicates accept either a relative or an absolute path and
+  # always return a strict boolean.
+  #
+  # The matching rules are deliberately syntactic: a path is a controller
+  # iff some path segment chain ends in `app/controllers/<...>.rb`, a view
+  # iff `app/views/<...>.{erb,haml,slim}`, a model iff `app/models/<...>.rb`.
+  # We never touch the filesystem from here -- the inputs are already paths
+  # that RuboCop or a caller has handed us.
+  #
+  # Phase 3 reuse: future cross-file analyzers (project index, service-soup
+  # detector, repeated-branching detector) need the same path-shape question
+  # answered. Keep predicates pure, allocation-light, and dependency-free
+  # so they can be reused as-is from the wrapper or future analyzers.
+  module FileClassifier
+    CONTROLLER_PATTERN = %r{(?:\A|/)app/controllers/[^\0]+\.rb\z}
+    VIEW_PATTERN       = %r{(?:\A|/)app/views/[^\0]+\.(?:erb|haml|slim)\z}
+    MODEL_PATTERN      = %r{(?:\A|/)app/models/[^\0]+\.rb\z}
+
+    module_function
+
+    def controller?(path)
+      normalize(path).match?(CONTROLLER_PATTERN)
+    end
+
+    def view?(path)
+      normalize(path).match?(VIEW_PATTERN)
+    end
+
+    def model?(path)
+      normalize(path).match?(MODEL_PATTERN)
+    end
+
+    # Windows-style paths arrive with backslash separators when the caller is
+    # an editor running on Windows or a CI step that shells out via `cmd.exe`.
+    # Normalize to forward slashes so the regexes below stay POSIX-shaped.
+    def normalize(path)
+      path.to_s.tr("\\", "/")
+    end
+  end
+end

data/lib/metz/haml_ruby_extractor.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require_relative "template_ruby_extractor"
+
+module Metz
+  # Ruby extractor for HAML view templates. Mirrors `Metz::ErbRubyExtractor`:
+  # registered with `RuboCop::Runner.ruby_extractors` so view-aware Metz cops
+  # (currently `Metz/ViewsDeepNavigation`) can run against HAML content.
+  #
+  # Recognises three HAML constructs that carry Ruby:
+  #
+  #   * `= ruby_expr`      - output script (escaped)
+  #   * `- ruby_stmt`      - silent script
+  #   * `:ruby` filter     - indented block of plain Ruby
+  #
+  # Each tag's body is handed to RuboCop as its own `ProcessedSource` whose
+  # offset points at the body's column in the original template. Tags whose
+  # body is not valid Ruby on its own are silently skipped (we never want to
+  # surface `Lint/Syntax` from a partial HAML fragment).
+  module HamlRubyExtractor
+    extend TemplateRubyExtractor
+
+    EXPR_LINE   = /\A(?<lead>[ \t]*(?:[%.#][^\s=]*)?)=\s(?<body>.*)$/
+    STMT_LINE   = /\A(?<lead>[ \t]*)-(?!#)\s(?<body>.*)$/
+    FILTER_LINE = /\A(?<indent>[ \t]*):ruby[ \t]*$/
+
+    module_function
+
+    def handles?(path)
+      File.extname(path.to_s) == ".haml" && ::Metz::FileClassifier.view?(path)
+    end
+  end
+end

data/lib/metz/slim_ruby_extractor.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require_relative "template_ruby_extractor"
+
+module Metz
+  # Ruby extractor for Slim view templates. Mirrors `Metz::ErbRubyExtractor`:
+  # registered with `RuboCop::Runner.ruby_extractors` so view-aware Metz cops
+  # (currently `Metz/ViewsDeepNavigation`) can run against Slim content.
+  #
+  # Recognises four Slim constructs that carry Ruby:
+  #
+  #   * `= ruby_expr`   - output script (escaped)
+  #   * `== ruby_expr`  - output script (raw / unescaped)
+  #   * `- ruby_stmt`   - silent script
+  #   * `ruby:` filter  - indented block of plain Ruby
+  #
+  # Each tag's body is handed to RuboCop as its own `ProcessedSource` whose
+  # offset points at the body's column in the original template. Tags whose
+  # body is not valid Ruby on its own are silently skipped (we never want to
+  # surface `Lint/Syntax` from a partial Slim fragment).
+  module SlimRubyExtractor
+    extend TemplateRubyExtractor
+
+    EXPR_LINE   = /\A(?<lead>[ \t]*(?:[a-zA-Z][\w-]*|[.#][^\s=]*)?)==?\s(?<body>.*)$/
+    STMT_LINE   = /\A(?<lead>[ \t]*)-\s(?<body>.*)$/
+    FILTER_LINE = /\A(?<indent>[ \t]*)ruby:[ \t]*$/
+
+    module_function
+
+    def handles?(path)
+      File.extname(path.to_s) == ".slim" && ::Metz::FileClassifier.view?(path)
+    end
+  end
+end

data/lib/metz/template_ruby_extractor.rb

@@ -0,0 +1,153 @@
+# frozen_string_literal: true
+
+require_relative "file_classifier"
+
+module Metz
+  # Shared iteration backbone for line-based Ruby extractors that target
+  # indentation-driven template languages (HAML, Slim). Concrete extractors
+  # define three patterns -- an expression line, a statement line, and a
+  # filter-block start -- and this module walks the raw source line by
+  # line, hands every matching body to RuboCop as its own ProcessedSource,
+  # and tracks the byte offset of each body inside the original template
+  # so offense locations refer back to the source file rather than the
+  # synthetic snippet.
+  module TemplateRubyExtractor
+    def call(processed_source)
+      path = processed_source.path
+      return nil unless path && handles?(path)
+
+      snippets = Walker.new(self, processed_source).snippets
+      snippets << empty_snippet(processed_source) if snippets.empty?
+      snippets
+    end
+
+    def install!
+      extractors = RuboCop::Runner.ruby_extractors
+      entrypoint = method(:call)
+      extractors.unshift(entrypoint) unless extractors.include?(entrypoint)
+    end
+
+    def empty_snippet(processed_source)
+      ps = build_processed_source("", processed_source)
+      { offset: 0, processed_source: ps }
+    end
+
+    def build_snippet(body, body_offset, processed_source)
+      return nil if body.strip.empty?
+
+      ps = build_processed_source(body, processed_source)
+      return nil unless ps.valid_syntax?
+
+      { offset: body_offset, processed_source: ps }
+    end
+
+    def build_processed_source(body, processed_source)
+      ruby_version = processed_source.ruby_version || RUBY_VERSION.to_f
+      RuboCop::ProcessedSource.new(body, ruby_version, processed_source.path)
+    end
+
+    # Walks lines of a template, dispatching each line to the owner module's
+    # match patterns. Holds the running byte offset, the line index, and the
+    # accumulating snippet list so the owner module can stay stateless.
+    class Walker
+      def initialize(owner, processed_source)
+        @owner = owner
+        @processed_source = processed_source
+        @cursor = Cursor.new(processed_source.raw_source.lines)
+        walk
+      end
+
+      attr_reader :snippets
+
+      def walk
+        @snippets = []
+        @snippets << next_snippet until @cursor.done?
+        @snippets.compact!
+      end
+
+      def next_snippet
+        line = @cursor.line
+        filter = line.match(@owner::FILTER_LINE)
+        return consume_filter(filter) if filter
+
+        consume_inline(line.match(@owner::EXPR_LINE) || line.match(@owner::STMT_LINE))
+      end
+
+      def consume_inline(match)
+        snippet = inline_snippet(match)
+        @cursor.advance(1)
+        snippet
+      end
+
+      def inline_snippet(match)
+        return nil if match.nil?
+
+        body_offset = @cursor.offset + match.begin(:body)
+        @owner.build_snippet(match[:body], body_offset, @processed_source)
+      end
+
+      def consume_filter(match)
+        body_offset = @cursor.offset + @cursor.line.length
+        body_lines = collect_filter_body(match[:indent].length)
+        snippet = build_filter_snippet(body_lines, body_offset)
+        @cursor.advance(1 + body_lines.size)
+        snippet
+      end
+
+      def collect_filter_body(base_indent)
+        body = []
+        body << @cursor.peek(body.size + 1) while filter_member?(body.size + 1, base_indent)
+        body
+      end
+
+      def filter_member?(lookahead, base_indent)
+        line = @cursor.peek(lookahead)
+        return false if line.nil?
+
+        line.match?(/\A\s*\z/) || leading_indent(line) > base_indent
+      end
+
+      def leading_indent(line)
+        line[/\A[ \t]*/].length
+      end
+
+      def build_filter_snippet(body_lines, body_offset)
+        return nil if body_lines.empty?
+
+        @owner.build_snippet(body_lines.join, body_offset, @processed_source)
+      end
+    end
+
+    # Tracks the running byte offset and line index while walking a template.
+    class Cursor
+      def initialize(lines)
+        @lines = lines
+        @index = 0
+        @offset = 0
+      end
+
+      attr_reader :offset
+
+      def done?
+        @index >= @lines.size
+      end
+
+      def line
+        @lines[@index]
+      end
+
+      def peek(lookahead)
+        @lines[@index + lookahead]
+      end
+
+      def advance(count)
+        count.times do
+          break if done?
+
+          @offset += @lines[@index].length
+          @index += 1
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/metz/classes_too_long.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+require "rubocop"
+require_relative "../../../metz/cop_metadata"
+
+module RuboCop
+  module Cop
+    module Metz
+      # Flags classes whose body exceeds the configured `Max` line count.
+      # Wraps the semantics of core's `Metrics/ClassLength` with a stricter
+      # default of 100 lines.
+      class ClassesTooLong < RuboCop::Cop::Base
+        include RuboCop::Cop::CodeLength
+        extend ::Metz::CopMetadata
+
+        why_it_matters "Long classes accumulate responsibilities and become hard to change safely."
+        fix_safety :manual
+        suggested_next_moves [
+          "Extract collaborating objects that own a coherent slice of the behavior.",
+          "Move data-shaping helpers onto value objects.",
+          "Split persistence, presentation, and orchestration concerns into separate classes."
+        ]
+
+        MSG = "Class has too many lines. [%<length>d/%<max>d]"
+
+        def on_class(node)
+          check_code_length(node)
+        end
+
+        def on_sclass(node)
+          return if node.each_ancestor(:class).any?
+
+          on_class(node)
+        end
+
+        def on_casgn(node)
+          block_node = node.expression || find_expression_within_parent(node.parent)
+          return unless block_node.respond_to?(:class_definition?) && block_node.class_definition?
+
+          check_code_length(block_node)
+        end
+
+        private
+
+        def message(length, max_length)
+          format(MSG, length: length, max: max_length)
+        end
+
+        def find_expression_within_parent(parent)
+          if parent&.assignment?
+            parent.expression
+          elsif parent&.parent&.masgn_type?
+            parent.parent.expression
+          end
+        end
+      end
+    end
+  end
+end