open_blog 0.1.0

data/lib/open_blog/post_attributes.rb

@@ -0,0 +1,172 @@
+require "digest"
+
+module OpenBlog
+  class PostAttributes
+    CONTENT_FIELDS = %i[title description search_title search_description body body_format author cover_image cover_alt social_image faq category tags series series_position featured canonical_url slug external_id].freeze
+    RECORD_FIELDS = %i[provenance provenance_evidence made_by_ai approval change change_description note connections publish_at].freeze
+    TEXT_FIELDS = %i[title description search_title search_description body cover_alt canonical_url slug external_id provenance_evidence].freeze
+
+    def self.normalize(attributes)
+      unless attributes.is_a?(Hash) && attributes.keys.all? { |key| key.is_a?(String) || key.is_a?(Symbol) }
+        raise Error::ValidationFailed.new(details: [ "attributes" ])
+      end
+      normalized = attributes.symbolize_keys
+      unknown = normalized.keys - CONTENT_FIELDS - RECORD_FIELDS
+      raise Error::UnknownField.new(details: unknown.map(&:to_s)) if unknown.any?
+      normalized
+    end
+
+    def self.assign(post, attributes, actor:, now:)
+      new(post, normalize(attributes), actor: actor, now: now).assign
+    rescue ActiveRecord::RecordNotFound
+      raise Error::NotFound
+    rescue ActiveRecord::RecordInvalid => error
+      raise Error::ValidationFailed.new(details: error.record.errors.attribute_names.map(&:to_s))
+    end
+
+    def initialize(post, attributes, actor:, now:)
+      @post, @attributes, @actor, @now = post, attributes, actor, now
+    end
+
+    def assign
+      validate_types
+      assign_scalars
+      assign_author if @attributes.key?(:author) || @post.author.nil?
+      %i[category series].each do |field|
+        @post.public_send("#{field}=", taxonomy(OpenBlog.const_get(field.to_s.classify), @attributes[field])) if @attributes.key?(field)
+      end
+      assign_faq if @attributes.key?(:faq)
+      assign_tags if @attributes.key?(:tags)
+      %i[cover_image social_image].each do |field|
+        @post.public_send("#{field}=", image(@attributes[field])) if @attributes.key?(field)
+      end
+      assign_provenance
+      PostIdentity.resolve({ slug: @post.slug }, post: @post)
+      @post
+    end
+
+    private
+
+    def invalid(field)
+      raise Error::ValidationFailed.new(details: [ field.to_s ])
+    end
+
+    def validate_types
+      TEXT_FIELDS.each { |field| invalid(field) if @attributes.key?(field) && !@attributes[field].nil? && !@attributes[field].is_a?(String) }
+      invalid(:featured) if @attributes.key?(:featured) && ![ true, false ].include?(@attributes[:featured])
+      if @attributes.key?(:series_position) && !@attributes[:series_position].nil?
+        invalid(:series_position) unless @attributes[:series_position].is_a?(Integer) && @attributes[:series_position].positive?
+      end
+      %i[category series].each do |field|
+        invalid(field) if @attributes.key?(field) && !@attributes[field].nil? && !@attributes[field].is_a?(String)
+      end
+      if @attributes.key?(:body_format)
+        format = @attributes[:body_format]
+        unless (format.is_a?(String) || format.is_a?(Symbol)) && OpenBlog.config.body_formats.map(&:to_s).include?(format.to_s)
+          raise Error::BodyFormatNotPermitted
+        end
+      end
+      if @attributes.key?(:provenance) && !%w[ai_assisted human_written unknown].include?(@attributes[:provenance].to_s)
+        invalid(:provenance)
+      end
+      if @attributes.key?(:tags)
+        invalid(:tags) unless @attributes[:tags].is_a?(Array) && @attributes[:tags].all? { |tag| tag.is_a?(String) && tag.present? }
+      end
+      if @attributes.key?(:faq)
+        invalid(:faq) unless @attributes[:faq].is_a?(Array)
+        @attributes[:faq].each do |entry|
+          invalid(:faq) unless entry.is_a?(Hash)
+          values = entry.stringify_keys
+          invalid(:faq) unless values.keys.sort == %w[answer question] && values.values.all? { |value| value.is_a?(String) && value.present? }
+        end
+      end
+    end
+
+    def assign_scalars
+      fields = TEXT_FIELDS - %i[body provenance_evidence]
+      (fields + %i[featured series_position body_format]).each do |field|
+        @post.public_send("#{field}=", @attributes[field]) if @attributes.key?(field)
+      end
+      %i[description search_title search_description cover_alt].each do |field|
+        @post.public_send("#{field}=", "") if @post.public_send(field).nil?
+      end
+      @post.canonical_url = nil if @post.canonical_url.blank?
+      if @post.slug.blank?
+        @post.slug = @post.title.to_s.parameterize.presence || "post-#{Digest::SHA256.hexdigest(@post.title.to_s)[0, 12]}"
+      end
+      if @attributes.key?(:body)
+        @post.public_send(@post.markdown? ? "body_markdown=" : "rich_body=", @attributes[:body])
+      end
+    end
+
+    def assign_author
+      input = @attributes.key?(:author) ? @attributes[:author] : OpenBlog.config.default_author
+      author = case input
+      when Author then input
+      when Integer then Author.find(input)
+      when String
+        invalid(:author) if input.blank?
+        if input.match?(/\A[1-9]\d*\z/)
+          Author.find(input)
+        else
+          Author.find_by(slug: input) || Author.find_by(name: input) || Author.create!(name: input)
+        end
+      when Hash
+        fields = input.symbolize_keys
+        invalid(:author) unless (fields.keys - %i[name type url]).empty? && fields[:name].is_a?(String) && fields[:name].present?
+        invalid(:author) if fields.key?(:type) && !%w[person organization].include?(fields[:type].to_s)
+        invalid(:author) if fields.key?(:url) && !fields[:url].nil? && !fields[:url].is_a?(String)
+        Author.find_by(name: fields[:name]) || Author.create!(name: fields[:name], author_type: fields.fetch(:type, :person).to_s, url: fields[:url])
+      else invalid(:author)
+      end
+      @post.author = author
+      @post.author_name = author.name
+    end
+
+    def taxonomy(model, value)
+      return if value.blank?
+      model.find_by(slug: value) || model.find_by(name: value) || model.create!(name: value)
+    end
+
+    def assign_faq
+      existing = @post.faqs.to_a.sort_by(&:position)
+      @attributes[:faq].each_with_index do |entry, index|
+        record = existing[index] || @post.faqs.build(position: (existing.last&.position || 0) + index + 1)
+        record.assign_attributes(entry.symbolize_keys)
+      end
+      existing.drop(@attributes[:faq].length).each(&:mark_for_destruction)
+    end
+
+    def assign_tags
+      tags = @attributes[:tags].uniq(&:downcase).map do |name|
+        Tag.where("LOWER(name) = ?", name.downcase).first || Tag.create!(name: name)
+      end
+      @post.taggings.each { |tagging| tagging.mark_for_destruction unless tags.any? { |tag| tag.id == tagging.tag_id } }
+      existing = @post.taggings.reject(&:marked_for_destruction?).map(&:tag_id)
+      tags.each { |tag| @post.taggings.build(tag: tag) unless existing.include?(tag.id) }
+      @post.association(:tags).target = tags
+      @post.association(:tags).loaded!
+    end
+
+    def image(input)
+      return if input.nil?
+      return input if input.is_a?(Image) && input.persisted?
+      return Image.find(input) if input.is_a?(Integer)
+      if input.is_a?(Hash) && input.keys.map(&:to_s) == [ "image_id" ]
+        id = input[:image_id] || input["image_id"]
+        return Image.find(id) if id.is_a?(Integer) || (id.is_a?(String) && id.match?(/\A[1-9]\d*\z/))
+      end
+      raise Error::ImageNotPermitted
+    end
+
+    def assign_provenance
+      changed = @attributes.key?(:provenance) && @post.provenance != @attributes[:provenance].to_s
+      @post.provenance = @attributes[:provenance] if @attributes.key?(:provenance)
+      if @attributes.key?(:provenance_evidence)
+        @post.provenance_evidence = @attributes[:provenance_evidence]
+      elsif changed
+        @post.provenance_evidence = "Stated by #{@actor} in the call of #{@now.iso8601}"
+      end
+    end
+  end
+end

