sevencop 0.25.0 → 0.26.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 922dc5655a1c67a3c6cbe88b4f5b4ca72fc6a504acb678451ca2aece5a7ac0b8
-  data.tar.gz: f00c654f92a7c6a26e4b6514dbaf68adc3a0a6c62efd7f113740675b0104a53f
+  metadata.gz: 7ae1550d29e9e7aeb18b9f63d2e8f167ef5a7d871f2e953551e7be6c86038430
+  data.tar.gz: fba303001375952d8f8f1e3de021a9a5b155adc79440bb526342391c81be2a9b
 SHA512:
-  metadata.gz: 6f21bb92a5a4409c777ba0770728f2e03d9ddc3fcebd75f5204f628155b99dbbf25006f37af1f5fdd58742cdce53400e201708194d5db46da5a53d5a269bc004
-  data.tar.gz: 7c1ecca97ecacebad51e38ff1005e7c500586b85f6d4ee3de816dc3ddb846cd0faeca19520ca5dd1edf1f0296b94a6fc631a53deaf8bb4745021f4fdfccdb08c
+  metadata.gz: a32371dd923b0922ae7072b11d6917cf876eec46061a3fe0a7229a5bac2713d77b66f75ef7259f15838173d20dbd7f039dcb4af0ce0c456216091906eda7f6c4
+  data.tar.gz: a5cece615fd407987d77a5e7d5db08ef78c816a07c3330da17fdd5d778552dfd4ff1d249d044b95540ce06a04b873623853b42a5e466bbe4d389fb284784f75a

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    sevencop (0.25.0)
+    sevencop (0.26.1)
       activesupport
       rubocop
 

data/README.md

@@ -38,6 +38,7 @@ Note that all cops are `Enabled: false` by default.
 - [Sevencop/MethodDefinitionOrdered](lib/rubocop/cop/sevencop/method_definition_ordered.rb)
 - [Sevencop/RailsActionName](lib/rubocop/cop/sevencop/rails_action_name.rb)
 - [Sevencop/RailsBelongsToOptional](lib/rubocop/cop/sevencop/rails_belongs_to_optional.rb)
+- [Sevencop/RailsDateAndTimeCalculation](lib/rubocop/cop/sevencop/rails_date_and_time_calculation.rb)
 - [Sevencop/RailsInferredSpecType](lib/rubocop/cop/sevencop/rails_inferred_spec_type.rb)
 - [Sevencop/RailsOrderField](lib/rubocop/cop/sevencop/rails_order_field.rb)
 - [Sevencop/RailsUniquenessValidatorExplicitCaseSensitivity](lib/rubocop/cop/sevencop/rails_uniqueness_validator_explicit_case_sensitivity.rb)

data/config/default.yml

@@ -91,6 +91,13 @@ Sevencop/RailsBelongsToOptional:
   Safe: false
   VersionAdded: '0.5'
 
+Sevencop/RailsDateAndTimeCalculation:
+  Description: |
+    Prefer ActiveSupport date and time helper.
+  Enabled: false
+  Safe: false
+  VersionAdded: '0.26'
+
 Sevencop/RailsInferredSpecType:
   Description: |
     Identifies redundant spec type.

data/lib/rubocop/cop/sevencop/rails_date_and_time_calculation.rb

