salvia 0.2.0 → 0.2.2

data/lib/salvia/ssr/quickjs.rb

@@ -15,21 +15,13 @@ module Salvia
         @last_build_error = nil
         @development = options.fetch(:development, true)
         
-        @vm = ::Quickjs::VM.new
-        
-        load_console_shim!
-        
-        if @development
-          load_vendor_bundle!
-        else
-          load_ssr_bundle!
-        end
+        # VM initialization is deferred to thread-local access
         
         mark_initialized!
       end
       
       def shutdown!
-        @vm = nil
+        Thread.current[:salvia_quickjs_vm] = nil
         @js_logs = []
         @initialized = false
         Salvia::Compiler.shutdown if @development
@@ -49,7 +41,24 @@ module Salvia
       private
 
       def vm
-        @vm
+        Thread.current[:salvia_quickjs_vm] ||= create_thread_local_vm
+      end
+      
+      def reset_vm!
+        Thread.current[:salvia_quickjs_vm] = nil
+      end
+
+      def create_thread_local_vm
+        new_vm = ::Quickjs::VM.new
+        load_console_shim!(new_vm)
+        
+        if @development
+          load_vendor_bundle!(new_vm)
+        else
+          load_ssr_bundle!(new_vm)
+        end
+        
+        new_vm
       end
 
       def render_jit(component_name, props)
@@ -59,23 +68,57 @@ module Salvia
             raise Error, "Component not found: #{component_name}"
           end
           
-          # Bundle component
-          js_code = Salvia::Compiler.bundle(
-            path, 
-            externals: ["preact", "preact/hooks", "preact-render-to-string"],
-            format: "iife",
-            global_name: "SalviaComponent"
-          )
+          # Bundle component (with simple memory cache)
+          @bundle_cache ||= {}
+          mtime = File.mtime(path)
           
-          # Async Type Check
-          Thread.new do
+          if @bundle_cache[path].nil? || @bundle_cache[path][:mtime] != mtime
+            # Load externals from deno.json if possible, otherwise use defaults
+            externals = ["preact", "preact/hooks", "preact/jsx-runtime", "preact-render-to-string", "@preact/signals"]
+            
             begin
-              result = Salvia::Compiler.check(path)
-              unless result["success"]
-                log_warn("Type Check Failed for #{component_name}:\n#{result["message"]}")
+              deno_json_path = File.join(Salvia.root, "salvia/deno.json")
+              if File.exist?(deno_json_path)
+                deno_config = JSON.parse(File.read(deno_json_path))
+                if deno_config["imports"]
+                  externals = (externals + deno_config["imports"].keys).uniq
+                end
               end
             rescue => e
-              log_debug("Type Check Error: #{e.message}")
+              log_warn("Failed to load externals from deno.json: #{e.message}")
+            end
+
+            js_code = Salvia::Compiler.bundle(
+              path, 
+              externals: externals,
+              format: "iife",
+              global_name: "SalviaComponent"
+            )
+            @bundle_cache[path] = { code: js_code, mtime: mtime }
+          end
+          
+          js_code = @bundle_cache[path][:code]
+          
+          # Async Type Check (Debounced)
+          @last_check_time ||= {}
+          now = Time.now.to_i
+          
+          # Debounce: Check at most once every 5 seconds per file
+          if @last_check_time[path].nil? || (now - @last_check_time[path]) > 5
+            @last_check_time[path] = now
+            
+            # Use a background thread but avoid spawning too many
+            # Ideally this should be a single worker queue, but for now simple detach is better than nothing
+            Thread.new do
+              begin
+                # Double check inside thread to handle race conditions slightly better
+                result = Salvia::Compiler.check(path)
+                unless result["success"]
+                  log_warn("Type Check Failed for #{component_name}:\n#{result["message"]}")
+                end
+              rescue => e
+                log_debug("Type Check Error: #{e.message}")
+              end
             end
           end
 
@@ -148,7 +191,7 @@ module Salvia
       end
 
       def eval_js(code)
-        result = @vm.eval_code(code)
+        result = vm.eval_code(code)
         process_console_output
         result
       rescue => e
@@ -156,21 +199,24 @@ module Salvia
         raise e
       end
       
-      def load_console_shim!
+      def load_console_shim!(target_vm)
         shim = generate_console_shim
