rubocop-performance 0.0.1 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 43633d075fac26295caf28e79d71f56cdbacd6d7853aead53b3ca35e4f29f99b
-  data.tar.gz: 60886d6ea540f6ed25014424376b2e0cf0f489a2291e298f1f4cbf6084f3e580
+  metadata.gz: ab226ddbd8840eb8a3c4281e137a727b4514d9ee99c0f321de8e5d16621622cd
+  data.tar.gz: 04e64315a9ecbbb6cbef28c1dfecb953069b3282f0749caede003c00c93b981c
 SHA512:
-  metadata.gz: b7b30f444965b49aa1597f9f1e483802b3c2f2f786c71fd577f6af18dbdf268e0100793982aa2d8979b86c7a9f302b0b211694e5f8e04c6b2eeaae85c7dd0591
-  data.tar.gz: ac1707a5f94ae008d1baf8c90b2ff269a6bfb3da8e27ed4adb1fa968b69e6dfdbc7ae8a074d18c4fa5d6e7c6b3d5de814f5b5dfbd38832338e80d107b854ad33
+  metadata.gz: 59f5c83e64695cb149d5babfa5e8be759fa11f23f4395810e928b627c236f0d7206f20527a1b2a96953e585f39a89c25f18ac68a44a3dd56ae2daffbc2513990
+  data.tar.gz: '0189ac9e3a329fec641134b595776cb04ba34fe13f1a3f72fc506bc95cb2021402a113090edc3be86bccd251f23768afe6cf81c6f64cfb9855ba3b32b30a0a9e'

data/README.md

