tina4ruby 3.10.24 → 3.10.31

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6bbf81019e88de5f456938818de88c5f8219dcb691d647c26d504f6aacdf229a
-  data.tar.gz: a0b70c415d26e8727cfec8337fc957a58cb4d4895565bc0c1922ef9ebd2383c8
+  metadata.gz: f58284436d1c4f21bf16c723f02d174c6b4090395eb59a8357387b776cdb3c07
+  data.tar.gz: e19f24eac4a4010d9377a74f7e5da9ab437c062b3c4773f1a0932995b661e298
 SHA512:
-  metadata.gz: a10cdebeca708e63aebaa1f75e8d18e1b77429560f42a0bedcec9247792c9ce7451d93a233f4b6c1bdd8865e7ce4bae3440ae33cded8974e8dbcf4cfac060e93
-  data.tar.gz: f613505809da1d5d5868e52a368f09a82e7f24905f5f51011b6747d4b45877e4151d5830f45a943764ba84f42d5b76aa40a47284038dafb8d40406164d748570
+  metadata.gz: 9191ea613953492469a000a221cc0c18f819eb48493c6a3128b04f5ef1e85d99ab08c29fe38ebbdb3b1fdfc85db1eaa648c6d327888d0f57ad19af7a14f4155d
+  data.tar.gz: 7d431e996a22db4a25879f148e891ceaeb6a7b8e186e2e5c9ccecb631234122c8a463b35f4bf4c963435973dc1b6c58dd819053ae2966917742c2baa0860a45d

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

@@ -45,7 +45,7 @@ module Tina4
     HASH_LIT_RE     = /\A\{(.+)\}\z/m
     HASH_PAIR_RE    = /\A\s*["']?(\w+)["']?\s*:\s*(.+)\z/
     RANGE_LIT_RE    = /\A(\d+)\.\.(\d+)\z/
-    ARITHMETIC_RE   = /\A(.+?)\s*(\+|-|\*|\/|%)\s*(.+)\z/
+    ARITHMETIC_OPS  = [" + ", " - ", " * ", " // ", " / ", " % ", " ** "].freeze
     FUNC_CALL_RE    = /\A(\w+)\s*\((.*)\)\z/m
     FILTER_WITH_ARGS_RE = /\A(\w+)\s*\((.*)\)\z/m
     FILTER_CMP_RE   = /\A(\w+)\s*(!=|==|>=|<=|>|<)\s*(.+)\z/
@@ -933,12 +933,15 @@ module Tina4
         return eval_comparison(expr, context)
       end
 
-      # Arithmetic: +, -, *, /, %
-      if expr =~ ARITHMETIC_RE
-        left  = eval_expr(Regexp.last_match(1), context)
-        op    = Regexp.last_match(2)
-        right = eval_expr(Regexp.last_match(3), context)
-        return apply_math(left, op, right)
+      # Arithmetic: +, -, *, //, /, %, ** (lowest to highest precedence)
+      ARITHMETIC_OPS.each do |op|
+        pos = find_outside_quotes(expr, op)
+        next unless pos && pos >= 0
+        left_s = expr[0...pos].strip
+        right_s = expr[(pos + op.length)..].strip
+        l_val = eval_expr(left_s, context)
+        r_val = eval_expr(right_s, context)
+        return apply_math(l_val, op.strip, r_val)
       end
 
       # Function call: name(arg1, arg2)
@@ -1144,17 +1147,21 @@ module Tina4
     # -----------------------------------------------------------------------
 
     def apply_math(left, op, right)
-      l = left.to_f
-      r = right.to_f
+      l = (left || 0).to_f
+      r = (right || 0).to_f
+      # Preserve int type when both operands are int-like (except for / which returns float)
+      both_int = l == l.to_i && r == r.to_i && op != "/"
       result = case op
-               when "+" then l + r
-               when "-" then l - r
-               when "*" then l * r
-               when "/" then r != 0 ? l / r : 0
-               when "%" then l % r
+               when "+"  then l + r
+               when "-"  then l - r
+               when "*"  then l * r
+               when "/"  then r != 0 ? l / r : 0
+               when "//" then r != 0 ? (l / r).floor : 0
+               when "%"  then r != 0 ? l % r : 0
+               when "**" then l ** r
                else 0
                end
-      result == result.to_i ? result.to_i : result
+      both_int && result == result.to_i ? result.to_i : result.to_f == result.to_i ? result.to_i : result
     end
 
     # -----------------------------------------------------------------------
@@ -1354,7 +1361,7 @@ module Tina4
       if content =~ SET_RE
         name = Regexp.last_match(1)
         expr = Regexp.last_match(2).strip
-        context[name] = eval_expr(expr, context)
+        context[name] = eval_var_raw(expr, context)
       end
     end
 
@@ -1423,7 +1430,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
@@ -1480,7 +1487,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.24"
+  VERSION = "3.10.31"
 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,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: tina4ruby
 version: !ruby/object:Gem::Version
-  version: 3.10.24
+  version: 3.10.31
 platform: ruby
 authors:
 - Tina4 Team