rubocop-obsession 0.1.0

data/lib/rubocop/cop/mixin/helpers.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Helpers
+      VERBS = File.read("#{__dir__}/files/verbs.txt").split
+
+      def rails_callback?(callback)
+        return true if callback == 'validate'
+
+        callback.match?(
+          /
+        ^(before|after|around)
+        _.*
+        (action|validation|create|update|save|destroy|commit|rollback)$
+        /x
+        )
+      end
+
+      def verb?(string)
+        short_string = string[2..] if string.start_with?('re')
+
+        VERBS.include?(string) || VERBS.include?(short_string)
+      end
+    end
+  end
+end

data/lib/rubocop/cop/obsession/graphql/mutation_name.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Obsession
+      module Graphql
+        # This cop checks for mutation names that do not start with a verb.
+        #
+        # Mutation names should start with a verb, because mutations are actions,
+        # and actions are best described with verbs.
+        #
+        # @example
+        #
+        #   # bad
+        #   module Mutations
+        #     class Event < Base
+        #     end
+        #   end
+        #
+        #   # good
+        #   module Mutations
+        #     class TrackEvent < Base
+        #     end
+        #   end
+        class MutationName < Cop
+          include Helpers
+
+          MSG = 'Mutation name should start with a verb.'
+
+          def on_class(class_node)
+            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
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/obsession/method_order.rb

