ruby2uml 0.1.3

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: bf7a8d24d4df375a813a59abc0543e0497cfe52b
+  data.tar.gz: e65d5635812219d1dc77ce5538e1bd0e70a9e62b
+SHA512:
+  metadata.gz: 2b4cc5ab718f5bbbd119c243ac9ff50f672ed0a9b819d3df57e3c3656c3beb7f0569cda3c5f4d78750aa25d57be36c4a5c2d8afb6bedd25e019de093978ed35e
+  data.tar.gz: 6b52d2878fea62ec642807a110b4e81517e915ab3c1b71a43f64e603fcb8688650775fc5be5008a7c0cd363b5292f277c670012d3e3bbc14c273610ab1c76e0e

data/README.md

@@ -0,0 +1,13 @@
+Extract a UML diagram from Ruby code.
+
+Usage: ruby lib/main.rb file directory ...
+
+TODO:
+add arguments to methods
+add instance variables to classes
+one-to-many aggregation and dependency
+extend relationships
+more advanced class and module resolution
+convert project to gem
+group classes and module in packages based on modules
+include/exclude flag for modules/classes with no dependencies

data/bin/ruby2uml

@@ -0,0 +1,59 @@
+#!/usr/bin/env ruby
+
+require 'optparse'
+require 'yaml'
+
+require_relative '../lib/directory_traverser'
+require_relative '../lib/exploration/explorer_builder'
+require_relative '../lib/graph_generator'
+require_relative '../lib/sexp_factory'
+require_relative '../lib/uml/dot_builder'
+
+def run
+  config = YAML.load_file File.join(File.dirname(File.expand_path(__FILE__)), '../config/config.yml')
+  dot_config = YAML.load_file File.join(File.dirname(File.expand_path(__FILE__)), '../config/dot.yml')
+
+  options = {}
+  optparse = OptionParser.new do|opts|
+    opts.banner = "Usage: main.rb [options] file dir ..."
+    
+    options[:verbose] = false
+    opts.on('-v', '--verbose', 'Display progress') do
+      options[:verbose] = true
+    end
+
+    opts.on('-h', '--help', 'Display this screen') do
+      puts opts
+      exit
+    end
+  end
+
+  optparse.parse!
+
+  if ARGV.length == 0
+    puts 'Must include a file name as an argument.'
+    exit
+  end
+
+  # TODO move the rest of the logic to lib
+
+  explore_file = lambda do |file_name|
+    file = File.open file_name, 'rb' # open file as binary to read into one string
+    program = file.read
+    SexpFactory.new.get_sexp program, 'rb'
+  end
+
+  paths = ARGV
+  traverser = DirectoryTraverser.new explore_file
+  generator = GraphGenerator.new
+  explorer = ExplorerBuilder.new.build_ruby_explorer
+  traverser.process(*paths) do |file, sexp|
+    generator.process_sexp explorer, sexp
+  end
+
+  graph = generator.graph
+
+  DotBuilder.new(config, dot_config).build_uml(graph)
+end
+
+puts run

data/config/config.yml

@@ -0,0 +1,6 @@
+delimiter: "::"
+exclude:
+  - Array
+  - Hash
+  - Set
+  - String

data/config/config.yml~

@@ -0,0 +1 @@
+delimiter: ::

data/config/dot.yml

@@ -0,0 +1,5 @@
+size: "\"10,10\""
+node:
+  shape: record
+  style: filled
+  fillcolor: gray95

data/config/dot.yml~

@@ -0,0 +1,5 @@
+size: \"10,10\"
+node:
+  shape: record
+  style: filled
+  fillcolor: gray95

data/lib/directory_traverser.rb

@@ -0,0 +1,42 @@
+require 'find'
+
+class DirectoryTraverser
+  def initialize command, include=/.*/, verbose=false, out=$stdout, err=$stderr
+    @command = command
+    @include = include
+    @verbose = verbose
+    @out = out
+    @err = err
+  end
+
+  def process *paths, &block
+    paths.each do |path|
+      if FileTest.directory? path
+        process_dir path, &block
+      elsif FileTest.file? path
+        process_file path, &block unless path.match(@include).nil? # only process file if it matches @include
+      else
+        raise "#{path} must be a directory or file"
+      end
+    end
+  end
+
+  private
+  def process_dir dir, &block
+    @out.puts "entering #{dir}" if @verbose
+    Find.find dir do |path|
+      process path, &block unless path == dir
+    end
+  end
+
+  def process_file file, &block
+    @out.puts "generating log for #{file}" if @verbose
+
+    #begin
+      result = @command.call file
+    #  @out.puts "failed to generate log, trying again" if $? != 0
+    #end while $? != 0
+    
+    yield file, result
+  end
+end

