static-site-builder 0.0.1 → 0.1.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 34651b912c8819f93ee3dd7dda4209674306e91ff9040d8343671412ba4a9873
-  data.tar.gz: 32ac2a4ce16874db16d7990607dbc557ab18fa0235670681377aabb0baf78684
+  metadata.gz: 4ec7765f3cc618a791a6d655fed75fe39f43a09d9c697cc71135d17160dbd27f
+  data.tar.gz: 74ace48bd713ba712607509baf63a80095cd610395be622b59c3e552336f10df
 SHA512:
-  metadata.gz: 96ace8067d05e208f9d26061962558fc9bfef30196e703be13249573612fb674ab496e6e052522e5c8ab6006b39b6825108d89a360323b5c4e6d2e9c02badc96
-  data.tar.gz: 2656f4592bf359cd186284ebbba773e83772fda781121e9515cee27d9f72b7fa7e6520c23858464842da95c9fab197782c7a4b510ef2b7cf3cbb0b2e7207be8d
+  metadata.gz: 358643b7c2cb4bd56693c18fa4f57114da85b519a1423e319a55d1b4d7ee0d3190768985225539e6c65f9eed044d96fced689d5464d39fb0db85238dbcb4e6d4
+  data.tar.gz: a8ab43edfdac947a34e0222c181037213120eb1f9dea91c924f218e974908c51491135ce475aadde6552bedd65698cf05a54e18af60b73669b6c6fe7134cb84a

data/CHANGELOG.md

@@ -5,6 +5,66 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.1.4] - 2025-11-22
+
+### Added
+- Generator now automatically creates `lib/page_helpers.rb` with `PageHelpers::PAGES` structure for page metadata
+- Generator now automatically creates `config/sitemap.rb` for sitemap generation
+- `sitemap_generator` gem is now automatically included in generated Gemfiles
+- `build:sitemap` task is automatically added to generated Rakefiles
+- Sitemap generation is integrated into `build:all` task
+
+### Changed
+- Page metadata is now managed via `PageHelpers::PAGES` hash instead of frontmatter
+- README updated to reflect `PageHelpers::PAGES` approach (frontmatter example removed)
+- ActionView requirement changed from `>= 8.0` to `~> 7.1` for Ruby 3.1 compatibility
+- Generated layouts now use `@title` and `@js_modules` instance variables instead of frontmatter
+
+### Fixed
+- Fixed `js_modules` variable reference in generated layouts (now uses `@js_modules`)
+- Fixed PageHelpers metadata loading to occur before page content rendering, allowing partials to access `@title`, `@description`, etc.
+- Removed all frontmatter parsing code and references
+- Updated all specs to use `PageHelpers::PAGES` instead of frontmatter
+
+## [0.1.3] - 2025-11-22
+
+### Added
+- Integrated ActionView 8+ for proper Rails-style partial rendering
+- Support for Rails-style render syntax: `render 'shared/header'` and `render partial: 'shared/header'`
+- Support for passing locals to partials: `render partial: 'shared/header', locals: { title: 'Hello' }`
+- Nested partial support (partials can render other partials)
+- Multiple partials on the same page now work correctly
+
+### Changed
+- Replaced raw ERB implementation with ActionView::Base for template rendering
+- Render method now uses ActionView's rendering system, matching Rails behaviour exactly
+- Partials automatically receive page variables (@js_modules, importmap_json, current_page)
+- Improved error messages for missing partials (converted from ActionView format for backwards compatibility)
+- Template annotations now preserve both page and layout annotations correctly
+
+### Fixed
+- Fixed issue where nested partials (partials rendering other partials) would fail or produce incorrect output
+- Fixed issue where multiple partials on the same page would only render the last one
+- Fixed template annotations being stripped when layout annotations were added
+
+## [0.1.2] - 2025-11-22
+
+### Fixed
+- CSS directory is now always created when Tailwind handles CSS compilation, preventing 404 errors for stylesheets
+- Build process now updates files in place instead of cleaning and recreating the dist directory, preventing 404 errors during rebuilds in development mode
+- Fixed race condition where pages would return 404 when code changes triggered rebuilds
+
+## [0.1.1] - 2025-11-21
+
+### Added
+- `render` helper method for ERB templates to include partials
+- Support for rendering partials from `app/views/shared/` directory
+- Partial files should be named with `_` prefix (e.g., `_header.html.erb`)
+- Partials have access to page variables (@js_modules, etc.)
+
+### Changed
+- Improved ERB compilation to support partial rendering
+
 ## [0.0.1] - 2025-11-21
 
 ### Added
