rbgccxml 0.9.1 → 1.0

data/lib/rbgccxml/parser.rb

@@ -58,11 +58,13 @@ module RbGCCXML
         xml_file = @xml_file
       end
 
-      document = Nokogiri::XML(::File.read(xml_file))
-      # Everything starts at the :: Namespace
-      global_ns = document.search("//Namespace[@name='::']")[0]
-      XMLParsing.doc_root = document
-      Namespace.new global_ns
+      NodeCache.clear
+
+      parser = SAXParser.new(xml_file)
+
+      # Runs the SAX parser and returns the root level node
+      # which will be the Namespace node for "::"
+      parser.parse
     end
 
     private

data/lib/rbgccxml/query_result.rb

@@ -72,7 +72,7 @@ module RbGCCXML
 
       if options[0] == :all
         node_type = self[0].class.to_s.split(/::/)[-1]
-        query_set = XMLParsing.find_all(:node_type => node_type)
+        query_set = NodeCache.all(node_type)
         options = options[1]
       else
         options = options[0]
@@ -149,7 +149,13 @@ module RbGCCXML
     # one Node is being returned by the Enumerable#find_all, returns that
     # single node.
     def find_all(&block)
-      res = super
+      res = QueryResult.new(super)
+      res.length == 1 ? res[0] : res
+    end
+
+    # Same with #find_all, force to work as a QueryResult
+    def select(&block)
+      res = QueryResult.new(super)
       res.length == 1 ? res[0] : res
     end
 

data/lib/rbgccxml/sax_parser.rb

@@ -0,0 +1,69 @@
+module RbGCCXML
+
+  # Use SAX to parse the generated xml file.
+  # This will end up building the full tree of RbGCCXML::Nodes
+  # that fit the parsed C++ code.
+  class SAXParser
+    def initialize(xml_file)
+      @file = xml_file
+      @parser = Nokogiri::XML::SAX::Parser.new(ParserEventHandler.new)
+    end
+
+    # Kick off the process. When the parsing finishes, we take
+    # the root node of the tree and return it
+    def parse
+      @parser.parse(::File.open(@file))
+      NodeCache.root
+    end
+  end
+
+  # Our SAX Events handler class
+  class ParserEventHandler < Nokogiri::XML::SAX::Document
+
+    # Ignore types we don't handle yet
+    IGNORE_NODES = %w(
+      GCC_XML
+      Ellipsis
+      OperatorMethod
+      OperatorFunction
+      Unimplemented
+      Converter
+      OffsetType
+    )
+
+    # Some nodes are actually stored in XML as nested structures
+    NESTED_NODES = %w(Argument Base EnumValue)
+
+    def start_element(name, attributes = [])
+      attr_hash = Hash[*attributes]
+
+      # Need to build a node in memory for those
+      # that we don't directly support
+      if IGNORE_NODES.include?(name)
+        name = "Node"
+      end
+
+      node = RbGCCXML.const_get(name).new(attr_hash)
+
+      if NESTED_NODES.include?(name)
+        # Don't save node to cache. These nodes don't have
+        # ids on which we can index off of
+        @context_node.children << node
+        node.parent = @context_node
+      else
+        # Save node to node cache
+        NodeCache << node
+
+        # Save node for any XML children it might have later
+        @context_node = node
+      end
+    end
+
+    # Once the document is done parsing we process our node tree
+    def end_document
+      NodeCache.process_tree
+    end
+
+  end
+
+end

data/lib/rbgccxml.rb

@@ -1,13 +1,15 @@
 require 'gccxml'
 
 require 'rbgccxml/rbgccxml'
+require 'vendor/facets/once'
 
 module RbGCCXML
 
   # Core classes
   autoload :Node,             "rbgccxml/node"
   autoload :Parser,           "rbgccxml/parser"
-  autoload :XMLParsing,       "rbgccxml/xml_parsing"
+  autoload :SAXParser,        "rbgccxml/sax_parser"
+  autoload :NodeCache,        "rbgccxml/node_cache"
   autoload :QueryResult,      "rbgccxml/query_result"
 
   # Nodes

data/lib/vendor/facets/once.rb

