code_node 0.1.2 → 0.1.3

data/cog/templates/code_node/generator.rb.erb

@@ -1,5 +1,5 @@
-<% if tool.explicit_require %>require '<%= tool.path %>'
-<% else %>require '<%= tool.name %>'
+<% if Cog.active_tool.explicit_require %>require '<%= Cog.active_tool.path %>'
+<% else %>require '<%= Cog.active_tool.name %>'
 <% end %>
 
 # Makes a graph of the project_source_path.

data/lib/code_node.rb

@@ -1,6 +1,7 @@
 $LOAD_PATH << File.join(File.dirname(__FILE__))
 require 'code_node/version'
 require 'code_node/dsl'
+require 'code_node/graph_builder'
 require 'code_node/ir'
 require 'code_node/sexp_walker'
 require 'cog'
@@ -13,57 +14,20 @@ module CodeNode
   
   # @param graph_name [String] name of the dot file to generate (without +.dot+ extension)
   # @option opt [Symbol] :ruby_version (:ruby19) either <tt>:ruby18</tt> or <tt>:ruby19</tt>, indicating which parser to use
-  # @yield [GraphDefinition] define rules for creating the graph
+  # @yieldparam graph [DSL::GraphDefiner] define rules for creating the graph
   def self.graph(graph_name, opt={}, &block)
-    feedback_color = :white
-    root = Cog.project_source_path
-    @graph = IR::Graph.new
-    graph_definer = DSL::GraphDefiner.new @graph
-    block.call graph_definer
-
-    rp = case opt[:ruby_version]
-    when :ruby18
+    parser = if opt[:ruby_version] == :ruby18
       Ruby18Parser.new
     else
       Ruby19Parser.new
     end
 
-    sexp = []
-    [:find_nodes, :find_relations].each_with_index do |mode, pass|
-      puts "#{(pass+1).ordinalize} pass: #{mode.to_s.gsub('_', ' ')}".color(feedback_color)
-      Dir.glob("#{root}/**/*.rb").each_with_index do |filename, i|
-        sexp[i] ||= begin
-          rp.parse(File.read filename)
-        rescue Racc::ParseError
-          STDERR.write "#{filename.relative_to_project_root}, skipped...\n".color(:yellow)
-          nil
-        end
-        if sexp[i]
-          walker = SexpWalker.new @graph, sexp[i], :mode => mode
-          walker.walk
-        end
-      end
-    end
-
-    # Apply styles before pruning because some relations may be destroyed while pruning
-    puts "Applying styles".color(feedback_color)
-    @graph.apply_styles
-
-    # Prune the graph according to ignore rules.
-    # We keep pruning until there are no more changes because some rules don't apply the first time (for example: &:island?)
-    puts "Pruning nodes".color(feedback_color)
-    i = 1
-    while (x = @graph.prune) > 0
-      puts "  #{x} nodes pruned on #{i.ordinalize} pass".color(feedback_color)
-      i += 1
-    end
-    
-    # Activate code_node while rendering templates
-    # so that cog will be able to find code_node templates
-    Cog.activate_tool 'code_node' do
-      stamp 'code_node/graph.dot', "#{graph_name}.dot"
-    end
-    
-    nil
+    GraphBuilder.new(graph_name, parser).
+      define(&block).
+      find_nodes.
+      find_relations.
+      finalize.
+      render
   end
+  
 end

data/lib/code_node/graph_builder.rb