data/lib/directory_traverser.rb~

@@ -0,0 +1,42 @@
+require 'find'
+
+class Logger
+  def initialize command, include=/.*/, verbose=false, out=$stdout, err=$stderr
+    @command = command
+    @include = include
+    @verbose = verbose
+    @out = out
+    @err = err
+  end
+
+  def process *paths, &block
+    paths.each do |path|
+      if FileTest.directory? path
+        process_dir path, &block
+      elsif FileTest.file? path
+        process_file path, &block unless path.match(@include).nil? # only process file if it matches @include
+      else
+        raise "#{path} must be a directory or file"
+      end
+    end
+  end
+
+  private
+  def process_dir dir, &block
+    @out.puts "entering #{dir}" if @verbose
+    Find.find dir do |path|
+      process path, &block unless path == dir
+    end
+  end
+
+  def process_file file, &block
+    @out.puts "generating log for #{file}" if @verbose
+
+    begin
+      result = @command.call file
+      @out.puts "failed to generate log, trying again" if $? != 0
+    end while $? != 0
+    
+    yield file, result
+  end
+end

data/lib/exploration/aggregation_relation.rb

@@ -0,0 +1,8 @@
+require_relative 'relation'
+
+class AggregationRelation < Relation
+
+  def each sexp, context=nil, &block
+    each_by_type [:iasgn, :cvasgn], :aggregation, sexp, context, &block
+  end
+end

data/lib/exploration/block_entity.rb

@@ -0,0 +1,12 @@
+require_relative 'entity'
+
+# Explores any children of a :block element. The block element itself is not yielded as an entity only children.
+class BlockEntity < Entity
+  def each sexp, context=nil, &block
+    if sexp.first == :block
+      sexp.each_sexp do |sub_sexp|
+        explore sub_sexp, context, &block
+      end
+    end
+  end
+end

data/lib/exploration/block_entity.rb~

@@ -0,0 +1,9 @@
+require_relative 'entity'
+
+module Exploration
+  class ClassEntity < Entity
+    def each sexp, context=nil, &block
+      each_type sexp, :class, context, &block
+    end
+  end
+end

data/lib/exploration/class_entity.rb

@@ -0,0 +1,7 @@
+require_relative 'entity'
+
+class ClassEntity < Entity
+  def each sexp, context=nil, &block
+    each_type sexp, :class, context, &block
+  end
+end

data/lib/exploration/dependency_relation.rb

@@ -0,0 +1,8 @@
+require_relative 'relation'
+
+class DependencyRelation < Relation
+
+  def each sexp, context=nil, &block
+    each_by_type [:call], :dependency, sexp, context, &block
+  end
+end

data/lib/exploration/entity.rb

@@ -0,0 +1,64 @@
+require_relative 'explorer'
+
+class Entity < Explorer
+  
+  def initialize
+    @explorers = Array.new
+  end
+  
+  # exp is an Explorer object
+  def add_explorer exp
+    @explorers << exp
+  end
+
+  protected
+
+  # REFACTOR context should be its own class instead of a hash
+
+  # Explore each Sexp with type +type+ (ex. :class, :module).
+  def each_type sexp, type, context=nil, &block
+    # if nothing has been explored (i.e. no context) and the top element does not match what we are exploring, skip exploring this sexp
+    return if context.nil? && sexp.sexp_type != type
+
+    # if there is no context and top-level sexp matches type, then just explore that
+    if context == nil && sexp.first == type
+      yield_entity sexp, context, type, &block
+
+      # otherwise, explore the siblings of the sexp
+    else
+      sexp.each_sexp do |sub_sexp|
+        yield_entity sub_sexp, context, type, &block if sub_sexp.sexp_type == type
+      end
+    end
+  end
+
+  private
+
+  # Yields an individual Sexp and all of its Relations.
+  def yield_entity sexp, context, type, &block
+    name = get_entity_name sexp
+    namespace = get_namespace context
+    new_context = { name: name, namespace: namespace, type: type }
+    block.call new_context
+    explore sexp, new_context, &block
+  end
+
+  def explore sexp, context, &block
+    @explorers.each do |exp|
+      exp.each sexp, context, &block
+    end
+  end
+
+  def get_entity_name sexp
+    sexp.rest.head.to_s
+  end
+
+  def get_namespace context
+    namespace = Array.new
+    if context != nil
+      namespace = context[:namespace].dup if context.has_key? :namespace
+      namespace.push context[:name] if context.has_key? :name
+    end
+    namespace
+  end
+  end

