funicular 0.5.0 → 0.5.1

data/lib/funicular/version.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
-module Funicular
-  VERSION = "0.5.0"
-end
+# The version is defined once in mrblib/version.rb so that the same value
+# is compiled into PicoRuby.wasm. This file only exists to keep the
+# conventional `require "funicular/version"` entry point working.
+require_relative "../../mrblib/version"

data/lib/tasks/funicular.rake

@@ -54,8 +54,8 @@ namespace :funicular do
     end
   end
 
-  desc "Install Funicular debug assets, PicoRuby.wasm artifacts, and test support into a Rails app"
-  task install: ["install:debug_assets", "install:wasm", "install:test"] do
+  desc "Install Funicular debug assets, the gem initializer, PicoRuby.wasm artifacts, and test support into a Rails app"
+  task install: ["install:debug_assets", "install:initializer", "install:wasm", "install:test"] do
     puts ""
     puts "All Funicular assets installed."
     puts ""
@@ -79,32 +79,39 @@ namespace :funicular do
   end
 
   namespace :install do
-    desc "Install Funicular debug JS/CSS assets and the gem initializer"
+    desc "Install Funicular debug JS/CSS assets"
     task :debug_assets do
       require "fileutils"
 
-      javascripts_dir  = Rails.root.join("app", "assets", "javascripts")
-      stylesheets_dir  = Rails.root.join("app", "assets", "stylesheets")
-      initializers_dir = Rails.root.join("config", "initializers")
+      javascripts_dir = Rails.root.join("app", "assets", "javascripts")
+      stylesheets_dir = Rails.root.join("app", "assets", "stylesheets")
 
       FileUtils.mkdir_p(javascripts_dir)
       FileUtils.mkdir_p(stylesheets_dir)
-      FileUtils.mkdir_p(initializers_dir)
 
-      source_js          = File.expand_path("../funicular/assets/funicular_debug.js", __dir__)
-      source_css         = File.expand_path("../funicular/assets/funicular_debug.css", __dir__)
-      source_initializer = File.expand_path("../funicular/assets/funicular.rb", __dir__)
+      source_js  = File.expand_path("../funicular/assets/funicular_debug.js", __dir__)
+      source_css = File.expand_path("../funicular/assets/funicular_debug.css", __dir__)
 
-      dest_js          = javascripts_dir.join("funicular_debug.js")
-      dest_css         = stylesheets_dir.join("funicular_debug.css")
-      dest_initializer = initializers_dir.join("funicular.rb")
+      dest_js  = javascripts_dir.join("funicular_debug.js")
+      dest_css = stylesheets_dir.join("funicular_debug.css")
 
-      FileUtils.cp(source_js,          dest_js)
-      FileUtils.cp(source_css,         dest_css)
+      FileUtils.cp(source_js,  dest_js)
+      FileUtils.cp(source_css, dest_css)
 
       puts "Installed Funicular debug assets:"
       puts "  - #{dest_js}"
       puts "  - #{dest_css}"
+    end
+
+    desc "Install the gem initializer (config/initializers/funicular.rb)"
+    task :initializer do
+      require "fileutils"
+
+      initializers_dir = Rails.root.join("config", "initializers")
+      FileUtils.mkdir_p(initializers_dir)
+
+      source_initializer = File.expand_path("../funicular/assets/funicular.rb", __dir__)
+      dest_initializer   = initializers_dir.join("funicular.rb")
 
       # The initializer belongs to the application once it exists:
       # re-running the installer must never clobber its configuration
@@ -113,6 +120,7 @@ namespace :funicular do
         puts "Skipped #{dest_initializer} (exists; delete it first to reinstall the template)"
       else
         FileUtils.cp(source_initializer, dest_initializer)
+        puts "Installed Funicular initializer:"
         puts "  - #{dest_initializer}"
       end
     end

data/mrblib/debug.rb

@@ -136,11 +136,7 @@ module Funicular
         state = component.instance_variable_get(:@state) || {}
         result = {} #: Hash[String, String]
         state.each do |key, value|
-          begin
-            result[key.to_s] = value.inspect
-          rescue
-            result[key.to_s] = "<error inspecting value>"
-          end
+          result[key.to_s] = safe_inspect(value)
         end
         JSON.generate(result)
       end
@@ -159,11 +155,7 @@ module Funicular
             result[name] = "<omitted>"
             next
           end
-          begin
-            result[name] = component.instance_variable_get(var).inspect
-          rescue
-            result[name] = "<error inspecting value>"
-          end
+          result[name] = safe_inspect(component.instance_variable_get(var))
         end
         JSON.generate(result)
       end
@@ -176,6 +168,58 @@ module Funicular
 
       private
 
