rubocop 0.49.1 → 0.50.0

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

@@ -16,10 +16,10 @@ module RuboCop
       class LstripRstrip < Cop
         MSG = 'Use `strip` instead of `%s.%s`.'.freeze
 
-        def_node_matcher :lstrip_rstrip, <<-END
+        def_node_matcher :lstrip_rstrip, <<-PATTERN
           {(send $(send _ $:rstrip) $:lstrip)
            (send $(send _ $:lstrip) $:rstrip)}
-        END
+        PATTERN
 
         def on_send(node)
           lstrip_rstrip(node) do |first_send, method_one, method_two|

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

@@ -22,9 +22,9 @@ module RuboCop
         # 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
+        def_node_matcher :range_include, <<-PATTERN
           (send {irange erange (begin {irange erange})} :include? ...)
-        END
+        PATTERN
 
         def on_send(node)
           return unless range_include(node)

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

@@ -29,18 +29,18 @@ module RuboCop
         CLOSE_PAREN = ')'.freeze
         SPACE = ' '.freeze
 
-        def_node_matcher :blockarg_def, <<-END
+        def_node_matcher :blockarg_def, <<-PATTERN
           {(def  _   (args ... (blockarg $_)) $_)
            (defs _ _ (args ... (blockarg $_)) $_)}
-        END
+        PATTERN
 
-        def_node_search :blockarg_calls, <<-END
+        def_node_search :blockarg_calls, <<-PATTERN
           (send (lvar %1) :call ...)
-        END
+        PATTERN
 
-        def_node_search :blockarg_assigned?, <<-END
+        def_node_search :blockarg_assigned?, <<-PATTERN
           (lvasgn %1 ...)
-        END
+        PATTERN
 
         def on_def(node)
           blockarg_def(node) do |argname, body|

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

@@ -22,21 +22,21 @@ module RuboCop
 
         # '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
+        def_node_matcher :match_call?, <<-PATTERN
           {(send {str regexp} :match _)
            (send !nil :match {str regexp})}
-        END
+        PATTERN
 
-        def_node_matcher :only_truthiness_matters?, <<-END
+        def_node_matcher :only_truthiness_matters?, <<-PATTERN
           ^({if while until case while_post until_post} equal?(%0) ...)
-        END
+        PATTERN
 
         def on_send(node)
           return unless match_call?(node) &&
                         (!node.value_used? || only_truthiness_matters?(node)) &&
                         !(node.parent && node.parent.block_type?)
 
-          add_offense(node, :expression)
+          add_offense(node)
         end
 
         def autocorrect(node)

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

@@ -14,28 +14,26 @@ module RuboCop
         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?, <<-END
+        def_node_matcher :redundant_merge_candidate, <<-PATTERN
+          (send $!nil :merge! [(hash $...) !kwsplat_type?])
+        PATTERN
+
+        def_node_matcher :modifier_flow_control?, <<-PATTERN
           [{if while until} modifier_form?]
-        END
+        PATTERN
 
         def on_send(node)
-          each_redundant_merge(node) do |receiver, pairs|
-            return if pairs.any?(&:kwsplat_type?)
-
-            assignments = to_assignments(receiver, pairs).join('; ')
-            message = format(MSG, assignments, node.source)
-            add_offense(node, :expression, message)
+          each_redundant_merge(node) do |redundant_merge_node|
+            add_offense(redundant_merge_node)
           end
         end
 
         def autocorrect(node)
-          redundant_merge(node) do |receiver, pairs|
+          redundant_merge_candidate(node) do |receiver, pairs|
             new_source = to_assignments(receiver, pairs).join("\n")
 
-            parent = node.parent
-            if parent && pairs.size > 1
-              correct_multiple_elements(node, parent, new_source)
+            if node.parent && pairs.size > 1
+              correct_multiple_elements(node, node.parent, new_source)
             else
               correct_single_element(node, new_source)
             end
@@ -44,18 +42,36 @@ module RuboCop
 
         private
 
