tina4ruby 3.10.91 → 3.10.92

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5a737d8b571f74eceea00422b681722ba711019f59c1fae14a8cc618bce5aa51
-  data.tar.gz: 6834b22997597eeb49064e17f56a6fd00280f9dc57c699a413402ff4fcbcc1c4
+  metadata.gz: 872c1e0d5dbae634259ad2772d69630f7160784967c03cb0d5ec68da3b122673
+  data.tar.gz: c08ab7a877b583e3141dc523125bc236e6e548f2acc5b757114074b3547b27c2
 SHA512:
-  metadata.gz: d85adcf4bfc4ca50956912e2fe926fc9cbe2833c0cb2a134d376ad63d13066d6c533e5418ff9aad40065a5c2a6313145d2a3da574f0a494fb86f906ca85545f5
-  data.tar.gz: 93a399a93f6c98ce34e0c521c33221cf5ac6d69238c0103099e7ecaa0f9c3c9c1d6ae2db48f0a2e12585e7d7700545a045c1e2122152657bdb753f518c4efcb5
+  metadata.gz: 2657a571cda5d98dcd0e46a0db670b6bcb027d23376d8b198413ad3b9c2f8bc56bec600fff1f77d71a0cf33ca51e632c3f4923f3caf67a8b40fd80125432f3b3
+  data.tar.gz: ecca10a04db72af6d1e7f42d60c1509c9d98ccb516d2635ecfa78bc48d2def7ac63dbb14092fa27e9c668fea1f2c57982c280210e56f755a6d9ccc122f326747

data/lib/tina4/ai.rb

@@ -29,7 +29,7 @@ module Tina4
       # @param root [String] project root directory
       # @param tool [Hash] tool entry from AI_TOOLS
       # @return [Boolean]
-      def installed?(root, tool)
+      def is_installed(root, tool)
         File.exist?(File.join(File.expand_path(root), tool[:context_file]))
       end
 
@@ -44,7 +44,7 @@ module Tina4
 
         puts "\n  Tina4 AI Context Installer\n"
         AI_TOOLS.each_with_index do |tool, i|
-          marker = installed?(root, tool) ? "  #{green}[installed]#{reset}" : ""
+          marker = is_installed(root, tool) ? "  #{green}[installed]#{reset}" : ""
           puts format("  %d. %-20s %s%s", i + 1, tool[:description], tool[:context_file], marker)
         end
 

data/lib/tina4/auto_crud.rb

@@ -194,10 +194,37 @@ module Tina4
         }, swagger_meta: { summary: "Delete #{pretty_name}", tags: [table.to_s] })
       end
 
+      # Discover ORM model classes from a directory and register them.
+      #
+      # @param models_dir [String] directory to scan (default "src/orm")
+      # @param prefix [String] URL prefix for generated routes (default "/api")
+      # @return [Array<String>] list of discovered model class names
+      def discover(models_dir = "src/orm", prefix: "/api")
+        discovered = []
+        return discovered unless Dir.exist?(models_dir)
+
+        Dir.glob(File.join(models_dir, "*.rb")).each do |file|
+          require_relative File.expand_path(file)
+        end
+
+        # Find all ORM subclasses that have a table_name
+        ObjectSpace.each_object(Class).select { |c| c < Tina4::ORM rescue false }.each do |klass|
+          next unless klass.respond_to?(:table_name) && klass.table_name
+          register(klass)
+          discovered << klass.name
+        end
+
+        generate_routes(prefix: prefix) unless discovered.empty?
+        discovered
+      end
+
       def clear!
         @models = []
       end
 
+      # Alias for parity with other frameworks
+      alias_method :clear, :clear!
+
       private
 
       # Parse sort parameter: "-name,created_at" => "name DESC, created_at ASC"

data/lib/tina4/cli.rb

@@ -204,7 +204,7 @@ module Tina4
 
       app = Tina4::RackApp.new(root_dir: root_dir)
 
-      is_debug = Tina4::Env.truthy?(ENV["TINA4_DEBUG"])
+      is_debug = Tina4::Env.is_truthy(ENV["TINA4_DEBUG"])
 
       # Use Puma only when explicitly requested via --production flag
       # WEBrick is used for development (supports dev toolbar/reload)

data/lib/tina4/dev_admin.rb

@@ -122,6 +122,7 @@ module Tina4
     def initialize
       @mutex  = Mutex.new
       @errors = nil  # lazy-loaded