data/lib/open_blog/post_identity.rb

@@ -0,0 +1,28 @@
+module OpenBlog
+  class PostIdentity
+    def self.resolve(attributes, post: nil)
+      raise Error::ValidationFailed.new(details: [ "attributes" ]) unless attributes.is_a?(Hash)
+      attributes = attributes.symbolize_keys
+      %i[external_id slug].each do |field|
+        if attributes.key?(field) && !attributes[field].nil? && !attributes[field].is_a?(String)
+          raise Error::ValidationFailed.new(details: [ field.to_s ])
+        end
+      end
+      unless post
+        external = Post.find_by(external_id: attributes[:external_id]) if attributes[:external_id].present?
+        slug = Post.find_by(slug: attributes[:slug]) if attributes[:slug].present?
+        raise Error::IdentityConflict if external && slug && external != slug
+        post = external || slug || Post.new
+      end
+      candidate = attributes[:slug].presence || post.slug
+      if candidate.present?
+        reserved = Post::RESERVED_SLUGS + OpenBlog.config.route_segments.values
+        redirect = Redirect.find_by(old_path: "#{OpenBlog.mount_path.chomp('/')}/#{candidate}")
+        if reserved.include?(candidate) || (redirect && (post.new_record? || redirect.post_id != post.id))
+          raise Error::SlugReserved
+        end
+      end
+      post
+    end
+  end
+end

