funicular 0.2.1 → 0.3.0

data/lib/funicular/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Funicular
-  VERSION = "0.2.1"
+  VERSION = "0.3.0"
 end

data/lib/generators/funicular/chat/templates/funicular_chat_component.rb.tt

@@ -1,24 +1,25 @@
 class FunicularChatComponent < Funicular::Component
-  styles do
-    shell "funicular-chat"
-    panel "funicular-chat__panel"
-    header "funicular-chat__header"
-    title "funicular-chat__title"
-    subtitle "funicular-chat__subtitle"
-    messages "funicular-chat__messages"
-    empty "funicular-chat__empty"
-    message "funicular-chat__message"
-    name "funicular-chat__message-name"
-    body "funicular-chat__message-body"
-    form "funicular-chat__form"
-    row "funicular-chat__form-row"
-    input "funicular-chat__input"
-    button base: "funicular-chat__button",
-           variants: {
-             enabled: "funicular-chat__button--enabled",
-             disabled: "funicular-chat__button--disabled"
-           }
-    error "funicular-chat__error"
+  styles do |css|
+    css.define :shell, "funicular-chat"
+    css.define :panel, "funicular-chat__panel"
+    css.define :header, "funicular-chat__header"
+    css.define :title, "funicular-chat__title"
+    css.define :subtitle, "funicular-chat__subtitle"
+    css.define :messages, "funicular-chat__messages"
+    css.define :empty, "funicular-chat__empty"
+    css.define :message, "funicular-chat__message"
+    css.define :name, "funicular-chat__message-name"
+    css.define :body, "funicular-chat__message-body"
+    css.define :form, "funicular-chat__form"
+    css.define :row, "funicular-chat__form-row"
+    css.define :input, "funicular-chat__input"
+    css.define :button,
+               base: "funicular-chat__button",
+               variants: {
+                 enabled: "funicular-chat__button--enabled",
+                 disabled: "funicular-chat__button--disabled"
+               }
+    css.define :error, "funicular-chat__error"
   end
 
   def initialize_state
@@ -55,7 +56,7 @@ class FunicularChatComponent < Funicular::Component
   def subscribe
     @consumer = Funicular::Cable.create_consumer("/cable")
     @subscription = @consumer.subscriptions.create(channel: "FunicularChatChannel") do |message|
-      patch(messages: state.messages + [message])
+      patch(messages: state[:messages] + [message])
     end
     @subscription.on_connected do
       patch(connected: true)
@@ -72,10 +73,10 @@ class FunicularChatComponent < Funicular::Component
 
   def send_message(event = nil)
     event.preventDefault if event
-    return if state.sending
+    return if state[:sending]
 
-    name = state.name.to_s.strip
-    body = state.body.to_s.strip
+    name = state[:name].to_s.strip
+    body = state[:body].to_s.strip
     if name == "" || body == ""
       patch(error: "Name and message are required")
       return
@@ -94,38 +95,38 @@ class FunicularChatComponent < Funicular::Component
     end
   end
 
-  def render
-    div(class: s.shell) do
-      div(class: s.panel) do
-        div(class: s.header) do
-          h1(class: s.title) { "Funicular Chat" }
-          p(class: s.subtitle) do
-            state.connected ? "Realtime Ruby chat over ActionCable" : "Connecting..."
+  def render(h)
+    h.div(class: h.styles[:shell]) do |hh|
+      hh.div(class: h.styles[:panel]) do |panel|
+        panel.div(class: h.styles[:header]) do |header|
+          header.h1(class: h.styles[:title]) { "Funicular Chat" }
+          header.p(class: h.styles[:subtitle]) do
+            state[:connected] ? "Realtime Ruby chat over ActionCable" : "Connecting..."
           end
         end
 
-        div(class: s.messages) do
-          if state.messages.empty?
-            p(class: s.empty) { "No messages yet." }
+        panel.div(class: h.styles[:messages]) do |messages|
+          if state[:messages].empty?
+            messages.p(class: h.styles[:empty]) { "No messages yet." }
           else
-            state.messages.each do |message|
-              div(class: s.message, key: message["id"]) do
-                div(class: s.name) { message["name"] }
-                div(class: s.body) { message["body"] }
+            state[:messages].each do |message|
+              messages.div(class: h.styles[:message], key: message["id"]) do |item|
+                item.div(class: h.styles[:name]) { message["name"] }
+                item.div(class: h.styles[:body]) { message["body"] }
               end
             end
           end
         end
 
