rails-erd 0.2.0 → 0.3.0

data/lib/rails_erd/entity.rb

@@ -2,6 +2,12 @@ module RailsERD
   # Entities represent your Active Record models. Entities may be connected
   # to other entities.
   class Entity
+    class << self
+      def from_models(domain, models) # @private :nodoc:
+        models.collect { |model| new domain, model }.sort
+      end
+    end
+    
     # The domain in which this entity resides.
     attr_reader :domain
     
@@ -23,11 +29,28 @@ module RailsERD
       @domain.relationships_for(@model)
     end
     
+    # Returns the parent entity, if this entity is a descendant.
+    def parent
+      @domain.entity_for(@model.superclass) if descendant?
+    end
+    
     # Returns +true+ if this entity has any relationships with other models,
     # +false+ otherwise.
     def connected?
       relationships.any?
     end
+
+    # Returns +true+ if this entity has no relationships with any other models,
+    # +false+ otherwise. Opposite of +connected?+.
+    def disconnected?
+      relationships.none?
+    end
+    
+    # Returns +true+ if this entity descends from another entity, and is
+    # represented in the same table as its parent.
+    def descendant?
+      !@model.descends_from_active_record?
+    end
   
     # Returns the name of this entity, which is the class name of the
     # corresponding model.

data/lib/rails_erd/relationship.rb

@@ -1,9 +1,14 @@
+require "rails_erd/relationship/cardinality"
+
 module RailsERD
   # Describes a relationship between two entities. A relationship is detected
   # based on Active Record associations. One relationship may represent more
-  # than one association, however. Associations that share the same foreign
-  # key are grouped together.
+  # than one association, however. Related associations are grouped together.
+  # Associations are related if they share the same foreign key, or the same
+  # join table in the case of many-to-many associations.
   class Relationship
+    N = Cardinality::N
+    
     class << self
       def from_associations(domain, associations) # @private :nodoc:
         assoc_groups = associations.group_by { |assoc| association_identity(assoc) }
@@ -28,11 +33,21 @@ module RailsERD
     # The destination entity. It corresponds to the model that has defined
     # a +belongs_to+ association with the other model.
     attr_reader :destination
+    
+    delegate :one_to_one?, :one_to_many?, :many_to_many?, :source_optional?,
+      :destination_optional?, :to => :cardinality
   
     def initialize(domain, associations) # @private :nodoc:
       @domain = domain
-      @reverse_associations, @forward_associations = *associations.partition(&:belongs_to?)
-    
+      @reverse_associations, @forward_associations = *unless any_habtm?(associations)
+        associations.partition(&:belongs_to?)
+      else
+        # Many-to-many associations don't have a clearly defined direction.
+        # We sort by name and use the first model as the source.
+        source = associations.first.active_record
+        associations.partition { |association| association.active_record == source }
+      end
+      
       assoc = @forward_associations.first || @reverse_associations.first
       @source, @destination = @domain.entity_for(assoc.active_record), @domain.entity_for(assoc.klass)
       @source, @destination = @destination, @source if assoc.belongs_to?
@@ -44,11 +59,14 @@ module RailsERD
       @forward_associations + @reverse_associations
     end
     
-    # Returns the cardinality of this relationship. The cardinality may be
-    # one of Cardinality::OneToOne, Cardinality::OneToMany, or
-    # Cardinality::ManyToMany.
+    # Returns the cardinality of this relationship.
     def cardinality
-      @forward_associations.collect { |assoc| Cardinality.from_macro(assoc.macro) }.max or Cardinality::OneToMany
+      @cardinality ||= begin
+        reverse_max = any_habtm?(associations) ? N : 1
+        forward_range = associations_range(@source.model, @forward_associations, N)
+        reverse_range = associations_range(@destination.model, @reverse_associations, reverse_max)
+        Cardinality.new(reverse_range, forward_range)
+      end
     end
     
     # Indicates if a relationship is indirect, that is, if it is defined
@@ -71,6 +89,32 @@ module RailsERD
       @source == @destination
     end
     
