rails-schema 0.1.7 → 0.1.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 06e278b737001f1ceeae2ef9d2014893a265125c7c011191a222a3d3fc48745e
-  data.tar.gz: '039a8aef58083c1ff5e023fee87e113c394a0dc1f008e37421460187f6fb3d44'
+  metadata.gz: d97a36c459cf91334bda4a6feb1bb99222432a71d75cf8fa368215facf465012
+  data.tar.gz: 5851a6d08e91c981fc15801a4cb805bb107079e8ede44c6ea5dc6da033302253
 SHA512:
-  metadata.gz: 17d59e29828e31ee3298a2f5b0f86b24d31240912b77668874f2be071c610f3af50641ebadaaf1c449d6cd532c0b5bdc4ac36c6137cdc15f5ca075a102c1a9e1
-  data.tar.gz: 979e7da7b4e3fb215b2f25095ae0eae96d6901efa5cb0915a5a76273571ec222ccc5fa41f2495e15126f3c01312a4096f5e44966a0b94c8e0fc59228dcb0b957
+  metadata.gz: 968db5097006071930a3972b96d7aa6b0a616133999aee055e45466612f6141dff125f6e38adb426c60dbf4dfc4ab31e1171613637577164a825e4db2be0684e
+  data.tar.gz: 735d4895a9e7b80ade035acfeab3439b810b572e5ff4835dfe1e0c2160d727aa59f9616910eecd72316813c448e429f40f50546ea33096b78f7b6ac1d3f4bd0e

data/CHANGELOG.md

@@ -4,6 +4,16 @@ All notable changes to this project will be documented in this file.
 
 The format is based on [Keep a Changelog](https://keepachangelog.com/), and this project adheres to [Semantic Versioning](https://semver.org/).
 
+## [0.1.8] - 2026-06-14
+
+### Added
+
+- SQL view support — models backed by a SQL view (`CREATE VIEW`, e.g. `self.table_name = "some_view"`) now appear on the diagram instead of being silently dropped. `StructureSqlParser` parses `CREATE VIEW` statements (column names from the SQLite hint comment or the `SELECT` list); columns are read from live DB introspection when a connection is available (accurate types) and fall back to the parsed names offline. View nodes are visually distinguished with a "VIEW" badge and a dashed border, plus a "VIEW" tag in the detail panel.
+
+### Fixed
+
+- SQLite `structure.sql` parsing — `StructureSqlParser` now correctly extracts all columns from SQLite-format dumps, which place the entire `CREATE TABLE` on a single line. Previously only the primary key was read (every model rendered with just its `id`). Column splitting is now parenthesis- and quote-aware, so commas inside type modifiers (`decimal(5,4)`), `FOREIGN KEY` clauses, and string literals no longer break parsing; inline C-style comments (`/* ... */`) are stripped. PostgreSQL `pg_dump` output continues to parse as before.
+
 ## [0.1.7] - 2026-04-25
 
 ### Added

data/CLAUDE.md

@@ -47,9 +47,10 @@ end
 ### Data Extraction Strategy
 
 1. **`db/schema.rb`** — `SchemaFileParser` parses with regex (table names, columns, types, nullable, defaults, PKs)
-2. **`db/structure.sql`** — `StructureSqlParser` parses SQL `CREATE TABLE` statements, maps SQL types to Rails types
+2. **`db/structure.sql`** — `StructureSqlParser` parses SQL `CREATE TABLE` statements, maps SQL types to Rails types. Column splitting is parenthesis/quote-aware (a top-level-comma splitter), so it handles both PostgreSQL `pg_dump` (one column per line) and SQLite (whole table on one line) dumps. Also parses `CREATE VIEW` statements — view names go into `#views` (a Set), and view column names come from the SQLite hint comment (`/* viewname(col,...) */`) or the `SELECT` list
 3. **ActiveRecord reflection API** — `AssociationReader` uses `reflect_on_all_associations` for associations
 4. **`Model.columns`** — `ColumnReader` falls back to this when table not found in schema_data
+5. **SQL views** — `parse_schema` returns `[columns, view_names]`. `ColumnReader.new(view_tables:)` reads view columns from live DB introspection first (accurate types), falling back to the parsed names offline. `GraphBuilder.new(view_tables:)` sets `Node#view`, which the frontend renders with a "VIEW" badge + dashed border. Views are always included (no config flag); the model just needs `self.table_name` pointing at the view
 
 ### Model Discovery
 

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

@@ -58,6 +58,7 @@
   var NODE_HEADER_HEIGHT = 36;
   var NODE_COLUMN_HEIGHT = 18;
   var NODE_PADDING = 8;
+  var VIEW_BADGE_WIDTH = 34;
 
   // Layout persistence
   function computeFingerprint() {
@@ -707,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)
@@ -755,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);
@@ -1034,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">';

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

