funicular 0.4.0 → 0.5.0

data/lib/funicular/ssr/runtime.rb

@@ -15,6 +15,7 @@ module Funicular
     # (Funicular.start, Router#start, FileUpload.mount, Debug) no-ops.
     module Runtime
       MRBLIB_DIR = File.expand_path("../../../mrblib", __dir__)
+      BOOT_MUTEX = Mutex.new
 
       # Load order is by dependency at *class-body* evaluation time. Most
       # files reference JS / other classes only inside methods, so only a
@@ -36,6 +37,8 @@ module Funicular
         router
         0_validations
         1_validators
+        db
+        relation
         model
         store
         store_singleton
@@ -71,33 +74,75 @@ module Funicular
         # In that case we rescue and continue: the AR constant is already defined
         # and is all that load_schemas needs (it ignores the hash on the server).
         #
-        # Loaded once per process. Restart the server to pick up changes.
+        # Loaded once per process. With auto_reload (the railtie enables
+        # it in development), edited sources are picked up on the next
+        # render: reloading re-runs the initializer, and the server-side
+        # Funicular.start builds a fresh router, so routes refresh too.
+        # Without it, restart the server to pick up changes.
         def boot!(source_dir)
-          load_framework!
-          return if @app_loaded
+          # Fast path for the steady production/test state: everything
+          # loaded and nobody watching for changes, no lock to take.
+          return if @framework_loaded && @app_loaded && !auto_reload
 
-          files = Funicular::Compiler.source_files(source_dir.to_s)
-          files.each do |file|
-            begin
-              Kernel.load(file)
-            rescue TypeError => e
-              # Funicular model name conflicts with an already-loaded AR model.
-              # The constant is already defined; safe to skip.
-              warn "[Funicular SSR] Skipped #{File.basename(file)}: #{e.message}"
+          # Concurrent renders (Puma threads in development) must not
+          # interleave two reloads: constants and the router would pass
+          # through inconsistent states mid-request.
+          BOOT_MUTEX.synchronize do
+            load_framework!
+            if @app_loaded
+              next unless auto_reload && sources_changed?(source_dir)
             end
+
+            files = Funicular::Compiler.source_files(source_dir.to_s)
+            files.each do |file|
+              begin
+                Kernel.load(file)
+              rescue TypeError => e
+                # Funicular model name conflicts with an already-loaded AR model.
+                # The constant is already defined; safe to skip.
+                warn "[Funicular SSR] Skipped #{File.basename(file)}: #{e.message}"
+              end
+            end
+            @app_loaded = true
+            @sources_snapshot = sources_snapshot(source_dir)
+          end
+        end
+
+        # Reload edited app sources on the next boot! instead of
+        # requiring a server restart (meant for development).
+        attr_accessor :auto_reload
+
+        def sources_changed?(source_dir)
+          @sources_snapshot != sources_snapshot(source_dir)
+        end
+
+        def sources_snapshot(source_dir)
+          Funicular::Compiler.source_files(source_dir.to_s).map do |file|
+            [ file, mtime_or_nil(file) ]
           end
-          @app_loaded = true
         end
 
         # Test/escape hatch: forget loaded application state so a different
         # app (or a reload) can be booted. Does not unload the framework.
         def reset_app!
           @app_loaded = false
+          @sources_snapshot = nil
         end
 
         def framework_loaded?
           !!@framework_loaded
         end
+
+        private
+
+        # The mtime read races with editors deleting or renaming files
+        # mid-edit; a vanished file counts as nil instead of breaking
+        # the render.
+        def mtime_or_nil(file)
+          File.mtime(file).to_f
+        rescue SystemCallError
+          nil
+        end
       end
     end
   end

data/lib/funicular/ssr.rb

@@ -37,6 +37,31 @@ module Funicular
       { html: html, state: state, component: component_class }
     end
 
