rubocop-obsession 0.1.0

data/lib/rubocop/cop/obsession/rails/no_callback_conditions.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Obsession
+      module Rails
+        # This cop checks for model callbacks with conditions.
+        #
+        # Model callback with conditions should be avoided because they can
+        # quickly degenerate into multiple conditions that pollute the macro
+        # definition section, even more so if lambdas are involved. Instead, move
+        # the condition inside the callback method.
+        #
+        # Note: conditions are allowed for `validates :field` callbacks, as it is
+        # sometimes not easy to translate them into `validate :validate_field`
+        # custom validation callbacks.
+        #
+        # @example
+        #
+        #   # bad
+        #   after_update_commit :crawl_rss, if: :rss_changed?
+        #   def crawl_rss
+        #     ...
+        #   end
+        #
+        #   # good
+        #   after_update_commit :crawl_rss
+        #   def crawl_rss
+        #     return if !rss_changed?
+        #     ...
+        #   end
+        class NoCallbackConditions < Cop
+          MSG =
+            'Avoid condition in callback declaration, move it inside the callback method instead.'
+
+          def_node_matcher :callback_with_condition?, <<~PATTERN
+            (
+              send nil? _
+                (sym _)
+                (hash
+                  ...
+                  (pair (sym {:if :unless}) ...)
+                  ...
+                )
+            )
+          PATTERN
+
+          def on_send(node)
+            return if !callback_with_condition?(node)
+            callback = node.children[1]
+            return if callback == :validates
+            return if callback.to_s.include?('around')
+
+            add_offense(node)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/obsession/rails/private_callback.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Obsession
+      module Rails
+        # This cop checks for callbacks methods that are not private.
+        #
+        # Callback methods are usually never called outside of the class, so
+        # there is no reason to declare them in the public section. They should
+        # be private.
+        #
+        # @example
+        #
+        #   # bad
+        #   before_action :load_blog_post
+        #
+        #   def load_blog_post
+        #     ...
+        #   end
+        #
+        #   # good
+        #   before_action :load_blog_post
+        #
+        #   private
+        #
+        #   def load_blog_post
+        #     ...
+        #   end
+        class PrivateCallback < Cop
+          include VisibilityHelp
+          include Helpers
+
+          MSG = 'Make callback method private'
+
+          def_node_matcher :on_callback, <<~PATTERN
+            (send nil? $_ (sym $_) ...)
+          PATTERN
+
+          def on_new_investigation
+            @callbacks = Set.new
+          end
+
+          def on_send(node)
+            on_callback(node) do |callback, method_name|
+              @callbacks << method_name if rails_callback?(callback.to_s)
+            end
+          end
+
+          def on_def(node)
+            if @callbacks.include?(node.method_name) && node_visibility(node) == :public
+              add_offense(node, message: MSG)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/obsession/rails/safety_assured_comment.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Obsession
+      module Rails
+        # This cop checks uses of strong_migrations' `safety_assured { ... }`
+        # without a valid reason.
+        #
+        # `safety_assured { ... }` should only be used after *carefully*
+        # following the instructions from the strong_migrations gem. Always add a
+        # `# Safe because <reason>` comment explaining how you assured the safety
+        # of the DB migration. The reason should be detailed and reviewed by a
+        # knowledgeable PR reviewer. Failure to follow instructions may bring your
+        # app down.
+        class SafetyAssuredComment < Cop
+          MSG =
+            'Add `# Safe because <reason>` comment above safety_assured. ' \
+              'An invalid reason may bring the site down.'
+
+          def_node_matcher :safety_assured_block?, <<~PATTERN
+            (block (send nil? :safety_assured) ...)
+          PATTERN
+
+          def on_block(node)
+            return if !safety_assured_block?(node)
+            previous_comment = processed_source.comments_before_line(node.first_line)&.first
+
+            if previous_comment.nil? || !previous_comment.text.match?(/^# Safe because( [^ ]+){4}/)
+              add_offense(node)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/obsession/rails/service_name.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Obsession
+      module Rails
+        # This cop checks for services and jobs whose name do not start with a verb.
+        #
+        # Services and jobs with only one public method should have a name that
+        # starts with a verb, because these classes are essentially performing
+        # one action, and the best way to describe an action is with a verb.
+        #
+        # @example
+        #
+        #   # bad
+        #   class Company
+        #     def perform
+        #       ...
+        #     end
+        #   end
+        #
+        #   # good
+        #   class ImportCompany
+        #     def perform
+        #       ...
+        #     end
+        #   end
+        #
+        #   # bad
+        #   class BlogPostPopularityJob < ApplicationJob
+        #     def perform
+        #       ...
+        #     end
+        #   end
+        #
+        #   # good
+        #   class UpdateBlogPostPopularityJob < ApplicationJob
+        #     def perform
+        #       ...
+        #     end
+        #   end
+        class ServiceName < Base
+          include Helpers
+
+          MSG = 'Service or Job name should start with a verb.'
+          IGNORED_PUBLIC_METHODS = %i[initialize lock_period].freeze
+
+          def_node_matcher :private_section?, <<~PATTERN
+            (send nil? {:private :protected})
+          PATTERN
+
+          def on_class(class_node)
+            return if public_methods(class_node).length != 1
+            class_name = class_node.identifier.source
+            class_name_first_word = class_name.underscore.split('_').first
+
+            add_offense(class_node) if !verb?(class_name_first_word)
+          end
+
+          private
+
+          def public_methods(class_node)
+            return [] if !class_node.body
+            public_methods = []
+
+            case class_node.body.type
+            when :def
+              public_methods << class_node.body
+            when :begin
+              class_node.body.children.each do |child|
+                public_methods << child if child.type == :def
+                break if private_section?(child)
+              end
+            end
+
+            public_methods.reject { |method| IGNORED_PUBLIC_METHODS.include?(method.method_name) }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/obsession/rails/service_perform_method.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Obsession
+      module Rails
+        # This cop checks for services whose single public method is not named
+        # `perform`.
+        #
+        # Services and jobs with only one public method should have their method
+        # named `perform` for consistency. The choice of `perform` as a name is
+        # inspired from ActiveJob and makes it easier to make services and jobs
+        # interchangeable.
+        #
+        # @example
+        #
+        #   # bad
+        #   class ImportCompany
+        #     def import
+        #       ...
+        #     end
+        #   end
+        #
+        #   # bad
+        #   class ImportCompany
+        #     def execute
+        #       ...
+        #     end
+        #   end
+        #
+        #   # good
+        #   class ImportCompany
+        #     def perform
+        #       ...
+        #     end
+        #   end
+        class ServicePerformMethod < ServiceName
+          extend AutoCorrector
+
+          MSG = 'Single public method of Service should be called `perform`'
+
+          def on_class(class_node)
+            public_methods = public_methods(class_node)
+            return if public_methods.length != 1
+            method = public_methods.first
+
+            if method.method_name != :perform
+              add_offense(method) do |corrector|
+                corrector.replace(method, method.source.sub(/#{method.method_name}/, 'perform'))
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/obsession/rails/short_after_commit.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Obsession
+      module Rails
+        # This cop checks for `after_commit` declarations that could be shorter.
+        #
+        # @example
+        #
+        #   # bad
+        #   after_commit :send_email, on: :create
+        #
+        #   # good
+        #   after_create_commit :send_email
+        class ShortAfterCommit < Cop
+          MSG = 'Use shorter %<prefer>s'
+
+          def_node_matcher :after_commit?, '(send nil? :after_commit ...)'
+
+          def_node_matcher :after_commit_create?, <<~PATTERN
+            (
+              send nil? :after_commit
+                (sym _)
+                (hash
+                  (pair (sym :on) {(sym :create)|(array (sym :create))})
+                )
+            )
+          PATTERN
+
+          def_node_matcher :after_commit_update?, <<~PATTERN
+            (
+              send nil? :after_commit
+                (sym _)
+                (hash
+                  (pair (sym :on) {(sym :update)|(array (sym :update))})
+                )
+            )
+          PATTERN
+
+          def_node_matcher :after_commit_destroy?, <<~PATTERN
+            (
+              send nil? :after_commit
+                (sym _)
+                (hash
+                  (pair (sym :on) {(sym :destroy)|(array (sym :destroy))})
+                )
+            )
+          PATTERN
+
+          def_node_matcher :after_commit_create_update?, <<~PATTERN
+            (
+              send nil? :after_commit
+                (sym _)
+                (hash
+                  (pair (sym :on) (array <(sym :create) (sym :update)>))
+                )
+            )
+          PATTERN
+
+          def_node_matcher :after_commit_all_events?, <<~PATTERN
+            (
+              send nil? :after_commit
+                (sym _)
+                (hash
+                  (pair (sym :on) (array <(sym :create) (sym :update) (sym :destroy)>))
+                )
+            )
+          PATTERN
+
+          def on_send(node)
+            return if !after_commit?(node)
+
+            if after_commit_create?(node)
+              add_offense(node, message: format(MSG, prefer: 'after_create_commit'))
+            elsif after_commit_update?(node)
+              add_offense(node, message: format(MSG, prefer: 'after_update_commit'))
+            elsif after_commit_destroy?(node)
+              add_offense(node, message: format(MSG, prefer: 'after_destroy_commit'))
+            elsif after_commit_create_update?(node)
+              add_offense(node, message: format(MSG, prefer: 'after_save_commit'))
+            elsif after_commit_all_events?(node)
+              add_offense(node, message: format(MSG, prefer: 'after_commit with no `on:` argument'))
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/obsession/rails/short_validate.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Obsession
+      module Rails
+        # This cop checks for `validate` declarations that could be shorter.
+        #
+        # @example
+        #
+        #   # bad
+        #   validate :validate_url, on: %i(create update)
+        #
+        #   # good
+        #   validate :validate_url
+        class ShortValidate < Cop
+          MSG = 'The `on:` argument is not needed in this validate.'
+
+          def_node_matcher :validate_with_unneeded_on?, <<~PATTERN
+            (
+              send nil? :validate
+                (sym _)
+                (hash
+                  (pair (sym :on) (array <(sym :create) (sym :update)>))
+                )
+            )
+          PATTERN
+
+          def on_send(node)
+            add_offense(node) if validate_with_unneeded_on?(node)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/obsession/rails/validate_one_field.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Obsession
+      module Rails
+        # This cop checks for `validates` callbacks with multiple fields.
+        #
+        # One field per `validates` makes the validation extra clear.
+        #
+        # @example
+        #
+        #   # bad
+        #   validates :name, :status, presence: true
+        #
+        #   # good
+        #   validates :name, presence: true
+        #   validates :status, presence: true
+        class ValidateOneField < Cop
+          MSG = 'Validate only one field per line.'
+
+          def_node_matcher :validates_with_more_than_one_field?, <<~PATTERN
+            (send nil? :validates (sym _) (sym _) ...)
+          PATTERN
+
+          def on_send(node)
+            add_offense(node) if validates_with_more_than_one_field?(node)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/obsession/rails/validation_method_name.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Obsession
+      module Rails
+        # This cop checks for validation methods that do not start with `validate_`.
+        #
+        # @example
+        #
+        #   # bad
+        #   validate :at_least_one_admin
+        #
+        #   # good
+        #   validate :validate_at_least_one_admin
+        class ValidationMethodName < Cop
+          MSG = 'Prefix custom validation method with validate_'
+
+          def_node_matcher :on_validate_callback, <<~PATTERN
+            (send nil? :validate (sym $_) ...)
+          PATTERN
+
+          def on_send(node)
+            on_validate_callback(node) do |method_name|
+              add_offense(node) if !method_name.start_with?('validate_')
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/obsession/rspec/describe_public_method.rb

@@ -0,0 +1,125 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Obsession
+      module Rspec
+        # This cop checks for `describe` blocks that test private methods.
+        #
+        # If you are doing black box unit testing, it means that you are only
+        # interested in testing external behavior, a.k.a public interface,
+        # a.k.a public methods. Private methods are considered implementation
+        # details and are not directly tested.
+        #
+        # If you need to test a Rails callback, test it indirectly through its
+        # corresponding Rails public method, e.g. #create, #save, etc.
+        #
+        # @example
+        #
+        #   class Comment < ApplicationRecord
+        #     after_create_commit :notify_users
+        #
+        #     private
+        #
+        #     def notify_users
+        #       ...
+        #     end
+        #   end
+        #
+        #   # bad
+        #   describe '#notify_users' do
+        #     ...
+        #   end
+        #
+        #   # good
+        #   describe '#create' do
+        #     it 'notifies users' do
+        #       ...
+        #     end
+        #   end
+        class DescribePublicMethod < Cop
+          MSG = 'Only test public methods.'
+
+          def_node_matcher :on_context_method, <<-PATTERN
+            (block (send nil? :describe (str $#method_name?)) ...)
+          PATTERN
+
+          def_node_search :class_nodes, <<~PATTERN
+            (class ...)
+          PATTERN
+
+          def_node_matcher :private_section?, <<~PATTERN
+            (send nil? {:private :protected})
+          PATTERN
+
+          def on_block(node)
+            on_context_method(node) do |method_name|
+              method_name = method_name.sub('#', '').to_sym
+              add_offense(node) if private_methods.include?(method_name)
+            end
+          end
+
+          private
+
+          def method_name?(description)
+            description.start_with?('#')
+          end
+
+          def private_methods
+            return @private_methods if @private_methods
+            @private_methods = []
+
+            if File.exist?(tested_file_path)
+              node = parse_file(tested_file_path)
+              @private_methods = find_private_methods(class_nodes(node).first)
+            end
+
+            @private_methods
+          end
+
+          def tested_file_path
+            return @tested_file_path if @tested_file_path
+
+            spec_path = processed_source.file_path.sub(Dir.pwd, '')
+            file_path =
+              if spec_path.include?('/lib/')
+                spec_path.sub('/spec/lib/', '/lib/')
+              else
+                spec_path.sub('/spec/', '/app/')
+              end
+            file_path = file_path.sub('_spec.rb', '.rb')
+            file_path = File.join(Dir.pwd, file_path)
+
+            @tested_file_path = file_path
+          end
+
+          def parse_file(file_path)
+            parser_class = ::Parser.const_get(:"Ruby#{target_ruby_version.to_s.sub('.', '')}")
+            parser = parser_class.new(RuboCop::AST::Builder.new)
+
+            buffer = Parser::Source::Buffer.new(file_path, 1)
+            buffer.source = File.read(file_path)
+
+            parser.parse(buffer)
+          end
+
+          def find_private_methods(class_node)
+            return [] if class_node&.body&.type != :begin
+            private_methods = []
+            private_section_found = false
+
+            class_node.body.children.each do |child|
+              if private_section?(child)
+                private_section_found = true
+              elsif child.type == :def && private_section_found
+                private_methods << child.method_name
+              end
+            end
+
+            private_methods
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/obsession/rspec/empty_line_after_final_let.rb

@@ -0,0 +1,36 @@
+if defined?(RuboCop::RSpec)
+  module RuboCop
+    module Cop
+      module Obsession
+        module Rspec
+          # Same as RSpec/EmptyLineAfterFinalLet, but allows `let` to be followed
+          # by `it` with no new line, to allow for this style of spec:
+          #
+          # @example
+          #
+          #   describe '#domain' do
+          #     context do
+          #       let(:url) { Url.new('http://www.some-site.com/some-page') }
+          #       it { expect(url.domain).to eq 'some-site.com' }
+          #     end
+          #
+          #     context do
+          #       let(:url) { Url.new('some-site.com') }
+          #       it { expect(url.domain).to eq 'some-site.com' }
+          #     end
+          #   end
+          class EmptyLineAfterFinalLet < RSpec::EmptyLineAfterFinalLet
+            def missing_separating_line(node)
+              line = final_end_location(node).line
+              line += 1 while comment_line?(processed_source[line])
+              return if processed_source[line].blank?
+              return if processed_source[line].match?(/\s*it /)
+
+              yield offending_loc(line)
+            end
+          end
+        end
+      end
+    end
+  end
+end