dmattes-railroad_xing 0.5.4

data/lib/railroad/app_diagram.rb

@@ -0,0 +1,109 @@
+# RailRoad - RoR diagrams generator
+# http://railroad.rubyforge.org
+#
+# Copyright 2007-2008 - Javier Smaldone (http://www.smaldone.com.ar)
+# See COPYING for more details
+#
+# Dec 2008 - Roy Wright
+# added FrameworkFactory to support multiple application frameworks
+
+require 'railroad/diagram_graph'
+require 'railroad/framework_factory'
+
+# Root class for RailRoad diagrams
+class AppDiagram
+
+  def initialize(options)
+    @options = options
+    @graph = DiagramGraph.new
+    @graph.show_label = @options.label
+
+    STDERR.print "Loading application environment\n" if @options.verbose
+    load_environment
+
+    STDERR.print "Loading application classes\n" if @options.verbose
+    load_classes
+  end
+
+  # Print diagram
+  def print
+    if @options.output
+      old_stdout = STDOUT.dup
+      begin
+        STDOUT.reopen(@options.output)
+      rescue
+        STDERR.print "Error: Cannot write diagram to #{@options.output}\n\n"
+        exit 2
+      end
+    end
+    
+    if @options.xmi 
+      STDERR.print "Generating XMI diagram\n" if @options.verbose
+    	STDOUT.print @graph.to_xmi
+    else
+      STDERR.print "Generating DOT graph\n" if @options.verbose
+      STDOUT.print @graph.to_dot 
+    end
+
+    if @options.output
+      STDOUT.reopen(old_stdout)
+    end
+  end # print
+
+  private 
+
+  # Prevents Rails application from writing to STDOUT
+  def disable_stdout
+    @old_stdout = STDOUT.dup
+    STDOUT.reopen(PLATFORM =~ /mswin/ ? "NUL" : "/dev/null")
+  end
+
+  # Restore STDOUT  
+  def enable_stdout
+    STDOUT.reopen(@old_stdout)
+  end
+
+
+  # Print error when loading Rails application
+  def print_error(type)
+    STDERR.print "Error loading #{type}.\n  (Are you running " +
+                 "#{APP_NAME} on the application's root directory?)\n\n"
+  end
+
+  # Load Rails application's environment
+  def load_environment
+    begin
+      disable_stdout
+      @framework = FrameworkFactory.getFramework
+      raise LoadError.new if @framework.nil?
+      @graph.migration_version = @framework.migration_version
+      enable_stdout
+    rescue LoadError
+      enable_stdout
+      print_error "application environment"
+      raise
+    end
+  end
+  
+  # is the given class a subclass of the application controller?
+  def is_application_subclass?(klass)
+    @framework.is_application_subclass?(klass)
+  end
+  
+  # get the controller's files returning the application controller first in returned array
+  def get_controller_files(options)
+    @framework.get_controller_files(options)
+  end
+
+  # Extract class name from filename
+  def extract_class_name(filename)
+    @framework.extract_class_name(filename)
+  end
+
+  # convert the give string to a constant
+  def constantize(str)
+    @framework.constantize(str)
+  end
+  
+end # class AppDiagram
+

data/lib/railroad/ar_model.rb

