open_blog 0.1.0

data/app/helpers/open_blog/structured_data_helper.rb

@@ -0,0 +1,63 @@
+module OpenBlog
+  module StructuredDataHelper
+    def open_blog_structured_data(resource = nil)
+      page = open_blog_page(resource)
+      graph = [ open_blog_page_schema(page), open_blog_breadcrumb_schema(page) ]
+      if %i[post preview].include?(page.kind) && (entries = page.record.faq_list).any?
+        graph << { "@type" => "FAQPage", "mainEntity" => entries.map do |entry|
+          { "@type" => "Question", "name" => entry[:question],
+            "acceptedAnswer" => { "@type" => "Answer", "text" => entry[:answer] } }
+        end }
+      end
+      json = ERB::Util.json_escape({ "@context" => "https://schema.org", "@graph" => graph }.to_json)
+      tag.script(json.html_safe, type: "application/ld+json")
+    end
+
+    def open_blog_page_schema(page)
+      case page.kind
+      when :post, :preview
+        post = page.record
+        publisher = OpenBlog.config.publisher || {}
+        data = { "@type" => "BlogPosting", "headline" => post.title, "description" => post.description.to_s,
+          "author" => open_blog_author_schema(post.author, name: post.author_name, base: page.base_url),
+          "publisher" => { "@type" => "Organization", "name" => publisher[:name], "url" => publisher[:url] }.compact,
+          "mainEntityOfPage" => open_blog_canonical_url(page), "wordCount" => post.word_count,
+          "keywords" => post.tags.map(&:name), "articleSection" => post.category&.name }
+        if publisher[:logo_url].present?
+          data["publisher"]["logo"] = { "@type" => "ImageObject", "url" => publisher[:logo_url] }
+        end
+        published, modified = ReaderDates.published_at(post), ReaderDates.modified_at(post)
+        data["datePublished"] = published.iso8601 if published
+        data["dateModified"] = modified.iso8601 if modified
+        image = open_blog_social_image_url(page)
+        data["image"] = image if image
+        data.compact
+      when :page
+        { "@type" => "WebPage", "name" => page.record.title, "description" => open_blog_page_description(page),
+          "url" => open_blog_canonical_url(page), "dateModified" => page.record.updated_at.iso8601 }
+      when :author
+        { "@type" => "ProfilePage", "name" => page.record.name, "url" => open_blog_canonical_url(page),
+          "mainEntity" => open_blog_author_schema(page.record, base: page.base_url) }
+      else
+        posts = page.pagination&.records || []
+        { "@type" => page.kind == :index ? "Blog" : "CollectionPage", "name" => open_blog_page_title(page),
+          "description" => open_blog_page_description(page), "url" => open_blog_canonical_url(page),
+          "mainEntity" => { "@type" => "ItemList", "itemListElement" => posts.each_with_index.map do |post, index|
+            { "@type" => "ListItem", "position" => index + 1, "url" => post.url(base: page.base_url), "name" => post.title }
+          end } }
+      end
+    end
+
+    def open_blog_author_schema(author, name: author.name, base: nil)
+      { "@type" => author.author_type == "organization" ? "Organization" : "Person", "name" => name,
+        "url" => open_blog_absolute_url(open_blog_list_path(:author, author), base: base) }
+    end
+
+    def open_blog_breadcrumb_schema(page)
+      { "@type" => "BreadcrumbList", "itemListElement" => page.breadcrumbs.each_with_index.map do |crumb, index|
+        { "@type" => "ListItem", "position" => index + 1, "name" => crumb[:name],
+          "item" => open_blog_absolute_url(crumb[:path], base: page.base_url) }
+      end }
+    end
+  end
+end

data/app/helpers/open_blog/theme_helper.rb

