rails_site_engine 0.6.2

data/lib/generators/rails_site_engine/install/templates/site_profiles/software-contracting/content/pages/privacy.md

@@ -0,0 +1,43 @@
+---
+title: "Privacy Policy"
+description: "How <%= business_name %> collects, uses, and protects your information."
+path: "/privacy"
+template: "standard"
+show_title: true
+lead: "This page explains what information we collect, how we use it, and your choices."
+sections:
+  - type: rich_text
+---
+
+## Information We Collect
+When you use our contact form, we may collect your name, email address, phone number, and the details in your message.
+
+Our form also includes a hidden `website` field used as an anti-spam honeypot. Legitimate visitors should leave this field empty.
+
+## How We Use Information
+We use inquiry details to:
+
+- respond to your questions and requests
+- follow up about potential work
+- keep basic records of conversations and project requests
+- improve service and communication
+
+## Sharing and Disclosure
+We do not sell or rent your personal information.
+
+We may share information with trusted service providers only when needed to operate this site or process communications (for example, email delivery). We may also disclose information if required by law.
+
+## Retention
+We keep inquiry information only as long as needed for legitimate business purposes, legal compliance, and recordkeeping. When information is no longer needed, we delete it or anonymize it.
+
+## Security
+We use reasonable technical and organizational safeguards to protect personal information. No internet transmission or storage method is 100% secure, but we work to reduce risk.
+
+## Your Choices
+You can request access, correction, or deletion of personal information you have submitted to us.
+
+## Changes to This Policy
+We may update this Privacy Policy from time to time. Updates are effective when posted on this page.
+
+## Contact
+For privacy questions or requests, use the contact details listed on the [Contact page](/contact).

data/lib/generators/rails_site_engine/install/templates/site_profiles/software-contracting/content/pages/projects.md

@@ -0,0 +1,27 @@
+---
+title: "Projects"
+description: "Past client projects by <%= business_name %>."
+path: "/projects"
+template: "standard"
+show_title: true
+lead: "Recent engagements focused on lead generation, speed, and maintainability."
+sections:
+  - type: project_cards
+    heading: "Past projects"
+    items:
+      - title: "Northline Plumbing Website"
+        summary: "Rebuilt a local plumbing site with clearer offers and lead capture."
+        stack: "Rails, Tailwind, daisyUI"
+        url: "https://example.com/projects/northline"
+        outcome: "42% increase in contact form submissions in 60 days."
+      - title: "Oakridge Carpentry Refresh"
+        summary: "Migrated a legacy WordPress site to a faster, easier-to-maintain stack."
+        stack: "Rails, Propshaft, Stimulus"
+        url: "https://example.com/projects/oakridge"
+        outcome: "Cut page load times by 58% and simplified content updates."
+      - title: "Atlas Electrical Lead Funnel"
+        summary: "Built dedicated service landing pages tied to paid campaigns."
+        stack: "Rails, PostgreSQL, analytics events"
+        url: "https://example.com/projects/atlas"
+        outcome: "Reduced cost per qualified lead by 31%."
+---

data/lib/generators/rails_site_engine/install/templates/site_profiles/software-contracting/content/site.yml

@@ -0,0 +1,38 @@
+site:
+  locale: "en"
+  name: "<%= business_name %>"
+  base_url: "https://example.com"
+
+navigation:
+  primary:
+    - label: "Home"
+      page: "home"
+    - label: "Projects"
+      page: "projects"
+    - label: "Pricing"
+      page: "pricing"
+    - label: "About"
+      page: "about"
+    - label: "Contact"
+      page: "contact"
+  footer:
+    - label: "Privacy"
+      page: "privacy"
+
+branding:
+  logo_text: "<%= business_name %>"
+  primary_cta:
+    label: "Book a discovery call"
+    page: "contact"
+
+contact:
+  page: "contact"
+  recipient_email: "leads@example.com"
+  phone: "(555) 123-4567"
+  email: "hello@example.com"
+
+seo:
+  default_title: "<%= business_name %>"
+  default_description: "Custom software and website delivery with hosting and maintenance included."
+  default_og_image: "/images/og-default.jpg"
+  twitter_handle: ""

data/lib/rails_site_engine/content/store.rb

