open_blog 0.1.0

data/lib/open_blog/adopt.rb

@@ -0,0 +1,159 @@
+module OpenBlog
+  class Adopt
+    autoload :Contract, "open_blog/adopt/contract"
+    autoload :Snapshot, "open_blog/adopt/snapshot"
+
+    def self.call(attributes, actor:, now: Time.current)
+      contract = Contract.new(attributes, now: now)
+      prepared = ImageResolution.prepare_inputs(contract.attributes)
+      body_images = ImageResolution.prepare(attributes: contract.content)
+      current = nil
+      result = nil
+      Post.transaction(requires_new: true) do
+        baseline = Baseline.find_by(contract.attributes.slice(:source_system, :source_id))
+        resolved = baseline ? baseline.post : PostIdentity.resolve(contract.attributes.slice(:external_id, :slug))
+        current = resolved.persisted? ? Post.lock.find(resolved.id) : resolved
+        result = RedirectTarget.synchronize do
+          new(current, contract, prepared, actor: actor, now: now, body_images: body_images).call
+        end
+        raise ActiveRecord::Rollback if contract.dry_run?
+      end
+      result
+    rescue Error => error
+      failure(current, error, contract)
+    rescue ActiveRecord::RecordInvalid => error
+      collision = error.record.is_a?(Baseline) && %i[source_id post_id].any? do |field|
+        error.record.errors.details[field].any? { |detail| detail[:error] == :taken }
+      end
+      refusal = collision ? Error::IdentityConflict.new : Error::ValidationFailed.new(details: error.record.errors.attribute_names.map(&:to_s))
+      failure(current, refusal, contract)
+    rescue ActiveRecord::RecordNotFound
+      failure(current, Error::NotFound.new, contract)
+    rescue ActiveRecord::RecordNotUnique
+      failure(current, Error::IdentityConflict.new, contract)
+    end
+
+    def self.failure(post, error, contract)
+      result = Operation.failure(post, error)
+      Result.new(**result.to_h.merge(dry_run: contract&.dry_run? || false))
+    end
+    private_class_method :failure
+
+    def initialize(post, contract, prepared, actor:, now:, body_images:)
+      @post, @contract, @prepared, @actor, @now = post, contract, prepared, actor, now
+      @body_images = body_images
+      @created = post.new_record?
+    end
+
+    def call
+      baseline = @post.baseline if @post.persisted?
+      verify_identity(baseline)
+      previous = Snapshot.stored(@post, baseline, include_connections: @contract.connections.present?)
+      assign_candidate
+      redirects = @contract.redirects(default_date: baseline&.adopted_at&.to_date || @now.to_date, current_slug: @post.slug)
+      validate_redirects(redirects)
+      candidate = Snapshot.candidate(@post, @contract, redirects)
+      if previous == candidate
+        @post.reload
+        return result({ revision: "same", publication: nil, approval: nil, baseline: nil, redirects: 0 })
+      end
+      replace_records(baseline) if baseline
+      @prepared.each { |field, value| @post.public_send("#{field}=", value.persist(uploaded_by: @actor)) }
+      @body_images.materialize(@post, actor: @actor)
+      @post.status = "draft"
+      @post.publish_at = nil
+      @post.save!
+      fill_category_description
+      revision = @post.revisions.create!(identifier: @post.current_revision_identifier,
+        payload: RevisionPayload.new(@post).to_json, actor: @actor, created_at: @now)
+      @post.create_baseline!(**@contract.baseline, adopted_revision: revision, adopted_at: @now, adopted_by: @actor)
+      @post.publications.create!(revision: revision, entry_type: "adopted", occurred_at: @now, released_by: @actor)
+      if @contract.approval
+        @post.approvals.create!(**@contract.approval, revision: revision, recorded_by: @actor)
+      end
+      if @contract.connections && Snapshot.latest_connections(@post) != @contract.connections
+        @post.connection_declarations.create!(**@contract.connections, recorded_by: @actor, created_at: @now)
+      end
+      write_redirects(redirects)
+      published_at = @contract.baseline[:first_published_at] || @contract.baseline[:declared_first_published_at]
+      @post.update_columns(status: "published", public_revision_id: revision.id, published_at: published_at,
+        modified_at: @contract.baseline[:last_modified_at] || published_at)
+      @post.association(:public_revision).reset
+      result({ revision: "new", publication: "adopted", approval: @contract.approval&.fetch(:kind),
+        baseline: baseline ? "replaced" : "new", redirects: redirects.length })
+    end
+
+    private
+
+    def verify_identity(baseline)
+      if baseline
+        if !@post.published? || @post.publications.where.not(entry_type: "adopted").exists? ||
+            Redirect.where(post: @post).where.not(source: "adoption").exists?
+          raise Error::AlreadyChangedInGem
+        end
+        unless baseline.source_system == @contract.attributes[:source_system] && baseline.source_id == @contract.attributes[:source_id]
+          raise Error::IdentityConflict
+        end
+      elsif @post.persisted? && (@post.public_revision_id || @post.revisions.exists? || @post.publications.exists? || @post.approvals.exists? || @post.connection_declarations.exists?)
+        raise Error::IdentityConflict
+      end
+    end
+
+    def assign_candidate
+      attributes = @contract.content.except(*@prepared.keys)
+      PostAttributes.assign(@post, attributes, actor: @actor, now: @now)
+      @prepared.each { |field, value| @post.public_send("#{field}=", value.image) }
+      @post.status = "published"
+      description = @contract.attributes[:category_description]
+      @post.category.description = description if @post.category && @post.category.description.blank? && description.present?
+      @body_images.preview(@post)
+      @post.send(:compute_derived)
+      @post.valid?
+      raise ActiveRecord::RecordInvalid, @post if @post.errors.any?
+    end
+
+    def fill_category_description
+      @post.category.save! if @post.category&.changed?
+    end
+
+    def replace_records(baseline)
+      revision_id = baseline.adopted_revision_id
+      @post.update_columns(public_revision_id: nil)
+      @post.association(:public_revision).reset
+      @post.approvals.where(revision_id: revision_id).delete_all
+      @post.publications.where(entry_type: "adopted").delete_all
+      Baseline.where(id: baseline.id).delete_all
+      @post.association(:baseline).reset
+      @post.revisions.where(id: revision_id).delete_all
+    end
+
+    def validate_redirects(redirects)
+      redirects.each do |entry|
+        slug = entry[:old_path].delete_prefix("#{OpenBlog.mount_path.chomp('/')}/")
+        owner = Redirect.find_by(old_path: entry[:old_path])
+        occupied = Post.where(slug: slug)
+        occupied = occupied.where.not(id: @post.id) if @post.persisted?
+        if (Post::RESERVED_SLUGS + OpenBlog.config.route_segments.values).include?(slug) || occupied.exists? ||
+            (owner && (owner.post_id != @post.id || owner.source != "adoption"))
+          raise Error::SlugReserved
+        end
+      end
+    end
+
+    def write_redirects(redirects)
+      Redirect.where(post: @post, source: "adoption").delete_all
+      redirects.each { |attributes| Redirect.create!(**attributes, post: @post, source: "adoption") }
+    end
+
+    def result(records)
+      if @contract.dry_run?
+        %i[author category series cover_image social_image public_revision baseline faqs tags revisions approvals publications connection_declarations rich_text_rich_body].each do |name|
+          @post.association(name).load_target
+        end
+      end
+      Result.new(post: @post, created: @created, records: records, label: LabelPolicy.for(@post),
+        findings: Findings.for(@post, context: { author_default_used: !@contract.attributes.key?(:author),
+          approval_incomplete: @contract.approval&.fetch(:facts_checked) == false }), dry_run: @contract.dry_run?)
+    end
+  end
+end

