rails-mermaid_erd 0.8.0 → 0.8.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5a6ae2943632ef191d3758420e84a0fc2e43f17a677359e21328bc67b83bd172
-  data.tar.gz: d1ecd0768360f3bdbca63e1569ac26f708af009bfc3b18d09c8001ff474ea77a
+  metadata.gz: 1e8b99cba042397b3b3fb6e1db0480aeb839aaf1c4232e24be6ae5e9cac9cb3e
+  data.tar.gz: 1980c75216f10e0e6314626784c027c4aab1167f76f043e84c5358ccaa78beac
 SHA512:
-  metadata.gz: 4ef1270960ec9ce3f1a91d7c8c9d6182f0ef489f11e10be3653f905e72dbf344d39cee5da22ac35cc2f799836e49da799f0db2df82f2e9c3b59f120b6592fcdd
-  data.tar.gz: f3a1d2f73421f4f2cbec8c7d394ca55ced02835df12e2fb3bfb24ec6c97685609cdd30137be1b9943d853b80ff86d6debdd996aa19066dd173009635c0615464
+  metadata.gz: 54387a81bc7df09d7dd723810848c2230ef31f043d27f14e8da8cb9184d1a00a997966f6cad191909e08ccfecbd69e101e655207fd580327e3d49d7f301ed103
+  data.tar.gz: 77047222cfdfc8bf8c814a9b5f2a9b8c06e8428fc23e1d4b81cad37ca4f6fc4af37afb0ccdd47774161ace5c8d7f725a5bc0f569e734aa294280babe45daf7f9

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2022 肥溜め
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -62,6 +62,8 @@ mermaid_erd
 
 If you share this file, it can be used by those who do not have a Ruby on Rails environment. Or, you can upload the file to a web server and share it with the same URL.
 
+The generated file contains your application's schema, including table and column names and comments. Share it, or host it, only as widely as you would share the schema itself.
+
 It would be very smart to generate it automatically using CI.
 
 ### Print the Mermaid source to stdout
@@ -88,7 +90,7 @@ The Ruby × Rails combinations exercised by CI on every push and pull request:
 | ----- | -------------------------------- |
 | 5.2   | 2.7                              |
 | 6.0   | 2.7, 3.0                         |
-| 6.1   | 2.7, 3.0, 3.1, 3.2               |
+| 6.1   | 2.7, 3.0, 3.1, 3.2, 3.3          |
 | 7.0   | 2.7, 3.0, 3.1, 3.2, 3.3          |
 | 7.1   | 3.1, 3.2, 3.3, 3.4               |
 | 7.2   | 3.1, 3.2, 3.3, 3.4               |
@@ -108,6 +110,7 @@ The setting items are as follows.
 | --- | --- | --- |
 | `result_path` | Destination of generated files. | `mermaid_erd/index.html` |
 | `ignore_tables` | Array of regular-expression strings. Tables whose `table_name` matches any pattern are dropped from the generated ERD, along with any relations that point at them. Useful for excluding audit-log models, soft-deleted/legacy tables, or other large noise you don't want to render. Patterns are compiled with `Regexp.new`, so escape backslashes inside YAML strings (e.g. `"\\Aaudit_"`). | `[]` |
+| `viewer_defaults` | The view the viewer opens on when the URL carries no saved state, and the one **Reset** returns to; a link with its own state always wins. `models`: array of model names selected at first (a name that is not in the diagram is skipped with a warning when the file is generated). `columns`: `all`, `keys` (primary and foreign keys only) or `none`, the same choices as Columns in the sidebar. Useful for opening a large app on the models people usually start from. | `models: []` (nothing selected), `columns: all` |
 
 <!--
 TODO:
@@ -118,3 +121,7 @@ Contribution directions go here.
 
 ## License
 The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).
+
+## Trademarks
+
+This project is not affiliated with, endorsed by, or sponsored by Rails, The Rails Foundation, the Mermaid project, or Mermaid Chart Inc. Rails and Ruby on Rails are registered trademarks of David Heinemeier Hansson. Mermaid Chart Inc. has registered or applied for the trademarks MERMAID CHART and MERMAID in the United States. All other trademarks are the property of their respective owners.

data/lib/rails-mermaid_erd/builder.rb

@@ -1,4 +1,8 @@
 class RailsMermaidErd::Builder
