rubocop 0.70.0 → 0.75.0

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

@@ -1,107 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Rails
-      # This cop checks for correct grammar when using ActiveSupport's
-      # core extensions to the numeric classes.
-      #
-      # @example
-      #   # bad
-      #   3.day.ago
-      #   1.months.ago
-      #
-      #   # good
-      #   3.days.ago
-      #   1.month.ago
-      class PluralizationGrammar < Cop
-        SINGULAR_DURATION_METHODS = { second: :seconds,
-                                      minute: :minutes,
-                                      hour: :hours,
-                                      day: :days,
-                                      week: :weeks,
-                                      fortnight: :fortnights,
-                                      month: :months,
-                                      year: :years }.freeze
-
-        PLURAL_DURATION_METHODS = SINGULAR_DURATION_METHODS.invert.freeze
-
-        MSG = 'Prefer `%<number>s.%<correct>s`.'
-
-        def on_send(node)
-          return unless duration_method?(node.method_name)
-          return unless literal_number?(node.receiver)
-
-          return unless offense?(node)
-
-          add_offense(node)
-        end
-
-        def autocorrect(node)
-          lambda do |corrector|
-            method_name = node.loc.selector.source
-
-            corrector.replace(node.loc.selector, correct_method(method_name))
-          end
-        end
-
-        private
-
-        def message(node)
-          number, = *node.receiver
-
-          format(MSG, number: number,
-                      correct: correct_method(node.method_name.to_s))
-        end
-
-        def correct_method(method_name)
-          if plural_method?(method_name)
-            singularize(method_name)
-          else
-            pluralize(method_name)
-          end
-        end
-
-        def offense?(node)
-          number, = *node.receiver
-
-          singular_receiver?(number) && plural_method?(node.method_name) ||
-            plural_receiver?(number) && singular_method?(node.method_name)
-        end
-
-        def plural_method?(method_name)
-          method_name.to_s.end_with?('s')
-        end
-
-        def singular_method?(method_name)
-          !plural_method?(method_name)
-        end
-
-        def singular_receiver?(number)
-          number.abs == 1
-        end
-
-        def plural_receiver?(number)
-          !singular_receiver?(number)
-        end
-
-        def literal_number?(node)
-          node && (node.int_type? || node.float_type?)
-        end
-
-        def pluralize(method_name)
-          SINGULAR_DURATION_METHODS.fetch(method_name.to_sym).to_s
-        end
-
-        def singularize(method_name)
-          PLURAL_DURATION_METHODS.fetch(method_name.to_sym).to_s
-        end
-
-        def duration_method?(method_name)
-          SINGULAR_DURATION_METHODS.key?(method_name) ||
-            PLURAL_DURATION_METHODS.key?(method_name)
-        end
-      end
-    end
-  end
-end

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

