open_blog 0.1.0

data/app/controllers/open_blog/api/v1/views_controller.rb

@@ -0,0 +1,19 @@
+module OpenBlog
+  module Api
+    module V1
+      class ViewsController < BaseController
+        def show
+          require_scope!(:read)
+          input = input_fields!(*ApiFields::VIEWS)
+          render json: PageViews.for(find_post!, **input)
+        end
+
+        def top
+          require_scope!(:read)
+          input = input_fields!(*ApiFields::TOP_VIEWS)
+          render json: PageViews.top(**input, base_url: request.base_url)
+        end
+      end
+    end
+  end
+end

data/app/controllers/open_blog/application_controller.rb

@@ -0,0 +1,5 @@
+module OpenBlog
+  class ApplicationController < OpenBlog.config.parent_controller.constantize
+    include ReaderController
+  end
+end

data/app/controllers/open_blog/authors_controller.rb

@@ -0,0 +1,14 @@
+module OpenBlog
+  class AuthorsController < ApplicationController
+    before_action :require_html
+
+    def show
+      @author = Author.find_by!(slug: params[:slug])
+      pagination = paginate(ReaderQueries.posts.where(author_id: @author.id))
+      @posts = pagination.records
+      path = ReaderQueries.author_path(@author)
+      page_context(:author, record: @author, path: path, pagination: pagination,
+        breadcrumbs: [ { name: OpenBlog.config.blog_title, path: OpenBlog.mount_path }, { name: @author.name, path: path } ])
+    end
+  end
+end

data/app/controllers/open_blog/categories_controller.rb

@@ -0,0 +1,15 @@
+module OpenBlog
+  class CategoriesController < ApplicationController
+    before_action :require_html
+
+    def show
+      @category = Category.find_by!(slug: params[:slug])
+      pagination = paginate(ReaderQueries.posts.where(category_id: @category.id))
+      @posts = pagination.records
+      load_sidebar
+      path = ReaderQueries.category_path(@category)
+      page_context(:category, record: @category, path: path, pagination: pagination,
+        breadcrumbs: [ { name: OpenBlog.config.blog_title, path: OpenBlog.mount_path }, { name: @category.name, path: path } ])
+    end
+  end
+end

data/app/controllers/open_blog/errors_controller.rb

@@ -0,0 +1,7 @@
+module OpenBlog
+  class ErrorsController < ApplicationController
+    def not_found
+      render_not_found
+    end
+  end
+end

data/app/controllers/open_blog/feeds_controller.rb

@@ -0,0 +1,22 @@
+module OpenBlog
+  class FeedsController < ApplicationController
+    def show
+      scope = ReaderQueries.posts
+      if params[:slug]
+        @category = Category.find_by!(slug: params[:slug])
+        scope = scope.where(category_id: @category.id)
+      end
+      @posts = scope.limit(OpenBlog.config.feed_size).to_a
+      @base_url = origin.chomp("/")
+      @feed_title = @category&.name || OpenBlog.config.blog_title
+      @feed_updated_at = @posts.map { |post| ReaderDates.feed_updated_at(post) }.max || Time.current
+      expires_in 1.hour, public: true
+      if request.format.json?
+        feed = JsonFeed.new(posts: @posts, base_url: @base_url, feed_path: request.path, title: @feed_title, category: @category)
+        render body: feed.to_json, content_type: "application/feed+json"
+      else
+        render "open_blog/feeds/atom", formats: [ :xml ], content_type: "application/atom+xml", layout: false
+      end
+    end
+  end
+end

data/app/controllers/open_blog/mcp_controller.rb

