rails-erd 1.0.0 → 1.1.0

data/LICENSE

@@ -1,4 +1,4 @@
-Copyright (c) 2010-2012 Voormedia B.V.
+Copyright (c) 2010-2013 Voormedia B.V.
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

data/README.md

@@ -51,7 +51,7 @@ About Rails ERD
 
 Rails ERD was created by Rolf Timmermans (r.timmermans *at* voormedia.com)
 
-Copyright 2010-2012 Voormedia - [www.voormedia.com](http://www.voormedia.com/)
+Copyright 2010-2013 Voormedia - [www.voormedia.com](http://www.voormedia.com/)
 
 
 License

data/Rakefile

@@ -1,5 +1,6 @@
 require "bundler"
 require "rake/testtask"
+require "yard"
 
 Bundler::GemHelper.install_tasks
 
@@ -7,59 +8,13 @@ Rake::TestTask.new do |test|
   test.test_files = FileList["test/**/*_test.rb"]
 end
 
-task :default => :test
+YARD::Rake::YardocTask.new do |yard|
+  yard.files = ["lib/**/*.rb", "-", "LICENSE", "CHANGES.md"]
+end
 
-# # encoding: utf-8
-# require "jeweler"
-# require "rake/testtask"
-#
-# Jeweler::Tasks.new do |spec|
-#   spec.name = "rails-erd"
-#   spec.rubyforge_project = "rails-erd"
-#   spec.summary = "Entity-relationship diagram for your Rails models."
-#   spec.description = "Automatically generate an entity-relationship diagram (ERD) for your Rails models."
-#
-#   spec.authors = ["Rolf Timmermans"]
-#   spec.email = "r.timmermans@voormedia.com"
-#   spec.homepage = "http://rails-erd.rubyforge.org/"
-#
-#   # Don't bundle examples or website in gem.
-#   excluded = Dir["{examples,site}/**/*"]
-#   spec.files -= excluded
-#   spec.test_files -= excluded
-# end
-#
-# Jeweler::GemcutterTasks.new
-#
-# Jeweler::RubyforgeTasks.new do |rubyforge|
-#   rubyforge.doc_task = "rdoc"
-#   rubyforge.remote_doc_path = "doc"
-# end
-#
-# Rake::TestTask.new do |test|
-#   test.pattern = "test/unit/**/*_test.rb"
-# end
-#
-# task :default => :test
-#
-# begin
-#   require "hanna/rdoctask"
-#   Rake::RDocTask.new do |rdoc|
-#     rdoc.rdoc_files = %w{CHANGES.rdoc LICENSE} + Dir["lib/**/*.rb"]
-#     rdoc.title = "Rails ERD – API Documentation"
-#     rdoc.rdoc_dir = "rdoc"
-#     rdoc.main = "RailsERD"
-#   end
-# rescue LoadError
-# end
-#
-# desc "Generate diagrams for bundled examples"
-# task :examples do
-#   require File.expand_path("examples/generate", File.dirname(__FILE__))
-# end
-#
-# namespace :examples do
-#   task :sfdp do
-#     require File.expand_path("examples/sfdp", File.dirname(__FILE__))
-#   end
-# end
+desc "Generate diagrams for bundled examples"
+task :examples do
+  require File.expand_path("examples/generate", File.dirname(__FILE__))
+end
+
+task :default => :test

data/lib/rails_erd/cli.rb

@@ -34,7 +34,7 @@ Choice.options do
 
   option :polymorphism do
     long "--polymorphism"
-    desc "Display polymorphic relationships."
+    desc "Display polymorphic and abstract entities."
   end
 
   option :no_indirect do
@@ -47,6 +47,16 @@ Choice.options do
     desc "Omit entities without relationships."
   end
 
+  option :only do
+    long "--only"
+    desc "Filter to only include listed models in diagram."
+  end
+
+  option :exclude do
+    long "--exclude"
+    desc "Filter to exclude listed models in diagram."
+  end
+
   separator ""
   separator "Output options:"
 

data/lib/rails_erd/diagram/graphviz.rb

@@ -5,7 +5,7 @@ require "erb"
 
 # Fix bad RegEx test in Ruby-Graphviz.
 GraphViz::Types::LblString.class_eval do
-  def output
+  def output # @private :nodoc:
     if /^<.*>$/m =~ @data
       @data
     else
@@ -84,7 +84,7 @@ module RailsERD
       module Simple
         def entity_style(entity, attributes)
           {}.tap do |options|
-            options[:fontcolor] = options[:color] = :grey60 if entity.abstract?
+            options[:fontcolor] = options[:color] = :grey60 if entity.virtual?
           end
         end
 
@@ -188,7 +188,8 @@ module RailsERD
       save do
         raise "Saving diagram failed!\nOutput directory '#{File.dirname(filename)}' does not exist." unless File.directory?(File.dirname(filename))
         begin
-          graph.output(filetype => filename)
+          # GraphViz doesn't like spaces in the filename
+          graph.output(filetype => filename.gsub(/\s/,"\\ "))
           filename
         rescue RuntimeError => e
           raise "Saving diagram failed!\nGraphviz produced errors. Verify it has support for filetype=#{options.filetype}, or use filetype=dot." <<
@@ -210,10 +211,11 @@ module RailsERD
       each_relationship do |relationship|
         from, to = relationship.source, relationship.destination
         unless draw_edge from.name, to.name, relationship_options(relationship)
-          if from.children.any?
-            from.children.each do |child|
-              draw_edge child.name, to.name, relationship_options(relationship)
-            end
+          from.children.each do |child|
+            draw_edge child.name, to.name, relationship_options(relationship)
+          end
+          to.children.each do |child|
+            draw_edge from.name, child.name, relationship_options(relationship)
           end
         end
       end

data/lib/rails_erd/domain.rb

@@ -114,7 +114,7 @@ module RailsERD
     end
 
     def models
-      @models ||= @source_models.reject(&:abstract_class?).select { |model| check_model_validity(model) }
+      @models ||= @source_models.select { |model| check_model_validity(model) }
     end
 
     def associations
@@ -122,7 +122,7 @@ module RailsERD
     end
 
     def check_model_validity(model)
-      model.table_exists? or raise "table #{model.table_name} does not exist"
+      model.abstract_class? or model.table_exists? or raise "table #{model.table_name} does not exist"
     rescue => e
       warn "Ignoring invalid model #{model.name} (#{e.message})"
     end

data/lib/rails_erd/domain/entity.rb

@@ -62,12 +62,13 @@ module RailsERD
       end
 
       # Returns +true+ if this entity is a generalization, which does not
-      # correspond with a database table. Generalized entities are constructed
+      # correspond with a database table. Generalized entities are either
+      # models that are defined as +abstract_class+ or they are constructed
       # from polymorphic interfaces. Any +has_one+ or +has_many+ association
       # that defines a polymorphic interface with <tt>:as => :name</tt> will
       # lead to a generalized entity to be created.
       def generalized?
-        !model
+        !model or !!model.abstract_class?
       end
 
       # Returns +true+ if this entity descends from another entity, and is
@@ -75,15 +76,16 @@ module RailsERD
       # referred to as single-table inheritance. In entity-relationship
       # diagrams it is called specialization.
       def specialized?
-        !generalized? and !model.descends_from_active_record?
+        !!model and !model.descends_from_active_record?
       end
 
       # Returns +true+ if this entity does not correspond directly with a
       # database table (if and only if the entity is specialized or
       # generalized).
-      def abstract?
-        specialized? or generalized?
+      def virtual?
+        generalized? or specialized?
       end
+      alias_method :abstract?, :virtual?
 
       # Returns all child entities, if this is a generalized entity.
       def children

data/lib/rails_erd/domain/relationship/cardinality.rb

@@ -31,7 +31,7 @@ module RailsERD
         # numbers (for source and destination). Can be any of
         # +:one_to_one:+, +:one_to_many+, or +:many_to_many+. The name
         # +:many_to_one+ also exists, but Rails ERD always normalises these
-        # kinds of relationships by inversing them, so they become
+        # kinds of relationships by inverting them, so they become
         # +:one_to_many+ associations.
         #
         # You can also call the equivalent method with a question mark, which

data/lib/rails_erd/domain/specialization.rb

@@ -1,12 +1,16 @@
 module RailsERD
   class Domain
     # Describes the specialization of an entity. Specialized entites correspond
-    # to inheritance. In Rails, specialization is referred to as single table
-    # inheritance.
+    # to inheritance or polymorphism. In Rails, specialization is referred to
+    # as single table inheritance, while generalization is referred to as
+    # polymorphism or abstract classes.
     class Specialization
       class << self
         def from_models(domain, models) # @private :nodoc:
-          (inheritance_from_models(domain, models) + polymorphic_from_models(domain, models)).sort
+          models = polymorphic_from_models(domain, models) +
+            inheritance_from_models(domain, models) +
+            abstract_from_models(domain, models)
+          models.sort
         end
 
         private
@@ -24,6 +28,12 @@ module RailsERD
             new(domain, domain.entity_by_name(model.base_class.name), domain.entity_by_name(model.name))
           }
         end
+
+        def abstract_from_models(domain, models)
+          models.select(&:abstract_class?).collect(&:descendants).flatten.collect { |model|
+            new(domain, domain.entity_by_name(model.superclass.name), domain.entity_by_name(model.name))
+          }
+        end
       end
 
       extend Inspectable
@@ -42,13 +52,15 @@ module RailsERD
         @domain, @generalized, @specialized = domain, generalized, specialized
       end
 
-      def inheritance?
-        !polymorphic?
+      def generalization?
+        generalized.generalized?
       end
+      alias_method :polymorphic?, :generalization?
 
-      def polymorphic?
-        generalized.generalized?
+      def specialization?
+        !generalization?
       end
+      alias_method :inheritance?, :specialization?
 
       def <=>(other) # @private :nodoc:
         (generalized.name <=> other.generalized.name).nonzero? or (specialized.name <=> other.specialized.name)

data/lib/rails_erd/version.rb

@@ -1,4 +1,4 @@
 module RailsERD
-  VERSION = "1.0.0"
+  VERSION = "1.1.0"
   BANNER = "RailsERD #{VERSION}"
 end

data/test/test_helper.rb

@@ -39,10 +39,11 @@ class ActiveSupport::TestCase
     superklass = args.first.kind_of?(Class) ? args.shift : ActiveRecord::Base
     columns = args.first || {}
     klass = Object.const_set name.to_sym, Class.new(superklass)
-    klass.class_eval(&block) if block_given?
-    if superklass == ActiveRecord::Base
+    if superklass == ActiveRecord::Base || superklass.abstract_class?
       create_table Object.const_get(name.to_sym).table_name, columns, Object.const_get(name.to_sym).primary_key rescue nil
     end
+    klass.class_eval(&block) if block_given?
+    Object.const_get(name.to_sym)
   end
 
   def create_models(*names)
@@ -98,16 +99,23 @@ class ActiveSupport::TestCase
 
   def create_specialization
     create_model "Beverage", :type => :string
-    Object.const_set :Beer, Class.new(Beverage)
+    create_model "Beer", Beverage
   end
 
-  def create_generalization
+  def create_polymorphic_generalization
     create_model "Cannon"
     create_model "Galleon" do
       has_many :cannons, :as => :defensible
     end
   end
 
+  def create_abstract_generalization
+    create_model "Structure" do
+      self.abstract_class = true
+    end
+    create_model "Palace", Structure
+  end
+
   private
 
   def reset_domain

data/test/unit/diagram_test.rb

@@ -266,26 +266,30 @@ class DiagramTest < ActiveSupport::TestCase
   # Specialization filtering =================================================
   test "generate should not yield specializations" do
     create_specialization
-    create_generalization
+    create_polymorphic_generalization
+    create_abstract_generalization
     assert_equal [], retrieve_specializations
   end
 
   test "generate should yield specializations but not generalizations if inheritance is true" do
     create_specialization
-    create_generalization
+    create_polymorphic_generalization
+    create_abstract_generalization
     assert_equal ["Beer"], retrieve_specializations(:inheritance => true).map { |s| s.specialized.name }
   end
 
   test "generate should yield generalizations but not specializations if polymorphism is true" do
     create_specialization
-    create_generalization
-    assert_equal ["Galleon"], retrieve_specializations(:polymorphism => true).map { |s| s.specialized.name }
+    create_polymorphic_generalization
+    create_abstract_generalization
+    assert_equal ["Galleon", "Palace"], retrieve_specializations(:polymorphism => true).map { |s| s.specialized.name }
   end
 
   test "generate should yield specializations and generalizations if polymorphism and inheritance is true" do
     create_specialization
-    create_generalization
-    assert_equal ["Beer", "Galleon"], retrieve_specializations(:inheritance => true,
+    create_polymorphic_generalization
+    create_abstract_generalization
+    assert_equal ["Beer", "Galleon", "Palace"], retrieve_specializations(:inheritance => true,
       :polymorphism => true).map { |s| s.specialized.name }
   end
 

data/test/unit/domain_test.rb

@@ -64,14 +64,12 @@ class DomainTest < ActiveSupport::TestCase
     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
-      self.table_name = "bars"
+  test "entities should include abstract models" do
+    create_model "Structure" do
+      self.abstract_class = true
     end
-    create_table "foos", {}, true
-    create_table "bars", {}, true
-    assert_equal ["Bar"], Domain.generate.entities.collect(&:name)
+    create_model "Palace", Structure
+    assert_equal ["Palace", "Structure"], Domain.generate.entities.collect(&:name)
   end
 
   # Relationship processing ==================================================
@@ -160,37 +158,22 @@ class DomainTest < ActiveSupport::TestCase
     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
-    end
-    create_model "Asset", :attachable => :references do
-      belongs_to :attachable, :polymorphic => true
-    end
+  test "specializations should return polymorphic generalizations in domain model" do
+    create_polymorphic_generalization
     assert_equal [Domain::Specialization], Domain.generate.specializations.collect(&:class)
   end
 
-  test "specializations should return generalizations and specializations in domain model" do
-    create_model "Content", :type => :string do
-      has_many :assets, :as => :attachable
-    end
-    Object.const_set :Post, Class.new(Content)
-    create_model "Asset", :attachable => :references do
-      belongs_to :attachable, :polymorphic => true
-    end
-    assert_equal [Domain::Specialization] * 2, Domain.generate.specializations.collect(&:class)
+  test "specializations should return abstract generalizations in domain model" do
+    create_abstract_generalization
+    assert_equal [Domain::Specialization], Domain.generate.specializations.collect(&:class)
   end
 
-  # test "generalizations should ..." do
-  #   # TODO
-  #   create_model "Post" do
-  #     has_many :assets, :as => :attachable
-  #   end
-  #   create_model "Asset", :attachable => :references do
-  #     belongs_to :attachable, :polymorphic => true
-  #   end
-  #   assert_equal [], Domain.generate.relationships
-  # end
+  test "specializations should return polymorphic and abstract generalizations and specializations in domain model" do
+    create_specialization
+    create_polymorphic_generalization
+    create_abstract_generalization
+    assert_equal [Domain::Specialization] * 3, Domain.generate.specializations.collect(&:class)
+  end
 
   # Erroneous associations ===================================================
   test "relationships should omit bad has_many associations" do
@@ -236,7 +219,7 @@ class DomainTest < ActiveSupport::TestCase
     assert_match /model Bar exists, but is not included in domain/, output
   end
 
-  test "relationships should output a warning when an association to a non existent generalization is encountere" do
+  test "relationships should output a warning when an association to a non existent generalization is encountered" do
     create_model "Foo" do
       has_many :bars, :as => :foo
     end

data/test/unit/entity_test.rb

@@ -9,6 +9,11 @@ class EntityTest < ActiveSupport::TestCase
     Domain::Entity.new(Domain.new, name)
   end
 
+  def create_abstract_entity(name)
+    model = create_model(name) { self.abstract_class = true }
+    create_entity(model)
+  end
+
   # Entity ===================================================================
   test "model should return active record model" do
     create_models "Foo"
@@ -63,36 +68,6 @@ class EntityTest < ActiveSupport::TestCase
     assert_equal domain.relationships.select { |r| r.destination == foo }, foo.relationships
   end
 
-  # test "parent should return nil for regular entities" do
-  #   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
-  #     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)
-  #   Object.const_set :VerySpecialFoo, Class.new(SpecialFoo)
-  #   domain = Domain.generate
-  #   assert_equal domain.entity_by_name("SpecialFoo"), Domain::Entity.from_models(domain, [VerySpecialFoo]).first.parent
-  # end
-
   # Entity properties ========================================================
   test "connected should return false for unconnected entities" do
     create_models "Foo", "Bar"
@@ -148,10 +123,10 @@ class EntityTest < ActiveSupport::TestCase
     assert_equal true, create_entity(VerySpecialFoo).specialized?
   end
 
-  test "abstract should return true for specialized entity" do
+  test "virtual should return true for specialized entity" do
     create_model "Foo", :type => :string
     Object.const_set :SpecialFoo, Class.new(Foo)
-    assert_equal true, create_entity(SpecialFoo).abstract?
+    assert_equal true, create_entity(SpecialFoo).virtual?
   end
 
   test "generalized should return false for regular entity" do
@@ -159,9 +134,9 @@ class EntityTest < ActiveSupport::TestCase
     assert_equal false, create_entity(Concrete).generalized?
   end
 
-  test "abstract should return false for regular entity" do
+  test "virtual should return false for regular entity" do
     create_model "Concrete"
-    assert_equal false, create_entity(Concrete).abstract?
+    assert_equal false, create_entity(Concrete).virtual?
   end
 
   # Attribute processing =====================================================
@@ -196,8 +171,8 @@ class EntityTest < ActiveSupport::TestCase
     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?
+  test "virtual should return true for generalized entity" do
+    assert_equal true, create_generalized_entity("MyAbstractModel").virtual?
   end
 
   test "relationships should return relationships for generalized entity" do
@@ -213,17 +188,37 @@ class EntityTest < ActiveSupport::TestCase
     assert_equal domain.relationships, defensible.relationships
   end
 
-  test "relationships should return relationships for generalized entity in reverse alphabetic order" do
-    create_model "Stronghold" do
-      has_many :cannons, :as => :defensible
-    end
-    create_model "Cannon", :defensible => :references do
-      belongs_to :defensible, :polymorphic => true
+  # Abstract generalized entity ==============================================
+  test "name should return given name for abstract generalized entity" do
+    assert_equal "MyAbstractModel", create_abstract_entity("MyAbstractModel").name
+  end
+
+  test "attributes should return empty array for abstract generalized entity" do
+    assert_equal [], create_abstract_entity("MyAbstractModel").attributes
+  end
+
+  test "generalized should return true for abstract generalized entity" do
+    assert_equal true, create_abstract_entity("MyAbstractModel").generalized?
+  end
+
+  test "specialized should return false for abstract generalized entity" do
+    assert_equal false, create_abstract_entity("MyAbstractModel").specialized?
+  end
+
+  test "virtual should return true for abstract generalized entity" do
+    assert_equal true, create_abstract_entity("MyAbstractModel").virtual?
+  end
+
+  test "relationships should return relationships for abstract generalized entity" do
+    create_model "Kingdom"
+    create_model "Structure" do
+      self.abstract_class = true
+      belongs_to :kingdom
     end
+    create_model "Palace", Structure, :kingdom => :references
 
     domain = Domain.generate
-    defensible = domain.entity_by_name("Defensible")
-    assert_equal domain.relationships, defensible.relationships
+    assert_equal domain.relationships, domain.entity_by_name("Structure").relationships
   end
 
   # Children =================================================================

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
 
@@ -92,6 +92,12 @@ class GraphvizTest < ActiveSupport::TestCase
     assert File.exists?("erd.dot")
   end
 
+  test "create should create output for filenames that have spaces" do
+    create_simple_domain
+    Diagram::Graphviz.create :filename => "erd with spaces"
+    assert File.exists?("erd with spaces.png")
+  end
+
   test "create should write to file with dot extension without requiring graphviz" do
     create_simple_domain
     begin
@@ -298,7 +304,7 @@ class GraphvizTest < ActiveSupport::TestCase
     assert_equal [["m_Bar", "m_Foo"], ["m_Foo", "m_Bar"]], find_dot_node_pairs(diagram).sort
   end
 
-  test "generate should create edge to generalized entity if polymorphism is true" do
+  test "generate should create edge to polymorphic entity if polymorphism is true" do
     create_model "Cannon", :defensible => :references do
       belongs_to :defensible, :polymorphic => true
     end
@@ -312,7 +318,7 @@ class GraphvizTest < ActiveSupport::TestCase
       find_dot_node_pairs(diagram(:polymorphism => true)).sort
   end
 
-  test "generate should create edge to each child of generalized entity if polymorphism is false" do
+  test "generate should create edge to each child of polymorphic entity if polymorphism is false" do
     create_model "Cannon", :defensible => :references do
       belongs_to :defensible, :polymorphic => true
     end
@@ -325,6 +331,35 @@ class GraphvizTest < ActiveSupport::TestCase
     assert_equal [["m_Galleon", "m_Cannon"], ["m_Stronghold", "m_Cannon"]], find_dot_node_pairs(diagram).sort
   end
 
+  test "generate should create edge to abstract entity if polymorphism is true" do
+    create_model "Person", :settlement => :references
+    create_model "Country" do
+      has_many :settlements
+    end
+    create_model "Settlement" do
+      self.abstract_class = true
+      belongs_to :country
+      has_many :people
+    end
+    create_model "City", Settlement, :country => :references
+    assert_equal [["m_Country", "m_Settlement"], ["m_Settlement", "m_City"], ["m_Settlement", "m_Person"]],
+      find_dot_node_pairs(diagram(:polymorphism => true)).sort
+  end
+
+  test "generate should create edge to each child of abstract entity if polymorphism is false" do
+    create_model "Person", :settlement => :references
+    create_model "Country" do
+      has_many :settlements
+    end
+    create_model "Settlement" do
+      self.abstract_class = true
+      belongs_to :country
+      has_many :people
+    end
+    create_model "City", Settlement, :country => :references
+    assert_equal [["m_City", "m_Person"], ["m_Country", "m_City"]], find_dot_node_pairs(diagram).sort
+  end
+
   # Simple notation style ====================================================
   test "generate should use no style for one to one cardinalities with simple notation" do
     create_one_to_one_assoc_domain

data/test/unit/specialization_test.rb

@@ -35,12 +35,22 @@ class SpecializationTest < ActiveSupport::TestCase
   end
 
   test "inheritance should be false for polymorphic specializations" do
-    create_generalization
+    create_polymorphic_generalization
     assert_equal [false], Domain.generate.specializations.map(&:inheritance?)
   end
 
   test "polymorphic should be true for polymorphic specializations" do
-    create_generalization
+    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
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rails-erd
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 1.1.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,11 +9,11 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-07-19 00:00:00.000000000 Z
+date: 2013-01-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
-  requirement: &70146121979600 !ruby/object:Gem::Requirement
+  requirement: !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -21,10 +21,15 @@ dependencies:
         version: '3.0'
   type: :runtime
   prerelease: false
-  version_requirements: *70146121979600
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '3.0'
 - !ruby/object:Gem::Dependency
   name: activesupport
-  requirement: &70146121979080 !ruby/object:Gem::Requirement
+  requirement: !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -32,10 +37,15 @@ dependencies:
         version: '3.0'
   type: :runtime
   prerelease: false
-  version_requirements: *70146121979080
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '3.0'
 - !ruby/object:Gem::Dependency
   name: ruby-graphviz
-  requirement: &70146121978600 !ruby/object:Gem::Requirement
+  requirement: !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -43,10 +53,15 @@ dependencies:
         version: 1.0.4
   type: :runtime
   prerelease: false
-  version_requirements: *70146121978600
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.0.4
 - !ruby/object:Gem::Dependency
   name: choice
-  requirement: &70146121978120 !ruby/object:Gem::Requirement
+  requirement: !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -54,18 +69,12 @@ dependencies:
         version: 0.1.6
   type: :runtime
   prerelease: false
-  version_requirements: *70146121978120
-- !ruby/object:Gem::Dependency
-  name: rake
-  requirement: &70146121977640 !ruby/object:Gem::Requirement
+  version_requirements: !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: '0.9'
-  type: :development
-  prerelease: false
-  version_requirements: *70146121977640
+        version: 0.1.6
 description: Automatically generate an entity-relationship diagram (ERD) for your
   Rails models.
 email:
@@ -75,7 +84,6 @@ executables:
 extensions: []
 extra_rdoc_files: []
 files:
-- CHANGES.rdoc
 - LICENSE
 - README.md
 - Rakefile
@@ -120,7 +128,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: 3954294952765829690
+      hash: 1960804951299581689
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
@@ -129,10 +137,10 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: 3954294952765829690
+      hash: 1960804951299581689
 requirements: []
 rubyforge_project: rails-erd
-rubygems_version: 1.8.11
+rubygems_version: 1.8.23
 signing_key: 
 specification_version: 3
 summary: Entity-relationship diagram for your Rails models.
@@ -147,3 +155,4 @@ test_files:
 - test/unit/rake_task_test.rb
 - test/unit/relationship_test.rb
 - test/unit/specialization_test.rb
+has_rdoc: 

data/CHANGES.rdoc

@@ -1,94 +0,0 @@
-=== 1.0.0:
-
-* The internal API is now stable and will be backwards compatible until
-  the next major version.
-* Added experimental command line interface (erd). The CLI still requires a
-  Rails application to be present, but it may one day support other kinds of
-  applications.
-* Crow's foot notation (also known as the Information Engineering notation)
-  can be used by adding 'notation=crowsfoot' to the 'rake erd' command
-  (contributed by Jeremy Holland).
-* Filter models by using the only or exclude options (only=ModelOne,ModelTwo
-  or exclude=ModelThree,ModelFour) from the command line (contributed by
-  Milovan Zogovic).
-* Process column types that are unsupported by Rails (contributed by Erik
-  Gustavson).
-* Ignore custom limit/scale attributes that cannot be converted to an integer
-  (reported by Adam St. John).
-
-=== 0.4.5:
-
-* Display more helpful error message when the application models could not be
-  loaded successfully by the 'rake erd' task (reported by Greg Weber).
-
-=== 0.4.4:
-
-* Added the ability to disable HTML markup in node labels (markup=false). This
-  causes .dot files to be compatible with OmniGraffle, which otherwise fails
-  to import graphs with HTML node labels (issue reported by Lucas Florio,
-  implementation based on template by Troy Anderson).
-* Prevent models named after Graphviz reserved words (Node, Edge) from causing
-  errors in .dot files (reported by gguthrie).
-* Improved error messages when Graphviz is throwing errors (reported by
-  Michael Irwin).
-
-=== 0.4.3:
-
-* Display the scale of decimal attributes when set. A decimal attribute with
-  precision 5 and scale 2 is now indicated with (5,2).
-* Fixed deprecation warnings for edge Rails (upcoming 3.1).
-
-=== 0.4.1:
-
-* Fix processing of associations with class_name set to absolute module paths.
-* Adjust model loading process to include models in non-standard paths eagerly.
-
-=== 0.4.0:
-
-* Support to optionally display single table inheritance relationships
-  (inheritance=true).
-* Support to optionally display polymorphic associations (polymorphism=true).
-* Adjustments to 'advanced' style so that it matches original Bachman style,
-  and therefore now called 'bachman'.
-* Ignore models without tables (reported by Mark Chapman).
-* Mutual indirect relationships are now combined.
-* Changed API for diagram generation.
-* Restructured classes and renamed several API properties and methods.
-* Added new edge type to describe single table inheritance and polymorphic
-  associations: Specialization.
-* Added compatibility for Active Record 3.1 (beta), removed dependency on Arel.
-* Rubinius compatibility.
-
-=== 0.3.0:
-
-* Added the ability to support multiple styles of cardinality notations.
-  Currently supported types are 'simple' and 'advanced'.
-* Added option to exclude indirect relationships (indirect=false).
-* Added option to change or disable the diagram title (title='Custom title').
-* Altered the type descriptions of attributes.
-* Renamed options for flexibility and clarity.
-* Improved internal logic to determine the cardinality of relationships.
-* More versatile API that allows you to inspect relationships and their
-  cardinalities.
-* Changed line widths to 1.0 to avoid invisible node boundaries with older
-  versions of Graphviz (reported by Mike McQuinn).
-* Bundled examples based on actual applications.
-
-=== 0.2.0
-
-* Added simple way to create your own type of diagrams with a tiny amount of code.
-* Improved internal API and documentation.
-* Subtle changes in diagram style.
-* Fixed error where non-mutual relationships might be inadvertently classified
-  as indirect relationships.
-* Fixed error where diagrams with a vertical layout might fail to be generated.
-
-=== 0.1.1
-
-* Fixed small errors in Ruby 1.8.7.
-* Abort generation of diagrams when there are no models.
-
-=== 0.1.0
-
-* Released on September 20th, 2010.
-* First public release.