+        def message(node)
+          redundant_merge_candidate(node) do |receiver, pairs|
+            assignments = to_assignments(receiver, pairs).join('; ')
+
+            format(MSG, assignments, node.source)
+          end
+        end
+
         def each_redundant_merge(node)
-          redundant_merge(node) do |receiver, pairs|
-            next unless receiver
-            next if node.value_used? &&
-                    !EachWithObjectInspector.new(node, receiver).value_used?
-            next if pairs.size > 1 && !receiver.pure?
-            next if pairs.size > max_key_value_pairs
-
-            yield receiver, pairs
+          redundant_merge_candidate(node) do |receiver, pairs|
+            next if non_redundant_merge?(node, receiver, pairs)
+
+            yield node
           end
         end
 
+        def non_redundant_merge?(node, receiver, pairs)
+          non_redundant_pairs?(receiver, pairs) ||
+            non_redundant_value_used?(receiver, node)
+        end
+
+        def non_redundant_pairs?(receiver, pairs)
+          pairs.size > 1 && !receiver.pure? || pairs.size > max_key_value_pairs
+        end
+
+        def non_redundant_value_used?(receiver, node)
+          node.value_used? &&
+            !EachWithObjectInspector.new(node, receiver).value_used?
+        end
+
         def correct_multiple_elements(node, parent, new_source)
           if modifier_flow_control?(parent)
             new_source = rewrite_with_modifier(node, parent, new_source)
@@ -141,9 +157,9 @@ module RuboCop
             receiver
           end
 
-          def_node_matcher :each_with_object_node, <<-END
+          def_node_matcher :each_with_object_node, <<-PATTERN
             (block (send _ :each_with_object _) (args _ $_) ...)
-          END
+          PATTERN
         end
       end
     end

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

@@ -18,9 +18,9 @@ module RuboCop
       class RedundantSortBy < Cop
         MSG = 'Use `sort` instead of `sort_by { |%s| %s }`.'.freeze
 
-        def_node_matcher :redundant_sort_by, <<-END
+        def_node_matcher :redundant_sort_by, <<-PATTERN
           (block $(send _ :sort_by) (args (arg $_x)) (lvar _x))
-        END
+        PATTERN
 
         def on_block(node)
           redundant_sort_by(node) do |send, var_name|

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

@@ -81,9 +81,11 @@ module RuboCop
           (send (regexp (str _) {(regopt) (regopt _)}) :=== !nil)
         PATTERN
 