@@ -0,0 +1,38 @@
+require "uri"
+
+module OpenBlog
+  class McpController < Api::V1::BaseController
+    prepend_before_action :check_transport!
+
+    def create
+      server = ::MCP::Server.new(name: "open_blog", tools: Mcp.tools,
+        server_context: { actor: actor, base_url: request.base_url })
+      result = server.handle_json(request.raw_post)
+      result.nil? ? head(:accepted) : render(body: result, content_type: "application/json")
+    end
+
+    private
+
+    def check_transport!
+      prevent_caching!
+      raise Error::NotFound unless OpenBlog.config.mcp.enabled
+      unless request.post?
+        response.headers["Allow"] = "POST"
+        return head :method_not_allowed
+      end
+      return unless request.headers.key?("Origin")
+      origin = normalized_origin(request.headers["Origin"])
+      allowed = [ request.base_url, OpenBlog.config.public_base_url ].compact.map { |value| normalized_origin(value) }
+      raise Error::ScopeRequired.new(details: [ "origin" ]) unless origin && allowed.include?(origin)
+    end
+
+    def normalized_origin(value)
+      uri = URI.parse(value.to_s)
+      return unless uri.is_a?(URI::HTTP) && uri.host.present? && uri.userinfo.nil? &&
+        uri.query.nil? && uri.fragment.nil? && [ "", "/" ].include?(uri.path)
+      [ uri.scheme.downcase, uri.host.downcase, uri.port ]
+    rescue URI::InvalidURIError
+      nil
+    end
+  end
+end

data/app/controllers/open_blog/media_controller.rb

@@ -0,0 +1,20 @@
+module OpenBlog
+  class MediaController < ApplicationController
+    include ActiveStorage::SetCurrent
+    rescue_from ActiveStorage::FileNotFoundError, with: :render_not_found
+
+    def show
+      image = Image.find_by!(sha256: params[:sha256])
+      raise NotFound unless image.file.attached?
+      if OpenBlog.config.image_delivery == :proxy
+        bytes = image.file.download
+        expires_in 365.days, public: true, immutable: true
+        send_data bytes, type: image.content_type, filename: image.filename, disposition: "inline"
+      else
+        lifetime = [ ActiveStorage.service_urls_expire_in.to_i, 365.days.to_i ].min
+        expires_in lifetime, public: true
+        redirect_to image.file.blob.url(expires_in: lifetime, disposition: "inline"), allow_other_host: true
+      end
+    end
+  end
+end

data/app/controllers/open_blog/pages_controller.rb

@@ -0,0 +1,12 @@
+module OpenBlog
+  class PagesController < ApplicationController
+    before_action :require_html
+
+    def show
+      @page = Page.published.find_by!(slug: params[:slug])
+      raise NotFound if OpenBlog.config.policy_urls[@page.kind.to_sym].present?
+      page_context(:page, record: @page, path: @page.path,
+        breadcrumbs: [ { name: OpenBlog.config.blog_title, path: OpenBlog.mount_path }, { name: @page.title, path: @page.path } ])
+    end
+  end
+end

data/app/controllers/open_blog/posts_controller.rb

@@ -0,0 +1,57 @@
+module OpenBlog
+  class PostsController < ApplicationController
+    before_action :require_html, only: :index
+    before_action :require_post_format, only: :show
+    after_action :count_page_view, only: :show
+
+    def index
+      @featured = ReaderQueries.featured
+      scope = ReaderQueries.posts
+      scope = scope.where.not(id: @featured.id) if @featured
+      pagination = paginate(scope)
+      @posts = pagination.records
+      load_sidebar
+      page_context(:index, path: OpenBlog.mount_path, pagination: pagination,
+        breadcrumbs: [ { name: OpenBlog.config.blog_title, path: OpenBlog.mount_path } ])
+    end
+
+    def show
+      @post = ReaderQueries.posts.find_by(slug: params[:slug])
+      unless @post
+        redirect = Redirect.find_by(old_path: "#{OpenBlog.mount_path.chomp('/')}/#{params[:slug]}")
+        raise NotFound unless redirect
+        return redirect_to(redirect.new_path, status: :moved_permanently, allow_other_host: true) if redirect.new_path
+        request.format = :html
+        @posts = ReaderQueries.posts.limit(6).to_a
+        page_context(:gone, path: request.path)
+        return render "open_blog/errors/not_found", status: :gone, formats: [ :html ], content_type: "text/html"
+      end
+      if request.format == Mime[:md]
+        canonical = @post.canonical_url.presence || @post.url(base: origin)
+        response.headers["X-Robots-Tag"] = "noindex"
+        response.headers["Link"] = "<#{canonical}>; rel=\"canonical\""
+        return render plain: MarkdownView.render(@post, base_url: origin), content_type: "text/markdown"
+      end
+      @related_posts = ReaderQueries.related(@post)
+      @related_cache_key = ReaderQueries.related_cache_key(@post, @related_posts)
+      crumbs = [ { name: OpenBlog.config.blog_title, path: OpenBlog.mount_path } ]
+      crumbs << { name: @post.category.name, path: ReaderQueries.category_path(@post.category) } if @post.category
+      crumbs << { name: @post.title, path: @post.path }
+      page_context(:post, record: @post, path: @post.path, breadcrumbs: crumbs)
+    end
+
+    private
+
+    def count_page_view
+      return unless @post && request.format.html? && [ 200, 304 ].include?(response.status)
+      PageViews.count!(@post, request)
+    rescue StandardError => error
+      Rails.logger.warn("OpenBlog page view count failed (#{error.class})")
+    end
+
+    def require_post_format
+      raise NotFound unless params[:format].blank? || %w[html md].include?(params[:format])
+      request.format = params[:format] == "md" ? :md : :html
+    end
+  end
+end

