tina4ruby 3.13.131 → 3.13.133

data/lib/tina4/rack_app.rb

@@ -941,7 +941,10 @@ module Tina4
       # data-reload gates the live reloader in toolbar.js: "1" on the human dev
       # port, "0" on the AI/stable port (the JS early-returns before starting the
       # reloader when it is not "1"). Matches Python's render_dev_toolbar.
-      reload = ai_port ? "0" : "1"
+      # Also suppress on the dev-admin dashboard (any /__dev page): its SPA reloads
+      # itself gently, so the toolbar's full-page reloader must not fire there --
+      # otherwise saving from the editor reloads the whole dashboard.
+      reload = (ai_port || request_info[:path].to_s.start_with?("/__dev")) ? "0" : "1"
       ai_badge = ai_port ? '<span class="t4-ai-badge">AI PORT</span>' : ""
 
       toolbar = <<~HTML.strip

data/lib/tina4/version.rb

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

data/lib/tina4/webserver.rb

@@ -97,6 +97,26 @@ module Tina4
         AccessLog: []
       )
 
+      # Dual-stack loopback: ALSO listen on the sibling loopback family on the
+      # MAIN port, so `localhost` reaches this server whether the OS resolves it
+      # to IPv4 (127.0.0.1) or IPv6 (::1). On Windows `localhost` resolves to
+      # ::1 first, so a server bound only to 127.0.0.1 -- or to 0.0.0.0, the
+      # IPv4 wildcard, which does NOT cover IPv6 -- refuses the browser with
+      # ERR_CONNECTION_REFUSED even though it is serving. The primary bind above
+      # is unchanged (keeps its fail-closed throw + port-takeover); each sibling
+      # is BEST-EFFORT via WEBrick::GenericServer#listen, which appends to the
+      # listener set the accept loop already services. A family that is
+      # unavailable, or that the primary bind already answers, raises and is
+      # skipped -- a sibling failure NEVER fails the boot. Main port only
+      # (mirrors tina4-php PR #206); the AI/debug port is left alone.
+      self.class.loopback_bind_hosts(@host).each do |sibling_host|
+        begin
+          @server.listen(sibling_host, @port)
+        rescue Errno::EADDRINUSE, Errno::EADDRNOTAVAIL, SocketError, Errno::EAFNOSUPPORT => e
+          Tina4::Log.debug("Dual-stack loopback: skipped #{sibling_host}:#{@port} (#{e.class})")
+        end
+      end
+
       # Record THIS process as the Tina4 dev server on the main port, so a later
       # `tina4 serve` can identify it as reclaimable (TAKEOVER-DEC-01).
       Tina4::PortTakeover.write_pidfile(@port)
@@ -106,6 +126,103 @@ module Tina4
 
       # Use a custom servlet that passes ALL methods (including OPTIONS) to Rack
       rack_app = @app