@@ -0,0 +1,52 @@
+module OpenBlog
+  module ThemeHelper
+    SURFACES = { "light" => "#ffffff", "dark" => "#0f172a" }.freeze
+
+    def open_blog_fixed_theme
+      OpenBlog.config.color_scheme.to_s if %w[light dark].include?(OpenBlog.config.color_scheme.to_s)
+    end
+
+    def open_blog_theme_attributes
+      open_blog_fixed_theme ? { data: { theme: open_blog_fixed_theme } } : {}
+    end
+
+    def open_blog_theme_script
+      return "".html_safe if open_blog_fixed_theme
+      javascript_tag(nonce: content_security_policy_nonce, data: { open_blog_theme: true }) do
+        <<~JS.html_safe
+          (() => {
+            try {
+              const theme = localStorage.getItem("open-blog-theme");
+              if (theme === "light" || theme === "dark") document.documentElement.dataset.theme = theme;
+            } catch (_) {}
+          })();
+        JS
+      end
+    end
+
+    def open_blog_theme_colors
+      safe_join(SURFACES.map do |scheme, surface|
+        tag.meta(name: "theme-color", media: "(prefers-color-scheme: #{scheme})", content: SURFACES.fetch(open_blog_fixed_theme, surface))
+      end, "\n")
+    end
+
+    def open_blog_stylesheets
+      stylesheets = [ stylesheet_link_tag("open_blog/blog") ]
+      stylesheets << stylesheet_link_tag("open_blog_theme") if open_blog_theme_override?
+      safe_join(stylesheets, "\n")
+    end
+
+    private
+
+    def open_blog_theme_override?
+      assets = Rails.application.assets if Rails.application.respond_to?(:assets)
+      if assets.respond_to?(:resolver)
+        assets.resolver.resolve("open_blog_theme.css").present?
+      elsif assets.respond_to?(:find_asset)
+        assets.find_asset("open_blog_theme.css").present?
+      elsif Rails.application.respond_to?(:assets_manifest)
+        Rails.application.assets_manifest&.assets&.key?("open_blog_theme.css")
+      end
+    end
+  end
+end

data/app/helpers/open_blog/url_helper.rb

@@ -0,0 +1,58 @@
+require "uri"
+
+module OpenBlog
+  module UrlHelper
+    def open_blog_index_path
+      OpenBlog.mount_path.chomp("/").presence || "/"
+    end
+
+    def open_blog_list_path(kind, record)
+      segment = OpenBlog.config.route_segments.fetch(kind.to_s.singularize.to_sym)
+      "#{open_blog_index_path.chomp('/')}/#{segment}/#{record.slug}"
+    end
+
+    def open_blog_page(resource = nil)
+      return resource if resource.is_a?(ReaderPage)
+      return @open_blog_page if @open_blog_page && (resource.nil? || resource == @open_blog_page.record)
+      kind = case resource
+      when Post then :post
+      when Page then :page
+      when Category then :category
+      when Tag then :tag
+      when Author then :author
+      when Series then :series
+      else :index
+      end
+      path = if %i[post page].include?(kind)
+        resource.path
+      elsif resource
+        open_blog_list_path(kind, resource)
+      else
+        open_blog_index_path
+      end
+      crumbs = [ { name: OpenBlog.config.blog_title, path: open_blog_index_path } ]
+      crumbs << { name: %i[post page].include?(kind) ? resource.title : resource.name, path: path } if resource
+      ReaderPage.new(kind: kind, record: resource, path: path, base_url: OpenBlog.config.public_base_url || request.base_url, breadcrumbs: crumbs)
+    end
+
+    def open_blog_absolute_url(path, base: nil)
+      return if path.blank?
+      base ||= @open_blog_page&.base_url || OpenBlog.config.public_base_url
+      base ||= request.base_url if respond_to?(:request) && request
+      uri = URI.join("#{base.to_s.chomp('/')}/", path.to_s)
+      uri.to_s if uri.is_a?(URI::HTTP) && uri.host.present? && uri.userinfo.nil?
+    rescue URI::InvalidURIError
+      nil
+    end
+
+    def open_blog_canonical_url(resource = nil)
+      page = open_blog_page(resource)
+      path = %i[post preview].include?(page.kind) && page.record.canonical_url.presence || page.canonical_path
+      open_blog_absolute_url(path, base: page.base_url)
+    end
+
+    def open_blog_translate(key, **options)
+      I18n.t("open_blog.#{key}", locale: OpenBlog.config.locale, **options)
+    end
+  end
+end

