rails-erd 2.0.1 → 2.1.0

data/test/unit/diagram_test.rb

@@ -165,6 +165,76 @@ class DiagramTest < ActiveSupport::TestCase
     assert_equal [Author, Editor], retrieve_entities(:only => ['Author', 'Editor']).map(&:model)
   end
 
+  test "generate should exclude relationships whose endpoints were removed by :only" do
+    create_model "Author"
+    create_model "Book", :author => :references do
+      belongs_to :author
+      has_many :reviews
+    end
+    create_model "Review", :book => :references do
+      belongs_to :book
+    end
+    relationships = retrieve_relationships(:only => [:Author, :Book])
+    assert_equal [Set[Author, Book]], relationships.map { |r| Set[r.source.model, r.destination.model] }
+  end
+
+  test "generate should exclude relationships to an excluded entity" do
+    create_model "Author"
+    create_model "Book", :author => :references do
+      belongs_to :author
+      has_many :reviews
+    end
+    create_model "Review", :book => :references do
+      belongs_to :book
+    end
+    relationships = retrieve_relationships(:exclude => [:Review])
+    assert_equal [Set[Author, Book]], relationships.map { |r| Set[r.source.model, r.destination.model] }
+  end
+
+  # Pattern matching for exclude/only ==========================================
+  test "generate should filter entities matching glob pattern in exclude" do
+    create_module_model "SolidQueue::Job"
+    create_module_model "SolidQueue::Process"
+    create_model "User"
+    assert_equal [User], retrieve_entities(:exclude => ["SolidQueue::*"]).map(&:model)
+  end
+
+  test "generate should filter entities matching regex pattern in exclude" do
+    create_module_model "SolidQueue::Job"
+    create_model "User"
+    assert_equal [User], retrieve_entities(:exclude => ["/^Solid/"]).map(&:model)
+  end
+
+  test "generate should include only entities matching glob pattern in only" do
+    create_module_model "MyApp::User"
+    create_module_model "MyApp::Post"
+    create_model "SomeOther"
+    entities = retrieve_entities(:only => ["MyApp::*"]).map(&:model)
+    assert_includes entities, MyApp::User
+    assert_includes entities, MyApp::Post
+    refute_includes entities, SomeOther
+  end
+
+  test "generate should include only entities matching regex pattern in only" do
+    create_model "AdminUser"
+    create_model "AdminPost"
+    create_model "GuestUser"
+    entities = retrieve_entities(:only => ["/^Admin/"]).map(&:model)
+    assert_includes entities, AdminUser
+    assert_includes entities, AdminPost
+    refute_includes entities, GuestUser
+  end
+
+  test "generate should exclude relationships when endpoint matches glob pattern" do
+    create_module_model "SolidQueue::Job"
+    create_model "Task", :solid_queue_job => :references do
+      belongs_to :solid_queue_job, :class_name => "SolidQueue::Job"
+    end
+    create_model "User"
+    relationships = retrieve_relationships(:exclude => ["SolidQueue::*"])
+    assert_equal [], relationships
+  end
+
   test "generate should filter disconnected entities if disconnected is false" do
     create_model "Book", :author => :references do
       belongs_to :author
@@ -235,7 +305,7 @@ class DiagramTest < ActiveSupport::TestCase
     create_model "Baz", :foo => :references do
       belongs_to :foo
     end
-    assert_equal [false, false, true], retrieve_relationships(:indirect => true).map(&:indirect?)
+    assert_equal({ false => 2, true => 1 }, retrieve_relationships(:indirect => true).map(&:indirect?).tally)
   end
 
   test "generate should filter indirect relationships if indirect is false" do
@@ -302,6 +372,21 @@ class DiagramTest < ActiveSupport::TestCase
       :polymorphism => true).map { |s| s.specialized.name }
   end
 
+  test "generate should not yield specializations whose entity is not part of the domain" do
+    # An abstract parent whose child model has no table (e.g. ActionMailbox::Record
+    # with a tableless ActionMailbox::InboundEmail): the child is excluded from the
+    # domain, so the specialization resolves to a nameless Null entity. It must not
+    # be yielded, otherwise generators emit an edge to a nameless entity (which is
+    # invalid Mermaid output).
+    Object.const_set "GhostRecord", Class.new(ActiveRecord::Base) { self.abstract_class = true }
+    Object.const_set "GhostThing", Class.new(GhostRecord)
+
+    specializations = retrieve_specializations(:inheritance => true, :polymorphism => true)
+    assert_equal [], specializations.select { |s|
+      s.generalized.name.to_s.empty? || s.specialized.name.to_s.empty?
+    }
+  end
+
   # Attribute filtering ======================================================
   test "generate should yield content attributes by default" do
     create_model "Book", :title => :string, :created_at => :datetime, :author => :references do