@@ -1,124 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Rails
-      # This cop checks code that can be written more easily using
-      # `Object#presence` defined by Active Support.
-      #
-      # @example
-      #   # bad
-      #   a.present? ? a : nil
-      #
-      #   # bad
-      #   !a.present? ? nil : a
-      #
-      #   # bad
-      #   a.blank? ? nil : a
-      #
-      #   # bad
-      #   !a.blank? ? a : nil
-      #
-      #   # good
-      #   a.presence
-      #
-      # @example
-      #   # bad
-      #   a.present? ? a : b
-      #
-      #   # bad
-      #   !a.present? ? b : a
-      #
-      #   # bad
-      #   a.blank? ? b : a
-      #
-      #   # bad
-      #   !a.blank? ? a : b
-      #
-      #   # good
-      #   a.presence || b
-      class Presence < Cop
-        MSG = 'Use `%<prefer>s` instead of `%<current>s`.'
-
-        def_node_matcher :redundant_receiver_and_other, <<-PATTERN
-          {
-            (if
-              (send $_recv :present?)
-              _recv
-              $!begin
-            )
-            (if
-              (send $_recv :blank?)
-              $!begin
-              _recv
-            )
-          }
-        PATTERN
-
-        def_node_matcher :redundant_negative_receiver_and_other, <<-PATTERN
-          {
-            (if
-              (send (send $_recv :present?) :!)
-              $!begin
-              _recv
-            )
-            (if
-              (send (send $_recv :blank?) :!)
-              _recv
-              $!begin
-            )
-          }
-        PATTERN
-
-        def on_if(node)
-          return if ignore_if_node?(node)
-
-          redundant_receiver_and_other(node) do |receiver, other|
-            unless ignore_other_node?(other) || receiver.nil?
-              add_offense(node, message: message(node, receiver, other))
-            end
-          end
-
-          redundant_negative_receiver_and_other(node) do |receiver, other|
-            unless ignore_other_node?(other) || receiver.nil?
-              add_offense(node, message: message(node, receiver, other))
-            end
-          end
-        end
-
-        def autocorrect(node)
-          lambda do |corrector|
-            redundant_receiver_and_other(node) do |receiver, other|
-              corrector.replace(node.source_range, replacement(receiver, other))
-            end
-
-            redundant_negative_receiver_and_other(node) do |receiver, other|
-              corrector.replace(node.source_range, replacement(receiver, other))
-            end
-          end
-        end
-
-        private
-
-        def ignore_if_node?(node)
-          node.elsif?
-        end
-
-        def ignore_other_node?(node)
-          node && (node.if_type? || node.rescue_type? || node.while_type?)
-        end
-
-        def message(node, receiver, other)
-          format(MSG,
-                 prefer: replacement(receiver, other),
-                 current: node.source)
-        end
-
-        def replacement(receiver, other)
-          or_source = other.nil? || other.nil_type? ? '' : " || #{other.source}"
-          "#{receiver.source}.presence" + or_source
-        end
-      end
-    end
-  end
-end

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

@@ -1,153 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Rails
-      # This cop checks for code that can be written with simpler conditionals
-      # using `Object#present?` defined by Active Support.
-      #
-      # Interaction with `Style/UnlessElse`:
-      # The configuration of `NotBlank` will not produce an offense in the
-      # context of `unless else` if `Style/UnlessElse` is inabled. This is
-      # to prevent interference between the auto-correction of the two cops.
-      #
-      # @example NotNilAndNotEmpty: true (default)
-      #   # Converts usages of `!nil? && !empty?` to `present?`
-      #
-      #   # bad
-      #   !foo.nil? && !foo.empty?
-      #
-      #   # bad
-      #   foo != nil && !foo.empty?
-      #
-      #   # good
-      #   foo.present?
-      #
-      # @example NotBlank: true (default)
-      #   # Converts usages of `!blank?` to `present?`
-      #
-      #   # bad
-      #   !foo.blank?
-      #
-      #   # bad
-      #   not foo.blank?
-      #
-      #   # good
-      #   foo.present?
-      #
-      # @example UnlessBlank: true (default)
-      #   # Converts usages of `unless blank?` to `if present?`
-      #
-      #   # bad
-      #   something unless foo.blank?
-      #
-      #   # good
-      #   something if foo.present?
-      class Present < Cop
-        MSG_NOT_BLANK = 'Use `%<prefer>s` instead of `%<current>s`.'
-        MSG_EXISTS_AND_NOT_EMPTY = 'Use `%<prefer>s` instead of ' \
-                                   '`%<current>s`.'
-        MSG_UNLESS_BLANK = 'Use `if %<prefer>s` instead of ' \
-                           '`%<current>s`.'
-
-        def_node_matcher :exists_and_not_empty?, <<-PATTERN
-          (and
-              {
-                (send (send $_ :nil?) :!)
-                (send (send $_ :!) :!)
-                (send $_ :!= nil)
-                $_
-              }
-              {
-                (send (send $_ :empty?) :!)
-              }
-          )
-        PATTERN
-
-        def_node_matcher :not_blank?, '(send (send $_ :blank?) :!)'
-
-        def_node_matcher :unless_blank?, <<-PATTERN
-          (:if $(send $_ :blank?) {nil? (...)} ...)
-        PATTERN
-
-        def on_send(node)
-          return unless cop_config['NotBlank']
-
-          not_blank?(node) do |receiver|
-            add_offense(node,
-                        message: format(MSG_NOT_BLANK,
-                                        prefer: replacement(receiver),
-                                        current: node.source))
-          end
-        end
-
-        def on_and(node)
-          return unless cop_config['NotNilAndNotEmpty']
-
-          exists_and_not_empty?(node) do |var1, var2|
-            return unless var1 == var2
-
-            add_offense(node,
-                        message: format(MSG_EXISTS_AND_NOT_EMPTY,
-                                        prefer: replacement(var1),
-                                        current: node.source))
-          end
-        end
-
-        def on_or(node)
-          return unless cop_config['NilOrEmpty']
-
-          exists_and_not_empty?(node) do |var1, var2|
-            return unless var1 == var2
-
-            add_offense(node, message: MSG_EXISTS_AND_NOT_EMPTY)
-          end
-        end
-
-        def on_if(node)
-          return unless cop_config['UnlessBlank']
-          return unless node.unless?
-          return if node.else? && config.for_cop('Style/UnlessElse')['Enabled']
-
-          unless_blank?(node) do |method_call, receiver|
-            range = unless_condition(node, method_call)
-            msg = format(MSG_UNLESS_BLANK, prefer: replacement(receiver),
-                                           current: range.source)
-            add_offense(node, location: range, message: msg)
-          end
-        end
-
-        def autocorrect(node)
-          lambda do |corrector|
-            method_call, variable1 = unless_blank?(node)
-
-            if method_call
-              corrector.replace(node.loc.keyword, 'if')
-              range = method_call.loc.expression
-            else
-              variable1, _variable2 =
-                exists_and_not_empty?(node) || not_blank?(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}.present?" : 'present?'
-        end
-      end
-    end
-  end
-end

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