@@ -0,0 +1,102 @@
+require 'cog'
+require 'code_node/ir/graph'
+
+module CodeNode
+  
+  # Helps to build an {IR::Graph}
+  class GraphBuilder
+    
+    # @return [IR::Graph] the graph being built
+    attr_reader :graph
+    
+    # @param name [String] the name of the graph
+    # @param parser [Ruby18Parser, Ruby19Parser] a ruby parser instance
+    def initialize(name, parser)
+      @name = name
+      @graph = IR::Graph.new
+      @parser = parser
+      @sexp = [] # array of file sexp, one per file
+    end
+    
+    # @return [Array<String>] paths to ruby source files
+    def sources
+      Dir.glob("#{Cog.project_source_path}/**/*.rb")
+    end
+    
+    # Define the custom graph generation rules
+    # @return [self]
+    def define(&block)
+      block.call DSL::GraphDefiner.new(@graph)
+      self
+    end
+    
+    # Search the sources for nodes
+    # @return [self]
+    def find_nodes
+      puts '1st pass: find nodes'
+      find :nodes
+      self
+    end
+    
+    # Search the sources for relations
+    # @return [nil]
+    def find_relations
+      puts '2nd pass: find relations'
+      find :relations
+      self
+    end
+
+    # Apply styles and prune the graph
+    # @return [nil]
+    def finalize
+      # Apply styles before pruning because some relations may be destroyed while pruning
+      puts "Applying styles"
+      @graph.apply_styles
+
+      # Prune the graph according to ignore rules.
+      # We keep pruning until there are no more changes because some rules don't apply the first time (for example: &:island?)
+      puts "Pruning nodes"
+      i = 1
+      while (x = @graph.prune) > 0
+        puts "  #{x} nodes pruned on #{i.ordinalize} pass"
+        i += 1
+      end
+      self
+    end
+
+    # Render the graph
+    # @return [nil]
+    def render
+      # Activate code_node while rendering templates
+      # so that cog will be able to find code_node templates
+      Cog.activate_tool 'code_node' do
+        stamp 'code_node/graph.dot', "#{@name}.dot"
+      end
+      nil
+    end
+    
+    private
+    
+    # @param type [Symbol] one of <tt>:nodes</tt> or <tt>:relations</tt>
+    # @return [nil]
+    def find(type)
+      sources.each_with_index do |filename, i|
+        @sexp[i] ||= parse filename
+        if @sexp[i]
+          walker = SexpWalker.new @graph, @sexp[i], :mode => "find_#{type}".to_sym
+          walker.walk
+        end
+      end
+      nil
+    end
+
+    # @param filename [String] path to the file to parse
+    # @return [Sexp]
+    def parse(filename)
+      @parser.parse(File.read filename)
+    rescue Racc::ParseError
+      STDERR.write "#{filename.relative_to_project_root}, skipped...\n".color(:yellow)
+      nil
+    end
+  end
+end

data/lib/code_node/ir/graph.rb

@@ -1,4 +1,6 @@
 require 'code_node/ir/node'
+require 'code_node/ir/graph/builder_methods'
+require 'code_node/ir/graph/template_methods'
 
 module CodeNode
   module IR
@@ -6,188 +8,6 @@ module CodeNode
     # A collection of {Node}s
     class Graph
 
-      # {Graph} methods which are useful in templates
-      module TemplateMethods
-        
-        # Iterate through each {Node} with {Node::QueryMethods#class?} in the graph
-        # @yieldparam node [Node::TemplateMethods] a class node. Does not yield ignored nodes.
-        # @return [nil]
-        def each_class(&block)
-          @nodes.values.select do |node|
-            node.class?
-          end.sort.each &block
-        end
-
-        # Iterate through each {Node} with {Node::QueryMethods#module?} in the graph
-        # @yieldparam node [Node::TemplateMethods] a module node. Does not yield ignored nodes.
-        # @return [nil]
-        def each_module(&block)
-          @nodes.values.select do |node|
-            node.module?
-          end.sort.each &block
-        end
-      
-        # Iterate through each containment relation in the graph
-        # @example
-        #   # a -> b (A contains B)
-        #   module A
-        #     module B
-        #     end
-        #   end
-        # @yieldparam a [Node::TemplateMethods] the container node
-        # @yieldparam b [Node::TemplateMethods] the contained node
-        # @return [nil]
-        def each_containment(&block)
-          @nodes.values.sort.each do |node|
-            if node.parent
-              block.call node.parent, node
-            end
-          end
-        end
-
-        # Iterate through each inheritance relation in the graph
-        # @example
-        #   # a -> b (A inherits from B)
-        #   class A < B
-        #   end
-        # @yieldparam a [Node::TemplateMethods] the derived class node
-        # @yieldparam b [Node::TemplateMethods] the super class node
-        # @return [nil]
-        def each_inheritance(&block)
-          @nodes.values.sort.each do |node|
-            if node.super_class_node
-              block.call node, node.super_class_node
-            end
-          end
-        end
-
-        # Iterate through each inclusion relation in the graph
-        # @example
-        #   # a -> b (A includes B)
-        #   module A
-        #     include B
-        #   end
-        # @yieldparam a [Node::TemplateMethods] the which includes
-        # @yieldparam b [Node::TemplateMethods] the included node
-        # @return [nil]
-        def each_inclusion(&block)
-          @nodes.values.sort.each do |node|
-            node.inclusions.each do |other|
-              block.call node, other
-            end
-          end
-        end
-
-        # Iterate through each extension relation in the graph
-        # @example
-        #   # a -> b (A extends B)
-        #   module A
-        #     extend B
-        #   end
-        # @yieldparam a [Node::TemplateMethods] the which extends
-        # @yieldparam b [Node::TemplateMethods] the extended node
-        # @return [nil]
-        def each_extension(&block)
-          @nodes.values.sort.each do |node|
-            node.extensions.each do |other|
-              block.call node, other
-            end
-          end
-        end
-        
-      end
-      
-      # {Graph} methods used during the graph building phase
-      # @api developer
-      module BuilderMethods
-
-        attr_reader :scope
-      
-        def apply_styles
-          @nodes.each_value do |node|
-            @style_matchers.each do |pair|
-              if pair[0].matches? node
-                node.style.update pair[1]
-              end
-            end
-          end
-        end
-        
-        # @return [FixNum] were any more nodes pruned?
-        def prune
-          prunees = []
-          @nodes.each_value do |node|
-            if @exclude_matchers.any? {|m| m.matches? node}
-              prunees << node
-            end
-          end
-          prunees.each do |node|
-            puts "  #{node.path}"
-            node.prune
-            @nodes.delete node.path
-          end
-          prunees.length
-        end
-        
-        # Find a node or create it and add it to the graph
-        # @api developer
-        # @param node_type [Symbol] either <tt>:module</tt> or <tt>:class</tt>
-        # @param s [Symbol, Sexp] either flat name, or a Sexp representing a color (<tt>:</tt>) separated path.
-        # @yieldparam node [Node]
-        # @return [Node]
-        def node_for(node_type, s, opt={}, &block)
-          name = if s.is_a? Symbol
-            s
-          elsif s[0] == :const
-            s[1]
-          elsif s[0] == :colon2
-            x = []
-            while s[0] == :colon2
-              x << s[2] ; s = s[1]
-            end
-            x << s[1]
-            x.reverse
-          elsif s[0] == :self
-            @scope.last.mark_as_singleton
-            nil
-          end
-          return if name.nil?
-    
-          node = if opt[:not_sure_if_nested]
-            candidate = if name.is_a?(Array)
-              parts = name.dup
-              n = !@scope.empty? && @scope.last.find(parts.shift)
-              while n && !parts.empty?
-                n = n.find parts.shift
-              end
-              n
-            else
-              !@scope.empty? && @scope.last.find(name)
-            end
-            candidate || Node.new(name, :node_type => node_type)
-          else
-            Node.new name, :parent => @scope.last, :node_type => node_type
-          end
-
-          node = self << node
-          unless block.nil? || node.nil?
-            @scope << node
-            block.call node
-            @scope.pop
-          end
-          node
-        end
-      
-        # Add the given node to the graph and return it. If a node with the same path is already in the graph, do not add it again, and return the original node.
-        # @param node [Node] a node to add to the graph
-        # @return [Node] the newly added node, or another node with the same path which was already in the graph
-        def <<(node)
-          @nodes[node.path] ||= node
-          @nodes[node.path]
-        end
-      
-      end
-      
       include BuilderMethods
       include TemplateMethods
       