@@ -358,4 +443,57 @@ class DiagramTest < ActiveSupport::TestCase
     Object.const_set :Whisky, Class.new(Beverage)
     assert_equal [], retrieve_attribute_lists(:inheritance => true)[Whisky].map(&:name)
   end
+
+  test "generate should hide all attributes for a model excluded with true" do
+    create_model "Book", :title => :string, :pages => :integer
+    create_model "Author", :name => :string
+    attribute_lists = retrieve_attribute_lists(:exclude_attributes => { "Book" => true })
+    assert_equal [], attribute_lists[Book].map(&:name)
+    assert_equal %w{name}, attribute_lists[Author].map(&:name)
+  end
+
+  test "generate should hide only listed attributes for a model" do
+    create_model "Book", :title => :string, :subtitle => :string, :pages => :integer
+    attribute_lists = retrieve_attribute_lists(:exclude_attributes => { "Book" => ["subtitle"] })
+    assert_equal %w{pages title}, attribute_lists[Book].map(&:name).sort
+  end
+
+  test "generate should hide attributes for the listed model only" do
+    create_model "Book", :title => :string
+    create_model "Author", :name => :string
+    attribute_lists = retrieve_attribute_lists(:exclude_attributes => { "Book" => ["title"] })
+    assert_equal [], attribute_lists[Book].map(&:name)
+    assert_equal %w{name}, attribute_lists[Author].map(&:name)
+  end
+
+  test "generate should accept exclude_attributes as a string" do
+    create_model "Book", :title => :string, :subtitle => :string
+    create_model "Author", :name => :string
+    attribute_lists = retrieve_attribute_lists(:exclude_attributes => "Book.subtitle,Author")
+    assert_equal %w{title}, attribute_lists[Book].map(&:name)
+    assert_equal [], attribute_lists[Author].map(&:name)
+  end
+
+  test "normalize_exclude_attributes should split namespaced models on the first dot only" do
+    assert_equal({ "Admin::User" => ["password_digest"] },
+      Diagram.normalize_exclude_attributes("Admin::User.password_digest"))
+  end
+
+  test "normalize_exclude_attributes should treat a bare namespaced model as hide all" do
+    assert_equal({ "Admin::User" => true },
+      Diagram.normalize_exclude_attributes("Admin::User"))
+  end
+
+  test "normalize_exclude_attributes should return an empty hash for nil" do
+    assert_equal({}, Diagram.normalize_exclude_attributes(nil))
+  end
+
+  test "normalize_exclude_attributes should return an empty hash for false" do
+    assert_equal({}, Diagram.normalize_exclude_attributes(false))
+  end
+
+  test "normalize_exclude_attributes should ignore blank entries in a string" do
+    assert_equal({ "Book" => true },
+      Diagram.normalize_exclude_attributes("Book, ,"))
+  end
 end

data/test/unit/domain_test.rb

@@ -151,6 +151,23 @@ class DomainTest < ActiveSupport::TestCase
     assert_equal ["Many", "More"], [relationship.source.name, relationship.destination.name]
   end
 
+  test "relationships should be deterministic regardless of model order" do
+    create_model "Author"
+    create_model "Book", :author => :references do
+      belongs_to :author
+      has_many :reviews
+    end
+    create_model "Review", :book => :references do
+      belongs_to :book
+    end
+    pairs = lambda do |models|
+      Domain.new(models).relationships.collect { |r| [r.source.name, r.destination.name] }
+    end
+    models = [Author, Book, Review]
+    # Order and source/destination direction must not depend on the input model order.
+    assert_equal pairs.call(models), pairs.call(models.reverse)
+  end
+
   # Specialization processing ================================================
   test "specializations should return empty array for empty domain" do
     assert_equal [], Domain.generate.specializations