@@ -15,7 +75,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - Support for multiple JavaScript bundlers (Importmap, ESBuild, Webpack, Vite, None)
 - Support for multiple CSS frameworks (TailwindCSS, shadcn/ui, Plain CSS)
 - Support for multiple JavaScript frameworks (Stimulus, React, Vue, Alpine.js, Vanilla)
-- Frontmatter parsing for ERB pages
+- Page metadata via `PageHelpers::PAGES` hash
 - Layout support with nested layouts
 - Importmap JSON generation
 - Asset copying (JavaScript, CSS, vendor files, static files)

data/README.md

@@ -48,11 +48,12 @@ A clean project structure that depends on gems:
 
 ```
 my-site/
-├── Gemfile              # Dependencies (static-site-builder, importmap-rails, etc.)
+├── Gemfile              # Dependencies (static-site-builder, sitemap_generator, etc.)
 ├── package.json         # JS dependencies (if needed)
-├── Rakefile            # Build tasks
+├── Rakefile            # Build tasks (includes sitemap generation)
 ├── config/
-│   └── importmap.rb    # Importmap config (if using importmap)
+│   ├── importmap.rb    # Importmap config (if using importmap)
+│   └── sitemap.rb      # Sitemap generation config
 ├── app/
 │   ├── views/
 │   │   ├── layouts/
@@ -61,7 +62,8 @@ my-site/
 │   ├── javascript/
 │   └── assets/
 └── lib/
-    └── site_builder.rb   # Compiles your site
+    ├── site_builder.rb   # Compiles your site
+    └── page_helpers.rb   # Page metadata (title, description, etc.)
 ```
 
 ## How It Works
@@ -109,18 +111,32 @@ my-site/
 
 ### Using ERB Templates
 
-Create pages in `app/views/pages/` with frontmatter:
+Create pages in `app/views/pages/`:
 
 ```erb
----
-title: My Page
-description: A great page
----
-
 <h1><%= @title %></h1>
 <p><%= @description %></p>
 ```
 
+Page metadata is automatically configured in `lib/page_helpers.rb` (generated automatically):
+
+```ruby
+module PageHelpers
+  PAGES = {
+    '/' => {
+      title: 'My Page',
+      description: 'A great page',
+      url: 'https://example.com',
+      image: 'https://example.com/image.jpg',
+      priority: 1.0,
+      changefreq: 'weekly'
+    }
+  }.freeze
+end
+```
+
+The builder automatically loads metadata from `PageHelpers::PAGES` and sets `@title`, `@description`, `@url`, and `@image` instance variables for use in your templates. This metadata is also used by the `sitemap_generator` gem for generating sitemaps.
+
 Use layouts in `app/views/layouts/application.html.erb`:
 
 ```erb
@@ -214,6 +230,18 @@ Install components and use them in your templates:
 npx shadcn-ui@latest add button
 ```
 
+### Generating Sitemaps
+
+Sitemap generation is automatically configured when you generate a new site. The `sitemap_generator` gem is included in the Gemfile, and `config/sitemap.rb` is automatically created.
+
+The sitemap is generated from your `PageHelpers::PAGES` metadata during `rake build:all`. Update `config/sitemap.rb` to set your domain:
+
+```ruby
+SitemapGenerator::Sitemap.default_host = 'https://yourdomain.com'
+```
+
+The sitemap will be generated in `dist/sitemaps/sitemap.xml.gz` during the build process.
+
 ## Examples
 
 ### ERB + Importmap + Stimulus + TailwindCSS

data/lib/generator.rb

@@ -68,8 +68,11 @@ module StaticSiteBuilder
       create_config_files
       create_app_structure
       create_build_files
+      create_page_helpers
+      create_sitemap_config
       create_example_pages
       create_readme
+      create_gitignore
 
       puts "\n✓ Site generated successfully!"
       puts "\nNext steps:"
@@ -103,7 +106,8 @@ module StaticSiteBuilder
       gems = [
         "rake",
         "static-site-builder",
-        "webrick"  # Required for dev server (removed from stdlib in Ruby 3.0+)
+        "webrick",  # Required for dev server (removed from stdlib in Ruby 3.0+)
+        "sitemap_generator"  # For generating sitemaps from PageHelpers::PAGES
       ]
       gems << "importmap-rails" if @options[:js_bundler] == "importmap"
       gems << "phlex-rails" if @options[:template_engine] == "phlex"