@@ -0,0 +1,105 @@
+# The "model" used to interact with ActiveRecord models.
+# 
+# Dec 2008 - Roy Wright
+# created class an refactored logic from models_diagram.rb
+#
+class AR_Model
+  def initialize(klass, options)
+    @klass = klass
+    @options = options
+    # Processed habtm associations
+    @habtm = []
+  end
+  
+  # return an Array of attribute (column) "name:type" strings for the 
+  # model.
+  # if @options.hide_magic is asserted, then remove some standard
+  # attribute names from the array.
+  # if @options.hide_types is asserted, then the returned strings are
+  # just the names "name".
+  def attributes
+    attribs = []
+
+    if @options.hide_magic 
+      # From patch #13351
+      # http://wiki.rubyonrails.org/rails/pages/MagicFieldNames
+      magic_fields = [
+      "created_at", "created_on", "updated_at", "updated_on",
+      "lock_version", "type", "id", "position", "parent_id", "lft", 
+      "rgt", "quote", "template"
+      ]
+      magic_fields << @klass.table_name + "_count" if @klass.respond_to? 'table_name' 
+      content_columns = @klass.content_columns.select {|c| ! magic_fields.include? c.name}
+    elsif @options.show_magic 
+      content_columns = @klass.columns
+    else
+      content_columns = @klass.content_columns
+    end
+    
+    content_columns.each do |a|
+      content_column = a.name
+      content_column += ' :' + a.type.to_s unless @options.hide_types
+      attribs << content_column
+    end
+    attribs
+  end
+  
+  # is the model abstract?
+  def abstract?
+    @klass.abstract_class?
+  end
+  
+  # return the model edges (relationships)
+  def edges
+    found_edges = []
+    # Process class associations
+    associations = @klass.reflect_on_all_associations
+    if @options.inheritance && ! @options.transitive
+      superclass_associations = @klass.superclass.reflect_on_all_associations
+      
+      associations = associations.select{|a| ! superclass_associations.include? a} 
+      # This doesn't works!
+      # associations -= current_class.superclass.reflect_on_all_associations
+    end
+    associations.each do |a|
+      found_edges << process_association(@klass.name, a)
+    end
+    found_edges.compact
+  end
+  
+  # is the model meaningful?
+  def meaningful?
+    (@klass.superclass != ActiveRecord::Base) && (@klass.superclass != Object)
+  end
+  
+  protected
+  
+  # Process a model association
+  def process_association(class_name, assoc)
+    STDERR.print "\t\tProcessing model association #{assoc.name.to_s}\n" if @options.verbose
+
+    assoc_type = nil
+    # Skip "belongs_to" associations
+    unless assoc.macro.to_s == 'belongs_to'
+      # Only non standard association names needs a label
+      assoc_class_name = (assoc.class_name.respond_to? 'underscore') ? assoc.class_name.underscore.singularize.camelize : assoc.class_name 
+      if assoc_class_name == assoc.name.to_s.singularize.camelize
+        assoc_name = ''
+      else
+        assoc_name = assoc.name.to_s
+      end 
+
+      if assoc.macro.to_s == 'has_one' 
+        assoc_type = 'one-one'
+      elsif assoc.macro.to_s == 'has_many' && (! assoc.options[:through])
+        assoc_type = 'one-many'
+      else # habtm or has_many, :through
+        return if @habtm.include? [assoc.class_name, class_name, assoc_name]
+        assoc_type = 'many-many'
+        @habtm << [class_name, assoc.class_name, assoc_name]
+      end  
+    end
+    assoc_type.nil? ? nil : [assoc_type, class_name, assoc_class_name, assoc_name]    
+  end # process_association
+
+end

data/lib/railroad/controllers_diagram.rb

@@ -0,0 +1,81 @@
+# RailRoad - RoR diagrams generator
+# http://railroad.rubyforge.org
+#
+# Copyright 2007-2008 - Javier Smaldone (http://www.smaldone.com.ar)
+# See COPYING for more details
+#
+# Dec 2008
+# minor isolation from framework
+
+require 'railroad/app_diagram'
+
+# RailRoad controllers diagram
+class ControllersDiagram < AppDiagram
+ 
+  def initialize(options)
+    #options.exclude.map! {|e| "app/controllers/" + e}
+    super options
+    @graph.diagram_type = 'Controllers'
+  end
+
+  # Process controller files
+  def generate
+    STDERR.print "Generating controllers diagram\n" if @options.verbose
+
+    files = get_controller_files(@options)
+    files.each do |f|
+      class_name = extract_class_name(f)
+      process_class constantize(class_name)
+    end 
+  end # generate
+
+  private
+
+  # Load controller classes
+  def load_classes
+    begin
+      disable_stdout
+      # ApplicationController must be loaded first
+      files = get_controller_files(@options)
+      files.each {|c| require c }
+      enable_stdout
+    rescue LoadError
+      enable_stdout
+      print_error "controller classes"
+      raise
+    end
+  end # load_classes
+
+  # Proccess a controller class
+  def process_class(current_class)
+
+    STDERR.print "\tProcessing #{current_class}\n" if @options.verbose
+
+    if @options.brief
+      @graph.add_node ['controller-brief', current_class.name]
+    elsif current_class.is_a? Class 
+      # Collect controller's methods
+      node_attribs = {:public    => [], 
+                      :protected => [], 
+                      :private   => []}
+      current_class.public_instance_methods(false).sort.each { |m|
+        node_attribs[:public] << m
+      } unless @options.hide_public
+      current_class.protected_instance_methods(false).sort.each { |m|
+        node_attribs[:protected] << m
+      } unless @options.hide_protected
+      current_class.private_instance_methods(false).sort.each { |m|
+        node_attribs[:private] << m 
+      } unless @options.hide_private
+      @graph.add_node ['controller', current_class.name, node_attribs]
+    elsif @options.modules && current_class.is_a?(Module)
+      @graph.add_node ['module', current_class.name]
+    end
+
+    # Generate the inheritance edge (only for ApplicationControllers)
+    if @options.inheritance && is_application_subclass?(current_class) 
+      @graph.add_edge ['is-a', current_class.superclass.name, current_class.name]
+    end
+  end # process_class
+
+end # class ControllersDiagram

data/lib/railroad/diagram_graph.rb