data/lib/open_blog/publish.rb

@@ -0,0 +1,7 @@
+module OpenBlog
+  class Publish
+    def self.call(attributes, post: nil, actor:, now: Time.current, authorize: nil)
+      WritePost.call(attributes, post: post, actor: actor, now: now, publish: true, authorize: authorize)
+    end
+  end
+end

data/lib/open_blog/reader_dates.rb

@@ -0,0 +1,21 @@
+module OpenBlog
+  module ReaderDates
+    def self.visible(time, now: Time.current)
+      time if time && time <= now
+    end
+
+    def self.published_at(post, now: Time.current)
+      visible(post.published_at, now: now)
+    end
+
+    def self.modified_at(post, now: Time.current)
+      visible(post.modified_at, now: now)
+    end
+
+    def self.feed_updated_at(post, now: Time.current)
+      modified_at(post, now: now) ||
+        post.publications.where(entry_type: %w[first substantive correction adopted]).where("occurred_at <= ?", now).maximum(:occurred_at) ||
+        visible(post.created_at, now: now) || now
+    end
+  end
+end

data/lib/open_blog/reader_page.rb

@@ -0,0 +1,21 @@
+module OpenBlog
+  class ReaderPage
+    attr_reader :kind, :record, :pagination, :path, :breadcrumbs, :base_url
+
+    def initialize(kind:, path:, base_url:, record: nil, pagination: nil, breadcrumbs: [])
+      @kind, @record, @pagination, @path, @breadcrumbs, @base_url = kind, record, pagination, path, breadcrumbs, base_url.chomp("/")
+    end
+
+    def page_number
+      pagination&.page || 1
+    end
+
+    def path_for(number)
+      number > 1 ? "#{path}#{path.include?("?") ? "&" : "?"}page=#{number}" : path
+    end
+
+    def canonical_path
+      path_for(page_number)
+    end
+  end
+end

data/lib/open_blog/reader_queries.rb