@@ -185,6 +189,78 @@ module StaticSiteBuilder
       create_rails_config if @options[:edit_rails]
     end
 
+    def create_page_helpers
+      content = <<~RUBY
+        # frozen_string_literal: true
+
+        module PageHelpers
+          # Page metadata configuration
+          # The builder automatically loads this and sets @title, @description, @url, and @image
+          # instance variables for use in your templates.
+          # This metadata is also used by sitemap_generator for generating sitemaps.
+          PAGES = {
+            '/' => {
+              title: 'Home',
+              description: 'Welcome to my site',
+              url: 'https://example.com',
+              image: 'https://example.com/image.jpg',
+              priority: 1.0,
+              changefreq: 'weekly'
+            }
+          }.freeze
+
+          def page_title(path = nil)
+            path ||= @current_page
+            PAGES[path]&.fetch(:title) || 'Site'
+          end
+
+          def page_description(path = nil)
+            path ||= @current_page
+            PAGES[path]&.fetch(:description) || 'A static site'
+          end
+
+          def page_url(path = nil)
+            path ||= @current_page
+            PAGES[path]&.fetch(:url) || 'https://example.com'
+          end
+
+          def page_image(path = nil)
+            path ||= @current_page
+            PAGES[path]&.fetch(:image) || 'https://example.com/image.jpg'
+          end
+        end
+      RUBY
+
+      write_file("lib/page_helpers.rb", content)
+    end
+
+    def create_sitemap_config
+      content = <<~RUBY
+        # frozen_string_literal: true
+
+        require 'sitemap_generator'
+        require_relative '../lib/page_helpers'
+
+        # Configure sitemap generator
+        # Update default_host to your actual domain
+        SitemapGenerator::Sitemap.default_host = 'https://example.com'
+        SitemapGenerator::Sitemap.sitemaps_path = 'sitemaps'
+        SitemapGenerator::Sitemap.public_path = 'dist'
+
+        # Generate sitemap from PageHelpers::PAGES
+        SitemapGenerator::Sitemap.create do
+          PageHelpers::PAGES.each do |path, metadata|
+            add path,
+                lastmod: Time.now,
+                priority: metadata[:priority] || 0.5,
+                changefreq: metadata[:changefreq] || 'weekly'
+          end
+        end
+      RUBY
+
+      write_file("config/sitemap.rb", content)
+    end
+
     def create_importmap_config
       content = <<~RUBY
         # frozen_string_literal: true
@@ -409,7 +485,7 @@ module StaticSiteBuilder
         <head>
           <meta charset="UTF-8">
           <meta name="viewport" content="width=device-width, initial-scale=1.0">
-          <title><%= frontmatter['title'] || 'Site' %></title>
+          <title><%= @title || 'Site' %></title>
           <link rel="stylesheet" href="/assets/stylesheets/application.css">
         </head>
         <body>
@@ -469,8 +545,8 @@ module StaticSiteBuilder
       case @options[:js_bundler]
       when "importmap"
         <<~ERB
-          <% if js_modules && !js_modules.empty? %>
-            <% js_modules.each do |module_name| %>
+          <% if @js_modules.present? %>
+            <% @js_modules.each do |module_name| %>
               <script type="module">import "<%= module_name %>";</script>
             <% end %>
           <% else %>
@@ -580,6 +656,18 @@ module StaticSiteBuilder
           @tailwind base;
           @tailwind components;
           @tailwind utilities;
+
+          @layer base {
+            html {
+              scroll-behavior: smooth;
+            }
+          }
+
+          @layer utilities {
+            section[id] {
+              scroll-margin-top: 5rem;
+            }
+          }
         CSS
       when "shadcn"
         write_file("app/assets/stylesheets/application.css", <<~CSS)
@@ -614,6 +702,7 @@ module StaticSiteBuilder
         require "webrick"
         require "fileutils"
         require "static_site_builder/websocket_server"
+        require "json"
 
         port = ENV["PORT"] || 3000
         ws_port = ENV["WS_PORT"] || 3001
@@ -629,13 +718,33 @@ module StaticSiteBuilder
         ENV["WS_PORT"] = ws_port.to_s
         Rake::Task["build:all"].invoke
 
