tina4ruby 3.10.23 → 3.10.30

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3ae8ae6d644a0cb19a5b5fc2f68b02066ecfc41c4f6b6e6bae2415fdbe078fcc
-  data.tar.gz: eb1dd0310b3ed508ea582ec186e64f050be8c4fc8925abd5f038689b20a6f551
+  metadata.gz: 9f356bd29729293ca6cbc614d058d1f36e587d24734ac95dc09dc2cb0dc8f106
+  data.tar.gz: 2fa1c1a2bd95599261b53b1790e27401abf8a9a9e308d03a05e33ccdafcbe7c2
 SHA512:
-  metadata.gz: cdcb3bf5c7d76949b51ec90fea3eed309fb0e9ec312f5ed5a02451da2a6953c3eb46524d191c0dee3d0efb587dc50581021dabd65b4432b42b469ccaa53342bf
-  data.tar.gz: ac974932d01d89edff858d9873ac39709f88161958956763757d952d8a3d17e97fccf96cd0cc1ce2678bca88488a357f9a28b7f2243d4bcd158be26f4e7fb541
+  metadata.gz: ff0588fb70c881e2b1a0a696df8b2ae1f7067b61c85dc29e64268a4f19b26e552e018c22321574e45b97814f86d708691f78120c74c7aaac0c76ad77f45bdbf4
+  data.tar.gz: c64f603f1d3cf692cfbbf45e476e16f7c69be7e4a0d127f9d10b3144b64edf3b82704ad2affdfc7ea127cbd67bef51c55b0b7f5416e741ef1c1210a6d75affdb

data/README.md

@@ -3,7 +3,7 @@
 </p>
 
 <h1 align="center">Tina4 Ruby</h1>
-<h3 align="center">This is not a framework</h3>
+<h3 align="center">This Is Now A 4Framework</h3>
 
 <p align="center">
   Laravel joy. Ruby speed. 10x less code. Zero third-party dependencies.

data/lib/tina4/dev_admin.rb

@@ -1,6 +1,8 @@
 # frozen_string_literal: true
 
 require "json"
+require "digest"
+require "tmpdir"
 
 module Tina4
   # Thread-safe in-memory message log for dev dashboard
@@ -104,6 +106,171 @@ module Tina4
     end
   end
 
