rails-schema 0.1.6 → 0.1.8

data/lib/rails/schema/assets/app.js

@@ -23,6 +23,27 @@
       showThroughEdges = this.checked;
       render();
       if (selectedNode) selectNode(selectedNode);
+      autoSave();
+    });
+  }
+
+  // Freeze layout toggle — when enabled, all simulation forces are removed so
+  // nodes stay wherever they are dropped without being pushed by the simulation.
+  var manualPositioningCheckbox = document.getElementById("manual-positioning");
+  function removeAllForces() {
+    ["link", "charge", "center", "collide", "x", "y", "group"].forEach(function(name) {
+      simulation.force(name, null);
+    });
+  }
+  if (manualPositioningCheckbox) {
+    manualPositioningCheckbox.addEventListener("change", function () {
+      if (this.checked) {
+        removeAllForces();
+      } else {
+        render();
+        if (selectedNode) selectNode(selectedNode);
+      }
+      autoSave();
     });
   }
 
@@ -37,6 +58,114 @@
   var NODE_HEADER_HEIGHT = 36;
   var NODE_COLUMN_HEIGHT = 18;
   var NODE_PADDING = 8;
+  var VIEW_BADGE_WIDTH = 34;
+
+  // Layout persistence
+  function computeFingerprint() {
+    var ids = nodes.map(function(n) { return n.id; }).sort().join(",");
+    var hash = 5381;
+    for (var i = 0; i < ids.length; i++) {
+      hash = ((hash << 5) + hash + ids.charCodeAt(i)) & 0xffffffff;
+    }
+    return hash.toString(16);
+  }
+  var layoutStorageKey = "rails-schema-layout:" + computeFingerprint();
+
+  function serializeLayout() {
+    var positions = {};
+    nodes.forEach(function(n) {
+      if (n.x !== undefined && n.y !== undefined) {
+        positions[n.id] = { x: n.x, y: n.y };
+      }
+    });
+    return {
+      version: 1,
+      schemaFingerprint: computeFingerprint(),
+      nodePositions: positions,
+      visibleModels: Array.from(visibleModels),
+      zoomTransform: { k: zoomTransform.k, x: zoomTransform.x, y: zoomTransform.y },
+      collapsedGroups: Array.from(collapsedGroups),
+      manualPositioning: manualPositioningCheckbox ? manualPositioningCheckbox.checked : false,
+      showThroughEdges: showThroughEdges
+    };
+  }
+
+  function applyLayout(layout) {
+    if (!layout || layout.version !== 1) return;
+
+    var nodeIdSet = new Set(nodes.map(function(n) { return n.id; }));
+
+    // Restore visibility
+    if (layout.visibleModels) {
+      visibleModels.clear();
+      layout.visibleModels.forEach(function(id) {
+        if (nodeIdSet.has(id)) visibleModels.add(id);
+      });
+    }
+
+    // Restore collapsed groups
+    collapsedGroups.clear();
+    if (layout.collapsedGroups) {
+      layout.collapsedGroups.forEach(function(g) { collapsedGroups.add(g); });
+    }
+
+    // Restore through edges
+    if (layout.showThroughEdges !== undefined) {
+      showThroughEdges = layout.showThroughEdges;
+      if (throughCheckbox) throughCheckbox.checked = showThroughEdges;
+    }
+
+    // Rebuild with restored visibility
+    buildSidebar();
+    render();
+
+    var manual = !!layout.manualPositioning;
+
+    // Apply positions AFTER render created the simulation nodes. Pin with fx/fy
+    // only when restoring into manual mode; otherwise seed x/y as initial
+    // conditions and let the simulation evolve from there.
+    if (layout.nodePositions) {
+      nodes.forEach(function(n) {
+        var saved = layout.nodePositions[n.id];
+        if (saved) {
+          n.x = saved.x;
+          n.y = saved.y;
+          if (manual) {
+            n.fx = saved.x;
+            n.fy = saved.y;
+          } else {
+            n.fx = null;
+            n.fy = null;
+          }
+        }
+      });
+    }
+
+    if (manualPositioningCheckbox) {
+      manualPositioningCheckbox.checked = manual;
+    }
+    if (manual) {
+      removeAllForces();
+    }
+
+    // Update display
+    ticked();
+
+    // Restore zoom
+    if (layout.zoomTransform) {
+      var t = layout.zoomTransform;
+      var transform = d3.zoomIdentity.translate(t.x, t.y).scale(t.k);
+      svg.call(zoom.transform, transform);
+    }
+  }
+
+  function autoSave() {
+    try {
+      localStorage.setItem(layoutStorageKey, JSON.stringify(serializeLayout()));
+    } catch (e) {
+      // localStorage full or unavailable — silently ignore
+    }
+  }
 
   // Bezier curve tuning for edge routing
   var MIN_LOOP_OFFSET = 60;      // Minimum control-point distance for same-side (loop) edges
