rubocop 1.12.0 → 1.13.0

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

@@ -77,8 +77,7 @@ module RuboCop
           first = args.first.source_range
           last = args.last.source_range
 
-          check_no_space(opening_pipe.end_pos, first.begin_pos,
-                         'Space before first')
+          check_no_space(opening_pipe.end_pos, first.begin_pos, 'Space before first')
           check_no_space(last_end_pos_inside_pipes(arguments, last),
                          closing_pipe.begin_pos, 'Space after last')
         end
@@ -98,8 +97,7 @@ module RuboCop
 
           check_space(opening_pipe.end_pos, range.begin_pos, range,
                       'before first block parameter', first_arg)
-          check_no_space(opening_pipe.end_pos, range.begin_pos - 1,
-                         'Extra space before first')
+          check_no_space(opening_pipe.end_pos, range.begin_pos - 1, 'Extra space before first')
         end
 
         def check_closing_pipe_space(arguments, closing_pipe)
@@ -108,10 +106,8 @@ module RuboCop
           last         = args.last.source_range
           last_end_pos = last_end_pos_inside_pipes(arguments, last)
 
-          check_space(last_end_pos, closing_pipe.begin_pos, last,
-                      'after last block parameter')
-          check_no_space(last_end_pos + 1, closing_pipe.begin_pos,
-                         'Extra space after last')
+          check_space(last_end_pos, closing_pipe.begin_pos, last, 'after last block parameter')
+          check_no_space(last_end_pos + 1, closing_pipe.begin_pos, 'Extra space after last')
         end
 
         def last_end_pos_inside_pipes(arguments, range)
@@ -123,9 +119,7 @@ module RuboCop
         end
 
         def check_each_arg(args)
-          args.children.each do |arg|
-            check_arg(arg)
-          end
+          args.children.each { |arg| check_arg(arg) }
         end
 
         def check_arg(arg)
@@ -160,9 +154,7 @@ module RuboCop
           return if range.source.include?("\n")
 
           message = "#{msg} block parameter detected."
-          add_offense(range, message: message) do |corrector|
-            corrector.remove(range)
-          end
+          add_offense(range, message: message) { |corrector| corrector.remove(range) }
         end
       end
     end

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

@@ -47,8 +47,7 @@ module RuboCop
           space_on_both_sides = space_on_both_sides?(arg, equals)
           no_surrounding_space = no_surrounding_space?(arg, equals)
 
-          if style == :space && space_on_both_sides ||
-             style == :no_space && no_surrounding_space
+          if style == :space && space_on_both_sides || style == :no_space && no_surrounding_space
             correct_style_detected
           else
             incorrect_style_detected(arg, value)

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

@@ -33,10 +33,8 @@ module RuboCop
         DO = 'do'
         SAFE_NAVIGATION = '&.'
         NAMESPACE_OPERATOR = '::'
-        ACCEPT_LEFT_PAREN =
-          %w[break defined? next not rescue return super yield].freeze
-        ACCEPT_LEFT_SQUARE_BRACKET =
-          %w[super yield].freeze
+        ACCEPT_LEFT_PAREN = %w[break defined? next not rescue return super yield].freeze
+        ACCEPT_LEFT_SQUARE_BRACKET = %w[super yield].freeze
         ACCEPT_NAMESPACE_OPERATOR = 'super'
 
         def on_and(node)
@@ -194,8 +192,7 @@ module RuboCop
 
           return false if accepted_opening_delimiter?(range, char)
           return false if safe_navigation_call?(range, pos)