data/lib/code_node/ir/graph/builder_methods.rb

@@ -0,0 +1,113 @@
+module CodeNode
+  module IR
+    class Graph
+
+      # {Graph} methods used during the graph building phase
+      # @api developer
+      module BuilderMethods
+
+        attr_reader :scope
+      
+        def apply_styles
+          @nodes.each_value do |node|
+            @style_matchers.each do |pair|
+              if pair[0].matches? node
+                node.style.update pair[1]
+              end
+            end
+          end
+        end
+        
+        # @return [FixNum] were any more nodes pruned?
+        def prune
+          prunees = []
+          @nodes.each_value do |node|
+            if @exclude_matchers.any? {|m| m.matches? node}
+              prunees << node
+            end
+          end
+          prunees.each do |node|
+            puts "  #{node.path}"
+            node.prune
+            @nodes.delete node.path
+          end
+          prunees.length
+        end
+        
+        # Find a node or create it and add it to the graph
+        # @api developer
+        # @param node_type [Symbol] either <tt>:module</tt> or <tt>:class</tt>
+        # @param s [Symbol, Sexp] either flat name, or a Sexp representing a color (<tt>:</tt>) separated path.
+        # @option opt [Boolean] :not_sure_if_nested (false)
+        # @yieldparam node [Node]
+        # @return [Node]
+        def node_for(node_type, s, opt={}, &block)
+          name = determine_name s
+          return if name.nil?
+    
+          node = if opt[:not_sure_if_nested]
+            search_for_node_in_parent(@scope.last, name) ||
+            Node.new(name, :node_type => node_type)
+          else
+            Node.new name, :parent => @scope.last, :node_type => node_type
+          end
+
+          node = add_or_find_duplicate node
+          unless block.nil?
+            @scope << node
+            block.call node
+            @scope.pop
+          end
+          node
+        end
+      
+        # Add the given node to the graph and return it. If a node with the same path is already in the graph, do not add it again, and return the original node.
+        # @param node [Node] a node to add to the graph
+        # @return [Node] the newly added node, or another node with the same path which was already in the graph
+        def add_or_find_duplicate(node)
+          @nodes[node.path] ||= node
+          @nodes[node.path]
+        end
+      
+        private
+        
+        # @param s [Sexp]
+        # @return [Symbol, Array<Symbol>, nil]
+        def determine_name(s)
+          name = if s.is_a? Symbol
+            s
+          elsif s[0] == :const
+            s[1]
+          elsif s[0] == :colon2
+            x = []
+            while s[0] == :colon2
+              x << s[2] ; s = s[1]
+            end
+            x << s[1]
+            x.reverse
+          elsif s[0] == :self
+            @scope.last.mark_as_singleton
+            nil
+          end
+        end
+        
+        # @param parent [Node, nil] the parent to search in
+        # @param name [Array<Symbol>, Symbol] name of the node to search for
+        # @return [Node, nil] the node, if found in the parent
+        def search_for_node_in_parent(parent, name)
+          if name.is_a?(Array)
+            parts = name.dup
+            n = parent && parent.find(parts.shift)
+            while n && !parts.empty?
+              n = n.find parts.shift
+            end
+            n
+          else
+            parent && parent.find(name)
+          end
+        end
+        
+      end
+    end
+  end
+end

