rubocop 0.51.0 → 0.87.0

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

@@ -1,170 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Performance
-      # This cop identifies places where `gsub` can be replaced by
-      # `tr` or `delete`.
-      #
-      # @example
-      #   @bad
-      #   'abc'.gsub('b', 'd')
-      #   'abc'.gsub('a', '')
-      #   'abc'.gsub(/a/, 'd')
-      #   'abc'.gsub!('a', 'd')
-      #
-      #   @good
-      #   'abc'.gsub(/.*/, 'a')
-      #   'abc'.gsub(/a+/, 'd')
-      #   'abc'.tr('b', 'd')
-      #   'a b c'.delete(' ')
-      class StringReplacement < Cop
-        MSG = 'Use `%s` instead of `%s`.'.freeze
-        DETERMINISTIC_REGEX = /\A(?:#{LITERAL_REGEX})+\Z/
-        DELETE = 'delete'.freeze
-        TR = 'tr'.freeze
-        BANG = '!'.freeze
-        SINGLE_QUOTE = "'".freeze
-
-        def_node_matcher :string_replacement?, <<-PATTERN
-          (send _ {:gsub :gsub!}
-                    ${regexp str (send (const nil? :Regexp) {:new :compile} _)}
-                    $str)
-        PATTERN
-
-        def on_send(node)
-          string_replacement?(node) do |first_param, second_param|
-            return if accept_second_param?(second_param)
-            return if accept_first_param?(first_param)
-
-            offense(node, first_param, second_param)
-          end
-        end
-
-        def autocorrect(node)
-          _string, _method, first_param, second_param = *node
-          first_source, = first_source(first_param)
-          second_source, = *second_param
-
-          unless first_param.str_type?
-            first_source = interpret_string_escapes(first_source)
-          end
-
-          replacement_method =
-            replacement_method(node, first_source, second_source)
-
-          replace_method(node, first_source, second_source, first_param,
-                         replacement_method)
-        end
-
-        def replace_method(node, first, second, first_param, replacement)
-          lambda do |corrector|
-            corrector.replace(node.loc.selector, replacement)
-            unless first_param.str_type?
-              corrector.replace(first_param.source_range,
-                                to_string_literal(first))
-            end
-
-            if second.empty? && first.length == 1
-              remove_second_param(corrector, node, first_param)
-            end
-          end
-        end
-
-        private
-
-        def accept_second_param?(second_param)
-          second_source, = *second_param
-          second_source.length > 1
-        end
-
-        def accept_first_param?(first_param)
-          first_source, options = first_source(first_param)
-          return true if first_source.nil?
-
-          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)
-          end
-
-          first_source.length != 1
-        end
-
-        def offense(node, first_param, second_param)
-          first_source, = first_source(first_param)
-          unless first_param.str_type?
-            first_source = interpret_string_escapes(first_source)
-          end
-          second_source, = *second_param
-          message = message(node, first_source, second_source)
-
-          add_offense(node, location: range(node), message: message)
-        end
-
-        def first_source(first_param)
-          case first_param.type
-          when :regexp
-            source_from_regex_literal(first_param)
-          when :send
-            source_from_regex_constructor(first_param)
-          when :str
-            first_param.children.first
-          end
-        end
-
-        def source_from_regex_literal(node)
-          regex, options = *node
-          source, = *regex
-          options, = *options
-          [source, options]
-        end
-
-        def source_from_regex_constructor(node)
-          _const, _init, regex = *node
-          case regex.type
-          when :regexp
-            source_from_regex_literal(regex)
-          when :str
-            source, = *regex
-            source
-          end
-        end
-
-        def range(node)
-          range_between(node.loc.selector.begin_pos, node.source_range.end_pos)
-        end
-
-        def replacement_method(node, first_source, second_source)
-          replacement = if second_source.empty? && first_source.length == 1
-                          DELETE
-                        else
-                          TR
-                        end
-
-          "#{replacement}#{BANG if node.bang_method?}"
-        end
-
-        def message(node, first_source, second_source)
-          replacement_method =
-            replacement_method(node, first_source, second_source)
-
-          format(MSG, replacement_method, node.method_name)
-        end
-
-        def method_suffix(node)
-          node.loc.end ? node.loc.end.source : ''
-        end
-
-        def remove_second_param(corrector, node, first_param)
-          end_range = range_between(first_param.source_range.end_pos,
-                                    node.source_range.end_pos)
-
-          corrector.replace(end_range, method_suffix(node))
-        end
-      end
-    end
-  end
-end

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