@@ -0,0 +1,297 @@
+require "pathname"
+require "yaml"
+
+module RailsSiteEngine
+  module Content
+    class RoutingConfigError < StandardError; end
+
+    Page = Struct.new(
+      :id,
+      :slug,
+      :path,
+      :title,
+      :description,
+      :template,
+      :show_title,
+      :lead,
+      :og_image,
+      :twitter_title,
+      :twitter_description,
+      :sections,
+      :body_markdown,
+      :body_html,
+      keyword_init: true
+    )
+
+    class Store
+      RESERVED_PATHS = [ "/robots.txt", "/sitemap.xml" ].freeze
+      ALLOWED_TEMPLATES = %w[landing standard contact].freeze
+
+      def initialize(
+        root_path: nil,
+        host_config: RailsSiteEngine::SiteEngineConfig.new
+      )
+        @host_config = host_config
+
+        if root_path
+          root = Pathname.new(root_path)
+          @override_site_config_path = root.join("site.yml")
+          @override_pages_path = root.join("pages")
+        else
+          @override_site_config_path = @host_config.override_site_config_path
+          @override_pages_path = @host_config.override_pages_path
+        end
+      end
+
+      def site_config
+        @site_config ||= load_yaml(@override_site_config_path)
+      end
+
+      def site_locale
+        configured_locale = site_config.dig("site", "locale").to_s.strip
+        return I18n.default_locale.to_s if configured_locale.blank?
+
+        available_locales = I18n.available_locales.map(&:to_s)
+        return configured_locale if available_locales.include?(configured_locale)
+
+        I18n.default_locale.to_s
+      end
+
+      def contact_page_id
+        site_config.dig("contact", "page").to_s.strip.presence || "contact"
+      end
+
+      def page(page_id)
+        page_id = page_id.to_s.strip
+        return nil if page_id.empty?
+
+        parsed = parsed_page_content(page_id)
+        return nil unless parsed
+
+        frontmatter = parsed[:frontmatter]
+        body_markdown = parsed[:body_markdown]
+        template = resolved_template(page_id, frontmatter)
+        sections = normalized_sections(frontmatter, body_markdown, template)
+
+        Page.new(
+          id: page_id,
+          slug: page_id,
+          path: path_for_page(page_id),
+          title: frontmatter["title"].to_s.strip.presence,
+          description: frontmatter["description"].to_s.strip.presence,
+          template: template,
+          show_title: resolved_show_title(frontmatter),
+          lead: frontmatter["lead"].to_s.strip.presence,
+          og_image: frontmatter["og_image"].to_s.strip.presence,
+          twitter_title: frontmatter["twitter_title"].to_s.strip.presence,
+          twitter_description: frontmatter["twitter_description"].to_s.strip.presence,
+          sections: sections,
+          body_markdown: body_markdown,
+          body_html: RailsSiteEngine::MarkdownRenderer.render(body_markdown)
+        )
+      end
+
+      def page_for_path(request_path)
+        page_id = route_map[normalize_request_path(request_path)]
+        return nil unless page_id
+
+        page(page_id)
+      end
+
+      def path_for_page(page_id)
+        page_id = page_id.to_s.strip
+        return nil if page_id.empty?
+
+        page_path_map[page_id]
+      end
+
+      def page_ids
+        @page_ids ||= begin
+          if @override_pages_path.directory?
+            @override_pages_path.glob("*.md").map { |path| path.basename(".md").to_s }.sort
+          else
+            []
+          end
+        end
+      end
+
+      def page_slugs = page_ids
+
+      def page_paths
+        route_map.keys.sort_by { |path| path == "/" ? "" : path }
+      end
+
+      private
+
+      def parsed_pages
+        @parsed_pages ||= page_ids.each_with_object({}) do |page_id, memo|
+          source = page_source(page_id)
+          next if source.nil?
+
+          frontmatter, body_markdown = parse_frontmatter_and_body(source)
+          memo[page_id] = {
+            frontmatter: frontmatter,
+            body_markdown: body_markdown.to_s
+          }
+        end
+      end
+
+      def parsed_page_content(page_id)
+        parsed_pages[page_id]
+      end
+
+      def route_map
+        @route_map ||= build_route_map
+      end
+
+      def page_path_map
+        @page_path_map ||= route_map.each_with_object({}) do |(path, page_id), memo|
+          memo[page_id] = path
+        end
+      end
+
+      def build_route_map
+        routes = {}
+        errors = []
+
+        page_ids.each do |page_id|
+          parsed = parsed_page_content(page_id)
+          frontmatter = parsed ? parsed[:frontmatter] : {}
+
+          path = normalize_config_path(frontmatter["path"])
+          path ||= default_path_for_page(page_id)
+
+          if path.blank?
+            errors << "content/pages/#{page_id}.md path must be a non-empty path"
+            next
+          end
+
+          if RESERVED_PATHS.include?(path)
+            errors << "content/pages/#{page_id}.md path cannot use reserved path #{path.inspect}"
+            next
+          end
+
+          if (conflict = routes[path]).present? && conflict != page_id
+            errors << "routing path #{path.inspect} is duplicated by #{conflict.inspect} and #{page_id.inspect}"
+            next
+          end
+
+          routes[path] = page_id
+        end
+
+        handle_routing_errors(errors)
+        routes
+      end
+
+      def default_path_for_page(page_id)
+        page_id == "home" ? "/" : "/#{page_id}"
+      end
+
+      def normalize_request_path(path)
+        normalize_path(path, blank: "/")
+      end
+
+      def normalize_config_path(path)
+        normalize_path(path, blank: nil)
+      end
+
+      def normalize_path(path, blank:)
+        value = path.to_s.strip
+        return blank if value.empty?
+
+        value = "/#{value}" unless value.start_with?("/")
+        value = value.gsub(%r{/+}, "/")
+        value = value.delete_suffix("/") unless value == "/"
+        value
+      end
+
+      def resolved_template(page_id, frontmatter)
+        configured_template = frontmatter["template"].to_s.strip.presence
+        template = configured_template || default_template_for_page(page_id)
+        ALLOWED_TEMPLATES.include?(template) ? template : default_template_for_page(page_id)
+      end
+
+      def default_template_for_page(page_id)
+        return "contact" if page_id == contact_page_id
+        return "landing" if page_id == "home"
+
+        "standard"
+      end
+
+      def resolved_show_title(frontmatter)
+        value = frontmatter["show_title"]
+        return true if value.nil?
+        return value if value == true || value == false
+
+        true
+      end
+
+      def normalized_sections(frontmatter, body_markdown, template)
+        sections = frontmatter["sections"]
+        sections = sections.is_a?(Array) ? sections.filter_map { |section| section.is_a?(Hash) ? section : nil } : []
+
+        if sections.empty? && body_markdown.strip.present?
+          sections = [ { "type" => "rich_text" } ]
+        end
+
+        if template == "contact" && sections.none? { |section| section["type"].to_s.strip == "contact_form" }
+          sections << { "type" => "contact_form" }
+        end
+
+        sections
+      end
+
+      def handle_routing_errors(errors)
+        return if errors.empty?
+
+        message = "rails_site_engine: invalid page path configuration:\n- #{errors.join("\n- ")}"
+
+        if Rails.env.production?
+          Rails.logger.error(message)
+        else
+          raise RoutingConfigError, message
+        end
+      end
+
+      def load_yaml(path)
+        return {} unless path.file?
+
+        YAML.safe_load(
+          path.read,
+          permitted_classes: [],
+          permitted_symbols: [],
+          aliases: false
+        ) || {}
+      rescue Psych::SyntaxError
+        {}
+      end
+
+      def parse_frontmatter_and_body(text)
+        text = text.to_s
+
+        match = text.match(/\A---\s*\n(?<yaml>.*?)\n---\s*\n/m)
+        return [ {}, text ] unless match
+
+        yaml_hash = YAML.safe_load(
+          match[:yaml],
+          permitted_classes: [],
+          permitted_symbols: [],
+          aliases: false
+        ) || {}
+        yaml_hash = {} unless yaml_hash.is_a?(Hash)
+
+        body = text[match.end(0)..] || ""
+        [ yaml_hash, body ]
+      rescue Psych::SyntaxError
+        [ {}, text ]
+      end
+
+      def page_source(page_id)
+        override_path = @override_pages_path.join("#{page_id}.md")
+        return nil unless override_path.file?
+
+        override_path.read
+      end
+    end
+  end
+end