data/app/jobs/open_blog/publish_scheduled_post_job.rb

@@ -0,0 +1,14 @@
+module OpenBlog
+  class PublishScheduledPostJob < ActiveJob::Base
+    def perform(post_id)
+      Post.transaction do
+        post = Post.lock.find_by(id: post_id)
+        now = Time.current
+        next unless post&.scheduled? && post.publish_at && post.publish_at <= now
+        result = WritePost.call({}, post: post, actor: nil, now: now, publish: :scheduled)
+        raise result.error unless result.success?
+        result
+      end
+    end
+  end
+end

data/app/models/concerns/open_blog/immutable.rb

@@ -0,0 +1,13 @@
+module OpenBlog
+  module Immutable
+    extend ActiveSupport::Concern
+
+    included do
+      before_destroy(prepend: true) { raise ActiveRecord::ReadOnlyRecord, "Stored records cannot be destroyed" if persisted? }
+    end
+
+    def readonly?
+      persisted? || super
+    end
+  end
+end

data/app/models/concerns/open_blog/immutable_image_attachment.rb

@@ -0,0 +1,43 @@
+module OpenBlog
+  module ImmutableImageAttachment
+    extend ActiveSupport::Concern
+
+    STRUCTURAL_ATTRIBUTES = %w[name blob_id record_type record_id].freeze
+
+    included do
+      before_create :check_image_attachment_creation
+      before_update :check_image_attachment_changes
+      before_destroy :check_image_attachment_destruction, prepend: true
+    end
+
+    def update_columns(attributes)
+      if image_attachment?(attributes.stringify_keys["record_type"]) && (attributes.keys.map(&:to_s) & STRUCTURAL_ATTRIBUTES).any?
+        raise ActiveRecord::ReadOnlyRecord, "Stored image attachments cannot change"
+      end
+      super
+    end
+
+    private
+      def image_attachment?(target_type = nil)
+        [ record_type, record_type_in_database, target_type ].include?("OpenBlog::Image")
+      end
+
+      def check_image_attachment_creation
+        return unless image_attachment?
+        change = record&.attachment_changes&.fetch("file", nil)
+        unless record&.saved_change_to_id? && change&.attachment.equal?(self)
+          raise ActiveRecord::ReadOnlyRecord, "Image attachments must be created with their image"
+        end
+      end
+
+      def check_image_attachment_changes
+        if image_attachment? && (changes_to_save.keys & STRUCTURAL_ATTRIBUTES).any?
+          raise ActiveRecord::ReadOnlyRecord, "Stored image attachments cannot change"
+        end
+      end
+
+      def check_image_attachment_destruction
+        raise ActiveRecord::ReadOnlyRecord, "Stored image attachments cannot be destroyed" if image_attachment?
+      end
+  end
+end

data/app/models/concerns/open_blog/previewable.rb

@@ -0,0 +1,38 @@
+module OpenBlog
+  module Previewable
+    extend ActiveSupport::Concern
+    TOKEN_LOCK = Mutex.new
+
+    class_methods do
+      def with_preview_tokens
+        TOKEN_LOCK.synchronize do
+          duration = OpenBlog.config.preview_duration
+          unless token_definitions[:preview]&.expires_in == duration
+            generates_token_for(:preview, expires_in: duration) { current_revision_identifier }
+          end
+          yield duration
+        end
+      end
+
+      def find_by_preview_token(token)
+        return unless token.is_a?(String)
+        with_preview_tokens { find_by_token_for(:preview, token) }
+      end
+    end
+
+    def previewable?
+      persisted? && (draft? || scheduled?)
+    end
+
+    def preview_token
+      preview_credentials.fetch(:token)
+    end
+
+    def preview_credentials
+      raise Error::NotFound unless previewable?
+      self.class.with_preview_tokens do |duration|
+        { token: generate_token_for(:preview), expires_at: Time.current + duration }
+      end
+    end
+  end
+end