@@ -287,7 +416,8 @@
       .force("charge", d3.forceManyBody().strength(-600))
       .force("center", d3.forceCenter(svgEl.clientWidth / 2, svgEl.clientHeight / 2))
       .force("collide", d3.forceCollide().radius(function(d) { return Math.max(NODE_WIDTH, d._height) / 2 + 50; }))
-      .on("tick", ticked);
+      .on("tick", ticked)
+      .on("end", autoSave);
 
     if (config.grouping_enabled) {
       simulation
@@ -491,6 +621,9 @@
     currentSim = setupSimulation();
     renderEdges(currentSim.simEdges);
     renderNodes(currentSim.simNodes);
+    if (manualPositioningCheckbox && manualPositioningCheckbox.checked) {
+      removeAllForces();
+    }
   }
 
   function renderEdges(simEdges) {
@@ -575,7 +708,7 @@
 
     // Background rect
     nGroups.append("rect")
-      .attr("class", "node-rect")
+      .attr("class", function(d) { return "node-rect" + (d.view ? " is-view" : ""); })
       .attr("width", NODE_WIDTH)
       .attr("height", function(d) { return d._height; })
       .attr("x", -NODE_WIDTH / 2)
@@ -623,6 +756,24 @@
       .attr("dominant-baseline", "central")
       .text(function(d) { return truncateText(d.table_name, NODE_WIDTH - NODE_PADDING * 2, "10px " + getComputedStyle(document.body).fontFamily); });
 
+    // VIEW badge — a pill floating just above the node, centered, for view-backed models
+    var viewNodes = nGroups.filter(function(d) { return d.view; });
+    viewNodes.append("rect")
+      .attr("class", "node-view-badge-bg")
+      .attr("width", VIEW_BADGE_WIDTH)
+      .attr("height", 13)
+      .attr("rx", 3)
+      .attr("ry", 3)
+      .attr("x", -VIEW_BADGE_WIDTH / 2)
+      .attr("y", function(d) { return -d._height / 2 - 16; });
+    viewNodes.append("text")
+      .attr("class", "node-view-badge")
+      .attr("x", 0)
+      .attr("y", function(d) { return -d._height / 2 - 9; })
+      .attr("text-anchor", "middle")
+      .attr("dominant-baseline", "central")
+      .text("VIEW");
+
     // Columns
     nGroups.each(function(d) {
       var g = d3.select(this);
@@ -669,8 +820,10 @@
   }
 
   function ticked() {
-    layoutOrphans();
-    layoutSelfRefNodes();
+    if (!manualPositioningCheckbox?.checked) {
+      layoutOrphans();
+      layoutSelfRefNodes();
+    }
     edgeGroup.selectAll(".edge-group").each(function(d) {
       var g = d3.select(this);
       var src = d.source;
@@ -820,8 +973,11 @@
   function dragEnded(event, d) {
     if (isOrphan(d)) return;
     if (!event.active) simulation.alphaTarget(0);
-    d.fx = null;
-    d.fy = null;
+    if (!manualPositioningCheckbox?.checked) {
+      d.fx = null;
+      d.fy = null;
+    }
+    autoSave();
   }
 
   // Zoom
@@ -831,6 +987,7 @@
       zoomTransform = event.transform;
       container.attr("transform", event.transform);
       document.getElementById("zoom-info").textContent = Math.round(event.transform.k * 100) + "%";
+      autoSave();
     });
 
   svg.call(zoom);
@@ -870,6 +1027,7 @@
     render();
     selectNode(nodeId);
     setTimeout(fitToScreen, 100);
+    autoSave();
   }
 
   function deselectNode() {
@@ -895,7 +1053,9 @@
     html += '<h2 title="' + escapeHtml(node.id) + '">' + escapeHtml(node.id) + '</h2>';
     html += '<button id="detail-close" onclick="window.__closeDetail()">&times;</button>';
     html += '</div>';
-    html += '<div class="detail-table" title="' + escapeHtml(node.table_name) + '">' + escapeHtml(node.table_name) + '</div>';
+    html += '<div class="detail-table" title="' + escapeHtml(node.table_name) + '">' + escapeHtml(node.table_name);
+    if (node.view) html += ' <span class="detail-view-tag">VIEW</span>';
+    html += '</div>';
 
     html += '<h3>Columns</h3>';
     html += '<ul class="column-list">';
@@ -979,6 +1139,7 @@
       buildSidebar();
       render();
       setTimeout(fitToScreen, 100);
+      autoSave();
     });
 
     div.addEventListener("click", function(e) {
@@ -1039,6 +1200,7 @@
           buildSidebar();
           render();
           setTimeout(fitToScreen, 100);
+          autoSave();
         });
 
         var clickTimer = null;
@@ -1057,6 +1219,7 @@
             var nowCollapsed = collapsedGroups.has(groupKey);
             content.style.display = nowCollapsed ? "none" : "";
             toggle.innerHTML = nowCollapsed ? "&#9654;" : "&#9660;";
+            autoSave();
           }, 250);
         });
 
