rubocop 0.35.1 → 0.36.0

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

@@ -1,4 +1,5 @@
 # encoding: utf-8
+# frozen_string_literal: true
 
 module RuboCop
   module Cop
@@ -18,11 +19,11 @@ module RuboCop
       #   [].detect { |item| true }
       #   [].reverse.detect { |item| true }
       class Detect < Cop
-        MSG = 'Use `%s` instead of `%s.%s`.'
-        REVERSE_MSG = 'Use `reverse.%s` instead of `%s.%s`.'
+        MSG = 'Use `%s` instead of `%s.%s`.'.freeze
+        REVERSE_MSG = 'Use `reverse.%s` instead of `%s.%s`.'.freeze
 
-        SELECT_METHODS = [:select, :find_all]
-        DANGEROUS_METHODS = [:first, :last]
+        SELECT_METHODS = [:select, :find_all].freeze
+        DANGEROUS_METHODS = [:first, :last].freeze
 
         def on_send(node)
           receiver, second_method = *node
@@ -59,7 +60,7 @@ module RuboCop
                         end
 
           first_range = Parser::Source::Range.new(
-            receiver.loc.expression.source,
+            receiver.source,
             receiver.loc.end.end_pos,
             receiver.loc.end.end_pos).join(node.loc.selector)
 

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

@@ -0,0 +1,65 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Performance
+      # This cop checks for double `#start_with?` or `#end_with?` calls
+      # separated by `||`. In some cases such calls can be replaced
+      # with an single `#start_with?`/`#end_with?` call.
+      #
+      # @example
+      #
+      #   @bad
+      #   str.start_with?("a") || str.start_with?(Some::CONST)
+      #   str.start_with?("a", "b") || str.start_with?("c")
+      #   var1 = ...
+      #   var2 = ...
+      #   str.end_with?(var1) || str.end_with?(var2)
+      #
+      #   @good
+      #   str.start_with?("a", Some::CONST)
+      #   str.start_with?("a", "b", "c")
+      #   var1 = ...
+      #   var2 = ...
+      #   str.end_with?(var1, var2)
+      class DoubleStartEndWith < Cop
+        MSG = 'Use `%{receiver}.%{method}(%{combined_args})` ' \
+              'instead of `%{original_code}`.'.freeze
+
+        def on_or(node)
+          receiver,
+          method,
+          first_call_args,
+          second_call_args = two_start_end_with_calls(node)
+
+          if receiver && second_call_args.all?(&:pure?)
+            add_offense(
+              node,
+              :expression,
+              format(
+                MSG,
+                receiver: receiver.source,
+                method: method,
+                combined_args: combine_args(first_call_args, second_call_args),
+                original_code: node.source
+              )
+            )
+          end
+        end
+
+        private
+
+        def combine_args(first_call_args, second_call_args)
+          (first_call_args + second_call_args).map(&:source).join(', ')
+        end
+
+        def_node_matcher :two_start_end_with_calls, <<-END
+          (or
+            (send $_recv [{:start_with? :end_with?} $_method] $...)
+            (send _recv _method $...))
+        END
+      end
+    end
+  end
+end

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

