canvas_erd 0.1.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5b593a4a8e3ebb6c820c3469cc0063acb4fdf129313e2ea2c68da33a15166be2
-  data.tar.gz: da8d50366c574f574289cf59046e98954fdf324ceff1f20d3ba2811349a5b35e
+  metadata.gz: 56efaf62a9da71464c99f1bbe4ad6e3b384d5268b62bdb056b68b7105f0b5ab3
+  data.tar.gz: a2c50f1c6408f5e19178eb7f70b476c0cb0d6376364601b745cf06a3ec510388
 SHA512:
-  metadata.gz: 8262355aa351a042ea353f9d1340aee15d30e839f29bcdea12c3d3d728070d176deb0cb845db2b43e7c1f0cb05cd8321a8480e00286e665379b1b368640c0f31
-  data.tar.gz: a4db10469eaf6ee4f1d95afbcc7f02f826c37f0234187d02d925c79d73f4c65f86c9fe5dbb8e08d6e46929189c6e53d5695f81f05e185d2a01c73349e88b1776
+  metadata.gz: 0a161a5b80937c795fa467d9cd6e0a7a6828dbaf6de2453f5e05728fa080baa2165ec05189c8adcfd2ca4df8d84a06ba77b501e5c432014f77f270f0307dc324
+  data.tar.gz: 61c7efe55ee748ac1768b29abe5018c396f9d64a528ee4bf1098cbdfcb8d1beeee30049a9d3981f87a639fe42cfdfee6e16a251a91b32900b36e17adbf9f2416

data/CHANGELOG.md

@@ -1,5 +1,23 @@
 # Changelog
 
+## 0.3.0 - 2026-10-12
+
+- Add syntax-highlighted code boxes with a selectable language and small, medium, or large font, highlighted with Rouge.
+- Add read-only source file snippets from the Rails application, with `.gitignore`-aware path autocompletion, optional start and end lines, toggleable line numbers, and clickable line highlighting; **Refresh schema** re-reads them.
+- Toggle a model's scopes from the table sidebar to show their source in a code box linked to its table, limited to scopes declared in the Rails application and its concerns.
+- Require Ruby 3.3 or newer.
+
+## 0.2.0 - 2026-09-19
+
+- Format whole notes with paragraph styles, bold, italic, underline, alignment, text and background colors, and keyboard shortcuts for styles and emphasis.
+- Choose colors from common options or custom values currently used in the diagram, including transparent note backgrounds and background-aware borders.
+- Color the headers of one or more selected tables to visually group related tables, with preset and custom colors.
+- Enter arrow endpoint editing immediately when an arrow is selected, without requiring a double-click.
+- Style arrows with independent endpoint heads, solid, dashed, or dotted lines, adjustable widths, and foreground-palette or custom colors.
+- Draw backmost grouping frames with editable labels, foreground-palette or custom colors, and solid, dashed, or dotted borders.
+- Render association cardinalities with table-edge-aligned crow's-foot notation, retaining text for nonstandard numeric ranges.
+- Open the most recently modified saved diagram when the editor starts.
+
 ## 0.1.0 - 2026-08-30
 
 - Generate a JSON-safe diagram schema from Rails ERD domain models.

data/README.md

@@ -15,7 +15,7 @@ group :development do
 end
 ```
 
-Then run `bundle install`. CanvasERD requires Ruby 3.1 or newer, Active Record 7.0 or newer, and a Rack server available in the Rails bundle.
+Then run `bundle install`. CanvasERD requires Ruby 3.3 or newer, Active Record 7.0 or newer, and a Rack server available in the Rails bundle.
 
 ## Usage
 
@@ -35,16 +35,22 @@ Diagrams are saved by the editor as `*.erd.png` files under `docs/erd/` in the R
 bundle exec canvas_erd --diagrams-dir db/diagrams
 ```
 
-The editor's saved-diagram menu loads these files directly. You can also open a diagram when starting CanvasERD with `bundle exec canvas_erd path/to/domain.erd.png`.
+The editor opens the most recently modified saved diagram when it starts. Its saved-diagram menu loads other files directly. You can also open a specific diagram with `bundle exec canvas_erd path/to/domain.erd.png`.
 
 ## Editor controls
 
 - Drag tables to reposition them.
 - Use the table sidebar to add or remove tables without losing their positions.
