railroady 0.9.0

data/lib/railroady/controllers_diagram.rb

@@ -0,0 +1,95 @@
+# RailRoady - RoR diagrams generator
+# http://railroad.rubyforge.org
+#
+# Copyright 2007-2008 - Javier Smaldone (http://www.smaldone.com.ar)
+# See COPYING for more details
+
+require 'railroady/app_diagram'
+
+# RailRoady controllers diagram
+class ControllersDiagram < AppDiagram
+ 
+  # as of Rails 2.3 the file is no longer application.rb but instead
+  # application_controller.rb
+  APP_CONTROLLER = File.exist?('app/controllers/application.rb') ? 'app/controllers/application.rb' : 'app/controllers/application_controller.rb'
+
+  def initialize(options = OptionsStruct.new)
+    #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_files
+    # only add APP_CONTROLLER if it isn't already included from the glob above
+    files << APP_CONTROLLER unless files.include? APP_CONTROLLER
+    files.each do |f|
+      class_name = extract_class_name(f)
+      # ApplicationController's file is 'application.rb' in Rails < 2.3
+      class_name += 'Controller' if class_name == 'Application'
+      begin
+        process_class class_name.constantize
+      rescue Exception
+        STDERR.print "Warning: exception #{$!} raised while trying to load controller class #{f}"
+      end
+    end 
+  end # generate
+
+  def get_files(prefix ='')
+    files = !@options.specify.empty? ? Dir.glob(@options.specify) : Dir.glob(prefix << "app/controllers/**/*_controller.rb")
+    files -= Dir.glob(@options.exclude)
+    files
+  end
+
+  private
+  # Load controller classes
+  def load_classes
+    begin
+      disable_stdout
+      # ApplicationController must be loaded first
+      require APP_CONTROLLER
+      get_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 && 
+       (ApplicationController.subclasses.include? current_class.name)
+      @graph.add_edge ['is-a', current_class.superclass.name, current_class.name]
+    end
+  end # process_class
+
+end # class ControllersDiagram

data/lib/railroady/diagram_graph.rb

@@ -0,0 +1,130 @@
+# RailRoady - RoR diagrams generator
+# http://railroad.rubyforge.org
+#
+# Copyright 2007-2008 - Javier Smaldone (http://www.smaldone.com.ar)
+# See COPYING for more details
+
+
+# RailRoady diagram structure
+class DiagramGraph
+
+  def initialize
+    @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.map{|n| dot_node n[0], n[1], n[2]}.join +
+           @edges.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
+    return "\t_diagram_info [shape=\"plaintext\", " +
+           "label=\"#{@diagram_type} diagram\\l" +
+           "Date: #{Time.now.strftime "%b %d %Y - %H:%M"}\\l" +
+           "Migration version: " +
+           "#{ActiveRecord::Migrator.current_version}\\l" +
+           "Generated by #{APP_HUMAN_NAME} #{APP_VERSION}"+
+           "\\l\", fontsize=14]\n"
+  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 += 'arrowtail=odot, arrowhead=dot, dir=both'
+      when 'one-many'
+           options += 'arrowtail=odot, arrowhead=crow, dir=both'
+      when 'many-many'
+           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/railroady/models_diagram.rb