data/app/models/open_blog/api_token.rb

@@ -0,0 +1,34 @@
+require "digest"
+require "active_support/core_ext/securerandom"
+
+module OpenBlog
+  class ApiToken < ApplicationRecord
+    SCOPES = %w[read write publish].freeze
+    scope :active, -> { where(revoked_at: nil).where("expires_at IS NULL OR expires_at > ?", Time.current) }
+
+    validates :name, presence: true
+    validates :token_digest, presence: true, uniqueness: true, format: { with: /\A[0-9a-f]{64}\z/ }
+    validates :token_prefix, length: { is: 8 }
+    validate do
+      errors.add(:scopes, "must contain only read, write or publish") unless scopes.is_a?(Array) && (scopes - SCOPES).empty?
+    end
+
+    def self.generate(name:, scopes: SCOPES, expires_at: nil)
+      secret = "ob_#{SecureRandom.base58(40)}"
+      record = create!(name: name, scopes: scopes, expires_at: expires_at,
+        token_digest: Digest::SHA256.hexdigest(secret), token_prefix: secret[0, 8])
+      [ record, secret ]
+    end
+
+    def self.authenticate(secret)
+      return unless secret.is_a?(String) && secret.match?(/\Aob_[1-9A-HJ-NP-Za-km-z]{40}\z/)
+      digest = Digest::SHA256.hexdigest(secret)
+      record = active.find_by(token_digest: digest)
+      return unless record && ActiveSupport::SecurityUtils.secure_compare(record.token_digest, digest)
+      now = Time.current
+      return unless active.where(id: record.id).update_all(last_used_at: now) == 1
+      record.last_used_at = now
+      record
+    end
+  end
+end

data/app/models/open_blog/application_record.rb

@@ -0,0 +1,5 @@
+module OpenBlog
+  class ApplicationRecord < ActiveRecord::Base
+    self.abstract_class = true
+  end
+end

data/app/models/open_blog/approval.rb

@@ -0,0 +1,19 @@
+module OpenBlog
+  class Approval < ApplicationRecord
+    include Immutable
+    belongs_to :post
+    belongs_to :revision
+
+    validates :kind, inclusion: { in: %w[sent imported declared] }
+    validates :reviewer_name, :approved_at, presence: true
+    validates :facts_checked, inclusion: { in: [ true, false ] }
+    validates :declared_on, :declared_by, presence: true, if: -> { kind == "declared" }
+    validates :confirmed_by, :evidence, presence: true, if: -> { kind == "imported" }
+    validate :revision_belongs_to_post
+
+    private
+      def revision_belongs_to_post
+        errors.add(:revision, "must belong to the post") if revision && revision.post != post
+      end
+  end
+end

data/app/models/open_blog/author.rb

@@ -0,0 +1,11 @@
+module OpenBlog
+  class Author < ApplicationRecord
+    has_many :posts, dependent: :restrict_with_exception
+    has_one_attached :avatar
+
+    before_validation { self.slug = name.to_s.parameterize if slug.blank? }
+    validates :name, :slug, presence: true
+    validates :slug, uniqueness: true, format: { with: /\A[a-z0-9]+(?:[-_][a-z0-9]+)*\z/ }
+    validates :author_type, inclusion: { in: %w[person organization] }
+  end
+end

data/app/models/open_blog/baseline.rb

@@ -0,0 +1,26 @@
+module OpenBlog
+  class Baseline < ApplicationRecord
+    include Immutable
+    belongs_to :post
+    belongs_to :adopted_revision, class_name: "OpenBlog::Revision"
+
+    validates :post_id, uniqueness: true
+    validates :adopted_at, presence: true
+    validates :provenance, inclusion: { in: %w[ai_assisted human_written unknown] }
+    validates :source_id, uniqueness: { scope: :source_system }, allow_nil: true
+    validates :source_body_sha256, format: { with: /\A[0-9a-f]{64}\z/ }, allow_nil: true
+    validate :separate_declared_and_evidenced_dates
+    validate :revision_belongs_to_post
+
+    private
+      def separate_declared_and_evidenced_dates
+        if first_published_at && declared_first_published_at
+          errors.add(:declared_first_published_at, "cannot accompany an evidenced first publication date")
+        end
+      end
+
+      def revision_belongs_to_post
+        errors.add(:adopted_revision, "must belong to the post") if adopted_revision && adopted_revision.post != post
+      end
+  end
+end

