rubocop-performance 0.0.0 → 0.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ab4ceb1e31551e3774fc563d05282b5339c9cb132d0e9a9ce1ce6f63358cf468
-  data.tar.gz: 8d5d42ecb4e72ed9d06e30e7c609569469d4cf2fc847c8fabf602723ac8b4c21
+  metadata.gz: 43633d075fac26295caf28e79d71f56cdbacd6d7853aead53b3ca35e4f29f99b
+  data.tar.gz: 60886d6ea540f6ed25014424376b2e0cf0f489a2291e298f1f4cbf6084f3e580
 SHA512:
-  metadata.gz: a42a85f9011b35eae2a99ffa9763bcfa2f409079b4c1aba3e0659adb351046cc5d8c42e5b374dda1f1d78289870339ee5fe8a34460a89d38a8fe2c24589398b5
-  data.tar.gz: 2acc0104f805827d517ebca4d9a29a382642af8b53fec7691b86bb53eaabe22a29b7c1df2b91c0d53e27429430fa191788477b19545dec4d17c286432bc03a03
+  metadata.gz: b7b30f444965b49aa1597f9f1e483802b3c2f2f786c71fd577f6af18dbdf268e0100793982aa2d8979b86c7a9f302b0b211694e5f8e04c6b2eeaae85c7dd0591
+  data.tar.gz: ac1707a5f94ae008d1baf8c90b2ff269a6bfb3da8e27ed4adb1fa968b69e6dfdbc7ae8a074d18c4fa5d6e7c6b3d5de814f5b5dfbd38832338e80d107b854ad33

data/config/default.yml

@@ -0,0 +1,24 @@
+# This is the default configuration file.
+
+Performance/CaseWhenSplat:
+  Description: >-
+                 Reordering `when` conditions with a splat to the end
+                 of the `when` branches can improve performance.
+  Enabled: false
+  AutoCorrect: false
+
+Performance/ChainArrayAllocation:
+  Description: >-
+                  Instead of chaining array methods that allocate new arrays, mutate an
+                  existing array.
+  Reference: 'https://twitter.com/schneems/status/1034123879978029057'
+  Enabled: false
+
+Performance/DoubleStartEndWith:
+  # Used to check for `starts_with?` and `ends_with?`.
+  # These methods are defined by `ActiveSupport`.
+  IncludeActiveSupportAliases: false
+
+Performance/RedundantMerge:
+  # Max number of key-value pairs to consider an offense
+  MaxKeyValuePairs: 2

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

@@ -3,16 +3,19 @@
 module RuboCop
   module Cop
     module Performance
-      # Place `when` conditions that use splat at the end
-      # of the list of `when` branches.
+      # Reordering `when` conditions with a splat to the end
+      # of the `when` branches can improve performance.
       #
       # Ruby has to allocate memory for the splat expansion every time
       # that the `case` `when` statement is run. Since Ruby does not support
       # fall through inside of `case` `when`, like some other languages do,
-      # the order of the `when` branches does not matter. By placing any
+      # the order of the `when` branches should not matter. By placing any
       # splat expansions at the end of the list of `when` branches we will
       # reduce the number of times that memory has to be allocated for
-      # the expansion.
+      # the expansion. The exception to this is if multiple of your `when`
+      # conditions can be true for any given condition. A likely scenario for
+      # this defining a higher level when condition to override a condition
+      # that is inside of the splat expansion.
       #
       # This is not a guaranteed performance improvement. If the data being
       # processed by the `case` condition is normalized in a manner that favors
@@ -54,9 +57,10 @@ module RuboCop
         include Alignment
         include RangeHelp
 
-        MSG = 'Place `when` conditions with a splat ' \
-              'at the end of the `when` branches.'.freeze
-        ARRAY_MSG = 'Do not expand array literals in `when` conditions.'.freeze
+        MSG = 'Reordering `when` conditions with a splat to the end ' \
+          'of the `when` branches can improve performance.'.freeze
+        ARRAY_MSG = 'Pass the contents of array literals ' \
+          'directly to `when` conditions.'.freeze
 
         def on_case(case_node)
           when_conditions = case_node.when_branches.flat_map(&:conditions)

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