data/app/controllers/open_blog/previews_controller.rb

@@ -0,0 +1,35 @@
+module OpenBlog
+  class PreviewsController < ActionController::Base
+    include ReaderController
+    before_action :preview_headers
+    before_action :require_html
+
+    def show
+      @post = Post.find_by_preview_token(params[:token])
+      raise NotFound unless @post && (@post.previewable? || @post.published?)
+      return redirect_to(@post.path, status: :found) if @post.published?
+      @related_posts = ReaderQueries.related(@post)
+      @related_cache_key = ReaderQueries.related_cache_key(@post, @related_posts)
+      page_context(:preview, record: @post, path: @post.path,
+        breadcrumbs: [ { name: OpenBlog.config.blog_title, path: OpenBlog.mount_path }, { name: @post.title, path: @post.path } ])
+      render "open_blog/posts/show"
+    end
+
+    private
+
+    def preview_headers
+      request.delete_header("HTTP_IF_NONE_MATCH")
+      request.delete_header("HTTP_IF_MODIFIED_SINCE")
+      response.headers["Cache-Control"] = "no-store"
+      response.headers["X-Robots-Tag"] = "noindex, nofollow"
+      response.headers["Referrer-Policy"] = "no-referrer"
+    end
+
+    def render_not_found
+      preview_headers
+      request.format = :html
+      page_context(:preview_expired, path: "#{OpenBlog.mount_path.chomp('/')}/preview")
+      render "open_blog/errors/preview_expired", status: :not_found, formats: [ :html ], content_type: "text/html"
+    end
+  end
+end

data/app/controllers/open_blog/search_controller.rb

@@ -0,0 +1,32 @@
+module OpenBlog
+  class SearchController < ApplicationController
+    before_action :limit_search_requests
+
+    def show
+      raise NotFound if params[:format].present? && !%w[html json].include?(params[:format])
+      response.headers["X-Robots-Tag"] = "noindex"
+      @query = params[:q].is_a?(String) ? params[:q].strip : ""
+      scope = Search.call(@query, scope: ReaderQueries.posts)
+      if params[:format] == "json"
+        render json: scope.limit(8).map { |post| { title: post.title, url: post.url(base: origin), description: post.description } }
+      else
+        request.format = :html
+        pagination = paginate(scope)
+        @posts = pagination.records
+        load_sidebar
+        path = "#{OpenBlog.mount_path.chomp('/')}/search?#{ { q: @query }.to_query }"
+        page_context(:search, path: path, pagination: pagination,
+          breadcrumbs: [ { name: OpenBlog.config.blog_title, path: OpenBlog.mount_path }, { name: I18n.t("open_blog.search.heading"), path: path } ])
+      end
+    end
+
+    private
+
+    def limit_search_requests
+      options = { to: OpenBlog.config.search_rate_limit.fetch(:to), within: OpenBlog.config.search_rate_limit.fetch(:within),
+        by: -> { request.remote_ip }, with: -> { head :too_many_requests }, store: OpenBlog.config.rate_limit_store, name: nil }
+      options[:scope] = "open_blog/search" if method(:rate_limiting).parameters.any? { |kind, name| kind == :keyreq && name == :scope }
+      rate_limiting(**options)
+    end
+  end
+end

data/app/controllers/open_blog/series_controller.rb