+        # Check if we need to run Tailwind CSS watch (after initial build)
+        tailwind_pid = nil
+        package_json_path = Pathname.new(Dir.pwd).join("package.json")
+        if package_json_path.exist?
+          package_json = JSON.parse(File.read(package_json_path))
+          if package_json.dig("scripts", "watch:css")
+            puts "🎨 Starting Tailwind CSS watch mode..."
+            tailwind_pid = spawn("npm", "run", "watch:css", :err => File::NULL, :out => File::NULL)
+            # Touch the source file to trigger Tailwind watch to process CSS immediately
+            css_source = Pathname.new(Dir.pwd).join("app", "assets", "stylesheets", "application.css")
+            if css_source.exist?
+              FileUtils.touch(css_source)
+            end
+            # Give Tailwind a moment to process CSS
+            sleep 1.5
+          end
+        end
+
         puts "\n🚀 Starting development server at http://localhost:#{port}"
         puts "📡 WebSocket server at ws://localhost:#{ws_port}"
         puts "📝 Watching for changes... (Ctrl+C to stop)"
         puts "🔄 Live reload enabled - pages will auto-refresh on changes\n"
 
-        # Simple file watcher - just rebuild when files change (no relaunch needed)
-        watcher_code = %q{watched = ['app', 'config']; exts = ['.erb', '.rb', '.js', '.css']; mtimes = {}; loop do; changed = false; watched.each do |dir|; Dir.glob(File.join(dir, '**', '*')).each do |f|; next unless File.file?(f) && exts.any? { |e| f.end_with?(e) }; mtime = File.mtime(f); if mtimes[f] != mtime; mtimes[f] = mtime; changed = true; end; end; end; system('rake build:all > /dev/null 2>&1') if changed; sleep 0.5; end}
+        # Simple file watcher - rebuild HTML when non-CSS files change
+        # CSS changes are handled by Tailwind watch, so we skip rebuild for CSS files
+        # When HTML rebuilds, it cleans dist, so we need to rebuild CSS immediately after
+        watcher_code = %q{watched = ['app', 'config']; exts = ['.erb', '.rb', '.js']; mtimes = {}; loop do; changed = false; watched.each do |dir|; Dir.glob(File.join(dir, '**', '*')).each do |f|; next unless File.file?(f) && exts.any? { |e| f.end_with?(e) }; next if f.end_with?('.css'); mtime = File.mtime(f); if mtimes[f] != mtime; mtimes[f] = mtime; changed = true; end; end; end; if changed; system('rake build:html > /dev/null 2>&1 && rake build:css > /dev/null 2>&1'); end; sleep 0.5; end}
         watcher_pid = spawn("ruby", "-e", watcher_code, :err => File::NULL)
 
         # Start web server
@@ -648,6 +757,7 @@ module StaticSiteBuilder
         trap("INT") do
           puts "\n\nShutting down..."
           Process.kill("TERM", watcher_pid) if watcher_pid
+          Process.kill("TERM", tailwind_pid) if tailwind_pid
           ws_server.stop
           server.shutdown
         end
@@ -693,27 +803,61 @@ module StaticSiteBuilder
           require "pathname"
 
           namespace :build do
-            desc "Build everything (assets + HTML)"
-            task :all => [:assets, :html] do
+            desc "Build everything (HTML + CSS + Sitemap)"
+            task :all => [:html, :css, :sitemap] do
               puts "\\n✓ Build complete!"
             end
 
-            desc "Build JavaScript/CSS assets"
+            desc "Build JavaScript assets"
             task :assets do
-              sh "npm run build" if File.exist?("package.json")
+              if File.exist?("package.json")
+                package_json = JSON.parse(File.read("package.json"))
+                build_script = package_json.dig("scripts", "build")
+                # Only run if build script exists and doesn't include CSS (CSS handled separately)
+                if build_script && !build_script.include?("build:css")
+                  sh "npm run build"
+                end
+              end
             end
 
             desc "Compile all pages to static HTML"
-            task :html do
+            task :html => [:assets] do
               load "lib/site_builder.rb"
             end
 