@@ -1,72 +0,0 @@
-# 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
-        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)
-        end
-
-        def on_block(node)
-          check(node)
-        end
-
-        private
-
-        def check(node)
-          times_map_call(node) do |map_or_collect, count|
-            add_offense(node, message: message(map_or_collect, count))
-          end
-        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_node_matcher :times_map_call, <<-PATTERN
-          {(block $(send (send $!nil? :times) {:map :collect}) ...)
-           $(send (send $!nil? :times) {:map :collect} (block_pass ...))}
-        PATTERN
-
-        def autocorrect(node)
-          map_or_collect, count = times_map_call(node)
-
-          replacement =
-            "Array.new(#{count.source}" \
-            "#{map_or_collect.arguments.map { |arg| ", #{arg.source}" }.join})"
-
-          lambda do |corrector|
-            corrector.replace(map_or_collect.loc.expression, replacement)
-          end
-        end
-      end
-    end
-  end
-end

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

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

@@ -1,47 +0,0 @@
-# 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, message: 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/action_filter.rb

@@ -1,94 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Rails
-      # This cop enforces the consistent use of action filter methods.
-      #
-      # The cop is configurable and can enforce the use of the older
-      # something_filter methods or the newer something_action methods.
-      #
-      # If the TargetRailsVersion is set to less than 4.0, the cop will enforce
-      # the use of filter methods.
-      class ActionFilter < Cop
-        extend TargetRailsVersion
-        include ConfigurableEnforcedStyle
-
-        MSG = 'Prefer `%s` over `%s`.'.freeze
-
-        FILTER_METHODS = %i[
-          after_filter
-          append_after_filter
-          append_around_filter
-          append_before_filter
-          around_filter
-          before_filter
-          prepend_after_filter
-          prepend_around_filter
-          prepend_before_filter
-          skip_after_filter
-          skip_around_filter
-          skip_before_filter
-          skip_filter
-        ].freeze
-
-        ACTION_METHODS = %i[
-          after_action
-          append_after_action
-          append_around_action
-          append_before_action
-          around_action
-          before_action
-          prepend_after_action
-          prepend_around_action
-          prepend_before_action
-          skip_after_action
-          skip_around_action
-          skip_before_action
-          skip_action_callback
-        ].freeze
-
-        minimum_target_rails_version 4.0
-
-        def on_block(node)
-          check_method_node(node.send_node)
-        end
-
-        def on_send(node)
-          check_method_node(node) unless node.receiver
-        end
-
-        def autocorrect(node)
-          lambda do |corrector|
-            corrector.replace(node.loc.selector,
-                              preferred_method(node.loc.selector.source).to_s)
-          end
-        end
-
-        private
-
-        def check_method_node(node)
-          return unless bad_methods.include?(node.method_name)
-
-          add_offense(node, location: :selector)
-        end
-
-        def message(node)
-          format(MSG, preferred_method(node.method_name), node.method_name)
-        end
-
-        def bad_methods
-          style == :action ? FILTER_METHODS : ACTION_METHODS
-        end
-
-        def good_methods
-          style == :action ? ACTION_METHODS : FILTER_METHODS
-        end
-
-        def preferred_method(method)
-          good_methods[bad_methods.index(method.to_sym)]
-        end
-      end
-    end
-  end
-end

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

