jw-rails-erd 1.4.5

data/test/unit/relationship_test.rb

@@ -0,0 +1,476 @@
+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
+      belongs_to :bar
+    end
+    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
+    end
+    create_model "Bar"
+    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
+    end
+    create_model "Bar"
+    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
+      has_many :foos, :class_name => "::Foo"
+    end
+    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
+      belongs_to :bar
+    end
+    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
+    end
+    create_model "Bar" do
+      has_many :foos
+    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
+    end
+    create_model "Bar" do
+      has_many :foos
+    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
+    end
+    create_model "Bar" do
+      has_many :foos
+    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
+    end
+    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
+      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
+    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
+      has_many :foos
+    end
+    assert_equal [1], Domain.generate.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
+    assert_equal [2], Domain.generate.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
+    assert_equal [4], Domain.generate.relationships.map(&:strength)
+  end
+
+  test "strength should count polymorphic associations only once" do
+    create_model "Foo", :bar => :references do
+      belongs_to :bar, :polymorphic => true
+    end
+    create_model "Qux" do
+      has_many :foos, :as => :bar
+    end
+    create_model "Quux" do
+      has_many :foos, :as => :bar
+    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
+    assert_equal [Domain::Relationship::Cardinality.new(0..1, 0..1)], domain_cardinalities
+  end
+
+  test "cardinality should be one to one for mutually mandatory one to one associations" do
+    create_one_to_one_assoc_domain
+    One.class_eval do
+      validates_presence_of :other
+    end
+    Other.class_eval do
+      validates_presence_of :one
+    end
+    assert_equal [Domain::Relationship::Cardinality.new(1, 1)], domain_cardinalities
+  end
+
+  test "cardinality should be zero-one to zero-many for optional one to many associations" do
+    create_one_to_many_assoc_domain
+    assert_equal [Domain::Relationship::Cardinality.new(0..1, 0..N)], domain_cardinalities
+  end
+
+  test "cardinality should be one to zero-many for one to many associations with not null foreign key" do
+    create_model "One" do
+      has_many :many
+    end
+    create_model "Many" do
+      belongs_to :one
+    end
+    add_column :manies, :one_id, :integer, :null => false, :default => 0
+    assert_equal [Domain::Relationship::Cardinality.new(1, 0..N)], domain_cardinalities
+  end
+
+  test "cardinality should be one to one-many for mutually mandatory one to many associations" do
+    create_one_to_many_assoc_domain
+    One.class_eval do
+      validates_presence_of :many
+    end
+    Many.class_eval do
+      validates_presence_of :one
+    end
+    assert_equal [Domain::Relationship::Cardinality.new(1, 1..N)], domain_cardinalities
+  end
+
+  test "cardinality should be zero-one to one-n for maximised one to many associations" do
+    create_one_to_many_assoc_domain
+    One.class_eval do
+      validates_presence_of :many
+
+      # This kind of validation is bizarre, but we support it.
+      validates_length_of :many, :maximum => 5
+      validates_length_of :many, :maximum => 2  # The lowest maximum should be used.
+    end
+    assert_equal [Domain::Relationship::Cardinality.new(0..1, 1..2)], domain_cardinalities
+  end
+
+  test "cardinality should be zero-one to n-many for minimised one to many associations" do
+    create_one_to_many_assoc_domain
+    One.class_eval do
+      validates_presence_of :many
+      validates_length_of :many, :minimum => 2
+      validates_length_of :many, :minimum => 5  # The highest minimum should be used.
+    end
+    assert_equal [Domain::Relationship::Cardinality.new(0..1, 5..N)], domain_cardinalities
+  end
+
+  test "cardinality should be zero-one to n-m for limited one to many associations with single validation" do
+    create_one_to_many_assoc_domain
+    One.class_eval do
+      validates_length_of :many, :minimum => 5, :maximum => 17
+    end
+    assert_equal [Domain::Relationship::Cardinality.new(0..1, 5..17)], domain_cardinalities
+  end
+
+  test "cardinality should be zero-one to n-m for limited one to many associations with multiple validations" do
+    create_one_to_many_assoc_domain
+    One.class_eval do
+      validates_presence_of :many
+      validates_length_of :many, :maximum => 17
+      validates_length_of :many, :minimum => 5
+      validates_length_of :many, :minimum => 2, :maximum => 28
+    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
+  end
+
+  test "cardinality should be one-many to one-many for mutually mandatory many to many associations" 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 [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
+      validates_length_of :more, :minimum => 3, :maximum => 18
+    end
+    More.class_eval do
+      validates_length_of :many, :maximum => 29, :minimum => 7
+    end
+    assert_equal [Domain::Relationship::Cardinality.new(7..29, 3..18)], domain_cardinalities
+  end
+
+  test "cardinality should be n-m to n-m for limited many to many associations with multiple validations" do
+    create_many_to_many_assoc_domain
+    Many.class_eval do
+      validates_presence_of :more
+      validates_length_of :more, :minimum => 3
+      validates_length_of :more, :maximum => 20
+      validates_length_of :more, :maximum => 33
+    end
+    More.class_eval do
+      validates_presence_of :many
+      validates_length_of :many, :minimum => 2
+      validates_length_of :many, :minimum => 9
+      validates_length_of :many, :maximum => 17
+    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"
+    create_model "Many", :one => :references do
+      belongs_to :one
+    end
+    assert_equal [Domain::Relationship::Cardinality.new(0..1, 0..N)], domain_cardinalities
+  end
+
+  test "cardinality should be zero-one to zero-many for non mutual relationship with has_many association" do
+    create_model "One" do
+      has_many :many
+    end
+    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
+    end
+    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"
+    create_model "More" do
+      has_and_belongs_to_many :many
+    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
+      belongs_to :person
+    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"
+    end
+    assert_equal [Domain::Relationship::Cardinality.new(0..1, 0..N)], domain_cardinalities
+  end
+
+  test "cardinality should be zero-one to one-many for conflicting validations in one to many associations" do
+    create_model "Book", :author => :references do
+      belongs_to :author
+    end
+    create_model "Author" do
+      has_many :books
+      has_many :published_books, :class_name => "Book"
+
+      # The author certainly has books, therefore, this association has a
+      # minimum cardinality of one.
+      validates_presence_of :books
+    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.
+      validates_length_of :ice_spells, :in => 10..20
+      validates_length_of :fire_spells, :in => 50..100
+    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
+      validates_presence_of :defensible
+    end
+    create_model "Stronghold" do
+      has_many :cannons, :as => :defensible
+      validates_presence_of :cannons
+    end
+    create_model "Galleon" do
+      has_many :cannons, :as => :defensible
+      validates_presence_of :cannons
+    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
+    domain = Domain.generate
+
+    # In these test, we are liberal with the number of assertions per test.
+    assert_equal [:one_to_one], domain.relationships.map(&:cardinality).map(&:name)
+
+    assert_equal [true], domain.relationships.map(&:one_to_one?)
+    assert_equal [false], domain.relationships.map(&:one_to_many?)
+    assert_equal [false], domain.relationships.map(&:many_to_many?)
+
+    assert_equal [true], domain.relationships.map(&:one_to?)
+    assert_equal [false], domain.relationships.map(&:many_to?)
+    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
+
+    assert_equal [:one_to_many], domain.relationships.map(&:cardinality).map(&:name)
+    assert_equal [false], domain.relationships.map(&:one_to_one?)
+    assert_equal [true], domain.relationships.map(&:one_to_many?)
+    assert_equal [false], domain.relationships.map(&:many_to_many?)
+
+    assert_equal [true], domain.relationships.map(&:one_to?)
+    assert_equal [false], domain.relationships.map(&:many_to?)
+    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
+
+    assert_equal [:many_to_many], domain.relationships.map(&:cardinality).map(&:name)
+
+    assert_equal [false], domain.relationships.map(&:one_to_one?)
+    assert_equal [false], domain.relationships.map(&:one_to_many?)
+    assert_equal [true], domain.relationships.map(&:many_to_many?)
+
+    assert_equal [false], domain.relationships.map(&:one_to?)
+    assert_equal [true], domain.relationships.map(&:many_to?)
+    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
+      has_one :foo
+      has_many :foos
+    end
+    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
+    end
+    create_model "Bar"
+    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
+    end
+    create_model "Cannon", :defensible => :references do
+      belongs_to :defensible, :polymorphic => true
+    end
+    domain = Domain.generate
+
+    assert_equal [:one_to_many], domain.relationships.map(&:cardinality).map(&:name)
+    assert_equal [false], domain.relationships.map(&:one_to_one?)
+    assert_equal [true], domain.relationships.map(&:one_to_many?)
+    assert_equal [false], domain.relationships.map(&:many_to_many?)
+
+    assert_equal [true], domain.relationships.map(&:one_to?)
+    assert_equal [false], domain.relationships.map(&:many_to?)
+    assert_equal [false], domain.relationships.map(&:to_one?)
+    assert_equal [true], domain.relationships.map(&:to_many?)
+  end
+end

data/test/unit/specialization_test.rb

@@ -0,0 +1,67 @@
+require File.expand_path("../test_helper", File.dirname(__FILE__))
+
+class SpecializationTest < ActiveSupport::TestCase
+  # Specialization ===========================================================
+  test "inspect should show source and destination" do
+    create_specialization
+    domain = Domain.generate
+    assert_match %r{#<RailsERD::Domain::Specialization:.* @generalized=Beverage @specialized=Beer>},
+      Domain::Specialization.new(domain, domain.entity_by_name("Beverage"), domain.entity_by_name("Beer")).inspect
+  end
+
+  test "generalized should return source entity" do
+    create_specialization
+    domain = Domain.generate
+    assert_equal domain.entity_by_name("Beverage"),
+      Domain::Specialization.new(domain, domain.entity_by_name("Beverage"), domain.entity_by_name("Beer")).generalized
+  end
+
+  test "specialized should return destination entity" do
+    create_specialization
+    domain = Domain.generate
+    assert_equal domain.entity_by_name("Beer"),
+      Domain::Specialization.new(domain, domain.entity_by_name("Beverage"), domain.entity_by_name("Beer")).specialized
+  end
+
+  # Specialization properties ================================================
+  test "inheritance should be true for inheritance specializations" do
+    create_specialization
+    assert_equal [true], Domain.generate.specializations.map(&:inheritance?)
+  end
+
+  test "polymorphic should be false for inheritance specializations" do
+    create_specialization
+    assert_equal [false], Domain.generate.specializations.map(&:polymorphic?)
+  end
+
+  test "inheritance should be false for polymorphic specializations" do
+    create_polymorphic_generalization
+    assert_equal [false], Domain.generate.specializations.map(&:inheritance?)
+  end
+
+  test "polymorphic should be true for polymorphic specializations" do
+    create_polymorphic_generalization
+    assert_equal [true], Domain.generate.specializations.map(&:polymorphic?)
+  end
+
+  test "inheritance should be false for abstract specializations" do
+    create_abstract_generalization
+    assert_equal [false], Domain.generate.specializations.map(&:inheritance?)
+  end
+
+  test "polymorphic should be true for abstract specializations" do
+    create_abstract_generalization
+    assert_equal [true], Domain.generate.specializations.map(&:polymorphic?)
+  end
+
+  test "inheritance should be false for polymorphic specializations to specialized entities" do
+    create_model "Cannon"
+    create_model "Ship", :type => :string
+    create_model "Galleon", Ship do
+      has_many :cannons, :as => :defensible
+    end
+    domain = Domain.generate
+    assert_equal false, domain.specializations.find { |s|
+      s.generalized == domain.entity_by_name("Defensible") }.inheritance?
+  end
+end

metadata

@@ -0,0 +1,155 @@
+--- !ruby/object:Gem::Specification
+name: jw-rails-erd
+version: !ruby/object:Gem::Version
+  version: 1.4.5
+platform: ruby
+authors:
+- Rolf Timmermans
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-12-03 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '3.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '3.2'
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '3.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '3.2'
+- !ruby/object:Gem::Dependency
+  name: ruby-graphviz
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.2'
+- !ruby/object:Gem::Dependency
+  name: choice
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.2.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.2.0
+description: Automatically generate an entity-relationship diagram (ERD) for your
+  Rails models.
+email:
+- r.timmermans@voormedia.com
+executables:
+- erd
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- Rakefile
+- bin/erd
+- lib/generators/erd/USAGE
+- lib/generators/erd/install_generator.rb
+- lib/generators/erd/templates/auto_generate_diagram.rake
+- lib/rails-erd.rb
+- lib/rails_erd.rb
+- lib/rails_erd/cli.rb
+- lib/rails_erd/config.rb
+- lib/rails_erd/custom.rb
+- lib/rails_erd/diagram.rb
+- lib/rails_erd/diagram/graphviz.rb
+- lib/rails_erd/diagram/templates/node.html.erb
+- lib/rails_erd/diagram/templates/node.record.erb
+- lib/rails_erd/domain.rb
+- lib/rails_erd/domain/attribute.rb
+- lib/rails_erd/domain/entity.rb
+- lib/rails_erd/domain/relationship.rb
+- lib/rails_erd/domain/relationship/cardinality.rb
+- lib/rails_erd/domain/specialization.rb
+- lib/rails_erd/railtie.rb
+- lib/rails_erd/tasks.rake
+- lib/rails_erd/version.rb
+- lib/tasks/auto_generate_diagram.rake
+- test/support_files/erdconfig.another_example
+- test/support_files/erdconfig.example
+- test/support_files/erdconfig.exclude.example
+- test/test_helper.rb
+- test/unit/attribute_test.rb
+- test/unit/cardinality_test.rb
+- test/unit/config_test.rb
+- test/unit/diagram_test.rb
+- test/unit/domain_test.rb
+- test/unit/entity_test.rb
+- test/unit/graphviz_test.rb
+- test/unit/rake_task_test.rb
+- test/unit/relationship_test.rb
+- test/unit/specialization_test.rb
+homepage: https://github.com/jamescway/rails-erd
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 1.9.3
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.5.0
+signing_key: 
+specification_version: 4
+summary: Entity-relationship diagram for your Rails models.
+test_files:
+- test/support_files/erdconfig.another_example
+- test/support_files/erdconfig.example
+- test/support_files/erdconfig.exclude.example
+- test/test_helper.rb
+- test/unit/attribute_test.rb
+- test/unit/cardinality_test.rb
+- test/unit/config_test.rb
+- test/unit/diagram_test.rb
+- test/unit/domain_test.rb
+- test/unit/entity_test.rb
+- test/unit/graphviz_test.rb
+- test/unit/rake_task_test.rb
+- test/unit/relationship_test.rb
+- test/unit/specialization_test.rb