@@ -1073,6 +1236,7 @@
           buildSidebar();
           render();
           setTimeout(fitToScreen, 100);
+          autoSave();
         });
 
         return header;
@@ -1180,6 +1344,7 @@
     buildSidebar();
     render();
     setTimeout(fitToScreen, 100);
+    autoSave();
   });
 
   document.getElementById("deselect-all-btn").addEventListener("click", function() {
@@ -1187,6 +1352,7 @@
     buildSidebar();
     render();
     setTimeout(fitToScreen, 100);
+    autoSave();
   });
 
   // Collapse/Expand all groups
@@ -1221,6 +1387,7 @@
       document.querySelectorAll(".group-toggle").forEach(function(el) {
         el.innerHTML = shouldExpand ? "\u25BC" : "\u25B6";
       });
+      autoSave();
     });
   }
 
@@ -1372,13 +1539,64 @@
     triggerDownload(blob, "schema-diagram.mmd");
   }
 
+  // File menu dropdown
+  var fileMenuBtn = document.getElementById("file-menu-btn");
+  var fileMenu = document.getElementById("file-menu");
+  fileMenuBtn.addEventListener("click", function(e) {
+    e.stopPropagation();
+    fileMenu.classList.toggle("open");
+  });
+  document.addEventListener("click", function() {
+    fileMenu.classList.remove("open");
+  });
+
   // Export button listener
   document.getElementById("export-mermaid-btn").addEventListener("click", function() { exportMermaid(); });
 