data/lib/exploration/explorer.rb

@@ -0,0 +1,15 @@
+# Contract: All classes that inherit Explorer must implement each(sexp, context=nil, &block) which yields entities (classes, modules, etc.) and their relationships among each other.
+#
+# == Explorer#each
+# [arguments] - +sexp+ an Sexp object
+#             - +context+ a String representing the Entity that is calling each (default: nil)
+#
+# [yields] - name of entity
+#          - type of entity
+#          - relation (can be +nil+)
+#          - name of entity receiving relation (can be +nil+)
+#          - type of entity receiving relation (can be +nil+)
+#
+class Explorer
+  attr_writer :resolve_strategy
+end

data/lib/exploration/explorer_builder.rb

@@ -0,0 +1,58 @@
+require_relative 'block_entity'
+require_relative 'class_entity'
+require_relative 'method_entity'
+require_relative 'module_entity'
+require_relative 'root_entity'
+require_relative 'aggregation_relation'
+require_relative 'dependency_relation'
+require_relative 'implements_relation'
+require_relative 'generalization_relation'
+
+# All build methods must return an object that implements Explorable.
+class ExplorerBuilder
+  
+  # Builds Explorer for Ruby programs. This explorer picks up:
+  #
+  # * Classes
+  #   * Generalization relationships
+  #   * Aggregation relationships
+  #   * Dependency relationships
+  #   * Implementation relationships
+  # * Modules
+  #   * Dependency relationships
+  #   * Implementation relationships
+  def build_ruby_explorer
+    agg = AggregationRelation.new
+    dep = DependencyRelation.new
+    par = GeneralizationRelation.new
+    imp = ImplementsRelation.new
+
+    class_method_entity = MethodEntity.new
+    class_method_entity.add_explorer agg
+    class_method_entity.add_explorer dep
+
+    module_method_entity = MethodEntity.new
+    module_method_entity.add_explorer dep
+
+    class_entity = ClassEntity.new
+    class_entity.add_explorer class_method_entity
+    class_entity.add_explorer par
+    class_entity.add_explorer imp
+    module_entity = ModuleEntity.new
+    module_entity.add_explorer module_entity
+    module_entity.add_explorer class_entity
+    module_entity.add_explorer module_method_entity
+    module_entity.add_explorer imp
+
+    block_entity = BlockEntity.new
+    block_entity.add_explorer module_entity
+    block_entity.add_explorer class_entity
+
+    root = RootEntity.new
+    root.add_explorer class_entity
+    root.add_explorer module_entity
+    root.add_explorer block_entity
+
+    return root
+  end
+end

data/lib/exploration/generalization_relation.rb

@@ -0,0 +1,13 @@
+require_relative 'relation'
+
+class GeneralizationRelation < Relation
+  
+  # Yields the parent of the +sexp+.
+  def each sexp, context=nil, &block
+    parent_node = sexp.rest.rest.head
+    if parent_node != nil # class has a parent
+      parent, namespace, explored = get_name_and_namespace parent_node
+      block.call context, :generalization, { name: parent, type: :class, namespace: namespace }
+    end
+  end
+end

data/lib/exploration/implements_relation.rb

@@ -0,0 +1,14 @@
+require_relative 'relation'
+
+class ImplementsRelation < Relation
+  def each sexp, context=nil, &block
+    sexp.each_sexp do |child|
+      # check if child is a call to include
+      if child.first == :call && child.rest.rest.first == :include
+        node = child.rest.rest.rest.first
+        name, namespace, explored = get_name_and_namespace node
+        block.call context, :implements, { name: name, type: :module, namespace: namespace }
+      end
+    end
+  end
+end

