rubocop 0.31.0 → 0.35.0

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

@@ -0,0 +1,175 @@
+# encoding: utf-8
+
+module RuboCop
+  module Cop
+    module Lint
+      # This lint sees if there is a mismatch between the number of
+      # expected fields for format/sprintf/#% and what is actually
+      # passed as arguments.
+      #
+      # @example
+      #
+      #   format('A value: %s and another: %i', a_value)
+      #
+      class FormatParameterMismatch < Cop
+        # http://rubular.com/r/CvpbxkcTzy
+        MSG = 'Number arguments (%i) to `%s` mismatches expected fields (%i).'
+        FIELD_REGEX = /(%(([\s#+-0\*])?(\d*)?(.\d+)?(\.)?[bBdiouxXeEfgGaAcps]|%))/.freeze # rubocop:disable Metrics/LineLength
+        NAMED_FIELD_REGEX = /%\{[_a-zA-Z][_a-zA-Z]+\}/.freeze
+        KERNEL = 'Kernel'.freeze
+        SHOVEL = '<<'.freeze
+        PERCENT = '%'.freeze
+        PERCENT_PERCENT = '%%'.freeze
+        SPLAT = '*'.freeze
+        STRING_TYPES = [:str, :dstr].freeze
+
+        def on_send(node)
+          add_offense(node, :selector) if offending_node?(node)
+        end
+
+        private
+
+        def offending_node?(node)
+          return false unless called_on_string?(node)
+
+          if sprintf?(node) || format?(node) || percent?(node)
+            if named_mode?(node) || node_with_splat_args?(node)
+              false
+            else
+              num_of_format_args, num_of_expected_fields = count_matches(node)
+
+              num_of_format_args != :unknown &&
+                num_of_expected_fields != :unknown &&
+                num_of_expected_fields != num_of_format_args
+            end
+          else
+            false
+          end
+        end
+
+        def called_on_string?(node)
+          receiver_node, _method, format_string, = *node
+          if receiver_node.nil? || receiver_node.const_type?
+            format_string && format_string.str_type?
+          else
+            receiver_node.str_type?
+          end
+        end
+
+        def named_mode?(node)
+          receiver_node, _method_name, *args = *node
+
+          relevant_node = if sprintf?(node) || format?(node)
+                            args.first
+                          elsif percent?(node)
+                            receiver_node
+                          end
+
+          relevant_node.loc.expression.source.scan(NAMED_FIELD_REGEX).size > 0
+        end
+
+        def node_with_splat_args?(node)
+          return false if percent?(node)
+
+          _receiver_node, _method_name, *args = *node
+
+          args[1..-1].any? { |arg| arg.type == :splat }
+        end
+
+        def heredoc?(node)
+          _receiver, _name, args = *node
+
+          args.loc.expression.source[0, 2] == SHOVEL
+        end
+
+        def literal?(node)
+          node.int_type? ||
+            node.str_type? ||
+            node.sym_type? ||
+            node.float_type? ||
+            node.dstr_type? ||
+            node.dsym_type?
+        end
+
+        def count_matches(node)
+          receiver_node, _method_name, *args = *node
+
+          if (sprintf?(node) || format?(node)) && !heredoc?(node)
+            number_of_args_for_format = (args.size - 1)
+            number_of_expected_fields = expected_fields_count(args.first)
+          elsif percent?(node) && args.first.array_type?
+            number_of_expected_fields = expected_fields_count(receiver_node)
+
+            first_child_argument = args.first
+            if first_child_argument.array_type?
+              number_of_args_for_format = args.first.child_nodes.size
+            elsif literal?(first_child_argument)
+              number_of_args_for_format = 1
+            else
+              # non-literals might evaluate to an Array, or they might not
+              # so we can't tell just how many format args there will be
+              number_of_args_for_format = :unknown
+            end
+          else
+            number_of_args_for_format = number_of_expected_fields = :unknown
+          end
+
+          [number_of_args_for_format, number_of_expected_fields]
+        end
+
+        def format_method?(name, node)
+          receiver, method_name, *args = *node
+
+          if receiver && receiver.const_type?
+            return false unless receiver.loc.name.is?(KERNEL)
+          end
+
+          return false unless method_name == name
+
+          args.size > 1 && args.first.str_type?
+        end
+
+        def expected_fields_count(node)
+          return :unknown unless node.str_type?
+          node
+            .loc
+            .expression
+            .source
+            .scan(FIELD_REGEX)
+            .select { |x| x.first != PERCENT_PERCENT }
+            .reduce(0) { |a, e| a + (e[2] == SPLAT ? 2 : 1) }
+        end
+
+        def format?(node)
+          format_method?(:format, node)
+        end
+
+        def sprintf?(node)
+          format_method?(:sprintf, node)
+        end
+
+        def percent?(node)
+          receiver_node, method_name, *arg_nodes = *node
+
+          percent = method_name == :% &&
+                    (STRING_TYPES.include?(receiver_node.type) ||
+                     arg_nodes[0].array_type?)
+
+          if percent && STRING_TYPES.include?(receiver_node.type)
+            return false if heredoc?(node)
+          end
+
+          percent
+        end
+
+        def message(node)
+          _receiver, method_name, *_args = *node
+          num_args_for_format, num_expected_fields = count_matches(node)
+
+          method_name = 'String#%' if PERCENT == method_name.to_s
+          format(MSG, num_args_for_format, method_name, num_expected_fields)
+        end
+      end
+    end
+  end
+end

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

@@ -20,11 +20,6 @@ module RuboCop
       class LiteralInCondition < Cop
         MSG = 'Literal `%s` appeared in a condition.'
 
-        LITERALS = [:str, :dstr, :int, :float, :array,
-                    :hash, :regexp, :nil, :true, :false]
-
-        BASIC_LITERALS = LITERALS - [:dstr, :array, :hash]
-
         def on_if(node)
           check_for_literal(node)
         end

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

@@ -25,6 +25,12 @@ module RuboCop
           end
         end
 
+        def autocorrect(node)
+          expr = node.parent.loc.expression
+          value = autocorrected_value(node)
+          ->(corrector) { corrector.replace(expr, value) }
+        end
+
         private
 
         def special_keyword?(node)
@@ -32,6 +38,10 @@ module RuboCop
           (node.type == :str && !node.loc.respond_to?(:begin)) ||
             node.loc.expression.is?('__LINE__')
         end
+
+        def autocorrected_value(node)
+          node.str_type? ? node.children.last : node.loc.expression.source
+        end
       end
     end
   end

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

@@ -0,0 +1,31 @@
+# encoding: utf-8
+
+module RuboCop
+  module Cop
+    module Lint
+      # This cop checks for nested method definitions.
+      #
+      # @example
+      #   # `bar` definition actually produces methods in the same scope
+      #   # as the outer `foo` method. Furthermore, the `bar` method
+      #   # will be redefined every time the `foo` is invoked
+      #   def foo
+      #     def bar
+      #     end
+      #   end
+      #
+      class NestedMethodDefinition < Cop
+        include OnMethodDef
+
+        MSG = 'Method definitions must not be nested. ' \
+              'Use `lambda` instead.'
+
+        def on_method_def(node, _method_name, _args, _body)
+          node.each_descendant(:def) do |nested_def_node|
+            add_offense(nested_def_node, :expression)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -5,7 +5,8 @@ module RuboCop
     module Lint
       # This cop checks for non-local exit from iterator, without return value.
       # It warns only when satisfies all of these: `return` doesn't have return
-      # value, block followed by method chain, and block have arguments.
+      # value, the block is preceded by a method chain, the block has arguments,
+      # and the method which receives the block is not `define_method`.
       #
       # @example
       #
@@ -39,6 +40,13 @@ module RuboCop
           return if return_value?(return_node)
           return_node.each_ancestor(:block) do |block_node|
             send_node, args_node, _body_node = *block_node
+
+            # `return` does not exit to outside of lambda block, this is safe.
+            break if lambda?(send_node)
+            # if a proc is passed to `Module#define_method`, `return` will not
+            # cause a non-local exit error
+            break if define_method?(send_node)
+
             next if args_node.children.empty?
             if chained_send?(send_node)
               add_offense(return_node, :keyword)
@@ -55,6 +63,16 @@ module RuboCop
           receiver_node, _selector_node = *send_node
           !receiver_node.nil?
         end
+
+        def lambda?(send_node)
+          receiver_node, selector_node = *send_node
+          receiver_node.nil? && selector_node == :lambda
+        end
+
+        def define_method?(send_node)
+          _receiver, selector = *send_node
+          selector == :define_method
+        end
       end
     end
   end

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

@@ -14,7 +14,7 @@ module RuboCop
 
         def on_send(node)
           _receiver, method_name, args = *node
-          return if operator?(method_name) || method_name.to_s.end_with?('=')
+          return if operator?(method_name) || node.asgn_method_call?
           return unless args && args.loc.expression.source.start_with?('(')
 
           space_length = spaces_before_left_parenthesis(node)

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

@@ -20,7 +20,7 @@ module RuboCop
           _receiver, method_name, *args = *node
           return if args.empty?
           return if operator?(method_name)
-          return if method_name.to_s.end_with?('=')
+          return if node.asgn_method_call?
 
           # Setter calls with parentheses are parsed this way. The parentheses
           # belong to the argument, not the send node.

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

@@ -0,0 +1,72 @@
+# encoding: utf-8
+
+module RuboCop
+  module Cop
+    module Lint
+      # This cop detects instances of rubocop:disable comments that can be
+      # removed without causing any offenses to be reported. It's implemented
+      # as a cop in that it inherits from the Cop base class and calls
+      # add_offense. The unusual part of its implementation is that it doesn't
+      # have any on_* methods or an investigate method. This means that it
+      # doesn't take part in the investigation phase when the other cops do
+      # their work. Instead, it waits until it's called in a later stage of the
+      # execution. The reason it can't be implemented as a normal cop is that
+      # it depends on the results of all other cops to do its work.
+      class UnneededDisable < Cop
+        COP_NAME = 'Lint/UnneededDisable'
+
+        def check(offenses, cop_disabled_line_ranges, comments)
+          unneeded_cops = {}
+          disabled_ranges = cop_disabled_line_ranges[COP_NAME] || [0..0]
+
+          cop_disabled_line_ranges.each do |cop, line_ranges|
+            cop_offenses = offenses.select { |o| o.cop_name == cop }
+            line_ranges.each do |line_range|
+              comment = comments.find { |c| c.loc.line == line_range.begin }
+              unneeded_cop = find_unneeded(comment, offenses, cop, cop_offenses,
+                                           line_range)
+
+              unless all_disabled?(comment)
+                next if ignore_offense?(disabled_ranges, line_range)
+              end
+
+              if unneeded_cop
+                unneeded_cops[comment.loc.expression] ||= Set.new
+                unneeded_cops[comment.loc.expression].add(unneeded_cop)
+              end
+            end
+          end
+
+          add_offenses(unneeded_cops)
+        end
+
+        private
+
+        def find_unneeded(comment, offenses, cop, cop_offenses, line_range)
+          if all_disabled?(comment)
+            'all cops' if offenses.none? { |o| line_range.include?(o.line) }
+          elsif cop_offenses.none? { |o| line_range.include?(o.line) }
+            cop
+          end
+        end
+
+        def all_disabled?(comment)
+          comment.loc.expression.source =~ /rubocop:disable\s+all\b/
+        end
+
+        def ignore_offense?(disabled_ranges, line_range)
+          disabled_ranges.any? do |range|
+            range.include?(line_range.min) && range.include?(line_range.max)
+          end
+        end
+
+        def add_offenses(unneeded_cops)
+          unneeded_cops.each do |range, cops|
+            add_offense(range, range,
+                        "Unnecessary disabling of #{cops.sort.join(', ')}.")
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -16,6 +16,12 @@ module RuboCop
 
         def check_argument(variable)
           return unless variable.block_argument?
+
+          if cop_config['IgnoreEmptyBlocks']
+            _send, _args, body = *variable.scope.node
+            return if body.nil?
+          end
+
           super
         end
 

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

@@ -15,6 +15,14 @@ module RuboCop
 
         def check_argument(variable)
           return unless variable.method_argument?
+          return if variable.keyword_argument? &&
+                    cop_config['AllowUnusedKeywordArguments']
+
+          if cop_config['IgnoreEmptyMethods']
+            _name, _args, body = *variable.scope.node
+            return if body.nil?
+          end
+
           super
         end
 

data/lib/rubocop/cop/metrics/abc_size.rb

@@ -10,16 +10,27 @@ module RuboCop
         include MethodComplexity
 
         MSG = 'Assignment Branch Condition size for %s is too high. [%.4g/%.4g]'
-        BRANCH_NODES = [:send]
-        CONDITION_NODES = CyclomaticComplexity::COUNTED_NODES
+        BRANCH_NODES = [:send].freeze
+        CONDITION_NODES = CyclomaticComplexity::COUNTED_NODES.freeze
 
         private
 
         def complexity(node)
-          a = node.each_node(ASGN_NODES).count
-          b = node.each_node(BRANCH_NODES).count
-          c = node.each_node(CONDITION_NODES).count
-          Math.sqrt(a**2 + b**2 + c**2).round(2)
+          assignment = 0
+          branch = 0
+          condition = 0
+
+          node.each_node do |child|
+            if child.assignment?
+              assignment += 1
+            elsif BRANCH_NODES.include?(child.type)
+              branch += 1
+            elsif CONDITION_NODES.include?(child.type)
+              condition += 1
+            end
+          end
+
+          Math.sqrt(assignment**2 + branch**2 + condition**2).round(2)
         end
       end
     end

data/lib/rubocop/cop/metrics/class_length.rb

@@ -16,7 +16,7 @@ module RuboCop
         private
 
         def message(length, max_length)
-          format('Class definition is too long. [%d/%d]', length, max_length)
+          format('Class has too many lines. [%d/%d]', length, max_length)
         end
       end
     end

data/lib/rubocop/cop/metrics/method_length.rb

@@ -23,9 +23,7 @@ module RuboCop
         def code_length(node)
           lines = node.loc.expression.source.lines.to_a[1..-2] || []
 
-          lines.reject! { |line| irrelevant_line(line) }
-
-          lines.size
+          lines.count { |line| !irrelevant_line(line) }
         end
       end
     end

data/lib/rubocop/cop/metrics/module_length.rb

@@ -16,7 +16,7 @@ module RuboCop
         private
 
         def message(length, max_length)
-          format('Module definition is too long. [%d/%d]', length, max_length)
+          format('Module has too many lines. [%d/%d]', length, max_length)
         end
       end
     end

data/lib/rubocop/cop/metrics/parameter_lists.rb

@@ -27,7 +27,7 @@ module RuboCop
           if count_keyword_args?
             node.children.size
           else
-            node.children.count { |a| a.type != :kwoptarg }
+            node.children.count { |a| ![:kwoptarg, :kwarg].include?(a.type) }
           end
         end
 

data/lib/rubocop/cop/mixin/access_modifier_node.rb

@@ -40,7 +40,7 @@ module RuboCop
       # Returns true when the block node looks like Class or Module.new do ... .
       def class_constructor?(block_node)
         send_node = block_node.children.first
-        receiver_node, method_name, *_ = *send_node
+        receiver_node, method_name, = *send_node
         return false unless method_name == :new
         %w(Class Module).include?(Util.const_name(receiver_node))
       end

data/lib/rubocop/cop/mixin/annotation_comment.rb

@@ -16,8 +16,7 @@ module RuboCop
         def split_comment(comment)
           match = comment.text.match(/^(# ?)([A-Za-z]+)(\s*:)?(\s+)?(\S+)?/)
           return false unless match
-          margin, first_word, colon, space, note = *match.captures
-          [margin, first_word, colon, space, note]
+          match.captures
         end
 
         def keyword_appearance?(first_word, colon, space)

data/lib/rubocop/cop/mixin/autocorrect_alignment.rb

@@ -6,27 +6,51 @@ module RuboCop
     # the left or to the right, amount being determined by the instance
     # variable @column_delta.
     module AutocorrectAlignment
+      SPACE = ' '.freeze
+
       def configured_indentation_width
         config.for_cop('IndentationWidth')['Width']
       end
 
+      def indentation(node)
+        offset(node) + (SPACE * configured_indentation_width)
+      end
+
+      def offset(node)
+        SPACE * node.loc.column
+      end
+
       def check_alignment(items, base_column = nil)
         base_column ||= items.first.loc.column unless items.empty?
         prev_line = -1
         items.each do |current|
           if current.loc.line > prev_line && start_of_line?(current.loc)
             @column_delta = base_column - current.loc.column
-            add_offense(current, :expression) if @column_delta != 0
+            if @column_delta != 0
+              expr = current.loc.expression
+              if offenses.any? { |o| within?(expr, o.location) }
+                # If this offense is within a line range that is already being
+                # realigned by autocorrect, we report the offense without
+                # autocorrecting it. Two rewrites in the same area by the same
+                # cop can not be handled. The next iteration will find the
+                # offense again and correct it.
+                add_offense(nil, expr)
+              else
+                add_offense(current, :expression)
+              end
+            end
           end
           prev_line = current.loc.line
         end
       end
 
       def start_of_line?(loc)
-        loc.expression.source_line[0...loc.column] =~ /^\s*$/
+        loc.expression.source_line[0...loc.column].blank?
       end
 
       def autocorrect(arg)
+        return unless arg
+
         heredoc_ranges = heredoc_ranges(arg)
         expr = arg.respond_to?(:loc) ? arg.loc.expression : arg
 
@@ -58,7 +82,7 @@ module RuboCop
             corrector.insert_before(range, ' ' * column_delta)
           end
         else
-          remove(range, corrector) if range.source =~ /^[ \t]+$/
+          remove(range, corrector) if range.source =~ /\A[ \t]+\z/
         end
       end
 
@@ -75,7 +99,7 @@ module RuboCop
       end
 
       def block_comment_within?(expr)
-        processed_source.comments.select(&:document?).find do |c|
+        processed_source.comments.select(&:document?).any? do |c|
           within?(c.loc.expression, expr)
         end
       end

data/lib/rubocop/cop/mixin/autocorrect_unless_changing_ast.rb

@@ -5,6 +5,10 @@ module RuboCop
     # This module does auto-correction of nodes that could become grammatically
     # different after the correction. If the code change would alter the
     # abstract syntax tree, it is not done.
+    #
+    # However, if the code change merely introduces extraneous "begin" nodes
+    # which do not change the meaning of the code, it is still accepted.
+    #
     module AutocorrectUnlessChangingAST
       def autocorrect(node)
         current_buffer_src = processed_source.buffer.source
@@ -12,11 +16,12 @@ module RuboCop
         pre = current_buffer_src[0...replaced_range.begin_pos]
         post = current_buffer_src[replaced_range.end_pos..-1]
         new_buffer_src = pre + rewrite_node(node) + post
+        new_processed_src = ProcessedSource.new(new_buffer_src)
 
         # Make the correction only if it doesn't change the AST for the buffer.
-        if processed_source.ast != ProcessedSource.new(new_buffer_src).ast
-          return
-        end
+        return if !new_processed_src.ast ||
+                  (INLINE_BEGIN.process(processed_source.ast) !=
+                   INLINE_BEGIN.process(new_processed_src.ast))
 
         correction(node)
       end
@@ -28,6 +33,24 @@ module RuboCop
         c = correction(ps.ast)
         Corrector.new(ps.buffer, [c]).rewrite
       end
+
+      # 'begin' nodes with a single child can be removed without changing
+      # the semantics of an AST. Canonicalizing an AST in this way can help
+      # us determine whether it has really changed in a meaningful way, or
+      # not. This means we can auto-correct in cases where we would otherwise
+      # refrain from doing so.
+      #
+      # If any other simplifications can be done to an AST without changing
+      # its meaning, they should be added here (and the class renamed).
+      # This will make autocorrection more powerful across the board.
+      #
+      class InlineBeginNodes < Parser::AST::Processor
+        def on_begin(node)
+          node.children.one? ? node.children[0] : node
+        end
+      end
+
+      INLINE_BEGIN = InlineBeginNodes.new
     end
   end
 end

data/lib/rubocop/cop/mixin/check_assignment.rb

@@ -23,13 +23,12 @@ module RuboCop
       end
 
       def on_send(node)
-        _receiver, method_name, *_, rhs = *node
-
         # we only want to indent relative to the receiver
         # when the method called looks like a setter
-        return unless method_name.to_s.end_with?('=')
+        return unless node.asgn_method_call?
 
         # This will match if, case, begin, blocks, etc.
+        rhs = node.children.last
         check_assignment(node, rhs) if rhs.is_a?(AST::Node)
       end
     end