+  # The order associations are read in, which is also the order their labels
+  # appear in a relation's comment.
+  RELATION_MACROS = [:has_many, :has_and_belongs_to_many, :belongs_to, :has_one].freeze
+
   class << self
     def model_data
       result = {
@@ -24,10 +28,25 @@ class RailsMermaidErd::Builder
       # pulling in `set` (which is autoloaded on Ruby 3.2+ but not earlier).
       ignored_model_names = compute_ignored_model_names(ignore_patterns)
 
+      # Single table inheritance subclasses share their base class's table, so
+      # each hierarchy is drawn as the base class's entity. Associations that
+      # target a subclass are pointed at that entity too.
+      sti_base_names = compute_sti_base_names
+
+      # Associations grouped by the link they describe (see `link_key`). Each
+      # group becomes one relation line once every model has been read.
+      links = Hash.new { |hash, key| hash[key] = [] }
+
+      # Foreign key columns the associations name, by the model whose table
+      # holds them. Not every application backs its associations with foreign
+      # key constraints, so these are drawn as foreign keys too.
+      association_foreign_keys = Hash.new { |hash, model_name| hash[model_name] = [] }
+
       ::ActiveRecord::Base.descendants.sort_by(&:name).each do |defined_model|
         next unless defined_model.table_exists?
         next if defined_model.name.include?("HABTM_")
         next if defined_model.table_name.blank?
+        next if sti_base_names.key?(defined_model.name)
         next if ignored_model_names.key?(defined_model.name)
 
         table_name = defined_model.table_name
@@ -40,10 +59,10 @@ class RailsMermaidErd::Builder
         }
 
         foreign_keys = ::ActiveRecord::Schema.foreign_keys(defined_model.table_name).map { |k| k.options[:column] }
-        primary_key = defined_model.primary_key
+        primary_keys = Array(defined_model.primary_key)
         defined_model.columns.each do |column|
           key = ""
-          if column.name == primary_key
+          if primary_keys.include?(column.name)
             key = "PK"
           elsif foreign_keys.include?(column.name)
             key = "FK"
@@ -58,119 +77,46 @@ class RailsMermaidErd::Builder
 
         result[:Models] << model
 
-        defined_model.reflect_on_all_associations(:has_many).each do |reflection|
-          reflection_model_name = get_reflection_model_name(reflection)
-          next if ignored_model_names.key?(reflection_model_name)
+        hierarchy = [defined_model] + defined_model.descendants
+          .select { |descendant| sti_base_names[descendant.name] == defined_model.name }
+          .sort_by(&:name)
 
-          reverse_relation = result[:Relations].find { |r|
-            if reflection.options[:through]
-              r[:RightModelName] == model[:ModelName] && r[:LeftModelName] == reflection_model_name && r[:Line] == ".."
-            else
-              r[:RightModelName] == model[:ModelName] && r[:LeftModelName] == reflection_model_name && r[:Line] == "--"
+        RELATION_MACROS.each do |macro|
+          hierarchy_reflections(hierarchy, macro, sti_base_names).each do |reflection, reflection_model_name|
+            # A `belongs_to` holds its foreign key itself, whatever it points at.
+            if macro == :belongs_to
+              association_foreign_keys[model[:ModelName]].concat(foreign_key_columns(reflection))
             end
-          }
-          if reverse_relation
-            reverse_relation[:Comment] = if reflection.options[:through]
-              "#{reverse_relation[:Comment]}, HMT:#{reflection.name}"
-            else
-              "#{reverse_relation[:Comment]}, HM:#{reflection.name}"
-            end
-          else
-            result[:Relations] << {
-              LeftModelName: model[:ModelName],
-              LeftValue: reflection.options[:through] ? "}o" : "||",
-              Line: reflection.options[:through] ? ".." : "--",
-              RightModelName: reflection_model_name,
-              RightValue: "o{",
-              Comment: reflection.options[:through] ? "HMT:#{reflection.name}" : "HM:#{reflection.name}"
-            }
-          end
-        end
 
-        defined_model.reflect_on_all_associations(:has_and_belongs_to_many).each do |reflection|
-          reflection_model_name = get_reflection_model_name(reflection)
-          next if ignored_model_names.key?(reflection_model_name)
-
-          reverse_relation = result[:Relations].find { |r| r[:RightModelName] == model[:ModelName] && r[:LeftModelName] == reflection_model_name }
-          if reverse_relation
-            reverse_relation[:Comment] = "HABTM"
-          else
-            result[:Relations] << {
-              LeftModelName: model[:ModelName],
-              LeftValue: "}o",
-              Line: "..",
-              RightModelName: reflection_model_name,
-              RightValue: "o{",
-              Comment: "HABTM"
-            }
-          end
-        end
+            # Polymorphic `belongs_to` has no concrete target class — the target is
+            # decided at row level by the `*_type` column. Emitting an edge to the
+            # macro name (e.g. `"Imageable"`) would render an orphan node with no
+            # columns; the polymorphic parents express the relationship via their
+            # `has_many ..., as: :foo` reflections instead.
+            next if macro == :belongs_to && reflection.polymorphic?
 
