rbgccxml 0.1

data/test/classes_test.rb

@@ -0,0 +1,60 @@
+require File.dirname(__FILE__) + '/test_helper'
+
+context "Querying for classes" do
+  setup do
+    @@source ||= RbGCCXML.parse(full_dir("headers/classes.h")).namespaces("classes")
+  end
+
+  specify "can find all classes in a given namespace" do
+    classes = @@source.classes
+    classes.size.should == 3 
+
+    %w(Test1 Test2 Test3).each do |t|
+      assert classes.detect {|c| c.node == @@source.classes(t).node }, 
+        "unable to find node for #{t}"
+    end
+  end
+
+  specify "can find classes within classes" do
+    test1 = @@source.classes.find(:name => "Test1")
+    test1.should.not.be.nil
+    
+    inner1 = test1.classes("Inner1")
+    inner1.should.not.be.nil
+    
+    inner2 = inner1.classes("Inner1")
+    inner2.should.not.be.nil
+  end
+
+  specify "can find out which file said class is in" do
+    test1 = @@source.classes.find(:name => "Test1")
+    test1.file_name.should == "classes.h"
+  end
+end
+
+context "Querying for class constructors" do
+  setup do
+    @@source ||= RbGCCXML.parse(full_dir("headers/classes.h")).namespaces("classes")
+  end
+
+  specify "should have a list of constructors" do
+    test1 = @@source.classes.find(:name => "Test1")
+    test1.constructors.size.should == 1
+
+    test2 = @@source.classes.find(:name => "Test2")
+    test2.constructors.size.should == 2
+  end
+
+  specify "constructors should have arguments" do
+    test2 = @@source.classes.find(:name => "Test2")
+    test2.constructors.size.should == 2
+
+    default = test2.constructors[0]
+    default.arguments.size.should == 0
+
+    specific = test2.constructors[1]
+    specific.arguments.size.should == 1
+    assert(specific.arguments[0].cpp_type == "int")
+  end
+end
+

data/test/functions_test.rb

@@ -0,0 +1,102 @@
+require File.dirname(__FILE__) + '/test_helper'
+
+context "Querying for functions" do
+
+  setup do
+    @@functions_source ||= RbGCCXML.parse(full_dir("headers/functions.h")).namespaces("functions")
+  end
+
+  specify "should be able to find all functions" do
+    @@functions_source.functions.length.should == 6
+  end
+
+  specify "can find functions by name" do
+    # Short-hand finding does #find(:name => "")
+    test1 = @@functions_source.functions("test1")
+    test1.should.be.a.kind_of RbGCCXML::Function
+    test1.name.should == "test1"
+
+    bool = @@functions_source.functions.find(:name => "bool_method")
+    bool.should.be.a.kind_of RbGCCXML::Function
+    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
+      test1.classes  
+    end
+  end
+
+  specify "should not have a namespaces finder" do
+    test1 = @@functions_source.functions("test1")
+    should.raise RbGCCXML::NotQueryableException do
+      test1.namespaces
+    end
+  end
+
+  specify "should not have a functions finder" do
+    test1 = @@functions_source.functions("test1")
+    should.raise RbGCCXML::NotQueryableException do
+      test1.functions  
+    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

@@ -0,0 +1,59 @@
+require File.dirname(__FILE__) + '/test_helper'
+
+context "Querying for class methods" do
+  setup do
+    @@adder_source ||= RbGCCXML.parse(full_dir("headers/Adder.h")).namespaces("classes")
+  end
+
+  specify "should be able to get the methods on a class" do
+    adder = @@adder_source.classes.find(:name => "Adder")
+    methods = adder.methods
+
+    methods.size.should == 4
+    methods[0].name.should == "addIntegers"
+    methods[1].name.should == "addFloats"
+    methods[2].name.should == "addStrings"
+    methods[3].name.should == "getClassName"
+  end
+
+  # The following are simplistic. functions_test tests the
+  # finder options much more completely. This is just to test
+  # that it works on Method objects fine
+  specify "should be able to get methods by name" do
+    adder = @@adder_source.classes("Adder")
+    adder.methods("addIntegers").name.should == "addIntegers"
+    adder.methods.find(:name => "addStrings").name.should == "addStrings"
+  end
+
+  specify "can search methods via arguments" do
+    adder = @@adder_source.classes("Adder")
+    adder.methods.find(:arguments => [:int, :int]).name.should == "addIntegers"
+  end
+
+  specify "can search methods via return type" do
+    adder = @@adder_source.classes("Adder")
+    adder.methods.find(:returns => [:float]).name.should == "addFloats"
+  end
+
+  specify "can search via all options (AND)" do
+    adder = @@adder_source.classes("Adder")
+    got = adder.methods.find(:returns => [:int], :arguments => [nil, nil])
+    got.name.should == "addIntegers"
+  end
+
+end
+
+context "Properties on Methods" do
+  setup do
+    @@classes_source ||= RbGCCXML.parse(full_dir("headers/classes.h")).namespaces("classes")
+  end
+
+  specify "should be able to tell if a given method is static or not" do
+    test1 = @@classes_source.classes("Test1")
+    assert test1.methods("staticMethod").static?
+
+    test2 = @@classes_source.classes.find(:name => "Test2")
+    assert !test2.methods("func1").static?
+  end
+
+end

