rubocop 0.36.0 → 0.37.0

data/lib/rubocop/cop/performance/redundant_block_call.rb

@@ -25,6 +25,10 @@ module RuboCop
       #   end
       class RedundantBlockCall < Cop
         MSG = 'Use `yield` instead of `%s.call`.'.freeze
+        YIELD = 'yield'.freeze
+        OPEN_PAREN = '('.freeze
+        CLOSE_PAREN = ')'.freeze
+        SPACE = ' '.freeze
 
         def_node_matcher :blockarg_def, <<-END
           {(def  _   (args ... (blockarg $_)) $_)
@@ -37,6 +41,7 @@ module RuboCop
 
         def on_def(node)
           blockarg_def(node) do |argname, body|
+            next unless body
             blockarg_calls(body, argname) do |blockcall|
               add_offense(blockcall, :expression, format(MSG, argname))
             end
@@ -46,9 +51,18 @@ module RuboCop
         # offenses are registered on the `block.call` nodes
         def autocorrect(node)
           _receiver, _method, *args = *node
-          new_source = 'yield'
-          new_source += ' ' unless args.empty?
-          new_source += args.map(&:source).join(', ')
+          new_source = String.new(YIELD)
+          unless args.empty?
+            new_source += if parentheses?(node)
+                            OPEN_PAREN
+                          else
+                            SPACE
+                          end
+
+            new_source << args.map(&:source).join(', ')
+          end
+
+          new_source << CLOSE_PAREN if parentheses?(node)
           ->(corrector) { corrector.replace(node.source_range, new_source) }
         end
       end

data/lib/rubocop/cop/performance/redundant_merge.rb

@@ -15,13 +15,15 @@ module RuboCop
         AREF_ASGN = '%s[%s] = %s'.freeze
         MSG = 'Use `%s` instead of `%s`.'.freeze
 
-        def_node_matcher :redundant_merge, '(send $_ :merge! (hash $...))'
+        def_node_matcher :redundant_merge,
+                         '(send $_ {:merge! :update} (hash $...))'
         def_node_matcher :modifier_flow_control, '[{if while until} #modifier?]'
 
         def on_send(node)
           redundant_merge(node) do |receiver, pairs|
             next if node.value_used?
             next if pairs.size > 1 && !receiver.pure?
+            next if pairs.size > max_key_value_pairs
 
             assignments = to_assignments(receiver, pairs).join('; ')
             message = format(MSG, assignments, node.source)
@@ -79,6 +81,10 @@ module RuboCop
         def modifier?(node)
           node.loc.respond_to?(:end) && node.loc.end.nil?
         end
+
+        def max_key_value_pairs
+          cop_config['MaxKeyValuePairs'].to_i
+        end
       end
     end
   end

data/lib/rubocop/cop/performance/times_map.rb

@@ -33,15 +33,14 @@ module RuboCop
         private
 
         def check(node)
-          map_or_collect = times_map_call(node)
-          if map_or_collect
+          times_map_call(node) do |map_or_collect|
             add_offense(node, :expression, format(MSG, map_or_collect))
           end
         end
 
         def_node_matcher :times_map_call, <<-END
-          {(block (send (send _ :times) ${:map :collect}) ...)
-           (send (send _ :times) ${:map :collect} (block_pass ...))}
+          {(block (send (send !nil :times) ${:map :collect}) ...)
+           (send (send !nil :times) ${:map :collect} (block_pass ...))}
         END
       end
     end

data/lib/rubocop/cop/severity.rb

@@ -33,7 +33,7 @@ module RuboCop
       def initialize(name_or_code)
         name = Severity.name_from_code(name_or_code)
         unless NAMES.include?(name)
-          fail ArgumentError, "Unknown severity: #{name}"
+          raise ArgumentError, "Unknown severity: #{name}"
         end
         @name = name.freeze
         freeze

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

@@ -234,7 +234,7 @@ module RuboCop
           when 'key'       then KeyAlignment.new
           when 'table'     then TableAlignment.new
           when 'separator' then SeparatorAlignment.new
-          else fail "Unknown #{key}: #{cop_config[key]}"
+          else raise "Unknown #{key}: #{cop_config[key]}"
           end
         end
 

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

@@ -44,7 +44,7 @@ module RuboCop
             indentation_of_line = /\S.*/.match(line).begin(0)
             indentation_of_line + configured_indentation_width
           else
-            args.first.loc.column
+            display_column(args.first.source_range)
           end
         end
 

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

@@ -91,7 +91,7 @@ module RuboCop
             elsif node.loc.selector.source == 'not'
               return correct_other(node, corrector)
             else
-              fail 'unrecognized unary negation operator'
+              raise 'unrecognized unary negation operator'
             end
           end
           return unless correctable_send?(node)

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

@@ -23,6 +23,7 @@ module RuboCop
 
           lambda do |corrector|
             corrector.remove(eq_begin)
+            # rubocop:disable Style/ZeroLengthPredicate
             unless contents.length == 0
               corrector.replace(contents,
                                 contents.source
@@ -30,6 +31,7 @@ module RuboCop
                                   .gsub(/\n\n/, "\n#\n")
                                   .gsub(/\n(?=[^\z#])/, "\n# "))
             end
+            # rubocop:enable Style/ZeroLengthPredicate
             corrector.remove(eq_end)
           end
         end

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

@@ -46,6 +46,8 @@ module RuboCop
             "#{node.children[0].source} &&= "
           when :or_asgn
             "#{node.children[0].source} ||= "
+          when :casgn
+            "#{node.children[1]} = "
           when *ConditionalAssignment::VARIABLE_ASSIGNMENT_TYPES
             "#{node.children[0]} = "
           else

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

@@ -69,10 +69,10 @@ module RuboCop
         end
 
         def autocorrect(token)
-          fail Warning, 'An AutocorrectNotice must be defined in ' \
+          raise Warning, 'An AutocorrectNotice must be defined in ' \
             'your RuboCop config' if autocorrect_notice.empty?
           regex = Regexp.new(notice)
-          fail Warning, "AutocorrectNotice '#{autocorrect_notice}' must " \
+          raise Warning, "AutocorrectNotice '#{autocorrect_notice}' must " \
             "match Notice /#{notice}/" unless autocorrect_notice =~ regex
 
           lambda do |corrector|

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

@@ -19,37 +19,29 @@ module RuboCop
 
         def_node_matcher :constant_definition?, '{class module casgn}'
 
-        def investigate(processed_source)
-          ast = processed_source.ast
-          return unless ast
+        def on_class(node)
+          _name, _superclass, body = *node
+          return unless body
+          return if namespace?(body)
+
+          ast_with_comments = processed_source.ast_with_comments
+          return if associated_comment?(node, ast_with_comments)
+          return if nodoc_comment?(node, ast_with_comments)
+          add_offense(node, :keyword, format(MSG, :class))
+        end
 
-          ast_with_comments = Parser::Source::Comment.associate(
-            ast,
-            processed_source.comments
-          )
+        def on_module(node)
+          _name, body = *node
+          return if namespace?(body)
 
-          check(ast, ast_with_comments)
+          ast_with_comments = processed_source.ast_with_comments
+          return if associated_comment?(node, ast_with_comments)
+          return if nodoc_comment?(node, ast_with_comments)
+          add_offense(node, :keyword, format(MSG, :module))
         end
 
         private
 
-        def check(ast, ast_with_comments)
-          ast.each_node(:class, :module) do |node|
-            case node.type
-            when :class
-              _name, _superclass, body = *node
-            when :module
-              _name, body = *node
-            end
-
-            next if node.type == :class && !body
-            next if namespace?(body)
-            next if associated_comment?(node, ast_with_comments)
-            next if nodoc?(node, ast_with_comments)
-            add_offense(node, :keyword, format(MSG, node.type.to_s))
-          end
-        end
-
         def namespace?(body_node)
           return false unless body_node
 
@@ -77,8 +69,6 @@ module RuboCop
         end
 
         def preceding_comments(node, ast_with_comments)
-          return [] unless node && ast_with_comments
-
           ast_with_comments[node].select { |c| c.loc.line < node.loc.line }
         end
 
@@ -93,7 +83,7 @@ module RuboCop
         # proceeds to check its ancestors for :nodoc: all.
         # Note: How end-of-line comments are associated with code changed in
         # parser-2.2.0.4.
-        def nodoc?(node, ast_with_comments, require_all = false)
+        def nodoc_comment?(node, ast_with_comments, require_all = false)
           return false unless node
           nodoc_node = node.children.first
           return false unless nodoc_node
@@ -104,7 +94,7 @@ module RuboCop
             return true if comment.text =~ regex
           end
 
-          nodoc?(node.ancestors.first, ast_with_comments, true)
+          nodoc_comment?(node.ancestors.first, ast_with_comments, true)
         end
       end
     end

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

@@ -5,7 +5,7 @@ module RuboCop
   module Cop
     module Style
       # This cop looks for inject / reduce calls where the passed in object is
-      # returned at the end and so could be replace by each_with_object without
+      # returned at the end and so could be replaced by each_with_object without
       # the need to return the object at the end.
       #
       # However, we can't replace with each_with_object if the accumulator

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

@@ -87,7 +87,7 @@ module RuboCop
           return unless rhs
 
           end_config = config.for_cop('Lint/EndAlignment')
-          style = end_config['Enabled'] ? end_config['AlignWith'] : 'keyword'
+          style = end_config['AlignWith'] || 'keyword'
           base = variable_alignment?(node.loc, rhs, style.to_sym) ? node : rhs
 
           return if rhs.type != :if
@@ -99,7 +99,7 @@ module RuboCop
         def check_alignment(base_range, else_range)
           return unless begins_its_line?(else_range)
 
-          @column_delta = base_range.column - else_range.column
+          @column_delta = effective_column(base_range) - else_range.column
           return if @column_delta == 0
 
           add_offense(else_range, else_range,

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

@@ -40,7 +40,7 @@ module RuboCop
               corrector.insert_before(range, "#{encoding}\n")
             end
           else
-            fail "#{encoding} does not match #{ENCODING_PATTERN}"
+            raise "#{encoding} does not match #{ENCODING_PATTERN}"
           end
         end
 

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

@@ -86,7 +86,7 @@ module RuboCop
           if source.include?("\n")
             previous_code_line(range.line + source.count("\n") + 1) =~ /\S/
           else
-            range.column
+            display_column(range)
           end
         end
 

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

@@ -11,10 +11,9 @@ module RuboCop
       # comment. The frozen string literal comment is only valid in Ruby 2.3+.
       class FrozenStringLiteralComment < Cop
         include ConfigurableEnforcedStyle
+        include FrozenStringLiteral
 
         MSG = 'Missing frozen string literal comment.'.freeze
-        FROZEN_STRING_LITERAL = '# frozen_string_literal:'.freeze
-        FROZEN_STRING_LITERAL_ENABLED = '# frozen_string_literal: true'.freeze
         SHEBANG = '#!'.freeze
 
         def_node_matcher :frozen_strings, '{(send {dstr str} :<< ...)
@@ -30,8 +29,8 @@ module RuboCop
         end
 
         def on_send(node)
-          return if target_ruby_version < 2.3 && RUBY_VERSION < '2.3.0'
           return unless style == :when_needed
+          return if target_ruby_version < 2.3
           return if frozen_string_literal_comment_exists?(processed_source)
 
           frozen_strings(node) { offense(processed_source) }
@@ -52,15 +51,6 @@ module RuboCop
 
         private
 
-        def frozen_string_literal_comment_exists?(processed_source)
-          first_three_lines =
-            [processed_source[0], processed_source[1], processed_source[2]]
-          first_three_lines.compact!
-          first_three_lines.any? do |line|
-            line.start_with?(FROZEN_STRING_LITERAL)
-          end
-        end
-
         def last_special_comment(processed_source)
           token_number = 0
           if processed_source.tokens[token_number].text.start_with?(SHEBANG)

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

@@ -112,8 +112,9 @@ module RuboCop
         def line_too_long?(node, body, keyword, condition)
           max    = config.for_cop('Metrics/LineLength')['Max'] || 80
           indent = node.loc.column
+          source = body && body.source || ''
           # 2 is for spaces on left and right of keyword
-          indent + (body.source + keyword + condition.source).length + 2 > max
+          indent + (source + keyword + condition.source).length + 2 > max
         end
       end
     end

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

@@ -24,18 +24,11 @@ module RuboCop
           return if modifier_if?(node)
           return if elsif?(node)
           return if if_else?(node)
-          return if chained?(node)
+          return if node.chained?
           return unless fit_within_line_as_modifier_form?(node)
           add_offense(node, :keyword, message(node.loc.keyword.source))
         end
 
-        def chained?(node)
-          # Don't register offense for `if ... end.method`
-          return false if node.parent.nil? || !node.parent.send_type?
-          receiver = node.parent.children[0]
-          node.equal?(receiver)
-        end
-
         def parenthesize?(node)
           # Parenthesize corrected expression if changing to modifier-if form
           # would change the meaning of the parent expression

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

@@ -34,7 +34,7 @@ module RuboCop
           return unless node.loc.operator
           return if node.loc.operator.line == rhs.loc.line
 
-          base = node.source_range.column
+          base = display_column(node.source_range)
           check_alignment([rhs], base + configured_indentation_width)
         end
       end

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

@@ -89,11 +89,7 @@ module RuboCop
           *_, body = *args.first
 
           def_end_config = config.for_cop('Lint/DefEndAlignment')
-          style = if def_end_config['Enabled']
-                    def_end_config['AlignWith']
-                  else
-                    'start_of_line'
-                  end
+          style = def_end_config['AlignWith'] || 'start_of_line'
           base = style == 'def' ? args.first : node
 
           check_indentation(base.source_range, body)
@@ -174,7 +170,7 @@ module RuboCop
           return unless rhs
 
           end_config = config.for_cop('Lint/EndAlignment')
-          style = end_config['Enabled'] ? end_config['AlignWith'] : 'keyword'
+          style = end_config['AlignWith'] || 'keyword'
           base = variable_alignment?(node.loc, rhs, style.to_sym) ? node : rhs
 
           case rhs.type
@@ -202,7 +198,7 @@ module RuboCop
         def check_indentation(base_loc, body_node, style = 'normal')
           return unless indentation_to_check?(base_loc, body_node)
 
-          indentation = body_node.loc.column - base_loc.column
+          indentation = body_node.loc.column - effective_column(base_loc)
           @column_delta = configured_indentation_width - indentation
           return if @column_delta == 0
 

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

@@ -19,6 +19,7 @@ module RuboCop
           return unless args.empty? && node.loc.begin
           return if same_name_assignment?(node)
           return if lambda_call_syntax?(node)
+          return if node.keyword_not?
 
           add_offense(node, :begin)
         end
@@ -35,7 +36,7 @@ module RuboCop
         def same_name_assignment?(node)
           _receiver, method_name, *_args = *node
 
-          node.each_ancestor(ASGN_NODES).any? do |asgn_node|
+          node.each_ancestor(*ASGN_NODES).any? do |asgn_node|
             if asgn_node.masgn_type?
               mlhs_node, _mrhs_node = *asgn_node
               asgn_node = mlhs_node.children[node.sibling_index]

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

@@ -69,7 +69,7 @@ module RuboCop
         end
 
         def arguments?(args)
-          args.children.size > 0
+          !args.children.empty?
         end
 
         def parentheses?(args)

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

@@ -38,6 +38,8 @@ module RuboCop
       #       :b
       #     ]
       class MultilineArrayBraceLayout < Cop
+        include MultilineLiteralBraceLayout
+
         SAME_LINE_MESSAGE = 'Closing array brace must be on the same line as ' \
           'the last array element when opening brace is on the same line as ' \
           'the first array element.'.freeze
@@ -47,47 +49,7 @@ module RuboCop
           'from the first array element.'.freeze
 
         def on_array(node)
-          return unless node.loc.begin # Ignore implicit arrays.
-          return if node.children.empty? # Ignore empty arrays.
-
-          if opening_brace_on_same_line?(node)
-            return if closing_brace_on_same_line?(node)
-
-            add_offense(node, :expression, SAME_LINE_MESSAGE)
-          else
-            return unless closing_brace_on_same_line?(node)
-
-            add_offense(node, :expression, NEW_LINE_MESSAGE)
-          end
-        end
-
-        def autocorrect(node)
-          if closing_brace_on_same_line?(node)
-            lambda do |corrector|
-              corrector.insert_before(node.loc.end, "\n".freeze)
-            end
-          else
-            range = Parser::Source::Range.new(
-              node.source_range.source_buffer,
-              node.children.last.source_range.end_pos,
-              node.loc.end.begin_pos)
-
-            ->(corrector) { corrector.remove(range) }
-          end
-        end
-
-        private
-
-        # This method depends on the fact that we have guarded
-        # against implicit and empty arrays.
-        def opening_brace_on_same_line?(node)
-          node.loc.begin.line == node.children.first.loc.first_line
-        end
-
-        # This method depends on the fact that we have guarded
-        # against implicit and empty arrays.
-        def closing_brace_on_same_line?(node)
-          node.loc.end.line == node.children.last.loc.last_line
+          check_brace_layout(node)
         end
       end
     end