-        @vm.eval_code(shim)
-        @vm.eval_code(Salvia::SSR::DomMock.generate_shim)
+        target_vm.eval_code(shim)
+        target_vm.eval_code(Salvia::SSR::DomMock.generate_shim)
       rescue => e
         log_error("Failed to load console shim: #{e.message}")
       end
       
-      def load_vendor_bundle!
+      def load_vendor_bundle!(target_vm)
         # Use internal vendor_setup.ts for Zero Config
         vendor_path = File.expand_path("../../../assets/scripts/vendor_setup.ts", __dir__)
         
         if File.exist?(vendor_path)
+          # Ensure module.exports shim exists before loading vendor bundle
+          target_vm.eval_code("if(typeof module === 'undefined') { globalThis.module = { exports: {} }; }")
+          
           code = Salvia::Compiler.bundle(vendor_path, format: "iife")
-          eval_js(code)
+          target_vm.eval_code(code)
           log_info("Loaded Vendor bundle (Internal)")
         else
           log_error("Internal vendor_setup.ts not found at #{vendor_path}")
@@ -179,15 +225,27 @@ module Salvia
         log_error("Failed to load vendor bundle: #{e.message}")
       end
       
-      def load_ssr_bundle!
+      def load_ssr_bundle!(target_vm)
         bundle_path = options[:bundle_path] || default_bundle_path
         
         unless File.exist?(bundle_path)
           raise Error, "SSR bundle not found: #{bundle_path}"
         end
         
+        # Check if bundle has changed (simple reload strategy)
+        mtime = File.mtime(bundle_path)
+        if @last_bundle_mtime && @last_bundle_mtime != mtime
+          log_info("SSR bundle changed, reloading...")
+          # Note: In a real scenario, we might need to reset the VM completely
+          # But since this is called inside create_thread_local_vm, we are creating a new VM anyway.
+          # However, if we want to support hot reload in production without restarting threads,
+          # we would need a mechanism to invalidate all thread-local VMs.
+          # For now, we just update the mtime tracking.
+        end
+        @last_bundle_mtime = mtime
+        
         bundle_content = File.read(bundle_path)
-        @vm.eval_code(bundle_content)
+        target_vm.eval_code(bundle_content)
         log_info("Loaded SSR bundle: #{bundle_path}")
       end
       
@@ -196,7 +254,7 @@ module Salvia
       end
       
       def process_console_output
-        logs_json = @vm.eval_code("globalThis.__salvia_flush_logs__()")
+        logs_json = vm.eval_code("globalThis.__salvia_flush_logs__()")
         return if logs_json.nil? || logs_json.empty?
         
         begin
@@ -270,7 +328,12 @@ module Salvia
       end
       
       def escape_html(str)
-        str.to_s.gsub("&", "&amp;").gsub("<", "&lt;").gsub(">", "&gt;").gsub('"', "&quot;")
+        str.to_s
+          .gsub("&", "&amp;")
+          .gsub("<", "&lt;")
+          .gsub(">", "&gt;")
+          .gsub('"', "&quot;")
+          .gsub("'", "&#39;")
       end
       
       def log_info(msg); defined?(Salvia.logger) ? Salvia.logger.info(msg) : puts("[SSR] #{msg}"); end

data/lib/salvia/ssr.rb

@@ -62,11 +62,20 @@ module Salvia
 
       # SSR エンジンを設定
       # @param options [Hash] エンジンオプション
+      # @option options [Symbol] :engine エンジン名 (:quickjs)
       # @option options [String] :bundle_path SSR バンドルのパス
       # @option options [Boolean] :development 開発モード
       def configure(options = {})
-        require_relative "ssr/quickjs"
-        @current_adapter = QuickJS.new(options)
+        engine = options.fetch(:engine, :quickjs)
+        
+        case engine
+        when :quickjs
+          require_relative "ssr/quickjs"
+          @current_adapter = QuickJS.new(options)
+        else
+          raise EngineNotFoundError, "Unknown SSR engine: #{engine}"
+        end
+
         @current_adapter.setup!
         @current_adapter
       end
@@ -76,19 +85,45 @@ module Salvia
       # @param props [Hash] プロパティ
       # @return [String] レンダリングされた HTML
       def render(component_name, props = {})
-        raise Error, "SSR not configured. Call Salvia::SSR.configure first." unless current_adapter
+        ensure_configured!
         current_adapter.render(component_name, props)
       end
 
