rubocop 0.33.0 → 0.34.0

data/lib/rubocop/cop/commissioner.rb

@@ -46,15 +46,12 @@ module RuboCop
 
       def investigate(processed_source)
         reset_errors
+        remove_irrelevant_cops(processed_source.buffer.name)
         prepare(processed_source)
         invoke_custom_processing(@cops, processed_source)
         invoke_custom_processing(@forces, processed_source)
         process(processed_source.ast) if processed_source.ast
-        @cops.each_with_object([]) do |cop, offenses|
-          filename = processed_source.buffer.name
-          # ignore files that are of no interest to the cop in question
-          offenses.concat(cop.offenses) if cop.relevant_file?(filename)
-        end
+        @cops.flat_map(&:offenses)
       end
 
       private
@@ -63,6 +60,10 @@ module RuboCop
         @errors = Hash.new { |hash, k| hash[k] = [] }
       end
 
+      def remove_irrelevant_cops(filename)
+        @cops.reject! { |cop| cop.excluded_file?(filename) }
+      end
+
       # TODO: Bad design.
       def prepare(processed_source)
         @cops.each { |cop| cop.processed_source = processed_source }
@@ -76,12 +77,6 @@ module RuboCop
         cops_or_forces.each do |cop|
           next unless cop.respond_to?(:investigate)
 
-          if cop.respond_to?(:relevant_file?)
-            # ignore files that are of no interest to the cop in question
-            filename = processed_source.buffer.name
-            next unless cop.relevant_file?(filename)
-          end
-
           with_cop_error_handling(cop) do
             cop.investigate(processed_source)
           end

data/lib/rubocop/cop/cop.rb

@@ -198,6 +198,10 @@ module RuboCop
           !file_name_matches_any?(file, 'Exclude', false)
       end
 
+      def excluded_file?(file)
+        !relevant_file?(file)
+      end
+
       def style_guide_url
         url = cop_config && cop_config['StyleGuide']
         (url.nil? || url.empty?) ? nil : url
@@ -249,9 +253,9 @@ module RuboCop
         if Severity::NAMES.include?(severity.to_sym)
           severity.to_sym
         else
-          warn("Warning: Invalid severity '#{severity}'. " +
-               "Valid severities are #{Severity::NAMES.join(', ')}."
-               .color(:red))
+          message = "Warning: Invalid severity '#{severity}'. " \
+            "Valid severities are #{Severity::NAMES.join(', ')}."
+          warn(Rainbow(message).red)
         end
       end
     end

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

@@ -5,12 +5,12 @@ module RuboCop
     module Lint
       # This cop checks for uses of the deprecated class method usages.
       class DeprecatedClassMethods < Cop
-        include AST::Sexp
-
         # Inner class to DeprecatedClassMethods.
         # This class exists to add abstraction and clean naming to the
         # objects that are going to be operated on.
         class DeprecatedClassMethod
+          include AST::Sexp
+
           attr_reader :class_constant, :deprecated_method, :replacement_method
 
           def initialize(class_constant, deprecated_method, replacement_method)
@@ -18,6 +18,13 @@ module RuboCop
             @deprecated_method = deprecated_method
             @replacement_method = replacement_method
           end
+
+          def class_nodes
+            @class_nodes ||= [
+              s(:const, nil, class_constant),
+              s(:const, s(:cbase), class_constant)
+            ]
+          end
         end
 
         MSG = '`%s` is deprecated in favor of `%s`.'
@@ -50,18 +57,13 @@ module RuboCop
           receiver, method_name, *_args = *node
 
           DEPRECATED_METHODS_OBJECT.each do |data|
-            next unless class_nodes(data).include?(receiver)
+            next unless data.class_nodes.include?(receiver)
             next unless method_name == data.deprecated_method
 
             block.call(data)
           end
         end
 
-        def class_nodes(data)
-          [s(:const, nil, data.class_constant),
-           s(:const, s(:cbase), data.class_constant)]
-        end
-
         def deprecated_method(data)
           method_call(data.class_constant, data.deprecated_method)
         end

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