-          return false if accept_namespace_operator?(range) &&
-                          namespace_operator?(range, pos)
+          return false if accept_namespace_operator?(range) && namespace_operator?(range, pos)
 
           !/[\s;,#\\)}\].]/.match?(char)
         end

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

@@ -92,9 +92,7 @@ module RuboCop
           if node.setter_method?
             on_special_asgn(node)
           elsif regular_operator?(node)
-            check_operator(:send,
-                           node.loc.selector,
-                           node.first_argument.source_range)
+            check_operator(:send, node.loc.selector, node.first_argument.source_range)
           end
         end
 
@@ -138,13 +136,11 @@ module RuboCop
         private
 
         def regular_operator?(send_node)
-          !send_node.unary_operation? && !send_node.dot? &&
-            operator_with_regular_syntax?(send_node)
+          !send_node.unary_operation? && !send_node.dot? && operator_with_regular_syntax?(send_node)
         end
 
         def operator_with_regular_syntax?(send_node)
-          send_node.operator_method? &&
-            !IRREGULAR_METHODS.include?(send_node.method_name)
+          send_node.operator_method? && !IRREGULAR_METHODS.include?(send_node.method_name)
         end
 
         def check_operator(type, operator, right_operand)
@@ -225,8 +221,7 @@ module RuboCop
         end
 
         def hash_table_style?
-          align_hash_cop_config &&
-            align_hash_cop_config['EnforcedHashRocketStyle'] == 'table'
+          align_hash_cop_config && align_hash_cop_config['EnforcedHashRocketStyle'] == 'table'
         end
 
         def space_around_exponent_operator?

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

@@ -136,8 +136,7 @@ module RuboCop
         end
 
         def conflict_with_block_delimiters?(node)
-          block_delimiters_style == 'line_count_based' &&
-            style == :no_space && node.multiline?
+          block_delimiters_style == 'line_count_based' && style == :no_space && node.multiline?
         end
 
         def block_delimiters_style

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

@@ -53,9 +53,7 @@ module RuboCop
         end
 
         def register_offense(range)
-          add_offense(range) do |corrector|
-            corrector.remove(range)
-          end
+          add_offense(range) { |corrector| corrector.remove(range) }
         end
 
         def reference_variable_with_brackets?(node)

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

@@ -25,9 +25,7 @@ module RuboCop
 
             range = token2.pos
 
-            add_offense(range) do |corrector|
-              corrector.insert_before(range, ' ')
-            end
+            add_offense(range) { |corrector| corrector.insert_before(range, ' ') }
           end
         end
       end

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

@@ -26,23 +26,18 @@ module RuboCop
         include RangeHelp
         extend AutoCorrector
 
-        MSG = 'Put one space between the method name and ' \
-              'the first argument.'
+        MSG = 'Put one space between the method name and the first argument.'
 
         def on_send(node)
           return unless regular_method_call_with_arguments?(node)
 
           first_arg = node.first_argument.source_range
-          first_arg_with_space = range_with_surrounding_space(range: first_arg,
-                                                              side: :left)
-          space = range_between(first_arg_with_space.begin_pos,
-                                first_arg.begin_pos)
+          first_arg_with_space = range_with_surrounding_space(range: first_arg, side: :left)
+          space = range_between(first_arg_with_space.begin_pos, first_arg.begin_pos)
           return if space.length == 1
           return unless expect_params_after_method_name?(node)
 
-          add_offense(space) do |corrector|
-            corrector.replace(space, ' ')
-          end
+          add_offense(space) { |corrector| corrector.replace(space, ' ') }
         end
         alias on_csend on_send
 
@@ -59,8 +54,7 @@ module RuboCop
           first_arg = node.first_argument
 
           same_line?(first_arg, node) &&
-            !(allow_for_alignment? &&
-              aligned_with_something?(first_arg.source_range))
+            !(allow_for_alignment? && aligned_with_something?(first_arg.source_range))
         end
 
         def no_space_between_method_name_and_first_argument?(node)

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

@@ -24,10 +24,8 @@ module RuboCop
         include RangeHelp
         extend AutoCorrector
 
-        MSG_REQUIRE_SPACE = 'Use a space between `->` and ' \
-                            '`(` in lambda literals.'
-        MSG_REQUIRE_NO_SPACE = 'Do not use spaces between `->` and ' \
-                               '`(` in lambda literals.'
+        MSG_REQUIRE_SPACE = 'Use a space between `->` and `(` in lambda literals.'
+        MSG_REQUIRE_NO_SPACE = 'Do not use spaces between `->` and `(` in lambda literals.'
 
         def on_send(node)
           return unless arrow_lambda_with_args?(node)

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

@@ -142,11 +142,9 @@ module RuboCop
           case style
           when :no_space
             start_ok = next_to_comment?(node, left)
-            no_space_offenses(node, left, right, MSG, start_ok: start_ok,
-                                                      end_ok: end_ok)
+            no_space_offenses(node, left, right, MSG, start_ok: start_ok, end_ok: end_ok)
           when :space
-            space_offenses(node, left, right, MSG, start_ok: start_ok,
-                                                   end_ok: end_ok)
+            space_offenses(node, left, right, MSG, start_ok: start_ok, end_ok: end_ok)
           else
             compact_offenses(node, left, right, start_ok, end_ok)
           end
@@ -160,21 +158,18 @@ module RuboCop
           if qualifies_for_compact?(node, left, side: :left)
             compact_offense(node, left, side: :left)
           elsif !multi_dimensional_array?(node, left, side: :left)
-            space_offenses(node, left, nil, MSG, start_ok: start_ok,
-                                                 end_ok: true)
+            space_offenses(node, left, nil, MSG, start_ok: start_ok, end_ok: true)
           end
           if qualifies_for_compact?(node, right)
             compact_offense(node, right)
           elsif !multi_dimensional_array?(node, right)
-            space_offenses(node, nil, right, MSG, start_ok: true,
-                                                  end_ok: end_ok)
+            space_offenses(node, nil, right, MSG, start_ok: true, end_ok: end_ok)
           end
         end
 
         def qualifies_for_compact?(node, token, side: :right)
           if side == :right
-            multi_dimensional_array?(node, token) &&
-              !next_to_bracket?(token)
+            multi_dimensional_array?(node, token) && !next_to_bracket?(token)
           else
             multi_dimensional_array?(node, token, side: :left) &&
               !next_to_bracket?(token, side: :left)

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

@@ -18,8 +18,7 @@ module RuboCop
         extend AutoCorrector
 
         MSG = 'Use only a single space inside array percent literal.'
-        MULTIPLE_SPACES_BETWEEN_ITEMS_REGEX =
-          /(?:[\S&&[^\\]](?:\\ )*)( {2,})(?=\S)/.freeze
+        MULTIPLE_SPACES_BETWEEN_ITEMS_REGEX = /(?:[\S&&[^\\]](?:\\ )*)( {2,})(?=\S)/.freeze
 
         def on_array(node)
           process(node, '%i', '%I', '%w', '%W')
@@ -36,11 +35,7 @@ module RuboCop
         private
 
         def each_unnecessary_space_match(node, &blk)
-          each_match_range(
-            contents_range(node),
-            MULTIPLE_SPACES_BETWEEN_ITEMS_REGEX,
-            &blk
-          )
+          each_match_range(contents_range(node), MULTIPLE_SPACES_BETWEEN_ITEMS_REGEX, &blk)
         end
       end
     end

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

@@ -129,8 +129,7 @@ module RuboCop
           args_delimiter = node.arguments.loc.begin # Can be ( | or nil.
 
           check_left_brace(inner, node.loc.begin, args_delimiter)
-          check_right_brace(inner, node.loc.begin, node.loc.end,
-                            node.single_line?)
+          check_right_brace(inner, node.loc.begin, node.loc.end, node.single_line?)
         end
 
         def check_left_brace(inner, left_brace, args_delimiter)
@@ -143,8 +142,7 @@ module RuboCop
 
         def check_right_brace(inner, left_brace, right_brace, single_line)
           if single_line && /\S$/.match?(inner)
-            no_space(right_brace.begin_pos, right_brace.end_pos,
-                     'Space missing inside }.')
+            no_space(right_brace.begin_pos, right_brace.end_pos, 'Space missing inside }.')
           else
             return if multiline_block?(left_brace, right_brace) &&
                       aligned_braces?(left_brace, right_brace)
@@ -174,8 +172,7 @@ module RuboCop
             # We indicate the position after the left brace. Otherwise it's
             # difficult to distinguish between space missing to the left and to
             # the right of the brace in autocorrect.
-            no_space(left_brace.end_pos, left_brace.end_pos + 1,
-                     'Space missing inside {.')
+            no_space(left_brace.end_pos, left_brace.end_pos + 1, 'Space missing inside {.')
           end
         end
 
@@ -188,8 +185,7 @@ module RuboCop
                       'Space between { and | detected.')
             end
           else
