rubocop-fourshark 0.2.1

data/lib/rubocop/cop/rails/mandatory_inverse_of.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+require 'rubocop'
+
+module RuboCop
+  module Cop
+    module Rails
+      # Ensures that every ActiveRecord association
+      # (belongs_to, has_many, has_one) has an `inverse_of` option.
+      #
+      # Stricter than the stock `Rails/InverseOf`, which only flags associations
+      # where Active Record cannot auto-detect the inverse. This cop mandates
+      # `inverse_of` on every association. Disable the stock cop when enabling
+      # this one.
+      #
+      # @example
+      #   # bad
+      #   belongs_to :user
+      #
+      #   # good
+      #   belongs_to :user, inverse_of: :posts
+      #
+      class MandatoryInverseOf < ::RuboCop::Cop::Base
+        MSG = 'All associations must declare `inverse_of`.'
+
+        def self.default_configuration
+          super.merge(
+            'Include' => ['app/models/**/*.rb'],
+            'Exclude' => ['app/serializers/**/*.rb']
+          )
+        end
+
+        def on_send(node)
+          return unless in_model_file?(processed_source.file_path)
+          return unless association?(node)
+          return if polymorphic_or_through?(node)
+
+          kwargs = node.last_argument
+
+          missing_inverse_of =
+            !kwargs || !kwargs.hash_type? || kwargs.keys.none? { |k| k.value == :inverse_of }
+
+          add_offense(node.loc.selector) if missing_inverse_of
+        rescue StandardError => e
+          source_name =
+            if processed_source && processed_source.buffer
+              processed_source.file_path
+            else
+              'unknown'
+            end
+
+          warn "Rails/MandatoryInverseOf failed on #{source_name}: #{e.message}"
+        end
+
+        private
+
+        def association?(node)
+          %i[belongs_to has_many has_one].include?(node.method_name)
+        end
+
+        def in_model_file?(path)
+          return false if path.nil?
+
+          path.start_with?(File.join(Dir.pwd, 'app/models'))
+        end
+
+        # Detects if the association has `polymorphic: true` or `through: ...`
+        def polymorphic_or_through?(node)
+          # Look for any hash arguments and check their keys
+          node.arguments.any? do |arg|
+            next false unless arg.hash_type?
+
+            arg.keys.any? { |k| %i[polymorphic through].include?(k.value) }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/rails/optional_belongs_to.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+require 'rubocop'
+
+module RuboCop
+  module Cop
+    module Rails
+      # Requires `belongs_to` to declare `optional: true`. The 4Shark convention
+      # is to skip Rails' automatic presence/existence validation (a SELECT per
+      # record) and validate presence manually with `validates :x_id, presence: true`.
+      #
+      # Scoped to `app/models` via the `Include` config.
+      #
+      # @example
+      #   # bad
+      #   belongs_to :user
+      #
+      #   # good
+      #   belongs_to :user, optional: true
+      #
+      class OptionalBelongsTo < ::RuboCop::Cop::Base
+        MSG = 'Declare `belongs_to` with `optional: true` and validate presence manually.'
+
+        def self.default_configuration
+          super.merge(
+            'Include' => ['app/models/**/*.rb']
+          )
+        end
+
+        def on_send(node)
+          return unless node.method?(:belongs_to)
+          return if optional_true?(node)
+
+          add_offense(node.loc.selector)
+        end
+
+        private
+
+        def optional_true?(node)
+          kwargs = node.last_argument
+          return false if !kwargs || !kwargs.hash_type?
+
+          kwargs.pairs.any? { |pair| pair.key.value == :optional && pair.value.true_type? }
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/rails/ordered_macros.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+require 'rubocop'
+
+module RuboCop
+  module Cop
+    module Rails
+      # Requires class-level macro declarations of the same kind to be sorted
+      # alphabetically by their first symbol argument. Checked per macro name:
+      # all `belongs_to` sorted among themselves, all `validates` sorted, etc.
+      #
+      # Exceptions (lifecycle callbacks, dependency-ordered items, logical
+      # grouping) are NOT modelled — this is an experimental cop; if it flags
+      # more legitimate cases than it helps, drop it.
+      #
+      # @example
+      #   # bad
+      #   validates :name
+      #   validates :email
+      #
+      #   # good
+      #   validates :email
+      #   validates :name
+      #
+      class OrderedMacros < ::RuboCop::Cop::Base
+        MSG = 'Sort `%<macro>s` declarations alphabetically (`%<name>s` should come before `%<previous>s`).'
+
+        MACROS = %i[belongs_to has_one has_many has_and_belongs_to_many validates scope].freeze
+
+        def self.default_configuration
+          super.merge('Include' => ['app/models/**/*.rb'])
+        end
+
+        def on_class(node)
+          body = node.body
+          return unless body
+
+          statements = body.begin_type? ? body.children : [body]
+
+          MACROS.each do |macro|
+            flag_unsorted(statements.select { |statement| macro_call?(statement, macro) })
+          end
+        end
+
+        private
+
+        def flag_unsorted(calls)
+          calls.each_cons(2) do |previous, current|
+            previous_name = macro_name(previous)
+            current_name = macro_name(current)
+            next if current_name >= previous_name
+
+            add_offense(
+              current.loc.selector,
+              message: format(MSG, macro: current.method_name, name: current_name, previous: previous_name)
+            )
+          end
+        end
+
+        def macro_call?(node, macro)
+          return false unless node.is_a?(::RuboCop::AST::Node) && node.send_type?
+          return false unless node.method?(macro)
+
+          first = node.first_argument
+          first && first.sym_type?
+        end
+
+        def macro_name(node)
+          node.first_argument.value.to_s
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/rspec/conditional_in_let.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+require 'rubocop'
+
+module RuboCop
+  module Cop
+    module RSpec
+      # Forbids conditional logic (`if`/`case`) inside a `let`/`let!` block.
+      # Branching object setup belongs in separate `context` blocks, not in a
+      # single `let`. Ternaries are allowed.
+      #
+      # @example
+      #   # bad
+      #   let(:user) do
+      #     if admin?
+      #       create(:user, :admin)
+      #     else
+      #       create(:user)
+      #     end
+      #   end
+      #
+      #   # good — one context each
+      #   context 'when admin' do
+      #     let(:user) { create(:user, :admin) }
+      #   end
+      #
+      class ConditionalInLet < ::RuboCop::Cop::Base
+        MSG = 'Do not put conditional logic in a `let` — use separate contexts.'
+
+        LET_METHODS = %i[let let!].freeze
+
+        def on_block(node)
+          return unless let_block?(node)
+
+          body = node.body
+          return unless body
+
+          body.each_node(:if, :case) do |conditional|
+            next if conditional.if_type? && conditional.ternary?
+
+            add_offense(conditional.loc.keyword)
+          end
+        end
+
+        alias on_numblock on_block
+        alias on_itblock on_block
+
+        private
+
+        def let_block?(node)
+          send = node.send_node
+          LET_METHODS.include?(send.method_name) && send.receiver.nil?
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/rspec/factory_bot_in_before.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require 'rubocop'
+
+module RuboCop
+  module Cop
+    module RSpec
+      # Forbids object creation (`create`/`build`/`create_list`/`build_list`)
+      # inside a `before` block. Object creation belongs in `let`; `before` is
+      # for actions only.
+      #
+      # @example
+      #   # bad
+      #   before { @user = create(:user) }
+      #
+      #   # good
+      #   let(:user) { create(:user) }
+      #
+      class FactoryBotInBefore < ::RuboCop::Cop::Base
+        MSG = 'Do not create objects in `before` — use `let` for object creation.'
+
+        CREATION_METHODS = %i[create build create_list build_list].freeze
+
+        def on_block(node)
+          return unless before_block?(node)
+
+          node.each_node(:send) do |send|
+            next unless CREATION_METHODS.include?(send.method_name) && send.receiver.nil?
+
+            add_offense(send.loc.selector)
+          end
+        end
+
+        alias on_numblock on_block
+        alias on_itblock on_block
+
+        private
+
+        def before_block?(node)
+          send = node.send_node
+          send.method?(:before) && send.receiver.nil?
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/rspec/inverse_of_matcher.rb

