code_node 0.0.2 → 0.1.0

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

@@ -2,11 +2,50 @@
 <% else %>require '<%= tool.name %>'
 <% end %>
 
-# Makes a graph of the project_source_path
+# Makes a graph of the project_source_path.
+# Nodes in the graph are clases and modules from your project.
 CodeNode.graph '<%= @name %>' do |g|
 
-  g.ignore /ClassMethods$/
-    
+  # Nodes
+  # =====
+
+  # Ignore nodes with no relations to other nodes
   g.ignore &:island?
+
+  # Uncomment and change the value to ignore a specific node
+  # g.ignore 'Foo::Bar::Car'
+  
+  # Uncomment to ignore nodes named ClassMethods
+  # g.ignore /::ClassMethods$/
+
+  # Uncomment and change the value to ignore all nodes descending
+  # from a specific node
+  # g.ignore {|node| node.inherits_from? 'Foo::Bar::Car'}
+  
+  # Apply styles common to all classes
+  g.style :shape => 'ellipse', :fillcolor => '#cccccc', :fontcolor => :black do |node|
+    node.class?
+  end
+
+  # Apply styles common to all nodes
+  g.style :shape => 'box', :fillcolor => '#333333', :fontcolor => :white do |node|
+    node.module?
+  end
+  
+  # Apply more specific style here
+  # ...
   
+  # Edges
+  # =====
+  #
+  # There is currently no way to style edges from the DSL.
+  # For now, there are only four categories of edges:
+  #  - containment
+  #  - inheritance
+  #  - inclusion
+  #  - extension
+  #
+  # They are style in the template. You can override the template
+  # and change the color if you like.
+  #   $ cog -t code_node template new -f code_node/graph.dot
 end

data/cog/templates/code_node/graph.dot.erb

@@ -4,13 +4,11 @@ graph [rankdir="LR"]
 node [style="filled"]
 
 /* Module nodes */
-node [shape="box" fillcolor="#333333" fontcolor="#ffffff"];
 <% @graph.each_module do |node| %>
 <%= node.stamp 'code_node/node.dot' %>
 <% end %>
 
 /* Class nodes */
-node [shape="ellipse" fillcolor="#cccccc" fontcolor="#000000"];
 <% @graph.each_class do |node| %>
 <%= node.stamp 'code_node/node.dot' %>
 <% end %>

data/cog/templates/code_node/node.dot.erb

@@ -1 +1 @@
-<%= key %> [label="<%= label %>"];
+<%= key %> [label="<%= label %>" <%= stamp_styles %>];

data/lib/code_node/dsl/graph_definer.rb

@@ -1,3 +1,5 @@
+require 'code_node/ir/node_matcher'
+
 module CodeNode
   module DSL
 
@@ -10,28 +12,73 @@ module CodeNode
         @graph = graph
       end
       
-      # Speficy an ignore rule for the graph.
-      # Nodes matching the ignore rule will not be included in the graph.
-      # Ignore rules can be given in one of three ways.
+      # Specify an ignore rule for the graph.
+      # Nodes matching the ignore rule will not be included in the graph. Ignore rules can be given in one of three ways,
       #
-      # * +String+ provide a fully qualified path
-      # * +Regexp+ provide a pattern that will be tested against the {IR::Node#path}
+      # * +String+ provide a fully qualified path which will have to match {IR::Node::QueryMethods#path} exactly
+      # * +Regexp+ provide a pattern that will be tested against the {IR::Node::QueryMethods#path}
       # * +Proc+ provide a block. If the block returns +true+ the node will be ignored
       #
-      # @param name [String, Regexp, nil] fully qualified path or regular expression which will be compared to {IR::Node#path}
-      # @yield [Node] if provided, return +true+ to ignore the node
+      # @example
+      #   CodeNode.graph 'my_graph' do |g|
+      #
+      #     # Using a full path
+      #     g.ignore 'Foo::Bar::Car'
+      #
+      #     # Using a regular expression
+      #     g.ignore /ClassMethods$/
+      #
+      #     # Using a block
+      #     g.ignore do |node|
+      #       node.inherits_from? 'Exception'
+      #     end
+      #   end
+      #
+      # @param name [String, Regexp, nil] fully qualified path or regular expression which will be compared to {IR::Node::QueryMethods#path}
+      # @yieldparam node [IR::Node::QueryMethods] if provided, return +true+ to ignore the node
       # @return [nil]
       def ignore(name=nil, &block)
         if (name.nil? && block.nil?) || (name && block)
           raise ArgumentError.new('Provide either a name or a block') 
         end