data/app/models/open_blog/category.rb

@@ -0,0 +1,10 @@
+module OpenBlog
+  class Category < ApplicationRecord
+    has_many :posts, dependent: :nullify
+
+    before_validation { self.slug = name.to_s.parameterize if slug.blank? }
+    validates :name, :slug, presence: true, uniqueness: true
+    validates :slug, format: { with: /\A[a-z0-9]+(?:[-_][a-z0-9]+)*\z/ }
+    validates :position, numericality: { only_integer: true }
+  end
+end

data/app/models/open_blog/connection_declaration.rb

@@ -0,0 +1,16 @@
+module OpenBlog
+  class ConnectionDeclaration < ApplicationRecord
+    include Immutable
+    belongs_to :post
+    validates :declared_by, :declared_on, presence: true
+    validates :third_party_paid, inclusion: { in: [ true, false ] }
+    validate :connections_are_named_relations
+
+    private
+      def connections_are_named_relations
+        unless connections.is_a?(Array) && connections.all? { |entry| entry.is_a?(Hash) && entry["party"].present? && entry["relation"].present? }
+          errors.add(:connections, "must be a list of named parties and relations")
+        end
+      end
+  end
+end

data/app/models/open_blog/faq.rb

@@ -0,0 +1,22 @@
+module OpenBlog
+  class Faq < ApplicationRecord
+    include ContentGuard
+    belongs_to :post, inverse_of: :faqs
+    validates :question, :answer, presence: true
+    validates :position, numericality: { only_integer: true, greater_than: 0 }, uniqueness: { scope: :post_id }
+
+    private
+
+    def content_guard_applies?
+      true
+    end
+
+    def content_guard_identity_changed?
+      persisted? && will_save_change_to_post_id?
+    end
+
+    def content_guard_parent
+      post
+    end
+  end
+end

data/app/models/open_blog/image.rb

@@ -0,0 +1,45 @@
+module OpenBlog
+  class Image < ApplicationRecord
+    include Immutable
+    has_one_attached :file, service: ->(_) { OpenBlog.config.storage_service || Rails.application.config.active_storage.service }
+
+    validates :sha256, presence: true, uniqueness: true, format: { with: /\A[0-9a-f]{64}\z/ }
+    validates :filename, :content_type, presence: true
+    validates :byte_size, numericality: { only_integer: true, greater_than_or_equal_to: 0 }
+    validates :width, :height, numericality: { only_integer: true, greater_than: 0 }, allow_nil: true
+
+    module ImmutableFile
+      %i[attach detach purge purge_later].each do |operation|
+        define_method(operation) do |*arguments, **options|
+          raise ActiveRecord::ReadOnlyRecord, "Stored image files cannot change" if record.persisted?
+          super(*arguments, **options)
+        end
+      end
+    end
+
+    def self.from_upload(io, filename:, content_type:, uploaded_by: nil)
+      ImageImport.prepare_upload(io, filename: filename, content_type: content_type).persist(uploaded_by: uploaded_by)
+    end
+
+    def self.from_signed_id(signed_id, uploaded_by: nil)
+      ImageImport.prepare(signed_id: signed_id).persist(uploaded_by: uploaded_by)
+    end
+
+    def self.from_url(url, uploaded_by: nil)
+      ImageImport.prepare(url: url).persist(uploaded_by: uploaded_by)
+    end
+
+    def path
+      "#{OpenBlog.mount_path.chomp("/")}/media/#{sha256}/#{ERB::Util.url_encode(filename)}"
+    end
+
+    def file
+      super.extend(ImmutableFile)
+    end
+
+    def file=(attachable)
+      raise ActiveRecord::ReadOnlyRecord, "Stored image files cannot change" if persisted?
+      super
+    end
+  end
+end