@@ -0,0 +1,59 @@
+module Kernel #:nodoc:
+
+  # Directive for making your functions faster by trading
+  # space for time. When you "memoize" a method/function
+  # using #once its results are cached so that later calls
+  # with the same arguments return results from the cache
+  # instead of recalculating them.
+  #
+  #   class T
+  #     def initialize(a)
+  #       @a = a
+  #     end
+  #     def a
+  #       "#{@a ^ 3 + 4}"
+  #     end
+  #     once :a
+  #   end
+  #
+  #   t = T.new
+  #   t.a.__id__ == t.a.__id__  #=> true
+  #
+  # This method can also be used at the instance level
+  # to cache singleton/eigen methods.
+  #
+  # Note, this method used to be called +cache+ along with
+  # it's other alias #memoize, but +once+ is the term used
+  # in PickAxe so it has been adopted instead. The #memoize
+  # alias has also been retained.
+  #
+  # CREDIT Robert Feldt
+  #
+  def once(*ids)
+    if ids.empty?
+      @_once ||= Hash::new{|h,k| h[k]={}}
+    else
+      base = (Module === self ? self : (class << self; self; end))
+      ids.each do |m|
+        base.module_eval <<-code
+          alias_method '#{ m }:once', '#{ m }'
+          private '#{ m }:once'
+          def #{ m }(*__a__,&__b__)
+            c = once['#{ m }']
+            k = [__a__,__b__]
+            if c.has_key? k
+              c[k]
+            else
+              c[k] = __send__('#{ m }:once',*__a__,&__b__)
+            end
+          end
+        code
+      end
+    end
+  end
+
+  # +once+ is also widely known as +memoize+.
+  alias_method :memoize, :once
+
+end
+

data/test/arguments_test.rb

@@ -1,29 +1,29 @@
 require "test_helper"
 
-context "Function and Method Arguments" do
+describe "Function and Method Arguments" do
 
-  setup do
-    @@arguments_source ||= RbGCCXML.parse(full_dir("headers/functions.h")).namespaces("functions")
+  before(:all) do
+    @arguments_source = RbGCCXML.parse(full_dir("headers/functions.h")).namespaces("functions")
   end
 
   specify "have type and to_cpp" do
-    test1 = @@arguments_source.functions("test1")
-    test1.arguments.length.should.equal 2
+    test1 = @arguments_source.functions("test1")
+    test1.arguments.length.should == 2
 
-    test1.arguments[0].to_cpp.should.equal "int x"
-    test1.arguments[0].cpp_type.to_cpp.should.equal "int"
+    test1.arguments[0].to_cpp.should == "int x"
+    test1.arguments[0].cpp_type.to_cpp.should == "int"
 
-    test1.arguments[1].to_cpp.should.equal "double y"
-    test1.arguments[1].cpp_type.to_cpp.should.equal "double"
+    test1.arguments[1].to_cpp.should == "double y"
+    test1.arguments[1].cpp_type.to_cpp.should == "double"
   end
 
   specify "can have a default value" do
-    test1 = @@arguments_source.functions("test1")
-    test1.arguments[0].value.should.be nil
-    test1.arguments[1].value.should.equal "3.0e+0"
+    test1 = @arguments_source.functions("test1")
+    test1.arguments[0].value.should be_nil
+    test1.arguments[1].value.should == "3.0e+0"
 
-    rockin = @@arguments_source.functions("rockin")
-    rockin.arguments[1].value.should.equal "functions::test()"
+    rockin = @arguments_source.functions("rockin")
+    rockin.arguments[1].value.should == "functions::test()"
   end
 end
 

data/test/classes_test.rb

@@ -1,197 +1,202 @@
 require "test_helper"
 
-context "Querying for classes" do
-  setup do
+describe "Querying for classes" do
+  before 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.equal 4
+    classes.size.should == 4
 
-    classes.find(:name => "Test1").should.not.be.nil
-    classes.find(:name => "Test2").should.not.be.nil
-    classes.find(:name => "Test3").should.not.be.nil
+    classes.find(:name => "Test1").should_not be_nil
+    classes.find(:name => "Test2").should_not be_nil
+    classes.find(:name => "Test3").should_not be_nil
   end
 
   specify "can find classes within classes" do
     test1 = @source.classes.find(:name => "Test1")
-    test1.should.not.be.nil
-    test1.should.be.kind_of RbGCCXML::Class
-    test1.name.should.equal "Test1"
+    test1.should_not be_nil
+    test1.should be_kind_of(RbGCCXML::Class)
+    test1.name.should == "Test1"
 
     inner1 = test1.classes("Inner1")