-        if block
-          @graph.instance_eval {@exclude_procs << block}
-        elsif name.is_a? Regexp
-          @graph.instance_eval {@exclude_patterns << name}
-        else
-          @graph.instance_eval {@exclude_paths << name}
+        matcher = IR::NodeMatcher.new name || block
+        @graph.instance_eval {@exclude_matchers << matcher}
+        nil
+      end
+      
+      # Specify a rule for styling nodes.
+      # Nodes matching the given rule will have the provided style attributes applied. Rules can be given in one of three ways,
+      #
+      # * +String+ provide a fully qualified path which will have to match {IR::Node::QueryMethods#path} exactly
+      # * +Regexp+ provide a pattern that will be tested against the {IR::Node::QueryMethods#path}
+      # * +Proc+ provide a block
+      #
+      # @example
+      #   CodeNode.graph 'my_graph' do |g|
+      #
+      #     # Using a full path
+      #     g.style 'Foo::Bar::Car', :shape => 'box'
+      #
+      #     # Using a regular expression
+      #     g.style /ClassMethods$/, :fillcolor => '#336699'
+      #
+      #     # Using a block
+      #     g.style :penwidth => 3 do |node|
+      #       node.extends? 'ActiveSupport::Concern'
+      #     end
+      #   end
+      #
+      # @param name [String, Regexp, nil] fully qualified path or regular expression which will be compared to {IR::Node::QueryMethods#path}
+      # @param style [Hash] a set of attributes and values to apply to matching nodes. For a full list of applicable to GraphViz nodes: http://www.graphviz.org/content/attrs
+      # @yieldparam node [IR::Node::QueryMethods] if provided, return +true+ to indicate a match
+      # @return [nil]
+      def style(name=nil, style={}, &block)
+        style, name = name, nil if name.is_a?(Hash)
+        if (name.nil? && block.nil?) || (name && block)
+          raise ArgumentError.new('Provide either a name or a block') 
         end
+        matcher = IR::NodeMatcher.new name || block
+        @graph.instance_eval {@style_matchers << [matcher, style]}
         nil
       end
     end

data/lib/code_node/ir/graph.rb

@@ -3,129 +3,196 @@ require 'code_node/ir/node'
 module CodeNode
   module IR
 
+    # A collection of {Node}s
     class Graph
 
-      # @api developer
-      attr_reader :scope
+      # {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
       
-      # @api developer
-      def initialize
-        @exclude_paths = []
-        @exclude_patterns = []
-        @exclude_procs = []
-        @nodes = {}
-        @scope = []
-      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
 
-      # @api developer
-      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]
+        # 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
-          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]
-          if @scope.length > 1 && @scope[-2].find(name)
-            @scope[-2].find name
-          else
-            Node.new name, :node_type => node_type
+
+        # 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
-        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
+        # 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
-        node
-      end
-  
-      def <<(node)
-        @nodes[node.path] ||= node
-        @nodes[node.path]
+        
       end
       
-      # Iterate through each {Node} with {Node#class?} in the graph
-      # @yield [Node] a class node. Does not yield ignored nodes.
-      # @return [nil]
-      def each_class(&block)
-        @nodes.values.select do |node|
-          node.class? && !should_exclude?(node)
-        end.sort.each &block
-      end
+      # {Graph} methods used during the graph building phase
+      # @api developer
+      module BuilderMethods
 
-      # Iterate through each {Node} with {Node#module?} in the graph
-      # @yield [Node] a module node. Does not yield ignored nodes.
-      # @return [nil]
-      def each_module(&block)
-        @nodes.values.select do |node|
-          node.module? && !should_exclude?(node)
-        end.sort.each &block
-      end
+        attr_reader :scope
       
-      # Iterate through each containment relation in the graph
-      def each_containment(&block)
-        @nodes.values.sort.each do |node|
-          if node.parent && !should_exclude?(node) && !should_exclude?(node.parent)
-            block.call node.parent, node
+        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
-      end
-
-      # Iterate through each inheritance relation in the graph
-      def each_inheritance(&block)
-        @nodes.values.sort.each do |node|
-          if node.super_class_node && !should_exclude?(node) && !should_exclude?(node.super_class_node)
-            block.call node, node.super_class_node
+        
+        # @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
-      end
-
-      # Iterate through each inclusion relation in the graph
-      def each_inclusion(&block)
-        @nodes.values.sort.each do |node|
-          node.inclusions.each do |other|
-            if !should_exclude?(node) && !should_exclude?(other)
-              block.call node, other
+        
+        # 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
-        end
-      end
-
-      # Iterate through each extension relation in the graph
-      def each_extension(&block)
-        @nodes.values.sort.each do |node|
-          node.extensions.each do |other|
-            if !should_exclude?(node) && !should_exclude?(other)
-              block.call node, other
+          return if name.nil?
+    
+          node = if opt[:not_sure_if_nested]
+            if @scope.length > 1 && @scope[-2].find(name)
+              @scope[-2].find name
+            else
+              Node.new name, :node_type => node_type
             end
