rubocop 0.32.1 → 0.33.0

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

@@ -20,7 +20,7 @@ module RuboCop
         include OnMethodDef
         include EndKeywordAlignment
 
-        MSG = '`end` at %d, %d is not aligned with `%s` at %d, %d'
+        MSG = '`end` at %d, %d is not aligned with `%s` at %d, %d.'
 
         def on_method_def(node, _method_name, _args, _body)
           check_offset_of_node(node)
@@ -28,8 +28,8 @@ module RuboCop
 
         def on_send(node)
           receiver, method_name, *args = *node
-          return unless visibility_and_def_on_same_line?(receiver, method_name,
-                                                         args)
+          return unless modifier_and_def_on_same_line?(receiver, method_name,
+                                                       args)
 
           method_def = args.first
           if style == :start_of_line
@@ -49,7 +49,11 @@ module RuboCop
         private
 
         def autocorrect(node)
-          align(node, style == :start_of_line ? node.ancestors.first : node)
+          if style == :start_of_line && node.parent && node.parent.send_type?
+            align(node, node.parent)
+          else
+            align(node, node)
+          end
         end
       end
     end

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

@@ -7,20 +7,27 @@ module RuboCop
       class DeprecatedClassMethods < Cop
         include AST::Sexp
 
-        MSG = '`%s` is deprecated in favor of `%s`.'
+        # 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
+          attr_reader :class_constant, :deprecated_method, :replacement_method
 
