rubocop 0.67.2 → 0.68.0

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

@@ -1,94 +0,0 @@
-# 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")
-      #   str.end_with?(var1) || str.end_with?(var2)
-      #
-      #   # good
-      #   str.start_with?("a", Some::CONST)
-      #   str.start_with?("a", "b", "c")
-      #   str.end_with?(var1, var2)
-      class DoubleStartEndWith < Cop
-        MSG = 'Use `%<receiver>s.%<method>s(%<combined_args>s)` ' \
-              'instead of `%<original_code>s`.'.freeze
-
-        def on_or(node)
-          receiver,
-          method,
-          first_call_args,
-          second_call_args = process_source(node)
-
-          return unless receiver && second_call_args.all?(&:pure?)
-
-          combined_args = combine_args(first_call_args, second_call_args)
-
-          add_offense_for_double_call(node, receiver, method, combined_args)
-        end
-
-        def autocorrect(node)
-          _receiver, _method,
-          first_call_args, second_call_args = process_source(node)
-
-          combined_args = combine_args(first_call_args, second_call_args)
-          first_argument = first_call_args.first.loc.expression
-          last_argument = second_call_args.last.loc.expression
-          range = first_argument.join(last_argument)
-
-          lambda do |corrector|
-            corrector.replace(range, combined_args)
-          end
-        end
-
-        private
-
-        def process_source(node)
-          if check_for_active_support_aliases?
-            check_with_active_support_aliases(node)
-          else
-            two_start_end_with_calls(node)
-          end
-        end
-
-        def combine_args(first_call_args, second_call_args)
-          (first_call_args + second_call_args).map(&:source).join(', ')
-        end
-
-        def add_offense_for_double_call(node, receiver, method, combined_args)
-          msg = format(MSG, receiver: receiver.source,
-                            method: method,
-                            combined_args: combined_args,
-                            original_code: node.source)
-
-          add_offense(node, message: msg)
-        end
-
-        def check_for_active_support_aliases?
-          cop_config['IncludeActiveSupportAliases']
-        end
-
-        def_node_matcher :two_start_end_with_calls, <<-PATTERN
-          (or
-            (send $_recv [{:start_with? :end_with?} $_method] $...)
-            (send _recv _method $...))
-        PATTERN
-
-        def_node_matcher :check_with_active_support_aliases, <<-PATTERN
-          (or
-            (send $_recv
-                    [{:start_with? :starts_with? :end_with? :ends_with?} $_method]
-                  $...)
-            (send _recv _method $...))
-        PATTERN
-      end
-    end
-  end
-end

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