-    inner1.should.not.be.nil
-    inner1.should.be.kind_of RbGCCXML::Class
-    inner1.name.should.equal "Inner1"
+    inner1.should_not be_nil
+    inner1.should be_kind_of(RbGCCXML::Class)
+    inner1.name.should == "Inner1"
 
     inner2 = inner1.classes("Inner1")
-    inner2.should.not.be.nil
-    inner2.should.be.kind_of Array
-    inner2.should.be.empty
+    inner2.should_not be_nil
+    inner2.should be_kind_of(Array)
+    inner2.should be_empty
 
     inner2 = inner1.classes("Inner2")
-    inner2.should.not.be.nil
-    inner2.should.be.kind_of RbGCCXML::Class
-    inner2.name.should.equal "Inner2"
+    inner2.should_not be_nil
+    inner2.should be_kind_of(RbGCCXML::Class)
+    inner2.name.should == "Inner2"
   end
 
   specify "can find classes within classes by regex" do
     test1 = @source.classes(/t1/)
-    test1.should.not.be.nil
-    test1.should.be.kind_of RbGCCXML::Class
-    test1.name.should.equal "Test1"
+    test1.should_not be_nil
+    test1.should be_kind_of(RbGCCXML::Class)
+    test1.name.should == "Test1"
 
     inner1 = test1.classes(/In.*1/)
-    inner1.should.not.be.nil
-    inner1.should.be.kind_of RbGCCXML::Class
-    inner1.name.should.equal "Inner1"
+    inner1.should_not be_nil
+    inner1.should be_kind_of(RbGCCXML::Class)
+    inner1.name.should == "Inner1"
 
     inner2 = inner1.classes(/1/)
-    inner2.should.not.be.nil
-    inner2.should.be.kind_of Array
-    inner2.should.be.empty
+    inner2.should_not be_nil
+    inner2.should be_kind_of(Array)
+    inner2.should be_empty
 
     inner2 = inner1.classes(/2/)
-    inner2.should.not.be.nil
-    inner2.should.be.kind_of RbGCCXML::Class
-    inner2.name.should.equal "Inner2"
+    inner2.should_not be_nil
+    inner2.should be_kind_of(RbGCCXML::Class)
+    inner2.name.should == "Inner2"
   end
 
   specify "can find classes within classes by block" do
     # We're looking for any class that has virtual methods.
-    test4 = @source.classes { |c| c.methods.any? { |m| m.virtual? } }
-    test4.should.not.be.nil
-    test4.should.be.kind_of RbGCCXML::Class
-    test4.name.should.equal "Test4"
+    test4 = @source.classes.select { |c| c.methods.any? { |m| m.virtual? } }
+    test4.should_not be_nil
+    test4.should be_kind_of(RbGCCXML::Class)
+    test4.name.should == "Test4"
 
     # Fail case -- there's no methods that return double.
-    test0 = @source.classes { |c| c.methods.any? { |m| m.return_type == "double" }}
-    test0.should.not.be.nil
-    test0.should.be.kind_of Array
-    test0.should.be.empty
+    test0 = @source.classes.select { |c| c.methods.any? { |m| m.return_type == "double" }}
+    test0.should_not be_nil
+    test0.should be_kind_of(Array)
+    test0.should be_empty
   end
 
   specify "can tell if a class is pure virtual" do
     test1 = @source.classes("Test1")
     test4 = @source.classes("Test4")
 
-    test1.pure_virtual?.should.be false
-    test4.pure_virtual?.should.be true
+    test1.pure_virtual?.should be_false
+    test4.pure_virtual?.should be_true
   end
 end
 
-context "Querying for class constructors" do
-  setup do
+describe "Querying for class constructors" do
+  before 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.equal 2
+    test1.constructors.size.should == 2
 
     test2 = @source.classes.find(:name => "Test2")
-    test2.constructors.size.should.equal 3
+    test2.constructors.size.should == 3
   end
 
   specify "constructors should have arguments" do
     test2 = @source.classes.find(:name => "Test2")
-    test2.constructors.size.should.equal 3
+    test2.constructors.size.should == 3
 
     # GCC generated copy constructors
     copy = test2.constructors[0]
-    copy.attributes[:artificial].should.equal "1"
+    copy.artificial?.should be_true
 
     default = test2.constructors[1]
-    default.arguments.size.should.equal 0
+    default.arguments.size.should == 0
 
     specific = test2.constructors[2]
-    specific.arguments.size.should.equal 1
-    specific.arguments[0].cpp_type.name.should.equal "int"
+    specific.arguments.size.should == 1
+    specific.arguments[0].cpp_type.name.should == "int"
   end
 end
 
