ruby-uml 0.2.2

data/examples/temperature_new.rb

@@ -0,0 +1,25 @@
+require 'observer'
+
+class TempSensor
+  include Observable
+  
+  def run(start = 26)
+    start.upto(27) do |temp|
+      changed
+      notify_observers temp
+    end
+  end
+end
+
+class TempAlarm
+
+  def initialize(sensor)
+    sensor.add_observer self
+  end
+  
+  def update(temp)
+    $stderr.puts temp if temp > 26
+    temp
+  end
+  
+end

data/examples/temperature_old.rb

@@ -0,0 +1,24 @@
+require 'observer'
+
+class TempSensor
+  include Observable
+  
+  def run(start = 26)
+    start.upto(27) do |temp|
+      changed
+      notify_observers temp
+    end
+  end
+end
+
+class TempAlarm
+
+  def initialize(sensor)
+    sensor.add_observer self
+  end
+  
+  def update(temp)
+    temp
+  end
+  
+end

data/lib/uml/class_diagram.rb

@@ -0,0 +1,208 @@
+require 'uml/lowlevel_backtracer'
+require 'uml/class_diagram_helper'
+
+module UML
+
+  # Generates dot representation out of program execution.
+  # 
+  # Starts with information gathering as soon as it is created.
+  # 
+  # TODO Parser in to_dot who checks double directed association and substitutes with undirected.
+  # 
+  # TODO When cluster_packages is true, module is printed as subgraph and node.
+  class ClassDiagram
+    include Graphviz
+
+    # Configuration options:
+    # show_private_methods:: If +true+, includes private instance methods in Nodes.
+    # 
+    #                        Default is +false+.
+    # show_protected_methods:: If +true+, includes protected instance methods in Nodes.
+    # 
+    #                          Default is +false+.
+    # show_public_methods:: If +true+, includes public instance methods in Nodes.
+    # 
+    #                       Default is +true+.
+    # cluster_packages:: If +true+, namespaces are clustered into a package-like representation.
+    # 
+    #                    Graphviz can't plot UML-package with tab, so there is just the package name in
+    #                    the top-left corner of a box. Defaults to +false+.
+    # exclude:: Array which contains information for classes to exclude from graph.
+    # 
+    #           Can contain regular expressions, strings, symbols, or Constants.
+    #           
+    #           Defaults to empty Array.
+    # include:: Array which contains information for desired classes.
+    # 
+    #           Can contain regular expressions, strings, symbols, or Constants.
+    #           
+    #           Defaults to empty Array.
+    def initialize(config = {})
+      @config = {
+        :show_private_methods   => false,
+        :show_protected_methods => false,
+        :show_public_methods    => true,
+        :cluster_packages       => false,
+        :exclude                => [],
+        :include                => []
+      }.update(config)
+      
+      @graph = Graph.new('digraph', 'class_diagram')
+      @graph.default_node_attributes[:shape]      = 'record'
+      @graph.default_graph_attributes[:labelloc]  = 't'
+      @graph.default_graph_attributes[:labeljust] = 'l'
+      
+      @tracer = LowlevelBacktracer.instance
+      @tracer.add_observer self
+    end
+    
+    # Returns a dot representation of gathered information
+    def to_dot
+      @graph.to_dot
+    end
+
+    # Manually add a klass with its included modules and superclasses to graph.
+    # 
+    # klass has to be accepted by configuration options.
+    def include(klass)
+      generate_node_with_supers(inheritance(klass))
+    end
+    
+    def update(event, tracer) # :nodoc:
+      return if event != :call
+       
+      right = tracer.call_stack[-1]
+      return if not accepted(right[:klass])
+
+      left = called_by_interesting(tracer.call_stack)
+ 
+      include(right[:klass])
+      if left
+        include(left[:klass])
+        @graph.edges[[left[:klass], right[:klass]]] ||= Dependency.new(left[:klass], right[:klass]) if left[:klass] != right[:klass]
+      end
+    end
+    
+  private
+    
+    # Creates parent subgraphs and returns needed one if package clustering is activated.
+    # If not, returns just toplevel graph.
+    def get_graph(klass)
+      return @graph if not @config[:cluster_packages]
+      result = @graph
+      namespaces = klass.to_s.split('::')
+      object = namespaces.pop
+      namespaces.each do |namespace|
+        unless result.subgraphs[namespace]
+          result.subgraphs[namespace] = Graph.new('subgraph', "cluster_#{namespace}")
+          result.subgraphs[namespace].default_graph_attributes[:label] = namespace
+        end
+        result = result.subgraphs[namespace]
+      end
+      return result
+    end
+
+    # When package clustering is activated, node labels contain just name of module.
+    # If not, the full qualified name is returned.
+    def get_nodelabel(klass)
+      @config[:cluster_packages] ? klass.to_s.split('::').last : klass
+    end
+    
+    def called_by_interesting(stack)
+      stack.reverse_each do |element|
+        next if element == stack.last
+        return element if accepted(element[:klass])
+      end
+      nil
+    end
+    
+    # Checks if klass is wanted or not according to +:include+ and +:exclude+ configuration options.
+    # If +:include+ is empty, everything is accepted at first place.
+    # Exclusions are checked at second.
+    def accepted(klass)
+      (@config[:include].empty? ? true : test_inclusion(@config[:include], klass)) and not test_inclusion(@config[:exclude], klass)
+    end
+    
+    # Is called by accepted.
+    # Makes it possible to use regular expressions, constants, strings or symbols
+    # in +:include+ and +:exclude+ configuration options.
+    def test_inclusion(array, klass)
+      array.each do |element|
+        case element
+        when Regexp
+          return true if element =~ klass.to_s
+        when String, Symbol
+          return true if element.to_s == klass.to_s
+        else
+          return true if element == klass
+        end
+      end
+      false
+    end
+     
+    def generate_public_method_hash(object)
+      object.public_instance_methods(false).inject({}) do |result, m|
+        result[m] = '+'
+        result
+      end
+    end
+    
+    def generate_protected_method_hash(object)
+      object.protected_instance_methods(false).inject({}) do |result, m|
+        result[m] = '#'
+        result
+      end
+    end
+    
+    def generate_private_method_hash(object)
+      object.private_instance_methods(false).inject({}) do |result, m|
+        result[m] = '-'
+        result
+      end
+    end
+    
+    # Add or update a node in graph with desired informations.
+    # Node is integrated in right graph, according to +:cluster_packages+
+    def generate_node(klass)
+      target_graph = get_graph(klass)
+      target_graph.nodes[klass] ||= ClassNode.new(klass, get_nodelabel(klass))
+      target_graph.nodes[klass].methods.update(generate_public_method_hash(klass))    if @config[:show_public_methods]
+      target_graph.nodes[klass].methods.update(generate_protected_method_hash(klass)) if @config[:show_protected_methods]
+      target_graph.nodes[klass].methods.update(generate_private_method_hash(klass))   if @config[:show_private_methods]
+    end
+  
+    # Uses hash from +inheritance+ to generate needed nodes with generalization edges
+    def generate_node_with_supers(hash, subclass = nil)
+      hash.each do |key, value|
+        generate_node(key)
+        generate_node_with_supers(value, key)
+        
+        # Generalization always has high priority. That means an existing edge at
+        # [subclass, key] is overwritten.
+        # Edges are always integrated in top graph.
+        @graph.edges[[subclass, key]] = Generalization.new(subclass, key) if subclass
+      end
+    end
+    
+    # Returns recursive hash with included modules and superclasses.
+    # Objects that are not accepted by configuration options and their predecessors
+    # are omitted.
+    # Modules are included once in deepest object that included it.
+    def inheritance(klass, excludes = [])
+      result = {}
+      if klass and (accepted(klass) and not excludes.include?(klass))
+
+        result[klass] = klass.respond_to?(:superclass) ? inheritance(klass.superclass, excludes) : {}
+        excludes << klass
+
+        klass.included_modules.each do |mod|
+          result[klass].update(inheritance(mod, excludes))
+          excludes << mod
+        end
+
+      end
+      result
+    end
+    
+  end
+end

