rubocop 0.39.0 → 0.40.0

data/lib/rubocop/cop/style/line_end_concatenation.rb

@@ -41,6 +41,11 @@ module RuboCop
           operator_range = range_with_surrounding_space(operator_range,
                                                         :right,
                                                         !:with_newline)
+          one_more_char = operator_range.resize(operator_range.size + 1)
+          # Don't create a double backslash at the end of the line, in case
+          # there already was a backslash after the concatenation operator.
+          operator_range = one_more_char if one_more_char.source.end_with?('\\')
+
           ->(corrector) { corrector.replace(operator_range, '\\') }
         end
 

data/lib/rubocop/cop/style/multiline_array_brace_layout.rb

@@ -4,35 +4,54 @@
 module RuboCop
   module Cop
     module Style
-      # This cop checks that the closing brace in an array literal is
-      # symmetrical with respect to the opening brace and the array
-      # elements.
+      # This cop checks that the closing brace in an array literal is either
+      # on the same line as the last array element, or a new line.
+      #
+      # When using the `symmetrical` (default) style:
       #
       # If an array's opening brace is on the same line as the first element
       # of the array, then the closing brace should be on the same line as
       # the last element of the array.
       #
-      # If an array's opening brace is on a separate line from the first
-      # element of the array, then the closing brace should be on the line
+      # If an array's opening brace is on the line above the first element
+      # of the array, then the closing brace should be on the line below
+      # the last element of the array.
+      #
+      # When using the `new_line` style:
+      #
+      # The closing brace of a multi-line array literal must be on the line
       # after the last element of the array.
       #
+      # When using the `same_line` style:
+      #
+      # The closing brace of a multi-line array literal must be on the same
+      # line as the last element of the array.
+      #
       # @example
       #
-      #     # bad
+      #     # symmetrical: bad
+      #     # new_line: good
+      #     # same_line: bad
       #     [ :a,
       #       :b
       #     ]
       #
-      #     # bad
+      #     # symmetrical: bad
+      #     # new_line: bad
+      #     # same_line: good
       #     [
       #       :a,
       #       :b ]
       #
-      #     # good
+      #     # symmetrical: good
+      #     # new_line: bad
+      #     # same_line: good
       #     [ :a,
       #       :b ]
       #
-      #     #good
+      #     # symmetrical: good
+      #     # new_line: good
+      #     # same_line: bad
       #     [
       #       :a,
       #       :b
@@ -48,6 +67,12 @@ module RuboCop
           'the last array element when opening brace is on a separate line ' \
           'from the first array element.'.freeze
 
+        ALWAYS_NEW_LINE_MESSAGE = 'Closing array brace must be on the line ' \
+          'after the last array element.'.freeze
+
+        ALWAYS_SAME_LINE_MESSAGE = 'Closing array brace must be on the same ' \
+          'line as teh last array element.'.freeze
+
         def on_array(node)
           check_brace_layout(node)
         end

data/lib/rubocop/cop/style/multiline_assignment_layout.rb

@@ -74,7 +74,8 @@ module RuboCop
             range = Parser::Source::Range.new(
               node.source_range.source_buffer,
               node.loc.operator.end_pos,
-              extract_rhs(node).source_range.begin_pos)
+              extract_rhs(node).source_range.begin_pos
+            )
 
             ->(corrector) { corrector.replace(range, ' ') }
           end

data/lib/rubocop/cop/style/multiline_hash_brace_layout.rb

@@ -4,38 +4,57 @@
 module RuboCop
   module Cop
     module Style
-      # This cop checks that the closing brace in an a hash literal is
-      # symmetrical with respect to the opening brace and the hash
-      # elements.
+      # 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 a separate line from the first
-      # element of the hash, then the closing brace should be on the line
+      # 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
       #
-      #     # bad
-      #     { a: 'a',
-      #       b: 'b'
+      #     # symmetrical: bad
+      #     # new_line: good
+      #     # same_line: bad
+      #     { a: 1,
+      #       b: 2
       #     }
       #
-      #     # bad
+      #     # symmetrical: bad
+      #     # new_line: bad
+      #     # same_line: good
       #     {