data/lib/exploration/method_entity.rb

@@ -0,0 +1,20 @@
+require_relative 'entity'
+
+class MethodEntity < Entity
+
+  def each sexp, context=nil, &block
+    # NOTE does not handle file with only methods in it
+    sexp.each_sexp do |sub_sexp|
+      if [:defn, :defs].include? sub_sexp.sexp_type
+        # TODO handle arguments for methods
+        if sub_sexp.rest.first.kind_of? Sexp # TODO right now, we assume this is self, need to look into
+          name = sub_sexp.rest.rest.first.to_s
+        else
+          name = sub_sexp.rest.first.to_s
+        end
+        block.call context, :defines, { name: name, type: :method }
+        explore sub_sexp, context, &block
+      end
+    end
+  end
+end

data/lib/exploration/module_entity.rb

@@ -0,0 +1,7 @@
+require_relative 'entity'
+
+class ModuleEntity < Entity
+  def each sexp, context=nil, &block
+    each_type sexp, :module, context, &block
+  end
+end

data/lib/exploration/multi_relation.rb~

@@ -0,0 +1,5 @@
+module Exploration
+  class MultiRelation < Relation
+    
+  end
+end

data/lib/exploration/relation.rb

@@ -0,0 +1,73 @@
+require_relative 'explorer'
+
+class Relation < Explorer
+
+  # TODO these two methods are only used by aggregation and dependency, find a better place for them
+  def each_by_type types, relation, sexp, context=nil, &block
+    already_explored = []
+    sexp.deep_each do |sub_sexp|
+      if types.include? sub_sexp.sexp_type
+        # by exploring :colon2 first, we won't pick up any :const that was inside a :colon2
+        explore_entity_sexp :colon2, sexp, relation, context, already_explored, &block
+        explore_entity_sexp :const, sexp, relation, context, already_explored, &block
+      end
+    end
+  end
+
+  def explore_entity_sexp type, sexp, relationship, context, already_explored, &block
+    sexp.each_of_type(type) do |node|
+      if !already_explored.include?(node)
+        name, namespace, explored = get_name_and_namespace node
+        block.call context, relationship, { name: name, type: :class, namespace: namespace }
+        already_explored.concat explored
+      end
+    end
+  end
+
+  # Extracts name and namespace of the Sexp object.
+  #
+  # [params] - sexp is a Sexp object
+  #
+  # [precondition] - sexp is of the form: s(:colon2, s(:colon2 ..., s(:const, FirstNamespace), SecondNamespace, ..., ClassName).
+  #                - :colon2 sexp's are optional but there must be a :const
+  #
+  # [return] - name as String
+  #          - namespace as Array of String objects
+  #          - explored Sexp objects as an Array
+  def get_name_and_namespace sexp
+    name = if sexp.first == :colon2
+             sexp.rest.rest.first.to_s
+           else
+             sexp.rest.first.to_s
+           end
+    namespace, explored = get_namespace sexp
+    explored << sexp
+    return name, namespace, explored
+  end
+
+  # Extracts the namespace from the Sexp object.
+  #
+  # [precondition] - sexp is of the form: s(:colon2, s(:colon2 ..., s(:const, FirstNamespace), SecondNamespace, ..., ClassName).
+  #                - :colon2 sexp's are optional but there must be a :const
+  #
+  # [params] - sexp is a Sexp object
+  #
+  # [return] - Array of String objects
+  #          - Array of Sexp objects that where encountered
+  #
+  # [example] - s(:colon2, s(:colon2, s(:const, :Baz), :Foo), :Bar) ==> ['Baz', 'Foo']
+  def get_namespace sexp
+    current = sexp
+    type = current.first
+    namespace = []
+    subs = []
+    while type == :colon2
+      namespace.unshift current.rest.rest.first.to_s
+      current = current.rest.first
+      subs << current
+      type = current.first
+    end
+    namespace.unshift current.rest.first.to_s
+    return namespace[0...namespace.length-1], subs # return all except for the last element
+  end
+end

data/lib/exploration/resolve/resolve_strategy.rb

