rails-erd 0.4.5 → 1.0.0

data/test/unit/entity_test.rb

@@ -4,17 +4,17 @@ class EntityTest < ActiveSupport::TestCase
   def create_entity(model)
     Domain::Entity.new(Domain.new, model.name, model)
   end
-  
+
   def create_generalized_entity(name)
     Domain::Entity.new(Domain.new, name)
   end
-  
+
   # Entity ===================================================================
   test "model should return active record model" do
     create_models "Foo"
     assert_equal Foo, create_entity(Foo).model
   end
-  
+
   test "name should return model name" do
     create_models "Foo"
     assert_equal "Foo", create_entity(Foo).name
@@ -25,7 +25,7 @@ class EntityTest < ActiveSupport::TestCase
     foo, bar = create_entity(Foo), create_entity(Bar)
     assert_equal [bar, foo], [foo, bar].sort
   end
-  
+
   test "to_s should equal name" do
     create_models "Foo"
     assert_equal "Foo", create_entity(Foo).to_s
@@ -49,7 +49,7 @@ class EntityTest < ActiveSupport::TestCase
     foo = domain.entity_by_name("Foo")
     assert_equal domain.relationships.select { |r| r.destination == foo }, foo.relationships
   end
-  
+
   test "relationships should return relationships that connect to this model" do
     create_model "Foo", :bar => :references
     create_model "Bar", :baz => :references do
@@ -67,24 +67,24 @@ class EntityTest < ActiveSupport::TestCase
   #   create_model "Foo"
   #   assert_nil create_entity(Foo).parent
   # end
-  # 
+  #
   # test "parent should return nil for specialized entities with distinct tables" do
   #   create_model "Foo", :type => :string
   #   Object.const_set :SpecialFoo, Class.new(Foo)
   #   SpecialFoo.class_eval do
-  #     set_table_name "special_foo"
+  #     self.table_name = "special_foo"
   #   end
   #   create_table "special_foo", {}, true
   #   assert_nil create_entity(SpecialFoo).parent
   # end
-  # 
+  #
   # test "parent should return parent entity for specialized entities" do
   #   create_model "Foo", :type => :string
   #   Object.const_set :SpecialFoo, Class.new(Foo)
   #   domain = Domain.generate
   #   assert_equal domain.entity_by_name("Foo"), Domain::Entity.from_models(domain, [SpecialFoo]).first.parent
   # end
-  # 
+  #
   # test "parent should return parent entity for specializations of specialized entities" do
   #   create_model "Foo", :type => :string
   #   Object.const_set :SpecialFoo, Class.new(Foo)
@@ -119,7 +119,7 @@ class EntityTest < ActiveSupport::TestCase
     create_model "Bar"
     assert_equal [false, false], Domain.generate.entities.map(&:disconnected?)
   end
-  
+
   test "specialized should return false for regular entities" do
     create_model "Foo"
     assert_equal false, create_entity(Foo).specialized?
@@ -129,7 +129,7 @@ class EntityTest < ActiveSupport::TestCase
     create_model "Foo", :type => :string
     Object.const_set :SpecialFoo, Class.new(Foo)
     SpecialFoo.class_eval do
-      set_table_name "special_foo"
+      self.table_name = "special_foo"
     end
     create_table "special_foo", {}, true
     assert_equal false, create_entity(SpecialFoo).specialized?
@@ -153,17 +153,17 @@ class EntityTest < ActiveSupport::TestCase
     Object.const_set :SpecialFoo, Class.new(Foo)
     assert_equal true, create_entity(SpecialFoo).abstract?
   end
-  
+
   test "generalized should return false for regular entity" do
     create_model "Concrete"
     assert_equal false, create_entity(Concrete).generalized?
   end
-  
+
   test "abstract should return false for regular entity" do
     create_model "Concrete"
     assert_equal false, create_entity(Concrete).abstract?
   end
