tina4ruby 3.10.42 → 3.10.44

data/lib/tina4/frond.rb

@@ -843,32 +843,68 @@ module Tina4
     # Expression evaluator
     # -----------------------------------------------------------------------
 
+    # ── Expression evaluator (dispatcher) ──────────────────────────────
+    # Each expression type is handled by a focused helper method.
+    # Helpers return :not_matched when the expression doesn't match their
+    # type, so the dispatcher falls through to the next handler.
+
     def eval_expr(expr, context)
       expr = expr.strip
       return nil if expr.empty?
 
-      # String literal
+      result = eval_literal(expr)
+      return result unless result == :not_literal
+
+      result = eval_collection_literal(expr, context)
+      return result unless result == :not_collection
+
+      return eval_expr(expr[1..-2], context) if matched_parens?(expr)
+
+      result = eval_ternary(expr, context)
+      return result unless result == :not_ternary
+
+      result = eval_inline_if(expr, context)
+      return result unless result == :not_inline_if
+
+      result = eval_null_coalesce(expr, context)
+      return result unless result == :not_coalesce
+
+      result = eval_concat(expr, context)
+      return result unless result == :not_concat
+
+      return eval_comparison(expr, context) if has_comparison?(expr)
+
+      result = eval_arithmetic(expr, context)
+      return result unless result == :not_arithmetic
+
+      result = eval_function_call(expr, context)
+      return result unless result == :not_function
+
+      resolve(expr, context)
+    end
+
+    # ── Literal values: strings, numbers, booleans, null ──
+
+    def eval_literal(expr)
       if (expr.start_with?('"') && expr.end_with?('"')) ||
          (expr.start_with?("'") && expr.end_with?("'"))
         return expr[1..-2]
       end
-
-      # Numeric
       return expr.to_i if expr =~ INTEGER_RE
       return expr.to_f if expr =~ FLOAT_RE
-
-      # Boolean/null
       return true  if expr == "true"
       return false if expr == "false"
       return nil   if expr == "null" || expr == "none" || expr == "nil"
+      :not_literal
+    end
+
+    # ── Collection literals: arrays, hashes, ranges ──
 
-      # Array literal [a, b, c]
+    def eval_collection_literal(expr, context)
       if expr =~ ARRAY_LIT_RE
         inner = Regexp.last_match(1)
         return split_args_toplevel(inner).map { |item| eval_expr(item.strip, context) }
       end
-
-      # Hash literal { key: value, ... }
       if expr =~ HASH_LIT_RE
         inner = Regexp.last_match(1)
         hash = {}
@@ -879,99 +915,94 @@ module Tina4
         end
         return hash
       end
-
-      # Range literal: 1..5
       if expr =~ RANGE_LIT_RE
         return (Regexp.last_match(1).to_i..Regexp.last_match(2).to_i).to_a
       end
+      :not_collection
+    end
 
-      # Parenthesized sub-expression: (expr) — strip parens and evaluate inner
-      if expr.start_with?("(") && expr.end_with?(")")
-        depth = 0
-        matched = true
-        expr.each_char.with_index do |ch, pi|
-          depth += 1 if ch == "("
-          depth -= 1 if ch == ")"
-          if depth == 0 && pi < expr.length - 1
-            matched = false
-            break
-          end
-        end
-        return eval_expr(expr[1..-2], context) if matched
+    # ── Parenthesized sub-expression check ──
+
+    def matched_parens?(expr)
+      return false unless expr.start_with?("(") && expr.end_with?(")")
+      depth = 0
+      expr.each_char.with_index do |ch, pi|
+        depth += 1 if ch == "("
+        depth -= 1 if ch == ")"
+        return false if depth == 0 && pi < expr.length - 1
       end
+      true
+    end
 
-      # Ternary: condition ? "yes" : "no" — quote-aware
+    # ── Ternary: condition ? "yes" : "no" ──
+
+    def eval_ternary(expr, context)
       q_pos = find_outside_quotes(expr, "?")