@@ -0,0 +1,146 @@
+# RailRoady - RoR diagrams generator
+# http://railroad.rubyforge.org
+#
+# Copyright 2007-2008 - Javier Smaldone (http://www.smaldone.com.ar)
+# See COPYING for more details
+
+require 'railroady/app_diagram'
+
+# RailRoady models diagram
+class ModelsDiagram < AppDiagram
+
+  def initialize(options = OptionsStruct.new)
+    #options.exclude.map! {|e| "app/models/" + e}
+    super options 
+    @graph.diagram_type = 'Models'
+    # Processed habtm associations
+    @habtm = []
+  end
+
+  # Process model files
+  def generate
+    STDERR.print "Generating models diagram\n" if @options.verbose
+    get_files.each do |f|
+      begin
+        process_class extract_class_name(f).constantize
+      rescue Exception
+        STDERR.print "Warning: exception #{$!} raised while trying to load model class #{f}\n"
+      end
+
+    end
+  end 
+
+  def get_files(prefix ='')
+    files = !@options.specify.empty? ? Dir.glob(@options.specify) : Dir.glob(prefix << "app/models/**/*.rb")
+    files += Dir.glob("vendor/plugins/**/app/models/*.rb") if @options.plugins_models
+    files -= Dir.glob(@options.exclude)
+    files
+  end
+
+  # Process a model class
+  def process_class(current_class)
+
+    STDERR.print "\tProcessing #{current_class}\n" if @options.verbose
+
+    generated = false
+        
+    # Is current_clas derived from ActiveRecord::Base?
+    if current_class.respond_to?'reflect_on_all_associations'
+
+
+      node_attribs = []
+      if @options.brief || current_class.abstract_class?
+        node_type = 'model-brief'
+      else 
+        node_type = 'model'
+
+        # Collect model's content columns
+
+        content_columns = current_class.content_columns
+	
+        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 << current_class.table_name + "_count" if current_class.respond_to? 'table_name' 
+          content_columns = current_class.content_columns.select {|c| ! magic_fields.include? c.name}
+        else
+          content_columns = current_class.content_columns
+        end
+        
+        content_columns.each do |a|
+          content_column = a.name
+          content_column += ' :' + a.type.to_s unless @options.hide_types
+          node_attribs << content_column
+        end
+      end
+      @graph.add_node [node_type, current_class.name, node_attribs]
+      generated = true
+      # Process class associations
+      associations = current_class.reflect_on_all_associations
+      if @options.inheritance && ! @options.transitive
+        superclass_associations = current_class.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|
+        process_association current_class.name, a
+      end
+    elsif @options.all && (current_class.is_a? Class)
+      # Not ActiveRecord::Base model
+      node_type = @options.brief ? 'class-brief' : 'class'
+      @graph.add_node [node_type, current_class.name]
+      generated = true
+    elsif @options.modules && (current_class.is_a? Module)
+        @graph.add_node ['module', current_class.name]
+    end
+
+    # Only consider meaningful inheritance relations for generated classes
+    if @options.inheritance && generated && 
+       (current_class.superclass != ActiveRecord::Base) &&
+       (current_class.superclass != Object)
+      @graph.add_edge ['is-a', current_class.superclass.name, current_class.name]
+    end      
+
+  end # process_class
+
+  # Process a model association
+  def process_association(class_name, assoc)
+
+    STDERR.print "\t\tProcessing model association #{assoc.name.to_s}\n" if @options.verbose
+
+    # Skip "belongs_to" associations
+    return if assoc.macro.to_s == 'belongs_to' && !@options.show_belongs_to
+
+    # Only non standard association names needs a label
+    
+    # from patch #12384
+    # if assoc.class_name == assoc.name.to_s.singularize.camelize
+    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 ['has_one', 'belongs_to'].include? assoc.macro.to_s
+      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  
+    # from patch #12384    
+    # @graph.add_edge [assoc_type, class_name, assoc.class_name, assoc_name]
+    @graph.add_edge [assoc_type, class_name, assoc_class_name, assoc_name]    
+  end # process_association
+
+end # class ModelsDiagram

data/lib/railroady/options_struct.rb

