salvia 0.2.0

data/lib/salvia/helpers/island.rb

@@ -0,0 +1,251 @@
+# frozen_string_literal: true
+
+require "json"
+
+module Salvia
+  module Helpers
+    module Island
+      # Island マニフェストをキャッシュ
+      @manifest = nil
+      @manifest_mtime = nil
+      
+      class << self
+        # マニフェストを読み込む
+        def load_manifest
+          manifest_path = File.join(Dir.pwd, "salvia/server/manifest.json")
+          return {} unless File.exist?(manifest_path)
+          
+          mtime = File.mtime(manifest_path)
+          if @manifest.nil? || @manifest_mtime != mtime
+            @manifest = JSON.parse(File.read(manifest_path))
+            @manifest_mtime = mtime
+          end
+          @manifest
+        rescue => e
+          {}
+        end
+        
+        # Island が client only かどうか
+        def client_only?(name)
+          manifest = load_manifest
+          manifest.dig(name, "clientOnly") == true
+        end
+
+        # Island が server only かどうか
+        def server_only?(name)
+          manifest = load_manifest
+          manifest.dig(name, "serverOnly") == true
+        end
+      end
+      
+      # Import Map タグを生成する
+      def salvia_import_map(additional_map = {})
+        default_map = {
+          "imports" => {
+            "preact" => "https://esm.sh/preact@10.19.6",
+            "preact/hooks" => "https://esm.sh/preact@10.19.6/hooks",
+            "preact/jsx-runtime" => "https://esm.sh/preact@10.19.6/jsx-runtime",
+            "@hotwired/turbo" => "https://esm.sh/@hotwired/turbo@8.0.0"
+          }
+        }
+
+        # Islands path mapping
+        islands_path = if defined?(Salvia.env) && Salvia.env == "development"
+                         "/salvia/assets/islands/"
+                       else
+                         "/assets/islands/"
+                       end
+        default_map["imports"]["@/islands/"] = islands_path
+
+        # deno.json から imports を読み込む
+        begin
+          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"]
+              # npm: スキームを https://esm.sh/ に変換してブラウザで使えるようにする
+              imports = deno_config["imports"].transform_values do |v|
+                if v.is_a?(String) && v.start_with?("npm:")
+                  package = v.sub("npm:", "")
+                  "https://esm.sh/#{package}"
+                else
+                  v
+                end
+              end
+              default_map["imports"].merge!(imports)
+            end
+          end
+        rescue => e
+          # 読み込みエラー時は無視
+        end
+
+        if additional_map.key?("imports")
+          default_map["imports"].merge!(additional_map["imports"])
+        end
+        
+        additional_map.each do |k, v|
+          next if k == "imports"
+          default_map[k] = v
+        end
+        
+        html = <<~HTML
+          <script type="importmap">
+            #{default_map.to_json}
+          </script>
+        HTML
+        
+        html.respond_to?(:html_safe) ? html.html_safe : html
+      end
+
+      # Island コンポーネントをレンダリングする
+      #
+      # SSR が有効な場合はサーバーサイドで HTML を生成し、
+      # クライアントサイドでハイドレーションを行います。
+      #
+      # @param name [String] コンポーネント名 (例: "Counter")
+      # @param props [Hash] コンポーネントに渡すプロパティ
+      # @param options [Hash] オプション
+      # @option options [String] :id 要素のID
+      # @option options [String] :tag ラッパータグ (デフォルト: div)
+      # @option options [Boolean] :ssr SSR を有効にするか (デフォルト: auto)
+      # @option options [Boolean] :hydrate クライアントサイドでハイドレーションするか (デフォルト: true)
+      # @return [String] レンダリングされた HTML
+      #
+      # @example 基本的な使用法
+      #   <%= island "Counter", count: 5 %>
+      #
+      # @example SSR を明示的に無効化
+      #   <%= island "HeavyChart", data: @data, ssr: false %>
+      #
+      # @example ハイドレーションを無効化 (静的 HTML のみ)
+      #   <%= island "StaticCard", title: "Hello", hydrate: false %>
+      #
+      def island(name, props = {}, options = {})
+        tag_name = options.delete(:tag) || :div
+        
+        # デフォルトの hydrate 値を決定
+        # serverOnly (app/pages) の場合はデフォルトで false
+        default_hydrate = !Island.server_only?(name)
+        hydrate = options.fetch(:hydrate, default_hydrate)
+        
+        # SSR 有効/無効の判定
+        # 1. options[:ssr] が明示的に指定されていればそれを使う
+        # 2. マニフェストで "client only" ならば SSR 無効
+        # 3. デフォルトは SSR 有効
+        ssr_enabled = if options.key?(:ssr)
+          options[:ssr]
+        else
+          !Island.client_only?(name)
+        end
+        
+        # 開発モードかどうか
+        development = defined?(Salvia.env) ? Salvia.env == "development" : true
+        
+        # SSR でコンテンツを生成
+        inner_html = ""
+        begin
+          if ssr_enabled && defined?(Salvia::SSR) && Salvia::SSR.respond_to?(:configured?) && Salvia::SSR.configured?
+            inner_html = Salvia::SSR.render(name, props)
+          end
+        rescue => e
+          # SSR 失敗時はエラーをログに出力し、CSR にフォールバック
+          if development
+            inner_html = ssr_error_inline(name, e.message)
+          end
+        end
+        
+        # データ属性を構築
+        data_attrs = {}
+        
+        if hydrate
+          data_attrs[:island] = name
+          data_attrs[:props] = props.to_json
+        end
+        
+        # 開発モードではデバッグ用の属性を追加
+        if development
+          data_attrs[:salvia_debug] = true
+          data_attrs[:salvia_component] = name
+        end
+        
+        # HTML オプションを構築
+        html_options = options.dup
+        html_options.delete(:ssr)
+        html_options.delete(:hydrate)
+        html_options[:data] = (html_options[:data] || {}).merge(data_attrs)
+        
+        # 開発モードではインスペクター用のクラスを追加
+        if development
+          html_options[:class] = [html_options[:class], "salvia-island"].compact.join(" ")
+        end
+        
+        result = build_tag(tag_name, html_options) { inner_html }
+        result.respond_to?(:html_safe) ? result.html_safe : result
+      end
+      
+      # ページコンポーネントをレンダリングする (Full JSX Architecture用)
+      #
+      # <!DOCTYPE html> を付与し、ルート要素としてレンダリングします。
+      # また、<head> タグが存在する場合、自動的に Import Map を注入します。
+      #
+      # @param name [String] ページコンポーネント名 (例: "pages/Home")
+      # @param props [Hash] プロパティ
+      # @return [String] 完全な HTML 文字列
+      def ssr(name, props = {})
+        # SSR で HTML を生成
+        html = Salvia::SSR.render(name, props)
+        
+        # <head> がある場合、Import Map を自動注入
+        if html.include?("</head>")
+          import_map_html = salvia_import_map
+          html = html.sub("</head>", "#{import_map_html}</head>")
+        end
+        
+        result = "<!DOCTYPE html>\n" + html
+        result.respond_to?(:html_safe) ? result.html_safe : result
+      end
+      
+      # 後方互換性のため
+      alias_method :salvia_page, :ssr
+
+      private
+      
+      def build_tag(name, options)
+        content = block_given? ? yield : ""
+        attrs = options.map do |key, value|
+          if key == :data && value.is_a?(Hash)
+            value.map { |k, v| " data-#{k.to_s.gsub('_', '-')}=\"#{escape_html(v)}\"" }.join
+          else
+            " #{key}=\"#{escape_html(value)}\""
+          end
+        end.join
+        
+        "<#{name}#{attrs}>#{content}</#{name}>"
+      end
+      
+      # インラインエラー表示 (開発モード用、軽量版)
+      def ssr_error_inline(name, message)
+        <<~HTML
+          <div style="
+            background: #fee;
+            border: 1px solid #fcc;
+            border-radius: 4px;
+            padding: 8px 12px;
+            font-size: 12px;
+            color: #900;
+          ">
+            <strong>⚠️ SSR Error:</strong> #{escape_html(name)} - #{escape_html(message)}
+          </div>
+        HTML
+      end
+      
+      def escape_html(str)
+        str.to_s
+          .gsub("&", "&amp;")
+          .gsub("<", "&lt;")
+          .gsub(">", "&gt;")
+          .gsub('"', "&quot;")
+      end
+    end
+  end
+end