data/lib/rails_site_engine/engine.rb

@@ -0,0 +1,15 @@
+module RailsSiteEngine
+  class Engine < ::Rails::Engine
+    isolate_namespace RailsSiteEngine
+
+    initializer "rails_site_engine.importmap", before: "importmap" do |app|
+      next unless app.config.respond_to?(:importmap)
+
+      app.config.importmap.paths << root.join("config/importmap.rb")
+    end
+
+    initializer "rails_site_engine.assets" do |app|
+      app.config.assets.paths << root.join("app/javascript")
+    end
+  end
+end

data/lib/rails_site_engine/markdown_renderer.rb

@@ -0,0 +1,37 @@
+require "commonmarker"
+
+module RailsSiteEngine
+  module MarkdownRenderer
+    SANITIZE_TAGS = %w[
+      a
+      b
+      blockquote
+      br
+      code
+      em
+      h2
+      h3
+      h4
+      h5
+      h6
+      hr
+      i
+      li
+      ol
+      p
+      pre
+      strong
+      ul
+    ].freeze
+
+    SANITIZE_ATTRIBUTES = %w[href title].freeze
+
+    def self.render(markdown)
+      markdown = markdown.to_s
+      return "".html_safe if markdown.strip.empty?
+
+      html = Commonmarker.to_html(markdown)
+      ActionController::Base.helpers.sanitize(html, tags: SANITIZE_TAGS, attributes: SANITIZE_ATTRIBUTES)
+    end
+  end
+end

data/lib/rails_site_engine/profile_defaults.rb

