rails-schema 0.1.0 → 0.1.2

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

@@ -16,13 +16,66 @@
   var NODE_COLUMN_HEIGHT = 18;
   var NODE_PADDING = 8;
 
+  // Bezier curve tuning for edge routing
+  var MIN_LOOP_OFFSET = 60;      // Minimum control-point distance for same-side (loop) edges
+  var LOOP_OFFSET_RATIO = 0.5;   // Proportion of vertical gap used for loop curve spread
+  var MIN_CURVE_OFFSET = 50;     // Minimum control-point distance for opposite-side edges
+  var CURVE_OFFSET_RATIO = 0.4;  // Proportion of horizontal gap used for curve spread
+
   // Setup SVG
   var svgEl = document.getElementById("schema-svg");
   var svg = d3.select(svgEl);
+  var defs = svg.append("defs");
   var container = svg.append("g").attr("class", "zoom-container");
   var edgeGroup = container.append("g").attr("class", "edges");
   var nodeGroup = container.append("g").attr("class", "nodes");
 
+  // Marker definitions for crow's foot notation
+  var MARKER_TYPES = {
+    belongs_to: "--edge-belongs-to",
+    has_many: "--edge-has-many",
+    has_one: "--edge-has-one",
+    has_and_belongs_to_many: "--edge-habtm"
+  };
+
+  function buildMarkers() {
+    defs.selectAll("marker").remove();
+    var cs = getComputedStyle(document.documentElement);
+    Object.keys(MARKER_TYPES).forEach(function(type) {
+      var color = cs.getPropertyValue(MARKER_TYPES[type]).trim();
+
+      // "one" marker: perpendicular bar
+      var one = defs.append("marker")
+        .attr("id", "marker-one-" + type)
+        .attr("viewBox", "0 0 4 10")
+        .attr("refX", 4).attr("refY", 5)
+        .attr("markerWidth", 4).attr("markerHeight", 10)
+        .attr("markerUnits", "userSpaceOnUse")
+        .attr("orient", "auto-start-reverse");
+      one.append("path")
+        .attr("d", "M 4 0 L 4 10")
+        .attr("stroke", color)
+        .attr("stroke-width", 1.5)
+        .attr("fill", "none");
+
+      // "many" marker: crow's foot (three tines)
+      var many = defs.append("marker")
+        .attr("id", "marker-many-" + type)
+        .attr("viewBox", "0 0 10 10")
+        .attr("refX", 10).attr("refY", 5)
+        .attr("markerWidth", 10).attr("markerHeight", 10)
+        .attr("markerUnits", "userSpaceOnUse")
+        .attr("orient", "auto-start-reverse");
+      many.append("path")
+        .attr("d", "M 10 5 L 0 0 M 10 5 L 0 10 M 10 5 L 0 5")
+        .attr("stroke", color)
+        .attr("stroke-width", 1.5)
+        .attr("fill", "none");
+    });
+  }
+
+  buildMarkers();
+
   // Compute node heights
   nodes.forEach(function(n) {
     var cols = config.expand_columns ? n.columns : n.columns.slice(0, 4);
@@ -31,6 +84,20 @@
     if (!config.expand_columns && n.columns.length > 4) {
       n._height += NODE_COLUMN_HEIGHT; // "+N more" row
     }
+
+    // Build column y-offset map (from node center)
+    n._colYMap = {};
+    var startY = -n._height / 2 + NODE_HEADER_HEIGHT + NODE_PADDING;
+    cols.forEach(function(col, i) {
+      n._colYMap[col.name] = startY + i * NODE_COLUMN_HEIGHT + 10;
+    });
+
+    // Store "+N more" row y-offset for collapsed column fallback
+    if (!config.expand_columns && n.columns.length > 4) {
+      n._moreRowY = startY + cols.length * NODE_COLUMN_HEIGHT + 10;
+    } else {
+      n._moreRowY = null;
+    }
   });
 
   // Build adjacency for focus
@@ -41,6 +108,76 @@
     if (adjacency[e.to]) adjacency[e.to].add(e.from);
   });
 