-      if q_pos > 0
-        cond_part = expr[0...q_pos].strip
-        rest = expr[(q_pos + 1)..]
-        c_pos = find_outside_quotes(rest, ":")
-        if c_pos >= 0
-          true_part = rest[0...c_pos].strip
-          false_part = rest[(c_pos + 1)..].strip
-          cond = eval_expr(cond_part, context)
-          return truthy?(cond) ? eval_expr(true_part, context) : eval_expr(false_part, context)
-        end
-      end
+      return :not_ternary unless q_pos && q_pos > 0
+      cond_part = expr[0...q_pos].strip
+      rest = expr[(q_pos + 1)..]
+      c_pos = find_outside_quotes(rest, ":")
+      return :not_ternary unless c_pos && c_pos >= 0
+      true_part = rest[0...c_pos].strip
+      false_part = rest[(c_pos + 1)..].strip
+      cond = eval_expr(cond_part, context)
+      truthy?(cond) ? eval_expr(true_part, context) : eval_expr(false_part, context)
+    end
+
+    # ── Inline if: value if condition else other_value ──
 
-      # Jinja2-style inline if: value if condition else other_value — quote-aware
+    def eval_inline_if(expr, context)
       if_pos = find_outside_quotes(expr, " if ")
-      if if_pos >= 0
-        else_pos = find_outside_quotes(expr, " else ")
-        if else_pos && else_pos > if_pos
-          value_part = expr[0...if_pos].strip
-          cond_part = expr[(if_pos + 4)...else_pos].strip
-          else_part = expr[(else_pos + 6)..].strip
-          cond = eval_expr(cond_part, context)
-          return truthy?(cond) ? eval_expr(value_part, context) : eval_expr(else_part, context)
-        end
-      end
+      return :not_inline_if unless if_pos && if_pos >= 0
+      else_pos = find_outside_quotes(expr, " else ")
+      return :not_inline_if unless else_pos && else_pos > if_pos
+      value_part = expr[0...if_pos].strip
+      cond_part = expr[(if_pos + 4)...else_pos].strip
+      else_part = expr[(else_pos + 6)..].strip
+      cond = eval_expr(cond_part, context)
+      truthy?(cond) ? eval_expr(value_part, context) : eval_expr(else_part, context)
+    end
 
-      # Null coalescing: value ?? "default"
-      if expr.include?("??")
-        left, _, right = expr.partition("??")
-        val = eval_expr(left.strip, context)
-        return val.nil? ? eval_expr(right.strip, context) : val
-      end
+    # ── Null coalescing: value ?? "default" ──
 
-      # String concatenation with ~
-      if expr.include?("~")
-        parts = expr.split("~")
-        return parts.map { |p| (eval_expr(p.strip, context) || "").to_s }.join
-      end
+    def eval_null_coalesce(expr, context)
+      return :not_coalesce unless expr.include?("??")
+      left, _, right = expr.partition("??")
+      val = eval_expr(left.strip, context)
+      val.nil? ? eval_expr(right.strip, context) : val
+    end
 
-      # Check for comparison / logical operators -- delegate
-      if has_comparison?(expr)
-        return eval_comparison(expr, context)
-      end
+    # ── String concatenation: a ~ b ──
+
+    def eval_concat(expr, context)
+      return :not_concat unless expr.include?("~")
+      parts = expr.split("~")
+      parts.map { |p| (eval_expr(p.strip, context) || "").to_s }.join
+    end
+
+    # ── Arithmetic: +, -, *, //, /, %, ** ──
 
-      # Arithmetic: +, -, *, //, /, %, ** (lowest to highest precedence)
+    def eval_arithmetic(expr, context)
       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)
+        l_val = eval_expr(expr[0...pos].strip, context)
+        r_val = eval_expr(expr[(pos + op.length)..].strip, context)
         return apply_math(l_val, op.strip, r_val)
       end