data/lib/open_blog/api_fields.rb

@@ -0,0 +1,40 @@
+module OpenBlog
+  module ApiFields
+    REPORT = %i[scope post page reach].freeze
+    POST_WRITE = (PostAttributes::CONTENT_FIELDS + PostAttributes::RECORD_FIELDS).freeze
+    POST_LIST = %i[status category tag author series q page per_page].freeze
+    POST_NESTED = {
+      author: %i[name type url], approval: %i[name facts_checked revision_identifier],
+      cover_image: %i[image_id signed_id url], social_image: %i[image_id signed_id url],
+      connections: %i[connections third_party_paid declared_by declared_on], faq: %i[question answer]
+    }.freeze
+    APPROVAL = %i[revision_identifier name facts_checked].freeze
+    CONNECTION = %i[connections third_party_paid declared_by declared_on].freeze
+    CATEGORY = %i[name slug description position].freeze
+    AUTHOR = %i[name slug type bio url profile_urls host_reference avatar].freeze
+    SERIES = %i[name slug description].freeze
+    REDIRECT = %i[old_path new_path occurred_on post_id].freeze
+    ADOPTION = (Adopt::Contract::CONTENT_FIELDS + Adopt::Contract::EXTRA_FIELDS).freeze
+    EXTRACTION = %i[body standalone_questions].freeze
+    PAGE = %i[page per_page].freeze
+    VIEWS = %i[from to].freeze
+    TOP_VIEWS = %i[days limit].freeze
+    SITE_PAGE = %i[title body status slug approved_by approved_on].freeze
+    IMAGE = %i[file url].freeze
+    REMOVE = %i[redirect_to].freeze
+
+    def self.validate_post_images!(attributes)
+      %i[cover_image social_image].each do |field|
+        value = attributes[field]
+        next if value.nil?
+        raise Error::ImageNotPermitted unless value.is_a?(Hash) && value.size == 1
+        if value.key?(:image_id)
+          raise Error::ImageNotPermitted unless value[:image_id].is_a?(Integer) && value[:image_id].positive?
+        else
+          key = value.keys.first
+          raise Error::ImageNotPermitted unless %i[signed_id url].include?(key) && value[key].is_a?(String)
+        end
+      end
+    end
+  end
+end