+    # Indicates whether the destination cardinality class of this relationship
+    # is equal to one. This is +true+ for one-to-one relationships only.
+    def to_one?
+      cardinality.cardinality_class[1] == 1
+    end
+    
+    # Indicates whether the destination cardinality class of this relationship
+    # is equal to infinity. This is +true+ for one-to-many or
+    # many-to-many relationships only.
+    def to_many?
+      cardinality.cardinality_class[1] != 1
+    end
+    
+    # Indicates whether the source cardinality class of this relationship
+    # is equal to one. This is +true+ for one-to-one or
+    # one-to-many relationships only.
+    def one_to?
+      cardinality.cardinality_class[0] == 1
+    end
+    
+    # Indicates whether the source cardinality class of this relationship
+    # is equal to infinity. This is +true+ for many-to-many relationships only.
+    def many_to?
+      cardinality.cardinality_class[0] != 1
+    end
+    
     # The strength of a relationship is equal to the number of associations
     # that describe it.
     def strength
@@ -84,5 +128,50 @@ module RailsERD
     def <=>(other) # @private :nodoc:
       (source.name <=> other.source.name).nonzero? or (destination.name <=> other.destination.name)
     end
+    
+    private
+
+    def associations_range(model, associations, absolute_max)
+      # The minimum of the range is the maximum value of each association
+      # minimum. If there is none, it is zero by definition. The reasoning is
+      # that from all associations, if only one has a required minimum, then
+      # this side of the relationship has a cardinality of at least one.
+      min = associations.map { |assoc| association_minimum(model, assoc) }.max || 0
+
+      # The maximum of the range is the maximum value of each association
+      # maximum. If there is none, it is equal to the absolute maximum. If
+      # only one association has a high cardinality on this side, the
+      # relationship itself has the same maximum cardinality.
+      max = associations.map { |assoc| association_maximum(model, assoc) }.max || absolute_max
+
+      min..max
+    end
+    
+    def association_minimum(model, association)
+      minimum = association_validators(:presence, model, association).any? ||
+        foreign_key_required?(model, association) ? 1 : 0
+      length_validators = association_validators(:length, model, association)
+      length_validators.map { |v| v.options[:minimum] }.compact.max or minimum
+    end
+
+    def association_maximum(model, association)
+      maximum = association.collection? ? N : 1      
+      length_validators = association_validators(:length, model, association)
+      length_validators.map { |v| v.options[:maximum] }.compact.min or maximum
+    end
+    
+    def association_validators(kind, model, association)
+      model.validators_on(association.name).select { |v| v.kind == kind }
+    end
+    
+    def any_habtm?(associations)
+      associations.any? { |association| association.macro == :has_and_belongs_to_many }
+    end
+    
+    def foreign_key_required?(model, association)
+      if association.belongs_to?
+        key = model.arel_table.columns.find { |column| column.name == association.primary_key_name } and !key.null
+      end
+    end
   end
 end

data/lib/rails_erd/relationship/cardinality.rb

@@ -1,35 +1,117 @@
 module RailsERD
   class Relationship
     class Cardinality
-      CARDINALITY_NAMES = %w{one_to_one one_to_many many_to_many} # @private :nodoc:
-      ORDER = {} # @private :nodoc:
+      N = Infinity = 1.0/0 # And beyond.
+      
+      CLASSES = {
+        [1, 1] => :one_to_one,
+        [1, N] => :one_to_many,
+        [N, 1] => :many_to_one,
+        [N, N] => :many_to_many
+      } # @private :nodoc:
 
