tina4ruby 3.13.34 → 3.13.36

data/lib/tina4/rack_app.rb

@@ -36,6 +36,29 @@ module Tina4
 
       # Shared WebSocket engine for route-based WS handling
       @websocket_engine = Tina4::WebSocket.new
+
+      # Register the dev-reload WebSocket route (debug mode only) so a browser
+      # handshake to /__dev_reload is accepted and held open by the connection
+      # manager. Without this the handshake never matches a route and falls
+      # through to 404, silently degrading the whole reloader to polling.
+      RackApp.register_dev_reload_ws if dev_mode?
+    end
+
+    # WebSocket handler for the dev-reload channel (/__dev_reload).
+    #
+    # Connections are accepted and held open; the shared Tina4::DevReload
+    # manager keeps a reference (wired in handle_websocket_upgrade) so
+    # POST /__dev/api/reload can broadcast an instant reload to every browser.
+    # Incoming frames are ignored — the open socket is the whole point.
+    DEV_RELOAD_WS_HANDLER = proc { |_connection, _event, _data| nil }
+
+    # Register the /__dev_reload WebSocket route (idempotent). Guarded on the
+    # router's actual state rather than a one-shot flag so that a Router.clear!
+    # (specs, hot-reload rescans) followed by a fresh RackApp re-registers it.
+    def self.register_dev_reload_ws
+      return if Tina4::Router.find_ws_route("/__dev_reload")
+
+      Tina4::Router.websocket("/__dev_reload", &DEV_RELOAD_WS_HANDLER)
     end
 
     def call(env)
@@ -865,8 +888,15 @@ module Tina4
       # Create a dedicated WebSocket engine for this route so handlers stay isolated
       ws = Tina4::WebSocket.new
 
+      # The dev-reload channel is held by a process-wide shared manager so a
+      # broadcast from POST /__dev/api/reload reaches every browser, not just
+      # the connections of this one isolated per-socket engine. Mirrors
+      # Python's single _ws_manager keyed on the /__dev_reload path.
+      dev_reload = ws_route.path == "/__dev_reload"
+
       ws.on(:open) do |connection|
         connection.params = ws_params
+        Tina4::DevReload.add(connection) if dev_reload
         handler.call(connection, :open, nil)
       end
 
@@ -875,6 +905,7 @@ module Tina4
       end
 
       ws.on(:close) do |connection|
+        Tina4::DevReload.remove(connection) if dev_reload
         handler.call(connection, :close, nil)
       end
 
@@ -1014,7 +1045,7 @@ module Tina4
                 el.style.color='#f38ba8';
             });
         }
-        #{ai_port ? "" : "/* tina4:reload-js */"}
+        #{ai_port ? "" : dev_reload_client_js}
         </script>
       HTML
 
@@ -1025,6 +1056,79 @@ module Tina4
       end
     end
 