@@ -0,0 +1,44 @@
+# Contract: All classes that inherit ResolveStrategy must implement +is_same?(v1, v2)+.
+#
+# == ResolveStrategy.is_same(v1, v2)
+# [arguments] - +v1+ a Vertex object
+#             - +v2+ a Vertex object
+#
+class ResolveStrategy
+
+  # precondition: vertices contains more the one Vertex
+  # postcondition: the namespace of the merged vertex will be the namespace among vertices that is the longest
+  def merge_vertices *vertices
+    merged = vertices[0].dup
+    (1...vertices.length).each do |i|
+      v = vertices[i]
+      merged.namespace = v.namespace if v.namespace.count > merged.namespace.count
+      merged.paths.concat v.paths
+
+      v.each do |edge, set|
+        set.each do |o|
+          merged.add_edge edge, o
+        end
+      end
+    end
+    merged
+  end
+
+  # For all incoming edges, for all +vertices+, change the refernce from that vertex to the merged vertex. For example, if Foo depends on Bar, and Bar was merged into Merged then Foo should now reference Merged.
+  #
+  # postcondition: all incoming edges that reference a vertex in +vertices+ will now reference +merged+.
+  def rereference_incoming_edges! merged, *vertices
+    to_add = []
+    vertices.each do |vertex|
+      vertex.each_incoming do |edge, set|
+        set.each do |incoming|
+          incoming.remove_edge edge, vertex
+          to_add << [incoming, edge, merged]
+        end
+      end
+    end
+    to_add.each do |incoming, edge, merged|
+      incoming.add_edge edge, merged
+    end
+  end
+end

data/lib/exploration/resolve/simple_resolve_strategy.rb

@@ -0,0 +1,14 @@
+require_relative 'resolve_strategy'
+
+# The SimpleResolveStrategy assumes any vertex with the same name  and a namespace that includes or is included by the other represents the same entity regardless of the namespace of the entity or paths where the entity is declared.
+class SimpleResolveStrategy < ResolveStrategy
+
+  # Returns true if v1 and v2 represent the same vertex based on the Simple Resolve Strategy
+  # v1, v2 are Vertex objects
+  def is_same? v1, v2
+    v1.name.eql?(v2.name) && (
+                              v1.namespace.is_included_by?(v2.namespace) ||
+                              v1.namespace.does_include?(v2.namespace)
+                              )
+  end
+end

data/lib/exploration/root_entity.rb

@@ -0,0 +1,8 @@
+require_relative 'entity'
+
+# A wrapper Entity to support multiple top-level entities in an explorer. Does not represent an actual Entity.
+class RootEntity < Entity
+  def each sexp, context=nil, &block
+    explore sexp, context, &block
+  end
+end

data/lib/graph/digraph.rb

@@ -0,0 +1,50 @@
+require 'set'
+
+class Digraph
+  include Enumerable
+
+  def initialize
+    @vertices = Array.new
+  end
+
+  # Returns an Array of Vertices that match the name, namespace and path.
+  def find_vertex name, namespace=nil, paths=nil # REFACTOR consider changing this to a Vertex object
+    @vertices.select do |v|
+      v.name == name &&
+        (namespace.nil? || v.namespace.eql?(namespace)) &&
+        (paths.nil? || (paths - v.paths).empty?) # checks to see if paths is a subset of v.paths
+    end
+  end
+
+  # Returns true if self has a Vertex with the name +vertex_name+.
+  def has_vertex? vertex_name
+    !@vertices.select { |v| v.name == vertex_name }.empty?
+  end
+
+  def add_vertex vertex
+    @vertices.push vertex
+    vertex
+  end
+
+  def remove_vertex vertex
+    @vertices.delete vertex
+  end
+
+  def each &block
+    @vertices.each &block
+  end
+
+  def eql? obj
+    Set.new(self.vertices).eql? Set.new(obj.vertices)
+    
+  end
+  alias_method :==, :eql?
+  
+  protected
+  attr_reader :vertices # needed for eql?
+  public
+
+  def to_s
+    @vertices.map(&:to_s).join("\n")
+  end
+end

data/lib/graph/edge.rb

@@ -0,0 +1,20 @@
+class Edge
+  attr_accessor :type
+
+  def initialize type
+    @type = type
+  end
+
+  def eql? object
+    self.type.eql?(object.type)
+  end
+  alias_method :==, :eql?
+  
+  def hash
+    @type.hash
+  end
+
+  def to_s
+    @type
+  end
+end

data/lib/graph/namespace.rb