+  // Save Layout
+  document.getElementById("save-layout-btn").addEventListener("click", function() {
+    var layout = serializeLayout();
+    var blob = new Blob([JSON.stringify(layout, null, 2)], { type: "application/json" });
+    var title = document.title.replace(/[^a-zA-Z0-9]/g, "-").replace(/-+/g, "-");
+    triggerDownload(blob, title + "-layout.json");
+  });
+
+  // Load Layout
+  var loadLayoutInput = document.getElementById("load-layout-input");
+  document.getElementById("load-layout-btn").addEventListener("click", function() {
+    loadLayoutInput.click();
+  });
+  loadLayoutInput.addEventListener("change", function() {
+    var file = this.files[0];
+    if (!file) return;
+    var reader = new FileReader();
+    reader.onload = function(e) {
+      try {
+        var layout = JSON.parse(e.target.result);
+        applyLayout(layout);
+        autoSave();
+      } catch (err) {
+        console.error("Failed to load layout:", err);
+      }
+    };
+    reader.readAsText(file);
+    this.value = "";
+  });
+
   // Init
   buildSidebar();
   render();
 
-  // Fit after simulation settles
-  setTimeout(function() { fitToScreen(); }, 1500);
+  // Restore saved layout or fit to screen
+  var savedLayout = null;
+  try {
+    var stored = localStorage.getItem(layoutStorageKey);
+    if (stored) savedLayout = JSON.parse(stored);
+  } catch (e) { /* ignore */ }
+
+  if (savedLayout) {
+    applyLayout(savedLayout);
+  } else {
+    setTimeout(function() { fitToScreen(); }, 1500);
+  }
 })();

data/lib/rails/schema/assets/style.css

@@ -142,11 +142,65 @@ body {
   margin: 0 4px;
 }
 
+#toolbar label.toolbar-label {
+  display: flex;
+  align-items: center;
+  gap: 4px;
+  font-size: 13px;
+  color: var(--text-secondary);
+  cursor: pointer;
+  white-space: nowrap;
+}
+
+#toolbar label.toolbar-label input[type="checkbox"] {
+  margin: 0;
+  cursor: pointer;
+  accent-color: var(--accent);
+}
+
 #toolbar .shortcuts-hint {
   font-size: 11px;
   color: var(--text-muted);
 }
 
+.toolbar-dropdown {
+  position: relative;
+}
+
+.toolbar-dropdown-menu {
+  display: none;
+  position: absolute;
+  top: 100%;
+  right: 0;
+  margin-top: 4px;
+  background: var(--bg-primary);
+  border: 1px solid var(--border-color);
+  border-radius: 6px;
+  box-shadow: 0 4px 12px rgba(0,0,0,0.15);
+  z-index: 300;
+  min-width: 160px;
+}
+
+.toolbar-dropdown-menu.open {
+  display: flex;
+  flex-direction: column;
+}
+
+.toolbar-dropdown-menu button {
+  border: none;
+  border-radius: 0;
+  text-align: left;
+  padding: 8px 12px;
+}
+
+.toolbar-dropdown-menu button:first-child {
+  border-radius: 6px 6px 0 0;
+}
+
+.toolbar-dropdown-menu button:last-of-type {
+  border-radius: 0 0 6px 6px;
+}
+
 /* Sidebar */
 #sidebar {
   width: var(--sidebar-width);
@@ -310,6 +364,22 @@ body {
   stroke-width: 2.5;
 }
 
+.node-rect.is-view {
+  stroke-dasharray: 5 3;
+}
+
+.node-view-badge-bg {
+  fill: var(--accent);
+}
+
+.node-view-badge {
+  fill: #ffffff;
+  font-size: 8px;
+  font-weight: 700;
+  letter-spacing: 0.5px;
+  font-family: inherit;
+}
+
 .node-header-rect {
   fill: var(--node-header-bg);
   rx: 8;
@@ -450,6 +520,18 @@ body {
   white-space: nowrap;
 }
 
+#detail-content .detail-view-tag {
+  display: inline-block;
+  font-size: 9px;
+  font-weight: 700;
+  letter-spacing: 0.5px;
+  color: var(--node-header-text);
+  background: var(--accent);
+  border-radius: 3px;
+  padding: 1px 5px;
+  vertical-align: middle;
+}
+
 #detail-content h3 {
   font-size: 13px;
   font-weight: 600;