-        defined_model.reflect_on_all_associations(:belongs_to).each do |reflection|
-          # Polymorphic `belongs_to` has no concrete target class — the target is
-          # decided at row level by the `*_type` column. Emitting an edge to the
-          # macro name (e.g. `"Imageable"`) would render an orphan node with no
-          # columns; the polymorphic parents express the relationship via their
-          # `has_many ..., as: :foo` reflections instead.
-          next if reflection.polymorphic?
-
-          reflection_model_name = get_reflection_model_name(reflection)
-          next if ignored_model_names.key?(reflection_model_name)
-
-          reverse_relation = result[:Relations].find { |r| r[:RightModelName] == model[:ModelName] && r[:LeftModelName] == reflection_model_name }
-          if reverse_relation
-            if (::Rails.application.config.active_record.belongs_to_required_by_default && reflection.options[:optional]) || (!::Rails.application.config.active_record.belongs_to_required_by_default && !reflection.options[:required])
-              reverse_relation[:LeftValue] = "|o"
-            end
-            reverse_relation[:Comment] = "#{reverse_relation[:Comment]}, BT:#{reflection.name}"
-          else
-            right_value = if (::Rails.application.config.active_record.belongs_to_required_by_default && reflection.options[:optional]) || (!::Rails.application.config.active_record.belongs_to_required_by_default && !reflection.options[:required])
-              "o|"
-            else
-              "||"
+            next if ignored_model_names.key?(reflection_model_name)
+
+            # `has_many` / `has_one` leave the foreign key to the model they
+            # point at. A `:through` association stores nothing of its own.
+            if [:has_many, :has_one].include?(macro) && !reflection.options[:through]
+              association_foreign_keys[reflection_model_name].concat(foreign_key_columns(reflection))
             end
-            result[:Relations] << {
-              LeftModelName: model[:ModelName],
-              LeftValue: "}o",
-              Line: "--",
-              RightModelName: reflection_model_name,
-              RightValue: right_value,
-              Comment: "BT:#{reflection.name}"
-            }
+
+            association = {owner: model[:ModelName], macro: macro, reflection: reflection, target: reflection_model_name}
+            links[link_key(association)] << association
           end
         end
+      end
 
-        defined_model.reflect_on_all_associations(:has_one).each do |reflection|
-          reflection_model_name = get_reflection_model_name(reflection)
-          next if ignored_model_names.key?(reflection_model_name)
-
-          reverse_relation = result[:Relations].find { |r|
-            if reflection.options[:through]
-              r[:RightModelName] == model[:ModelName] && r[:LeftModelName] == reflection_model_name && r[:Line] == ".."
-            else
-              r[:RightModelName] == model[:ModelName] && r[:LeftModelName] == reflection_model_name && r[:Line] == "--"
-            end
-          }
-          if reverse_relation
-            reverse_relation[:LeftValue] = "|o"
-            reverse_relation[:Comment] = if reflection.options[:through]
-              "#{reverse_relation[:Comment]}, HOT:#{reflection.name}"
-            else
-              "#{reverse_relation[:Comment]}, HO:#{reflection.name}"
-            end
-          else
-            result[:Relations] << {
-              LeftModelName: model[:ModelName],
-              LeftValue: reflection.options[:through] ? "}o" : "||",
-              Line: reflection.options[:through] ? ".." : "--",
-              RightModelName: reflection_model_name,
-              RightValue: "o|",
-              Comment: reflection.options[:through] ? "HOT:#{reflection.name}" : "HO:#{reflection.name}"
-            }
-          end
+      result[:Models].each do |model|
+        model[:Columns].each do |column|
+          column[:key] = "FK" if column[:key].empty? && association_foreign_keys[model[:ModelName]].include?(column[:name])
         end
       end
 
+      result[:Relations] = links.map { |key, associations| relation_for(key, associations) }
+
       result
     end
 