-            brace_with_space = range_with_surrounding_space(range: left_brace,
-                                                            side: :right)
+            brace_with_space = range_with_surrounding_space(range: left_brace, side: :right)
             space(brace_with_space.begin_pos + 1, brace_with_space.end_pos,
                   'Space inside { detected.')
           end
@@ -200,8 +196,7 @@ module RuboCop
         end
 
         def space_inside_right_brace(right_brace)
-          brace_with_space = range_with_surrounding_space(range: right_brace,
-                                                          side: :left)
+          brace_with_space = range_with_surrounding_space(range: right_brace, side: :left)
           space(brace_with_space.begin_pos, brace_with_space.end_pos - 1,
                 'Space inside } detected.')
         end

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

@@ -90,8 +90,7 @@ module RuboCop
           expect_space    = expect_space?(token1, token2)
 
           if offense?(token1, expect_space)
-            incorrect_style_detected(token1, token2,
-                                     expect_space, is_empty_braces)
+            incorrect_style_detected(token1, token2, expect_space, is_empty_braces)
           else
             correct_style_detected
           end

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

@@ -107,8 +107,7 @@ module RuboCop
           current_token = tokens.reverse.find(&:left_ref_bracket?)
           previous_token = previous_token(current_token)
 
-          if node.method?(:[]=) ||
-             previous_token && !previous_token.right_bracket?
+          if node.method?(:[]=) || previous_token && !previous_token.right_bracket?
             tokens.find(&:left_ref_bracket?)
           else
             current_token

