tina4ruby 3.13.71 → 3.13.72

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9f7c750568ef4a0318f99b67d4d92a5a9ce7b8ba4acbb6ac44be312713f8bced
-  data.tar.gz: 0a206bb1d8e813073e5d2914d5f90f450ab5bb52f74fd60fe5cdc27f11ee1733
+  metadata.gz: 3ed4c522a29f92b73683272345e23d289b81698615cc9d006c72a09d19dca1a2
+  data.tar.gz: 77e3fb90d8ce8c4a7609655c512e2794fead60a70ec03c728968cea1f9f5a122
 SHA512:
-  metadata.gz: a188e4d9926366ddc6152711722f9bfaddba8740353abb1b616e931c4ebec67ef26a798b5cb54248f95ea9987510bae5b931627da5b7e9aa6ca58967528bb6df
-  data.tar.gz: a554393a76905b3bd88304c7d70e76b59e29c678d7248ff880d0754ec2261e23c7699536b8a29916c9855f21973de43e60fe044fa428c0f4107048a972f810b7
+  metadata.gz: 0dfd6b813d86acf8b6977e0132d60dc0ab735d2f312197e8bef771f20a74c607d31fb720b9496227430fb205d40ec02f185d8b7b2e459f15ee594779e53df381
+  data.tar.gz: e112213e75cbd5ffadbaca25f4a910bd409542c40bdde4f194bfc93d591e9d780b628615f6f7b3831191113d60722f087fb93c7c3c091c7876aa1316649b07f8

data/lib/tina4/dev_admin.rb

@@ -488,11 +488,14 @@ module Tina4
           begin
             if defined?(Tina4::Queue)
               queue = Tina4::Queue.new(backend: :file, topic: topic)
+              # Queue#size is keyword-only (def size(status:)). Calling it
+              # positionally raises ArgumentError, which the rescue below
+              # swallows — silently zeroing every stat. Use keyword form.
               stats = {
-                pending: queue.respond_to?(:size) ? queue.size("pending") : 0,
-                completed: queue.respond_to?(:size) ? queue.size("completed") : 0,
-                failed: queue.respond_to?(:size) ? queue.size("failed") : 0,
-                reserved: queue.respond_to?(:size) ? queue.size("reserved") : 0,
+                pending: queue.respond_to?(:size) ? queue.size(status: "pending") : 0,
+                completed: queue.respond_to?(:size) ? queue.size(status: "completed") : 0,
+                failed: queue.respond_to?(:size) ? queue.size(status: "failed") : 0,
+                reserved: queue.respond_to?(:size) ? queue.size(status: "reserved") : 0,
               }
               jobs.concat(queue.failed.map { |j| j.merge(status: "failed") }) if queue.respond_to?(:failed)
               jobs.concat(queue.dead_letters.map { |j| j.merge(status: "dead_letter") }) if queue.respond_to?(:dead_letters)
@@ -519,11 +522,10 @@ module Tina4
           error_tracker.clear_all
           json_response({ cleared: true })
         when ["GET", "/__dev/api/websockets"]
-          json_response({ connections: [], count: 0 })
+          json_response(websockets_payload)
         when ["POST", "/__dev/api/websockets/disconnect"]
-          body = read_json_body(env)
-          # TODO: disconnect WS connection by id from body["id"]
-          json_response({ disconnected: true })
+          body = read_json_body(env) || {}
+          json_response(websockets_disconnect(body))
         when ["GET", "/__dev/api/mailbox/read"]
           message_id = query_param(env, "id")
           message = mailbox.read(message_id)
@@ -547,16 +549,14 @@ module Tina4
           filtered = keyword.empty? ? all_messages : all_messages.select { |m| m[:message].to_s.downcase.include?(keyword.downcase) }
           json_response({ messages: filtered, count: filtered.size, keyword: keyword })
         when ["POST", "/__dev/api/queue/retry"]
-          body = read_json_body(env)
-          # TODO: retry failed jobs by id from body["id"]
-          json_response({ retried: true })
+          body = read_json_body(env) || {}
+          json_response(queue_retry(body))
         when ["POST", "/__dev/api/queue/purge"]
-          # TODO: purge completed jobs
-          json_response({ purged: true })
+          body = read_json_body(env) || {}
+          json_response(queue_purge(body))
         when ["POST", "/__dev/api/queue/replay"]
