rails-erd 0.4.5 → 1.0.0

data/test/unit/attribute_test.rb

@@ -49,6 +49,16 @@ class AttributeTest < ActiveSupport::TestCase
     assert_equal :binary, create_attribute(Foo, "a").type
   end
 
+  test "type should return native type if unsupported by rails" do
+    create_model "Foo"
+    ActiveRecord::Schema.define do
+      suppress_messages do
+        add_column "foos", "a", "REAL"
+      end
+    end
+    assert_equal :real, create_attribute(Foo, "a").type
+  end
+
   # Attribute properties =====================================================
   test "mandatory should return false by default" do
     create_model "Foo", :column => :string
@@ -75,7 +85,7 @@ class AttributeTest < ActiveSupport::TestCase
 
   test "primary_key should return true if column is used as primary key" do
     create_model "Bar", :my_key => :integer do
-      set_primary_key :my_key
+      self.primary_key = :my_key
     end
     assert_equal true, create_attribute(Bar, "my_key").primary_key?
   end
@@ -114,14 +124,14 @@ class AttributeTest < ActiveSupport::TestCase
 
   test "inheritance should return false by default" do
     create_model "Foo", :type => :string, :alternative => :string do
-      set_inheritance_column :alternative
+      self.inheritance_column = :alternative
     end
     assert_equal false, create_attribute(Foo, "type").inheritance?
   end
 
   test "inheritance should return if this column is used for single table inheritance" do
     create_model "Foo", :type => :string, :alternative => :string do
-      set_inheritance_column :alternative
+      self.inheritance_column = :alternative
     end
     assert_equal true, create_attribute(Foo, "alternative").inheritance?
   end
@@ -145,6 +155,16 @@ class AttributeTest < ActiveSupport::TestCase
     assert_equal "binary", create_attribute(Foo, "a").type_description
   end
 
+  test "type_description should return short type description if unsupported by rails" do
+    create_model "Foo"
+    ActiveRecord::Schema.define do
+      suppress_messages do
+        add_column "foos", "a", "REAL"
+      end
+    end
+    assert_equal "real", create_attribute(Foo, "a").type_description
+  end
+
   test "type_description should return short type description without limit if standard" do
     with_native_limit :string, 456 do
       create_model "Foo"
@@ -209,6 +229,28 @@ class AttributeTest < ActiveSupport::TestCase
     assert_equal nil, create_attribute(Foo, "num").limit
   end
 
+  test "limit should return nil if type is unsupported by rails" do
+    create_model "Foo"
+    ActiveRecord::Schema.define do
+      suppress_messages do
+        add_column "foos", "a", "REAL"
+      end
+    end
+    assert_equal nil, create_attribute(Foo, "a").limit
+  end
+
+  test "limit should return nil for oddball column types that misuse the limit attribute" do
+    create_model "Business", :location => :integer
+    attribute = create_attribute(Business, "location")
+    attribute.column.class_eval do
+      define_method :limit do
+        # https://github.com/voormedia/rails-erd/issues/21
+        { :srid => 4326, :type => "point", :geographic => true }
+      end
+    end
+    assert_equal nil, attribute.limit
+  end
+
   test "scale should return scale for decimal columns if nonstandard" do
     create_model "Foo"
     add_column :foos, :num, :decimal, :precision => 5, :scale => 2
@@ -226,4 +268,25 @@ class AttributeTest < ActiveSupport::TestCase
     add_column :foos, :num, :decimal, :precision => 5
     assert_equal 0, create_attribute(Foo, "num").scale
   end
+
+  test "scale should return nil if type is unsupported by rails" do
+    create_model "Foo"
+    ActiveRecord::Schema.define do
+      suppress_messages do
+        add_column "foos", "a", "REAL"
+      end
+    end
+    assert_equal nil, create_attribute(Foo, "a").scale
+  end
+
+  test "scale should return nil for oddball column types that misuse the scale attribute" do
+    create_model "Kobold", :size => :integer
+    attribute = create_attribute(Kobold, "size")
+    attribute.column.class_eval do
+      define_method :scale do
+        1..5
+      end
+    end
+    assert_equal nil, attribute.scale
+  end
 end

data/test/unit/cardinality_test.rb

@@ -4,7 +4,7 @@ class CardinalityTest < ActiveSupport::TestCase
   def setup
     @n = Domain::Relationship::Cardinality::N
   end