+      @registered = false
       @store_path = File.join(
         Dir.tmpdir,
         "tina4_dev_errors_#{Digest::MD5.hexdigest(Dir.pwd)}.json"
@@ -232,10 +233,26 @@ module Tina4
       end
     end
 
+    # Register Ruby error handlers to feed the tracker.
+    # Installs an at_exit hook that captures unhandled exceptions.
+    # Safe to call multiple times — only registers once.
+    def register
+      return if @registered
+
+      @registered = true
+      tracker = self
+      at_exit do
+        if (exc = $!) && !exc.is_a?(SystemExit)
+          tracker.capture_exception(exc)
+        end
+      end
+    end
+
     # Reset (for testing).
     def reset!
       @mutex.synchronize do
         @errors = {}
+        @registered = false
         File.delete(@store_path) if File.exist?(@store_path)
       end
     end
@@ -294,7 +311,7 @@ module Tina4
       end
 
       def enabled?
-        Tina4::Env.truthy?(ENV["TINA4_DEBUG"])
+        Tina4::Env.is_truthy(ENV["TINA4_DEBUG"])
       end
 
       # Handle a /__dev request; returns [status, headers, body] or nil if not a dev path

data/lib/tina4/env.rb

@@ -16,7 +16,7 @@ module Tina4
     #
     # Accepts: "true", "True", "TRUE", "1", "yes", "Yes", "YES", "on", "On", "ON".
     # Everything else is falsy (including empty string, nil, not set).
-    def self.truthy?(val)
+    def self.is_truthy(val)
       %w[true 1 yes on].include?(val.to_s.strip.downcase)
     end
 

data/lib/tina4/error_overlay.rb

@@ -8,11 +8,11 @@
 #   begin
 #     handler.call(request, response)
 #   rescue => e
-#     Tina4::ErrorOverlay.render(e, request: env)
+#     Tina4::ErrorOverlay.render_error_overlay(e, request: env)
 #   end
 #
 # Only activate when TINA4_DEBUG is true.
-# In production, call Tina4::ErrorOverlay.render_production instead.
+# In production, call Tina4::ErrorOverlay.render_production_error instead.
 
 module Tina4
   module ErrorOverlay
@@ -38,7 +38,7 @@ module Tina4
       # @param exception [Exception] the caught exception
       # @param request [Hash, nil] optional request details (Rack env or custom hash)
       # @return [String] complete HTML page
-      def render(exception, request: nil)
+      def render_error_overlay(exception, request: nil)
         exc_type = exception.class.name
         exc_msg  = exception.message
 
@@ -113,7 +113,7 @@ module Tina4
       end
 
       # Render a safe, generic error page for production.
-      def render_production(status_code: 500, message: "Internal Server Error", path: "")
+      def render_production_error(status_code: 500, message: "Internal Server Error", path: "")
         # Determine color based on status code
         code_color = case status_code
                      when 403 then "#f59e0b"
@@ -155,8 +155,8 @@ module Tina4
       end
 
       # Return true if TINA4_DEBUG is enabled.
-      def debug_mode?
-        Tina4::Env.truthy?(ENV.fetch("TINA4_DEBUG", ""))
+      def is_debug_mode
+        Tina4::Env.is_truthy(ENV.fetch("TINA4_DEBUG", ""))
       end
 
       private

data/lib/tina4/html_element.rb

@@ -145,4 +145,26 @@ module Tina4
   def self.html_helpers
     HtmlHelpers
   end
+
+  # Inject _div(), _p(), _a(), etc. helper methods into the given namespace (hash or object).
+  #
+  # Usage:
+  #   h = {}
+  #   Tina4.add_html_helpers(h)
+  #   h[:_div].call({ class: "card" }, h[:_p].call("Hello"))
+  #
+  def self.add_html_helpers(namespace)
+    helper = Object.new.extend(HtmlHelpers)
+
+    HtmlElement::HTML_TAGS.each do |tag|
+      name = "_#{tag}"
+      fn = helper.method(name.to_sym)
+
+      if namespace.is_a?(Hash)
+        namespace[name.to_sym] = fn
+      else
+        namespace.define_singleton_method(name.to_sym, &fn)
+      end
+    end
+  end
 end

data/lib/tina4/log.rb

@@ -30,7 +30,7 @@ module Tina4
     class << self
       attr_reader :log_dir
 
-      def setup(root_dir = Dir.pwd)
+      def configure(root_dir = Dir.pwd)
         @log_dir = File.join(root_dir, "logs")
         FileUtils.mkdir_p(@log_dir)
 
@@ -55,7 +55,7 @@ module Tina4
         @mutex.synchronize { @request_id = nil }
       end
 
-      def request_id
+      def get_request_id
         @mutex.synchronize { @request_id }
       end
 
@@ -87,7 +87,7 @@ module Tina4
       end
 
       def log(level, message, context = {})
-        setup unless @initialized
+        configure unless @initialized
         @current_context = context.is_a?(Hash) ? context : {}
 
         formatted = format_line(level, message)
@@ -135,7 +135,7 @@ module Tina4
       def format_line(level, message)
         level_str = severity_to_level(level)
         ts = utc_timestamp
-        rid = request_id
+        rid = get_request_id
         rid_str = rid ? " [#{rid}]" : ""
         ctx = @current_context && !@current_context.empty? ? " #{JSON.generate(@current_context)}" : ""
         "#{ts} [#{level_str.ljust(7)}]#{rid_str} #{message}#{ctx}"
@@ -148,7 +148,7 @@ module Tina4
           level: level_str,
           message: message
         }
