funicular 0.4.0 → 0.5.0

data/minitest/testing_ensure_compiled_test.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require "fileutils"
+require "tmpdir"
+
+require "test_helper"
+
+# Covers the freshness decision behind Funicular::Testing.ensure_compiled!.
+# The actual compile (Node + vendored mrbc) is integration-only, matching
+# the compiler tests' scope.
+class TestingEnsureCompiledTest < Minitest::Test
+  def test_stale_when_bundle_is_missing
+    Dir.mktmpdir do |dir|
+      assert Funicular::Testing.stale?(File.join(dir, "app.mrb"), [])
+    end
+  end
+
+  def test_fresh_when_bundle_is_newer_than_every_source
+    Dir.mktmpdir do |dir|
+      source = File.join(dir, "component.rb")
+      output = File.join(dir, "app.mrb")
+      File.write(source, "")
+      File.write(output, "")
+      File.utime(Time.now - 60, Time.now - 60, source)
+
+      refute Funicular::Testing.stale?(output, [ source ])
+    end
+  end
+
+  def test_stale_when_any_source_is_newer_than_the_bundle
+    Dir.mktmpdir do |dir|
+      old_source = File.join(dir, "old.rb")
+      new_source = File.join(dir, "new.rb")
+      output = File.join(dir, "app.mrb")
+      [ old_source, new_source, output ].each { |f| File.write(f, "") }
+      File.utime(Time.now - 60, Time.now - 60, old_source)
+      File.utime(Time.now - 30, Time.now - 30, output)
+      File.utime(Time.now, Time.now, new_source)
+
+      assert Funicular::Testing.stale?(output, [ old_source, new_source ])
+    end
+  end
+
+  def test_missing_sources_do_not_count
+    Dir.mktmpdir do |dir|
+      output = File.join(dir, "app.mrb")
+      File.write(output, "")
+
+      refute Funicular::Testing.stale?(output, [ File.join(dir, "gone.rb") ])
+    end
+  end
+end

data/minitest/validations_test.rb

@@ -30,6 +30,35 @@ class ValidationsTest < Minitest::Test
     assert_equal true, k.new("name" => "Alice").valid?
   end
 
