le1t0-dige 0.9.0

data/bin/dige

@@ -0,0 +1,85 @@
+#!/usr/bin/env ruby
+
+require 'optparse'
+
+$diagram_types=[]
+$project_type=:unknown
+
+def action(diagram_type, project_type)
+  if $project_type == :unknown
+    "generate_#{diagram_type}"
+  else
+    "generate_#{project_type}_#{diagram_type}"
+  end
+end
+
+def env
+  ENV.select { |k,v| [ "NO_RM", "DEBUG", "FILE", "IGNORE_CLASSES" ].include?(k) }.collect do |k,v|
+    "#{k}=#{v}"
+  end.compact.join(' ')
+end
+
+def run(runner, call_style)
+  $diagram_types.each do |diagram_type|
+    cmd = case call_style
+    when :argument
+      "#{env} #{runner} \"require 'dige' ; Dige.#{action(diagram_type, $project_type)}\""
+    when :piped
+      "echo Dige.#{action(diagram_type, $project_type)} | #{env} #{runner}"
+    end
+    puts cmd if ENV['DEBUG'] and ENV['DEBUG'].upcase == 'TRUE'
+    raise unless IO.popen(cmd) do |p|
+      while !p.eof? && l = p.readline do
+        puts l
+      end
+    end
+  end
+end
+
+OptionParser.new do |opts|
+  opts.banner = "Usage: #{File.basename($0)} [path]"
+
+  opts.on("-t", "--type TYPE", String, "Explicitly set project type to one of <rails3, rails2, datamapper>") do |v|
+    $project_type=v.to_sym
+  end
+
+  opts.on("-c", "Generate UML Class Diagram") do
+    $diagram_types << :uml_class_diagram
+  end
+
+  opts.on("-e", "Generate Entity Relationship Diagram") do
+    $diagram_types << :entity_relationship_diagram
+  end
+  
+  opts.on("-h", "--help", "Displays this help info") do
+    puts opts
+    exit 0
+  end
+  
+  begin
+    opts.parse!(ARGV)
+  rescue OptionParser::ParseError => e
+    warn e.message
+    puts opts
+    exit 1
+  end
+end
+
+begin
+  unless [
+          [ [ File.join(File.expand_path('.'), "script", "rails"), "runner" ], :argument ], # rails 3
+          [ File.join(File.expand_path('.'), "script", "runner"), :argument ], # rails 2 and other projects which provide a runner
+          [ File.join(File.expand_path('.'), "script", "console"), :piped ] # non-rails, but something that has console
+        ].inject(false) do |has_run, runner|
+        if File.exists?([runner.first].flatten.first)
+          run([runner.first].flatten.join(' '), runner.last)
+          true
+        else
+          false
+        end
+      end
+    abort "Can't find anything (script/runner, script/console, ..) to run Dige in your project"
+  end
+rescue
+  abort "Failed to generate diagram(s)"
+end

data/lib/dige/association.rb