@@ -0,0 +1,15 @@
+module OpenBlog
+  class SeriesController < ApplicationController
+    before_action :require_html
+
+    def show
+      @series = Series.find_by!(slug: params[:slug])
+      pagination = paginate(ReaderQueries.series_posts(@series))
+      @posts = pagination.records
+      load_sidebar
+      path = ReaderQueries.series_path(@series)
+      page_context(:series, record: @series, path: path, pagination: pagination,
+        breadcrumbs: [ { name: OpenBlog.config.blog_title, path: OpenBlog.mount_path }, { name: @series.name, path: path } ])
+    end
+  end
+end

data/app/controllers/open_blog/sitemaps_controller.rb

@@ -0,0 +1,10 @@
+module OpenBlog
+  class SitemapsController < ApplicationController
+    def show
+      raise NotFound unless OpenBlog.config.serve_sitemap
+      @entries = OpenBlog.sitemap_entries(base_url: origin)
+      expires_in 1.hour, public: true
+      render "open_blog/sitemaps/show", formats: [ :xml ], content_type: "application/xml", layout: false
+    end
+  end
+end

data/app/controllers/open_blog/tags_controller.rb

@@ -0,0 +1,15 @@
+module OpenBlog
+  class TagsController < ApplicationController
+    before_action :require_html
+
+    def show
+      @tag = Tag.find_by!(slug: params[:slug])
+      pagination = paginate(ReaderQueries.posts.where(id: Tagging.where(tag_id: @tag.id).select(:post_id)))
+      @posts = pagination.records
+      load_sidebar
+      path = ReaderQueries.tag_path(@tag)
+      page_context(:tag, record: @tag, path: path, pagination: pagination,
+        breadcrumbs: [ { name: OpenBlog.config.blog_title, path: OpenBlog.mount_path }, { name: @tag.name, path: path } ])
+    end
+  end
+end

data/app/helpers/open_blog/content_helper.rb

@@ -0,0 +1,79 @@
+module OpenBlog
+  module ContentHelper
+    include FaqHelper
+
+    def open_blog_post_content(_post, &block)
+      tag.article(class: "ob-post-content", data: { open_blog_content: true }, &block)
+    end
+
+    def open_blog_title(post)
+      tag.h1(post.title, class: "ob-post-title")
+    end
+
+    def open_blog_byline(post)
+      tag.div(class: "ob-byline") do
+        safe_join([ link_to(post.author_name, open_blog_list_path(:author, post.author), class: "ob-byline-author"), open_blog_dates(post) ], " ")
+      end
+    end
+
+    def open_blog_cover(post)
+      return "".html_safe unless post.cover_image
+      image = post.cover_image
+      tag.figure(class: "ob-cover") do
+        tag.img(src: image.path, alt: post.cover_alt.to_s, width: image.width, height: image.height)
+      end
+    end
+
+    def open_blog_card_image(post)
+      image = post.cover_image
+      return tag.div(class: "ob-card-placeholder", aria: { hidden: true }) unless image
+      source = image.file.attached? ? main_app.url_for(image.file.variant(resize_to_fill: [ 640, 360 ])) : image.path
+      tag.img(src: source, alt: post.cover_alt.to_s, width: 640, height: 360, loading: "lazy", class: "ob-card-image")
+    end
+
+    def open_blog_avatar(author, name: nil)
+      name ||= author.name
+      if author.avatar.attached?
+        tag.img(src: main_app.url_for(author.avatar.variant(resize_to_fill: [ 80, 80 ])), alt: name, width: 40, height: 40, class: "ob-avatar", loading: "lazy")
+      else
+        tag.span(name.to_s.chars.first(2).join.upcase, class: "ob-avatar ob-avatar--initials", aria: { hidden: true })
+      end
+    end
+
+    def open_blog_body(post)
+      tag.div(Renderer.render(post, cache: @open_blog_page&.kind != :preview), class: "ob-prose", data: { open_blog_body: true })
+    end
+
+    def open_blog_reading_time(post)
+      tag.span(open_blog_translate("reading_time", count: post.reading_time_minutes || 1), class: "ob-reading-time")
+    end
+
+    def open_blog_toc(post)
+      fragment = Nokogiri::HTML5.fragment(Renderer.render(post, cache: @open_blog_page&.kind != :preview))
+      headings = fragment.css("h2, h3")
+      has_faq = post.faq_list.any?
+      return "".html_safe if headings.length + (has_faq ? 1 : 0) < 3
+      items = headings.map do |heading|
+        text = heading.dup
+        text.css(".ob-heading-anchor").remove
+        tag.li(link_to(text.text, "##{heading['id']}"), class: "ob-toc-item ob-toc-item--#{heading.name}")
+      end
+      if has_faq
+        items << tag.li(link_to(open_blog_translate("faq.heading"), "##{open_blog_faq_section_id(post, body: fragment)}"), class: "ob-toc-item ob-toc-item--h2")
+      end
+      tag.nav(class: "ob-toc", aria: { label: open_blog_translate("navigation.toc") }, data: { controller: "open-blog--toc" }) do
+        safe_join([ tag.h2(open_blog_translate("navigation.toc")), tag.ol(safe_join(items)) ])
+      end
+    end
+
+    def open_blog_breadcrumbs(page = nil)
+      page = open_blog_page(page)
+      tag.nav(class: "ob-breadcrumbs", aria: { label: open_blog_translate("navigation.breadcrumbs") }) do
+        tag.ol(safe_join(page.breadcrumbs.each_with_index.map do |crumb, index|
+          last = index == page.breadcrumbs.length - 1
+          tag.li(last ? tag.span(crumb[:name], aria: { current: "page" }) : link_to(crumb[:name], crumb[:path]))
+        end))
+      end
+    end
+  end
+end