@@ -255,6 +272,19 @@ class DomainTest < ActiveSupport::TestCase
     assert_match(/polymorphic interface FooBar does not exist/, output)
   end
 
+  test "relationships should not crash when exclude is present and a polymorphic association's interface does not exist" do
+    create_model "Foo" do
+      has_many :bars, :as => :foo
+    end
+    create_model "Bar", :foobar => :references do
+      belongs_to :foo_bar, :polymorphic => true
+    end
+    output = collect_stdout do
+      Domain.generate(:exclude => ["Qux"]).relationships
+    end
+    assert_match(/polymorphic interface FooBar does not exist/, output)
+  end
+
   test "relationships should not warn when a bad association is encountered if warnings are disabled" do
     create_model "Foo" do
       has_many :flabs
@@ -288,4 +318,91 @@ class DomainTest < ActiveSupport::TestCase
     end
     assert_equal "", output
   end
+
+  # Pattern matching for exclude/only ==========================================
+  test "matches_pattern? should match exact string" do
+    domain = Domain.new([])
+    assert domain.send(:matches_pattern?, "Foo", "Foo")
+    refute domain.send(:matches_pattern?, "Foo", "Bar")
+  end
+
+  test "matches_pattern? should match glob pattern with asterisk" do
+    domain = Domain.new([])
+    assert domain.send(:matches_pattern?, "SolidQueue::*", "SolidQueue::Job")
+    assert domain.send(:matches_pattern?, "SolidQueue::*", "SolidQueue::Process")
+    refute domain.send(:matches_pattern?, "SolidQueue::*", "SolidCache::Entry")
+  end
+
+  test "matches_pattern? should match glob pattern without namespace separator" do
+    domain = Domain.new([])
+    assert domain.send(:matches_pattern?, "ActiveStorage*", "ActiveStorageBlob")
+    assert domain.send(:matches_pattern?, "ActiveStorage*", "ActiveStorage::Blob")
+    refute domain.send(:matches_pattern?, "ActiveStorage*", "ActionMailbox::InboundEmail")
+  end
+
+  test "matches_pattern? should match regex pattern" do
+    domain = Domain.new([])
+    assert domain.send(:matches_pattern?, "/^Active/", "ActiveRecord")
+    assert domain.send(:matches_pattern?, "/^Active/", "ActiveStorage::Blob")
+    refute domain.send(:matches_pattern?, "/^Active/", "SolidQueue::Job")
+  end
+
+  test "matches_pattern? should match regex pattern with flags" do
+    domain = Domain.new([])
+    assert domain.send(:matches_pattern?, "/queue/i", "SolidQueue::Job")
+    refute domain.send(:matches_pattern?, "/queue/", "SolidQueue::Job")
+  end
+
+  test "excluded_model? should match glob patterns" do
+    create_module_model "SolidQueue::Job"
+    create_module_model "SolidQueue::Process"
+    create_model "User"
+
+    domain = Domain.generate(:exclude => ["SolidQueue::*"])
+
+    # excluded_model? returns true for matching patterns
+    assert domain.send(:excluded_model?, SolidQueue::Job)
+    assert domain.send(:excluded_model?, SolidQueue::Process)
+    refute domain.send(:excluded_model?, User)
+  end
+
+  test "excluded_model? should match regex patterns" do
+    create_module_model "SolidQueue::Job"
+    create_model "User"
+
+    domain = Domain.generate(:exclude => ["/^Solid/"])
+    assert domain.send(:excluded_model?, SolidQueue::Job)
+    refute domain.send(:excluded_model?, User)
+  end
+
+  test "excluded_model? should still match exact names for backward compatibility" do
+    create_model "Foo"
+    create_model "Bar"
+
+    domain = Domain.generate(:exclude => ["Foo"])
+    assert domain.send(:excluded_model?, Foo)
+    refute domain.send(:excluded_model?, Bar)
+  end
+
+  test "excluded_association? should match glob patterns for source model" do
+    create_module_model "SolidQueue::Job" do
+      has_many :executions
+    end
+    create_model "User"
+
+    domain = Domain.generate(:exclude => ["SolidQueue::*"], :warn => false)
+    association = SolidQueue::Job.reflect_on_association(:executions)
+    assert domain.send(:excluded_association?, association)
+  end
+
+  test "excluded_association? should match glob patterns for target model" do
+    create_module_model "SolidQueue::Execution"
+    create_model "Task" do
+      has_many :executions, :class_name => "SolidQueue::Execution"
+    end
+
+    domain = Domain.generate(:exclude => ["SolidQueue::*"], :warn => false)
+    association = Task.reflect_on_association(:executions)
+    assert domain.send(:excluded_association?, association)
+  end
 end