data/test/namespaces_test.rb

@@ -0,0 +1,25 @@
+require File.dirname(__FILE__) + '/test_helper'
+
+context "Querying for namespaces" do
+
+  setup do
+    @source ||= RbGCCXML.parse(full_dir("headers/namespaces.h"))
+  end
+
+  specify "can find a namespace" do
+    upper = @source.namespaces.find(:name => "upper")
+    upper.should.be.a.kind_of RbGCCXML::Namespace
+
+    inner1 = upper.namespaces("inner1")
+    inner1.should.be.a.kind_of RbGCCXML::Namespace
+    inner1.name.should == "inner1"
+
+    inner2 = upper.namespaces("inner2")
+    inner2.should.be.a.kind_of RbGCCXML::Namespace
+    inner2.name.should == "inner2"
+
+    nested = inner2.namespaces("nested")
+    nested.should.be.a.kind_of RbGCCXML::Namespace
+    nested.name.should == "nested"
+  end
+end

data/test/node_test.rb

@@ -0,0 +1,66 @@
+require File.dirname(__FILE__) + '/test_helper'
+
+context "Qualified name generation" do
+
+  specify "for namespaces" do
+    source = RbGCCXML.parse(full_dir("headers/namespaces.h"))
+
+    upper = source.namespaces.find(:name => "upper")
+    upper.qualified_name.should == "upper"
+
+    inner2 = upper.namespaces("inner2")
+    inner2.qualified_name.should == "upper::inner2"
+  end
+
+  specify "for classes" do
+    source = RbGCCXML.parse(full_dir("headers/classes.h")).namespaces("classes")
+
+    test1 = source.classes.find(:name => "Test1")
+    test1.qualified_name.should == "classes::Test1"
+    
+    inner1 = test1.classes("Inner1")
+    inner1.qualified_name.should == "classes::Test1::Inner1"
+    
+    inner2 = inner1.classes("Inner2")
+    inner2.qualified_name.should == "classes::Test1::Inner1::Inner2"
+  end
+
+  specify "for functions" do
+    source = RbGCCXML.parse(full_dir("headers/functions.h")).namespaces("functions")
+    test1 = source.functions("test1")
+    test1.qualified_name.should == "functions::test1"
+  end
+
+  specify "for methods in classes" do
+    source = RbGCCXML.parse(full_dir("headers/classes.h")).namespaces("classes")
+    inner = source.classes("Test1").classes("Inner1")
+    func = inner.methods("innerFunc")
+
+    func.qualified_name.should == "classes::Test1::Inner1::innerFunc"
+  end
+
+end
+
+context "Equality testing" do
+
+  specify "testing against a string will test against the name" do
+    source = RbGCCXML.parse(full_dir("headers/namespaces.h"))
+    assert(source.namespaces("upper") == "upper")
+  end
+
+  specify "c++ nesting should be usable as well" do
+    source = RbGCCXML.parse(full_dir("headers/classes.h")).namespaces("classes")
+    klass = source.classes("Test1").classes("Inner1")
+    assert !(klass == "Inner2")
+    assert(klass == "Inner1")
+    assert(klass == "Test1::Inner1")
+    assert(klass == "classes::Test1::Inner1")
+  end
+
+  specify "but should be able to test against nodes as well" do
+    source = RbGCCXML.parse(full_dir("headers/namespaces.h"))
+    upper = source.namespaces("upper")
+    inner = upper.namespaces("inner1")
+    assert !(upper == inner)
+  end
+end

