royw-railroad_xing 0.5.0.1

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

data/lib/railroad/framework_factory.rb

@@ -0,0 +1,35 @@
+# A factory that determines if railroad is running in an application
+# framework and if so, returns a "framework" object that handles interacting
+# with the framework.  If the factory can not determine find a framework,
+# then the factory will return nil.
+#
+# === Usage
+# 
+# framework = FrameworkFactory.getFramework
+#
+# Dec 2008 - Roy Wright
+# created to support multiple frameworks
+#
+class FrameworkFactory
+  
+  # the factory the returns a "framework" object or nil
+  def self.getFramework
+    framework = nil
+    if File.exist? 'merb'
+      require 'railroad/merb_framework'
+      framework = MerbFramework.new 
+    end
+    if File.exist? 'script/server'
+      require 'railroad/rails_framework'
+      framework = RailsFramework.new 
+    end
+    framework
+  end
+  
+  private
+  
+  # prevent instantiation
+  def initialize
+  end
+end
+

data/lib/railroad/merb_framework.rb

@@ -0,0 +1,45 @@
+# A class that encapsulates the interaction with the Merb framework.
+#
+# Note, will use the 'test' envirnoment and database.
+#
+# Warning, will automigrate the 'test' database
+#
+# Dec 2008 - Roy Wright
+# created to support the Merb application framework
+#
+class MerbFramework
+  attr_reader :name, :migration_version
+  
+  # enter the merb 'test' environment
+  def initialize
+    require 'merb-core'
+    Merb.start_environment(:testing => true, :adapter => 'runner', :environment => ENV['MERB_ENV'] || 'test')
+    DataMapper.auto_migrate!
+    @name = 'Merb'
+    @migration_version = nil
+  end
+  
+  # is the given class a subclass of the application controller?
+  def is_application_subclass?(klass)
+    (Application.subclasses_list.include? klass.name)
+  end
+  
+  # get the controller's files returning the application controller first in returned array
+  def get_controller_files(options)
+    files = []
+    files << 'app/controllers/application.rb'
+    files += Dir.glob("app/controllers/**/*.rb") - options.exclude
+    files.uniq
+  end
+  
+  # Extract class name from filename
+  def extract_class_name(filename)
+    File.basename(filename).chomp(".rb").camel_case
+  end
+
+  # convert the give string to a constant
+  def constantize(str)
+    Object.full_const_get(str)
+  end
+
+end

data/lib/railroad/model_factory.rb

@@ -0,0 +1,25 @@
+require 'railroad/ar_model'
+require 'railroad/dm_model'
+
+# A factory for discovering the ORM being used that will then return the
+# corresponding "model" that will be used to interact with the ORM.  Will
+# return nil if unable to discover a supported ORM.
+#
+# Dec 2008 - Roy Wright
+# created to support multiple ORMs
+#
+class ModelFactory
+  def self.getModel(klass, options)
+    model = nil
+    model = AR_Model.new(klass, options) if klass.respond_to?'reflect_on_all_associations'
+    model = DM_Model.new(klass, options) if klass.respond_to?'relationships'
+    model
+  end
+  
+  private
+  
+  # prevent instantiation
+  def initialize
+  end
+end
+

data/lib/railroad/models_diagram.rb

@@ -0,0 +1,86 @@
+# 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
+# modified to support multiple application frameworks and ORMs
+
+require 'railroad/app_diagram'
+require 'railroad/model_factory'
+
+# RailRoad models diagram
+class ModelsDiagram < AppDiagram
+
+  def initialize(options)
+    #options.exclude.map! {|e| "app/models/" + e}
+    super options 
+    @graph.diagram_type = 'Models'
+  end
+
+  # Process model files
+  def generate
+    STDERR.print "Generating models diagram\n" if @options.verbose
+    files = Dir.glob("app/models/**/*.rb")
+    files += Dir.glob("vendor/plugins/**/app/models/*.rb") if @options.plugins_models    
+    files -= @options.exclude
+    files.each do |f| 
+      process_class constantize(extract_class_name(f))
+    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
+      files.each {|m| require m }
+      enable_stdout
+    rescue LoadError
+      enable_stdout
+      print_error "model classes"
+      raise
+    end
+  end  # load_classes
+    
+  # Process a model class
+  def process_class(current_class)
+
+    STDERR.print "\tProcessing #{current_class}\n" if @options.verbose
+
+    model = ModelFactory.getModel(current_class, @options)
+    node_attribs = []
+    edges = []
+    nodes = []
+    if @options.brief || (!model.nil? && model.abstract?)
+      node_type = 'model-brief'
+    else 
+      node_type = 'model'
+      node_attribs += model.attributes unless model.nil?
+    end
+    nodes << [node_type, current_class.name, node_attribs]
+    
+    if !model.nil?
+      edges += model.edges
+      # Only consider meaningful inheritance relations classes
+      if @options.inheritance && model.meaningful?
+        edges << ['is-a', current_class.superclass.name, current_class.name]
+      end
+    elsif @options.all && (current_class.is_a? Class)
+      # Not database model
+      node_type = @options.brief ? 'class-brief' : 'class'
+      nodes << [node_type, current_class.name]
+      edges << ['is-a', current_class.superclass.name, current_class.name]
+    elsif @options.modules && (current_class.is_a? Module)
+      nodes << ['module', current_class.name]
+    end
+    nodes.compact.each {|node| @graph.add_node node}
+    edges.compact.each {|edge| @graph.add_edge edge}
+  end # process_class
+  
+end # class ModelsDiagram

data/lib/railroad/options_struct.rb

@@ -0,0 +1,169 @@
+# RailRoad - RoR diagrams generator
+# http://railroad.rubyforge.org
+#
+# Copyright 2007-2008 - Javier Smaldone (http://www.smaldone.com.ar)
+# See COPYING for more details
+
+require 'ostruct'
+
+# RailRoad command line options parser
+class OptionsStruct < OpenStruct
+
+  require 'optparse'
+
+  def initialize
+    init_options = { :all => false,
+                     :brief => false,
+                     :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 => '',
+                     :transitive => false,
+                     :verbose => false,
+                     :xmi => false,
+                     :command => '' }
+    super(init_options)
+  end # initialize
+
+  def parse(args)
+    @opt_parser = OptionParser.new do |opts|
+      opts.banner = "Usage: #{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("-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("--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 "#{APP_HUMAN_NAME} version #{APP_VERSION.join('.')}\n\n" +
+                     "#{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