rails-erd 0.1.0

data/test/unit/entity_test.rb

@@ -0,0 +1,82 @@
+require File.expand_path("../test_helper", File.dirname(__FILE__))
+
+class EntityTest < ActiveSupport::TestCase
+  # Entity ===================================================================
+  test "model should return active record model" do
+    create_models "Foo"
+    assert_equal Foo, Entity.new(Domain.new, Foo).model
+  end
+  
+  test "name should return model name" do
+    create_models "Foo"
+    assert_equal "Foo", Entity.new(Domain.new, Foo).name
+  end
+
+  test "spaceship should sort entities by name" do
+    create_models "Foo", "Bar"
+    foo, bar = Entity.new(Domain.new, Foo), Entity.new(Domain.new, Bar)
+    assert_equal [bar, foo], [foo, bar].sort
+  end
+  
+  test "to_s should equal name" do
+    create_models "Foo"
+    assert_equal "Foo", Entity.new(Domain.new, Foo).to_s
+  end
+
+  test "inspect should show name" do
+    create_models "Foo"
+    assert_match %r{#<RailsERD::Entity:.* @model=Foo>}, Entity.new(Domain.new, Foo).inspect
+  end
+
+  test "relationships should return relationships for this model" do
+    create_model "Foo", :bar => :references do
+      belongs_to :bar
+    end
+    create_model "Bar", :baz => :references do
+      belongs_to :baz
+    end
+    create_model "Baz"
+
+    domain = Domain.generate
+    foo = domain.entity_for(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
+      belongs_to :baz
+      has_many :foos
+    end
+    create_model "Baz"
+
+    domain = Domain.generate
+    foo = domain.entity_for(Foo)
+    assert_equal domain.relationships.select { |r| r.destination == foo }, foo.relationships
+  end
+  
+  # Entity properties ========================================================
+  test "connected should return false for unconnected entities" do
+    create_models "Foo", "Bar"
+    assert_equal [false, false], Domain.generate.entities.map(&:connected?)
+  end
+
+  test "connected should return true for connected entities" do
+    create_model "Foo", :bar => :references do
+      belongs_to :bar
+    end
+    create_model "Bar"
+    assert_equal [true, true], Domain.generate.entities.map(&:connected?)
+  end
+  
+  # Attribute processing =====================================================
+  test "attributes should return list of attributes" do
+    create_model "Bar", :some_column => :integer, :another_column => :string
+    assert_equal [Attribute] * 3, Entity.new(Domain.new, Bar).attributes.collect(&:class)
+  end
+
+  test "attributes should return attributes sorted by name" do
+    create_model "Bar", :some_column => :integer, :another_column => :string
+    assert_equal ["another_column", "id", "some_column"], Entity.new(Domain.new, Bar).attributes.collect(&:name)
+  end
+end

data/test/unit/relationship_test.rb

@@ -0,0 +1,308 @@
+require File.expand_path("../test_helper", File.dirname(__FILE__))
+
+class RelationshipTest < ActiveSupport::TestCase
+  # Relationship =============================================================
+  test "inspect should show source and destination" do
+    create_model "Foo", :bar => :references do
+      belongs_to :bar
+    end
+    create_model "Bar"
+    domain = Domain.generate
+    assert_match %r{#<RailsERD::Relationship:.* @source=Bar @destination=Foo>}, domain.relationships.first.inspect
+  end
+  
+  test "source should return relationship source" do
+    create_model "Foo", :bar => :references do
+      belongs_to :bar
+    end
+    create_model "Bar"
+    domain = Domain.generate
+    assert_equal [domain.entity_for(Bar)], domain.relationships.map(&:source)
+  end
+  
+  test "destination should return relationship destination" do
+    create_model "Foo", :bar => :references do
+      belongs_to :bar
+    end
+    create_model "Bar"
+    domain = Domain.generate
+    assert_equal [domain.entity_for(Foo)], domain.relationships.map(&:destination)
+  end
+  
+  # Relationship properties ==================================================
+  test "mutual should return false for one way relationship" do
+    create_model "Foo", :bar => :references do
+      belongs_to :bar
+    end
+    create_model "Bar"
+    domain = Domain.generate
+    assert_equal [false], domain.relationships.map(&:mutual?)
+  end
+  
+  test "mutual should return true for mutual relationship" do
+    create_model "Foo", :bar => :references do
+      belongs_to :bar
+    end
+    create_model "Bar" do
+      has_many :foos
+    end
+    domain = Domain.generate
+    assert_equal [true], domain.relationships.map(&:mutual?)
+  end
+  
+  test "recursive should return false for ordinary relationship" do
+    create_model "Foo", :bar => :references do
+      belongs_to :bar
+    end
+    create_model "Bar" do
+      has_many :foos
+    end
+    domain = Domain.generate
+    assert_equal [false], domain.relationships.map(&:recursive?)
+  end
+  
+  test "recursive should return true for self referencing relationship" do
+    create_model "Foo", :foo => :references do
+      belongs_to :foo
+    end
+    domain = Domain.generate
+    assert_equal [true], domain.relationships.map(&:recursive?)
+  end
+  
+  test "indirect should return false for ordinary relationship" do
+    create_model "Foo", :bar => :references do
+      belongs_to :bar
+    end
+    create_model "Bar" do
+      has_many :foos
+    end
+    domain = Domain.generate
+    assert_equal [false], domain.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
+      belongs_to :bar
+    end
+    create_model "Bar" do
+      has_many :foos
+      has_many :bazs, :through => :foos
+    end
+    create_model "Baz" do
+      has_many :foos
+    end
+    domain = Domain.generate
+    assert_equal true, domain.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
+      has_many :foos
+    end
+    domain = Domain.generate
+    assert_equal [1], domain.relationships.map(&:strength)
+  end
+
+  test "strength should return two for relationship with two associations" do
+    create_model "Foo", :bar => :references do
+      belongs_to :bar
+    end
+    create_model "Bar" do
+      has_many :foos
+    end
+    domain = Domain.generate
+    assert_equal [2], domain.relationships.map(&:strength)
+  end
+
+  test "strength should return number of associations that make up the relationship" do
+    create_model "Foo", :bar => :references do
+      belongs_to :bar
+      belongs_to :special_bar, :class_name => "Bar", :foreign_key => :bar_id
+    end
+    create_model "Bar" do
+      has_many :foos
+      has_many :special_foos, :class_name => "Foo", :foreign_key => :bar_id
+    end
+    domain = Domain.generate
+    assert_equal [4], domain.relationships.map(&:strength)
+  end
+  
+  # Cardinality ==============================================================
+  test "cardinality should return one to one for has_one associations" do
+    create_model "Foo", :bar => :references
+    create_model "Bar" do
+      has_one :foo
+    end
+    domain = Domain.generate
+    assert_equal [Relationship::Cardinality::OneToOne], domain.relationships.map(&:cardinality)
+  end
+  
+  test "cardinality should return one to many for has_many associations" do
+    create_model "Foo", :bar => :references
+    create_model "Bar" do
+      has_many :foos
+    end
+    domain = Domain.generate
+    assert_equal [Relationship::Cardinality::OneToMany], domain.relationships.map(&:cardinality)
+  end
+  
+  test "cardinality should return many to many for has_and_belongs_to_many associations" do
+    create_table "bars_foos", :foo_id => :integer, :bar_id => :integer
+    create_model "Foo" do
+      has_and_belongs_to_many :bars
+    end
+    create_model "Bar" do
+      has_and_belongs_to_many :foos
+    end
+    domain = Domain.generate
+    assert_equal [Relationship::Cardinality::ManyToMany], domain.relationships.map(&:cardinality)
+  end
+  
+  test "cardinality should return one to many for multiple associations with maximum cardinality of has_many" do
+    create_model "Foo", :bar => :references
+    create_model "Bar" do
+      has_one :foo
+      has_many :foos
+    end
+    domain = Domain.generate
+    assert_equal [Relationship::Cardinality::OneToMany], domain.relationships.map(&:cardinality)
+  end
+  
+  test "cardinality should return one to many if forward association is missing" do
+    create_model "Foo", :bar => :references do
+      belongs_to :bar
+    end
+    create_model "Bar"
+    domain = Domain.generate
+    assert_equal [Relationship::Cardinality::OneToMany], domain.relationships.map(&:cardinality)
+  end
+  
+  # test "cardinality should return zero or more for has_many association" do
+  #   create_model "Foo", :bar => :references do
+  #     belongs_to :bar
+  #   end
+  #   create_model "Bar" do
+  #     has_many :foos
+  #   end
+  #   domain = Domain.generate
+  #   assert_equal Cardinality::ZeroOrMore, domain.relationships.first.cardinality
+  # end
+  # 
+  # test "cardinality should return one or more for validated has_many association" do
+  #   create_model "Foo", :bar => :references do
+  #     belongs_to :bar
+  #   end
+  #   create_model "Bar" do
+  #     has_many :foos
+  #     validates :foos, :presence => true
+  #   end
+  #   domain = Domain.generate
+  #   assert_equal Cardinality::OneOrMore, domain.relationships.first.cardinality
+  # end
+  # 
+  # test "cardinality should return zero or more for has_many association with foreign database constraint" do
+  #   create_model "Foo" do
+  #     belongs_to :bar
+  #   end
+  #   add_column :foos, :bar_id, :integer, :null => false, :default => 0
+  #   create_model "Bar" do
+  #     has_many :foos
+  #   end
+  #   domain = Domain.generate
+  #   assert_equal Cardinality::ZeroOrMore, domain.relationships.first.cardinality
+  # end
+  # 
+  # test "cardinality should return zero or one for has_one association" do
+  #   create_model "Foo", :bar => :references do
+  #     belongs_to :bar
+  #   end
+  #   create_model "Bar" do
+  #     has_one :foo
+  #   end
+  #   domain = Domain.generate
+  #   assert_equal Cardinality::ZeroOrOne, domain.relationships.first.cardinality
+  # end
+  # 
+  # test "cardinality should return exactly one for validated has_one association" do
+  #   create_model "Foo", :bar => :references do
+  #     belongs_to :bar
+  #   end
+  #   create_model "Bar" do
+  #     has_one :foo
+  #     validates :foo, :presence => true
+  #   end
+  #   domain = Domain.generate
+  #   assert_equal Cardinality::ExactlyOne, domain.relationships.first.cardinality
+  # end
+  # 
+  # test "cardinality should return exactly one for has_one association with foreign database constraint" do
+  #   create_model "Foo" do
+  #     belongs_to :bar
+  #   end
+  #   add_column :foos, :bar_id, :integer, :null => false, :default => 0
+  #   create_model "Bar" do
+  #     has_one :foo
+  #   end
+  #   domain = Domain.generate
+  #   assert_equal Cardinality::ZeroOrOne, domain.relationships.first.cardinality
+  # end
+  # 
+  # # Reverse cardinality ======================================================
+  # test "reverse_cardinality should return nil if reverse association is missing" do
+  #   create_model "Foo", :bar => :references
+  #   create_model "Bar" do
+  #     has_many :foos
+  #   end
+  #   domain = Domain.generate
+  #   assert_nil domain.relationships.first.reverse_cardinality
+  # end
+  # 
+  # test "reverse_cardinality should return zero or one for has_many association" do
+  #   create_model "Foo", :bar => :references do
+  #     belongs_to :bar
+  #   end
+  #   create_model "Bar" do
+  #     has_many :foos
+  #   end
+  #   domain = Domain.generate
+  #   assert_equal Cardinality::ZeroOrOne, domain.relationships.first.reverse_cardinality
+  # end
+  # 
+  # test "reverse_cardinality should return exactly one for validated has_many association" do
+  #   create_model "Foo", :bar => :references do
+  #     belongs_to :bar
+  #     validates :bar, :presence => true
+  #   end
+  #   create_model "Bar" do
+  #     has_many :foos
+  #   end
+  #   domain = Domain.generate
+  #   assert_equal Cardinality::ExactlyOne, domain.relationships.first.reverse_cardinality
+  # end
+  # 
+  # test "reverse_cardinality should return zero or one for has_one association" do
+  #   create_model "Foo", :bar => :references do
+  #     belongs_to :bar
+  #   end
+  #   create_model "Bar" do
+  #     has_one :foo
+  #   end
+  #   domain = Domain.generate
+  #   assert_equal Cardinality::ZeroOrOne, domain.relationships.first.reverse_cardinality
+  # end
+  # 
+  # test "reverse_cardinality should return exactly one for validated has_one association" do
+  #   create_model "Foo", :bar => :references do
+  #     belongs_to :bar
+  #     validates :bar, :presence => true
+  #   end
+  #   create_model "Bar" do
+  #     has_one :foo
+  #   end
+  #   domain = Domain.generate
+  #   assert_equal Cardinality::ExactlyOne, domain.relationships.first.reverse_cardinality
+  # end
+end

metadata

@@ -0,0 +1,123 @@
+--- !ruby/object:Gem::Specification 
+name: rails-erd
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 1
+  - 0
+  version: 0.1.0
+platform: ruby
+authors: 
+- Rolf Timmermans
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-09-20 00:00:00 +02:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: activesupport
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 3
+        - 0
+        - 0
+        version: 3.0.0
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: ruby-graphviz
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        - 9
+        - 17
+        version: 0.9.17
+  type: :runtime
+  version_requirements: *id002
+description: Automatically generate an entity-relationship diagram (ERD) for the models in your Rails application.
+email: r.timmermans@voormedia.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE
+- README.rdoc
+files: 
+- .gitignore
+- CHANGES.rdoc
+- LICENSE
+- README.rdoc
+- Rakefile
+- VERSION
+- lib/rails-erd.rb
+- lib/rails_erd.rb
+- lib/rails_erd/attribute.rb
+- lib/rails_erd/diagram.rb
+- lib/rails_erd/domain.rb
+- lib/rails_erd/entity.rb
+- lib/rails_erd/railtie.rb
+- lib/rails_erd/relationship.rb
+- lib/rails_erd/relationship/cardinality.rb
+- lib/rails_erd/tasks.rake
+- lib/rails_erd/templates/node.erb
+- test/test_helper.rb
+- test/unit/attribute_test.rb
+- test/unit/cardinality_test.rb
+- test/unit/diagram_test.rb
+- test/unit/domain_test.rb
+- test/unit/entity_test.rb
+- test/unit/relationship_test.rb
+has_rdoc: true
+homepage: http://rails-erd.rubyforge.org/
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: rails-erd
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: Entity-relationship diagram for your Rails models.
+test_files: 
+- test/test_helper.rb
+- test/unit/attribute_test.rb
+- test/unit/cardinality_test.rb
+- test/unit/diagram_test.rb
+- test/unit/domain_test.rb
+- test/unit/entity_test.rb
+- test/unit/relationship_test.rb