-  
+
   # Attribute processing =====================================================
   test "attributes should return list of attributes" do
     create_model "Bar", :some_column => :integer, :another_column => :string
@@ -179,23 +179,23 @@ class EntityTest < ActiveSupport::TestCase
   test "model should return nil for generalized entity" do
     assert_nil create_generalized_entity("MyAbstractModel").model
   end
-  
+
   test "name should return given name for generalized entity" do
     assert_equal "MyAbstractModel", create_generalized_entity("MyAbstractModel").name
   end
-  
+
   test "attributes should return empty array for generalized entity" do
     assert_equal [], create_generalized_entity("MyAbstractModel").attributes
   end
-  
+
   test "generalized should return true for generalized entity" do
     assert_equal true, create_generalized_entity("MyAbstractModel").generalized?
   end
-  
+
   test "specialized should return false for generalized entity" do
     assert_equal false, create_generalized_entity("MyAbstractModel").specialized?
   end
-  
+
   test "abstract should return true for generalized entity" do
     assert_equal true, create_generalized_entity("MyAbstractModel").abstract?
   end

data/test/unit/graphviz_test.rb

@@ -8,7 +8,7 @@ class GraphvizTest < ActiveSupport::TestCase
   end
 
   def teardown
-    FileUtils.rm Dir["ERD.*"] rescue nil
+    FileUtils.rm Dir["erd.*"] rescue nil
     RailsERD::Diagram.send :remove_const, :Graphviz rescue nil
   end
 
@@ -54,9 +54,9 @@ class GraphvizTest < ActiveSupport::TestCase
   test "file name should depend on file type" do
     create_simple_domain
     begin
-      assert_equal "ERD.svg", Diagram::Graphviz.create(:filetype => :svg)
+      assert_equal "erd.svg", Diagram::Graphviz.create(:filetype => :svg)
     ensure
-      FileUtils.rm "ERD.svg" rescue nil
+      FileUtils.rm "erd.svg" rescue nil
     end
   end
 
@@ -77,19 +77,19 @@ class GraphvizTest < ActiveSupport::TestCase
     end
     create_model "Bar", :column => :string
     Diagram::Graphviz.create
-    assert File.exists?("ERD.png")
+    assert File.exists?("erd.png")
   end
 
   test "create should create output for domain without attributes" do
     create_simple_domain
     Diagram::Graphviz.create
-    assert File.exists?("ERD.png")
+    assert File.exists?("erd.png")
   end
 
   test "create should write to file with dot extension if type is dot" do
     create_simple_domain
     Diagram::Graphviz.create :filetype => :dot
-    assert File.exists?("ERD.dot")
+    assert File.exists?("erd.dot")
   end
 
   test "create should write to file with dot extension without requiring graphviz" do
@@ -115,18 +115,18 @@ class GraphvizTest < ActiveSupport::TestCase
     end
     create_model "Bar", :column => :string
     Diagram::Graphviz.create(:orientation => :vertical)
-    assert File.exists?("ERD.png")
+    assert File.exists?("erd.png")
   end
 
   test "create should create output for domain if orientation is vertical" do
     create_simple_domain
     Diagram::Graphviz.create(:orientation => :vertical)
-    assert File.exists?("ERD.png")
+    assert File.exists?("erd.png")
   end
 
   test "create should not create output if there are no connected models" do
     Diagram::Graphviz.create rescue nil
-    assert !File.exists?("ERD.png")
+    assert !File.exists?("erd.png")
   end
 
   test "create should abort and complain if there are no connected models" do
@@ -341,7 +341,7 @@ class GraphvizTest < ActiveSupport::TestCase
     assert_equal [["normal", "normal"]], find_dot_edge_styles(diagram(:notation => :simple))
   end
 
-  # Advanced notation style ===================================================
+  # Advanced notation style ==================================================
   test "generate should use open dots for one to one cardinalities with bachman notation" do
     create_one_to_one_assoc_domain
     assert_equal [["odot", "odot"]], find_dot_edge_styles(diagram(:notation => :bachman))