@@ -1,67 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Rails
-      # This cop checks that ActiveSupport aliases to core ruby methods
-      # are not used.
-      #
-      # @example
-      #   # good
-      #   'some_string'.start_with?('prefix')
-      #   'some_string'.end_with?('suffix')
-      #   [1, 2, 'a'] << 'b'
-      #   [1, 2, 'a'].unshift('b')
-      #
-      #   # bad
-      #   'some_string'.starts_with?('prefix')
-      #   'some_string'.ends_with?('suffix')
-      #   [1, 2, 'a'].append('b')
-      #   [1, 2, 'a'].prepend('b')
-      #
-      class ActiveSupportAliases < Cop
-        MSG = 'Use `%s` instead of `%s`.'.freeze
-
-        ALIASES = {
-          starts_with?: {
-            original: :start_with?, matcher: '(send str :starts_with? _)'
-          },
-          ends_with?: {
-            original: :end_with?, matcher: '(send str :ends_with? _)'
-          },
-          append: { original: :<<, matcher: '(send array :append _)' },
-          prepend: { original: :unshift, matcher: '(send array :prepend _)' }
-        }.freeze
-
-        ALIASES.each do |aliased_method, options|
-          def_node_matcher aliased_method, options[:matcher]
-        end
-
-        def on_send(node)
-          ALIASES.each_key do |aliased_method|
-            register_offense(node, aliased_method) if
-              public_send(aliased_method, node)
-          end
-        end
-
-        private
-
-        def autocorrect(node)
-          return false if append(node)
-          lambda do |corrector|
-            method_name = node.loc.selector.source
-            replacement = ALIASES[method_name.to_sym][:original]
-            corrector.replace(node.loc.selector, replacement.to_s)
-          end
-        end
-
-        def register_offense(node, method_name)
-          add_offense(
-            node,
-            message: format(MSG, ALIASES[method_name][:original], method_name)
-          )
-        end
-      end
-    end
-  end
-end

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

@@ -1,32 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Rails
-      # This cop checks that jobs subclass ApplicationJob with Rails 5.0.
-      #
-      # @example
-      #
-      #  # good
-      #  class Rails5Job < ApplicationJob
-      #    ...
-      #  end
-      #
-      #  # bad
-      #  class Rails4Job < ActiveJob::Base
-      #    ...
-      #  end
-      class ApplicationJob < Cop
-        extend TargetRailsVersion
-
-        minimum_target_rails_version 5.0
-
-        MSG = 'Jobs should subclass `ApplicationJob`.'.freeze
-        SUPERCLASS = 'ApplicationJob'.freeze
-        BASE_PATTERN = '(const (const nil? :ActiveJob) :Base)'.freeze
-
-        include RuboCop::Cop::EnforceSuperclass
-      end
-    end
-  end
-end

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

@@ -1,32 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Rails
-      # This cop checks that models subclass ApplicationRecord with Rails 5.0.
-      #
-      # @example
-      #
-      #  # good
-      #  class Rails5Model < ApplicationRecord
-      #    ...
-      #  end
-      #
-      #  # bad
-      #  class Rails4Model < ActiveRecord::Base
-      #    ...
-      #  end
-      class ApplicationRecord < Cop
-        extend TargetRailsVersion
-
-        minimum_target_rails_version 5.0
-
-        MSG = 'Models should subclass `ApplicationRecord`.'.freeze
-        SUPERCLASS = 'ApplicationRecord'.freeze
-        BASE_PATTERN = '(const (const nil? :ActiveRecord) :Base)'.freeze
-
-        include RuboCop::Cop::EnforceSuperclass
-      end
-    end
-  end
-end

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