+  # Thread-safe, file-persisted error tracker for the dev dashboard Error Tracker panel.
+  #
+  # Errors are stored in a JSON file in the system temp directory keyed by
+  # project path, so they survive across requests and server restarts.
+  # Duplicate errors (same type + message + file + line) are de-duplicated —
+  # the count increments and the entry is re-opened if it was resolved.
+  class ErrorTracker
+    MAX_ERRORS = 200
+    private_constant :MAX_ERRORS
+
+    def initialize
+      @mutex  = Mutex.new
+      @errors = nil  # lazy-loaded
+      @store_path = File.join(
+        Dir.tmpdir,
+        "tina4_dev_errors_#{Digest::MD5.hexdigest(Dir.pwd)}.json"
+      )
+    end
+
+    # Capture a Ruby error / exception into the tracker.
+    # @param error_type [String]  e.g. "RuntimeError" or "NoMethodError"
+    # @param message    [String]  exception message
+    # @param traceback  [String]  formatted backtrace (optional)
+    # @param file       [String]  source file (optional)
+    # @param line       [Integer] source line (optional)
+    def capture(error_type:, message:, traceback: "", file: "", line: 0)
+      @mutex.synchronize do
+        load_unlocked
+        fingerprint = Digest::MD5.hexdigest("#{error_type}|#{message}|#{file}|#{line}")
+        now = Time.now.utc.strftime("%Y-%m-%dT%H:%M:%SZ")
+
+        if @errors.key?(fingerprint)
+          @errors[fingerprint][:count]    += 1
+          @errors[fingerprint][:last_seen] = now
+          @errors[fingerprint][:resolved]  = false  # re-open resolved duplicates
+        else
+          @errors[fingerprint] = {
+            id:          fingerprint,
+            error_type:  error_type,
+            message:     message,
+            traceback:   traceback,
+            file:        file,
+            line:        line,
+            first_seen:  now,
+            last_seen:   now,
+            count:       1,
+            resolved:    false
+          }
+        end
+        save_unlocked
+      end
+    end
+
+    # Capture a Ruby exception object directly.
+    def capture_exception(exc)
+      capture(
+        error_type: exc.class.name,
+        message:    exc.message,
+        traceback:  (exc.backtrace || []).first(20).join("\n"),
+        file:       (exc.backtrace_locations&.first&.path || ""),
+        line:       (exc.backtrace_locations&.first&.lineno || 0)
+      )
+    end
+
+    # Return all errors (newest first).
+    # @param include_resolved [Boolean]
+    def get(include_resolved: true)
+      @mutex.synchronize do
+        load_unlocked
+        entries = @errors.values
+        entries = entries.reject { |e| e[:resolved] } unless include_resolved
+        entries.sort_by { |e| e[:last_seen] }.reverse
+      end
+    end
+
+    # Count of unresolved errors.
+    def unresolved_count
+      @mutex.synchronize do
+        load_unlocked
+        @errors.count { |_, e| !e[:resolved] }
+      end
+    end
+
+    # Health summary (matches Python BrokenTracker interface).
+    def health
+      @mutex.synchronize do
+        load_unlocked
+        total    = @errors.size
+        resolved = @errors.count { |_, e| e[:resolved] }
+        unresolved = total - resolved
+        { total: total, unresolved: unresolved, resolved: resolved, healthy: unresolved.zero? }
+      end
+    end
+
+    # Mark a single error as resolved.
+    def resolve(id)
+      @mutex.synchronize do
+        load_unlocked
+        return false unless @errors.key?(id)
+
+        @errors[id][:resolved] = true
+        save_unlocked
+        true
+      end
+    end
+
+    # Remove all resolved errors.
+    def clear_resolved
+      @mutex.synchronize do
+        load_unlocked
+        @errors.reject! { |_, e| e[:resolved] }
+        save_unlocked
+      end
+    end
+
+    # Remove ALL errors.
+    def clear_all
+      @mutex.synchronize do
+        @errors = {}
+        save_unlocked
+      end
+    end
+
+    # Reset (for testing).
+    def reset!
+      @mutex.synchronize do
+        @errors = {}
+        File.delete(@store_path) if File.exist?(@store_path)
+      end
+    end
+
+    private
+
+    def load_unlocked
+      return if @errors
+
+      if File.exist?(@store_path)
+        raw = File.read(@store_path) rescue nil
+        data = raw ? (JSON.parse(raw, symbolize_names: true) rescue nil) : nil
+        if data.is_a?(Array)
+          # Re-key by id
+          @errors = {}
+          data.each { |e| @errors[e[:id]] = e if e[:id] }
+        else
+          @errors = {}
+        end
+      else
+        @errors = {}
+      end
+    end
+
+    def save_unlocked
+      # Trim to max, keeping newest last_seen
+      if @errors.size > MAX_ERRORS
+        sorted = @errors.values.sort_by { |e| e[:last_seen] }.last(MAX_ERRORS)
+        @errors = {}
+        sorted.each { |e| @errors[e[:id]] = e }
+      end
+
+      File.write(@store_path, JSON.generate(@errors.values))
+    rescue StandardError
+      # Best-effort persistence — never raise in a tracker
+    end
+  end
+
   # Developer dashboard module - only active in debug mode
   module DevAdmin
     class << self
@@ -119,6 +286,10 @@ module Tina4
         @mailbox ||= DevMailbox.new
       end
 
+      def error_tracker
+        @error_tracker ||= ErrorTracker.new
+      end
+
       def enabled?
         Tina4::Env.truthy?(ENV["TINA4_DEBUG"])
       end
@@ -163,13 +334,16 @@ module Tina4
           messages = mailbox.inbox
           json_response({ messages: messages, count: messages.size, unread: mailbox.unread_count })
         when ["GET", "/__dev/api/broken"]