+  // Marker assignment per association type
+  var MARKER_MAP = {
+    belongs_to:              { start: "many", end: "one" },
+    has_many:                { start: "one",  end: "many" },
+    has_one:                 { start: "one",  end: "one" },
+    has_and_belongs_to_many: { start: "many", end: "many" }
+  };
+
+  function getColumnY(node, colName) {
+    if (colName && node._colYMap[colName] !== undefined) {
+      return node._colYMap[colName];
+    }
+    if (node._moreRowY !== null) return node._moreRowY;
+    return 0;
+  }
+
+  function getPkColumnY(node) {
+    for (var i = 0; i < node._displayCols.length; i++) {
+      if (node._displayCols[i].primary) {
+        return node._colYMap[node._displayCols[i].name];
+      }
+    }
+    if (node._moreRowY !== null) return node._moreRowY;
+    return 0;
+  }
+
+  function getConnectionPoints(d) {
+    var src = d.source;
+    var tgt = d.target;
+    var assocType = d.data.association_type;
+    var fk = d.data.foreign_key;
+    var srcColY = 0;
+    var tgtColY = 0;
+
+    if (assocType === "belongs_to") {
+      srcColY = getColumnY(src, fk);
+      tgtColY = getPkColumnY(tgt);
+    } else if (assocType === "has_many" || assocType === "has_one") {
+      srcColY = getPkColumnY(src);
+      tgtColY = getColumnY(tgt, fk);
+    } else {
+      srcColY = getPkColumnY(src);
+      tgtColY = getPkColumnY(tgt);
+    }
+
+    var dx = tgt.x - src.x;
+    var srcX, tgtX, sameDirection;
+
+    if (Math.abs(dx) > NODE_WIDTH) {
+      sameDirection = false;
+      if (dx > 0) {
+        srcX = src.x + NODE_WIDTH / 2;
+        tgtX = tgt.x - NODE_WIDTH / 2;
+      } else {
+        srcX = src.x - NODE_WIDTH / 2;
+        tgtX = tgt.x + NODE_WIDTH / 2;
+      }
+    } else {
+      sameDirection = true;
+      srcX = src.x + NODE_WIDTH / 2;
+      tgtX = tgt.x + NODE_WIDTH / 2;
+    }
+
+    return {
+      x1: srcX, y1: src.y + srcColY,
+      x2: tgtX, y2: tgt.y + tgtColY,
+      sameDirection: sameDirection
+    };
+  }
+
   // d3-force simulation
   function setupSimulation() {
     var nodeMap = {};
@@ -57,10 +194,10 @@
     if (simulation) simulation.stop();
 
     simulation = d3.forceSimulation(simNodes)
-      .force("link", d3.forceLink(simEdges).id(function(d) { return d.id; }).distance(200))
-      .force("charge", d3.forceManyBody().strength(-400))
+      .force("link", d3.forceLink(simEdges).id(function(d) { return d.id; }).distance(320))
+      .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 + 20; }))
+      .force("collide", d3.forceCollide().radius(function(d) { return Math.max(NODE_WIDTH, d._height) / 2 + 50; }))
       .on("tick", ticked);
 
     return { simNodes: simNodes, simEdges: simEdges };