@@ -191,6 +137,132 @@ class RailsMermaidErd::Builder
       end
     end
 
+    # Returns a Hash mapping each single table inheritance subclass name to its
+    # base class name. A subclass that sets its own `table_name` keeps its own
+    # entity, since it no longer shares the base class's table.
+    def compute_sti_base_names
+      ::ActiveRecord::Base.descendants.each_with_object({}) do |defined_model, acc|
+        next unless defined_model.table_exists?
+        next if defined_model.name.include?("HABTM_")
+        base_class = defined_model.base_class
+        next if base_class == defined_model
+        next unless base_class.table_name == defined_model.table_name
+        acc[defined_model.name] = base_class.name
+      end
+    end
+
+    # Returns `[reflection, target model name]` pairs for the associations
+    # declared anywhere in an inheritance hierarchy, with targets resolved to
+    # their base class. A subclass inherits its base class's reflections, so
+    # pairs repeating a name and target are dropped rather than drawn twice.
+    def hierarchy_reflections(hierarchy, macro, sti_base_names)
+      hierarchy
+        .flat_map { |model| model.reflect_on_all_associations(macro) }
+        .map { |reflection|
+          model_name = get_reflection_model_name(reflection)
+          [reflection, sti_base_names.fetch(model_name, model_name)]
+        }
+        .uniq { |reflection, model_name| [reflection.name, model_name] }
+    end
+
+    # Identifies the link between two tables that an association describes, so
+    # that every association describing the same link is drawn as one line —
+    # whichever model declares it and whichever model sorts first — and
+    # associations describing different links are never folded together:
+    #
+    # - A foreign key column is one link: `belongs_to` on the model that holds
+    #   the column, `has_many` / `has_one` on the model it references.
+    # - A join table is one link: both sides of `has_and_belongs_to_many`.
+    # - A `:through` association derives from other links and stores nothing
+    #   of its own, so it is identified by the two models it connects.
+    def link_key(association)
+      owner, target, reflection = association.values_at(:owner, :target, :reflection)
+
+      if reflection.options[:through]
+        [:through, *[owner, target].sort]
+      elsif association[:macro] == :has_and_belongs_to_many
+        [:join_table, reflection.join_table.to_s, *[owner, target].sort]
+      elsif association[:macro] == :belongs_to
+        [:foreign_key, owner, foreign_key_columns(reflection), target]
+      else
+        [:foreign_key, target, foreign_key_columns(reflection), owner]
+      end
+    end
+
+    # Builds the relation line for one link from every association that
+    # describes it, so no glyph depends on the order they were read in.
+    def relation_for(key, associations)
+      case key.first
+      when :foreign_key
+        _, child, _, parent = key
+        macros = associations.map { |association| association[:macro] }
+        optional = associations.any? { |association| association[:macro] == :belongs_to && optional_belongs_to?(association[:reflection]) }
+        {
+          LeftModelName: parent,
+          LeftValue: optional ? "|o" : "||",
+          Line: "--",
+          RightModelName: child,
+          RightValue: (macros.include?(:has_one) && !macros.include?(:has_many)) ? "o|" : "o{",
+          Comment: association_labels(associations)
+        }
+      when :join_table
+        _, _, left, right = key
+        {LeftModelName: left, LeftValue: "}o", Line: "..", RightModelName: right, RightValue: "o{", Comment: "HABTM"}
+      when :through
+        _, left, right = key
+        # Each end is "at most one" only when every association reaching that
+        # end is a `has_one :through`.
+        at_most_one = lambda do |model_name|
+          reaching = associations.select { |association| association[:target] == model_name }
+          reaching.any? && reaching.all? { |association| association[:macro] == :has_one }
+        end
+        {
+          LeftModelName: left,
+          LeftValue: at_most_one.call(left) ? "|o" : "}o",
+          Line: "..",
+          RightModelName: right,
+          RightValue: at_most_one.call(right) ? "o|" : "o{",
+          Comment: association_labels(associations)
+        }
+      end
+    end
+
+    def association_labels(associations)
+      associations.map { |association|
+        reflection = association[:reflection]
+        prefix = {has_many: "HM", has_one: "HO", belongs_to: "BT"}.fetch(association[:macro])
+        prefix = "#{prefix}T" if reflection.options[:through]
+        "#{prefix}:#{reflection.name}"
+      }.join(", ")
+    end
+
+    # Rails may hand back a String or a Symbol, or an Array for a composite key.
+    #
+    # Rails 7.1+ derives an undeclared key from `inverse_of` or the model's
+    # `query_constraints`, and raises when those are misdeclared. The host app
+    # only hits that once it uses the association, so one such declaration
+    # must not abort the whole diagram: fall back to the naming convention.
+    def foreign_key_columns(reflection)
+      Array(reflection.foreign_key).map(&:to_s)
+    rescue NameError, ArgumentError
+      column = if reflection.macro == :belongs_to
+        "#{reflection.name}_id"
+      elsif reflection.options[:as]
+        "#{reflection.options[:as]}_id"
+      else
+        reflection.active_record.name.foreign_key
+      end
+      [column]
+    end
+
+    def optional_belongs_to?(reflection)
+      if ::Rails.application.config.active_record.belongs_to_required_by_default
+        reflection.options[:optional]
+      else
+        !reflection.options[:required]
+      end
+    end
+
     # Doc: https://guides.rubyonrails.org/association_basics.html
     def get_reflection_model_name(reflection)
       if reflection.options[:class_name]

