rbgccxml 0.1.1 → 0.8

data/lib/rbgccxml/xml_parsing.rb

@@ -25,13 +25,17 @@ module RbGCCXML
     # Returns the first found node
     def self.find(options = {})
       return nil if options.empty?
-
       type = options.delete(:type)
-      attrs = options.map {|key, value| "[@#{key}='#{value}']"}.join
+      
+      # Look value up in the cache for common operations if a type was given
+      if(type && options.length == 1 && options.keys[0] == :id)
+        return cache(type, options[:id])
+      end
 
+      attrs = options.map {|key, value| "[@#{key}='#{value}']"}.join
       xpath = "//#{type}#{attrs}"
 
-      got = @@doc_root.search(xpath)[0]
+      got = @@doc_root.at(xpath)
 
       if got
         RbGCCXML.const_get(type || got.name).new(got) 
@@ -39,6 +43,36 @@ module RbGCCXML
         nil
       end
     end
+    
+    # Generic finding of nodes according to attributes.
+    # Special options:
+    #
+    # <tt>:type</tt>:: Specify a certain node type to search by
+    #
+    # Any other options is directly mapped to attributes on the node. For example, to find all
+    # Function nodes:
+    #
+    #   XMLParsing.find_all(:type => "Function")
+    #
+    # Returns all matching nodes
+    def self.find_all(options = {})
+      return nil if options.empty?
+
+      type = options.delete(:type)
+      attrs = options.map {|key, value| "[@#{key}='#{value}']"}.join
+
+      xpath = "//#{type}#{attrs}"
+      
+      results = @@doc_root.search(xpath)
+      
+      if results
+        results.collect do |got|
+          RbGCCXML.const_get(type || got.name).new(got) 
+        end
+      else
+        nil
+      end
+    end
 
     # Look through the DOM under +node+ for +node_type+ nodes.
     # +node_type+ must be the string name of an existing Node subclass.
@@ -46,7 +80,7 @@ module RbGCCXML
     # Returns a QueryResult with the findings.
     def self.find_nested_nodes_of_type(node, node_type)
       results = QueryResult.new
-
+      
       # First of all limit which elements we're searching for, to ease processing.
       # In the GCCXML output, node heirarchy is designated by id, members, and context
       # attributes:
@@ -56,22 +90,27 @@ module RbGCCXML
       #   context => The parent node id of this node
       #
       # We only want those nodes in node's context.
-      xpath = "//#{node_type}[@context='#{node.attributes["id"]}']"
-
-      @@doc_root.search(xpath).each do |found|
-        results << RbGCCXML.const_get(node_type).new(found)
-      end
-
-      results.flatten
+      return nested_cache(node_type, node.attributes["id"]).flatten
     end
 
     # Arguments are a special case in gccxml as they are actual children of
     # the functions / methods they are a part of. 
     def self.find_arguments_for(node)
+      get_children_nodes_of_type(node, "Argument")
+    end
+
+    # Enumeration values are children of the Enumeration element
+    def self.get_values_of(enum)
+      get_children_nodes_of_type(enum.node, "EnumValue")
+    end
+
+    # Generic lookup method for nodes that are XML children of the passed in node.
+    # See find_arguments_for and get_values_of for example usage
+    def self.get_children_nodes_of_type(node, type)
       results = QueryResult.new
 
-      node.get_elements_by_tag_name("Argument").each do |argument|
-        results << Argument.new(argument)
+      node.get_elements_by_tag_name(type).each do |found|
+        results << RbGCCXML.const_get(type).new(found) 
       end
       
       results.flatten
@@ -83,7 +122,63 @@ module RbGCCXML
     #
     #   +find_type_of(func_node, "returns")+ could return "std::string" node, "int" node, etc
     def self.find_type_of(node, attribute)