+      # ページコンポーネントをレンダリング (Import Map 注入 + DOCTYPE)
+      # @param component_name [String] コンポーネント名
+      # @param props [Hash] プロパティ
+      # @param options [Hash] オプション
+      # @return [String] 完全な HTML 文字列
+      def render_page(component_name, props = {}, options = {})
+        html = render(component_name, props)
+        
+        # <head> がある場合、Import Map を自動注入
+        if html.include?("</head>")
+          map = Salvia::Core::ImportMap.generate
+          import_map_html = <<~HTML
+            <script type="importmap">
+              #{map.to_json}
+            </script>
+          HTML
+          html = html.sub("</head>", "#{import_map_html}</head>")
+        end
+        
+        if options.fetch(:doctype, true)
+          html = "<!DOCTYPE html>\n" + html
+        end
+        
+        html
+      end
+
       # コンポーネントを登録
       def register_component(name, code)
-        raise Error, "SSR not configured. Call Salvia::SSR.configure first." unless current_adapter
+        ensure_configured!
         current_adapter.register_component(name, code)
       end
       
       # バンドルをリロード (開発モード用)
       def reload!
-        return unless current_adapter
+        return unless configured?
         current_adapter.reload_bundle! if current_adapter.respond_to?(:reload_bundle!)
       end
       
@@ -98,6 +133,16 @@ module Salvia
         current_adapter.last_build_error = error if current_adapter&.respond_to?(:last_build_error=)
       end
       
+      # ビルドエラーを取得
+      def build_error
+        @last_build_error || (current_adapter&.respond_to?(:last_build_error) ? current_adapter.last_build_error : nil)
+      end
+
+      # ビルドエラーがあるか確認
+      def build_error?
+        !build_error.nil?
+      end
+      
       # ビルドエラーをクリア
       def clear_build_error
         @last_build_error = nil
@@ -114,6 +159,23 @@ module Salvia
       def configured?
         !current_adapter.nil? && current_adapter.initialized?
       end
+
+      private
+
+      def ensure_configured!
+        return if configured?
+        
+        # Auto-configure using defaults from Salvia.config
+        # This handles cases where Salvia.configure wasn't explicitly called
+        # or called before SSR module was fully loaded
+        configure(
+          bundle_path: Salvia.config.ssr_bundle_path,
+          development: Salvia.development?
+        )
+      rescue => e
+        # If auto-configuration fails, we raise the original error to avoid masking it
+        raise Error, "SSR not configured and auto-configuration failed: #{e.message}. Call Salvia::SSR.configure explicitly."
+      end
     end
   end
 end

data/lib/salvia/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Salvia
-  VERSION = "0.2.0"
+  VERSION = "0.2.2"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: salvia
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.2.2
 platform: ruby
 authors:
 - Hiroto Furugen
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2025-12-11 00:00:00.000000000 Z
+date: 2025-12-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rack
@@ -94,8 +94,9 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '5.0'
-description: A standalone SSR engine for Ruby, bringing Islands Architecture to any
-  Rack application without Node.js.
+description: A standalone SSR engine for Ruby that brings Islands Architecture to
+  any Rack application. Write JSX/TSX components and render them server-side without
+  Node.js, JSON APIs, or complex build steps.
 email:
 - hiro_genfuru0119@icloud.com
 executables:
@@ -103,8 +104,10 @@ executables:
 extensions: []
 extra_rdoc_files: []
 files:
+- ".vscode/settings.json"
+- Gemfile
 - LICENSE.txt
-- README.md
+- Rakefile
 - assets/components/Island.tsx
 - assets/islands/Counter.tsx
 - assets/javascripts/islands.js
@@ -114,6 +117,8 @@ files:
 - assets/scripts/deno.lock
 - assets/scripts/sidecar.ts
 - assets/scripts/vendor_setup.ts
+- bin/console
+- bin/setup
 - exe/salvia
 - lib/salvia.rb
 - lib/salvia/cli.rb
@@ -161,5 +166,5 @@ requirements: []
 rubygems_version: 3.4.19
 signing_key:
 specification_version: 4
-summary: Ruby Islands Architecture Engine
+summary: 'Ruby Islands Architecture Engine: SSR with JSX/TSX for Rails & Rack'
 test_files: []

data/README.md