data/lib/open_blog/approve.rb

@@ -0,0 +1,18 @@
+module OpenBlog
+  class Approve
+    def self.call(post, revision_identifier:, name:, facts_checked:, actor:, now: Time.current)
+      Operation.run(post: post, actor: actor, now: now, context: { approval_incomplete: facts_checked == false }) do |current, _created|
+        raise Error::NotFound unless current.persisted?
+        unless name.is_a?(String) && name.present? && [ true, false ].include?(facts_checked)
+          raise Error::ApprovalIncomplete
+        end
+        revision = current.public_revision
+        raise Error::RevisionMismatch unless revision && revision.identifier == revision_identifier
+
+        current.approvals.create!(revision: revision, kind: "sent", reviewer_name: name,
+          facts_checked: facts_checked, approved_at: now, recorded_by: actor)
+        { revision: "same", publication: nil, approval: "sent" }
+      end
+    end
+  end
+end

data/lib/open_blog/authentication.rb

@@ -0,0 +1,18 @@
+module OpenBlog
+  module Authentication
+    def self.actor_for(request)
+      if (hook = OpenBlog.config.authenticate)
+        source = hook.call(request)
+        return unless source
+        scopes = source.respond_to?(:scopes) ? source.scopes : ApiToken::SCOPES
+        identity = source.respond_to?(:id) && source.id.present? ? source.id : source.name
+        return Actor.new(name: source.name, scopes: scopes, id: "hook:#{identity}")
+      end
+
+      match = /\ABearer (ob_[1-9A-HJ-NP-Za-km-z]{40})\z/.match(request.authorization.to_s)
+      return unless match
+      token = ApiToken.authenticate(match[1])
+      Actor.new(name: token.name, scopes: token.scopes, id: "token:#{token.id}") if token
+    end
+  end
+end

data/lib/open_blog/build_css.rb