-      XMLParsing.find(:id => node.attributes[attribute])
+      id = node.attributes[attribute]
+      %w( PointerType ReferenceType FundamentalType Typedef Enumeration CvQualifiedType Class Struct ).each do |type|
+        return cache(type, id) if cache(type, id)
+      end
+      return nil
+    end
+    
+    #
+    # Returns the element in cache for type at id.
+    # Used internally.
+    #
+    def self.cache(type, id)
+      @@types_cache ||= {}
+      @@types_cache[type] ||= {}
+      build_cache(type) if @@types_cache[type].empty?
+      return @@types_cache[type][id]
+    end
+    
+    #
+    # Creates a cache to work off of.
+    # Used internally
+    #
+    def self.build_cache(type) 
+      XMLParsing.find_all(:type => type).each do |result|
+        @@types_cache[type][result.attributes["id"]] = result
+      end
+    end
+    
+    #
+    # Returns the element in cache for type at id
+    # Used internally
+    #
+    def self.nested_cache(type, context)
+      @@nested_cache ||= {}
+      @@nested_cache[type] ||= {}
+      build_nested_cache(type) if @@nested_cache[type].empty?
+      return @@nested_cache[type][context] || QueryResult.new
+    end
+    
+    #
+    # Creates a nested cache to work off of.
+    # Used internally
+    #
+    def self.build_nested_cache(type) 
+      XMLParsing.find_all(:type => type).each do |result|
+        @@nested_cache[type][result.attributes["context"]] ||= QueryResult.new
+        @@nested_cache[type][result.attributes["context"]] << result
+      end
+    end
+   
+   
+    #
+    # Clears the cache.  Use this if you are querying two seperate libraries.
+    #  
+    def self.clear_cache
+      @@nested_cache = nil
+      @@types_cache = nil
     end
   end
 end

data/lib/rbgccxml.rb

@@ -21,11 +21,15 @@ module RbGCCXML
   autoload :Method, "rbgccxml/nodes/method" 
   autoload :Namespace, "rbgccxml/nodes/namespace" 
   autoload :Struct, "rbgccxml/nodes/struct" 
+  autoload :Enumeration, "rbgccxml/nodes/enumeration"  
+  autoload :EnumValue, "rbgccxml/nodes/enum_value"  
 
   # Type Management
   autoload :Type, "rbgccxml/nodes/type"
   autoload :FundamentalType, "rbgccxml/nodes/types/fundamental_type" 
   autoload :PointerType, "rbgccxml/nodes/types/pointer_type" 
   autoload :Typedef, "rbgccxml/nodes/types/typedef" 
+  autoload :ReferenceType, "rbgccxml/nodes/types/reference_type"
+  autoload :CvQualifiedType, "rbgccxml/nodes/types/cv_qualified_type"  
 
 end

data/test/classes_test.rb

@@ -7,7 +7,7 @@ context "Querying for classes" do
 
   specify "can find all classes in a given namespace" do
     classes = @@source.classes
-    classes.size.should == 3 
+    classes.size.should == 4
 
     %w(Test1 Test2 Test3).each do |t|
       assert classes.detect {|c| c.node == @@source.classes(t).node }, 
@@ -39,7 +39,7 @@ context "Querying for class constructors" do
 
   specify "should have a list of constructors" do
     test1 = @@source.classes.find(:name => "Test1")
-    test1.constructors.size.should == 1
+    test1.constructors.size.should == 2
 
     test2 = @@source.classes.find(:name => "Test2")
     test2.constructors.size.should == 2

data/test/enumerations_test.rb