-        form(onsubmit: :send_message, class: s.form) do
-          if state.error
-            div(class: s.error) { state.error }
+        panel.form(onsubmit: :send_message, class: h.styles[:form]) do |form|
+          if state[:error]
+            form.div(class: h.styles[:error]) { state[:error] }
           end
-          div(class: s.row) do
-            input(type: "text", value: state.name, placeholder: "Name", oninput: :update_name, class: s.input)
-            input(type: "text", value: state.body, placeholder: "Message", oninput: :update_body, class: s.input)
-            button(type: "submit", class: s.button(state.sending ? :disabled : :enabled), disabled: state.sending) do
-              state.sending ? "Sending..." : "Send"
+          form.div(class: h.styles[:row]) do |row|
+            row.input(type: "text", value: state[:name], placeholder: "Name", oninput: :update_name, class: h.styles[:input])
+            row.input(type: "text", value: state[:body], placeholder: "Message", oninput: :update_body, class: h.styles[:input])
+            row.button(type: "submit", class: h.styles[:button, state[:sending] ? :disabled : :enabled], disabled: state[:sending]) do
+              state[:sending] ? "Sending..." : "Send"
             end
           end
         end

data/lib/tasks/funicular.rake

@@ -29,7 +29,7 @@ namespace :funicular do
     rescue Funicular::Plugin::Error => e
       puts "ERROR: #{e.message}"
       exit 1
-    rescue Funicular::Compiler::PicorbcMissingError => e
+    rescue Funicular::Compiler::MrbcMissingError => e
       puts "ERROR: #{e.message}"
       exit 1
     rescue => e

data/minitest/commands_routes_test.rb

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+require "fileutils"
+require "tmpdir"
+
+require "test_helper"
+require_relative "support/rails_stub"
+require "funicular/commands/routes"
+
+# Exercises the `funicular:routes` CLI command: its guard clauses (not a Rails
+# app / no initializer / no routes) and the aligned routes table it prints.
+class CommandsRoutesTest < Minitest::Test
+  def setup
+    Rails.reset_stub!
+  end
+
+  def teardown
+    Rails.reset_stub!
+  end
+
+  # Runs Routes#execute inside a throwaway app dir, capturing stdout and the
+  # SystemExit status (nil when the command runs to completion).
+  def run_in_app(files: {})
+    Dir.mktmpdir do |dir|
+      files.each do |rel, contents|
+        path = File.join(dir, rel)
+        FileUtils.mkdir_p(File.dirname(path))
+        File.write(path, contents)
+      end
+      Rails.root = Pathname(dir)
+
+      status = nil
+      out = +""
+      Dir.chdir(dir) do
+        out, = capture_io do
+          begin
+            Funicular::Commands::Routes.new.execute
+          rescue SystemExit => e
+            status = e.status
+          end
+        end
+      end
+      yield out, status
+    end
+  end
+
+  def test_errors_when_not_in_a_rails_app
+    run_in_app(files: {}) do |out, status|
+      assert_equal 1, status
+      assert_includes out, "Not in a Rails application"
+    end
+  end
+
+  def test_reports_when_initializer_is_missing
+    run_in_app(files: { "config/application.rb" => "# app\n" }) do |out, status|
+      assert_equal 0, status
+      assert_includes out, "No Funicular routes found"
+    end
+  end
+
+  def test_reports_when_initializer_defines_no_routes
+    run_in_app(files: {
+      "config/application.rb" => "# app\n",
+      "app/funicular/initializer.rb" => "# nothing here\n"
+    }) do |out, status|
+      assert_equal 0, status
+      assert_includes out, "No routes defined"
+    end
+  end
+
+  def test_prints_aligned_table_with_totals
+    initializer = <<~RUBY
+      router.get("/", to: HomeComponent, as: "home")
+      router.get("/channels/:id", to: ChannelComponent)
+    RUBY
+
+    run_in_app(files: {
+      "config/application.rb" => "# app\n",
+      "app/funicular/initializer.rb" => initializer
+    }) do |out, status|
+      assert_nil status # ran to completion, no exit
+      assert_includes out, "Method"
+      assert_includes out, "Component"
+      assert_includes out, "HomeComponent"
+      assert_includes out, "home_path"
+      assert_includes out, "/channels/:id"
+      assert_includes out, "Total: 2 routes"
+    end
+  end
+
+  def test_total_is_singular_for_one_route
+    routes = [{ method: "GET", path: "/", component: "HomeComponent", helper: nil }]
+    out, = capture_io { Funicular::Commands::Routes.new.send(:print_routes_table, routes) }
+    assert_includes out, "Total: 1 route"
+    refute_includes out, "1 routes"
+  end
+end