-        DEPRECATED_METHODS = [
-          [:File, :exists?, :exist?],
-          [:Dir, :exists?, :exist?]
+          def initialize(class_constant, deprecated_method, replacement_method)
+            @class_constant = class_constant
+            @deprecated_method = deprecated_method
+            @replacement_method = replacement_method
+          end
+        end
+
+        MSG = '`%s` is deprecated in favor of `%s`.'
+        DEPRECATED_METHODS_OBJECT = [
+          DeprecatedClassMethod.new(:File, :exists?, :exist?),
+          DeprecatedClassMethod.new(:Dir, :exists?, :exist?)
         ]
 
         def on_send(node)
-          receiver, method_name, *_args = *node
-
-          DEPRECATED_METHODS.each do |data|
-            next unless class_nodes(data).include?(receiver)
-            next unless method_name == data[1]
-
+          check(node) do |data|
             add_offense(node, :selector,
                         format(MSG,
                                deprecated_method(data),
@@ -30,31 +37,41 @@ module RuboCop
 
         def autocorrect(node)
           lambda do |corrector|
-            receiver, method_name, *_args = *node
-
-            DEPRECATED_METHODS.each do |data|
-              next unless class_nodes(data).include?(receiver)
-              next unless method_name == data[1]
-
+            check(node) do |data|
               corrector.replace(node.loc.selector,
-                                data[2].to_s)
+                                data.replacement_method.to_s)
             end
           end
         end
 
         private
 
+        def check(node, &block)
+          receiver, method_name, *_args = *node
+
+          DEPRECATED_METHODS_OBJECT.each do |data|
+            next unless class_nodes(data).include?(receiver)
+            next unless method_name == data.deprecated_method
+
+            block.call(data)
+          end
+        end
+
         def class_nodes(data)
-          [s(:const, nil, data[0]),
-           s(:const, s(:cbase), data[0])]
+          [s(:const, nil, data.class_constant),
+           s(:const, s(:cbase), data.class_constant)]
         end
 
         def deprecated_method(data)
-          format('%s.%s', data[0], data[1])
+          method_call(data.class_constant, data.deprecated_method)
         end
 
         def replacement_method(data)
-          format('%s.%s', data[0], data[2])
+          method_call(data.class_constant, data.replacement_method)
+        end
+
+        def method_call(class_constant, method)
+          format('%s.%s', class_constant, method)
         end
       end
     end

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

@@ -65,7 +65,7 @@ module RuboCop
 
         def method_names(body)
           body.child_nodes.map do |node|
-            _receiver, node, body  = *node if node.send_type?
+            _receiver, node, body = *node if node.send_type?
 
             if node.is_a? Symbol
               next if body.nil?

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

@@ -0,0 +1,95 @@
+# 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/HdWs2uXZv4
+        MSG = 'Number arguments (%i) to `%s` mismatches expected fields (%i).'
+        FIELDS_REGEX = /%([\s#+-0\*])?([0-9]*)?(.[0-9]+)?[bBdiouxXeEfgGacps]/
+
+        def fields_regex
+          FIELDS_REGEX
+        end
+
+        def on_send(node)
+          add_offense(node, :selector) if offending_node?(node)
+        end
+
+        private
+
+        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
+          else
+            false
+          end
+        end
+
+        def count_matches(node)
+          receiver_node, _method_name, *args = *node
+
+          if sprintf?(node) || format?(node)
+            number_of_args_for_format = (args.size - 1)
+            number_of_expected_fields = expected_fields(args.first).size
+          elsif percent?(node)
+            number_of_args_for_format = args.first.child_nodes.size
+            number_of_expected_fields = expected_fields(receiver_node).size
+          end
+
+          [number_of_args_for_format, number_of_expected_fields]
+        end
+
+        def format_method?(name, node)
+          receiver, method_name, *args = *node
+
+          # commands have no explicit receiver
+          return false unless !receiver && method_name == name
+
+          args.size > 1 && :str == args.first.type
+        end
+
+        def expected_fields(node)
+          node
+            .loc
+            .expression
+            .source
+            .scan(FIELDS_REGEX)
+        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
+
+          method_name == :% &&
+            ([:str, :dstr].include?(receiver_node.type) ||
+             arg_nodes[0].type == :array)
+        end
+
+        def message(node)
+          _receiver, method_name, *_args = *node
+          num_args_for_format, num_expected_fields = count_matches(node)
+
+          method_name = 'String#%' if '%' == method_name.to_s
+          format(MSG, num_args_for_format, method_name, num_expected_fields)
+        end
+      end
+    end
+  end
+end

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

@@ -6,7 +6,7 @@ module RuboCop
     module EndKeywordAlignment
       include ConfigurableEnforcedStyle
 
-      MSG = '`end` at %d, %d is not aligned with `%s` at %d, %d'
+      MSG = '`end` at %d, %d is not aligned with `%s` at %d, %d.'
 
       private
 

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

@@ -19,12 +19,11 @@ module RuboCop
       # Returns true for constructs such as
       # private def my_method
       # which are allowed in Ruby 2.1 and later.
-      def visibility_and_def_on_same_line?(receiver, method_name, args)
+      def modifier_and_def_on_same_line?(receiver, method_name, args)
         !receiver &&
-          [:public, :protected, :private,
-           :private_class_method, :public_class_method,
-           :module_function].include?(method_name) &&
-          args.size == 1 && [:def, :defs].include?(args.first.type)
+          method_name != :def &&
+          args.size == 1 &&
+          [:def, :defs].include?(args.first.type)
       end
     end
   end

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

@@ -12,7 +12,7 @@ module RuboCop
         if style == :single_quotes
           src !~ /'/ && src !~ StringHelp::ESCAPED_CHAR_REGEXP
         else
-          src !~ /" | \\/x
+          src !~ /" | \\ | \#/x
         end
       end
 

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

@@ -68,6 +68,8 @@ module RuboCop
             if selector.is_a?(Symbol)
               if expression && expression.parent.loc.respond_to?(:selector)
                 expression.parent.loc.selector
+              else
+                left.loc.selector if left.loc.respond_to?(:selector)
               end
             else
               _enumerable, selector, params = *expression

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

@@ -22,21 +22,24 @@ module RuboCop
         REVERSE_MSG = 'Use `reverse.%s` instead of `%s.%s`.'
 
         SELECT_METHODS = [:select, :find_all]
+        DANGEROUS_METHODS = [:first, :last]
 
         def on_send(node)
           receiver, second_method = *node
-          return unless second_method == :first || second_method == :last
           return if receiver.nil?
+          return unless DANGEROUS_METHODS.include?(second_method)
 
           receiver, _args, body = *receiver if receiver.block_type?
 
-          _, first_method, args = *receiver
+          caller, first_method, args = *receiver
 
           # check that we have usual block or block pass
           return if body.nil? && (args.nil? || !args.block_pass_type?)
 
           return unless SELECT_METHODS.include?(first_method)
 
+          return if lazy?(caller)
+
           range = receiver.loc.selector.join(node.loc.selector)
 
           message = second_method == :last ? REVERSE_MSG : MSG
@@ -70,6 +73,12 @@ module RuboCop
           config.for_cop('Style/CollectionMethods') \
             ['PreferredMethods']['detect'] || 'detect'
         end
+
+        def lazy?(node)
+          return false if node.nil?
+          receiver, method, _args = *node
+          method == :lazy && !receiver.nil?
+        end
       end
     end
   end

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

@@ -18,11 +18,11 @@ module RuboCop
         MSG = 'Use `flat_map` instead of `%s...%s`.'
         FLATTEN_MULTIPLE_LEVELS = ' Beware, `flat_map` only flattens 1 level ' \
                                   'and `flatten` can be used to flatten ' \
-                                  'multiple levels'
+                                  'multiple levels.'
         FLATTEN = [:flatten, :flatten!]
 
         def on_send(node)
-          left, second_method, flatten_param  = *node
+          left, second_method, flatten_param = *node
           return unless FLATTEN.include?(second_method)
           flatten_level, = *flatten_param
           expression, = *left
@@ -44,7 +44,7 @@ module RuboCop
         end
 
         def autocorrect(node)
-          receiver, _flatten, flatten_param  = *node
+          receiver, _flatten, flatten_param = *node
           flatten_level, = *flatten_param
           return if flatten_level.nil?
 

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

@@ -0,0 +1,161 @@
+# encoding: utf-8
+
+module RuboCop
+  module Cop
+    module Performance
+      # This cop identifies places where `gsub` can be replaced by
+      # `tr` or `delete`.
+      #
+      # @example
+      #   @bad
+      #   'abc'.gsub('b', 'd')
+      #   'abc'.gsub('a', '')
+      #   'abc'.gsub(/a/, 'd')
+      #   'abc'.gsub!('a', 'd')
+      #
+      #   @good
+      #   'abc'.gsub(/.*/, 'a')
+      #   'abc'.gsub(/a+/, 'd')
+      #   'abc'.tr('b', 'd')
+      #   'a b c'.delete(' ')
+      class StringReplacement < Cop
+        MSG = 'Use `%s` instead of `%s`.'
+        DETERMINISTIC_REGEX = /^[\w\s\-,."']+$/
+        REGEXP_CONSTRUCTOR_METHODS = [:new, :compile]
+        GSUB_METHODS = [:gsub, :gsub!]
+        DETERMINISTIC_TYPES = [:regexp, :str, :send]
+
+        def on_send(node)
+          _string, method, first_param, second_param = *node
+          return unless GSUB_METHODS.include?(method)
+          return unless second_param && second_param.str_type?
+          return unless DETERMINISTIC_TYPES.include?(first_param.type)
+
+          first_source = first_source(first_param)
+          second_source, = *second_param
+
+          return if first_source.nil?
+
+          if regex?(first_param)
+            return unless first_source =~ DETERMINISTIC_REGEX
+          end
+
+          return if first_source.length != 1
+          return unless second_source.length <= 1
+
+          message = message(method, first_source, second_source)
+          add_offense(node, range(node), message)
+        end
+
+        def autocorrect(node)
+          _string, method, first_param, second_param = *node
+          first_source = first_source(first_param)
+          second_source, = *second_param
+          replacement_method = replacement_method(first_source, second_source)
+
+          lambda do |corrector|
+            replacement =
+              if second_source.empty? && first_source.length == 1
+                "#{replacement_method}#{'!' if bang_method?(method)}" \
+                "(#{escape(first_source)})"
+              else
+                "#{replacement_method}#{'!' if bang_method?(method)}" \
+                "(#{escape(first_source)}, #{escape(second_source)})"
+              end
+
+            corrector.replace(range(node), replacement)
+          end
+        end
+
+        private
+
+        def first_source(first_param)
+          case first_param.type
+          when :regexp, :send
+            return nil unless regex?(first_param)
+
+            source, = extract_source(first_param)
+          when :str
+            source, = *first_param
+          end
+
+          source
+        end
+
+        def extract_source(node)
+          case node.type
+          when :regexp
+            source_from_regex_literal(node)
+          when :send
+            source_from_regex_constructor(node)
+          end
+        end
+
+        def source_from_regex_literal(node)
+          regex, = *node
+          source, = *regex
+          source
+        end
+
+        def source_from_regex_constructor(node)
+          _const, _init, regex = *node
+          case regex.type
+          when :regexp
+            source_from_regex_literal(regex)
+          when :str
+            source, = *regex
+            source
+          end
+        end
+
+        def regex?(node)
+          return true if node.regexp_type?
+
+          const, init, = *node
+          _, klass = *const
+
+          klass == :Regexp && REGEXP_CONSTRUCTOR_METHODS.include?(init)
+        end
+
+        def range(node)
+          Parser::Source::Range.new(node.loc.expression.source_buffer,
+                                    node.loc.selector.begin_pos,
+                                    node.loc.expression.end_pos)
+        end
+
+        def replacement_method(first_source, second_source)
+          if second_source.empty? && first_source.length == 1
+            'delete'
+          else
+            'tr'
+          end
+        end
+
+        def message(method, first_source, second_source)
+          replacement_method = replacement_method(first_source, second_source)
+
+          format(MSG,
+                 "#{replacement_method}#{'!' if bang_method?(method)}",
+                 method)
+        end
+
+        def bang_method?(method)
+          method.to_s.end_with?('!')
+        end
+
+        def escape(string)
+          if require_double_quotes?(string)
+            string.inspect
+          else
+            "'#{string}'"
+          end
+        end
+
+        def require_double_quotes?(string)
+          /'/ =~ string.inspect ||
+            StringHelp::ESCAPED_CHAR_REGEXP =~ string.inspect
+        end
+      end
+    end
+  end
+end