rubbycop 0.49.0

data/lib/rubbycop/cop/layout/align_parameters.rb

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  module Cop
+    module Layout
+      # Here we check if the parameters on a multi-line method call or
+      # definition are aligned.
+      #
+      # @example
+      #
+      #   # EnforcedStyle: with_first_parameter
+      #
+      #   # good
+      #
+      #   foo :bar,
+      #       :baz
+      #
+      #   # bad
+      #
+      #   foo :bar,
+      #     :baz
+      #
+      # @example
+      #
+      #   # EnforcedStyle: with_fixed_indentation
+      #
+      #   # good
+      #
+      #   foo :bar,
+      #     :baz
+      #
+      #   # bad
+      #
+      #   foo :bar,
+      #       :baz
+      class AlignParameters < Cop
+        include AutocorrectAlignment
+        include OnMethodDef
+
+        ALIGN_PARAMS_MSG = 'Align the parameters of a method %s if they span ' \
+          'more than one line.'.freeze
+
+        FIXED_INDENT_MSG = 'Use one level of indentation for parameters ' \
+          'following the first line of a multi-line method %s.'.freeze
+
+        def on_send(node)
+          return if node.arguments.size < 2 || node.method?(:[]=)
+
+          check_alignment(node.arguments, base_column(node, node.arguments))
+        end
+
+        def on_method_def(node, _method_name, args, _body)
+          args = args.children
+
+          return if args.size < 2
+
+          check_alignment(args, base_column(node, args))
+        end
+
+        def message(node)
+          type = node && node.parent.send_type? ? 'call' : 'definition'
+          msg = fixed_indentation? ? FIXED_INDENT_MSG : ALIGN_PARAMS_MSG
+
+          format(msg, type)
+        end
+
+        private
+
+        def fixed_indentation?
+          cop_config['EnforcedStyle'] == 'with_fixed_indentation'
+        end
+
+        def base_column(node, args)
+          if fixed_indentation?
+            lineno = target_method_lineno(node)
+            line = node.source_range.source_buffer.source_line(lineno)
+            indentation_of_line = /\S.*/.match(line).begin(0)
+            indentation_of_line + configured_indentation_width
+          else
+            display_column(args.first.source_range)
+          end
+        end
+
+        def target_method_lineno(node)
+          if node.def_type? || node.defs_type?
+            node.loc.keyword.line
+          elsif node.loc.selector
+            node.loc.selector.line
+          else
+            # l.(1) has no selector, so we use the opening parenthesis instead
+            node.loc.begin.line
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubbycop/cop/layout/block_end_newline.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  module Cop
+    module Layout
+      # This cop checks whether the end statement of a do..end block
+      # is on its own line.
+      #
+      # @example
+      #   # bad
+      #   blah do |i|
+      #     foo(i) end
+      #
+      #   # good
+      #   blah do |i|
+      #     foo(i)
+      #   end
+      #
+      #   # bad
+      #   blah { |i|
+      #     foo(i) }
+      #
+      #   # good
+      #   blah { |i|
+      #     foo(i)
+      #   }
+      class BlockEndNewline < Cop
+        MSG = 'Expression at %d, %d should be on its own line.'.freeze
+
+        def on_block(node)
+          end_loc = node.loc.end
+          do_loc = node.loc.begin # Actually it's either do or {.
+          return if do_loc.line == end_loc.line # Ignore one-liners.
+
+          # If the end is on its own line, there is no offense
+          return if end_loc.source_line =~ /^\s*#{end_loc.source}/
+
+          msg = format(MSG, end_loc.line, end_loc.column + 1)
+          add_offense(node, end_loc, msg)
+        end
+
+        def autocorrect(node)
+          lambda do |corrector|
+            indentation = indentation_of_block_start_line(node)
+            corrector.insert_before(node.loc.end, "\n" + (' ' * indentation))
+          end
+        end
+
+        def indentation_of_block_start_line(node)
+          match = /\S.*/.match(node.loc.begin.source_line)
+          match.begin(0)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,163 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  module Cop
+    module Layout
+      # This cop checks how the *when*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*.
+      #
+      # @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
+      #
+      #   # good for all styles
+      #   case n
+      #   when 0
+      #     x * 2
+      #   else
+      #     y / 3
+      #   end
+      #
+      # @example
+      #   # if EndAlignment is set to other style such as
+      #   # start_of_line (as shown below), then *when* alignment
+      #   # configuration does have an effect.
+      #
+      #   # EnforcedStyle: case (default)
+      #
+      #   # bad
+      #   a = case n
+      #   when 0
+      #     x * 2
+      #   else
+      #     y / 3
+      #   end
+      #
+      #   # good
+      #   a = case n
+      #       when 0
+      #         x * 2
+      #       else
+      #         y / 3
+      #   end
+      #
+      #   # EnforcedStyle: end
+      #
+      #   # bad
+      #   a = case n
+      #       when 0
+      #         x * 2
+      #       else
+      #         y / 3
+      #   end
+      #
+      #   # good
+      #   a = case n
+      #   when 0
+      #     x * 2
+      #   else
+      #     y / 3
+      #   end
+      class CaseIndentation < Cop
+        include AutocorrectAlignment
+        include ConfigurableEnforcedStyle
+
+        MSG = 'Indent `when` %s `%s`.'.freeze
+
+        def on_case(case_node)
+          return if case_node.single_line?
+
+          case_node.each_when do |when_node|
+            check_when(when_node)
+          end
+        end
+
+        private
+
+        def check_when(when_node)
+          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)
+          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)
+          when_column = when_node.loc.keyword.column
+          base_column = base_column(when_node.parent, alternative_style)
+
+          add_offense(when_node, :keyword, message(style)) do
+            if when_column == base_column
+              opposite_style_detected
+            else
+              unrecognized_style_detected
+            end
+          end
+        end
+
+        def message(base)
+          depth = indent_one_step? ? 'one step more than' : 'as deep as'
+
+          format(MSG, depth, base)
+        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 autocorrect(node)
+          whitespace = whitespace_range(node)
+
+          return false unless whitespace.source.strip.empty?
+
+          lambda do |corrector|
+            corrector.replace(whitespace, replacement(node))
+          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).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/rubbycop/cop/layout/closing_parenthesis_indentation.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  module Cop
+    module Layout
+      # This cops checks the indentation of hanging closing parentheses in
+      # method calls, method definitions, and grouped expressions. A hanging
+      # closing parenthesis means `)` preceded by a line break.
+      #
+      # @example
+      #
+      #   # good: when x is on its own line, indent this way
+      #   func(
+      #     x,
+      #     y
+      #   )
+      #
+      #   # good: when x follows opening parenthesis, align parentheses
+      #   a = b * (x +
+      #            y
+      #           )
+      #
+      #   # bad
+      #   def func(
+      #     x,
+      #     y
+      #     )
+      class ClosingParenthesisIndentation < Cop
+        include AutocorrectAlignment
+        include OnMethodDef
+
+        MSG_INDENT =
+          'Indent `)` the same as the start of the line where `(` is.'.freeze
+        MSG_ALIGN = 'Align `)` with `(`.'.freeze
+
+        def on_send(node)
+          check(node, node.arguments)
+        end
+
+        def on_begin(node)
+          check(node, node.children)
+        end
+
+        private
+
+        def on_method_def(_node, _method_name, args, _body)
+          check(args, args.children)
+        end
+
+        def check(node, elements)
+          right_paren = node.loc.end
+
+          return unless right_paren && begins_its_line?(right_paren)
+
+          correct_column = expected_column(node, elements)
+          @column_delta = correct_column - right_paren.column
+
+          return if @column_delta.zero?
+
+          left_paren = node.loc.begin
+          msg = correct_column == left_paren.column ? MSG_ALIGN : MSG_INDENT
+
+          add_offense(right_paren, right_paren, msg)
+        end
+
+        def expected_column(node, elements)
+          left_paren = node.loc.begin
+
+          if node.send_type? && fixed_parameter_indentation? ||
+             line_break_after_left_paren?(left_paren, elements)
+            left_paren.source_line =~ /\S/
+          else
+            left_paren.column
+          end
+        end
+
+        def fixed_parameter_indentation?
+          config.for_cop('Layout/AlignParameters')['EnforcedStyle'] ==
+            'with_fixed_indentation'
+        end
+
+        def line_break_after_left_paren?(left_paren, elements)
+          elements.first && elements.first.loc.line > left_paren.line
+        end
+      end
+    end
+  end
+end