data/lib/rubocop/cop/legacy/corrections_proxy.rb

@@ -11,11 +11,7 @@ module RuboCop
         end
 
         def <<(callable)
-          suppress_clobbering do
-            @corrector.transaction do
-              callable.call(@corrector)
-            end
-          end
+          suppress_clobbering { @corrector.transaction { callable.call(@corrector) } }
         end
 
         def empty?
@@ -24,9 +20,7 @@ module RuboCop
 
         def concat(corrections)
           if corrections.is_a?(CorrectionsProxy)
-            suppress_clobbering do
-              corrector.merge!(corrections.corrector)
-            end
+            suppress_clobbering { corrector.merge!(corrections.corrector) }
           else
             corrections.each { |correction| self << correction }
           end

data/lib/rubocop/cop/legacy/corrector.rb

@@ -13,9 +13,7 @@ module RuboCop
             merge!(corr.send(:corrector))
           else
             # warn "Corrector.new with corrections is deprecated." unless corr.empty? TODO
-            corr.each do |c|
-              corrections << c
-            end
+            corr.each { |c| corrections << c }
           end
         end
 

data/lib/rubocop/cop/lint/ambiguous_assignment.rb

@@ -25,12 +25,7 @@ module RuboCop
 
         SIMPLE_ASSIGNMENT_TYPES = %i[lvasgn ivasgn cvasgn gvasgn casgn].freeze
 
-        MISTAKES = {
-          '=-' => '-=',
-          '=+' => '+=',
-          '=*' => '*=',
-          '=!' => '!='
-        }.freeze
+        MISTAKES = { '=-' => '-=', '=+' => '+=', '=*' => '*=', '=!' => '!=' }.freeze
 
         def on_asgn(node)
           return unless (rhs = rhs(node))

data/lib/rubocop/cop/lint/ambiguous_block_association.rb

@@ -6,6 +6,8 @@ module RuboCop
       # This cop checks for ambiguous block association with method
       # when param passed without parentheses.
       #
+      # This cop can customize ignored methods with `IgnoredMethods`.
+      #
       # @example
       #
       #   # bad
@@ -26,7 +28,14 @@ module RuboCop
       #   # good
       #   # Lambda arguments require no disambiguation
       #   foo = ->(bar) { bar.baz }
+      #
+      # @example IgnoredMethods: [change]
+      #
+      #   # good
+      #   expect { do_something }.to change { object.attribute }
       class AmbiguousBlockAssociation < Base
+        include IgnoredMethods
+
         MSG = 'Parenthesize the param `%<param>s` to make sure that the ' \
               'block will be associated with the `%<method>s` method ' \
               'call.'
@@ -35,8 +44,7 @@ module RuboCop
           return unless node.arguments?
 
           return unless ambiguous_block_association?(node)
-          return if node.parenthesized? ||
-                    node.last_argument.lambda? || allowed_method?(node)
+          return if node.parenthesized? || node.last_argument.lambda? || allowed_method?(node)
 
           message = message(node)
 
@@ -47,19 +55,18 @@ module RuboCop
         private
 
         def ambiguous_block_association?(send_node)
-          send_node.last_argument.block_type? &&
-            !send_node.last_argument.send_node.arguments?
+          send_node.last_argument.block_type? && !send_node.last_argument.send_node.arguments?
         end
 
         def allowed_method?(node)
-          node.assignment? || node.operator_method? || node.method?(:[])
+          node.assignment? || node.operator_method? || node.method?(:[]) ||
+            ignored_method?(node.last_argument.send_node.source)
         end
 
         def message(send_node)
           block_param = send_node.last_argument
 
-          format(MSG, param: block_param.source,
-                      method: block_param.send_node.source)
+          format(MSG, param: block_param.source, method: block_param.send_node.source)
         end
       end
     end