Merge pull request #3854 from AlchemyCMS/configurable-publishable-resolver

Configurable publishable resolver

Author: tvdeyen

app/models/alchemy/publishable/timestamp_resolver.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+module Alchemy
+  module Publishable
+    # Default resolver for Publishable records.
+    #
+    # Uses the +public_on+ and +public_until+ timestamp columns to determine
+    # whether a record is public, scheduled, or publishable.
+    #
+    # This class defines the interface that custom resolvers configured via
+    # +Alchemy.config.publishable_resolver+ must implement.
+    #
+    class TimestampResolver
+      class << self
+        # Returns records without a +public_on+ date set.
+        def draft(publishables)
+          publishables.where(public_on: nil)
+        end
+
+        # Returns records with a +public_on+ date set.
+        def scheduled(publishables)
+          publishables.where.not(public_on: nil)
+        end
+
+        # Returns records that are public at the given time.
+        def published(publishables, at:)
+          scheduled(publishables)
+            .where("#{publishables.table_name}.public_on <= :at", at:)
+            .where(public_until: nil).or(
+              publishables.where("#{publishables.table_name}.public_until > :at", at:)
+            )
+        end
+      end
+
+      def initialize(publishable)
+        @publishable = publishable
+      end
+
+      # Determines if the record is public at the given time.
+      def public?(at: Current.preview_time)
+        already_public_for?(at:) && still_public_for?(at:)
+      end
+
+      # Determines if the record has a future publication or expiration event.
+      def scheduled?(at: Current.preview_time)
+        (publishable.public_on.present? && publishable.public_on > at) ||
+          (publishable.public_until.present? && publishable.public_until > at)
+      end
+
+      # Determines if the record is publishable.
+      #
+      # A record is publishable if a +public_on+ timestamp is set and not
+      # expired yet.
+      def publishable?
+        !publishable.public_on.nil? && still_public_for?
+      end
+
+      private
+
+      attr_reader :publishable
+
+      def already_public_for?(at:)
+        !publishable.public_on.nil? && publishable.public_on <= at
+      end
+
+      def still_public_for?(at: Current.preview_time)
+        publishable.public_until.nil? || publishable.public_until > at
+      end
+    end
+  end
+end

app/models/concerns/alchemy/publishable.rb

@@ -3,15 +3,10 @@ module Publishable
     extend ActiveSupport::Concern
 
     included do
-      scope :draft, -> { where(public_on: nil) }
-      scope :scheduled, -> { where.not(public_on: nil) }
-
+      scope :draft, -> { Alchemy.config.publishable_resolver.draft(all) }
+      scope :scheduled, -> { Alchemy.config.publishable_resolver.scheduled(all) }
       scope :published, ->(at: Current.preview_time) {
-        scheduled
-          .where("#{table_name}.public_on <= :at", at:)
-          .where(public_until: nil).or(
-            where("#{table_name}.public_until > :at", at:)
-          )
+        Alchemy.config.publishable_resolver.published(all, at:)
       }
 
       validate do
@@ -25,42 +20,32 @@ module Publishable
 
     # Determines if this record is public
     #
-    # Takes the two timestamps +public_on+ and +public_until+
-    # and returns true if the time given (+Time.current+ per default)
-    # is in this timespan.
-    #
-    # @param at [DateTime] (Time.current)
+    # @param at [DateTime] (Current.preview_time)
     # @returns Boolean
     def public?(at: Current.preview_time)
-      already_public_for?(at:) && still_public_for?(at:)
+      publishable_resolver.public?(at:)
     end
     alias_method :public, :public?
 
+    # Determines if this record has a future publication or expiration event
+    #
+    # @param at [DateTime] (Current.preview_time)
+    # @returns Boolean
     def scheduled?(at: Current.preview_time)
-      (public_on.present? && public_on > at) || (public_until.present? && public_until > at)
+      publishable_resolver.scheduled?(at:)
     end
 
     # Determines if this record is publishable
     #
-    # A record is publishable if a +public_on+ timestamp is set and not expired yet.
-    #
     # @returns Boolean
     def publishable?
-      !public_on.nil? && still_public_for?
+      publishable_resolver.publishable?
     end
 
-    # Determines if this record is already public for given time
-    # @param at [DateTime] (Time.current)
-    # @returns Boolean
-    def already_public_for?(at: Current.preview_time)
-      !public_on.nil? && public_on <= at
-    end
+    private
 
-    # Determines if this record is still public for given time
-    # @param at [DateTime] (Time.current)
-    # @returns Boolean
-    def still_public_for?(at: Current.preview_time)
-      public_until.nil? || public_until > at
+    def publishable_resolver
+      Alchemy.config.publishable_resolver.new(self)
     end
   end
 end

lib/alchemy/configurations/main.rb

@@ -453,6 +453,20 @@ def user_class_name = "::#{raw_user_class}"
       # == Example
       #     Alchemy.config.abilities.add("MyCustom::Ability")
       option :abilities, :collection, item_type: :class
+
+      # === Publishable resolver
+      #
+      # The class used to resolve publication state for Publishable records
+      # (currently +Alchemy::Element+ and +Alchemy::PageVersion+).
+      #
+      # The default resolver uses the +public_on+ / +public_until+ timestamp
+      # columns. Extension gems can provide a custom resolver that implements
+      # the same interface — see +Alchemy::Publishable::TimestampResolver+
+      # for the interface.
+      #
+      # == Example
+      #     Alchemy.config.publishable_resolver = "MyApp::CustomResolver"
+      option :publishable_resolver, :class, default: "Alchemy::Publishable::TimestampResolver"
     end
   end
 end

lib/alchemy/test_support/shared_publishable_examples.rb

@@ -33,6 +33,11 @@
     it "only includes records without public_on date" do
       expect(subject).to eq [nil]
     end
+
+    it "delegates to the resolver" do
+      expect(Alchemy.config.publishable_resolver).to receive(:draft)
+      described_class.draft
+    end
   end
 
   describe ".scheduled" do
@@ -50,13 +55,23 @@
         public_two
       ])
     end
+
+    it "delegates to the resolver" do
+      expect(Alchemy.config.publishable_resolver).to receive(:scheduled)
+      subject
+    end
   end
 
   describe ".published" do
     let!(:public_one) { create(factory_name, public_on: Date.yesterday) }
     let!(:public_two) { create(factory_name, public_on: Date.tomorrow) }
     let!(:non_public) { create(factory_name, public_on: nil) }
 
+    it "delegates to the resolver" do
+      expect(Alchemy.config.publishable_resolver).to receive(:published)
+      described_class.published
+    end
+
     context "without time given" do
       subject { described_class.published }
 
@@ -87,13 +102,16 @@
     subject { record.scheduled? }
 
     let(:record) { build(factory_name, public_on:, public_until:) }
+    let(:public_on) { nil }
+    let(:public_until) { nil }
 
-    context "when public_on is nil" do
-      let(:public_on) { nil }
+    it "delegates to the resolver" do
+      expect_any_instance_of(Alchemy.config.publishable_resolver).to receive(:scheduled?)
+      subject
+    end
 
+    context "when public_on is nil" do
       context "and public_until is nil" do
-        let(:public_until) { nil }
-
         it { expect(subject).to be(false) }
       end
 
@@ -145,6 +163,13 @@
   describe "#public?" do
     subject { page_version.public? }
 
+    let(:page_version) { build(factory_name) }
+
+    it "delegates to the resolver" do
+      expect_any_instance_of(Alchemy.config.publishable_resolver).to receive(:public?)
+      subject
+    end
+
     context "when public_on is not set" do
       let(:page_version) { build(factory_name, public_on: nil) }