data/lib/rails/schema/assets/template.html.erb

@@ -42,7 +42,17 @@
       <button id="fit-btn" title="Fit to screen (F)">Fit</button>
       <button id="theme-btn" title="Toggle theme">Theme</button>
       <span class="toolbar-divider"></span>
-      <button id="export-mermaid-btn" title="Export as Mermaid (Markdown)">Export Mermaid</button>
+      <label class="toolbar-label" for="manual-positioning"><input type="checkbox" id="manual-positioning">Manual Positioning</label>
+      <span class="toolbar-divider"></span>
+      <div class="toolbar-dropdown">
+        <button id="file-menu-btn">File &#9660;</button>
+        <div class="toolbar-dropdown-menu" id="file-menu">
+          <button id="export-mermaid-btn">Export Mermaid</button>
+          <button id="save-layout-btn">Save Layout</button>
+          <button id="load-layout-btn">Load Layout</button>
+          <input type="file" id="load-layout-input" accept=".json" style="display:none">
+        </div>
+      </div>
       <span class="shortcuts-hint">/ search · Esc deselect · F fit</span>
     </div>
 

data/lib/rails/schema/extractor/column_reader.rb

@@ -1,15 +1,20 @@
 # frozen_string_literal: true
 
+require "set"
+
 module Rails
   module Schema
     module Extractor
       class ColumnReader
-        def initialize(schema_data: nil)
+        def initialize(schema_data: nil, view_tables: nil)
           @schema_data = schema_data
+          @view_tables = view_tables ? Set.new(view_tables) : Set.new
         end
 
         def read(model)
-          if @schema_data&.key?(model.table_name)
+          if @view_tables.include?(model.table_name)
+            read_view(model)
+          elsif @schema_data&.key?(model.table_name)
             @schema_data[model.table_name]
           else
             read_from_model(model)
@@ -18,6 +23,16 @@ module Rails
 
         private
 
+        # Views have no column types in their DDL, so prefer live DB
+        # introspection (accurate names + types) and fall back to the parsed
+        # column names when no database connection is available.
+        def read_view(model)
+          from_db = read_from_model(model)
+          return from_db unless from_db.empty?
+
+          @schema_data&.fetch(model.table_name, []) || []
+        end
+
         def read_from_model(model)
           model.columns.map do |col|
             {

data/lib/rails/schema/extractor/schema_file_parser.rb

@@ -1,11 +1,19 @@
 # frozen_string_literal: true
 
+require "set"
+
 module Rails
   module Schema
     module Extractor
       class SchemaFileParser
+        # schema.rb does not declare SQL views, so this is always empty; the
+        # reader exists so SchemaFileParser and StructureSqlParser share an
+        # interface (see Rails::Schema.parse_schema).
+        attr_reader :views
+
         def initialize(schema_path = nil)
           @schema_path = schema_path
+          @views = Set.new
         end
 
         def parse

data/lib/rails/schema/extractor/structure_sql_parser.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "set"
+
 module Rails
   module Schema
     module Extractor
@@ -23,8 +25,14 @@ module Rails
         CONSTRAINT_RE = /\A(CONSTRAINT|UNIQUE|CHECK|EXCLUDE|FOREIGN\s+KEY)\b/i.freeze
         PK_CONSTRAINT_RE = /PRIMARY\s+KEY\s*\(([^)]+)\)/i.freeze
 
+        # Set of table names that are backed by SQL views (CREATE VIEW), not
+        # real tables. Populated by #parse / #parse_content. Lets downstream
+        # code badge view-backed models on the diagram.
+        attr_reader :views
+
         def initialize(structure_path = nil)
           @structure_path = structure_path
+          @views = Set.new
         end
 
         def parse
@@ -36,6 +44,7 @@ module Rails
 
         def parse_content(content)
           tables = {}