@@ -0,0 +1,244 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Obsession
+      # This cop checks for private/protected methods that are not ordered correctly.
+      #
+      # Code should read from top to bottom: methods should be defined in the
+      # same order as the order when they are first mentioned.
+      # Private/protected methods should follow that rule.
+      #
+      # Note 1: public methods do not have to follow that rule, and can be
+      # defined in any order the developer wants, like by order of
+      # importance. This is because they are usually called outside of the
+      # class and often not called within the class at all. If possible though,
+      # developers should still try to order their public methods from top to
+      # bottom when it makes sense.
+      #
+      # Note 2: method order cannot be computed for methods called by `send`,
+      # metaprogramming, private methods called by superclasses or modules,
+      # etc. This cop's suggestions and autocorrections may be slightly off for
+      # these kinds of edge cases.
+      #
+      # Note 3: for more information on this style of method ordering, see
+      # Robert C. Martin's "Clean Code" book > "Chapter 3: Functions" > "One
+      # level of abstraction per function" > "Reading Code from Top to Bottom:
+      # The Stepdown Rule" chapter.
+      #
+      # @example
+      #
+      #   # bad
+      #   def perform
+      #     return if method_a?
+      #     method_b
+      #     method_c
+      #   end
+      #
+      #   private
+      #
+      #   def method_c; ...; end
+      #   def method_b; ...; end
+      #   def method_a?; ...; end
+      #
+      #   # good
+      #   def perform
+      #     return if method_a?
+      #     method_b
+      #     method_c
+      #   end
+      #
+      #   private
+      #
+      #   def method_a?; ...; end
+      #   def method_b; ...; end
+      #   def method_c; ...; end
+      class MethodOrder < Base
+        include Helpers
+        include RangeHelp
+        include VisibilityHelp
+        extend AutoCorrector
+
+        MSG = 'Method `%<after>s` should appear below `%<previous>s`.'
+
+        def_node_search :private_node, <<~PATTERN
+          (send nil? {:private :protected})
+        PATTERN
+
+        def_node_matcher :on_callback, <<~PATTERN
+          (send nil? $_ (sym $_) ...)
+        PATTERN
+
+        def_node_search :method_calls, <<~PATTERN
+          (send nil? $_ ...)
+        PATTERN
+
+        class Node
+          attr_accessor :value, :children
+
+          def initialize(value:, children: [])
+            @value = value
+            @children = children
+          end
+        end
+
+        def on_class(class_node)
+          @class_node = class_node
+          find_private_node || return
+          build_methods || return
+          build_callback_methods
+
+          build_method_call_tree
+          build_ordered_private_methods
+          build_private_methods
+
+          verify_private_methods_order
+        end
+
+        private
+
+        def find_private_node
+          @private_node = private_node(@class_node)&.first
+        end
+
+        def build_methods
+          @methods = {}
+          return false if @class_node&.body&.type != :begin
+
+          @class_node.body.children.each do |child|
+            @methods[child.method_name] = child if child.type == :def
+          end
+
+          @methods.any?
+        end
+
+        def build_callback_methods
+          @callback_methods = []
+
+          @class_node.body.children.each do |node|
+            on_callback(node) do |callback, method_name|
+              if rails_callback?(callback.to_s) && @methods[method_name]
+                @callback_methods << @methods[method_name]
+              end
+            end
+          end
+        end
+
+        def build_method_call_tree
+          methods = (@callback_methods + @methods.values).uniq
+
+          @method_call_tree =
+            Node.new(value: nil, children: methods.map { |method| method_call_tree(method) })
+        end
+
+        def method_call_tree(method_node, seen_method_calls = Set.new)
+          method_name = method_node.method_name
+          return nil if seen_method_calls.include?(method_name)
+          called_methods = find_called_methods(method_node)
+          return Node.new(value: method_node, children: []) if called_methods.empty?
+
+          children =
+            called_methods.filter_map do |called_method|
+              method_call_tree(called_method, seen_method_calls + [method_name])
+            end
+
+          Node.new(value: method_node, children: children)
+        end
+
+        def find_called_methods(method_node)
+          called_methods =
+            method_calls(method_node).filter_map { |method_call| @methods[method_call] }
+
+          @called_methods ||= Set.new(@callback_methods)
+          @called_methods += called_methods
+
+          called_methods
+        end
+
+        def build_ordered_private_methods
+          @ordered_private_methods = ordered_private_methods(@method_call_tree)
+        end
+
+        def ordered_private_methods(node)
+          ast_node = node.value
+          method_name = should_ignore?(ast_node) ? nil : ast_node.method_name
+
+          next_names = node.children.flat_map { |child| ordered_private_methods(child) }
+
+          ([method_name] + next_names).compact.uniq
+        end
+
+        def should_ignore?(ast_node)
+          ast_node.nil? || node_visibility(ast_node) == :public ||
+            !@called_methods.include?(ast_node)
+        end
+
+        def build_private_methods
+          @private_methods = @methods.keys.intersection(@ordered_private_methods)
+        end
+
+        def verify_private_methods_order
+          @ordered_private_methods.each_with_index do |ordered_method, ordered_index|
+            index = @private_methods.index(ordered_method)
+
+            add_method_offense(ordered_method, ordered_index) && return if index != ordered_index
+          end
+        end
+
+        def add_method_offense(method_name, method_index)
+          method = @methods[method_name]
+          previous_method =
+            if method_index > 0
+              previous_method_name = @ordered_private_methods[method_index - 1]
+              @methods[previous_method_name]
+            else
+              @private_node
+            end
+
+          message = format(MSG, previous: previous_method.method_name, after: method_name)
+
+          add_offense(method, message: message) do |corrector|
+            autocorrect(corrector, method, previous_method)
+          end
+        end
+
+        def autocorrect(corrector, method, previous_method)
+          previous_method_range = source_range_with_comment(previous_method)
+          method_range = source_range_with_comment(method)
+
+          corrector.insert_after(previous_method_range, method_range.source)
+          corrector.remove(method_range)
+        end
+
+        def source_range_with_comment(node)
+          range_between(start_position_with_comment(node), end_position(node) + 1)
+        end
+
+        def start_position_with_comment(node)
+          first_comment = nil
+
+          (node.first_line - 1).downto(1) do |annotation_line|
+            comment = processed_source.comment_at_line(annotation_line)
+            break if !comment
+            first_comment = comment if whole_line_comment_at_line?(annotation_line)
+          end
+
+          start_line_position(first_comment || node)
+        end
+
+        def whole_line_comment_at_line?(line)
+          /\A\s*#/.match?(processed_source.lines[line - 1])
+        end
+
+        def start_line_position(node)
+          processed_source.buffer.line_range(node.loc.line).begin_pos - 1
+        end
+
+        def end_position(node)
+          end_line = processed_source.buffer.line_for_position(node.loc.expression.end_pos)
+          processed_source.buffer.line_range(end_line).end_pos
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/obsession/no_break_or_next.rb

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Obsession
+      # This cop checks for `next` (and sometimes `break`) in loops.
+      #
+      # - For big loops, `next` or `break` indicates that the loop body has
+      # significant logic, which means it should be moved into its own method,
+      # and you can convert the `next` or `break` into `return` and the like.
+      # - For small loops, you can just use normal conditions instead of `next`.
+      # `break` is allowed.
+      #
+      # Note: Sometimes loops can also be rethought, like transforming a `loop`
+      # + `break` into a `while`.
+      #
+      # @example
+      #
+      #   # bad
+      #   github_teams.each do |github_team|
+      #     next if github_team['size'] == 0
+      #     team = @company.teams.find_or_initialize_by(github_team['id'])
+      #
+      #     team.update!(
+      #       name: github_team['name'],
+      #       description: github_team['description'],
+      #       owner: @company,
+      #     )
+      #   end
+      #
+      #   # good
+      #   github_teams.each do |github_team| { |github_team| upsert_team(github_team) }
+      #
+      #   def upsert_team(github_team)
+      #     return if github_team['size'] == 0
+      #     team = @company.teams.find_or_initialize_by(github_team['id'])
+      #
+      #     team.update!(
+      #       name: github_team['name'],
+      #       description: github_team['description'],
+      #       owner: @company,
+      #     )
+      #   end
+      #
+      #   # bad
+      #   def highlight
+      #     blog_posts.each do |blog_post|
+      #       next if !blog_post.published?
+      #
+      #       self.highlighted = true
+      #     end
+      #   end
+      #
+      #   # good
+      #   def highlight
+      #     blog_posts.each do |blog_post|
+      #       if blog_post.published?
+      #         self.highlighted = true
+      #       end
+      #     end
+      #   end
+      class NoBreakOrNext < Cop
+        BIG_LOOP_MSG =
+          'Avoid `break`/`next` in big loop, decompose into private method or rethink loop.'
+        NO_NEXT_MSG = 'Avoid `next` in loop, use conditions or rethink loop.'
+        BIG_LOOP_MIN_LINES = 7
+
+        def_node_matcher :contains_break_or_next?, <<~PATTERN
+          `(if <({next break}) ...>)
+        PATTERN
+
+        def_node_matcher :contains_next?, <<~PATTERN
+          `(if <(next) ...>)
+        PATTERN
+
+        def on_block(node)
+          return if !contains_break_or_next?(node)
+
+          if big_loop?(node)
+            add_offense(node, message: BIG_LOOP_MSG)
+          elsif contains_next?(node)
+            add_offense(node, message: NO_NEXT_MSG)
+          end
+        end
+
+        private
+
+        def big_loop?(node)
+          node.line_count >= BIG_LOOP_MIN_LINES + 2
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/obsession/no_paragraphs.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Obsession
+      # This cop checks for methods with many instructions but no paragraphs.
+      #
+      # If your method code has many instructions that are not organized into
+      # paragraphs, you should break it up into multiple paragraphs to make the
+      # code more breathable and readable. The 3 possible paragraphs themes
+      # always are: initialization, action, and result.
+      #
+      # @example
+      #
+      #   # bad
+      #   def set_seo_content
+      #     return if slug.blank?
+      #     return if seo_content.present?
+      #     template = SeoTemplate.find_by(template_type: 'BlogPost')
+      #     return if template.blank?
+      #     self.seo_content = build_seo_content(seo_template: template, slug: slug)
+      #     Rails.logger.info('Content has been set')
+      #   end
+      #
+      #   # good
+      #   def set_seo_content
+      #     return if slug.blank?
+      #     return if seo_content.present?
+      #     template = SeoTemplate.find_by(template_type: 'BlogPost')
+      #     return if template.blank?
+      #
+      #     self.seo_content = build_seo_content(seo_template: template, slug: slug)
+      #
+      #     Rails.logger.info('Content has been set')
+      #   end
+      class NoParagraphs < Cop
+        MSG = 'Method has many instructions and should be broken up into paragraphs.'
+        MAX_CONSECUTIVE_INSTRUCTIONS_ALLOWED = 5
+
+        def on_def(node)
+          lines = processed_source.lines[node.first_line..(node.last_line - 2)]
+          return if lines.any?(&:blank?)
+          node_body_type = node&.body&.type
+          return if %i[send if or case array hash].include?(node_body_type)
+          return if %w[asgn str].any? { |string| node_body_type.to_s.include?(string) }
+
+          too_big =
+            case node_body_type
+            when :begin, :block, :rescue
+              node.body.children.count > MAX_CONSECUTIVE_INSTRUCTIONS_ALLOWED &&
+                !node.body.children.all? { |child| child.type.to_s.include?('asgn') }
+            else
+              lines.count > MAX_CONSECUTIVE_INSTRUCTIONS_ALLOWED
+            end
+
+          add_offense(node) if too_big
+        end
+        alias_method :on_defs, :on_def
+      end
+    end
+  end
+end