data/lib/uml/class_diagram_helper.rb

@@ -0,0 +1,61 @@
+require 'uml/graphviz_helper'
+
+module UML
+  module Graphviz
+
+    class ClassNode < Node
+    
+      attr_accessor :methods
+      
+      def initialize(name, title)
+        super(name)
+        @title = title
+        # key = method_symbol, value = visibility
+        @methods = {}
+      end
+      
+      def to_dot(indent = 0)
+        @attributes[:label] = label
+        super
+      end
+
+    private
+
+      def label
+        result = "{#{@title}"
+        result << '|' if not @methods.empty?
+        @methods.each do |symbol, visibility|
+          result << "#{visibility} #{escape_symbol(symbol)}()\\l"
+        end
+        result << '}'
+      end
+      
+      def escape_symbol(symbol)
+        symbol.gsub(/</, '\<').gsub(/>/, '\>').gsub(/\|/, '\|')
+      end
+    end
+   
+    class Generalization < Edge
+      def initialize(tail, head)
+        super
+        @attributes[:arrowhead] = 'onormal'
+      end
+    end
+    
+    # aka directed association
+    class Dependency < Edge
+      def initialize(tail, head)
+        super
+        @attributes[:arrowhead] = 'vee'
+      end
+    end
+    
+    class Association < Edge
+      def initialize(tail, head)
+        super
+        @attributes[:arrowhead] = 'none'
+      end
+    end
+    
+  end
+end

