rubocop-grantbirki 1.75.2

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

@@ -0,0 +1,139 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Layout
+      # Checks if empty lines exist around the bodies of `begin`
+      # sections. This cop doesn't check empty lines at `begin` body
+      # beginning/end and around method definition body.
+      # `Layout/EmptyLinesAroundBeginBody` or `Layout/EmptyLinesAroundMethodBody`
+      # can be used for this purpose.
+      #
+      # @example
+      #
+      #   # good
+      #
+      #   begin
+      #     do_something
+      #   rescue
+      #     do_something2
+      #   else
+      #     do_something3
+      #   ensure
+      #     do_something4
+      #   end
+      #
+      #   # good
+      #
+      #   def foo
+      #     do_something
+      #   rescue
+      #     do_something2
+      #   end
+      #
+      #   # bad
+      #
+      #   begin
+      #     do_something
+      #
+      #   rescue
+      #
+      #     do_something2
+      #
+      #   else
+      #
+      #     do_something3
+      #
+      #   ensure
+      #
+      #     do_something4
+      #   end
+      #
+      #   # bad
+      #
+      #   def foo
+      #     do_something
+      #
+      #   rescue
+      #
+      #     do_something2
+      #   end
+      class EmptyLinesAroundExceptionHandlingKeywords < Base
+        include EmptyLinesAroundBody
+        extend AutoCorrector
+
+        MSG = 'Extra empty line detected %<location>s the `%<keyword>s`.'
+
+        def on_def(node)
+          check_body(node.body, node.loc.line)
+        end
+        alias on_defs on_def
+        alias on_block on_def
+        alias on_numblock on_def
+
+        def on_kwbegin(node)
+          check_body(node.children.first, node.loc.line)
+        end
+
+        private
+
+        def check_body(body, line_of_def_or_kwbegin)
+          locations = keyword_locations(body)
+
+          locations.each do |loc|
+            line = loc.line
+            next if line == line_of_def_or_kwbegin || last_body_and_end_on_same_line?(body)
+
+            keyword = loc.source
+            # below the keyword
+            check_line(style, line, message('after', keyword), &:empty?)
+            # above the keyword
+            check_line(style, line - 2, message('before', keyword), &:empty?)
+          end
+        end
+
+        def last_body_and_end_on_same_line?(body)
+          end_keyword_line = body.parent.loc.end.line
+          return body.loc.last_line == end_keyword_line unless body.rescue_type?
+
+          last_body_line = body.else? ? body.loc.else.line : body.resbody_branches.last.loc.line
+
+          last_body_line == end_keyword_line
+        end
+
+        def message(location, keyword)
+          format(MSG, location: location, keyword: keyword)
+        end
+
+        def style
+          :no_empty_lines
+        end
+
+        def keyword_locations(node)
+          return [] unless node
+
+          case node.type
+          when :rescue
+            keyword_locations_in_rescue(node)
+          when :ensure
+            keyword_locations_in_ensure(node)
+          else
+            []
+          end
+        end
+
+        def keyword_locations_in_rescue(node)
+          [node.loc.else, *node.resbody_branches.map { |body| body.loc.keyword }].compact
+        end
+
+        def keyword_locations_in_ensure(node)
+          rescue_body_without_ensure = node.children.first
+          [
+            node.loc.keyword,
+            *keyword_locations(rescue_body_without_ensure)
+          ]
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Layout
+      # Checks if empty lines exist around the bodies of methods.
+      #
+      # @example
+      #
+      #   # good
+      #
+      #   def foo
+      #     # ...
+      #   end
+      #
+      #   # bad
+      #
+      #   def bar
+      #
+      #     # ...
+      #
+      #   end
+      class EmptyLinesAroundMethodBody < Base
+        include EmptyLinesAroundBody
+        extend AutoCorrector
+
+        KIND = 'method'
+
+        def on_def(node)
+          if node.endless?
+            return unless offending_endless_method?(node)
+
+            register_offense_for_endless_method(node)
+          else
+            first_line = node.arguments.source_range&.last_line
+            check(node, node.body, adjusted_first_line: first_line)
+          end
+        end
+        alias on_defs on_def
+
+        private
+
+        def style
+          :no_empty_lines
+        end
+
+        def offending_endless_method?(node)
+          node.body.first_line > node.loc.assignment.line + 1 &&
+            processed_source.lines[node.loc.assignment.line].empty?
+        end
+
+        def register_offense_for_endless_method(node)
+          range = processed_source.buffer.line_range(node.loc.assignment.line + 1).resize(1)
+
+          msg = message(MSG_EXTRA, 'beginning')
+
+          add_offense(range, message: msg) do |corrector|
+            corrector.remove(range)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Layout
+      # Checks if empty lines around the bodies of modules match
+      # the configuration.
+      #
+      # @example EnforcedStyle: no_empty_lines (default)
+      #   # good
+      #
+      #   module Foo
+      #     def bar
+      #       # ...
+      #     end
+      #   end
+      #
+      # @example EnforcedStyle: empty_lines
+      #   # good
+      #
+      #   module Foo
+      #
+      #     def bar
+      #       # ...
+      #     end
+      #
+      #   end
+      #
+      # @example EnforcedStyle: empty_lines_except_namespace
+      #   # good
+      #
+      #   module Foo
+      #     module Bar
+      #
+      #       # ...
+      #
+      #     end
+      #   end
+      #
+      # @example EnforcedStyle: empty_lines_special
+      #   # good
+      #   module Foo
+      #
+      #     def bar; end
+      #
+      #   end
+      class EmptyLinesAroundModuleBody < Base
+        include EmptyLinesAroundBody
+        extend AutoCorrector
+
+        KIND = 'module'
+
+        def on_module(node)
+          check(node, node.body)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,210 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Layout
+      # Checks whether the end keywords are aligned properly.
+      #
+      # Three modes are supported through the `EnforcedStyleAlignWith`
+      # configuration parameter:
+      #
+      # If it's set to `keyword` (which is the default), the `end`
+      # shall be aligned with the start of the keyword (if, class, etc.).
+      #
+      # If it's set to `variable` the `end` shall be aligned with the
+      # left-hand-side of the variable assignment, if there is one.
+      #
+      # If it's set to `start_of_line`, the `end` shall be aligned with the
+      # start of the line where the matching keyword appears.
+      #
+      # This `Layout/EndAlignment` cop aligns with keywords (e.g. `if`, `while`, `case`)
+      # by default. On the other hand, `Layout/BeginEndAlignment` cop aligns with
+      # `EnforcedStyleAlignWith: start_of_line` by default due to `||= begin` tends
+      # to align with the start of the line. `Layout/DefEndAlignment` cop also aligns with
+      # `EnforcedStyleAlignWith: start_of_line` by default.
+      # These style can be configured by each cop.
+      #
+      # @example EnforcedStyleAlignWith: keyword (default)
+      #   # bad
+      #
+      #   variable = if true
+      #       end
+      #
+      #   # good
+      #
+      #   variable = if true
+      #              end
+      #
+      #   variable =
+      #     if true
+      #     end
+      #
+      # @example EnforcedStyleAlignWith: variable
+      #   # bad
+      #
+      #   variable = if true
+      #       end
+      #
+      #   # good
+      #
+      #   variable = if true
+      #   end
+      #
+      #   variable =
+      #     if true
+      #     end
+      #
+      # @example EnforcedStyleAlignWith: start_of_line
+      #   # bad
+      #
+      #   variable = if true
+      #       end
+      #
+      #   puts(if true
+      #        end)
+      #
+      #   # good
+      #
+      #   variable = if true
+      #   end
+      #
+      #   puts(if true
+      #   end)
+      #
+      #   variable =
+      #     if true
+      #     end
+      class EndAlignment < Base
+        include CheckAssignment
+        include EndKeywordAlignment
+        include RangeHelp
+        extend AutoCorrector
+
+        def on_class(node)
+          check_other_alignment(node)
+        end
+
+        def on_sclass(node)
+          if node.parent&.assignment?
+            check_asgn_alignment(node.parent, node)
+          else
+            check_other_alignment(node)
+          end
+        end
+
+        def on_module(node)
+          check_other_alignment(node)
+        end
+
+        def on_if(node)
+          check_other_alignment(node) unless node.ternary?
+        end
+
+        def on_while(node)
+          check_other_alignment(node)
+        end
+
+        def on_until(node)
+          check_other_alignment(node)
+        end
+
+        def on_case(node)
+          if node.argument?
+            check_asgn_alignment(node.parent, node)
+          else
+            check_other_alignment(node)
+          end
+        end
+        alias on_case_match on_case
+
+        private
+
+        def autocorrect(corrector, node)
+          AlignmentCorrector.align_end(corrector, processed_source, node, alignment_node(node))
+        end
+
+        def check_assignment(node, rhs)
+          # If there are method calls chained to the right hand side of the
+          # assignment, we let rhs be the receiver of those method calls before
+          # we check if it's an if/unless/while/until.
+          return unless (rhs = first_part_of_call_chain(rhs))
+          return unless rhs.conditional?
+          return if rhs.if_type? && rhs.ternary?
+
+          check_asgn_alignment(node, rhs)
+        end
+
+        def check_asgn_alignment(outer_node, inner_node)
+          align_with = {
+            keyword: inner_node.loc.keyword,
+            start_of_line: start_line_range(inner_node),
+            variable: asgn_variable_align_with(outer_node, inner_node)
+          }
+
+          check_end_kw_alignment(inner_node, align_with)
+          ignore_node(inner_node)
+        end
+
+        def asgn_variable_align_with(outer_node, inner_node)
+          expr = outer_node.source_range
+
+          if line_break_before_keyword?(expr, inner_node)
+            inner_node.loc.keyword
+          else
+            range_between(expr.begin_pos, inner_node.loc.keyword.end_pos)
+          end
+        end
+
+        def check_other_alignment(node)
+          align_with = {
+            keyword: node.loc.keyword,
+            variable: node.loc.keyword,
+            start_of_line: start_line_range(node)
+          }
+          check_end_kw_alignment(node, align_with)
+        end
+
+        def alignment_node(node)
+          case style
+          when :keyword
+            node
+          when :variable
+            align_to = alignment_node_for_variable_style(node)
+
+            while (parent = align_to.parent) && parent.send_type? && same_line?(align_to, parent)
+              align_to = parent
+            end
+
+            align_to
+          else
+            start_line_range(node)
+          end
+        end
+
+        def alignment_node_for_variable_style(node)
+          if node.type?(:case, :case_match) && node.argument? &&
+             same_line?(node, node.parent)
+            return node.parent
+          end
+
+          assignment = assignment_or_operator_method(node)
+
+          if assignment && !line_break_before_keyword?(assignment.source_range, node)
+            assignment
+          else
+            # Fall back to 'keyword' style if this node is not on the RHS of an
+            # assignment, or if it is but there's a line break between LHS and
+            # RHS.
+            node
+          end
+        end
+
+        def assignment_or_operator_method(node)
+          node.ancestors.find do |ancestor|
+            ancestor.assignment_or_similar? || (ancestor.send_type? && ancestor.operator_method?)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Layout
+      # Checks for Windows-style line endings in the source code.
+      #
+      # @example EnforcedStyle: native (default)
+      #   # The `native` style means that CR+LF (Carriage Return + Line Feed) is
+      #   # enforced on Windows, and LF is enforced on other platforms.
+      #
+      #   # bad
+      #   puts 'Hello' # Return character is LF on Windows.
+      #   puts 'Hello' # Return character is CR+LF on other than Windows.
+      #
+      #   # good
+      #   puts 'Hello' # Return character is CR+LF on Windows.
+      #   puts 'Hello' # Return character is LF on other than Windows.
+      #
+      # @example EnforcedStyle: lf
+      #   # The `lf` style means that LF (Line Feed) is enforced on
+      #   # all platforms.
+      #
+      #   # bad
+      #   puts 'Hello' # Return character is CR+LF on all platforms.
+      #
+      #   # good
+      #   puts 'Hello' # Return character is LF on all platforms.
+      #
+      # @example EnforcedStyle: crlf
+      #   # The `crlf` style means that CR+LF (Carriage Return + Line Feed) is
+      #   # enforced on all platforms.
+      #
+      #   # bad
+      #   puts 'Hello' # Return character is LF on all platforms.
+      #
+      #   # good
+      #   puts 'Hello' # Return character is CR+LF on all platforms.
+      #
+      class EndOfLine < Base
+        include ConfigurableEnforcedStyle
+        include RangeHelp
+
+        MSG_DETECTED = 'Carriage return character detected.'
+        MSG_MISSING = 'Carriage return character missing.'
+
+        def on_new_investigation
+          last_line = last_line(processed_source)
+
+          processed_source.raw_source.each_line.with_index do |line, index|
+            break if index >= last_line
+
+            msg = offense_message(line)
+            next unless msg
+            next if unimportant_missing_cr?(index, last_line, line)
+
+            range = source_range(processed_source.buffer, index + 1, 0, line.length)
+
+            add_offense(range, message: msg)
+            # Usually there will be carriage return characters on all or none
+            # of the lines in a file, so we report only one offense.
+            break
+          end
+        end
+
+        # If there is no LF on the last line, we don't care if there's no CR.
+        def unimportant_missing_cr?(index, last_line, line)
+          style == :crlf && index == last_line - 1 && !line.end_with?("\n")
+        end
+
+        def offense_message(line)
+          effective_style = if style == :native
+                              Platform.windows? ? :crlf : :lf
+                            else
+                              style
+                            end
+          case effective_style
+          when :lf then MSG_DETECTED if line.end_with?("\r", "\r\n")
+          else MSG_MISSING unless line.end_with?("\r\n")
+          end
+        end
+
+        private
+
+        def last_line(processed_source)
+          last_token = processed_source.tokens.last
+          last_token ? last_token.line : processed_source.lines.length
+        end
+      end
+    end
+  end
+end