@@ -0,0 +1,779 @@
+# frozen_string_literal: true
+
+require 'set'
+
+module RuboCop
+  module Cop
+    module Sevencop
+      # Prefer ActiveSupport date and time helper.
+      #
+      # @safety
+      #   This cop is unsafe becuase it considers that `n.days` is a Duration,
+      #   and `date` in `date == Date.current` is a Date, but there is no guarantee.
+      #
+      # @example
+      #   # bad
+      #   Time.zone.now
+      #
+      #   # good
+      #   Time.current
+      #
+      #   # bad
+      #   Time.zone.today
+      #
+      #   # good
+      #   Date.current
+      #
+      #   # bad
+      #   Time.current.to_date
+      #
+      #   # good
+      #   Date.current
+      #
+      #   # bad
+      #   Date.current.tomorrow
+      #
+      #   # good
+      #   Date.tomorrow
+      #
+      #   # bad
+      #   Date.current.yesterday
+      #
+      #   # good
+      #   Date.yesterday
+      #
+      #   # bad
+      #   date == Date.current
+      #   Date.current == date
+      #
+      #   # good
+      #   date.today?
+      #
+      #   # bad
+      #   date == Date.tomorrow
+      #   Date.tomorrow == date
+      #
+      #   # good
+      #   date.tomorrow?
+      #
+      #   # bad
+      #   date == Date.yesterday
+      #   Date.yesterday == date
+      #
+      #   # good
+      #   date.yesterday?
+      #
+      #   # bad
+      #   Time.current - n.days
+      #   Time.zone.now - n.days
+      #
+      #   # good
+      #   n.days.ago
+      #
+      #   # bad
+      #   Time.current + n.days
+      #
+      #   # good
+      #   n.days.since
+      #
+      #   # bad
+      #   Date.current - 1
+      #   Date.current - 1.day
+      #
+      #   # good
+      #   Date.yesterday
+      #
+      #   # bad
+      #   Date.current + 1
+      #   Date.current + 1.day
+      #
+      #   # good
+      #   Date.tomorrow
+      #
+      #   # bad
+      #   time.after?(Time.current)
+      #   time > Time.current
+      #   Time.current < time
+      #   Time.current.before?(time)
+      #
+      #   # good
+      #   time.future?
+      #
+      #   # bad
+      #   time.before?(Time.current)
+      #   time < Time.current
+      #   Time.current > time
+      #   Time.current.after?(time)
+      #
+      #   # good
+      #   time.past?
+      class RailsDateAndTimeCalculation < Base
+        extend AutoCorrector
+
+        CALCULATION_METHOD_NAMES = ::Set.new(
+          %i[
+            -
+            +
+          ]
+        ).freeze
+
+        COMPARISON_METHOD_NAMES = ::Set.new(
+          %i[
+            <
+            >
+            after?
+            before?
+          ]
+        ).freeze
+
+        DURATION_METHOD_NAMES = ::Set.new(
+          %i[
+            day
+            days
+            fortnight
+            fortnights
+            hour
+            hours
+            minute
+            minutes
+            month
+            months
+            second
+            seconds
+            week
+            weeks
+            year
+            years
+          ]
+        ).freeze
+
+        MSG = 'Prefer ActiveSupport date and time helper.'
+
+        RESTRICT_ON_SEND = [
+          *CALCULATION_METHOD_NAMES,
+          *COMPARISON_METHOD_NAMES,
+          :==,
+          :now,
+          :to_date,
+          :today,
+          :tomorrow,
+          :yesterday
+        ].freeze
+
+        # @param node [RuboCop::AST::SendNode]
+        # @return [void]
+        def on_send(node)
+          case node.method_name
+          when :-
+            check_subtraction(node)
+          when :+
+            check_addition(node)
+          when :==
+            check_equality(node)
+          when :<, :before?
+            check_less_than(node)
+          when :>, :after?
+            check_greater_than(node)
+          when :now
+            check_now(node)
+          when :to_date
+            check_to_date(node)
+          when :today
+            check_today(node)
+          when :tomorrow
+            check_tomorrow(node)
+          when :yesterday
+            check_yesterday(node)
+          end
+        end
+
+        private
+
+        # @!method comparison_to_time_current?(node)
+        #   @param node [RuboCop::AST::Node]
+        #   @return [Boolean]
+        def_node_matcher :comparison_to_time_current?, <<~PATTERN
+          {
+            #comparison_for_future? |
+              #comparison_for_past?
+          }
+        PATTERN
+
+        # @!method comparison_for_future?(node)
+        #   @param node [RuboCop::AST::Node]
+        #   @return [Boolean]
+        def_node_matcher :comparison_for_future?, <<~PATTERN
+          {
+            #comparison_for_future_with_time_current_left? |
+              #comparison_for_future_with_time_current_right?
+          }
+        PATTERN
+
+        # @!method comparison_for_future_with_time_current_left?(node)
+        #   @param node [RuboCop::AST::Node]
+        #   @return [Boolean]
+        def_node_matcher :comparison_for_future_with_time_current_left?, <<~PATTERN
+          (send
+            #time_current?
+            {:< | :before?}
+            _
+          )
+        PATTERN
+
+        # @!method comparison_for_future_with_time_current_right?(node)
+        #   @param node [RuboCop::AST::Node]
+        #   @return [Boolean]
+        def_node_matcher :comparison_for_future_with_time_current_right?, <<~PATTERN
+          (send
+            _
+            {:> | :after?}
+            #time_current?
+          )
+        PATTERN
+
+        # @!method comparison_for_past?(node)
+        #   @param node [RuboCop::AST::Node]
+        #   @return [Boolean]
+        def_node_matcher :comparison_for_past?, <<~PATTERN
+          {
+            #comparison_for_past_with_time_current_left? |
+              #comparison_for_past_with_time_current_right?
+          }
+        PATTERN
+
+        # @!method comparison_for_past_with_time_current_left?(node)
+        #   @param node [RuboCop::AST::Node]
+        #   @return [Boolean]
+        def_node_matcher :comparison_for_past_with_time_current_left?, <<~PATTERN
+          (send
+            #time_current?
+            {:> | :after?}
+            _
+          )
+        PATTERN
+
+        # @!method comparison_for_past_with_time_current_right?(node)
+        #   @param node [RuboCop::AST::Node]
+        #   @return [Boolean]
+        def_node_matcher :comparison_for_past_with_time_current_right?, <<~PATTERN
+          (send
+            _
+            {:< | :before?}
+            #time_current?
+          )
+        PATTERN
+
+        # @!method date_current?(node)
+        #   @param node [RuboCop::AST::Node]
+        #   @return [Booelan]
+        def_node_matcher :date_current?, <<~PATTERN
+          (send
+            (const
+              {nil? | cbase}
+              :Date
+            )
+            :current
+          )
+        PATTERN
+
+        # @!method date_current_minus_one_day?(node)
+        #   @param node [RuboCop::AST::Node]
+        #   @return [Boolean]
+        def_node_matcher :date_current_minus_one_day?, <<~PATTERN
+          (send
+            #date_current?
+            :-
+            #one_day_on_date_calculation?
+          )
+        PATTERN
+
+        # @!method date_current_plus_one_day?(node)
+        #   @param node [RuboCop::AST::Node]
+        #   @return [Boolean]
+        def_node_matcher :date_current_plus_one_day?, <<~PATTERN
+          (send
+            #date_current?
+            :+
+            #one_day_on_date_calculation?
+          )
+        PATTERN
+
+        # @!method date_current_with?(node, method_name)
+        #   @param node [RuboCop::AST::Node]
+        #   @param method_name [Symbol]
+        #   @return [Boolean]
+        def_node_matcher :date_current_with?, <<~PATTERN
+          (send
+            #date_current?
+            %1
+          )
+        PATTERN
+
+        # @!method date_with?(node, method_name)
+        #   @param node [RuboCop::AST::Node]
+        #   @param method_name [Symbol]
+        #   @return [Boolean]
+        def_node_matcher :date_with?, <<~PATTERN
+          (send
+            (const
+              {nil? | cbase}
+              :Date
+            )
+            %1
+          )
+        PATTERN
+
+        # @!method duration?(node)
+        #   @param node [RuboCop::AST::Node]
+        #   @return [Boolean]
+        def_node_matcher :duration?, <<~PATTERN
+          (send
+            _
+            DURATION_METHOD_NAMES
+          )
+        PATTERN
+
+        # @!method duration_calculation_to_time_current?(node)
+        #   @param node [RuboCop::AST::Node]
+        #   @return [Boolean]
+        def_node_matcher :duration_calculation_to_time_current?, <<~PATTERN
+          (send
+            #time_current?
+            _
+            #duration?
+          )
+        PATTERN
+
+        # @!method equals_to_date_with_left?(node, method_name)
+        #   @param node [RuboCop::AST::Node]
+        #   @param method_name [Symbol]
+        #   @return [Boolean]
+        def_node_matcher :equals_to_date_with_left?, <<~PATTERN
+          (send
+            #date_with?(%1)
+            :==
+            _
+          )
+        PATTERN
+
+        # @!method equals_to_date_with_right?(node, method_name)
+        #   @param node [RuboCop::AST::Node]
+        #   @param method_name [Symbol]
+        #   @return [Boolean]
+        def_node_matcher :equals_to_date_with_right?, <<~PATTERN
+          (send
+            _
+            :==
+            #date_with?(%1)
+          )
+        PATTERN
+
+        # @!method one_day_on_date_calculation?(node)
+        #   @param node [RuboCop::AST::Node]
+        #   @return [Boolean]
+        def_node_matcher :one_day_on_date_calculation?, <<~PATTERN
+          {
+            (int 1) |
+            (send (int 1) :day)
+          }
+        PATTERN
+
+        # @!method time_current?(node)
+        #   @param node [RuboCop::AST::Node]
+        #   @return [Boolean]
+        def_node_matcher :time_current?, <<~PATTERN
+          (send
+            (const
+              {nil? | cbase}
+              :Time
+            )
+            :current
+          )
+        PATTERN
+
+        # @!method time_current_to_date?(node)
+        #   @param node [RuboCop::AST::Node]
+        #   @return [Boolean]
+        def_node_matcher :time_current_to_date?, <<~PATTERN
+          (send
+            #time_current?
+            :to_date
+          )
+        PATTERN
+
+        # @!method time_zone_with?(node, method_name)
+        #   @param node [RuboCop::AST::Node]
+        #   @param method_name [Symbol]
+        #   @return [Boolean]
+        def_node_matcher :time_zone_with?, <<~PATTERN
+          (send
+            (send
+              (const
+                {nil? | cbase}
+                :Time
+              )
+              :zone
+            )
+            %1
+          )
+        PATTERN
+
+        # @param corrector [RuboCop::Cop::Corrector]
+        # @param node [RuboCop::AST::SendNode]
+        # @return [void]
+        def autocorrect_to_comparison_helper_for_time_current(
+          corrector,
+          node
+        )
+          corrector.replace(
+            node,
+            format_to_method_call(
+              method: helper_method_name_for_comparison(node),
+              receiver: find_comparison_subject_to_time_current(node)
+            )
+          )
+        end
+
+        # @param corrector [RuboCop::Cop::Corrector]
+        # @param helper_method_name [Symbol]
+        # @param node [RuboCop::AST::SendNode]
+        # @return [void]
+        def autocorrect_to_duration_helper(
+          corrector,
+          node,
+          helper_method_name:
+        )
+          corrector.replace(
+            node,
+            format_to_method_call(
+              method: helper_method_name,
+              receiver: node.first_argument
+            )
+          )
+        end
+
+        # @param corrector [RuboCop::Cop::Corrector]
+        # @param date_method_name [Symbol]
+        # @param helper_method_name [Symbol]
+        # @param node [RuboCop::AST::SendNode]
+        # @return [void]
+        def autocorrect_to_equality_helper_for_date(
+          corrector,
+          node,
+          date_method_name:,
+          helper_method_name:
+        )
+          corrector.replace(
+            node,
+            format_to_method_call(
+              method: helper_method_name,
+              receiver: find_equality_subject_to_date_with(node, date_method_name)
+            )
+          )
+        end
+
+        # @param node [RuboCop::AST::SendNode]
+        # @return [void]
+        def check_addition(node)
+          check_addition_to_date_current(node)
+          check_addition_to_time_current(node)
+        end
+
+        # @param node [RuboCop::AST::SendNode]
+        # @return [void]
+        def check_addition_to_date_current(node)
+          return unless date_current_plus_one_day?(node)
+
+          add_offense(node) do |corrector|
+            replace_keeping_cbase(
+              corrector: corrector,
+              node: node,
+              with: 'Date.tomorrow'
+            )
+          end
+        end
+
+        # @param node [RuboCop::AST::SendNode]
+        # @return [void]
+        def check_addition_to_time_current(node)
+          return unless duration_calculation_to_time_current?(node)
+
+          add_offense(node) do |corrector|
+            autocorrect_to_duration_helper(
+              corrector,
+              node,
+              helper_method_name: :since
+            )
+          end
+        end
+
+        # @param node [RuboCop::AST::SendNode]
+        # @return [void]
+        def check_equality(node)
+          check_equality_to_date_current(node)
+          check_equality_to_date_tomorrow(node)
+          check_equality_to_date_yesterday(node)
+        end
+
+        # @param node [RuboCop::AST::SendNode]
+        # @return [void]
+        def check_equality_to_date_current(node)
+          return unless equals_to_date_with?(node, :current)
+
+          add_offense(node) do |corrector|
+            autocorrect_to_equality_helper_for_date(
+              corrector,
+              node,
+              date_method_name: :current,
+              helper_method_name: :today?
+            )
+          end
+        end
+
+        # @param node [RuboCop::AST::SendNode]
+        # @return [void]
+        def check_equality_to_date_tomorrow(node)
+          return unless equals_to_date_with?(node, :tomorrow)
+
+          add_offense(node) do |corrector|
+            autocorrect_to_equality_helper_for_date(
+              corrector,
+              node,
+              date_method_name: :tomorrow,
+              helper_method_name: :tomorrow?
+            )
+          end
+        end
+
+        # @param node [RuboCop::AST::SendNode]
+        # @return [void]
+        def check_equality_to_date_yesterday(node)
+          return unless equals_to_date_with?(node, :yesterday)
+
+          add_offense(node) do |corrector|
+            autocorrect_to_equality_helper_for_date(
+              corrector,
+              node,
+              date_method_name: :yesterday,
+              helper_method_name: :yesterday?
+            )
+          end
+        end
+
+        # @param node [RuboCop::AST::SendNode]
+        # @return [void]
+        def check_greater_than(node)
+          return unless comparison_to_time_current?(node)
+
+          add_offense(node) do |corrector|
+            autocorrect_to_comparison_helper_for_time_current(
+              corrector,
+              node
+            )
+          end
+        end
+        alias check_less_than check_greater_than
+
+        # @param node [RuboCop::AST::SendNode]
+        # @return [void]
+        def check_now(node)
+          return unless time_zone_with?(node, :now)
+
+          add_offense(node) do |corrector|
+            replace_keeping_cbase(
+              corrector: corrector,
+              node: node,
+              with: 'Time.current'
+            )
+          end
+        end
+
+        # @param node [RuboCop::AST::SendNode]
+        # @return [void]
+        def check_subtraction(node)
+          check_subtraction_to_date_current(node)
+          check_subtraction_to_time_current(node)
+        end
+
+        # @param node [RuboCop::AST::SendNode]
+        # @return [void]
+        def check_subtraction_to_date_current(node)
+          return unless date_current_minus_one_day?(node)
+
+          add_offense(node) do |corrector|
+            replace_keeping_cbase(
+              corrector: corrector,
+              node: node,
+              with: 'Date.yesterday'
+            )
+          end
+        end
+
+        # @param node [RuboCop::AST::SendNode]
+        # @return [void]
+        def check_subtraction_to_time_current(node)
+          return unless duration_calculation_to_time_current?(node)
+
+          add_offense(node) do |corrector|
+            autocorrect_to_duration_helper(
+              corrector,
+              node,
+              helper_method_name: :ago
+            )
+          end
+        end
+
+        # @param node [RuboCop::AST::SendNode]
+        # @return [void]
+        def check_to_date(node)
+          return unless time_current_to_date?(node)
+
+          add_offense(node) do |corrector|
+            replace_keeping_cbase(
+              corrector: corrector,
+              node: node,
+              with: 'Date.current'
+            )
+          end
+        end
+
+        # @param node [RuboCop::AST::SendNode]
+        # @return [void]
+        def check_today(node)
+          check_today_to_date_current(node)
+          check_today_to_time_zone(node)
+        end
+
+        # @param node [RuboCop::AST::SendNode]
+        # @return [void]
+        def check_today_to_date_current(node)
+          return unless date_current_with?(node, :today)
+
+          add_offense(node) do |corrector|
+            replace_keeping_cbase(
+              corrector: corrector,
+              node: node,
+              with: 'Date.current'
+            )
+          end
+        end
+
+        # @param node [RuboCop::AST::SendNode]
+        # @return [void]
+        def check_today_to_time_zone(node)
+          return unless time_zone_with?(node, :today)
+
+          add_offense(node) do |corrector|
+            replace_keeping_cbase(
+              corrector: corrector,
+              node: node,
+              with: 'Date.current'
+            )
+          end
+        end
+
+        # @param node [RuboCop::AST::SendNode]
+        # @return [void]
+        def check_tomorrow(node)
+          return unless date_current_with?(node, :tomorrow)
+
+          add_offense(node) do |corrector|
+            replace_keeping_cbase(
+              corrector: corrector,
+              node: node,
+              with: 'Date.tomorrow'
+            )
+          end
+        end
+
+        # @param node [RuboCop::AST::SendNode]
+        # @return [void]
+        def check_yesterday(node)
+          return unless date_current_with?(node, :yesterday)
+
+          add_offense(node) do |corrector|
+            replace_keeping_cbase(
+              corrector: corrector,
+              node: node,
+              with: 'Date.yesterday'
+            )
+          end
+        end
+
+        # @param node [RuboCop::AST::SendNode]
+        # @param method_name [Symbol]
+        # @return [Boolean]
+        def equals_to_date_with?(
+          node,
+          method_name
+        )
+          equals_to_date_with_left?(node, method_name) ||
+            equals_to_date_with_right?(node, method_name)
+        end
+
+        # @param node [RuboCop::AST::SendNode]
+        # @return [RuboCop::AST::Node]
+        def find_comparison_subject_to_time_current(node)
+          if time_current?(node.receiver)
+            node.first_argument
+          else
+            node.receiver
+          end
+        end
+
+        # @param node [RuboCop::AST::SendNode]
+        # @param method_name [Symbol]
+        # @return [RuboCop::AST::Node]
+        def find_equality_subject_to_date_with(
+          node,
+          method_name
+        )
+          if date_with?(node.receiver, method_name)
+            node.first_argument
+          else
+            node.receiver
+          end
+        end
+
+        # @param receiver [RuboCop::AST::Node]
+        # @param method [String]
+        # @return [String]
+        def format_to_method_call(
+          method:,
+          receiver:
+        )
+          receiver_source = receiver.source
+          receiver_source = "(#{receiver_source})" if receiver.operator_method?
+          [receiver_source, method].join('.')
+        end
+
+        # @param node [RuboCop::AST::SendNode]
+        # @return [Symbol]
+        def helper_method_name_for_comparison(node)
+          if comparison_for_future?(node)
+            :future?
+          else
+            :past?
+          end
+        end
+
+        # @param corrector [RuboCop::Cop::Corrector]
+        # @param node [RuboCop::AST::SendNode]
+        # @param with [String]
+        # @return [void]
+        def replace_keeping_cbase(
+          corrector:,
+          node:,
+          with:
+        )
+          corrector.replace(
+            node.location.expression.with(
+              begin_pos: node.each_descendant(:const).first.location.name.begin_pos
+            ),
+            with
+          )
+        end
+      end
+    end
+  end
+end