data/app/helpers/open_blog/dates_helper.rb

@@ -0,0 +1,18 @@
+module OpenBlog
+  module DatesHelper
+    def open_blog_dates(post)
+      published = ReaderDates.published_at(post)
+      modified = ReaderDates.modified_at(post)
+      dates = []
+      dates << open_blog_date(published, :published) if published
+      dates << open_blog_date(modified, :updated) if modified && (!published || modified > published)
+      safe_join(dates, " ")
+    end
+
+    def open_blog_date(time, label)
+      tag.span(class: "ob-date ob-date--#{label}") do
+        safe_join([ tag.span(open_blog_translate("dates.#{label}")), tag.time(I18n.l(time.to_date, format: :long, locale: OpenBlog.config.locale), datetime: time.iso8601) ], " ")
+      end
+    end
+  end
+end

data/app/helpers/open_blog/faq_helper.rb

@@ -0,0 +1,59 @@
+require "uri"
+
+module OpenBlog
+  module FaqHelper
+    def open_blog_faq(post)
+      entries = post.faq_list
+      return "".html_safe if entries.empty?
+      heading = tag.h2(open_blog_translate("faq.heading"), id: open_blog_faq_section_id(post))
+      items = entries.map do |entry|
+        question = tag.h3(ERB::Util.html_escape(String.new(entry[:question].to_s)))
+        paragraphs = entry[:answer].to_s.gsub(/\r\n?/, "\n").split(/\n[\t ]*\n+/).map do |paragraph|
+          tag.p(safe_join(paragraph.split("\n", -1).map { |line| open_blog_faq_links(line) }, safe_join([ tag.br, "\n" ])))
+        end
+        tag.div(safe_join([ question, *paragraphs ], "\n"), class: "ob-faq-entry", data: { open_blog_faq_entry: true })
+      end
+      tag.section(safe_join([ heading, *items ], "\n"), class: "ob-faq", data: { open_blog_faq: true })
+    end
+
+    def open_blog_faq_section_id(post, body: nil)
+      body ||= Nokogiri::HTML5.fragment(Renderer.render(post, cache: @open_blog_page&.kind != :preview))
+      used = body.css("[id]").map { |node| node["id"] }
+      identifier, suffix = "open-blog-faq", 0
+      while used.include?(identifier)
+        suffix += 1
+        identifier = "open-blog-faq-#{suffix}"
+      end
+      identifier
+    end
+
+    private
+
+    def open_blog_faq_links(line)
+      line = String.new(line)
+      parts, offset = [], 0
+      line.to_enum(:scan, %r{https?://[^\s<>"']+}i).each do
+        match = Regexp.last_match
+        parts << line[offset...match.begin(0)]
+        candidate = match[0]
+        url = candidate.sub(/[.,;:!?]+\z/, "")
+        { ")" => "(", "]" => "[", "}" => "{" }.each do |closing, opening|
+          url = url.chop while url.end_with?(closing) && url.count(closing) > url.count(opening)
+        end
+        url = url.sub(/[.,;:!?]+\z/, "")
+        parts << (open_blog_faq_http_url?(url) ? link_to(url, url, rel: "noopener") : url)
+        parts << candidate[url.length..]
+        offset = match.end(0)
+      end
+      parts << line[offset..]
+      safe_join(parts)
+    end
+
+    def open_blog_faq_http_url?(url)
+      parsed = URI.parse(url)
+      %w[http https].include?(parsed.scheme&.downcase) && parsed.host.present?
+    rescue URI::InvalidURIError
+      false
+    end
+  end
+end

data/app/helpers/open_blog/head_helper.rb

@@ -0,0 +1,75 @@
+module OpenBlog
+  module HeadHelper
+    include ThemeHelper
+
+    def open_blog_lang
+      OpenBlog.config.locale.to_s.tr("_", "-")
+    end
+
+    def open_blog_head(resource = nil)
+      page = open_blog_page(resource)
+      title = open_blog_page_title(page)
+      description = open_blog_page_description(page)
+      canonical = open_blog_canonical_url(page)
+      tags = [ tag.title(title), tag.meta(name: "description", content: description), tag.link(rel: "canonical", href: canonical),
+        tag.meta(name: "robots", content: open_blog_robots(page)), tag.meta(name: "viewport", content: "width=device-width, initial-scale=1"),
+        tag.meta(property: "og:title", content: title), tag.meta(property: "og:description", content: description),
+        tag.meta(property: "og:type", content: %i[post preview].include?(page.kind) ? "article" : "website"), tag.meta(property: "og:url", content: canonical),
+        tag.meta(property: "og:site_name", content: OpenBlog.config.site_name), tag.meta(name: "twitter:card", content: "summary_large_image") ]
+      image = open_blog_social_image_url(page)
+      tags << tag.meta(property: "og:image", content: image) if image
+      if %i[post preview].include?(page.kind)
+        { published_time: ReaderDates.published_at(page.record), modified_time: ReaderDates.modified_at(page.record) }.each do |name, time|
+          tags << tag.meta(property: "article:#{name}", content: time.iso8601) if time
+        end
+      end
+      feed_path = page.kind == :category ? "#{page.path}/feed.xml" : "#{open_blog_index_path.chomp('/')}/feed.xml"
+      tags << tag.link(rel: "alternate", type: "application/atom+xml", title: OpenBlog.config.blog_title, href: open_blog_absolute_url(feed_path, base: page.base_url))
+      tags << tag.link(rel: "alternate", type: "application/feed+json", title: OpenBlog.config.blog_title,
+        href: open_blog_absolute_url(feed_path.sub(/\.xml\z/, ".json"), base: page.base_url))
+      tags << open_blog_theme_colors
+      safe_join(tags, "\n")
+    end
+
+    def open_blog_page_title(page = open_blog_page)
+      title = case page.kind
+      when :post, :preview then page.record.search_title.presence || page.record.title
+      when :page then page.record.title
+      when :search then open_blog_translate("search.heading")
+      when :category, :author, :series then page.record.name
+      when :tag then open_blog_translate("titles.tag", name: page.record.name)
+      when :not_found, :gone, :preview_expired then open_blog_translate("titles.#{page.kind}")
+      else OpenBlog.config.blog_title
+      end
+      title = open_blog_translate("titles.page", title: title, page: page.page_number) if page.page_number > 1
+      "#{title}#{OpenBlog.config.title_suffix}"
+    end
+
+    def open_blog_page_description(page = open_blog_page)
+      record = page.record
+      return record.search_description.presence || record.description.to_s if %i[post preview].include?(page.kind)
+      return record.title if page.kind == :page
+      return open_blog_translate("search.description") if page.kind == :search
+      paginated = page.page_number > 1
+      if !paginated
+        return OpenBlog.config.blog_tagline if page.kind == :index && OpenBlog.config.blog_tagline.present?
+        return record.description if %i[category tag series].include?(page.kind) && record.respond_to?(:description) && record.description.present?
+        return record.bio if page.kind == :author && record.bio.present?
+      end
+      kind = %i[index category tag author series].include?(page.kind) ? page.kind : :index
+      open_blog_translate("descriptions.#{kind}#{'_page' if paginated}", site_name: OpenBlog.config.site_name, name: record&.try(:name), page: page.page_number)
+    end
+
+    def open_blog_robots(page = open_blog_page)
+      return "noindex, nofollow" if %i[not_found gone preview preview_expired].include?(page.kind)
+      return "index, follow" if %i[index post page].include?(page.kind)
+      primary = OpenBlog.config.primary_list_type.to_s.singularize.to_sym
+      page.kind == primary ? "index, follow" : "noindex, follow"
+    end
+
+    def open_blog_social_image_url(page = open_blog_page)
+      image = %i[post preview].include?(page.kind) && (page.record.social_image || page.record.cover_image)
+      open_blog_absolute_url(image ? image.path : OpenBlog.config.default_social_image_url, base: page.base_url)
+    end
+  end
+end

data/app/helpers/open_blog/icons_helper.rb

@@ -0,0 +1,10 @@
+module OpenBlog
+  module IconsHelper
+    ICONS = %w[sun moon monitor share copy check link].freeze
+
+    def open_blog_icon(name)
+      raise ArgumentError, "Unknown icon: #{name}" unless ICONS.include?(name.to_s)
+      render partial: "open_blog/icons/#{name}", formats: [ :svg ]
+    end
+  end
+end

data/app/helpers/open_blog/notices_helper.rb

@@ -0,0 +1,47 @@
+module OpenBlog
+  module NoticesHelper
+    def open_blog_notices(post)
+      notices = []
+      label = LabelPolicy.for(post)
+      notices << tag.p(open_blog_translate("notices.#{label}"), class: "ob-notice ob-notice--ai") unless label == :none
+      if open_blog_connection_declaration(post)&.third_party_paid?
+        notices << tag.p(open_blog_translate("notices.paid"), class: "ob-notice ob-notice--paid")
+      end
+      safe_join(notices)
+    end
+
+    def open_blog_disclosure(post)
+      declaration = open_blog_connection_declaration(post)
+      return "".html_safe unless declaration
+      content = if declaration.connections.empty?
+        tag.p(open_blog_translate("notices.connections_none"))
+      else
+        tag.ul(safe_join(declaration.connections.map { |entry| tag.li("#{entry['party']}: #{entry['relation']}") }))
+      end
+      tag.aside(class: "ob-disclosure ob-notice", aria: { label: open_blog_translate("notices.disclosure") }) do
+        safe_join([ tag.h2(open_blog_translate("notices.disclosure")), content ])
+      end
+    end
+
+    def open_blog_corrections(post)
+      rows = post.publications.where(entry_type: "correction").where("occurred_at <= ?", Time.current).order(:occurred_at, :id)
+      safe_join(rows.map do |entry|
+        tag.aside(class: "ob-correction ob-notice") do
+          safe_join([ tag.strong(open_blog_translate("notices.correction")),
+            tag.time(I18n.l(entry.occurred_at.to_date, format: :long, locale: OpenBlog.config.locale), datetime: entry.occurred_at.iso8601),
+            tag.p(entry.note) ], " ")
+        end
+      end)
+    end
+
+    def open_blog_responsible_party_link
+      url = OpenBlog.policy_url(:responsible_party)
+      return "".html_safe unless url.present? && Renderer::Sanitizer.safe_url?(url)
+      link_to(open_blog_translate("navigation.responsible_party"), url, class: "ob-responsible-party")
+    end
+
+    def open_blog_connection_declaration(post)
+      post.connection_declarations.order(id: :desc).first
+    end
+  end
+end

data/app/helpers/open_blog/pagination_helper.rb

@@ -0,0 +1,18 @@
+module OpenBlog
+  module PaginationHelper
+    def open_blog_paginate(pagination = nil)
+      page = open_blog_page
+      pagination ||= page.pagination
+      return "".html_safe unless pagination && pagination.total_pages > 1
+      links = (1..pagination.total_pages).map do |number|
+        if number == pagination.page
+          tag.span(number, class: "ob-pagination-current", aria: { current: "page" })
+        else
+          path = page.path_for(number)
+          link_to(number, path, class: "ob-pagination-link", aria: { label: open_blog_translate("navigation.page", page: number) })
+        end
+      end
+      tag.nav(safe_join(links, " "), class: "ob-pagination", aria: { label: open_blog_translate("navigation.pagination") })
+    end
+  end
+end