sevencop 0.24.4 → 0.26.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e9088cb86686701cb1c115190aeff24d1e4828ff5db228981edbcfbd0303b941
-  data.tar.gz: a1ae55865f74bd7e4707be7df3d53964c622c048484f4e679e90fc7604383456
+  metadata.gz: 9b03712edc9d72494a99f77fe83b616b83314f1b72347dd96fbe30d3ecb66508
+  data.tar.gz: bf06a9f54c5dfea1d64c357d70e14287b389efe7f26474c87355e38ab7bc5736
 SHA512:
-  metadata.gz: a871f2e1ce6a83aa0e78a77f2445f73fffb33c4019fbb99f91cfc9bd717ad9fd46548322de8816dcc745113a1304bc0024ecacf28629a745e93612d1286f3d58
-  data.tar.gz: 58765fd6530c476d4a3c411cce6373c3f9f42b804e4b91a6f5e6ac43fbb923ade08e538ccdf27c3d2b94da24a43feb33392e94841e25a33ac2e65e5f11d3017d
+  metadata.gz: 260701a809a5b831e985ff159550b62bec1e0801c80dbfd7ed79a55ab9297307512116c6cc96161bdf374a8afcd350ea993543b335d5621f296d5d2bbdc451d1
+  data.tar.gz: 894f7f028033cf169c1f5576b29418245dfbe052f6e088e5f5a021c040fef68ab9784f969a98c17287ebbfe5832d79f2d107fd932b5d1f0953c04c07d8f6f07a

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    sevencop (0.24.4)
+    sevencop (0.26.0)
       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.
@@ -139,6 +146,7 @@ Sevencop/RSpecExamplesInSameGroup:
     Combine examples in the same groups in the time-consuming kinds of specs.
   Enabled: false
   VersionAdded: '0.17'
+  IncludeSharedExamples: false
   Include:
     - spec/controllers/**/*
     - spec/requests/**/*

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

@@ -0,0 +1,768 @@
+# frozen_string_literal: true
+
+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(
+              '%<time>s.%<helper_method_name>s',
+              helper_method_name: helper_method_name_for_comparison(node),
+              time: find_comparison_subject_to_time_current(node).source
+            )
+          )
+        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(
+              '%<duration>s.%<helper_method_name>s',
+              duration: node.first_argument.source,
+              helper_method_name: helper_method_name
+            )
+          )
+        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(
+              '%<date>s.%<helper_method_name>s',
+              date: find_equality_subject_to_date_with(node, date_method_name).source,
+              helper_method_name: helper_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 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/rubocop/cop/sevencop/rspec_examples_in_same_group.rb

@@ -6,7 +6,6 @@ module RuboCop
       # Combine examples in same group in the time-consuming kinds of specs.
       #
       # @example
-      #
       #   # bad
       #   context 'when user is logged in' do
       #     it 'returns 200' do
@@ -27,20 +26,42 @@ module RuboCop
       #     end
       #   end
       #
+      #   # bad - IncludeSharedExamples: true
+      #   context 'when user is logged in' do
+      #     it 'returns 200' do
+      #       subject
+      #       expect(response).to have_http_status(200)
+      #     end
+      #
+      #     includes_examples 'creates Foo'
+      #   end
       class RSpecExamplesInSameGroup < Base
-        EXAMPLE_METHOD_NAMES_REGULAR = ::Set[
+        METHOD_NAMES_FOR_REGULAR_EXAMPLE = ::Set[
+          :example,
           :it,
           :its,
-          :specify,
-          :example,
           :scenario,
+          :specify
         ].freeze
 
+        METHOD_NAMES_FOR_SHARED_EXAMPLES = ::Set[
+          :include_examples,
+          :it_behaves_like,
+          :it_should_behave_like
+        ]
+
         MSG = 'Combine examples in the same group in the time-consuming kinds of specs.'
 
-        # @param node [RuboCop::AST::BlockNode]
+        RESTRICT_ON_SEND = [
+          *METHOD_NAMES_FOR_REGULAR_EXAMPLE,
+          *METHOD_NAMES_FOR_SHARED_EXAMPLES
+        ].freeze
+
+        # @param node [RuboCop::AST::SendNode]
         # @return [void]
-        def on_block(node)
+        def on_send(node)
+          node = node.block_node || node
+
           return unless example?(node)
 
           previous_sibling_example = previous_sibling_example_of(node)
@@ -48,27 +69,45 @@ module RuboCop
 
           add_offense(node)
         end
-        alias on_numblock on_block
 
         private
 
-        # @!method example?(node)
-        #   @param node [RuboCop::AST::Node]
-        #   @return [Boolean]
-        def_node_matcher :example?, <<~PATTERN
-          (block
-            (send nil? EXAMPLE_METHOD_NAMES_REGULAR ...)
-            ...
-          )
-        PATTERN
+        # @param node [RuboCop::AST::BlockNode, RuboCop::AST::SendNode]
+        # @return [Boolean]
+        def example?(node)
+          if include_shared_examples?
+            regular_example?(node) || shared_example?(node)
+          else
+            regular_example?(node)
+          end
+        end
+
+        # @return [Boolean]
+        def include_shared_examples?
+          cop_config['IncludeSharedExamples']
+        end
 
-        # @param node [RuboCop::AST::BlockNode]
-        # @return [RuboCop::AST::BlockNode, nil]
+        # @param node [RuboCop::AST::BlockNode, RuboCop::AST::SendNode]
+        # @return [RuboCop::AST::BlockNode, RuboCop::AST::SendNode, nil]
         def previous_sibling_example_of(node)
+          return unless node.parent&.begin_type?
+
           node.left_siblings.find do |sibling|
             sibling.is_a?(::RuboCop::AST::Node) && example?(sibling)
           end
         end
+
+        # @param node [RuboCop::AST::BlockNode, RuboCop::AST::SendNode]
+        # @return [Boolean]
+        def regular_example?(node)
+          METHOD_NAMES_FOR_REGULAR_EXAMPLE.include?(node.method_name)
+        end
+
+        # @param node [RuboCop::AST::BlockNode, RuboCop::AST::SendNode]
+        # @return [Boolean]
+        def shared_example?(node)
+          METHOD_NAMES_FOR_SHARED_EXAMPLES.include?(node.method_name)
+        end
       end
     end
   end

data/lib/sevencop/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Sevencop
-  VERSION = '0.24.4'
+  VERSION = '0.26.0'
 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.24.4
+  version: 0.26.0
 platform: ruby
 authors:
 - Ryo Nakamura
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2022-10-27 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