@@ -0,0 +1,125 @@
+# frozen_string_literal: true
+
+require 'rubocop'
+
+module RuboCop
+  module Cop
+    module RSpec
+      # Ensures that RSpec association specs handle `.inverse_of` correctly
+      # depending on whether the model is a root (directly `< ApplicationRecord`)
+      # or an STI subclass.
+      #
+      # Rules:
+      # - Root models (direct superclass = `ApplicationRecord`) must include `.inverse_of`.
+      # - STI subclasses (superclass is another model) must NOT include `.inverse_of` (it belongs to the parent).
+      # - Associations marked as polymorphic or through are ignored.
+      # - Classes whose model file is missing or whose superclass is not a model are ignored.
+      #
+      # The root/subclass decision is made **statically** — by reading the model
+      # file and parsing its `class X < Y` declaration. The cop never loads the
+      # model class (a linter runs without the Rails app booted).
+      #
+      class InverseOfMatcher < ::RuboCop::Cop::Base
+        MSG_MISSING_INVERSE   = 'Root models must include `.inverse_of` in association specs.'
+        MSG_FORBIDDEN_INVERSE = 'Subclasses must NOT include `.inverse_of` in specs (it belongs to the parent).'
+
+        def self.default_configuration
+          super.merge(
+            'Include' => ['spec/models/**/*_spec.rb']
+          )
+        end
+
+        def on_send(node)
+          return unless node.method?(:belong_to)
+          return if chain_has_option?(node, :polymorphic)
+          return if chain_has_option?(node, :through)
+
+          model_name = model_class_from_spec
+          return unless model_name
+
+          classification = classify_model(model_name)
+          return if classification == :non_ar
+
+          if classification == :root
+            add_offense(node.loc.selector, message: MSG_MISSING_INVERSE) unless chain_has_inverse_of?(node)
+          elsif classification == :subclass
+            add_offense(node.loc.selector, message: MSG_FORBIDDEN_INVERSE) if chain_has_inverse_of?(node)
+          end
+        rescue StandardError => e
+          source_name =
+            if processed_source && processed_source.buffer
+              processed_source.file_path
+            else
+              'unknown'
+            end
+
+          warn "RSpec/InverseOfMatcher failed on #{source_name}: #{e.message}"
+        end
+
+        private
+
+        # Check if .inverse_of exists in the send chain
+        def chain_has_inverse_of?(node)
+          node.each_ancestor(:send).any? { |ancestor| ancestor.method?(:inverse_of) }
+        end
+
+        # Check if association has a given option (e.g., :polymorphic, :through)
+        def chain_has_option?(node, option_name)
+          node.each_ancestor(:send).any? do |ancestor|
+            ancestor.arguments.any? do |arg|
+              arg.hash_type? && arg.keys.any? { |k| k.value == option_name }
+            end
+          end
+        end
+
+        # Convert spec file path into model class name
+        def model_class_from_spec
+          path = processed_source.file_path if processed_source && processed_source.buffer
+          return nil unless path
+
+          match = path.match(%r{spec/models/(.+)_spec\.rb})
+          return nil unless match
+
+          relative = match[1]
+          return nil if relative.empty?
+
+          relative.split('/').map { |part| part.split('_').map(&:capitalize).join }.join('::')
+        end
+
+        # Classify the model as :root, :subclass, or :non_ar by reading the
+        # model file statically (no class loading).
+        def classify_model(model_name)
+          content = model_source(model_name)
+          return :non_ar unless content
+
+          superclass = superclass_of(content)
+          return :non_ar unless superclass
+          return :root if superclass == 'ApplicationRecord'
+          return :subclass if model_source(superclass)
+
+          :non_ar
+        rescue StandardError
+          :non_ar
+        end
+
+        def model_source(model_name)
+          path = File.join(Dir.pwd, 'app/models', "#{camel_to_snake(model_name)}.rb")
+          File.exist?(path) ? File.read(path) : nil
+        end
+
+        def superclass_of(content)
+          match = content.match(/^\s*class\s+[\w:]+\s*<\s*([\w:]+)/)
+          match && match[1]
+        end
+
+        # "UserAccount" → "user_account"; "Plan::Statement" → "plan/statement"
+        def camel_to_snake(name)
+          name.gsub('::', '/')
+              .gsub(/([A-Z\d]+)([A-Z][a-z])/, '\1_\2')
+              .gsub(/([a-z\d])([A-Z])/, '\1_\2')
+              .downcase
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/rspec/overwritten_let.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+require 'rubocop'
+
+module RuboCop
+  module Cop
+    module RSpec
+      # Forbids overriding a `let`/`let!` that is already defined in an outer
+      # example group. Shadowing an ancestor's `let` makes it ambiguous which
+      # value applies in a given example.
+      #
+      # A `let` that is specific to a single scenario is allowed, even when a
+      # sibling context defines a `let` of the same name — siblings are separate
+      # scopes and do not override each other. Only an inner `let` that shadows
+      # an `let` from an ancestor example group is flagged.
+      #
+      # @example
+      #   # bad — inner let shadows the outer one
+      #   let(:user) { create(:user) }
+      #
+      #   context 'when admin' do
+      #     let(:user) { create(:user, :admin) }
+      #   end
+      #
+      #   # good — scenario-specific let, no ancestor defines it
+      #   context 'when admin' do
+      #     let(:user) { create(:user, :admin) }
+      #   end
+      #
+      #   context 'when regular' do
+      #     let(:user) { create(:user) }
+      #   end
+      #
+      class OverwrittenLet < ::RuboCop::Cop::Base
+        MSG = 'Do not override the outer `let` `%<name>s`; use a distinct name or set the value in `before`.'
+
+        LET_METHODS = %i[let let!].freeze
+        EXAMPLE_GROUP_METHODS = %i[describe context].freeze
+
+        def on_send(node)
+          return unless LET_METHODS.include?(node.method_name) && node.receiver.nil?
+
+          name = let_name(node)
+          return unless name
+
+          immediate_group = node.each_ancestor(:block).find { |block| example_group?(block) }
+          return unless immediate_group
+          return unless outer_groups(immediate_group).any? { |group| defines_let?(group, name) }
+
+          add_offense(node.loc.selector, message: format(MSG, name: name))
+        end
+
+        private
+
+        def outer_groups(group)
+          group.each_ancestor(:block).select { |block| example_group?(block) }
+        end
+
+        def example_group?(block)
+          send = block.send_node
+          EXAMPLE_GROUP_METHODS.include?(send.method_name)
+        end
+
+        def defines_let?(group, name)
+          body = group.body
+          return false unless body
+
+          statements = body.begin_type? ? body.children : [body]
+
+          statements.any? { |statement| let_named?(statement, name) }
+        end
+
+        def let_named?(statement, name)
+          return false unless statement.is_a?(::RuboCop::AST::Node)
+
+          send = statement.respond_to?(:send_node) ? statement.send_node : statement
+          return false unless send.send_type?
+          return false unless LET_METHODS.include?(send.method_name) && send.receiver.nil?
+
+          first = send.first_argument
+          first && first.sym_type? && first.value == name
+        end
+
+        def let_name(node)
+          first = node.first_argument
+          first && first.sym_type? ? first.value : nil
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/style/disallow_safe_navigation.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require 'rubocop'
+
+module RuboCop
+  module Cop
+    module Style
+      class DisallowSafeNavigation < ::RuboCop::Cop::Base
+        MSG = 'Do not use safe navigation (`&.`). Use explicit conditionals instead.'
+
+        def on_csend(node)
+          add_offense(node)
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/style/disallow_try.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require 'rubocop'
+
+module RuboCop
+  module Cop
+    module Style
+      class DisallowTry < ::RuboCop::Cop::Base
+        MSG = 'Do not use `try` or `try!`. Use explicit conditionals instead.'
+
+        RESTRICT_ON_SEND = %i[try try!].freeze
+
+        def on_send(node)
+          add_offense(node)
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/fourshark/plugin.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require 'lint_roller'
+
+module RuboCop
+  module Fourshark
+    # A plugin that integrates rubocop-fourshark with RuboCop's plugin system.
+    class Plugin < LintRoller::Plugin
+      def about
+        LintRoller::About.new(
+          name: 'rubocop-fourshark',
+          version: VERSION,
+          homepage: 'https://github.com/4shark/rubocop-fourshark',
+          description: "4Shark's Ruby, Rails, and RSpec conventions as RuboCop cops."
+        )
+      end
+
+      def supported?(context)
+        context.engine == :rubocop
+      end
+
+      def rules(_context)
+        LintRoller::Rules.new(
+          type: :path,
+          config_format: :rubocop,
+          value: Pathname.new(__dir__).join('../../../config/default.yml')
+        )
+      end
+    end
+  end
+end

data/lib/rubocop/fourshark/version.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Fourshark
+    VERSION = '0.2.1'
+  end
+end

data/lib/rubocop/fourshark.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+require_relative 'fourshark/version'
+
+module RuboCop
+  module Fourshark
+    class Error < StandardError; end
+    # Your code goes here...
+  end
+end

data/lib/rubocop-fourshark.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+require 'rubocop'
+
+require_relative 'rubocop/fourshark'
+require_relative 'rubocop/fourshark/version'
+require_relative 'rubocop/fourshark/plugin'
+
+require_relative 'rubocop/cop/fourshark_cops'