+          @views = Set.new
 
           content.scan(/CREATE\s+TABLE\s+(?:IF\s+NOT\s+EXISTS\s+)?([\w."]+)\s*\((.*?)\)\s*;/mi) do |table_name, body|
             name = extract_table_name(table_name)
@@ -44,11 +53,52 @@ module Rails
             tables[name] = columns
           end
 
+          parse_views(content, tables)
           tables
         end
 
         private
 
+        # Views carry no column-type information in their DDL, so offline we can
+        # only recover column names (from the SQLite hint comment or the SELECT
+        # list). ColumnReader prefers live DB introspection for views when a
+        # connection is available; these names are the offline fallback.
+        def parse_views(content, tables)
+          content.scan(/CREATE\s+VIEW\s+([\w."]+)\s+AS\b(.*?);/mi) do |raw_name, body|
+            name = extract_table_name(raw_name)
+            @views << name
+            tables[name] = view_columns(name, body)
+          end
+        end
+
+        def view_columns(name, body)
+          view_column_names(name, body).map do |col_name|
+            { name: col_name, type: "", nullable: true, default: nil, primary: false }
+          end
+        end
+
+        def view_column_names(name, body)
+          if (match = body.match(%r{/\*\s*#{Regexp.escape(name)}\s*\(([^)]*)\)\s*\*/}))
+            match[1].split(",").map { |c| unquote(c.strip) }
+          else
+            select_list_aliases(body)
+          end
+        end
+
+        def select_list_aliases(body)
+          match = body.match(/\bSELECT\b(.*?)\bFROM\b/mi)
+          return [] unless match
+
+          split_columns(match[1]).filter_map { |item| column_alias(item) }
+        end
+
+        def column_alias(item)
+          item = strip_comments(item).strip
+          return nil if item.empty? || item.include?("*")
+
+          item[/\bAS\s+"?(\w+)"?\s*\z/i, 1] || item[/"?(\w+)"?\s*\z/, 1]
+        end
+
         def resolve_path
           return @structure_path if @structure_path
           return ::Rails.root.join("db", "structure.sql").to_s if defined?(::Rails.root) && ::Rails.root
@@ -67,8 +117,8 @@ module Rails
         def parse_table_body(body)
           columns = []
           pk_columns = []
-          body.each_line do |raw|
-            line = raw.strip.chomp(",")
+          split_columns(body).each do |segment|
+            line = segment.strip
             next if line.empty?
 
             if (pk = extract_pk_constraint(line))
@@ -81,6 +131,50 @@ module Rails
           [columns, pk_columns]
         end
 
+        # Splits a table body on top-level commas, ignoring commas inside
+        # parentheses (e.g. decimal(5,4), FK clauses) or quoted strings. This
+        # handles both PostgreSQL (one column per line) and SQLite (whole table
+        # on a single line) structure.sql dumps.
+        def split_columns(body)
+          segments = []
+          current = +""
+          state = { depth: 0, squote: false, dquote: false }
+          strip_comments(body).each_char do |ch|
+            if split_point?(ch, state)
+              segments << current
+              current = +""
+            else
+              current << ch
+            end
+          end
+          segments << current
+        end
+
+        def split_point?(char, state)
+          toggle_quote(char, state)
+          return false if quoted?(state)
+
+          case char
+          when "(" then state[:depth] += 1
+          when ")" then state[:depth] -= 1
+          when "," then return state[:depth].zero?
+          end
+          false
+        end
+
+        def toggle_quote(char, state)
+          state[:squote] = !state[:squote] if char == "'" && !state[:dquote]
+          state[:dquote] = !state[:dquote] if char == '"' && !state[:squote]
+        end
+
+        def quoted?(state)
+          state[:squote] || state[:dquote]
+        end
+
+        def strip_comments(sql)
+          sql.gsub(%r{/\*.*?\*/}m, "")
+        end
+
         def extract_pk_constraint(line)
           return unless (match = line.match(PK_CONSTRAINT_RE))