@@ -0,0 +1,178 @@
+# RailRoady - RoR diagrams generator
+# http://railroad.rubyforge.org
+#
+# Copyright 2007-2008 - Javier Smaldone (http://www.smaldone.com.ar)
+# See COPYING for more details
+
+require 'ostruct'
+
+# RailRoady command line options parser
+class OptionsStruct < OpenStruct
+
+  require 'optparse'
+
+  def initialize(args={})
+    init_options = { :all => false,
+                     :brief => false,
+                     :specify => [],
+                     :exclude => [],
+                     :inheritance => false,
+                     :join => false,
+                     :label => false,
+                     :modules => false,
+                     :hide_magic => false,
+                     :hide_types => false,
+                     :hide_public => false,
+                     :hide_protected => false,
+                     :hide_private => false,
+                     :plugins_models => false,
+                     :root => '',
+                     :show_belongs_to => false,
+                     :transitive => false,
+                     :verbose => false,
+                     :xmi => false,
+                     :command => '',
+                     :app_name => 'railroady', :app_human_name => 'Railroady', :app_version =>'', :copyright =>'' }
+    super(init_options.merge(args))
+  end # initialize
+
+  def parse(args)
+    @opt_parser = OptionParser.new do |opts|
+      opts.banner = "Usage: #{self.app_name} [options] command"
+      opts.separator ""
+      opts.separator "Common options:"
+      opts.on("-b", "--brief", "Generate compact diagram", 
+              "  (no attributes nor methods)") do |b|
+        self.brief = b
+      end
+      opts.on("-s", "--specify file1[,fileN]", Array, "Specify only given files") do |list|
+        self.specify = list
+      end
+      opts.on("-e", "--exclude file1[,fileN]", Array, "Exclude given files") do |list|
+        self.exclude = list
+      end
+      opts.on("-i", "--inheritance", "Include inheritance relations") do |i|
+        self.inheritance = i
+      end
+      opts.on("-l", "--label", "Add a label with diagram information", 
+              "  (type, date, migration, version)") do |l|
+        self.label = l
+      end
+      opts.on("-o", "--output FILE", "Write diagram to file FILE") do |f|
+        self.output = f
+      end
+      opts.on("-r", "--root PATH", "Set PATH as the application root") do |r|
+        self.root = r
+      end
+      opts.on("-v", "--verbose", "Enable verbose output", 
+              "  (produce messages to STDOUT)") do |v|
+        self.verbose = v
+      end
+      opts.on("-x", "--xmi", "Produce XMI instead of DOT", 
+              "  (for UML tools)") do |x|
+        self.xmi = x
+      end
+      opts.separator ""
+      opts.separator "Models diagram options:"
+      opts.on("-a", "--all", "Include all models", 
+              "  (not only ActiveRecord::Base derived)") do |a|
+        self.all = a
+      end
+      opts.on("--show-belongs_to", "Show belongs_to associations") do |s|
+        self.show_belongs_to = s
+      end
+      opts.on("--hide-magic", "Hide magic field names") do |h|
+        self.hide_magic = h
+      end
+      opts.on("--hide-types", "Hide attributes type") do |h|
+        self.hide_types = h
+      end
+      opts.on("-j", "--join", "Concentrate edges") do |j|
+        self.join = j
+      end
+      opts.on("-m", "--modules", "Include modules") do |m|
+        self.modules = m
+      end
+      opts.on("-p", "--plugins-models", "Include plugins models") do |p|
+        self.plugins_models = p
+      end
+      opts.on("-t", "--transitive", "Include transitive associations",
+              "(through inheritance)") do |t|
+        self.transitive = t
+      end
+      opts.separator ""
+      opts.separator "Controllers diagram options:"
+      opts.on("--hide-public", "Hide public methods") do |h|
+        self.hide_public = h
+      end
+      opts.on("--hide-protected", "Hide protected methods") do |h|
+        self.hide_protected = h
+      end
+      opts.on("--hide-private", "Hide private methods") do |h|
+        self.hide_private = h
+      end
+      opts.separator ""
+      opts.separator "Other options:"
+      opts.on("-h", "--help", "Show this message") do
+        STDOUT.print "#{opts}\n"
+        exit
+      end
+      opts.on("--version", "Show version and copyright") do 
+        STDOUT.print"#{self.app_human_name} version #{self.app_version}\n\n" +
+                     "#{self.copyright}\nThis is free software; see the source " +
+                     "for copying conditions.\n\n"
+        exit
+      end
+      opts.separator ""
+      opts.separator "Commands (you must supply one of these):"
+      opts.on("-M", "--models", "Generate models diagram") do |c|
+        if self.command != ''
+          STDERR.print "Error: Can only generate one diagram type\n\n"
+          exit 1
+        else 
+          self.command = 'models'        
+        end
+      end 
+      opts.on("-C", "--controllers", "Generate controllers diagram") do |c|
+        if self.command != ''
+          STDERR.print "Error: Can only generate one diagram type\n\n"
+          exit 1
+        else 
+          self.command = 'controllers'        
+        end
+      end
+      # From Ana Nelson's patch
+      opts.on("-A", "--aasm", "Generate \"acts as state machine\" diagram") do |c|
+        if self.command == 'controllers'
+          STDERR.print "Error: Can only generate one diagram type\n\n"
+          exit 1
+        else    
+          self.command = 'aasm'
+        end
+      end        
+      opts.separator ""
+      opts.separator "For bug reporting and additional information, please see:"
+      opts.separator "http://railroad.rubyforge.org/"
+    end # do
+
+    begin
+      @opt_parser.parse!(args)
+    rescue OptionParser::AmbiguousOption
+      option_error "Ambiguous option"
+    rescue OptionParser::InvalidOption
+      option_error "Invalid option"
+    rescue OptionParser::InvalidArgument
+      option_error "Invalid argument"
+    rescue OptionParser::MissingArgument
+      option_error "Missing argument"
+    end
+  end  # parse
+
+  private 
+
+  def option_error(msg)
+    STDERR.print "Error: #{msg}\n\n #{@opt_parser}\n"
+    exit 1
+  end
+
+end  # class OptionsStruct