@@ -0,0 +1,83 @@
+require "erb"
+require "pathname"
+require "yaml"
+
+module RailsSiteEngine
+  class ProfileDefaults
+    def initialize(profile:, business_name:, site_profiles: nil)
+      @profile = profile.to_s.strip
+      @business_name = business_name.to_s
+      @site_profiles =
+        site_profiles || RailsSiteEngine::SiteProfiles.new(path: RailsSiteEngine::Engine.root.join("config/site_profiles.yml"))
+    end
+
+    def profile_key
+      return @profile if @site_profiles.valid_concrete_profile?(@profile)
+
+      @site_profiles.fallback_concrete_profile
+    end
+
+    def site_config
+      @site_config ||= load_yaml_from_template("content/site.yml")
+    end
+
+    def theme_config
+      @theme_config ||= load_yaml_from_template("config/theme.yml")
+    end
+
+    def page_ids
+      return [] unless pages_root.directory?
+
+      pages_root.glob("*.md").map { |path| path.basename(".md").to_s }.sort
+    end
+
+    def page_content(page_id)
+      path = pages_root.join("#{page_id}.md")
+      return nil unless path.file?
+
+      render_template(path.read)
+    end
+
+    private
+
+    def template_root
+      @template_root ||= begin
+        concrete_profile = profile_key
+        return nil if concrete_profile.to_s.empty?
+
+        @site_profiles.template_root_for(concrete_profile)
+      end
+    end
+
+    def pages_root
+      return Pathname.new("/nonexistent") if template_root.nil?
+
+      template_root.join("content/pages")
+    end
+
+    def load_yaml_from_template(relative_path)
+      return {} if template_root.nil?
+
+      path = template_root.join(relative_path)
+      return {} unless path.file?
+
+      payload = YAML.safe_load(
+        render_template(path.read),
+        permitted_classes: [],
+        permitted_symbols: [],
+        aliases: false
+      ) || {}
+      payload.is_a?(Hash) ? payload : {}
+    rescue Psych::SyntaxError
+      {}
+    end
+
+    def render_template(template)
+      ERB.new(template.to_s).result_with_hash(
+        business_name: @business_name
+      )
+    rescue StandardError
+      template.to_s
+    end
+  end
+end

data/lib/rails_site_engine/site_engine_config.rb

@@ -0,0 +1,78 @@
+require "pathname"
+require "yaml"
+
+module RailsSiteEngine
+  class SiteEngineConfig
+    DEFAULT_PROFILE = "home-services-general".freeze
+    DEFAULT_SITE_CONFIG_PATH = "content/site.yml".freeze
+    DEFAULT_PAGES_PATH = "content/pages".freeze
+    DEFAULT_THEME_PATH = "config/theme.yml".freeze
+
+    def initialize(path: Rails.root.join("config/site_engine.yml"), site_profiles: nil)
+      @path = Pathname.new(path)
+      @site_profiles =
+        site_profiles || RailsSiteEngine::SiteProfiles.new(path: RailsSiteEngine::Engine.root.join("config/site_profiles.yml"))
+    end
+
+    def profile
+      requested = raw_config["profile"].to_s.strip
+      return requested if @site_profiles.valid_concrete_profile?(requested)
+
+      @site_profiles.fallback_concrete_profile || DEFAULT_PROFILE
+    end
+
+    def business_name
+      configured = raw_config["business_name"].to_s.strip
+      return configured unless configured.empty?
+
+      inferred_business_name
+    end
+
+    def override_site_config_path
+      configured_path("site_config_path", DEFAULT_SITE_CONFIG_PATH)
+    end
+
+    def override_pages_path
+      configured_path("pages_path", DEFAULT_PAGES_PATH)
+    end
+
+    def override_theme_path
+      configured_path("theme_path", DEFAULT_THEME_PATH)
+    end
+
+    private
+
+    def raw_config
+      @raw_config ||= load_yaml(@path)
+    end
+
+    def load_yaml(path)
+      return {} unless path.file?
+
+      payload = YAML.safe_load(
+        path.read,
+        permitted_classes: [],
+        permitted_symbols: [],
+        aliases: false
+      ) || {}
+
+      payload.is_a?(Hash) ? payload : {}
+    rescue Psych::SyntaxError
+      {}
+    end
+
+    def configured_path(key, fallback)
+      value = raw_config.dig("overrides", key).to_s.strip
+      value = fallback if value.empty?
+
+      path = Pathname.new(value)
+      path.absolute? ? path : Rails.root.join(path)
+    end
+
+    def inferred_business_name
+      app_name = Rails.application.class.module_parent_name.to_s
+      normalized = app_name.gsub(/([a-z])([A-Z])/, '\1 \2').tr("_", " ").strip
+      normalized.empty? ? "Your Business" : normalized
+    end
+  end
+end