-          json_response({ errors: [], health: { total: 0, unresolved: 0, resolved: 0, healthy: true } })
+          errors   = error_tracker.get(include_resolved: true)
+          h        = error_tracker.health
+          json_response({ errors: errors, count: errors.size, health: h })
         when ["POST", "/__dev/api/broken/resolve"]
           body = read_json_body(env)
-          # TODO: resolve tracked error by id from body["id"]
-          json_response({ resolved: true })
+          id   = body && body["id"]
+          resolved = id ? error_tracker.resolve(id) : false
+          json_response({ resolved: resolved, id: id })
         when ["POST", "/__dev/api/broken/clear"]
-          # TODO: clear resolved errors
+          error_tracker.clear_resolved
           json_response({ cleared: true })
         when ["GET", "/__dev/api/websockets"]
           json_response({ connections: [], count: 0 })
@@ -301,7 +475,8 @@ module Tina4
           uptime: (Time.now - (defined?(@boot_time) && @boot_time ? @boot_time : (@boot_time = Time.now))).round(1),
           route_count: Tina4::Router.routes.size,
           request_stats: request_inspector.stats,
-          message_counts: message_log.count
+          message_counts: message_log.count,
+          health: error_tracker.health
         }
       end
 

data/lib/tina4/frond.rb

@@ -197,20 +197,14 @@ module Tina4
       raise "Template not found: #{path}" unless File.exist?(path)
 
       debug_mode = ENV.fetch("TINA4_DEBUG", "").downcase == "true"
-      cached = @compiled[template]
 
-      if cached
-        if debug_mode
-          # Dev mode: check if file changed
-          mtime = File.mtime(path)
-          if cached[1] == mtime
-            return execute_cached(cached[0], context)
-          end
-        else
-          # Production: skip mtime check, cache is permanent
-          return execute_cached(cached[0], context)
-        end
+      unless debug_mode
+        # Production: use permanent cache (no filesystem checks)
+        cached = @compiled[template]
+        return execute_cached(cached[0], context) if cached
       end
+      # Dev mode: skip cache entirely — always re-read and re-tokenize
+      # so edits to partials and extended base templates are detected
 
       # Cache miss — load, tokenize, cache
       source = File.read(path, encoding: "utf-8")
@@ -1429,7 +1423,7 @@ module Tina4
         param_names.each_with_index do |pname, pi|
           macro_ctx[pname] = pi < args.length ? args[pi] : nil
         end
-        engine.send(:render_tokens, captured_body.dup, macro_ctx)
+        Tina4::SafeString.new(engine.send(:render_tokens, captured_body.dup, macro_ctx))
       }
 
       i
@@ -1486,7 +1480,7 @@ module Tina4
         param_names.each_with_index do |pname, pi|
           macro_ctx[pname] = pi < args.length ? args[pi] : nil
         end
-        engine.send(:render_tokens, body_tokens.dup, macro_ctx)
+        Tina4::SafeString.new(engine.send(:render_tokens, body_tokens.dup, macro_ctx))
       }
     end
 

data/lib/tina4/orm.rb

@@ -388,21 +388,22 @@ module Tina4
       pk = self.class.primary_key_field || :id
       pk_value = __send__(pk)
 
-      if @persisted && pk_value
-        filter = { pk => pk_value }
-        data.delete(pk)
-        # Remove mapped primary key too
-        mapped_pk = self.class.field_mapping[pk.to_s]
-        data.delete(mapped_pk.to_sym) if mapped_pk
-        self.class.db.update(self.class.table_name, data, filter)
-      else
-        result = self.class.db.insert(self.class.table_name, data)
-        if result[:last_id] && respond_to?("#{pk}=")
-          __send__("#{pk}=", result[:last_id])
+      self.class.db.transaction do |db|
+        if @persisted && pk_value
+          filter = { pk => pk_value }
+          data.delete(pk)
+          # Remove mapped primary key too
+          mapped_pk = self.class.field_mapping[pk.to_s]
+          data.delete(mapped_pk.to_sym) if mapped_pk
+          db.update(self.class.table_name, data, filter)
+        else
+          result = db.insert(self.class.table_name, data)
+          if result[:last_id] && respond_to?("#{pk}=")
+            __send__("#{pk}=", result[:last_id])
+          end
+          @persisted = true
         end