@@ -1,56 +0,0 @@
-# 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'.match?(/bc\Z/)
-      #   'abc' =~ /bc\Z/
-      #   'abc'.match(/bc\Z/)
-      #
-      #   # good
-      #   'abc'.end_with?('bc')
-      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?, <<-PATTERN
-          {(send $!nil? {:match :=~ :match?} (regexp (str $#literal_at_end?) (regopt)))
-           (send (regexp (str $#literal_at_end?) (regopt)) {:match :=~} $_)}
-        PATTERN
-
-        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)
-          return unless redundant_regex?(node)
-
-          add_offense(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,97 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Performance
-      # Do not compute the size of statically sized objects.
-      #
-      # @example
-      #   # String methods
-      #   # bad
-      #   'foo'.size
-      #   %q[bar].count
-      #   %(qux).length
-      #
-      #   # Symbol methods
-      #   # bad
-      #   :fred.size
-      #   :'baz'.length
-      #
-      #   # Array methods
-      #   # bad
-      #   [1, 2, thud].count
-      #   %W(1, 2, bar).size
-      #
-      #   # Hash methods
-      #   # bad
-      #   { a: corge, b: grault }.length
-      #
-      #   # good
-      #   foo.size
-      #   bar.count
-      #   qux.length
-      #
-      #   # good
-      #   :"#{fred}".size
-      #   CONST = :baz.length
-      #
-      #   # good
-      #   [1, 2, *thud].count
-      #   garply = [1, 2, 3]
-      #   garly.size
-      #
-      #   # good
-      #   { a: corge, **grault }.length
-      #   waldo = { a: corge, b: grault }
-      #   waldo.size
-      #
-      class FixedSize < Cop
-        MSG = 'Do not compute the size of statically sized objects.'.freeze
-
-        def_node_matcher :counter, <<-MATCHER
-          (send ${array hash str sym} {:count :length :size} $...)
-        MATCHER
-
-        def on_send(node)
-          return if allowed_parent?(node.parent)
-
-          counter(node) do |var, arg|
-            return if allowed_variable?(var) || allowed_argument?(arg)
-
-            add_offense(node)
-          end
-        end
-
-        private
-
-        def allowed_variable?(var)
-          contains_splat?(var) || contains_double_splat?(var)
-        end
-
-        def allowed_argument?(arg)
-          arg && non_string_argument?(arg.first)
-        end
-
-        def allowed_parent?(node)
-          node && (node.casgn_type? || node.block_type?)
-        end
-
-        def contains_splat?(node)
-          return unless node.array_type?
-
-          node.each_child_node(:splat).any?
-        end
-
-        def contains_double_splat?(node)
-          return unless node.hash_type?
-
-          node.each_child_node(:kwsplat).any?
-        end
-
-        def non_string_argument?(node)
-          node && !node.str_type?
-        end
-      end
-    end
-  end
-end

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

@@ -1,78 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Performance
-      # This cop is used to identify usages of
-      #
-      # @example
-      #   # bad
-      #   [1, 2, 3, 4].map { |e| [e, e] }.flatten(1)
-      #   [1, 2, 3, 4].collect { |e| [e, e] }.flatten(1)
-      #
-      #   # good
-      #   [1, 2, 3, 4].flat_map { |e| [e, e] }
-      #   [1, 2, 3, 4].map { |e| [e, e] }.flatten
-      #   [1, 2, 3, 4].collect { |e| [e, e] }.flatten
-      class FlatMap < Cop
-        include RangeHelp
-
-        MSG = 'Use `flat_map` instead of `%<method>s...%<flatten>s`.'.freeze
-        FLATTEN_MULTIPLE_LEVELS = ' Beware, `flat_map` only flattens 1 level ' \
-                                  'and `flatten` can be used to flatten ' \
-                                  'multiple levels.'.freeze
-
-        def_node_matcher :flat_map_candidate?, <<-PATTERN
-          (send (block $(send _ ${:collect :map}) ...) ${:flatten :flatten!} $...)
-        PATTERN
-
-        def on_send(node)
-          flat_map_candidate?(node) do |map_node, first_method, flatten, params|
-            flatten_level, = *params.first
-            if cop_config['EnabledForFlattenWithoutParams'] && !flatten_level
-              offense_for_levels(node, map_node, first_method, flatten)
-            elsif flatten_level == 1
-              offense_for_method(node, map_node, first_method, flatten)
-            end
-          end
-        end
-
-        def autocorrect(node)
-          map_node, _first_method, _flatten, params = flat_map_candidate?(node)
-          flatten_level, = *params.first
-
-          return unless flatten_level
-
-          range = range_between(node.loc.dot.begin_pos,
-                                node.source_range.end_pos)
-
-          lambda do |corrector|
-            corrector.remove(range)
-            corrector.replace(map_node.loc.selector, 'flat_map')
-          end
-        end
-
-        private
-
-        def offense_for_levels(node, map_node, first_method, flatten)
-          message = MSG + FLATTEN_MULTIPLE_LEVELS
-          register_offense(node, map_node, first_method, flatten, message)
-        end
-
-        def offense_for_method(node, map_node, first_method, flatten)
-          register_offense(node, map_node, first_method, flatten, MSG)
-        end
-
-        def register_offense(node, map_node, first_method, flatten, message)
-          range = range_between(map_node.loc.selector.begin_pos,
-                                node.loc.expression.end_pos)
-
-          add_offense(node,
-                      location: range,
-                      message: format(message, method: first_method,
-                                               flatten: flatten))
-        end
-      end
-    end
-  end
-end

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

@@ -1,99 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Performance
-      # This cop checks for inefficient searching of keys and values within
-      # hashes.
-      #
-      # `Hash#keys.include?` is less efficient than `Hash#key?` because
-      # the former allocates a new array and then performs an O(n) search
-      # through that array, while `Hash#key?` does not allocate any array and
-      # performs a faster O(1) search for the key.
-      #
-      # `Hash#values.include?` is less efficient than `Hash#value?`. While they
-      # both perform an O(n) search through all of the values, calling `values`
-      # allocates a new array while using `value?` does not.
-      #
-      # @example
-      #   # bad
-      #   { a: 1, b: 2 }.keys.include?(:a)
-      #   { a: 1, b: 2 }.keys.include?(:z)
-      #   h = { a: 1, b: 2 }; h.keys.include?(100)
-      #
-      #   # good
-      #   { a: 1, b: 2 }.key?(:a)
-      #   { a: 1, b: 2 }.has_key?(:z)
-      #   h = { a: 1, b: 2 }; h.key?(100)
-      #
-      #   # bad
-      #   { a: 1, b: 2 }.values.include?(2)
-      #   { a: 1, b: 2 }.values.include?('garbage')
-      #   h = { a: 1, b: 2 }; h.values.include?(nil)
-      #
-      #   # good
-      #   { a: 1, b: 2 }.value?(2)
-      #   { a: 1, b: 2 }.has_value?('garbage')
-      #   h = { a: 1, b: 2 }; h.value?(nil)
-      #
-      class InefficientHashSearch < Cop
-        def_node_matcher :inefficient_include?, <<-PATTERN
-          (send (send $_ {:keys :values}) :include? _)
-        PATTERN
-
-        def on_send(node)
-          inefficient_include?(node) do |receiver|
-            return if receiver.nil?
-
-            add_offense(node)
-          end
-        end
-
-        def autocorrect(node)
-          lambda do |corrector|
-            # Replace `keys.include?` or `values.include?` with the appropriate
-            # `key?`/`value?` method.
-            corrector.replace(
-              node.loc.expression,
-              "#{autocorrect_hash_expression(node)}."\
-              "#{autocorrect_method(node)}(#{autocorrect_argument(node)})"
-            )
-          end
-        end
-
-        private
-
-        def message(node)
-          "Use `##{autocorrect_method(node)}` instead of "\
-            "`##{current_method(node)}.include?`."
-        end
-
-        def autocorrect_method(node)
-          case current_method(node)
-          when :keys then use_long_method ? 'has_key?' : 'key?'
-          when :values then use_long_method ? 'has_value?' : 'value?'
-          end
-        end
-
-        def current_method(node)
-          node.receiver.method_name
-        end
-
-        def use_long_method
-          preferred_config = config.for_all_cops['Style/PreferredHashMethods']
-          preferred_config &&
-            preferred_config['EnforcedStyle'] == 'long' &&
-            preferred_config['Enabled']
-        end
-
-        def autocorrect_argument(node)
-          node.arguments.first.source
-        end
-
-        def autocorrect_hash_expression(node)
-          node.receiver.receiver.source
-        end
-      end
-    end
-  end
-end

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

@@ -1,46 +0,0 @@
-# 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