data/test/parser_test.rb

@@ -0,0 +1,65 @@
+require File.dirname(__FILE__) + '/test_helper'
+
+context "Default parsing configuration" do
+
+  specify "can parse a single header file" do
+    should.not.raise do
+      RbGCCXML.parse(full_dir("headers/Adder.h"))
+    end
+  end
+
+  specify "can parse a glob" do
+    should.not.raise do
+      RbGCCXML.parse(full_dir("headers/*.hpp"))
+    end
+  end
+
+  specify "can parse all files in a directory" do
+    should.not.raise do
+      RbGCCXML.parse(full_dir("headers"),
+                    :includes => full_dir("headers/include"))
+    end
+  end
+
+  specify "can take an array of files" do
+    files = [full_dir("headers/Adder.h"),
+              full_dir("headers/Subtracter.hpp")]
+    should.not.raise do
+      RbGCCXML.parse(files)
+    end
+  end
+
+  specify "can take an array of globs" do
+    files = [full_dir("headers/*.h"),
+              full_dir("headers/*.hpp")]
+    should.not.raise do
+      RbGCCXML.parse(files, :includes => full_dir("headers/include"))
+    end
+  end
+
+  specify "should throw an error if files aren't found" do
+    should.raise RbGCCXML::SourceNotFoundError do
+      RbGCCXML.parse(full_dir("headers/Broken.hcc"))
+    end
+
+    should.raise RbGCCXML::SourceNotFoundError do
+      RbGCCXML.parse(full_dir("hockers"))
+    end
+
+    should.raise RbGCCXML::SourceNotFoundError do
+      RbGCCXML.parse(full_dir("something/*"))
+    end
+
+    should.raise RbGCCXML::SourceNotFoundError do
+      RbGCCXML.parse([full_dir("something/*"), full_dir("anotherthing/*")])
+    end
+  end
+end
+
+context "Configurable parsing configuration" do
+  specify "can give extra include directories for parsing" do
+    found = RbGCCXML.parse full_dir("headers/with_includes.h"),
+      :includes => full_dir("headers/include")
+    found.namespaces("code").should.not.be.nil
+  end
+end

data/test/structs_test.rb

@@ -0,0 +1,60 @@
+require File.dirname(__FILE__) + '/test_helper'
+
+context "Querying for structs" do
+  setup do
+    @@structs_source ||= RbGCCXML.parse(full_dir("headers/structs.h")).namespaces("structs")
+  end
+
+  specify "can find all structs in a given namespace" do
+    structs = @@structs_source.structs
+    structs.size.should == 3 
+
+    %w(Test1 Test2 Test3).each do |t|
+      assert structs.detect {|c| c.node == @@structs_source.structs(t).node }, 
+        "unable to find node for #{t}"
+    end
+  end
+
+  specify "can find structs within structs" do
+    test1 = @@structs_source.structs.find(:name => "Test1")
+    test1.should.not.be.nil
+    
+    inner1 = test1.structs("Inner1")
+    inner1.should.not.be.nil
+    
+    inner2 = inner1.structs("Inner1")
+    inner2.should.not.be.nil
+  end
+
+  specify "can find out which file said class is in" do
+    test1 = @@structs_source.structs.find(:name => "Test1")
+    test1.file_name.should == "structs.h"
+  end
+end
+
+context "Querying for struct constructors" do
+  setup do
+    @@structs_source ||= RbGCCXML.parse(full_dir("headers/structs.h")).namespaces("structs")
+  end
+
+  specify "should have a list of constructors" do
+    test1 = @@structs_source.structs.find(:name => "Test1")
+    test1.constructors.size.should == 1
+
+    test2 = @@structs_source.structs.find(:name => "Test2")
+    test2.constructors.size.should == 2
+  end
+
+  specify "constructors should have arguments" do
+    test2 = @@structs_source.structs.find(:name => "Test2")
+    test2.constructors.size.should == 2
+
+    default = test2.constructors[0]
+    default.arguments.size.should == 0
+
+    specific = test2.constructors[1]
+    specific.arguments.size.should == 1
+    assert(specific.arguments[0].cpp_type == "int")
+  end
+end
+