+  def test_uncompilable_format_regex_is_skipped_not_fatal
+    k = model_class
+    out, _err = capture_io do
+      k.register_schema_validations(
+        "name" => {
+          "format" => { "with" => "[", "flags" => "" },
+          "presence" => true
+        }
+      )
+    end
+    # The warning names the rejected pattern so it can be found among
+    # many schemas loading at boot.
+    assert_match(/Skipping format validator/, out)
+    assert_match(/pattern: \[/, out)
+    # The broken format validator is dropped; the rest still applies and
+    # schema registration does not raise.
+    blank = k.new("name" => "")
+    assert_equal false, blank.valid?
+    assert_equal true, k.new("name" => "Alice").valid?
+  end
+
+  def test_schema_numericality_with_allow_nil_skips_nil
+    k = model_class({ "age" => false })
+    k.register_schema_validations("age" => { "numericality" => { "allow_nil" => true } })
+
+    assert_equal true, k.new("age" => nil).valid?
+    assert_equal false, k.new("age" => "abc").valid?
+  end
+
   def test_length_maximum_and_minimum
     k = model_class
     k.class_eval { validates :name, length: { minimum: 2, maximum: 5 } }
@@ -170,14 +199,15 @@ class ValidationsTest < Minitest::Test
     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_error = :unset
+    m.update("name" => "") do |result, error|
       got_result = result
+      got_error = error
     end
 
-    assert_equal false, got_success
-    assert_equal ["can't be blank"], got_result[:name]
+    # Unified 0.5.0 callback contract: (result, error), result nil on failure
+    assert_nil got_result
+    assert_equal ["can't be blank"], got_error[:name]
   end
 end

data/mrbgem.rake

@@ -7,7 +7,9 @@ MRuby::Gem::Specification.new('picoruby-funicular') do |spec|
     spec.add_dependency 'picoruby-wasm'
   end
   spec.add_dependency 'picoruby-indexeddb'
+  spec.add_dependency 'picoruby-sqlite3'
   spec.add_dependency 'picoruby-json'
+  spec.add_dependency 'picoruby-uri'
   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"
   spec.add_dependency 'mruby-array-ext', gemdir: "#{MRUBY_ROOT}/mrbgems/picoruby-mruby/lib/mruby/mrbgems/mruby-array-ext"

data/mrblib/cable.rb

@@ -229,7 +229,7 @@ module Funicular
 
       # Setup beforeunload handler to persist pending commands
       def setup_beforeunload_handler
-        @beforeunload_callback_id = JS.global.addEventListener("beforeunload") do
+        @beforeunload_callback_id = JS.global.addEventListener("beforeunload", sync: true) do
           save_pending_to_storage
         end
       end

data/mrblib/component.rb

@@ -171,6 +171,72 @@ module Funicular
       self
     end
 
+    # Bind a state key to a local-database Relation (docs decision 10):
+    # the block runs once now, and again after every change event on the
+    # relation's table. Each evaluation re-subscribes (a branchy block
+    # may return a different model's relation this time) and patches
+    # state[key], triggering a re-render. Subscriptions die with the
+    # component (see unmount), even when a lifecycle hook raises.
+    def watch(key, &block)
+      unless block
+        raise ArgumentError, "watch requires a block returning a Relation"
+      end
+      evaluate_watch(key, block)
+      nil
+    end
+
+    # Framework use (the subscription re-enters here on every event).
+    def evaluate_watch(key, block)
+      relation = block.call
+      unless relation.is_a?(Funicular::Relation)
+        raise ArgumentError,
+          "the watch(:#{key}) block must return a Funicular::Relation, " \
+          "got #{relation.class}; for hashes, counts, or raw SQL, " \
+          "subscribe with Model.on_change and patch state yourself"
+      end
+      # Materialize BEFORE touching subscriptions: if the query raises,
+      # neither a fresh subscription leaks (initial watch) nor the
+      # previous healthy one is lost (re-evaluation). Next-tick delivery
+      # guarantees no change event interleaves with this evaluation.
+      records = relation.to_a
+      source = relation.__event_source
+      watches = (@__watches ||= {}) # steep:ignore UnannotatedEmptyCollection
+      old = watches[key]
+      Funicular::DB.unsubscribe(old) if old
+      component = self
+      watches[key] = Funicular::DB.subscribe(source[0], source[1]) do |r, t|
+        component.evaluate_watch(key, block)
+      end
+      if @mounted
+        # The normal update contract: patch runs the update lifecycle
+        # (component_will_update/component_updated/component_raised),
+        # normalizes values, and re-renders. The bus's next-tick
+        # delivery guarantees we are never inside another update here.
+        patch(key => records)
+      else
+        # Before mount there is no update lifecycle to honor yet: land
+        # the initial data directly so state is ready for the first
+        # render.
+        @state = @state.merge({ key => records })
+        @state_accessor = nil
+      end
+      nil
+    end
+
+    def cleanup_watches
+      watches = @__watches
+      return nil unless watches
+      keys = watches.keys
+      keys_size = keys.size
+      i = 0
+      while i < keys_size
+        Funicular::DB.unsubscribe(watches[keys[i]])
+        i += 1
+      end
+      @__watches = {}
+      nil
+    end
+
     # Load all registered suspense data
     # Called automatically in component_mounted if suspense definitions exist
     def load_suspense_data
@@ -408,6 +474,10 @@ module Funicular
 
         component_mounted if respond_to?(:component_mounted)
       rescue => e
+        # A failed mount never reaches unmount (@mounted is still
+        # false), so watch subscriptions taken before/during the mount
+        # must be released here or they would pin the dead component.
+        cleanup_watches
         component_raised(e) if respond_to?(:component_raised)
         raise e
       end
@@ -423,9 +493,12 @@ module Funicular
     # window.__FUNICULAR_STATE__ before calling this.
     def hydrate(dom_element)
       return if @mounted
-      raise "hydrate: missing server DOM element" unless dom_element
 
       begin
+        # Inside the begin so a nil element takes the same cleanup path
+        # (releasing watch subscriptions) as every other hydrate failure.
+        raise "hydrate: missing server DOM element" unless dom_element
+
         component_will_mount if respond_to?(:component_will_mount)
 
         # The router/start sets the container; without it, unmount could not
@@ -467,11 +540,30 @@ module Funicular
 
         component_mounted if respond_to?(:component_mounted)
       rescue => e
+        # Same as mount: a failed hydrate cannot be unmounted, so the
+        # watch subscriptions must not outlive it.
+        cleanup_watches
         component_raised(e) if respond_to?(:component_raised)
         raise e
       end
     end
 
+    # Navigation guard: return a String message to ask the user for
+    # confirmation before this component is navigated away from (router
+    # navigation, browser back/forward, reload, tab close), or nil to
+    # allow leaving freely. Consulted by the router and its beforeunload
+    # listener; override in components with unsaved work:
+    #
+    #   def navigation_guard
+    #     state[:dirty] ? "Unsaved changes will be lost. Leave?" : nil
+    #   end
+    #
+    # Must not suspend (no fetch/HTTP): the beforeunload path runs it on
+    # the synchronous JS event dispatch stack.
+    def navigation_guard
+      nil
+    end
+
     # Unmount component from DOM
     def unmount
       return unless @mounted
@@ -502,6 +594,11 @@ module Funicular
       rescue => e
         component_raised(e) if respond_to?(:component_raised)
         raise e
+      ensure
+        # Watch subscriptions die with the component NO MATTER WHAT: a
+        # raising lifecycle hook must not leave a zombie watcher
+        # patching an unmounted component (docs decision 10).
+        cleanup_watches
       end
     end
 
@@ -559,6 +656,7 @@ module Funicular
             begin
               self.send(value, event)
             rescue => e
+              report_handler_error(event_name, "##{value}", e)
               component_raised(e) if respond_to?(:component_raised)
               raise e
             end
@@ -575,6 +673,7 @@ module Funicular
                 value.call(event)
               end
             rescue => e
+              report_handler_error(event_name, "##{value.name}", e)
               component_raised(e) if respond_to?(:component_raised)
               raise e
             end
@@ -591,6 +690,7 @@ module Funicular
                 value.call(event)
               end
             rescue => e
+              report_handler_error(event_name, "(proc)", e)
               component_raised(e) if respond_to?(:component_raised)
               raise e
             end
@@ -623,6 +723,18 @@ module Funicular
       end
     end
 
+    # Name the culprit before an event handler error is re-raised into
+    # the JS bridge, where "Callback <id>: ArgumentError: ..." carries no
+    # hint of which component or handler it came from. Uses puts so the
+    # message reaches the browser console (same idiom as the
+    # ErrorBoundary logger). Never raises itself.
+    def report_handler_error(event_name, handler, error)
+      puts "[Funicular] #{self.class}#{handler} (on#{event_name}) raised " \
+           "#{error.class}: #{error.message}"
+    rescue
+      nil
+    end
+
     # Collect ref elements from VDOM
     # Called by VDOM::Renderer and Patcher
     def collect_refs(dom_element, vnode, refs_map = {})