rubocop-grantbirki 1.75.2

data/lib/rubocop/cop/layout/case_indentation.rb

@@ -0,0 +1,219 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Layout
+      # Checks how the `when` and ``in``s of a `case` expression
+      # are indented in relation to its `case` or `end` keyword.
+      #
+      # It will register a separate offense for each misaligned `when` and `in`.
+      #
+      # @example
+      #   # If Layout/EndAlignment is set to keyword style (default)
+      #   # *case* and *end* should always be aligned to same depth,
+      #   # and therefore *when* should always be aligned to both -
+      #   # regardless of configuration.
+      #
+      #   # bad for all styles
+      #   case n
+      #     when 0
+      #       x * 2
+      #     else
+      #       y / 3
+      #   end
+      #
+      #   case n
+      #     in pattern
+      #       x * 2
+      #     else
+      #       y / 3
+      #   end
+      #
+      #   # good for all styles
+      #   case n
+      #   when 0
+      #     x * 2
+      #   else
+      #     y / 3
+      #   end
+      #
+      #   case n
+      #   in pattern
+      #     x * 2
+      #   else
+      #     y / 3
+      #   end
+      #
+      # @example EnforcedStyle: case (default)
+      #   # if EndAlignment is set to other style such as
+      #   # start_of_line (as shown below), then *when* alignment
+      #   # configuration does have an effect.
+      #
+      #   # bad
+      #   a = case n
+      #   when 0
+      #     x * 2
+      #   else
+      #     y / 3
+      #   end
+      #
+      #   a = case n
+      #   in pattern
+      #     x * 2
+      #   else
+      #     y / 3
+      #   end
+      #
+      #   # good
+      #   a = case n
+      #       when 0
+      #         x * 2
+      #       else
+      #         y / 3
+      #   end
+      #
+      #   a = case n
+      #       in pattern
+      #         x * 2
+      #       else
+      #         y / 3
+      #   end
+      #
+      # @example EnforcedStyle: end
+      #   # bad
+      #   a = case n
+      #       when 0
+      #         x * 2
+      #       else
+      #         y / 3
+      #   end
+      #
+      #   a = case n
+      #       in pattern
+      #         x * 2
+      #       else
+      #         y / 3
+      #   end
+      #
+      #   # good
+      #   a = case n
+      #   when 0
+      #     x * 2
+      #   else
+      #     y / 3
+      #   end
+      #
+      #   a = case n
+      #   in pattern
+      #     x * 2
+      #   else
+      #     y / 3
+      #   end
+      class CaseIndentation < Base
+        include Alignment
+        include ConfigurableEnforcedStyle
+        include RangeHelp
+        extend AutoCorrector
+
+        MSG = 'Indent `%<branch_type>s` %<depth>s `%<base>s`.'
+
+        def on_case(case_node)
+          return if case_node.single_line?
+          return if enforced_style_end? && end_and_last_conditional_same_line?(case_node)
+
+          case_node.when_branches.each { |when_node| check_when(when_node, 'when') }
+        end
+
+        def on_case_match(case_match_node)
+          return if case_match_node.single_line?
+          return if enforced_style_end? && end_and_last_conditional_same_line?(case_match_node)
+
+          case_match_node.each_in_pattern { |in_pattern_node| check_when(in_pattern_node, 'in') }
+        end
+
+        private
+
+        def end_and_last_conditional_same_line?(node)
+          end_line = node.loc.end&.line
+          last_conditional_line = if node.loc.else
+                                    node.loc.else.line
+                                  else
+                                    node.child_nodes.last.loc.begin&.line
+                                  end
+          end_line && last_conditional_line && end_line == last_conditional_line
+        end
+
+        def enforced_style_end?
+          cop_config[style_parameter_name] == 'end'
+        end
+
+        def check_when(when_node, branch_type)
+          when_column = when_node.loc.keyword.column
+          base_column = base_column(when_node.parent, style)
+
+          if when_column == base_column + indentation_width
+            correct_style_detected
+          else
+            incorrect_style(when_node, branch_type)
+          end
+        end
+
+        def indent_one_step?
+          cop_config['IndentOneStep']
+        end
+
+        def indentation_width
+          indent_one_step? ? configured_indentation_width : 0
+        end
+
+        def incorrect_style(when_node, branch_type)
+          depth = indent_one_step? ? 'one step more than' : 'as deep as'
+          message = format(MSG, branch_type: branch_type, depth: depth, base: style)
+
+          add_offense(when_node.loc.keyword, message: message) do |corrector|
+            detect_incorrect_style(when_node)
+
+            whitespace = whitespace_range(when_node)
+
+            corrector.replace(whitespace, replacement(when_node)) if whitespace.source.strip.empty?
+          end
+        end
+
+        def detect_incorrect_style(when_node)
+          when_column = when_node.loc.keyword.column
+          base_column = base_column(when_node.parent, alternative_style)
+
+          if when_column == base_column
+            opposite_style_detected
+          else
+            unrecognized_style_detected
+          end
+        end
+
+        def base_column(case_node, base)
+          case base
+          when :case then case_node.location.keyword.column
+          when :end  then case_node.location.end.column
+          end
+        end
+
+        def whitespace_range(node)
+          when_column = node.location.keyword.column
+          begin_pos = node.loc.keyword.begin_pos
+
+          range_between(begin_pos - when_column, begin_pos)
+        end
+
+        def replacement(node)
+          case_node = node.each_ancestor(:case, :case_match).first
+          base_type = cop_config[style_parameter_name] == 'end' ? :end : :case
+
+          column = base_column(case_node, base_type)
+          column += indentation_width
+
+          ' ' * column
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/layout/class_structure.rb

