rubocop 0.35.1 → 0.36.0

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

@@ -0,0 +1,85 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Performance
+      # This cop identifies places where `Hash#merge!` can be replaced by
+      # `Hash#[]=`.
+      #
+      # @example
+      #   hash.merge!(a: 1)
+      #   hash.merge!({'key' => 'value'})
+      #   hash.merge!(a: 1, b: 2)
+      class RedundantMerge < Cop
+        AREF_ASGN = '%s[%s] = %s'.freeze
+        MSG = 'Use `%s` instead of `%s`.'.freeze
+
+        def_node_matcher :redundant_merge, '(send $_ :merge! (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?
+
+            assignments = to_assignments(receiver, pairs).join('; ')
+            message = format(MSG, assignments, node.source)
+            add_offense(node, :expression, message)
+          end
+        end
+
+        def autocorrect(node)
+          redundant_merge(node) do |receiver, pairs|
+            lambda do |corrector|
+              new_source = to_assignments(receiver, pairs).join("\n")
+
+              parent = node.parent
+              if parent && pairs.size > 1
+                if modifier_flow_control(parent)
+                  cond, = *parent
+                  padding = "\n#{' ' * indent_width}"
+                  new_source.gsub!(/\n/, padding)
+                  new_source = parent.loc.keyword.source << ' ' <<
+                               cond.source << padding << leading_spaces(node) <<
+                               new_source << "\n" << leading_spaces(node) <<
+                               'end'
+                  node = parent
+                end
+              end
+
+              corrector.replace(node.source_range, new_source)
+            end
+          end
+        end
+
+        private
+
+        def to_assignments(receiver, pairs)
+          pairs.map do |pair|
+            key, value = *pair
+            key_src = if key.sym_type? && !key.source.start_with?(':')
+                        ":#{key.source}"
+                      else
+                        key.source
+                      end
+
+            format(AREF_ASGN, receiver.source, key_src, value.source)
+          end
+        end
+
+        def leading_spaces(node)
+          node.source_range.source_line[/\A\s*/]
+        end
+
+        def indent_width
+          @config.for_cop('IndentationWidth')['Width'] || 2
+        end
+
+        def modifier?(node)
+          node.loc.respond_to?(:end) && node.loc.end.nil?
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,45 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Performance
+      # This cop identifies places where `sort_by { ... }` can be replaced by
+      # `sort`.
+      #
+      # @example
+      #   @bad
+      #   array.sort_by { |x| x }
+      #   array.sort_by do |var|
+      #     var
+      #   end
+      #
+      #   @good
+      #   array.sort
+      class RedundantSortBy < Cop
+        MSG = 'Use `sort` instead of `sort_by { |%s| %s }`.'.freeze
+
+        def_node_matcher :redundant_sort_by, <<-END
+          (block $(send _ :sort_by) (args (arg $_x)) (lvar _x))
+        END
+
+        def on_block(node)
+          redundant_sort_by(node) do |send, var_name|
+            range = Parser::Source::Range.new(node.source_range.source_buffer,
+                                              send.loc.selector.begin_pos,
+                                              node.loc.end.end_pos)
+            add_offense(node, range, format(MSG, var_name, var_name))
+          end
+        end
+
+        def autocorrect(node)
+          send, = *node
+          range = Parser::Source::Range.new(node.source_range.source_buffer,
+                                            send.loc.selector.begin_pos,
+                                            node.loc.end.end_pos)
+          ->(corrector) { corrector.replace(range, 'sort') }
+        end
+      end
+    end
+  end
+end

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

@@ -1,4 +1,5 @@
 # encoding: utf-8
+# frozen_string_literal: true
 
 module RuboCop
   module Cop
@@ -13,7 +14,7 @@ module RuboCop
       #   # good
       #   [].reverse_each
       class ReverseEach < Cop
-        MSG = 'Use `reverse_each` instead of `reverse.each`.'
+        MSG = 'Use `reverse_each` instead of `reverse.each`.'.freeze
 
         def on_send(node)
           receiver, second_method = *node
@@ -22,7 +23,7 @@ module RuboCop
           _, first_method = *receiver
           return unless first_method == :reverse
 
-          source_buffer = node.loc.expression.source_buffer
+          source_buffer = node.source_range.source_buffer
           location_of_reverse = receiver.loc.selector.begin_pos
           end_location = node.loc.selector.end_pos
 

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