+      :not_arithmetic
+    end
 
-      # Function call: name(arg1, arg2)
-      if expr =~ FUNC_CALL_RE
-        fn_name  = Regexp.last_match(1)
-        raw_args = Regexp.last_match(2).strip
-        fn = context[fn_name]
-        if fn.respond_to?(:call)
-          if raw_args.empty?
-            return fn.call
-          else
-            args = split_args_toplevel(raw_args).map { |a| eval_expr(a.strip, context) }
-            return fn.call(*args)
-          end
-        end
-      end
+    # ── Function call: name(arg1, arg2) ──
 
-      resolve(expr, context)
+    def eval_function_call(expr, context)
+      return :not_function unless expr =~ FUNC_CALL_RE
+      fn_name = Regexp.last_match(1)
+      raw_args = Regexp.last_match(2).strip
+      fn = context[fn_name]
+      return :not_function unless fn.respond_to?(:call)
+      args = raw_args.empty? ? [] : split_args_toplevel(raw_args).map { |a| eval_expr(a.strip, context) }
+      fn.call(*args)
     end
 
     def has_comparison?(expr)

data/lib/tina4/metrics.rb

@@ -21,12 +21,31 @@ module Tina4
     @full_cache_time = 0
     CACHE_TTL = 60
 
+    # ── Root Resolution ──────────────────────────────────────────
+
+    # Pick the right directory to scan.
+    #
+    # If the root dir has Ruby files, scan the user's project code.
+    # Otherwise, scan the framework itself — so the bubble chart is never empty.
+    def self._resolve_root(root = 'src')
+      root_path = Pathname.new(root)
+      if root_path.directory? && !Dir.glob(root_path.join('**', '*.rb')).empty?
+        return root
+      end
+      # Fallback: scan the framework package itself
+      File.dirname(__FILE__)
+    end
+
     # ── Quick Metrics ───────────────────────────────────────────
 
     def self.quick_metrics(root = 'src')
+      # Check if the requested directory exists before falling back
       root_path = Pathname.new(root)
       return { "error" => "Directory not found: #{root}" } unless root_path.directory?
 
+      root = _resolve_root(root)
+      root_path = Pathname.new(root)
+
       rb_files = Dir.glob(root_path.join('**', '*.rb'))
       twig_files = Dir.glob(root_path.join('**', '*.twig')) + Dir.glob(root_path.join('**', '*.erb'))
 
@@ -184,9 +203,13 @@ module Tina4
     # ── Full Analysis (Ripper-based) ────────────────────────────
 
     def self.full_analysis(root = 'src')
+      # Check if the requested directory exists before falling back
       root_path = Pathname.new(root)
       return { "error" => "Directory not found: #{root}" } unless root_path.directory?
 
+      root = _resolve_root(root)
+      root_path = Pathname.new(root)
+
       current_hash = _files_hash(root)
       now = Time.now.to_f
 
@@ -271,7 +294,9 @@ module Tina4
           "halstead_volume" => volume.round(1),
           "coupling_afferent" => ca,
           "coupling_efferent" => ce,
-          "instability" => instability.round(3)
+          "instability" => instability.round(3),
+          "has_tests" => _has_matching_test(rel_path),
+          "dep_count" => imports.length
         }
       end
 
@@ -293,6 +318,11 @@ module Tina4
       total_mi = file_metrics.sum { |f| f["maintainability"] }
       avg_mi = file_metrics.empty? ? 0 : total_mi.to_f / file_metrics.length
 