+            desc "Build CSS (runs after HTML so dist directory exists)"
+            task :css do
+              if File.exist?("package.json")
+                package_json = JSON.parse(File.read("package.json"))
+                if package_json.dig("scripts", "build:css")
+                  sh "npm run build:css"
+                end
+              elsif File.exist?("tailwind.config.js")
+                # Build CSS even if no package.json (standalone Tailwind)
+                if system("which tailwindcss > /dev/null 2>&1")
+                  FileUtils.mkdir_p("dist/assets/stylesheets")
+                  sh "tailwindcss -i ./app/assets/stylesheets/application.css -o ./dist/assets/stylesheets/application.css --minify"
+                end
+              end
+            end
+
             desc "Clean dist directory"
             task :clean do
               dist_dir = Pathname.new(Dir.pwd).join("dist")
               FileUtils.rm_rf(dist_dir) if dist_dir.exist?
               puts "Cleaned \#{dist_dir}"
             end
+
+            desc "Build for production/release (cleans dist directory first)"
+            task :production do
+              ENV["PRODUCTION"] = "true"
+              Rake::Task["build:all"].invoke
+            end
+
+            desc "Generate sitemap from PageHelpers::PAGES"
+            task :sitemap do
+              require './config/sitemap'
+            end
           end
 
           namespace :dev do
@@ -734,8 +878,8 @@ module StaticSiteBuilder
           require "pathname"
 
           namespace :build do
-            desc "Build everything (HTML)"
-            task :all => [:html] do
+            desc "Build everything (HTML + Sitemap)"
+            task :all => [:html, :sitemap] do
               puts "\\n✓ Build complete!"
             end
 
@@ -750,6 +894,17 @@ module StaticSiteBuilder
               FileUtils.rm_rf(dist_dir) if dist_dir.exist?
               puts "Cleaned \#{dist_dir}"
             end
+
+            desc "Build for production/release (cleans dist directory first)"
+            task :production do
+              ENV["PRODUCTION"] = "true"
+              Rake::Task["build:all"].invoke
+            end
+
+            desc "Generate sitemap from PageHelpers::PAGES"
+            task :sitemap do
+              require './config/sitemap'
+            end
           end
 
           namespace :dev do
@@ -887,7 +1042,7 @@ module StaticSiteBuilder
     end
 
     def build_script
-      case @options[:js_bundler]
+      js_build = case @options[:js_bundler]
       when "esbuild"
         "node esbuild.config.js"
       when "webpack"
@@ -895,7 +1050,20 @@ module StaticSiteBuilder
       when "vite"
         "vite build"
       else
-        "echo 'No JS bundling needed'"
+        nil
+      end
+
+      css_build = if needs_css_build?
+        "npm run build:css"
+      else
+        nil
+      end
+
+      builds = [js_build, css_build].compact
+      if builds.empty?
+        "echo 'No bundling needed'"
+      else
+        builds.join(" && ")
       end
     end
 
@@ -924,6 +1092,41 @@ module StaticSiteBuilder
       @options[:css_framework] == "tailwindcss" || @options[:css_framework] == "shadcn"
     end
 
+    def create_gitignore
+      content = <<~GITIGNORE
+        # Dependencies
+        /.bundle/
+        /vendor/bundle
+        /node_modules/
+
+        # Build artifacts
+        *.gem
+        *.gemspec.bak
+        /dist/
+        /tmp/
+        /coverage/
+
+        # Test artifacts
+        /.rspec_status
+
+        # IDE
+        /.idea/
+        /.vscode/
+        *.swp
+        *.swo
+        *~
+
+        # OS
+        .DS_Store
+        Thumbs.db
+
+        # Logs
+        *.log
+      GITIGNORE
+
+      write_file(".gitignore", content)
+    end
+
     def write_file(path, content)
       file_path = @app_path.join(path)
       FileUtils.mkdir_p(file_path.dirname)

data/lib/static_site_builder/builder.rb

@@ -1,5 +1,8 @@
 # frozen_string_literal: true
 
+require "uri"
+require "action_view"
+require "action_view/helpers"
 require "erb"
 require "fileutils"
 require "json"
@@ -49,18 +52,30 @@ module StaticSiteBuilder
     def build
       puts "Building static site..."
 
-      # Clean dist directory
       dist_dir = @root.join("dist")
-      FileUtils.rm_rf(dist_dir) if dist_dir.exist?
+      
+      # Only clean dist directory for production/release builds
+      # In development, update files in place to prevent 404s during rebuilds
+      production_build = ENV["PRODUCTION"] == "true" || ENV["RELEASE"] == "true"
+      if production_build
+        if dist_dir.exist?
+          puts "Cleaning dist directory for production build..."
+          FileUtils.rm_rf(dist_dir)
+        else
+          puts "Dist directory does not exist, skipping clean"
+        end
+      end
+      
+      # Ensure dist directory exists
       FileUtils.mkdir_p(dist_dir)
 