@@ -1,4 +1,5 @@
 # encoding: UTF-8
+# frozen_string_literal: true
 
 module RuboCop
   module Cop
@@ -25,7 +26,7 @@ module RuboCop
       #   [1, 2, 3].shuffle[foo, bar]
       #   [1, 2, 3].shuffle(random: Random.new)
       class Sample < Cop
-        MSG = 'Use `%<correct>s` instead of `%<incorrect>s`.'
+        MSG = 'Use `%<correct>s` instead of `%<incorrect>s`.'.freeze
 
         def on_send(node)
           analyzer = ShuffleAnalyzer.new(node)
@@ -57,9 +58,9 @@ module RuboCop
           end
 
           def source_range
-            Parser::Source::Range.new(shuffle_node.loc.expression.source_buffer,
+            Parser::Source::Range.new(shuffle_node.source_range.source_buffer,
                                       shuffle_node.loc.selector.begin_pos,
-                                      method_node.loc.expression.end_pos)
+                                      method_node.source_range.end_pos)
           end
 
           private
@@ -85,7 +86,7 @@ module RuboCop
 
           def method_arg
             _, _, arg = *method_node
-            arg.loc.expression.source if arg
+            arg.source if arg
           end
 
           # FIXME: use Range#size once Ruby 1.9 support is dropped
@@ -126,7 +127,7 @@ module RuboCop
 
           def shuffle_arg
             _, _, arg = *shuffle_node
-            arg.loc.expression.source if arg
+            arg.source if arg
           end
         end
       end

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

@@ -1,4 +1,5 @@
 # encoding: utf-8
+# frozen_string_literal: true
 
 module RuboCop
   module Cop
@@ -24,7 +25,7 @@ module RuboCop
       # TODO: Add advanced detection of variables that could
       # have been assigned to an array or a hash.
       class Size < Cop
-        MSG = 'Use `size` instead of `count`.'
+        MSG = 'Use `size` instead of `count`.'.freeze
 
         def on_send(node)
           receiver, method, args = *node

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