data/minitest/compiler_test.rb

@@ -0,0 +1,195 @@
+# frozen_string_literal: true
+
+require "fileutils"
+require "tmpdir"
+
+require "test_helper"
+require_relative "support/rails_stub"
+
+# Exercises the environment-independent parts of Funicular::Compiler: the
+# source-file discovery/ordering (shared with the SSR runtime), the `node`
+# executable lookup, and the vendored-mrbc availability guard. The actual
+# spawn of mrbc via Node is integration-only and not covered here.
+class CompilerTest < Minitest::Test
+  def make_compiler(source_dir: "/tmp/app", output_file: "/tmp/out.mrb", **opts)
+    Funicular::Compiler.new(source_dir: source_dir, output_file: output_file, **opts)
+  end
+
+  # --- source_files ordering -------------------------------------------
+
+  def test_source_files_orders_models_stores_components_then_initializers
+    Dir.mktmpdir do |dir|
+      %w[models stores components].each { |d| FileUtils.mkdir_p(File.join(dir, d)) }
+      File.write(File.join(dir, "models", "b_model.rb"), "")
+      File.write(File.join(dir, "models", "a_model.rb"), "")
+      File.write(File.join(dir, "stores", "s_store.rb"), "")
+      File.write(File.join(dir, "components", "c_component.rb"), "")
+      File.write(File.join(dir, "app_initializer.rb"), "")
+      File.write(File.join(dir, "initializer.rb"), "")
+
+      files = Funicular::Compiler.source_files(dir).map { |f| f.sub("#{dir}/", "") }
+
+      assert_equal(
+        [
+          "models/a_model.rb",
+          "models/b_model.rb",
+          "stores/s_store.rb",
+          "components/c_component.rb",
+          "app_initializer.rb",
+          "initializer.rb"
+        ],
+        files
+      )
+    end
+  end
+
+  def test_source_files_recurses_into_subdirectories
+    Dir.mktmpdir do |dir|
+      FileUtils.mkdir_p(File.join(dir, "components", "nested"))
+      File.write(File.join(dir, "components", "nested", "deep_component.rb"), "")
+
+      files = Funicular::Compiler.source_files(dir)
+
+      assert_equal 1, files.size
+      assert_match %r{components/nested/deep_component\.rb\z}, files.first
+    end
+  end
+
+  def test_source_files_empty_for_missing_directory
+    assert_equal [], Funicular::Compiler.source_files("/no/such/dir")
+  end
+
+  # --- node executable lookup ------------------------------------------
+
+  def test_node_command_prefers_node_env_var
+    original = ENV["NODE"]
+    ENV["NODE"] = "/custom/bin/node"
+    assert_equal "/custom/bin/node", make_compiler.send(:node_command)
+  ensure
+    ENV["NODE"] = original
+  end
+
+  def test_which_finds_executable_on_path
+    Dir.mktmpdir do |dir|
+      exe = File.join(dir, "faketool")
+      File.write(exe, "#!/bin/sh\n")
+      File.chmod(0o755, exe)
+
+      original = ENV["PATH"]
+      ENV["PATH"] = dir
+      assert_equal exe, make_compiler.send(:which, "faketool")
+      assert_nil make_compiler.send(:which, "does_not_exist_tool")
+    ensure
+      ENV["PATH"] = original
+    end
+  end
+
+  # --- availability guard ----------------------------------------------
+
+  def test_compile_raises_when_vendored_mrbc_missing
+    skip "vendored mrbc present in this checkout" if File.exist?(Funicular::Compiler::MRBC_JS)
+
+    error = assert_raises(Funicular::Compiler::MrbcMissingError) { make_compiler.compile }
+    assert_includes error.message, "Vendored mrbc not found"
+  end
+
+  def test_prepend_source_files_are_coerced_to_strings
+    compiler = make_compiler(prepend_source_files: [Pathname.new("/a.rb"), :b])
+    assert_equal ["/a.rb", "b"], compiler.prepend_source_files
+  end
+
+  # --- source gathering (writes the FUNICULAR_ENV temp file) -----------
+
+  def test_gather_source_files_prepends_extras_and_writes_env_file
+    Rails.reset_stub!
+    Rails.env_name = "test"
+    Dir.mktmpdir do |dir|
+      FileUtils.mkdir_p(File.join(dir, "components"))
+      File.write(File.join(dir, "components", "a_component.rb"), "")
+      output = File.join(dir, "build", "app.mrb")
+
+      compiler = make_compiler(source_dir: dir, output_file: output,
+                               prepend_source_files: ["/plugin/x.rb"])
+      compiler.send(:gather_source_files)
+
+      gathered = compiler.instance_variable_get(:@source_files)
+      assert_equal "/plugin/x.rb", gathered.first
+      assert(gathered.any? { |f| f.end_with?("a_component.rb") })
+
+      env_file = compiler.instance_variable_get(:@env_file)
+      assert_match(/FUNICULAR_ENV.*test/, File.read(env_file))
+    ensure
+      Rails.reset_stub!
+    end
+  end
+
+  def test_gather_source_files_raises_without_ruby_files
+    Dir.mktmpdir do |dir|
+      compiler = make_compiler(source_dir: dir, output_file: File.join(dir, "out.mrb"))
+      error = assert_raises(RuntimeError) { compiler.send(:gather_source_files) }
+      assert_includes error.message, "No Ruby files found"
+    end
+  end
+
+  # --- compile_to_mrb (spawns the mrbc command) ------------------------
+  #
+  # `true`/`false` stand in for `node mrbc.js ...`: both ignore their argv, so
+  # the exit status alone drives the success/failure branches without needing a
+  # real Node/WASM toolchain.
+
+  def prepared_compiler(dir, node:, debug_mode: false)
+    src = File.join(dir, "a.rb")
+    File.write(src, "")
+    compiler = make_compiler(source_dir: dir, output_file: File.join(dir, "out.mrb"),
+                             debug_mode: debug_mode)
+    compiler.instance_variable_set(:@node_command, node)
+    compiler.instance_variable_set(:@source_files, [src])
+    compiler.instance_variable_set(:@env_file, nil)
+    compiler
+  end
+
+  def test_compile_to_mrb_succeeds_when_command_exits_zero
+    Dir.mktmpdir do |dir|
+      compiler = prepared_compiler(dir, node: "/bin/true", debug_mode: true)
+      out, = capture_io { compiler.send(:compile_to_mrb) }
+      assert_includes out, "Successfully compiled"
+      assert_includes out, "Debug mode: true"
+    end
+  end
+
+  def test_compile_to_mrb_raises_when_command_fails
+    Dir.mktmpdir do |dir|
+      compiler = prepared_compiler(dir, node: "/bin/false")
+      error = nil
+      capture_io do
+        error = assert_raises(RuntimeError) { compiler.send(:compile_to_mrb) }
+      end
+      assert_includes error.message, "Failed to compile with mrbc"
+    end
+  end
+
+  def test_compile_to_mrb_deletes_env_file_unless_kept
+    Dir.mktmpdir do |dir|
+      compiler = prepared_compiler(dir, node: "/bin/true")
+      env_file = File.join(dir, "out.mrb.env.rb")
+      File.write(env_file, "ENV['FUNICULAR_ENV'] = 'test'\n")
+      compiler.instance_variable_set(:@env_file, env_file)
+
+      capture_io { compiler.send(:compile_to_mrb) }
+      refute File.exist?(env_file), "temp env file should be removed"
+    end
+  end
+
+  def test_logger_is_used_when_provided
+    Dir.mktmpdir do |dir|
+      messages = []
+      fake_logger = Object.new
+      fake_logger.define_singleton_method(:info) { |m| messages << m }
+      compiler = prepared_compiler(dir, node: "/bin/true")
+      compiler.instance_variable_set(:@logger, fake_logger)
+
+      compiler.send(:compile_to_mrb)
+      assert(messages.any? { |m| m.include?("Successfully compiled") })
+    end
+  end
+end

