rails-erd 0.1.1 → 0.2.0

data/.gitignore

@@ -1,3 +1,5 @@
 doc
 pkg
 rdoc
+*.rbc
+.yardoc

data/CHANGES.rdoc

@@ -1,3 +1,13 @@
+=== 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.

data/README.rdoc

@@ -40,7 +40,6 @@ http://rails-erd.rubyforge.org/examples/typo-blog.png
 
 {Download complete diagram as PDF}[http://rails-erd.rubyforge.org/examples/typo-blog.pdf]
 
-
 == Getting started
 
 In its most simple form, Rails ERD is a plugin for Rails 3 that provides you
@@ -102,7 +101,56 @@ suppress_warnings:: When set to +true+, no warnings are printed to the
                     command line while processing the domain model. Defaults
                     to +false+.
 
-== Advanced use
+== Custom diagrams
+
+If you're completely unsatisfied with the diagrams that Rails ERD creates,
+you can still use it to create your own diagrams. It provides you with an easy
+way to create any kind of diagram based on your application's domain model.
+
+As an example, a diagram class that generates code that can be used with
+yUML (http://yuml.me) can be as simple as:
+
+  require "rails_erd/diagram"
+
+  class YumlDiagram < RailsERD::Diagram
+    def process_relationship(rel)
+      return if rel.indirect?
+
+      arrow = case
+      when rel.cardinality.one_to_one?   then "1-1>"
+      when rel.cardinality.one_to_many?  then "1-*>"
+      when rel.cardinality.many_to_many? then "*-*>"
+      end
+
+      instructions << "[#{rel.source}] #{arrow} [#{rel.destination}]"
+    end
+
+    def save
+      instructions * "\n"
+    end
+
+    def instructions
+      @instructions ||= []
+    end
+  end
+
+Only 18 lines of code! Then, to generate the diagram (example based on the
+domain model of Gemcutter):
+
+  YumlDiagram.create
+  #=> "[Rubygem] 1-*> [Ownership]
+  #    [Rubygem] 1-*> [Subscription]
+  #    [Rubygem] 1-*> [Version]
+  #    [Rubygem] 1-1> [Linkset]
+  #    [Rubygem] 1-*> [Dependency]
+  #    [Version] 1-*> [Dependency]
+  #    [User] 1-*> [Ownership]
+  #    [User] 1-*> [Subscription]
+  #    [User] 1-*> [WebHook]"
+
+{See what that would look like}[http://yuml.me/diagram/scruffy/class/%5BRubygem%5D%201-*%3E%20%5BOwnership%5D,%20%5BRubygem%5D%201-*%3E%20%5BSubscription%5D,%20%5BRubygem%5D%201-*%3E%20%5BVersion%5D,%20%5BRubygem%5D%201-1%3E%20%5BLinkset%5D,%20%5BRubygem%5D%201-*%3E%20%5BDependency%5D,%20%5BVersion%5D%201-*%3E%20%5BDependency%5D,%20%5BUser%5D%201-*%3E%20%5BOwnership%5D,%20%5BUser%5D%201-*%3E%20%5BSubscription%5D,%20%5BUser%5D%201-*%3E%20%5BWebHook%5D].
+
+== Internal API
 
 Rails ERD also allows you to use its internal API to inspect your Rails domain
 model. It is easy to generate alternative presentations of your Active Record
@@ -158,10 +206,6 @@ The above is just a sample of what is possible. See the API documentation for
 more details:
 http://rails-erd.rubyforge.org/doc/
 
-If you wish to generate your own graphs, take a look at how the default
-diagrams are being generated. See the source of RailsERD::Diagram:
-http://github.com/voormedia/rails-erd/blob/master/lib/rails_erd/diagram.rb
-
 Please note that before the 1.0 release, the API may change subtly between
 minor versions.
 

data/Rakefile

@@ -12,8 +12,10 @@ Jeweler::Tasks.new do |spec|
   spec.email = "r.timmermans@voormedia.com"
   spec.homepage = "http://rails-erd.rubyforge.org/"
 
+  spec.add_runtime_dependency "activerecord", "~> 3.0.0"
   spec.add_runtime_dependency "activesupport", "~> 3.0.0"
   spec.add_runtime_dependency "ruby-graphviz", "~> 0.9.17"
+  spec.add_development_dependency "sqlite3-ruby"
 end
 
 Jeweler::GemcutterTasks.new
@@ -36,6 +38,5 @@ begin
     rdoc.title = "Rails ERD – Entity-Relationship Diagrams for Rails"
     rdoc.rdoc_dir = "rdoc"
   end
-rescue => e
-  puts e.message
+rescue LoadError
 end

data/VERSION

@@ -1 +1 @@
-0.1.1
+0.2.0

data/lib/rails_erd/attribute.rb

@@ -3,17 +3,17 @@ module RailsERD
   # Describes an entity's attribute. Attributes correspond directly to
   # database columns.
   class Attribute
-    TIMESTAMP_NAMES = %w{created_at created_on updated_at updated_on} #:nodoc:
+    TIMESTAMP_NAMES = %w{created_at created_on updated_at updated_on} # @private :nodoc:
 
     class << self
-      def from_model(domain, model) #:nodoc:
+      def from_model(domain, model) # @private :nodoc:
         model.arel_table.columns.collect { |column| Attribute.new(domain, model, column) }.sort
       end
     end
 
-    attr_reader :column #:nodoc:
+    attr_reader :column # @private :nodoc:
   
-    def initialize(domain, model, column) #:nodoc:
+    def initialize(domain, model, column) # @private :nodoc:
       @domain, @model, @column = domain, model, column
     end
     
@@ -53,15 +53,15 @@ module RailsERD
       TIMESTAMP_NAMES.include? name
     end
     
-    def <=>(other) #:nodoc:
+    def <=>(other) # @private :nodoc:
       name <=> other.name
     end
     
-    def inspect #:nodoc:
+    def inspect # @private :nodoc:
       "#<#{self.class.name}:0x%.14x @column=#{name.inspect} @type=#{type.inspect}>" % (object_id << 1)
     end
   
-    def to_s #:nodoc:
+    def to_s # @private :nodoc:
       name
     end
   

data/lib/rails_erd/diagram.rb

@@ -1,110 +1,150 @@
 require "rails_erd/domain"
-require "graphviz"
-require "erb"
 
 module RailsERD
-  # Create Graphviz-based diagrams based on the domain model. For easy
-  # command line graph generation, you can use rake:
+  # This class is an abstract class that will process a domain model and
+  # allows easy creation of diagrams. To implement a new diagram type, derive
+  # from this class and override +process_entity+, +process_relationship+, 
+  # and (optionally) +save+.
   #
-  #   % rake erd
+  # As an example, a diagram class that generates code that can be used with
+  # yUML (http://yuml.me) can be as simple as:
   #
-  # Please see the README.rdoc file for more details on how to use Rails ERD
-  # from the command line.
+  #   require "rails_erd/diagram"
+  #
+  #   class YumlDiagram < RailsERD::Diagram
+  #     def process_relationship(rel)
+  #       return if rel.indirect?
+  #
+  #       arrow = case
+  #       when rel.cardinality.one_to_one?   then "1-1>"
+  #       when rel.cardinality.one_to_many?  then "1-*>"
+  #       when rel.cardinality.many_to_many? then "*-*>"
+  #       end
+  #
+  #       instructions << "[#{rel.source}] #{arrow} [#{rel.destination}]"
+  #     end
+  #
+  #     def save
+  #       instructions * "\n"
+  #     end
+  #
+  #     def instructions
+  #       @instructions ||= []
+  #     end
+  #   end
+  #
+  # Then, to generate the diagram (example based on the domain model of Gemcutter):
+  #
+  #   YumlDiagram.create
+  #   #=> "[Rubygem] 1-*> [Ownership]
+  #   #    [Rubygem] 1-*> [Subscription]
+  #   #    [Rubygem] 1-*> [Version]
+  #   #    [Rubygem] 1-1> [Linkset]
+  #   #    [Rubygem] 1-*> [Dependency]
+  #   #    [Version] 1-*> [Dependency]
+  #   #    [User] 1-*> [Ownership]
+  #   #    [User] 1-*> [Subscription]
+  #   #    [User] 1-*> [WebHook]"
+  #
+  # For another example implementation, see Diagram::Graphviz, which is the
+  # default (and currently only) diagram type that is used by Rails ERD.
   class Diagram
-    NODE_LABEL_TEMPLATE = File.read(File.expand_path("templates/node.erb", File.dirname(__FILE__))) #:nodoc:
-    NODE_WIDTH = 130 #:nodoc:
-    
     class << self
-      # Generate a new domain model based on all <tt>ActiveRecord::Base</tt>
-      # subclasses, and create a new diagram. Use the given options for both
+      # Generates a new domain model based on all <tt>ActiveRecord::Base</tt>
+      # subclasses, and creates a new diagram. Use the given options for both
       # the domain generation and the diagram generation.
-      def generate(options = {})
-        new(Domain.generate(options), options).output
+      def create(options = {})
+        new(Domain.generate(options), options).create
       end
     end
+
+    # The options that are used to create this diagram.
+    attr_reader :options
     
-    attr_reader :options #:nodoc:
+    # The domain that this diagram represents.
+    attr_reader :domain
 
     # Create a new diagram based on the given domain.
     def initialize(domain, options = {})
       @domain, @options = domain, RailsERD.options.merge(options)
     end
     
-    # Save the diagram.
-    def output
-      graph.output(options.file_type.to_sym => file_name)
-      self
-    end
-    
-    # Returns the file name that will be used when saving the diagram.
-    def file_name
-      "ERD.#{options.file_type}"
+    # Generates and saves the diagram, returning the result of +save+.
+    def create
+      generate
+      save
     end
     
-    private
-    
-    def graph
-      @graph ||= GraphViz.new(@domain.name, :type => :digraph) do |graph|
-        graph[:rankdir] = horizontal? ? :LR : :TB
-        graph[:ranksep] = 0.5
-        graph[:nodesep] = 0.35
-        graph[:margin] = "0.4,0.4"
-        graph[:concentrate] = true
-        graph[:label] = "#{@domain.name} domain model\\n\\n"
-        graph[:labelloc] = :t
-        graph[:fontsize] = 13
-        graph[:fontname] = "Arial Bold"
-        graph[:remincross] = true
-        graph[:outputorder] = :edgesfirst
-
-        graph.node[:shape] = "Mrecord"
-        graph.node[:fontsize] = 10
-        graph.node[:fontname] = "Arial"
-        graph.node[:margin] = "0.07,0.05"
+    # Generates the diagram, but does not save the output. It is called
+    # internally by Diagram#create.
+    def generate
+      filtered_entities.each do |entity|
+        process_entity entity, filtered_attributes(entity)
+      end
 
-        graph.edge[:fontname] = "Arial"
-        graph.edge[:fontsize] = 8
-        graph.edge[:dir] = :both
-        graph.edge[:arrowsize] = 0.8
-        
-        nodes = {}
+      filtered_relationships.each do |relationship|
+        process_relationship relationship
+      end
+    end
 
-        @domain.entities.each do |entity|
-          if options.exclude_unconnected && !entity.connected?
-            warn "Skipping unconnected model #{entity.name} (use exclude_unconnected=false to include)"
-            next
-          end
-          
-          attributes = entity.attributes.reject { |attribute|
-            options.exclude_primary_keys && attribute.primary_key? or
-            options.exclude_foreign_keys && attribute.foreign_key? or
-            options.exclude_timestamps && attribute.timestamp?
-          }
-          
-          nodes[entity] = graph.add_node entity.name, :label => "<" + ERB.new(NODE_LABEL_TEMPLATE, nil, "<>").result(binding) + ">"
-        end
-        
-        raise "No (connected) entities found; create your models first!" if nodes.empty?
+    # Saves the diagram. Can be overridden in subclasses to write to an output
+    # file. It is called internally by Diagram#create.
+    def save
+    end
         
-        @domain.relationships.each do |relationship|
-          options = {}
-          options[:arrowhead] = relationship.cardinality.one_to_one? ? :dot : :normal
-          options[:arrowtail] = relationship.cardinality.many_to_many? ? :normal : :dot
-          options[:weight] = relationship.strength
-          options.merge! :style => :dashed, :constraint => false if relationship.indirect?
+    protected
 
-          graph.add_edge nodes[relationship.source], nodes[relationship.destination], options
-        end
-      end
+    # Process a given entity and its attributes. This method should be implemented
+    # by subclasses. It is intended to add a representation of the entity to
+    # the diagram. This method will be called once for each entity that should
+    # be displayed, typically in alphabetic order.
+    def process_entity(entity, attributes)
+    end
+    
+    # Process a given relationship. This method should be implemented by
+    # subclasses. It should add a representation of the relationship to
+    # the diagram. This method will be called once for eacn relationship
+    # that should be displayed.
+    def process_relationship(relationship)
     end
     
+    # Returns +true+ if the layout or hierarchy of the diagram should be
+    # horizontally oriented.
     def horizontal?
       options.orientation == :horizontal
     end
 
+    # Returns +true+ if the layout or hierarchy of the diagram should be
+    # vertically oriented.
     def vertical?
       !horizontal?
     end
+    
+    private
+    
+    def filtered_entities
+      @domain.entities.collect do |entity|
+        if options.exclude_unconnected && !entity.connected?
+          warn "Skipping unconnected model #{entity.name} (use exclude_unconnected=false to include)"
+        else
+          entity
+        end
+      end.compact.tap do |entities|
+        raise "No (connected) entities found; create your models first!" if entities.empty?
+      end
+    end
+    
+    def filtered_relationships
+      @domain.relationships
+    end
+    
+    def filtered_attributes(entity)
+      entity.attributes.reject { |attribute|
+        options.exclude_primary_keys && attribute.primary_key? or
+        options.exclude_foreign_keys && attribute.foreign_key? or
+        options.exclude_timestamps && attribute.timestamp?
+      }
+    end
 
     def warn(message)
       puts "Warning: #{message}" unless options.suppress_warnings

data/lib/rails_erd/diagram/graphviz.rb

@@ -0,0 +1,120 @@
+require "rails_erd/diagram"
+require "graphviz"
+require "erb"
+
+# Fix bad RegEx test in Ruby-Graphviz.
+GraphViz::Types::LblString.class_eval do
+  def output
+    if /^<.*>$/m =~ @data
+      @data
+    else
+      @data.to_s.inspect.gsub("\\\\", "\\")
+    end
+  end
+  alias_method :to_gv, :output
+  alias_method :to_s, :output
+end
+
+module RailsERD
+  class Diagram
+    # Create Graphviz-based diagrams based on the domain model. For easy
+    # command line graph generation, you can use rake:
+    #
+    #   % rake erd
+    #
+    # Please see the README.rdoc file for more details on how to use Rails ERD
+    # from the command line.
+    class Graphviz < Diagram
+      NODE_LABEL_TEMPLATE = ERB.new(File.read(File.expand_path("templates/node.erb", File.dirname(__FILE__))), nil, "<>") # @private :nodoc:
+
+      NODE_WIDTH = 130 # @private :nodoc:
+      
+      # Default graph attributes.
+      GRAPH_ATTRIBUTES = {
+        :rankdir => :LR,
+        :ranksep => 0.5,
+        :nodesep => 0.35,
+        :margin => "0.4,0.4",
+        :concentrate => true,
+        :labelloc => :t,
+        :fontsize => 13,
+        :fontname => "Arial Bold",
+        :remincross => true,
+        :outputorder => :edgesfirst }
+
+      # Default node attributes.
+      NODE_ATTRIBUTES = {
+        :shape => "Mrecord",
+        :fontsize => 10,
+        :fontname => "Arial",
+        :margin => "0.07,0.05",
+        :penwidth => 0.8 }
+
+      # Default edge attributes.
+      EDGE_ATTRIBUTES = {
+        :fontname => "Arial",
+        :fontsize => 8,
+        :dir => :both,
+        :arrowsize => 0.7,
+        :penwidth => 0.8 }
+
+      def graph
+        @graph ||= GraphViz.digraph(@domain.name) do |graph|
+          # Set all default attributes.
+          GRAPH_ATTRIBUTES.each { |attribute, value| graph[attribute] = value }
+          NODE_ATTRIBUTES.each  { |attribute, value| graph.node[attribute] = value }
+          EDGE_ATTRIBUTES.each  { |attribute, value| graph.edge[attribute] = value }
+
+          # Switch rank direction if we're told to create a vertically
+          # oriented graph.
+          graph[:rankdir] = :TB if vertical?
+          
+          # Title of the graph itself.
+          graph[:label] = "#{@domain.name} domain model\\n\\n"
+        end
+      end
+      
+      # Save the diagram and return the file name that was written to.
+      def save
+        graph.output(options.file_type.to_sym => file_name)
+        file_name
+      end
+
+      protected
+
+      def process_entity(entity, attributes)
+        graph.add_node entity.name, entity_options(entity, attributes)
+      end
+
+      def process_relationship(relationship)
+        graph.add_edge graph.get_node(relationship.source.name), graph.get_node(relationship.destination.name),
+          relationship_options(relationship)
+      end
+      
+      private
+      
+      # Returns the file name that will be used when saving the diagram.
+      def file_name
+        "ERD.#{options.file_type}"
+      end
+
+      # Returns an options hash based on the given entity and its attributes.
+      def entity_options(entity, attributes)
+        { :label => "<#{NODE_LABEL_TEMPLATE.result(binding)}>" }
+      end
+      
+      # Returns an options hash 
+      def relationship_options(relationship)
+        {}.tap do |options|
+          options[:arrowhead] = relationship.cardinality.one_to_one?   ? :dot : :normal
+          options[:arrowtail] = relationship.cardinality.many_to_many? ? :normal : :dot
+          options[:weight] = relationship.strength
+          if relationship.indirect?
+            options[:style] = :dotted
+            options[:constraint] = false
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rails_erd/{templates → diagram/templates}/node.erb

@@ -1,13 +1,17 @@
 <% if vertical? %>{<% end %>
 <table border="0" align="center" cellspacing="0.5" cellpadding="0" width="<%= NODE_WIDTH + 4 %>">
   <tr><td align="center" valign="bottom" width="<%= NODE_WIDTH %>"><font face="Arial Bold" point-size="11"><%= entity.name %></font></td></tr>
-</table>|<% if attributes.any? %>
-  <table border="0" align="left" cellspacing="2" cellpadding="0" width="<%= NODE_WIDTH + 4 %>">
+</table>
+|
+<table border="0" align="left" cellspacing="2" cellpadding="0" width="<%= NODE_WIDTH + 4 %>">
+  <% if attributes.any? %>
     <% attributes.each do |attribute| %>
       <tr>
         <td align="left" width="<%= NODE_WIDTH %>" port="<%= attribute %>"><%= attribute %> <font face="Arial Italic" color="grey60"><%= attribute.type_description %></font></td>
       </tr>
     <% end %>
-  </table>
-<% end %>
+  <% else %>
+    <tr><td height="6"></td></tr>
+  <% end %>
+</table>
 <% if vertical? %>}<% end %>

data/lib/rails_erd/domain.rb

@@ -21,7 +21,8 @@ module RailsERD
       end
     end
     
-    attr_reader :options #:nodoc:
+    # The options that are used to generate this domain model.
+    attr_reader :options
 
     # Create a new domain model object based on the given array of models.
     # The given models are assumed to be subclasses of <tt>ActiveRecord::Base</tt>.
@@ -46,17 +47,18 @@ module RailsERD
     end
     
     # Returns a specific entity object for the given Active Record model.
-    def entity_for(model) #:nodoc:
+    def entity_for(model) # @private :nodoc:
       entity_mapping[model] or raise "model #{model} exists, but is not included in the domain"
     end
     
     # Returns an array of relationships for the given Active Record model.
-    def relationships_for(model) #:nodoc:
+    def relationships_for(model) # @private :nodoc:
       relationships_mapping[model] or []
     end
   
-    def inspect #:nodoc:
-      "#<#{self.class} {#{relationships.map { |rel| "#{rel.from} => #{rel.to}" } * ", "}}>"
+    def inspect # @private :nodoc:
+      "#<#{self.class}:0x%.14x {%s}>" %
+        [object_id << 1, relationships.map { |rel| "#{rel.source} => #{rel.destination}" } * ", "]
     end
     
     private

data/lib/rails_erd/entity.rb

@@ -8,7 +8,7 @@ module RailsERD
     # The Active Record model that this entity corresponds to.
     attr_reader :model
 
-    def initialize(domain, model) #:nodoc:
+    def initialize(domain, model) # @private :nodoc:
       @domain, @model = domain, model
     end
     
@@ -35,15 +35,15 @@ module RailsERD
       model.name
     end
   
-    def inspect #:nodoc:
+    def inspect # @private :nodoc:
       "#<#{self.class}:0x%.14x @model=#{name}>" % (object_id << 1)
     end
     
-    def to_s #:nodoc:
+    def to_s # @private :nodoc:
       name
     end
   
-    def <=>(other) #:nodoc:
+    def <=>(other) # @private :nodoc:
       self.name <=> other.name
     end
   end

data/lib/rails_erd/railtie.rb

@@ -1,5 +1,8 @@
 module RailsERD
-  class Railtie < Rails::Railtie #:nodoc:
+  # Rails ERD integrates with Rails 3. If you add it to your +Gemfile+, you
+  # will gain a Rake task called +erd+, which you can use to generate diagrams
+  # of your domain model. See the README.rdoc file for more information.
+  class Railtie < Rails::Railtie
     rake_tasks do
       load "rails_erd/tasks.rake"
     end

data/lib/rails_erd/relationship.rb

@@ -5,7 +5,7 @@ module RailsERD
   # key are grouped together.
   class Relationship
     class << self
-      def from_associations(domain, associations) #:nodoc:
+      def from_associations(domain, associations) # @private :nodoc:
         assoc_groups = associations.group_by { |assoc| association_identity(assoc) }
         assoc_groups.collect { |_, assoc_group| Relationship.new(domain, assoc_group.to_a) }
       end
@@ -29,7 +29,7 @@ module RailsERD
     # a +belongs_to+ association with the other model.
     attr_reader :destination
   
-    def initialize(domain, associations) #:nodoc:
+    def initialize(domain, associations) # @private :nodoc:
       @domain = domain
       @reverse_associations, @forward_associations = *associations.partition(&:belongs_to?)
     
@@ -56,7 +56,7 @@ module RailsERD
     # Rails with <tt>has_many :through</tt> or <tt>has_one :through</tt>
     # association macros.
     def indirect?
-      @forward_associations.all?(&:through_reflection)
+      !@forward_associations.empty? and @forward_associations.all?(&:through_reflection)
     end
     
     # Indicates whether or not the relationship is defined by two inverse
@@ -77,11 +77,11 @@ module RailsERD
       associations.size
     end
 
-    def inspect #:nodoc:
+    def inspect # @private :nodoc:
       "#<#{self.class}:0x%.14x @source=#{source} @destination=#{destination}>" % (object_id << 1)
     end
   
-    def <=>(other) #:nodoc:
+    def <=>(other) # @private :nodoc:
       (source.name <=> other.source.name).nonzero? or (destination.name <=> other.destination.name)
     end
   end

data/lib/rails_erd/relationship/cardinality.rb

@@ -1,14 +1,14 @@
 module RailsERD
   class Relationship
     class Cardinality
-      CARDINALITY_NAMES = %w{one_to_one one_to_many many_to_many} #:nodoc:
-      ORDER = {} #:nodoc:
+      CARDINALITY_NAMES = %w{one_to_one one_to_many many_to_many} # @private :nodoc:
+      ORDER = {} # @private :nodoc:
 
       class << self
-        # Returns the cardinality as symbol.
+        # Returns the cardinality as a symbol.
         attr_reader :type
-
-        def from_macro(macro) #:nodoc:
+        
+        def from_macro(macro) # @private :nodoc:
           case macro
           when :has_and_belongs_to_many then ManyToMany
           when :has_many then OneToMany
@@ -16,7 +16,7 @@ module RailsERD
           end
         end
         
-        def <=>(other) #:nodoc:
+        def <=>(other) # @private :nodoc:
           ORDER[self] <=> ORDER[other]
         end
         
@@ -28,7 +28,7 @@ module RailsERD
       end
       
       CARDINALITY_NAMES.each_with_index do |cardinality, i|
-        klass = Cardinality.const_set cardinality.camelize.to_sym, Class.new(Cardinality) { @@type = cardinality }
+        klass = Cardinality.const_set cardinality.camelize.to_sym, Class.new(Cardinality) { @type = cardinality }
         ORDER[klass] = i
       end
     end

data/lib/rails_erd/tasks.rake

@@ -14,7 +14,7 @@ namespace :erd do
   end
   
   task :load_models do
-    say "Loading ActiveRecord models..."
+    say "Loading Active Record models..."
 
     Rake::Task[:environment].invoke
     Rails.application.config.paths.app.models.paths.each do |model_path|
@@ -25,12 +25,12 @@ namespace :erd do
   end
   
   task :generate => [:options, :load_models] do
-    say "Generating ERD diagram..."
+    say "Generating Entity-Relationship Diagram..."
 
-    require "rails_erd/diagram"
-    diagram = RailsERD::Diagram.generate
+    require "rails_erd/diagram/graphviz"
+    file = RailsERD::Diagram::Graphviz.create
 
-    say "Done! Saved diagram to #{diagram.file_name}."
+    say "Done! Saved diagram to #{file}."
   end
 end
 

data/rails-erd.gemspec

@@ -0,0 +1,89 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run the gemspec command
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{rails-erd}
+  s.version = "0.2.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.description = %q{Automatically generate an entity-relationship diagram (ERD) for your Rails models.}
+  s.email = %q{r.timmermans@voormedia.com}
+  s.extra_rdoc_files = [
+    "LICENSE",
+     "README.rdoc"
+  ]
+  s.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/diagram/graphviz.rb",
+     "lib/rails_erd/diagram/templates/node.erb",
+     "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",
+     "rails-erd.gemspec",
+     "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/graphviz_test.rb",
+     "test/unit/rake_task_test.rb",
+     "test/unit/relationship_test.rb"
+  ]
+  s.homepage = %q{http://rails-erd.rubyforge.org/}
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.require_paths = ["lib"]
+  s.rubyforge_project = %q{rails-erd}
+  s.rubygems_version = %q{1.3.7}
+  s.summary = %q{Entity-relationship diagram for your Rails models.}
+  s.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/graphviz_test.rb",
+     "test/unit/rake_task_test.rb",
+     "test/unit/relationship_test.rb"
+  ]
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    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<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<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<ruby-graphviz>, ["~> 0.9.17"])
+    s.add_dependency(%q<sqlite3-ruby>, [">= 0"])
+  end
+end
+

data/test/test_helper.rb

@@ -4,8 +4,8 @@ require "active_support/test_case"
 
 require "rails_erd/domain"
 
-require "rails"
 require "active_record"
+require "sqlite3"
 
 ActiveRecord::Base.establish_connection :adapter => "sqlite3", :database => ":memory:"
 
@@ -57,6 +57,13 @@ class ActiveSupport::TestCase
     $stdout = stdout
   end
   
+  def create_simple_domain
+    create_model "Foo", :bar => :references do
+      belongs_to :bar
+    end
+    create_model "Bar"
+  end
+  
   private
   
   def reset_domain

data/test/unit/cardinality_test.rb

@@ -1,8 +1,25 @@
 require File.expand_path("../test_helper", File.dirname(__FILE__))
 
 class CardinalityTest < ActiveSupport::TestCase
+  # Cardinality order ========================================================
   test "cardinalities should be sorted in order of maniness" do
     assert_equal [Relationship::Cardinality::OneToOne, Relationship::Cardinality::OneToMany, Relationship::Cardinality::ManyToMany],
       [Relationship::Cardinality::OneToMany, Relationship::Cardinality::ManyToMany, Relationship::Cardinality::OneToOne].sort
   end
+  
+  # Cardinality properties ===================================================
+  test "one_to_one should return true for one to one cardinalities" do
+    assert_equal [true, false, false], [Relationship::Cardinality::OneToOne,
+      Relationship::Cardinality::OneToMany, Relationship::Cardinality::ManyToMany].map(&:one_to_one?)
+  end
+
+  test "one_to_many should return true for one to many cardinalities" do
+    assert_equal [false, true, false], [Relationship::Cardinality::OneToOne,
+      Relationship::Cardinality::OneToMany, Relationship::Cardinality::ManyToMany].map(&:one_to_many?)
+  end
+
+  test "many_to_many should return true for many to many cardinalities" do
+    assert_equal [false, false, true], [Relationship::Cardinality::OneToOne,
+      Relationship::Cardinality::OneToMany, Relationship::Cardinality::ManyToMany].map(&:many_to_many?)
+  end
 end

data/test/unit/diagram_test.rb

@@ -1,34 +1,57 @@
 require File.expand_path("../test_helper", File.dirname(__FILE__))
 
-require "rails_erd/diagram"
-
 class DiagramTest < ActiveSupport::TestCase
+  def setup
+    load "rails_erd/diagram.rb"
+  end
+  
   def teardown
-    FileUtils.rm "ERD.dot" rescue nil
+    RailsERD.send :remove_const, :Diagram
   end
   
-  # Diagram generation =======================================================
-  test "generate should create output based on domain model" do
-    create_model "Foo", :bar => :references do
-      belongs_to :bar
+  # Diagram ==================================================================
+  test "create class method should return result of save" do
+    create_simple_domain
+    subclass = Class.new(Diagram) do
+      def save
+        "foobar"
+      end
     end
-    create_model "Bar"
-    RailsERD::Diagram.generate(:file_type => :dot)
-    assert File.exists?("ERD.dot")
+    assert_equal "foobar", subclass.create
+  end
+
+  test "create should return result of save" do
+    create_simple_domain
+    diagram = Class.new(Diagram) do
+      def save
+        "foobar"
+      end
+    end.new(Domain.generate)
+    assert_equal "foobar", diagram.create
+  end
+  
+  test "domain sould return given domain" do
+    domain = Object.new
+    assert_same domain, Class.new(Diagram).new(domain).domain
   end
 
-  test "generate should not create output if there are no connected models" do
-    RailsERD::Diagram.generate(:file_type => :dot) rescue nil
-    assert !File.exists?("ERD.dot")
+  # Diagram abstractness =====================================================
+  test "create should succeed silently if called on abstract class" do
+    create_simple_domain
+    assert_nothing_raised do
+      Diagram.create
+    end
   end
 
-  test "generate should abort and complain if there are no connected models" do
-    message = nil
-    begin
-      RailsERD::Diagram.generate(:file_type => :dot)
-    rescue => e
-      message = e.message
+  test "create should succeed if called on class that implements process_entity and process_relationship" do
+    create_simple_domain
+    assert_nothing_raised do
+      Class.new(Diagram) do
+        def process_entity(*args)
+        end
+        def process_relationship(*args)
+        end
+      end.create
     end
-    assert_match /No \(connected\) entities found/, message
   end
 end

data/test/unit/domain_test.rb

@@ -7,15 +7,30 @@ class DomainTest < ActiveSupport::TestCase
   end
   
   test "name should return rails application name" do
-    Object::Quux = Module.new
-    Object::Quux::Application = Class.new Rails::Application
-    assert_equal "Quux", Domain.generate.name
+    begin
+      Object::Quux = Module.new
+      Object::Quux::Application = Class.new
+      Object::Rails = Struct.new(:application).new(Object::Quux::Application.new)
+      assert_equal "Quux", Domain.generate.name
+    ensure
+      Object::Quux.send :remove_const, :Application
+      Object.send :remove_const, :Quux
+      Object.send :remove_const, :Rails
+    end
   end
   
   test "name should return nil outside rails" do
     assert_nil Domain.generate.name
   end
   
+  test "inspect should display relationships" do
+    create_model "Foo", :bar => :references do
+      belongs_to :bar
+    end
+    create_model "Bar"
+    assert_match %r{#<RailsERD::Domain:.* {Bar => Foo}>}, Domain.generate.inspect
+  end
+  
   # Entity processing ========================================================
   test "entity_for should return associated entity for given model" do
     create_model "Foo"

data/test/unit/graphviz_test.rb

@@ -0,0 +1,140 @@
+require File.expand_path("../test_helper", File.dirname(__FILE__))
+
+class GraphvizTest < ActiveSupport::TestCase
+  def setup
+    RailsERD.options.file_type = :dot
+    load "rails_erd/diagram/graphviz.rb"
+  end
+  
+  def teardown
+    FileUtils.rm "ERD.dot" rescue nil
+    RailsERD::Diagram.send :remove_const, :Graphviz
+  end
+  
+  def diagram
+    @diagram ||= Diagram::Graphviz.new(Domain.generate).tap do |diagram|
+      diagram.generate
+    end
+  end
+  
+  def find_dot_nodes(diagram)
+    [].tap do |nodes|
+      diagram.graph.each_node do |node|
+        nodes << node
+      end
+    end
+  end
+
+  def find_dot_edges(diagram)
+    [].tap do |edges|
+      diagram.graph.each_edge do |edge|
+        edges << [edge.node_one, edge.node_two]
+      end
+    end
+  end
+  
+  # Diagram properties =======================================================
+  test "file name should depend on file type" do
+    create_simple_domain
+    begin
+      assert_equal "ERD.svg", Diagram::Graphviz.create(:file_type => :svg)
+    ensure
+      FileUtils.rm "ERD.svg" rescue nil
+    end
+  end
+  
+  # Diagram generation =======================================================
+  test "create should create output based on domain model" do
+    create_model "Foo", :bar => :references, :column => :string do
+      belongs_to :bar
+    end
+    create_model "Bar", :column => :string
+    Diagram::Graphviz.create
+    assert File.exists?("ERD.dot")
+  end
+
+  test "create should create output based on domain without attributes" do
+    create_model "Foo", :bar => :references do
+      belongs_to :bar
+    end
+    create_model "Bar"
+    Diagram::Graphviz.create
+    assert File.exists?("ERD.dot")
+  end
+  
+  test "create should create vertical output based on domain model" do
+    create_model "Foo", :bar => :references, :column => :string do
+      belongs_to :bar
+    end
+    create_model "Bar", :column => :string
+    Diagram::Graphviz.create(:orientation => :vertical)
+    assert File.exists?("ERD.dot")
+  end
+
+  test "create should create vertical output based on domain without attributes" do
+    create_model "Foo", :bar => :references do
+      belongs_to :bar
+    end
+    create_model "Bar"
+    Diagram::Graphviz.create(:orientation => :vertical)
+    assert File.exists?("ERD.dot")
+  end
+
+  test "create should not create output if there are no connected models" do
+    Diagram::Graphviz.create rescue nil
+    assert !File.exists?("ERD.dot")
+  end
+
+  test "create should abort and complain if there are no connected models" do
+    message = nil
+    begin
+      Diagram::Graphviz.create
+    rescue => e
+      message = e.message
+    end
+    assert_match /No \(connected\) entities found/, message
+  end
+  
+  # Graphviz output ==========================================================
+  test "generate should create directed graph" do
+    create_simple_domain
+    assert_equal "digraph", diagram.graph.type
+  end
+  
+  test "generate should create node for each entity" do
+    create_model "Foo", :bar => :references do
+      belongs_to :bar
+    end
+    create_model "Bar"
+    assert_equal ["Bar", "Foo"], find_dot_nodes(diagram).sort
+  end
+  
+  test "generate should add label for entities" do
+    create_model "Foo", :bar => :references do
+      belongs_to :bar
+    end
+    create_model "Bar"
+    assert_match %r{<\w+.*?>Bar</\w+>},
+      diagram.graph.get_node(find_dot_nodes(diagram).first)[:label].to_gv
+  end
+
+  test "generate should add attributes to entity labels" do
+    create_model "Foo", :bar => :references do
+      belongs_to :bar
+    end
+    create_model "Bar", :column => :string
+    assert_match %r{<\w+.*?>column <\w+.*?>str</\w+.*?>},
+      diagram.graph.get_node(find_dot_nodes(diagram).first)[:label].to_gv
+  end
+
+
+  test "generate should create edge for each relationship" do
+    create_model "Foo", :bar => :references do
+      belongs_to :bar
+    end
+    create_model "Bar", :foo => :references do
+      belongs_to :foo
+    end
+    assert_equal [["Bar", "Foo"], ["Foo", "Bar"]], find_dot_edges(diagram).sort
+  end
+end

data/test/unit/rake_task_test.rb

@@ -0,0 +1,31 @@
+require File.expand_path("../test_helper", File.dirname(__FILE__))
+
+class RakeTaskTest < ActiveSupport::TestCase
+  include ActiveSupport::Testing::Isolation
+
+  def setup
+    require "rake"
+    load "rails_erd/tasks.rake"
+
+    RailsERD.options.file_type = :dot
+    RailsERD.options.suppress_warnings = true
+    Rake.application.options.silent = true
+  end
+
+  def teardown
+    FileUtils.rm "ERD.dot" rescue nil
+    RailsERD::Diagram.send :remove_const, :Graphviz rescue nil
+  end
+  
+  # Diagram generation =======================================================
+  test "generate task should create output based on domain model" do
+    create_simple_domain
+    Rake::Task["erd:generate"].execute
+    assert File.exists?("ERD.dot")
+  end
+
+  test "generate task should not create output if there are no connected models" do
+    Rake::Task["erd:generate"].execute rescue nil
+    assert !File.exists?("ERD.dot")
+  end
+end

data/test/unit/relationship_test.rb

@@ -80,6 +80,15 @@ class RelationshipTest < ActiveSupport::TestCase
     assert_equal [false], domain.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"
+    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

metadata

@@ -1,13 +1,12 @@
 --- !ruby/object:Gem::Specification 
 name: rails-erd
 version: !ruby/object:Gem::Version 
-  hash: 25
   prerelease: false
   segments: 
   - 0
-  - 1
-  - 1
-  version: 0.1.1
+  - 2
+  - 0
+  version: 0.2.0
 platform: ruby
 authors: 
 - Rolf Timmermans
@@ -15,18 +14,17 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-09-20 00:00:00 +02:00
+date: 2010-09-21 00:00:00 +02:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
-  name: activesupport
+  name: activerecord
   prerelease: false
   requirement: &id001 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
     - - ~>
       - !ruby/object:Gem::Version 
-        hash: 7
         segments: 
         - 3
         - 0
@@ -35,21 +33,48 @@ dependencies:
   type: :runtime
   version_requirements: *id001
 - !ruby/object:Gem::Dependency 
-  name: ruby-graphviz
+  name: activesupport
   prerelease: false
   requirement: &id002 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
     - - ~>
       - !ruby/object:Gem::Version 
-        hash: 25
+        segments: 
+        - 3
+        - 0
+        - 0
+        version: 3.0.0
+  type: :runtime
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: ruby-graphviz
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
         segments: 
         - 0
         - 9
         - 17
         version: 0.9.17
   type: :runtime
-  version_requirements: *id002
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: sqlite3-ruby
+  prerelease: false
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id004
 description: Automatically generate an entity-relationship diagram (ERD) for your Rails models.
 email: r.timmermans@voormedia.com
 executables: []
@@ -70,19 +95,23 @@ files:
 - lib/rails_erd.rb
 - lib/rails_erd/attribute.rb
 - lib/rails_erd/diagram.rb
+- lib/rails_erd/diagram/graphviz.rb
+- lib/rails_erd/diagram/templates/node.erb
 - 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
+- rails-erd.gemspec
 - 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/graphviz_test.rb
+- test/unit/rake_task_test.rb
 - test/unit/relationship_test.rb
 has_rdoc: true
 homepage: http://rails-erd.rubyforge.org/
@@ -98,7 +127,6 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
-      hash: 3
       segments: 
       - 0
       version: "0"
@@ -107,7 +135,6 @@ required_rubygems_version: !ruby/object:Gem::Requirement
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
-      hash: 3
       segments: 
       - 0
       version: "0"
@@ -125,4 +152,6 @@ test_files:
 - 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