@@ -1 +1,73 @@
-# rubocop-performance
+# RuboCop Performance
+
+[![CircleCI](https://circleci.com/gh/rubocop-hq/rubocop-performance.svg?style=svg)](https://circleci.com/gh/rubocop-hq/rubocop-performance)
+
+Performance optimization analysis for your projects, as an extension to [RuboCop](https://github.com/rubocop-hq/rubocop).
+
+## Installation
+
+Just install the `rubocop-performance` gem
+
+```sh
+gem install rubocop-performance
+```
+
+or if you use bundler put this in your `Gemfile`
+
+```ruby
+gem 'rubocop-performance'
+```
+
+## Usage
+
+You need to tell RuboCop to load the Performance extension. There are three
+ways to do this:
+
+### RuboCop configuration file
+
+Put this into your `.rubocop.yml`.
+
+```yaml
+require: rubocop-performance
+```
+
+Now you can run `rubocop` and it will automatically load the RuboCop Performance
+cops together with the standard cops.
+
+### Command line
+
+```sh
+rubocop --require rubocop-performance
+```
+
+### Rake task
+
+```ruby
+RuboCop::RakeTask.new do |task|
+  task.requires << 'rubocop-performance'
+end
+```
+
+## The Cops
+
+All cops are located under
+[`lib/rubocop/cop/performance`](lib/rubocop/cop/performance), and contain
+examples/documentation.
+
+In your `.rubocop.yml`, you may treat the Performance cops just like any other
+cop. For example:
+
+```yaml
+Performance/Size:
+  Exclude:
+    - lib/example.rb
+```
+
+## Contributing
+
+Checkout the [contribution guidelines](CONTRIBUTING.md).
+
+## License
+
+`rubocop-performance` is MIT licensed. [See the accompanying file](LICENSE.txt) for
+the full text.

data/config/default.yml

@@ -1,11 +1,27 @@
 # This is the default configuration file.
 
+Performance/Caller:
+  Description: >-
+             Use `caller(n..n)` instead of `caller`.
+  Enabled: true
+  VersionAdded: '0.49'
+
 Performance/CaseWhenSplat:
   Description: >-
                  Reordering `when` conditions with a splat to the end
                  of the `when` branches can improve performance.
   Enabled: false
   AutoCorrect: false
+  SafeAutoCorrect: false
+  VersionAdded: '0.34'
+  VersionChanged: '0.59'
+
+Performance/Casecmp:
+  Description: >-
+             Use `casecmp` rather than `downcase ==`, `upcase ==`, `== downcase`, or `== upcase`..
+  Reference: 'https://github.com/JuanitoFatas/fast-ruby#stringcasecmp-vs-stringdowncase---code'
+  Enabled: true
+  VersionAdded: '0.36'
 
 Performance/ChainArrayAllocation:
   Description: >-
@@ -13,12 +29,206 @@ Performance/ChainArrayAllocation:
                   existing array.
   Reference: 'https://twitter.com/schneems/status/1034123879978029057'
   Enabled: false
+  VersionAdded: '0.59'
+
+Performance/CompareWithBlock:
+  Description: 'Use `sort_by(&:foo)` instead of `sort { |a, b| a.foo <=> b.foo }`.'
+  Enabled: true
+  VersionAdded: '0.46'
+
+Performance/Count:
+  Description: >-
+                  Use `count` instead of `select...size`, `reject...size`,
+                  `select...count`, `reject...count`, `select...length`,
+                  and `reject...length`.
+  # This cop has known compatibility issues with `ActiveRecord` and other
+  # frameworks. ActiveRecord's `count` ignores the block that is passed to it.
+  # For more information, see the documentation in the cop itself.
+  # If you understand the known risk, you can disable `SafeMode`.
+  SafeMode: true
+  Enabled: true
+  VersionAdded: '0.31'
+  VersionChanged: '0.39'
+
+Performance/Detect:
+  Description: >-
+                  Use `detect` instead of `select.first`, `find_all.first`,
+                  `select.last`, and `find_all.last`.
+  Reference: 'https://github.com/JuanitoFatas/fast-ruby#enumerabledetect-vs-enumerableselectfirst-code'
+  # This cop has known compatibility issues with `ActiveRecord` and other
+  # frameworks. `ActiveRecord` does not implement a `detect` method and `find`
+  # has its own meaning. Correcting `ActiveRecord` methods with this cop
+  # should be considered unsafe.
+  SafeMode: true
+  Enabled: true
+  VersionAdded: '0.30'
+  VersionChanged: '0.39'
 
 Performance/DoubleStartEndWith:
+  Description: >-
+                  Use `str.{start,end}_with?(x, ..., y, ...)`
+                  instead of `str.{start,end}_with?(x, ...) || str.{start,end}_with?(y, ...)`.
+  Enabled: true
+  VersionAdded: '0.36'
+  VersionChanged: '0.48'
   # Used to check for `starts_with?` and `ends_with?`.
   # These methods are defined by `ActiveSupport`.
   IncludeActiveSupportAliases: false
 
+Performance/EndWith:
+  Description: 'Use `end_with?` instead of a regex match anchored to the end of a string.'
+  Reference: 'https://github.com/JuanitoFatas/fast-ruby#stringmatch-vs-stringstart_withstringend_with-code-start-code-end'
+  # This will change to a new method call which isn't guaranteed to be on the
+  # object. Switching these methods has to be done with knowledge of the types
+  # of the variables which rubocop doesn't have.
+  SafeAutoCorrect: false
+  AutoCorrect: false
+  Enabled: true
+  VersionAdded: '0.36'
+  VersionChanged: '0.44'
+
+Performance/FixedSize:
+  Description: 'Do not compute the size of statically sized objects except in constants'
+  Enabled: true
+  VersionAdded: '0.35'
+
+Performance/FlatMap:
+  Description: >-
+                  Use `Enumerable#flat_map`
+                  instead of `Enumerable#map...Array#flatten(1)`
+                  or `Enumberable#collect..Array#flatten(1)`
+  Reference: 'https://github.com/JuanitoFatas/fast-ruby#enumerablemaparrayflatten-vs-enumerableflat_map-code'
+  Enabled: true
+  VersionAdded: '0.30'
+  EnabledForFlattenWithoutParams: false
+  # If enabled, this cop will warn about usages of
+  # `flatten` being called without any parameters.
+  # This can be dangerous since `flat_map` will only flatten 1 level, and
+  # `flatten` without any parameters can flatten multiple levels.
+
+Performance/InefficientHashSearch:
+  Description: 'Use `key?` or `value?` instead of `keys.include?` or `values.include?`'
+  Reference: 'https://github.com/JuanitoFatas/fast-ruby#hashkey-instead-of-hashkeysinclude-code'
+  Enabled: true
+  VersionAdded: '0.56'
+  Safe: false
+
+Performance/LstripRstrip:
+  Description: 'Use `strip` instead of `lstrip.rstrip`.'
+  Enabled: true
+  VersionAdded: '0.36'
+
+Performance/OpenStruct:
+  Description: 'Use `Struct` instead of `OpenStruct`.'
+  Enabled: false
+  VersionAdded: '0.61'
+  Safe: false
+
+Performance/RangeInclude:
+  Description: 'Use `Range#cover?` instead of `Range#include?`.'
+  Reference: 'https://github.com/JuanitoFatas/fast-ruby#cover-vs-include-code'
+  Enabled: true
+  VersionAdded: '0.36'
+  Safe: false
+
+Performance/RedundantBlockCall:
+  Description: 'Use `yield` instead of `block.call`.'
+  Reference: 'https://github.com/JuanitoFatas/fast-ruby#proccall-and-block-arguments-vs-yieldcode'
+  Enabled: true
+  VersionAdded: '0.36'
+
+Performance/RedundantMatch:
+  Description: >-
+                  Use `=~` instead of `String#match` or `Regexp#match` in a context where the
+                  returned `MatchData` is not needed.
+  Enabled: true
+  VersionAdded: '0.36'
+
 Performance/RedundantMerge:
+  Description: 'Use Hash#[]=, rather than Hash#merge! with a single key-value pair.'
+  Reference: 'https://github.com/JuanitoFatas/fast-ruby#hashmerge-vs-hash-code'
+  Enabled: true
+  VersionAdded: '0.36'
   # Max number of key-value pairs to consider an offense
   MaxKeyValuePairs: 2
+
+Performance/RedundantSortBy:
+  Description: 'Use `sort` instead of `sort_by { |x| x }`.'
+  Enabled: true
+  VersionAdded: '0.36'
+
+Performance/RegexpMatch:
+  Description: >-
+                  Use `match?` instead of `Regexp#match`, `String#match`, `Symbol#match`,
+                  `Regexp#===`, or `=~` when `MatchData` is not used.
+  Reference: 'https://github.com/JuanitoFatas/fast-ruby#regexp-vs-stringmatch-vs-string-vs-stringmatch-code-'
+  Enabled: true
+  VersionAdded: '0.47'
+
+Performance/ReverseEach:
+  Description: 'Use `reverse_each` instead of `reverse.each`.'
+  Reference: 'https://github.com/JuanitoFatas/fast-ruby#enumerablereverseeach-vs-enumerablereverse_each-code'
+  Enabled: true
+  VersionAdded: '0.30'
+
+Performance/Sample:
+  Description: >-
+                  Use `sample` instead of `shuffle.first`,
+                  `shuffle.last`, and `shuffle[Integer]`.
+  Reference: 'https://github.com/JuanitoFatas/fast-ruby#arrayshufflefirst-vs-arraysample-code'
+  Enabled: true
+  VersionAdded: '0.30'
+
+Performance/Size:
+  Description: >-
+                  Use `size` instead of `count` for counting
+                  the number of elements in `Array` and `Hash`.
+  Reference: 'https://github.com/JuanitoFatas/fast-ruby#arraylength-vs-arraysize-vs-arraycount-code'
+  Enabled: true
+  VersionAdded: '0.30'
+
+Performance/StartWith:
+  Description: 'Use `start_with?` instead of a regex match anchored to the beginning of a string.'
+  Reference: 'https://github.com/JuanitoFatas/fast-ruby#stringmatch-vs-stringstart_withstringend_with-code-start-code-end'
+  # This will change to a new method call which isn't guaranteed to be on the
+  # object. Switching these methods has to be done with knowledge of the types
+  # of the variables which rubocop doesn't have.
+  SafeAutoCorrect: false
+  AutoCorrect: false
+  Enabled: true
+  VersionAdded: '0.36'
+  VersionChanged: '0.44'
+
+Performance/StringReplacement:
+  Description: >-
+                  Use `tr` instead of `gsub` when you are replacing the same
+                  number of characters. Use `delete` instead of `gsub` when
+                  you are deleting characters.
+  Reference: 'https://github.com/JuanitoFatas/fast-ruby#stringgsub-vs-stringtr-code'
+  Enabled: true
+  VersionAdded: '0.33'
+
+Performance/TimesMap:
+  Description: 'Checks for .times.map calls.'
+  AutoCorrect: false
+  Enabled: true
+  VersionAdded: '0.36'
+  VersionChanged: '0.50'
+  SafeAutoCorrect: false # see https://github.com/rubocop-hq/rubocop/issues/4658
+
+Performance/UnfreezeString:
+  Description: 'Use unary plus to get an unfrozen string literal.'
+  Enabled: true
+  VersionAdded: '0.50'
+
+Performance/UnneededSort:
+  Description: >-
+                  Use `min` instead of `sort.first`,
+                  `max_by` instead of `sort_by...last`, etc.
+  Enabled: true
+  VersionAdded: '0.55'
+
+Performance/UriDefaultParser:
+  Description: 'Use `URI::DEFAULT_PARSER` instead of `URI::Parser.new`.'
+  Enabled: true
+  VersionAdded: '0.50'

data/lib/rubocop-performance.rb

@@ -1,5 +1,11 @@
 # frozen_string_literal: true
 
 require 'rubocop'
+
+require_relative 'rubocop/performance'
 require_relative 'rubocop/performance/version'
+require_relative 'rubocop/performance/inject'
+
+RuboCop::Performance::Inject.defaults!
+
 require_relative 'rubocop/cop/performance_cops'

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

@@ -47,8 +47,9 @@ module RuboCop
         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
+        MSG = 'Use unchained `%<method>s!` and `%<second_method>s!` '\
+              '(followed by `return array` if required) instead of chaining '\
+              '`%<method>s...%<second_method>s`.'.freeze
 
         def_node_matcher :flat_map_candidate?, <<-PATTERN
           {

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

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Performance
+      # This cop checks for `OpenStruct.new` calls.
+      # Instantiation of an `OpenStruct` invalidates
+      # Ruby global method cache as it causes dynamic method
+      # definition during program runtime.
+      # This could have an effect on performance,
+      # especially in case of single-threaded
+      # applications with multiple `OpenStruct` instantiations.
+      #
+      # @example
+      #   # bad
+      #   class MyClass
+      #     def my_method
+      #       OpenStruct.new(my_key1: 'my_value1', my_key2: 'my_value2')
+      #     end
+      #   end
+      #
+      #   # good
+      #   class MyClass
+      #     MyStruct = Struct.new(:my_key1, :my_key2)
+      #     def my_method
+      #       MyStruct.new('my_value1', 'my_value2')
+      #     end
+      #   end
+      #
+      class OpenStruct < Cop
+        MSG = 'Consider using `Struct` over `OpenStruct` ' \
+              'to optimize the performance.'.freeze
+
+        def_node_matcher :open_struct, <<-PATTERN
+          (send (const {nil? cbase} :OpenStruct) :new ...)
+        PATTERN
+
+        def on_send(node)
+          open_struct(node) do |method|
+            add_offense(node, location: :selector, message: format(MSG, method))
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -9,6 +9,9 @@ module RuboCop
       # end points of the `Range`. In a great majority of cases, this is what
       # is wanted.
       #
+      # This cop is `Safe: false` by default because `Range#include?` and
+      # `Range#cover?` are not equivalent behaviour.
+      #
       # @example
       #   # bad
       #   ('a'..'z').include?('b') # => true

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

@@ -14,6 +14,12 @@ module RuboCop
         AREF_ASGN = '%<receiver>s[%<key>s] = %<value>s'.freeze
         MSG = 'Use `%<prefer>s` instead of `%<current>s`.'.freeze
 
+        WITH_MODIFIER_CORRECTION = <<-RUBY.strip_indent
+          %<keyword>s %<condition>s
+          %<leading_space>s%<indent>s%<body>s
+          %<leading_space>send
+        RUBY
+
         def_node_matcher :redundant_merge_candidate, <<-PATTERN
           (send $!nil? :merge! [(hash $...) !kwsplat_type?])
         PATTERN
@@ -60,6 +66,7 @@ module RuboCop
 
         def non_redundant_merge?(node, receiver, pairs)
           non_redundant_pairs?(receiver, pairs) ||
+            kwsplat_used?(pairs) ||
             non_redundant_value_used?(receiver, node)
         end
 
@@ -67,6 +74,10 @@ module RuboCop
           pairs.size > 1 && !receiver.pure? || pairs.size > max_key_value_pairs
         end
 
+        def kwsplat_used?(pairs)
+          pairs.any?(&:kwsplat_type?)
+        end
+
         def non_redundant_value_used?(receiver, node)
           node.value_used? &&
             !EachWithObjectInspector.new(node, receiver).value_used?
@@ -101,12 +112,15 @@ module RuboCop
         end
 
         def rewrite_with_modifier(node, parent, new_source)
-          cond, = *parent
-          padding = "\n#{(' ' * indent_width) + leading_spaces(node)}"
+          indent = ' ' * indent_width
+          padding = "\n#{indent + leading_spaces(node)}"
           new_source.gsub!(/\n/, padding)
 
-          parent.loc.keyword.source << ' ' << cond.source << padding <<
-            new_source << "\n" << leading_spaces(node) << 'end'
+          format(WITH_MODIFIER_CORRECTION, keyword: parent.loc.keyword.source,
+                                           condition: parent.condition.source,
+                                           leading_space: leading_spaces(node),
+                                           indent: indent,
+                                           body: new_source).chomp
         end
 
         def leading_spaces(node)

data/lib/rubocop/cop/performance_cops.rb

@@ -1,9 +1,9 @@
 # frozen_string_literal: true
 
 module RuboCop
+  # RuboCop included the performance cops directly before version 1.0.0.
+  # We can remove them to avoid warnings about redefining constants.
   module Cop
-    # RuboCop included the performance cops directly before version 1.0.0.
-    # We can remove them to avoid warnings about redefining constants.
     remove_const('Performance') if const_defined?('Performance')
   end
 end
@@ -20,6 +20,7 @@ require_relative 'performance/fixed_size'
 require_relative 'performance/flat_map'
 require_relative 'performance/inefficient_hash_search'
 require_relative 'performance/lstrip_rstrip'
+require_relative 'performance/open_struct'
 require_relative 'performance/range_include'
 require_relative 'performance/redundant_block_call'
 require_relative 'performance/redundant_match'

data/lib/rubocop/performance.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module RuboCop
+  # RuboCop Performance project namespace
+  module Performance
+    PROJECT_ROOT = Pathname.new(__dir__).parent.parent.expand_path.freeze
+    CONFIG_DEFAULT = PROJECT_ROOT.join('config', 'default.yml').freeze
+    CONFIG = YAML.safe_load(CONFIG_DEFAULT.read).freeze
+
+    private_constant(:CONFIG_DEFAULT, :PROJECT_ROOT)
+  end
+end

data/lib/rubocop/performance/inject.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Performance
+    # Because RuboCop doesn't yet support plugins, we have to monkey patch in a
+    # bit of our configuration.
+    module Inject
+      def self.defaults!
+        path = CONFIG_DEFAULT.to_s
+        hash = ConfigLoader.send(:load_yaml_configuration, path)
+        config = Config.new(hash, path)
+        puts "configuration from #{path}" if ConfigLoader.debug?
+        config = ConfigLoader.merge_with_default(config, path)
+        ConfigLoader.instance_variable_set(:@default_configuration, config)
+      end
+    end
+  end
+end

data/lib/rubocop/performance/version.rb

@@ -3,7 +3,7 @@
 module RuboCop
   module Performance
     module Version
-      STRING = '0.0.1'
+      STRING = '1.0.0'.freeze
     end
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rubocop-performance
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 1.0.0
 platform: ruby
 authors:
 - Bozhidar Batsov
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-10-31 00:00:00.000000000 Z
+date: 2019-03-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rubocop
@@ -67,6 +67,7 @@ files:
 - lib/rubocop/cop/performance/flat_map.rb
 - lib/rubocop/cop/performance/inefficient_hash_search.rb
 - lib/rubocop/cop/performance/lstrip_rstrip.rb
+- lib/rubocop/cop/performance/open_struct.rb
 - lib/rubocop/cop/performance/range_include.rb
 - lib/rubocop/cop/performance/redundant_block_call.rb
 - lib/rubocop/cop/performance/redundant_match.rb
@@ -83,6 +84,8 @@ files:
 - lib/rubocop/cop/performance/unneeded_sort.rb
 - lib/rubocop/cop/performance/uri_default_parser.rb
 - lib/rubocop/cop/performance_cops.rb
+- lib/rubocop/performance.rb
+- lib/rubocop/performance/inject.rb
 - lib/rubocop/performance/version.rb
 homepage: https://github.com/rubocop-hq/rubocop-performance
 licenses:
@@ -108,8 +111,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.7.6
+rubygems_version: 3.0.3
 signing_key: 
 specification_version: 4
 summary: Automatic performance checking tool for Ruby code.