data/lib/rails-mermaid_erd/configuration.rb

@@ -1,11 +1,15 @@
 require "yaml"
 
 class RailsMermaidErd::Configuration
-  attr_accessor :result_path, :ignore_tables
+  attr_accessor :result_path, :ignore_tables, :viewer_defaults
+
+  # Mirrors the Columns choice in the viewer's sidebar.
+  VIEWER_COLUMNS = %w[all keys none].freeze
 
   DEFAULTS = {
     result_path: "mermaid_erd/index.html",
-    ignore_tables: []
+    ignore_tables: [],
+    viewer_defaults: {}
   }.freeze
 
   def initialize
@@ -23,6 +27,7 @@ class RailsMermaidErd::Configuration
 
     @result_path = config[:result_path]
     @ignore_tables = normalize_ignore_tables(config[:ignore_tables])
+    @viewer_defaults = normalize_viewer_defaults(config[:viewer_defaults])
   end
 
   private
@@ -42,4 +47,51 @@ class RailsMermaidErd::Configuration
 
     value
   end
+
+  # The two keys are read one by one rather than merged over a default hash,
+  # so setting only `columns` leaves `models` at its default. Unknown keys are
+  # rejected because a typo such as `column: keys` would otherwise be dropped
+  # without a trace and the viewer would open the way it always did.
+  def normalize_viewer_defaults(value)
+    value = {} if value.nil?
+
+    unless value.is_a?(Hash)
+      raise ArgumentError,
+        "config/mermaid_erd.yml: `viewer_defaults` must be a mapping with `models` and/or `columns`, got #{value.inspect}"
+    end
+
+    unknown = value.keys.map(&:to_s) - %w[models columns]
+    unless unknown.empty?
+      raise ArgumentError,
+        "config/mermaid_erd.yml: unknown `viewer_defaults` key(s) #{unknown.join(", ")}; use `models` and/or `columns`"
+    end
+
+    value = value.transform_keys(&:to_s)
+    {
+      models: normalize_viewer_models(value["models"]),
+      columns: normalize_viewer_columns(value["columns"])
+    }
+  end
+
+  def normalize_viewer_models(value)
+    return [] if value.nil?
+
+    unless value.is_a?(Array) && value.all? { |entry| entry.is_a?(String) && !entry.empty? }
+      raise ArgumentError,
+        "config/mermaid_erd.yml: `viewer_defaults.models` must be an array of non-empty model names, got #{value.inspect}"
+    end
+
+    value.uniq
+  end
+
+  def normalize_viewer_columns(value)
+    return "all" if value.nil?
+
+    unless VIEWER_COLUMNS.include?(value)
+      raise ArgumentError,
+        "config/mermaid_erd.yml: `viewer_defaults.columns` must be one of #{VIEWER_COLUMNS.join(", ")}, got #{value.inspect}"
+    end
+
+    value
+  end
 end

data/lib/rails-mermaid_erd/mermaid_text.rb

@@ -6,13 +6,14 @@ class RailsMermaidErd::MermaidText
   # (lib/templates/index.html.erb): the dump always shows every table, every
   # column with its key marker and comment, and every relation label — i.e.
   # the diagram the viewer produces with all of its detail toggles ("Show