@@ -0,0 +1,90 @@
+require "digest"
+require "json"
+
+module OpenBlog
+  module ReaderQueries
+    def self.posts
+      Post.listed.includes(:author, :category, :tags, cover_image: { file_attachment: :blob }).order(Arel.sql("published_at IS NULL ASC"), published_at: :desc, id: :desc)
+    end
+
+    def self.featured
+      posts.where(featured: true).first
+    end
+
+    def self.category_path(category)
+      "#{OpenBlog.mount_path.chomp('/')}/#{OpenBlog.config.route_segments.fetch(:category)}/#{category.slug}"
+    end
+
+    def self.tag_path(tag)
+      "#{OpenBlog.mount_path.chomp('/')}/#{OpenBlog.config.route_segments.fetch(:tag)}/#{tag.slug}"
+    end
+
+    def self.author_path(author)
+      "#{OpenBlog.mount_path.chomp('/')}/#{OpenBlog.config.route_segments.fetch(:author)}/#{author.slug}"
+    end
+
+    def self.series_path(series)
+      "#{OpenBlog.mount_path.chomp('/')}/#{OpenBlog.config.route_segments.fetch(:series)}/#{series.slug}"
+    end
+
+    def self.series_posts(series)
+      posts.where(series_id: series.id).reorder(Arel.sql("series_position IS NULL ASC"), series_position: :asc, id: :asc)
+    end
+
+    def self.series_neighbors(post)
+      return {} unless post.series_id
+      scope = series_posts(post.series).where.not(id: post.id)
+      if post.series_position
+        previous = scope.where("series_position < ?", post.series_position).reverse_order.first
+        following = scope.where("series_position > ? OR series_position IS NULL", post.series_position).first
+      else
+        previous = scope.where("series_position IS NOT NULL OR id < ?", post.id).reverse_order.first
+        following = scope.where(series_position: nil).where("id > ?", post.id).first
+      end
+      { previous: previous, next: following }
+    end
+
+    def self.sidebar
+      category_counts = Post.listed.where.not(category_id: nil).group(:category_id).count
+      tag_counts = Tagging.joins(:post).merge(Post.listed).group(:tag_id).count
+      categories = Category.where(id: category_counts.keys).order(:position, :name).map { |category| { category: category, count: category_counts.fetch(category.id) } }
+      tags = Tag.where(id: tag_counts.keys).to_a.sort_by { |tag| [ -tag_counts.fetch(tag.id), tag.name, tag.id ] }.first(20).map { |tag| { tag: tag, count: tag_counts.fetch(tag.id) } }
+      { categories: categories, tags: tags }
+    end
+
+    def self.sidebar_cache_key(sidebar)
+      fields = sidebar[:categories].map { |entry| [ entry[:category].attributes.slice("id", "name", "slug", "position"), entry[:count] ] } +
+        sidebar[:tags].map { |entry| [ entry[:tag].attributes.slice("id", "name", "slug"), entry[:count] ] }
+      [ "open_blog/sidebar", Post.listed.maximum(:modified_at), Post.listed.count,
+        OpenBlog.config.locale, OpenBlog.mount_path, Digest::SHA256.hexdigest(JSON.generate([ fields, OpenBlog.config.route_segments ])) ]
+    end
+
+    def self.related_cache_key(post, related)
+      fields = related.map do |entry|
+        [ entry.id, entry.current_revision_identifier, entry.slug, entry.author.slug, entry.author.avatar.blob&.key,
+          entry.category&.attributes&.slice("name", "slug"), entry.cover_image&.path,
+          ReaderDates.published_at(entry), ReaderDates.modified_at(entry), entry.reading_time_minutes ]
+      end
+      [ "open_blog/related", post.id, Post.listed.maximum(:modified_at), Post.listed.count,
+        OpenBlog.config.locale, OpenBlog.mount_path, Digest::SHA256.hexdigest(JSON.generate([ fields, OpenBlog.config.route_segments ])) ]
+    end
+
+    def self.popular
+      settings = OpenBlog.config.popular_posts
+      return [] unless settings[:enabled]
+      days, limit = settings.fetch(:days, 30), settings.fetch(:limit, 5)
+      key = [ "open_blog/popular", days, limit, OpenBlog.config.locale, OpenBlog.mount_path, OpenBlog.config.route_segments ]
+      ids = Rails.cache.fetch(key, expires_in: 1.hour) do
+        PageViews.top(days: days, limit: limit, scope: Post.listed).fetch(:posts).map { |post| post.fetch(:id) }
+      end
+      current = Post.listed.where(id: ids).index_by(&:id)
+      ids.filter_map { |id| current[id] }
+    end
+
+    def self.related(post)
+      scope = posts.where.not(id: post.id)
+      scope = scope.where(category_id: post.category_id) if post.category_id
+      scope.limit(3).to_a
+    end
+  end
+end

data/lib/open_blog/record_release.rb