-        rid = request_id
+        rid = get_request_id
         entry[:request_id] = rid if rid
         entry[:context] = @current_context if @current_context && !@current_context.empty?
         JSON.generate(entry)

data/lib/tina4/mcp.rb

@@ -215,7 +215,7 @@ module Tina4
     end
 
     # Register HTTP routes for this MCP server on the Tina4 router.
-    def register_routes
+    def register_routes(router = nil)
       server   = self
       msg_path = "#{@path}/message"
       sse_path = "#{@path}/sse"

data/lib/tina4/messenger.rb

@@ -194,6 +194,31 @@ module Tina4
       []
     end
 
+    # Mark a message as read (set \Seen flag).
+    #
+    # @param uid [String, Integer] message UID
+    # @param folder [String] IMAP folder name
+    def mark_read(uid, folder: "INBOX")
+      imap_connect do |imap|
+        imap.select(folder)
+        imap.uid_store(uid.to_i, "+FLAGS", [:Seen])
+      end
+    rescue => e
+      Tina4::Log.error("IMAP mark_read failed: #{e.message}")
+    end
+
+    # Test IMAP connectivity without reading messages.
+    #
+    # @return [Hash] { success: Boolean, message: String }
+    def test_imap_connection
+      imap_connect do |_imap|
+        # Connection succeeded
+      end
+      { success: true, message: "Connected to #{@imap_host}:#{@imap_port}" }
+    rescue => e
+      { success: false, message: "IMAP connection failed: #{e.message}" }
+    end
+
     private
 
     # ── SMTP helpers ─────────────────────────────────────────────────────
@@ -515,7 +540,7 @@ module Tina4
   # Factory: returns a DevMailbox-intercepting messenger in dev mode,
   # or a real Messenger in production.
   def self.create_messenger(**options)
-    dev_mode = Tina4::Env.truthy?(ENV["TINA4_DEBUG"])
+    dev_mode = Tina4::Env.is_truthy(ENV["TINA4_DEBUG"])
 
     smtp_configured = (ENV["TINA4_MAIL_HOST"] && !ENV["TINA4_MAIL_HOST"].empty?) ||
                       (ENV["SMTP_HOST"] && !ENV["SMTP_HOST"].empty?)

data/lib/tina4/middleware.rb

@@ -156,6 +156,12 @@ module Tina4
         }
       end
 
+      def is_preflight(request)
+        request.method&.upcase == "OPTIONS" &&
+          request.headers["origin"] &&
+          request.headers["access-control-request-method"]
+      end
+
       def resolve_origin(request, config)
         request_origin = request.headers["origin"] || request.headers["referer"]
 
@@ -219,6 +225,28 @@ module Tina4
         [request, response]
       end
 
+      def check(ip)
+        limit  = (ENV["TINA4_RATE_LIMIT"]  || 100).to_i
+        window = (ENV["TINA4_RATE_WINDOW"] || 60).to_i
+        now = Time.now
+
+        @mutex.synchronize do
+          @store[ip] ||= []
+          entries = @store[ip]
+          entries.reject! { |t| t < now - window }
+
+          remaining = [limit - entries.length, 0].max
+          reset_at  = entries.empty? ? window : (entries.first + window - now).ceil
+
+          if entries.length >= limit
+            return [false, { limit: limit, remaining: 0, reset: reset_at, window: window }]
+          end
+
+          entries << now
+          [true, { limit: limit, remaining: remaining - 1, reset: window, window: window }]
+        end
+      end
+
       # Allow resetting state (useful in tests)
       def reset!
         @mutex.synchronize { @store.clear }

data/lib/tina4/orm.rb

@@ -124,7 +124,7 @@ module Tina4
       #
       # @return [Tina4::QueryBuilder]
       def query # -> QueryBuilder
-        QueryBuilder.from(table_name, db: db)
+        QueryBuilder.from_table(table_name, db: db)
       end
 
       # Find records by filter dict. Always returns an array.
@@ -732,7 +732,7 @@ module Tina4
 
     # ── Imperative relationship methods (ad-hoc, like Python/PHP/Node) ──
 
-    def query_has_one(related_class, foreign_key: nil)
+    def has_one(related_class, foreign_key: nil)
       pk = self.class.primary_key_field || :id
       pk_value = __send__(pk)
       return nil unless pk_value
@@ -744,7 +744,7 @@ module Tina4
       result ? related_class.from_hash(result) : nil
     end
 
-    def query_has_many(related_class, foreign_key: nil, limit: 100, offset: 0)
+    def has_many(related_class, foreign_key: nil, limit: 100, offset: 0)
       pk = self.class.primary_key_field || :id
       pk_value = __send__(pk)
       return [] unless pk_value
@@ -757,18 +757,12 @@ module Tina4
       results.map { |row| related_class.from_hash(row) }
     end
 