+    # Render one component to an HTML string with no route lookup: for
+    # embedding a Funicular component into an otherwise server-rendered
+    # (ERB) page -- a shared site header, say -- so the markup has a
+    # single source of truth. The component is named by string and
+    # resolved after boot!, because host apps keep app/funicular out of
+    # Rails autoloading and the constant does not exist before loading.
+    # Handlers are not bound and no hydration happens: the output is
+    # static HTML (links still work; onclick and friends do not).
+    def self.render_component(component_name, props: {}, state: {}, source_dir: nil)
+      Runtime.boot!(source_dir || default_source_dir)
+
+      router = Funicular.router
+      raise "Funicular router is not configured; check app/funicular/initializer.rb" unless router
+
+      component_class = Object.const_get(component_name.to_s)
+      unless component_class.is_a?(Class) && component_class < Funicular::Component
+        raise ArgumentError, "#{component_name} is not a Funicular::Component subclass"
+      end
+
+      instance = component_class.new(symbolize_keys(props))
+      instance.runtime = Funicular::Runtime.new(router)
+      instance.seed_state(state)
+      Funicular::VDOM::HTMLSerializer.serialize(instance.build_vdom, instance.runtime)
+    end
+
     def self.default_source_dir
       raise "source_dir is required outside Rails" unless defined?(Rails) && Rails.respond_to?(:root)
       Rails.root.join("app", "funicular")

data/lib/funicular/testing/node_runner.mjs

@@ -105,6 +105,15 @@ module Funicular
         report(!actual.nil?, "Expected selector #{selector.inspect} to exist", selector, actual)
       end
 
+      def assert_no_selector(selector)
+        actual = query(selector)
+        report(actual.nil?, "Expected selector #{selector.inspect} to be absent", selector, actual)
+      end
+
+      def selector_count(selector)
+        JS.eval("document.querySelectorAll(" + JSON.generate(selector) + ").length").to_i
+      end
+
       def text(selector = nil)
         target = selector ? query(selector) : document.body
         target ? target[:textContent].to_s : ''
@@ -120,6 +129,16 @@ module Funicular
         )
       end
 
+      def assert_no_text(expected, selector = nil)
+        actual = text(selector)
+        report(
+          !actual.include?(expected.to_s),
+          "Expected text not to include #{expected.to_s.inspect}",
+          expected.to_s,
+          actual
+        )
+      end
+
       def dispatch(selector, event_type)
         script = "document.querySelector(" + JSON.generate(selector) + ")" \
           + ".dispatchEvent(new Event(" + JSON.generate(event_type) \

data/lib/funicular/testing.rb

@@ -1,6 +1,8 @@
 # frozen_string_literal: true
 
 require_relative "testing/node_runner"
+require_relative "plugin"
+require_relative "compiler"
 
 module Funicular
   module Testing
@@ -8,6 +10,51 @@ module Funicular
       NodeRunner.new(**options).run
     end
 
+    # One-call test-environment setup: syncs plugin assets and compiles
+    # the client bundle when it is missing or older than any source or
+    # plugin file. Development recompiles through the middleware and
+    # production through assets:precompile, but the test environment
+    # serves whatever app.mrb is lying around; call this once from
+    # test_helper and rely on the mtime check to keep it cheap.
+    #
+    #   Funicular::Testing.ensure_compiled!            # Rails.root
+    #   Funicular::Testing.ensure_compiled!(force: true)
+    #
+    # Returns the path of the compiled bundle.
+    def self.ensure_compiled!(root: nil, force: false, debug_mode: true)
+      root = Pathname.new(root || default_root)
+      registry = Funicular::Plugin::Registry.new(root)
+      registry.validate!
+      registry.sync_assets
+
+      source_dir = root.join("app", "funicular").to_s
+      output_file = root.join("app", "assets", "builds", "app.mrb").to_s
+      sources = registry.local_source_files + Funicular::Compiler.source_files(source_dir)
+
+      if force || stale?(output_file, sources)
+        Funicular::Compiler.new(
+          source_dir: source_dir,
+          output_file: output_file,
+          debug_mode: debug_mode,
+          prepend_source_files: registry.local_source_files
+        ).compile
+      end
+      output_file
+    end
+
+    # A bundle is stale when it does not exist or any source file was
+    # modified after it was built.
+    def self.stale?(output_file, source_files)
+      return true unless File.exist?(output_file)
+      build_time = File.mtime(output_file)
+      source_files.any? { |f| File.exist?(f) && File.mtime(f) > build_time }
+    end
+
+    def self.default_root
+      raise ArgumentError, "root is required outside Rails" unless defined?(Rails) && Rails.respond_to?(:root)
+      Rails.root
+    end
+
     def self.assert_picotests(test_case, result, print_summary: true)
       puts result.picotest_summary if print_summary
       test_case.assert result.success?, result.output

data/lib/funicular/vendor/mrbc/VERSION

@@ -1 +1 @@
-4.0.2
+4.0.3