@@ -0,0 +1,66 @@
+module OpenBlog
+  class RecordRelease
+    def self.call(post, change: nil, note: nil, description: nil, actor: nil, now: Time.current, made_by_ai: nil, republishing: false)
+      post.class.transaction do
+        stored = post.class.lock.find(post.id)
+        ImageResolution.native!(stored)
+        unless stored.published?
+          stored.send(:compute_derived)
+          post.update_columns(stored.attributes.slice("current_revision_identifier", "word_count", "reading_time_minutes", "search_text", "body_image_manifest", "body_image_source_digest"))
+          next { revision: nil, publication: nil, approval: nil }
+        end
+
+        new(stored, post, change: change, note: note, description: description, actor: actor,
+          now: now, made_by_ai: made_by_ai, republishing: republishing).call
+      end
+    end
+
+    def initialize(stored, original, **context)
+      @post, @original, @context = stored, original, context
+    end
+
+    def call
+      @post.send(:compute_derived)
+      payload = RevisionPayload.new(@post)
+      changed = @post.public_revision&.identifier != payload.identifier
+      type = entry_type(changed)
+      revision = @post.revisions.find_by(identifier: payload.identifier)
+      revision_kind = revision ? "same" : "new"
+      revision ||= Revision.create!(post: @post, identifier: payload.identifier, payload: payload.to_json,
+        actor: @context[:actor], made_by_ai: @context[:made_by_ai], created_at: @context[:now])
+      if type
+        Publication.create!(post: @post, revision: revision, entry_type: type, occurred_at: @context[:now],
+          released_by: @context[:actor], note: @context[:note], description: description(changed))
+      end
+      attributes = @post.attributes.slice("current_revision_identifier", "word_count", "reading_time_minutes", "search_text", "body_image_manifest", "body_image_source_digest")
+      attributes.merge!(public_revision_id: revision.id, published_at: published_at, modified_at: modified_at)
+      @original.update_columns(attributes)
+      @original.association(:public_revision).reset
+      { revision: revision_kind, publication: type, approval: nil }
+    end
+
+    private
+
+    def entry_type(changed)
+      return "first" unless @post.public_revision_id || @post.publications.exists?
+      return @context[:change].to_s if @context[:change].present?
+      return "substantive" if changed
+      "maintenance" if @context[:republishing]
+    end
+
+    def description(changed)
+      return @context[:description] if @context[:description].present?
+      "republished" if @context[:republishing] && !changed
+    end
+
+    def published_at
+      @post.publications.find_by(entry_type: "first")&.occurred_at ||
+        @post.baseline&.first_published_at || @post.baseline&.declared_first_published_at
+    end
+
+    def modified_at
+      @post.publications.where(entry_type: %w[substantive correction]).maximum(:occurred_at) ||
+        @post.baseline&.last_modified_at || published_at
+    end
+  end
+end

data/lib/open_blog/redirect_target.rb

@@ -0,0 +1,58 @@
+require "uri"
+
+module OpenBlog
+  class RedirectTarget
+    LOCK_KEY = 1_867_541_239
+
+    def self.synchronize
+      Redirect.transaction do
+        connection = Redirect.connection
+        if connection.adapter_name == "PostgreSQL"
+          connection.execute("SELECT pg_advisory_xact_lock(#{LOCK_KEY})")
+        elsif connection.adapter_name == "SQLite"
+          connection.execute("UPDATE open_blog_redirects SET id = id WHERE 1 = 0")
+        end
+        yield
+      end
+    rescue ActiveRecord::StatementInvalid => error
+      raise unless error.cause.class.name == "SQLite3::BusyException"
+      raise Error::ValidationFailed.new(details: [ "redirects" ])
+    end
+
+    def self.call(target, from:)
+      visited = [ from ]
+      while target
+        target, path = normalize_target(target)
+        raise Error::ValidationFailed.new(details: [ "redirect_to" ]) if visited.include?(path)
+        visited << path
+        redirect = Redirect.find_by(old_path: path)
+        break unless redirect
+        target = redirect.new_path
+      end
+      target
+    end
+    def self.normalize_target(target)
+      unless target.is_a?(String) && target.present? && !target.match?(/\s/)
+        raise Error::ValidationFailed.new(details: [ "redirect_to" ])
+      end
+      uri = URI.parse(target)
+      if target.start_with?("/") && !target.start_with?("//") && !uri.host && !uri.scheme
+        return [ target, uri.path ]
+      end
+      unless uri.is_a?(URI::HTTP) && uri.host.present? && !uri.userinfo
+        raise Error::ValidationFailed.new(details: [ "redirect_to" ])
+      end
+      origin = URI.parse(OpenBlog.config.public_base_url) if OpenBlog.config.public_base_url
+      if origin && [ origin.scheme, origin.host, origin.port ] == [ uri.scheme, uri.host, uri.port ]
+        target = uri.request_uri
+        target += "##{uri.fragment}" if uri.fragment
+        [ target, uri.path ]
+      else
+        [ target, target ]
+      end
+    rescue URI::InvalidURIError
+      raise Error::ValidationFailed.new(details: [ "redirect_to" ])
+    end
+    private_class_method :normalize_target
+  end
+end