-        @persisted = true
       end
-      self.class.db.commit
       true
     rescue => e
       @errors << e.message
@@ -414,17 +415,17 @@ module Tina4
       pk_value = __send__(pk)
       return false unless pk_value
 
-      if self.class.soft_delete
-        # Soft delete: set the flag
-        self.class.db.update(
-          self.class.table_name,
-          { self.class.soft_delete_field => 1 },
-          { pk => pk_value }
-        )
-      else
-        self.class.db.delete(self.class.table_name, { pk => pk_value })
+      self.class.db.transaction do |db|
+        if self.class.soft_delete
+          db.update(
+            self.class.table_name,
+            { self.class.soft_delete_field => 1 },
+            { pk => pk_value }
+          )
+        else
+          db.delete(self.class.table_name, { pk => pk_value })
+        end
       end
-      self.class.db.commit
       @persisted = false
       true
     end
@@ -434,8 +435,9 @@ module Tina4
       pk_value = __send__(pk)
       raise "Cannot delete: no primary key value" unless pk_value
 
-      self.class.db.delete(self.class.table_name, { pk => pk_value })
-      self.class.db.commit
+      self.class.db.transaction do |db|
+        db.delete(self.class.table_name, { pk => pk_value })
+      end
       @persisted = false
       true
     end
@@ -447,12 +449,13 @@ module Tina4
       pk_value = __send__(pk)
       raise "Cannot restore: no primary key value" unless pk_value
 
-      self.class.db.update(
-        self.class.table_name,
-        { self.class.soft_delete_field => 0 },
-        { pk => pk_value }
-      )
-      self.class.db.commit
+      self.class.db.transaction do |db|
+        db.update(
+          self.class.table_name,
+          { self.class.soft_delete_field => 0 },
+          { pk => pk_value }
+        )
+      end
       __send__("#{self.class.soft_delete_field}=", 0) if respond_to?("#{self.class.soft_delete_field}=")
       true
     end

data/lib/tina4/rack_app.rb

@@ -433,7 +433,7 @@ module Tina4
         <div class="hero">
             <img src="/images/tina4-logo-icon.webp" class="logo" alt="Tina4">
             <h1>Tina4Ruby</h1>
-            <p class="tagline">This is not a framework</p>
+            <p class="tagline">This Is Now A 4Framework</p>
             <div class="actions">
                 <a href="https://tina4.com/ruby" class="btn" target="_blank">Website</a>
                 <a href="/__dev" class="btn">Dev Admin</a>

data/lib/tina4/version.rb

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

data/lib/tina4.rb

@@ -134,7 +134,7 @@ module Tina4
       end
 
       puts "#{color}#{BANNER}#{reset}"
-      puts "  Tina4 Ruby v#{VERSION} — This is not a framework"
+      puts "  Tina4 Ruby v#{VERSION} — This Is Now A 4Framework"
       puts ""
       puts "  Server:    http://#{display}:#{port} (#{server_name})"
       puts "  Swagger:   http://localhost:#{port}/swagger"

metadata

@@ -1,13 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: tina4ruby
 version: !ruby/object:Gem::Version
-  version: 3.10.23
+  version: 3.10.30
 platform: ruby
 authors:
 - Tina4 Team
+autorequire:
 bindir: exe
 cert_chain: []
-date: 1980-01-02 00:00:00.000000000 Z
+date: 2026-03-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rack
@@ -399,6 +400,7 @@ licenses:
 - MIT
 metadata:
   homepage_uri: https://tina4.com
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -413,7 +415,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.3
+rubygems_version: 3.4.19
+signing_key:
 specification_version: 4
 summary: Simple. Fast. Human. This is not a framework.
 test_files: []