rails-wayback 0.1.0 → 0.2.0

data/lib/rails_wayback/bar_renderer.rb

@@ -1,54 +1,38 @@
 # frozen_string_literal: true
 
-require "json"
 require "cgi"
+require "erb"
+require "rails_wayback/version"
 
 module RailsWayback
-  # Builds the HTML/CSS/JS payload that the middleware injects into
-  # every HTML response so the developer can travel from any page of
-  # their app without visiting a dedicated route.
+  # Builds the HTML payload that the middleware injects into every HTML
+  # response and references the toolbar's same-origin CSS and JavaScript.
   class BarRenderer
+    TEMPLATE = ERB.new(File.read(File.expand_path("bar_renderer.html.erb", __dir__))).freeze
+    STYLES = File.read(File.expand_path("bar_renderer.css", __dir__)).freeze
+    SEARCH_SCRIPT = File.read(File.expand_path("bar_search.js", __dir__)).freeze
+    SCRIPT = [SEARCH_SCRIPT, File.read(File.expand_path("bar_renderer.js", __dir__))].join("\n").freeze
+
     def initialize(current_branch:, current_commit:, active_ref: nil, active_branch: nil,
-                   engine_mount: "/rails-wayback", diff_info: nil)
+                   engine_mount: "/rails-wayback", diff_info: nil, csp_nonce: nil, ref_error: nil)
       @current_branch = current_branch
       @current_commit = current_commit
       @active_ref = active_ref
       @active_branch = active_branch
-      @engine_mount = engine_mount
+      @engine_mount = normalize_mount(engine_mount)
       @diff_info = diff_info
+      @csp_nonce = csp_nonce.to_s
+      @ref_error = ref_error.to_s
     end
 
     def render
-      <<~HTML
-        <style data-rails-wayback>#{styles}</style>
-        <div id="rails-wayback-bar" data-mount="#{escape(@engine_mount)}"
-             data-branch="#{escape(@current_branch)}"
-             data-commit="#{escape(@current_commit)}"
-             data-active-ref="#{escape(@active_ref.to_s)}"
-             data-active-branch="#{escape(@active_branch.to_s)}">
-          <div class="rw-bar-inner">
-            <div class="rw-field">
-              <label>#{escape(branch_label)}</label>
-              <select data-rw-branch></select>
-            </div>
-            <div class="rw-field rw-flex">
-              <label>#{escape(commit_label)}</label>
-              <select data-rw-commit></select>
-            </div>
-            <div class="rw-state" data-rw-state></div>
-            <button type="button" data-rw-travel class="rw-btn rw-btn-primary">Travel</button>
-            <button type="button" data-rw-reset  class="rw-btn rw-btn-ghost" hidden>Return to HEAD</button>
-          </div>
-          #{diff_summary_html}
-        </div>
-        <script data-rails-wayback>#{script}</script>
-      HTML
+      TEMPLATE.result(binding)
     end
 
     private
 
     def branch_label
-      @active_ref ? "Rendering branch" : "Current branch"
+      @active_ref ? "Rendering ref" : "Current ref"
     end
 
     def commit_label
@@ -87,12 +71,51 @@ module RailsWayback
 
       <<~HTML.strip
         <div class="#{css_class}">
+          #{provenance_html}
+          #{asset_provenance_html}
           <span class="rw-diff-msg">#{escape(message)}</span>
           #{list_html}
         </div>
       HTML
     end
 
