rubocop-rails 2.0.0

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

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

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

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

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Rails
+      # This cop checks if the value of the option `class_name`, in
+      # the definition of a reflection is a string.
+      #
+      # @example
+      #   # bad
+      #   has_many :accounts, class_name: Account
+      #   has_many :accounts, class_name: Account.name
+      #
+      #   # good
+      #   has_many :accounts, class_name: 'Account'
+      class ReflectionClassName < Cop
+        MSG = 'Use a string value for `class_name`.'
+
+        def_node_matcher :association_with_reflection, <<-PATTERN
+          (send nil? {:has_many :has_one :belongs_to} _
+            (hash <$#reflection_class_name ...>)
+          )
+        PATTERN
+
+        def_node_matcher :reflection_class_name, <<-PATTERN
+          (pair (sym :class_name) [!dstr !str !sym])
+        PATTERN
+
+        def on_send(node)
+          association_with_reflection(node) do |reflection_class_name|
+            add_offense(node, location: reflection_class_name.loc.expression)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Rails
+      #
+      # Use `assert_not` methods instead of `refute` methods.
+      #
+      # @example
+      #   # bad
+      #   refute false
+      #   refute_empty [1, 2, 3]
+      #   refute_equal true, false
+      #
+      #   # good
+      #   assert_not false
+      #   assert_not_empty [1, 2, 3]
+      #   assert_not_equal true, false
+      #
+      class RefuteMethods < Cop
+        MSG = 'Prefer `%<assert_method>s` over `%<refute_method>s`.'
+
+        CORRECTIONS = {
+          refute:             'assert_not',
+          refute_empty:       'assert_not_empty',
+          refute_equal:       'assert_not_equal',
+          refute_in_delta:    'assert_not_in_delta',
+          refute_in_epsilon:  'assert_not_in_epsilon',
+          refute_includes:    'assert_not_includes',
+          refute_instance_of: 'assert_not_instance_of',
+          refute_kind_of:     'assert_not_kind_of',
+          refute_nil:         'assert_not_nil',
+          refute_operator:    'assert_not_operator',
+          refute_predicate:   'assert_not_predicate',
+          refute_respond_to:  'assert_not_respond_to',
+          refute_same:        'assert_not_same',
+          refute_match:       'assert_no_match'
+        }.freeze
+
+        OFFENSIVE_METHODS = CORRECTIONS.keys.freeze
+
+        def_node_matcher :offensive?, '(send nil? #refute_method? ...)'
+
+        def on_send(node)
+          return unless offensive?(node)
+
+          message = offense_message(node.method_name)
+          add_offense(node, location: :selector, message: message)
+        end
+
+        def autocorrect(node)
+          lambda do |corrector|
+            corrector.replace(
+              node.loc.selector,
+              CORRECTIONS[node.method_name]
+            )
+          end
+        end
+
+        private
+
+        def refute_method?(method_name)
+          OFFENSIVE_METHODS.include?(method_name)
+        end
+
+        def offense_message(method_name)
+          format(
+            MSG,
+            refute_method: method_name,
+            assert_method: CORRECTIONS[method_name]
+          )
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Rails
+      # This cop checks whether constant value isn't relative date.
+      # Because the relative date will be evaluated only once.
+      #
+      # @example
+      #   # bad
+      #   class SomeClass
+      #     EXPIRED_AT = 1.week.since
+      #   end
+      #
+      #   # good
+      #   class SomeClass
+      #     def self.expired_at
+      #       1.week.since
+      #     end
+      #   end
+      class RelativeDateConstant < Cop
+        include RangeHelp
+
+        MSG = 'Do not assign %<method_name>s to constants as it ' \
+              'will be evaluated only once.'
+
+        def on_casgn(node)
+          relative_date_assignment?(node) do |method_name|
+            add_offense(node, message: format(MSG, method_name: method_name))
+          end
+        end
+
+        def on_masgn(node)
+          lhs, rhs = *node
+
+          return unless rhs&.array_type?
+
+          lhs.children.zip(rhs.children).each do |(name, value)|
+            next unless name.casgn_type?
+
+            relative_date?(value) do |method_name|
+              add_offense(node,
+                          location: range_between(name.loc.expression.begin_pos,
+                                                  value.loc.expression.end_pos),
+                          message: format(MSG, method_name: method_name))
+            end
+          end
+        end
+
+        def on_or_asgn(node)
+          relative_date_or_assignment?(node) do |method_name|
+            add_offense(node, message: format(MSG, method_name: method_name))
+          end
+        end
+
+        def autocorrect(node)
+          return unless node.casgn_type?
+
+          scope, const_name, value = *node
+          return unless scope.nil?
+
+          indent = ' ' * node.loc.column
+          new_code = ["def self.#{const_name.downcase}",
+                      "#{indent}#{value.source}",
+                      'end'].join("\n#{indent}")
+          ->(corrector) { corrector.replace(node.source_range, new_code) }
+        end
+
+        private
+
+        def_node_matcher :relative_date_assignment?, <<-PATTERN
+          {
+            (casgn _ _ (send _ ${:since :from_now :after :ago :until :before}))
+            (casgn _ _ ({erange irange} _ (send _ ${:since :from_now :after :ago :until :before})))
+            (casgn _ _ ({erange irange} (send _ ${:since :from_now :after :ago :until :before}) _))
+          }
+        PATTERN
+
+        def_node_matcher :relative_date_or_assignment?, <<-PATTERN
+          (:or_asgn (casgn _ _) (send _ ${:since :from_now :after :ago :until :before}))
+        PATTERN
+
+        def_node_matcher :relative_date?, <<-PATTERN
+          {
+            ({erange irange} _ (send _ ${:since :from_now :after :ago :until :before}))
+            ({erange irange} (send _ ${:since :from_now :after :ago :until :before}) _)
+            (send _ ${:since :from_now :after :ago :until :before})
+          }
+        PATTERN
+      end
+    end
+  end
+end