-      class << self
-        # Returns the cardinality as a symbol.
-        attr_reader :type
-        
-        def from_macro(macro) # @private :nodoc:
-          case macro
-          when :has_and_belongs_to_many then ManyToMany
-          when :has_many then OneToMany
-          when :has_one then OneToOne
-          end
-        end
-        
-        def <=>(other) # @private :nodoc:
-          ORDER[self] <=> ORDER[other]
-        end
-        
-        CARDINALITY_NAMES.each do |cardinality|
-          define_method :"#{cardinality}?" do
-            type == cardinality
+      # Returns a range that indicates the source (left) cardinality.
+      attr_reader :source_range
+      
+      # Returns a range that indicates the destination (right) cardinality.
+      attr_reader :destination_range
+
+      # Create a new cardinality based on a source range and a destination
+      # range. These ranges describe which number of values are valid.
+      def initialize(source_range, destination_range) # @private :nodoc:
+        @source_range = compose_range(source_range)
+        @destination_range = compose_range(destination_range)
+      end
+      
+      # Returns the name of this cardinality, based on its two cardinal
+      # 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
+      # +:one_to_many+ associations.
+      #
+      # You can also call the equivalent method with a question mark, which
+      # will return true if the name corresponds to that method. For example:
+      #
+      #   cardinality.one_to_one?
+      #   #=> true
+      #   cardinality.one_to_many?
+      #   #=> false
+      def name
+        CLASSES[cardinality_class]
+      end
+      
+      # Returns +true+ if the source (left side) is not mandatory.
+      def source_optional?
+        source_range.first < 1
+      end
+      
+      # Returns +true+ if the destination (right side) is not mandatory.
+      def destination_optional?
+        destination_range.first < 1
+      end
+      
+      # Returns the inverse cardinality. Destination becomes source, source
+      # becomes destination.
+      def inverse
+        self.class.new destination_range, source_range
+      end
+      
+      CLASSES.each do |cardinality_class, name|
+        class_eval <<-RUBY
+          def #{name}?
+            cardinality_class == #{cardinality_class.inspect}
           end
-        end
+        RUBY
+      end
+      
+      def ==(other) # @private :nodoc:
+        source_range == other.source_range and destination_range == other.destination_range
+      end
+      
+      def <=>(other) # @private :nodoc:
+        (cardinality_class <=> other.cardinality_class).nonzero? or
+        compare_with(other) { |x| x.source_range.first + x.destination_range.first }.nonzero? or
+        compare_with(other) { |x| x.source_range.last + x.destination_range.last }.nonzero? or
+        compare_with(other) { |x| x.source_range.last }.nonzero? or
+        compare_with(other) { |x| x.destination_range.last }
+      end
+      
+      def inspect # @private :nodoc:
+        "#<#{self.class}:0x%.14x (%s,%s) => (%s,%s)>" %
+          [object_id << 1, source_range.first, source_range.last, destination_range.first, destination_range.last]
+      end
+      
+      # Returns an array with the cardinality classes for the source and
+      # destination of this cardinality. Possible return values are:
+      # <tt>[1, 1]</tt>, <tt>[1, N]</tt>, <tt>[N, N]</tt>, and (in theory)
+      # <tt>[N, 1]</tt>.
+      def cardinality_class
+        [source_cardinality_class, destination_cardinality_class]
       end
       
-      CARDINALITY_NAMES.each_with_index do |cardinality, i|
-        klass = Cardinality.const_set cardinality.camelize.to_sym, Class.new(Cardinality) { @type = cardinality }
-        ORDER[klass] = i
+      protected
+
+      # The cardinality class of the source (left side). Either +1+ or +Infinity+.
+      def source_cardinality_class
+        source_range.last == 1 ? 1 : N
+      end
+      
+      # The cardinality class of the destination (right side). Either +1+ or +Infinity+.
+      def destination_cardinality_class
+        destination_range.last == 1 ? 1 : N
+      end
+      
+      private
+      
+      def compose_range(r)
+        return r..r if r.kind_of?(Integer) && r > 0
+        return (r.begin)..(r.end - 1) if r.exclude_end?
+        r
+      end
+
+      def compare_with(other, &block)
+        yield(self) <=> yield(other)
       end
     end
   end

data/lib/rails_erd/tasks.rake

@@ -6,8 +6,9 @@ namespace :erd do
   task :options do
     (RailsERD.options.keys.map(&:to_s) & ENV.keys).each do |option|
       RailsERD.options[option.to_sym] = case ENV[option]
