rubocop 1.12.1 → 1.13.0

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

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

@@ -24,8 +24,7 @@ module RuboCop
       class BooleanSymbol < Base
         extend AutoCorrector
 
-        MSG = 'Symbol with a boolean name - ' \
-              'you probably meant to use `%<boolean>s`.'
+        MSG = 'Symbol with a boolean name - you probably meant to use `%<boolean>s`.'
 
         # @!method boolean_symbol?(node)
         def_node_matcher :boolean_symbol?, '(sym {:true :false})'

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

@@ -73,8 +73,7 @@ module RuboCop
 
         def const_name?(name)
           name = name.to_s
-          (allowed_names.empty? || allowed_names.include?(name)) &&
-            !ignored_names.include?(name)
+          (allowed_names.empty? || allowed_names.include?(name)) && !ignored_names.include?(name)
         end
 
         def allowed_names

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

@@ -58,8 +58,7 @@ module RuboCop
           DeprecatedClassMethod.new(deprecated: :exists?,
                                     replacement: :exist?,
                                     class_constant: :Dir),
-          DeprecatedClassMethod.new(deprecated: :iterator?,
-                                    replacement: :block_given?)
+          DeprecatedClassMethod.new(deprecated: :iterator?, replacement: :block_given?)
         ].freeze
 
         RESTRICT_ON_SEND = DEPRECATED_METHODS_OBJECT.map(&:deprecated_method).freeze
@@ -96,8 +95,7 @@ module RuboCop
 
         def method_call(class_constant, method)
           if class_constant
-            format('%<constant>s.%<method>s', constant: class_constant,
-                                              method: method)
+            format('%<constant>s.%<method>s', constant: class_constant, method: method)
           else
             format('%<method>s', method: method)
           end

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

@@ -42,7 +42,7 @@ module RuboCop
           #        Maybe further investigation of RuboCop AST will lead to an essential solution.
           return unless node.loc
 
-          constant = node.absolute? ? consntant_name(node, node.short_name.to_s) : node.source
+          constant = node.absolute? ? constant_name(node, node.short_name.to_s) : node.source
           return unless (deprecated_constant = deprecated_constants[constant])
 
           alternative = deprecated_constant['Alternative']
@@ -55,10 +55,10 @@ module RuboCop
 
         private
 
-        def consntant_name(node, nested_constant_name)
+        def constant_name(node, nested_constant_name)
           return nested_constant_name unless node.namespace.const_type?
 
-          consntant_name(node.namespace, "#{node.namespace.short_name}::#{nested_constant_name}")
+          constant_name(node.namespace, "#{node.namespace.short_name}::#{nested_constant_name}")
         end
 
         def message(good, bad, deprecated_version)

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

@@ -41,8 +41,7 @@ module RuboCop
         include RangeHelp
         extend AutoCorrector
 
-        MSG = 'Use `%<constant>s.%<method>s(%<replacement_args>s)`' \
-          ' instead of `%<original>s`.'
+        MSG = 'Use `%<constant>s.%<method>s(%<replacement_args>s)` instead of `%<original>s`.'
 
         NO_ARG_ALGORITHM = %w[BF DES IDEA RC4].freeze
 
@@ -62,9 +61,7 @@ module RuboCop
 
           message = message(node)
 
-          add_offense(node, message: message) do |corrector|
-            autocorrect(corrector, node)
-          end
+          add_offense(node, message: message) { |corrector| autocorrect(corrector, node) }
         end
 
         private