static-site-builder 0.0.1 → 0.1.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 34651b912c8819f93ee3dd7dda4209674306e91ff9040d8343671412ba4a9873
-  data.tar.gz: 32ac2a4ce16874db16d7990607dbc557ab18fa0235670681377aabb0baf78684
+  metadata.gz: cfa2d9ecc9c90e973fd3cecd6c04e2aad09a80fa29ba0bd78a95b524206986c4
+  data.tar.gz: 2394ef787382dec487390d4b05a1add37a27e3e9154f032f82d9972fae25924e
 SHA512:
-  metadata.gz: 96ace8067d05e208f9d26061962558fc9bfef30196e703be13249573612fb674ab496e6e052522e5c8ab6006b39b6825108d89a360323b5c4e6d2e9c02badc96
-  data.tar.gz: 2656f4592bf359cd186284ebbba773e83772fda781121e9515cee27d9f72b7fa7e6520c23858464842da95c9fab197782c7a4b510ef2b7cf3cbb0b2e7207be8d
+  metadata.gz: 89d7320b08a5e90d12f7c155a8f2e2b0a7f907b9ff18c53c81632dcc5f49cd90e34d41b1533baf760bd4866a07aa06ad95a6f84ac4d34600ed8a86296a24b25e
+  data.tar.gz: 7db49008d74e0aa849e084edb8a8ccc515c1764c3d97e3fb820e952697d3187dd3723e4f4edb4dc284b1dff5ccf5549de7de282413c4616d619d7a8addb693da

data/CHANGELOG.md

@@ -5,6 +5,45 @@ 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.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 (frontmatter, 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 (frontmatter, js_modules, etc.)
+
+### Changed
+- Improved ERB compilation to support partial rendering
+
 ## [0.0.1] - 2025-11-21
 
 ### Added

data/lib/generator.rb

@@ -70,6 +70,7 @@ module StaticSiteBuilder
       create_build_files
       create_example_pages
       create_readme
+      create_gitignore
 
       puts "\n✓ Site generated successfully!"
       puts "\nNext steps:"
@@ -580,6 +581,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 +627,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 +643,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 +682,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 +728,56 @@ module StaticSiteBuilder
           require "pathname"
 
           namespace :build do
-            desc "Build everything (assets + HTML)"
-            task :all => [:assets, :html] do
+            desc "Build everything (HTML + CSS)"
+            task :all => [:html, :css] 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
           end
 
           namespace :dev do
@@ -750,6 +814,12 @@ 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
           end
 
           namespace :dev do
@@ -887,7 +957,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 +965,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 +1007,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,117 @@ 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
+
+      # 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)
+      
+      
+      # 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 ERB content
-      page_content = ERB.new(content).result(page_binding)
+      # 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 +413,65 @@ module StaticSiteBuilder
         page_content = annotate_template(page_content, relative_template_path.to_s)
       end
 
-      page_binding.local_variable_set(:page_content, page_content)
+      # Set title and metadata from PageHelpers before rendering layout
+      puts "  DEBUG: About to set metadata for #{current_page_path}"
+      page_helpers_path = @root.join('lib', 'page_helpers.rb')
+      puts "  DEBUG: Checking PageHelpers at: #{page_helpers_path} (exists: #{page_helpers_path.exist?})"
+      begin
+        if page_helpers_path.exist?
+          require page_helpers_path.to_s
+          pages = ::PageHelpers::PAGES rescue nil
+          puts "  Pages loaded: #{pages ? 'yes' : 'no'}, keys: #{pages&.keys&.inspect}"
+          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])
+            puts "  ✓ Set metadata for #{current_page_path}: #{metadata[:title]}"
+          else
+            puts "  ⚠ No metadata found for #{current_page_path}"
+          end
+        end
+      rescue => e
+        puts "  ⚠ Error loading PageHelpers: #{e.class} - #{e.message}"
+        puts e.backtrace.first(3)
+      end
 
-      # 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 +537,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.3"
 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.3
 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: '8.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '8.0'
 - !ruby/object:Gem::Dependency
   name: base64
   requirement: !ruby/object:Gem::Requirement