data/lib/uml/graphviz_helper.rb

@@ -0,0 +1,90 @@
+module UML
+  module Graphviz
+  
+    class Attributes < Hash
+      def to_dot
+        return '' if empty?
+        result = inject([]) do |tmp, value|
+          tmp << "#{value[0]} = \"#{value[1]}\""
+        end
+        '[' + result.join(', ') + ']'
+      end
+    end
+    
+    class Graph
+    
+      attr_accessor :subgraphs, :nodes, :edges
+      attr_reader :default_graph_attributes,
+        :default_node_attributes,
+        :default_edge_attributes
+      
+      def initialize(type, name)
+        @name = name
+        @type = type
+        @subgraphs = {}
+        @nodes = {}
+        @edges = {}
+        @default_graph_attributes = Attributes.new
+        @default_node_attributes = Attributes.new
+        @default_edge_attributes = Attributes.new
+      end
+      
+      def to_dot(indent = 0)
+        result = ''
+        result << '  ' * indent << "#{@type} #{@name} {\n"
+        result << '  ' * (indent + 1) << "graph #{@default_graph_attributes.to_dot};\n" unless @default_graph_attributes.empty?
+        result << '  ' * (indent + 1) << "node #{@default_node_attributes.to_dot};\n" unless @default_node_attributes.empty?
+        result << '  ' * (indent + 1) << "edge #{@default_edge_attributes.to_dot};\n" unless @default_edge_attributes.empty?
+        result << collection_to_dot(@subgraphs.values, indent)
+        result << collection_to_dot(@nodes.values, indent)
+        result << collection_to_dot(@edges.values, indent)
+        result << '  ' * indent << '}'
+      end
+      
+      def name_to_id(object)
+        self.class.name_to_id object
+      end
+      
+      def self.name_to_id(object)
+        '_' << object.to_s.gsub(/::/, '_')
+      end
+      
+    private
+      def collection_to_dot(collection, indent)
+        collection.inject([]) { |result, element| result << "#{element.to_dot(indent + 1)}\n" }.to_s
+      end 
+    end
+    
+    class Node
+    
+      attr_reader :attributes, :name
+      
+      def initialize(name)
+        @name = name
+        @attributes = Attributes.new
+      end
+      
+      def to_dot(indent = 0)
+        "#{'  ' * indent}#{Graph::name_to_id(name)} #{@attributes.to_dot};"
+      end
+      
+    end
+    
+    class Edge
+      
+      attr_reader :attributes
+      
+      def initialize(tail, head)
+        @tail = tail
+        @head = head
+        @attributes = Attributes.new
+      end
+      
+      def to_dot(indent = 0)
+        "#{'  ' * indent}#{Graph::name_to_id(@tail)} -> #{Graph::name_to_id(@head)} #{@attributes.to_dot};"
+      end
+
+    end
+    
+  end
+end

data/lib/uml/highlevel_backtracer.rb

@@ -0,0 +1,73 @@
+require 'observer'
+require 'aspectr'
+require 'uml/method_helper'
+
+module UML
+
+  class HighlevelBacktracer < AspectR::Aspect
+    include Observable
+    include MethodHelper
+    
+    # +call_stack+ is an array with hashes as elements.
+    # Each element represents a call to a wrapped method with topmost element at last.
+    # 
+    # Element has following keys as symbols:
+    # args:: holds an array of the arguments to method
+    # object:: reference to receiver of method
+    # method_symbol:: symbol of called method
+    # real_object:: the real receiver of method in inheritance tree
+    # returns:: return value of method. Only valid if method returned already
+    attr_reader :call_stack
+    
+    def initialize
+      
+      @call_stack = []
+    end
+
+    # Wrap given methods of class or instance.
+    # 
+    # each wrapped method will notify observers with <tt>(symbol, self)</tt>
+    # where symbol can be +:call+ or +:return+
+    def include(klass, *methods)
+      methods.each do |method_symbol|
+        add_advice klass, PRE, method_symbol, :before
+        add_advice klass, POST, method_symbol, :after
+      end
+    end
+    
+  private
+  
+    def before(method_string, object, return_value, *args)
+      method_symbol = method_string.to_sym
+      
+      actual_information = {
+        :args          => args,
+        :object        => object,
+        :method_symbol => method_symbol,
+        :real_object   => get_real_receiver_of_method(object, method_symbol)
+      }
+
+      @call_stack.push actual_information 
+
+      changed
+      notify_observers :call, self
+
+    end
+
+    def after(method_string, object, return_value, *args)
+      method_symbol = method_string.to_sym
+
+      actual_information = {
+        :returns => return_value
+      }
+      
+      @call_stack.last.update actual_information
+      
+      changed
+      notify_observers :return, self
+      
+      @call_stack.pop
+    end
+
+  end # class Backtracer
+end # module UML