-  
+
   # Cardinality ==============================================================
   test "inspect should show source and destination ranges" do
     assert_match %r{#<RailsERD::Domain::Relationship::Cardinality:.* @source_range=1\.\.1 @destination_range=1\.\.Infinity>},
@@ -15,7 +15,7 @@ class CardinalityTest < ActiveSupport::TestCase
   test "new should return cardinality object" do
     assert_kind_of Domain::Relationship::Cardinality, Domain::Relationship::Cardinality.new(1, 1..@n)
   end
-  
+
   # Cardinality properties ===================================================
   test "source_optional should return true if source range starts at zero" do
     assert_equal true, Domain::Relationship::Cardinality.new(0..1, 1).source_optional?
@@ -32,11 +32,11 @@ class CardinalityTest < ActiveSupport::TestCase
   test "destination_optional should return false if destination range starts at one or more" do
     assert_equal false, Domain::Relationship::Cardinality.new(0..1, 1..2).destination_optional?
   end
-  
+
   test "inverse should return inverse cardinality" do
     assert_equal Domain::Relationship::Cardinality.new(23..45, 0..15), Domain::Relationship::Cardinality.new(0..15, 23..45).inverse
   end
-  
+
   # Cardinality equality =====================================================
   test "cardinalities are equal if they have the same boundaries" do
     assert_equal Domain::Relationship::Cardinality.new(1, 1..Domain::Relationship::Cardinality::N),
@@ -52,7 +52,7 @@ class CardinalityTest < ActiveSupport::TestCase
     assert_not_equal Domain::Relationship::Cardinality.new(0..1, 1..Domain::Relationship::Cardinality::N),
       Domain::Relationship::Cardinality.new(0..1, 2..Domain::Relationship::Cardinality::N)
   end
-  
+
   # Cardinal names ===========================================================
   test "one_to_one should return true if source and destination are exactly one" do
     assert_equal true, Domain::Relationship::Cardinality.new(1, 1).one_to_one?
@@ -65,11 +65,11 @@ class CardinalityTest < ActiveSupport::TestCase
   test "one_to_one should return false if source range upper limit is more than one" do
     assert_equal false, Domain::Relationship::Cardinality.new(0..15, 0..1).one_to_one?
   end
-  
+
   test "one_to_one should return false if destination range upper limit is more than one" do
     assert_equal false, Domain::Relationship::Cardinality.new(0..1, 0..15).one_to_one?
   end
-  
+
   test "one_to_many should return true if source is exactly one and destination is higher than one" do
     assert_equal true, Domain::Relationship::Cardinality.new(1, 15).one_to_many?
   end
@@ -81,7 +81,7 @@ class CardinalityTest < ActiveSupport::TestCase
   test "one_to_many should return false if source range upper limit is more than one" do
     assert_equal false, Domain::Relationship::Cardinality.new(0..15, 0..15).one_to_many?
   end
-  
+
   test "one_to_many should return false if destination range upper limit is one" do
     assert_equal false, Domain::Relationship::Cardinality.new(0..1, 1).one_to_many?
   end
@@ -97,11 +97,11 @@ class CardinalityTest < ActiveSupport::TestCase
   test "many_to_many should return false if source range upper limit is is one" do
     assert_equal false, Domain::Relationship::Cardinality.new(1, 0..15).many_to_many?
   end
-  
+
   test "many_to_many should return false if destination range upper limit is one" do
     assert_equal false, Domain::Relationship::Cardinality.new(0..1, 1).many_to_many?
   end
-  
+
   test "inverse of one_to_many should be many_to_one" do
     assert_equal true, Domain::Relationship::Cardinality.new(0..1, 0..@n).inverse.many_to_one?
   end

data/test/unit/diagram_test.rb

@@ -4,11 +4,11 @@ class DiagramTest < ActiveSupport::TestCase
   def setup
     load "rails_erd/diagram.rb"
   end
-  
+
   def teardown
     RailsERD.send :remove_const, :Diagram
   end
-  
+
   def retrieve_entities(options = {})
     klass = Class.new(Diagram)
     [].tap do |entities|
@@ -20,7 +20,7 @@ class DiagramTest < ActiveSupport::TestCase
       klass.create(options)
     end
   end
-  
+
   def retrieve_relationships(options = {})
     klass = Class.new(Diagram)
     [].tap do |relationships|
@@ -32,7 +32,7 @@ class DiagramTest < ActiveSupport::TestCase
       klass.create(options)
     end
   end
-  
+
   def retrieve_specializations(options = {})
     klass = Class.new(Diagram)
     [].tap do |specializations|
@@ -56,7 +56,7 @@ class DiagramTest < ActiveSupport::TestCase
       klass.create(options)
     end
   end
-  
+
   # Diagram ==================================================================
   test "domain sould return given domain" do
     domain = Object.new
@@ -84,19 +84,19 @@ class DiagramTest < ActiveSupport::TestCase
       setup do
         calls << :setup
       end
-      
+
       each_entity do
         calls << :entity
       end
-      
+
       each_relationship do
         calls << :relationship
       end
-      
+
       save do
         calls << :save
       end
-      
+
       def calls
         @calls ||= []
       end
@@ -123,13 +123,39 @@ class DiagramTest < ActiveSupport::TestCase
     end.new(Domain.generate)
     assert_equal "foobar", diagram.create
   end
-  
+
   # Entity filtering =========================================================
   test "generate should yield entities" do
     create_model "Foo"
     assert_equal [Foo], retrieve_entities.map(&:model)
   end
 
+  test "generate should filter excluded entity" do
+    create_model "Book"
+    create_model "Author"
+    assert_equal [Book], retrieve_entities(:exclude => :Author).map(&:model)
+  end
+
+  test "generate should filter excluded entities" do
+    create_model "Book"
+    create_model "Author"
+    create_model "Editor"
+    assert_equal [Book], retrieve_entities(:exclude => [:Author, :Editor]).map(&:model)
+  end
+
+  test "generate should include only specified entity" do
+    create_model "Book"
+    create_model "Author"
+    assert_equal [Book], retrieve_entities(:only => [:Book]).map(&:model)
+  end
+
+  test "generate should include only specified entities" do
+    create_model "Book"
+    create_model "Author"
+    create_model "Editor"
+    assert_equal [Author, Editor], retrieve_entities(:only => [:Author, :Editor]).map(&:model)
+  end
+
   test "generate should filter disconnected entities if disconnected is false" do
     create_model "Book", :author => :references do
       belongs_to :author
@@ -149,7 +175,7 @@ class DiagramTest < ActiveSupport::TestCase
     Object.const_set :SpecialFoo, Class.new(Foo)
     assert_equal [Foo], retrieve_entities.map(&:model)
   end
-  
+
   test "generate should yield specialized entities if inheritance is true" do
     create_model "Foo", :type => :string
     Object.const_set :SpecialFoo, Class.new(Foo)
@@ -160,7 +186,7 @@ class DiagramTest < ActiveSupport::TestCase
     create_model "Foo"
     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 [Foo, SpecialFoo], retrieve_entities.map(&:model)
@@ -173,7 +199,7 @@ class DiagramTest < ActiveSupport::TestCase
     end
     assert_equal ["Cannon", "Galleon"], retrieve_entities.map(&:name)
   end
-  
+
   test "generate should yield generalized entities if polymorphism is true" do
     create_model "Cannon"
     create_model "Galleon" do
@@ -181,7 +207,7 @@ class DiagramTest < ActiveSupport::TestCase
     end
     assert_equal ["Cannon", "Defensible", "Galleon"], retrieve_entities(:polymorphism => true).map(&:name)
   end
-  
+
   # Relationship filtering ===================================================
   test "generate should yield relationships" do
     create_simple_domain
@@ -202,7 +228,7 @@ class DiagramTest < ActiveSupport::TestCase
     end
     assert_equal [false, false, true], retrieve_relationships(:indirect => true).map(&:indirect?)
   end
-  
+
   test "generate should filter indirect relationships if indirect is false" do
     create_model "Foo" do
       has_many :bazs
@@ -227,7 +253,7 @@ class DiagramTest < ActiveSupport::TestCase
     end
     assert_equal 1, retrieve_relationships.length
   end
-  
+
   test "generate should yield relationships to specialized entities" do
     create_model "Foo", :type => :string, :bar => :references
     Object.const_set :SpecialFoo, Class.new(Foo)
@@ -243,7 +269,7 @@ class DiagramTest < ActiveSupport::TestCase
     create_generalization
     assert_equal [], retrieve_specializations
   end
-  
+
   test "generate should yield specializations but not generalizations if inheritance is true" do
     create_specialization
     create_generalization
@@ -305,7 +331,7 @@ class DiagramTest < ActiveSupport::TestCase
     assert_equal %w{created_at title},
       retrieve_attribute_lists(:attributes => [:content, :timestamps])[Book].map(&:name)
   end
-  
+
   test "generate should yield no attributes for specialized entities" do
     create_model "Beverage", :type => :string, :name => :string, :distillery => :string, :age => :integer
     Object.const_set :Whisky, Class.new(Beverage)

data/test/unit/domain_test.rb

@@ -5,7 +5,7 @@ class DomainTest < ActiveSupport::TestCase
   test "generate should return domain" do
     assert_kind_of Domain, Domain.generate
   end
-  
+
   test "name should return rails application name" do
     begin
       Object::Quux = Module.new
@@ -18,11 +18,11 @@ class DomainTest < ActiveSupport::TestCase
       Object.send :remove_const, :Rails
     end
   end
-  
+
   test "name should return nil outside rails" do
     assert_nil Domain.generate.name
   end
-  
+
   test "inspect should display object id only" do
     create_model "Foo", :bar => :references do
       belongs_to :bar
@@ -30,18 +30,18 @@ class DomainTest < ActiveSupport::TestCase
     create_model "Bar"
     assert_match %r{#<RailsERD::Domain:.*>}, Domain.generate.inspect
   end
-  
+
   # Entity processing ========================================================
   test "entity_by_name should return associated entity for given name" do
     create_model "Foo"
     assert_equal Foo, Domain.generate.entity_by_name("Foo").model
   end
-  
+
   test "entities should return domain entities" do
     create_models "Foo", "Bar"
     assert_equal [Domain::Entity] * 2, Domain.generate.entities.collect(&:class)
   end
-  
+
   test "entities should return all domain entities sorted by name" do
     create_models "Foo", "Bar", "Baz", "Qux"
     assert_equal [Bar, Baz, Foo, Qux], Domain.generate.entities.collect(&:model)
@@ -63,22 +63,22 @@ class DomainTest < ActiveSupport::TestCase
     end
     assert_equal ["Defensible", "Galleon", "Stronghold"], Domain.generate.entities.collect(&:name)
   end
-  
+
   test "entities should omit abstract models" do
     Object.const_set :Foo, Class.new(ActiveRecord::Base) { self.abstract_class = true }
     create_model "Bar", Foo do
-      set_table_name "bars"
+      self.table_name = "bars"
     end
     create_table "foos", {}, true
     create_table "bars", {}, true
     assert_equal ["Bar"], Domain.generate.entities.collect(&:name)
   end
-  
+
   # Relationship processing ==================================================
   test "relationships should return empty array for empty domain" do
     assert_equal [], Domain.generate.relationships
   end
-  
+
   test "relationships should return relationships in domain model" do
     create_models "Baz", "Qux"
     create_model "Foo", :bar => :references, :qux => :references do
@@ -90,7 +90,7 @@ class DomainTest < ActiveSupport::TestCase
     end
     assert_equal [Domain::Relationship] * 3, Domain.generate.relationships.collect(&:class)
   end
-  
+
   test "relationships should count mutual relationship as one" do
     create_model "Foo", :bar => :references do
       belongs_to :bar
@@ -116,7 +116,7 @@ class DomainTest < ActiveSupport::TestCase
     end
     assert_equal [Domain::Relationship], Domain.generate.relationships.select(&:indirect?).collect(&:class)
   end
-  
+
   test "relationships should count relationship between same models with distinct foreign key seperately" do
     create_model "Foo", :bar => :references, :special_bar => :references do
       belongs_to :bar
@@ -126,7 +126,7 @@ class DomainTest < ActiveSupport::TestCase
     end
     assert_equal [Domain::Relationship] * 2, Domain.generate.relationships.collect(&:class)
   end
-  
+
   test "relationships should use model name first in alphabet as source for many to many relationships" do
     create_table "many_more", :many_id => :integer, :more_id => :integer
     create_model "Many" do
@@ -138,7 +138,7 @@ class DomainTest < ActiveSupport::TestCase
     relationship = Domain.generate.relationships.first
     assert_equal ["Many", "More"], [relationship.source.name, relationship.destination.name]
   end
-  
+
   # Specialization processing ================================================
   test "specializations should return empty array for empty domain" do
     assert_equal [], Domain.generate.specializations
@@ -159,7 +159,7 @@ class DomainTest < ActiveSupport::TestCase
     Object.const_set :BelgianBeer, Class.new(Beer)
     assert_equal [Domain::Specialization] * 2, Domain.generate.specializations.collect(&:class)
   end
-  
+
   test "specializations should return generalizations in domain model" do
     create_model "Post" do
       has_many :assets, :as => :attachable
@@ -180,7 +180,7 @@ class DomainTest < ActiveSupport::TestCase
     end
     assert_equal [Domain::Specialization] * 2, Domain.generate.specializations.collect(&:class)
   end
-  
+
   # test "generalizations should ..." do
   #   # TODO
   #   create_model "Post" do
@@ -191,7 +191,7 @@ class DomainTest < ActiveSupport::TestCase
   #   end
   #   assert_equal [], Domain.generate.relationships
   # end
-  
+
   # Erroneous associations ===================================================
   test "relationships should omit bad has_many associations" do
     create_model "Foo" do
@@ -199,14 +199,14 @@ class DomainTest < ActiveSupport::TestCase
     end
     assert_equal [], Domain.generate(:warn => false).relationships
   end
-  
+
   test "relationships should omit bad has_many through association" do
     create_model "Foo" do
       has_many :flabs, :through => :bars
     end
     assert_equal [], Domain.generate(:warn => false).relationships
   end
-  
+
   test "relationships should omit association to model outside domain" do
     create_model "Foo" do
       has_many :bars
@@ -258,7 +258,7 @@ class DomainTest < ActiveSupport::TestCase
     end
     assert_equal "", output
   end
-  
+
   # Erroneous models =========================================================
   test "entities should omit bad models" do
     Object.const_set :Foo, Class.new(ActiveRecord::Base)