andromeda_cms 0.1.0-arm64-darwin

data/lib/andromeda/pipeline.rb

@@ -0,0 +1,296 @@
+# frozen_string_literal: true
+
+require "digest"
+require_relative "store"
+
+module Andromeda
+  # The one place source -> stored-result conversion happens.
+  # Both the development request path (convert this one
+  # entry, on demand, if it looks stale) and `andromeda:build` (
+  # convert every entry, unconditionally) call `Pipeline#convert`/
+  # `#build_collection` -- neither reimplements "frontmatter -> tree -> HTML"
+  # on its own, so the two can never drift apart: both always run the same
+  # conversion process.
+  #
+  # A Pipeline instance is cheap and stateless beyond its Store/mode, so
+  # callers are free to build a fresh one per request/task rather than
+  # reaching for a shared singleton.
+  class Pipeline
+    # @return [Symbol] result of `Pipeline.build_all`/`#build_collection` for
+    #   one collection: how many entries converted cleanly, and every
+    #   problem found among the rest (schema violations, missing
+    #   components, syntax errors) -- collected rather than raised
+    #   individually, so a build reports everything in one pass (same
+    #   principle as Andromeda::LoaderError).
+    BuildResult = Struct.new(:collection, :converted, :errors, keyword_init: true) do
+      def success? = errors.empty?
+    end
+
+    # @param store [Andromeda::Store]
+    # @param mode [Symbol, String] `:development` or `:production`.
+    #   Defaults to `Andromeda.config.mode`, which itself defaults to
+    #   `:development` -- see Configuration's comment for why that default
+    #   (rather than `:production`) is the safe one outside a Railtie that
+    #   has not set it explicitly yet.
+    def initialize(store: Andromeda::Store.new, mode: Andromeda.config.mode)
+      @store = store
+      @mode = mode.to_sym
+    end
+
+    # Converts one already-loaded entry's body into HTML, writes the result
+    # to the store, and returns it. Unconditional -- always re-parses and
+    # re-renders, even if a stored copy with a matching digest already
+    # exists -- because `andromeda:build` needs exactly that ("always
+    # produce today's output") and because staleness-checking is `#fetch`'s
+    # job, not this one's, so this method has exactly one behaviour to
+    # reason about.
+    #
+    # @param entry [Andromeda::Entry] built by Andromeda::Loader (so
+    #   `data`/`body`/`digest`/`file_path` all come straight from the
+    #   source file, not from a previous build).
+    # @return [Hash] the stored payload (Symbol-keyed: `id`, `collection`,
+    #   `data`, `html`, `headings`, `digest`, `file_path`).
+    # @raise [Andromeda::SyntaxError, Andromeda::ParserError,
+    #   Andromeda::Renderer::MissingComponentError] on a bad file; callers
+    #   that want every problem across a whole collection reported together
+    #   should go through `#build_collection` instead of calling this
+    #   directly in a loop.
+    def convert(entry)
+      mdx = Andromeda::Parser.mdx?(entry.file_path)
+      tree = Andromeda::Parser.parse(entry.body, mdx: mdx, path: entry.file_path)
+      result = Andromeda::Renderer.new(
+        components: components_for(entry, tree),
+        image_resolver: image_resolver_for(entry)
+      ).render(tree)
+
+      payload = {
+        id: entry.id,
+        collection: entry.collection,
+        data: publish_data_images(entry),
+        html: result.html,
+        headings: result.headings,
+        digest: entry.digest,
+        render_key: render_key,
+        file_path: entry.file_path
+      }
+      @store.write_entry(entry.collection, entry.id, payload)
+      payload
+    end
+
+    # The read path an `Andromeda::Entry` instance's `#html`/`#headings`
+    # actually call:
+    #
+    # - production: read-only. A missing stored entry means the deploy-time
+    #   `andromeda:build` never ran (or this entry is new since it last
+    #   did) -- raises `Andromeda::BuildMissing` naming the fix, rather than
+    #   silently converting in a request. Production never runs the
+    #   conversion process at all.
+    # - development: converts on demand when the stored digest does not
+    #   match the source file's current digest (or nothing is stored yet),
+    #   otherwise just reads what is already there. No mtime polling/watcher
+    #   process -- staleness is only ever checked when something asks
+    #   to read.
+    #
+    # @param entry [Andromeda::Entry]
+    # @return [Hash] same shape as `#convert`'s return value.
+    # @raise [Andromeda::BuildMissing] in production, when nothing is built yet.
+    def fetch(entry)
+      stored = @store.read_entry(entry.collection, entry.id)
+
+      if production?
+        return stored if stored
+
+        raise Andromeda::BuildMissing.new(collection: entry.collection, id: entry.id, file_path: entry.file_path)
+      end
+
+      return stored if stored && stored[:digest] == entry.digest && stored[:render_key] == render_key
+
+      convert(entry)
+    end
+
+    # The list-view read path behind a future `Content::Post.index` helper:
+    # in production, just reads `_index.json` (never touches source files);
+    # in development, does a full staleness-aware pass over the collection
+    # first (via `#refresh_collection`) so the index reflects edits/deletes
+    # made since the last read, without a watcher process.
+    #
+    # @param entry_class [Class] an Andromeda::Entry subclass.
+    # @return [Array<Hash>] summaries (`id`/`data`/`headings`/`digest`/`file_path`).
+    # @raise [Andromeda::BuildMissing] in production, when nothing is built yet.
+    def collection_index(entry_class)
+      if production?
+        index = @store.read_index(entry_class.collection_name)
+        return index if index
+
+        raise Andromeda::BuildMissing.new(collection: entry_class.collection_name)
+      end
+
+      refresh_collection(entry_class)
+      @store.read_index(entry_class.collection_name) || []
+    end
+
+    # Dev-mode collection refresh: re-converts only entries whose stored
+    # digest is missing/stale (via `#fetch`, so an unchanged file is never
+    # re-parsed), then rewrites `_index.json` from exactly the entries found
+    # on disk right now -- which is also what prunes a deleted source file's
+    # leftover JSON (Store#replace_collection! deletes any `<id>.json` not
+    # in that set).
+    #
+    # @param entry_class [Class]
+    # @return [Array<Hash>] every payload just fetched/converted.
+    # @raise [Andromeda::BuildError] if any entry fails to convert; a schema
+    #   problem across the whole collection surfaces as
+    #   Andromeda::LoaderError instead, straight out of `entry_class.all`.
+    def refresh_collection(entry_class)
+      errors = []
+      payloads = entry_class.all.to_a.filter_map do |entry|
+        begin
+          fetch(entry)
+        rescue Andromeda::Error => e
+          errors << "[#{entry_class.collection_name}] #{entry.file_path}: #{e.message}"
+          nil
+        end
+      end
+
+      @store.replace_collection!(entry_class.collection_name, payloads)
+      raise Andromeda::BuildError, errors unless errors.empty?
+
+      payloads
+    end
+
+    # `andromeda:build`'s per-collection unit of work (called
+    # once per registered collection, or via `Pipeline.build_all`): force-
+    # converts every entry (unlike `#refresh_collection`, ignoring any
+    # existing stored digest -- a build always reflects *today's* renderer/
+    # components, not just today's content), collecting every problem
+    # instead of stopping at the first bad file, then writes whatever
+    # succeeded and prunes anything stale.
+    #
+    # @param entry_class [Class]
+    # @return [BuildResult]
+    def build_collection(entry_class)
+      entries =
+        begin
+          entry_class.all.to_a
+        rescue Andromeda::LoaderError => e
+          return BuildResult.new(
+            collection: entry_class.collection_name, converted: 0,
+            errors: e.messages.map { |message| "[#{entry_class.collection_name}] #{message}" }
+          )
+        end
+
+      errors = []
+      payloads = entries.filter_map do |entry|
+        begin
+          convert(entry)
+        rescue Andromeda::Error => e
+          errors << "[#{entry_class.collection_name}] #{entry.file_path}: #{e.message}"
+          nil
+        end
+      end
+
+      @store.replace_collection!(entry_class.collection_name, payloads)
+      BuildResult.new(collection: entry_class.collection_name, converted: payloads.size, errors: errors)
+    end
+
+    # Converts every registered collection, reporting every problem found
+    # across all of them together instead of
+    # aborting at the first bad collection or the first bad file within one.
+    #
+    # @param entry_classes [Array<Class>] defaults to every collection
+    #   currently registered in Andromeda::Registry.
+    # @param store [Andromeda::Store] shared across every collection, so
+    #   tests (and a Rake task that wants a non-default build path) can
+    #   inject one instead of every collection reaching for
+    #   `Andromeda::Store.new`'s own `Andromeda.config.build_path` default.
+    # @return [Array<BuildResult>] one per collection, on success.
+    # @raise [Andromeda::BuildError] listing every problem found, across
+    #   every collection, if any entry failed to convert.
+    def self.build_all(entry_classes = default_entry_classes, store: Andromeda::Store.new)
+      results = entry_classes.map { |entry_class| new(store: store).build_collection(entry_class) }
+      errors = results.flat_map(&:errors)
+      raise Andromeda::BuildError, errors unless errors.empty?
+
+      results
+    end
+
+    def self.default_entry_classes
+      Andromeda::Registry.collection_names.map { |name| Andromeda::Registry[name] }
+    end
+
+    private
+
+    # What the stored HTML depends on besides the entry's own source.
+    # Component partials are rendered into the HTML at conversion time, so
+    # without this an edited partial would keep serving the old markup until
+    # the MDX file itself changed. Partials outside `components_path` (an
+    # import pointing elsewhere under app/views) are not tracked; scanning
+    # every view on every development request would cost more than it saves.
+    def render_key
+      partials = Dir.glob(File.join(Andromeda.config.project_root, Andromeda.config.components_path, "**", "*")).sort.filter_map do |file|
+        next unless File.file?(file)
+
+        [file, File.mtime(file).to_r, File.size(file)].join(":")
+      end
+      Digest::SHA256.hexdigest([Andromeda::VERSION, Andromeda.config.highlight_theme, *partials].join("\n"))
+    end
+
+    def production?
+      @mode == :production
+    end
+
+    # Only constructed for `.mdx` sources: a plain Markdown parse (`mdx:
+    # false`) never produces an `mdxJsxFlowElement`/`mdxJsxTextElement` node
+    # for the Renderer to call this on, so there is nothing to inject for
+    # `.md` entries. Resolved lazily (by constant name, not a `require`) so
+    # this file loads and works whether or not
+    # `Andromeda::Components` has landed yet.
+    # `image` attributes are published alongside the ones written in the body,
+    # so a hero image declared only in frontmatter is served the same way and
+    # a view never has to publish anything while handling a request.
+    def publish_data_images(entry)
+      base_dir = Andromeda::Registry[entry.collection]&.base_dir || File.dirname(entry.file_path)
+
+      entry.data.each_value do |value|
+        Andromeda::Assets.publish(value.path, content_root: base_dir) if value.is_a?(Andromeda::Image)
+      end
+      entry.data
+    end
+
+    # Images referenced from a content file are copied into the asset
+    # pipeline as they are encountered, so a build only publishes what the
+    # content actually uses and a deleted reference stops shipping its file.
+    # Absolute and remote URLs are left alone: they are already served by
+    # something else.
+    def image_resolver_for(entry)
+      content_root = File.dirname(entry.file_path)
+      base_dir = Andromeda::Registry[entry.collection]&.base_dir || content_root
+
+      lambda do |url, _node|
+        # Absolute URLs point at something already being served -- a file in
+        # `public/`, another host, or an inline data URI -- so they are left
+        # exactly as the author wrote them.
+        next url if url.empty? || url.start_with?("/", "http://", "https://", "data:")
+
+        source = File.expand_path(url, content_root)
+        if File.file?(source)
+          logical = Andromeda::Assets.publish(source, content_root: base_dir)
+          next Andromeda::Assets.marker_for(logical) if logical
+        end
+
+        # Not a file next to the content: treat it as a logical asset path so
+        # images the application already ships (`app/assets/images/logo.png`,
+        # written as `logo.png`) resolve through the asset pipeline and get
+        # their digest, instead of 404ing in production.
+        Andromeda::Assets.marker_for(url)
+      end
+    end
+
+    def components_for(entry, tree)
+      return nil unless Andromeda::Parser.mdx?(entry.file_path)
+      return nil unless defined?(Andromeda::Components)
+
+      Andromeda::Components.new(tree: tree, path: entry.file_path, view: nil, frontmatter: entry.data)
+    end
+  end
+end