data/test/test_helper.rb

@@ -0,0 +1,14 @@
+$: << File.expand_path(File.dirname(__FILE__) + "/../lib")
+
+require 'rubygems'
+require 'test/spec'
+require 'rbgccxml'
+
+class Test::Unit::TestCase
+
+  def full_dir(path)
+    File.expand_path(File.join(File.dirname(__FILE__), path))
+  end
+
+end
+

data/test/types_test.rb

@@ -0,0 +1,41 @@
+require File.dirname(__FILE__) + '/test_helper'
+
+context "Proper Type handling" do
+
+  setup do
+    @@types_source ||= RbGCCXML.parse(full_dir("headers/types.h")).namespaces("types")
+  end
+
+  specify "fundamental types" do
+    assert @@types_source.functions.find(:returns => "int") == "returnsInt"
+    assert @@types_source.functions.find(:returns => "float") == "returnsFloat"
+  end
+
+  xspecify "unsigned fundamental types" do
+  end
+
+  specify "typedefs" do
+    assert @@types_source.functions.find(:returns => "myLongType") == "returnsLongType"
+    assert @@types_source.functions.find(:returns => "myShortType") == "returnsShortType"
+  end
+
+  specify "user defined types (classes / structs)" do
+    assert @@types_source.functions.find(:returns => "user_type") == "returnsUserType"
+    assert @@types_source.functions.find(:returns => "struct_type") == "returnsStructType"
+  end
+
+  # Are these three necessary or can it be just one?
+  specify "pointers to user defined types" do
+    assert @@types_source.functions.find(:returns => "user_type*") == "returnsUserTypePointer"
+    assert @@types_source.functions.find(:returns => "struct_type*") == "returnsStructTypePointer"
+  end
+
+  specify "pointers to fundamental types" do
+    assert @@types_source.functions.find(:returns => "int*") == "returnsIntPointer"
+  end
+
+  specify "pointers to typedefs" do
+    assert @@types_source.functions.find(:returns => "myLongType*") == "returnsLongTypePointer"
+  end
+
+end

metadata

@@ -0,0 +1,98 @@
+--- !ruby/object:Gem::Specification 
+name: rbgccxml
+version: !ruby/object:Gem::Version 
+  version: "0.1"
+platform: ruby
+authors: 
+- Jason Roelofs
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2008-05-04 00:00:00 -04:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: hpricot
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - "="
+      - !ruby/object:Gem::Version 
+        version: "0.6"
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: gccxml_gem
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - "="
+      - !ruby/object:Gem::Version 
+        version: "0.9"
+    version: 
+description: 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 what you want out of the C++ source code
+email: jameskilton@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- TODO
+- Rakefile
+- lib/rbgccxml/parser.rb
+- lib/rbgccxml/nodes/types/fundamental_type.rb
+- lib/rbgccxml/nodes/types/pointer_type.rb
+- lib/rbgccxml/nodes/types/typedef.rb
+- lib/rbgccxml/nodes/struct.rb
+- lib/rbgccxml/nodes/function.rb
+- lib/rbgccxml/nodes/file.rb
+- lib/rbgccxml/nodes/namespace.rb
+- lib/rbgccxml/nodes/argument.rb
+- lib/rbgccxml/nodes/type.rb
+- lib/rbgccxml/nodes/constructor.rb
+- lib/rbgccxml/nodes/method.rb
+- lib/rbgccxml/nodes/class.rb
+- lib/rbgccxml/query_result.rb
+- lib/rbgccxml/xml_parsing.rb
+- lib/rbgccxml/node.rb
+- lib/rbgccxml/rbgccxml.rb
+- lib/jamis.rb
+- lib/rbgccxml.rb
+has_rdoc: false
+homepage: http://rbplusplus.rubyforge.org/rbgccxml
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: rbplusplus
+rubygems_version: 1.1.1
+signing_key: 
+specification_version: 2
+summary: Ruby interface to GCCXML
+test_files: 
+- test/classes_test.rb
+- test/node_test.rb
+- test/methods_test.rb
+- test/structs_test.rb
+- test/parser_test.rb
+- test/functions_test.rb
+- test/test_helper.rb
+- test/types_test.rb
+- test/namespaces_test.rb