funicular 0.2.1 → 0.4.0

data/lib/funicular/version.rb

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

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

@@ -55,7 +55,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 +72,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
@@ -95,37 +95,37 @@ class FunicularChatComponent < Funicular::Component
   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..."
+    div(class: styles.shell) do
+      div(class: styles.panel) do
+        div(class: styles.header) do
+          h1(class: styles.title) { "Funicular Chat" }
+          p(class: 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." }
+        div(class: styles.messages) do
+          if state[:messages].empty?
+            p(class: 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|
+              div(class: styles.message, key: message["id"]) do
+                div(class: styles.name) { message["name"] }
+                div(class: 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 }
+        form(onsubmit: :send_message, class: styles.form) do
+          if state[:error]
+            div(class: 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"
+          div(class: styles.row) do
+            input(type: "text", value: state[:name], placeholder: "Name", oninput: :update_name, class: styles.input)
+            input(type: "text", value: state[:body], placeholder: "Message", oninput: :update_body, class: styles.input)
+            button(type: "submit", class: 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/dsl_test.rb

@@ -0,0 +1,237 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+# Bareword component DSL (0.4.0), CRuby/SSR side. Twin of test/dsl_test.rb;
+# the attr_accessor case differs by VM: CRuby fires method_added for attr_*
+# so the collision surfaces at class-definition time, while mruby relies on
+# the mount-time sweep.
+class DSLTest < Minitest::Test
+  def setup
+    Funicular::SSR::Runtime.load_framework!
+  end
+
+  def test_bareword_render_builds_nested_tree
+    klass = Class.new(Funicular::Component) do
+      def initialize_state
+        { items: ["a", "b"] }
+      end
+
+      def render
+        div(class: "list") do
+          h1 { "title" }
+          ul do
+            state[:items].each_with_index do |item, i|
+              li(key: i) { item }
+            end
+          end
+        end
+      end
+    end
+
+    vnode = klass.new.build_vdom
+
+    assert_equal "div", vnode.tag
+    assert_equal ["h1", "ul"], vnode.children.map(&:tag)
+    assert_equal 2, vnode.children[1].children.size
+  end
+
+  def test_defining_reserved_tag_name_raises_at_class_definition
+    assert_raises(Funicular::DSLCollisionError) do
+      Class.new(Funicular::Component) do
+        def label
+        end
+      end
+    end
+  end
+
+  def test_attr_accessor_collision_raises_at_class_definition_on_cruby
+    # CRuby fires method_added for attr_*, so this is caught immediately
+    # (on mruby the mount-time sweep catches it instead).
+    assert_raises(Funicular::DSLCollisionError) do
+      Class.new(Funicular::Component) do
+        attr_accessor :label
+      end
+    end
+  end
+
+  def test_included_module_collision_is_caught_at_first_build
+    mod = Module.new do
+      def select
+      end
+    end
+    klass = Class.new(Funicular::Component) do
+      def render
+        div { "x" }
+      end
+    end
+    klass.include(mod)
+
+    assert_raises(Funicular::DSLCollisionError) { klass.new.build_vdom }
+  end
+
+  def test_allow_dsl_override_restores_user_method_and_tag_escape_hatch
+    klass = Class.new(Funicular::Component) do
+      allow_dsl_override :label
+
+      def label
+        "custom"
+      end
+
+      def render
+        div { tag(:label) { label } }
+      end
+    end
+
+    vnode = klass.new.build_vdom
+
+    assert_equal "label", vnode.children.first.tag
+    assert_equal ["custom"], vnode.children.first.children
+  end
+
+  def test_render_with_parameter_raises_migration_error
+    klass = Class.new(Funicular::Component) do
+      def render(h)
+        h
+      end
+    end
+
+    error = assert_raises(Funicular::DSLCollisionError) { klass.new.build_vdom }
+    assert_match(/must not take parameters/, error.message)
+  end
+
+  def test_p_with_non_hash_raises_with_hint
+    klass = Class.new(Funicular::Component) do
+      def render
+        div { p "debug me" }
+      end
+    end
+
+    error = assert_raises(ArgumentError) { klass.new.build_vdom }
+    assert_match(/puts x.inspect/, error.message)
+  end
+
+  def test_p_with_hash_builds_paragraph
+    klass = Class.new(Funicular::Component) do
+      def render
+        p(class: "para") { "text" }
+      end
+    end
+
+    vnode = klass.new.build_vdom
+
+    assert_equal "p", vnode.tag
+    assert_equal ["text"], vnode.children
+  end
+
+  def test_tag_outside_render_raises
+    klass = Class.new(Funicular::Component) do
+      def render
+        div { "x" }
+      end
+    end
+    component = klass.new
+    component.build_vdom
+
+    assert_raises(Funicular::RenderContextError) { component.div { "outside" } }
+  end
+
+  def test_bareword_styles_definition_and_method_access
+    klass = Class.new(Funicular::Component) do
+      styles do
+        shell "app-shell"
+        display "display-class"
+        button base: "btn", variants: { primary: "btn--primary" }, active: "btn--on"
+      end
+
+      def render
+        div(class: styles.shell) do
+          span(class: styles.display) { "d" }
+          button(class: styles.button(:primary)) { "b" }
+          a(class: styles[:button, true] | "extra") { "x" }
+        end
+      end
+    end
+
+    vnode = klass.new.build_vdom
+
+    assert_equal "app-shell", vnode.props[:class]
+    # :display would resolve to Object#display on an Object-based accessor;
+    # the BasicObject accessor keeps it a plain style name under CRuby SSR,
+    # matching the mruby client.
+    assert_equal "display-class", vnode.children[0].props[:class]
+    assert_equal "btn btn--primary", vnode.children[1].props[:class]
+    assert_equal "btn btn--on extra", vnode.children[2].props[:class]
+  end
+
+  def test_unknown_style_raises
+    klass = Class.new(Funicular::Component) do
+      styles do
+        shell "app-shell"
+      end
+
+      def render
+        div { "x" }
+      end
+    end
+    component = klass.new
+
+    assert_raises(NoMethodError) { component.styles.typo_name }
+    assert_raises(ArgumentError) { component.styles[:typo] }
+  end
+
+  def test_bareword_helper_call_inside_styles_block_raises
+    assert_raises(ArgumentError) do
+      Class.new(Funicular::Component) do
+        styles do
+          button base: helper_that_does_not_exist("x")
+        end
+      end
+    end
+  end
+
+  def test_duplicate_style_definition_raises
+    assert_raises(ArgumentError) do
+      Class.new(Funicular::Component) do
+        styles do
+          shell "a"
+          shell "b"
+        end
+      end
+    end
+  end
+
+  def test_suspense_fallback_runs_bareword_in_own_component
+    klass = Class.new(Funicular::Component) do
+      use_suspense :user, ->(resolve, _reject) { resolve.call("u") }
+
+      def render
+        div do
+          suspense(:user, fallback: -> { span { "loading" } }) do |res|
+            span { res[:user] }
+          end
+        end
+      end
+    end
+
+    component = klass.new
+    vnode = component.build_vdom
+    assert_equal "loading", vnode.children.first.children.first
+
+    component.instance_variable_get(:@suspense_data)[:user] = "u"
+    component.instance_variable_get(:@suspense_states)[:user] = :resolved
+    vnode = component.build_vdom
+    assert_equal "u", vnode.children.first.children.first
+  end
+
+  def test_error_boundary_fallback_receives_view_context
+    fallback = ->(h, error) { h.div(class: "custom-error") { error.message } }
+    boundary = Funicular::ErrorBoundary.new(fallback: fallback)
+    boundary.catch_error(RuntimeError.new("boom"))
+    vnode = boundary.build_vdom
+
+    assert_equal "div", vnode.tag
+    assert_equal "custom-error", vnode.props[:class]
+    assert_equal ["boom"], vnode.children
+  end
+end