-      # Copy assets
+      # Copy assets (overwrites existing files)
       copy_assets(dist_dir)
 
-      # Generate importmap JSON if using importmap
+      # Generate importmap JSON if using importmap (overwrites existing file)
       generate_importmap(dist_dir) if @js_bundler == "importmap"
 
-      # Compile pages based on template engine
+      # Compile pages based on template engine (overwrites existing files)
       case @template_engine
       when "erb"
         compile_erb_pages(dist_dir)
@@ -68,7 +83,7 @@ module StaticSiteBuilder
         compile_phlex_pages(dist_dir)
       end
 
-      # Copy static files
+      # Copy static files (overwrites existing files)
       copy_static_files(dist_dir)
 
       # Notify WebSocket server (always update, even if file doesn't exist yet)
@@ -78,6 +93,20 @@ module StaticSiteBuilder
       puts "\n✓ Build complete! Output in #{dist_dir}"
     end
 
+    # Public method to render partials - no longer needed as ActionView handles this directly
+    # ActionView's render method automatically finds and renders partials from app/views
+    # This method is kept for backwards compatibility but should not be called
+    def render_partial(partial_path, view_context, locals = {})
+      # ActionView handles partial rendering automatically through its render method
+      # When templates call render 'shared/header', ActionView finds _header.html.erb automatically
+      begin
+        view_context.render(partial: partial_path, locals: locals)
+      rescue ActionView::MissingTemplate => e
+        # Convert ActionView's error to our format for backwards compatibility
+        raise "Partial not found: #{partial_path} (looked for #{e.path})"
+      end
+    end
+
     private
 
     def load_importmap_config
@@ -116,10 +145,18 @@ module StaticSiteBuilder
         copy_vendor_files_from_node_modules(dist_dir)
       end
 
-      # Copy CSS
+      # Copy CSS (skip if Tailwind is handling it - check for tailwind.config.js)
+      # Tailwind outputs directly to dist, so we don't want to overwrite with raw files
+      # But we still need to ensure the directory exists for Tailwind to write to
+      tailwind_config = @root.join("tailwind.config.js")
       css_dir = @root.join("app", "assets", "stylesheets")
-      if css_dir.exist? && css_dir.directory?
-        dist_css = dist_dir.join("assets", "stylesheets")
+      dist_css = dist_dir.join("assets", "stylesheets")
+      
+      if tailwind_config.exist?
+        # Tailwind is handling CSS - ensure directory exists but don't copy raw files
+        FileUtils.mkdir_p(dist_css)
+      elsif css_dir.exist? && css_dir.directory?
+        # No Tailwind - copy CSS files normally
         FileUtils.mkdir_p(dist_css)
         Dir.glob(css_dir.join("*")).each do |item|
           FileUtils.cp_r(item, dist_css, preserve: true)
@@ -223,30 +260,11 @@ module StaticSiteBuilder
     def compile_erb_page(erb_file, page_name, dist_dir, importmap_json_str)
       puts "Compiling #{page_name}..."
 
-      # Read and parse frontmatter
+      # Read ERB content - ActionView will process it directly
       content = File.read(erb_file)
-      frontmatter = {}
+
+      # Default layout
       layout = "application"
-      js_modules = []
-
-      if content.match?(/^---\s*\n/)
-        match = content.match(/^---\s*\n(.*?)\n---\s*\n/m)
-        if match
-          frontmatter_text = match[1]
-          frontmatter_text.each_line do |line|
-            key, value = line.split(":", 2).map(&:strip)
-            case key
-            when "layout"
-              layout = value
-            when "js"
-              js_modules = value.split(",").map(&:strip)
-            else
-              frontmatter[key] = value
-            end
-          end
-          content = content.sub(/^---\s*\n.*?\n---\s*\n/m, "")
-        end
-      end
 
       # Load layout - try .html.erb first, then .html
       layout_file = @root.join("app", "views", "layouts", "#{layout}.html.erb")
@@ -277,14 +295,135 @@ module StaticSiteBuilder
         end
       end
 
-      # Create binding with variables for ERB
-      page_binding = binding
-      page_binding.local_variable_set(:frontmatter, frontmatter)
-      page_binding.local_variable_set(:js_modules, js_modules)
-      page_binding.local_variable_set(:importmap_json, importmap_json_str) if importmap_json_str
+      # Set current_page based on the file being compiled
+      current_page_path = if page_name == 'index.html'
+        '/'
+      else
+        "/#{page_name.gsub(/\.html$/, '')}"
+      end
 