data/test/unit/mermaid_test.rb

@@ -230,9 +230,9 @@ class MermaidTest < ActiveSupport::TestCase
       "\tclass `Bar`",
       "\tclass `Baz`",
       "\tclass `Foo`",
-      "\t`Foo` --> `Baz`",
       "\t`Foo` --> `Bar`",
-      "\t`Bar` ..> `Baz`"
+      "\t`Bar` ..> `Baz`",
+      "\t`Foo` --> `Baz`"
     ]
 
     assert_equal expected, diagram.graph.uniq
@@ -437,4 +437,126 @@ class MermaidTest < ActiveSupport::TestCase
     # Verify the specialization relationship line also quotes it
     assert result.match?(/Vehicle.*--.*"Transport::Car"/), "Specialization relationship should quote namespaced entity"
   end
+
+  # Namespace clustering tests (Issue #479) =====================================
+
+  test "classDiagram with cluster should group entities by namespace" do
+    create_model "Post"
+    create_module_model "Admin::Author", :post => :references do
+      belongs_to :post
+    end
+    create_module_model "Admin::Role"
+
+    result = diagram(:cluster => true).graph.join("\n")
+
+    assert result.include?("classDiagram")
+    # Should have namespace block for Admin
+    assert result.include?("namespace Admin {"), "Should have namespace block for Admin"
+    # Author and Role should be inside the Admin namespace
+    assert result.match?(/namespace Admin \{[^}]*class `Author`/m), "Author should be inside Admin namespace"
+    assert result.match?(/namespace Admin \{[^}]*class `Role`/m), "Role should be inside Admin namespace"
+  end
+
+  test "classDiagram with cluster should place entities without namespace outside blocks" do
+    create_model "Post"
+    create_module_model "Admin::Author", :post => :references do
+      belongs_to :post
+    end
+
+    result = diagram(:cluster => true).graph.join("\n")
+
+    # Post should appear before any namespace block
+    post_index = result.index("class `Post`")
+    namespace_index = result.index("namespace Admin {")
+    assert post_index < namespace_index, "Entities without namespace should appear before namespace blocks"
+  end
+
+  test "classDiagram with cluster should handle nested namespaces" do
+    create_model "Post"
+    create_module_model "Admin::Users::Role", :post => :references do
+      belongs_to :post
+    end
+
+    result = diagram(:cluster => true).graph.join("\n")
+
+    # Nested namespace should use dot notation (Admin.Users)
+    assert result.include?("namespace Admin.Users {"), "Should convert :: to . in namespace names"
+    assert result.match?(/namespace Admin\.Users \{[^}]*class `Role`/m), "Role should be inside Admin.Users namespace"
+  end
+
+  test "classDiagram with cluster should render relationships outside namespace blocks" do
+    create_model "Post"
+    create_module_model "Admin::Author", :post => :references do
+      belongs_to :post
+    end
+
+    result = diagram(:cluster => true).graph.join("\n")
+
+    # Relationship should appear after the namespace block closes
+    namespace_close_index = result.index("}")
+    relationship_index = result.index("`Post` --> `Admin::Author`")
+    assert relationship_index > namespace_close_index, "Relationships should appear after namespace blocks"
+  end
+
+  test "erDiagram with cluster should emit warning and render flat" do
+    create_model "Post"
+    create_module_model "Admin::Author", :post => :references do
+      belongs_to :post
+    end
+
+    test_diagram = nil
+
+    warning_output = collect_stdout do
+      domain = Domain.generate
+      test_diagram = Diagram::Mermaid.new(domain, :cluster => true, :mermaid_style => :erdiagram, :warn => true)
+      test_diagram.generate
+    end
+
+    result = test_diagram.graph.join("\n")
+
+    # Should emit warning about clustering not supported
+    assert warning_output.include?("Clustering is not supported"), "Should warn about clustering not supported in erDiagram"
+    # Should still render the diagram (flat, no namespace blocks)
+    assert result.include?("erDiagram")
+    refute result.include?("namespace"), "erDiagram should not have namespace blocks"
+  end
+
+  test "classDiagram with cluster false should not group entities" do
+    create_model "Post"
+    create_module_model "Admin::Author", :post => :references do
+      belongs_to :post
+    end
+
+    result = diagram(:cluster => false).graph.join("\n")
+
+    assert result.include?("classDiagram")
+    # Should NOT have namespace blocks
+    refute result.include?("namespace"), "cluster: false should not create namespace blocks"
+    # Should use full entity names
+    assert result.include?("class `Admin::Author`"), "Should use full entity name without clustering"
+  end
+
+  test "classDiagram with cluster and inheritance should emit entities before specializations" do
+    create_model "Vehicle", :type => :string
+    create_module_model "Transport::Car", Vehicle
+
+    result = diagram(:cluster => true, :inheritance => true).graph.join("\n")
+
+    # Entity class definitions should appear BEFORE specialization lines
+    vehicle_class_index = result.index("class `Vehicle`")
+    polymorphic_index = result.index("<<polymorphic>>")
+    inheritance_index = result.index("<|--")
+
+    assert vehicle_class_index, "Should have Vehicle class definition.\nGot:\n#{result}"
+    assert polymorphic_index, "Should have polymorphic marker.\nGot:\n#{result}"
+    assert inheritance_index, "Should have inheritance relationship.\nGot:\n#{result}"
+
+    # The key assertion: class definitions must come BEFORE specializations
+    assert vehicle_class_index < polymorphic_index,
+      "Class definitions should appear before polymorphic markers.\n" \
+      "Got:\n#{result}"
+    assert vehicle_class_index < inheritance_index,
+      "Class definitions should appear before inheritance relationships.\n" \
+      "Got:\n#{result}"
+  end
 end