data/lib/code_node/ir/graph/template_methods.rb

@@ -0,0 +1,97 @@
+module CodeNode
+  module IR
+    class Graph
+      
+      # {Graph} methods which are useful in templates
+      module TemplateMethods
+        
+        # Iterate through each {Node} with {Node::QueryMethods#class?} in the graph
+        # @yieldparam node [Node::TemplateMethods] a class node. Does not yield ignored nodes.
+        # @return [nil]
+        def each_class(&block)
+          @nodes.values.select do |node|
+            node.class?
+          end.sort.each &block
+        end
+
+        # Iterate through each {Node} with {Node::QueryMethods#module?} in the graph
+        # @yieldparam node [Node::TemplateMethods] a module node. Does not yield ignored nodes.
+        # @return [nil]
+        def each_module(&block)
+          @nodes.values.select do |node|
+            node.module?
+          end.sort.each &block
+        end
+      
+        # Iterate through each containment relation in the graph
+        # @example
+        #   # a -> b (A contains B)
+        #   module A
+        #     module B
+        #     end
+        #   end
+        # @yieldparam a [Node::TemplateMethods] the container node
+        # @yieldparam b [Node::TemplateMethods] the contained node
+        # @return [nil]
+        def each_containment(&block)
+          @nodes.values.sort.each do |node|
+            if node.parent
+              block.call node.parent, node
+            end
+          end
+        end
+
+        # Iterate through each inheritance relation in the graph
+        # @example
+        #   # a -> b (A inherits from B)
+        #   class A < B
+        #   end
+        # @yieldparam a [Node::TemplateMethods] the derived class node
+        # @yieldparam b [Node::TemplateMethods] the super class node
+        # @return [nil]
+        def each_inheritance(&block)
+          @nodes.values.sort.each do |node|
+            if node.super_class_node
+              block.call node, node.super_class_node
+            end
+          end
+        end
+
+        # Iterate through each inclusion relation in the graph
+        # @example
+        #   # a -> b (A includes B)
+        #   module A
+        #     include B
+        #   end
+        # @yieldparam a [Node::TemplateMethods] the which includes
+        # @yieldparam b [Node::TemplateMethods] the included node
+        # @return [nil]
+        def each_inclusion(&block)
+          @nodes.values.sort.each do |node|
+            node.inclusions.each do |other|
+              block.call node, other
+            end
+          end
+        end
+
+        # Iterate through each extension relation in the graph
+        # @example
+        #   # a -> b (A extends B)
+        #   module A
+        #     extend B
+        #   end
+        # @yieldparam a [Node::TemplateMethods] the which extends
+        # @yieldparam b [Node::TemplateMethods] the extended node
+        # @return [nil]
+        def each_extension(&block)
+          @nodes.values.sort.each do |node|
+            node.extensions.each do |other|
+              block.call node, other
+            end
+          end
+        end
+        
+      end
+    end
+  end
+end

data/lib/code_node/ir/node.rb

@@ -1,4 +1,7 @@
 require 'cog'
+require 'code_node/ir/node/builder_methods'
+require 'code_node/ir/node/template_methods'
+require 'code_node/ir/node/query_methods'
 
 module CodeNode
   module IR
@@ -8,210 +11,6 @@ module CodeNode
     class Node
 
       include Cog::Generator
