rubocop-nathank 1.0.0

data/lib/rubocop/nathank/no_modifier_if.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+# Released under the Apache License, Version 2.0.
+# Copyright, 2026, by General Intelligence Systems.
+
+# Bans the modifier `if` / `unless` form.
+#
+# @example
+#   return true if task.state_task_completed?     # NO
+#
+# @example
+#   if task.state_task_completed?                 # YES
+#     return true
+#   end
+
+require_relative "support/prism_source"
+
+module RuboCop
+  module Nathank
+    class NoModifierIf < ::RuboCop::Cop::Base
+      include PrismSource
+      extend ::RuboCop::Cop::AutoCorrector
+
+      MSG = "Do not use modifier `%<keyword>s`; use the full `%<keyword>s ... end` block form."
+
+      def on_new_investigation
+        self.prism_each(::Prism::IfNode, ::Prism::UnlessNode).each do |node|
+          if self.modifier_form?(node)
+            range = self.prism_node_range(node)
+
+            add_offense(range, message: format(MSG, keyword: self.keyword(node))) do |corrector|
+              if self.safe_to_unwrap?(node)
+                corrector.replace(range, self.block_form(node))
+              end
+            end
+          end
+        end
+      end
+
+      private
+
+      # A modifier has its keyword written after what it guards, and so has no `end` to close.
+      # A ternary has no keyword at all, and is not this cop's business.
+      def modifier_form?(node)
+        if node.is_a?(::Prism::UnlessNode)
+          keyword = node.keyword_loc
+        else
+          keyword = node.if_keyword_loc
+        end
+
+        !keyword.nil? && node.end_keyword_loc.nil?
+      end
+
+      def keyword(node)
+        if node.is_a?(::Prism::UnlessNode)
+          "unless"
+        else
+          "if"
+        end
+      end
+
+      # Two shapes are left for a human.
+      def safe_to_unwrap?(node)
+        self.own_line?(node) && !self.prism_heredoc?(node)
+      end
+
+      def own_line?(node)
+        line = processed_source.lines[node.location.start_line - 1].to_s
+
+        line[0...self.prism_column(node)].strip.empty?
+      end
+
+      def block_form(node)
+        indent = " " * self.prism_column(node)
+        body = node.statements
+
+        "#{self.keyword(node)} #{self.prism_source(node.predicate)}\n" \
+          "#{self.reindent(body, indent)}\n" \
+          "#{indent}end"
+      end
+
+      # Move the body to a new indent.
+      def reindent(node, indent)
+        target = indent.length + 2
+        delta = target - self.prism_column(node)
+        lines = self.prism_source(node).lines
+
+        rest = lines[1..].to_a.map{|line|
+          if delta.negative?
+            line.chomp.sub(/\A {0,#{-delta}}/, "")
+          else
+            "#{" " * delta}#{line.chomp}"
+          end
+        }
+
+        [("#{" " * target}#{lines.first.chomp}")].concat(rest).join("\n")
+      end
+    end
+  end
+end

data/lib/rubocop/nathank/no_return.rb

@@ -0,0 +1,208 @@
+# frozen_string_literal: true
+
+# Released under the Apache License, Version 2.0.
+# Copyright, 2026, by General Intelligence Systems.
+
+# Bans the `return` keyword.
+#
+# @example
+#   if cond          →    if cond
+#     return X              X
+#   end                   else
+#   rest                    rest
+#                         end
+
+require_relative "support/prism_source"
+
+module RuboCop
+  module Nathank
+    class NoReturn < ::RuboCop::Cop::Base
+      include PrismSource
+      extend ::RuboCop::Cop::AutoCorrector
+
+      MSG = "Do not use `return`; let the method's last expression be the return value."
+
+      def on_new_investigation
+        # One guard per body per pass — two corrections inside the same body would overlap and clobber each other. `rubocop -a` re-runs the cop until it stops changing anything, so chained guards still unwind, one per pass.
+        @corrected_bodies = {}
+
+        self.prism_each(::Prism::ReturnNode).each do |node|
+          self.report(node)
+        end
+      end
+
+      private
+
+      def report(node)
+        add_offense(self.prism_node_range(node)) do |corrector|
+          guard = self.correctable_guard(node)
+
+          if guard
+            body, index = guard
+
+            if @corrected_bodies[body.object_id].nil?
+              @corrected_bodies[body.object_id] = true
+              corrector.replace(self.replaced_range(body, index), self.rewritten(body, index))
+            end
+          end
+        end
+      end
+
+      # The guard's body and index, when the node is one.
+      #
+      # Prism writes a `StatementsNode` between a conditional and its body, so the guard is the `return`'s grandparent.
+      def correctable_guard(node)
+        statements = self.prism_parent(node)
+
+        if !statements.is_a?(::Prism::StatementsNode)
+          nil
+        else
+          if_node = self.prism_parent(statements)
+
+          if self.unguarded?(if_node, statements, node)
+            nil
+          else
+            body = self.prism_parent(if_node)
+
+            if !body.is_a?(::Prism::StatementsNode) || !self.tail_position?(body)
+              nil
+            else
+              index = body.body.index(if_node)
+
+              if index.nil? || index == body.body.size - 1
+                nil
+              else
+                [body, index]
+              end
+            end
+          end
+        end
+      end
+
+      # Every shape which is not a plain `if cond / return X / end` guard.
+      def unguarded?(if_node, statements, node)
+        !self.conditional?(if_node) ||
+          self.modifier_form?(if_node) ||
+          self.ternary?(if_node) ||
+          self.elsif?(if_node) ||
+          !if_node.statements.equal?(statements) ||
+          statements.body != [node] ||
+          !self.else_branch(if_node).nil?
+      end
+
+      def conditional?(node)
+        node.is_a?(::Prism::IfNode) || node.is_a?(::Prism::UnlessNode)
+      end
+
+      # A modifier has its keyword written after what it guards, and so has no `end` to close.
+      def modifier_form?(node)
+        !self.keyword_location(node).nil? && node.end_keyword_loc.nil?
+      end
+
+      # A ternary has no keyword at all.
+      def ternary?(node)
+        self.keyword_location(node).nil?
+      end
+
+      # An `elsif` is a conditional whose keyword says so.
+      def elsif?(node)
+        location = self.keyword_location(node)
+
+        !location.nil? && self.prism_range(location).source == "elsif"
+      end
+
+      def keyword_location(node)
+        if node.is_a?(::Prism::UnlessNode)
+          node.keyword_loc
+        else
+          node.if_keyword_loc
+        end
+      end
+
+      # What follows the then-branch: an `else`, or a chained `elsif`.
+      def else_branch(node)
+        if node.is_a?(::Prism::UnlessNode)
+          node.else_clause
+        else
+          node.subsequent
+        end
+      end
+
+      def keyword(node)
+        if node.is_a?(::Prism::UnlessNode)
+          "unless"
+        else
+          "if"
+        end
+      end
+
+      # Whether this node is the last thing its enclosing method evaluates.
+      def tail_position?(node)
+        parent = self.prism_parent(node)
+
+        if parent.nil?
+          false
+        elsif parent.is_a?(::Prism::DefNode)
+          parent.body.equal?(node)
+        elsif parent.is_a?(::Prism::StatementsNode)
+          parent.body.last.equal?(node) && self.tail_position?(parent)
+        elsif parent.is_a?(::Prism::ElseNode)
+          parent.statements.equal?(node) && self.tail_position?(parent)
+        elsif self.conditional?(parent) && !self.ternary?(parent)
+          parent.statements.equal?(node) && self.tail_position?(parent)
+        else
+          false
+        end
+      end
+
+      def replaced_range(body, index)
+        self.prism_span(body.body[index].location, body.body.last.location)
+      end
+
+      def rewritten(body, index)
+        if_node = body.body[index]
+        indent = " " * self.prism_column(if_node)
+        guarded = self.returned_value(if_node)
+        rest = body.body[(index + 1)..]
+
+        if guarded
+          guard_value = self.reindent(guarded, indent)
+        else
+          guard_value = "#{indent}  nil"
+        end
+        rest_source = rest.map{|statement| self.reindent(statement, indent)}.join("\n")
+
+        # `unless cond / return X / end` means "X unless cond", so the branches swap rather than the condition being negated.
+        if self.keyword(if_node) == "unless"
+          first, second = rest_source, guard_value
+        else
+          first, second = guard_value, rest_source
+        end
+
+        "if #{self.prism_source(if_node.predicate)}\n#{first}\n#{indent}else\n#{second}\n#{indent}end"
+      end
+
+      # The value the guard returns, or nil for a bare `return`.
+      def returned_value(if_node)
+        if_node.statements.body.first.arguments&.arguments&.first
+      end
+
+      # Move a statement to a new indent.
+      def reindent(node, indent)
+        target = indent.length + 2
+        delta = target - self.prism_column(node)
+        lines = self.prism_source(node).lines
+
+        rest = lines[1..].to_a.map{|line|
+          if delta.negative?
+            line.chomp.sub(/\A {0,#{-delta}}/, "")
+          else
+            "#{" " * delta}#{line.chomp}"
+          end
+        }
+
+        [("#{" " * target}#{lines.first.chomp}")].concat(rest).join("\n")
+      end
+    end
+  end
+end

data/lib/rubocop/nathank/plugin.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+# Released under the MIT License.
+# Copyright, 2026, by Nathan Kidd.
+
+require "lint_roller"
+require_relative "version"
+
+module RuboCop
+  module Nathank
+    # Represents a LintRoller plugin that provides RuboCop rules for Nathank projects.
+    # This plugin integrates custom RuboCop cops and configuration into the LintRoller system.
+    class Plugin < LintRoller::Plugin
+      # Initialize the plugin with version information.
+      def initialize(...)
+        super
+        @version = RuboCop::Nathank::VERSION
+      end
+
+      # Get information about this plugin for the LintRoller system.
+      # @returns [LintRoller::About] Plugin metadata including name, version, and description.
+      def about
+        LintRoller::About.new(
+          name: "rubocop-nathank",
+          version: @version,
+          homepage: "https://github.com/n-at-han-k/rubocop-nathank",
+          description: "RuboCop rules for Nathank projects."
+        )
+      end
+
+      # Define the rules configuration for this plugin.
+      # @parameter context [Object] The LintRoller context object.
+      # @returns [LintRoller::Rules] Rules configuration specifying the path to the default RuboCop config.
+      def rules(context)
+        LintRoller::Rules.new(
+          type: :path,
+          config_format: :rubocop,
+          value: File.expand_path("config.yaml", __dir__),
+        )
+      end
+    end
+  end
+end

data/lib/rubocop/nathank/single_line_methods_for_events.rb

@@ -0,0 +1,168 @@
+# frozen_string_literal: true
+
+# Released under the Apache License, Version 2.0.
+# Copyright, 2026, by General Intelligence Systems.
+
+require_relative "support/prism_source"
+
+module RuboCop
+  module Nathank
+    # Requires a method whose body is a single expression to use the endless method form.
+    #
+    # @example
+    #   # bad
+    #   def event_type
+    #     "m.room.message"
+    #   end
+    #   # good
+    #   def event_type = "m.room.message"
+    class SingleLineMethodsForEvents < ::RuboCop::Cop::Base
+      include PrismSource
+      extend ::RuboCop::Cop::AutoCorrector
+
+      MSG = "A method whose body is one expression must use the endless form: `def name = expression`."
+
+      # Expressions which can follow ` = ` unchanged. Anything with its own `end`, or with lower precedence than the assignment, is left as a block: what it would parse as is not what it says as a body.
+      ACCEPTED_BODIES = [
+        ::Prism::ArrayNode,
+        ::Prism::CallNode,
+        ::Prism::ClassVariableReadNode,
+        ::Prism::ConstantPathNode,
+        ::Prism::ConstantReadNode,
+        ::Prism::FalseNode,
+        ::Prism::FloatNode,
+        ::Prism::GlobalVariableReadNode,
+        ::Prism::HashNode,
+        ::Prism::ImaginaryNode,
+        ::Prism::InstanceVariableReadNode,
+        ::Prism::IntegerNode,
+        ::Prism::InterpolatedStringNode,
+        ::Prism::InterpolatedSymbolNode,
+        ::Prism::InterpolatedXStringNode,
+        ::Prism::LocalVariableReadNode,
+        ::Prism::NilNode,
+        ::Prism::RangeNode,
+        ::Prism::RationalNode,
+        ::Prism::RegularExpressionNode,
+        ::Prism::SelfNode,
+        ::Prism::StringNode,
+        ::Prism::SymbolNode,
+        ::Prism::TrueNode,
+        ::Prism::XStringNode,
+      ].freeze
+
+      def on_new_investigation
+        self.prism_each(::Prism::DefNode).each do |node|
+          if self.rewriteable?(node)
+            self.report(node)
+          end
+        end
+      end
+
+      private
+
+      # The one expression a method's body is, when that is what it is.
+      def sole_expression(node)
+        statements = self.prism_statements(node.body)
+
+        if statements.size == 1
+          statements.first
+        else
+          nil
+        end
+      end
+
+      # A method is rewritten only when it is not endless, not a setter, and has one non-heredoc body expression on one line.
+      def rewriteable?(node)
+        body = self.sole_expression(node)
+
+        !self.endless?(node) &&
+          !self.setter?(node.name) &&
+          !body.nil? &&
+          ACCEPTED_BODIES.any?{|klass| body.is_a?(klass)} &&
+          self.single_line?(node, body) &&
+          !self.prism_heredoc?(body)
+      end
+
+      # An endless method is written with `=` rather than a body closed by `end`.
+      def endless?(node)
+        !node.equal_loc.nil?
+      end
+
+      # The offense is reported either way; the correction is withheld when a comment sits inside the method, since replacing the method would take the comment with it.
+      def report(node)
+        range = self.prism_node_range(node)
+
+        if self.comment?(node)
+          add_offense(range)
+        else
+          add_offense(range) do |corrector|
+            corrector.replace(range, self.endless_form(node))
+          end
+        end
+      end
+
+      # `def foo=(value)` and `def []=(key, value)` have no endless form.
+      def setter?(name)
+        name == :[]= || /\A[a-zA-Z_]\w*=\z/.match?(name.to_s)
+      end
+
+      # The body on one line, and the signature on one line too, so that the rewritten method is still a single line.
+      def single_line?(node, body)
+        body.location.start_line == body.location.end_line &&
+          !self.signature_source(node).include?("\n")
+      end
+
+      # The source of the signature, e.g. `def build(**fields)`, without the gap before the body.
+      def signature_source(node)
+        source = processed_source.buffer.source
+
+        # byteslice, because every offset here is one of Prism's and those count bytes, where `String#[]` counts characters.
+        source.byteslice(node.location.start_offset...self.signature_end(node))
+      end
+
+      def signature_end(node)
+        ending = node.name_loc.end_offset
+
+        if parameters = node.parameters
+          [ending, parameters.location.end_offset].max
+        else
+          ending
+        end
+      end
+
+      def comment?(node)
+        self.prism_comments.any? do |comment|
+          (node.location.start_line..node.location.end_line).cover?(comment.location.start_line)
+        end
+      end
+
+      def endless_form(node)
+        "#{self.signature(node)} = #{self.prism_source(self.sole_expression(node))}"
+      end
+
+      def signature(node)
+        "#{self.receiver_prefix(node)}#{node.name}#{self.arguments_suffix(node)}"
+      end
+
+      def receiver_prefix(node)
+        if node.receiver
+          "def #{self.prism_source(node.receiver)}."
+        else
+          "def "
+        end
+      end
+
+      # Bare arguments are ambiguous before ` = `; parenthesize them.
+      def arguments_suffix(node)
+        parameters = node.parameters
+
+        if parameters.nil?
+          ""
+        else
+          "(#{self.prism_source(parameters)})"
+        end
+      end
+    end
+  end
+end