-      when "true" then true
-      when "false" then false
+      when "true", "yes" then true
+      when "false", "no" then false
+      when /,/ then ENV[option].split(/\s*,\s*/).map(&:to_sym)
       else ENV[option].to_sym
       end
     end

data/rails-erd.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{rails-erd}
-  s.version = "0.2.0"
+  s.version = "0.3.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Rolf Timmermans"]
-  s.date = %q{2010-09-21}
+  s.date = %q{2010-10-03}
   s.description = %q{Automatically generate an entity-relationship diagram (ERD) for your Rails models.}
   s.email = %q{r.timmermans@voormedia.com}
   s.extra_rdoc_files = [
@@ -19,6 +19,8 @@ Gem::Specification.new do |s|
   s.files = [
     ".gitignore",
      "CHANGES.rdoc",
+     "Gemfile",
+     "Gemfile.lock",
      "LICENSE",
      "README.rdoc",
      "Rakefile",
@@ -70,18 +72,18 @@ Gem::Specification.new do |s|
 
     if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
       s.add_runtime_dependency(%q<activerecord>, ["~> 3.0.0"])
-      s.add_runtime_dependency(%q<activesupport>, ["~> 3.0.0"])
+      s.add_runtime_dependency(%q<activesupport>, ["~> 3.0"])
       s.add_runtime_dependency(%q<ruby-graphviz>, ["~> 0.9.17"])
       s.add_development_dependency(%q<sqlite3-ruby>, [">= 0"])
     else
       s.add_dependency(%q<activerecord>, ["~> 3.0.0"])
-      s.add_dependency(%q<activesupport>, ["~> 3.0.0"])
+      s.add_dependency(%q<activesupport>, ["~> 3.0"])
       s.add_dependency(%q<ruby-graphviz>, ["~> 0.9.17"])
       s.add_dependency(%q<sqlite3-ruby>, [">= 0"])
     end
   else
     s.add_dependency(%q<activerecord>, ["~> 3.0.0"])
-    s.add_dependency(%q<activesupport>, ["~> 3.0.0"])
+    s.add_dependency(%q<activesupport>, ["~> 3.0"])
     s.add_dependency(%q<ruby-graphviz>, ["~> 0.9.17"])
     s.add_dependency(%q<sqlite3-ruby>, [">= 0"])
   end

data/test/test_helper.rb

@@ -1,17 +1,15 @@
 require "rubygems"
-require "test/unit"
-require "active_support/test_case"
+require "bundler"
+Bundler.require
 
+require "test/unit"
 require "rails_erd/domain"
 
-require "active_record"
-require "sqlite3"
-
 ActiveRecord::Base.establish_connection :adapter => "sqlite3", :database => ":memory:"
 
-include RailsERD
-
 class ActiveSupport::TestCase
+  include RailsERD
+
   teardown :reset_domain
 
   def create_table(table, columns = {}, pk = nil)
@@ -58,12 +56,40 @@ class ActiveSupport::TestCase
   end
   
   def create_simple_domain
-    create_model "Foo", :bar => :references do
+    create_model "Beer", :bar => :references do
       belongs_to :bar
     end
     create_model "Bar"
   end
   
+  def create_one_to_one_assoc_domain
+    create_model "One" do
+      has_one :other
+    end
+    create_model "Other", :one => :references do
+      belongs_to :one
+    end
+  end
+
+  def create_one_to_many_assoc_domain
+    create_model "One" do
+      has_many :many
+    end
+    create_model "Many", :one => :references do
+      belongs_to :one
+    end
+  end
+
+  def create_many_to_many_assoc_domain
+    create_model "Many" do
+      has_and_belongs_to_many :more
+    end
+    create_model "More" do
+      has_and_belongs_to_many :many
+    end
+    create_table "manies_mores", :many_id => :integer, :more_id => :integer
+  end
+  
   private
   
   def reset_domain