polyrun 1.4.1 → 1.5.0

data/lib/polyrun/cli/run_shards_worker_interrupt.rb

@@ -0,0 +1,75 @@
+module Polyrun
+  class CLI
+    # SIGINT/SIGTERM handling and non-blocking reap for parallel worker PIDs (used by run-shards / ci-shard fan-out).
+    module RunShardsWorkerInterrupt
+      private
+
+      def run_shards_log_interrupt_workers(pids, _ctx)
+        parts = pids.map { |h| "shard=#{h[:shard]} pid=#{h[:pid]}" }
+        Polyrun::Log.orchestration_warn "polyrun run-shards: SIGINT/SIGTERM while waiting on workers — stopping: #{parts.join(", ")}"
+        Polyrun::Log.warn "polyrun run-shards: search this log for each shard's started … pid= line and RSpec output; repeat SIGINT during cleanup escalates to SIGKILL"
+      end
+
+      # Best-effort worker teardown then exit. Does not return.
+      def run_shards_shutdown_on_signal!(pids, code)
+        run_shards_log_interrupt_workers(pids, nil)
+        run_shards_terminate_children!(pids)
+        exit(code)
+      rescue Interrupt
+        run_shards_signal_workers_kill(pids)
+        run_shards_reap_worker_pids_interruptible(pids.map { |h| h[:pid] })
+        exit(code)
+      end
+
+      # Send SIGTERM to each worker PID and wait so Ctrl+C / SIGTERM does not leave orphans.
+      def run_shards_terminate_children!(pids)
+        run_shards_signal_workers_term(pids)
+        run_shards_reap_worker_pids_interruptible(pids.map { |h| h[:pid] })
+      end
+
+      def run_shards_signal_workers_term(pids)
+        pids.each do |h|
+          Process.kill(:TERM, h[:pid])
+        rescue Errno::ESRCH
+        end
+      end
+
+      def run_shards_signal_workers_kill(pids)
+        pids.each do |h|
+          Process.kill(:KILL, h[:pid])
+        rescue Errno::ESRCH
+        end
+      end
+
+      # Reap child PIDs without blocking uninterruptibly on one stuck zombie (avoids noisy stacks on repeat Ctrl+C).
+      def run_shards_reap_worker_pids_interruptible(pids)
+        pending = pids.compact.uniq
+        force_note = false
+        until pending.empty?
+          pending.reject! do |pid|
+            w = Process.wait(pid, Process::WNOHANG)
+            next true if w == pid
+
+            false
+          rescue Errno::ECHILD
+            true
+          end
+          break if pending.empty?
+
+          begin
+            sleep(0.05)
+          rescue Interrupt
+            unless force_note
+              force_note = true
+              Polyrun::Log.orchestration_warn "polyrun run-shards: repeated SIGINT during worker cleanup — SIGKILL to #{pending.size} process(es)"
+            end
+            pending.each do |pid|
+              Process.kill(:KILL, pid)
+            rescue Errno::ESRCH
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/polyrun/coverage/collector_finish.rb

@@ -41,9 +41,10 @@ module Polyrun
       def self.track_blob_for_finish(cfg, blob)
         sharded = ENV["POLYRUN_SHARD_TOTAL"].to_i > 1
         if cfg[:track_files]
-          return Collector.keep_under_root(blob, cfg[:root], cfg[:track_under]) if sharded
+          filtered = TrackFiles.keep_tracked_files(blob, cfg[:root], cfg[:track_files])
+          return filtered if sharded
 
-          TrackFiles.merge_untracked_into_blob(blob, cfg[:root], cfg[:track_files])
+          TrackFiles.merge_untracked_into_blob(filtered, cfg[:root], cfg[:track_files])
         else
           Collector.keep_under_root(blob, cfg[:root], cfg[:track_under])
         end

data/lib/polyrun/coverage/formatter.rb

@@ -106,7 +106,8 @@ module Polyrun
         def write_files(result, output_dir, basename)
           path = File.join(output_dir, "#{basename}.html")
           title = (result.meta && result.meta["title"]) || (result.meta && result.meta[:title]) || "Polyrun coverage"
-          File.write(path, Merge.emit_html(result.coverage_blob, title: title))
+          root = result.meta && (result.meta["polyrun_coverage_root"] || result.meta[:polyrun_coverage_root])
+          File.write(path, Merge.emit_html(result.coverage_blob, title: title, root: root, groups: result.groups))
           {html: path}
         end
       end