data/lib/andromeda/railtie.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require "rails/railtie"
+require_relative "helpers"
+
+module Andromeda
+  class Railtie < ::Rails::Railtie
+    config.andromeda = Andromeda.config
+
+    # Development converts on demand so edits show up without a build;
+    # anywhere else the build is the only writer. Test behaves like
+    # development so a suite never has to run the build task first.
+    initializer "andromeda.mode" do
+      Andromeda.config.mode = Rails.env.local? ? :development : :production
+    end
+
+    # A slug that matches no entry is a missing page, and should look like
+    # one to browsers, crawlers and uptime monitors rather than a 500. Set at
+    # class level, as Active Record does for RecordNotFound: ActionDispatch
+    # copies this table while it initializes, before any initializer of ours.
+    if config.respond_to?(:action_dispatch)
+      config.action_dispatch.rescue_responses["Andromeda::EntryNotFound"] = :not_found
+    end
+
+    initializer "andromeda.helpers" do
+      ActiveSupport.on_load(:action_view) { include Andromeda::Helpers }
+    end
+
+    # Entry classes are ordinary autoloaded constants, so Zeitwerk -- not
+    # Kernel#load -- has to be the one that loads them; loading the files
+    # directly would create a second copy of each class that Rails' reloader
+    # neither tracks nor unloads. Eager-loading the directory on every
+    # `to_prepare` also covers development, where nothing would otherwise
+    # reference the classes until a request needs one.
+    config.to_prepare do
+      Andromeda::Registry.clear!
+      directory = Rails.root.join(Andromeda.config.entry_class_path)
+      next unless directory.directory?
+
+      Rails.autoloaders.main.eager_load_dir(directory) if Rails.autoloaders.respond_to?(:main)
+    end
+
+    rake_tasks do
+      load File.expand_path("tasks/andromeda.rake", __dir__)
+    end
+  end
+end