-      # Render ERB content
-      page_content = ERB.new(content).result(page_binding)
+      # Create ActionView lookup context with view paths
+      view_paths = ActionView::PathSet.new([@root.join("app", "views").to_s])
+      lookup_context = ActionView::LookupContext.new(view_paths)
+      
+      # Create ActionView::Base instance for rendering using with_empty_template_cache
+      # This is the recommended way for standalone ActionView usage
+      view_class = ActionView::Base.with_empty_template_cache
+      view = view_class.new(lookup_context, {}, self)
+
+      # Include PageHelpers if available (look in project root)
+      # Only require once (first time)
+      unless defined?(@page_helpers_loaded)
+        begin
+          page_helpers_path = @root.join('lib', 'page_helpers.rb')
+          if page_helpers_path.exist?
+            require page_helpers_path.to_s
+            @page_helpers_loaded = true
+          end
+        rescue LoadError
+          # PageHelpers not available, continue without it
+        end
+      end
+      
+      # Extend view with PageHelpers if available
+      if defined?(PageHelpers)
+        view.extend(PageHelpers) unless view.singleton_class.included_modules.include?(PageHelpers)
+      end
+
+      # Set instance variables that will be available in templates
+      # Pages can set @title, @js_modules, etc. via ERB at the top
+      view.instance_variable_set(:@js_modules, [])
+      view.instance_variable_set(:@importmap_json, importmap_json_str) if importmap_json_str
+      view.instance_variable_set(:@current_page, current_page_path)
+      view.instance_variable_set(:@page_content, nil)
+      
+      # Set title and metadata from PageHelpers BEFORE rendering page content
+      # This ensures partials rendered within the page have access to metadata
+      page_helpers_path = @root.join('lib', 'page_helpers.rb')
+      begin
+        if page_helpers_path.exist?
+          require page_helpers_path.to_s
+          pages = ::PageHelpers::PAGES rescue nil
+          if pages && pages.is_a?(Hash) && pages.key?(current_page_path)
+            metadata = pages[current_page_path]
+            view.instance_variable_set(:@title, metadata[:title])
+            view.instance_variable_set(:@description, metadata[:description])
+            view.instance_variable_set(:@url, metadata[:url])
+            view.instance_variable_set(:@image, metadata[:image])
+          end
+        end
+      rescue => e
+        # Silently continue if PageHelpers can't be loaded
+      end
+      
+      # Override render to handle 'footer' -> 'shared/footer' conversion
+      # and ensure locals are passed to partials
+      view.define_singleton_method(:render) do |options = {}, locals = {}, &block|
+        begin
+          # Handle string/symbol partial names: render 'footer' -> render 'shared/footer'
+          if options.is_a?(String) || options.is_a?(Symbol)
+            partial_name = options.to_s
+            # If no path separator, assume it's in shared/
+            unless partial_name.include?('/')
+              partial_name = "shared/#{partial_name}"
+            end
+            # Merge page locals with any provided locals
+            merged_locals = {
+              importmap_json: importmap_json_str,
+              current_page: current_page_path
+            }.merge(locals.is_a?(Hash) ? locals : {})
+            super(partial: partial_name, locals: merged_locals, &block)
+          elsif options.is_a?(Hash)
+            # Handle hash options: render partial: 'footer', locals: {}
+            partial_path = options[:partial] || options['partial']
+            if partial_path
+              # Convert 'footer' to 'shared/footer' if no path
+              unless partial_path.to_s.include?('/')
+                partial_path = "shared/#{partial_path}"
+              end
+              # Merge page locals with provided locals
+              provided_locals = options[:locals] || options['locals'] || {}
+              merged_locals = {
+                importmap_json: importmap_json_str,
+                current_page: current_page_path
+              }.merge(provided_locals)
+              super(partial: partial_path, locals: merged_locals, &block)
+            else
+              # Other render options (template, etc.)
+              super(options, locals, &block)
+            end
+          else
+            super(options, locals, &block)
+          end
+        rescue ActionView::MissingTemplate => e
+          # Convert ActionView's error to our format for backwards compatibility
+          raise "Partial not found: #{partial_path || partial_name || 'unknown'} (looked for #{e.path})"
+        end
+      end
+
+      # Render page content using ActionView
+      # Pages can set instance variables via ERB (e.g., <% @title = '...' %>)
+      page_template = ActionView::Template.new(
+        content,
+        "inline:page",
+        ActionView::Template::Handlers::ERB.new,
+        virtual_path: "pages/#{page_name.gsub(/\.html$/, '')}",
+        format: :html,
+        locals: [:importmap_json, :current_page]
+      )
+      
+      begin
+        page_content = view.render(template: page_template, locals: {
+          importmap_json: importmap_json_str,
+          current_page: current_page_path
+        })
+      rescue ActionView::Template::Error => e
+        # Convert ActionView errors to our format
+        if e.cause.is_a?(ActionView::MissingTemplate)
+          raise "Partial not found: #{e.cause.path} (looked for #{e.cause.path})"
+        end
+        raise
+      end
 
       # Annotate page content if enabled
       if @annotate_template_file_names