@@ -0,0 +1,139 @@
+# RailRoad - RoR diagrams generator
+# http://railroad.rubyforge.org
+#
+# Copyright 2007-2008 - Javier Smaldone (http://www.smaldone.com.ar)
+# See COPYING for more details
+#
+# Dec 2008 - Roy Wright
+# minor isolation from framework
+
+# RailRoad diagram structure
+class DiagramGraph
+  attr_accessor :migration_version
+  def initialize
+    @migration_version = nil
+    @diagram_type = ''
+    @show_label = false
+    @nodes = []
+    @edges = []
+  end 
+
+  def add_node(node)
+    @nodes << node
+  end
+
+  def add_edge(edge)
+    @edges << edge
+  end
+  
+  def diagram_type= (type)
+    @diagram_type = type
+  end
+
+  def show_label= (value)
+    @show_label = value
+  end
+
+
+  # Generate DOT graph
+  def to_dot
+    return dot_header +
+           @nodes.uniq.map{|n| dot_node n[0], n[1], n[2]}.join +
+           @edges.uniq.map{|e| dot_edge e[0], e[1], e[2], e[3]}.join +
+           dot_footer
+  end
+  
+  # Generate XMI diagram (not yet implemented)
+  def to_xmi
+     STDERR.print "Sorry. XMI output not yet implemented.\n\n"
+     return ""
+  end
+
+  private
+
+  # Build DOT diagram header
+  def dot_header
+    result = "digraph #{@diagram_type.downcase}_diagram {\n" +
+             "\tgraph[overlap=false, splines=true]\n"
+    result += dot_label if @show_label
+    return result
+  end
+
+  # Build DOT diagram footer
+  def dot_footer
+    return "}\n"
+  end
+  
+  # Build diagram label
+  def dot_label
+    buf = []
+    buf << "\t_diagram_info [shape=\"plaintext\", "
+    buf << "label=\"#{@diagram_type} diagram\\l"
+    buf << "Date: #{Time.now.strftime "%b %d %Y - %H:%M"}\\l"
+    unless @migration_version.nil?
+      buf << "Migration version: #{@migration_version}\\l"
+    end
+    buf << "Generated by #{APP_HUMAN_NAME} #{APP_VERSION.join('.')}"
+    buf << "\\l\", fontsize=14]\n"
+    buf.join('')
+  end
+
+  # Build a DOT graph node
+  def dot_node(type, name, attributes=nil)
+    case type
+      when 'model'
+           options = 'shape=Mrecord, label="{' + name + '|'
+           options += attributes.join('\l')
+           options += '\l}"'
+      when 'model-brief'
+           options = ''
+      when 'class'
+           options = 'shape=record, label="{' + name + '|}"' 
+      when 'class-brief'
+           options = 'shape=box' 
+      when 'controller'
+           options = 'shape=Mrecord, label="{' + name + '|'
+           public_methods    = attributes[:public].join('\l')
+           protected_methods = attributes[:protected].join('\l')
+           private_methods   = attributes[:private].join('\l')
+           options += public_methods + '\l|' + protected_methods + '\l|' + 
+                      private_methods + '\l'
+           options += '}"'
+      when 'controller-brief'
+           options = '' 
+      when 'module'
+           options = 'shape=box, style=dotted, label="' + name + '"'
+      when 'aasm'
+           # Return subgraph format
+           return "subgraph cluster_#{name.downcase} {\n\tlabel = #{quote(name)}\n\t#{attributes.join("\n  ")}}"
+    end # case
+    return "\t#{quote(name)} [#{options}]\n"
+  end # dot_node
+
+  # Build a DOT graph edge
+  def dot_edge(type, from, to, name = '')
+    options =  name != '' ? "label=\"#{name}\", " : ''
+    case type
+      when 'one-one'
+           #options += 'taillabel="1"'
+           options += 'arrowtail=odot, arrowhead=dot, dir=both'
+      when 'one-many'
+	   #options += 'taillabel="n"'
+           options += 'arrowtail=crow, arrowhead=dot, dir=both'                    
+      when 'many-many'
+           #options += 'taillabel="n", headlabel="n", arrowtail="normal"'
+           options += 'arrowtail=crow, arrowhead=crow, dir=both'
+      when 'is-a'
+           options += 'arrowhead="none", arrowtail="onormal"'
+      when 'event'
+           options += "fontsize=10"
+    end
+    return "\t#{quote(from)} -> #{quote(to)} [#{options}]\n"
+  end # dot_edge
+
+  # Quotes a class name
+  def quote(name)
+    '"' + name.to_s + '"'
+  end
+  
+end # class DiagramGraph

data/lib/railroad/dm_model.rb