@@ -0,0 +1,53 @@
+require "fileutils"
+require "open3"
+require "pathname"
+require "tmpdir"
+require "tailwindcss/ruby"
+
+module OpenBlog
+  class BuildCss
+    COMPILER_VERSION = "4.3.3"
+
+    def self.render
+      unless Gem.loaded_specs.fetch("tailwindcss-ruby").version.to_s == COMPILER_VERSION
+        raise ConfigurationError, "Build stylesheets with tailwindcss-ruby #{COMPILER_VERSION}"
+      end
+      Dir.mktmpdir("open-blog-css") do |directory|
+        input = Pathname(directory).join("input.css")
+        output = Pathname(directory).join("output.css")
+        input.write(<<~CSS)
+          @import "tailwindcss" source(none);
+          @import #{theme_root.join("theme.css").to_s.to_json};
+          @source #{Engine.root.join("lib/generators/open_blog/install/templates/views").to_s.to_json};
+        CSS
+        _stdout, stderr, status = Open3.capture3(Tailwindcss::Ruby.executable.to_s, "--input", input.to_s,
+          "--output", output.to_s, "--minify", chdir: Engine.root.to_s)
+        raise ConfigurationError, "Stylesheet build failed: #{stderr.strip}" unless status.success?
+        output.binread
+      end
+    end
+
+    def self.tokens
+      source = theme_root.join("theme.css").read
+      block = source.match(%r{/\* open-blog:tokens:start \*/(.*?)/\* open-blog:tokens:end \*/}m)
+      raise ConfigurationError, "The theme must contain its marked token block" unless block
+      "#{block[1].strip}\n"
+    end
+
+    def self.write(path: Engine.root.join("app/assets/builds/open_blog/blog.css"), tokens_path: theme_root.join("open_blog_theme.css"))
+      css = render
+      values = tokens
+      [ [ path, css ], [ tokens_path, values ] ].each do |destination, bytes|
+        destination = Pathname(destination)
+        FileUtils.mkdir_p(destination.dirname)
+        destination.binwrite(bytes)
+      end
+      Pathname(path)
+    end
+
+    def self.theme_root
+      Engine.root.join("lib/generators/open_blog/install/templates/theme")
+    end
+    private_class_method :theme_root
+  end
+end

data/lib/open_blog/configuration.rb