+- Toggle **scopes** in the table sidebar to show a model's scope source in a code box linked to its table. Only scopes declared in the Rails application (including its concerns) are shown.
+- Select one or more tables to color their headers and visually group related tables.
 - Use **Layout tables** to rearrange the tables currently on the canvas with ELK without moving notes or hidden tables.
 - Pinch over the canvas or use the toolbar buttons to zoom.
 - Use a two-finger trackpad gesture to pan. Space-drag remains available as a keyboard fallback, and **Fit diagram** resets the view.
-- Add editable notes with **Add note**. Select a note and press Delete to remove it.
+- Add editable notes with **Add note**. Notes support paragraph styles, emphasis, alignment, and text and background colors; new notes inherit the last touched note's style.
+- Add syntax-highlighted code boxes with **Add code**, choosing the language and a small, medium, or large font from the formatting toolbar. **Add source file** shows a read-only snippet of a file in the Rails application, with path autocompletion from the application's files (respecting `.gitignore`) and optional start and end lines. Select the snippet to change its path or lines from the toolbar, or to toggle line numbers (which follow the source file). Click line numbers to highlight lines, and Shift-click to highlight or clear a range to match the last line clicked; **Refresh schema** re-reads it. Highlighting uses [Rouge](https://github.com/rouge-ruby/rouge).
+- Draw and style arrows with independent endpoint heads. Selecting an arrow immediately exposes its movable endpoints.
+- Draw grouping frames behind the diagram, then edit their labels, colors, and border styles.
+- Relationship cardinalities use crow's-foot notation at table edges, with exact text retained for uncommon numeric ranges.
 - Use **Refresh schema** after a database migration to update columns and relationships. Existing table positions, selections, notes, and the current view are preserved; new tables start unselected.
 - Edit the diagram name, then use **Save** (or <kbd>⌘S</kbd>/<kbd>Ctrl-S</kbd>) to write the complete diagram into the Rails application as a normal `*.erd.png` image with its editable schema, layout, notes, selection, and viewport embedded inside it. Select a saved diagram from the menu to reopen it, or use **New** to start an “Untitled ERD.”
 

data/lib/canvas_erd/cli.rb

@@ -72,6 +72,7 @@ module CanvasERD
       end
 
       @err.puts "Loading Rails application from #{@root}..."
+      ModelDetails.install
       ApplicationLoader.new(@root).load
 
       schema_provider = SchemaProvider.new
@@ -87,7 +88,9 @@ module CanvasERD
         schema: schema,
         schema_provider: schema_provider,
         state: state,
-        diagram_store: diagram_store
+        diagram_store: diagram_store,
+        source_files: SourceFiles.new(root: @root),
+        model_details: ModelDetails.new(root: @root)
       )
       server = Server.new(app: app)
 

data/lib/canvas_erd/diagram_store.rb

@@ -31,10 +31,23 @@ module CanvasERD
       Dir.children(directory).select { |name| valid_filename?(name) && File.file?(path_for(name)) }.sort
     end
 
+    def most_recent_name
+      names.max_by { |name| [File.mtime(path_for(name)).to_f, name] }
+    rescue SystemCallError => error
+      raise Error, "Could not inspect saved diagrams: #{error.message}"
+    end
+
+    def document(name)
+      read_diagram(name).last
+    end
+
     def read(name)
+      read_diagram(name).first
+    end
+
+    def read_diagram(name)
       bytes = File.binread(path_for(name))
-      PngDocument.read(StringIO.new(bytes))
-      bytes
+      [bytes, PngDocument.read(StringIO.new(bytes))]
     rescue Errno::ENOENT
       raise NotFound, "Diagram not found: #{name}"
     rescue SystemCallError => error
@@ -42,6 +55,7 @@ module CanvasERD
     rescue PngDocument::Error => error
       raise Error, error.message
     end
+    private :read_diagram
 
     def write(name, bytes)
       path = path_for(name)