@@ -0,0 +1,148 @@
+# The "model" used to interact with DataMapper models.
+#
+# Dec 2008 - Roy Wright
+# created based on code from models_diagram adapted for DataMapper models.
+#
+class DM_Model
+  def initialize(klass, options)
+    @klass = klass
+    @options = options
+    # Processed habtm associations
+    @habtm = []
+  end
+  
+  # return an Array of attribute (column) "name:type" strings for the 
+  # model.
+  # if @options.hide_magic is asserted, then remove some standard
+  # attribute names from the array.
+  # if @options.hide_types is asserted, then the returned strings are
+  # just the names "name".
+  def attributes
+    attribs = []
+    if @options.hide_magic 
+      magic_fields = [
+      "created_at", "created_on", "updated_at", "updated_on",
+      "lock_version", "type", "id", "position", "parent_id", "lft", 
+      "rgt", "quote", "template", "count"
+      ]
+      content_columns = @klass.properties.select {|c| ! magic_fields.include? c.field}
+    else
+      content_columns = @klass.properties
+    end
+    
+    content_columns.each do |a|
+      content_column = a.field
+      content_column += ' :' + a.type.to_s unless @options.hide_types
+      attribs << content_column
+    end
+    attribs
+  end
+  
+  # is the model abstract?
+  def abstract?
+    # TODO: does datamapper support the abstract concept?
+    false
+  end
+  
+  # return the model edges (relationships)
+  def edges
+    found_edges = []
+    # Process class relationships
+    relationships = @klass.relationships
+
+    if @options.inheritance && ! @options.transitive
+      if @klass.superclass.respond_to?'relationships'
+        superclass_relationships = @klass.superclass.relationships
+        relationships = relationships.select{|k,a| superclass_relationships[k].nil?} 
+      end
+    end
+    remove_joins(relationships).each do |k, a|
+      found_edges << process_relationship(@klass.name, a)
+    end
+    found_edges.compact
+  end
+  
+  # is the model meaningful?
+  def meaningful?
+    (@klass.superclass != Object)
+  end
+  
+  protected
+
+  # datamapper's relationships for HABTM fully map the relationship
+  # from each end.  We do not want to duplicate relationship arrows
+  # on the graph, so remove the duplicates here.
+  def remove_joins(relationships)
+    new_relationships = {}
+    join_names = []
+    relationships.each do |k,v|
+      if v.kind_of? DataMapper::Associations::RelationshipChain
+        join_names << v.name
+      end
+    end
+    relationships.each do |k,v|
+      unless join_names.include? k
+        new_relationships[k] = v
+      end
+    end
+    new_relationships
+  end
+
+  # Process a model association
+  def process_relationship(class_name, relationship)
+    STDERR.print "\t\tProcessing model relationship #{relationship.name.to_s}\n" if @options.verbose
+
+    assoc_type = nil
+    # Skip "belongs_to" relationships
+    unless relationship.options.empty?
+      # Only non standard association names needs a label
+      assoc_class_name = (relationship.child_model.respond_to? 'underscore') ? 
+                            relationship.child_model.underscore.singularize.camelize : 
+                            relationship.child_model
+      if assoc_class_name == relationship.name.to_s.singularize.camel_case
+        assoc_name = ''
+      else
+        assoc_name = relationship.name.to_s
+      end 
+
+      assoc_type = nil
+      if has_one_relationship?(relationship)
+        assoc_type = 'one-one'
+      elsif has_many_relationship?(relationship) && !has_through_relationship?(relationship)
+        assoc_type = 'one-many'
+      elsif has_many_relationship?(relationship) && has_through_relationship?(relationship)
+        if relationship.kind_of? DataMapper::Associations::RelationshipChain
+          assoc_name = relationship.options[:remote_relationship_name]
+        end
+        return if @habtm.include? [relationship.child_model, class_name, assoc_name]
+        assoc_type = 'many-many'
+        @habtm << [class_name, relationship.child_model, assoc_name]
+      end  
+    end
+    assoc_type.nil? ? nil : [assoc_type, class_name, assoc_class_name, assoc_name]    
+  end # process_association
+
+  # is this relationship a has n, through?
+  def has_through_relationship?(relationship)
+    result = false
+    # names are symbols
+    near_name = relationship.options[:near_relationship_name]
+    remote_name = relationship.options[:remote_relationship_name]
+    unless near_name.nil? || remote_name.nil?
+      # ok, both near and remote have names
+      result = (near_name != remote_name)
+    end
+    result
+  end
+
+  # is this relationship a has 1?
+  def has_one_relationship?(relationship)
+    (relationship.options[:min] == 1) && (relationship.options[:max] == 1)
+  end
+
+  # is this relationship a has n?
+  def has_many_relationship?(relationship)
+    !relationship.options[:max].nil? && (relationship.options[:max] != 0) && (relationship.options[:max] != 1)
+  end
+
+end