@@ -0,0 +1,37 @@
+# encoding: utf-8
+
+module RuboCop
+  module Cop
+    module Lint
+      # This cop checks for duplicated keys in hash literals.
+      #
+      # This cop mirrors a warning in Ruby 2.2.
+      #
+      # @example
+      #   hash = { food: 'apple', food: 'orange' }
+      class DuplicatedKey < Cop
+        MSG = 'Duplicated key in hash literal.'
+
+        LITERALS = [:sym, :str, :float, :int]
+
+        def on_hash(node)
+          keys = []
+
+          hash_pairs = *node
+          hash_pairs.each do |pair|
+            key, _value = *pair
+            if keys.include?(key) && LITERALS.include?(key.type)
+              add_offense(key, :expression)
+            elsif keys.include?(key) && key.type == :array
+              key.children.each do |child|
+                return false unless LITERALS.include?(child.type)
+              end
+              add_offense(key, :expression)
+            end
+            keys << key
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -40,6 +40,10 @@ module RuboCop
           check_offset_of_node(node)
         end
 
+        def on_case(node)
+          check_offset_of_node(node)
+        end
+
         private
 
         def check_assignment(node, rhs)
@@ -50,11 +54,11 @@ module RuboCop
 
           return unless rhs
 
-          return unless [:if, :while, :until].include?(rhs.type)
+          return unless [:if, :while, :until, :case].include?(rhs.type)
           return if ternary_op?(rhs)
 
           expr = node.loc.expression
-          if style == :variable && !line_break_before_keyword?(expr, rhs)
+          if variable_alignment?(expr, rhs, style)
             range = Parser::Source::Range.new(expr.source_buffer,
                                               expr.begin_pos,
                                               rhs.loc.keyword.end_pos)
@@ -68,10 +72,6 @@ module RuboCop
           ignore_node(rhs) # Don't check again.
         end
 
-        def line_break_before_keyword?(whole_expression, rhs)
-          rhs.loc.keyword.line > whole_expression.line
-        end
-
         def autocorrect(node)
           align(node,
                 style == :variable ? node.each_ancestor(:lvasgn).first : node)

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

@@ -12,12 +12,14 @@ module RuboCop
       #   format('A value: %s and another: %i', a_value)
       #
       class FormatParameterMismatch < Cop
-        # http://rubular.com/r/HdWs2uXZv4
+        # http://rubular.com/r/CvpbxkcTzy
         MSG = 'Number arguments (%i) to `%s` mismatches expected fields (%i).'