@@ -292,20 +431,40 @@ module StaticSiteBuilder
         page_content = annotate_template(page_content, relative_template_path.to_s)
       end
 
-      page_binding.local_variable_set(:page_content, page_content)
-
-      # Render layout with page content
-      layout_erb = ERB.new(layout_content)
-      rendered = layout_erb.result(page_binding)
+      # Render layout using ActionView
+      # Instance variables set in the page template are available in the layout
+      layout_template = ActionView::Template.new(
+        layout_content,
+        "inline:layout",
+        ActionView::Template::Handlers::ERB.new,
+        virtual_path: "layouts/#{layout}",
+        format: :html,
+        locals: [:page_content, :importmap_json, :current_page]
+      )
+
+      # Mark page_content as HTML safe to prevent escaping
+      # ActionView will escape strings by default in ERB, so we mark it as safe
+      safe_page_content = page_content.respond_to?(:html_safe) ? page_content.html_safe : page_content
+      
+      rendered = view.render(template: layout_template, locals: {
+        page_content: safe_page_content,
+        importmap_json: importmap_json_str,
+        current_page: current_page_path
+      })
 
       # Annotate layout if enabled
+      # Note: We wrap the rendered content without removing existing annotations
+      # This preserves page annotations that are already in the content
       if @annotate_template_file_names && layout_file.exist?
         relative_layout_path = Pathname.new(layout_file).relative_path_from(@root)
-        rendered = annotate_template(rendered, relative_layout_path.to_s)
+        begin_comment = "<!-- BEGIN #{relative_layout_path} -->"
+        end_comment = "<!-- END #{relative_layout_path} -->"
+        rendered = "#{begin_comment}\n#{rendered}\n#{end_comment}"
       end
 
       output_path = dist_dir.join(page_name)
       FileUtils.mkdir_p(output_path.dirname)
+      puts "  Debug: Writing #{rendered.length} chars to #{output_path}"
       File.write(output_path, rendered)
 
       puts "  ✓ Created #{page_name}"
@@ -371,16 +530,16 @@ module StaticSiteBuilder
         <head>
           <meta charset="UTF-8">
           <meta name="viewport" content="width=device-width, initial-scale=1.0">
-          <title><%= frontmatter['title'] || 'Site' %></title>
+          <title><%= @title || 'Site' %></title>
           <link rel="stylesheet" href="/assets/stylesheets/application.css">
         </head>
         <body>
           <%= page_content %>
-          <% if defined?(importmap_json) && importmap_json %>
-            <script type="importmap"><%= importmap_json %></script>
+          <% if defined?(@importmap_json) && @importmap_json %>
+            <script type="importmap"><%= @importmap_json %></script>
           <% end %>
-          <% if js_modules && !js_modules.empty? %>
-            <% js_modules.each do |module_name| %>
+          <% if @js_modules && !@js_modules.empty? %>
+            <% @js_modules.each do |module_name| %>
               <script type="module">import "<%= module_name %>";</script>
             <% end %>
           <% else %>

data/lib/static_site_builder/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module StaticSiteBuilder
-  VERSION = "0.0.1"
+  VERSION = "0.1.4"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: static-site-builder
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.1.4
 platform: ruby
 authors:
 - Lukasz Czapiewski
@@ -9,6 +9,20 @@ bindir: exe
 cert_chain: []
 date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: actionview
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '7.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '7.1'
 - !ruby/object:Gem::Dependency
   name: base64
   requirement: !ruby/object:Gem::Requirement
@@ -114,7 +128,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '3.0'
+      version: '3.1'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="