@@ -0,0 +1,44 @@
+
+require File.dirname(__FILE__) + '/test_helper'
+
+context "Querying for enumerations" do
+  setup do
+    @@enum_source ||= RbGCCXML.parse(full_dir("headers/enums.h")).namespaces("enums")
+  end
+
+  specify "can query for enumerations" do
+    enums = @@enum_source.enumerations
+    enums.length.should == 2
+
+    assert @@enum_source.enumerations("TestEnum") == "TestEnum"
+    assert @@enum_source.enumerations.find(:name => "MyEnum") == "MyEnum"
+  end
+
+  specify "can find specific enum values" do
+    enum = @@enum_source.enumerations("TestEnum")
+    enum.values.length.should == 3
+    assert enum.values[0] == "VALUE1"
+    assert enum.values[1] == "VALUE2"
+    assert enum.values[2] == "VALUE3"
+  end
+
+  specify "can find the given value of enum entries" do
+    enum = @@enum_source.enumerations.find(:name => "MyEnum")
+    enum.values[0].value.should == 3
+    enum.values[1].value.should == 4
+    enum.values[2].value.should == 7
+  end
+
+  specify "properly prints out fully qualified C++ identifier for enum values" do
+    enum = @@enum_source.enumerations("TestEnum")
+    enum.values.length.should == 3
+    assert enum.values[0].qualified_name == "enums::VALUE1"
+    assert enum.values[1].qualified_name == "enums::VALUE2"
+    assert enum.values[2].qualified_name == "enums::VALUE3"
+
+    enum = @@enum_source.classes("Inner").enumerations("InnerEnum")
+    assert enum.values[0].qualified_name == "enums::Inner::INNER_1"
+    assert enum.values[1].qualified_name == "enums::Inner::INNER_2"
+  end
+end
+

data/test/functions_test.rb

@@ -7,7 +7,7 @@ context "Querying for functions" do
   end
 
   specify "should be able to find all functions" do
-    @@functions_source.functions.length.should == 6
+    @@functions_source.functions.length.should == 2
   end
 
   specify "can find functions by name" do
@@ -21,18 +21,6 @@ context "Querying for functions" do
     bool.name.should == "bool_method"
   end
 
-  specify "can find names by regex" do
-    bool = @@functions_source.functions.find(:name => /bool/)
-    bool.should.be.a.kind_of RbGCCXML::Function
-    bool.name.should == "bool_method"
-  end
-
-  xspecify "can find names by fully qualified name" do
-    nested = @@functions_source.functions.find(:name => "nested1::nested2::nestedFunction")
-    nested.should.be.a.kind_of RbGCCXML::Function
-    nested.name.should == "nestedFunction"
-  end
-
   specify "should not have a classes finder" do
     test1 = @@functions_source.functions("test1")
     should.raise RbGCCXML::NotQueryableException do
@@ -54,49 +42,3 @@ context "Querying for functions" do
     end
   end
 end
-
-context "Finding functions via arguments and return type" do
-
-  setup do
-    @@functions_source ||= RbGCCXML.parse(full_dir("headers/functions.h")).namespaces("functions")
-  end
-
-  specify "by return type" do
-    funcs = @@functions_source.functions.find(:returns => :void)
-    funcs.size.should == 3
-    assert funcs.find {|f| f.name == "test1" }
-    assert funcs.find {|f| f.name == "test2" }
-    assert funcs.find {|f| f.name == "test3" }
-  end
-
-  specify "no arguments" do
-    funcs = @@functions_source.functions.find(:arguments => [])
-    funcs.size.should == 2
-    assert funcs.find {|f| f.name == "test1" }
-    assert funcs.find {|f| f.name == "bool_method" }
-  end
-
-  specify "multiple arguments" do
-    # If we find just one result, we get it back
-    func = @@functions_source.functions.find(:arguments => [:int])
-    assert func.is_a?(RbGCCXML::Function)
-    func.name.should == "test2"
-
-    func = @@functions_source.functions.find(:arguments => [:int, :float])
-    assert func.is_a?(RbGCCXML::Function)
-    func.name.should == "test3"
-  end
-
-  specify "when searching arguments, can specify catch-all" do
-    funcs = @@functions_source.functions.find(:arguments => [:int, nil])
-    funcs.size.should == 2
-    assert funcs.find {|f| f.name == "test3" }
-    assert funcs.find {|f| f.name == "test4" }
-  end
-
-  specify "by both return type and arguments (AND form, not OR)" do
-    func = @@functions_source.functions.find(:returns => :int, :arguments => [nil, nil])
-    assert func.is_a?(RbGCCXML::Function)
-    func.name.should == "test4"
-  end
-end

data/test/methods_test.rb

@@ -56,4 +56,15 @@ context "Properties on Methods" do
     assert !test2.methods("func1").static?
   end
 