data/minitest/configuration_test.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+# Exercises Funicular::Configuration: the per-environment source selection, the
+# source allowlist validation, and the cdn_version fallback to the vendored
+# wasm version.
+class ConfigurationTest < Minitest::Test
+  def setup
+    @config = Funicular::Configuration.new
+  end
+
+  def test_defaults
+    assert_equal :local_debug, @config.development_source
+    assert_equal :local_debug, @config.test_source
+    assert_equal :local_dist,  @config.production_source
+  end
+
+  def test_source_for_known_environments
+    assert_equal :local_debug, @config.source_for("development")
+    assert_equal :local_debug, @config.source_for("test")
+    assert_equal :local_dist,  @config.source_for("production")
+  end
+
+  def test_source_for_accepts_symbols
+    assert_equal :local_dist, @config.source_for(:production)
+  end
+
+  def test_source_for_unknown_environment_falls_back_to_development
+    assert_equal :local_debug, @config.source_for("staging")
+  end
+
+  def test_setters_accept_valid_sources
+    @config.development_source = :cdn
+    @config.test_source = "local_dist"
+    @config.production_source = :cdn
+
+    assert_equal :cdn, @config.development_source
+    assert_equal :local_dist, @config.test_source
+    assert_equal :cdn, @config.source_for("production")
+  end
+
+  def test_setters_reject_invalid_sources
+    error = assert_raises(ArgumentError) { @config.production_source = :nonsense }
+    assert_includes error.message, "Invalid Funicular source"
+    assert_includes error.message, "nonsense"
+  end
+
+  def test_cdn_version_prefers_explicit_value
+    @config.cdn_version = "9.9.9"
+    assert_equal "9.9.9", @config.cdn_version
+  end
+
+  def test_cdn_version_falls_back_to_vendored_wasm_version
+    # No explicit version set -> delegates to Funicular.vendored_wasm_version
+    # (nil in a source checkout without vendored artifacts).
+    vendored = Funicular.vendored_wasm_version
+    if vendored.nil?
+      assert_nil @config.cdn_version
+    else
+      assert_equal vendored, @config.cdn_version
+    end
+  end
+end