@@ -383,4 +383,47 @@ class GraphvizTest < ActiveSupport::TestCase
     end
     assert_equal [["dotnormal", "dotnormal"]], find_dot_edge_styles(diagram(:notation => :bachman))
   end
+
+  # Crows-foot notation style ================================================
+  test "generate should use 0/1 crowsfeet for one to one cardinalities with crowsfoot notation" do
+    create_one_to_one_assoc_domain
+    assert_equal [["teeodot", "teeodot"]], find_dot_edge_styles(diagram(:notation => :crowsfoot))
+  end
+
+  test "generate should use 1/1 crowsfeet for mandatory one to one cardinalities with crowsfoot notation" do
+    create_one_to_one_assoc_domain
+    One.class_eval do
+      validates_presence_of :other
+    end
+    assert_equal [["teeodot","teetee"]], find_dot_edge_styles(diagram(:notation => :crowsfoot))
+  end
+
+  test "generate should use 0/* crowsfeet with 0/1 crowsfeet for one to many cardinalities with crowsfoot notation" do
+    create_one_to_many_assoc_domain
+    assert_equal [["teeodot", "crowodot"]], find_dot_edge_styles(diagram(:notation => :crowsfoot))
+  end
+
+  test "generate should use 0/* crowsfeet with 1/1 crowsfett for mandatory one to many cardinalities with crowsfoot notation" do
+    create_one_to_many_assoc_domain
+    One.class_eval do
+      validates_presence_of :many
+    end
+    assert_equal [["teeodot", "crowtee"]], find_dot_edge_styles(diagram(:notation => :crowsfoot))
+  end
+
+  test "generate should use 0/* and 0/* crowsfeet for many to many cardinalities with crowsfoot notation" do
+    create_many_to_many_assoc_domain
+    assert_equal [["crowodot", "crowodot"]], find_dot_edge_styles(diagram(:notation => :crowsfoot))
+  end
+
+  test "generate should use 1/* and 1/* tail and head for mandatory many to many cardinalities with crowsfoot notation" do
+    create_many_to_many_assoc_domain
+    Many.class_eval do
+      validates_presence_of :more
+    end
+    More.class_eval do
+      validates_presence_of :many
+    end
+    assert_equal [["crowtee", "crowtee"]], find_dot_edge_styles(diagram(:notation => :crowsfoot))
+  end
 end

data/test/unit/rake_task_test.rb

@@ -13,7 +13,7 @@ class RakeTaskTest < ActiveSupport::TestCase
   end
 
   def teardown
-    FileUtils.rm "ERD.dot" rescue nil
+    FileUtils.rm "erd.dot" rescue nil
     RailsERD::Diagram.send :remove_const, :Graphviz rescue nil
   end
 
@@ -35,12 +35,12 @@ class RakeTaskTest < ActiveSupport::TestCase
   test "generate task should create output based on domain model" do
     create_simple_domain
     Rake::Task["erd:generate"].execute
-    assert File.exists?("ERD.dot")
+    assert File.exists?("erd.dot")
   end
 
   test "generate task should not create output if there are no connected models" do
     Rake::Task["erd:generate"].execute rescue nil
-    assert !File.exists?("ERD.dot")
+    assert !File.exists?("erd.dot")
   end
 
   test "generate task should eager load application environment" do
@@ -92,11 +92,11 @@ class RakeTaskTest < ActiveSupport::TestCase
     rescue => e
       message = e.message
     end
-    assert_equal <<-MSG.strip, message
+    assert_match /#{Regexp.escape(<<-MSG.strip).gsub("xxx", ".*?")}/, message
 Loading models failed!
 Error occurred while loading application: FooBar (RuntimeError)