@@ -0,0 +1,58 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Performance
+      # This cop identifies unnecessary use of a regex where
+      # `String#start_with?` would suffice.
+      #
+      # @example
+      #   @bad
+      #   'abc' =~ /\Aab/
+      #   'abc'.match(/\Aab/)
+      #
+      #   @good
+      #   'abc' =~ /ab/
+      #   'abc' =~ /\A\w*/
+      class StartWith < Cop
+        MSG = 'Use `String#start_with?` instead of a regex match anchored to ' \
+              'the beginning of the string.'.freeze
+        SINGLE_QUOTE = "'".freeze
+
+        def_node_matcher :redundant_regex?, <<-END
+          {(send $_ {:match :=~} (regexp (str $#literal_at_start?) (regopt)))
+           (send (regexp (str $#literal_at_start?) (regopt)) {:match :=~} $_)}
+        END
+
+        def literal_at_start?(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 start of the string?
+          # (tricky: \s, \d, and so on are metacharacters, but other characters
+          #  escaped with a slash are just literals. LITERAL_REGEX takes all
+          #  that into account.)
+          regex_str =~ /\A\\A(?:#{LITERAL_REGEX})+\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[2..-1] # drop \A anchor
+            regex_str = interpret_string_escapes(regex_str)
+
+            lambda do |corrector|
+              new_source = receiver.source + '.start_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/string_replacement.rb

@@ -1,4 +1,5 @@
 # encoding: utf-8
+# frozen_string_literal: true
 
 module RuboCop
   module Cop
@@ -19,8 +20,8 @@ module RuboCop
       #   'abc'.tr('b', 'd')
       #   'a b c'.delete(' ')
       class StringReplacement < Cop
-        MSG = 'Use `%s` instead of `%s`.'
-        DETERMINISTIC_REGEX = /^[\w\s\-,"']+$/.freeze
+        MSG = 'Use `%s` instead of `%s`.'.freeze
+        DETERMINISTIC_REGEX = /\A(?:#{LITERAL_REGEX})+\Z/
         REGEXP_CONSTRUCTOR_METHODS = [:new, :compile].freeze
         GSUB_METHODS = [:gsub, :gsub!].freeze
         DETERMINISTIC_TYPES = [:regexp, :str, :send].freeze
@@ -43,6 +44,9 @@ module RuboCop
           if regex?(first_param)
             return unless first_source =~ DETERMINISTIC_REGEX
             return if options
+            # This must be done after checking DETERMINISTIC_REGEX
+            # Otherwise things like \s will trip us up
+            first_source = interpret_string_escapes(first_source)
           end
 
           return if first_source.length != 1
@@ -56,6 +60,11 @@ module RuboCop
           _string, method, first_param, second_param = *node
           first_source, = first_source(first_param)
           second_source, = *second_param
+
+          if regex?(first_param)
+            first_source = interpret_string_escapes(first_source)
+          end
+
           replacement_method = replacement_method(method,
                                                   first_source,
                                                   second_source)
@@ -63,8 +72,8 @@ module RuboCop
           lambda do |corrector|
             corrector.replace(node.loc.selector, replacement_method)
             unless first_param.str_type?
-              corrector.replace(first_param.loc.expression,
-                                escape(first_source))
+              corrector.replace(first_param.source_range,
+                                to_string_literal(first_source))
             end
 
             if second_source.empty? && first_source.length == 1
@@ -83,7 +92,6 @@ module RuboCop
           case first_param.type
           when :regexp, :send
             return nil unless regex?(first_param)
-
             source, options = extract_source(first_param)
           when :str
             source, = *first_param
@@ -129,9 +137,9 @@ module RuboCop
         end
 
         def range(node)
-          Parser::Source::Range.new(node.loc.expression.source_buffer,
+          Parser::Source::Range.new(node.source_range.source_buffer,
                                     node.loc.selector.begin_pos,
-                                    node.loc.expression.end_pos)
+                                    node.source_range.end_pos)
         end
 
         def replacement_method(method, first_source, second_source)
@@ -156,28 +164,15 @@ module RuboCop
           method.to_s.end_with?(BANG)
         end
 
-        def escape(string)
-          if require_double_quotes?(string)
-            string.inspect
-          else
-            "'#{string}'"
-          end
-        end
-
-        def require_double_quotes?(string)
-          string.inspect.include?(SINGLE_QUOTE) ||
-            StringHelp::ESCAPED_CHAR_REGEXP =~ string
-        end
-
         def method_suffix(node)
           node.loc.end ? node.loc.end.source : ''
         end
 
         def remove_second_param(corrector, node, first_param)
           end_range =
-            Parser::Source::Range.new(node.loc.expression.source_buffer,
-                                      first_param.loc.expression.end_pos,
-                                      node.loc.expression.end_pos)
+            Parser::Source::Range.new(node.source_range.source_buffer,
+                                      first_param.source_range.end_pos,
+                                      node.source_range.end_pos)
 
           corrector.replace(end_range, method_suffix(node))
         end

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

@@ -0,0 +1,49 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Performance
+      # This cop checks for .times.map calls.
+      # In most cases such calls can be replaced
+      # with an explicit array creation.
+      #
+      # @example
+      #
+      #   @bad
+      #   9.times.map do |i|
+      #     i.to_s
+      #   end
+      #
+      #   @good
+      #   Array.new(9) do |i|
+      #     i.to_s
+      #   end
+      class TimesMap < Cop
+        MSG = 'Use `Array.new` with a block instead of `.times.%s`.'.freeze
+
+        def on_send(node)
+          check(node)
+        end
+
+        def on_block(node)
+          check(node)
+        end
+
+        private
+
+        def check(node)
+          map_or_collect = times_map_call(node)
+          if 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 ...))}
+        END
+      end
+    end
+  end
+end

data/lib/rubocop/cop/rails/action_filter.rb

@@ -1,4 +1,5 @@
 # encoding: utf-8
+# frozen_string_literal: true
 
 module RuboCop
   module Cop
@@ -10,7 +11,7 @@ module RuboCop
       class ActionFilter < Cop
         include ConfigurableEnforcedStyle
 
-        MSG = 'Prefer `%s` over `%s`.'
+        MSG = 'Prefer `%s` over `%s`.'.freeze
 
         FILTER_METHODS = [
           :after_filter,
@@ -26,7 +27,7 @@ module RuboCop
           :skip_around_filter,
           :skip_before_filter,
           :skip_filter
-        ]
+        ].freeze
 
         ACTION_METHODS = [
           :after_action,
@@ -42,7 +43,7 @@ module RuboCop
           :skip_around_action,
           :skip_before_action,
           :skip_action_callback
-        ]
+        ].freeze
 
         def on_block(node)
           method, _args, _body = *node