data/lib/canvas_erd/highlighter.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+require "rouge"
+
+module CanvasERD
+  class Highlighter
+    def initialize(theme: Rouge::Themes::Github.new)
+      @theme = theme
+    end
+
+    def languages
+      Rouge::Lexer.all
+        .map { |lexer| { "tag" => lexer.tag, "title" => lexer.title } }
+        .sort_by { |language| language["title"].downcase }
+    end
+
+    def colors
+      style = @theme.style_for(Rouge::Token::Tokens::Text) || {}
+      { "foreground" => color(style[:fg]), "background" => color(style[:bg]) }
+    end
+
+    def language_for(filename)
+      Rouge::Lexer.guess(filename: filename) { Rouge::Lexers::PlainText }.tag
+    rescue Rouge::Guesser::Ambiguous
+      Rouge::Lexers::PlainText.tag
+    end
+
+    def highlight(code, language)
+      code = normalize(code)
+      lexer = Rouge::Lexer.find(language.to_s) || Rouge::Lexers::PlainText
+      background = colors["background"]
+      runs = lexer.lex(code).map { |token, text| [text, run_style(token, background)] }
+      { "code" => code, "language" => lexer.tag, "runs" => runs }
+    end
+
+    def normalize(code)
+      code.to_s.gsub(/\r\n?/, "\n").gsub("\t", "  ")
+    end
+
+    private
+
+    def run_style(token, background)
+      style = @theme.style_for(token) || {}
+      result = {}
+      result["fill"] = color(style[:fg]) if style[:fg]
+      result["fontWeight"] = "bold" if style[:bold]
+      result["fontStyle"] = "italic" if style[:italic]
+      token_background = color(style[:bg])
+      result["textBackgroundColor"] = token_background if token_background && token_background != background
+      result
+    end
+
+    def color(value)
+      value.is_a?(Symbol) ? @theme.class.palette(value) : value
+    end
+  end
+end

data/lib/canvas_erd/model_details.rb

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+require "prism"
+
+module CanvasERD
+  class ModelDetails
+    class NotFound < StandardError; end
+
+    DETAILS = %w[scopes].freeze
+
+    module ScopeRecorder
+      def scope(name, body, &block)
+        location = caller_locations(1, 1).first
+        ModelDetails.record_scope(self, name, location.absolute_path || location.path, location.lineno)
+        super
+      end
+    end
+
+    @scopes = Hash.new { |scopes, model| scopes[model] = [] }
+
+    class << self
+      attr_reader :scopes
+
+      def install
+        require "active_support/lazy_load_hooks"
+        ActiveSupport.on_load(:active_record) { singleton_class.prepend(ScopeRecorder) }
+      end
+
+      def record_scope(model, name, path, line)
+        return unless model.name
+
+        scopes[model.name] << { name: name.to_s, path: path, line: line }
+      end
+    end
+
+    def initialize(root:, scopes: self.class.scopes, source_path: ->(model) { Object.const_source_location(model)&.first })
+      @root = File.realpath(root)
+      @scopes = scopes
+      @source_path = source_path
+    end
+
+    def summary
+      @scopes.keys.each_with_object({}) do |model, summary|
+        count = application_scopes(model).length
+        summary[model] = { "scopes" => count } if count.positive?
+      end
+    end
+
+    def detail(model, detail)
+      raise NotFound, "Unknown model detail: #{detail}" unless DETAILS.include?(detail)
+      raise NotFound, "No #{detail} for #{model}" if application_scopes(model).empty?
+
+      rows = scope_rows(model)
+      { "code" => rows.map(&:first).join("\n"), "language" => "ruby", "lineNumbers" => rows.map(&:last) }
+    end
+
+    private
+
+    def scope_rows(model)
+      model_path = @source_path.call(model)
+      groups = application_scopes(model).group_by { |scope| scope[:path] }.map do |path, scopes|
+        header = path == model_path ? [] : [["# #{relative_path(path)}", nil]]
+        header + scopes.flat_map { |scope| snippet(path, scope) }
+      end
+      groups.each_with_index.flat_map { |rows, index| index.zero? ? rows : [["", nil], *rows] }
+    end
+
+    def application_scopes(model)
+      return [] unless @scopes.key?(model)
+
+      @scopes[model].select { |scope| scope[:path].start_with?("#{@root}#{File::SEPARATOR}") }
+    end
+
+    def snippet(path, scope)
+      lines = File.readlines(path)
+      node = scope_call_covering(Prism.parse_file(path).value, scope[:line])
+      range = node ? node.location.start_line..node.location.end_line : scope[:line]..scope[:line]
+      dedent(lines[(range.begin - 1)..(range.end - 1)]).zip(range)
+    rescue SystemCallError
+      [["# scope :#{scope[:name]} (source unavailable)", nil]]
+    end
+
+    def scope_call_covering(node, line)
+      if node.is_a?(Prism::CallNode) && node.name == :scope && node.receiver.nil? &&
+          (node.location.start_line..node.location.end_line).cover?(line)
+        return node
+      end
+
+      node.compact_child_nodes.each do |child|
+        found = scope_call_covering(child, line)
+        return found if found
+      end
+      nil
+    end
+
+    def dedent(lines)
+      indentation = lines.reject { |line| line.strip.empty? }.map { |line| line[/\A */].length }.min || 0
+      lines.map { |line| line.strip.empty? ? "" : line.chomp[indentation..] }
+    end
+
+    def relative_path(path)
+      path.delete_prefix("#{@root}#{File::SEPARATOR}")
+    end
+  end
+end