data/lib/andromeda/registry.rb

@@ -0,0 +1,127 @@
+# frozen_string_literal: true
+
+module Andromeda
+  # Maps collection name (`:blog`) to the `Andromeda::Entry` subclass that
+  # declared it (`Content::Post`), so `Andromeda.get_collection`/`get_entry`
+  # and cross-collection `reference` resolution can find a class by name
+  # alone.
+  #
+  # ## How collection classes get found in development
+  #
+  # In production, Rails eager loads `app/models/`, so every `Content::*`
+  # class runs its `collection` macro (and thus registers itself) simply by
+  # being loaded -- no discovery step needed. In development, autoloading is
+  # lazy: a class that nothing has referenced yet (the exact situation for
+  # an STI-style class only ever looked up by a symbol, never a Ruby
+  # constant) never runs, so `Registry[:blog]` would come back empty even
+  # though `app/models/content/post.rb` exists on disk.
+  #
+  # `discover` closes that gap by force-loading every `.rb` file under a
+  # directory (default `app/models/content`, the conventional content
+  # class location), which runs each file's `collection` call and populates
+  # this registry as a side effect. It uses `Kernel#load` rather than
+  # `require`, because `require` is a no-op the second time it sees the same
+  # absolute path -- exactly the case on every code reload after the first
+  # boot, and load is required for `discover` to be reload-safe.
+  #
+  # This module is intentionally Rails-agnostic: it doesn't reference
+  # `Rails`, `ActiveSupport::Reloader`, or zeitwerk. The Railtie is
+  # expected to call `discover` from a `Rails.application.reloader.to_prepare`
+  # block, which already runs once at boot and again after every reload in
+  # development -- giving `discover` the "run again after files changed"
+  # trigger for free without this file needing to know reloading exists.
+  # One caveat left unresolved: `to_prepare` fires after Rails'
+  # own autoloader (Zeitwerk) has already unloaded stale constants for
+  # *changed* files, but a class we reach via a plain `load` (bypassing
+  # Zeitwerk's own autoload hook) is not necessarily one Zeitwerk considers
+  # itself responsible for unloading. If that turns out to matter in
+  # practice, the Railtie can instead trigger the load by referencing
+  # the constant Zeitwerk expects (`Rails.autoloaders.main.eager_load_dir`)
+  # rather than calling `Kernel#load` directly -- `discover` below is the
+  # dependency-free fallback for that decision, not the final word on it.
+  #
+  # `clear!` before rebuilding is what makes a second `discover` call safe:
+  # without it, a renamed or deleted entry class would linger in the
+  # registry as a zombie pointing at a stale class object whose constant no
+  # longer resolves to it.
+  module Registry
+    DEFAULT_DIRECTORY = "app/models/content"
+
+    class << self
+      # @param name [Symbol, String]
+      # @param entry_class [Class] an Andromeda::Entry subclass.
+      def register(name, entry_class)
+        entries[name.to_sym] = entry_class
+      end
+
+      # @return [Class, nil]
+      def [](name)
+        entries[name.to_sym]
+      end
+
+      # @return [Array<Symbol>]
+      def collection_names
+        entries.keys
+      end
+
+      # Wipes every registration. Called automatically at the start of
+      # `discover`; exposed on its own for tests that need a clean slate.
+      def clear!
+        @entries = {}
+      end
+
+      # Force-loads every `.rb` file under `dir`, registering whatever
+      # `collection` calls they contain. See the module comment for why
+      # this clears the registry first and uses `load` rather than
+      # `require`.
+      #
+      # @param dir [String] absolute path to a directory of entry classes.
+      def discover(dir = default_directory)
+        clear!
+        Dir.glob(File.join(dir, "**", "*.rb")).sort.each { |file| load file }
+        self
+      end
+
+      # @return [String] `app/models/content` under Rails.root when Rails is
+      #   loaded, or under the current working directory otherwise (kept
+      #   Rails-agnostic so plain-Ruby usage and tests don't need Rails).
+      def default_directory
+        File.join(Andromeda.config.project_root, DEFAULT_DIRECTORY)
+      end
+
+      private
+
+      def entries
+        @entries ||= {}
+      end
+    end
+  end
+
+  class << self
+    # Astro's `getCollection("blog")`, returning every entry.
+    #
+    # @param name [Symbol, String]
+    # @return [Andromeda::Relation]
+    # @raise [Andromeda::UnknownCollection]
+    def get_collection(name)
+      entry_class_for(name).all
+    end
+
+    # Astro's `getEntry("blog", id)`.
+    #
+    # @param name [Symbol, String]
+    # @param id [String]
+    # @return [Andromeda::Entry]
+    # @raise [Andromeda::UnknownCollection]
+    # @raise [Andromeda::EntryNotFound]
+    def get_entry(name, id)
+      entry_class_for(name).find(id)
+    end
+
+    private
+
+    def entry_class_for(name)
+      Registry[name] || raise(Andromeda::UnknownCollection, name.to_sym)
+    end
+  end
+end