+      # Detect if we're scanning framework or project
+      framework_dir = File.expand_path(File.dirname(__FILE__))
+      resolved_root = File.expand_path(root_path.to_s)
+      scanning_framework = resolved_root == framework_dir || resolved_root.start_with?(framework_dir + '/')
+
       result = {
         "files_analyzed" => file_metrics.length,
         "total_functions" => all_functions.length,
@@ -301,7 +331,9 @@ module Tina4
         "most_complex_functions" => all_functions.first(15),
         "file_metrics" => file_metrics,
         "violations" => violations,
-        "dependency_graph" => import_graph
+        "dependency_graph" => import_graph,
+        "scan_mode" => scanning_framework ? "framework" : "project",
+        "scan_root" => resolved_root
       }
 
       @full_cache_hash = current_hash
@@ -372,6 +404,15 @@ module Tina4
 
     private_class_method
 
+    def self._has_matching_test(rel_path)
+      name = File.basename(rel_path, '.rb')
+      ['spec', 'test'].any? do |dir|
+        File.exist?("#{dir}/#{name}_spec.rb") ||
+        File.exist?("#{dir}/#{name}_test.rb") ||
+        File.exist?("#{dir}/test_#{name}.rb")
+      end
+    end
+
     def self._files_hash(root)
       md5 = Digest::MD5.new
       root_path = Pathname.new(root)

data/lib/tina4/orm.rb

@@ -474,15 +474,25 @@ module Tina4
       errors
     end
 
-    def load(id = nil)
-      pk = self.class.primary_key_field || :id
-      id ||= __send__(pk)
-      return false unless id
+    def load(filter_sql = nil, params = [])
       @relationship_cache = {} # Clear relationship cache on reload
 
-      result = self.class.db.fetch_one(
-        "SELECT * FROM #{self.class.table_name} WHERE #{pk} = ?", [id]
-      )
+      pk = self.class.primary_key_field || :id
+
+      # Determine the SQL to execute
+      if filter_sql.nil? || filter_sql.is_a?(Integer)
+        # Legacy: load by primary key (load() or load(id))
+        id = filter_sql || __send__(pk)
+        return false unless id
+        sql = "SELECT * FROM #{self.class.table_name} WHERE #{pk} = ?"
+        query_params = [id]
+      else
+        # Filter-based: load("email = ?", ["alice@example.com"])
+        sql = "SELECT * FROM #{self.class.table_name} WHERE #{filter_sql}"
+        query_params = params
+      end
+
+      result = self.class.db.fetch_one(sql, query_params)
       return false unless result
 
       mapping_reverse = self.class.field_mapping.invert

data/lib/tina4/public/js/tina4-dev-admin.min.js