data/lib/salvia/helpers/tag.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module Salvia
+  module Helpers
+    module Tag
+      # HTML タグを生成する
+      #
+      # @param name [Symbol, String] タグ名
+      # @param options [Hash] 属性
+      # @param block [Proc] コンテンツブロック
+      # @return [String] HTML 文字列
+      def tag(name, options = {}, &block)
+        html_options = options.map do |key, value|
+          next if value.nil?
+          
+          if value.is_a?(Hash) && key == :data
+            value.map { |k, v| %(data-#{k.to_s.gsub("_", "-")}="#{escape_html(v)}") }.join(" ")
+          elsif value == true
+            key
+          else
+            %(#{key}="#{escape_html(value)}")
+          end
+        end.compact.join(" ")
+        
+        html_options = " " + html_options unless html_options.empty?
+        
+        if block_given?
+          content = block.call
+          "<#{name}#{html_options}>#{content}</#{name}>"
+        else
+          "<#{name}#{html_options} />"
+        end
+      end
+
+      private
+
+      def escape_html(str)
+        str.to_s
+          .gsub("&", "&amp;")
+          .gsub("<", "&lt;")
+          .gsub(">", "&gt;")
+          .gsub('"', "&quot;")
+          .gsub("'", "&#39;")
+      end
+    end
+  end
+end

data/lib/salvia/helpers.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module Salvia
+  module Helpers
+    include Tag
+    include Island
+  end
+end

data/lib/salvia/railtie.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Salvia
+  class Railtie < ::Rails::Railtie
+    initializer "salvia.helpers" do
+      ActiveSupport.on_load(:action_view) do
+        include Salvia::Helpers
+      end
+
+      ActiveSupport.on_load(:action_controller) do
+        include Salvia::Helpers
+      end
+
+      ActiveSupport.on_load(:action_controller_api) do
+        include Salvia::Helpers
+      end
+    end
+
+    initializer "salvia.configure" do |app|
+      # Default configuration for Rails
+      Salvia.configure do |config|
+        # Use Rails logger
+        Salvia.logger = Rails.logger
+      end
+    end
+
+    initializer "salvia.middleware" do |app|
+      if Rails.env.development?
+        app.middleware.use Salvia::Server::DevServer
+      end
+    end
+  end
+end

data/lib/salvia/server/dev_server.rb

@@ -0,0 +1,83 @@
+module Salvia
+  module Server
+    class DevServer
+    def initialize(app)
+      @app = app
+    end
+
+    def call(env)
+      # Only active in development
+      unless ENV["RACK_ENV"] == "development" || ENV["RAILS_ENV"] == "development"
+        return @app.call(env)
+      end
+
+      request = Rack::Request.new(env)
+      
+      if request.path.start_with?("/salvia/assets/")
+        handle_asset_request(request)
+      else
+        @app.call(env)
+      end
+    end
+
+    private
+
+    def handle_asset_request(request)
+      # /salvia/assets/islands/Counter.js -> islands/Counter.tsx
+      path_info = request.path.sub("/salvia/assets/", "")
+      
+      # Special handling for islands.js (Client Entry)
+      if path_info == "javascripts/islands.js"
+        return serve_islands_js
+      end
+      
+      # Remove .js extension to find source
+      base_name = path_info.sub(/\.js$/, "")
+      
+      source_path = resolve_source_path(base_name)
+      
+      unless source_path
+        return [404, { "content-type" => "text/plain" }, ["Not Found: #{path_info}"]]
+      end
+      
+      begin
+        # Bundle for browser (ESM)
+        # We externalize dependencies that should be handled by Import Map
+        externals = Salvia::Core::ImportMap.new.keys
+        # Always externalize framework aliases just in case
+        externals += ["framework", "framework/hooks", "framework/jsx-runtime"]
+        
+        js_code = Salvia::Compiler.bundle(
+          source_path, 
+          externals: externals.uniq,
+          format: "esm"
+        )
+        
+        [200, { "content-type" => "application/javascript" }, [js_code]]
+      rescue => e
+        [500, { "content-type" => "text/plain" }, ["Build Error: #{e.message}"]]
+      end
+    end
+    
+    def resolve_source_path(name)
+      Salvia::Core::PathResolver.resolve(name)
+    end
+
+    def serve_islands_js
+      # Check user's islands.js
+      user_path = File.join(Salvia.root, "salvia/assets/javascripts/islands.js")
+      if File.exist?(user_path)
+        return [200, { "content-type" => "application/javascript" }, [File.read(user_path)]]
+      end
+      
+      # Fallback to internal islands.js
+      internal_path = File.expand_path("../../../assets/javascripts/islands.js", __dir__)
+      if File.exist?(internal_path)
+        return [200, { "content-type" => "application/javascript" }, [File.read(internal_path)]]
+      end
+      
+      [404, { "content-type" => "text/plain" }, ["islands.js not found"]]
+    end
+    end
+  end
+end

data/lib/salvia/server/sidecar.rb

@@ -0,0 +1,136 @@
+require 'net/http'
+require 'uri'
+require 'json'
+require 'timeout'
+
+module Salvia
+  module Server
+    class Sidecar
+    SCRIPT_PATH = File.join(__dir__, "sidecar.ts")
+
+    def self.instance
+      @instance ||= new
+    end
+
+    def initialize
+      @pid = nil
+      @port = nil
+      at_exit { stop }
+    end
+
+    def start
+      return if running?
+
+      cmd = ["deno", "run", "--allow-all", SCRIPT_PATH]
+      
+      puts "🚀 Starting Salvia Sidecar..."
+      # Spawn process and capture stdout to find the port
+      # We use IO.popen to read the output stream
+      @io = IO.popen(cmd)
+      @pid = @io.pid
+      
+      # Wait for "Listening on http://localhost:PORT/"
+      wait_for_port
+      
+      # Detach so it runs in background, but we keep the IO open to read logs if needed
+      # Actually, for IO.popen, we shouldn't detach if we want to read from it.
+      # But we need to read in a non-blocking way or in a separate thread after finding the port.
+      
+      Thread.new do
+        begin
+          while line = @io.gets
+            # Forward Deno logs to stdout/logger
+            puts "[Deno] #{line}"
+          end
+        rescue IOError
+          # Stream closed
+        end
+      end
+    end
+
+    def stop
+      return unless @pid
+      Process.kill("TERM", @pid)
+      @pid = nil
+      @port = nil
+      @io.close if @io && !@io.closed?
+    end
+
+    def running?
+      return false unless @pid
+      Process.getpgid(@pid)
+      true
+    rescue Errno::ESRCH
+      false
+    end
+
+    def bundle(entry_point, externals: [], format: "esm", global_name: nil, config_path: nil)
+      start unless running?
+      
+      resolved_config_path = File.expand_path(config_path || Salvia.config.deno_config_path, Salvia.root)
+      puts "[Salvia] Bundle config path: #{resolved_config_path}"
+
+      response = request("bundle", { 
+        entryPoint: entry_point, 
+        externals: externals,
+        format: format,
+        globalName: global_name,
+        configPath: resolved_config_path
+      })
+      if response["error"]
+        raise "Sidecar Bundle Error: #{response["error"]}"
+      end
+      response["code"]
+    end
+
+    def check(entry_point, config_path: nil)
+      start unless running?
+      resolved_config_path = File.expand_path(config_path || Salvia.config.deno_config_path, Salvia.root)
+      request("check", { entryPoint: entry_point, configPath: resolved_config_path })
+    end
+
+    def fmt(entry_point, config_path: nil)
+      start unless running?
+      resolved_config_path = File.expand_path(config_path || Salvia.config.deno_config_path, Salvia.root)
+      request("fmt", { entryPoint: entry_point, configPath: resolved_config_path })
+    end
+
+    private
+
+    def wait_for_port
+      Timeout.timeout(10) do
+        while line = @io.gets
+          puts "[Deno Init] #{line}"
+          if match = line.match(/Listening on http:\/\/localhost:(\d+)\//)
+            @port = match[1].to_i
+            puts "✅ Salvia Sidecar connected on port #{@port}"
+            return
+          end
+        end
+      end
+    rescue Timeout::Error
+      stop
+      raise "Sidecar failed to start (Timeout waiting for port)"
+    end
+
+    def request(command, params = {})
+      uri = URI("http://localhost:#{@port}/")
+      http = Net::HTTP.new(uri.host, uri.port)
+      
+      request = Net::HTTP::Post.new(uri)
+      request.content_type = 'application/json'
+      request.body = { command: command, params: params }.to_json
+      
+      response = http.request(request)
+      
+      if response.is_a?(Net::HTTPSuccess)
+        JSON.parse(response.body)
+      else
+        raise "Sidecar Request Failed: #{response.code} #{response.message}"
+      end
+    rescue => e
+      raise "Sidecar Request Error: #{e.message}"
+    end
+    end
+  end
+end