@@ -0,0 +1,185 @@
+require "rails"
+require "i18n"
+require "uri"
+require "active_support/core_ext/numeric/time"
+require "active_support/core_ext/numeric/bytes"
+require "open_blog/configuration_error"
+require "open_blog/page_views"
+
+module OpenBlog
+  class Configuration
+    class Mcp
+      attr_accessor :enabled, :max_page_size
+
+      def initialize
+        @enabled = true
+        @max_page_size = 50
+      end
+    end
+
+    attr_accessor :site_name, :public_base_url, :default_author, :publisher, :locale,
+      :blog_title, :blog_tagline, :layout, :parent_controller, :mount_path,
+      :route_segments, :posts_per_page, :primary_list_type, :call_to_action,
+      :default_social_image_url, :policy_urls, :sign_in_destinations, :body_formats,
+      :default_body_format, :markdown_hardbreaks, :ai_label, :require_approval,
+      :color_scheme, :syntax_theme, :feed_content, :feed_size, :serve_sitemap,
+      :page_views, :page_view_bot_pattern, :page_view_retention_days, :popular_posts,
+      :preview_expires_in, :storage_service, :image_delivery, :max_image_bytes,
+      :image_content_types, :image_fetch_policy, :api_rate_limit, :search_rate_limit
+    attr_reader :mcp, :authenticate, :before_publish
+    attr_writer :title_suffix, :rate_limit_store
+
+    def initialize
+      @locale = I18n.default_locale
+      @blog_title = "Blog".dup
+      @layout = "open_blog".dup
+      @parent_controller = "ActionController::Base".dup
+      @mount_path = "/blog".dup
+      @route_segments = { category: "category", tag: "tag", author: "author", series: "series" }.transform_values(&:dup)
+      @posts_per_page = 12
+      @primary_list_type = :categories
+      @policy_urls = { responsible_party: nil, corrections: nil, editorial: nil, ai_use: nil }
+      @body_formats = [ :markdown ]
+      @default_body_format = :markdown
+      @markdown_hardbreaks = true
+      @ai_label = :when_required
+      @require_approval = false
+      @color_scheme = :system
+      @syntax_theme = "github".dup
+      @feed_content = :summary
+      @feed_size = 20
+      @serve_sitemap = true
+      @page_views = true
+      @page_view_bot_pattern = PageViews::BOT_PATTERN
+      @popular_posts = { enabled: false, days: 30, limit: 5 }
+      @preview_expires_in = 7.days
+      @image_delivery = :redirect
+      @max_image_bytes = 10.megabytes
+      @image_content_types = %w[image/png image/jpeg image/webp image/gif image/avif].map(&:dup)
+      @image_fetch_policy = :public_only
+      @api_rate_limit = { to: 120, within: 1.minute }
+      @search_rate_limit = { to: 30, within: 1.minute }
+      @mcp = Mcp.new
+    end
+
+    def title_suffix
+      defined?(@title_suffix) ? @title_suffix : " — #{site_name}"
+    end
+
+    def rate_limit_store
+      defined?(@rate_limit_store) ? @rate_limit_store : Rails.cache
+    end
+
+    def authenticate=(hook)
+      validate_hook!(:authenticate, hook, 1)
+      @authenticate = hook
+    end
+
+    def before_publish=(hook)
+      validate_hook!(:before_publish, hook, 2)
+      @before_publish = hook
+    end
+
+    def validate!
+      %i[site_name default_author publisher].each do |key|
+        invalid!(key, "is required") if public_send(key).nil?
+      end
+      invalid!(:public_base_url, "is required in production") if Rails.env.production? && public_base_url.nil?
+      validate_structure!
+    end
+
+    def validate_structure!
+      invalid!(:site_name, "must be a nonblank string") unless site_name.nil? || nonblank_string?(site_name)
+      validate_identity!(:default_author, default_author)
+      validate_identity!(:publisher, publisher)
+      if default_author && !%i[person organization].include?(default_author[:type])
+        invalid!(:default_author, "type must be :person or :organization")
+      end
+      validate_base_url! unless public_base_url.nil?
+      unless body_formats.is_a?(Array) && body_formats.any? && (body_formats - %i[markdown rich_text]).empty?
+        invalid!(:body_formats, "must be a nonempty array containing :markdown or :rich_text")
+      end
+      invalid!(:default_body_format, "must be enabled in body_formats") unless body_formats.include?(default_body_format)
+      preview_duration
+      validate_view_settings!
+      invalid!(:mcp, "enabled must be true or false") unless [ true, false ].include?(mcp.enabled)
+      invalid!(:mcp, "max_page_size must be a positive integer") unless mcp.max_page_size.is_a?(Integer) && mcp.max_page_size.positive?
+      self
+    end
+
+    def preview_duration
+      value = preview_expires_in
+      unless (value.is_a?(Numeric) || value.is_a?(ActiveSupport::Duration)) && value.to_f.finite? && value.to_f.positive?
+        invalid!(:preview_expires_in, "must be a positive finite duration")
+      end
+      value.to_f
+    end
+
+    private
+
+    def validate_view_settings!
+      invalid!(:page_views, "must be true or false") unless [ true, false ].include?(page_views)
+      invalid!(:page_view_bot_pattern, "must be a regular expression") unless page_view_bot_pattern.is_a?(Regexp)
+      unless page_view_retention_days.nil? || (page_view_retention_days.is_a?(Integer) && page_view_retention_days.positive?)
+        invalid!(:page_view_retention_days, "must be nil or a positive integer")
+      end
+      unless popular_posts.is_a?(Hash) && [ true, false ].include?(popular_posts[:enabled])
+        invalid!(:popular_posts, "must include an enabled boolean")
+      end
+      { days: 36500, limit: 100 }.each do |key, maximum|
+        value = popular_posts.fetch(key, key == :days ? 30 : 5)
+        invalid!(:popular_posts, "#{key} must be an integer from 1 to #{maximum}") unless value.is_a?(Integer) && value.between?(1, maximum)
+      end
+    end
+
+    def validate_identity!(key, identity)
+      return if identity.nil?
+      unless identity.is_a?(Hash) && nonblank_string?(identity[:name])
+        invalid!(key, "must be a hash with a nonblank name")
+      end
+      %i[url logo_url].each do |field|
+        next if identity[field].nil?
+        invalid!(key, "#{field} must be an absolute HTTP(S) URL") unless http_url?(identity[field])
+      end
+    end
+
+    def validate_base_url!
+      unless http_url?(public_base_url)
+        invalid!(:public_base_url, "must be an absolute HTTP(S) origin")
+      end
+      uri = URI.parse(public_base_url)
+      unless [ "", "/" ].include?(uri.path) && uri.query.nil? && uri.fragment.nil?
+        invalid!(:public_base_url, "must contain only the scheme, host and optional port")
+      end
+    end
+
+    def http_url?(value)
+      return false unless value.is_a?(String)
+      uri = URI.parse(value)
+      uri.is_a?(URI::HTTP) && !uri.host.to_s.empty? && uri.userinfo.nil?
+    rescue URI::InvalidURIError
+      false
+    end
+
+    def nonblank_string?(value)
+      value.is_a?(String) && !value.strip.empty?
+    end
+
+    def validate_hook!(name, hook, argument_count)
+      return if hook.nil?
+      invalid!(name, "must be callable") unless hook.respond_to?(:call)
+      parameters = hook.is_a?(Proc) || hook.is_a?(Method) ? hook.parameters : hook.method(:call).parameters
+      required = parameters.count { |kind, _| kind == :req }
+      capacity = parameters.count { |kind, _| %i[req opt].include?(kind) }
+      rest = parameters.any? { |kind, _| kind == :rest }
+      keywords = parameters.any? { |kind, _| kind == :keyreq }
+      unless required <= argument_count && (rest || capacity >= argument_count) && !keywords
+        invalid!(name, "must accept #{argument_count} positional arguments without required keywords")
+      end
+    end
+
+    def invalid!(name, message)
+      raise ConfigurationError, "OpenBlog #{name} #{message}"
+    end
+  end
+end