+      # Bounded inspect for the DevTools inspector. A plain Object#inspect
+      # walks the whole object graph: a component's @runtime reaches the
+      # router, the mounted component and its entire VDOM tree, and that
+      # recursion overflows the wasm C stack in a -O0 build. Without a
+      # guard page the overflow silently overwrites the heap below the
+      # stack, which surfaces later as garbage registers and GC crashes.
+      # Only leaves are inspected in full; containers and objects are
+      # summarized past INSPECT_MAX_DEPTH.
+      INSPECT_MAX_DEPTH = 3
+      INSPECT_MAX_ITEMS = 25
+
+      def safe_inspect(value, depth = 0)
+        case value
+        when nil, true, false, Integer, Float, Symbol, String
+          value.inspect
+        when Array
+          return "[...#{value.size} items]" if depth >= INSPECT_MAX_DEPTH
+          items = value.first(INSPECT_MAX_ITEMS).map { |v| safe_inspect(v, depth + 1) }
+          items << "...#{value.size - INSPECT_MAX_ITEMS} more" if value.size > INSPECT_MAX_ITEMS
+          "[#{items.join(', ')}]"
+        when Hash
+          return "{...#{value.size} pairs}" if depth >= INSPECT_MAX_DEPTH
+          pairs = [] #: Array[String]
+          value.each do |k, v|
+            break if pairs.size >= INSPECT_MAX_ITEMS
+            pairs << "#{safe_inspect(k, depth + 1)} => #{safe_inspect(v, depth + 1)}"
+          end
+          pairs << "...#{value.size - INSPECT_MAX_ITEMS} more" if value.size > INSPECT_MAX_ITEMS
+          "{#{pairs.join(', ')}}"
+        else
+          safe_inspect_object(value, depth)
+        end
+      rescue => e
+        "<#{e.class}: #{e.message}>"
+      end
+
+      def safe_inspect_object(value, depth)
+        # JS::Object#inspect is a shallow C implementation; other BasicObject
+        # proxies (style accessors) raise from method_missing on any name.
+        return value.inspect if defined?(::JS::Object) && ::JS::Object === value
+        return "#<BasicObject>" unless ::Object === value
+        klass = value.class.to_s
+        return "#<#{klass}>" if depth >= INSPECT_MAX_DEPTH
+        ivars = value.instance_variables
+        return value.inspect if ivars.empty?
+        parts = ivars.first(INSPECT_MAX_ITEMS).map do |iv|
+          "#{iv}=#{safe_inspect(value.instance_variable_get(iv), depth + 1)}"
+        end
+        parts << "...#{ivars.size - INSPECT_MAX_ITEMS} more" if ivars.size > INSPECT_MAX_ITEMS
+        "#<#{klass} #{parts.join(', ')}>"
+      end
+
       def get_state_keys(component)
         state = component.instance_variable_get(:@state)
         return [] unless state.is_a?(Hash)

data/mrblib/differ.rb

@@ -103,8 +103,8 @@ module Funicular
       # The new shape is `[[:keyed_children, ops, removes]]`, applied as
       # three phases by the patcher:
       #   1. removes (descending old_index, against the original DOM snapshot)
-      #   2. content updates for kept children (against the snapshot, no move)
-      #   3. inserts in ascending new_index using insertBefore on the live DOM
+      #   2. content updates for kept children (against the snapshot)
+      #   3. kept-node moves and inserts in new-index order on the live DOM
       def self.diff_children_with_keys(old_children, new_children)
         # 1. Build key map from old children
         old_key_map = {} #: Hash[untyped, [Integer, child_t]]
@@ -127,7 +127,7 @@ module Funicular
               matched_old_indices[old_index] = true
               child_patches = diff(old_child, new_child)
               ops << [:keep, old_index, new_index, child_patches]
-              has_change = true unless child_patches.empty?
+              has_change = true if old_index != new_index || !child_patches.empty?
             else
               ops << [:insert, new_index, new_child]
               has_change = true
@@ -156,10 +156,12 @@ module Funicular
         #    unkeyed ones) is gone from the new render and must be removed.
         #    Skipping unkeyed olds here left stale nodes in the DOM, e.g. a
         #    "Loading..." placeholder that never disappeared once the keyed
-        #    list it was replaced by arrived.
+        #    list it was replaced by arrived. Raw String children are text
+        #    nodes in the DOM (normalize_children keeps them as Strings), so
+        #    they must be collected here as well; only nil slots are skipped.
         removes = [] #: Array[[Integer, child_t]]
         old_children.each_with_index do |old_child, old_index|
-          next unless old_child.is_a?(VNode)
+          next if old_child.nil?
           next if matched_old_indices[old_index]
           removes << [old_index, old_child]
           has_change = true