@@ -18,7 +18,7 @@ module RuboCop
       #   str.casecmp('ABC').zero?
       #   'abc'.casecmp(str).zero?
       class Casecmp < Cop
-        MSG = 'Use `casecmp` instead of `%<methods>s`.'.freeze
+        MSG = 'Use `%<good>s` instead of `%<bad>s`.'.freeze
         CASE_METHODS = %i[downcase upcase].freeze
 
         def_node_matcher :downcase_eq, <<-PATTERN
@@ -43,16 +43,29 @@ module RuboCop
         PATTERN
 
         def on_send(node)
-          return if part_of_ignored_node?(node)
+          return unless downcase_eq(node) || eq_downcase(node)
+          return unless (parts = take_method_apart(node))
 
-          inefficient_comparison(node) do |range, is_other_part, *methods|
-            ignore_node(node) if is_other_part
-            add_offense(node, location: range,
-                              message: format(MSG, methods: methods.join(' ')))
-          end
+          _, _, arg, variable = parts
+          good_method = build_good_method(arg, variable)
+
+          add_offense(
+            node,
+            message: format(MSG, good: good_method, bad: node.source)
+          )
         end
 
         def autocorrect(node)
+          return unless (parts = take_method_apart(node))
+
+          receiver, method, arg, variable = parts
+
+          correction(node, receiver, method, arg, variable)
+        end
+
+        private
+
+        def take_method_apart(node)
           if downcase_downcase(node)
             receiver, method, rhs = *node
             arg, = *rhs
@@ -65,52 +78,30 @@ module RuboCop
           end
 
           variable, = *receiver
-          correction(node, receiver, method, arg, variable)
-        end
-
-        private
-
-        def inefficient_comparison(node)
-          loc = node.loc
 
-          downcase_eq(node) do |send_downcase, case_method, eq_method, other|
-            *_, method = *other
-            range, is_other_part = downcase_eq_range(method, loc, send_downcase)
-
-            yield range, is_other_part, case_method, eq_method
-            return
-          end
-
-          eq_downcase(node) do |eq_method, send_downcase, case_method|
-            range = loc.selector.join(send_downcase.loc.selector)
-            yield range, false, eq_method, case_method
-          end
-        end
-
-        def downcase_eq_range(method, loc, send_downcase)
-          if CASE_METHODS.include?(method)
-            [loc.expression, true]
-          else
-            [loc.selector.join(send_downcase.loc.selector), false]
-          end
+          [receiver, method, arg, variable]
         end
 
         def correction(node, _receiver, method, arg, variable)
           lambda do |corrector|
             corrector.insert_before(node.loc.expression, '!') if method == :!=
 
-            # we want resulting call to be parenthesized
-            # if arg already includes one or more sets of parens, don't add more
-            # or if method call already used parens, again, don't add more
-            replacement = if arg.send_type? || !parentheses?(arg)
-                            "#{variable.source}.casecmp(#{arg.source}).zero?"
-                          else
-                            "#{variable.source}.casecmp#{arg.source}.zero?"
-                          end
+            replacement = build_good_method(arg, variable)
 
             corrector.replace(node.loc.expression, replacement)
           end
         end