+    # WebSocket-primary dev reloader injected into HTML pages in debug mode.
+    #
+    # The running server re-imports changed src/ route files in-process and
+    # pushes a {type,file,mtime} message over /__dev_reload — no respawn,
+    # instant refresh. The mtime poll is a FALLBACK only: it is started when
+    # the socket is down and stopped the moment it connects. On a CSS change
+    # the client swaps <link rel=stylesheet> hrefs with a cache-bust query;
+    # any other change does a full location.reload(). The poll seeds its
+    # last-seen mtime to a null sentinel (NOT 0) and reloads whenever the
+    # polled mtime DIFFERS (not just when greater) so the first change after
+    # load isn't swallowed and a counter reset on restart still triggers.
+    # Mirrors the Python master's injected client exactly.
+    def dev_reload_client_js
+      poll_interval_ms = (ENV["TINA4_DEV_POLL_INTERVAL"] || "3000").to_i
+      poll_interval_ms = 3000 if poll_interval_ms <= 0
+      <<~JS
+        (function(){
+            var _t4_css_exts=['.css','.scss'],_t4_debounce=null;
+            var _t4_interval=parseInt('#{poll_interval_ms}')||3000;
+            var _t4_ws=null,_t4_poll_timer=null,_t4_mtime=null;
+            function _t4_apply(d){
+                d=d||{};
+                var f=d.file||'',t=d.type||'';
+                var isCss=t==='css'||_t4_css_exts.some(function(e){return f.endsWith(e)});
+                if(isCss){
+                    var links=document.querySelectorAll('link[rel="stylesheet"]');
+                    links.forEach(function(l){
+                        var href=l.getAttribute('href');
+                        if(href){l.setAttribute('href',href.split('?')[0]+'?_t4='+(d.mtime||Date.now()))}
+                    });
+                }else{
+                    location.reload();
+                }
+            }
+            function _t4_poll(){
+                fetch('/__dev/api/mtime').then(function(r){return r.json()}).then(function(d){
+                    if(_t4_mtime===null){_t4_mtime=d.mtime;return;}
+                    if(d.mtime!==_t4_mtime){
+                        _t4_mtime=d.mtime;
+                        if(_t4_debounce)clearTimeout(_t4_debounce);
+                        _t4_debounce=setTimeout(function(){_t4_apply(d);},500);
+                    }
+                }).catch(function(){});
+            }
+            function _t4_startPoll(){
+                if(_t4_poll_timer)return;
+                _t4_mtime=null;
+                _t4_poll_timer=setInterval(_t4_poll,_t4_interval);
+            }
+            function _t4_stopPoll(){
+                if(_t4_poll_timer){clearInterval(_t4_poll_timer);_t4_poll_timer=null;}
+            }
+            function _t4_connect(){
+                var url=(location.protocol==='https:'?'wss':'ws')+'://'+location.host+'/__dev_reload';
+                try{_t4_ws=new WebSocket(url);}catch(_){_t4_startPoll();return;}
+                _t4_ws.addEventListener('open',function(){_t4_stopPoll();});
+                _t4_ws.addEventListener('message',function(ev){
+                    var d=null;
+                    try{d=typeof ev.data==='string'?JSON.parse(ev.data):null;}catch(_){}
+                    if(!d)return;
+                    if(d.type==='reload'||d.type==='change'||d.type==='css'){
+                        if(_t4_debounce)clearTimeout(_t4_debounce);
+                        _t4_debounce=setTimeout(function(){_t4_apply(d);},150);
+                    }
+                });
+                _t4_ws.addEventListener('close',function(){_t4_ws=null;_t4_startPoll();setTimeout(_t4_connect,2000);});
+                _t4_ws.addEventListener('error',function(){try{_t4_ws&&_t4_ws.close();}catch(_){}});
+            }
+            _t4_connect();
+        })();
+      JS
+    end
+
 
     # Read and rewind the Rack input body. Returns the raw body string.
     def _read_rack_body(env)

data/lib/tina4/router.rb

@@ -327,9 +327,31 @@ module Tina4
                           swagger_meta: swagger_meta,
                           middleware: middleware,
                           template: template)
-        routes << route
-        method_index[route.method] << route
-        Tina4::Log.debug("Route registered: #{method.upcase} #{path}")
+        # Replace semantics: re-registering the same (method, path) overwrites
+        # the existing entry in place rather than appending a second one.
+        # This is what makes dev hot-reload work — when a changed route file is
+        # re-loaded, its Router.get("/x") call runs again with a fresh handler,
+        # and #find_route returns the FIRST match, so a stale leftover would
+        # otherwise shadow the new handler forever. Overwriting keeps the
+        # registry free of duplicates and ensures the latest handler wins.
+        # Distinct (method, path) pairs are untouched — only an exact dup
+        # collapses onto the prior slot, preserving its position/order.
+        bucket = method_index[route.method]
+        existing_index = routes.index { |r| r.method == route.method && r.path == route.path }
+        if existing_index
+          routes[existing_index] = route
+          bucket_index = bucket.index { |r| r.path == route.path }
+          if bucket_index
+            bucket[bucket_index] = route
+          else
+            bucket << route
+          end
+          Tina4::Log.debug("Route replaced: #{route.method} #{route.path}")
+        else
+          routes << route
+          bucket << route
+          Tina4::Log.debug("Route registered: #{route.method} #{route.path}")
+        end
         route
       end
       # Convenience registration methods
@@ -485,10 +507,20 @@ module Tina4
 
       # Load route files from a directory (file-based route discovery).
       #