-      #       a: 'a',
-      #       b: 'b' }
+      #       a: 1,
+      #       b: 2 }
       #
-      #     # good
-      #     { a: 'a',
-      #       b: 'b' }
+      #     # symmetrical: good
+      #     # new_line: bad
+      #     # same_line: good
+      #     { a: 1,
+      #       b: 2 }
       #
-      #     #good
+      #     # symmetrical: good
+      #     # new_line: good
+      #     # same_line: bad
       #     {
-      #       a: 'a',
-      #       b: 'b'
+      #       a: 1,
+      #       b: 2
       #     }
       class MultilineHashBraceLayout < Cop
         include MultilineLiteralBraceLayout
@@ -48,6 +67,12 @@ module RuboCop
           '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

data/lib/rubocop/cop/style/multiline_method_call_brace_layout.rb

@@ -4,35 +4,54 @@
 module RuboCop
   module Cop
     module Style
-      # This cop checks that the closing brace in a method call is
-      # symmetrical with respect to the opening brace and the method
-      # arguments.
+      # 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.
       #
-      # 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.
+      # When using the `symmetrical` (default) style:
       #
-      # If a method call's opening brace is on a separate line from
-      # the first argument of the call, then the closing brace should
-      # be on the line after the last argument of the call.
+      # 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
       #
-      #     # bad
+      #     # symmetrical: bad
+      #     # new_line: good
+      #     # same_line: bad
       #     foo(a,
       #       b
-      #       )
+      #     )
       #
-      #     # bad
+      #     # symmetrical: bad
+      #     # new_line: bad
+      #     # same_line: good
       #     foo(
       #       a,
       #       b)
       #
-      #     # good
+      #     # symmetrical: good
+      #     # new_line: bad
+      #     # same_line: good
       #     foo(a,
       #       b)
       #
-      #     #good
+      #     # symmetrical: good
+      #     # new_line: good
+      #     # same_line: bad
       #     foo(
       #       a,
       #       b
@@ -48,6 +67,12 @@ module RuboCop
           '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

data/lib/rubocop/cop/style/multiline_method_definition_brace_layout.rb

@@ -4,43 +4,58 @@
 module RuboCop
   module Cop
     module Style
-      # This cop checks that the closing brace in a method definition is
-      # symmetrical with respect to the opening brace and the method
-      # parameters.
+      # This cop checks that the closing brace in a method definition is either
+      # on the same line as the last method parameter, or a new line.
+      #
+      # When using the `symmetrical` (default) style:
       #
       # If a method definition's opening brace is on the same line as the
       # first parameter of the definition, then the closing brace should be
       # on the same line as the last parameter of the definition.
       #
-      # If a method definition's opening brace is on a separate line from
-      # the first parameter of the definition, then the closing brace should
-      # be on the line after the last parameter of the definition.
+      # If an method definition's opening brace is on the line above the first
+      # parameter of the definition, then the closing brace should be on the
+      # line below the last parameter of the definition.
+      #
+      # When using the `new_line` style:
+      #
+      # The closing brace of a multi-line method definition must be on the line
+      # after the last parameter of the definition.
+      #
+      # When using the `same_line` style:
+      #
+      # The closing brace of a multi-line method definition must be on the same
+      # line as the last parameter of the definition.
       #
       # @example
       #
-      #     # bad
+      #     # symmetrical: bad
+      #     # new_line: good
+      #     # same_line: bad
       #     def foo(a,
       #       b
-      #       )
-      #     end
+      #     )
       #
-      #     # bad
+      #     # symmetrical: bad
+      #     # new_line: bad
+      #     # same_line: good
       #     def foo(
       #       a,
       #       b)
-      #     end
       #
-      #     # good
+      #     # symmetrical: good
+      #     # new_line: bad
+      #     # same_line: good
       #     def foo(a,
       #       b)
-      #     end
       #
-      #     #good
+      #     # symmetrical: good
+      #     # new_line: good
+      #     # same_line: bad
       #     def foo(
       #       a,
       #       b
       #     )