data/lib/polyrun/coverage/merge/formatters_html.rb

@@ -1,55 +1,203 @@
+# rubocop:disable Polyrun/FileLength -- HTML merge formatter + helpers in one file
 require "cgi"
+require "digest/sha1"
+require "erb"
+require "pathname"
 
 module Polyrun
   module Coverage
     module Merge
       module_function
 
-      # Minimal standalone HTML report (no extra gems), index listing similar to SimpleCov.
-      def emit_html(coverage_blob, title: "Polyrun coverage")
-        summary = console_summary(coverage_blob)
-        rows = []
-        coverage_blob.keys.sort.each do |path|
-          file = coverage_blob[path]
-          pct, rel, cov = file_line_stats(file)
-          esc = CGI.escapeHTML(path.to_s)
-          rows << "<tr><td class=\"path\">#{esc}</td><td class=\"pct\">#{format("%.2f", pct)}</td><td class=\"hits\">#{cov} / #{rel}</td></tr>"
+      # Standalone HTML report with summary, file table, and per-file source details.
+      # rubocop:disable Metrics/AbcSize -- linear assembly of overview, file table, sections, asset reads
+      def emit_html(coverage_blob, title: "Polyrun coverage", root: nil, groups: nil, generated_at: Time.now)
+        files = coverage_blob.keys.sort.map { |path| html_file_payload(path, coverage_blob[path], root) }
+        summary = html_summary(files)
+        groups_html = render_html_partial("groups_table", group_rows_html: html_group_rows(groups).join("\n"))
+        overview_html = render_html_partial(
+          "overview",
+          summary: summary,
+          summary_badge_class: html_badge_class(summary[:line_percent]),
+          groups_html: groups_html
+        )
+        file_list_html = render_html_partial("file_list", file_rows_html: files.map { |file| html_file_list_row(file) }.join("\n"))
+        file_sections_html = files.map { |file| render_html_partial("file_section", file: file) }.join("\n")
+        ERB.new(File.read(html_template_path), trim_mode: "-").result_with_hash(
+          title: CGI.escapeHTML(title.to_s),
+          generated_label: html_generated_label(generated_at),
+          overview_html: overview_html,
+          file_list_html: file_list_html,
+          file_sections_html: file_sections_html,
+          stylesheet: File.read(html_stylesheet_path),
+          javascript: File.read(html_javascript_path)
+        )
+      end
+      # rubocop:enable Metrics/AbcSize
+
+      def html_asset_dir
+        File.join(__dir__, "html")
+      end
+
+      def html_template_path
+        File.join(html_asset_dir, "template.html.erb")
+      end
+
+      def html_stylesheet_path
+        File.join(html_asset_dir, "report.css")
+      end
+
+      def html_javascript_path
+        File.join(html_asset_dir, "report.js")
+      end
+
+      def html_partial_path(name)
+        File.join(html_asset_dir, "_#{name}.html.erb")
+      end
+
+      def render_html_partial(name, locals = {})
+        ERB.new(File.read(html_partial_path(name)), trim_mode: "-").result_with_hash(locals)
+      end
+
+      def html_file_payload(path, file, root)
+        line_arr = line_array_from_file_entry(file) || []
+        source_lines = html_source_lines(path, line_arr.length)
+        counts = line_counts(file)
+        relevant = counts[:relevant]
+        covered = counts[:covered]
+        total_hits = line_arr.sum { |hit| html_numeric_hit(hit) || 0 }
+        pct = relevant.positive? ? (100.0 * covered / relevant) : 0.0
+        {
+          id: "file-#{Digest::SHA1.hexdigest(path.to_s)}",
+          path: path.to_s,
+          display_path: html_display_path(path, root),
+          badge_class: html_badge_class(pct),
+          total_lines: [source_lines.length, line_arr.length].max,
+          relevant: relevant,
+          covered: covered,
+          missed: relevant - covered,
+          avg_hits: relevant.positive? ? (total_hits.to_f / relevant) : 0.0,
+          line_percent: pct,
+          source_rows: html_source_rows(source_lines, line_arr)
+        }
+      end
+
+      def html_summary(files)
+        relevant = files.sum { |file| file[:relevant] }
+        covered = files.sum { |file| file[:covered] }
+        total_hits = files.sum { |file| file[:avg_hits] * file[:relevant] }
+        {
+          files: files.length,
+          lines_relevant: relevant,
+          lines_covered: covered,
+          lines_missed: relevant - covered,
+          line_percent: relevant.positive? ? (100.0 * covered / relevant) : 0.0,
+          avg_hits: relevant.positive? ? (total_hits.to_f / relevant) : 0.0
+        }
+      end
+
+      def html_group_rows(groups)
+        return [] unless groups.is_a?(Hash) && !groups.empty?
+
+        groups.map do |name, data|
+          pct = html_group_percent(data)
+          <<~ROW.strip
+            <tr>
+              <td>#{CGI.escapeHTML(name.to_s)}</td>
+              <td class="cell--number"><span class="badge #{html_badge_class(pct)}">#{format("%.2f", pct)}%</span></td>
+            </tr>
+          ROW
         end