-    def query_belongs_to(related_class, foreign_key: nil)
+    def belongs_to(related_class, foreign_key: nil)
       fk = foreign_key || "#{related_class.name.split('::').last.downcase}_id"
       fk_value = respond_to?(fk.to_sym) ? __send__(fk.to_sym) : nil
       return nil unless fk_value
 
       related_class.find_by_id(fk_value)
     end
-
-    # Instance-level aliases matching Python/PHP/Node.js naming
-    # These are imperative relationship queries (not class-level declarations)
-    alias imperative_has_one query_has_one
-    alias imperative_has_many query_has_many
-    alias imperative_belongs_to query_belongs_to
   end
 end

data/lib/tina4/query_builder.rb

@@ -5,7 +5,7 @@ module Tina4
   #
   # Usage:
   #   # Standalone
-  #   result = Tina4::QueryBuilder.from("users", db: db)
+  #   result = Tina4::QueryBuilder.from_table("users", db: db)
   #     .select("id", "name")
   #     .where("active = ?", [1])
   #     .order_by("name ASC")
@@ -39,7 +39,7 @@ module Tina4
     # @param table_name [String] The database table name.
     # @param db [Object, nil] Optional database connection.
     # @return [QueryBuilder]
-    def self.from(table_name, db: nil)
+    def self.from_table(table_name, db: nil)
       new(table_name, db: db)
     end
 

data/lib/tina4/rack_app.rb

@@ -589,7 +589,7 @@ module Tina4
       Tina4::Log.error(error.backtrace&.first(10)&.join("\n"))
       if dev_mode?
         # Rich error overlay with stack trace, source context, and line numbers
