Include future-scheduled elements when publishing pages

Previously, only currently visible elements were copied to the public
version when publishing a page. This meant elements scheduled for future
publication required a republish once their public_on date arrived.

Now the publisher copies all publishable elements, which includes both
currently visible elements and those scheduled for the future. This
allows elements with a future public_on date to automatically become
visible once their scheduled time passes without requiring a republish.

Author: tvdeyen

app/models/alchemy/element.rb

@@ -313,7 +313,7 @@ def nestable_elements
 
     def set_default_public_on
       return if @public_on_explicitely_set
-      self.public_on = Time.current
+      self.public_on ||= Time.current
     end
 
     def generate_nested_elements

app/models/alchemy/elements_repository.rb

@@ -22,6 +22,12 @@ def visible
       self.class.new select(&:public)
     end
 
+    # All publishable elements
+    # @return [Alchemy::ElementRepository]
+    def publishable
+      self.class.new select(&:publishable?)
+    end
+
     # All not fixed elements
     # @return [Alchemy::ElementRepository]
     def hidden

app/models/alchemy/page/publisher.rb

@@ -10,7 +10,7 @@ def initialize(page)
         @page = page
       end
 
-      # Copies all currently visible elements to the public version of page
+      # Copies all currently publishable elements to the public version of page
       #
       # Creates a new published version if none exists yet and updates
       # the `published_at` timestamp of the page.
@@ -29,7 +29,7 @@ def publish!(public_on:)
             repository = page.draft_version.element_repository
             ActiveRecord::Base.no_touching do
               Element.acts_as_list_no_update do
-                repository.visible.not_nested.each.with_index(1) do |element, position|
+                repository.publishable.not_nested.each.with_index(1) do |element, position|
                   Alchemy::DuplicateElement.new(element, repository: repository, publishable_only: true).call(
                     page_version_id: version.id,
                     position: position

app/models/concerns/alchemy/publishable.rb

@@ -28,6 +28,15 @@ def public?(time = Time.current)
     end
     alias_method :public, :public?
 
+    # 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?
+    end
+
     # Determines if this record is already public for given time
     # @param time [DateTime] (Time.current)
     # @returns Boolean

app/services/alchemy/duplicate_element.rb

@@ -36,7 +36,7 @@ def call(differences = {})
       new_element.save!
 
       nested_elements = repository.children_of(source_element)
-      nested_elements = nested_elements.visible if publishable_only
+      nested_elements = nested_elements.publishable if publishable_only
       Element.acts_as_list_no_update do
         nested_elements.each.with_index(1) do |nested_element, position|
           self.class.new(nested_element, repository: repository, publishable_only: publishable_only).call(

spec/dummy/db/schema.rb

@@ -10,7 +10,7 @@
 #
 # It's strongly recommended that you check this file into your version control system.
 
-ActiveRecord::Schema[8.1].define(version: 2026_01_15_171818) do
+ActiveRecord::Schema[8.1].define(version: 2026_01_20_163927) do
   create_table "active_storage_attachments", force: :cascade do |t|
     t.bigint "blob_id", null: false
     t.datetime "created_at", null: false

spec/models/alchemy/page/publisher_spec.rb

@@ -54,6 +54,52 @@
       end
     end
 
+    context "with elements scheduled for future publication" do
+      let(:page) { create(:alchemy_page) }
+
+      let!(:current_element) do
+        create(:alchemy_element,
+          page_version: page.draft_version,
+          public_on: 1.day.ago)
+      end
+
+      let!(:future_element) do
+        create(:alchemy_element,
+          page_version: page.draft_version,
+          public_on: 1.day.from_now)
+      end
+
+      let!(:draft_element) do
+        create(:alchemy_element, page_version: page.draft_version).tap do |element|
+          element.update_columns(public_on: nil)
+        end
+      end
+
+      let!(:expired_element) do
+        create(:alchemy_element,
+          page_version: page.draft_version,
+          public_on: 2.days.ago,
+          public_until: 1.day.ago)
+      end
+
+      it "copies currently public and future scheduled elements" do
+        publish
+        expect(page.reload.public_version.elements.count).to eq(2)
+      end
+
+      it "does not copy draft elements without public_on" do
+        publish
+        public_ons = page.reload.public_version.elements.pluck(:public_on)
+        expect(public_ons).to all(be_present)
+      end
+
+      it "does not copy expired elements" do
+        publish
+        public_untils = page.reload.public_version.elements.pluck(:public_until)
+        expect(public_untils).to all(be_nil)
+      end
+    end
+
     context "with draft version metadata" do
       before do
         page.draft_version.update!(

spec/services/alchemy/duplicate_element_spec.rb

@@ -74,20 +74,38 @@
     context "with publishable_only option" do
       let(:element) { create(:alchemy_element) }
 
-      let!(:visible_nested) do
-        create(:alchemy_element, parent_element: element, page_version: element.page_version, public: true)
+      let!(:current_nested) do
+        create(:alchemy_element, parent_element: element, page_version: element.page_version, public_on: 1.day.ago)
       end
 
-      let!(:hidden_nested) do
-        create(:alchemy_element, parent_element: element, page_version: element.page_version, public: false)
+      let!(:future_nested) do
+        create(:alchemy_element, parent_element: element, page_version: element.page_version, public_on: 1.day.from_now)
+      end
+
+      let!(:draft_nested) do
+        create(:alchemy_element, parent_element: element, page_version: element.page_version, public_on: nil)
+      end
+
+      let!(:expired_nested) do
+        create(:alchemy_element, parent_element: element, page_version: element.page_version, public_on: 2.days.ago, public_until: 1.day.ago)
       end
 
       subject do
         described_class.new(element, publishable_only: true).call(differences)
       end
 
-      it "only copies visible nested elements" do
-        expect(subject.all_nested_elements).to all(be_public)
+      it "only copies publishable nested elements" do
+        expect(subject.all_nested_elements.count).to eq(2)
+      end
+
+      it "does not copy draft nested elements" do
+        public_ons = subject.all_nested_elements.map(&:public_on)
+        expect(public_ons).to all(be_present)
+      end
+
+      it "does not copy expired nested elements" do
+        public_untils = subject.all_nested_elements.map(&:public_until)
+        expect(public_untils).to all(be_nil)
       end
     end
   end