rubocop 0.71.0 → 0.72.0

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

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

@@ -1,111 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Rails
-      # Checks Rails model validations for a redundant `allow_nil` when
-      # `allow_blank` is present.
-      #
-      # @example
-      #   # bad
-      #   validates :x, length: { is: 5 }, allow_nil: true, allow_blank: true
-      #
-      #   # bad
-      #   validates :x, length: { is: 5 }, allow_nil: false, allow_blank: true
-      #
-      #   # bad
-      #   validates :x, length: { is: 5 }, allow_nil: false, allow_blank: false
-      #
-      #   # good
-      #   validates :x, length: { is: 5 }, allow_blank: true
-      #
-      #   # good
-      #   validates :x, length: { is: 5 }, allow_blank: false
-      #
-      #   # good
-      #   # Here, `nil` is valid but `''` is not
-      #   validates :x, length: { is: 5 }, allow_nil: true, allow_blank: false
-      #
-      class RedundantAllowNil < Cop
-        include RangeHelp
-
-        MSG_SAME =
-          '`allow_nil` is redundant when `allow_blank` has the same value.'
-
-        MSG_ALLOW_NIL_FALSE =
-          '`allow_nil: false` is redundant when `allow_blank` is true.'
-
-        def on_send(node)
-          return unless node.method_name == :validates
-
-          allow_nil, allow_blank = find_allow_nil_and_allow_blank(node)
-          return unless allow_nil && allow_blank
-
-          allow_nil_val = allow_nil.children.last
-          allow_blank_val = allow_blank.children.last
-
-          offense(allow_nil_val, allow_blank_val, allow_nil)
-        end
-
-        def autocorrect(node)
-          prv_sib = previous_sibling(node)
-          nxt_sib = next_sibling(node)
-
-          lambda do |corrector|
-            if nxt_sib
-              corrector.remove(range_between(node_beg(node), node_beg(nxt_sib)))
-            elsif prv_sib
-              corrector.remove(range_between(node_end(prv_sib), node_end(node)))
-            else
-              corrector.remove(node.loc.expression)
-            end
-          end
-        end
-
-        private
-
-        def offense(allow_nil_val, allow_blank_val, allow_nil)
-          if allow_nil_val.type == allow_blank_val.type
-            add_offense(allow_nil, message: MSG_SAME)
-          elsif allow_nil_val.false_type? && allow_blank_val.true_type?
-            add_offense(allow_nil, message: MSG_ALLOW_NIL_FALSE)
-          end
-        end
-
-        def find_allow_nil_and_allow_blank(node)
-          allow_nil = nil
-          allow_blank = nil
-
-          node.each_descendant do |descendant|
-            next unless descendant.pair_type?
-
-            key = descendant.children.first.source
-
-            allow_nil = descendant if key == 'allow_nil'
-            allow_blank = descendant if key == 'allow_blank'
-
-            break if allow_nil && allow_blank
-          end
-
-          [allow_nil, allow_blank]
-        end
-
-        def previous_sibling(node)
-          node.parent.children[node.sibling_index - 1]
-        end
-
-        def next_sibling(node)
-          node.parent.children[node.sibling_index + 1]
-        end
-
-        def node_beg(node)
-          node.loc.expression.begin_pos
-        end
-
-        def node_end(node)
-          node.loc.expression.end_pos
-        end
-      end
-    end
-  end
-end

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

@@ -1,136 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Rails
-      # This cop checks for redundant receiver in `with_options`.
-      # Receiver is implicit from Rails 4.2 or higher.
-      #
-      # @example
-      #   # bad
-      #   class Account < ApplicationRecord
-      #     with_options dependent: :destroy do |assoc|
-      #       assoc.has_many :customers
-      #       assoc.has_many :products
-      #       assoc.has_many :invoices
-      #       assoc.has_many :expenses
-      #     end
-      #   end
-      #
-      #   # good
-      #   class Account < ApplicationRecord
-      #     with_options dependent: :destroy do
-      #       has_many :customers
-      #       has_many :products
-      #       has_many :invoices
-      #       has_many :expenses
-      #     end
-      #   end
-      #
-      # @example
-      #   # bad
-      #   with_options options: false do |merger|
-      #     merger.invoke(merger.something)
-      #   end
-      #
-      #   # good
-      #   with_options options: false do
-      #     invoke(something)
-      #   end
-      #
-      #   # good
-      #   client = Client.new
-      #   with_options options: false do |merger|
-      #     client.invoke(merger.something, something)
-      #   end
-      #
-      #   # ok
-      #   # When `with_options` includes a block, all scoping scenarios
-      #   # cannot be evaluated. Thus, it is ok to include the explicit
-      #   # receiver.
-      #   with_options options: false do |merger|
-      #     merger.invoke
-      #     with_another_method do |another_receiver|
-      #       merger.invoke(another_receiver)
-      #     end
-      #   end
-      class RedundantReceiverInWithOptions < Cop
-        extend TargetRailsVersion
-        include RangeHelp
-
-        minimum_target_rails_version 4.2
-
-        MSG = 'Redundant receiver in `with_options`.'
-
-        def_node_matcher :with_options?, <<-PATTERN
-          (block
-            (send nil? :with_options
-              (...))
-            (args
-              $_arg)
-            $_body)
-        PATTERN
-
-        def_node_search :all_block_nodes_in, <<-PATTERN
-          (block ...)
-        PATTERN
-
-        def_node_search :all_send_nodes_in, <<-PATTERN
-          (send ...)
-        PATTERN
-
-        def on_block(node)
-          with_options?(node) do |arg, body|
-            return if body.nil?
-            return unless all_block_nodes_in(body).count.zero?
-
-            send_nodes = all_send_nodes_in(body)
-
-            if send_nodes.all? { |n| same_value?(arg, n.receiver) }
-              send_nodes.each do |send_node|
-                receiver = send_node.receiver
-                add_offense(send_node, location: receiver.source_range)
-              end
-            end
-          end
-        end
-
-        def autocorrect(node)
-          lambda do |corrector|
-            corrector.remove(node.receiver.source_range)
-            corrector.remove(node.loc.dot)
-            corrector.remove(block_argument_range(node))
-          end
-        end
-
-        private
-
-        def block_argument_range(node)
-          block_node = node.each_ancestor(:block).first
-          block_argument = block_node.children[1].source_range
-
-          range_between(
-            search_begin_pos_of_space_before_block_argument(
-              block_argument.begin_pos
-            ),
-            block_argument.end_pos
-          )
-        end
-
-        def search_begin_pos_of_space_before_block_argument(begin_pos)
-          position = begin_pos - 1
-
-          if processed_source.raw_source[position] == ' '
-            search_begin_pos_of_space_before_block_argument(position)
-          else
-            begin_pos
-          end
-        end
-
-        def same_value?(arg_node, recv_node)
-          recv_node && recv_node.children[0] == arg_node.children[0]
-        end
-      end
-    end
-  end
-end