rubbycop 0.49.0

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

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  module Cop
+    module Layout
+      # This cop checks whether the multiline assignments have a newline
+      # after the assignment operator.
+      #
+      # @example
+      #   # bad (with EnforcedStyle set to new_line)
+      #   foo = if expression
+      #     'bar'
+      #   end
+      #
+      #   # good (with EnforcedStyle set to same_line)
+      #   foo = if expression
+      #     'bar'
+      #   end
+      #
+      #   # good (with EnforcedStyle set to new_line)
+      #   foo =
+      #     if expression
+      #       'bar'
+      #     end
+      #
+      #   # good (with EnforcedStyle set to new_line)
+      #   foo =
+      #     begin
+      #       compute
+      #     rescue => e
+      #       nil
+      #     end
+      class MultilineAssignmentLayout < Cop
+        include CheckAssignment
+        include ConfigurableEnforcedStyle
+
+        NEW_LINE_OFFENSE = 'Right hand side of multi-line assignment is on ' \
+          'the same line as the assignment operator `=`.'.freeze
+
+        SAME_LINE_OFFENSE = 'Right hand side of multi-line assignment is not ' \
+          'on the same line as the assignment operator `=`.'.freeze
+
+        def check_assignment(node, rhs)
+          return unless rhs
+          return unless supported_types.include?(rhs.type)
+          return if rhs.loc.first_line == rhs.loc.last_line
+
+          case style
+          when :new_line
+            check_new_line_offense(node, rhs)
+          when :same_line
+            check_same_line_offense(node, rhs)
+          end
+        end
+
+        def check_new_line_offense(node, rhs)
+          return unless node.loc.operator.line == rhs.loc.line
+
+          add_offense(node, :expression, NEW_LINE_OFFENSE)
+        end
+
+        def check_same_line_offense(node, rhs)
+          return unless node.loc.operator.line != rhs.loc.line
+
+          add_offense(node, :expression, SAME_LINE_OFFENSE)
+        end
+
+        def autocorrect(node)
+          case style
+          when :new_line
+            ->(corrector) { corrector.insert_after(node.loc.operator, "\n") }
+          when :same_line
+            range = range_between(node.loc.operator.end_pos,
+                                  extract_rhs(node).source_range.begin_pos)
+
+            ->(corrector) { corrector.replace(range, ' ') }
+          end
+        end
+
+        private
+
+        def supported_types
+          @supported_types ||= cop_config['SupportedTypes'].map(&:to_sym)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,134 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  module Cop
+    module Layout
+      # This cop checks whether the multiline do end blocks have a newline
+      # after the start of the block. Additionally, it checks whether the block
+      # arguments, if any, are on the same line as the start of the block.
+      #
+      # @example
+      #   # bad
+      #   blah do |i| foo(i)
+      #     bar(i)
+      #   end
+      #
+      #   # bad
+      #   blah do
+      #     |i| foo(i)
+      #     bar(i)
+      #   end
+      #
+      #   # good
+      #   blah do |i|
+      #     foo(i)
+      #     bar(i)
+      #   end
+      #
+      #   # bad
+      #   blah { |i| foo(i)
+      #     bar(i)
+      #   }
+      #
+      #   # good
+      #   blah { |i|
+      #     foo(i)
+      #     bar(i)
+      #   }
+      class MultilineBlockLayout < Cop
+        MSG = 'Block body expression is on the same line as ' \
+              'the block start.'.freeze
+        ARG_MSG = 'Block argument expression is not on the same line as the ' \
+                  'block start.'.freeze
+
+        def on_block(node)
+          return if oneliner?(node)
+
+          # A block node has three children: the block start,
+          # the arguments, and the expression. We care if the block start
+          # with arguments and the expression start on the same line.
+          _block_start, args, last_expression = node.children
+          do_loc = node.loc.begin # Actually it's either do or {.
+
+          if args_on_different_line?(do_loc.line, args)
+            add_offense_for_expression(node, args, ARG_MSG)
+          end
+
+          return unless last_expression
+          expression_loc = last_expression.loc
+          return unless do_loc.line == expression_loc.line
+          add_offense_for_expression(node, last_expression, MSG)
+        end
+
+        def oneliner?(node)
+          node.loc.begin.line == node.loc.end.line
+        end
+
+        def args_on_different_line?(do_line, args)
+          return false if args.children.empty?
+
+          do_line != args.loc.last_line
+        end
+
+        def add_offense_for_expression(node, expr, msg)
+          expression = expr.source_range
+          range = range_between(expression.begin_pos, expression.end_pos)
+
+          add_offense(node, range, msg)
+        end
+
+        def autocorrect(node)
+          lambda do |corrector|
+            _method, args, block_body = *node
+            unless arguments_on_different_line?(node, args)
+              autocorrect_arguments(corrector, node, args)
+              expr_before_body = args.source_range.end
+            end
+
+            return unless block_body
+
+            expr_before_body ||= node.loc.begin
+            if expr_before_body.line == block_body.loc.line
+              autocorrect_body(corrector, node, block_body)
+            end
+          end
+        end
+
+        def arguments_on_different_line?(node, args)
+          args.children.empty? || args.loc.last_line == node.loc.line
+        end
+
+        def autocorrect_arguments(corrector, node, args)
+          end_pos =
+            range_with_surrounding_space(args.source_range, :right, false)
+            .end_pos
+          range = range_between(node.loc.begin.end.begin_pos, end_pos)
+          corrector.replace(range, " |#{block_arg_string(args)}|")
+        end
+
+        def autocorrect_body(corrector, node, block_body)
+          first_node = if block_body.begin_type?
+                         block_body.children.first
+                       else
+                         block_body
+                       end
+
+          block_start_col = node.source_range.column
+
+          corrector.insert_before(first_node.source_range,
+                                  "\n  #{' ' * block_start_col}")
+        end
+
+        def block_arg_string(args)
+          args.children.map do |arg|
+            if arg.mlhs_type?
+              "(#{block_arg_string(arg)})"
+            else
+              arg.source
+            end
+          end.join(', ')
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  module Cop
+    module Layout
+      # This cop checks that the closing brace in a hash literal is either
+      # on the same line as the last hash element, or a new line.
+      #
+      # When using the `symmetrical` (default) style:
+      #
+      # If a hash's opening brace is on the same line as the first element
+      # of the hash, then the closing brace should be on the same line as
+      # the last element of the hash.
+      #
+      # If a hash's opening brace is on the line above the first element
+      # of the hash, then the closing brace should be on the line below
+      # the last element of the hash.
+      #
+      # When using the `new_line` style:
+      #
+      # The closing brace of a multi-line hash literal must be on the line
+      # after the last element of the hash.
+      #
+      # When using the `same_line` style:
+      #
+      # The closing brace of a multi-line hash literal must be on the same
+      # line as the last element of the hash.
+      #
+      # @example
+      #
+      #     # symmetrical: bad
+      #     # new_line: good
+      #     # same_line: bad
+      #     { a: 1,
+      #       b: 2
+      #     }
+      #
+      #     # symmetrical: bad
+      #     # new_line: bad
+      #     # same_line: good
+      #     {
+      #       a: 1,
+      #       b: 2 }
+      #
+      #     # symmetrical: good
+      #     # new_line: bad
+      #     # same_line: good
+      #     { a: 1,
+      #       b: 2 }
+      #
+      #     # symmetrical: good
+      #     # new_line: good
+      #     # same_line: bad
+      #     {
+      #       a: 1,
+      #       b: 2
+      #     }
+      class MultilineHashBraceLayout < Cop
+        include MultilineLiteralBraceLayout
+
+        SAME_LINE_MESSAGE = 'Closing hash brace must be on the same line as ' \
+          'the last hash element when opening brace is on the same line as ' \
+          'the first hash element.'.freeze
+
+        NEW_LINE_MESSAGE = 'Closing hash brace must be on the line after ' \
+          'the last hash element when opening brace is on a separate line ' \
+          'from the first hash element.'.freeze
+
+        ALWAYS_NEW_LINE_MESSAGE = 'Closing hash brace must be on the line ' \
+          'after the last hash element.'.freeze
+
+        ALWAYS_SAME_LINE_MESSAGE = 'Closing hash brace must be on the same ' \
+          'line as the last hash element.'.freeze
+
+        def on_hash(node)
+          check_brace_layout(node)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  module Cop
+    module Layout
+      # This cop checks that the closing brace in a method call is either
+      # on the same line as the last method argument, or a new line.
+      #
+      # When using the `symmetrical` (default) style:
+      #
+      # If a method call's opening brace is on the same line as the first
+      # argument of the call, then the closing brace should be on the same
+      # line as the last argument of the call.
+      #
+      # If an method call's opening brace is on the line above the first
+      # argument of the call, then the closing brace should be on the line
+      # below the last argument of the call.
+      #
+      # When using the `new_line` style:
+      #
+      # The closing brace of a multi-line method call must be on the line
+      # after the last argument of the call.
+      #
+      # When using the `same_line` style:
+      #
+      # The closing brace of a multi-line method call must be on the same
+      # line as the last argument of the call.
+      #
+      # @example
+      #
+      #     # symmetrical: bad
+      #     # new_line: good
+      #     # same_line: bad
+      #     foo(a,
+      #       b
+      #     )
+      #
+      #     # symmetrical: bad
+      #     # new_line: bad
+      #     # same_line: good
+      #     foo(
+      #       a,
+      #       b)
+      #
+      #     # symmetrical: good
+      #     # new_line: bad
+      #     # same_line: good
+      #     foo(a,
+      #       b)
+      #
+      #     # symmetrical: good
+      #     # new_line: good
+      #     # same_line: bad
+      #     foo(
+      #       a,
+      #       b
+      #     )
+      class MultilineMethodCallBraceLayout < Cop
+        include MultilineLiteralBraceLayout
+
+        SAME_LINE_MESSAGE = 'Closing method call brace must be on the ' \
+          'same line as the last argument when opening brace is on the same ' \
+          'line as the first argument.'.freeze
+
+        NEW_LINE_MESSAGE = 'Closing method call brace must be on the ' \
+          'line after the last argument when opening brace is on a separate ' \
+          'line from the first argument.'.freeze
+
+        ALWAYS_NEW_LINE_MESSAGE = 'Closing method call brace must be on ' \
+          'the line after the last argument.'.freeze
+
+        ALWAYS_SAME_LINE_MESSAGE = 'Closing method call brace must be on ' \
+          'the same line as the last argument.'.freeze
+
+        def on_send(node)
+          check_brace_layout(node)
+        end
+
+        private
+
+        def children(node)
+          node.arguments
+        end
+
+        def ignored_literal?(node)
+          single_line_ignoring_receiver?(node) || super
+        end
+
+        def single_line_ignoring_receiver?(node)
+          return false unless node.loc.begin && node.loc.end
+
+          node.loc.begin.line == node.loc.end.line
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,215 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  module Cop
+    module Layout
+      # This cop checks the indentation of the method name part in method calls
+      # that span more than one line.
+      #
+      # @example
+      #   # bad
+      #   while myvariable
+      #   .b
+      #     # do something
+      #   end
+      #
+      #   # good, EnforcedStyle: aligned
+      #   while myvariable
+      #         .b
+      #     # do something
+      #   end
+      #
+      #   # good, EnforcedStyle: aligned
+      #   Thing.a
+      #        .b
+      #        .c
+      #
+      #   # good, EnforcedStyle:    indented,
+      #           IndentationWidth: 2
+      #   while myvariable
+      #     .b
+      #
+      #     # do something
+      #   end
+      #
+      #   # good, EnforcedStyle:    indented_relative_to_receiver,
+      #           IndentationWidth: 2
+      #   while myvariable
+      #           .a
+      #           .b
+      #
+      #     # do something
+      #   end
+      #
+      #   # good, EnforcedStyle:    indented_relative_to_receiver,
+      #           IndentationWidth: 2
+      #   myvariable = Thing
+      #                  .a
+      #                  .b
+      #                  .c
+      class MultilineMethodCallIndentation < Cop
+        include ConfigurableEnforcedStyle
+        include AutocorrectAlignment
+        include MultilineExpressionIndentation
+
+        def validate_config
+          return unless style == :aligned && cop_config['IndentationWidth']
+
+          raise ValidationError,
+                'The `Layout/MultilineMethodCallIndentation`' \
+                ' cop only accepts an `IndentationWidth` ' \
+                'configuration parameter when ' \
+                '`EnforcedStyle` is `indented`.'
+        end
+
+        private
+
+        def relevant_node?(send_node)
+          send_node.loc.dot # Only check method calls with dot operator
+        end
+
+        def offending_range(node, lhs, rhs, given_style)
+          return false unless begins_its_line?(rhs)
+          return false if not_for_this_cop?(node)
+
+          @base = alignment_base(node, rhs, given_style)
+          correct_column = if @base
+                             @base.column + extra_indentation(given_style)
+                           else
+                             indentation(lhs) + correct_indentation(node)
+                           end
+          @column_delta = correct_column - rhs.column
+          rhs if @column_delta.nonzero?
+        end
+
+        def extra_indentation(given_style)
+          if given_style == :indented_relative_to_receiver
+            configured_indentation_width
+          else
+            0
+          end
+        end
+
+        def message(node, lhs, rhs)
+          if should_indent_relative_to_receiver?
+            relative_to_receiver_message(rhs)
+          elsif should_align_with_base?
+            align_with_base_message(rhs)
+          else
+            no_base_message(lhs, rhs, node)
+          end
+        end
+
+        def should_indent_relative_to_receiver?
+          @base && style == :indented_relative_to_receiver
+        end
+
+        def should_align_with_base?
+          @base && style != :indented_relative_to_receiver
+        end
+
+        def relative_to_receiver_message(rhs)
+          "Indent `#{rhs.source}` #{configured_indentation_width} spaces " \
+            "more than `#{base_source}` on line #{@base.line}."
+        end
+
+        def align_with_base_message(rhs)
+          "Align `#{rhs.source}` with `#{base_source}` on line #{@base.line}."
+        end
+
+        def base_source
+          @base.source[/[^\n]*/]
+        end
+
+        def no_base_message(lhs, rhs, node)
+          used_indentation = rhs.column - indentation(lhs)
+          what = operation_description(node, rhs)
+
+          "Use #{correct_indentation(node)} (not #{used_indentation}) " \
+            "spaces for indenting #{what} spanning multiple lines."
+        end
+
+        def alignment_base(node, rhs, given_style)
+          case given_style
+          when :aligned
+            semantic_alignment_base(node, rhs) ||
+              syntactic_alignment_base(node, rhs)
+          when :indented
+            nil
+          when :indented_relative_to_receiver
+            receiver_alignment_base(node)
+          end
+        end
+
+        def syntactic_alignment_base(lhs, rhs)
+          # a if b
+          #      .c
+          n = kw_node_with_special_indentation(lhs)
+          if n
+            case n.type
+            when :for            then _, expression, = *n
+            when :return         then expression, = *n
+            when *MODIFIER_NODES then expression, = *n
+            end
+            return expression.source_range
+          end
+
+          # a = b
+          #     .c
+          n = part_of_assignment_rhs(lhs, rhs)
+          return assignment_rhs(n).source_range if n
+
+          # a + b
+          #     .c
+          n = operation_rhs(lhs)
+          return n.source_range if n
+        end
+
+        # a.b
+        #  .c
+        def semantic_alignment_base(node, rhs)
+          return unless rhs.source.start_with?('.')
+
+          node = semantic_alignment_node(node)
+          return unless node
+
+          node.loc.dot.join(node.loc.selector)
+        end
+
+        # a
+        #   .b
+        #   .c
+        def receiver_alignment_base(node)
+          node = node.receiver while node.receiver
+          node = node.parent
+          node = node.parent until node.loc.dot
+
+          node.receiver.source_range if node
+        end
+
+        def semantic_alignment_node(node)
+          return if argument_in_method_call(node, :with_parentheses)
+
+          # descend to root of method chain
+          node = node.receiver while node.receiver
+          # ascend to first call which has a dot
+          node = node.parent
+          node = node.parent until node.loc.dot
+
+          return if node.loc.dot.line != node.loc.line
+          node
+        end
+
+        def operation_rhs(node)
+          receiver, = *node
+          receiver.each_ancestor(:send) do |a|
+            _, method, args = *a
+            return args if operator?(method) && args &&
+                           within_node?(receiver, args)
+          end
+          nil
+        end
+      end
+    end
+  end
+end