-          body = read_json_body(env)
-          # TODO: replay a specific job by id from body["id"]
-          json_response({ replayed: true })
+          body = read_json_body(env) || {}
+          json_response(queue_replay(body))
         when ["GET", "/__dev/api/table"]
           table_name = query_param(env, "name")
           json_response(table_detail_payload(table_name))
@@ -573,6 +573,23 @@ module Tina4
           body = read_json_body(env)
           tool = (body && body["tool"]) || ""
           json_response(run_tool(tool))
+        # Dedicated run-chip routes (parity with the SPA's migrate/test/seed
+        # chips + Python's dev-admin tools). Not MCP-gated — same as the
+        # sibling /tool, /seed and /query operational routes, which are only
+        # reachable at all under TINA4_DEBUG (DevAdmin.enabled?).
+        when ["POST", "/__dev/api/migrate"]
+          json_response(run_migrations_payload)
+        when ["POST", "/__dev/api/test"]
+          json_response(run_tests_payload)
+        when ["POST", "/__dev/api/seed/run"]
+          json_response(run_seeds_payload)
+        # Grounding panel — configure the tina4-coder MCP token used for
+        # live-docs grounding. Self-contained (.env read/write); no proxy.
+        when ["GET", "/__dev/api/grounding/status"]
+          json_response(grounding_status_payload)
+        when ["POST", "/__dev/api/grounding/token"]
+          body = read_json_body(env) || {}
+          json_response(grounding_token_save(body))
         when ["POST", "/__dev/api/chat"]
           # Proxy dev-admin chat to the Rust agent's /chat endpoint.
           # The SPA POSTs {message, thread_id?, active_file?, settings?}
@@ -878,21 +895,281 @@ module Tina4
         }
       end
 
+      # Run a named developer tool. `test`/`migrate`/`seed` reuse the same
+      # real code paths as the dedicated run-chip routes above (no stubs), so
+      # the legacy POST /tool surface and the new chips stay in lockstep.
       def run_tool(tool)
-        output = case tool
-                 when "routes"
-                   routes = Tina4::Router.routes.map { |r| { method: r.method, path: r.path } }
-                   JSON.pretty_generate(routes)
-                 when "test"
-                   "Test runner not yet configured. Run: bundle exec rspec"
-                 when "migrate"
-                   "Migration runner not yet configured. Run: tina4ruby migrate"
-                 when "seed"
-                   "Seeder not yet configured. Run: tina4ruby seed"
+        case tool
+        when "routes"
+          routes = Tina4::Router.routes.map { |r| { method: r.method, path: r.path } }
+          { tool: tool, output: JSON.pretty_generate(routes) }
+        when "test"
+          r = run_tests_payload
+          { tool: tool, output: r[:output].to_s, exit_code: r[:code], ok: r[:ok] }
+        when "migrate"
+          r = run_migrations_payload
+          lines = []
+          lines << "Applied: #{Array(r[:applied]).join(', ')}" unless Array(r[:applied]).empty?
+          lines << "Skipped: #{Array(r[:skipped]).join(', ')}" unless Array(r[:skipped]).empty?
+          failed_names = Array(r[:failed]).map { |f| f.is_a?(Hash) ? f[:name] : f }
+          lines << "Failed: #{failed_names.join(', ')}" unless failed_names.empty?
+          lines << "No pending migrations" if lines.empty? && r[:error].nil?
+          lines << "Error: #{r[:error]}" if r[:error]
+          { tool: tool, output: lines.join("\n"), result: r }
+        when "seed"
+          r = run_seeds_payload
+          { tool: tool, output: "Seeded #{r[:seeded]} file(s), #{r[:failed]} failed", result: r }
+        else
+          { tool: tool, output: "Unknown tool: #{tool}" }
+        end
+      end
+
+      # ── Run-chip implementations (Tier 1) ──────────────────────────
+
+      # POST /__dev/api/migrate — run pending migrations via the REAL
+      # Tina4::Migration runner (the same path `tina4ruby migrate` uses).
+      # `skipped` are pending files that never ran because an earlier
+      # migration in the batch failed (the runner stops on first failure).
+      def run_migrations_payload
+        db = Tina4.database
+        return { applied: [], skipped: [], failed: [], error: "No database configured" } unless db
+
+        require_relative "migration"
+        migration = Tina4::Migration.new(db)
+        pending_before = (migration.status[:pending] rescue [])
+        results = Array(migration.migrate)
+
+        applied = results.select { |r| r[:status] == "success" }.map { |r| r[:name] }
+        failed  = results.select { |r| r[:status] == "failed" }
+                         .map { |r| { name: r[:name], error: r[:error] } }
+        handled = results.map { |r| r[:name] }
+        skipped = pending_before - handled
+        { applied: applied, skipped: skipped, failed: failed }
+      rescue => e
+        { applied: [], skipped: [], failed: [], error: e.message }
+      end
+
+      # POST /__dev/api/test — run the project RSpec suite. Prefers
+      # `bundle exec rspec` when a Gemfile + bundler are present.
+      def run_tests_payload
+        root = Dir.pwd
+        runner = if File.exist?(File.join(root, "Gemfile")) &&
+                    system("command -v bundle > /dev/null 2>&1")
+                   "bundle exec rspec --no-color"
                  else