-      # Idempotent: files already loaded by a previous call are skipped, so
-      # calling load_routes repeatedly (e.g. on /__dev/api/reload) only
-      # picks up NEW files. Records the directory so #rescan_routes! can
-      # re-run without re-passing it.
+      # mtime-tracked & re-runnable so re-discovery on /__dev/api/reload is
+      # cheap and picks up edits without a server restart:
+      #
+      #   * NEW file (not seen before)            → load it, record its mtime.
+      #   * CHANGED file (mtime newer than seen)  → load it again. Ruby's `load`
+      #     RE-EXECUTES the file, so its Router.get(...) calls run afresh and
+      #     #add replaces the (method, path) in place — the new handler wins
+      #     instead of being shadowed by the stale one.
+      #   * UNCHANGED file (present, same mtime)  → skip (keeps reload cheap).
+      #
+      # Scope guard: the glob is rooted at the user's routes/`src` `directory`,
+      # so only application route files are ever (re)loaded — framework files
+      # are never touched. Records the directory so #rescan_routes! can re-run
+      # without re-passing it.
       def load_routes(directory)
         return unless Dir.exist?(directory)
 
@@ -498,10 +530,12 @@ module Tina4
         files = Dir.glob(File.join(directory, "**/*.rb")).sort
         total = files.length
         files.each do |file|
-          next if @loaded_route_files[file]
+          current_mtime = File.mtime(file).to_i
+          # Skip only when we've seen this file AND it hasn't changed since.
+          next if @loaded_route_files.key?(file) && current_mtime <= @loaded_route_files[file]
           begin
             load file
-            @loaded_route_files[file] = true
+            @loaded_route_files[file] = current_mtime
             Tina4::Log.debug("Route loaded: #{file}")
           rescue ScriptError, StandardError => e
             # ScriptError catches SyntaxError, which is NOT a StandardError —

data/lib/tina4/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Tina4
-  VERSION = "3.13.34"
+  VERSION = "3.13.36"
 end

data/lib/tina4/websocket.rb

@@ -344,4 +344,52 @@ module Tina4
       Tina4.build_frame(opcode, data)
     end
   end
+
+  # Shared, process-wide manager for the dev-reload channel (/__dev_reload).
+  #
+  # Every browser that loads a page in debug mode opens a WebSocket here and
+  # keeps it open. POST /__dev/api/reload (issued by the tina4 Rust CLI on a
+  # file change) calls Tina4::DevReload.broadcast(...) to push an instant
+  # {type, file, mtime} message to every connected client — no respawn, no
+  # poll. Mirrors Python's single `_ws_manager` holding /__dev_reload
+  # connections by path; in Ruby each route upgrade otherwise spins its own
+  # isolated WebSocket engine, so a dedicated shared manager is what makes a
+  # broadcast reach all clients.
+  module DevReload
+    @manager = nil
+    @mutex = Mutex.new
+
+    class << self
+      # The shared WebSocket manager that holds every /__dev_reload connection.
+      def manager
+        @mutex.synchronize { @manager ||= Tina4::WebSocket.new }
+      end
+
+      # Register an open connection so a later broadcast reaches it.
+      def add(connection)
+        manager.connections[connection.id] = connection
+      end
+
+      # Drop a connection on close.
+      def remove(connection)
+        manager.connections.delete(connection.id)
+      end
+
+      # Number of live dev-reload clients (used by tests / introspection).
+      def count
+        manager.connections.size
+      end
+
+      # Push a text frame to every connected dev-reload client. Best-effort:
+      # a dead socket or zero clients must never raise into the caller (the
+      # /__dev/api/reload endpoint), so failures are swallowed per-connection.
+      def broadcast(message)
+        manager.connections.values.each do |conn|
+          conn.send_text(message)
+        rescue StandardError
+          next
+        end
+      end
+    end
+  end
 end

data/lib/tina4.rb

@@ -107,6 +107,7 @@ module Tina4
   autoload :GraphQL,             File.expand_path("tina4/graphql", __dir__)
   autoload :WebSocket,           File.expand_path("tina4/websocket", __dir__)
   autoload :WebSocketConnection, File.expand_path("tina4/websocket", __dir__)
+  autoload :DevReload,           File.expand_path("tina4/websocket", __dir__)
   autoload :Testing,             File.expand_path("tina4/testing", __dir__)
   autoload :ScssCompiler,        File.expand_path("tina4/scss_compiler", __dir__)
   autoload :FakeData,            File.expand_path("tina4/seeder", __dir__)

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: tina4ruby
 version: !ruby/object:Gem::Version
-  version: 3.13.34
+  version: 3.13.36
 platform: ruby
 authors:
 - Tina4 Team