-        FIELDS_REGEX = /%([\s#+-0\*])?([0-9]*)?(.[0-9]+)?[bBdiouxXeEfgGacps]/
+        # rubocop:disable Metrics/LineLength
+        FIELD_REGEX = /(%(([\s#+-0\*])?(\d*)?(.\d+)?(\.)?[bBdiouxXeEfgGaAcps]|%))/
+        NAMED_FIELD_REGEX = /%\{[_a-zA-Z][_a-zA-Z]+\}/
 
         def fields_regex
-          FIELDS_REGEX
+          FIELD_REGEX
         end
 
         def on_send(node)
@@ -28,22 +30,55 @@ module RuboCop
 
         def offending_node?(node)
           if sprintf?(node) || format?(node) || percent?(node)
-            num_of_args_for_format, num_of_expected_fields = count_matches(node)
-            num_of_expected_fields != num_of_args_for_format
+            if named_mode?(node)
+              false
+            else
+              num_of_args_for_format, num_of_expected_fields = count_matches(node)
+              num_of_expected_fields != num_of_args_for_format
+            end
           else
             false
           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).count > 0
+        end
+
+        def heredoc?(node)
+          _receiver, _name, args = *node
+
+          args.loc.expression.source[0, 2] == '<<'
+        end
+
         def count_matches(node)
           receiver_node, _method_name, *args = *node
 
-          if sprintf?(node) || format?(node)
+          if (sprintf?(node) || format?(node)) && !heredoc?(node)
             number_of_args_for_format = (args.size - 1)
-            number_of_expected_fields = expected_fields(args.first).size
+            number_of_expected_fields = expected_fields_count(args.first)
           elsif percent?(node)
-            number_of_args_for_format = args.first.child_nodes.size
-            number_of_expected_fields = expected_fields(receiver_node).size
+            first_child_argument = args.first
+
+            if first_child_argument.type == :array
+              number_of_args_for_format = args.first.child_nodes.size
+              number_of_expected_fields = expected_fields_count(receiver_node)
+            else
+              number_of_args_for_format = 1
+              number_of_expected_fields = expected_fields_count(receiver_node)
+            end
           end
 
           [number_of_args_for_format, number_of_expected_fields]
@@ -58,12 +93,14 @@ module RuboCop
           args.size > 1 && :str == args.first.type
         end
 
-        def expected_fields(node)
+        def expected_fields_count(node)
           node
             .loc
             .expression
             .source
-            .scan(FIELDS_REGEX)
+            .scan(FIELD_REGEX)
+            .select { |x| x.first != '%%' }
+            .reduce(0) { |a, e| a + (e[2] == '*' ? 2 : 1) }
         end
 
         def format?(node)
@@ -77,9 +114,15 @@ module RuboCop
         def percent?(node)
           receiver_node, method_name, *arg_nodes = *node
 
-          method_name == :% &&
-            ([:str, :dstr].include?(receiver_node.type) ||
-             arg_nodes[0].type == :array)
+          percent = method_name == :% &&
+                    ([:str, :dstr].include?(receiver_node.type) ||
+                     arg_nodes[0].type == :array)
+
+          if percent && [:str, :dstr].include?(receiver_node.type)
+            return false if heredoc?(node)
+          end
+
+          percent
         end
 
         def message(node)

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/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,10 +6,20 @@ 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
@@ -35,7 +45,7 @@ module RuboCop
       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)

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

@@ -13,7 +13,7 @@ module RuboCop
       def check_name(node, name, name_range)
         return if operator?(name)
 
-        if valid_name?(name)
+        if valid_name?(node, name)
           correct_style_detected
         else
           add_offense(node, name_range, message(style)) do
@@ -22,9 +22,20 @@ module RuboCop
         end
       end
 
-      def valid_name?(name)
+      def valid_name?(node, name)
         pattern = (style == :snake_case ? SNAKE_CASE : CAMEL_CASE)
-        name.match(pattern)
+        name.match(pattern) || class_emitter_method?(node, name)
+      end
+
+      # A class emitter method is a singleton method in a class/module, where
+      # the method has the same name as a class defined in the class/module.
+      def class_emitter_method?(node, name)
+        return false unless node.defs_type?
+        return false unless node.parent
+
+        node.parent.children.any? do |c|
+          c.class_type? && c.loc.name.is?(name.to_s)
+        end
       end
     end
   end

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

@@ -34,9 +34,7 @@ module RuboCop
         def check_source(start_line, end_line)
           case style
           when :no_empty_lines
-            check_both(start_line, end_line, MSG_EXTRA) do |line|
-              line.empty?
-            end
+            check_both(start_line, end_line, MSG_EXTRA, &:empty?)
           when :empty_lines
             check_both(start_line, end_line, MSG_MISSING) do |line|
               !line.empty?

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

@@ -38,6 +38,15 @@ module RuboCop
         'AlignWith'
       end
 
+      def variable_alignment?(whole_expression, rhs, end_alignment_style)
+        end_alignment_style == :variable &&
+          !line_break_before_keyword?(whole_expression, rhs)
+      end
+
+      def line_break_before_keyword?(whole_expression, rhs)
+        rhs.loc.line > whole_expression.line
+      end
+
       def align(node, alignment_node)
         source_buffer = node.loc.expression.source_buffer
         begin_pos = node.loc.end.begin_pos

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

@@ -0,0 +1,28 @@
+# encoding: utf-8
+
+module RuboCop
+  module Cop
+    # Common code for cops that deal with preferred methods.
+    module MethodPreference
+      def preferred_method(method)
+        preferred_methods[method.to_sym]
+      end
+
+      def preferred_methods
+        @preferred_methods ||=
+          begin
+            # Make sure default configuration 'foo' => 'bar' is removed from
+            # the total configuration if there is a 'bar' => 'foo' override.
+            default = default_cop_config['PreferredMethods']
+            merged = cop_config['PreferredMethods']
+            overrides = merged.values - default.values
+            merged.reject { |key, _| overrides.include?(key) }.symbolize_keys
+          end
+      end
+
+      def default_cop_config
+        ConfigLoader.default_configuration[cop_name]
+      end
+    end
+  end
+end

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

@@ -12,11 +12,11 @@ module RuboCop
 
         child = node.children.first
         case child.type
-        when *Util::EQUALS_ASGN_NODES
-          true
         when :send
           _receiver, method_name, _args = *child
           method_name.to_s.end_with?('=')
+        when *Util::EQUALS_ASGN_NODES
+          true
         else
           false
         end