@@ -1,141 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Rails
-      # This cops checks for code that can be changed to `blank?`.
-      # Settings:
-      #   NilOrEmpty: Convert checks for `nil` or `empty?` to `blank?`
-      #   NotPresent: Convert usages of not `present?` to `blank?`
-      #   UnlessPresent: Convert usages of `unless` `present?` to `blank?`
-      #
-      # @example
-      #   # NilOrEmpty: true
-      #     # bad
-      #     foo.nil? || foo.empty?
-      #     foo == nil || foo.empty?
-      #
-      #     # good
-      #     foo.blank?
-      #
-      #   # NotPresent: true
-      #     # bad
-      #     !foo.present?
-      #
-      #     # good
-      #     foo.blank?
-      #
-      #   # UnlessPresent: true
-      #     # bad
-      #     something unless foo.present?
-      #     unless foo.present?
-      #       something
-      #     end
-      #
-      #     # good
-      #     something if foo.blank?
-      #     if foo.blank?
-      #       something
-      #     end
-      class Blank < Cop
-        MSG_NIL_OR_EMPTY = 'Use `%s` instead of `%s`.'.freeze
-        MSG_NOT_PRESENT = 'Use `%s` instead of `%s`.'.freeze
-        MSG_UNLESS_PRESENT = 'Use `if %s` instead of `%s`.'.freeze
-
-        # `(send nil $_)` is not actually a valid match for an offense. Nodes
-        # that have a single method call on the left hand side
-        # (`bar || foo.empty?`) will blow up when checking
-        # `(send (:nil) :== $_)`.
-        def_node_matcher :nil_or_empty?, <<-PATTERN
-          (or
-              {
-                (send $_ :!)
-                (send $_ :nil?)
-                (send $_ :== nil)
-                (send nil :== $_)
-              }
-              {
-                (send $_ :empty?)
-                (send (send (send $_ :empty?) :!) :!)
-              }
-          )
-        PATTERN
-
-        def_node_matcher :not_present?, '(send (send $_ :present?) :!)'
-
-        def_node_matcher :unless_present?, <<-PATTERN
-          (:if $(send $_ :present?) {nil? (...)} ...)
-        PATTERN
-
-        def on_send(node)
-          return unless cop_config['NotPresent']
-
-          not_present?(node) do |receiver|
-            add_offense(node,
-                        message: format(MSG_NOT_PRESENT,
-                                        replacement(receiver),
-                                        node.source))
-          end
-        end
-
-        def on_or(node)
-          return unless cop_config['NilOrEmpty']
-
-          nil_or_empty?(node) do |variable1, variable2|
-            return unless variable1 == variable2
-
-            add_offense(node,
-                        message: format(MSG_NIL_OR_EMPTY,
-                                        replacement(variable1),
-                                        node.source))
-          end
-        end
-
-        def on_if(node)
-          return unless cop_config['UnlessPresent']
-          return unless node.unless?
-
-          unless_present?(node) do |method_call, receiver|
-            range = unless_condition(node, method_call)
-
-            add_offense(node,
-                        location: range,
-                        message: format(MSG_UNLESS_PRESENT,
-                                        replacement(receiver),
-                                        range.source))
-          end
-        end
-
-        def autocorrect(node)
-          lambda do |corrector|
-            method_call, variable1 = unless_present?(node)
-
-            if method_call
-              corrector.replace(node.loc.keyword, 'if')
-              range = method_call.loc.expression
-            else
-              variable1, _variable2 = nil_or_empty?(node) || not_present?(node)
-              range = node.loc.expression
-            end
-
-            corrector.replace(range, replacement(variable1))
-          end
-        end
-
-        private
-
-        def unless_condition(node, method_call)
-          if node.modifier_form?
-            node.loc.keyword.join(node.loc.expression.end)
-          else
-            node.loc.expression.begin.join(method_call.loc.expression)
-          end
-        end
-
-        def replacement(node)
-          node.respond_to?(:source) ? "#{node.source}.blank?" : 'blank?'
-        end
-      end
-    end
-  end
-end