+  specify "should be able to tell if a given method is virtual or not" do
+    test4 = @@classes_source.classes("Test4")
+    assert test4.methods("func1").virtual?
+    assert !test4.methods("func1").purely_virtual?
+    
+    assert test4.methods("func2").virtual?
+    assert !test4.methods("func2").purely_virtual?
+    
+    assert test4.methods("func3").virtual?
+    assert test4.methods("func3").purely_virtual?
+  end
 end

data/test/node_test.rb

@@ -63,4 +63,23 @@ context "Equality testing" do
     inner = upper.namespaces("inner1")
     assert !(upper == inner)
   end
+
+  specify "should find explicit over matches" do
+    source = RbGCCXML.parse(full_dir("headers/classes.h")).namespaces("classes")
+    f = source.classes("Test2").methods("func")
+    f.name.should == "func"
+  end
+end
+
+context "Misc access methods" do
+
+  specify "can tell if something is public, protected, and private" do
+    source = RbGCCXML.parse(full_dir("headers/misc.h"))
+    access = source.namespaces("misc").classes("AccessSettings")
+
+    assert access.methods("privateMethod").private?
+    assert access.methods("protectedMethod").protected?
+    assert access.methods("publicMethod").public?
+  end
+
 end

data/test/query_results_test.rb