-                   "Unknown tool: #{tool}"
+                   "rspec --no-color"
                  end
-        { tool: tool, output: output }
+        output = `cd #{Shellwords.escape(root)} && #{runner} 2>&1`
+        code = $?.exitstatus.to_i
+        { ok: code.zero?, code: code, output: output.strip }
+      rescue => e
+        { ok: false, code: -1, output: e.message }
+      end
+
+      # POST /__dev/api/seed/run — run every seed file in seeds/ for real
+      # (each file `load`ed in the project context, exactly like `tina4ruby
+      # seed`). Counts files that ran vs. files that raised.
+      def run_seeds_payload
+        seed_folder = File.join(Dir.pwd, "seeds")
+        return { seeded: 0, failed: 0, error: "No seeds folder" } unless Dir.exist?(seed_folder)
+
+        files = Dir.glob(File.join(seed_folder, "*.rb")).sort
+                   .reject { |f| File.basename(f).start_with?("_") }
+        seeded = 0
+        failed = 0
+        files.each do |filepath|
+          begin
+            load filepath
+            seeded += 1
+          rescue StandardError => e
+            failed += 1
+            Tina4::Log.error("Seed failed: #{File.basename(filepath)} - #{e.message}") if defined?(Tina4::Log)
+          end
+        end
+        { seeded: seeded, failed: failed }
+      rescue => e
+        { seeded: 0, failed: 0, error: e.message }
+      end
+
+      # ── Grounding panel (Tier 2) ───────────────────────────────────
+
+      # Resolve an env value: live process ENV first (a just-saved token is
+      # reflected there), then the project .env. Returns nil when unset.
+      def grounding_env_value(key)
+        live = ENV[key]
+        return live unless live.nil? || live.empty?
+
+        env_path = File.join(Dir.pwd, ".env")
+        return nil unless File.file?(env_path)
+
+        File.readlines(env_path).each do |line|
+          line = line.strip
+          next if line.empty? || line.start_with?("#") || !line.include?("=")
+          k, v = line.split("=", 2)
+          next unless k.strip == key
+          return (v || "").strip.gsub(/\A["']|["']\z/, "")
+        end
+        nil
+      end
+
+      # GET /__dev/api/grounding/status
+      def grounding_status_payload
+        token = grounding_env_value("TINA4_MCP_TOKEN").to_s
+        url = grounding_env_value("TINA4_MCP_URL").to_s
+        url = "https://mcp.tina4.com" if url.empty?
+        configured = !token.empty?
+        { configured: configured, last4: configured ? token[-4..].to_s : "", url: url }
+      end
+
+      # POST /__dev/api/grounding/token — upsert TINA4_MCP_TOKEN into the
+      # project .env (empty token clears it). Reflects into the live process
+      # ENV so a subsequent status read returns the new state immediately.
+      def grounding_token_save(body)
+        token = (body && body["token"]).to_s.strip
+        env_path = File.join(Dir.pwd, ".env")
+        lines = File.file?(env_path) ? File.readlines(env_path, chomp: true) : []
+        found = false
+        new_lines = lines.map do |line|
+          stripped = line.strip
+          if !stripped.empty? && !stripped.start_with?("#") && stripped.include?("=") &&
+             stripped.split("=", 2).first.strip == "TINA4_MCP_TOKEN"
+            found = true
+            "TINA4_MCP_TOKEN=#{token}"
+          else
+            line
+          end
+        end
+        new_lines << "TINA4_MCP_TOKEN=#{token}" unless found
+        File.write(env_path, new_lines.join("\n") + "\n")
+
+        if token.empty?
+          ENV.delete("TINA4_MCP_TOKEN")
+        else
+          ENV["TINA4_MCP_TOKEN"] = token
+        end
+        configured = !token.empty?
+        { ok: true, configured: configured, last4: configured ? token[-4..].to_s : "" }
+      rescue => e
+        { ok: false, error: e.message }
+      end
+
+      # ── Queue run-chips (Tier 3) ───────────────────────────────────
+
+      # A file-backed dev Queue for +topic+ (matches the GET /queue handler).
+      def dev_queue(topic)
+        require_relative "queue" unless defined?(Tina4::Queue)
+        Tina4::Queue.new(backend: :file, topic: topic)
+      end
+
+      # POST /__dev/api/queue/retry — revive failed/dead-letter jobs back to
+      # pending (real mutation via Queue#retry_failed).
+      def queue_retry(body)
+        topic = (body["topic"] || "default").to_s
+        queue = dev_queue(topic)
+        retried = queue.respond_to?(:retry_failed) ? queue.retry_failed : 0
+        { retried: retried, topic: topic }
+      rescue => e
+        { retried: 0, error: e.message }
+      end
+
+      # POST /__dev/api/queue/purge — delete jobs by status (default
+      # "completed"). Pass {"status": "pending"} to drop queued jobs.
+      # Real mutation via Queue#purge; returns the number removed.
+      def queue_purge(body)
+        topic = (body["topic"] || "default").to_s
+        status = (body["status"] || "completed").to_s
+        queue = dev_queue(topic)
+        removed = queue.respond_to?(:purge) ? queue.purge(status) : 0
+        { purged: true, removed: removed, status: status, topic: topic }
+      rescue => e
+        { purged: false, error: e.message }
+      end
+
+      # POST /__dev/api/queue/replay — re-queue a specific job by id from the
+      # dead-letter/failed store (real mutation via Queue#retry(job_id)).
+      def queue_replay(body)
+        topic = (body["topic"] || "default").to_s
+        job_id = body["id"]
+        return { replayed: false, error: "Missing job id" } if job_id.nil? || job_id.to_s.empty?
+
+        delay = (body["delay"] || 0).to_i
+        queue = dev_queue(topic)
+        result = queue.respond_to?(:retry) ? queue.retry(job_id, delay_seconds: delay) : false
+        { replayed: result, id: job_id, topic: topic }
+      rescue => e
+        { replayed: false, error: e.message }
+      end
+
+      # ── WebSocket introspection (Tier 3) ───────────────────────────
+
+      # The live WebSocket managers to introspect. In tina4-ruby app routes
+      # share the process-wide engine (Tina4::WebSocket.current) while the
+      # dev-reload channel keeps its own manager (Tina4::DevReload) — both
+      # hold real, live connections, so the panel enumerates both.
+      def ws_managers
+        managers = []
+        if defined?(Tina4::WebSocket) && Tina4::WebSocket.current
+          managers << Tina4::WebSocket.current
+        end
+        managers << Tina4::DevReload.manager if defined?(Tina4::DevReload)
+        managers.compact
+      end
+
+      # GET /__dev/api/websockets — enumerate real live connections.
+      def websockets_payload
+        seen = {}
+        ws_managers.each do |mgr|
+          conns = mgr.respond_to?(:connections) ? mgr.connections : {}
+          conns.each do |id, conn|
+            next if seen.key?(id)
+            seen[id] = {
+              id: id.to_s,
+              path: (conn.respond_to?(:path) ? conn.path : "/").to_s,
+              ip: ws_conn_ip(conn),
+              rooms: (conn.respond_to?(:rooms) ? conn.rooms.to_a : []),
+              last_activity: (conn.respond_to?(:last_activity) ? conn.last_activity : nil),
+              closed: (conn.respond_to?(:closed?) ? conn.closed? : false),
+            }
+          end
+        end
+        list = seen.values
+        { connections: list, count: list.size }
+      rescue => e
+        { connections: [], count: 0, error: e.message }
+      end
+
+      # Best-effort peer IP off the connection params (nil-safe).
+      def ws_conn_ip(conn)
+        return "" unless conn.respond_to?(:params) && conn.params
+        (conn.params["ip"] || conn.params[:ip] || "").to_s
+      end
+
+      # POST /__dev/api/websockets/disconnect — actually close + unregister
+      # the given connection id across the live managers.
+      def websockets_disconnect(body)
+        id = body["id"]
+        return { disconnected: false, error: "id required" } if id.nil? || id.to_s.empty?
+
+        disconnected = false
+        ws_managers.each do |mgr|
+          conns = mgr.respond_to?(:connections) ? mgr.connections : {}
+          next unless conns.key?(id)
+
+          begin
+            mgr.close(id) if mgr.respond_to?(:close)
+          rescue StandardError
+            # closing a half-dead socket must not abort the unregister below
+          end
+          if mgr.respond_to?(:unregister_connection)
+            mgr.unregister_connection(id)
+          else
+            conns.delete(id)
+          end
+          disconnected = true
+        end
+        { disconnected: disconnected, id: id }
+      rescue => e
+        { disconnected: false, error: e.message }
       end
 
       def run_query(sql)
@@ -1590,14 +1867,29 @@ module Tina4
       def deps_install(body)
         name = body["name"].to_s.strip
         return { ok: false, error: "name required" } if name.empty?
-        # Append to Gemfile if not present — do NOT actually bundle install.
+        version = body["version"].to_s.strip
+        dev = [true, "true", 1, "1"].include?(body["dev"])
         gemfile = File.join(Dir.pwd, "Gemfile")
         return { ok: false, error: "No Gemfile at project root" } unless File.exist?(gemfile)
+
+        # Prefer `bundle add` — it updates the Gemfile AND installs the gem, so a
+        # dev dep is deployed (not just recorded). Fall back to appending to the
+        # Gemfile when bundler isn't available.
+        if system("command -v bundle > /dev/null 2>&1")
+          cmd = ["bundle", "add", name]
+          cmd += ["--version", version] unless version.empty?
+          cmd += ["--group", "development"] if dev
+          out = `#{cmd.map { |c| Shellwords.escape(c) }.join(' ')} 2>&1`
+          return { ok: true, gem: name, output: out.strip } if $?.success?
+          return { ok: false, error: out.strip }
+        end
+
         content = File.read(gemfile)
         if content.include?("gem \"#{name}\"") || content.include?("gem '#{name}'")
           return { ok: true, gem: name, note: "already in Gemfile" }
         end
-        File.open(gemfile, "a") { |f| f.write("\ngem \"#{name}\"\n") }
+        entry = dev ? "\ngroup :development do\n  gem \"#{name}\"\nend\n" : "\ngem \"#{name}\"\n"
+        File.open(gemfile, "a") { |f| f.write(entry) }
         { ok: true, gem: name, note: "added to Gemfile; run `bundle install`" }
       end
 

data/lib/tina4/frond.rb

@@ -93,6 +93,19 @@ module Tina4
     HASH_PAIR_RE    = /\A\s*(?:["']([^"']+)["']|(\w+))\s*:\s*(.+)\z/
     RANGE_LIT_RE    = /\A(\d+)\.\.(\d+)\z/
     ARITHMETIC_OPS  = [" + ", " - ", " * ", " // ", " / ", " % ", " ** "].freeze
+    # Operators Twig binds LOOSER than the filter pipe `|`. When one of these
+    # sits at the top level alongside a pipe (e.g. `amount|number_format(2) ~
+    # ' EUR'`), the whole expression must go through eval_expr (which resolves
+    # the pipe at its correct, tighter precedence) instead of being split on
+    # the pipe as a plain filter chain. Detection is quote/paren-aware
+    # (find_outside_quotes) so operator-like text inside a string or filter
+    # args never false-triggers.
+    LOOSER_THAN_PIPE_OPS = [
+      "~", "??", " if ",
+      " not in ", " in ", " is not ", " is ", "!=", "==", ">=", "<=", ">", "<",
+      " and ", " or ", " not ",
+      " + ", " - ", " * ", " // ", " / ", " % ", " ** "
+    ].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/
@@ -673,6 +686,12 @@ module Tina4
       filters.each do |fname, args|
         next if fname == "raw" || fname == "safe"
 
+        # Sandbox: a blocked filter is silently skipped (value passes through
+        # unchanged) — same gate as eval_var_inner. Without this, a filter pipe
+        # reached via eval_filter_pipe (`x|f ~ y`, #171) or a ternary condition
+        # (`x|f ? a : b`) would run a non-allow-listed filter in sandbox mode.
+        next if @sandbox && @allowed_filters && !@allowed_filters.include?(fname)
+
         # Filter + property-access chain: `first.groupSummary` — apply
         # the filter, then traverse the path on the result using a
         # synthetic context so eval_expr's dotted resolution does the
@@ -723,6 +742,20 @@ module Tina4
     end
 
     def eval_var_inner(expr, context)
+      # Twig binds the filter pipe `|` TIGHTER than ~, comparison, and
+      # arithmetic. When a looser operator sits at the top level alongside a
+      # pipe (e.g. `amount|number_format(2) ~ ' EUR'`), splitting on the pipe
+      # here would swallow the tail (`~ ' EUR'`) into the filter args and drop
+      # it. Hand the whole expression to eval_expr — which resolves the pipe at
+      # the correct precedence (eval_filter_pipe) — then apply output escaping.
+      if find_outside_quotes(expr, "|") >= 0 && has_looser_than_pipe_operator?(expr)
+        value = eval_expr(expr, context)
+        if @auto_escape && value.is_a?(String) && !value.is_a?(SafeString)
+          value = Frond.escape_html(value)
+        end
+        return value
+      end
+
       var_name, filters = parse_filter_chain(expr)
 
       # Sandbox: check variable access
@@ -1068,12 +1101,37 @@ module Tina4
       result = eval_arithmetic(expr, context)
       return result unless result == :not_arithmetic
 
+      result = eval_filter_pipe(expr, context)
+      return result unless result == :not_filter_pipe
+
       result = eval_function_call(expr, context)
       return result unless result == :not_function
 
       resolve(expr, context)
     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
+    # binds tighter than all of them — matching Twig. This is what makes
+    # `amount|number_format(2) ~ ' EUR'` resolve as `(amount|number_format(2))
+    # ~ ' EUR'`, and it lets a pipe inside parens / a sub-expression resolve
+    # (previously such a pipe fell through to `resolve` and returned empty).
+    # Delegates to eval_var_raw, which applies the filter chain WITHOUT output
+    # escaping (escaping happens once, at the output layer, on the final value).
+    def eval_filter_pipe(expr, context)
+      return :not_filter_pipe unless find_outside_quotes(expr, "|") >= 0
+
+      eval_var_raw(expr, context)
+    end
+
+    # True when the expression carries a top-level operator that Twig binds
+    # 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)
+      LOOSER_THAN_PIPE_OPS.any? { |op| find_outside_quotes(expr, op) >= 0 }
+    end
+
     # ── Literal values: strings, numbers, booleans, null ──
 
     def eval_literal(expr)
@@ -2172,12 +2230,17 @@ module Tina4
         "int"           => ->(v, *_a) { v.to_i },
         "float"         => ->(v, *_a) { v.to_f },
         "number_format" => ->(v, *a) {
-          decimals = a[0] ? a[0].to_i : 0
+          # Twig signature: number_format(decimals, decimalPoint, thousandsSep).
+          # The defaults reproduce the historical output ("1,234.50") so a
+          # 1-arg call is unchanged; args 2 and 3 apply the localized
+          # separators (e.g. number_format(2, ',', '.') -> "1.234,50").
+          decimals      = a[0] ? a[0].to_i : 0
+          decimal_point = a[1].nil? ? "." : a[1].to_s
+          thousands_sep = a[2].nil? ? "," : a[2].to_s
           formatted = format("%.#{decimals}f", v.to_f)
-          # Add comma thousands separator
-          parts = formatted.split(".")
-          parts[0] = parts[0].gsub(THOUSANDS_RE, '\\1,')
-          parts.join(".")
+          int_part, frac_part = formatted.split(".")
+          int_part = int_part.gsub(THOUSANDS_RE) { |digit| "#{digit}#{thousands_sep}" }
+          frac_part ? "#{int_part}#{decimal_point}#{frac_part}" : int_part
         },
 
         # -- Date --