data/lib/rubocop/cop/obsession/no_todos.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Obsession
+      # This cop checks for TODO/FIXME/etc comments.
+      #
+      # Avoid TODO comments, instead create tasks for them in your project
+      # management software, and assign them to the right person. Half of the
+      # TODOs usually never get done, and the code is then polluted with old
+      # stale TODOs. Sometimes developers really mean to work on their TODOs
+      # soon, but then Product re-prioritizes their work, or the developer
+      # leaves the company, and never gets a chance to tackle them.
+      class NoTodos < Cop
+        MSG = 'Avoid TODO comment, create a task in your project management tool instead.'
+        KEYWORD_REGEX = /(^|[^\w])(TODO|FIXME|OPTIMIZE|HACK)($|[^\w])/i
+
+        def on_new_investigation
+          processed_source.comments.each do |comment|
+            add_offense(comment) if comment.text.match?(KEYWORD_REGEX)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Obsession
+      module Rails
+        # This cop checks for Rails callbacks with multiple fields.
+        #
+        # One method per callback definition makes the definition extra clear.
+        #
+        # @example
+        #
+        #   # bad
+        #   after_create :notify_followers, :send_stats
+        #
+        #   # good
+        #   after_create :notify_followers
+        #   after_create :send_stats
+        class CallbackOneMethod < Cop
+          include Helpers
+
+          MSG = 'Declare only one method per callback definition.'
+
+          def_node_matcher :on_callback, <<~PATTERN
+            (send nil? $_ (sym _) (sym _) ...)
+          PATTERN
+
+          def on_send(node)
+            on_callback(node) { |callback| add_offense(node) if rails_callback?(callback.to_s) }
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Obsession
+      module Rails
+        # This cop checks for json(b) fields that are not fully defined with
+        # defaults or comments.
+        #
+        # - json(b) fields should have a default value like {} or [] so code can
+        # do my_field['field'] or my_field.first without fear that my_field is
+        # nil.
+        # - It is impossible to know the structure of a json(b) field just by
+        # reading the schema, because json(b) is an unstructured type. That's why
+        # an "Example: ..." Postgres comment should always be present when
+        # defining the field.
+        #
+        # @example
+        #
+        #   # bad
+        #   add_column :languages, :items, :jsonb
+        #
+        #   # good
+        #   add_column :languages,
+        #              :items,
+        #              :jsonb,
+        #              default: [],
+        #              comment: "Example: [{ 'name': 'ruby' }, { 'name': 'python' }]"
+        class FullyDefinedJsonField < Cop
+          def_node_matcher :json_field?, <<~PATTERN
+            (send nil? :add_column _ _ (sym {:json :jsonb}) ...)
+          PATTERN
+
+          def_node_matcher :has_default?, <<~PATTERN
+            (hash <(pair (sym :default) ...) ...>)
+          PATTERN
+
+          def_node_matcher :has_comment_with_example?, <<~PATTERN
+            (hash <
+              (pair
+                (sym :comment)
+                `{
+                  (str /^Example: [\\[\\{].{4,}[\\]\\}]/) |
+                  (dstr (str /^Example: [\\[\\{]/) ... (str /[\\]\\}]/) )
+                }
+              )
+              ...
+            >)
+          PATTERN
+
+          def on_send(node)
+            return if !json_field?(node)
+            options_node = node.children[5]
+
+            if !has_default?(options_node)
+              add_offense(node, message: 'Add default value of {} or []')
+            end
+
+            if !has_comment_with_example?(options_node)
+              add_offense(
+                node,
+                message:
+                  'Add `comment: "Example: <example>"` option with an example array or hash value'
+              )
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Obsession
+      module Rails
+        # This cop checks for migrations that use `references` instead of `belongs_to`.
+        #
+        # Instead of adding `references` in migrations, use the `belongs_to`
+        # alias. It reads nicer and is more similar to the `belongs_to`
+        # declarations that you find in model code.
+        #
+        # @example
+        #
+        #   # bad
+        #   def change
+        #     add_reference :blog_posts, :user
+        #   end
+        #
+        #   # good
+        #   def change
+        #     add_belongs_to :blog_posts, :user
+        #   end
+        class MigrationBelongsTo < Cop
+          def_node_matcher :add_reference?, <<~PATTERN
+            (send nil? :add_reference ...)
+          PATTERN
+
+          def_node_matcher :table_reference?, <<~PATTERN
+            (send (lvar :t) :references ...)
+          PATTERN
+
+          def on_send(node)
+            if add_reference?(node)
+              add_offense(node, message: 'Use add_belongs_to instead of add_reference')
+            elsif table_reference?(node)
+              add_offense(node, message: 'Use t.belongs_to instead of t.references')
+            end
+          end
+        end
+      end
+    end
+  end
+end