@@ -0,0 +1,228 @@
+require File.dirname(__FILE__) + '/test_helper'
+
+context "Managing Query results" do
+
+  class MyObj
+    attr_accessor :call_me_called, :other_thingy_called
+
+    def call_me
+      @call_me_called = true
+    end
+
+    def other_thingy
+      @other_thingy_called = true
+    end
+  end
+
+  specify "should forward off unknown methods to the results" do
+    obj1 = MyObj.new
+    obj2 = MyObj.new
+
+    q = RbGCCXML::QueryResult.new  
+    q << obj1 << obj2
+
+    should.not.raise NoMethodError do
+      q.call_me
+      q.other_thingy
+    end
+
+    assert obj1.call_me_called
+    assert obj1.other_thingy_called
+
+    assert obj2.call_me_called
+    assert obj2.other_thingy_called
+
+    should.raise NoMethodError do
+      q.not_here
+    end
+  end
+
+  specify "should throw appropriately with an empty result set" do
+    should.raise NoMethodError do
+      RbGCCXML::QueryResult.new.some_method
+    end
+  end
+
+  specify "should error out with unknown keys" do
+    should.raise do
+      RbGCCXML::QueryResult.new.find(:key_bad => :hi_mom)
+    end
+  end
+
+end
+
+context "QueryResult#find :name" do
+
+  setup do
+    @@query_source ||= RbGCCXML.parse(full_dir("headers/queryable.h")).namespaces("query")
+  end
+
+  specify "can find by regular name" do
+    func = @@query_source.functions.find(:name => "test4")
+    func.should.be.a.kind_of RbGCCXML::Function
+    func.name.should == "test4"
+  end
+
+  specify "can find names by regex" do
+    bool = @@query_source.functions.find(:name => /bool/)
+    bool.should.be.a.kind_of RbGCCXML::Function
+    bool.name.should == "bool_method"
+  end
+
+end
+
+context "QueryResult#find :arguments" do
+
+  setup do
+    @@query_source ||= RbGCCXML.parse(full_dir("headers/queryable.h")).namespaces("query")
+  end
+
+  specify "no arguments" do
+    funcs = @@query_source.functions.find(:arguments => [])
+    assert funcs.detect {|f| f.name == "test1" }
+    assert funcs.detect {|f| f.name == "bool_method" }
+  end
+
+  specify "multiple arguments" do
+    # If we find just one result, we get it back
+    func = @@query_source.functions.find(:arguments => [:int])
+    assert func.is_a?(RbGCCXML::Function)
+    func.name.should == "test2"
+
+    func = @@query_source.functions.find(:arguments => [:int, :float])
+    assert func.is_a?(RbGCCXML::Function)
+    func.name.should == "test3"
+  end
+
+  specify "when searching arguments, can specify catch-all" do
+    funcs = @@query_source.functions.find(:arguments => [:int, nil])
+    funcs.size.should == 2
+    assert funcs.detect {|f| f.name == "test3" }
+    assert funcs.detect {|f| f.name == "test4" }
+  end
+
+  specify "works when using custom defined types" do
+    func = @@query_source.functions.find(:arguments => ["MyType"])
+    func.name.should == "testMyTypeArgs"
+  end
+
+  specify "works with pointers and references" do
+    func = @@query_source.functions.find(:arguments => ["MyType *"])
+    func.name.should == "testMyTypeArgsPtr"
+
+    func = @@query_source.functions.find(:arguments => ["MyType &"])
+    func.name.should == "testMyTypeArgsRef"
+  end
+
+  specify "works with qualified names" do
+    func = @@query_source.functions.find(:arguments => ["query::MyType"])
+    func.name.should == "testMyTypeArgs"
+
+    func = @@query_source.functions.find(:arguments => ["::query::MyType"])
+    func.name.should == "testMyTypeArgs"
+  end
+
+  specify "works with qualifiers like const" do
+    func = @@query_source.functions.find(:arguments => ["const MyType*"])
+    func.name.should == "testMyTypeArgsConstPtr"
+  end
+end
+
+context "QueryResult#find :returns" do
+
+  setup do
+    @@query_source ||= RbGCCXML.parse(full_dir("headers/queryable.h")).namespaces("query")
+  end
+
+  specify "by return type" do
+    funcs = @@query_source.functions.find(:returns => :void)
+    assert funcs.detect {|f| f.name == "test1" }
+    assert funcs.detect {|f| f.name == "test2" }
+    assert funcs.detect {|f| f.name == "test3" }
+  end
+
+  specify "works with custom defined types" do
+    func = @@query_source.functions.find(:returns => "MyType")
+    func.name.should == "testMyType"
+  end
+
+  specify "work with qualified names" do
+    func = @@query_source.functions.find(:returns => "query::MyType")
+    func.name.should == "testMyType"
+
+    func = @@query_source.functions.find(:returns => "::query::MyType")
+    func.name.should == "testMyType"
+  end
+
+  specify "works with pointers and references" do
+    func = @@query_source.functions.find(:returns => "MyType *")
+    func.name.should == "testMyTypePtr"
+
+    func = @@query_source.functions.find(:returns => "MyType&")
+    func.name.should == "testMyTypeRef"
+  end
+
+  specify "works with type modifiers (const)" do
+    func = @@query_source.functions.find(:returns => "const MyType")
+    func.name.should == "testMyTypeConst"
+  end
+end
+
+context "QueryResult#find access type" do
+
+  setup do
+    @@query_source ||= RbGCCXML.parse(full_dir("headers/queryable.h")).namespaces("query")
+  end
+
+  specify "can find according to public / private / protected" do
+    klass = @@query_source.classes("AccessTester")
+    m = klass.methods.find(:access => :public)
+    m.name.should == "publicMethod"
+
+    m = klass.methods.find(:access => :protected)
+    m.name.should == "protectedMethod"
+
+    m = klass.methods.find(:access => :private)
+    m.name.should == "privateMethod"
+  end
+
+end
+
+context "QueryResult#find multiple options" do
+
+  setup do
+    @@query_source ||= RbGCCXML.parse(full_dir("headers/queryable.h")).namespaces("query")
+  end
+
+  specify "by both return type and arguments (AND form, not OR)" do
+    func = @@query_source.functions.find(:returns => :int, :arguments => [nil, nil])
+    assert func.is_a?(RbGCCXML::Function)
+    func.name.should == "test4"
+  end
+
+end
+
+context "QueryResult#find :all - Flag full source search" do
+
+  setup do
+    @@query_source ||= RbGCCXML.parse(full_dir("headers/queryable.h")).namespaces("query")
+  end
+
+  specify "can find all :names regardless of nesting" do
+    func = @@query_source.functions.find(:all, :name => "nestedFunction")
+    func.name.should == "nestedFunction"
+  end
+
+  specify "can find according to :arguments" do
+    func = @@query_source.functions.find(:all, :arguments => ["MyType", "MyType"])
+    func.name.should == "nestedMyTypeArg"
+  end
+  
+  specify "can find according to :returns " do
+    funcs = @@query_source.functions.find(:all, :returns => ["MyType"])
+    funcs.size.should == 2
+    assert funcs.detect {|f| f.name == "nestedMyTypeReturns"}
+    assert funcs.detect {|f| f.name == "testMyType"}
+  end
+
+end