@@ -1,152 +0,0 @@
-# Salvia 🌿
-
-> **The Future of Rails View Layer**
-
-Salvia is a next-generation **Server-Side Rendering (SSR) engine** designed to replace ERB with **JSX/TSX** in Ruby on Rails. It brings the **Islands Architecture** and **True HTML First** philosophy to the Rails ecosystem.
-
-<img src="https://img.shields.io/gem/v/salvia?style=flat-square&color=ff6347" alt="Gem">
-
-## Vision: The Road to Sage
-
-Salvia is the core engine for a future MVC framework called **Sage**.
-While Sage will be a complete standalone framework, Salvia is available *today* as a drop-in replacement for the View layer in **Ruby on Rails**.
-
-## Features
-
-*   🏝️ **Islands Architecture**: Render interactive components (Preact/React) only where needed. Zero JS for static content.
-*   🚀 **True HTML First**: Replace `app/views/**/*.erb` with `app/pages/**/*.tsx`.
-*   ⚡ **JIT Compilation**: No build steps during development. Just run `rails s`.
-*   💎 **Rails Native**: Seamless integration with Controllers, Routes, and Models.
-*   🦕 **Deno Powered**: Uses Deno for lightning-fast TypeScript compilation and formatting.
-
-## Installation
-
-Add this line to your Rails application's Gemfile:
-
-```ruby
-gem 'salvia'
-```
-
-And then execute:
-
-```bash
-$ bundle install
-```
-
-## Getting Started
-
-### 1. Install Salvia
-
-Run the interactive installer to set up Salvia for your Rails project:
-
-```bash
-$ bundle exec salvia install
-```
-
-This creates the `salvia/` directory structure and configures your app with a **Zero Config** setup (Preact + Signals).
-
-### 2. Create a Page (Server Component)
-
-Delete `app/views/home/index.html.erb` and create `salvia/app/pages/home/Index.tsx`:
-
-```tsx
-import { h } from 'preact';
-
-export default function Home({ title }) {
-  return (
-    <div class="p-10">
-      <h1 class="text-3xl font-bold">{title}</h1>
-      <p>This is rendered on the server with 0kb JavaScript sent to the client.</p>
-    </div>
-  );
-}
-```
-
-### 3. Render in Controller
-
-In your Rails controller:
-
-```ruby
-class HomeController < ApplicationController
-  def index
-    # Renders salvia/app/pages/home/Index.tsx
-    render html: ssr("home/Index", title: "Hello Salvia")
-  end
-end
-```
-
-### 4. Add Interactivity (Islands)
-
-Create an interactive component in `salvia/app/islands/Counter.tsx`:
-
-```tsx
-import { h } from 'preact';
-import { useState } from 'preact/hooks';
-
-export default function Counter() {
-  const [count, setCount] = useState(0);
-  return (
-    <button onClick={() => setCount(count + 1)} class="btn">
-      Count: {count}
-    </button>
-  );
-}
-```
-
-Use it in your Page:
-
-```tsx
-import Counter from '../../islands/Counter.tsx';
-
-export default function Home() {
-  return (
-    <div>
-      <h1>Interactive Island</h1>
-      <Counter />
-    </div>
-  );
-}
-```
-
-### 4. Turbo Drive (Optional)
-
-Salvia works seamlessly with Turbo Drive for SPA-like navigation.
-
-Add Turbo to your layout file (e.g., `app/pages/layouts/Main.tsx`):
-
-```tsx
-<head>
-  {/* ... */}
-  <script type="module">
-    import * as Turbo from "https://esm.sh/@hotwired/turbo@8.0.0";
-    Turbo.start();
-  </script>
-</head>
-```
-
-This approach leverages Import Maps and browser-native modules, keeping your bundle size small and your architecture transparent.
-
-## Documentation
-
-*   **English**:
-    *   [**Wisdom for Salvia**](docs/en/DESIGN.md): Deep dive into the architecture, directory structure, and "True HTML First" philosophy.
-    *   [**Architecture**](docs/en/ARCHITECTURE.md): Internal design of the gem.
-*   **Japanese (日本語)**:
-    *   [**Salviaの知恵**](docs/ja/DESIGN.md): アーキテクチャ、ディレクトリ構造、「真のHTMLファースト」哲学についての詳細。
-    *   [**アーキテクチャ**](docs/ja/ARCHITECTURE.md): Gemの内部設計。
-
-## Framework Support
-
-Salvia is primarily designed for **Ruby on Rails** to pave the way for the **Sage** framework.
-
-*   **Ruby on Rails**: First-class support.
-
-## Requirements
-
-*   Ruby 3.1+
-*   Rails 7.0+ (Recommended)
-*   Deno (for JIT compilation and tooling)
-
-## License
-
-The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).