-      #     end
       class MultilineMethodDefinitionBraceLayout < Cop
         include OnMethodDef
         include MultilineLiteralBraceLayout
@@ -53,6 +68,12 @@ module RuboCop
           'line after the last parameter when opening brace is on a separate ' \
           'line from the first parameter.'.freeze
 
+        ALWAYS_NEW_LINE_MESSAGE = 'Closing method definition brace must be ' \
+          'on the line after the last parameter.'.freeze
+
+        ALWAYS_SAME_LINE_MESSAGE = 'Closing method definition brace must be ' \
+          'on the same line as the last parameter.'.freeze
+
         def on_method_def(_node, _method_name, args, _body)
           check_brace_layout(args)
         end

data/lib/rubocop/cop/style/multiline_ternary_operator.rb

@@ -6,17 +6,19 @@ module RuboCop
     module Style
       # This cop checks for multi-line ternary op expressions.
       class MultilineTernaryOperator < Cop
-        MSG = 'Avoid multi-line ?: (the ternary operator);' \
-              ' use `if`/`unless` instead.'.freeze
+        include IfNode
+
+        MSG = 'Avoid multi-line ternary operators, ' \
+              'use `if` or `unless` instead.'.freeze
 
         def on_if(node)
           _condition, _if_branch, else_branch = *node
-          loc = node.loc
 
-          # discard non-ternary ops
-          return unless loc.respond_to?(:question)
+          return unless ternary?(node)
 
-          add_offense(node, :expression) if loc.line != else_branch.loc.line
+          unless node.loc.line == else_branch.loc.line
+            add_offense(node, :expression)
+          end
         end
       end
     end

data/lib/rubocop/cop/style/negated_while.rb

@@ -37,7 +37,8 @@ module RuboCop
             pos_condition, _method, = *condition
             corrector.replace(
               node.loc.keyword,
-              node.type == :while ? 'until' : 'while')
+              node.type == :while ? 'until' : 'while'
+            )
             corrector.replace(condition.source_range, pos_condition.source)
           end
         end

data/lib/rubocop/cop/style/nested_parenthesized_calls.rb

@@ -39,6 +39,21 @@ module RuboCop
             RSPEC_MATCHERS.include?(send.method_name) &&
             send.method_args.one?
         end
+
+        def autocorrect(nested)
+          _scope, _method_name, *args = *nested
+
+          first_arg = args.first.source_range
+          last_arg = args.last.source_range
+
+          first_arg_with_space = range_with_surrounding_space(first_arg, :left)
+          leading_space = first_arg_with_space.begin.resize(1)
+
+          lambda do |corrector|
+            corrector.replace(leading_space, '(')
+            corrector.insert_after(last_arg, ')')
+          end
+        end
       end
     end
   end

data/lib/rubocop/cop/style/nested_ternary_operator.rb

@@ -6,19 +6,16 @@ module RuboCop
     module Style
       # This cop checks for nested ternary op expressions.
       class NestedTernaryOperator < Cop
-        MSG = 'Ternary operators must not be nested. Prefer `if`/`else` ' \
+        include IfNode
+
+        MSG = 'Ternary operators must not be nested. Prefer `if` or `else` ' \
               'constructs instead.'.freeze
 
         def on_if(node)
-          loc = node.loc
-
-          # discard non-ternary ops
-          return unless loc.respond_to?(:question)
+          return unless ternary?(node)
 
           node.each_descendant(:if) do |nested_if_node|
-            if nested_if_node.loc.respond_to?(:question)
-              add_offense(nested_if_node, :expression)
-            end
+            add_offense(nested_if_node, :expression) if ternary?(nested_if_node)
           end
         end
       end

data/lib/rubocop/cop/style/next.rb

@@ -82,7 +82,7 @@ module RuboCop
 
         def simple_if_without_break?(node)
           return false unless node.if_type?
-          return false if ternary_op?(node)
+          return false if ternary?(node)
           return false if if_else?(node)
           return false if style == :skip_modifier_ifs && modifier_if?(node)
           return false if !modifier_if?(node) && !min_body_length?(node)