funicular 0.1.0 → 0.2.1

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

@@ -0,0 +1,16 @@
+class GreetingComponent < Funicular::Component
+  def initialize_state
+    { 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"] }
+        end
+      end
+    end
+  end
+end

data/minitest/fixtures/funicular_app/initializer.rb

@@ -0,0 +1,5 @@
+Funicular.start(container: "app") do |router|
+  router.get("/greet", to: GreetingComponent, as: "greet")
+  router.get("/greet/:id", to: GreetingComponent, as: "greet_item")
+  router.set_default("/greet")
+end

data/minitest/form_for_test.rb

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+class FormForTest < Minitest::Test
+  def setup
+    Funicular::SSR::Runtime.load_framework!
+  end
+
+  def component_class
+    Class.new(Funicular::Component) do
+      attr_reader :submitted
+
+      def initialize_state
+        { comment: { body: "" } }
+      end
+
+      def handle_submit(data)
+        @submitted = data
+      end
+
+      def render
+        form_for(:comment, on_submit: :handle_submit) do |f|
+          f.textarea(:body)
+          f.submit("Post")
+        end
+      end
+    end
+  end
+
+  class SubmitEvent
+    attr_reader :target
+
+    def initialize(target)
+      @target = target
+      @prevented = false
+    end
+
+    def preventDefault
+      @prevented = true
+    end
+
+    def prevented?
+      @prevented
+    end
+
+    def [](key)
+      key == :target ? @target : nil
+    end
+  end
+
+  class FormElement
+    def initialize(elements)
+      @elements = Elements.new(elements)
+    end
+
+    def [](key)
+      key == :elements ? @elements : nil
+    end
+  end
+
+  class Elements
+    def initialize(elements)
+      @elements = elements
+    end
+
+    def [](key)
+      return @elements.length if key == :length
+
+      @elements[key]
+    end
+  end
+
+  class Field
+    def initialize(attrs)
+      @attrs = attrs
+    end
+
+    def [](key)
+      @attrs[key]
+    end
+  end
+
+  def test_form_for_submits_current_dom_values
+    component = component_class.new
+    vnode = component.build_vdom
+    event = SubmitEvent.new(
+      FormElement.new([
+        Field.new(name: "body", type: "textarea", value: "fresh")
+      ])
+    )
+
+    vnode.props[:onsubmit].call(event)
+
+    assert_predicate event, :prevented?
+    assert_equal({ body: "fresh" }, component.submitted)
+  end
+
+  def test_form_builder_fields_include_names
+    component = component_class.new
+    vnode = component.build_vdom
+    textarea = vnode.children[0].children[0]
+
+    assert_equal "body", textarea.props[:name]
+  end
+end

data/minitest/hydration_test.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+# Exercises the hydration mismatch guard under CRuby. The structural decision
+# (`hydration_match?`) and the dev warning (`warn_hydration_mismatch`) are pure
+# Ruby, so they are tested here without a DOM. The actual recovery swap done by
+# `full_render_fallback` (Renderer + replaceChild) is JS-only and is covered by
+# the browser/manual verification step, not here.
+#
+# A plain Hash stands in for the server DOM node: hydration_match? only reads
+# `dom_element[:tagName]`, which a Hash answers the same way a JS::Element does.
+class HydrationMatchTest < Minitest::Test
+  def setup
+    Funicular::SSR::Runtime.load_framework!
+    Funicular.env = "development"
+  end
+
+  def teardown
+    Funicular.env = "development"
+  end
+
+  # Builds the probe at runtime (Class.new) so the suite matches its picotest
+  # twin and never references Funicular::Component at load time. render is never
+  # invoked here (we feed vnodes directly); it only satisfies the abstract API.
+  def probe
+    klass = Class.new(Funicular::Component) do
+      def render
+        div { "x" }
+      end
+
+      def match?(vnode, dom)
+        hydration_match?(vnode, dom)
+      end
+
+      def warn_for(vnode, dom)
+        warn_hydration_mismatch(vnode, dom)
+      end
+    end
+    klass.new
+  end
+
+  def el(tag)
+    Funicular::VDOM::Element.new(tag, {}, ["x"])
+  end
+
+  # --- hydration_match? (the decision that drives the fallback) ---------
+
+  def test_matches_when_root_tags_agree
+    assert_equal true, probe.match?(el("div"), { tagName: "DIV" })
+  end
+
+  def test_detects_mismatched_root_tag
+    assert_equal false, probe.match?(el("div"), { tagName: "SPAN" })
+  end
+
+  def test_tag_comparison_is_case_insensitive
+    assert_equal true, probe.match?(el("h1"), { tagName: "H1" })
+  end
+
+  def test_non_element_vnode_is_treated_as_match
+    assert_equal true, probe.match?(Funicular::VDOM::Text.new("hi"), { tagName: "DIV" })
+  end
+
+  def test_missing_dom_tag_name_is_treated_as_match
+    assert_equal true, probe.match?(el("div"), {})
+  end
+
+  # --- warn_hydration_mismatch (dev-only diagnostics) -------------------
+
+  def test_warning_fires_in_development
+    out, _err = capture_io do
+      probe.warn_for(el("div"), { tagName: "SPAN" })
+    end
+    assert_includes out, "Hydration mismatch"
+    assert_includes out, "<div>"
+    assert_includes out, "<span>"
+  end
+
+  def test_warning_is_silent_in_production
+    Funicular.env = "production"
+    out, _err = capture_io do
+      probe.warn_for(el("div"), { tagName: "SPAN" })
+    end
+    assert_equal "", out
+  end
+end

data/minitest/plugin_test.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+require "fileutils"
+require "tmpdir"
+
+require_relative "test_helper"
+
+class PluginTest < Minitest::Test
+  def test_registry_resolves_funicular_group_gems_and_syncs_assets
+    Dir.mktmpdir do |dir|
+      rails_root = File.join(dir, "app")
+      gem_root = File.join(dir, "funicular-datepicker")
+      FileUtils.mkdir_p(File.join(gem_root, "lib", "components"))
+      FileUtils.mkdir_p(File.join(gem_root, "assets"))
+      File.write(File.join(gem_root, "lib", "date_picker.rb"), "# plugin entry\n")
+      File.write(File.join(gem_root, "lib", "components", "date_picker_component.rb"), "# component\n")
+      File.write(File.join(gem_root, "assets", "date_picker.css"), "/* css */\n")
+
+      spec = Gem::Specification.new do |s|
+        s.name = "funicular-datepicker"
+        s.version = "0.1.0"
+        s.full_gem_path = gem_root
+      end
+
+      registry = Funicular::Plugin::Registry.new(rails_root)
+      registry.define_singleton_method(:funicular_specs) { [spec] }
+      registry.sync_assets
+
+      synced_css = File.join(
+        rails_root,
+        "app",
+        "assets",
+        "builds",
+        "funicular",
+        "plugins",
+        "funicular_datepicker",
+        "date_picker.css"
+      )
+      assert File.exist?(synced_css)
+
+      entries = registry.asset_entries
+      assert_equal 1, entries.size
+      assert_equal "css", entries.first["type"]
+      assert_equal "funicular/plugins/funicular_datepicker/date_picker.css", entries.first["logical_path"]
+      assert_equal [
+        File.join(gem_root, "lib", "components", "date_picker_component.rb"),
+        File.join(gem_root, "lib", "date_picker.rb")
+      ], registry.local_source_files
+    end
+  end
+end

data/minitest/schema_test.rb

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+require "test_helper"
+require "active_model"
+
+# Exercises Funicular::Schema.validations_for: deriving client validation rules
+# from an ActiveModel class, honoring the attribute allowlist and the per-kind
+# denylist, skipping unsupported/conditional validators, and translating the
+# `format` regexp for the JS RegExp engine.
+class SchemaDerivationTest < Minitest::Test
+  class Account
+    include ActiveModel::Validations
+    attr_accessor :name, :email, :age, :role, :code, :score
+
+    # Custom validator (kind :even) stands in for any non-standard validator
+    # the client has no counterpart for; it must be skipped during derivation.
+    class EvenValidator < ActiveModel::EachValidator
+      def validate_each(record, attribute, value); end
+    end
+
+    validates :name, presence: true, length: { maximum: 30 }
+    validates :email, format: { with: /\A[^@\s]+@[^@\s]+\z/ }
+    validates :age, numericality: { only_integer: true, greater_than: 0 }
+    validates :role, inclusion: { in: %w[admin user] }
+    validates :code, presence: true, if: -> { false }      # conditional -> skipped
+    validates :score, even: true                           # unsupported kind -> skipped
+  end
+
+  def derive(attrs, except: {})
+    Funicular::Schema.validations_for(Account, attrs, except: except)
+  end
+
+  def test_presence_and_length
+    result = derive(["name"])
+    assert_equal({ "presence" => true, "length" => { "maximum" => 30 } }, result["name"])
+  end
+
+  def test_only_listed_attributes_are_introspected
+    result = derive(["name"])
+    assert_equal ["name"], result.keys
+  end
+
+  def test_numericality_and_inclusion
+    result = derive(["age", "role"])
+    assert_equal({ "only_integer" => true, "greater_than" => 0 }, result["age"]["numericality"])
+    assert_equal({ "in" => %w[admin user] }, result["role"]["inclusion"])
+  end
+
+  def test_format_translates_ruby_anchors
+    result = derive(["email"])
+    fmt = result["email"]["format"]
+    # \A and \z become ^ and $ for JS RegExp.
+    assert_equal "^[^@\\s]+@[^@\\s]+$", fmt["with"]
+  end
+
+  def test_denylist_suppresses_a_kind
+    result = derive(["name"], except: { name: [:length] })
+    assert_equal({ "presence" => true }, result["name"])
+  end
+
+  def test_conditional_validator_is_skipped
+    result = derive(["code"])
+    assert_nil result["code"]
+  end
+
+  def test_unsupported_kind_is_skipped
+    result = derive(["score"])
+    assert_nil result["score"]
+  end
+
+  def test_build_inlines_validations_into_attributes
+    schema = Funicular::Schema.build(
+      Account,
+      attributes: {
+        "display_name" => { type: "string", readonly: false },
+        "name" => { type: "string", readonly: false }
+      },
+      endpoints: { "update" => { method: "PATCH", path: "/x/:id" } },
+      except: { name: [:length] }
+    )
+    # Attribute with no validators is untouched.
+    assert_equal({ type: "string", readonly: false }, schema[:attributes]["display_name"])
+    # Validators are merged inline; denylist drops :length here.
+    assert_equal(
+      { type: "string", readonly: false, validations: { "presence" => true } },
+      schema[:attributes]["name"]
+    )
+    assert_equal({ "update" => { method: "PATCH", path: "/x/:id" } }, schema[:endpoints])
+  end
+
+  def test_extended_regexp_is_skipped
+    klass = Class.new do
+      include ActiveModel::Validations
+      def self.name; "Extended"; end
+      attr_accessor :token
+      validates :token, format: { with: /
+        \A \d+ \z   # an integer, written with x-mode whitespace
+      /x }
+    end
+    result = nil
+    capture_io do  # silence the skip warning
+      result = Funicular::Schema.validations_for(klass, ["token"])
+    end
+    assert_nil result["token"]
+  end
+end

data/minitest/ssr_test.rb

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+# Exercises the SSR half of Funicular under CRuby: the shared HTMLSerializer
+# and the full path of loading the mrblib runtime + a fixture app, then
+# rendering a routed component to HTML with injected state.
+class SSRTest < Minitest::Test
+  APP_DIR = File.expand_path("fixtures/funicular_app", __dir__)
+
+  def setup
+    Funicular::SSR::Runtime.load_framework!
+  end
+
+  # --- HTMLSerializer (pure Ruby) ---------------------------------------
+
+  def serialize(vnode)
+    Funicular::VDOM::HTMLSerializer.serialize(vnode)
+  end
+
+  def el(tag, props = {}, children = [])
+    Funicular::VDOM::Element.new(tag, props, children)
+  end
+
+  def test_serializes_element_with_attributes
+    assert_equal '<div class="box" id="x"></div>',
+                 serialize(el("div", { class: "box", id: "x" }))
+  end
+
+  def test_escapes_text_content
+    assert_equal "<p>a &amp; b &lt;c&gt;</p>",
+                 serialize(el("p", {}, ["a & b <c>"]))
+  end
+
+  def test_escapes_attribute_values
+    assert_equal '<div title="&quot;hi&quot;"></div>',
+                 serialize(el("div", { title: '"hi"' }))
+  end
+
+  def test_skips_event_handlers
+    html = serialize(el("button", { onclick: :handle }, ["Go"]))
+    assert_equal "<button>Go</button>", html
+  end
+
+  def test_boolean_attribute_present_and_absent
+    assert_equal '<input disabled="disabled">',
+                 serialize(el("input", { disabled: true }))
+    assert_equal "<input>",
+                 serialize(el("input", { disabled: false }))
+  end
+
+  def test_void_element_self_closes
+    assert_equal "<br>", serialize(el("br"))
+    assert_equal '<img src="/a.png">', serialize(el("img", { src: "/a.png" }))
+  end
+
+  def test_blocks_javascript_uri
+    assert_equal "<a>x</a>",
+                 serialize(el("a", { href: "javascript:alert(1)" }, ["x"]))
+  end
+
+  # --- Full SSR render (runtime + fixture app) --------------------------
+
+  def test_render_injects_server_state
+    result = Funicular::SSR.render(
+      path: "/greet",
+      state: { title: "Channels", items: [{ "id" => 1, "name" => "general" },
+                                          { "id" => 2, "name" => "random" }] },
+      source_dir: APP_DIR
+    )
+
+    assert_includes result[:html], "<h1>Channels</h1>"
+    assert_includes result[:html], "general"
+    assert_includes result[:html], "random"
+    assert_equal GreetingComponent, result[:component]
+  end
+
+  def test_render_uses_initialize_state_without_injection
+    result = Funicular::SSR.render(path: "/greet", source_dir: APP_DIR)
+    assert_includes result[:html], "<h1>Default Title</h1>"
+  end
+
+  def test_render_unmatched_route_returns_empty
+    result = Funicular::SSR.render(path: "/no/such/path", source_dir: APP_DIR)
+    assert_equal "", result[:html]
+    assert_nil result[:component]
+  end
+
+  def test_route_params_become_props
+    # Renders without raising; :id from the path is passed as a prop.
+    result = Funicular::SSR.render(path: "/greet/42", source_dir: APP_DIR)
+    assert_includes result[:html], "greeting"
+  end
+end

data/minitest/validations_test.rb

@@ -0,0 +1,183 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+# Load the mrblib runtime before defining model subclasses below, since their
+# class bodies reference Funicular::Model and call `validates` at load time.
+Funicular::SSR::Runtime.load_framework!
+
+# Exercises the client-side validation framework under CRuby (the same code
+# runs in the browser under PicoRuby; see test/validations_test.rb).
+class ValidationsTest < Minitest::Test
+  # A fresh, isolated model class with the given schema so validators declared
+  # in one test never leak into another.
+  def model_class(attributes = { "name" => false, "age" => false }, endpoints = {})
+    klass = Class.new(Funicular::Model)
+    attrs = {}
+    attributes.each { |name, readonly| attrs[name] = { "type" => "string", "readonly" => readonly } }
+    klass.load_schema("attributes" => attrs, "endpoints" => endpoints)
+    klass
+  end
+
+  # --- individual validators -------------------------------------------
+
+  def test_presence
+    k = model_class
+    k.class_eval { validates :name, presence: true }
+    blank = k.new("name" => "")
+    assert_equal false, blank.valid?
+    assert_equal ["can't be blank"], blank.errors[:name]
+    assert_equal true, k.new("name" => "Alice").valid?
+  end
+
+  def test_length_maximum_and_minimum
+    k = model_class
+    k.class_eval { validates :name, length: { minimum: 2, maximum: 5 } }
+
+    short = k.new("name" => "a"); short.valid?
+    assert_equal ["is too short (minimum is 2 characters)"], short.errors[:name]
+
+    long = k.new("name" => "abcdef"); long.valid?
+    assert_equal ["is too long (maximum is 5 characters)"], long.errors[:name]
+
+    assert_equal true, k.new("name" => "abc").valid?
+  end
+
+  def test_format
+    k = model_class
+    k.class_eval { validates :name, format: { with: /^[a-z]+$/ } }
+    assert_equal true, k.new("name" => "abc").valid?
+    bad = k.new("name" => "ABC"); bad.valid?
+    assert_equal ["is invalid"], bad.errors[:name]
+  end
+
+  def test_numericality
+    k = model_class
+    k.class_eval { validates :age, numericality: { only_integer: true, greater_than: 0 } }
+    nan = k.new("age" => "abc"); nan.valid?
+    assert_equal ["is not a number"], nan.errors[:age]
+    assert_equal true, k.new("age" => "10").valid?
+    low = k.new("age" => "0"); low.valid?
+    assert_equal ["must be greater than 0"], low.errors[:age]
+    frac = k.new("age" => "1.5"); frac.valid?
+    assert_equal ["must be an integer"], frac.errors[:age]
+  end
+
+  def test_inclusion_and_exclusion
+    inc = model_class
+    inc.class_eval { validates :name, inclusion: { in: ["a", "b"] } }
+    assert_equal true, inc.new("name" => "a").valid?
+    assert_equal false, inc.new("name" => "z").valid?
+
+    exc = model_class
+    exc.class_eval { validates :name, exclusion: { in: ["admin"] } }
+    assert_equal false, exc.new("name" => "admin").valid?
+    assert_equal true, exc.new("name" => "alice").valid?
+  end
+
+  def test_allow_blank_skips_validation
+    k = model_class
+    k.class_eval { validates :name, length: { minimum: 3 }, allow_blank: true }
+    assert_equal true, k.new("name" => "").valid?
+    assert_equal false, k.new("name" => "ab").valid?
+  end
+
+  def test_valid_clears_previous_errors
+    k = model_class
+    k.class_eval { validates :name, presence: true }
+    m = k.new("name" => "")
+    m.valid?
+    m.instance_variable_set("@name", "now set")
+    assert_equal true, m.valid?
+    assert_equal [], m.errors[:name]
+  end
+
+  # --- schema-derived validators + merge -------------------------------
+
+  def test_load_schema_merges_and_dedupes
+    k = Class.new(Funicular::Model)
+    k.class_eval { validates :name, presence: true } # client-declared
+    k.load_schema(
+      "attributes" => {
+        "name" => { "type" => "string", "readonly" => false },
+        "age" => { "type" => "string", "readonly" => false }
+      },
+      "endpoints" => {},
+      "validations" => {
+        "name" => { "presence" => true, "length" => { "maximum" => 3 } },
+        "age" => { "presence" => true }
+      }
+    )
+
+    name_kinds = k.validators_on(:name).map(&:kind).sort
+    # presence appears once (client wins, schema presence deduped) + length merged
+    assert_equal [:length, :presence], name_kinds
+    assert_equal [:presence], k.validators_on(:age).map(&:kind)
+  end
+
+  def test_inline_attribute_validations_are_registered
+    # The shape produced by Funicular::Schema.build: validations nested inside
+    # each attribute entry.
+    k = Class.new(Funicular::Model)
+    k.load_schema(
+      "attributes" => {
+        "name" => {
+          "type" => "string", "readonly" => false,
+          "validations" => { "presence" => true, "length" => { "maximum" => 3 } }
+        }
+      },
+      "endpoints" => {}
+    )
+    assert_equal [:length, :presence], k.validators_on(:name).map(&:kind).sort
+    assert_equal false, k.new("name" => "toolong").valid?
+    assert_equal true, k.new("name" => "ok").valid?
+  end
+
+  def test_format_from_schema_rebuilds_regexp
+    k = Class.new(Funicular::Model)
+    k.load_schema(
+      "attributes" => { "name" => { "type" => "string", "readonly" => false } },
+      "endpoints" => {},
+      "validations" => { "name" => { "format" => { "with" => "^[a-z]+$", "flags" => "i" } } }
+    )
+    assert_equal true, k.new("name" => "ABC").valid? # 'i' flag honored
+    assert_equal false, k.new("name" => "123").valid?
+  end
+
+  # --- create/update auto-validation -----------------------------------
+
+  def test_create_short_circuits_when_invalid
+    k = model_class({ "name" => false }, "create" => { "method" => "POST", "path" => "/things" })
+    k.class_eval { validates :name, presence: true }
+
+    got_instance = :unset
+    got_error = :unset
+    # Invalid -> returns before any HTTP call, yields the errors.
+    k.create({ "name" => "" }) do |instance, error|
+      got_instance = instance
+      got_error = error
+    end
+
+    assert_nil got_instance
+    assert_instance_of Funicular::Model::Errors, got_error
+    assert_equal ["can't be blank"], got_error[:name]
+  end
+
+  def test_update_short_circuits_when_invalid
+    k = model_class({ "name" => false }, "update" => { "method" => "PATCH", "path" => "/things/:id" })
+    k.class_eval { validates :name, presence: true }
+
+    m = k.new("name" => "ok")
+    m.instance_variable_set("@id", 1)
+
+    got_success = :unset
+    got_result = :unset
+    m.update("name" => "") do |success, result|
+      got_success = success
+      got_result = result
+    end
+
+    assert_equal false, got_success
+    assert_equal ["can't be blank"], got_result[:name]
+  end
+end

data/mrbgem.rake

@@ -6,6 +6,7 @@ MRuby::Gem::Specification.new('picoruby-funicular') do |spec|
   unless ENV['TEST_TASK']
     spec.add_dependency 'picoruby-wasm'
   end
+  spec.add_dependency 'picoruby-indexeddb'
   spec.add_dependency 'picoruby-json'
   spec.add_dependency 'mruby-object-ext', gemdir: "#{MRUBY_ROOT}/mrbgems/picoruby-mruby/lib/mruby/mrbgems/mruby-object-ext"
   spec.add_dependency 'mruby-hash-ext', gemdir: "#{MRUBY_ROOT}/mrbgems/picoruby-mruby/lib/mruby/mrbgems/mruby-hash-ext"