data/app/models/open_blog/page.rb

@@ -0,0 +1,23 @@
+module OpenBlog
+  class Page < ApplicationRecord
+    DEFAULT_SLUGS = { "responsible_party" => "responsible-party", "corrections" => "corrections",
+      "editorial" => "editorial-policy", "ai_use" => "ai-use" }.freeze
+    KINDS = DEFAULT_SLUGS.keys.freeze
+
+    enum :status, { draft: "draft", published: "published" }, validate: true
+    before_validation { self.slug = DEFAULT_SLUGS[kind] if slug.blank? }
+    validates :kind, inclusion: { in: KINDS }, uniqueness: true
+    validates :title, :slug, presence: true
+    validates :slug, uniqueness: true, format: { with: /\A[a-z0-9]+(?:[-_][a-z0-9]+)*\z/ }
+    validates :body_markdown, presence: true, if: :published?
+
+    def path
+      "#{OpenBlog.mount_path.chomp('/')}/policies/#{slug}"
+    end
+
+    def url(base: nil)
+      origin = base || OpenBlog.config.public_base_url
+      "#{origin.chomp('/')}#{path}" if origin
+    end
+  end
+end

data/app/models/open_blog/page_view.rb

@@ -0,0 +1,7 @@
+module OpenBlog
+  class PageView < ApplicationRecord
+    belongs_to :post
+    validates :day, presence: true
+    validates :views, numericality: { only_integer: true, greater_than_or_equal_to: 0 }
+  end
+end

data/app/models/open_blog/post.rb