data/lib/open_blog/configuration_error.rb

@@ -0,0 +1,4 @@
+module OpenBlog
+  class ConfigurationError < StandardError
+  end
+end

data/lib/open_blog/content_guard.rb

@@ -0,0 +1,77 @@
+module OpenBlog
+  module ContentGuard
+    extend ActiveSupport::Concern
+
+    STATE_KEY = :open_blog_content_parents
+
+    def self.with_parent(post)
+      previous = ActiveSupport::IsolatedExecutionState[STATE_KEY]
+      Post.lock.find(post.id) if post.persisted?
+      ActiveSupport::IsolatedExecutionState[STATE_KEY] = Array(previous) + [ post ]
+      yield
+    ensure
+      if previous
+        ActiveSupport::IsolatedExecutionState[STATE_KEY] = previous
+      else
+        ActiveSupport::IsolatedExecutionState.delete(STATE_KEY)
+      end
+    end
+
+    def self.active?(post)
+      return false unless post
+      Array(ActiveSupport::IsolatedExecutionState[STATE_KEY]).any? do |parent|
+        parent.equal?(post) || (parent.id && parent.id == post.id)
+      end
+    end
+
+    included do
+      around_save :guard_content_write, prepend: true
+      around_destroy :guard_content_write, prepend: true
+    end
+
+    def update_columns(attributes)
+      reject_content_bypass if content_guard_applies? || content_guard_target?(attributes)
+      super
+    end
+
+    def delete
+      reject_content_bypass if content_guard_applies?
+      super
+    end
+
+    def increment!(attribute, by = 1, touch: nil)
+      reject_content_bypass if content_guard_applies?
+      super
+    end
+
+    def touch(*names, time: nil)
+      if content_guard_applies? && (names.map(&:to_s) - %w[created_at updated_at]).any?
+        reject_content_bypass
+      end
+      super
+    end
+
+    private
+
+    def content_guard_target?(_attributes)
+      false
+    end
+
+    def guard_content_write
+      return yield unless content_guard_applies?
+      reject_content_bypass if content_guard_identity_changed?
+      parent = content_guard_parent
+      return yield if ContentGuard.active?(parent)
+      reject_content_bypass unless parent&.persisted?
+
+      fresh = Post.lock.find(parent.id)
+      result = yield
+      RecordRelease.call(fresh) if result
+      result
+    end
+
+    def reject_content_bypass
+      raise ActiveRecord::ReadOnlyRecord, "Save or destroy content through its existing post association"
+    end
+  end
+end