@@ -78,17 +215,40 @@
   function renderEdges(simEdges) {
     edgeGroup.selectAll(".edge-group").remove();
 
+    // Compute parallel edge offsets for edges between same node pair
+    var pairCounts = {};
+    simEdges.forEach(function(d) {
+      var key = [d.data.from, d.data.to].sort().join("||");
+      pairCounts[key] = (pairCounts[key] || 0) + 1;
+    });
+    var pairSeen = {};
+    simEdges.forEach(function(d) {
+      var key = [d.data.from, d.data.to].sort().join("||");
+      pairSeen[key] = (pairSeen[key] || 0);
+      d._pairCount = pairCounts[key];
+      d._pairIndex = pairSeen[key];
+      pairSeen[key]++;
+    });
+
     var eGroups = edgeGroup.selectAll(".edge-group")
       .data(simEdges, function(d) { return d.data.from + "-" + d.data.to + "-" + d.data.label; })
       .enter().append("g")
       .attr("class", "edge-group");
 
-    eGroups.append("line")
+    eGroups.append("path")
       .attr("class", function(d) {
         var cls = "edge-line " + d.data.association_type;
         if (d.data.through) cls += " through";
         if (d.data.polymorphic) cls += " polymorphic-edge";
         return cls;
+      })
+      .attr("marker-start", function(d) {
+        var m = MARKER_MAP[d.data.association_type];
+        return m ? "url(#marker-" + m.start + "-" + d.data.association_type + ")" : null;
+      })
+      .attr("marker-end", function(d) {
+        var m = MARKER_MAP[d.data.association_type];
+        return m ? "url(#marker-" + m.end + "-" + d.data.association_type + ")" : null;
       });
 
     eGroups.append("text")
@@ -192,14 +352,66 @@
   function ticked() {
     edgeGroup.selectAll(".edge-group").each(function(d) {
       var g = d3.select(this);
-      g.select("line")
-        .attr("x1", d.source.x)
-        .attr("y1", d.source.y)
-        .attr("x2", d.target.x)
-        .attr("y2", d.target.y);
+      var src = d.source;
+      var tgt = d.target;
+
+      // Self-referential association (markers are applied at path creation time via marker-start/marker-end)
+      if (src.id === tgt.id) {
+        var selfX = src.x + NODE_WIDTH / 2;
+        var selfY1 = src.y - 20;
+        var selfY2 = src.y + 20;
+        var selfOffset = 60;
+        g.select("path").attr("d",
+          "M " + selfX + " " + selfY1 +
+          " C " + (selfX + selfOffset) + " " + selfY1 +
+          ", " + (selfX + selfOffset) + " " + selfY2 +
+          ", " + selfX + " " + selfY2);
+        g.select("text")
+          .attr("x", selfX + selfOffset + 5)
+          .attr("y", src.y);
+        return;
+      }
+
+      var connPts = getConnectionPoints(d);
+
+      // Parallel edge offset
+      var parallelOffset = 0;
+      if (d._pairCount > 1) {
+        parallelOffset = (d._pairIndex - (d._pairCount - 1) / 2) * 8;
+      }
+
+      var y1 = connPts.y1 + parallelOffset;
+      var y2 = connPts.y2 + parallelOffset;
+
+      // Compute cubic bezier control points
+      var cp1x, cp1y, cp2x, cp2y;
+      if (connPts.sameDirection) {
+        var loopOffset = Math.max(MIN_LOOP_OFFSET, Math.abs(y2 - y1) * LOOP_OFFSET_RATIO);
+        cp1x = connPts.x1 + loopOffset;
+        cp1y = y1;
+        cp2x = connPts.x2 + loopOffset;
+        cp2y = y2;
+      } else {
+        var dx = connPts.x2 - connPts.x1;
+        var cpOffset = Math.max(MIN_CURVE_OFFSET, Math.abs(dx) * CURVE_OFFSET_RATIO);
+        var dir = Math.sign(dx) || 1;
+        cp1x = connPts.x1 + cpOffset * dir;
+        cp1y = y1;
+        cp2x = connPts.x2 - cpOffset * dir;
+        cp2y = y2;
+      }
+
+      g.select("path").attr("d",
+        "M " + connPts.x1 + " " + y1 +
+        " C " + cp1x + " " + cp1y +
+        ", " + cp2x + " " + cp2y +
+        ", " + connPts.x2 + " " + y2);
+
+      var labelX = 0.125 * connPts.x1 + 0.375 * cp1x + 0.375 * cp2x + 0.125 * connPts.x2;
+      var labelY = (y1 + y2) / 2;
       g.select("text")
-        .attr("x", (d.source.x + d.target.x) / 2)
-        .attr("y", (d.source.y + d.target.y) / 2);
+        .attr("x", labelX)
+        .attr("y", labelY);
     });
 
     nodeGroup.selectAll(".node-group")
@@ -417,6 +629,12 @@
       var isDark = window.matchMedia("(prefers-color-scheme: dark)").matches;
       html.classList.add(isDark ? "light" : "dark");
     }
+    buildMarkers();
+  });
+
+  // Rebuild markers when system theme changes
+  window.matchMedia("(prefers-color-scheme: dark)").addEventListener("change", function() {
+    buildMarkers();
   });
 
   function fitToScreen() {

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

@@ -310,6 +310,8 @@ body {
 .edge-line {
   fill: none;
   stroke-width: 1.5;
+  stroke-linecap: round;
+  stroke-linejoin: round;
 }
 
 .edge-line.belongs_to { stroke: var(--edge-belongs-to); }
@@ -471,3 +473,23 @@ body {
 .legend-line.has_many { background: var(--edge-has-many); }
 .legend-line.has_one { background: var(--edge-has-one); }
 .legend-line.habtm { background: var(--edge-habtm); }
+
+.legend-line.through {
+  background: var(--edge-color);
+  background-image: repeating-linear-gradient(
+    to right,
+    var(--edge-color) 0, var(--edge-color) 6px,
+    transparent 6px, transparent 9px
+  );
+  background-color: transparent;
+}
+
+.legend-line.polymorphic {
+  background: var(--edge-color);
+  background-image: repeating-linear-gradient(
+    to right,
+    var(--edge-color) 0, var(--edge-color) 3px,
+    transparent 3px, transparent 6px
+  );
+  background-color: transparent;
+}

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

@@ -22,10 +22,12 @@
 
     <div id="toolbar">
       <div class="legend">
-        <span class="legend-item"><span class="legend-line belongs_to"></span> belongs_to</span>
-        <span class="legend-item"><span class="legend-line has_many"></span> has_many</span>
-        <span class="legend-item"><span class="legend-line has_one"></span> has_one</span>
-        <span class="legend-item"><span class="legend-line habtm"></span> habtm</span>
+        <span class="legend-item"><span class="legend-line belongs_to"></span> belongs_to (M:1)</span>
+        <span class="legend-item"><span class="legend-line has_many"></span> has_many (1:M)</span>
+        <span class="legend-item"><span class="legend-line has_one"></span> has_one (1:1)</span>
+        <span class="legend-item"><span class="legend-line habtm"></span> habtm (M:M)</span>
+        <span class="legend-item"><span class="legend-line through"></span> :through</span>
+        <span class="legend-item"><span class="legend-line polymorphic"></span> polymorphic</span>
       </div>
       <div class="spacer"></div>
       <span class="zoom-info" id="zoom-info">100%</span>

data/lib/rails/schema/configuration.rb

@@ -3,7 +3,7 @@
 module Rails
   module Schema
     class Configuration
-      attr_accessor :output_path, :exclude_models, :title, :theme, :expand_columns
+      attr_accessor :output_path, :exclude_models, :title, :theme, :expand_columns, :schema_format
 
       def initialize
         @output_path = "docs/schema.html"
@@ -11,6 +11,7 @@ module Rails
         @title = "Database Schema"
         @theme = :auto
         @expand_columns = false
+        @schema_format = :auto
       end
     end
   end

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

@@ -26,16 +26,27 @@ module Rails
             association_type: ref.macro.to_s,
             label: ref.name.to_s,
             foreign_key: ref.foreign_key.to_s,
-            through: ref.options[:through]&.to_s,
-            polymorphic: ref.options[:as] ? true : false
+            through: through_name(ref),
+            polymorphic: polymorphic?(ref)
           }
-        rescue StandardError
+        rescue StandardError => e
+          warn "[rails-schema] Could not read association #{ref.name} on #{model.name}: #{e.class}: #{e.message}"
           nil
         end
 
+        def through_name(ref)
+          ref.options[:through]&.to_s
+        end
+
+        def polymorphic?(ref)
+          ref.options[:as] ? true : false
+        end
+
         def target_model_name(ref)
           ref.klass.name
-        rescue StandardError
+        rescue StandardError => e
+          warn "[rails-schema] Could not resolve target for #{ref.name}, " \
+               "falling back to #{ref.class_name}: #{e.class}: #{e.message}"
           ref.class_name
         end
       end

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

@@ -28,7 +28,8 @@ module Rails
               default: col.default
             }
           end
-        rescue StandardError
+        rescue StandardError => e
+          warn "[rails-schema] Could not read columns for #{model.name}: #{e.class}: #{e.message}"
           []
         end
       end

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

@@ -0,0 +1,131 @@
+# frozen_string_literal: true
+
+module Rails
+  module Schema
+    module Extractor
+      class StructureSqlParser
+        SQL_TYPE_MAP = {
+          "character varying" => "string", "varchar" => "string",
+          "integer" => "integer", "smallint" => "integer", "serial" => "integer",
+          "bigint" => "bigint", "bigserial" => "bigint",
+          "boolean" => "boolean", "text" => "text",
+          "timestamp without time zone" => "datetime", "timestamp with time zone" => "datetime",
+          "timestamp" => "datetime",
+          "json" => "json", "jsonb" => "jsonb", "uuid" => "uuid",
+          "numeric" => "decimal", "decimal" => "decimal", "money" => "decimal",
+          "date" => "date",
+          "float" => "float", "double precision" => "float", "real" => "float",
+          "bytea" => "binary"
+        }.freeze
+
+        COMPOUND_TYPE_RE = /\A(character\s+varying|bit\s+varying|double\s+precision|
+                               timestamp(?:\(\d+\))?\s+with(?:out)?\s+time\s+zone)/ix
+        CONSTRAINT_RE = /\A(CONSTRAINT|UNIQUE|CHECK|EXCLUDE|FOREIGN\s+KEY)\b/i
+        PK_CONSTRAINT_RE = /PRIMARY\s+KEY\s*\(([^)]+)\)/i
+
+        def initialize(structure_path = nil)
+          @structure_path = structure_path
+        end
+
+        def parse
+          path = resolve_path
+          return {} unless path && File.exist?(path)
+
+          parse_content(File.read(path))
+        end
+
+        def parse_content(content)
+          tables = {}
+
+          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)
+            columns, pk_columns = parse_table_body(body)
+            pk_columns.each { |pk| columns.find { |c| c[:name] == pk }&.[]= :primary, true }
+            tables[name] = columns
+          end
+
+          tables
+        end
+
+        private
+
+        def resolve_path
+          return @structure_path if @structure_path
+          return ::Rails.root.join("db", "structure.sql").to_s if defined?(::Rails.root) && ::Rails.root
+
+          File.join(Dir.pwd, "db", "structure.sql")
+        end
+
+        def unquote(identifier) = identifier.delete('"')
+
+        def extract_table_name(raw)
+          unquote(raw).split(".").last
+        end
+
+        def parse_table_body(body)
+          columns = []
+          pk_columns = []
+          body.each_line do |raw|
+            line = raw.strip.chomp(",")
+            next if line.empty?
+
+            if (pk = extract_pk_constraint(line))
+              pk_columns.concat(pk)
+            elsif !line.match?(CONSTRAINT_RE) && (col = parse_column_line(line))
+              pk_columns << col[:name] if col.delete(:inline_pk)
+              columns << col
+            end
+          end
+          [columns, pk_columns]
+        end
+
+        def extract_pk_constraint(line)
+          return unless (match = line.match(PK_CONSTRAINT_RE))
+
+          match[1].split(",").map { |c| unquote(c.strip) }
+        end
+
+        def parse_column_line(line)
+          match = line.match(/\A("?\w+"?)\s+(.+)/i)
+          return nil unless match
+
+          rest = match[2]
+          type = extract_type(rest)
+          return nil unless type
+
+          build_column(unquote(match[1]), rest, type)
+        end
+
+        def build_column(col_name, rest, type)
+          {
+            name: col_name,
+            type: SQL_TYPE_MAP.fetch(type, type),
+            nullable: !rest.match?(/\bNOT\s+NULL\b/i),
+            default: extract_default(rest),
+            primary: false,
+            inline_pk: rest.match?(/\bPRIMARY\s+KEY\b/i)
+          }
+        end
+
+        def extract_type(rest)
+          if (m = rest.match(COMPOUND_TYPE_RE))
+            m[1].downcase.gsub(/\(\d+\)/, "")
+          elsif rest.match?(/\A(FOREIGN\s+KEY)\b/i)
+            nil
+          else
+            rest[/\A(\w+)/i, 1]&.downcase
+          end
+        end
+
+        def extract_default(rest)
+          case rest
+          when /\bDEFAULT\s+'([^']*)'(?:::\w+)?/i, /\bDEFAULT\s+(\d+(?:\.\d+)?)\b/i
+            Regexp.last_match(1)
+          when /\bDEFAULT\s+true\b/i then "true"
+          when /\bDEFAULT\s+false\b/i then "false"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rails/schema/version.rb