-        def_node_matcher :match_with_lvasgn?, <<-PATTERN
-          (match_with_lvasgn !nil !nil)
-        PATTERN
+        def match_with_lvasgn?(node)
+          return false unless node.match_with_lvasgn_type?
+          regexp, _rhs = *node
+          regexp.to_regexp.named_captures.empty?
+        end
 
         MATCH_NODE_PATTERN = <<-PATTERN.freeze
           {
@@ -139,11 +141,15 @@ module RuboCop
         def check_condition(cond)
           match_node?(cond) do
             return if last_match_used?(cond)
-            add_offense(cond, :expression,
-                        format(MSG, cond.loc.selector.source))
+
+            add_offense(cond)
           end
         end
 
+        def message(node)
+          format(MSG, node.loc.selector.source)
+        end
+
         def last_match_used?(match_node)
           scope_root = scope_root(match_node)
           body = scope_root ? scope_body(scope_root) : match_node.ancestors.last
@@ -176,6 +182,8 @@ module RuboCop
           case node.type
           when :module
             children[1]
+          when :defs
+            children[3]
           else
             children[2]
           end

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

@@ -29,7 +29,7 @@ module RuboCop
         def on_send(node)
           return unless eligible_node?(node)
 
-          add_offense(node, node.loc.selector)
+          add_offense(node, :selector)
         end
 
         private

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

@@ -18,10 +18,10 @@ module RuboCop
               'the beginning of the string.'.freeze
         SINGLE_QUOTE = "'".freeze
 
-        def_node_matcher :redundant_regex?, <<-END
+        def_node_matcher :redundant_regex?, <<-PATTERN
           {(send $!nil {:match :=~} (regexp (str $#literal_at_start?) (regopt)))
            (send (regexp (str $#literal_at_start?) (regopt)) {:match :=~} $_)}
-        END
+        PATTERN
 
         def literal_at_start?(regex_str)
           # is this regexp 'literal' in the sense of only matching literal
@@ -36,7 +36,7 @@ module RuboCop
         def on_send(node)
           return unless redundant_regex?(node)
 
-          add_offense(node, :expression)
+          add_offense(node)
         end
 
         def autocorrect(node)

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

@@ -19,7 +19,9 @@ module RuboCop
       #     i.to_s
       #   end
       class TimesMap < Cop
-        MSG = 'Use `Array.new` with a block instead of `.times.%s`.'.freeze
+        MESSAGE = 'Use `Array.new(%<count>s)` with a block ' \
+                  'instead of `.times.%<map_or_collect>s`'.freeze
+        MESSAGE_ONLY_IF = 'only if `%<count>s` is always 0 or more'.freeze
 
         def on_send(node)
           check(node)
@@ -32,27 +34,36 @@ module RuboCop
         private
 
         def check(node)
-          times_map_call(node) do |map_or_collect|
-            add_offense(node, :expression, format(MSG, map_or_collect))
+          times_map_call(node) do |map_or_collect, count|
+            add_offense(node, :expression, message(map_or_collect, count))
           end
         end
 
-        def_node_matcher :times_map_call, <<-END
-          {(block (send (send !nil :times) ${:map :collect}) ...)
-           (send (send !nil :times) ${:map :collect} (block_pass ...))}
-        END
+        def message(map_or_collect, count)
+          template = if count.literal?
+                       MESSAGE + '.'
+                     else
+                       "#{MESSAGE} #{MESSAGE_ONLY_IF}."
+                     end
+          format(template,
+                 count: count.source,
+                 map_or_collect: map_or_collect.method_name)
+        end
 
-        def autocorrect(node)
-          send_node = node.send_type? ? node : node.each_descendant(:send).first
+        def_node_matcher :times_map_call, <<-PATTERN
+          {(block $(send (send $!nil :times) {:map :collect}) ...)
+           $(send (send $!nil :times) {:map :collect} (block_pass ...))}
+        PATTERN
 
-          count, = *send_node.receiver
+        def autocorrect(node)
+          map_or_collect, count = times_map_call(node)
 
           replacement =
             "Array.new(#{count.source}" \
-            "#{send_node.arguments.map { |arg| ", #{arg.source}" }.join})"
+            "#{map_or_collect.arguments.map { |arg| ", #{arg.source}" }.join})"
 
           lambda do |corrector|
-            corrector.replace(send_node.loc.expression, replacement)
+            corrector.replace(map_or_collect.loc.expression, replacement)
           end
         end
       end

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

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Performance
+      # In Ruby 2.3 or later, use unary plus operator to unfreeze a string
+      # literal instead of `String#dup` and `String.new`.
+      # Unary plus operator is faster than `String#dup`.
+      #
+      # Note: `String.new` (without operator) is not exactly the same as `+''`.
+      # These differ in encoding. `String.new.encoding` is always `ASCII-8BIT`.
+      # However, `(+'').encoding` is the same as script encoding(e.g. `UTF-8`).
+      # So, if you expect `ASCII-8BIT` encoding, disable this cop.
+      #
+      # @example
+      #   # bad
+      #   ''.dup
+      #   "something".dup
+      #   String.new
+      #   String.new('')
+      #   String.new('something')
+      #
+      #   # good
+      #   +'something'
+      #   +''
+      class UnfreezeString < Cop
+        extend TargetRubyVersion
+
+        minimum_target_ruby_version 2.3
+
+        MSG = 'Use unary plus to get an unfrozen string literal.'.freeze
+
+        def_node_matcher :dup_string?, <<-PATTERN
+          (send {str dstr} :dup)
+        PATTERN
+
+        def_node_matcher :string_new?, <<-PATTERN
+          {
+            (send (const nil :String) :new {str dstr})
+            (send (const nil :String) :new)
+          }
+        PATTERN
+
+        def on_send(node)
+          add_offense(node) if dup_string?(node) || string_new?(node)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Performance
+      # This cop identifies places where `URI::Parser.new`
+      # can be replaced by `URI::DEFAULT_PARSER`.
+      #
+      # @example
+      #   # bad
+      #   URI::Parser.new
+      #
+      #   # good
+      #   URI::DEFAULT_PARSER
+      #
+      class UriDefaultParser < Cop
+        MSG = 'Use `%sURI::DEFAULT_PARSER` instead of ' \
+              '`%sURI::Parser.new`.'.freeze
+
+        def_node_matcher :uri_parser_new?, <<-PATTERN
+          (send
+            (const
+              (const ${nil cbase} :URI) :Parser) :new)
+        PATTERN
+
+        def on_send(node)
+          return unless uri_parser_new?(node) do |captured_value|
+            double_colon = captured_value ? '::' : ''
+            message = format(MSG, double_colon, double_colon)
+
+            add_offense(node, :expression, message)
+          end
+        end
+
+        def autocorrect(node)
+          lambda do |corrector|
+            double_colon = uri_parser_new?(node) ? '::' : ''
+
+            corrector.replace(
+              node.loc.expression, "#{double_colon}URI::DEFAULT_PARSER"
+            )
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -38,7 +38,7 @@ module RuboCop
         end
 
         def on_send(node)
-          ALIASES.keys.each do |aliased_method|
+          ALIASES.each_key do |aliased_method|
             register_offense(node, aliased_method) if
               public_send(aliased_method, node)
           end

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

@@ -3,8 +3,17 @@
 module RuboCop
   module Cop
     module Rails
-      # This cop looks for delegations, that could have been created
-      # automatically with delegate method.
+      # This cop looks for delegations that could have been created
+      # automatically with the `delegate` method.
+      #
+      # Safe navigation `&.` is ignored because Rails' `allow_nil`
+      # option checks not just for nil but also delegates if nil
+      # responds to the delegated method.
+      #
+      # The `EnforceForPrefixed` option (defaulted to `true`) means that
+      # using the target object as a prefix of the method name
+      # without using the `delegate` method will be a violation.
+      # When set to `false`, this case is legal.
       #
       # @example
       #   # bad
@@ -15,6 +24,18 @@ module RuboCop
       #   # good
       #   delegate :bar, to: :foo
       #
+      #   # good
+      #   def bar
+      #     foo&.bar
+      #   end
+      #
+      #   # good
+      #   private
+      #   def bar
+      #     foo.bar
+      #   end
+      #
+      #   # EnforceForPrefixed: true
       #   # bad
       #   def foo_bar
       #     foo.bar
@@ -23,11 +44,14 @@ module RuboCop
       #   # good
       #   delegate :bar, to: :foo, prefix: true
       #
+      #   # EnforceForPrefixed: false
       #   # good
-      #   private
-      #   def bar
+      #   def foo_bar
       #     foo.bar
       #   end
+      #
+      #   # good
+      #   delegate :bar, to: :foo, prefix: true
       class Delegate < Cop
         MSG = 'Use `delegate` to define delegations.'.freeze
 
@@ -35,7 +59,7 @@ module RuboCop
           method_name, args, body = *node
           return unless trivial_delegate?(method_name, args, body)
           return if private_or_protected_delegation(node)
-          add_offense(node, :keyword, MSG)
+          add_offense(node, :keyword)
         end
 
         private
@@ -54,7 +78,7 @@ module RuboCop
         end
 
         def trivial_delegate?(method_name, args, body)
-          body && delegate?(body) &&
+          body && delegate?(body) && !body.csend_type? &&
             method_name_matches?(method_name, body) &&
             arguments_match?(args, body)
         end
@@ -78,7 +102,12 @@ module RuboCop
         def method_name_matches?(method_name, body)
           _receiver, property_name, *_args = *body
           method_name == property_name ||
-            method_name == prefixed_method_name(body)
+            (include_prefix_case? &&
+              method_name == prefixed_method_name(body))
+        end
+
+        def include_prefix_case?
+          cop_config['EnforceForPrefixed']
         end
 
         def prefixed_method_name(body)