@@ -0,0 +1,346 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Layout
+      # Checks if the code style follows the `ExpectedOrder` configuration:
+      #
+      # `Categories` allows us to map macro names into a category.
+      #
+      # Consider an example of code style that covers the following order:
+      #
+      # * Module inclusion (`include`, `prepend`, `extend`)
+      # * Constants
+      # * Associations (`has_one`, `has_many`)
+      # * Public attribute macros (`attr_accessor`, `attr_writer`, `attr_reader`)
+      # * Other macros (`validates`, `validate`)
+      # * Public class methods
+      # * Initializer
+      # * Public instance methods
+      # * Protected attribute macros (`attr_accessor`, `attr_writer`, `attr_reader`)
+      # * Protected instance methods
+      # * Private attribute macros (`attr_accessor`, `attr_writer`, `attr_reader`)
+      # * Private instance methods
+      #
+      # You can configure the following order:
+      #
+      # [source,yaml]
+      # ----
+      #  Layout/ClassStructure:
+      #    ExpectedOrder:
+      #      - module_inclusion
+      #      - constants
+      #      - association
+      #      - public_attribute_macros
+      #      - public_delegate
+      #      - macros
+      #      - public_class_methods
+      #      - initializer
+      #      - public_methods
+      #      - protected_attribute_macros
+      #      - protected_methods
+      #      - private_attribute_macros
+      #      - private_delegate
+      #      - private_methods
+      # ----
+      #
+      # Instead of putting all literals in the expected order, is also
+      # possible to group categories of macros. Visibility levels are handled
+      # automatically.
+      #
+      # [source,yaml]
+      # ----
+      #  Layout/ClassStructure:
+      #    Categories:
+      #      association:
+      #        - has_many
+      #        - has_one
+      #      attribute_macros:
+      #        - attr_accessor
+      #        - attr_reader
+      #        - attr_writer
+      #      macros:
+      #        - validates
+      #        - validate
+      #      module_inclusion:
+      #        - include
+      #        - prepend
+      #        - extend
+      # ----
+      #
+      # @safety
+      #   Autocorrection is unsafe because class methods and module inclusion
+      #   can behave differently, based on which methods or constants have
+      #   already been defined.
+      #
+      #   Constants will only be moved when they are assigned with literals.
+      #
+      # @example
+      #   # bad
+      #   # Expect extend be before constant
+      #   class Person < ApplicationRecord
+      #     has_many :orders
+      #     ANSWER = 42
+      #
+      #     extend SomeModule
+      #     include AnotherModule
+      #   end
+      #
+      #   # good
+      #   class Person
+      #     # extend and include go first
+      #     extend SomeModule
+      #     include AnotherModule
+      #
+      #     # inner classes
+      #     CustomError = Class.new(StandardError)
+      #
+      #     # constants are next
+      #     SOME_CONSTANT = 20
+      #
+      #     # afterwards we have public attribute macros
+      #     attr_reader :name
+      #
+      #     # followed by other macros (if any)
+      #     validates :name
+      #
+      #     # then we have public delegate macros
+      #     delegate :to_s, to: :name
+      #
+      #     # public class methods are next in line
+      #     def self.some_method
+      #     end
+      #
+      #     # initialization goes between class methods and instance methods
+      #     def initialize
+      #     end
+      #
+      #     # followed by other public instance methods
+      #     def some_method
+      #     end
+      #
+      #     # protected attribute macros and methods go next
+      #     protected
+      #
+      #     attr_reader :protected_name
+      #
+      #     def some_protected_method
+      #     end
+      #
+      #     # private attribute macros, delegate macros and methods
+      #     # are grouped near the end
+      #     private
+      #
+      #     attr_reader :private_name
+      #
+      #     delegate :some_private_delegate, to: :name
+      #
+      #     def some_private_method
+      #     end
+      #   end
+      #
+      class ClassStructure < Base
+        include VisibilityHelp
+        include CommentsHelp
+        extend AutoCorrector
+
+        HUMANIZED_NODE_TYPE = {
+          casgn: :constants,
+          defs: :public_class_methods,
+          def: :public_methods,
+          sclass: :class_singleton
+        }.freeze
+
+        MSG = '`%<category>s` is supposed to appear before `%<previous>s`.'
+
+        # Validates code style on class declaration.
+        # Add offense when find a node out of expected order.
+        def on_class(class_node)
+          previous = -1
+          walk_over_nested_class_definition(class_node) do |node, category|
+            index = expected_order.index(category)
+            if index < previous
+              message = format(MSG, category: category, previous: expected_order[previous])
+              add_offense(node, message: message) { |corrector| autocorrect(corrector, node) }
+            end
+            previous = index
+          end
+        end
+        alias on_sclass on_class
+
+        private
+
+        # Autocorrect by swapping between two nodes autocorrecting them
+        def autocorrect(corrector, node)
+          previous = node.left_siblings.reverse.find do |sibling|
+            !ignore_for_autocorrect?(node, sibling)
+          end
+          return unless previous
+
+          current_range = source_range_with_comment(node)
+          previous_range = source_range_with_comment(previous)
+
+          corrector.insert_before(previous_range, current_range.source)
+          corrector.remove(current_range)
+        end
+
+        # Classifies a node to match with something in the {expected_order}
+        # @param node to be analysed
+        # @return String when the node type is a `:block` then
+        #   {classify} recursively with the first children
+        # @return String when the node type is a `:send` then {find_category}
+        #   by method name
+        # @return String otherwise trying to {humanize_node} of the current node
+        def classify(node)
+          return node.to_s unless node.respond_to?(:type)
+
+          case node.type
+          when :block
+            classify(node.send_node)
+          when :send
+            find_category(node)
+          else
+            humanize_node(node)
+          end.to_s
+        end
+
+        # Categorize a node according to the {expected_order}
+        # Try to match {categories} values against the node's method_name given
+        # also its visibility.
+        # @param node to be analysed.
+        # @return [String] with the key category or the `method_name` as string
+        def find_category(node)
+          name = node.method_name.to_s
+          category, = categories.find { |_, names| names.include?(name) }
+          key = category || name
+          visibility_key =
+            if node.def_modifier?
+              "#{name}_methods"
+            else
+              "#{node_visibility(node)}_#{key}"
+            end
+          expected_order.include?(visibility_key) ? visibility_key : key
+        end
+
+        def walk_over_nested_class_definition(class_node)
+          class_elements(class_node).each do |node|
+            classification = classify(node)
+            next if ignore?(node, classification)
+
+            yield node, classification
+          end
+        end
+
+        def class_elements(class_node)
+          class_def = class_node.body
+
+          return [] unless class_def
+
+          if class_def.type?(:def, :send)
+            [class_def]
+          else
+            class_def.children.compact
+          end
+        end
+
+        def ignore?(node, classification)
+          classification.nil? ||
+            classification.to_s.end_with?('=') ||
+            expected_order.index(classification).nil? ||
+            private_constant?(node)
+        end
+
+        def ignore_for_autocorrect?(node, sibling)
+          classification = classify(node)
+          sibling_class = classify(sibling)
+
+          ignore?(sibling, sibling_class) ||
+            classification == sibling_class ||
+            dynamic_constant?(node)
+        end
+
+        def humanize_node(node)
+          if node.def_type?
+            return :initializer if node.method?(:initialize)
+
+            return "#{node_visibility(node)}_methods"
+          end
+          HUMANIZED_NODE_TYPE[node.type] || node.type
+        end
+
+        def dynamic_constant?(node)
+          return false unless node.casgn_type? && node.namespace.nil?
+
+          expression = node.expression
+          expression.send_type? &&
+            !(expression.method?(:freeze) && expression.receiver&.recursive_basic_literal?)
+        end
+
+        def private_constant?(node)
+          return false unless node.casgn_type? && node.namespace.nil?
+          return false unless (parent = node.parent)
+
+          parent.each_child_node(:send) do |child_node|
+            return true if marked_as_private_constant?(child_node, node.name)
+          end
+          false
+        end
+
+        def marked_as_private_constant?(node, name)
+          return false unless node.method?(:private_constant)
+
+          node.arguments.any? { |arg| arg.type?(:sym, :str) && arg.value == name }
+        end
+
+        def end_position_for(node)
+          if node.casgn_type?
+            heredoc = find_heredoc(node)
+            return heredoc.location.heredoc_end.end_pos + 1 if heredoc
+          end
+
+          end_line = buffer.line_for_position(node.source_range.end_pos)
+          buffer.line_range(end_line).end_pos
+        end
+
+        def begin_pos_with_comment(node)
+          first_comment = nil
+          (node.first_line - 1).downto(1) do |annotation_line|
+            break unless (comment = processed_source.comment_at_line(annotation_line))
+
+            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)
+          buffer.line_range(node.loc.line).begin_pos - 1
+        end
+
+        def find_heredoc(node)
+          node.each_node(:str, :dstr, :xstr).find(&:heredoc?)
+        end
+
+        def buffer
+          processed_source.buffer
+        end
+
+        # Load expected order from `ExpectedOrder` config.
+        # Define new terms in the expected order by adding new {categories}.
+        def expected_order
+          cop_config['ExpectedOrder']
+        end
+
+        # Setting categories hash allow you to group methods in group to match
+        # in the {expected_order}.
+        def categories
+          cop_config['Categories']
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/layout/closing_heredoc_indentation.rb