-context "Querying for the class's deconstructor" do
-  setup do
+describe "Querying for the class's deconstructor" do
+  before do
     @source ||= RbGCCXML.parse(full_dir("headers/classes.h")).namespaces("classes")
   end
 
   specify "can tell if a class has an explicit destructor" do
     test1 = @source.classes("Test1")
-    test1.destructor.should.not.be.nil
-    test1.destructor.attributes[:artificial].should.be.nil
+    test1.destructor.should_not be_nil
+    test1.destructor.artificial?.should be_false
 
     test2 = @source.classes("Test2")
-    test2.destructor.should.not.be.nil
-    test2.destructor.attributes[:artificial].should.not.be.nil
+    test2.destructor.should_not be_nil
+    test2.destructor.artificial?.should be_true
   end
 
 end
 
-context "Query for class variables" do
-  setup do
+describe "Query for class variables" do
+  before do
     @source ||= RbGCCXML.parse(full_dir("headers/classes.h")).namespaces("classes")
   end
 
   specify "find all i-vars" do
     test1 = @source.classes("Test1")
-    test1.variables.length.should.equal 4
+    test1.variables.length.should == 4
   end
 
   specify "can find by access level" do
     test1 = @source.classes("Test1")
-    test1.variables.find(:access => "public").length.should.equal 2
-    test1.variables.find(:access => "protected").name.should.equal "protVariable"
-    test1.variables.find(:access => "private").name.should.equal "privateVariable"
+    test1.variables.find(:access => "public").length.should == 2
+    test1.variables.find(:access => "protected").name.should == "protVariable"
+    test1.variables.find(:access => "private").name.should == "privateVariable"
   end
 end
 
-context "Query inheritance heirarchy" do
-  setup do
+describe "Query inheritance heirarchy" do
+  before do
     @source ||= RbGCCXML.parse(full_dir("headers/inheritance.h")).namespaces("inheritance")
   end
 
   specify "can find a class's superclass" do
     pc = @source.classes("ParentClass")
-    pc.superclass.should.be.nil
+    pc.superclass.should be_nil
 
     base1 = @source.classes("Base1")
-    base1.superclass.should.not.be.nil
-    base1.superclass.name.should.equal "ParentClass"
+    base1.superclass.should_not be_nil
+    base1.superclass.name.should == "ParentClass"
   end
 
   specify "can query for multiple inheritance" do
     multi = @source.classes("MultiBase")
-    multi.superclasses.length.should.equal 2
-    assert multi.superclasses.select {|sp| sp.name == "ParentClass"}
-    assert multi.superclasses.select {|sp| sp.name == "Parent2"}
+    multi.superclasses.length.should == 2
+    multi.superclasses.select {|sp| sp.name == "ParentClass"}.should_not be_nil
+    multi.superclasses.select {|sp| sp.name == "Parent2"}.should_not be_nil
   end
 
   specify "calling #superclasses always returns an array" do
     pc = @source.classes("ParentClass")
-    pc.superclasses.should.be.empty
+    pc.superclasses.should be_empty
 
     base1 = @source.classes("Base1")
-    base1.superclasses.length.should.equal 1
-    base1.superclasses[0].name.should.equal "ParentClass"
+    base1.superclasses.length.should == 1
+    base1.superclasses[0].name.should == "ParentClass"
   end
 
   specify "can infinitely climb the inheritance heirarchy" do
     low = @source.classes("VeryLow")
-    low.superclass.superclass.superclass.name.should.equal "ParentClass"
+    low.superclass.superclass.superclass.name.should == "ParentClass"
   end
 
   specify "can query for types of inheritance" do
     pvb1 = @source.classes("PrivateBase1")
-    pvb1.superclass(:public).should.be.nil
-    pvb1.superclass(:protected).should.be.nil
-    pvb1.superclass(:private).should.not.be.nil
+    pvb1.superclass(:public).should be_nil
+    pvb1.superclass(:protected).should be_nil
+    pvb1.superclass(:private).should_not be_nil
 
-    pvb1.superclass(:private).name.should.equal "ParentClass"
+    pvb1.superclass(:private).name.should == "ParentClass"
 