data/lib/rubbycop/cop/layout/comment_indentation.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  module Cop
+    module Layout
+      # This cops checks the indentation of comments.
+      class CommentIndentation < Cop
+        include AutocorrectAlignment
+
+        MSG = 'Incorrect indentation detected (column %d instead of %d).'.freeze
+
+        def investigate(processed_source)
+          processed_source.comments.each { |comment| check(comment) }
+        end
+
+        private
+
+        def check(comment)
+          return unless own_line_comment?(comment)
+
+          next_line = line_after_comment(comment)
+          correct_comment_indentation = correct_indentation(next_line)
+          column = comment.loc.column
+
+          @column_delta = correct_comment_indentation - column
+          return if @column_delta.zero?
+
+          if two_alternatives?(next_line)
+            # Try the other
+            correct_comment_indentation += configured_indentation_width
+            # We keep @column_delta unchanged so that autocorrect changes to
+            # the preferred style of aligning the comment with the keyword.
+            return if column == correct_comment_indentation
+          end
+
+          add_offense(comment, comment.loc.expression,
+                      format(MSG, column, correct_comment_indentation))
+        end
+
+        def own_line_comment?(comment)
+          own_line = processed_source.lines[comment.loc.line - 1]
+          own_line =~ /\A\s*#/
+        end
+
+        def line_after_comment(comment)
+          lines = processed_source.lines
+          lines[comment.loc.line..-1].find { |line| !line.blank? }
+        end
+
+        def correct_indentation(next_line)
+          return 0 unless next_line
+
+          indentation_of_next_line = next_line =~ /\S/
+          indentation_of_next_line + if less_indented?(next_line)
+                                       configured_indentation_width
+                                     else
+                                       0
+                                     end
+        end
+
+        def less_indented?(line)
+          line =~ /^\s*(end\b|[)}\]])/
+        end
+
+        def two_alternatives?(line)
+          line =~ /^\s*(else|elsif|when|rescue|ensure)\b/
+        end
+      end
+    end
+  end
+end