tina4ruby 3.13.85 → 3.13.87

data/lib/tina4/frond.rb

@@ -106,7 +106,11 @@ module Tina4
       " and ", " or ", " not ",
       " + ", " - ", " * ", " // ", " / ", " % ", " ** "
     ].freeze
-    FUNC_CALL_RE    = /\A(\w+)\s*\((.*)\)\z/m
+    # A dot is allowed in the callee so {% import "f" as m %} can register its macros
+    # under the literal key "m.greet" and {{ m.greet("Andre") }} resolves as a call.
+    # Without the dot the whole expression was not recognised as a function call at
+    # all, so an aliased macro rendered as SILENTLY EMPTY.
+    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/
     OR_SPLIT_RE     = /\s+or\s+/
@@ -136,6 +140,7 @@ module Tina4
            .gsub("<", "&lt;").gsub(">", "&gt;")
     end
     FROM_IMPORT_RE  = /\Afrom\s+["'](.+?)["']\s+import\s+(.+)/
+    IMPORT_AS_RE    = /\Aimport\s+["'](.+?)["']\s+as\s+(\w+)/
     CACHE_RE        = /\Acache\s+["'](.+?)["']\s*(\d+)?/
     SPACELESS_RE    = />\s+</
     AUTOESCAPE_RE   = /\Aautoescape\s+(false|true)/
@@ -147,6 +152,17 @@ module Tina4
     # Set of common no-arg filter names that can be inlined for speed
     INLINE_FILTERS = %w[upper lower length trim capitalize title string int escape e].each_with_object({}) { |f, h| h[f] = true }.freeze
 
+    # Hard cap on the template caches — @compiled and @compiled_strings
+    # (ADR-0004, parity with PHP/Python/Node TEMPLATE_CACHE_MAX).
+    #
+    # An entry here is a whole token list, so the cap sits well below what a
+    # per-expression memo would justify. 256 is far above any real
+    # application's template count, so a normal app never evicts. The cap
+    # exists for the workload that genuinely grows without limit for the life
+    # of a worker: +render_string+ keys on md5(source), so an app that builds
+    # template strings dynamically adds an entry per distinct string.
+    TEMPLATE_CACHE_MAX = 256
+
     # -- Lazy context overlay for for-loops (avoids full Hash#dup) --
     class LoopContext
       def initialize(parent)
@@ -302,6 +318,7 @@ module Tina4
       source = File.read(path, encoding: "utf-8")
       mtime = File.mtime(path)
       tokens = tokenize(source)
+      cap_cache(@compiled, TEMPLATE_CACHE_MAX)
       @compiled[template] = [tokens, mtime, Time.now.to_i]
       execute_with_tokens(source, tokens, context)
     end
@@ -318,6 +335,7 @@ module Tina4
       end
 
       tokens = tokenize(source)
+      cap_cache(@compiled_strings, TEMPLATE_CACHE_MAX)
       @compiled_strings[key] = tokens
       execute_cached(tokens, context)
     end
@@ -413,6 +431,27 @@ module Tina4
 
     private
 
+    # Keep a memo cache bounded (ADR-0004). Call immediately before inserting
+    # a new entry.
+    #
+    # Eviction is insertion-ordered (oldest first), not true LRU: a Ruby Hash
+    # preserves insertion order, so dropping from the front is cheap, whereas
+    # refreshing recency on every cache HIT would add writes to the hottest
+    # path in a render and cost more than it saves. Half the cache is dropped
+    # at once so the sweep amortises to O(1) per insert.
+    #
+    # Evicting can never change what a render produces: every read site treats
+    # a miss as "recompute", so a swept entry is rebuilt on next use.
+    #
+    # @param cache [Hash] memo cache to bound, mutated in place
+    # @param max_entries [Integer] cap for this cache
+    # @return [void]
+    def cap_cache(cache, max_entries)
+      return if cache.size < max_entries
+
+      cache.keys.first(max_entries / 2).each { |key| cache.delete(key) }
+    end
+
     # -----------------------------------------------------------------------
     # Tokenizer
     # -----------------------------------------------------------------------
@@ -625,6 +664,9 @@ module Tina4
             end
           when "macro"
             i = handle_macro(tokens, i, context)
+          when "import"
+            handle_import_as(content, context)
+            i += 1
           when "from"
             handle_from_import(content, context)
             i += 1
@@ -837,12 +879,22 @@ module Tina4
     # Find the first occurrence of +needle+ that is not inside quotes or
     # parentheses.  Returns the index, or -1 if not found.
     def find_outside_quotes(expr, needle)
+      # Fast path. This is the hottest method in a render -- profiling the Python
+      # twin showed 415,200 calls and 53% of render time for a single 20-row loop
+      # template, and the overwhelming majority return -1 because the needle
+      # simply is not in the expression. include? is a C-level scan, so bailing
+      # here skips the whole Ruby character loop. Exact, not a heuristic: a
+      # needle absent from the string cannot be present outside quotes either.
+      return -1 unless expr.include?(needle)
+
       in_q = nil
       depth = 0
       bracket_depth = 0
       i = 0
       nlen = needle.length
-      while i <= expr.length - nlen
+      # Hoisted: expr.length was recomputed on every iteration of the condition.
+      last_start = expr.length - nlen
+      while i <= last_start
         ch = expr[i]
         if (ch == '"' || ch == "'") && depth == 0
           if in_q.nil?
@@ -1072,44 +1124,111 @@ module Tina4
     # Helpers return :not_matched when the expression doesn't match their
     # type, so the dispatcher falls through to the next handler.
 
+    # Bound for the expression-form cache. Python bounds its expression caches
+    # (lru_cache 1024) and PHP's were unbounded instance arrays until ADR-0004;
+    # a template with generated expression strings must not grow this forever.
+    # FIFO drop-oldest-half, deliberately not LRU (no per-hit bookkeeping on the
+    # hot path).
+    EXPR_FORM_CACHE_MAX = 2048
+
+    # ── Expression evaluation: a cascade, with the branch memoised ──
+    #
+    # eval_expr tries 12 structural forms in Twig precedence order. The catch is
+    # that the LAST one, `resolve`, is by far the most common (a plain `i.name`),
+    # so every ordinary variable used to walk all 11 detectors ahead of it on
+    # EVERY render. Measured: ~6-7 microseconds and ~38 Frond method calls per
+    # expression evaluation, linear in expression count.
+    #
+    # So: on first sight run the real cascade and RECORD which branch fired; on
+    # later renders jump straight to that branch. The cache key is the expression
+    # string, and a form is a pure property of that string.
+    #
+    # Correctness is owned by the existing evaluators, not by a second copy of the
+    # detection logic (which is what would drift). The fast path calls exactly one
+    # evaluator; if it declines -- returns its own :not_* sentinel -- we fall
+    # through to the full cascade and re-record. A wrong cache entry therefore
+    # costs one wasted call, never a wrong render.
     def eval_expr(expr, context)
       expr = expr.strip
       return nil if expr.empty?
 
+      form = (@expr_form ||= {})[expr]
+      if form
+        result = eval_expr_as(form, expr, context)
+        return result unless result == :form_declined
+      end
+
       result = eval_literal(expr)
-      return result unless result == :not_literal
+      return remember_form(expr, :literal, result) unless result == :not_literal
 
       result = eval_collection_literal(expr, context)
-      return result unless result == :not_collection
+      return remember_form(expr, :collection, result) unless result == :not_collection
 
-      return eval_expr(expr[1..-2], context) if matched_parens?(expr)
+      if matched_parens?(expr)
+        remember_form(expr, :parens, nil)
+        return eval_expr(expr[1..-2], context)
+      end
 
       result = eval_ternary(expr, context)
-      return result unless result == :not_ternary
+      return remember_form(expr, :ternary, result) unless result == :not_ternary
 
       result = eval_inline_if(expr, context)
-      return result unless result == :not_inline_if
+      return remember_form(expr, :inline_if, result) unless result == :not_inline_if
 
       result = eval_null_coalesce(expr, context)
-      return result unless result == :not_coalesce
+      return remember_form(expr, :coalesce, result) unless result == :not_coalesce
 
       result = eval_concat(expr, context)
-      return result unless result == :not_concat
+      return remember_form(expr, :concat, result) unless result == :not_concat
 
-      return eval_comparison(expr, context) if has_comparison?(expr)
+      if has_comparison?(expr)
+        remember_form(expr, :comparison, nil)
+        return eval_comparison(expr, context)
+      end
 
       result = eval_arithmetic(expr, context)
-      return result unless result == :not_arithmetic
+      return remember_form(expr, :arithmetic, result) unless result == :not_arithmetic
 
       result = eval_filter_pipe(expr, context)
-      return result unless result == :not_filter_pipe
+      return remember_form(expr, :pipe, result) unless result == :not_filter_pipe
 
       result = eval_function_call(expr, context)
-      return result unless result == :not_function
+      return remember_form(expr, :function, result) unless result == :not_function
 
+      remember_form(expr, :resolve, nil)
       resolve(expr, context)
     end
 
+    # Record the branch an expression took, then hand back its value unchanged.
+    def remember_form(expr, form, result)
+      cache = (@expr_form ||= {})
+      if cache.length >= EXPR_FORM_CACHE_MAX
+        cache.keys.first(EXPR_FORM_CACHE_MAX / 2).each { |k| cache.delete(k) }
+      end
+      cache[expr] = form
+      result
+    end
+
+    # Evaluate via the one remembered branch. Returns :form_declined when that
+    # branch no longer applies, so the caller re-runs the full cascade.
+    def eval_expr_as(form, expr, context)
+      case form
+      when :resolve     then resolve(expr, context)
+      when :pipe        then (r = eval_filter_pipe(expr, context)) == :not_filter_pipe ? :form_declined : r
+      when :literal     then (r = eval_literal(expr)) == :not_literal ? :form_declined : r
+      when :function    then (r = eval_function_call(expr, context)) == :not_function ? :form_declined : r
+      when :concat      then (r = eval_concat(expr, context)) == :not_concat ? :form_declined : r
+      when :comparison  then has_comparison?(expr) ? eval_comparison(expr, context) : :form_declined
+      when :arithmetic  then (r = eval_arithmetic(expr, context)) == :not_arithmetic ? :form_declined : r
+      when :ternary     then (r = eval_ternary(expr, context)) == :not_ternary ? :form_declined : r
+      when :inline_if   then (r = eval_inline_if(expr, context)) == :not_inline_if ? :form_declined : r
+      when :coalesce    then (r = eval_null_coalesce(expr, context)) == :not_coalesce ? :form_declined : r
+      when :collection  then (r = eval_collection_literal(expr, context)) == :not_collection ? :form_declined : r
+      when :parens      then matched_parens?(expr) ? eval_expr(expr[1..-2], context) : :form_declined
+      else :form_declined
+      end
+    end
+
     # ── Filter pipe: value|filter(args) ──
     # Reached only after every looser-binding operator (concat ~, comparison,
     # arithmetic, ternary, ...) has been ruled out at this level, so the pipe
@@ -1129,6 +1248,10 @@ module Tina4
     # looser than the filter pipe. Quote/paren-aware via find_outside_quotes so
     # operator-like text inside a string literal or filter args never matches.
     def has_looser_than_pipe_operator?(expr)
+      # Leading unary `not` -- see has_comparison? for why a space-delimited
+      # match cannot see it. `not x|upper` must be `not (x|upper)`.
+      return true if expr.start_with?("not ")
+
       LOOSER_THAN_PIPE_OPS.any? { |op| find_outside_quotes(expr, op) >= 0 }
     end
 
@@ -1244,7 +1367,12 @@ module Tina4
     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
+      # `|| ""` would swallow a legitimate `false`: in Ruby only nil and false are
+      # falsy, so `false || ""` is "" and a boolean rendered as EMPTY. Guard on nil
+      # only -- false must render as "false", matching the other three frameworks
+      # (and line 635, which already got this right, which is why a comparison
+      # rendered "false" while a bare false variable rendered "").
+      parts.map { |p| v = eval_expr(p.strip, context); v.nil? ? "" : v.to_s }.join
     end
 
     # ── Arithmetic: +, -, *, //, /, %, ** ──
@@ -1272,7 +1400,21 @@ module Tina4
       fn.call(*args)
     end
 
+    # True when the expression carries a comparison/logical operator, so it is
+    # routed to eval_comparison -- the SAME evaluator {% if %} uses. A condition
+    # therefore means the same thing in a condition and in an output expression.
+    #
+    # The LEADING unary `not` needs its own check: every operator in the list is
+    # matched WITH surrounding spaces, so `not x` (nothing to its left) matched
+    # none of them and fell through to the variable-resolution tail, which
+    # looked up a variable literally named "not x", found nothing, and rendered
+    # EMPTY. `{% if not x %}` and `x and not y` always worked; only the
+    # standalone `{{ not x }}` was dropped, and before booleans rendered
+    # lowercase a dropped expression and `false -> ''` looked identical.
+    # Fixed in 3.13.87 alongside the boolean contract.
     def has_comparison?(expr)
+      return true if expr.start_with?("not ")
+
       [" not in ", " in ", " is not ", " is ", "!=", "==", ">=", "<=", ">", "<",
        " and ", " or ", " not "].any? { |op| expr.include?(op) }
     end
@@ -1438,7 +1580,19 @@ module Tina4
       parts.each do |part|
         part = part.strip.gsub(RESOLVE_STRIP_RE, "") # strip quotes from bracket access
         if value.is_a?(Hash) || value.is_a?(LoopContext)
-          value = value[part] || value[part.to_sym]
+          # `a[k] || a[k.to_sym]` LOSES a stored `false`: only nil and false are
+          # falsy in Ruby, so a legitimate false fell through to the symbol lookup,
+          # missed, and became nil -- rendering as EMPTY. That is why
+          # `{{ flag }}` printed nothing while `{{ n < 3 }}` printed "false".
+          # Probe the string key by presence, not truthiness.
+          value = if value.is_a?(Hash) && value.key?(part)
+                    value[part]
+                  elsif value.is_a?(Hash) && value.key?(part.to_sym)
+                    value[part.to_sym]
+                  else
+                    sv = value[part]
+                    sv.nil? ? value[part.to_sym] : sv
+                  end
         elsif value.is_a?(Array)
           # Slice syntax: value[1:5], value[:10], value[start:end]
           if part.include?(":") && !(part.start_with?('"') || part.start_with?("'"))
@@ -1740,7 +1894,7 @@ module Tina4
       end
 
       macro_name = m[1]
-      param_names = m[2].split(",").map(&:strip).reject(&:empty?)
+      params = parse_macro_params(m[2])
 
       body_tokens = []
       i = start + 1
@@ -1759,8 +1913,8 @@ module Tina4
 
       context[macro_name] = lambda { |*args|
         macro_ctx = captured_context.dup
-        param_names.each_with_index do |pname, pi|
-          macro_ctx[pname] = pi < args.length ? args[pi] : nil
+        params.each_with_index do |(pname, pdefault), pi|
+          macro_ctx[pname] = pi < args.length ? args[pi] : pdefault
         end
         Tina4::SafeString.new(engine.send(:render_tokens, captured_body.dup, macro_ctx))
       }
@@ -1768,6 +1922,54 @@ module Tina4
       i
     end
 
+    # {% import "file" as alias %} — load EVERY macro in a file under one namespace.
+    #
+    # Macros are registered in the context under the dotted key "alias.name", so
+    # {{ alias.greet("Andre") }} resolves through the ordinary function-call path
+    # (FUNC_CALL_RE now admits a dot) and reuses _make_macro_fn — identical argument
+    # binding, default handling and SafeString output as every other macro. Both
+    # import forms therefore render identically, the contract Python locks too.
+    def handle_import_as(content, context)
+      m = content.match(IMPORT_AS_RE)
+      return unless m
+
+      filename = m[1]
+      alias_name = m[2]
+      source = load_template(filename)
+      tokens = tokenize(source)
+
+      i = 0
+      while i < tokens.length
+        ttype, raw = tokens[i]
+        if ttype == BLOCK
+          tag_content, = strip_tag(raw)
+          if tag_content.split(/\s+/).first == "macro"
+            macro_m = tag_content.match(MACRO_RE)
+            if macro_m
+              macro_name = macro_m[1]
+              params = parse_macro_params(macro_m[2])
+
+              body_tokens = []
+              i += 1
+              while i < tokens.length
+                if tokens[i][0] == BLOCK && tokens[i][1].include?("endmacro")
+                  i += 1
+                  break
+                end
+                body_tokens << tokens[i]
+                i += 1
+              end
+
+              context["#{alias_name}.#{macro_name}"] =
+                _make_macro_fn(body_tokens.dup, params.dup, context.dup)
+              next
+            end
+          end
+        end
+        i += 1
+      end
+    end
+
     # {% from "file" import macro1, macro2 %}
     def handle_from_import(content, context)
       m = content.match(FROM_IMPORT_RE)
@@ -1789,7 +1991,7 @@ module Tina4
             macro_m = tag_content.match(MACRO_RE)
             if macro_m && names.include?(macro_m[1])
               macro_name = macro_m[1]
-              param_names = macro_m[2].split(",").map(&:strip).reject(&:empty?)
+              param_names = parse_macro_params(macro_m[2])
 
               body_tokens = []
               i += 1
@@ -1811,13 +2013,34 @@ module Tina4
       end
     end
 
+    # Parse a macro parameter list into [name, default] pairs.
+    #
+    # Handles: name, name="default", name='default'. Splitting on "," alone left
+    # a defaulted parameter NAMED "greeting='Hello'", so the body's {{ greeting }}
+    # matched nothing (rendered empty) AND the caller's positional argument was
+    # stored under that junk key and lost. Mirrors the Python master's
+    # _parse_macro_params. `default` is nil when none is declared.
+    def parse_macro_params(raw_params)
+      raw_params.split(",").map(&:strip).reject(&:empty?).map do |p|
+        name, default = p.split("=", 2)
+        default = default.strip if default
+        if default && default.length >= 2 &&
+           ((default.start_with?('"') && default.end_with?('"')) ||
+            (default.start_with?("'") && default.end_with?("'")))
+          default = default[1..-2]
+        end
+        [name.strip, default]
+      end
+    end
+
     # Build an isolated lambda for a macro — avoids closure-in-loop variable sharing.
-    def _make_macro_fn(body_tokens, param_names, ctx)
+    # `params` is the [name, default] list from parse_macro_params.
+    def _make_macro_fn(body_tokens, params, ctx)
       engine = self
       lambda { |*args|
         macro_ctx = ctx.dup
-        param_names.each_with_index do |pname, pi|
-          macro_ctx[pname] = pi < args.length ? args[pi] : nil
+        params.each_with_index do |(pname, pdefault), pi|
+          macro_ctx[pname] = pi < args.length ? args[pi] : pdefault
         end
         Tina4::SafeString.new(engine.send(:render_tokens, body_tokens.dup, macro_ctx))
       }

data/lib/tina4/metrics.rb

@@ -338,7 +338,14 @@ module Tina4
         "total_functions" => all_functions.length,
         "avg_complexity" => avg_cc.round(2),
         "avg_maintainability" => avg_mi.round(1),
+        # Display-only: the top-15 for the "most complex functions" report.
+        # Do NOT source offenders / --fail-on from this — capping here silently
+        # hides the 16th+ over-threshold function from the gate. offenders()
+        # reads "all_functions" (below) instead.
         "most_complex_functions" => all_functions.first(15),
+        # Full, uncapped, complexity-sorted list — offenders()/--fail-on use this
+        # so no function over the complexity threshold ever escapes the gate.
+        "all_functions" => all_functions,
         "file_metrics" => file_metrics,
         "violations" => violations,
         "dependency_graph" => import_graph,
@@ -386,8 +393,10 @@ module Tina4
 
       items = []
 
-      # Function-level: cyclomatic complexity.
-      (analysis["most_complex_functions"] || []).each do |fn|
+      # Function-level: cyclomatic complexity. Use the FULL function list (not the
+      # display-capped most_complex_functions[:15]) so a 16th+ over-threshold
+      # function is never silently dropped from the offenders list or --fail-on.
+      (analysis["all_functions"] || analysis["most_complex_functions"] || []).each do |fn|
         cc = fn["complexity"]
         next unless cc > 10
         items << {

data/lib/tina4/orm.rb

@@ -785,9 +785,9 @@ module Tina4
               # Only adopt the engine-assigned id for an auto-increment PK. A
               # natural-key PK was set by the caller; don't overwrite it with the
               # driver's last_insert_id (which may be a sequence value that
-              # doesn't apply here).
-              if auto_increment && result[:last_id] && respond_to?("#{pk}=")
-                __send__("#{pk}=", result[:last_id])
+              # doesn't apply here). db.insert returns a DatabaseResult (.last_id).
+              if auto_increment && result.last_id && respond_to?("#{pk}=")
+                __send__("#{pk}=", result.last_id)
               end
             end
           end