data/test/test_helper.rb

@@ -9,6 +9,10 @@ class Test::Unit::TestCase
   def full_dir(path)
     File.expand_path(File.join(File.dirname(__FILE__), path))
   end
+  
+  def teardown
+    RbGCCXML::XMLParsing.clear_cache
+  end
 
 end
 

data/test/types_test.rb

@@ -38,4 +38,82 @@ context "Proper Type handling" do
     assert @@types_source.functions.find(:returns => "myLongType*") == "returnsLongTypePointer"
   end
 
+  specify "reference types" do
+    assert @@types_source.functions.find(:returns => "struct_type&") == "returnStructReference"
+  end
+
+  specify "const definitions (fundamental types)" do
+    assert @@types_source.functions.find(:returns => "const int") == "returnConstInt"
+  end
+
+  specify "const definitions (defined types)" do
+    assert @@types_source.functions.find(:returns => "const struct_type") == "returnConstStruct"
+  end
+
+  specify "const references" do
+    assert @@types_source.functions.find(:returns => "const user_type&") == "returnConstUserTypeRef"
+  end
+
+  specify "const pointers" do
+    assert @@types_source.functions.find(:returns => "const int*") == "returnConstIntPointer"
+  end
+
+  specify "enumerations" do
+    assert @@types_source.functions.find(:returns => "myEnum") == "returnMyEnum"
+  end
+
+end
+
+context "Printing types" do
+  
+  setup do
+    @@types_source ||= RbGCCXML.parse(full_dir("headers/types.h")).namespaces("types")
+  end
+
+  specify "types should print back properly into string format" do
+    @@types_source.functions.find(:returns => "int").return_type.to_s.should == "int"
+    @@types_source.functions.find(:returns => "int").return_type.to_s(true).should == "int"
+
+    @@types_source.functions.find(:returns => "float").return_type.to_s.should == "float"
+
+    # pointers
+    @@types_source.functions.find(:returns => "int*").return_type.to_s.should == "int*"
+
+    # references
+    @@types_source.functions.find(:returns => "struct_type&").return_type.to_s.should == "struct_type&"
+    @@types_source.functions.find(:returns => "struct_type&").return_type.to_s(true).should == "types::struct_type&"
+    
+    # printout full from the global namespace
+    @@types_source.functions.find(:returns => "string").return_type.to_s(true).should == "others::string"
+
+    # const
+    @@types_source.functions.find(:returns => "const int").return_type.to_s.should == "const int"
+    
+    # const pointers
+    @@types_source.functions.find(:returns => "const int*").return_type.to_s.should == "const int*"
+
+    # const references
+    @@types_source.functions.find(:returns => "const user_type&").return_type.to_s.should == "const user_type&"
+    @@types_source.functions.find(:returns => "const user_type&").return_type.to_s(true).should == "const types::user_type&"
+
+    # Enumerations
+    @@types_source.functions.find(:returns => "myEnum").return_type.to_s.should == "myEnum"
+    @@types_source.functions.find(:returns => "myEnum").return_type.to_s(true).should == "types::myEnum"
+  end
+
+  specify "can get to the base C++ construct of given types" do
+    @@types_source.functions.find(:returns => "const user_type&").return_type.base_type.to_s.should == "user_type"
+    @@types_source.functions.find(:returns => "const int*").return_type.base_type.to_s.should == "int"
+  end
+
+end
+
+context "Type comparitors" do
+  specify "can tell of a given type is a const" do
+    assert @@types_source.functions.find(:returns => "const user_type&").return_type.const?
+    assert @@types_source.functions.find(:returns => "const int*").return_type.const?
+    assert !@@types_source.functions.find(:returns => "user_type").return_type.const?
+    assert !@@types_source.functions.find(:returns => "string").return_type.const?
+    assert !@@types_source.functions.find(:returns => "int").return_type.const?
+  end
 end