-      
-      # Node methods which are useful in templates
-      module TemplateMethods
-        
-        # @return [String] the name of the node. Not necessarilly unique.
-        # @see {#path}
-        attr_reader :name
-
-        # @return [Node] node which contains this node
-        # @example
-        #   module Foo     # Foo is the parent
-        #     module Bar   # to Bar
-        #     end
-        #   end
-        attr_reader :parent
-
-        # The child nodes of this node
-        # @return [Hash<String,Node>] a mapping from node {#path} names to nodes
-        # @example
-        #   module Foo     # Foo has children
-        #     module Bar   # Bar
-        #     end          # and
-        #     class Car    # Car
-        #     end
-        #   end
-        attr_reader :children
-        
-        # @return [Node,nil] the super class of this class. Will be +nil+ for modules.
-        def super_class_node
-          @inherits_from
-        end
-        
-        # @return [Array<Node>] module nodes for which this node has an +include+ statement
-        def inclusions
-          @includes.values.sort
-        end
-      
-        # @return [Array<Node>] module nodes for which this node has an +extend+ statement
-        def extensions
-          @extends.values.sort
-        end
-        
-        # @return [String] fully qualified identifier for the node in the form <tt>Foo_Bar_Car</tt>. Ideal for graphviz identifiers.
-        def key
-          @path.join '_'
-        end
-        
-        # @return [String] how the node will be labelled in the graph. Nodes without parents display their full {#path}, while nodes with parents only display their {#name}.
-        def label
-          @parent.nil? ? path : name
-        end
-
-        # Stamp the accumulated GraphViz styles in a format suitable for inclusion in a <tt>.dot</tt> file
-        # @return [String] style in the form <tt>key1="value1" key2="value2"</tt>...
-        def stamp_styles
-          x = []
-          style.each_pair do |key, value|
-            x << "#{key}=\"#{value}\""
-          end
-          x.join ' '
-        end
-        
-      end
-      
-      # {Node} methods which are useful for querying in matchers
-      module QueryMethods
-
-        # @return [Boolean] does this node represent a module?
-        def module?
-          @node_type == :module
-        end
-
-        # @return [Boolean] does this node represent a class?
-        def class?
-          @node_type == :class
-        end
-        
-        # @return [String] fully qualified name of the node in the form <tt>'Foo::Bar::Car'</tt>. Not good as a graphviz identifier because of the colon (<tt>:</tt>) characters. Use {TemplateMethods#key} for graphviz identifiers instead.
-        def path
-          @path.join '::'
-        end
-        
-        # @param path [String] a class or module path in the form <tt>Foo::Bar::Car</tt>
-        # @return [Boolean] does this node include a {#module?} node with the given {#path}?
-        def includes?(path)
-          @includes.member? path
-        end
-
-        # @param path [String] a class or module path in the form <tt>Foo::Bar::Car</tt>
-        # @return [Boolean] does this node extend a {#module?} node with the given {#path}?
-        def extends?(path)
-          @extends.member? path
-        end
-
-        # @param path [String] a class or module path in the form <tt>Foo::Bar::Car</tt>
-        # @return [Boolean] does this node inherit from (directly or indirectly) a {#class?} node with the given {#path}? Note that a node inherits from itself according to this method. Recursively checks the ancestry of the node.
-        def inherits_from?(path)
-          # TODO: need process all nodes first, marking for deletion on the first pass, because the superclass gets deleting and then the inherits from relation breaks down
-          self.path == path || @inherits_from && @inherits_from.inherits_from?(path)
-        end
-      
-        # @return [Boolean] whether or not this node represents a singleton module. A singleton module is one which contains an <tt>extend self</tt> statement.
-        def singleton?
-          @singleton
-        end
-
-        # @return [Boolean] whether or not this node is an island. An island is a node with no connections to other nodes.
-        def island?
-          ([@parent, @inherits_from].all?(&:nil?) &&
-           [@children, @inherited_by, @extends, @includes, @extended_by, @included_by].all?(&:empty?))
-        end
-        
-      end
-      
-      # {Node} methods used during the graph building phase
-      # @api developer
-      module BuilderMethods
-        
-        attr_reader :style
-        
-        # Find a node contained in this node, or contained in this nodes {#parent}, recursively.
-        # @return [Node, nil]
-        def find(name)
-          path = (@path + [name].flatten).join '::'
-          @children[path] || (@parent && @parent.find(name))
-        end
-        
-        # Add other as a child of this node
-        # @param other [Node] another node
-        # @return [nil]
-        def contains(other)
-          this = self
-          @children[other.path] = other
-          other.instance_eval {@parent = this}
-          nil
-        end
-        
-        # Add other as the super class of this node
-        # @param other [Node] another node
-        # @return [nil]
-        def inherits_from(other)
-          this = self
-          @inherits_from = other
-          other.instance_eval {@inherited_by[this.path] = this}
-          nil
-        end
-
-        # Add other to this nodes includes set
-        # @param other [Node] another node
-        # @return [nil]
-        def includes(other)
-          this = self
-          @includes[other.path] = other
-          other.instance_eval {@included_by[this.path] = this}
-          nil
-        end
-      
-        # Add other to this nodes extends set
-        # @param other [Node] another node
-        # @return [nil]
-        def extends(other)
-          this = self
-          @extends[other.path] = other
-          other.instance_eval {@extended_by[this.path] = this}
-          nil
-        end
-        
-        # Mark this module node as a singleton
-        # @return [nil]
-        def mark_as_singleton
-          throw :NodeNotAModule unless module?
-          @singleton = true
-        end
-      
-        # Remove any relations involving this node
-        def prune
-          this = self
-          if @inherits_from
-            @inherits_from.instance_eval {@inherited_by.delete this.path}
-          end
-          @inherited_by.each_value do |other|
-            other.instance_eval {@inherits_from = nil}
-          end
-          if @parent
-            @parent.instance_eval {@children.delete this.path}
-          end
-          @children.each_value do |other|
-            other.instance_eval {@parent = nil}
-          end
-          @includes.each_value do |other|
-            other.instance_eval {@included_by.delete this.path}
-          end
-          @included_by.each_value do |other|
-            other.instance_eval {@includes.delete this.path}
-          end
-          @extends.each_value do |other|
-            other.instance_eval {@extended_by.delete this.path}
-          end
-          @extended_by.each_value do |other|
-            other.instance_eval {@extends.delete this.path}
-          end
-        end
-      end
-      
       include BuilderMethods
       include TemplateMethods
       include QueryMethods