+          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
-
-      private
       
-      def should_exclude?(node)
-        @exclude_paths.any? {|path| path == node.path} ||
-        @exclude_patterns.any? {|pattern| pattern =~ node.path} ||
-        @exclude_procs.any? {|block| block.call(node)}
+      include BuilderMethods
+      include TemplateMethods
+      
+      # @api developer
+      def initialize
+        @exclude_matchers = []
+        @style_matchers = []
+        @nodes = {}
+        @scope = []
       end
+
     end
-    
   end  
 end

data/lib/code_node/ir/node.rb

@@ -9,44 +9,230 @@ module CodeNode
 
       include Cog::Generator
       
-      # @return [String] the name of the node. Not necessarilly unique.
-      # @see {#path}
-      attr_reader :name
+      # 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 [Node] node which contains this node
-      # @example
-      #   module Foo     # Foo is the parent
-      #     module Bar   # to Bar
-      #     end
-      #   end
-      attr_reader :parent
+        # @return [Boolean] does this node represent a module?
+        def module?
+          @node_type == :module
+        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
-      attr_reader :children
+        # @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)
+          self.path == path || @inherits_from && (@inherits_from.path == path || @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
+      
+      # Initialize a node
+      # @api developer
       # @param name [String, Array]
-      # @option opt [Node] :parent (nil)
+      # @option opt [Node] :parent (nil) if provided, the parent's path is prepended to name. The parent child is not made at this time though. See {BuilderMethods#contains} instead.
       # @option opt [Symbol] :node_type (:module) either <tt>:module</tt> or <tt>:class</tt>
       def initialize(name, opt={})
+        @style = {}
         @node_type = opt[:node_type] || :module
-        @parent = opt[:parent]
-        parent_path = @parent ? @parent.instance_eval {@path} : []
+        parent_path = opt[:parent] ? opt[:parent].instance_eval {@path} : []
         @path = if name.is_a? Array
           parent_path + name
         else
           parent_path + [name]
         end
         @name = @path.last
-        @parent.children[path] = self unless @parent.nil?
+        @parent = nil
         @children = {}
+        @inherits_from = nil
         @inherited_by = {}
         @includes = {}
         @included_by = {}
@@ -54,109 +240,11 @@ module CodeNode
         @extended_by = {}
       end
       
-      def find(name)
-        path = (@path + [name].flatten).join '::'
-        @children[path] || (@parent && @parent.find(name))
-      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] fully qualified name of the node in the form <tt>'Foo::Bar::Car'</tt>. Not good as a graphviz identifier because of the colon (+:+) characters. Use {#key} for graphviz identifiers instead.
-      def path
-        @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
-
       # @return [FixNum] order nodes by {#path}
       def <=>(other)
         path <=> other.path
       end
 
-      # @return [Boolean] whether or not this node represents a module
-      def module?
-        @node_type == :module
-      end
-
-      # @return [Boolean] whether or not this node represents a class
-      def class?
-        @node_type == :class
-      end
-
-      # @param other [Node]
-      def inherits_from(other)
-        this = self
-        @inherits_from = other
-        other.instance_eval {@inherited_by[this.path] = this}
-      end
-
-      # @return [Node,nil] the super class of this class. Will be +nil+ for modules.
-      def super_class_node
-        @inherits_from
-      end
-
-      # @param other [Node]
-      def includes(other)
-        this = self
-        @includes[other.path] = other
-        other.instance_eval {@included_by[this.path] = this}
-      end
-      
-      # @return [Array<Node>] module nodes for which this node has an +include+ statement
-      def inclusions
-        @includes.values.sort
-      end
-
-      # @param other [Node]
-      def extends(other)
-        this = self
-        @extends[other.path] = other
-        other.instance_eval {@extended_by[this.path] = this}
-      end
-
-      # @return [Array<Node>] module nodes for which this node has an +extend+ statement
-      def extensions
-        @extends.values.sort
-      end
-      
-      # Set the given class node as the super class of this node
-      # @param super_node [Node] a {#class?} node
-      # @return [nil]
-      def inherits_from=(super_node)
-        throw :NodeNotAClass unless class?
-        throw :SuperNodeNotAClass unless super_node.class?
-        @inherits_from = super_node
-      end
-      
-      # @return [Boolean] whether or not this node inherits from a given node. Note that a node does inherit from itself, according to this method. Recursively checks the ancestry of the node.
-      def inherits_from?(k)
-        key == k || @inherits_from && (@inherits_from.key == k || @inherits_from.inherits_from?(k))
-      end
-            
-      # Mark this module node as a singleton
-      # @return [nil]
-      def mark_as_singleton
-        throw :NodeNotAModule unless module?
-        @singleton = true
-      end
-      
-      # @return [Boolean] whether or not this node represents a singleton module
-      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
   end
 end

data/lib/code_node/ir/node_matcher.rb

@@ -0,0 +1,26 @@
+module CodeNode
+  module IR
+    
+    # @api developer
+    # Encapsulates a pattern match test for nodes
+    class NodeMatcher
+      
+      def initialize(pattern)
+        @pattern = pattern
+      end
+      
+      # @param node [Node]
+      # @return [Boolean] does the node match?
+      def matches?(node)
+        if @pattern.is_a? Proc
+          @pattern.call node
+        elsif @pattern.is_a? Regexp
+          @pattern =~ node.path
+        else
+          @pattern.to_s == node.path
+        end
+      end
+
+    end
+  end
+end

data/lib/code_node/sexp_walker.rb

@@ -1,5 +1,6 @@
 module CodeNode
   
+  # @api developer
   # Walks a Sexp representing a ruby file looking for classes and modules.
   class SexpWalker
     
@@ -7,7 +8,7 @@ module CodeNode
     #
     # All files in a code base should be walked once in <tt>:find_nodes</tt> mode, and then walked again in <tt>:find_relations</tt> mode.
     #
-    # @param graph [Graph] a graph to which nodes and relations will be added
+    # @param graph [IR::Graph] a graph to which nodes and relations will be added
     # @param sexp [Sexp] the root sexp of a ruby file
     # @option opt [Symbol] :mode (:find_nodes) one of <tt>:find_nodes</tt> or <tt>:find_relations</tt>
     def initialize(graph, sexp, opt={})
@@ -22,7 +23,7 @@ module CodeNode
     def walk(s = nil)
       s ||= @root
       if [:module, :class].member?(s[0])
-        @graph.node_for(s[0], s[1]) do |node|
+        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?
@@ -32,6 +33,9 @@ module CodeNode
             walk(c) if c.class == Sexp
           end
         end
+        if find_relations? && !@graph.scope.empty?
+          @graph.scope.last.contains node
+        end
       elsif find_relations? && s[0] == :call && s.length >= 4 && [:extend, :include].member?(s[2]) && !@graph.scope.empty?
         node = @graph.node_for :module, s[3], :not_sure_if_nested => true
         unless node.nil?

data/lib/code_node/version.rb

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

data/lib/code_node.rb

@@ -15,6 +15,7 @@ module CodeNode
   # @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
   def self.graph(graph_name, opt={}, &block)
+    feedback_color = :white
     root = Cog::Config.instance.project_source_path
     @graph = IR::Graph.new
     graph_definer = DSL::GraphDefiner.new @graph
@@ -29,13 +30,12 @@ module CodeNode
 
     sexp = []
     [:find_nodes, :find_relations].each_with_index do |mode, pass|
-      puts "#{(pass+1).ordinalize} pass: #{mode.to_s.gsub('_', ' ')}".color(:cyan)
-      
+      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(:red)
+          STDERR.write "#{filename.relative_to_project_root}, skipped...\n".color(:yellow)
           nil
         end
         if sexp[i]
@@ -44,6 +44,19 @@ module CodeNode
         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

metadata

@@ -5,9 +5,9 @@ version: !ruby/object:Gem::Version
   prerelease: 
   segments: 
   - 0
+  - 1
   - 0
-  - 2
-  version: 0.0.2
+  version: 0.1.0
 platform: ruby
 authors: 
 - Kevin Tonon
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2012-11-19 00:00:00 Z
+date: 2012-11-20 00:00:00 Z
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: cog
@@ -119,6 +119,7 @@ files:
 - lib/code_node/dsl.rb
 - lib/code_node/ir/graph.rb
 - lib/code_node/ir/node.rb
+- lib/code_node/ir/node_matcher.rb
 - lib/code_node/ir.rb
 - lib/code_node/sexp_walker.rb
 - lib/code_node/version.rb