@@ -0,0 +1,49 @@
+require 'forwardable'
+
+# Instances of Namespace are immutable.
+class Namespace
+  include Enumerable
+  extend Forwardable
+
+  def_delegators :@array, :join
+
+  def initialize array
+    @array = array || Array.new # do not want a nil array for namespace, better to have an empty array
+  end
+
+  # Checks if the Namespace could be included by the other Namespace.
+  # ex. B::C is included by A::B::C since B::C could belong to A
+  # other is a Namespace object
+  def is_included_by? other
+    return false if self.count > other.count
+    return true if self.eql? other
+    return other.drop(other.count - self.count).to_a.eql? self.to_a
+  end
+  
+  # Checks if the Namespace include the other Namespace.
+  # ex. A::B::C includes B::C since B::C could belong to A
+  # other is a Namespace object
+  def does_include? other
+    return false if other.count > self.count
+    return true if self.eql? other
+    return self.drop(self.count - other.count).to_a.eql? other.to_a
+  end
+
+  def eql? other
+    @array.eql?(other.to_a) && self.class.eql?(other.class)
+  end
+  alias_method :==, :eql?
+
+  def hash
+    @array.hash
+  end
+
+  # postcondition: order will be preserved
+  def each &block
+    @array.each &block
+  end
+
+  def to_s
+    @array.join '::'
+  end
+end

data/lib/graph/vertex.rb

@@ -0,0 +1,89 @@
+require 'set'
+
+require_relative 'namespace'
+
+class Vertex
+  include Enumerable
+
+  attr_accessor :name, :namespace, :paths, :type
+  
+  def initialize name, type, namespace=[]
+    @name = name
+    @type = type
+    @namespace = Namespace.new namespace
+    @paths = Array.new
+
+    @outgoing = Hash.new
+    @incoming = Hash.new
+  end
+
+  def get_edge edge
+    @outgoing[edge] = Set.new if !@outgoing.has_key? edge
+    @outgoing[edge]
+  end
+  alias_method :[], :get_edge
+
+  def add_edge edge, vertex
+    @outgoing[edge] = Set.new if !@outgoing.has_key? edge
+    @outgoing[edge] << vertex
+
+    vertex.add_incoming_edge edge, self
+  end
+
+  def remove_edge edge, vertex
+    @outgoing[edge].delete vertex
+    vertex.remove_incoming_edge edge, self
+  end
+
+  def each &block
+    @outgoing.each &block
+  end
+  alias_method :each_outgoing, :each
+
+  def each_incoming &block
+    @incoming.each &block
+  end
+
+  def eql? obj
+    self.class.eql?(obj.class) &&
+      self.name.eql?(obj.name) &&
+      self.namespace.eql?(obj.namespace) &&
+      Set.new(self.each.to_a).eql?(Set.new(obj.each.to_a)) &&
+      self.paths.eql?(obj.paths) &&
+      self.type.eql?(obj.type)
+  end
+  alias_method :==, :eql?
+
+  def hash
+    @name.hash
+  end
+
+  def fully_qualified_name delimiter
+    ns = self.namespace.join delimiter
+    ns << delimiter if ns != ''
+    ns + self.name
+  end
+
+  def to_s
+    string = fully_qualified_name '::'
+    string += "~#{type}\n"
+    @outgoing.each do |edge, set|
+      string << "\t#{edge.to_s}: [ "
+      set.each do |v|
+        string << "#{v.namespace.to_s}#{'::' if v.namespace.to_s != ''}#{v.name.to_s},"
+      end
+      string << "]\n"
+    end
+    return string.chomp
+  end
+
+  protected
+  def add_incoming_edge edge, vertex
+    @incoming[edge] = Set.new if !@incoming.has_key? edge
+    @incoming[edge] << vertex
+  end
+
+  def remove_incoming_edge edge, vertex
+    @incoming[edge].delete vertex if @incoming.has_key? edge
+  end
+end

data/lib/graph_generator.rb