@@ -231,14 +30,21 @@ module CodeNode
           parent_path + [name]
         end
         @name = @path.last
-        @parent = nil
-        @children = {}
-        @inherits_from = nil
-        @inherited_by = {}
-        @includes = {}
-        @included_by = {}
-        @extends = {}
-        @extended_by = {}
+        @inverse_relation = {} # :rel => :inv_rel
+        @edge = {} # :rel => { 'node::path' =>  }
+        define_relation :parent, :children
+        define_relation :inherits_from, :inherited_by
+        define_relation :includes, :included_by
+        define_relation :extends, :extended_by
+      end
+      
+      # @param rel [Symbol] the name of a relation
+      # @param inv [Symbol] the name of the inverse relation
+      def define_relation(rel, inv)
+        @inverse_relation[rel] = inv
+        @inverse_relation[inv] = rel
+        @edge[rel] = {}
+        @edge[inv] = {}
       end
       
       # @return [FixNum] order nodes by {#path}

data/lib/code_node/ir/node/builder_methods.rb

@@ -0,0 +1,83 @@
+module CodeNode
+  module IR
+    class Node
+
+      # {Node} methods used during the graph building phase
+      # @api developer
+      module BuilderMethods
+        
+        attr_reader :style
+        
+        # Find a node contained in this node, or contained in this nodes {#parent}, recursively.
+        # @return [Node, nil]
+        def find(name)
+          path = (@path + [name].flatten).join '::'
+          children[path] || (parent && parent.find(name))
+        end
+        
+        # Add other as a child of this node
+        # @param other [Node] another node
+        # @return [nil]
+        def contains(other)
+          add_edge :children, other
+        end
+        
+        # Add other as the super class of this node
+        # @param other [Node] another node
+        # @return [nil]
+        def inherits_from(other)
+          add_edge :inherits_from, other
+        end
+
+        # Add other to this nodes includes set
+        # @param other [Node] another node
+        # @return [nil]
+        def includes(other)
+          add_edge :includes, other
+        end
+      
+        # Add other to this nodes extends set
+        # @param other [Node] another node
+        # @return [nil]
+        def extends(other)
+          add_edge :extends, other
+        end
+        
+        # Add an edge between this node and another with the given relation type
+        # @param rel [Symbol] the type of relation
+        # @param other [Node] another node
+        # @return [nil]
+        def add_edge(rel, other)
+          this = self
+          inv = @inverse_relation[rel]
+          @edge[rel][other.path] = other
+          other.instance_eval do
+            @edge[inv][this.path] = this
+          end
+          nil
+        end
+        
+        # Mark this module node as a singleton
+        # @return [nil]
+        def mark_as_singleton
+          throw :NodeNotAModule unless module?
+          @singleton = true
+        end
+      
+        # Remove any relations involving this node
+        def prune
+          this = self
+          @edge.each_pair do |rel, edges|
+            inv = @inverse_relation[rel]
+            edges.each_value do |other|
+              other.instance_eval do
+                @edge[inv].delete this.path
+              end
+            end
+          end
+        end
+
+      end
+    end
+  end
+end

data/lib/code_node/ir/node/query_methods.rb