data/lib/open_blog/doctor/files.rb

@@ -0,0 +1,61 @@
+module OpenBlog
+  class Doctor
+    module Files
+      private
+
+      def read(path)
+        file = @root.join(path)
+        file.file? ? file.read : ""
+      end
+
+      def layout_source
+        read("app/views/layouts/#{@config.layout}.html.erb")
+      end
+
+      def views
+        layout = layout_source
+        content = view_tree("app/views/open_blog/posts/show.html.erb")
+        required = %w[open_blog_post_content open_blog_notices open_blog_byline open_blog_faq open_blog_responsible_party_link open_blog_cover]
+        absent = required.reject { |helper| content.match?(/\b#{helper}\b/) }
+        absent += %w[open_blog_head open_blog_structured_data].reject { |helper| layout.match?(/\b#{helper}\b/) }
+        absent << "original content cover (variant found)" if content.match?(/cover_image[^\n]*\.variant\b/)
+        absent.any? ? [ "error", "Copied views are missing required helpers: #{absent.join(', ')}." ] : [ "ok", "Copied layout and post partials call the reader helpers." ]
+      end
+
+      def view_tree(path, seen = [])
+        return "" if seen.include?(path)
+        seen << path
+        source = read(path)
+        partials = source.scan(/\brender\s*(?:\(?\s*)(?:partial:\s*)?["']([^"']+)["']/).flatten
+        source + partials.map do |partial|
+          directory, name = File.dirname(partial), File.basename(partial)
+          view_tree("app/views/#{directory}/_#{name}.html.erb", seen)
+        end.join("\n")
+      end
+
+      def theme
+        layout = layout_source
+        tailwind = @root.join("app/assets/tailwind/application.css")
+        bundled = @root.join("app/assets/stylesheets/application.tailwind.css")
+        if !layout.include?("open_blog_stylesheets")
+          asset = layout[/stylesheet_link_tag\s*\(?\s*["']([^"']+)["']/, 1]
+          return [ "error", "The blog layout must load the installed stylesheet." ] unless %w[tailwind application].include?(asset)
+          entry = asset == "tailwind" ? tailwind : bundled
+          return [ "error", "Missing Tailwind entry stylesheet #{entry.relative_path_from(@root)}." ] unless entry.file?
+          source = entry.read
+          return [ "error", "Import open_blog/theme.css in #{entry.relative_path_from(@root)}." ] unless source.match?(/@import\s+["'][^"']*open_blog\/theme(?:\.css)?["']/)
+          absent = %w[theme blog syntax].reject { |name| @root.join("app/assets/tailwind/open_blog/#{name}.css").file? }
+          return [ "error", "Missing theme sources: #{absent.join(', ')}." ] if absent.any?
+          asset = "#{asset}.css"
+        else
+          return [ "error", "Install app/assets/stylesheets/open_blog_theme.css." ] unless @root.join("app/assets/stylesheets/open_blog_theme.css").file?
+          asset = "open_blog/blog.css"
+          return [ "error", "The blog layout must load open_blog_stylesheets." ] unless layout.include?("open_blog_stylesheets")
+        end
+        return [ "error", "Build the missing #{asset} stylesheet." ] unless @application.assets&.resolver&.resolve(asset)
+        all = Dir[@root.join("app/views/layouts/**/*")].select { |path| File.file?(path) }.any? { |path| File.read(path).match?(/stylesheet_link_tag\s*(?:\(?\s*):all\b/) }
+        all ? [ "warning", "Replace stylesheet_link_tag :all to avoid loading the blog reset on other pages." ] : [ "ok", "Theme sources and compiled stylesheet are available." ]
+      end
+    end
+  end
+end