rbgccxml 0.9.1 → 1.0

data/Rakefile

@@ -1,17 +1,18 @@
-require 'rake/testtask'
 require 'rake/rdoctask'
 require 'rake/contrib/sshpublisher'
 require 'rake/gempackagetask'
 
+require 'rspec/core/rake_task'
+
 PROJECT_NAME = "rbgccxml"
-RBGCCXML_VERSION = "0.9.1"
+RBGCCXML_VERSION = "1.0"
 
-task :default => :test
+task :default => :spec
 
-Rake::TestTask.new do |t|
-  t.libs = ["lib", "test"]
-  t.test_files = FileList["test/*_test.rb"]
-  t.verbose = true
+desc "Run all specs"
+RSpec::Core::RakeTask.new do |t|
+  t.ruby_opts = ["-Itest"]
+  t.pattern = "test/**/*.rb"
 end
 
 Rake::RDocTask.new do |rd|
@@ -58,9 +59,6 @@ spec = Gem::Specification.new do |s|
   s.add_dependency "nokogiri", "~> 1.4.0"
   s.add_dependency "gccxml_gem", "~> 0.9"
 
-  s.add_development_dependency "test-unit", "1.2.3"
-  s.add_development_dependency "mocha", "~> 0.9"
-
   s.description = <<-END
 Rbgccxml is a library that parses out GCCXML (http://www.gccxml.org) output
 and provides a simple but very powerful querying API for finding exactly

data/lib/rbgccxml/node.rb

@@ -13,61 +13,79 @@ module RbGCCXML
   # attempt to will throw a NotQueryableException.
   class Node 
 
-    # The underlying xml node for this Node.
-    attr_reader :node
+    # GCC_XML id of this node
+    attr_accessor :id
 
-    # Initialize this node according to the XML element passed in
+    # The C++ scoping parent of this node
+    attr_accessor :parent
+
+    # Any children this node has
+    attr_accessor :children
+
+    # The base name of this node
+    attr_accessor :name
+
+    # Hash of all the attributes
+    attr_accessor :attributes
+
+    # HACK A linking ivar that lets types figure out where they sit,
+    # for example an argument type can find the <Argument> it's
+    # a part of.
+    attr_accessor :container
+
+    # Initialize this node according to the attributes passed in
     # Only to be used internally. Use query methods on the object
     # returned by RbGCCXML::parse
-    def initialize(node)
-      @node = node
-    end
-    protected :initialize
+    def initialize(attributes)
+      @id = attributes["id"]
+      @name = attributes["name"]
+      @demangled = attributes["demangled"]
 
-    # Get the C++ name of this node
-    def name
-      @node['name']
+      @attributes = attributes
+
+      @children = []
     end
     
     # Get the fully qualified (demangled) C++ name of this node.
     def qualified_name
-      if @node["demangled"]
+      if @demangled
         # The 'demangled' attribute of the node for methods / functions is the 
         # full signature, so cut that part out.
-        @node["demangled"].split(/\(/)[0]
+        @demangled.split(/\(/)[0]
       else
-        parent ? "#{parent.qualified_name}::#{name}" : name
+        @parent ? "#{@parent.qualified_name}::#{@name}" : @name
       end
     end
+    once :qualified_name
 
     # Is this node const qualified?
     def const?
-      @node["const"] ? @node["const"] == "1" : false
+      @attributes["const"] ? @attributes["const"] == "1" : false
     end
 
     # Does this node have public access?
     def public?
-     @node["access"] ? @node["access"] == "public" : true
+     @attributes["access"] ? @attributes["access"] == "public" : true
     end
 
     # Does this node have protected access?
     def protected?
-     @node["access"] ? @node["access"] == "protected" : false
+     @attributes["access"] ? @attributes["access"] == "protected" : false
     end
 
     # Does this node have private access?
     def private?
-     @node["access"] ? @node["access"] == "private" : false
+     @attributes["access"] ? @attributes["access"] == "private" : false
     end
 
-    # Access to the underlying xml node's attributes.
-    def attributes
-      @node
+    # Is this node automatically generated by gcc?
+    def artificial?
+      @attributes["artificial"] ? @attributes["artificial"] == "1" : false
     end
 
     # Access indivitual attributes directly
     def [](val)
-      @node[val]
+      @attributes[val]
     end
 
     # Some C++ nodes are actually wrappers around other nodes. For example, 
@@ -83,90 +101,68 @@ module RbGCCXML
     # Returns the full path to the file this node is found in.
     # Returns nil if no File node is found for this node
     def file
-      file_id = @node["file"]
-      file_node = XMLParsing.find(:node_type => "File", :id => file_id) if file_id
-      file_node ? file_node.attributes["name"] : nil
-    end
-
-    # Returns the parent node of this node. e.g. function.parent will get the class
-    # the function is contained in.
-    def parent
-      return nil if @node["context"].nil? || @node["context"] == "_1"
-      XMLParsing.find(:id => @node["context"])
+      file_id = @attributes["file"]
+      file_node = NodeCache.find(file_id)
+      file_node ? file_node.name : nil
     end
+    once :file
 
     # This is a unified search routine for finding nested nodes. It
     # simplifies the search routines below significantly.
-    def find_nested_nodes_of_type(type, matcher = nil, &block)
-      res = XMLParsing.find_nested_nodes_of_type(@node, type)
-
-      case matcher
-      when String
-        res = res.find(:name => matcher)
-      when Regexp
-        res = res.find_all { |t| t.name =~ matcher }
-      when nil
-        # Do nothing, since not specifying a matcher is okay.
-      else
-        message = "Can't handle a match condition of type #{matcher.class}."
-        raise UnsupportedMatcherException.new(message)
-      end
-
-      res = res.find_all(&block) if block
-
-      res
+    def find_children_of_type(type, matcher = nil)
+      NodeCache.find_children_of_type(self, type, matcher)
     end
-    private :find_nested_nodes_of_type
+    private :find_children_of_type
 
     # Find all namespaces. There are two ways of calling this method:
     #   #namespaces  => Get all namespaces in this scope
     #   #namespaces(name) => Shortcut for namespaces.find(:name => name)
     #
     # Returns a QueryResult unless only one node was found
-    def namespaces(name = nil, &block)
-      find_nested_nodes_of_type("Namespace", name, &block)
+    def namespaces(name = nil)
+      find_children_of_type("Namespace", name)
     end
 
     # Find all classes in this scope. 
     #
     # See Node.namespaces
-    def classes(name = nil, &block)
-      find_nested_nodes_of_type("Class", name, &block)
+    def classes(name = nil)
+      find_children_of_type("Class", name)
     end
 
     # Find all structs in this scope. 
     #
     # See Node.namespaces
-    def structs(name = nil, &block)
-      find_nested_nodes_of_type("Struct", name, &block)
+    def structs(name = nil)
+      find_children_of_type("Struct", name)
     end
 
     # Find all functions in this scope. 
     #
     # See Node.namespaces
-    def functions(name = nil, &block)
-      find_nested_nodes_of_type("Function", name, &block)
+    def functions(name = nil)
+      find_children_of_type("Function", name)
     end
 
     # Find all enumerations in this scope. 
     #
     # See Node.namespaces
-    def enumerations(name = nil, &block)
-      find_nested_nodes_of_type("Enumeration", name, &block)
+    def enumerations(name = nil)
+      find_children_of_type("Enumeration", name)
     end
     
     # Find all variables in this scope
     #
     # See Node.namespaces
-    def variables(name = nil, &block)
-      find_nested_nodes_of_type("Variable", name, &block)
+    def variables(name = nil)
+      find_children_of_type("Variable", name)
     end
 
     # Find all typedefs in this scope
     #
     # See Node.namespaces
-    def typedefs(name = nil, &block)
-      find_nested_nodes_of_type("Typedef", name, &block)
+    def typedefs(name = nil)
+      find_children_of_type("Typedef", name)
     end
 
     # Print out the full C++ valid code for this node.
@@ -175,6 +171,11 @@ module RbGCCXML
     def to_cpp(qualified = true)
       qualified ? self.qualified_name : self.name
     end
+
+    def to_s
+      "#<#{self.class.name} @attributes=#{self.attributes.inspect}>"
+    end
+    alias :inspect :to_s
   end
 
 end

data/lib/rbgccxml/node_cache.rb

@@ -0,0 +1,93 @@
+module RbGCCXML
+
+  # Manager of the tree of Nodes we build from GCC-XML.
+  #
+  # This is a static class that keeps around references to the
+  # entire generated Node tree as well as other structures
+  # designed for quick and easy searching of Nodes
+  class NodeCache
+    class << self
+
+      # Hash of id => node for all nodes
+      attr_reader :index_list
+
+      # Hash of Type => [node list] for easy
+      # searching of all nodes of a given type
+      attr_reader :types_list
+
+      # Add a new node to the index list
+      def <<(node)
+        @index_list ||= {}
+        @types_list ||= {}
+
+        @index_list[node.id] = node
+
+        class_name = node.class.name.split("::")[-1]
+        @types_list[class_name] ||= []
+        @types_list[class_name] << node
+      end
+
+      def clear
+        @index_list = {}
+        @types_list = {}
+      end
+
+      # Get the root node of the parse
+      def root
+        # This is simply a way to hide GCC_XML specifics,
+        # the :: Namespace node is always id _1
+        @index_list["_1"]
+      end
+
+      # Given an id, find the node
+      def find(id)
+        @index_list[id]
+      end
+
+      # Get the list of all nodes of a given type
+      def all(type)
+        @types_list[type] || []
+      end
+
+      # Given an array of ids return an array of nodes that match
+      def find_by_ids(ids)
+        QueryResult.new(ids.map {|id| @index_list[id] })
+      end
+
+      # Look through the DOM under +node+ for +type+ nodes.
+      # +type+ must be the string name of an existing Node subclass.
+      #
+      # Returns a QueryResult with the findings.
+      def find_children_of_type(node, type, matcher = nil)
+        results = QueryResult.new(self.select_nodes_of_type(node.children, type))
+        results = results.find(:name => matcher) if matcher
+        results
+      end
+
+      # Once all parsing is done and all nodes are in memory
+      # we need to actually build up the parent / child relationships
+      # of the nodes. We can't do this during parsing because there
+      # is no guarentee the nodes will come in the right order
+      def process_tree
+        @index_list.each do |id, node|
+
+          # If this node has a context, link to that context as a parent
+          # and then put ourselves as that parent's child
+          if node["context"]
+            node.parent = @index_list[node["context"]]
+            node.parent.children << node
+          end
+
+        end
+      end
+
+      protected
+
+      def select_nodes_of_type(nodes, type)
+        nodes.select {|node| node.class.to_s == "RbGCCXML::#{type}" }
+      end
+
+    end
+  end
+
+end

data/lib/rbgccxml/nodes/argument.rb

@@ -5,7 +5,9 @@ module RbGCCXML
 
     # Get the Node for this argument's type
     def cpp_type
-      XMLParsing.find_type_of(node, "type")
+      type = NodeCache.find(attributes["type"])
+      type.container = self
+      type
     end
 
     # Get any default value for this argument
@@ -17,6 +19,7 @@ module RbGCCXML
     def to_cpp(qualified = true)
       "#{self.cpp_type.to_cpp(qualified)} #{self.name}"
     end
+    once :to_cpp
 
   end
 end

data/lib/rbgccxml/nodes/base.rb

@@ -7,7 +7,7 @@ module RbGCCXML
 
     # Get the Class node representing the type of this Base
     def cpp_type
-      XMLParsing.find_type_of(node, "type")
+      NodeCache.find(attributes["type"])
     end
 
   end

data/lib/rbgccxml/nodes/class.rb

@@ -1,7 +1,7 @@
 module RbGCCXML
   # Represents a <Class> node.
   class Class < Node
-    
+
     # Disabled: Classes cannot have nested namespaces
     def namespaces(name = nil)
       raise NotQueryableException.new("Cannot query for Namespaces while in a Class")
@@ -9,30 +9,32 @@ module RbGCCXML
 
     # Is this class pure virtual?
     def pure_virtual?
-      @node["abstract"] ? @node["abstract"] == "1" : false
+      attributes["abstract"] ? attributes["abstract"] == "1" : false
     end
 
-    # Find all the constructors for this class. 
+    # Find all the constructors for this class.
     def constructors
-      XMLParsing::find_nested_nodes_of_type(@node, "Constructor")
+      NodeCache.find_children_of_type(self, "Constructor")
     end
 
     # Find the destructor for this class.
     # To tell if a destructor is gcc-generated or not, check the
     # 'artificial' attribute:
     #
-    #   class_node.destructor.attributes[:artificial]
+    #   class_node.destructor.artificial?
     #
     def destructor
-      XMLParsing::find_nested_nodes_of_type(@node, "Destructor")[0]
+      NodeCache.find_children_of_type(self, "Destructor")[0]
     end
 
-    # Find the superclass for this class. 
+    # Find the superclass for this class.
     # By default, this will find the superclass of any access type, pass in
-    # the type of access you're looking for if you want specific types (e.g. public, private, protected).
+    # the type of access you're looking for if you want specific types
+    # (e.g. public, private, protected).
     #
-    # If there is more than one superclass to this class, this method will only return the first superclass.
-    # If you know or expect there to be multiple superclasses, use #superclasses instead
+    # If there is more than one superclass to this class, this method will only return
+    # the first superclass.  # If you know or expect there to be multiple superclasses,
+    # use #superclasses instead
     def superclass(access_type = nil)
       found = superclasses(access_type)
       found.empty? ? nil : found[0]
@@ -41,22 +43,27 @@ module RbGCCXML
     # Like #superclass above, this will find all superclasses for this class.
     # Functions the same as #superclass except this method always returns a QueryResult
     def superclasses(access_type = nil)
-      XMLParsing::find_bases_for(@node, access_type)
+      [
+        NodeCache.find_children_of_type(self, "Base").select do |base|
+          access_type.nil? ? true : base.send("#{access_type}?")
+        end
+      ].flatten.map {|base| base.cpp_type }
     end
 
     # Find all methods for this class. See Node#namespaces
-    def methods(name = nil, &block)
-      find_nested_nodes_of_type("Method", name, &block)
+    def methods(name = nil)
+      NodeCache.find_children_of_type(self, "Method", name)
     end
 
     # Find all instance variables for this class. See Node#namespaces
     def variables(name = nil, &block)
-      find_nested_nodes_of_type("Field", name, &block)
+      NodeCache.find_children_of_type(self, "Field", name)
     end
 
     # Find all constants under this class. See Node#namespaces
     def constants(name = nil, &block)
-      find_nested_nodes_of_type("Variable", name, &block)
+      NodeCache.find_children_of_type(self, "Variable", name)
     end
+
   end
 end

data/lib/rbgccxml/nodes/enum_value.rb

@@ -3,12 +3,9 @@ module RbGCCXML
   # Represents an <EnumValue> node, which is an entry in an <Enumeration>
   class EnumValue < Node
 
-    # Link to the Enumeration that holds this EnumValue
-    attr_accessor :parent
-
     # Get the defined value of this EnumValue
     def value
-      node["init"].to_i
+      attributes["init"].to_i
     end
 
     # The qualified name of an EnumValue doesn't
@@ -16,6 +13,7 @@ module RbGCCXML
     def qualified_name #:nodoc:
       "#{self.parent.parent.qualified_name}::#{self.name}"
     end
+    once :qualified_name
 
   end
 

data/lib/rbgccxml/nodes/enumeration.rb

@@ -6,7 +6,7 @@ module RbGCCXML
 
     # Get the list of EnumValues for this enumeration
     def values
-      XMLParsing.get_values_of(self).each {|v| v.parent = self }
+      children
     end
 
     # Is this enumeration anonymous? As in, does it have a name or is

data/lib/rbgccxml/nodes/field.rb

@@ -5,13 +5,15 @@ module RbGCCXML
 
     # Get the Node representing this field's type
     def cpp_type
-      XMLParsing.find_type_of(node, "type")
+      NodeCache.find(attributes["type"])
     end
+    once :cpp_type
 
     # See Node#to_cpp
     def to_cpp(qualified = false)
       "#{self.cpp_type.to_cpp(qualified)} #{self.name}"
     end
+    once :to_cpp
 
   end
 

data/lib/rbgccxml/nodes/function.rb

@@ -13,12 +13,12 @@ module RbGCCXML
     
     # Get the list of Arguments for this Function.
     def arguments
-      XMLParsing.find_arguments_for(node)
+      children
     end
 
     # Get the Node representing this Function's return type
     def return_type
-      XMLParsing.find_type_of(node, "returns")
+      NodeCache.find(attributes["returns"])
     end
   end
 

data/lib/rbgccxml/nodes/method.rb

@@ -5,17 +5,17 @@ module RbGCCXML
 
     # Is this method static?
     def static?
-      @node["static"] == "1"
+      attributes["static"] == "1"
     end
 
     # Is this a virtual method?
     def virtual?
-      @node["virtual"] == "1"
+      attributes["virtual"] == "1"
     end
 
     # Is this a pure virtual method? A purely virtual method has no body.
     def purely_virtual?
-      @node["pure_virtual"] == "1"
+      attributes["pure_virtual"] == "1"
     end
 
   end

data/lib/rbgccxml/nodes/namespace.rb

@@ -2,5 +2,19 @@ module RbGCCXML
   # Represents the <Namespace> node. Namespaces can have in it
   # more namespaces, methods, classes, structs, attributes, ... everything.
   class Namespace < Node
+
+    # Special case for the top-level namespace, ignore :: or
+    # we get elements that print out as ::::type
+    def qualified_name #:nodoc:
+      if @name == "::"
+        ""
+      else
+        super
+      end
+    end
+
+    def to_cpp
+      self.qualified_name
+    end
   end
 end

data/lib/rbgccxml/nodes/type.rb

@@ -12,7 +12,7 @@ module RbGCCXML
     def check_sub_type_without(val, delim)
       return false unless val =~ delim
       new_val = val.gsub(delim, "").strip
-      XMLParsing.find_type_of(self.node, "type") == new_val
+      NodeCache.find(attributes["type"]) == new_valu
     end
 
     # Get the base type without any qualifiers. E.g, if you've
@@ -21,13 +21,14 @@ module RbGCCXML
     #
     # returns: Node related to the base C++ construct of this type
     def base_type
-      n = XMLParsing.find_type_of(self.node, "type")
+      n = NodeCache.find(attributes["type"])
       n.is_a?(Type) ? n.base_type : n
     end
+    once :base_type
 
     # Is this type const qualified?
     def const?
-      found = XMLParsing.find_type_of(self.node, "type")
+      found = NodeCache.find(attributes["type"])
       found ? found.const? : false
     end
 

data/lib/rbgccxml/nodes/types/array_type.rb

@@ -20,9 +20,10 @@ module RbGCCXML
 
     # See Node#to_cpp
     def to_cpp(qualified = true)
-      type = XMLParsing.find_type_of(self.node, "type")
-      "#{type.to_cpp(qualified)}[#{self.node["max"].gsub(/[^\d]/, '').to_i + 1}]"
+      type = NodeCache.find(attributes["type"])
+      "#{type.to_cpp(qualified)}[#{attributes["max"].gsub(/[^\d]/, '').to_i + 1}]"
     end
+    once :to_cpp
 
   end
 

data/lib/rbgccxml/nodes/types/cv_qualified_type.rb

@@ -3,20 +3,26 @@ module RbGCCXML
   # Represents a <CvQualifiedType> node. This node keeps track of
   # the const nature of a Node.
   class CvQualifiedType < Type
-    
+
     def ==(val)
       check_sub_type_without(val, /const/)
     end
 
     # See Node#to_cpp
     def to_cpp(qualified = true)
-      type = XMLParsing.find_type_of(self.node, "type")
-      "const #{type.to_cpp(qualified)}"
+      type = NodeCache.find(attributes["type"])
+
+      post_const = container ? " const" : ""
+      pre_const = container ? "" : "const "
+
+      "#{pre_const}#{type.to_cpp(qualified)}#{post_const}"
     end
+    once :to_cpp
 
-    # Is this node const?
-    def const?
-      self.node["const"].to_i == 1
+    # Have to redefine this as Type#const? looks up the 
+    # tree for const, and in our case we are the const knower
+    def const? #:nodoc:
+      attributes["const"] == "1"
     end
 
   end

data/lib/rbgccxml/nodes/types/pointer_type.rb

@@ -9,9 +9,10 @@ module RbGCCXML
 
     # See Node#to_cpp
     def to_cpp(qualified = true)
-      type = XMLParsing.find_type_of(self.node, "type")
+      type = NodeCache.find(attributes["type"])
       "#{type.to_cpp(qualified)}*"
     end
+    once :to_cpp
 
   end
 

data/lib/rbgccxml/nodes/types/reference_type.rb

@@ -8,9 +8,10 @@ module RbGCCXML
     end
 
     def to_cpp(qualified = true)
-      type = XMLParsing.find_type_of(self.node, "type")
+      type = NodeCache.find(attributes["type"])
       "#{type.to_cpp(qualified)}&"
     end
+    once :to_cpp
 
   end