data/mrblib/funicular.rb

@@ -15,11 +15,8 @@ rescue LoadError
 end
 
 module Funicular
-  # Guard against redefinition: when the mrblib runtime is loaded into a
-  # CRuby/Rails process for SSR, lib/funicular/version.rb has already defined
-  # VERSION for the CRuby gem. In the wasm build VERSION is undefined here.
-  VERSION = '0.5.0' unless Funicular.const_defined?(:VERSION)
-
+  # VERSION is defined in mrblib/version.rb, which is compiled into the wasm
+  # build alongside this file and loaded by lib/funicular/version.rb on CRuby.
   def self.version
     VERSION
   end

data/mrblib/patcher.rb

@@ -31,9 +31,13 @@ module Funicular
             # Apply internal patches and get the potentially new root element
             new_dom_element = Patcher.new(@doc, instance.runtime).apply(old_dom_element, internal_patches)
 
-            # Update the instance's reference to its root DOM element if it changed
+            # Update the instance's reference to its root DOM element if it
+            # changed. The new root must also become this apply's return
+            # value; otherwise a caller that stores the result (for example
+            # the keyed_children snapshot) keeps pointing at a detached node.
             if new_dom_element != old_dom_element && new_dom_element.is_a?(JS::Element)
               instance.dom_element = new_dom_element
+              result = new_dom_element
             end
 
             # Update the instance's VDOM to the new one AFTER applying patches
@@ -65,18 +69,23 @@ module Funicular
             #   1. snapshot DOM children, then remove unmatched keyed old
             #      children (descending old_index so the snapshot indices
             #      remain valid as removes happen).
-            #   2. apply content updates to kept children in place. The
+            #   2. apply content updates to kept children. The
             #      lookup is by snapshot[old_index], so updates are stable
-            #      regardless of subsequent insertions.
-            #   3. insert new children at their new_index using
-            #      insertBefore on the live DOM. Processed in ascending
-            #      new_index order so each insertion fixes its own
-            #      position before later inserts run.
+            #      regardless of removals.
+            #   3. place kept and new children at their new_index using
+            #      insertBefore on the live DOM. Ops are already in ascending
+            #      new_index order, so each placement fixes the next position.
+            #
+            # Phase 3 tracks the live child order in a Ruby array instead of
+            # re-reading childNodes per op. Every childNodes.to_a allocates a
+            # fresh JS::Object wrapper per node, so wrappers of the same DOM
+            # node never compare equal and the read itself is O(n) across the
+            # wasm boundary. Identity is therefore decided with equal? on the
+            # snapshot objects, which is both exact and free.
             ops = patch[1]
             removes = patch[2]
 
-            child_nodes = element[:childNodes]
-            snapshot = child_nodes.is_a?(JS::Object) ? child_nodes.to_a : [] #: Array[untyped]
+            snapshot = child_nodes_array(element)
 
             # Phase 1: removes (descending old_index)
             sorted_removes = removes.sort { |a, b| b[0] <=> a[0] }
@@ -88,9 +97,10 @@ module Funicular
               unmount_component(old_vnode)
               parent_el = target.parentElement
               parent_el.removeChild(target) if parent_el
+              snapshot[old_index] = nil
             end
 
-            # Phase 2: updates against the snapshot (no movement)
+            # Phase 2: updates against the snapshot
             ops.each do |op|
               next unless op[0] == :keep
               old_index = op[1]
@@ -98,31 +108,45 @@ module Funicular
               next if child_patches.empty?
               target = snapshot[old_index]
               next if target.nil?
-              apply(target, child_patches)
+              snapshot[old_index] = apply(target, child_patches)
             end
 
-            # Phase 3: inserts in ascending new_index order
+            # Phase 3: moves and inserts in ascending new_index order.
+            # `live` mirrors the DOM child order after phases 1 and 2 and is
+            # updated alongside every DOM mutation, so a node already sitting
+            # at new_index is left untouched (no detach/re-attach).
+            live = snapshot.compact #: Array[untyped]
             ops.each do |op|
-              next unless op[0] == :insert
-              new_index = op[1]
-              new_vnode = op[2]
-              new_node = create_element(new_vnode)
+              case op[0]
+              when :keep
+                new_node = snapshot[op[1]]
+                new_index = op[2]
+              when :insert
+                new_index = op[1]
+                new_node = create_element(op[2])
+              else
+                next
+              end
               next if new_node.nil?