data/lib/canvas_erd/server.rb

@@ -21,10 +21,14 @@ module CanvasERD
 
     attr_reader :schema
 
-    def initialize(schema:, schema_provider: nil, state: nil, diagram_store: nil)
+    def initialize(schema:, schema_provider: nil, state: nil, diagram_store: nil, source_files: nil,
+      model_details: nil, highlighter: Highlighter.new)
       @schema = schema
       @schema_provider = schema_provider || -> { schema }
       @diagram_store = diagram_store
+      @source_files = source_files
+      @model_details = model_details
+      @highlighter = highlighter
       @schema_mutex = Mutex.new
       @document = {
         "format" => "canvas_erd",
@@ -42,10 +46,10 @@ module CanvasERD
 
       body = [] if method == "HEAD"
       [status, security_headers.merge(headers), body]
-    rescue DiagramStore::NotFound => error
+    rescue DiagramStore::NotFound, SourceFiles::NotFound, ModelDetails::NotFound => error
       status, headers, body = response(404, "text/plain; charset=utf-8", error.message)
       [status, security_headers.merge(headers), method == "HEAD" ? [] : body]
-    rescue DiagramStore::Error => error
+    rescue DiagramStore::Error, SourceFiles::Error => error
       status, headers, body = response(400, "text/plain; charset=utf-8", error.message)
       [status, security_headers.merge(headers), method == "HEAD" ? [] : body]
     end
@@ -59,6 +63,12 @@ module CanvasERD
         return diagram_response(environment, write: method == "PUT")
       end
 
+      if path == "/api/highlight"
+        return method_not_allowed("POST") unless method == "POST"
+
+        return highlight_response(environment)
+      end
+
       return method_not_allowed("GET, HEAD") unless %w[GET HEAD].include?(method)
 
       if path == "/api/schema"
@@ -67,6 +77,16 @@ module CanvasERD
         document_response
       elsif path == "/api/diagrams"
         diagrams_response
+      elsif path == "/api/highlighting"
+        json_response(@highlighter.colors.merge("languages" => @highlighter.languages))
+      elsif path == "/api/source_files"
+        source_files_response
+      elsif path == "/api/source"
+        source_response(environment)
+      elsif path == "/api/model_details"
+        json_response(@model_details ? @model_details.summary : {})
+      elsif path == "/api/model_detail"
+        model_detail_response(environment)
       elsif STATIC_FILES.key?(path)
         file_response(*STATIC_FILES.fetch(path))
       else
@@ -92,7 +112,16 @@ module CanvasERD
     end
 
     def document_response
-      document = @document["state"] ? @document : @document.merge("schema" => schema)
+      document = if @document["state"]
+        @document
+      elsif @diagram_store && (name = @diagram_store.most_recent_name)
+        @diagram_store.document(name).merge(
+          "filename" => name,
+          "application_schema" => schema
+        )
+      else
+        @document.merge("schema" => schema)
+      end
       response(
         200,
         "application/json; charset=utf-8",
@@ -130,6 +159,52 @@ module CanvasERD
       end
     end
 
+    def highlight_response(environment)
+      request = JSON.parse(environment.fetch("rack.input").read)
+      raise JSON::ParserError, "expected an object" unless request.is_a?(Hash)
+
+      json_response(@highlighter.highlight(request["code"], request["language"]))
+    rescue JSON::ParserError
+      response(400, "text/plain; charset=utf-8", "Invalid highlight request")
+    end
+
+    def source_response(environment)
+      return response(404, "text/plain; charset=utf-8", "Source files are not configured") unless @source_files
+
+      query = Rack::Utils.parse_query(environment.fetch("QUERY_STRING", ""))
+      path = query["path"]
+      code = @source_files.read(path, start_line: line_number(query["start"]), end_line: line_number(query["end"]))
+      json_response(
+        "path" => path,
+        "code" => @highlighter.normalize(code),
+        "language" => @highlighter.language_for(path)
+      )
+    end
+
+    def source_files_response
+      return response(404, "text/plain; charset=utf-8", "Source files are not configured") unless @source_files
+
+      json_response("paths" => @source_files.paths)
+    end
+
+    def model_detail_response(environment)
+      return response(404, "text/plain; charset=utf-8", "Model details are not configured") unless @model_details
+
+      query = Rack::Utils.parse_query(environment.fetch("QUERY_STRING", ""))
+      json_response(@model_details.detail(query["model"], query["detail"]))
+    end
+
+    def line_number(value)
+      return nil if value.nil? || value.empty?
+      raise SourceFiles::Error, "Invalid line number: #{value}" unless value.match?(/\A\d+\z/)
+
+      value.to_i
+    end
+
+    def json_response(data)
+      response(200, "application/json; charset=utf-8", JSON.generate(data), "cache-control" => "no-store")
+    end
+
     def file_response(relative_path, content_type)
       response(
         200,

data/lib/canvas_erd/source_files.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+require "find"
+require "open3"
+
+module CanvasERD
+  class SourceFiles
+    class Error < StandardError; end
+    class NotFound < Error; end
+
+    IGNORED_DIRECTORIES = %w[node_modules tmp log storage coverage vendor/bundle public/assets public/packs].freeze
+
+    def initialize(root:)
+      @root = File.realpath(root)
+    end
+
+    def paths
+      output, status = Open3.capture2(
+        "git", "ls-files", "-z", "--cached", "--others", "--exclude-standard",
+        chdir: @root, err: File::NULL
+      )
+      return walked_paths unless status.success?
+
+      output.split("\0").select { |path| File.file?(File.join(@root, path)) }.sort
+    rescue SystemCallError
+      walked_paths
+    end
+
+    def walked_paths
+      paths = []
+      Find.find(@root) do |path|
+        relative_path = path.delete_prefix("#{@root}#{File::SEPARATOR}")
+        next if path == @root
+        next Find.prune if File.basename(path).start_with?(".") || IGNORED_DIRECTORIES.include?(relative_path)
+
+        paths << relative_path if File.file?(path)
+      end
+      paths.sort
+    end
+    private :walked_paths
+
+    def read(path, start_line: nil, end_line: nil)
+      full_path = File.realpath(path.to_s, @root)
+      unless full_path.start_with?("#{@root}#{File::SEPARATOR}")
+        raise Error, "Source file must be inside the Rails application"
+      end
+      raise Error, "Source path is not a file: #{path}" unless File.file?(full_path)
+
+      code = File.read(full_path, encoding: "UTF-8")
+      raise Error, "Source file is not UTF-8 text: #{path}" if !code.valid_encoding? || code.include?("\0")
+
+      lines(code, start_line, end_line)
+    rescue Errno::ENOENT
+      raise NotFound, "Source file not found: #{path}"
+    rescue SystemCallError => error
+      raise Error, "Could not read source file #{path}: #{error.message}"
+    end
+
+    private
+
+    def lines(code, start_line, end_line)
+      lines = code.lines
+      first = start_line || 1
+      last = [end_line || lines.length, lines.length].min
+      raise Error, "Invalid line range #{start_line}-#{end_line}" if first < 1 || (lines.any? && first > last)
+
+      Array(lines[(first - 1)..(last - 1)]).join.chomp
+    end
+  end
+end

data/lib/canvas_erd/version.rb

@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 
 module CanvasERD
-  VERSION = "0.1.0"
+  VERSION = "0.3.0"
 end
-