data/test/unit/tbls_test.rb

@@ -0,0 +1,152 @@
+# frozen_string_literal: true
+
+require File.expand_path("../test_helper", File.dirname(__FILE__))
+require "rails_erd/diagram/tbls"
+require "json"
+
+class TblsTest < ActiveSupport::TestCase
+  def setup
+    RailsERD.options.warn = false
+  end
+
+  def diagram(options = {})
+    Diagram::Tbls.new(Domain.generate(options), options).tap(&:generate)
+  end
+
+  def payload(options = {})
+    diagram(options).send(:schema_payload)
+  end
+
+  def table(payload, name)
+    payload[:tables].find { |t| t[:name] == name }
+  end
+
+  def constraint(table, type)
+    table[:constraints].find { |c| c[:type] == type }
+  end
+
+  # File output ==============================================================
+  test "filename has json extension" do
+    create_simple_domain
+    result = Diagram::Tbls.create
+    assert result.end_with?(".json"), "Expected .json, got #{result}"
+  end
+
+  test "written file is valid JSON parseable by tbls schema shape" do
+    create_simple_domain
+    file = Diagram::Tbls.create
+    parsed = JSON.parse(File.read(file))
+
+    assert parsed.key?("tables")
+    assert parsed["tables"].is_a?(Array)
+    assert parsed["tables"].all? { |t| t.key?("name") && t.key?("columns") }
+  end
+
+  # Tables ===================================================================
+  test "emits one table per concrete entity using db table name" do
+    create_simple_domain
+    p = payload
+
+    names = p[:tables].map { |t| t[:name] }.sort
+    assert_equal %w[bars beers], names
+  end
+
+  test "columns carry name, type, nullable; default and comment only when set" do
+    create_model "Widget", name: :string, qty: :integer do
+      belongs_to :gizmo, optional: true
+    end
+    create_model "Gizmo"
+
+    widgets = table(payload, "widgets")
+    name_col = widgets[:columns].find { |c| c[:name] == "name" }
+
+    assert name_col[:type].start_with?("varchar"), "Expected varchar type, got #{name_col[:type]}"
+    assert_equal true, name_col[:nullable]
+    # tbls schema rejects null comments/defaults — they must be omitted, not nulled.
+    refute_includes name_col.keys, :default
+    refute_includes name_col.keys, :comment
+  end
+
+  # Primary keys =============================================================
+  test "every table gets a PRIMARY KEY constraint" do
+    create_simple_domain
+
+    table(payload, "beers")[:constraints].tap do |constraints|
+      pk = constraints.find { |c| c[:type] == "PRIMARY KEY" }
+      assert pk, "expected a PRIMARY KEY constraint"
+      assert_equal ["id"], pk[:columns]
+      assert_equal "beers_pkey", pk[:name]
+    end
+  end
+
+  # Foreign keys =============================================================
+  test "belongs_to becomes a FOREIGN KEY constraint on the owning table" do
+    create_simple_domain  # Beer belongs_to :bar
+
+    beers = table(payload, "beers")
+    fk = constraint(beers, "FOREIGN KEY")
+
+    assert fk, "expected a FOREIGN KEY constraint on beers"
+    assert_equal ["bar_id"], fk[:columns]
+    assert_equal "bars", fk[:referenced_table]
+    assert_equal ["id"], fk[:referenced_columns]
+  end
+
+  test "FK def string is parseable by tbls parser" do
+    create_simple_domain
+    fk = constraint(table(payload, "beers"), "FOREIGN KEY")
+
+    assert_equal "FOREIGN KEY (bar_id) REFERENCES bars(id)", fk[:def]
+  end
+
+  test "has_many side does not get an FK; only the belongs_to side does" do
+    create_one_to_many_assoc_domain  # One has_many :many; Many belongs_to :one
+
+    ones = table(payload, "ones")
+    manies = table(payload, "manies")
+
+    assert_nil constraint(ones, "FOREIGN KEY"), "owner side must not have an FK"
+    assert constraint(manies, "FOREIGN KEY"), "belongs_to side must have an FK"
+  end
+
+  test "polymorphic associations are skipped (no synthetic FK)" do
+    create_polymorphic_generalization  # Cannon belongs_to :defensible, polymorphic; Galleon has_many :cannons, as: :defensible
+
+    cannons = table(payload(polymorphism: true), "cannons")
+    assert_nil constraint(cannons, "FOREIGN KEY"),
+      "polymorphic belongs_to has no concrete target — must not emit FK"
+  end
+
+  test "indirect (has_many :through) relationships do not produce extra constraints" do
+    create_model "Author" do
+      has_many :authorships
+      has_many :books, through: :authorships
+    end
+    create_model "Book" do
+      has_many :authorships
+      has_many :authors, through: :authorships
+    end
+    create_model "Authorship", author: :references, book: :references do
+      belongs_to :author
+      belongs_to :book
+    end
+
+    authorships = table(payload, "authorships")
+    fk_targets = authorships[:constraints]
+      .select { |c| c[:type] == "FOREIGN KEY" }
+      .map { |c| c[:referenced_table] }
+      .sort
+
+    # Exactly two FKs — author + book — not duplicated by the indirect relationship.
+    assert_equal %w[authors books], fk_targets
+  end
+
+  # Schema-level payload =====================================================
+  test "top-level payload has a name and a tables array" do
+    create_simple_domain
+    p = payload
+
+    assert p[:name].is_a?(String) && !p[:name].empty?
+    assert p[:tables].is_a?(Array)
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rails-erd
 version: !ruby/object:Gem::Version
-  version: 2.0.1
+  version: 2.1.0
 platform: ruby
 authors:
 - Rolf Timmermans
@@ -118,6 +118,8 @@ executables:
 extensions: []
 extra_rdoc_files: []
 files:
+- CHANGES.md
+- LICENSE.md
 - README.md
 - Rakefile
 - bin/erd
@@ -131,6 +133,7 @@ files:
 - lib/rails_erd/diagram.rb
 - lib/rails_erd/diagram/graphviz.rb
 - lib/rails_erd/diagram/mermaid.rb
+- lib/rails_erd/diagram/tbls.rb
 - lib/rails_erd/diagram/templates/node.html.erb
 - lib/rails_erd/diagram/templates/node.record.erb
 - lib/rails_erd/domain.rb
@@ -160,6 +163,7 @@ files:
 - test/unit/rake_task_test.rb
 - test/unit/relationship_test.rb
 - test/unit/specialization_test.rb
+- test/unit/tbls_test.rb
 homepage: https://github.com/voormedia/rails-erd
 licenses:
 - MIT
@@ -199,3 +203,4 @@ test_files:
 - test/unit/rake_task_test.rb
 - test/unit/relationship_test.rb
 - test/unit/specialization_test.rb
+- test/unit/tbls_test.rb