@@ -0,0 +1,55 @@
+module CodeNode
+  module IR
+    class Node
+      
+      # {Node} methods which are useful for querying in matchers
+      module QueryMethods
+
+        # @return [Boolean] does this node represent a module?
+        def module?
+          @node_type == :module
+        end
+
+        # @return [Boolean] does this node represent a class?
+        def class?
+          @node_type == :class
+        end
+        
+        # @return [String] fully qualified name of the node in the form <tt>'Foo::Bar::Car'</tt>. Not good as a graphviz identifier because of the colon (<tt>:</tt>) characters. Use {TemplateMethods#key} for graphviz identifiers instead.
+        def path
+          @path.join '::'
+        end
+        
+        # @param path [String] a class or module path in the form <tt>Foo::Bar::Car</tt>
+        # @return [Boolean] does this node include a {#module?} node with the given {#path}?
+        def includes?(path)
+          includes.member? path
+        end
+
+        # @param path [String] a class or module path in the form <tt>Foo::Bar::Car</tt>
+        # @return [Boolean] does this node extend a {#module?} node with the given {#path}?
+        def extends?(path)
+          extends.member? path
+        end
+
+        # @param path [String] a class or module path in the form <tt>Foo::Bar::Car</tt>
+        # @return [Boolean] does this node inherit from (directly or indirectly) a {#class?} node with the given {#path}? Note that a node inherits from itself according to this method. Recursively checks the ancestry of the node.
+        def inherits_from?(path)
+          # TODO: need process all nodes first, marking for deletion on the first pass, because the superclass gets deleting and then the inherits from relation breaks down
+          self.path == path || !@edge[:inherits_from].empty? && @edge[:inherits_from].values.first.inherits_from?(path)
+        end
+      
+        # @return [Boolean] whether or not this node represents a singleton module. A singleton module is one which contains an <tt>extend self</tt> statement.
+        def singleton?
+          @singleton
+        end
+
+        # @return [Boolean] whether or not this node is an island. An island is a node with no connections to other nodes.
+        def island?
+          @edge.values.all? &:empty?
+        end
+        
+      end
+    end
+  end
+end

data/lib/code_node/ir/node/template_methods.rb

@@ -0,0 +1,73 @@
+module CodeNode
+  module IR
+    class Node
+      
+      # Node methods which are useful in templates
+      module TemplateMethods
+        
+        # @return [String] the name of the node. Not necessarilly unique.
+        # @see {#path}
+        attr_reader :name
+
+        # @return [Node] node which contains this node
+        # @example
+        #   module Foo     # Foo is the parent
+        #     module Bar   # to Bar
+        #     end
+        #   end
+        def parent
+          @edge[:parent].values.first
+        end
+
+        # The child nodes of this node
+        # @return [Hash<String,Node>] a mapping from node {#path} names to nodes
+        # @example
+        #   module Foo     # Foo has children
+        #     module Bar   # Bar
+        #     end          # and
+        #     class Car    # Car
+        #     end
+        #   end
+        def children
+          @edge[:children]
+        end
+        
+        # @return [Node,nil] the super class of this class. Will be +nil+ for modules.
+        def super_class_node
+          @edge[:inherits_from].values.first
+        end
+        
+        # @return [Array<Node>] module nodes for which this node has an +include+ statement
+        def inclusions
+          @edge[:includes].values.sort
+        end
+      
+        # @return [Array<Node>] module nodes for which this node has an +extend+ statement
+        def extensions
+          @edge[:extends].values.sort
+        end
+        
+        # @return [String] fully qualified identifier for the node in the form <tt>Foo_Bar_Car</tt>. Ideal for graphviz identifiers.
+        def key
+          @path.join '_'
+        end
+        
+        # @return [String] how the node will be labelled in the graph. Nodes without parents display their full {#path}, while nodes with parents only display their {#name}.
+        def label
+          parent.nil? ? path : name
+        end
+
+        # Stamp the accumulated GraphViz styles in a format suitable for inclusion in a <tt>.dot</tt> file
+        # @return [String] style in the form <tt>key1="value1" key2="value2"</tt>...
+        def stamp_styles
+          x = []
+          style.each_pair do |key, value|
+            x << "#{key}=\"#{value}\""
+          end
+          x.join ' '
+        end
+        
+      end
+    end
+  end
+end

data/lib/code_node/sexp_walker.rb

@@ -23,39 +23,48 @@ module CodeNode
     def walk(s = nil)
       s ||= @root
       if [:module, :class].member?(s[0])
-        node = @graph.node_for(s[0], s[1]) do |node|
-          if find_relations? && s[0] == :class && !s[2].nil?
-            super_node = @graph.node_for :class, s[2], :not_sure_if_nested => true
-            node.inherits_from super_node unless super_node.nil?
-          end
-          rest = s[0] == :module ? s.slice(2..-1) : s.slice(3..-1)
-          rest.each do |c|
-            walk(c) if c.class == Sexp
-          end
-        end
-        unless @graph.scope.empty?
-          @graph.scope.last.contains node
-        end
+        add_node s
       elsif find_relations? && s[0] == :call && s.length >= 4 && [:extend, :include].member?(s[2]) && !@graph.scope.empty?