data/lib/andromeda/relation.rb

@@ -0,0 +1,125 @@
+# frozen_string_literal: true
+
+module Andromeda
+  # A small, chainable wrapper around an Array of loaded entries.
+  # v0 keeps everything in memory, so there is no query to build up and
+  # defer -- every method here just filters/sorts the Array it already has.
+  # Deliberately not lazy/Enumerator-based: at v0 scale that would only add
+  # indirection without saving any real work.
+  class Relation
+    include Enumerable
+
+    # @return [Class, nil] the Andromeda::Entry subclass this relation was
+    #   built from, so `scope` calls (defined on the class) can be looked up
+    #   and re-run when chained off a Relation instead of the class itself.
+    attr_reader :entry_class
+
+    # @param records [Array<Andromeda::Entry>]
+    # @param entry_class [Class, nil]
+    def initialize(records, entry_class: nil)
+      @records = records
+      @entry_class = entry_class
+    end
+
+    def each
+      return enum_for(:each) unless block_given?
+
+      @records.each { |record| yield record }
+    end
+
+    # @return [Array<Andromeda::Entry>] a defensive copy.
+    def to_a
+      @records.dup
+    end
+
+    # `where(draft: false)` (equality on `data`) or `where { |e| ... }`
+    # (arbitrary block) -- both forms Astro's own `getCollection(name,
+    # filter)` supports as one argument, split here into two Ruby-idiomatic
+    # entry points instead.
+    #
+    # @param conditions [Hash, nil] Symbol/String keys, matched against
+    #   `entry.data`.
+    def where(conditions = nil, &block)
+      filtered =
+        if block
+          @records.select(&block)
+        elsif conditions
+          @records.select { |record| conditions.all? { |key, value| record.data[key.to_sym] == value } }
+        else
+          @records
+        end
+
+      self.class.new(filtered, entry_class: entry_class)
+    end
+
+    # @return [Andromeda::Entry, nil]
+    def find_by(conditions = nil, &block)
+      where(conditions, &block).first
+    end
+
+    # `order(:pub_date)` (ascending) or `order(pub_date: :desc)`. Multiple
+    # criteria apply left to right, like SQL's `ORDER BY a, b`.
+    def order(*criteria)
+      keys = criteria.flat_map { |criterion| criterion.is_a?(Hash) ? criterion.to_a : [[criterion, :asc]] }
+
+      # Array#sort is not stable, but JavaScript's is, and an Astro listing
+      # sorted by date keeps same-day posts in their original order. The
+      # original position breaks every remaining tie so the order is the
+      # same here, and the same on every run.
+      sorted = @records.each_with_index.sort do |(a, a_index), (b, b_index)|
+        compare_by(keys, a, b).nonzero? || a_index <=> b_index
+      end
+
+      self.class.new(sorted.map(&:first), entry_class: entry_class)
+    end
+
+    # @return [Andromeda::Relation]
+    def limit(count)
+      self.class.new(@records.first(count), entry_class: entry_class)
+    end
+
+    # @return [Andromeda::Entry, Array<Andromeda::Entry>, nil]
+    def first(count = nil)
+      count ? @records.first(count) : @records.first
+    end
+
+    def count
+      @records.size
+    end
+
+    def size
+      @records.size
+    end
+    alias length size
+
+    def empty?
+      @records.empty?
+    end
+
+    # Lets a scope declared on `entry_class` (via `Entry.scope`) be called
+    # directly on a Relation, so `Post.published.recent` chains the same way
+    # `Post.published` does at the class level.
+    def method_missing(name, *args, &block)
+      scope = entry_class&.scopes&.[](name)
+      return instance_exec(*args, &scope) if scope
+
+      super
+    end
+
+    def respond_to_missing?(name, include_private = false)
+      !!entry_class&.scopes&.key?(name) || super
+    end
+
+    private
+
+    # The first criterion on which `a` and `b` differ decides; 0 if none does.
+    def compare_by(keys, a, b)
+      keys.each do |attribute, direction|
+        # Incomparable values (one side nil) count as a tie, not an error.
+        comparison = (a.data[attribute.to_sym] <=> b.data[attribute.to_sym]) || 0
+        return direction == :desc ? -comparison : comparison unless comparison.zero?
+      end
+      0
+    end
+  end
+end