+    def provenance_html
+      historical = Array(@diff_info[:rendered_from_ref])
+      current = Array(@diff_info[:rendered_from_current])
+
+      message, css_class = case @diff_info[:preview_mode]&.to_sym
+                           when :mixed
+                             ["Mixed preview: #{count_label(historical.size, "historical template")}, " \
+                              "#{count_label(current.size, "current fallback")}.", "rw-provenance-mixed"]
+                           when :historical
+                             ["Historical preview: #{count_label(historical.size, "historical template")}.",
+                              "rw-provenance-historical"]
+                           when :current_fallback
+                             ["Current fallback: no historical templates rendered " \
+                              "(#{count_label(current.size, "current template")}).", "rw-provenance-current"]
+                           else
+                             return ""
+                           end
+
+      %(<span class="rw-provenance #{css_class}">#{escape(message)}</span>)
+    end
+
+    def count_label(count, singular)
+      "#{count} #{singular}#{"s" unless count == 1}"
+    end
+
+    def asset_provenance_html
+      historical = Array(@diff_info[:historical_assets])
+      current = Array(@diff_info[:current_asset_fallbacks])
+      return "" if historical.empty? && current.empty?
+
+      labels = []
+      labels << count_label(historical.size, "historical asset") if historical.any?
+      labels << count_label(current.size, "current asset fallback") if current.any?
+      css_class = current.any? ? "rw-provenance-mixed" : "rw-provenance-historical"
+      %(<span class="rw-provenance #{css_class}">Assets: #{escape(labels.join(", "))}.</span>)
+    end
+
     def diff_details(summary, files)
       items = files.map { |f| %(<li>#{escape(f)}</li>) }.join
       <<~HTML.strip
@@ -103,199 +126,28 @@ module RailsWayback
       HTML
     end
 
-    def styles
-      <<~CSS
-        #rails-wayback-bar {
-          position: fixed; left: 0; right: 0; bottom: 0; z-index: 2147483000;
-          font-family: ui-monospace, SFMono-Regular, Menlo, Consolas, monospace;
-          font-size: 12px; color: #e6e9ef;
-          background: rgba(15, 17, 21, 0.96);
-          border-top: 1px solid #2a2f3a;
-          box-shadow: 0 -8px 20px rgba(0,0,0,.35);
-        }
-        #rails-wayback-bar * { box-sizing: border-box; }
-        #rails-wayback-bar .rw-bar-inner {
-          display: flex; align-items: end; gap: 12px; padding: 8px 12px;
-        }
-        #rails-wayback-bar .rw-field { display: flex; flex-direction: column; gap: 3px; min-width: 180px; }
-        #rails-wayback-bar .rw-flex { flex: 1; }
-        #rails-wayback-bar label {
-          color: #8a93a6; text-transform: uppercase; letter-spacing: .06em; font-size: 10px;
-        }
-        #rails-wayback-bar select {
-          background: #0b0d12; color: #e6e9ef;
-          border: 1px solid #2a2f3a; border-radius: 4px;
-          padding: 5px 8px; font-family: inherit; font-size: 12px; width: 100%;
-        }
-        #rails-wayback-bar .rw-state { color: #8a93a6; font-size: 11px; margin: 0 4px; }
-        #rails-wayback-bar .rw-state.rw-active { color: #ffd479; }
-        #rails-wayback-bar .rw-btn {
-          border: 0; border-radius: 4px; padding: 8px 14px; cursor: pointer;
-          font-family: inherit; font-size: 12px; font-weight: 600;
-        }
-        #rails-wayback-bar .rw-btn-primary { background: #6ea8fe; color: #0b0d12; }
-        #rails-wayback-bar .rw-btn-ghost   { background: transparent; color: #8a93a6; border: 1px solid #2a2f3a; }
-        #rails-wayback-bar .rw-btn:disabled { opacity: .5; cursor: not-allowed; }
-        #rails-wayback-bar .rw-diff {
-          border-top: 1px solid #2a2f3a;
-          padding: 6px 12px; font-size: 11px; color: #8a93a6;
-          display: flex; align-items: center; gap: 10px; flex-wrap: wrap;
-        }
-        #rails-wayback-bar .rw-diff-match .rw-diff-msg { color: #7ee787; }
-        #rails-wayback-bar .rw-diff-miss  .rw-diff-msg { color: #ffd479; }
-        #rails-wayback-bar .rw-diff-neutral .rw-diff-msg { color: #8a93a6; }
-        #rails-wayback-bar .rw-diff-details { color: #8a93a6; }
-        #rails-wayback-bar .rw-diff-details summary {
-          cursor: pointer; user-select: none;
-        }
-        #rails-wayback-bar .rw-diff-details[open] {
-          flex-basis: 100%;
-        }
-        #rails-wayback-bar .rw-diff-details ul {
-          margin: 6px 0 0; padding: 6px 10px; list-style: none;
-          background: #0b0d12; border: 1px solid #2a2f3a; border-radius: 4px;
-          max-height: 200px; overflow: auto;
-          font-family: inherit; font-size: 11px;
-        }
-        #rails-wayback-bar .rw-diff-details li { padding: 2px 0; color: #c8cfdc; }
-        body { padding-bottom: 56px !important; }
-        body:has(#rails-wayback-bar .rw-diff) { padding-bottom: 88px !important; }
-      CSS
+    def stylesheet_url
+      asset_url("bar.css")
     end
 
-    def script
-      <<~JS
-        (function () {
-          var bar = document.getElementById("rails-wayback-bar");
-          if (!bar) return;
-
-          var mount     = bar.dataset.mount;
-          var headBranch = bar.dataset.branch;
-          var headCommit = bar.dataset.commit;
-          var activeRef  = bar.dataset.activeRef || "";
-          var activeBranch = bar.dataset.activeBranch || "";
-          // While traveling, reflect the ref's branch/commit in the
-          // dropdowns instead of the developer's local HEAD, so the bar
-          // matches what is actually being rendered.
-          var selectedBranch = activeBranch || headBranch;
-          var selectedCommit = activeRef || headCommit;
-
-          var branchSel = bar.querySelector("[data-rw-branch]");
-          var commitSel = bar.querySelector("[data-rw-commit]");
-          var stateEl   = bar.querySelector("[data-rw-state]");
-          var travelBtn = bar.querySelector("[data-rw-travel]");
-          var resetBtn  = bar.querySelector("[data-rw-reset]");
-
-          function setState() {
-            if (activeRef) {
-              var label = activeBranch
-                ? activeBranch + "@" + activeRef.slice(0, 7)
-                : activeRef.slice(0, 7);
-              stateEl.textContent = "Traveling: " + label;
-              stateEl.classList.add("rw-active");
-              resetBtn.hidden = false;
-            } else {
-              stateEl.textContent = "Live";
-              stateEl.classList.remove("rw-active");
-              resetBtn.hidden = true;
-            }
-          }
-
-          function showError(msg) {
-            stateEl.textContent = msg;
-            stateEl.classList.add("rw-active");
-          }
-
-          function loadBranches() {
-            fetch(mount + "/branches", { headers: { Accept: "application/json" } })
-              .then(function (r) {
-                if (!r.ok) throw new Error("HTTP " + r.status + " on /branches");
-                return r.json();
-              })
-              .then(function (data) {
-                branchSel.innerHTML = "";
-                (data.branches || []).forEach(function (b) {
-                  var opt = document.createElement("option");
-                  opt.value = b; opt.textContent = b;
-                  if (b === selectedBranch) opt.selected = true;
-                  branchSel.appendChild(opt);
-                });
-                if ((data.errors || []).length > 0) showError(data.errors.join(" | "));
-                if (branchSel.value) loadCommits(branchSel.value);
-              })
-              .catch(function (err) {
-                showError("branches: " + err.message);
-              });
-          }
-
-          function loadCommits(branch) {
-            travelBtn.disabled = true;
-            fetch(mount + "/commits/" + encodeURI(branch), { headers: { Accept: "application/json" } })
-              .then(function (r) {
-                if (!r.ok) throw new Error("HTTP " + r.status + " on /commits/" + branch);
-                return r.json();
-              })
-              .then(function (data) {
-                commitSel.innerHTML = "";
-                (data.commits || []).forEach(function (c) {
-                  var opt = document.createElement("option");
-                  opt.value = c.sha;
-                  opt.textContent = c.short_sha + " — " + (c.subject || "").slice(0, 80);
-                  if (c.sha === selectedCommit) opt.selected = true;
-                  commitSel.appendChild(opt);
-                });
-                if (data.error) {
-                  showError("commits: " + data.error);
-                } else if (!activeRef) {
-                  setState();
-                }
-                travelBtn.disabled = !commitSel.value;
-              })
-              .catch(function (err) {
-                showError("commits: " + err.message);
-              });
-          }
-
-          function setCookie(name, value) {
-            document.cookie = name + "=" + encodeURIComponent(value) + "; Path=/; SameSite=Lax";
-          }
-
-          function clearCookie(name) {
-            document.cookie = name + "=; Path=/; Max-Age=0; SameSite=Lax";
-          }
+    def javascript_url
+      asset_url("bar.js")
+    end
 
-          // Travel is a *session*, not a one-off request: the ref lives
-          // in a cookie so it survives every subsequent link click. The
-          // URL params are added just so a first-time landing (or a
-          // shared link) still works even before the cookie is set.
-          function travel() {
-            var sha = commitSel.value;
-            if (!sha) return;
-            setCookie("rails_wayback_ref", sha);
-            if (branchSel.value) setCookie("rails_wayback_branch", branchSel.value);
-            var url = new URL(window.location.href);
-            url.searchParams.set("_wayback_ref", sha);
-            if (branchSel.value) url.searchParams.set("_wayback_branch", branchSel.value);
-            window.location.assign(url.toString());
-          }
+    def asset_url(filename)
+      "#{@engine_mount}/assets/#{filename}?v=#{RailsWayback::VERSION}"
+    end
 
-          function reset() {
-            clearCookie("rails_wayback_ref");
-            clearCookie("rails_wayback_branch");
-            var url = new URL(window.location.href);
-            url.searchParams.delete("_wayback_ref");
-            url.searchParams.delete("_wayback_branch");
-            window.location.assign(url.toString());
-          }
+    def nonce_attribute
+      return "" if @csp_nonce.empty?
 
-          branchSel.addEventListener("change", function (e) { loadCommits(e.target.value); });
-          travelBtn.addEventListener("click", travel);
-          resetBtn.addEventListener("click", reset);
+      %( nonce="#{escape(@csp_nonce)}")
+    end
 
-          setState();
-          loadBranches();
-        })();
-      JS
+    def normalize_mount(value)
+      mount = value.to_s
+      mount = "/rails-wayback" if mount.empty?
+      mount.sub(%r{/+\z}, "")
     end
   end
 end

data/lib/rails_wayback/bar_search.js

@@ -0,0 +1,73 @@
+(function (root, factory) {
+  const search = factory();
+
+  if (typeof module !== "undefined" && module.exports) module.exports = search;
+  if (root) root.RailsWaybackSearch = search;
+})(typeof globalThis !== "undefined" ? globalThis : this, function () {
+  function normalizeQuery(value) {
+    return String(value || "").trim().toLocaleLowerCase();
+  }
+
+  function searchableText(item, fields) {
+    return fields.map(function (field) {
+      return String(item[field] || "");
+    }).join(" ").toLocaleLowerCase();
+  }
+
+  function preserveSelection(items, matches, selected, valueField) {
+    const selectedValue = String(selected || "");
+    if (!selectedValue || matches.some(function (item) {
+      return String(item[valueField] || "") === selectedValue;
+    })) return matches;
+
+    const selectedItem = items.find(function (item) {
+      return String(item[valueField] || "") === selectedValue;
+    });
+    if (!selectedItem) return matches;
+
+    return items.filter(function (item) {
+      return item === selectedItem || matches.indexOf(item) !== -1;
+    });
+  }
+
+  function search(items, query, selected, fields, valueField) {
+    const collection = Array.isArray(items) ? items : [];
+    const normalized = normalizeQuery(query);
+    const matches = normalized
+      ? collection.filter(function (item) {
+        return searchableText(item, fields).includes(normalized);
+      })
+      : collection.slice();
+
+    return {
+      matches: matches,
+      visible: preserveSelection(collection, matches, selected, valueField)
+    };
+  }
+
+  function searchReferences(references, query, selected) {
+    return search(
+      references,
+      query,
+      selected,
+      ["full_name", "name", "label", "type"],
+      "full_name"
+    );
+  }
+
+  function searchCommits(commits, query, selected) {
+    return search(
+      commits,
+      query,
+      selected,
+      ["sha", "short_sha", "subject", "author", "date"],
+      "sha"
+    );
+  }
+
+  return {
+    normalizeQuery: normalizeQuery,
+    searchReferences: searchReferences,
+    searchCommits: searchCommits
+  };
+});

data/lib/rails_wayback/cache_inventory.rb

@@ -0,0 +1,199 @@
+# frozen_string_literal: true
+
+require "find"
+require "fileutils"
+require "json"
+require "pathname"
+require "time"
+
+module RailsWayback
+  # Reads cache metadata and applies explicit LRU pruning policies.
+  class CacheInventory
+    MATERIALIZATION_VERSION = "4"
+    METADATA_VERSION = 1
+    MARKER_NAME = ".rails_wayback.sha"
+    METADATA_NAME = ".rails_wayback.meta.json"
+    SHA_PATTERN = /\A(?:[0-9a-f]{40}|[0-9a-f]{64})\z/i
+
+    Entry = Struct.new(
+      :sha, :path, :size_bytes, :file_count, :last_accessed_at, :valid,
+      keyword_init: true
+    ) do
+      def valid?
+        valid
+      end
+    end
+
+    Snapshot = Struct.new(:refs, keyword_init: true) do
+      def ref_count
+        refs.size
+      end
+
+      def size_bytes
+        refs.sum(&:size_bytes)
+      end
+
+      def file_count
+        refs.sum(&:file_count)
+      end
+    end
+
+    PruneResult = Struct.new(:removed, :snapshot, :limits_satisfied, keyword_init: true) do
+      def removed_size_bytes
+        removed.sum(&:size_bytes)
+      end
+
+      def limits_satisfied?
+        limits_satisfied
+      end
+    end
+
+    def initialize(configuration: RailsWayback.configuration)
+      @configuration = configuration
+    end
+
+    def snapshot
+      Snapshot.new(refs: entry_paths.filter_map { |path| build_entry(path) })
+    end
+
+    def write_metadata(path, sha)
+      size_bytes, file_count = measure(path)
+      payload = {
+        metadata_version: METADATA_VERSION,
+        materialization_version: MATERIALIZATION_VERSION,
+        sha: sha,
+        size_bytes: size_bytes,
+        file_count: file_count,
+        created_at: Time.now.utc.iso8601
+      }
+      metadata_path(path).write(JSON.generate(payload))
+    end
+
+    # Caller must hold the cache's exclusive lock.
+    def prune!(preserve: [])
+      preserved = Array(preserve).map(&:to_s)
+      entries = snapshot.refs
+      removed = remove_invalid(entries, preserved)
+      remaining = entries - removed
+
+      removable = remaining.reject { |entry| preserved.include?(entry.sha) }
+                           .sort_by { |entry| [entry.last_accessed_at, entry.sha] }
+      while limits_exceeded?(remaining) && removable.any?
+        entry = removable.shift
+        remove_entry(entry)
+        removed << entry
+        remaining.delete(entry)
+      end
+
+      final_snapshot = Snapshot.new(refs: remaining)
+      PruneResult.new(
+        removed: removed,
+        snapshot: final_snapshot,
+        limits_satisfied: !limits_exceeded?(remaining)
+      )
+    end
+
+    private
+
+    attr_reader :configuration
+
+    def entry_paths
+      root = configuration.refs_cache_path
+      return [] unless root.directory?
+
+      root.children.sort_by { |path| path.basename.to_s }.select do |path|
+        path.basename.to_s.match?(SHA_PATTERN) && File.lstat(path).directory?
+      rescue SystemCallError
+        false
+      end
+    end
+
+    def build_entry(path)
+      sha = path.basename.to_s.downcase
+      marker = marker_path(path)
+      valid = marker.file? && marker.read.strip == "#{MATERIALIZATION_VERSION}:#{sha}"
+      size_bytes, file_count = stored_metrics(path, sha) || measure(path)
+      accessed = marker.file? ? marker.mtime : path.mtime
+      Entry.new(
+        sha: sha,
+        path: path,
+        size_bytes: size_bytes,
+        file_count: file_count,
+        last_accessed_at: accessed,
+        valid: valid
+      )
+    rescue SystemCallError
+      nil
+    end
+
+    def stored_metrics(path, sha)
+      metadata = metadata_path(path)
+      return unless metadata.file?
+
+      payload = JSON.parse(metadata.read)
+      return unless payload["metadata_version"] == METADATA_VERSION
+      return unless payload["materialization_version"] == MATERIALIZATION_VERSION
+      return unless payload["sha"] == sha
+
+      size_bytes = Integer(payload["size_bytes"])
+      file_count = Integer(payload["file_count"])
+      return if size_bytes.negative? || file_count.negative?
+
+      [size_bytes, file_count]
+    rescue JSON::ParserError, ArgumentError, TypeError
+      nil
+    end
+
+    def measure(path)
+      size_bytes = 0
+      file_count = 0
+      Find.find(path.to_s) do |entry_path|
+        stat = File.lstat(entry_path)
+        next if stat.directory?
+        next if [marker_path(path).to_s, metadata_path(path).to_s].include?(entry_path)
+
+        size_bytes += stat.size
+        file_count += 1
+      end
+      [size_bytes, file_count]
+    end
+
+    def remove_invalid(entries, preserved)
+      entries.reject(&:valid?).reject { |entry| preserved.include?(entry.sha) }.each do |entry|
+        remove_entry(entry)
+      end
+    end
+
+    def remove_entry(entry)
+      FileUtils.rm_rf(entry.path)
+      FileUtils.rm_f(configuration.cache_root_path.join("locks", "#{entry.sha}.lock"))
+      return unless entry.path.exist?
+
+      raise MaterializationError, "Could not remove cached ref #{entry.sha}"
+    end
+
+    def limits_exceeded?(entries)
+      count_limit = normalized_limit(configuration.max_cached_refs)
+      byte_limit = normalized_limit(configuration.max_cache_bytes)
+      count_exceeded = count_limit && entries.size > count_limit
+      bytes_exceeded = byte_limit && entries.sum(&:size_bytes) > byte_limit
+      count_exceeded || bytes_exceeded
+    end
+
+    def normalized_limit(value)
+      return if value.nil?
+
+      [Integer(value), 0].max
+    rescue ArgumentError, TypeError
+      0
+    end
+
+    def marker_path(path)
+      path.join(MARKER_NAME)
+    end
+
+    def metadata_path(path)
+      path.join(METADATA_NAME)
+    end
+  end
+end