-    test/unit/rake_task_test.rb:#{l1}:in `block (3 levels) in <class:RakeTaskTest>'
-    test/unit/rake_task_test.rb:#{l2}:in `block in <class:RakeTaskTest>'
+    test/unit/rake_task_test.rb:#{l1}:in `xxx'
+    test/unit/rake_task_test.rb:#{l2}:in `xxx'
     MSG
   end
 
@@ -110,13 +110,13 @@ Error occurred while loading application: FooBar (RuntimeError)
     Rake::Task.define_task :environment
     message = nil
     begin
-      old_stdout, $stdout = $stdout, StringIO.new
+      old_stderr, $stderr = $stderr, StringIO.new
       Rake.application.options.trace = true
       Rake::Task["erd:generate"].invoke
     rescue => e
       message = e.message
     ensure
-      $stdout = old_stdout
+      $stderr = old_stderr
     end
     assert_equal "FooBar", message
   end

data/test/unit/relationship_test.rb

@@ -2,11 +2,11 @@ require File.expand_path("../test_helper", File.dirname(__FILE__))
 
 class RelationshipTest < ActiveSupport::TestCase
   N = Domain::Relationship::N
-  
+
   def domain_cardinalities
     Domain.generate.relationships.map(&:cardinality)
   end
-  
+
   # Relationship =============================================================
   test "inspect should show source and destination" do
     create_model "Foo", :bar => :references do