data/lib/open_blog/remove.rb

@@ -0,0 +1,43 @@
+require "uri"
+
+module OpenBlog
+  class Remove
+    def self.call(post, redirect_to: nil, actor:, now: Time.current)
+      Operation.run(post: post, actor: actor, now: now) do |current, _created|
+        raise Error::NotFound unless current.persisted?
+        if (current.draft? || current.scheduled?) && !retained_records?(current)
+          current.destroy!
+        else
+          current.update!(status: "archived", publish_at: nil)
+          write_redirect(current, target: redirect_to, source: "removal", now: now)
+        end
+        { revision: nil, publication: nil, approval: nil }
+      end
+    end
+
+    def self.write_redirect(post, target:, source:, now:)
+      RedirectTarget.synchronize do
+        target = RedirectTarget.call(target, from: post.path)
+        redirect = Redirect.find_by(old_path: post.path)
+        raise Error::SlugReserved if redirect && redirect.post_id != post.id
+
+        if redirect
+          redirect.update!(new_path: target)
+        else
+          Redirect.create!(old_path: post.path, new_path: target, source: source,
+            post: post, occurred_on: now.to_date)
+        end
+        Redirect.where(new_path: post.path).where.not(old_path: post.path).find_each do |incoming|
+          incoming.update!(new_path: target)
+        end
+      end
+    end
+
+    def self.retained_records?(post)
+      post.public_revision_id.present? || post.revisions.exists? || post.publications.exists? ||
+        post.approvals.exists? || post.connection_declarations.exists? || post.baseline.present? ||
+        Redirect.where(post_id: post.id).exists?
+    end
+    private_class_method :retained_records?
+  end
+end

data/lib/open_blog/renderer/highlighter.rb

@@ -0,0 +1,44 @@
+require "rouge"
+
+module OpenBlog
+  class Renderer
+    module Highlighter
+      def self.call(pre)
+        code = pre.at_css("code")
+        return unless code
+        language = pre["lang"].presence || code["lang"].presence
+        pre.remove_attribute("lang")
+        lexer = Rouge::Lexer.find(language) if language
+        code.inner_html = Rouge::Formatters::HTML.new.format(lexer.new.lex(code.text)) if lexer
+        pre["class"] = "ob-highlight"
+        pre["tabindex"] = "0"
+        if language
+          pre["data-lang"] = language
+          label = Nokogiri::XML::Node.new("span", pre.document)
+          label["class"] = "ob-code-language"
+          label["aria-hidden"] = "true"
+          label.content = language
+          pre.prepend_child(label)
+        end
+        pre["data-controller"] = "open-blog--code-copy"
+        code["data-open-blog--code-copy-target"] = "code"
+        pre["data-open-blog--code-copy-copied-label-value"] = translate(:copied)
+        pre["data-open-blog--code-copy-error-label-value"] = translate(:copy_failed)
+        button = Nokogiri::XML::Node.new("button", pre.document)
+        button["type"] = "button"
+        button["class"] = "ob-code-copy"
+        button["data-action"] = "open-blog--code-copy#copy"
+        button["data-open-blog--code-copy-target"] = "button"
+        button["hidden"] = "hidden"
+        button["aria-live"] = "polite"
+        button["aria-label"] = translate(:copy_label)
+        button.content = translate(:copy)
+        pre.add_child(button)
+      end
+
+      def self.translate(key)
+        I18n.t("open_blog.code.#{key}", locale: OpenBlog.config.locale)
+      end
+    end
+  end
+end

data/lib/open_blog/renderer/markdown.rb

@@ -0,0 +1,14 @@
+require "commonmarker"
+
+module OpenBlog
+  class Renderer
+    module Markdown
+      def self.render(text)
+        Commonmarker.to_html(text.to_s.encode(Encoding::UTF_8), options: {
+          extension: { header_ids: nil, footnotes: true, alerts: true, table: true, tasklist: true, strikethrough: true, autolink: true },
+          render: { unsafe: false, hardbreaks: OpenBlog.config.markdown_hardbreaks }
+        }, plugins: { syntax_highlighter: nil })
+      end
+    end
+  end
+end