-              live_nodes = element[:childNodes]
-              live_arr = live_nodes.is_a?(JS::Object) ? live_nodes.to_a : [] #: Array[untyped]
-              ref = live_arr[new_index]
-              if ref.nil?
-                element.appendChild(new_node) if element.is_a?(JS::Element)
+              current = live[new_index]
+              next if current.equal?(new_node)
+              live.delete_if { |n| n.equal?(new_node) }
+              if new_index < live.length
+                live.insert(new_index, new_node)
               else
-                element.insertBefore(new_node, ref) if element.is_a?(JS::Element)
+                live << new_node
+              end
+              next unless element.is_a?(JS::Element)
+              if current.nil?
+                element.appendChild(new_node)
+              else
+                element.insertBefore(new_node, current)
               end
             end
           when Integer
             child_index = patch[0]
             child_patches = patch[1]
-            # Use childNodes instead of children to include text nodes
-            child_nodes = element[:childNodes]
-            children = child_nodes.is_a?(JS::Object) ? child_nodes.to_a : [] #: Array[JS::Object]
+            children = child_nodes_array(element)
             child_element = children[child_index]
             if child_element.nil?
               # No existing child at this index - we need to create new elements
@@ -150,6 +174,14 @@ module Funicular
 
       private
 
+      # childNodes (not children) so that text nodes are included. Each call
+      # crosses the wasm boundary once per child, so callers should read it
+      # once and work on the returned array.
+      def child_nodes_array(element)
+        child_nodes = element[:childNodes]
+        child_nodes.is_a?(JS::Object) ? child_nodes.to_a : [] #: Array[untyped]
+      end
+
       def unmount_component(vnode)
         return unless vnode.is_a?(VDOM::Component) && vnode.instance
         vnode.instance.unmount

data/mrblib/vdom.rb

@@ -100,6 +100,11 @@ module Funicular
         @children = normalize_children(children || [])
       end
 
+      def ==(other)
+        return false unless other.is_a?(Element)
+        @tag == other.tag && @props == other.props && @children == other.children
+      end
+
       private
 
       def normalize_children(children)
@@ -124,11 +129,6 @@ module Funicular
         end
         result
       end
-
-      def ==(other)
-        return false unless other.is_a?(Element)
-        @tag == other.tag && @props == other.props && @children == other.children
-      end
     end
 
     class Text < VNode

data/mrblib/version.rb

@@ -0,0 +1,11 @@
+# Single source of truth for the Funicular version.
+#
+# This file lives in mrblib so that it is compiled into PicoRuby.wasm along
+# with the rest of the runtime. The CRuby gem reuses it via
+# lib/funicular/version.rb, so the version is defined in exactly one place.
+#
+# Keep this file free of any dependency: it must evaluate standalone in
+# both PicoRuby and CRuby, regardless of load order.
+module Funicular
+  VERSION = '0.5.1'
+end

data/sig/debug.rbs

@@ -20,7 +20,12 @@ module Funicular
     def self.last_error: () -> Hash[Symbol, untyped]?
     def self.error_count: () -> Integer
 
+    INSPECT_MAX_DEPTH: Integer
+    INSPECT_MAX_ITEMS: Integer
+
     private def self.error_registry: () -> Array[Hash[Symbol, untyped]]
+    private def self.safe_inspect: (untyped value, ?Integer depth) -> String
+    private def self.safe_inspect_object: (untyped value, Integer depth) -> String
     private def self.get_state_keys: (Funicular::Component) -> Array[String]
     private def self.get_child_ids: (Funicular::Component) -> Array[Integer]
     private def self.collect_direct_children: (Funicular::VDOM::VNode, Array[Funicular::Component]) -> void

data/sig/patcher.rbs

@@ -9,6 +9,7 @@ module Funicular
       def apply: (JS::Object element, Array[patch_t] patches) -> JS::Object
 
       # Accepts JS::Object since callers narrow via is_a?(JS::Element) at runtime
+      private def child_nodes_array: (JS::Object element) -> Array[untyped]
       private def update_props: (JS::Object element, Hash[Symbol, String?] props_patch) -> void
       private def create_element: (untyped vnode) -> JS::Object
       private def unmount_component: (VDOM::VNode vnode) -> void

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: funicular
 version: !ruby/object:Gem::Version
-  version: 0.5.0
+  version: 0.5.1
 platform: ruby
 authors:
 - HASUMI Hitoshi
@@ -156,6 +156,7 @@ files:
 - mrblib/store_singleton.rb
 - mrblib/styles.rb
 - mrblib/vdom.rb
+- mrblib/version.rb
 - mrblib/view_context.rb
 - sig/cable.rbs
 - sig/component.rbs
@@ -223,7 +224,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.10
+rubygems_version: 4.0.20
 specification_version: 4
 summary: Rails plugin for client-side Ruby development with mruby
 test_files: []