-        body = Tina4::ErrorOverlay.render(error, request: env)
+        body = Tina4::ErrorOverlay.render_error_overlay(error, request: env)
       else
         body = Tina4::Template.render_error(500, {
           "error_message" => "#{error.message}\n#{error.backtrace&.first(10)&.join("\n")}",
@@ -600,7 +600,7 @@ module Tina4
     end
 
     def dev_mode?
-      Tina4::Env.truthy?(ENV["TINA4_DEBUG"])
+      Tina4::Env.is_truthy(ENV["TINA4_DEBUG"])
     end
 
     def websocket_upgrade?(env)
@@ -652,7 +652,7 @@ module Tina4
       method = request_info[:method]
       path = request_info[:path]
       matched_pattern = request_info[:matched_pattern]
-      request_id = Tina4::Log.request_id || "-"
+      request_id = Tina4::Log.get_request_id || "-"
       route_count = Tina4::Router.routes.length
 
       ai_badge = ai_port ? '<span style="background:#7c3aed;color:#fff;font-size:10px;padding:1px 6px;border-radius:3px;font-weight:bold;">AI PORT</span>' : ""

data/lib/tina4/rate_limiter.rb

@@ -86,8 +86,15 @@ module Tina4
       true
     end
 
+    # Standardized middleware hook — enforces rate limiting before the route handler.
+    def before_rate_limit(request, response)
+      ip = request.respond_to?(:ip) ? request.ip : "unknown"
+      apply(ip, response)
+      [request, response]
+    end
+
     # Reset tracking for a specific IP (useful for testing)
-    def reset!(ip = nil)
+    def reset(ip = nil)
       @mutex.synchronize do
         if ip
           @store.delete(ip)

data/lib/tina4/request.rb

@@ -126,8 +126,8 @@ module Tina4
     end
 
     # Look up a param by symbol or string key (indifferent access shortcut).
-    def param(key)
-      params[key.to_s] || params[key.to_sym]
+    def param(key, default = nil)
+      params[key.to_s] || params[key.to_sym] || default
     end
 
     def [](key)

data/lib/tina4/response.rb

@@ -3,6 +3,37 @@ require "json"
 require "uri"
 
 module Tina4
+  # ---------------------------------------------------------------------------
+  # Global Frond template engine registry
+  # ---------------------------------------------------------------------------
+  @_global_frond = nil
+  @_framework_frond = nil
+
+  # Return the global Frond engine, creating a default if needed.
+  def self.get_frond
+    @_global_frond ||= Tina4::Frond.new(template_dir: "src/templates")
+  end
+
+  # Return the singleton Frond engine for built-in framework templates.
+  def self.get_framework_frond
+    framework_dir = ::File.join(::File.dirname(__FILE__), "templates")
+    if @_framework_frond.nil? && ::File.directory?(framework_dir)
+      @_framework_frond = Tina4::Frond.new(template_dir: framework_dir)
+    end
+    # Sync custom filters/globals from the user engine
+    if @_framework_frond
+      user_engine = get_frond
+      @_framework_frond.instance_variable_get(:@filters).merge!(user_engine.instance_variable_get(:@filters))
+      @_framework_frond.instance_variable_get(:@globals).merge!(user_engine.instance_variable_get(:@globals))
+    end
+    @_framework_frond
+  end
+
+  # Register a pre-configured Frond engine for response.render().
+  def self.set_frond(engine)
+    @_global_frond = engine
+  end
+
   class Response
     MIME_TYPES = {
       ".html" => "text/html", ".htm" => "text/html",
@@ -123,12 +154,38 @@ module Tina4
     def render(template_path, data = {}, status: 200, template_dir: nil)
       @status_code = status
       @headers["content-type"] = HTML_CONTENT_TYPE
-      if template_dir
-        frond = Tina4::Frond.new(template_dir: template_dir)
-        @body = frond.render(template_path, data)
-      else
-        @body = Tina4::Template.render(template_path, data)
+
+      engine = template_dir ? Tina4::Frond.new(template_dir: template_dir) : Tina4.get_frond
+
+      # Try user templates first
+      begin
+        @body = engine.render(template_path, data)
+        return self
+      rescue Errno::ENOENT
+        # Not found in user templates — try framework templates
+      rescue => e
+        @body = "<pre>Template error: #{e.message}</pre>"
+        @status_code = 500
+        return self
+      end
+
+      # Fallback: framework templates
+      fw_engine = Tina4.get_framework_frond
+      if fw_engine
+        begin
+          @body = fw_engine.render(template_path, data)
+          return self
+        rescue Errno::ENOENT
+          # Not found in framework templates either
+        rescue => e
+          @body = "<pre>Template error: #{e.message}</pre>"
+          @status_code = 500
+          return self
+        end
       end
+
+      @body = "<pre>Template not found: #{template_path}</pre>"
+      @status_code = 404
       self
     end
 
@@ -152,9 +209,9 @@ module Tina4
     # Build a standard error envelope hash (class method).
     #
     # Usage:
-    #   response.json(Tina4::Response.error_envelope("NOT_FOUND", "Resource not found", 404), status: 404)
+    #   response.json(Tina4::Response.error_response("NOT_FOUND", "Resource not found", 404), status: 404)
     #
-    def self.error_envelope(code, message, status = 400)
+    def self.error_response(code, message, status = 400)
       { error: true, code: code, message: message, status: status }
     end
 
@@ -231,8 +288,17 @@ module Tina4
       self
     end
 
-    # Flush / finalize -- alias for to_rack for semantic clarity
-    def send
+    # Finalize and return the response — matches Python/Node API.
+    def send(data = nil, status_code: nil, content_type: nil)
+      if data
+        if data.is_a?(Hash) || data.is_a?(Array)
+          return json(data, status_code || 200)
+        end
+        @headers["content-type"] = content_type if content_type
+        @body = data.to_s
+        @status_code = status_code if status_code
+        return self
+      end
       to_rack
     end
 

data/lib/tina4/scss_compiler.rb

@@ -6,7 +6,37 @@ module Tina4
     SCSS_DIRS = %w[src/scss scss src/styles styles].freeze
     CSS_OUTPUT = "public/css"
 
+    # Module-level state for import paths and variables
+    @import_paths = []
+    @variables = {}
+
     class << self
+      # Add a search path for @import resolution.
+      def add_import_path(path)
+        @import_paths ||= []
+        @import_paths << path
+      end
+
+      # Set a variable that will be available during compilation.
+      def set_variable(name, value)
+        @variables ||= {}
+        name = name.sub(/^\$/, "")
+        @variables[name] = value
+      end
+
+      # Compile an SCSS string to CSS.
+      def compile(source)
+        @variables ||= {}
+        @import_paths ||= []
+        # Inject preset variables
+        unless @variables.empty?
+          var_block = @variables.map { |k, v| "$#{k}: #{v};" }.join("\n")
+          source = "#{var_block}\n#{source}"
+        end
+        basic_compile(source, @import_paths.first || Dir.pwd)
+      end
+
+      # Compile all .scss files from known directories.
       def compile_all(root_dir = Dir.pwd)
         output_dir = File.join(root_dir, CSS_OUTPUT)
         FileUtils.mkdir_p(output_dir)
@@ -22,20 +52,28 @@ module Tina4
         end
       end
 
-      def compile_file(scss_file, output_dir, base_dir)
-        relative = scss_file.sub(base_dir, "").sub(/\.scss$/, ".css")
-        css_file = File.join(output_dir, relative)
-        FileUtils.mkdir_p(File.dirname(css_file))
-
+      # Compile a single SCSS file. If output_dir is provided, writes CSS there.
+      # Always returns the compiled CSS string.
+      def compile_file(scss_file, output_dir = nil, base_dir = nil)
+        base_dir ||= File.dirname(scss_file)
         scss_content = File.read(scss_file)
         css_content = compile_scss(scss_content, File.dirname(scss_file))
-        File.write(css_file, css_content)
 
-        Tina4::Log.debug("Compiled SCSS: #{scss_file} -> #{css_file}")
+        if output_dir
+          relative = scss_file.sub(base_dir, "").sub(/\.scss$/, ".css")
+          css_file = File.join(output_dir, relative)
+          FileUtils.mkdir_p(File.dirname(css_file))
+          File.write(css_file, css_content)
+          Tina4::Log.debug("Compiled SCSS: #{scss_file} -> #{css_file}")
+        end
+
+        css_content
       rescue => e
         Tina4::Log.error("SCSS compilation failed: #{scss_file} - #{e.message}")
+        ""
       end
 
+      # Compile an SCSS content string with a base directory for import resolution.
       def compile_scss(content, base_dir)
         # Try sassc gem first
         begin
@@ -84,6 +122,12 @@ module Tina4
             File.join(base_dir, "_#{import_path}.scss"),
             File.join(base_dir, import_path)
           ]
+          # Also search additional import paths
+          (@import_paths || []).each do |search_path|
+            candidates << File.join(search_path, "#{import_path}.scss")
+            candidates << File.join(search_path, "_#{import_path}.scss")
+            candidates << File.join(search_path, import_path)
+          end
           found = candidates.find { |c| File.exist?(c) }
           if found
             imported = File.read(found)

data/lib/tina4/service_runner.rb

@@ -133,7 +133,7 @@ module Tina4
       end
 
       # Check if a specific service is currently running.
-      def running?(name)
+      def is_running(name)
         ctx = @contexts[name.to_s]
         ctx&.running == true && @threads[name.to_s]&.alive? == true
       end

data/lib/tina4/swagger.rb

@@ -4,9 +4,10 @@ require "json"
 module Tina4
   module Swagger
     class << self
-      def generate
+      def generate(routes = [])
         spec = base_spec
-        Tina4::Router.routes.each do |route|
+        route_list = routes.empty? ? Tina4::Router.routes : routes
+        route_list.each do |route|
           add_route_to_spec(spec, route)
         end
         spec

data/lib/tina4/testing.rb

@@ -15,6 +15,7 @@ module Tina4
 
       def reset!
         @suites = []
+        @inline_registry = []
         @results = { passed: 0, failed: 0, errors: 0, tests: [] }
       end
 
@@ -24,43 +25,159 @@ module Tina4
         suites << suite
       end
 
-      def run_all
+      def run_all(quiet: false, failfast: false)
         reset_results
         suites.each do |suite|
-          run_suite(suite)
+          run_suite(suite, quiet: quiet, failfast: failfast)
+          break if failfast && results[:failed] > 0
         end
-        print_results
+        # Run inline-registered tests
+        inline_registry.each do |entry|
+          run_inline_entry(entry, quiet: quiet)
+          break if failfast && results[:failed] > 0
+        end
+        print_results unless quiet
         results
       end
 
+      # ── Inline testing (parity with Python/PHP/Node decorator pattern) ──
+
+      # Assertion builder: assert_equal(args, expected)
+      def assert_equal(args, expected)
+        { type: :equal, args: args, expected: expected }
+      end
+
+      # Assertion builder: assert_raises(exception_class, args)
+      def assert_raises(exception_class, args)
+        { type: :raises, exception: exception_class, args: args }
+      end
+
+      # Assertion builder: assert_true(args)
+      def assert_true(args)
+        { type: :true, args: args }
+      end
+
+      # Assertion builder: assert_false(args)
+      def assert_false(args)
+        { type: :false, args: args }
+      end
+
+      # Register a callable with inline assertions (mirrors Python's @tests decorator).
+      #
+      #   Tina4::Testing.tests(
+      #     Tina4::Testing.assert_equal([5, 3], 8),
+      #     Tina4::Testing.assert_raises(ArgumentError, [nil]),
+      #   ) { |a, b| raise ArgumentError, "b required" if b.nil?; a + b }
+      #
+      def tests(*assertions, name: nil, &block)
+        raise ArgumentError, "tests requires a block" unless block_given?
+        inline_registry << {
+          fn: block,
+          name: name || "anonymous",
+          assertions: assertions
+        }
+        block
+      end
+
+      def inline_registry
+        @inline_registry ||= []
+      end
+
       private
 
+      def run_inline_entry(entry, quiet: false)
+        fn = entry[:fn]
+        name = entry[:name]
+        puts "\n  #{name}" unless entry[:assertions].empty? || quiet
+
+        entry[:assertions].each do |assertion|
+          args = assertion[:args]
+          case assertion[:type]
+          when :equal
+            begin
+              result = fn.call(*args)
+              if result == assertion[:expected]
+                results[:passed] += 1
+                puts "    \e[32m✓\e[0m #{name}(#{args.inspect}) == #{assertion[:expected].inspect}" unless quiet
+              else
+                results[:failed] += 1
+                puts "    \e[31m✗\e[0m #{name}(#{args.inspect}) expected #{assertion[:expected].inspect}, got #{result.inspect}" unless quiet
+              end
+            rescue => e
+              results[:errors] += 1
+              puts "    \e[33m!\e[0m #{name}(#{args.inspect}) raised #{e.class}: #{e.message}" unless quiet
+            end
+          when :raises
+            begin
+              fn.call(*args)
+              results[:failed] += 1
+              puts "    \e[31m✗\e[0m #{name}(#{args.inspect}) expected #{assertion[:exception]} but none raised" unless quiet
+            rescue assertion[:exception]
+              results[:passed] += 1
+              puts "    \e[32m✓\e[0m #{name}(#{args.inspect}) raises #{assertion[:exception]}" unless quiet
+            rescue => e
+              results[:failed] += 1
+              puts "    \e[31m✗\e[0m #{name}(#{args.inspect}) expected #{assertion[:exception]}, got #{e.class}" unless quiet
+            end
+          when :true
+            begin
+              result = fn.call(*args)
+              if result
+                results[:passed] += 1
+                puts "    \e[32m✓\e[0m #{name}(#{args.inspect}) is truthy" unless quiet
+              else
+                results[:failed] += 1
+                puts "    \e[31m✗\e[0m #{name}(#{args.inspect}) expected truthy, got #{result.inspect}" unless quiet
+              end
+            rescue => e
+              results[:errors] += 1
+              puts "    \e[33m!\e[0m #{name}(#{args.inspect}) raised #{e.class}: #{e.message}" unless quiet
+            end
+          when :false
+            begin
+              result = fn.call(*args)
+              if !result
+                results[:passed] += 1
+                puts "    \e[32m✓\e[0m #{name}(#{args.inspect}) is falsy" unless quiet
+              else
+                results[:failed] += 1
+                puts "    \e[31m✗\e[0m #{name}(#{args.inspect}) expected falsy, got #{result.inspect}" unless quiet
+              end
+            rescue => e
+              results[:errors] += 1
+              puts "    \e[33m!\e[0m #{name}(#{args.inspect}) raised #{e.class}: #{e.message}" unless quiet
+            end
+          end
+        end
+      end
+
       def reset_results
         @results = { passed: 0, failed: 0, errors: 0, tests: [] }
       end
 
-      def run_suite(suite)
-        puts "\n  #{suite.name}"
+      def run_suite(suite, quiet: false, failfast: false)
+        puts "\n  #{suite.name}" unless quiet
         suite.tests.each do |test|
-          run_test(suite, test)
+          run_test(suite, test, quiet: quiet)
+          break if failfast && results[:failed] > 0
         end
       end
 
-      def run_test(suite, test)
+      def run_test(suite, test, quiet: false)
         suite.run_before_each
         context = TestContext.new
         context.instance_eval(&test[:block])
         results[:passed] += 1
         results[:tests] << { name: test[:name], status: :passed, suite: suite.name }
-        puts "    \e[32m✓\e[0m #{test[:name]}"
+        puts "    \e[32m✓\e[0m #{test[:name]}" unless quiet
       rescue TestFailure => e
         results[:failed] += 1
         results[:tests] << { name: test[:name], status: :failed, suite: suite.name, message: e.message }
-        puts "    \e[31m✗\e[0m #{test[:name]}: #{e.message}"
+        puts "    \e[31m✗\e[0m #{test[:name]}: #{e.message}" unless quiet
       rescue => e
         results[:errors] += 1
         results[:tests] << { name: test[:name], status: :error, suite: suite.name, message: e.message }
-        puts "    \e[33m!\e[0m #{test[:name]}: #{e.message}"
+        puts "    \e[33m!\e[0m #{test[:name]}: #{e.message}" unless quiet
       ensure
         suite.run_after_each
       end
@@ -143,6 +260,16 @@ module Tina4
         true
       end
 
+      def assert_true(value, message = nil)
+        msg = message || "Expected truthy, got #{value.inspect}"
+        raise TestFailure, msg unless value
+      end
+
+      def assert_false(value, message = nil)
+        msg = message || "Expected falsy, got #{value.inspect}"
+        raise TestFailure, msg if value
+      end
+
       def assert_match(pattern, string, message = nil)
         msg = message || "Expected #{string.inspect} to match #{pattern.inspect}"
         raise TestFailure, msg unless pattern.match?(string)

data/lib/tina4/version.rb

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

data/lib/tina4/webserver.rb

@@ -276,5 +276,16 @@ module Tina4
       @ai_thread&.join(5)
       @server&.shutdown
     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
   end
 end

data/lib/tina4/websocket.rb

@@ -5,8 +5,32 @@ require "base64"
 require "set"
 
 module Tina4
+  WEBSOCKET_GUID = "258EAFA5-E914-47DA-95CA-5AB5DC11AD37"
+
+  # Compute Sec-WebSocket-Accept from Sec-WebSocket-Key per RFC 6455.
+  def self.compute_accept_key(key)
+    Base64.strict_encode64(Digest::SHA1.digest("#{key}#{WEBSOCKET_GUID}"))
+  end
+
+  # Build a WebSocket frame (server→client, never masked).
+  def self.build_frame(opcode, data, fin: true)
+    first_byte = (fin ? 0x80 : 0x00) | opcode
+    frame = [first_byte].pack("C")
+    length = data.bytesize
+
+    if length < 126
+      frame += [length].pack("C")
+    elsif length < 65536
+      frame += [126, length].pack("Cn")
+    else
+      frame += [127, length].pack("CQ>")
+    end
+
+    frame + data
+  end
+
   class WebSocket
-    GUID = "258EAFA5-E914-47DA-95CA-5AB5DC11AD37"
+    GUID = WEBSOCKET_GUID
 
     attr_reader :connections
 
@@ -68,6 +92,16 @@ module Tina4
       end
     end
 
+    def send_to(conn_id, message)
+      conn = @connections[conn_id]
+      conn&.send_text(message)
+    end
+
+    def close(conn_id, code: 1000, reason: "")
+      conn = @connections[conn_id]
+      conn&.close(code: code, reason: reason)
+    end
+
     # ── Rooms ──────────────────────────────────────────────────
 
     def join_room_for(conn_id, room_name)
@@ -99,9 +133,7 @@ module Tina4
       key = env["HTTP_SEC_WEBSOCKET_KEY"]
       return unless key
 
-      accept = Base64.strict_encode64(
-        Digest::SHA1.digest("#{key}#{GUID}")
-      )
+      accept = Tina4.compute_accept_key(key)
 
       response = "HTTP/1.1 101 Switching Protocols\r\n" \
                  "Upgrade: websocket\r\n" \
@@ -247,18 +279,7 @@ module Tina4
     end
 
     def build_frame(opcode, data)
-      frame = [0x80 | opcode].pack("C")
-      length = data.bytesize
-
-      if length < 126
-        frame += [length].pack("C")
-      elsif length < 65536
-        frame += [126, length].pack("Cn")
-      else
-        frame += [127, length].pack("CQ>")
-      end
-
-      frame + data
+      Tina4.build_frame(opcode, data)
     end
   end
 end

data/lib/tina4/websocket_backplane.rb

@@ -11,7 +11,7 @@
 #   TINA4_WS_BACKPLANE_URL — Connection string (default: redis://localhost:6379)
 #
 # Usage:
-#   backplane = Tina4::WebSocketBackplane.create
+#   backplane = Tina4::WebSocketBackplane.create_backplane
 #   if backplane
 #     backplane.subscribe("chat") { |msg| relay_to_local(msg) }
 #     backplane.publish("chat", '{"user":"A","text":"hello"}')
@@ -49,7 +49,7 @@ module Tina4
     #
     # This keeps backplane usage entirely optional — callers simply check
     # +if backplane+ before publishing.
-    def self.create(url: nil)
+    def self.create_backplane(url: nil)
       backend = ENV.fetch("TINA4_WS_BACKPLANE", "").strip.downcase
 
       case backend

data/lib/tina4/wsdl.rb

@@ -155,7 +155,8 @@ module Tina4
 
     # ── WSDL generation ──────────────────────────────────────────────────
 
-    def generate_wsdl
+    def generate_wsdl(endpoint_url = "")
+      @service_url = endpoint_url unless endpoint_url.empty?
       service_name = self.class.name ? self.class.name.split("::").last : "AnonymousService"
       tns = "urn:#{service_name}"
 

data/lib/tina4.rb

@@ -120,7 +120,7 @@ module Tina4
       color = is_tty ? "\e[31m" : ""
       reset = is_tty ? "\e[0m" : ""
 
-      is_debug = Tina4::Env.truthy?(ENV["TINA4_DEBUG"])
+      is_debug = Tina4::Env.is_truthy(ENV["TINA4_DEBUG"])
       log_level = (ENV["TINA4_LOG_LEVEL"] || "[TINA4_LOG_ALL]").upcase
       display = (host == "0.0.0.0" || host == "::") ? "localhost" : host
 
@@ -161,7 +161,7 @@ module Tina4
       Tina4::Env.load_env(root_dir)
 
       # Setup debug logging
-      Tina4::Log.setup(root_dir)
+      Tina4::Log.configure(root_dir)
       Tina4::Log.info("Tina4 Ruby v#{VERSION} initializing...")
 
       # Setup auth keys
@@ -240,7 +240,7 @@ module Tina4
       url = "http://#{display_host}:#{port}"
 
       app = Tina4::RackApp.new(root_dir: root_dir)
-      is_debug = Tina4::Env.truthy?(ENV["TINA4_DEBUG"])
+      is_debug = Tina4::Env.is_truthy(ENV["TINA4_DEBUG"])
 
       # Try Puma first (production-grade), fall back to WEBrick
       if !is_debug
@@ -390,7 +390,7 @@ module Tina4
       Tina4::Container.singleton(name, &block)
     end
 
-    def get(name)
+    def resolve(name)
       Tina4::Container.get(name)
     end
 

metadata

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