@@ -15,7 +15,7 @@ class RelationshipTest < ActiveSupport::TestCase
     create_model "Bar"
     assert_match %r{#<RailsERD::Domain::Relationship:.* @source=Bar @destination=Foo>}, Domain.generate.relationships.first.inspect
   end
-  
+
   test "source should return relationship source" do
     create_model "Foo", :bar => :references do
       belongs_to :bar
@@ -24,7 +24,7 @@ class RelationshipTest < ActiveSupport::TestCase
     domain = Domain.generate
     assert_equal [domain.entity_by_name("Bar")], domain.relationships.map(&:source)
   end
-  
+
   test "destination should return relationship destination" do
     create_model "Foo", :bar => :references do
       belongs_to :bar
@@ -33,7 +33,7 @@ class RelationshipTest < ActiveSupport::TestCase
     domain = Domain.generate
     assert_equal [domain.entity_by_name("Foo")], domain.relationships.map(&:destination)
   end
-  
+
   test "destination should return relationship destination if specified with absolute module path" do
     create_model "Foo", :bar => :references
     create_model "Bar" do
@@ -42,7 +42,7 @@ class RelationshipTest < ActiveSupport::TestCase
     domain = Domain.generate
     assert_equal [domain.entity_by_name("Foo")], domain.relationships.map(&:destination)
   end
-  
+
   # Relationship properties ==================================================
   test "mutual should return false for one way relationship" do
     create_model "Foo", :bar => :references do
@@ -51,7 +51,7 @@ class RelationshipTest < ActiveSupport::TestCase
     create_model "Bar"
     assert_equal [false], Domain.generate.relationships.map(&:mutual?)
   end
-  
+
   test "mutual should return true for mutual relationship" do
     create_model "Foo", :bar => :references do
       belongs_to :bar
@@ -61,12 +61,12 @@ class RelationshipTest < ActiveSupport::TestCase
     end
     assert_equal [true], Domain.generate.relationships.map(&:mutual?)
   end
-  
+
   test "mutual should return true for mutual many to many relationship" do
     create_many_to_many_assoc_domain
     assert_equal [true], Domain.generate.relationships.map(&:mutual?)
   end
-  
+
   test "recursive should return false for ordinary relationship" do
     create_model "Foo", :bar => :references do
       belongs_to :bar
@@ -76,14 +76,14 @@ class RelationshipTest < ActiveSupport::TestCase
     end
     assert_equal [false], Domain.generate.relationships.map(&:recursive?)
   end
-  
+
   test "recursive should return true for self referencing relationship" do
     create_model "Foo", :foo => :references do
       belongs_to :foo
     end
     assert_equal [true], Domain.generate.relationships.map(&:recursive?)
   end
-  
+
   test "indirect should return false for ordinary relationship" do
     create_model "Foo", :bar => :references do
       belongs_to :bar
@@ -93,7 +93,7 @@ class RelationshipTest < ActiveSupport::TestCase
     end
     assert_equal [false], Domain.generate.relationships.map(&:indirect?)
   end
-  
+
   test "indirect should return false for non mutual ordinary relationship" do
     create_model "Foo", :bar => :references do
       belongs_to :bar
@@ -101,7 +101,7 @@ class RelationshipTest < ActiveSupport::TestCase
     create_model "Bar"
     assert_equal [false], Domain.generate.relationships.map(&:indirect?)
   end
-  
+
   test "indirect should return true if relationship is a through association" do
     create_model "Foo", :baz => :references, :bar => :references do
       belongs_to :baz
@@ -117,7 +117,7 @@ class RelationshipTest < ActiveSupport::TestCase
     assert_equal true, Domain.generate.relationships.find { |rel|
       rel.source.model == Bar and rel.destination.model == Baz }.indirect?
   end
-  
+
   test "strength should return one for relationship with one association" do
     create_model "Foo", :bar => :references
     create_model "Bar" do
@@ -160,7 +160,7 @@ class RelationshipTest < ActiveSupport::TestCase
     end
     assert_equal [1], Domain.generate.relationships.map(&:strength)
   end
-  
+
   # Cardinalities ============================================================
   test "cardinality should be zero-one to zero-one for optional one to one associations" do
     create_one_to_one_assoc_domain
@@ -245,7 +245,7 @@ class RelationshipTest < ActiveSupport::TestCase
     end
     assert_equal [Domain::Relationship::Cardinality.new(0..1, 5..17)], domain_cardinalities
   end
-  
+
   test "cardinality should be zero-many to zero-many for optional many to many associations" do
     create_many_to_many_assoc_domain
     assert_equal [Domain::Relationship::Cardinality.new(0..N, 0..N)], domain_cardinalities
@@ -261,7 +261,7 @@ class RelationshipTest < ActiveSupport::TestCase
     end
     assert_equal [Domain::Relationship::Cardinality.new(1..N, 1..N)], domain_cardinalities
   end
-  
+
   test "cardinality should be n-m to n-m for limited many to many associations with single validations" do
     create_many_to_many_assoc_domain
     Many.class_eval do
@@ -289,7 +289,7 @@ class RelationshipTest < ActiveSupport::TestCase
     end
     assert_equal [Domain::Relationship::Cardinality.new(9..17, 3..20)], domain_cardinalities
   end
-  
+
   # Cardinality for non-mutual relationships =================================
   test "cardinality should be zero-one to zero-many for non mutual relationship with belongs_to association" do
     create_model "One"
@@ -306,7 +306,7 @@ class RelationshipTest < ActiveSupport::TestCase
     create_model "Many", :one => :references
     assert_equal [Domain::Relationship::Cardinality.new(0..1, 0..N)], domain_cardinalities
   end
-  
+
   test "cardinality should be zero-one to zero-one for non mutual relationship with has_one association" do
     create_model "One" do
       has_one :other
@@ -314,7 +314,7 @@ class RelationshipTest < ActiveSupport::TestCase
     create_model "Other", :one => :references
     assert_equal [Domain::Relationship::Cardinality.new(0..1, 0..1)], domain_cardinalities
   end
-  
+
   test "cardinality should be zero-many to zero-many for non mutual relationship with has_and_belongs_to_many association" do
     create_table "many_more", :many_id => :integer, :more_id => :integer
     create_model "Many"
@@ -323,7 +323,7 @@ class RelationshipTest < ActiveSupport::TestCase
     end
     assert_equal [Domain::Relationship::Cardinality.new(0..N, 0..N)], domain_cardinalities
   end
-  
+
   # Cardinality for multiple associations ====================================
   test "cardinality should be zero-one to zero-many for conflicting one to many associations" do
     create_model "CreditCard", :person => :references do
@@ -331,7 +331,7 @@ class RelationshipTest < ActiveSupport::TestCase
     end
     create_model "Person" do
       has_many :credit_cards
-      
+
       # A person may have a preferred card, but they are still able to have
       # many cards. The association has an infinite maximum cardinality.
       has_one :preferred_credit_card, :class_name => "CreditCard"
@@ -353,14 +353,14 @@ class RelationshipTest < ActiveSupport::TestCase
     end
     assert_equal [Domain::Relationship::Cardinality.new(0..1, 1..N)], domain_cardinalities
   end
-  
+
   test "cardinality should be n-m to n-m for conflicting validations in one to many associations" do
     create_model "Spell", :wizard => :references do
     end
     create_model "Wizard" do
       has_many :ice_spells, :class_name => "Spell"
       has_many :fire_spells, :class_name => "Spell"
-      
+
       # Well, this can make sense, based on the conditions for the associations.
       # We don't go that far yet. We ignore the lower values and opt for the
       # higher values. It'll be okay. Really... You'll never need this.
@@ -369,7 +369,7 @@ class RelationshipTest < ActiveSupport::TestCase
     end
     assert_equal [Domain::Relationship::Cardinality.new(0..1, 50..100)], domain_cardinalities
   end
-  
+
   test "cardinality should be one to one-many for mandatory one to many associations on polymorphic interfaces" do
     create_model "Cannon", :defensible => :references do
       belongs_to :defensible, :polymorphic => true
@@ -385,7 +385,7 @@ class RelationshipTest < ActiveSupport::TestCase
     end
     assert_equal [Domain::Relationship::Cardinality.new(1, 1..N)], domain_cardinalities
   end
-  
+
   # Cardinality classes ======================================================
   test "cardinality should be one to one for has_one associations" do
     create_one_to_one_assoc_domain
@@ -403,7 +403,7 @@ class RelationshipTest < ActiveSupport::TestCase
     assert_equal [true], domain.relationships.map(&:to_one?)
     assert_equal [false], domain.relationships.map(&:to_many?)
   end
-  
+
   test "cardinality should be one to many for has_many associations" do
     create_one_to_many_assoc_domain
     domain = Domain.generate
@@ -418,7 +418,7 @@ class RelationshipTest < ActiveSupport::TestCase
     assert_equal [false], domain.relationships.map(&:to_one?)
     assert_equal [true], domain.relationships.map(&:to_many?)
   end
-  
+
   test "cardinality should be many to many for has_and_belongs_to_many associations" do
     create_many_to_many_assoc_domain
     domain = Domain.generate
@@ -434,7 +434,7 @@ class RelationshipTest < ActiveSupport::TestCase
     assert_equal [false], domain.relationships.map(&:to_one?)
     assert_equal [true], domain.relationships.map(&:to_many?)
   end
-  
+
   test "cardinality should be one to many for multiple associations with maximum cardinality of has_many" do
     create_model "Foo", :bar => :references
     create_model "Bar" do
@@ -444,7 +444,7 @@ class RelationshipTest < ActiveSupport::TestCase
     domain = Domain.generate
     assert_equal [:one_to_many], domain.relationships.map(&:cardinality).map(&:name)
   end
-  
+
   test "cardinality should be one to many if forward association is missing" do
     create_model "Foo", :bar => :references do
       belongs_to :bar
@@ -453,7 +453,7 @@ class RelationshipTest < ActiveSupport::TestCase
     domain = Domain.generate
     assert_equal [:one_to_many], domain.relationships.map(&:cardinality).map(&:name)
   end
-  
+
   test "cardinality should be one to many for has_many associations from generalized entity" do
     create_model "Stronghold" do
       has_many :cannons, :as => :defensible