@@ -0,0 +1,25 @@
+class Dige::Association
+  include Dige::ClassBase
+  attr_accessor :from_class_name, :from_table_name, :to_class_name, :to_table_name, :from_arity, :to_arity, :type, :table_name, :macro
+  
+  def debug_inspect
+    "#{from_class_name}(#{from_table_name}) #{from_arity} =#{table_name ? "[#{table_name}]" : ""}> #{to_arity} #{to_class_name}(#{to_table_name})"
+  end
+  
+  def ==(objekt)
+    self.type == objekt.type && (
+      (
+        self.from_class_name == objekt.from_class_name &&
+        self.from_table_name == objekt.from_table_name &&
+        self.to_class_name == objekt.to_class_name &&
+        self.to_table_name == objekt.to_table_name
+      ) ||
+      (
+        self.from_class_name == objekt.to_class_name &&
+        self.from_table_name == objekt.to_table_name &&
+        self.to_class_name == objekt.from_class_name &&
+        self.to_table_name == objekt.from_table_name
+      )
+    )
+  end
+end

data/lib/dige/associations.rb

@@ -0,0 +1,39 @@
+class Dige::Associations
+  include Dige::List
+
+  def register(from_class_name, from_table_name, to_class_name, to_table_name, type, assoc_macro, table_name)
+    # assoc_macro can be : :has_many, :belongs_to, :has_one
+    
+    tail_class_name = [ :belongs_to ].include?(assoc_macro) ? from_class_name : to_class_name
+    tail_table_name = [ :belongs_to ].include?(assoc_macro) ? from_table_name : to_table_name
+    head_class_name = [ :belongs_to ].include?(assoc_macro) ? to_class_name : from_class_name
+    head_table_name = [ :belongs_to ].include?(assoc_macro) ? to_table_name : from_table_name
+    
+    objekt = Dige::Association.new({
+      :from_class_name => tail_class_name,
+      :from_table_name => tail_table_name,
+      :to_class_name => head_class_name,
+      :to_table_name => head_table_name,
+      :type => type,
+      :table_name => table_name
+    })
+    objekt.macro = assoc_macro if type == :polymorphic
+    unless return_objekt = find(objekt)
+      list << objekt
+      return_objekt = objekt
+    end
+    if assoc_macro == :has_many || assoc_macro == :has_and_belongs_to_many
+      return_objekt.from_arity = '0..*'
+    elsif assoc_macro == :has_one
+      return_objekt.from_arity = '1'
+    elsif assoc_macro == :belongs_to
+      return_objekt.to_arity = '1'
+    end 
+    return_objekt
+  end
+  
+  def all(type = :normal)
+    list.select { |list_item| type == :all || list_item.type == type }
+  end
+  
+end

data/lib/dige/class_base.rb

@@ -0,0 +1,7 @@
+module Dige::ClassBase
+  def initialize(attributes = {})
+    attributes.each do |key, value|
+      self.send "#{key}=".to_sym, value
+    end
+  end
+end

data/lib/dige/dige.rb

@@ -0,0 +1,53 @@
+class Dige
+  
+  IGNORE_CLASSES = (ENV['IGNORE_CLASSES'] || "").split(/,/) + [ 'ActiveRecord::Base' ]
+  
+  DIAGRAM_TYPES = {
+    :entity_relationship_diagram => "Dige::GraphvizDiagram::EntityRelationshipDiagram",
+    :uml_class_diagram => "Dige::GraphvizDiagram::UMLClassDiagram"
+  }
+  
+  PROJECT_TYPES = {
+    :rails2 => "Rails2",
+    :rails3 => "Rails3",
+    :data_mapper => "DataMapper"
+  }
+  
+  DIAGRAM_TYPES.each do |diagram_type, diagram_klass|
+    class_eval("
+      def self.generate_#{diagram_type}(project_type = :unknown) ; generate_diagram(#{diagram_klass}, project_type) ; end
+    ")
+    PROJECT_TYPES.each_key do |project_type|
+      class_eval("
+        def self.generate_#{project_type}_#{diagram_type} ; generate_#{diagram_type}(:#{project_type}) ; end
+      ")
+    end
+  end
+  
+  private
+  
+  def self.induce_project_type
+    PROJECT_TYPES.values.collect { |v| Dige::Recognizer.const_get(v) }.inject(nil) do |recognized_type, klass|
+      recognized_type || klass.new.recognize
+    end || :unknown
+  end
+  
+  def self.initialize_instantiator(project_type)
+    project_type = induce_project_type if project_type == :unknown
+    instantiator = PROJECT_TYPES[project_type]
+    if instantiator.nil?
+      raise UnrecognizedProjectTypeError
+    else
+      Dige::Instantiator.const_get(instantiator).new
+    end
+  end
+  
+  def self.generate_diagram(klass, project_type)
+    instantiator = initialize_instantiator(project_type)
+    instantiator.load_models
+    diagram = klass.new(instantiator.load_klasses)
+    puts diagram.debug_inspect.join("\n") if ENV['DEBUG'] and ENV['DEBUG'].upcase == 'TRUE'
+    diagram.generate
+  end
+  
+end

data/lib/dige/errors.rb

@@ -0,0 +1 @@
+class UnrecognizedProjectTypeError < RuntimeError ; end

data/lib/dige/graphviz_diagram/entity_relationship_diagram.rb

@@ -0,0 +1,18 @@
+class Dige::GraphvizDiagram::EntityRelationshipDiagram < Dige::GraphvizDiagram
+  def generate(file = ENV['FILE'], type = 'png')
+    generate_diagram(file + "_entity_relationship_model", type) do
+      assocs = associations.all.collect do |assoc|
+        clr = random_color
+        if assoc.table_name
+          [{ :from => assoc.table_name, :to => assoc.from_table_name }, { :from => assoc.table_name, :to => assoc.to_table_name }]
+        else
+          [{ :from => assoc.from_table_name, :to => assoc.to_table_name }]
+        end
+      end.flatten
+
+      klasses.all.collect { |klass| node(klass.table_name, :associations_count => klass.associations_count) }.uniq.sort +
+      associations.all.collect { |assoc| assoc.table_name ? node(assoc.table_name) : nil }.compact.uniq.sort +
+      assocs.uniq.collect { |ass| edge(ass[:from], ass[:to], true, { :color => random_color}) }.uniq.sort
+    end    
+  end
+end

data/lib/dige/graphviz_diagram/uml_class_diagram.rb

@@ -0,0 +1,24 @@
+class Dige::GraphvizDiagram::UMLClassDiagram < Dige::GraphvizDiagram
+  def edge_settings
+    super.merge(
+    {
+      :arrowhead => :none
+    })
+  end
+
+  def generate(file = ENV['FILE'], type = 'png')
+    generate_diagram(file + "_uml_class_diagram", type) do
+      assocs = associations.all.collect do |assoc|
+        { :from => assoc.from_class_name, :to => assoc.to_class_name, :from_arity => assoc.from_arity, :to_arity => assoc.to_arity }
+      end
+      
+      pcrs = parent_child_relations.all.collect do |pcr|
+        { :from => pcr.child_class_name, :to => pcr.parent_class_name}
+      end
+
+      klasses.all.collect { |klass| node(klass.class_name, :associations_count => klass.associations_count) }.uniq.sort +
+      pcrs.collect { |pcr| edge(pcr[:from], pcr[:to], true, {:color => random_color, :arrowhead => :empty}) }.uniq.sort + 
+      assocs.collect { |ass| edge(ass[:from], ass[:to], true, { :color => random_color, :headlabel => ass[:to_arity], :taillabel => ass[:from_arity]}) }.uniq.sort
+    end    
+  end
+end

data/lib/dige/graphviz_diagram.rb

@@ -0,0 +1,94 @@
+class Dige::GraphvizDiagram
+  include Dige::ClassBase
+  attr_accessor :klasses, :parent_child_relations, :associations
+
+  DEFAULT_NODE_WIDTH = 3.0
+  DEFAULT_NODE_HEIGHT = 2.0
+
+  def generate_diagram(file = nil, type = 'png', graphtype = :digraph, &block)
+    output = [header(*([graphtype, file].compact)), settings, yield, "}"].flatten.compact.join("\n")
+    puts output if ENV['DEBUG'] and ENV['DEBUG'].upcase == 'TRUE'
+    
+    unless file.nil?
+      File.open("#{file}.dot", "w") do |f| f.write output end
+      unless system("dot -T#{type} -o#{file}.#{type} #{file}.dot") && ((ENV['NO_RM'] && ENV['NO_RM'].upcase == 'TRUE') || FileUtils.rm_f("#{file}.dot"))
+        $stderr.puts "error: failed to generate png diagram from dot file #{file}.dot, file is left existing for investigation."
+      end
+    else
+      puts output
+    end
+  end
+  
+  def header(type, name = "my_diagram")
+    "#{type} #{name} {"
+  end
+  
+  def settings
+    [
+      (!graph_settings.empty? ? "graph [" + graph_settings.collect { |k,v| "#{k}=#{quote(v)}" }.join(",") + "];" : nil),
+      (!edge_settings.empty? ? "edge [" + edge_settings.collect { |k,v| "#{k}=#{quote(v)}" }.join(",") + "];" : nil),
+      (!node_settings.empty? ? "node [" + node_settings.collect { |k,v| "#{k}=#{quote(v)}" }.join(",") + "];" : nil)
+    ]
+  end
+  
+  def graph_settings
+    {
+      :outputorder => :nodesfirst,
+      :concentrate => true,
+      :ranksep => 2.5
+    }
+  end
+  
+  def node_settings
+    {
+      :shape => :box,
+      :fontsize => 36.0
+    }
+  end
+  
+  def edge_settings
+    {
+      :arrowsize => 1.0,
+      :penwidth => 2.0
+    }
+  end
+    
+  def node(name, options={})
+    associations_count = options.delete(:associations_count)
+    options[:width] = DEFAULT_NODE_WIDTH
+    options[:height] = DEFAULT_NODE_HEIGHT
+    node_options = options.empty? ? "" : "[" + options.collect { |k,v| "#{k}=#{quote(v)}" }.join(",") + "]"
+    "#{quote(name)}#{node_options};"
+  end
+  
+  def edge(from, to, directed=true, options={})
+    edge_options = options.empty? ? "" : "[" + options.collect { |k,v| "#{k}=#{quote(v)}" }.join(",") + "]"
+    "#{quote(from)} #{directed ? "->" : "--"} #{quote(to)}#{edge_options};"
+  end
+  
+  def quote(string)
+    "\"#{string}\""
+  end
+  
+  def debug_inspect
+    [
+      klasses.debug_inspect,
+      associations.debug_inspect,
+      parent_child_relations.debug_inspect
+    ].flatten
+  end
+  
+  def random_color
+    minimum = 10
+    maximum = 210
+    r = ((rand*maximum) + minimum).to_i
+    g = ((rand*maximum) + minimum).to_i
+    b = ((rand*maximum) + minimum).to_i
+    
+    "#" + r.to_s(16).rjust(2, '0') + g.to_s(16).rjust(2, '0') + b.to_s(16).rjust(2, '0')
+  end
+  
+end
+
+require 'dige/graphviz_diagram/entity_relationship_diagram'
+require 'dige/graphviz_diagram/uml_class_diagram'

data/lib/dige/instantiator/data_mapper.rb

@@ -0,0 +1,11 @@
+class Dige::Instantiator::DataMapper < Dige::Instantiator
+  
+  def load_models
+    raise NotImplementedError.new("This method should be overridden in a subclass")
+  end
+  
+  def load_klasses
+    raise NotImplementedError.new("This method should be overridden in a subclass")
+  end
+  
+end

data/lib/dige/instantiator/rails2.rb

@@ -0,0 +1,99 @@
+class Dige::Instantiator::Rails2 < Dige::Instantiator
+
+  def load_models
+    models = Dir["app/models/**/*.rb"].collect do |model| File.expand_path(model) end
+    retries = {}
+    while !models.empty? do
+      model = models.shift
+      begin
+        require model
+        retries = {}
+      rescue Exception => e
+        retries[model] ||= 0
+        retries[model] += 1
+        break if retries[model] > 1
+        models.push model
+      end
+    end
+    $stderr.puts "warning: Failed to load models: #{retries.keys.collect { |m| m.gsub(/^#{RAILS_ROOT}\/app\/models\//, '') }.join(', ')}." unless retries.empty?
+  end
+
+  def load_klasses
+    klasses = Dige::Klasses.new
+    parent_child_relations = Dige::ParentChildRelations.new
+    associations = Dige::Associations.new
+  
+    Class.subclasses_of(ActiveRecord::Base).each do |klass|
+      columns = ActiveRecord::Base.connection.table_exists?(klass.table_name) ? klass.columns.collect { |column| column.name.to_s } : []
+      klasses.register(klass.name, klass.table_name, columns)  unless Dige::IGNORE_CLASSES.include?(klass.name)
+      parent_child_relations.register(klass.superclass.name, klass.name) unless Dige::IGNORE_CLASSES.include?(klass.superclass.name) || Dige::IGNORE_CLASSES.include?(klass.name)
+    end.each do |klass|
+      klass.reflect_on_all_associations.each do |assoc|
+        type = assoc.options[:polymorphic] ? :polymorphic : :normal
+
+        next if assoc.options[:through] || Dige::IGNORE_CLASSES.include?(klass.name)
+
+        if type == :polymorphic &&
+           (!klasses[klass.name].columns.include?((assoc.options[:foreign_key] || "#{assoc.name.to_s}_id").to_s) ||
+            !klasses[klass.name].columns.include?((assoc.options[:foreign_type] || "#{assoc.name.to_s}_type").to_s))
+          $stderr.puts "warning: class #{klass.name} defines a polymorphic relationship #{assoc.name.to_s}, for which there are not the necessary columns in the DB."
+          next
+        end
+
+        assoc_class_name = if type == :polymorphic
+          assoc.name.to_s
+        elsif assoc.options[:class_name]
+          assoc.options[:class_name].to_s
+        else
+          if assoc.macro == :has_many || assoc.macro == :has_and_belongs_to_many
+            assoc.name.to_s.singularize.camelize
+          else
+            assoc.name.to_s.camelize
+          end
+        end
+        
+        next if Dige::IGNORE_CLASSES.include?(assoc_class_name)
+      
+        if klasses[assoc_class_name].nil? && type != :polymorphic
+          polymorphic_name = (assoc.options[:foreign_key] || assoc.options[:foreign_type] || "").to_s.gsub(/_(id|type)$/, '')
+          if !polymorphic_name.empty? &&
+             (klasses[klass.name].columns.include?("#{polymorphic_name}_id")) && 
+             (klasses[klass.name].columns.include?("#{polymorphic_name}_type"))
+            assoc_class_name = polymorphic_name
+            type = :polymorphic
+          else
+            $stderr.puts "warning: class #{klass.name} references non-existing class #{assoc_class_name}" unless assoc.options[:through]
+            next
+          end
+        end
+      
+        assoc_table_name = klasses[assoc_class_name].table_name unless type == :polymorphic
+
+        associations.register(klass.name, klass.table_name, assoc_class_name, assoc_table_name, type, assoc.macro, assoc.options[:join_table])
+      end
+    
+    end
+  
+    associations.all(:polymorphic).each do |assoc|
+      polymorphic_klasses = ActiveRecord::Base.connection.select_values("SELECT DISTINCT #{assoc.to_class_name}_type FROM #{assoc.from_table_name};").compact
+    
+      klasses.all.each do |klass|
+        next unless polymorphic_klasses.include?(klass.class_name)
+        associations.register(assoc.from_class_name, assoc.from_table_name, klass.class_name, klass.table_name, :normal, assoc.macro, assoc.table_name)
+      end
+    end
+  
+    associations.all.each do |assoc|
+      klasses[assoc.from_class_name].associations_count += 1
+      klasses[assoc.to_class_name].associations_count += 1
+    end
+  
+    {
+      :klasses => klasses,
+      :parent_child_relations => parent_child_relations,
+      :associations => associations
+    }
+  
+  end
+
+end

data/lib/dige/instantiator/rails3.rb

@@ -0,0 +1,99 @@
+class Dige::Instantiator::Rails3 < Dige::Instantiator
+
+  def load_models
+    models = Dir["app/models/**/*.rb"].collect do |model| File.expand_path(model) end
+    retries = {}
+    while !models.empty? do
+      model = models.shift
+      begin
+        require model
+        retries = {}
+      rescue Exception => e
+        retries[model] ||= 0
+        retries[model] += 1
+        break if retries[model] > 1
+        models.push model
+      end
+    end
+    $stderr.puts "warning: Failed to load models: #{retries.keys.collect { |m| m.gsub(/^#{RAILS_ROOT}\/app\/models\//, '') }.join(', ')}." unless retries.empty?
+  end
+
+  def load_klasses
+    klasses = Dige::Klasses.new
+    parent_child_relations = Dige::ParentChildRelations.new
+    associations = Dige::Associations.new
+  
+    ActiveRecord::Base.subclasses.each do |klass|
+      columns = ActiveRecord::Base.connection.table_exists?(klass.table_name) ? klass.columns.collect { |column| column.name.to_s } : []
+      klasses.register(klass.name, klass.table_name, columns)  unless Dige::IGNORE_CLASSES.include?(klass.name)
+      parent_child_relations.register(klass.superclass.name, klass.name) unless Dige::IGNORE_CLASSES.include?(klass.superclass.name) || Dige::IGNORE_CLASSES.include?(klass.name)
+    end.each do |klass|
+      klass.reflect_on_all_associations.each do |assoc|
+        type = assoc.options[:polymorphic] ? :polymorphic : :normal
+
+        next if assoc.options[:through] || Dige::IGNORE_CLASSES.include?(klass.name)
+
+        if type == :polymorphic &&
+           (!klasses[klass.name].columns.include?((assoc.options[:foreign_key] || "#{assoc.name.to_s}_id").to_s) ||
+            !klasses[klass.name].columns.include?((assoc.options[:foreign_type] || "#{assoc.name.to_s}_type").to_s))
+          $stderr.puts "warning: class #{klass.name} defines a polymorphic relationship #{assoc.name.to_s}, for which there are not the necessary columns in the DB."
+          next
+        end
+
+        assoc_class_name = if type == :polymorphic
+          assoc.name.to_s
+        elsif assoc.options[:class_name]
+          assoc.options[:class_name].to_s
+        else
+          if assoc.macro == :has_many || assoc.macro == :has_and_belongs_to_many
+            assoc.name.to_s.singularize.camelize
+          else
+            assoc.name.to_s.camelize
+          end
+        end
+        
+        next if Dige::IGNORE_CLASSES.include?(assoc_class_name)
+      
+        if klasses[assoc_class_name].nil? && type != :polymorphic
+          polymorphic_name = (assoc.options[:foreign_key] || assoc.options[:foreign_type] || "").to_s.gsub(/_(id|type)$/, '')
+          if !polymorphic_name.empty? &&
+             (klasses[klass.name].columns.include?("#{polymorphic_name}_id")) && 
+             (klasses[klass.name].columns.include?("#{polymorphic_name}_type"))
+            assoc_class_name = polymorphic_name
+            type = :polymorphic
+          else
+            $stderr.puts "warning: class #{klass.name} references non-existing class #{assoc_class_name}" unless assoc.options[:through]
+            next
+          end
+        end
+      
+        assoc_table_name = klasses[assoc_class_name].table_name unless type == :polymorphic
+
+        associations.register(klass.name, klass.table_name, assoc_class_name, assoc_table_name, type, assoc.macro, assoc.options[:join_table])
+      end
+    
+    end
+  
+    associations.all(:polymorphic).each do |assoc|
+      polymorphic_klasses = ActiveRecord::Base.connection.select_values("SELECT DISTINCT #{assoc.to_class_name}_type FROM #{assoc.from_table_name};").compact
+    
+      klasses.all.each do |klass|
+        next unless polymorphic_klasses.include?(klass.class_name)
+        associations.register(assoc.from_class_name, assoc.from_table_name, klass.class_name, klass.table_name, :normal, assoc.macro, assoc.table_name)
+      end
+    end
+  
+    associations.all.each do |assoc|
+      klasses[assoc.from_class_name].associations_count += 1
+      klasses[assoc.to_class_name].associations_count += 1
+    end
+  
+    {
+      :klasses => klasses,
+      :parent_child_relations => parent_child_relations,
+      :associations => associations
+    }
+  
+  end
+
+end

data/lib/dige/instantiator.rb

@@ -0,0 +1,15 @@
+class Dige::Instantiator
+  
+  def load_models
+    raise NotImplementedError.new("This method should be overridden in a subclass")
+  end
+  
+  def load_klasses
+    raise NotImplementedError.new("This method should be overridden in a subclass")
+  end
+  
+end
+
+require 'dige/instantiator/data_mapper'
+require 'dige/instantiator/rails2'
+require 'dige/instantiator/rails3'

data/lib/dige/klass.rb

@@ -0,0 +1,13 @@
+class Dige::Klass
+  include Dige::ClassBase
+  attr_accessor :class_name, :table_name, :columns, :associations_count
+  
+  def debug_inspect
+    "#{class_name}(#{table_name})[ASSOCIATIONS_COUNT: #{associations_count}, COLUMNS: #{columns.join(",")}]"
+  end
+  
+  def ==(objekt)
+    self.class_name == objekt.class_name &&
+    self.table_name == objekt.table_name
+  end
+end

data/lib/dige/klasses.rb

@@ -0,0 +1,21 @@
+class Dige::Klasses
+  include Dige::List
+  
+  def [](name)
+    @list.detect { |list_item| list_item.send("#{name.to_s =~ /^[A-Z]/ ? "class_name" : "table_name"}".to_sym).to_s == name.to_s }
+  end
+  
+  def register(class_name, table_name, columns)
+    objekt = Dige::Klass.new({ :class_name => class_name, :table_name => table_name, :columns => columns, :associations_count => 0 })
+    unless return_objekt = find(objekt)
+      list << objekt
+      return_objekt = objekt
+    end
+    return_objekt
+  end
+  
+  def all
+    list
+  end
+  
+end

data/lib/dige/list.rb

@@ -0,0 +1,19 @@
+module Dige::List
+  def self.included(base)
+    base.send(:include, InstanceMethods)
+  end
+  
+  module InstanceMethods
+    def find(objekt)
+      list.detect { |list_item| list_item == objekt }
+    end
+    
+    def list
+      @list ||= []
+    end
+    
+    def debug_inspect
+      [ "\n\n#{self.class.name}:\n" ] + all.collect { |objekt| objekt.debug_inspect }.flatten.sort
+    end
+  end
+end

data/lib/dige/parent_child_relation.rb

@@ -0,0 +1,13 @@
+class Dige::ParentChildRelation
+  include Dige::ClassBase
+  attr_accessor :parent_class_name, :child_class_name
+  
+  def debug_inspect
+    "#{parent_class_name} < #{child_class_name}"
+  end
+  
+  def ==(objekt)
+    self.parent_class_name == objekt.parent_class_name &&
+    self.child_class_name == objekt.child_class_name
+  end
+end

data/lib/dige/parent_child_relations.rb

@@ -0,0 +1,17 @@
+class Dige::ParentChildRelations
+  include Dige::List
+
+  def register(parent_class_name, child_class_name)
+    objekt = Dige::ParentChildRelation.new({ :parent_class_name => parent_class_name, :child_class_name => child_class_name })
+    unless return_objekt = find(objekt)
+      list << objekt
+      return_objekt = objekt
+    end
+    return_objekt
+  end
+
+  def all
+    list
+  end
+    
+end

data/lib/dige/project_type_recognizer/data_mapper.rb

@@ -0,0 +1,7 @@
+class Dige::ProjectTypeRecognizer::DataMapper < Dige::ProjectTypeRecognizer
+  
+  def recognize
+    raise NotImplementedError.new("This method should be overridden in a subclass")
+  end
+  
+end

data/lib/dige/project_type_recognizer/rails2.rb

@@ -0,0 +1,7 @@
+class Dige::ProjectTypeRecognizer::Rails2 < Dige::ProjectTypeRecognizer
+  
+  def recognize
+    raise NotImplementedError.new("This method should be overridden in a subclass")
+  end
+  
+end

data/lib/dige/project_type_recognizer/rails3.rb

@@ -0,0 +1,7 @@
+class Dige::ProjectTypeRecognizer::Rails3 < Dige::ProjectTypeRecognizer
+  
+  def recognize
+    raise NotImplementedError.new("This method should be overridden in a subclass")
+  end
+  
+end

data/lib/dige/project_type_recognizer.rb

@@ -0,0 +1,11 @@
+class Dige::ProjectTypeRecognizer
+  
+  def recognize
+    raise NotImplementedError.new("This method should be overridden in a subclass")
+  end
+  
+end
+
+require 'dige/project_type_recognizer/data_mapper'
+require 'dige/project_type_recognizer/rails2'
+require 'dige/project_type_recognizer/rails3'

data/lib/dige.rb

@@ -0,0 +1,13 @@
+require 'dige/dige'
+require 'dige/errors'
+require 'dige/class_base'
+require 'dige/klass'
+require 'dige/association'
+require 'dige/parent_child_relation'
+require 'dige/list'
+require 'dige/klasses'
+require 'dige/associations'
+require 'dige/parent_child_relations'
+require 'dige/project_type_recognizer'
+require 'dige/instantiator'
+require 'dige/graphviz_diagram'

metadata

@@ -0,0 +1,79 @@
+--- !ruby/object:Gem::Specification 
+name: le1t0-dige
+version: !ruby/object:Gem::Version 
+  prerelease: 
+  version: 0.9.0
+platform: ruby
+authors: 
+- Le1t0
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-03-03 00:00:00 +01:00
+default_executable: dige
+dependencies: []
+
+description: "      This project provides code for generating ERD and class diagrams from rails projects.\n"
+email: dev@ewout.to
+executables: 
+- dige
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- bin/dige
+- lib/dige/association.rb
+- lib/dige/associations.rb
+- lib/dige/class_base.rb
+- lib/dige/dige.rb
+- lib/dige/errors.rb
+- lib/dige/graphviz_diagram/entity_relationship_diagram.rb
+- lib/dige/graphviz_diagram/uml_class_diagram.rb
+- lib/dige/graphviz_diagram.rb
+- lib/dige/instantiator/data_mapper.rb
+- lib/dige/instantiator/rails2.rb
+- lib/dige/instantiator/rails3.rb
+- lib/dige/instantiator.rb
+- lib/dige/klass.rb
+- lib/dige/klasses.rb
+- lib/dige/list.rb
+- lib/dige/parent_child_relation.rb
+- lib/dige/parent_child_relations.rb
+- lib/dige/project_type_recognizer/data_mapper.rb
+- lib/dige/project_type_recognizer/rails2.rb
+- lib/dige/project_type_recognizer/rails3.rb
+- lib/dige/project_type_recognizer.rb
+- lib/dige.rb
+- README
+has_rdoc: true
+homepage: http://github.com/le1t0/dige
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.5.2
+signing_key: 
+specification_version: 3
+summary: (rails) diagram generator
+test_files: []
+