+      servlet = build_rack_servlet(@host, @port.to_s)
+
+      @server.mount("/", servlet, rack_app)
+
+      # Test port (port + 1000) — stable, no-browser
+      @ai_server = nil
+      @ai_thread = nil
+      no_ai_port = %w[true 1 yes].include?(ENV.fetch("TINA4_NO_AI_PORT", "").downcase)
+      is_debug   = %w[true 1 yes].include?(ENV.fetch("TINA4_DEBUG", "").downcase)
+
+      if is_debug && !no_ai_port
+        ai_port = @port + 1000
+        begin
+          test = TCPServer.new("0.0.0.0", ai_port)
+          test.close
+
+          @ai_server = WEBrick::HTTPServer.new(
+            BindAddress: @host,
+            Port: ai_port,
+            Logger: WEBrick::Log.new(File::NULL),
+            AccessLog: []
+          )
+
+          # Wrap the rack app so AI-port requests are tagged
+          ai_rack_app = Tina4::AiPortRackApp.new(@app)
+
+          # Same servlet as the main port, bound to the AI port's host/port.
+          ai_servlet = build_rack_servlet(@host, ai_port.to_s)
+
+          @ai_server.mount("/", ai_servlet, ai_rack_app)
+          @ai_thread = Thread.new { @ai_server.start }
+          puts "  Test Port: http://localhost:#{ai_port} (stable — no hot-reload)"
+        rescue Errno::EADDRINUSE
+          puts "  Test Port: SKIPPED (port #{ai_port} in use)"
+        end
+      end
+
+      @server.start
+
+      # Shutdown closes the listener FIRST, so #start returns as soon as the
+      # in-flight workers are joined - potentially while the signal handler's
+      # thread is still stopping background tasks and closing the database.
+      # Wait for that teardown instead of exiting out from under it.
+      Tina4::Shutdown.wait_for_completion
+    end
+
+    def stop
+      @ai_server&.shutdown
+      @ai_thread&.join(5)
+      @server&.shutdown
+      # Drop our identity marker so a later takeover does not match a dead PID.
+      Tina4::PortTakeover.remove_pidfile(@port)
+    end
+
+    # Dispatch a Rack-style env through the Tina4 app and return [status, headers, body].
+    #
+    # Useful for testing and embedding — does not require a running server.
+    # Cross-framework parity with Python and Node.js.
+    #
+    # @param env [Hash] A Rack environment hash
+    # @return [Array] Rack-style response triple [status, headers, body]
+    def handle(env)
+      @app.call(env)
+    end
+
+    # Sibling loopback addresses to ALSO listen on, so `localhost` reaches this
+    # server whether the OS resolves it to IPv4 (127.0.0.1) or IPv6 (::1).
+    #
+    # Returns only the families a direct bind of *host* does not already cover;
+    # a host that is neither loopback nor a wildcard yields an empty list -- an
+    # explicit LAN address is bound exactly as asked, with no sibling. The host
+    # is normalised (downcased, surrounding whitespace and brackets stripped) so
+    # "[::1]", " ::1 " and "::1" all resolve alike.
+    #
+    # Mirrors the tina4-php Server::loopbackBindHosts mapping exactly. WEBrick
+    # binds "::1" WITHOUT brackets (PHP's stream URL needed "[::1]"; the brackets
+    # are not carried into Ruby).
+    #
+    # @param host [String] the host the main socket binds
+    # @return [Array<String>] extra bind addresses (possibly empty)
+    def self.loopback_bind_hosts(host)
+      normalized = host.to_s.strip.downcase.gsub(/\A\[+|\]+\z/, "")
+      case normalized
+      when "localhost"            then ["127.0.0.1", "::1"]
+      when "127.0.0.1", "0.0.0.0" then ["::1"]
+      when "::1", "::"            then ["127.0.0.1"]
+      else []
+      end
+    end
+
+    private
+
+    # Build the Rack->WEBrick servlet class bound to a specific host/port.
+    # The main port and the debug AI port mount an identical servlet; the ONLY
+    # difference is the host/port reported in the Rack env, bound below via
+    # define_method. Extracted from two verbatim-identical copies.
+    def build_rack_servlet(host, port)
       servlet = Class.new(WEBrick::HTTPServlet::AbstractServlet) do
         define_method(:initialize) do |server, app|
           super(server)
@@ -186,146 +303,11 @@ module Tina4
         end
       end
 
-      # Store host/port for the servlet's build_rack_env
-      host = @host
-      port = @port.to_s
+      # Bind the per-server host/port the Rack env reports (the ONLY thing that
+      # differs between the main port and the AI port).
       servlet.define_method(:webrick_req_host) { host }
       servlet.define_method(:webrick_req_port) { port }