-    pvb1.superclasses(:public).length.should.equal 0
-    pvb1.superclasses(:protected).length.should.equal 0
-    pvb1.superclasses(:private).length.should.equal 1
+    pvb1.superclasses(:public).length.should == 0
+    pvb1.superclasses(:protected).length.should == 0
+    pvb1.superclasses(:private).length.should == 1
+
+    vlow = @source.classes("VeryLow")
+    vlow.superclasses(:public).length.should == 1
+    vlow.superclasses(:private).length.should == 0
+    vlow.superclasses(:protected).length.should == 1
   end
 
 end

data/test/enumerations_test.rb

@@ -1,51 +1,49 @@
 require "test_helper"
 
-context "Querying for enumerations" do
-  setup do
-    @@enum_source ||= RbGCCXML.parse(full_dir("headers/enums.h")).namespaces("enums")
+describe "Querying for enumerations" do
+  before(:all) 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.equal 3
+    enums = @enum_source.enumerations
+    enums.length.should == 3
   end
 
   specify "can find specific enum values" do
-    enum = @@enum_source.enumerations("TestEnum")
-    enum.values.length.should.equal 3
-    enum.values[0].name.should.equal "VALUE1"
-    enum.values[1].name.should.equal "VALUE2"
-    enum.values[2].name.should.equal "VALUE3"
+    enum = @enum_source.enumerations("TestEnum")
+    enum.values.length.should == 3
+    enum.values[0].name.should == "VALUE1"
+    enum.values[1].name.should == "VALUE2"
+    enum.values[2].name.should == "VALUE3"
   end
 
   specify "can find the given value of enum entries" do
-    enum = @@enum_source.enumerations.find(:name => "MyEnum")
-    enum.values[0].value.should.equal 3
-    enum.values[1].value.should.equal 4
-    enum.values[2].value.should.equal 7
+    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.equal 3
-    enum.values[0].qualified_name.should.equal "enums::VALUE1"
-    enum.values[1].qualified_name.should.equal "enums::VALUE2"
-    enum.values[2].qualified_name.should.equal "enums::VALUE3"
-
-    enum = @@enum_source.classes("Inner").enumerations("InnerEnum")
-    enum.values[0].qualified_name.should.equal "enums::Inner::INNER_1"
-    enum.values[1].qualified_name.should.equal "enums::Inner::INNER_2"
+    enum = @enum_source.enumerations("TestEnum")
+    enum.values.length.should == 3
+    enum.values[0].qualified_name.should == "enums::VALUE1"
+    enum.values[1].qualified_name.should == "enums::VALUE2"
+    enum.values[2].qualified_name.should == "enums::VALUE3"
+
+    enum = @enum_source.classes("Inner").enumerations("InnerEnum")
+    enum.values[0].qualified_name.should == "enums::Inner::INNER_1"
+    enum.values[1].qualified_name.should == "enums::Inner::INNER_2"
   end
 
   specify "knows if an enumeration is anonymous" do
-    found = @@enum_source.enumerations.select {|e| e.anonymous? }
-    found.length.should.equal 1
-    found = found[0]
-
-    assert found.is_a?(RbGCCXML::Enumeration)
-    found.values[0].value.should.equal 0
-    found.values[1].value.should.equal 1
-    found.values[2].value.should.equal 2
+    found = @enum_source.enumerations.select {|e| e.anonymous? }
+
+    found.should be_a(RbGCCXML::Enumeration)
+    found.values[0].value.should == 0
+    found.values[1].value.should == 1
+    found.values[2].value.should == 2
   end
 
 end

data/test/function_pointers_test.rb

@@ -1,18 +1,18 @@
 require "test_helper"
 
-context "Function pointers" do
-  setup do
-    @@fp_source ||= RbGCCXML.parse(full_dir("headers/types.h")).namespaces("types")
+describe "Function pointers" do
+  before(:all) do
+    @fp_source = RbGCCXML.parse(full_dir("headers/types.h")).namespaces("types")
   end
 
   specify "have arguments" do
-    fp = @@fp_source.functions("takesCallback").arguments[0].cpp_type.base_type
+    fp = @fp_source.functions("takesCallback").arguments[0].cpp_type.base_type
     fp.arguments.length.should == 1
-    fp.arguments[0].cpp_type.name.should.equal "int"
+    fp.arguments[0].cpp_type.name.should == "int"
   end
 
   specify "have return value" do
-    fp = @@fp_source.functions("takesCallbackWithReturn").arguments[0].cpp_type.base_type
-    fp.return_type.name.should.equal "int"
+    fp = @fp_source.functions("takesCallbackWithReturn").arguments[0].cpp_type.base_type
+    fp.return_type.name.should == "int"
   end
 end