data/lib/open_blog/renderer/rich_text.rb

@@ -0,0 +1,19 @@
+module OpenBlog
+  class Renderer
+    module RichText
+      def self.render(text, post: nil)
+        ActionText::Content.new(text.to_s).render_attachments(with_full_attributes: false) do |attachment|
+          blob = attachment.attachable
+          image = ImageResolution.image_for_attachment(blob, post: post) if blob.is_a?(ActiveStorage::Blob)
+          if image
+            caption = PlainText.from_html(attachment.caption.to_s)
+            alt = attachment.node["alt"].presence || caption
+            ActionText::Content.render(partial: "open_blog/attachments/blob", locals: { image: image, alt: alt, caption: caption })
+          else
+            ERB::Util.html_escape(PlainText.from_html(attachment.caption.to_s))
+          end
+        end.to_html
+      end
+    end
+  end
+end

data/lib/open_blog/renderer/sanitizer.rb

@@ -0,0 +1,72 @@
+require "uri"
+require "rails/html/sanitizer"
+require "nokogiri"
+
+module OpenBlog
+  class Renderer
+    module Sanitizer
+      TAGS = %w[p h1 h2 h3 h4 h5 h6 ul ol li a strong em del code pre blockquote br hr img figure figcaption table thead tbody tr th td sup sub section div span input].freeze
+      ATTRIBUTES = %w[href rel src alt title width height lang align].freeze
+      TOKEN = "data-ob-render-token".freeze
+      Document = Struct.new(:fragment, :metadata, keyword_init: true)
+
+      def self.call(html, trusted: false)
+        fragment = Nokogiri::HTML5.fragment(html)
+        fragment.css("pre").each do |node|
+          code = Nokogiri::XML::Node.new("code", node.document)
+          code["lang"] = node.at_css("code")["lang"] if node.at_css("code")&.key?("lang")
+          code.content = node.text
+          node.children.remove
+          node.add_child(code)
+        end
+        fragment.css("code").each { |node| node.content = node.text }
+        metadata = trusted ? capture(fragment) : {}
+        output = Rails::HTML5::SafeListSanitizer.new.sanitize(fragment.to_html, scrubber: Scrubber.new(metadata))
+        Document.new(fragment: Nokogiri::HTML5.fragment(output), metadata: metadata)
+      end
+
+      def self.safe_url?(value, image: false)
+        return false unless value.is_a?(String) && value.present?
+        uri = URI.parse(value)
+        uri.scheme.nil? || (image ? %w[http https] : %w[http https mailto]).include?(uri.scheme.downcase)
+      rescue URI::InvalidURIError
+        false
+      end
+
+      def self.restore!(document)
+        document.fragment.css("[#{TOKEN}]").each do |node|
+          document.metadata.fetch(node[TOKEN], {}).each { |name, value| node[name] = value }
+          node.remove_attribute(TOKEN)
+        end
+        document.fragment
+      end
+
+      def self.capture(fragment)
+        metadata = {}
+        fragment.traverse do |node|
+          next unless node.element?
+          attributes = {}
+          classes = node["class"].to_s.split.select do |name|
+            name.match?(/\A(?:markdown-alert(?:-(?:note|tip|important|warning|caution|title))?|footnotes?|footnote-(?:ref|backref)|task-list(?:-item)?)\z/)
+          end
+          attributes["class"] = classes.join(" ") if classes.any?
+          if node["id"].to_s.match?(/\Afn(?:ref)?-/)
+            attributes["id"] = "ob-footnote-#{node['id']}"
+          end
+          if node["href"].to_s.match?(/\A#fn(?:ref)?-/)
+            attributes["href"] = "#ob-footnote-#{node['href'].delete_prefix('#')}"
+          end
+          %w[data-footnote-ref data-footnotes data-footnote-backref data-footnote-backref-idx aria-label].each do |name|
+            attributes[name] = node[name] if node.key?(name)
+          end
+          next if attributes.empty?
+          token = metadata.length.to_s
+          metadata[token] = attributes
+          node[TOKEN] = token
+        end
+        metadata
+      end
+      private_class_method :capture
+    end
+  end
+end