-
-      @server.mount("/", servlet, rack_app)
-
-      # Test port (port + 1000) — stable, no-browser
-      @ai_server = nil
-      @ai_thread = nil
-      no_ai_port = %w[true 1 yes].include?(ENV.fetch("TINA4_NO_AI_PORT", "").downcase)
-      is_debug   = %w[true 1 yes].include?(ENV.fetch("TINA4_DEBUG", "").downcase)
-
-      if is_debug && !no_ai_port
-        ai_port = @port + 1000
-        begin
-          test = TCPServer.new("0.0.0.0", ai_port)
-          test.close
-
-          @ai_server = WEBrick::HTTPServer.new(
-            BindAddress: @host,
-            Port: ai_port,
-            Logger: WEBrick::Log.new(File::NULL),
-            AccessLog: []
-          )
-
-          # Wrap the rack app so AI-port requests are tagged
-          ai_rack_app = Tina4::AiPortRackApp.new(@app)
-
-          # Build a servlet identical to the main one but bound to the AI port host/port
-          ai_host = @host
-          ai_port_str = ai_port.to_s
-          ai_servlet = Class.new(WEBrick::HTTPServlet::AbstractServlet) do
-            define_method(:initialize) do |server, app|
-              super(server)
-              @app = app
-            end
-
-            %w[GET POST PUT DELETE PATCH HEAD OPTIONS].each do |http_method|
-              define_method("do_#{http_method}") do |webrick_req, webrick_res|
-                handle_request(webrick_req, webrick_res)
-              end
-            end
-
-            define_method(:handle_request) do |webrick_req, webrick_res|
-              # Same accepted-a-moment-before-the-listener-closed race as the
-              # main servlet above - see the comment there.
-              if Tina4::Shutdown.shutting_down?
-                webrick_res.status = 503
-                webrick_res.body = '{"error":"Service shutting down"}'
-                webrick_res["content-type"] = "application/json"
-                return
-              end
-
-              Tina4::Shutdown.track_request do
-                env = build_rack_env(webrick_req)
-                status, headers, body = @app.call(env)
-
-                webrick_res.status = status
-                headers.each do |key, value|
-                  if key.downcase == "set-cookie"
-                    Array(value.split("\n")).each { |c| webrick_res.cookies << WEBrick::Cookie.parse_set_cookie(c) }
-                  else
-                    webrick_res[key] = value
-                  end
-                end
-
-                response_body = ""
-                body.each { |chunk| response_body += chunk }
-                webrick_res.body = response_body
-              end
-            end
-
-            define_method(:build_rack_env) do |req|
-              input = StringIO.new(req.body || "")
-              env = {
-                "REQUEST_METHOD"  => req.request_method,
-                "PATH_INFO"       => req.path,
-                "QUERY_STRING"    => req.query_string || "",
-                "SERVER_NAME"     => webrick_req_host,
-                "SERVER_PORT"     => webrick_req_port,
-                "CONTENT_TYPE"    => req.content_type || "",
-                "CONTENT_LENGTH"  => (req.content_length rescue 0).to_s,
-                "REMOTE_ADDR"     => req.peeraddr&.last || "127.0.0.1",
-                "rack.input"      => input,
-                "rack.errors"     => $stderr,
-                "rack.url_scheme" => "http",
-                "rack.version"    => [1, 3],
-                "rack.multithread"  => true,
-                "rack.multiprocess" => false,
-                "rack.run_once"     => false
-              }
-
-              req.header.each do |key, values|
-                env_key = "HTTP_#{key.upcase.gsub('-', '_')}"
-                env[env_key] = values.join(", ")
-              end
-
-              env
-            end
-          end
-
-          ai_servlet.define_method(:webrick_req_host) { ai_host }
-          ai_servlet.define_method(:webrick_req_port) { ai_port_str }
-
-          @ai_server.mount("/", ai_servlet, ai_rack_app)
-          @ai_thread = Thread.new { @ai_server.start }
-          puts "  Test Port: http://localhost:#{ai_port} (stable — no hot-reload)"
-        rescue Errno::EADDRINUSE
-          puts "  Test Port: SKIPPED (port #{ai_port} in use)"
-        end
-      end
-
-      @server.start
-
-      # Shutdown closes the listener FIRST, so #start returns as soon as the
-      # in-flight workers are joined - potentially while the signal handler's
-      # thread is still stopping background tasks and closing the database.
-      # Wait for that teardown instead of exiting out from under it.
-      Tina4::Shutdown.wait_for_completion
-    end
-
-    def stop
-      @ai_server&.shutdown
-      @ai_thread&.join(5)
-      @server&.shutdown
-      # Drop our identity marker so a later takeover does not match a dead PID.
-      Tina4::PortTakeover.remove_pidfile(@port)
-    end
-
-    # Dispatch a Rack-style env through the Tina4 app and return [status, headers, body].
-    #
-    # Useful for testing and embedding — does not require a running server.
-    # Cross-framework parity with Python and Node.js.
-    #
-    # @param env [Hash] A Rack environment hash
-    # @return [Array] Rack-style response triple [status, headers, body]
-    def handle(env)
-      @app.call(env)
+      servlet
     end
   end
 end

data/lib/tina4.rb

@@ -18,6 +18,7 @@ require_relative "tina4/database_result"
 require_relative "tina4/graph"
 require_relative "tina4/point"
 require_relative "tina4/field_types"
+require_relative "tina4/model_collection"
 require_relative "tina4/orm"
 require_relative "tina4/query_builder"
 require_relative "tina4/migration"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: tina4ruby
 version: !ruby/object:Gem::Version
-  version: 3.13.131
+  version: 3.13.133
 platform: ruby
 authors:
 - Tina4 Team
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-09-02 00:00:00.000000000 Z
+date: 2026-09-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rack
@@ -384,6 +384,7 @@ files:
 - lib/tina4/metrics.rb
 - lib/tina4/middleware.rb
 - lib/tina4/migration.rb
+- lib/tina4/model_collection.rb
 - lib/tina4/mqtt.rb
 - lib/tina4/mqtt_message.rb
 - lib/tina4/orm.rb