@@ -119,49 +119,187 @@ ${m.data ? '<code class="text-sm text-muted">' + JSON.stringify(m.data) + '</cod
 </div>`).join('');
 }
 function clearMessages() { api('/__dev/api/messages/clear', 'POST', {}).then(() => loadMessages()); }
+var _currentTable='';
 function loadTables() {
-api('/__dev/api/tables').then(d => {
-const tables = d.tables || [];
+api('/__dev/api/tables').then(function(d) {
+var tables = d.tables || [];
 document.getElementById('db-count').textContent = tables.length;
-document.getElementById('table-list').innerHTML = tables.map(t =>
-`<div style="padding:0.2rem 0.4rem;cursor:pointer;border-radius:0.25rem" onclick="browseTable('${t}')" onmouseover="this.style.background='rgba(198,40,40,0.1)'" onmouseout="this.style.background=''">${t}</div>`
-).join('');
-const sel = document.getElementById('seed-table');
-sel.innerHTML = '<option value="">Pick table...</option>' + tables.map(t => `<option value="${t}">${t}</option>`).join('');
+var list = document.getElementById('table-list');
+var seed = document.getElementById('seed-table');
+if (!tables.length) { list.innerHTML = '<div class="text-muted">No tables</div>'; return; }
+list.innerHTML = '';
+tables.forEach(function(t) {
+var div = document.createElement('div');
+div.style.cssText = 'cursor:pointer;padding:4px 6px;color:var(--primary);border-radius:4px;margin-bottom:1px';
+div.textContent = t;
+div.addEventListener('mouseenter', function() { if (t !== _currentTable) div.style.background = 'var(--bg-alt,rgba(255,255,255,0.05))'; });
+div.addEventListener('mouseleave', function() { if (t !== _currentTable) div.style.background = ''; });
+div.addEventListener('click', function() {
+list.querySelectorAll('div').forEach(function(d) { d.style.background = ''; d.style.fontWeight = ''; });
+div.style.background = 'var(--primary-bg,rgba(53,114,165,0.2))'; div.style.fontWeight = '600';
+browseTable(t);
+});
+list.appendChild(div);
+});
+seed.innerHTML = '<option value="">Pick table...</option>' + tables.map(function(t) { return '<option value="' + t + '">' + t + '</option>'; }).join('');
 });
 }
-function browseTable(name) { document.getElementById('query-input').value = 'SELECT * FROM ' + name + ' LIMIT 20'; runQuery(); }
+function browseTable(name) {
+_currentTable = name;
+var lim = document.getElementById('query-limit').value;
+document.getElementById('query-input').value = 'SELECT * FROM ' + name + (lim !== '0' ? ' LIMIT ' + lim : '');
+runQuery();
+}
 function seedTable() {
-const table = document.getElementById('seed-table').value;
-const count = parseInt(document.getElementById('seed-count').value) || 10;
+var table = document.getElementById('seed-table').value;
+var count = parseInt(document.getElementById('seed-count').value) || 10;
 if (!table) return;
-api('/__dev/api/seed', 'POST', {table, count}).then(d => {
+api('/__dev/api/seed', 'POST', {table: table, count: count}).then(function(d) {
 if (d.error) { alert(d.error); return; }
 browseTable(table);
 });
 }
+function _clipCopy(text, btn) {
+var orig = btn.textContent;
+var ta = document.createElement('textarea');
+ta.value = text;
+ta.style.cssText = 'position:fixed;left:-9999px;top:-9999px';
+document.body.appendChild(ta);
+ta.focus();
+ta.select();
+try { document.execCommand('copy'); btn.textContent = 'Copied!'; btn.style.color = 'var(--success)'; }
+catch(e) { btn.textContent = 'Failed'; btn.style.color = 'var(--danger)'; }
+document.body.removeChild(ta);
+setTimeout(function() { btn.textContent = orig; btn.style.color = ''; }, 1500);
+}
+function copyResults(fmt, btn) {
+var el = document.getElementById('query-results');
+var tbl = el ? el.querySelector('table') : null;
+if (!tbl) { btn.textContent = 'No data'; btn.style.color = 'var(--danger)'; setTimeout(function() { btn.textContent = fmt === 'json' ? 'Copy JSON' : 'Copy CSV'; btn.style.color = ''; }, 1500); return; }
+var headerCells = tbl.querySelectorAll('thead th');
+var headers = []; headerCells.forEach(function(h) { headers.push(h.textContent); });
+var bodyRows = tbl.querySelectorAll('tbody tr');
+var data = [];
+bodyRows.forEach(function(row) {
+var cells = row.querySelectorAll('td');
+var obj = {};
+cells.forEach(function(c, i) { obj[headers[i] || ('col' + i)] = c.textContent === 'null' ? null : c.textContent; });
+data.push(obj);
+});
+var text = '';
+if (fmt === 'json') {
+text = JSON.stringify(data, null, 2);
+} else {
+var lines = [headers.join(',')];
+data.forEach(function(r) {
+lines.push(headers.map(function(h) { var v = (r[h] !== null ? r[h] : ''); return v.indexOf(',') >= 0 || v.indexOf('"') >= 0 ? '"' + v.replace(/"/g, '""') + '"' : v; }).join(','));
+});
+text = lines.join(String.fromCharCode(10));
+}
+_clipCopy(text, btn);
+}
+function pasteData() {
+var NL = String.fromCharCode(10);
+var TAB = String.fromCharCode(9);
+var overlay = document.createElement('div');
+overlay.style.cssText = 'position:fixed;top:0;left:0;right:0;bottom:0;background:rgba(0,0,0,0.6);z-index:99999;display:flex;align-items:center;justify-content:center';
+var box = document.createElement('div');
+box.style.cssText = 'background:var(--bg,#1e293b);border:1px solid var(--border,#334155);border-radius:0.5rem;padding:1rem;width:500px;max-width:90vw';
+box.innerHTML = '<div style="font-weight:600;margin-bottom:0.5rem;color:var(--text,#e2e8f0)">Paste Data</div><div style="font-size:0.75rem;color:var(--muted,#94a3b8);margin-bottom:0.5rem">Paste JSON array or CSV/tab-separated data below</div>';
+var ta = document.createElement('textarea');
+ta.style.cssText = 'width:100%;height:150px;font-family:monospace;font-size:0.75rem;background:var(--bg-alt,#0f172a);color:var(--text,#e2e8f0);border:1px solid var(--border,#334155);border-radius:0.25rem;padding:0.5rem;resize:vertical';
+ta.placeholder = 'Paste here (Ctrl+V)...';
+var btns = document.createElement('div');
+btns.style.cssText = 'display:flex;gap:0.5rem;margin-top:0.5rem;justify-content:flex-end';
+var cancelBtn = document.createElement('button');
+cancelBtn.className = 'btn btn-sm'; cancelBtn.textContent = 'Cancel';
+cancelBtn.onclick = function() { document.body.removeChild(overlay); };
+var goBtn = document.createElement('button');
+goBtn.className = 'btn btn-sm btn-primary'; goBtn.textContent = 'Generate SQL';
+goBtn.onclick = function() {
+var text = ta.value.trim();
+if (!text) { alert('Paste some data first'); return; }
+var upper = text.substring(0, 50).toUpperCase();
+if (upper.indexOf('INSERT ') >= 0 || upper.indexOf('CREATE ') >= 0 || upper.indexOf('SELECT ') >= 0) {
+document.getElementById('query-input').value = text;
+document.body.removeChild(overlay);
+return;
+}
+var rows = [];
+var parsed = null;
+try { parsed = JSON.parse(text); } catch(e) {}
+if (parsed && Array.isArray(parsed) && parsed.length > 0) {
+rows = parsed;
+} else {
+var lines = text.split(NL);
+if (lines.length < 2) { alert('Need a header row + at least one data row'); return; }
+var sep = lines[0].indexOf(TAB) >= 0 ? TAB : ',';
+var headers = lines[0].split(sep);
+for (var i = 1; i < lines.length; i++) {
+var vals = lines[i].split(sep);
+if (!vals.length || vals.join('').trim() === '') continue;
+var row = {};
+headers.forEach(function(h, idx) { row[h.trim()] = vals[idx] !== undefined ? vals[idx].trim() : ''; });
+rows.push(row);
+}
+}
+if (!rows.length) { alert('No data rows found'); return; }
+var allCols = Object.keys(rows[0]);
+var table = typeof _currentTable !== 'undefined' && _currentTable ? _currentTable : '';
+var isNew = false;
+if (!table) {
+table = prompt('No table selected. Enter table name (creates if new):');
+if (!table) { return; }
+isNew = true;
+}
+var sql = '';
+if (isNew) {
+var hasId = allCols.some(function(c) { return c.toLowerCase() === 'id'; });
+var colDefs = allCols.map(function(h) {
+if (h.toLowerCase() === 'id') return h + ' INTEGER PRIMARY KEY AUTOINCREMENT';
+return h + ' TEXT';
+}).join(', ');
+if (!hasId) colDefs = 'id INTEGER PRIMARY KEY AUTOINCREMENT, ' + colDefs;
+sql = 'CREATE TABLE IF NOT EXISTS ' + table + ' (' + colDefs + ');' + NL;
+}
+sql += rows.map(function(r) {
+var keys = Object.keys(r);
+if (isNew) { keys = keys.filter(function(k) { return k.toLowerCase() !== 'id'; }); }
+var cols = keys.join(', ');
+var vals = keys.map(function(k) { var v = r[k]; return v === null ? 'NULL' : "'" + String(v).replace(/'/g, "''") + "'"; }).join(', ');
+return 'INSERT INTO ' + table + ' (' + cols + ') VALUES (' + vals + ')';
+}).join(';' + NL);
+document.getElementById('query-input').value = sql;
+document.body.removeChild(overlay);
+};
+btns.appendChild(cancelBtn); btns.appendChild(goBtn);
+box.appendChild(ta); box.appendChild(btns);
+overlay.appendChild(box); document.body.appendChild(overlay);
+ta.focus();
+}
 function runQuery() {
-const query = document.getElementById('query-input').value.trim();
-const type = document.getElementById('query-type').value;
-const errorEl = document.getElementById('query-error');
+var query = document.getElementById('query-input').value.trim();
+var type = document.getElementById('query-type').value;
+var errorEl = document.getElementById('query-error');
+var resultEl = document.getElementById('query-results');
+if (!query) { errorEl.textContent = 'Enter a query'; errorEl.classList.remove('hidden'); return; }
 errorEl.classList.add('hidden');
-if (!query) return;
-api('/__dev/api/query', 'POST', {query, type}).then(d => {
-if (d.error) { errorEl.textContent = d.error; errorEl.classList.remove('hidden'); return; }
-const results = document.getElementById('query-results');
-if (d.rows && d.rows.length) {
-const cols = d.columns || Object.keys(d.rows[0]);
-results.innerHTML = `<div class="text-sm text-muted p-sm">${d.count||d.rows.length} rows</div>
-<table><thead><tr>${cols.map(c => '<th>'+c+'</th>').join('')}</tr></thead>
-<tbody>${d.rows.map(r => '<tr>' + cols.map(c => '<td class="text-mono text-sm">' + (r[c]===null?'<span class="text-muted">NULL</span>':esc(String(r[c]))) + '</td>').join('') + '</tr>').join('')}</tbody></table>`;
-} else if (d.data) {
-results.innerHTML = '<pre class="p-md text-mono text-sm">' + JSON.stringify(d.data, null, 2) + '</pre>';
+resultEl.innerHTML = '<p class="text-muted">Running...</p>';
+api('/__dev/api/query', 'POST', {query: query, type: type}).then(function(d) {
+if (d.error) { errorEl.textContent = d.error; errorEl.classList.remove('hidden'); resultEl.innerHTML = ''; return; }
+if (d.rows) {
+if (!d.rows.length) { resultEl.innerHTML = '<p class="text-muted">No results</p>'; return; }
+var cols = d.columns || Object.keys(d.rows[0]);
+var html = '<div class="text-muted" style="margin-bottom:0.25rem">' + d.rows.length + ' row(s)</div><table class="table"><thead><tr>' + cols.map(function(c) { return '<th>' + c + '</th>'; }).join('') + '</tr></thead><tbody>';
+d.rows.forEach(function(row) { html += '<tr>' + cols.map(function(c) { return '<td>' + (row[c] !== null ? row[c] : '<em>null</em>') + '</td>'; }).join('') + '</tr>'; });
+html += '</tbody></table>'; resultEl.innerHTML = html;
 } else if (d.success) {
-results.innerHTML = '<div class="empty">Query executed. ' + (d.affected||0) + ' rows affected.</div>';
+resultEl.innerHTML = '<p style="color:var(--success)">' + d.affected + ' row(s) affected</p>';
+loadTables();
 } else {
-results.innerHTML = '<div class="empty">No results</div>';
+resultEl.innerHTML = '<pre>' + JSON.stringify(d, null, 2) + '</pre>';
 }
-}).catch(e => { errorEl.textContent = e.message; errorEl.classList.remove('hidden'); });
+}).catch(function(e) { errorEl.textContent = e.message; errorEl.classList.remove('hidden'); });
 }
 function loadRequests() {
 api('/__dev/api/requests').then(d => {
@@ -364,4 +502,5 @@ if (d.health) document.getElementById('err-count').textContent = d.health.unreso
 if (d.requests) document.getElementById('req-count').textContent = d.requests.total || 0;
 if (d.message_counts) document.getElementById('messages-count').textContent = d.message_counts.total || 0;
 if (d.request_stats) document.getElementById('req-count').textContent = d.request_stats.total || 0;
+if (d.db_tables !== undefined) document.getElementById('db-count').textContent = d.db_tables;
 });

data/lib/tina4/query_builder.rb

@@ -365,10 +365,16 @@ module Tina4
 
     # Ensure a database connection is available.
     def ensure_db!
-      return unless @db.nil?
+      if @db.nil?
+        @db = Tina4.database if defined?(Tina4.database) && Tina4.database
+      end
 
-      @db = Tina4.database if defined?(Tina4.database) && Tina4.database
       raise "QueryBuilder: No database connection provided." if @db.nil?
+
+      # Check if the database connection is still open
+      if @db.respond_to?(:connected) && !@db.connected
+        raise "QueryBuilder: No database connection provided."
+      end
     end
   end
 end

data/lib/tina4/rack_app.rb

@@ -434,6 +434,8 @@ module Tina4
         .view-modal-content{background:#1e293b;border:1px solid #334155;border-radius:0.75rem;padding:2rem;max-width:700px;width:90%;max-height:80vh;overflow-y:auto;position:relative}
         .view-modal-close{position:absolute;top:0.75rem;right:1rem;color:#94a3b8;cursor:pointer;font-size:1.25rem;background:none;border:none}
         .view-modal-close:hover{color:#e2e8f0}
+        @keyframes wiggle{0%{transform:rotate(0deg)}15%{transform:rotate(14deg)}30%{transform:rotate(-10deg)}45%{transform:rotate(8deg)}60%{transform:rotate(-4deg)}75%{transform:rotate(2deg)}100%{transform:rotate(0deg)}}
+        .star-wiggle{display:inline-block;transform-origin:center}
         </style>
         </head>
         <body>
@@ -447,7 +449,7 @@ module Tina4
                 <a href="/__dev" class="btn">Dev Admin</a>
                 <a href="#gallery" class="btn">Gallery</a>
                 <a href="https://github.com/tina4stack/tina4-ruby" class="btn" target="_blank">GitHub</a>
-                <a href="https://github.com/tina4stack/tina4-ruby/stargazers" class="btn" target="_blank">&#11088; Star</a>
+                <a href="https://github.com/tina4stack/tina4-ruby/stargazers" class="btn" target="_blank"><span class="star-wiggle">&#9734;</span> Star</a>
             </div>
             <div class="status">
                 <span><span class="dot"></span>Server running</span>
@@ -543,6 +545,20 @@ module Tina4
         document.getElementById('viewModal').addEventListener('click', function(e) {
             if (e.target === this) this.classList.remove('active');
         });
+        (function(){
+            var star=document.querySelector('.star-wiggle');
+            if(!star)return;
+            function doWiggle(){
+                star.style.animation='wiggle 1.2s ease-in-out';
+                star.addEventListener('animationend',function onEnd(){
+                    star.removeEventListener('animationend',onEnd);
+                    star.style.animation='none';
+                    var delay=3000+Math.random()*15000;
+                    setTimeout(doWiggle,delay);
+                });
+            }
+            setTimeout(doWiggle,3000);
+        })();
         </script>
         </body>
         </html>