@@ -0,0 +1,123 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Layout
+      # Checks the indentation of here document closings.
+      #
+      # @example
+      #
+      #   # bad
+      #   class Foo
+      #     def bar
+      #       <<~SQL
+      #         'Hi'
+      #     SQL
+      #     end
+      #   end
+      #
+      #   # good
+      #   class Foo
+      #     def bar
+      #       <<~SQL
+      #         'Hi'
+      #       SQL
+      #     end
+      #   end
+      #
+      #   # bad
+      #
+      #   # heredoc contents is before closing heredoc.
+      #   foo arg,
+      #       <<~EOS
+      #     Hi
+      #       EOS
+      #
+      #   # good
+      #   foo arg,
+      #       <<~EOS
+      #     Hi
+      #   EOS
+      #
+      #   # good
+      #   foo arg,
+      #       <<~EOS
+      #         Hi
+      #       EOS
+      #
+      class ClosingHeredocIndentation < Base
+        include Heredoc
+        extend AutoCorrector
+
+        SIMPLE_HEREDOC = '<<'
+        MSG = '`%<closing>s` is not aligned with `%<opening>s`.'
+        MSG_ARG = '`%<closing>s` is not aligned with `%<opening>s` or ' \
+                  'beginning of method definition.'
+
+        def on_heredoc(node)
+          return if heredoc_type(node) == SIMPLE_HEREDOC ||
+                    opening_indentation(node) == closing_indentation(node) ||
+                    argument_indentation_correct?(node)
+
+          message = message(node)
+          add_offense(node.loc.heredoc_end, message: message) do |corrector|
+            corrector.replace(node.loc.heredoc_end, indented_end(node))
+          end
+        end
+
+        private
+
+        def opening_indentation(node)
+          indent_level(heredoc_opening(node))
+        end
+
+        def argument_indentation_correct?(node)
+          return false unless node.argument? || node.chained?
+
+          opening_indentation(
+            find_node_used_heredoc_argument(node.parent)
+          ) == closing_indentation(node)
+        end
+
+        def closing_indentation(node)
+          indent_level(heredoc_closing(node))
+        end
+
+        def heredoc_opening(node)
+          node.source_range.source_line
+        end
+
+        def heredoc_closing(node)
+          node.loc.heredoc_end.source_line
+        end
+
+        def indented_end(node)
+          closing_indent = closing_indentation(node)
+          opening_indent = opening_indentation(node)
+          closing_text = heredoc_closing(node)
+          closing_text.gsub(/^\s{#{closing_indent}}/, ' ' * opening_indent)
+        end
+
+        def find_node_used_heredoc_argument(node)
+          if node.parent&.send_type?
+            find_node_used_heredoc_argument(node.parent)
+          else
+            node
+          end
+        end
+
+        def message(node)
+          format(
+            node.argument? ? MSG_ARG : MSG,
+            closing: heredoc_closing(node).strip,
+            opening: heredoc_opening(node).strip
+          )
+        end
+
+        def indent_level(source_line)
+          source_line[/\A */].length
+        end
+      end
+    end
+  end
+end