@@ -0,0 +1,132 @@
+require "uri"
+
+module OpenBlog
+  class Post < ApplicationRecord
+    include Previewable
+    RESERVED_SLUGS = %w[feed search preview media policies api mcp sitemap].freeze
+    SLUG_PATTERN = /\A[a-z0-9]+(?:[-_][a-z0-9]+)*\z/
+
+    belongs_to :author
+    belongs_to :category, optional: true
+    belongs_to :series, optional: true
+    belongs_to :cover_image, class_name: "OpenBlog::Image", optional: true
+    belongs_to :social_image, class_name: "OpenBlog::Image", optional: true
+    belongs_to :public_revision, class_name: "OpenBlog::Revision", optional: true
+
+    has_many :faqs, -> { order(:position) }, autosave: true, dependent: :destroy, inverse_of: :post
+    accepts_nested_attributes_for :faqs, allow_destroy: true, reject_if: ->(attributes) { attributes["id"].blank? && attributes["question"].blank? && attributes["answer"].blank? }
+    has_many :taggings, autosave: true, dependent: :destroy
+    has_many :tags, through: :taggings, autosave: false
+    has_many :page_views, dependent: :delete_all
+    has_many :revisions, dependent: :restrict_with_exception
+    has_many :approvals, dependent: :restrict_with_exception
+    has_many :publications, dependent: :restrict_with_exception
+    has_many :connection_declarations, dependent: :restrict_with_exception
+    has_one :baseline, dependent: :restrict_with_exception
+    has_rich_text :rich_body
+
+    attribute :body_format, :string, default: -> { OpenBlog.config.default_body_format.to_s }
+    enum :body_format, { markdown: "markdown", rich_text: "rich_text" }, validate: true
+    enum :status, { draft: "draft", scheduled: "scheduled", published: "published", archived: "archived" }, validate: true
+    enum :provenance, { ai_assisted: "ai_assisted", human_written: "human_written", unknown: "unknown" }, validate: true, prefix: true
+
+    validates :title, :author_name, presence: true
+    validates :slug, presence: true, uniqueness: true, format: { with: SLUG_PATTERN }
+    validates :external_id, uniqueness: true, allow_nil: true
+    validates :canonical_url, length: { maximum: 2048 }, allow_nil: true
+    validates :body_format, inclusion: { in: ->(_post) { OpenBlog.config.body_formats.map(&:to_s) } }
+    validates :series_position, numericality: { only_integer: true, greater_than: 0 }, allow_nil: true
+    validates :series_position, uniqueness: { scope: :series_id }, if: -> { series_id && series_position }
+    validate :slug_is_available
+    validate :public_revision_ownership
+    validate :canonical_url_is_absolute
+
+    scope :listed, -> { where(status: "published") }
+
+    attr_accessor :release_context, :release_records
+
+    before_save :resolve_body_images
+    before_save :compute_derived
+    after_save :record_release
+    around_save :guard_parent_content, prepend: true
+    around_destroy :guard_parent_content, prepend: true
+
+    def path
+      "#{OpenBlog.mount_path.chomp('/')}/#{slug}"
+    end
+
+    def url(base: nil)
+      origin = base || OpenBlog.config.public_base_url
+      "#{origin.chomp('/')}#{path}" if origin
+    end
+
+    def faq_list
+      faqs.to_a.reject(&:marked_for_destruction?).sort_by { |entry| entry.position || 0 }.map do |entry|
+        { question: entry.question, answer: entry.answer }
+      end
+    end
+
+    def body_for_payload
+      return body_markdown.to_s if markdown?
+
+      if rich_body.will_save_change_to_body?
+        rich_body.read_attribute_for_database(:body).to_s
+      else
+        rich_body.read_attribute_before_type_cast(:body).to_s
+      end
+    end
+
+    private
+
+    def guard_parent_content(&block)
+      ContentGuard.with_parent(self, &block)
+    end
+
+    def record_release
+      republishing = saved_change_to_status? && status_before_last_save != "published"
+      self.release_records = RecordRelease.call(self, **(release_context || {}), republishing: republishing)
+    ensure
+      self.release_context = nil
+    end
+
+    def canonical_url_is_absolute
+      return if canonical_url.nil?
+
+      uri = URI.parse(canonical_url)
+      unless uri.is_a?(URI::HTTP) && uri.host.present?
+        errors.add(:canonical_url, "must be an absolute HTTP or HTTPS URL")
+      end
+    rescue URI::InvalidURIError
+      errors.add(:canonical_url, "must be an absolute HTTP or HTTPS URL")
+    end
+
+    def resolve_body_images
+      ImageResolution.native!(self)
+    end
+
+    def compute_derived
+      self.current_revision_identifier = RevisionPayload.new(self).identifier
+      body_text = markdown? ? PlainText.from_markdown(body_markdown) : PlainText.from_html(body_for_payload)
+      faq_text = faq_list.flat_map { |entry| entry.values_at(:question, :answer) }.join("\n")
+      self.word_count = [ body_text, faq_text ].join("\n").split.length
+      self.reading_time_minutes = [ (word_count / 238.0).ceil, 1 ].max
+      self.search_text = [ title, description, body_text, faq_text ].join("\n")
+    end
+
+    def slug_is_available
+      if (RESERVED_SLUGS + OpenBlog.config.route_segments.values).include?(slug)
+        errors.add(:slug, "is reserved")
+      end
+      redirect = Redirect.find_by(old_path: path)
+      if redirect && (new_record? || redirect.post_id != id)
+        errors.add(:slug, "belongs to an existing redirect")
+      end
+    end
+
+    def public_revision_ownership
+      if public_revision && (new_record? || public_revision.post_id != id)
+        errors.add(:public_revision, "must belong to this post")
+      end
+    end
+  end
+end

data/app/models/open_blog/publication.rb

@@ -0,0 +1,17 @@
+module OpenBlog
+  class Publication < ApplicationRecord
+    include Immutable
+    belongs_to :post
+    belongs_to :revision
+
+    validates :entry_type, inclusion: { in: %w[first substantive correction maintenance adopted] }
+    validates :occurred_at, presence: true
+    validates :note, presence: true, if: -> { entry_type == "correction" }
+    validate :revision_belongs_to_post
+
+    private
+      def revision_belongs_to_post
+        errors.add(:revision, "must belong to the post") if revision && revision.post != post
+      end
+  end
+end