data/lib/andromeda/renderer/code_highlighter.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+require "rouge"
+
+module Andromeda
+  class Renderer
+    # Stands in for Shiki: matches the *markup shape*
+    # Astro/Shiki produce for fenced code blocks -- `<pre class="astro-code
+    # <theme>" style="..." data-language="...">` -- so existing CSS written
+    # against Astro's default output keeps working, while the actual colours
+    # come from Rouge instead of Shiki (a byte-identical palette is not the
+    # goal -- displaying the code correctly is, not matching Shiki exactly).
+    module CodeHighlighter
+      # `github.dark` is Rouge's built-in theme closest to Shiki's default
+      # `github-dark` (same source palette family: GitHub's dark code theme),
+      # and it keeps the CSS class name Astro emits (`astro-code github-dark`)
+      # meaningful rather than mismatched with the actual colours.
+      THEME_NAME = "github-dark"
+      THEME = Rouge::Theme.find("github.dark").new
+      FORMATTER = Rouge::Formatters::HTMLInline.new(THEME)
+      BACKGROUND = THEME.palette[:bgDefault]
+      FOREGROUND = THEME.palette[:fgDefault]
+
+      module_function
+
+      # @param code [String] the fenced code block's body (already the raw
+      #   text -- mdast `code` nodes store it unescaped).
+      # @param lang [String, nil] the fence's language tag, if any.
+      # @return [String] a full `<pre>...</pre>` element.
+      def render(code, lang)
+        lexer = lookup_lexer(lang)
+        body = lexer ? FORMATTER.format(lexer.lex(code)) : Renderer.escape_html(code)
+
+        # Shiki/Astro emit `data-language` verbatim from the fence even when
+        # the language is not one Shiki recognizes (it would raise instead);
+        # Rouge is more permissive about *finding* a lexer but we still fall
+        # back to plain text for anything it can't find, per this step's
+        # brief ("falls back to plain text without raising") -- so an
+        # unrecognized `lang` keeps its `data-language` label for styling
+        # purposes even though no syntax highlighting was applied.
+        language_attr = lang && !lang.empty? ? %( data-language="#{Renderer.escape_attr(lang)}") : ""
+
+        %(<pre class="astro-code #{THEME_NAME}" style="background-color:#{BACKGROUND};color:#{FOREGROUND};overflow-x:auto;"#{language_attr}><code>#{body}</code></pre>)
+      end
+
+      def lookup_lexer(lang)
+        return nil if lang.nil? || lang.empty?
+
+        Rouge::Lexer.find(lang.downcase)
+      end
+    end
+  end
+end