plum-cms 0.1.0

data/app/services/plum/form_renderer.rb

@@ -0,0 +1,110 @@
+module Plum
+  class FormRenderer
+    FIELD_CLASSES = "plum-form-field".freeze
+
+    def initialize(form)
+      @form = form
+    end
+
+    def render
+      return "" if form.blank?
+
+      <<~HTML
+        <form class="plum-form" method="post" action="#{h(form['action'])}" data-plum-form-handle="#{h(form['handle'])}">
+          #{hidden_inputs}
+          #{fields_html}
+          <button class="plum-form-submit" type="submit">Submit</button>
+        </form>
+      HTML
+    end
+
+    private
+
+    attr_reader :form
+
+    def hidden_inputs
+      [
+        hidden_input(form["csrf_param"], form["csrf_token"]),
+        hidden_input("return_to", form["return_to"])
+      ].compact.join("\n  ")
+    end
+
+    def fields_html
+      Array(form["fields"]).map { |field| field_html(field) }.join("\n  ")
+    end
+
+    def field_html(field)
+      handle = field["handle"].to_s
+      type = field["type"].to_s
+      label = field_label(field)
+      input_id = "plum_form_#{form['handle']}_#{handle}"
+
+      <<~HTML.strip
+        <div class="#{FIELD_CLASSES}">
+          <label for="#{h(input_id)}">#{h(label)}</label>
+          #{input_html(field, input_id)}
+        </div>
+      HTML
+    end
+
+    def input_html(field, input_id)
+      case field["type"]
+      when "textarea"
+        textarea_html(field, input_id)
+      when "select"
+        select_html(field, input_id)
+      when "checkbox"
+        checkbox_html(field, input_id)
+      else
+        text_input_html(field, input_id)
+      end
+    end
+
+    def text_input_html(field, input_id)
+      type = field["type"] == "email" ? "email" : "text"
+
+      %(<input type="#{type}" id="#{h(input_id)}" name="#{field_name(field)}"#{required_attribute(field)}>)
+    end
+
+    def textarea_html(field, input_id)
+      %(<textarea id="#{h(input_id)}" name="#{field_name(field)}"#{required_attribute(field)}></textarea>)
+    end
+
+    def select_html(field, input_id)
+      options = Array(field["options"]).map do |option|
+        %(<option value="#{h(option)}">#{h(option)}</option>)
+      end.join
+
+      %(<select id="#{h(input_id)}" name="#{field_name(field)}"#{required_attribute(field)}><option value=""></option>#{options}</select>)
+    end
+
+    def checkbox_html(field, input_id)
+      <<~HTML.squish
+        <input type="hidden" name="#{field_name(field)}" value="0">
+        <input type="checkbox" id="#{h(input_id)}" name="#{field_name(field)}" value="1"#{required_attribute(field)}>
+      HTML
+    end
+
+    def hidden_input(name, value)
+      return if name.blank? || value.blank?
+
+      %(<input type="hidden" name="#{h(name)}" value="#{h(value)}">)
+    end
+
+    def field_name(field)
+      h("form_submission[data][#{field['handle']}]")
+    end
+
+    def field_label(field)
+      field["label"].presence || field["handle"].to_s.humanize
+    end
+
+    def required_attribute(field)
+      ActiveModel::Type::Boolean.new.cast(field["required"]) ? " required" : ""
+    end
+
+    def h(value)
+      ERB::Util.html_escape(value.to_s)
+    end
+  end
+end

data/app/services/plum/liquid_context.rb

@@ -0,0 +1,335 @@
+require "nokogiri"
+
+module Plum
+  class LiquidContext
+    MAX_RELATIONSHIP_DEPTH = 2
+
+    def initialize(controller:, site:, entry: nil, theme_name: nil, theme_settings: nil)
+      @controller = controller
+      @site = site
+      @entry = entry
+      @theme_name = theme_name
+      @theme_settings = theme_settings
+    end
+
+    def to_h
+      {
+        "site" => site_context,
+        "entry" => entry ? entry_context(entry, expand_blocks: true) : nil,
+        "entries" => entries_context,
+        "taxonomies" => taxonomies_context,
+        "forms" => forms_context,
+        "globals" => globals_context,
+        "nav" => nav_context
+      }.compact.merge(Plum.content_sources_for(controller, site: site))
+    end
+
+    private
+
+    attr_reader :controller, :site, :entry, :theme_name, :theme_settings
+
+    def site_context
+      @site_context ||= begin
+        settings = SiteSetting.instance(site)
+        {
+          "name" => settings.name,
+          "tagline" => settings.tagline,
+          "seo_title" => settings.seo_title,
+          "seo_description" => settings.seo_description,
+          "primary_color" => settings.primary_color,
+          "support_email" => settings.support_email,
+          "logo" => image_asset_context(settings.logo),
+          "theme_name" => theme_name.presence || settings.theme_name,
+          "theme_settings" => theme_settings || site.theme_settings,
+          "theme_asset_base_url" => theme_asset_base_url,
+          "custom_css" => site.custom_css,
+          "url" => public_root_path,
+          "meta_title" => settings.seo_title,
+          "meta_description" => settings.seo_description,
+          "powered_by_name" => Plum.configuration.powered_by_name,
+          "powered_by_url" => Plum.configuration.powered_by_url
+        }
+      end
+    end
+
+    def entry_context(entry, relationship_depth: MAX_RELATIONSHIP_DEPTH, expand_blocks: false)
+      ctx = {
+        "title" => entry.title,
+        "slug" => entry.slug,
+        "published_at" => entry.published_at,
+        "url" => public_entry_path(entry),
+        "data" => entry_data_context(entry, relationship_depth: relationship_depth, expand_blocks: expand_blocks)
+      }
+      if entry.association(:terms).loaded? && entry.terms.any?
+        ctx["terms"] = entry.terms.group_by { |t| t.taxonomy.handle }.transform_values do |terms|
+          terms.map { |t| { "name" => t.name, "slug" => t.slug, "url" => "/#{t.taxonomy.slug}/#{t.slug}" } }
+        end
+      end
+      ctx.merge!(adjacent_entry_context(entry)) if expand_blocks
+      ctx
+    end
+
+    def entry_data_context(entry, relationship_depth:, expand_blocks: false)
+      data = (entry.data || {}).deep_dup
+
+      entry.content_type.fields.each do |field|
+        handle = field["handle"].to_s
+        next if handle.blank?
+
+        case field["type"]
+        when "image"
+          data[handle] = image_asset_context(data[handle])
+        when "rich_text"
+          data[handle] = resolve_rich_text(data[handle])
+        when "relationship"
+          data[handle] = relationship_entry_context(data[handle], relationship_depth: relationship_depth)
+        when "blocks"
+          data[handle] = expand_blocks ? blocks_html(data[handle]) : "".html_safe
+        end
+      end
+
+      data
+    end
+
+    def taxonomies_context
+      @taxonomies_context ||= Taxonomy.for_site(site).includes(:terms).each_with_object({}) do |taxonomy, hash|
+        hash[taxonomy.handle] = {
+          "name" => taxonomy.name,
+          "handle" => taxonomy.handle,
+          "slug" => taxonomy.slug,
+          "terms" => taxonomy.terms.sort_by(&:position).map { |term|
+            { "name" => term.name, "slug" => term.slug, "url" => "/#{taxonomy.slug}/#{term.slug}" }
+          }
+        }
+      end
+    end
+
+    def entries_context
+      @entries_context ||= begin
+        ContentType.for_site(site).each_with_object({}) do |content_type, hash|
+          hash[content_type.handle] = Array(live_entries_by_type[content_type.id]).map { |item| entry_context(item) }
+        end
+      end
+    end
+
+    def globals_context
+      @globals_context ||= Global.for_site(site).each_with_object({}) do |global, hash|
+        hash[global.handle] = global.data
+      end
+    end
+
+    def forms_context
+      @forms_context ||= FormDefinition.for_site(site).each_with_object({}) do |form, hash|
+        hash[form.handle] = {
+          "name" => form.name,
+          "handle" => form.handle,
+          "fields" => form.form_fields,
+          "action" => public_form_path(form),
+          "csrf_token" => form_authenticity_token,
+          "csrf_param" => "authenticity_token",
+          "return_to" => controller.request.fullpath
+        }
+      end
+    end
+
+    def nav_context
+      @nav_context ||= begin
+        items_by_menu = NavItem.for_site(site)
+                               .includes(entry: [ :content_type, { terms: :taxonomy } ])
+                               .group_by(&:nav_menu_id)
+
+        NavMenu.for_site(site).each_with_object({}) do |menu, hash|
+          menu_items = Array(items_by_menu[menu.id])
+          items_by_parent = menu_items.group_by(&:parent_id)
+          hash[menu.handle] = {
+            "name" => menu.name,
+            "handle" => menu.handle,
+            "items" => Array(items_by_parent[nil]).map { |item| nav_item_context(item, items_by_parent) }
+          }
+        end
+      end
+    end
+
+    def nav_item_context(item, items_by_parent)
+      {
+        "label" => item.label,
+        "url" => nav_item_url(item),
+        "entry" => item.entry ? entry_context(item.entry) : nil,
+        "children" => Array(items_by_parent[item.id]).map { |child| nav_item_context(child, items_by_parent) }
+      }
+    end
+
+    def nav_item_url(item)
+      item.entry ? public_entry_path(item.entry) : item.url
+    end
+
+    def image_asset_context(value)
+      return if value.blank?
+
+      asset_cache[value.to_i]&.to_liquid
+    end
+
+    def relationship_entry_context(value, relationship_depth:)
+      return if value.blank? || relationship_depth <= 0
+
+      related_entry = relationship_entry_cache[value.to_i]
+      return unless related_entry
+
+      entry_context(related_entry, relationship_depth: relationship_depth - 1)
+    end
+
+    LEXXY_CSS_VARS = {
+      "var(--highlight-1)" => "rgb(136, 118, 38)",
+      "var(--highlight-2)" => "rgb(185, 94, 6)",
+      "var(--highlight-3)" => "rgb(207, 0, 0)",
+      "var(--highlight-4)" => "rgb(216, 28, 170)",
+      "var(--highlight-5)" => "rgb(144, 19, 254)",
+      "var(--highlight-6)" => "rgb(5, 98, 185)",
+      "var(--highlight-7)" => "rgb(17, 138, 15)",
+      "var(--highlight-8)" => "rgb(148, 82, 22)",
+      "var(--highlight-9)" => "rgb(102, 102, 102)",
+      "var(--highlight-bg-1)" => "rgba(229, 223, 6, 0.3)",
+      "var(--highlight-bg-2)" => "rgba(255, 185, 87, 0.3)",
+      "var(--highlight-bg-3)" => "rgba(255, 118, 118, 0.3)",
+      "var(--highlight-bg-4)" => "rgba(248, 137, 216, 0.3)",
+      "var(--highlight-bg-5)" => "rgba(190, 165, 255, 0.3)",
+      "var(--highlight-bg-6)" => "rgba(124, 192, 252, 0.3)",
+      "var(--highlight-bg-7)" => "rgba(140, 255, 129, 0.3)",
+      "var(--highlight-bg-8)" => "rgba(221, 170, 123, 0.3)",
+      "var(--highlight-bg-9)" => "rgba(200, 200, 200, 0.3)"
+    }.freeze
+
+    def resolve_rich_text(html)
+      return html if html.blank?
+
+      result = html.to_s
+
+      result.gsub!(/<action-text-attachment[^>]*>.*?<\/action-text-attachment>/m) do |tag|
+        url = tag[/url="([^"]*)"/, 1]
+        alt = tag[/alt="([^"]*)"/, 1] || ""
+        width = tag[/width="([^"]*)"/, 1]
+        height = tag[/height="([^"]*)"/, 1]
+
+        attrs = %(src="#{url}" alt="#{alt}")
+        attrs += %( width="#{width}") if width
+        attrs += %( height="#{height}") if height
+        %(<img #{attrs}>)
+      end
+
+      LEXXY_CSS_VARS.each { |var, val| result.gsub!(var, val) }
+
+      result.gsub!(/<mark\b/, "<span")
+      result.gsub!(%r{</mark>}, "</span>")
+
+      add_heading_ids(result)
+    end
+
+    def add_heading_ids(html)
+      fragment = Nokogiri::HTML.fragment(html)
+      used_ids = Hash.new(0)
+
+      fragment.css("h2, h3").each do |heading|
+        base_id = heading["id"].presence || heading.text.parameterize.presence || "section"
+        used_ids[base_id] += 1
+        heading["id"] = used_ids[base_id] == 1 ? base_id : "#{base_id}-#{used_ids[base_id]}"
+      end
+
+      fragment.to_html
+    end
+
+    def adjacent_entry_context(current_entry)
+      siblings = Array(live_entries_by_type[current_entry.content_type_id]).sort_by do |item|
+        [ item.data&.fetch("position", nil).to_i, item.title.to_s ]
+      end
+      index = siblings.index { |item| item.id == current_entry.id }
+      return {} unless index
+
+      {
+        "previous" => index.positive? ? navigation_entry_context(siblings[index - 1]) : nil,
+        "next" => index < siblings.length - 1 ? navigation_entry_context(siblings[index + 1]) : nil
+      }
+    end
+
+    def navigation_entry_context(item)
+      { "title" => item.title, "slug" => item.slug, "url" => public_entry_path(item) }
+    end
+
+    # Renders a blocks field value (an array of block instances) into HTML using
+    # the active theme's Liquid block partials. The shared site context (site,
+    # globals, nav, forms, registered content sources) is exposed inside each
+    # block, but the global `entries` collection is intentionally excluded to
+    # avoid an infinite render loop, since every entry's blocks are expanded.
+    def blocks_html(value)
+      return "".html_safe unless value.is_a?(Array) && value.any?
+
+      BuilderRenderer.new(
+        blocks: value,
+        base_assigns: blocks_base_assigns,
+        site: site,
+        theme: blocks_theme,
+        registers: blocks_registers
+      ).render
+    end
+
+    def blocks_theme
+      @blocks_theme ||= ThemeRegistry.new.fetch(blocks_theme_name)
+    end
+
+    def blocks_theme_name
+      theme_name.presence || SiteSetting.instance(site).theme_name
+    end
+
+    def blocks_base_assigns
+      @blocks_base_assigns ||= {
+        "site" => site_context,
+        "globals" => globals_context,
+        "nav" => nav_context,
+        "forms" => forms_context
+      }.merge(Plum.content_sources_for(controller, site: site))
+    end
+
+    def blocks_registers
+      base_url = theme_asset_base_url
+      {
+        theme_asset_url_builder: ->(path) { ThemeAssetPath.url(base_url: base_url, path: path) },
+        form_renderer: ->(handle) { FormRenderer.new(forms_context[handle]).render }
+      }
+    end
+
+    def asset_cache
+      @asset_cache ||= Asset.for_site(site).with_attached_file.index_by(&:id)
+    end
+
+    def relationship_entry_cache
+      @relationship_entry_cache ||= Entry.for_site(site).live.includes(:content_type).index_by(&:id)
+    end
+
+    def live_entries_by_type
+      @live_entries_by_type ||= Entry.for_site(site).live
+                                    .includes(:content_type, terms: :taxonomy)
+                                    .order(published_at: :desc, created_at: :desc)
+                                    .group_by(&:content_type_id)
+    end
+
+    def public_root_path
+      controller.request.script_name.presence || "/"
+    end
+
+    def theme_asset_base_url
+      "#{controller.request.script_name.to_s.chomp("/")}/theme_assets/#{theme_name.presence || site.theme_name}"
+    end
+
+    def public_entry_path(entry)
+      path = [ entry.content_type.route_prefix, entry.slug ].compact.join("/")
+      "#{controller.request.script_name.to_s.chomp("/")}/#{path}"
+    end
+
+    def public_form_path(form)
+      "#{controller.request.script_name.to_s.chomp("/")}/forms/#{form.handle}"
+    end
+
+    def form_authenticity_token
+      controller.send(:form_authenticity_token) if controller.respond_to?(:form_authenticity_token, true)
+    end
+  end
+end

data/app/services/plum/liquid_filters.rb

@@ -0,0 +1,58 @@
+require "redcarpet"
+require "nokogiri"
+
+module Plum
+  module LiquidFilters
+    def markdown(input)
+      return "" if input.blank?
+
+      text = input.to_s
+      return text if text.match?(/<[a-z][\s\S]*>/i)
+
+      renderer = Redcarpet::Render::HTML.new(
+        hard_wrap: true,
+        link_attributes: { target: "_blank", rel: "noopener" }
+      )
+
+      md = Redcarpet::Markdown.new(renderer,
+        autolink: true,
+        tables: true,
+        fenced_code_blocks: true,
+        strikethrough: true,
+        superscript: true,
+        no_intra_emphasis: true
+      )
+
+      md.render(text)
+    end
+
+    def image_url(input, size = nil)
+      return "" if input.blank?
+      return input["url"].to_s unless size && input.is_a?(Hash)
+
+      input[size].presence || input["url"].to_s
+    end
+
+    def theme_asset_url(input)
+      builder = @context.registers[:theme_asset_url_builder]
+      return "" unless builder
+
+      builder.call(input)
+    end
+
+    def table_of_contents(input)
+      return "" if input.blank?
+
+      headings = Nokogiri::HTML.fragment(input.to_s).css("h2, h3")
+      return "" if headings.empty?
+
+      items = headings.map do |heading|
+        id = heading["id"].presence || heading.text.parameterize
+        label = ERB::Util.html_escape(heading.text)
+        %(<li class="toc-#{heading.name}"><a href="##{id}">#{label}</a></li>)
+      end
+
+      %(<nav class="table-of-contents" aria-label="On this page"><p>On this page</p><ol>#{items.join}</ol></nav>)
+    end
+  end
+end

data/app/services/plum/liquid_renderer.rb

@@ -0,0 +1,49 @@
+require "liquid"
+require_relative "liquid_filters"
+require "plum/liquid_tags/form_tag"
+
+module Plum
+  class LiquidRenderer
+    Liquid::Environment.default.register_tag("form", LiquidTags::FormTag)
+
+    class << self
+      def render_template(template_name, context = {})
+        theme = current_theme(context)
+        resolver = ThemeResolver.new
+        template_path = resolver.find_template(theme, template_name)
+
+        raise "Template not found: #{template_name}" unless template_path
+
+        template_content = File.read(template_path)
+        template = Liquid::Template.parse(template_content)
+        registers = render_registers(context)
+
+        rendered_content = template.render(context, filters: [ LiquidFilters ], registers: registers)
+
+        layout_path = resolver.find_layout(theme)
+        if layout_path
+          layout_content = File.read(layout_path)
+          layout = Liquid::Template.parse(layout_content)
+          layout.render(context.merge("content" => rendered_content), filters: [ LiquidFilters ], registers: registers)
+        else
+          rendered_content
+        end
+      end
+
+      private
+
+      def current_theme(context)
+        context.dig("site", "theme_name").presence || "default"
+      end
+
+      def render_registers(context)
+        base_url = context.dig("site", "theme_asset_base_url").presence || "/theme_assets/#{current_theme(context)}"
+
+        {
+          theme_asset_url_builder: ->(path) { ThemeAssetPath.url(base_url: base_url, path: path) },
+          form_renderer: ->(handle) { FormRenderer.new(context.dig("forms", handle)).render }
+        }
+      end
+    end
+  end
+end