+
+        def build_good_method(arg, variable)
+          # We want resulting call to be parenthesized
+          # if arg already includes one or more sets of parens, don't add more
+          # or if method call already used parens, again, don't add more
+          if arg.send_type? || !parentheses?(arg)
+            "#{variable.source}.casecmp(#{arg.source}).zero?"
+          else
+            "#{variable.source}.casecmp#{arg.source}.zero?"
+          end
+        end
       end
     end
   end

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

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Performance
+      # This cop is used to identify usages of
+      # @example
+      #   # bad
+      #   array = ["a", "b", "c"]
+      #   array.compact.flatten.map { |x| x.downcase }
+      #
+      # Each of these methods (`compact`, `flatten`, `map`) will generate a
+      # new intermediate array that is promptly thrown away. Instead it is
+      # faster to mutate when we know it's safe.
+      #
+      # @example
+      #   # good.
+      #   array = ["a", "b", "c"]
+      #   array.compact!
+      #   array.flatten!
+      #   array.map! { |x| x.downcase }
+      #   array
+      class ChainArrayAllocation < Cop
+        include RangeHelp
+
+        # These methods return a new array but only sometimes. They must be
+        # called with an argument. For example:
+        #
+        #   [1,2].first    # => 1
+        #   [1,2].first(1) # => [1]
+        #
+        RETURN_NEW_ARRAY_WHEN_ARGS = ':first :last :pop :sample :shift '.freeze
+
+        # These methods return a new array only when called without a block.
+        RETURNS_NEW_ARRAY_WHEN_NO_BLOCK = ':zip :product '.freeze
+
+        # These methods ALWAYS return a new array
+        # after they're called it's safe to mutate the the resulting array
+        ALWAYS_RETURNS_NEW_ARRAY = ':* :+ :- :collect :compact :drop '\
+                                   ':drop_while :flatten :map :reject ' \
+                                   ':reverse :rotate :select :shuffle :sort ' \
+                                   ':take :take_while :transpose :uniq ' \
+                                   ':values_at :| '.freeze
+
+        # These methods have a mutation alternative. For example :collect
+        # can be called as :collect!
+        HAS_MUTATION_ALTERNATIVE = ':collect :compact :flatten :map :reject '\
+                                   ':reverse :rotate :select :shuffle :sort '\
+                                   ':uniq '.freeze
+        MSG = 'Use `%<method>s...%<second_method>s!` instead of `%<method>s' \
+              '...%<second_method>s`.'.freeze
+
+        def_node_matcher :flat_map_candidate?, <<-PATTERN
+          {
+            (send (send _ ${#{RETURN_NEW_ARRAY_WHEN_ARGS}} {int lvar ivar cvar gvar}) ${#{HAS_MUTATION_ALTERNATIVE}} $...)
+            (send (block (send _ ${#{ALWAYS_RETURNS_NEW_ARRAY} }) ...) ${#{HAS_MUTATION_ALTERNATIVE}} $...)
+            (send (send _ ${#{ALWAYS_RETURNS_NEW_ARRAY + RETURNS_NEW_ARRAY_WHEN_NO_BLOCK}} ...) ${#{HAS_MUTATION_ALTERNATIVE}} $...)
+          }
+        PATTERN
+
+        def on_send(node)
+          flat_map_candidate?(node) do |fm, sm, _|
+            range = range_between(
+              node.loc.dot.begin_pos,
+              node.source_range.end_pos
+            )
+            add_offense(
+              node,
+              location: range,
+              message: format(MSG, method: fm, second_method: sm)
+            )
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -48,6 +48,7 @@ module RuboCop
           compare?(node) do |send, var_a, var_b, body|
             replaceable_body?(body, var_a, var_b) do |method, args_a, args_b|
               return unless slow_compare?(method, args_a, args_b)
+
               range = compare_range(send, node)
 
               add_offense(
@@ -78,8 +79,10 @@ module RuboCop
 
         def slow_compare?(method, args_a, args_b)
           return false unless args_a == args_b
+
           if method == :[]
             return false unless args_a.size == 1
+
             key = args_a.first
             return false unless %i[sym str int].include?(key.type)
           else

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Performance
-      # In Ruby 2.4, `String#match?`, `Regexp#match?` and `Symbol#match?`
+      # In Ruby 2.4, `String#match?`, `Regexp#match?`, and `Symbol#match?`
       # have been added. The methods are faster than `match`.
       # Because the methods avoid creating a `MatchData` object or saving
       # backref.
@@ -101,6 +101,7 @@ module RuboCop
 
         def match_with_lvasgn?(node)
           return false unless node.match_with_lvasgn_type?
+
           regexp, _rhs = *node
           regexp.to_regexp.named_captures.empty?
         end

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

@@ -3,8 +3,9 @@
 module RuboCop
   module Cop
     module Performance
-      # This cop is used to identify usages of `shuffle.first`, `shuffle.last`
-      # and `shuffle[]` and change them to use `sample` instead.
+      # This cop is used to identify usages of `shuffle.first`,
+      # `shuffle.last`, and `shuffle[]` and change them to use
+      # `sample` instead.
       #
       # @example
       #   # bad
@@ -88,12 +89,14 @@ module RuboCop
 
         def sample_size_for_two_args(first, second)
           return :unknown unless first.int_type? && first.to_a.first.zero?
+
           second.int_type? ? second.to_a.first : :unknown
         end
 
         def range_size(range_node)
           vals = range_node.to_a
           return :unknown unless vals.all?(&:int_type?)
+
           low, high = vals.map { |val| val.children[0] }
           return :unknown unless low.zero? && high >= 0
 

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

@@ -55,15 +55,21 @@ module RuboCop
         end
 
         def array?(node)
+          return true if node.array_type?
+          return false unless node.send_type?
+
           _, constant = *node.receiver
 
-          node.array_type? || constant == :Array || node.method_name == :to_a
+          constant == :Array || node.method_name == :to_a
         end
 
         def hash?(node)
+          return true if node.hash_type?
+          return false unless node.send_type?
+
           _, constant = *node.receiver
 
-          node.hash_type? || constant == :Hash || node.method_name == :to_h
+          constant == :Hash || node.method_name == :to_h
         end
       end
     end

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

@@ -26,7 +26,7 @@ module RuboCop
 
         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?
+          # 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

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

@@ -22,7 +22,7 @@ module RuboCop
         include RangeHelp
 
         MSG = 'Use `%<prefer>s` instead of `%<current>s`.'.freeze
-        DETERMINISTIC_REGEX = /\A(?:#{LITERAL_REGEX})+\Z/
+        DETERMINISTIC_REGEX = /\A(?:#{LITERAL_REGEX})+\Z/.freeze
         DELETE = 'delete'.freeze
         TR = 'tr'.freeze
         BANG = '!'.freeze
@@ -87,6 +87,7 @@ module RuboCop
           unless first_param.str_type?
             return true if options
             return true unless first_source =~ DETERMINISTIC_REGEX
+
             # This must be done after checking DETERMINISTIC_REGEX
             # Otherwise things like \s will trip us up
             first_source = interpret_string_escapes(first_source)

data/lib/rubocop/cop/performance_cops.rb

@@ -35,3 +35,4 @@ require_relative 'performance/times_map'
 require_relative 'performance/unfreeze_string'
 require_relative 'performance/unneeded_sort'
 require_relative 'performance/uri_default_parser'
+require_relative 'performance/chain_array_allocation'

data/lib/rubocop/performance/version.rb

@@ -3,7 +3,7 @@
 module RuboCop
   module Performance
     module Version
-      STRING = '0.0.0'
+      STRING = '0.0.1'
     end
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rubocop-performance
 version: !ruby/object:Gem::Version
-  version: 0.0.0
+  version: 0.0.1
 platform: ruby
 authors:
 - Bozhidar Batsov
@@ -10,22 +10,22 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-07-10 00:00:00.000000000 Z
+date: 2018-10-31 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rubocop
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '0.57'
+        version: 0.58.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '0.57'
+        version: 0.58.0
 - !ruby/object:Gem::Dependency
   name: simplecov
   requirement: !ruby/object:Gem::Requirement
@@ -52,10 +52,12 @@ extra_rdoc_files:
 files:
 - LICENSE.txt
 - README.md
+- config/default.yml
 - lib/rubocop-performance.rb
 - lib/rubocop/cop/performance/caller.rb
 - lib/rubocop/cop/performance/case_when_splat.rb
 - lib/rubocop/cop/performance/casecmp.rb
+- lib/rubocop/cop/performance/chain_array_allocation.rb
 - lib/rubocop/cop/performance/compare_with_block.rb
 - lib/rubocop/cop/performance/count.rb
 - lib/rubocop/cop/performance/detect.rb
@@ -99,7 +101,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 2.3.0
+      version: 2.2.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
@@ -107,7 +109,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.7.7
+rubygems_version: 2.7.6
 signing_key: 
 specification_version: 4
 summary: Automatic performance checking tool for Ruby code.