@@ -364,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;
@@ -504,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/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))
 

data/lib/rails/schema/transformer/graph_builder.rb

@@ -7,10 +7,11 @@ module Rails
     module Transformer
       class GraphBuilder
         def initialize(column_reader: Extractor::ColumnReader.new, association_reader: Extractor::AssociationReader.new,
-                       configuration: ::Rails::Schema.configuration)
+                       configuration: ::Rails::Schema.configuration, view_tables: nil)
           @column_reader = column_reader
           @association_reader = association_reader
           @group_proc = configuration.resolved_group_proc
+          @view_tables = view_tables ? Set.new(view_tables) : Set.new
         end
 
         def build(models)
@@ -47,7 +48,8 @@ module Rails
             id: unique_id,
             table_name: model.table_name,
             columns: @column_reader.read(model),
-            group: group
+            group: group,
+            view: @view_tables.include?(model.table_name)
           )
         end
 

data/lib/rails/schema/transformer/node.rb

@@ -4,18 +4,20 @@ module Rails
   module Schema
     module Transformer
       class Node
-        attr_reader :id, :table_name, :columns, :group
+        attr_reader :id, :table_name, :columns, :group, :view
 
-        def initialize(id:, table_name:, columns: [], group: [])
+        def initialize(id:, table_name:, columns: [], group: [], view: false)
           @id = id
           @table_name = table_name
           @columns = columns
           @group = group
+          @view = view
         end
 
         def to_h
           h = { id: @id, table_name: @table_name, columns: @columns }
           h[:group] = @group unless @group.empty?
+          h[:view] = true if @view
           h
         end
       end

data/lib/rails/schema/version.rb

@@ -2,6 +2,6 @@
 
 module Rails
   module Schema
-    VERSION = "0.1.7"
+    VERSION = "0.1.8"
   end
 end

data/lib/rails/schema.rb

@@ -52,10 +52,10 @@ module Rails
       private
 
       def generate_active_record(output:)
-        schema_data = parse_schema
+        schema_data, views = parse_schema
         models = Extractor::ModelScanner.new(schema_data: schema_data).scan
-        column_reader = Extractor::ColumnReader.new(schema_data: schema_data)
-        graph_data = Transformer::GraphBuilder.new(column_reader: column_reader).build(models)
+        column_reader = Extractor::ColumnReader.new(schema_data: schema_data, view_tables: views)
+        graph_data = Transformer::GraphBuilder.new(column_reader: column_reader, view_tables: views).build(models)
         graph_data[:metadata][:mode] = "active_record"
         generator = Renderer::HtmlGenerator.new(graph_data: graph_data)
         generator.render_to_file(output)
@@ -84,17 +84,24 @@ module Rails
         generator.render_to_file(output)
       end
 
+      # Returns [columns_by_table, view_table_names]. For :auto, falls through
+      # to structure.sql when schema.rb yields nothing.
       def parse_schema
         case configuration.schema_format
         when :ruby
-          Extractor::SchemaFileParser.new.parse
+          parse_with(Extractor::SchemaFileParser.new)
         when :sql
-          Extractor::StructureSqlParser.new.parse
+          parse_with(Extractor::StructureSqlParser.new)
         when :auto
-          data = Extractor::SchemaFileParser.new.parse
-          data.empty? ? Extractor::StructureSqlParser.new.parse : data
+          columns, views = parse_with(Extractor::SchemaFileParser.new)
+          columns.empty? ? parse_with(Extractor::StructureSqlParser.new) : [columns, views]
         end
       end
+
+      def parse_with(parser)
+        columns = parser.parse
+        [columns, parser.views]
+      end
     end
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rails-schema
 version: !ruby/object:Gem::Version
-  version: 0.1.7
+  version: 0.1.8
 platform: ruby
 authors:
 - Andrei Kislichenko