allenwei-railroad 0.7.8

data/lib/railroad/controllers_diagram.rb

@@ -0,0 +1,98 @@
+# RailRoad - RoR diagrams generator
+# http://railroad.rubyforge.org
+#
+# Copyright 2007-2008 - Javier Smaldone (http://www.smaldone.com.ar)
+# See COPYING for more details
+
+# 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 = Dir.glob("app/controllers/**/*_controller.rb") - @options.exclude
+    files.each do |f|
+      class_name = extract_class_name('app/controllers/', f)
+      process_class class_name.constantize
+    end
+  end # generate
+
+  private
+
+  # Load controller classes
+  def load_classes
+    begin
+      disable_stdout
+      files = Dir.glob("app/controllers/**/*_controller.rb") - @options.exclude
+      files.each {|file| get_controller_class(file) }
+      enable_stdout
+    rescue LoadError
+      enable_stdout
+      print_error "controller classes"
+      raise
+    end
+  end # load_classes
+
+  # This method is taken from the annotate models gem
+  # http://github.com/ctran/annotate_models/tree/master
+  #
+  # Retrieve the classes belonging to the controller names we're asked to process
+  # Check for namespaced controllers in subdirectories as well as controllers
+  # in subdirectories without namespacing.
+  def get_controller_class(file)
+    model = file.sub(/^.*app\/controllers\//, '').sub(/\.rb$/, '').camelize
+    parts = model.split('::')
+    begin
+      parts.inject(Object) {|klass, part| klass.const_get(part) }
+    rescue LoadError
+      Object.const_get(parts.last)
+    end
+  end
+
+  # 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|
+        process_method(node_attribs[:public], m)
+      } unless @options.hide_public
+      current_class.protected_instance_methods(false).sort.each { |m|
+        process_method(node_attribs[:protected], m)
+      } unless @options.hide_protected
+      current_class.private_instance_methods(false).sort.each { |m|
+        process_method(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
+
+  # Process a method
+  def process_method(attribs, method)
+    return if @options.hide_underscore && method[0..0] == '_'
+    attribs << method
+  end
+
+end # class ControllersDiagram

data/lib/railroad/diagram_graph.rb

@@ -0,0 +1,189 @@
+# RailRoad - RoR diagrams generator
+# http://railroad.rubyforge.org
+#
+# Copyright 2007-2008 - Javier Smaldone (http://www.smaldone.com.ar)
+# See COPYING for more details
+
+
+# RailRoad 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}.join +
+           @edges.map{|e| dot_edge *e}.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
+def to_yuml
+      classes={}
+      parts=[]
+      parts<<@nodes.collect{|node| 
+        type=node[0]
+        name=node[1]
+        attributes=node[2]
+        case type
+          when 'model'
+               "[#{name}|#{attributes.join(';')}|#{methods.join(';')}]"
+          else
+             "[#{name}]"  
+        end
+      }
+      parts<<@edges.collect{|edge|
+        type=edge[0]
+        from=edge[1]
+        to=edge[2]
+        name=edge[3]
+        from_edg=edge[4]
+        to_edg=edge[5]
+        association=case type
+          when 'is-a'
+               "^-"
+          else 
+            yuml_association(from_edg,to_edg)
+          #when 'event'
+          #     options += "fontsize=10"
+        end
+        "[#{from}]#{association}[#{to}]"
+      }
+      parts.join(",")
+  end
+  
+
+  private
+
+  def yuml_association(from_edg,to_edg)
+    if from_edg == '0-n' && to_edg == "0-n"
+      "*-*"
+    elsif from_edg == "0-1" && to_edg == "0-n"
+      "1-*"
+    elsif from_edg == "0-1" && to_edg == "0-1"
+      "1-1"
+      else 
+        raise "Can't find association from #{from_edg} to #{to_edg}"
+    end
+  end
+
+  # 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.join('.')}"+
+           "\\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
+
+  @@arrow_types = {
+    '0-n' => 'crowodot',
+    '1-n' => 'crowtee',
+    '1-1' => 'teetee',
+    '0-1' => 'teeodot',
+    '' => 'dot'
+  }
+
+  # Build a DOT graph edge
+  def dot_edge(type, from, to, name = '', from_type = '', to_type = '')
+    options = (name.blank? ? "" : "label=#{name}, ")
+    case type
+      when 'n-n'
+           options += "arrowtail=#{@@arrow_types[from_type]}, arrowhead=#{@@arrow_types[to_type]}, dir=both"
+      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/models_diagram.rb

@@ -0,0 +1,225 @@
+# RailRoad - RoR diagrams generator
+# http://railroad.rubyforge.org
+#
+# Copyright 2007-2008 - Javier Smaldone (http://www.smaldone.com.ar)
+# See COPYING for more details
+
+# RailRoad models diagram
+class ModelsDiagram < AppDiagram
+
+  def initialize(options)
+    #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
+    base = "(app/models/|lib/)"
+    files = Dir.glob("app/models/**/*.rb")
+    files += Dir.glob("vendor/plugins/**/app/models/*.rb") if @options.plugins_models
+    files += Dir.glob("lib/**/*.rb") if @options.libraries
+
+    files -= @options.exclude
+    (files + ['filter_condition_type']).each do |file|
+      model_name =
+        @options.classes_by_files[file] ||
+        (model_path = file.gsub(/^#{base}([\w_\/\\]+)\.rb/, '\2')).camelize
+      STDERR.print "Processing #{file} ...\n" if @options.verbose
+      # Hack to skip all xxx_related.rb files
+      next if /_related/i =~ model_name
+
+      klass = begin
+                model_name.constantize
+              rescue LoadError
+                STDERR.print "\t#{model_name} raised LoadError.\n" if @options.verbose
+                oldlen = model_path.length
+                model_path.gsub!(/.*[\/\\]/, '')
+                model_name = model_path.camelize
+                if oldlen > model_path.length
+                  retry
+                end
+                STDERR.print "\tDone trying to remove slashes, skipping this model.\n" if @options.verbose
+                next
+              rescue NameError
+                STDERR.print "\t#{model_name} raised NameError, skipping this model.\n" if @options.verbose
+                next
+              end
+
+      process_class klass
+      STDERR.print "Done #{file}\n" if @options.verbose
+    end
+  end
+
+  private
+
+  # Load model classes
+  def load_classes
+    begin
+      disable_stdout
+      files = Dir.glob("app/models/**/*.rb")
+      files += Dir.glob("vendor/plugins/**/app/models/*.rb") if @options.plugins_models
+      files -= @options.exclude
+      require 'ruby-debug';debugger
+      @models = files.map{|file| get_model_class(file) }
+      enable_stdout
+      @models
+    rescue LoadError
+      enable_stdout
+      print_error "model classes"
+      raise
+    end
+  end  # load_classes
+
+  # This method is taken from the annotate models gem
+  # http://github.com/ctran/annotate_models/tree/master
+  #
+  # Retrieve the classes belonging to the model names we're asked to process
+  # Check for namespaced models in subdirectories as well as models
+  # in subdirectories without namespacing.
+  def get_model_class(file)
+    begin
+    model = file.sub(/^.*app\/models\//, '').sub(/\.rb$/, '').camelize
+    rescue
+      STDERR.print "Can't find class #{model}"
+    end
+  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? || current_class.superclass != ActiveRecord::Base
+        node_type = 'model-brief'
+      else
+        node_type = 'model'
+
+        # Collect model's content columns
+
+        begin
+        content_columns = current_class.content_columns
+        rescue
+          STDERR.print "Table #{current_class.table_name} not exist"
+          return
+        end
+
+        if @options.hide_magic
+          magic_fields = [
+          # Restful Authentication
+          "login", "crypted_password", "salt", "remember_token", "remember_token_expires_at", "activation_code", "activated_at",
+          # From patch #13351
+          # http://wiki.rubyonrails.org/rails/pages/MagicFieldNames
+          "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|
+        begin
+        process_association current_class, a
+        rescue
+        end
+      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
+
+    STDERR.print "\tDone #{current_class}\n" if @options.verbose
+  end # process_class
+
+  def determine_minimum_association(klass, column)
+    if klass.respond_to?(:reflect_on_validations_for)
+      return 1 if klass.reflect_on_validations_for(column).detect { |r|
+        [:validates_presence_of, :validates_existence_of, :validates_length_of, :validates_associated].include?(r.macro)
+      }
+    end
+    return 0
+  end
+
+  # Process a model association
+  def process_association(klass, assoc)
+    begin
+    STDERR.print "\t\tProcessing model association #{assoc.name.to_s} ..." if @options.verbose
+
+    # Skip "belongs_to" associations
+    return if assoc.macro.to_s == '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
+    return unless @models.include? assoc_class_name
+#    STDERR.print "#{assoc_name}\n"
+    if assoc.macro.to_s == 'has_one'
+      from_max='1'
+      to_max='1'
+    elsif assoc.macro.to_s == 'has_many' && (! assoc.options[:through])
+      from_max='1'
+      to_max='n'
+    else # habtm or has_many, :through
+      return if @habtm.include? [assoc.class_name, klass.name, assoc_name]
+      from_max='n'
+      to_max='n'
+      @habtm << [klass.name, assoc.class_name, assoc_name]
+    end
+    to_min = determine_minimum_association(klass, assoc.name)
+      # have to guess at name for association in other direction
+    from_min = determine_minimum_association(assoc.klass, assoc.primary_key_name.to_s.gsub(/_id$/, ""))
+    @graph.add_edge ["n-n", klass.name, assoc_class_name, assoc_name, "#{from_min}-#{from_max}", "#{to_min}-#{to_max}"]
+    ensure
+      STDERR.print " done.\n" if @options.verbose
+    end
+  end # process_association
+
+end # class ModelsDiagram