-  # key", "Show comment", "Show relation comment") enabled and with no
-  # model-selection filtering. The viewer defaults those toggles off, so the
-  # dump is deliberately more detailed than the viewer's initial view. The only
-  # thing it drops is the viewer's "Restore Hash" comment line, which encodes
-  # browser-only UI state and is meaningless on the command line. Apart from
-  # that line and a single trailing newline (added by the rake task's `puts`),
-  # it is byte-identical to the viewer's "all toggles on" output.
+  # key", "Show column comment", "Show table comment", "Show relationship
+  # comment") enabled and with no model-selection filtering. The viewer
+  # defaults those toggles off, so the dump is deliberately more detailed than
+  # the viewer's initial view. The only thing it drops is the viewer's
+  # "Restore Hash" comment line, which encodes browser-only UI state and is
+  # meaningless on the command line. Apart from that line and a single trailing
+  # newline (added by the rake task's `puts`), it is byte-identical to the
+  # viewer's "all toggles on" output.
   #
   # Comment values come from arbitrary DB metadata, so they are sanitised the
   # same way the viewer's renderer must (and now does): newlines collapse to a
@@ -39,7 +40,12 @@ class RailsMermaidErd::MermaidText
         lines << "    %% table comment: #{one_line(model[:TableComment])}"
         # Mermaid entity names can't contain ":", so namespaced models like
         # `Admin::User` are written as `Admin-User` (matches the front-end).
-        lines << "    #{model[:ModelName].tr(":", "-")} {"
+        name = model[:ModelName].tr(":", "-")
+        # A model with a table comment gets Mermaid's entity alias, so its
+        # heading reads "Model / comment" while relations keep using the name.
+        comment = one_line(model[:TableComment])
+        alias_label = comment.empty? ? "" : %(["#{name} / #{comment.gsub('"', "#quot;")}"])
+        lines << "    #{name}#{alias_label} {"
         model[:Columns].each do |column|
           lines << "        #{column[:type]} #{column[:name]} #{column[:key]} #{quoted(column[:comment])}"
         end

data/lib/rails-mermaid_erd/version.rb

@@ -1,3 +1,3 @@
 module RailsMermaidErd
-  VERSION = "0.8.0"
+  VERSION = "0.8.2"
 end

data/lib/tasks/mermaid_erd.rake

@@ -12,12 +12,36 @@ desc "Generate Mermaid ERD."
 task mermaid_erd: :environment do
   result = RailsMermaidErd::Builder.model_data
 
+  viewer_defaults = RailsMermaidErd.configuration.viewer_defaults
+  # A model that was renamed, or whose table is now in `ignore_tables`, would
+  # otherwise leave the viewer opening on a selection that quietly lost a
+  # model. Don't fail the build over it — the diagram is still usable — but say
+  # which names were dropped.
+  unknown_models = viewer_defaults[:models] - result[:Models].map { |model| model[:ModelName] }
+  unless unknown_models.empty?
+    warn "rails-mermaid_erd: `viewer_defaults.models` in config/mermaid_erd.yml lists " \
+         "#{unknown_models.join(", ")}, which #{unknown_models.one? ? "is" : "are"} not in the diagram; not preselecting."
+    viewer_defaults = viewer_defaults.merge(models: viewer_defaults[:models] - unknown_models)
+  end
+
   version = RailsMermaidErd::VERSION
   app_name = ::Rails.application.class.try(:parent_name) || ::Rails.application.class.try(:module_parent_name)
   logo = RailsMermaidErd.read_gem_asset("./assets/logo.svg")
-  tailwindcss_js = RailsMermaidErd.read_gem_asset("./templates/vendor/tailwindcss.js")
+  tailwind_css = RailsMermaidErd.read_gem_asset("./templates/vendor/tailwind.css")
   mermaid_js = RailsMermaidErd.read_gem_asset("./templates/vendor/mermaid.min.js")
   vue_js = RailsMermaidErd.read_gem_asset("./templates/vendor/vue.global.prod.min.js")
+  # Everything in the page is redistributed: the viewer under the gem's own
+  # license, the bundled libraries under theirs. Carrying the notices in the
+  # file keeps a shared copy within those licenses.
+  license_notices = <<~NOTICE.strip
+    This file was generated by rails-mermaid_erd, which is distributed under the MIT License:
+
+    #{RailsMermaidErd.read_gem_asset("../LICENSE").strip}
+
+    ----------------------------------------------------------------------
+
+    #{RailsMermaidErd.read_gem_asset("./templates/vendor/LICENSES.md").strip}
+  NOTICE
   erb = ERB.new(RailsMermaidErd.read_gem_asset("./templates/index.html.erb"))
   result_html = erb.result(binding)