@@ -0,0 +1,62 @@
+require_relative 'exploration/resolve/simple_resolve_strategy'
+
+require_relative 'graph/digraph'
+require_relative 'graph/edge'
+require_relative 'graph/namespace'
+require_relative 'graph/vertex'
+
+class GraphGenerator
+  attr_reader :graph
+  attr_writer :resolve_strategy
+
+  def initialize
+    @graph = Digraph.new
+    @resolve_strategy = SimpleResolveStrategy.new
+  end
+
+  # Traverse +sexp+ using the given +explorer+ and store the extracted relationships in the +graph+.
+  #
+  # [params] - explorer is an Explorable used for the traversal
+  #          - sexp is a Sexp that is the subject of the traversal
+  def process_sexp explorer, sexp
+    explorer.each(sexp) do |entity, relation, other_entity|
+      vertex = get_or_create_vertex @graph, entity[:name], entity[:namespace], entity[:type]
+      if not relation.nil?
+        o_vertex = get_or_create_vertex @graph, other_entity[:name], other_entity[:namespace], other_entity[:type]
+        edge = get_edge relation
+        vertex.add_edge edge, o_vertex
+      end
+    end
+  end
+  
+private
+
+  def get_or_create_vertex graph, name, namespace, type
+    vertex = nil
+    if graph.has_vertex? name
+      vertices = graph.find_vertex(name)
+      found_vertex = vertices.first
+      new_vertex = create_vertex(name, namespace, type)
+      if @resolve_strategy.is_same?(found_vertex, new_vertex)
+        vertex = @resolve_strategy.merge_vertices(found_vertex, new_vertex)
+        @resolve_strategy.rereference_incoming_edges!(vertex, found_vertex, new_vertex)
+        graph.remove_vertex found_vertex
+        graph.remove_vertex new_vertex
+      else
+        vertex = new_vertex
+      end
+    else
+      vertex = create_vertex(name, namespace, type)
+    end
+    graph.add_vertex vertex
+    return vertex
+  end
+
+  def create_vertex name, namespace, type
+    Vertex.new name, type, namespace
+  end
+
+  def get_edge type
+    Edge.new type
+  end
+end

data/lib/sexp_factory.rb

@@ -0,0 +1,20 @@
+require 'ruby_parser'
+
+# SexpFactory generates a Sexp object from a given file and for a given type. The only supported type so far is Ruby (.rb) files.
+class SexpFactory
+
+  def initialize
+    @ext_map = Hash.new
+    rb_parser = RubyParser.new
+    @ext_map['rb'] = lambda { |program| rb_parser.parse program }
+  end
+
+  # Returns a Sexp representation of the program
+  # = +Sexp+
+  # Params:
+  # +program+:: string containing a program to be converted to s-expression
+  # +ext+:: string for file extensions of the program
+  def get_sexp program, ext
+    @ext_map[ext].call program
+  end
+end

data/lib/uml/dot_builder.rb

@@ -0,0 +1,84 @@
+require_relative 'uml_builder'
+
+# DotBuilder constructs a String in .dot format from a Digraph to be used with the Graphviz Dot program.
+class DotBuilder
+  include UmlBuilder
+
+  def node_beginning vertex
+    id = @vertex_to_id[vertex]
+    name = vertex.fully_qualified_name(@config["delimiter"]).chomp("?").chomp("!") # TODO find a better solution than removing question marks and bangs from methods
+    "#{id}[label = \"{#{name}|"
+  end
+
+  def node_ending
+    "}\"]\n"
+  end
+
+  def initialize config={}, dot_config={}
+    super(config)
+    @dot_config = dot_config
+
+    @id_counter = 0
+    @vertex_to_id = Hash.new
+
+    def get_methods vertex
+      methods = vertex.get_edge(Edge.new(:defines))
+      return '...' if methods.empty?
+      methods.to_a.map(&:name).join('\n').chomp('\n') # TODO need to figure out how to add new lines correctly
+    end
+
+    @vertex_mappings = Hash.new lambda { |*| '' }
+    @vertex_mappings[:module] = lambda do |moduel|
+      node_beginning(moduel) +
+        get_methods(moduel) +
+        node_ending
+    end
+    @vertex_mappings[:class] = lambda do |klass|
+      node_beginning(klass) +
+        "...|" + get_methods(klass) +
+        node_ending
+    end
+
+    @edge_mappings = Hash.new lambda { |*| '' }
+    @edge_mappings[:generalization] = lambda do |child, parent|
+      return "#{parent}->#{child}[arrowtail=empty, dir=back]"
+    end
+    @edge_mappings[:implements] = lambda do |impl, type|
+      return "#{type}->#{impl}[arrowtail=empty, dir=back, style=dashed]"
+    end
+    @edge_mappings[:aggregation] = lambda do |aggregator, aggregate|
+      return "#{aggregator}->#{aggregate}[arrowtail=odiamond, constraint=false, dir=back]"
+    end
+    @edge_mappings[:dependency] = lambda do |vertex, depends_on|
+      return "#{vertex}->#{depends_on}[dir=forward, style=dashed]"
+    end
+  end
+
+  def build_header
+    header = "digraph hierarchy {\n"
+    header << "size=#{@dot_config["size"]}\n" if @dot_config.has_key? "size"
+    if @dot_config.has_key? "node"
+      header << "node["
+      @dot_config["node"].each do |setting_name, setting_value|
+        header << "#{setting_name}=#{setting_value}, "
+      end
+      header.chomp!(", ")
+      header << "]\n"
+    end
+    header
+  end
+
+  def build_entity vertex
+    @id_counter += 1
+    @vertex_to_id[vertex] = @id_counter
+    @vertex_mappings[vertex.type].call(vertex)
+  end
+
+  def build_relation vertex, edge, o_vertex
+    @edge_mappings[edge].call(@vertex_to_id[vertex], @vertex_to_id[o_vertex]) + "\n"
+  end
+
+  def build_footer
+    "}"
+  end
+end