data/minitest/fixtures/funicular_app/components/greeting_component.rb

@@ -3,12 +3,12 @@ class GreetingComponent < Funicular::Component
     { title: "Default Title", items: [] }
   end
 
-  def render
-    div(class: "greeting") do
-      h1 { state.title }
-      ul do
-        state.items.each do |item|
-          li(key: item["id"]) { item["name"] }
+  def render(h)
+    h.div(class: "greeting") do |hh|
+      hh.h1 { state[:title] }
+      hh.ul do |hhh|
+        state[:items].each do |item|
+          hhh.li(key: item["id"]) { item["name"] }
         end
       end
     end

data/minitest/form_for_test.rb

@@ -19,8 +19,8 @@ class FormForTest < Minitest::Test
         @submitted = data
       end
 
-      def render
-        form_for(:comment, on_submit: :handle_submit) do |f|
+      def render(h)
+        h.form_for(:comment, on_submit: :handle_submit) do |f|
           f.textarea(:body)
           f.submit("Post")
         end

data/minitest/funicular_test.rb

@@ -2,12 +2,38 @@
 
 require "test_helper"
 
+# Exercises the top-level Funicular module: version constant, the
+# configuration accessor/DSL, and the vendored wasm version reader.
 class FunicularTest < Minitest::Test
   def test_VERSION
     assert ::Funicular.const_defined?(:VERSION)
+    assert_match(/\A\d+\.\d+\.\d+/, Funicular::VERSION)
   end
 
-  def test_something_useful
-    assert("expected"!="actual")
+  def test_configuration_is_memoized
+    assert_instance_of Funicular::Configuration, Funicular.configuration
+    assert_same Funicular.configuration, Funicular.configuration
+  end
+
+  def test_configure_yields_the_configuration
+    yielded = nil
+    Funicular.configure { |config| yielded = config }
+    assert_same Funicular.configuration, yielded
+  end
+
+  def test_vendored_wasm_version_reads_version_file
+    # The vendored artifacts are not present in a source checkout, so the
+    # reader swallows Errno::ENOENT and returns nil. When they are present it
+    # returns the trimmed VERSION file contents.
+    version_file = File.join(Funicular::VENDOR_PICORUBY_DIR, "VERSION")
+    Funicular.instance_variable_set(:@vendored_wasm_version, nil)
+
+    if File.exist?(version_file)
+      assert_equal File.read(version_file).strip, Funicular.vendored_wasm_version
+    else
+      assert_nil Funicular.vendored_wasm_version
+    end
+  ensure
+    Funicular.instance_variable_set(:@vendored_wasm_version, nil)
   end
 end

data/minitest/hydration_test.rb

@@ -25,8 +25,8 @@ class HydrationMatchTest < Minitest::Test
   # invoked here (we feed vnodes directly); it only satisfies the abstract API.
   def probe
     klass = Class.new(Funicular::Component) do
-      def render
-        div { "x" }
+      def render(h)
+        h.div { "x" }
       end
 
       def match?(vnode, dom)