-        esc_title = CGI.escapeHTML(title.to_s)
-        <<~HTML
-          <!DOCTYPE html>
-          <html lang="en">
-          <head>
-            <meta charset="utf-8"/>
-            <title>#{esc_title}</title>
-            <style>
-              body { font-family: system-ui, sans-serif; margin: 1.5rem; color: #1a1a1a; }
-              h1 { font-size: 1.25rem; }
-              .summary { margin: 1rem 0; }
-              table { border-collapse: collapse; width: 100%; max-width: 56rem; }
-              th, td { border: 1px solid #ccc; padding: 0.35rem 0.5rem; text-align: left; }
-              th { background: #f4f4f4; }
-              tr:nth-child(even) { background: #fafafa; }
-              td.path { word-break: break-all; font-size: 0.9rem; }
-              td.pct { white-space: nowrap; }
-            </style>
-          </head>
-          <body>
-            <h1>#{esc_title}</h1>
-            <p class="summary">
-              <strong>#{format("%.2f", summary[:line_percent])}%</strong> lines
-              (#{summary[:lines_covered]} / #{summary[:lines_relevant]}) across #{summary[:files]} files
-            </p>
-            <table>
-              <thead><tr><th>File</th><th>Coverage</th><th>Lines (covered / relevant)</th></tr></thead>
-              <tbody>
-              #{rows.join("\n")}
-              </tbody>
-            </table>
-          </body>
-          </html>
-        HTML
+      end
+
+      def html_group_percent(data)
+        return 0.0 unless data.is_a?(Hash)
+
+        lines = data["lines"] || data[:lines]
+        pct = lines.is_a?(Hash) ? (lines["covered_percent"] || lines[:covered_percent]) : nil
+        pct.to_f
+      end
+
+      def html_file_list_row(file)
+        <<~ROW.strip
+          <tr class="t-file">
+            <td class="strong t-file__name"><a href="##{file[:id]}" class="src_link" title="#{CGI.escapeHTML(file[:display_path])}">#{CGI.escapeHTML(file[:display_path])}</a></td>
+            <td class="cell--number"><span class="badge #{html_badge_class(file[:line_percent])}">#{format("%.2f", file[:line_percent])}%</span></td>
+            <td class="cell--number">#{file[:total_lines]}</td>
+            <td class="cell--number">#{file[:relevant]}</td>
+            <td class="cell--number">#{file[:covered]}</td>
+            <td class="cell--number">#{file[:missed]}</td>
+            <td class="cell--number">#{format("%.2f", file[:avg_hits])}</td>
+          </tr>
+        ROW
+      end
+
+      def html_source_rows(source_lines, line_arr)
+        max_len = [source_lines.length, line_arr.length].max
+        Array.new(max_len) do |idx|
+          source = source_lines[idx] || ""
+          hit = line_arr[idx]
+          css = html_line_class(hit)
+          hits_label = html_hit_label(hit)
+          <<~ROW.strip
+            <tr class="#{css}">
+              <td class="line-num">#{idx + 1}</td>
+              <td class="line-hits">#{hits_label}</td>
+              <td class="line-source"><code>#{source.empty? ? "&nbsp;" : CGI.escapeHTML(source)}</code></td>
+            </tr>
+          ROW
+        end
+      end
+
+      def html_source_lines(path, fallback_length)
+        return Array.new(fallback_length, "") unless File.file?(path.to_s)
+
+        File.readlines(path.to_s, chomp: true)
+      rescue Errno::ENOENT, Errno::EACCES, ArgumentError
+        Array.new(fallback_length, "")
+      end
+
+      def html_display_path(path, root)
+        p = File.expand_path(path.to_s)
+        return p if root.nil? || root.to_s.empty?
+
+        Pathname.new(p).relative_path_from(Pathname.new(File.expand_path(root.to_s))).to_s
+      rescue ArgumentError
+        p
+      end
+
+      def html_generated_label(generated_at)
+        t = generated_at.is_a?(Time) ? generated_at : Time.now
+        t.utc.strftime("%Y-%m-%d %H:%M:%S UTC")
+      end
+
+      def html_badge_class(percent)
+        return "green" if percent >= 90.0
+        return "yellow" if percent >= 80.0
+
+        "red"
+      end
+
+      def html_numeric_hit(hit)
+        return nil if hit.nil? || hit == "ignored"
+
+        hit.to_i
+      end
+
+      def html_hit_label(hit)
+        return "" if hit.nil?
+        return "ignored" if hit == "ignored"
+
+        hit.to_i.to_s
+      end
+
+      def html_line_class(hit)
+        return "line-none" if hit.nil?
+        return "line-ignored" if hit == "ignored"
+
+        hit.to_i.positive? ? "line-covered" : "line-missed"
       end
     end
   end
 end
+# rubocop:enable Polyrun/FileLength

data/lib/polyrun/coverage/merge/html/_file_list.html.erb

@@ -0,0 +1,21 @@
+<div class="panel file_list_container" id="file-list">
+  <h2>Files</h2>
+  <div class="file_list--responsive">
+    <table class="file_list" data-sortable="true">
+      <thead>
+        <tr>
+          <th>File</th>
+          <th class="cell--number">% covered</th>
+          <th class="cell--number">Lines</th>
+          <th class="cell--number">Relevant Lines</th>
+          <th class="cell--number">Lines covered</th>
+          <th class="cell--number">Lines missed</th>
+          <th class="cell--number">Avg. Hits / Line</th>
+        </tr>
+      </thead>
+      <tbody>
+        <%= file_rows_html %>
+      </tbody>
+    </table>
+  </div>
+</div>

data/lib/polyrun/coverage/merge/html/_file_section.html.erb

@@ -0,0 +1,26 @@
+<div class="panel file-section source_file" id="<%= file[:id] %>">
+  <div class="file-heading">
+    <h2><%= CGI.escapeHTML(file[:display_path]) %></h2>
+    <a href="#overview">Back to summary</a>
+  </div>
+  <div class="file-meta">
+    <span class="badge <%= file[:badge_class] %>"><%= format("%.2f", file[:line_percent]) %>%</span>
+    <%= file[:covered] %> / <%= file[:relevant] %> relevant lines covered,
+    <%= file[:missed] %> missed,
+    <%= format("%.2f", file[:avg_hits]) %> avg. hits / line
+  </div>
+  <div class="file_list--responsive">
+    <table class="source_table">
+      <thead>
+        <tr>
+          <th class="line-num">Line</th>
+          <th class="line-hits">Hits</th>
+          <th class="line-source">Source</th>
+        </tr>
+      </thead>
+      <tbody>
+        <%= file[:source_rows].join("\n") %>
+      </tbody>
+    </table>
+  </div>
+</div>

data/lib/polyrun/coverage/merge/html/_groups_table.html.erb

@@ -0,0 +1,18 @@
+<% unless group_rows_html.empty? %>
+  <div class="group-summary">
+    <h3>Groups</h3>
+    <div class="file_list--responsive">
+      <table class="group-table" data-sortable="true">
+        <thead>
+          <tr>
+            <th>Group</th>
+            <th class="cell--number">% covered</th>
+          </tr>
+        </thead>
+        <tbody>
+          <%= group_rows_html %>
+        </tbody>
+      </table>
+    </div>
+  </div>
+<% end %>

data/lib/polyrun/coverage/merge/html/_overview.html.erb

@@ -0,0 +1,47 @@
+<div class="panel file_list_container" id="overview">
+  <h2>
+    <span class="group_name">All Files</span>
+    (<span class="covered_percent"><span class="<%= summary_badge_class %>"><%= format("%.2f", summary[:line_percent]) %>%</span></span>
+    covered at
+    <span class="covered_strength"><span class="<%= summary_badge_class %>"><%= format("%.2f", summary[:avg_hits]) %></span></span>
+    hits/line)
+  </h2>
+
+  <div><b><%= summary[:files] %></b> files in total.</div>
+  <div class="t-line-summary">
+    <b><%= summary[:lines_relevant] %></b> relevant lines,
+    <span class="green"><b><%= summary[:lines_covered] %></b> lines covered</span> and
+    <span class="red"><b><%= summary[:lines_missed] %></b> lines missed</span>
+    (<span class="<%= summary_badge_class %>"><%= format("%.2f", summary[:line_percent]) %>%</span>)
+  </div>
+
+  <div class="metrics">
+    <div class="metric">
+      <div class="metric-label">Coverage</div>
+      <div class="metric-value"><%= format("%.2f", summary[:line_percent]) %>%</div>
+    </div>
+    <div class="metric">
+      <div class="metric-label">Relevant Lines</div>
+      <div class="metric-value"><%= summary[:lines_relevant] %></div>
+    </div>
+    <div class="metric">
+      <div class="metric-label">Lines Covered</div>
+      <div class="metric-value"><%= summary[:lines_covered] %></div>
+    </div>
+    <div class="metric">
+      <div class="metric-label">Lines Missed</div>
+      <div class="metric-value"><%= summary[:lines_missed] %></div>
+    </div>
+    <div class="metric">
+      <div class="metric-label">Avg. Hits / Line</div>
+      <div class="metric-value"><%= format("%.2f", summary[:avg_hits]) %></div>
+    </div>
+  </div>
+
+  <%= groups_html %>
+
+  <div class="nav-links">
+    <a href="#file-list">File List</a>
+    <a href="#source-files">Source Files</a>
+  </div>
+</div>

data/lib/polyrun/coverage/merge/html/report.css

@@ -0,0 +1,147 @@
+:root {
+  color-scheme: light;
+  --bg: #f5f7fb;
+  --surface: #ffffff;
+  --border: #d7ddea;
+  --text: #1f2937;
+  --muted: #6b7280;
+  --green: #0f766e;
+  --green-bg: #ecfdf5;
+  --yellow: #b45309;
+  --yellow-bg: #fffbeb;
+  --red: #b91c1c;
+  --red-bg: #fef2f2;
+  --gray-bg: #f8fafc;
+}
+
+* { box-sizing: border-box; }
+
+html {
+  scroll-behavior: smooth;
+}
+
+body {
+  margin: 0;
+  font-family: Inter, system-ui, -apple-system, BlinkMacSystemFont, "Segoe UI", sans-serif;
+  background: var(--bg);
+  color: var(--text);
+  line-height: 1.45;
+}
+
+a { color: #1d4ed8; text-decoration: none; }
+a:hover { text-decoration: underline; }
+
+#wrapper { max-width: 1200px; margin: 0 auto; padding: 1.5rem; }
+
+.topbar {
+  display: flex;
+  justify-content: space-between;
+  gap: 1rem;
+  align-items: baseline;
+  margin-bottom: 1rem;
+}
+
+.timestamp { color: var(--muted); font-size: 0.9rem; }
+
+.panel {
+  background: var(--surface);
+  border: 1px solid var(--border);
+  border-radius: 12px;
+  padding: 1rem 1.25rem;
+  margin-bottom: 1rem;
+  box-shadow: 0 2px 8px rgba(15, 23, 42, 0.04);
+}
+
+.metrics {
+  display: grid;
+  grid-template-columns: repeat(auto-fit, minmax(180px, 1fr));
+  gap: 0.75rem;
+  margin-top: 1rem;
+}
+
+.metric {
+  border: 1px solid var(--border);
+  border-radius: 10px;
+  padding: 0.85rem 1rem;
+  background: var(--gray-bg);
+}
+
+.metric-label { color: var(--muted); font-size: 0.82rem; text-transform: uppercase; letter-spacing: 0.03em; }
+.metric-value { font-size: 1.4rem; font-weight: 700; margin-top: 0.2rem; }
+.summary-line, .t-line-summary { margin-top: 0.75rem; color: var(--muted); }
+.group-summary { margin-top: 1rem; }
+
+table { width: 100%; border-collapse: collapse; }
+
+th, td { padding: 0.55rem 0.7rem; border-top: 1px solid var(--border); vertical-align: top; }
+
+thead th {
+  background: var(--gray-bg);
+  color: var(--muted);
+  font-size: 0.82rem;
+  text-transform: uppercase;
+  letter-spacing: 0.03em;
+  border-top: none;
+  position: sticky;
+  top: 0;
+}
+
+th[data-sortable-column="true"] {
+  cursor: pointer;
+  user-select: none;
+}
+
+th[data-sort-direction="asc"]::after { content: " ↑"; }
+th[data-sort-direction="desc"]::after { content: " ↓"; }
+
+.cell--number { text-align: right; white-space: nowrap; }
+
+.badge {
+  display: inline-block;
+  min-width: 72px;
+  text-align: center;
+  border-radius: 999px;
+  padding: 0.15rem 0.55rem;
+  font-weight: 700;
+}
+
+.green { color: var(--green); }
+.yellow { color: var(--yellow); }
+.red { color: var(--red); }
+.badge.green { background: var(--green-bg); }
+.badge.yellow { background: var(--yellow-bg); }
+.badge.red { background: var(--red-bg); }
+
+.file_list--responsive { overflow-x: auto; }
+.file-section { margin-top: 1rem; }
+
+.file-heading {
+  display: flex;
+  justify-content: space-between;
+  gap: 1rem;
+  align-items: baseline;
+  flex-wrap: wrap;
+}
+
+.file-meta { color: var(--muted); font-size: 0.95rem; }
+
+.source_table td {
+  font-family: ui-monospace, SFMono-Regular, Menlo, Consolas, monospace;
+  font-size: 0.83rem;
+  white-space: pre-wrap;
+  word-break: break-word;
+}
+
+.line-num, .line-hits {
+  width: 5rem;
+  color: var(--muted);
+  text-align: right;
+  white-space: nowrap;
+}
+
+.line-source { width: auto; }
+.line-covered { background: rgba(16, 185, 129, 0.10); }
+.line-missed { background: rgba(239, 68, 68, 0.10); }
+.line-ignored, .line-none { background: transparent; }
+.nav-links { display: flex; gap: 0.75rem; flex-wrap: wrap; margin-top: 0.75rem; }
+.group-table td:first-child, .file_list td:first-child { width: 100%; }

data/lib/polyrun/coverage/merge/html/report.js

@@ -0,0 +1,48 @@
+(() => {
+  function cellValue(row, index) {
+    const cell = row.children[index];
+    return cell ? cell.textContent.trim() : "";
+  }
+
+  function sortableValue(text) {
+    const numeric = Number.parseFloat(text.replace(/[% ,]/g, ""));
+    return Number.isNaN(numeric) ? text.toLowerCase() : numeric;
+  }
+
+  function sortTable(table, index, direction) {
+    const body = table.tBodies[0];
+    if (!body) return;
+
+    const rows = Array.from(body.rows);
+    rows.sort((left, right) => {
+      const a = sortableValue(cellValue(left, index));
+      const b = sortableValue(cellValue(right, index));
+      if (a < b) return direction === "asc" ? -1 : 1;
+      if (a > b) return direction === "asc" ? 1 : -1;
+      return 0;
+    });
+
+    rows.forEach((row) => body.appendChild(row));
+  }
+
+  function installSortableTables() {
+    document.querySelectorAll("table[data-sortable='true']").forEach((table) => {
+      const headers = Array.from(table.tHead ? table.tHead.rows[0].cells : []);
+      headers.forEach((header, index) => {
+        header.dataset.sortableColumn = "true";
+        header.addEventListener("click", () => {
+          const nextDirection = header.dataset.sortDirection === "asc" ? "desc" : "asc";
+          headers.forEach((cell) => delete cell.dataset.sortDirection);
+          header.dataset.sortDirection = nextDirection;
+          sortTable(table, index, nextDirection);
+        });
+      });
+    });
+  }
+
+  if (document.readyState === "loading") {
+    document.addEventListener("DOMContentLoaded", installSortableTables);
+  } else {
+    installSortableTables();
+  }
+})();