@@ -0,0 +1,55 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Performance
+      # This cop identifies unnecessary use of a regex where `String#end_with?`
+      # would suffice.
+      #
+      # @example
+      #   @bad
+      #   'abc' =~ /bc\Z/
+      #   'abc'.match(/bc\Z/)
+      #
+      #   @good
+      #   'abc' =~ /ab/
+      #   'abc' =~ /\w*\Z/
+      class EndWith < Cop
+        MSG = 'Use `String#end_with?` instead of a regex match anchored to ' \
+              'the end of the string.'.freeze
+        SINGLE_QUOTE = "'".freeze
+
+        def_node_matcher :redundant_regex?, <<-END
+          {(send $_ {:match :=~} (regexp (str $#literal_at_end?) (regopt)))
+           (send (regexp (str $#literal_at_end?) (regopt)) {:match :=~} $_)}
+        END
+
+        def literal_at_end?(regex_str)
+          # is this regexp 'literal' in the sense of only matching literal
+          # chars, rather than using metachars like . and * and so on?
+          # also, is it anchored at the end of the string?
+          regex_str =~ /\A(?:#{LITERAL_REGEX})+\\z\z/
+        end
+
+        def on_send(node)
+          add_offense(node, :expression, MSG) if redundant_regex?(node)
+        end
+
+        def autocorrect(node)
+          redundant_regex?(node) do |receiver, regex_str|
+            receiver, regex_str = regex_str, receiver if receiver.is_a?(String)
+            regex_str = regex_str[0..-3] # drop \Z anchor
+            regex_str = interpret_string_escapes(regex_str)
+
+            lambda do |corrector|
+              new_source = receiver.source + '.end_with?(' +
+                           to_string_literal(regex_str) + ')'
+              corrector.replace(node.source_range, new_source)
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -1,4 +1,5 @@
 # encoding: utf-8
+# frozen_string_literal: true
 
 module RuboCop
   module Cop

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

@@ -1,4 +1,5 @@
 # encoding: utf-8
+# frozen_string_literal: true
 
 module RuboCop
   module Cop
@@ -15,11 +16,11 @@ module RuboCop
       #   [1, 2, 3, 4].map { |e| [e, e] }.flatten
       #   [1, 2, 3, 4].collect { |e| [e, e] }.flatten
       class FlatMap < Cop
-        MSG = 'Use `flat_map` instead of `%s...%s`.'
+        MSG = 'Use `flat_map` instead of `%s...%s`.'.freeze
         FLATTEN_MULTIPLE_LEVELS = ' Beware, `flat_map` only flattens 1 level ' \
                                   'and `flatten` can be used to flatten ' \
-                                  'multiple levels.'
-        FLATTEN = [:flatten, :flatten!]
+                                  'multiple levels.'.freeze
+        FLATTEN = [:flatten, :flatten!].freeze
 
         def on_send(node)
           left, second_method, flatten_param = *node
@@ -32,11 +33,11 @@ module RuboCop
           message = MSG
           if cop_config['EnabledForFlattenWithoutParams'] && flatten_level.nil?
             message = MSG + FLATTEN_MULTIPLE_LEVELS
-          else
-            return unless flatten_level == 1
+          elsif flatten_level != 1
+            return
           end
 
-          range = Parser::Source::Range.new(node.loc.expression.source_buffer,
+          range = Parser::Source::Range.new(node.source_range.source_buffer,
                                             expression.loc.selector.begin_pos,
                                             node.loc.selector.end_pos)
 
@@ -51,9 +52,9 @@ module RuboCop
           array, = *receiver
 
           lambda do |corrector|
-            range = Parser::Source::Range.new(node.loc.expression.source_buffer,
+            range = Parser::Source::Range.new(node.source_range.source_buffer,
                                               node.loc.dot.begin_pos,
-                                              node.loc.expression.end_pos)
+                                              node.source_range.end_pos)
 
             corrector.remove(range)
             corrector.replace(array.loc.selector, 'flat_map')

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

@@ -0,0 +1,86 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Performance
+      # This cop checks for uses of `each_key` & `each_value` Hash methods.
+      #
+      # @example
+      #   # bad
+      #   hash.keys.each { |k| p k }
+      #   hash.values.each { |v| p v }
+      #   hash.each { |k, _v| p k }
+      #   hash.each { |_k, v| p v }
+      #
+      #   # good
+      #   hash.each_key { |k| p k }
+      #   hash.each_value { |v| p v }
+      class HashEachMethods < Cop
+        include Lint::UnusedArgument
+
+        MSG = 'Use `%s` instead of `%s`.'.freeze
+
+        def_node_matcher :plain_each, <<-END
+          (block $(send (send _ :hash) :each) (args (arg $_k) (arg $_v)) ...)
+        END
+
+        def_node_matcher :kv_each, <<-END
+          (block $(send (send (send _ :hash) ${:keys :values}) :each) ...)
+        END
+
+        def on_block(node)
+          plain_each(node) do |target, k, v|
+            return if @args[k] && @args[v]
+            used = @args[k] ? :key : :value
+            add_offense(target, range(target), format(message,
+                                                      "each_#{used}",
+                                                      :each))
+          end
+          kv_each(node) do |target, method|
+            add_offense(target, range(target), format(message,
+                                                      "each_#{method[0..-2]}",
+                                                      "#{method}.each"))
+          end
+        end
+
+        def check_argument(variable)
+          return unless variable.block_argument?
+          (@args ||= {})[variable.name] = variable.used?
+        end
+
+        def autocorrect(node)
+          receiver, _second_method = *node
+          caller, first_method = *receiver
+          lambda do |corrector|
+            if first_method == :hash
+              method = @args.values.first ? :key : :value
+              new_source = receiver.source + ".each_#{method}"
+              corrector.replace(node.loc.expression, new_source)
+              correct_args(node, corrector)
+            else
+              new_source = caller.source + ".each_#{first_method[0..-2]}"
+              corrector.replace(node.loc.expression, new_source)
+            end
+          end
+        end
+
+        private
+
+        def correct_args(node, corrector)
+          args = node.parent.children[1]
+          used_arg = "|#{@args.detect { |_k, v| v }.first}|"
+          args_range = Parser::Source::Range.new(node.parent.source,
+                                                 args.loc.begin.begin_pos,
+                                                 args.loc.end.end_pos)
+          corrector.replace(args_range, used_arg)
+        end
+
+        def range(outer_node)
+          inner_node = outer_node.children.first
+          inner_node.loc.selector.join(outer_node.loc.selector)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,44 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Performance
+      # This cop identifies places where `lstrip.rstrip` can be replaced by
+      # `strip`.
+      #
+      # @example
+      #   @bad
+      #   'abc'.lstrip.rstrip
+      #   'abc'.rstrip.lstrip
+      #
+      #   @good
+      #   'abc'.strip
+      class LstripRstrip < Cop
+        MSG = 'Use `strip` instead of `%s.%s`.'.freeze
+
+        def_node_matcher :lstrip_rstrip, <<-END
+          {(send $(send _ $:rstrip) $:lstrip)
+           (send $(send _ $:lstrip) $:rstrip)}
+        END
+
+        def on_send(node)
+          lstrip_rstrip(node) do |first_send, method_one, method_two|
+            range = Parser::Source::Range.new(node.source_range.source_buffer,
+                                              first_send.loc.selector.begin_pos,
+                                              node.source_range.end_pos)
+            add_offense(node, range, format(MSG, method_one, method_two))
+          end
+        end
+
+        def autocorrect(node)
+          first_send, = *node
+          range = Parser::Source::Range.new(node.source_range.source_buffer,
+                                            first_send.loc.selector.begin_pos,
+                                            node.source_range.end_pos)
+          ->(corrector) { corrector.replace(range, 'strip') }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,40 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Performance
+      # This cop identifies uses of `Range#include?`, which iterates over each
+      # item in a `Range` to see if a specified item is there. In contrast,
+      # `Range#cover?` simply compares the target item with the beginning and
+      # end points of the `Range`. In a great majority of cases, this is what
+      # is wanted.
+      #
+      # Here is an example of a case where `Range#cover?` may not provide the
+      # desired result:
+      #
+      #     ('a'..'z').cover?('yellow') # => true
+      #
+      class RangeInclude < Cop
+        MSG = 'Use `Range#cover?` instead of `Range#include?`.'.freeze
+
+        # TODO: If we traced out assignments of variables to their uses, we
+        # might pick up on a few more instances of this issue
+        # Right now, we only detect direct calls on a Range literal
+        # (We don't even catch it if the Range is in double parens)
+
+        def_node_matcher :range_include, <<-END
+          (send {irange erange (begin {irange erange})} :include? ...)
+        END
+
+        def on_send(node)
+          add_offense(node, :selector, MSG) if range_include(node)
+        end
+
+        def autocorrect(node)
+          ->(corrector) { corrector.replace(node.loc.selector, 'cover?') }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,57 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Performance
+      # This cop identifies the use of a `&block` parameter and `block.call`
+      # where `yield` would do just as well.
+      #
+      # @example
+      #   @bad
+      #   def method(&block)
+      #     block.call
+      #   end
+      #   def another(&func)
+      #     func.call 1, 2, 3
+      #   end
+      #
+      #   @good
+      #   def method
+      #     yield
+      #   end
+      #   def another
+      #     yield 1, 2, 3
+      #   end
+      class RedundantBlockCall < Cop
+        MSG = 'Use `yield` instead of `%s.call`.'.freeze
+
+        def_node_matcher :blockarg_def, <<-END
+          {(def  _   (args ... (blockarg $_)) $_)
+           (defs _ _ (args ... (blockarg $_)) $_)}
+        END
+
+        def_node_search :blockarg_calls, <<-END
+          (send (lvar %1) :call ...)
+        END
+
+        def on_def(node)
+          blockarg_def(node) do |argname, body|
+            blockarg_calls(body, argname) do |blockcall|
+              add_offense(blockcall, :expression, format(MSG, argname))
+            end
+          end
+        end
+
+        # 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(', ')
+          ->(corrector) { corrector.replace(node.source_range, new_source) }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,51 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Performance
+      # This cop identifies use of `Regexp#match` or `String#match in a context
+      # where the integral return value of `=~` would do just as well.
+      #
+      # @example
+      #   @bad
+      #   do_something if str.match(/regex/)
+      #   while regex.match('str')
+      #     do_something
+      #   end
+      #
+      #   @good
+      #   method(str.match(/regex/))
+      #   return regex.match('str')
+      class RedundantMatch < Cop
+        MSG = 'Use `=~` in places where the `MatchData` returned by ' \
+              '`#match` will not be used.'.freeze
+
+        # 'match' is a fairly generic name, so we don't flag it unless we see
+        # a string or regexp literal on one side or the other
+        def_node_matcher :match_call?, <<-END
+          {(send {str regexp} :match _)
+           (send !nil :match {str regexp})}
+        END
+
+        def_node_matcher :only_truthiness_matters?, <<-END
+          ^({if while until case while_post until_post} equal?(%0) ...)
+        END
+
+        def on_send(node)
+          return unless match_call?(node) &&
+                        (!node.value_used? || only_truthiness_matters?(node))
+          add_offense(node, :expression, MSG)
+        end
+
+        def autocorrect(node)
+          # Regexp#match can take a second argument, but this cop doesn't
+          # register an offense in that case
+          receiver, _method, arg = *node
+          new_source = receiver.source + ' =~ ' + arg.source
+          ->(corrector) { corrector.replace(node.source_range, new_source) }
+        end
+      end
+    end
+  end
+end