data/lib/uml/uml_builder.rb

@@ -0,0 +1,31 @@
+# Contract:
+# Classes that include UmlBuilder must implement the following methods:
+# * build_entity(vertex)
+# * build_relation(vertex, edge, vertex)
+module UmlBuilder
+
+  def initialize config={}
+    @config = config
+    @exclude = config['exclude'] || []
+  end
+
+  def build_uml graph
+    content = ''
+    content << build_header if self.respond_to? :build_header
+    graph.each do |vertex|
+      content << build_entity(vertex) unless @exclude.include? vertex.name
+    end
+
+    graph.each do |vertex|
+      vertex.each do |edge, set|
+        unless @exclude.include? vertex.name
+          set.each do |o_vertex|
+            content << build_relation(vertex, edge.type, o_vertex) unless @exclude.include? o_vertex.name
+          end
+        end
+      end
+    end
+    content << build_footer if self.respond_to? :build_footer
+    content
+  end
+end

metadata

@@ -0,0 +1,90 @@
+--- !ruby/object:Gem::Specification
+name: ruby2uml
+version: !ruby/object:Gem::Version
+  version: 0.1.3
+platform: ruby
+authors:
+- Michael Dalton
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-07-04 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: ruby_parser
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 3.1.3
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 3.1.3
+description: ruby2uml generates a UML Class diagram from Ruby source code.
+email: michaelcdalton@gmail.com
+executables:
+- ruby2uml
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/graph/vertex.rb
+- lib/graph/namespace.rb
+- lib/graph/edge.rb
+- lib/graph/digraph.rb
+- lib/graph_generator.rb
+- lib/directory_traverser.rb
+- lib/sexp_factory.rb
+- lib/exploration/dependency_relation.rb
+- lib/exploration/module_entity.rb
+- lib/exploration/resolve/resolve_strategy.rb
+- lib/exploration/resolve/simple_resolve_strategy.rb
+- lib/exploration/entity.rb
+- lib/exploration/block_entity.rb
+- lib/exploration/class_entity.rb
+- lib/exploration/multi_relation.rb~
+- lib/exploration/explorer.rb
+- lib/exploration/aggregation_relation.rb
+- lib/exploration/root_entity.rb
+- lib/exploration/method_entity.rb
+- lib/exploration/relation.rb
+- lib/exploration/explorer_builder.rb
+- lib/exploration/generalization_relation.rb
+- lib/exploration/block_entity.rb~
+- lib/exploration/implements_relation.rb
+- lib/uml/dot_builder.rb
+- lib/uml/uml_builder.rb
+- lib/directory_traverser.rb~
+- config/dot.yml
+- config/dot.yml~
+- config/config.yml~
+- config/config.yml
+- README.md
+- bin/ruby2uml
+homepage: http://github.com/kcdragon/ruby2uml
+licenses: []
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.0.3
+signing_key: 
+specification_version: 4
+summary: UML Class Diagram Generation
+test_files: []