-        s.slice(3..-1).each do |mod_sexp|
-          node = @graph.node_for :module, mod_sexp, :not_sure_if_nested => true
-          unless node.nil?
-            if s[2] == :extend
-              @graph.scope.last.extends node
-            else
-              @graph.scope.last.includes node
-            end
-          end
-        end
+        add_relation s
       else
-        s.slice(1..-1).each do |c|
-          walk(c) if c.class == Sexp
-        end
+        walk_siblings s.slice(1..-1)
       end
     end
     
     private
     
+    def walk_siblings(s)
+      s.each do |c|
+        walk(c) if c.class == Sexp
+      end
+    end
+    
+    def add_node(s)
+      node = @graph.node_for(s[0], s[1]) do |node|
+        if find_relations? && s[0] == :class && !s[2].nil?
+          super_node = @graph.node_for :class, s[2], :not_sure_if_nested => true
+          node.inherits_from super_node unless super_node.nil?
+        end
+        walk_siblings s.slice((s[0] == :module ? 2 : 3)..-1)
+      end
+      unless @graph.scope.empty?
+        @graph.scope.last.contains node
+      end
+    end
+    
+    def add_relation(s)
+      s.slice(3..-1).each do |mod_sexp|
+        node = @graph.node_for :module, mod_sexp, :not_sure_if_nested => true
+        unless node.nil?
+          if s[2] == :extend
+            @graph.scope.last.extends node
+          else
+            @graph.scope.last.includes node
+          end
+        end
+      end
+    end
+    
     # @return [Boolean] whether or not the walker should look for relations
     def find_relations?
       @mode == :find_relations

data/lib/code_node/spec_helpers/dot_file.rb

@@ -59,27 +59,19 @@ module CodeNode
       end
       
       def has_containment?(path1, path2)
-        key1 = path1.to_s.split('::').join '_'
-        key2 = path2.to_s.split('::').join '_'
-        @edges[:containment].member?([key1, key2])
+        has_relation? :containment, path1, path2
       end
 
       def has_inheritance?(path1, path2)
-        key1 = path1.to_s.split('::').join '_'
-        key2 = path2.to_s.split('::').join '_'
-        @edges[:inheritance].member?([key1, key2])
+        has_relation? :inheritance, path1, path2
       end
 
       def has_inclusion?(path1, path2)
-        key1 = path1.to_s.split('::').join '_'
-        key2 = path2.to_s.split('::').join '_'
-        @edges[:inclusion].member?([key1, key2])
+        has_relation? :inclusion, path1, path2
       end
 
       def has_extension?(path1, path2)
-        key1 = path1.to_s.split('::').join '_'
-        key2 = path2.to_s.split('::').join '_'
-        @edges[:extension].member?([key1, key2])
+        has_relation? :extension, path1, path2
       end
       
       private
@@ -108,6 +100,12 @@ module CodeNode
         end
         @i += 1
       end
+      
+      def has_relation?(relation, path1, path2)
+        key1 = path1.to_s.split('::').join '_'
+        key2 = path2.to_s.split('::').join '_'
+        @edges[relation].member?([key1, key2])
+      end
     end
     
   end

data/lib/code_node/version.rb

@@ -1,5 +1,5 @@
 module Code_node 
   unless const_defined? :VERSION
-    VERSION = '0.1.2'
+    VERSION = '0.1.3'
   end
 end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: code_node
 version: !ruby/object:Gem::Version 
-  hash: 31
+  hash: 29
   prerelease: 
   segments: 
   - 0
   - 1
-  - 2
-  version: 0.1.2
+  - 3
+  version: 0.1.3
 platform: ruby
 authors: 
 - Kevin Tonon
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2012-12-16 00:00:00 Z
+date: 2012-12-17 00:00:00 Z
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: cog
@@ -117,7 +117,13 @@ files:
 - lib/code_node/cog_tool.rb
 - lib/code_node/dsl/graph_definer.rb
 - lib/code_node/dsl.rb
+- lib/code_node/graph_builder.rb
+- lib/code_node/ir/graph/builder_methods.rb
+- lib/code_node/ir/graph/template_methods.rb
 - lib/code_node/ir/graph.rb
+- lib/code_node/ir/node/builder_methods.rb
+- lib/code_node/ir/node/query_methods.rb
+- lib/code_node/ir/node/template_methods.rb
 - lib/code_node/ir/node.rb
 - lib/code_node/ir/node_matcher.rb
 - lib/code_node/ir.rb