@@ -2,6 +2,6 @@
 
 module Rails
   module Schema
-    VERSION = "0.1.0"
+    VERSION = "0.1.2"
   end
 end

data/lib/rails/schema.rb

@@ -5,6 +5,7 @@ require_relative "schema/configuration"
 require_relative "schema/transformer/node"
 require_relative "schema/transformer/edge"
 require_relative "schema/extractor/schema_file_parser"
+require_relative "schema/extractor/structure_sql_parser"
 require_relative "schema/extractor/model_scanner"
 require_relative "schema/extractor/column_reader"
 require_relative "schema/extractor/association_reader"
@@ -29,13 +30,27 @@ module Rails
       end
 
       def generate(output: nil)
-        schema_data = Extractor::SchemaFileParser.new.parse
+        schema_data = 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)
         generator = Renderer::HtmlGenerator.new(graph_data: graph_data)
         generator.render_to_file(output)
       end
+
+      private
+
+      def parse_schema
+        case configuration.schema_format
+        when :ruby
+          Extractor::SchemaFileParser.new.parse
+        when :sql
+          Extractor::StructureSqlParser.new.parse
+        when :auto
+          data = Extractor::SchemaFileParser.new.parse
+          data.empty? ? Extractor::StructureSqlParser.new.parse : data
+        end
+      end
     end
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rails-schema
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.2
 platform: ruby
 authors:
 - Andrei Kislichenko
@@ -45,6 +45,7 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- CHANGELOG.md
 - LICENSE.txt
 - PROJECT.md
 - README.md
@@ -61,6 +62,7 @@ files:
 - lib/rails/schema/extractor/column_reader.rb
 - lib/rails/schema/extractor/model_scanner.rb
 - lib/rails/schema/extractor/schema_file_parser.rb
+- lib/rails/schema/extractor/structure_sql_parser.rb
 - lib/rails/schema/railtie.rb
 - lib/rails/schema/renderer/html_generator.rb
 - lib/rails/schema/transformer/edge.rb