@@ -1,74 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Rails
-      # This cop checks for the use of the `read_attribute` or `write_attribute`
-      # methods and recommends square brackets instead.
-      #
-      # If an attribute is missing from the instance (for example, when
-      # initialized by a partial `select`) then `read_attribute`
-      # will return nil, but square brackets will raise
-      # an `ActiveModel::MissingAttributeError`.
-      #
-      # Explicitly raising an error in this situation is preferable, and that
-      # is why rubocop recommends using square brackets.
-      #
-      # @example
-      #
-      #   # bad
-      #   x = read_attribute(:attr)
-      #   write_attribute(:attr, val)
-      #
-      #   # good
-      #   x = self[:attr]
-      #   self[:attr] = val
-      class ReadWriteAttribute < Cop
-        MSG = 'Prefer `%<prefer>s` over `%<current>s`.'
-
-        def_node_matcher :read_write_attribute?, <<-PATTERN
-          {
-            (send nil? :read_attribute _)
-            (send nil? :write_attribute _ _)
-          }
-        PATTERN
-
-        def on_send(node)
-          return unless read_write_attribute?(node)
-
-          add_offense(node, location: :selector)
-        end
-
-        def autocorrect(node)
-          case node.method_name
-          when :read_attribute
-            replacement = read_attribute_replacement(node)
-          when :write_attribute
-            replacement = write_attribute_replacement(node)
-          end
-
-          ->(corrector) { corrector.replace(node.source_range, replacement) }
-        end
-
-        private
-
-        def message(node)
-          if node.method?(:read_attribute)
-            format(MSG, prefer: 'self[:attr]', current: 'read_attribute(:attr)')
-          else
-            format(MSG, prefer: 'self[:attr] = val',
-                        current: 'write_attribute(:attr, val)')
-          end
-        end
-
-        def read_attribute_replacement(node)
-          "self[#{node.first_argument.source}]"
-        end
-
-        def write_attribute_replacement(node)
-          "self[#{node.first_argument.source}] = #{node.last_argument.source}"
-        end
-      end
-    end
-  end
-end