data/lib/sevencop/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Sevencop
-  VERSION = '0.25.0'
+  VERSION = '0.26.1'
 end

data/lib/sevencop.rb

@@ -14,6 +14,7 @@ require_relative 'rubocop/cop/sevencop/method_definition_keyword_argument_ordere
 require_relative 'rubocop/cop/sevencop/method_definition_ordered'
 require_relative 'rubocop/cop/sevencop/rails_action_name'
 require_relative 'rubocop/cop/sevencop/rails_belongs_to_optional'
+require_relative 'rubocop/cop/sevencop/rails_date_and_time_calculation'
 require_relative 'rubocop/cop/sevencop/rails_inferred_spec_type'
 require_relative 'rubocop/cop/sevencop/rails_order_field'
 require_relative 'rubocop/cop/sevencop/rails_uniqueness_validator_explicit_case_sensitivity'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: sevencop
 version: !ruby/object:Gem::Version
-  version: 0.25.0
+  version: 0.26.1
 platform: ruby
 authors:
 - Ryo Nakamura
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2022-10-28 00:00:00.000000000 Z
+date: 2022-11-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -66,6 +66,7 @@ files:
 - lib/rubocop/cop/sevencop/method_definition_ordered.rb
 - lib/rubocop/cop/sevencop/rails_action_name.rb
 - lib/rubocop/cop/sevencop/rails_belongs_to_optional.rb
+- lib/rubocop/cop/sevencop/rails_date_and_time_calculation.rb
 - lib/rubocop/cop/sevencop/rails_inferred_spec_type.rb
 - lib/rubocop/cop/sevencop/rails_order_field.rb
 - lib/rubocop/cop/sevencop/rails_uniqueness_validator_explicit_case_sensitivity.rb