doxyparser 1.3 → 1.5

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: ddb97c91354a56d85495ca4dd7fdda3be9d02806
+  data.tar.gz: 78a25a5f867401e60d7212433cdb8a9d36debf74
+SHA512:
+  metadata.gz: db5492d5aef0f23620ea7cd3af58726feae425fa83389195eb25f6dca1ff498bef49e1f591b4ad26ee4d5148d7f42b5920f7f4df629a702a368a8da646c50600
+  data.tar.gz: 8f26ecc142d43c7f71d3de4df6970d3b260aff6ffe626d7761749946996f2bc78da3a184d479458fc4b12f3f700446cc09228e0380b61f77fdc7024bda14b107

data/lib/doxyparser.rb

@@ -13,10 +13,10 @@ require_relative 'nodes/typedef'
 require_relative 'nodes/friend'
 require_relative 'nodes/struct'
 require_relative 'nodes/class'
+require_relative 'nodes/enum_value'
 require_relative 'nodes/enum'
 require_relative 'nodes/hfile'
 require_relative 'nodes/function'
-require_relative 'nodes/group'
 require_relative 'nodes/namespace'
 require_relative 'nodes/variable'
 
@@ -24,27 +24,47 @@ require_relative 'nodes/variable'
 module Doxyparser
 
   class << self
+  	
+  	# Retrieves metadata for a given Namespace
+    # @param basename [String] Name of the namespace to parse (for instance: NamespaceA::NamespaceB)
+    # @param xml_dir [String] Path to the directory with the generated intermediate XML representation
+    # @return [Namespace] A tree of objects representing the namespace and its members (classes, structs, enums, etc)
     def parse_namespace basename, xml_dir
       Doxyparser::Namespace.new :name => basename, :dir => xml_dir
     end
 
-    def parse_group basename, xml_dir
-      Doxyparser::Group.new :name => basename, :dir => xml_dir
-    end
-
+		# Retrieves metadata for a given Class
+    # @param basename [String] Name of the class to parse (for instance: MyNamespace::MyClass)
+    # @param xml_dir [String] Path to the directory with the generated intermediate XML representation
+    # @return [Class] A tree of objects representing the class and its members (attributes, methods, innerclasses, etc) 
     def parse_class basename, xml_dir
       Doxyparser::Class.new :name => basename, :dir => xml_dir
     end
 
-    def parse_struct basename, xml_dir
+		# Retrieves metadata for a given Struct
+    # @param basename [String] Name of the struct to parse (for instance: MyNamespace::MyStruct)
+    # @param xml_dir [String] Path to the directory with the generated intermediate XML representation
+    # @return [Struct] A tree of objects representing the struct and its members (attributes, methods, enums, etc) 
+    def parse_struct(basename, xml_dir)
       Doxyparser::Struct.new :name => basename, :dir => xml_dir
     end
-
-    def parse_file basename, xml_dir
+    
+		# Retrieves metadata for a given header file
+    # @param basename [String] Name of the header file to parse (for instance: myheader.h)
+    # @param xml_dir [String] Path to the directory with the generated intermediate XML representation
+    # @return [HFile] A tree of objects representing the header file and its contents (classes, functions, enums, etc)
+    def parse_file(basename, xml_dir)
       Doxyparser::HFile.new :name => basename, :dir => xml_dir
     end
     
-    def gen_xml_docs source_dirs, xml_dir, recursive = nil, include_dirs = nil, generate_html = nil
+    # Generates intermediate XML representation for a group of header files
+    # @param source_dirs [Array<String>, String] Input source directory (or directories)
+    # @param xml_dir [String] Output Directory for the generated XML documents
+    # @param recursive if present (and not nil) sets the RECURSIVE FLAG in Doxygen. Subdirectories will also be searched 
+    # @param include_dirs [Array<String>, String] Adds given directories to Doxygen's INCLUDE_PATH (Doxyfile variable)
+    # @param generate_html if present (and not nil) HTML documentation will also be generated 
+    # @param stl_support if present (and not nil) sets the BUILTIN_STL_SUPPORT flag in Doxygen. Special support for STL Libraries
+    def gen_xml_docs(source_dirs, xml_dir, recursive = nil, include_dirs = nil, generate_html = nil, stl_support = 1)
     	
     	if include_dirs.nil? || include_dirs.empty?
     		inc_dirs = ''
@@ -66,10 +86,11 @@ module Doxyparser
     	recursive = recursive ? 'YES' : 'NO'    	
     	home_dir = Doxyparser::Util.home_dir
     	gen_html = generate_html ? 'YES' : 'NO'
+    	stl_support = stl_support ? 'YES' : 'NO'
       doxyfile =  "# Doxyfile 1.7.6.1\n\n"
       doxyfile << "# Project related configuration options\n\n"
       doxyfile << %Q{PROJECT_NAME\t\t= "#{proj_name}"\nINPUT\t\t\t\t= #{src_dirs}\nGENERATE_HTML\t\t= #{gen_html}\n}
-      doxyfile << %Q{RECURSIVE\t\t\t= #{recursive}\nINCLUDE_PATH\t\t= #{inc_dirs}\n\n}
+      doxyfile << %Q{RECURSIVE\t\t\t= #{recursive}\nINCLUDE_PATH\t\t= #{inc_dirs}\nBUILTIN_STL_SUPPORT\t= #{stl_support}\n}
       doxyfile << "# Default doxygen configuration options\n\n"
       doxyfile << Doxyparser::Util.read_file(home_dir+'/resources/Doxyfile')
       doxyfile_path = xml_dir+'/Doxyfile'

data/lib/nodes/class.rb

@@ -1,5 +1,6 @@
 module Doxyparser
 
+	# Just like an {Struct} but with different naming conventions 
   class Class < Struct
 
     private

data/lib/nodes/compound.rb

@@ -1,13 +1,10 @@
 module Doxyparser
 
+	# Representation of a 'high level' {Node} which is represented in its own XML file such as namespaces, classes, etc
   class Compound < Node
 
     attr_reader :xml_path
 
-    def new_unnamed
-      @unnamed += 1
-    end
-
     private
 
     def init_attributes

data/lib/nodes/enum.rb

@@ -1,20 +1,33 @@
 module Doxyparser
 
+	# A C/C++ Enumeration
   class Enum < Member
 
-    def values
-      ret=[]
-      xpath("enumvalue/name").each { |v| ret << v.child.content }
-      ret
-    end
+		# [Array<EnumValue>] List of values
+    attr_reader :values
 
     private
 
+    def init_attributes
+      super
+      @values= []
+      all_values = self.xpath("enumvalue")
+      return if all_values.nil? || all_values.empty?
+      all_values.each { |enumvalue|
+        @values << Doxyparser::EnumValue.new(node: enumvalue, parent: self)
+      }
+    end
+
     def find_name
       super.gsub(/@\d*/) {
-        num = parent.new_unnamed
-        '_Enum' +  (num == 1 ? '' : num.to_s)
+        prefix = (parent.class == Doxyparser::Namespace) ? 'ns_' : ''
+        if (parent.class == Doxyparser::HFile)
+        	enum_name = 'file_' + escape_file_name(parent.basename.gsub(/\.\w+$/, '')) 
+        else
+        	enum_name = parent.basename
+        end
+        "#{prefix}#{enum_name}_Enum"
       }
     end
   end
-end
+end

data/lib/nodes/enum_value.rb

@@ -0,0 +1,20 @@
+module Doxyparser
+
+	# Every one of the members of an {Enum} 
+  class EnumValue < Node
+  	
+		attr_reader :initializer
+		
+		private
+		
+		def find_name
+			@parent.name + '::' + @node.xpath("name")[0].child.content
+		end
+		
+		def init_attributes
+      super
+      aux_initializer = @node.xpath("initializer")
+      @initializer = aux_initializer[0].child.content.strip unless (aux_initializer.nil? || aux_initializer.empty?)
+    end
+  end
+ end

data/lib/nodes/friend.rb

@@ -1,11 +1,14 @@
 module Doxyparser
 
+	# A friend member declared inside a C++ {Class}. Can itself refer to an external {Function} or {Class}
   class Friend < Member
 
+		# @return true if the friend declaration refers to a {Class} false if refers to a {Function}
     def is_class?
       args.nil? || args == ""
     end
 
+		# @return true if the name used in the declaration is fully qualified (using the '::' operator) false otherwise
     def is_qualified?
       basename.include? '::'
     end

data/lib/nodes/function.rb

@@ -1,35 +1,27 @@
 module Doxyparser
 
+	# A C/C++ function with its parameters und return type 
   class Function < Member
 
-    def == another
-      super
-      self.args == another.args
-    end
-
-    def eql?(another)
-      super
-      self.args == another.args
-    end
-
-    def to_str
-      super + @args
-    end
-
-    def to_s
-      super + @args
-    end
-
+	  # @return true if the function is a constructor of a {Struct} or {Class}
     def constructor?
       @basename == parent.basename
     end
 
+		# @return true if the function is a destructor of a {Struct} or {Class}
     def destructor?
       @basename.start_with? %Q{~}
     end
 
-    def getter_for
-      if @params.empty? || (@params.size == 1 && @params[0].type.name =~ /\s*void\s*/)
+		# Finds the name of the -hypothetical- property this method refers to in case this {Function} complies 
+		# with the 'getter' naming convention and has no parameters.  
+		# Getter examples for 'myProperty' are: getMyProperty, get_myProperty, GetMyProperty, Get_MyProperty, etc
+		# Getter examples for 'booleanProp' are: isBooleanProp, is_booleanProp, get_booleanProp, etc  
+		# @return [String] name of the property  
+    def getter_for    	
+    	return nil if @type.name == 'void'
+    	
+      if @params.empty? || (@params.size == 1 && @params[0].type.name.strip == 'void')
         if @basename.start_with?('get') || @basename.start_with?('Get')
           ret = @basename.gsub(/^get[_]?(\w)/i) { |match| $1.downcase }
           ret.prepend('_') if ret =~ %r{^\d}
@@ -46,8 +38,12 @@ module Doxyparser
       return nil
     end
 
+	  # Finds the name of the -hypothetical- property this method refers to in case this {Function} complies 
+		# with the 'setter' naming convention and has no return value (void).  
+		# Setter examples for 'myProperty' are: setMyProperty, set_myProperty, SetMyProperty, Set_MyProperty, etc
+		# @return [String] name of the property  
     def setter_for
-      if (@type.name == 'void') && (@params.size == 1)
+      if (@type.name == 'void') && (@params.size == 1 && @params[0].type.name.strip != 'void')
         if @basename.start_with?('set') || @basename.start_with?('Set')
           ret = @basename.gsub(/^set[_]?(\w)/i) { |match| $1.downcase }
           ret.prepend('_') if ret =~ %r{^\d}
@@ -56,5 +52,23 @@ module Doxyparser
       end
       return nil
     end
+    
+    def == another
+      super
+      self.args == another.args
+    end
+
+    def eql?(another)
+      super
+      self.args == another.args
+    end
+    
+    def to_str
+      super + @args
+    end
+
+    def to_s
+      super + @args
+    end
   end
 end

data/lib/nodes/hfile.rb

@@ -1,64 +1,61 @@
 module Doxyparser
 
+	# Representation of a C/C++ header file
   class HFile < Compound
 
+	  # @return [Array<String>] names for all header files which are listed as include statements in this header file
     def list_included
-      lst=doc.xpath(%Q{/doxygen/compounddef/includes})
-      lst.map { |f| f.child.content }
+      @list_included ||= doc.xpath(%Q{/doxygen/compounddef/includes}).map { |f| f.child.content }
     end
-
-    def list_including
-      lst=doc.xpath(%Q{/doxygen/compounddef/includedby})
-      lst.map { |f| f[:refid].nil? ? f.child.content : escape_file_name(f[:refid]) }
+    
+		# @return [Array<HFile>] local header files which are listed as include statements in this header file
+    def files_included
+      @files_included ||= doc.xpath(%Q{/doxygen/compounddef/includes[@local="yes"]}).map { |f| 	Doxyparser::HFile.new(dir: @dir, node: f) }
     end
 
-    def files_included
-      lst=doc.xpath(%Q{/doxygen/compounddef/includes[@local="yes"]})
-      lst.map { |f| 
-      	Doxyparser::HFile.new(dir: @dir, node: f) 
-      }
+		# @return [Array<String>] names for all header files which refer to this one in their include statements
+    def list_including
+      @list_including ||= doc.xpath(%Q{/doxygen/compounddef/includedby}).map { |f| f[:refid].nil? ? f.child.content : escape_file_name(f[:refid]) }
     end
 
+	 	# @return [Array<HFile>] local header files which refer to this one in their include statements
     def files_including
-      lst=doc.xpath(%Q{/doxygen/compounddef/includedby[@local="yes"]})
-      lst.map { |f| Doxyparser::HFile.new(dir: @dir, node: f) }
+      @files_including ||= doc.xpath(%Q{/doxygen/compounddef/includedby[@local="yes"]}).map { |f| Doxyparser::HFile.new(dir: @dir, node: f) }
     end
-
+	
+		# @return [Array<Struct>] structs declared inside this header file
     def structs
-      lst=doc.xpath(%Q{/doxygen/compounddef/innerclass})
-      lst = lst.select { |c| c["refid"].start_with?("struct") }
-      lst.map { |node| Doxyparser::Struct.new(dir: @dir, node: node) }
+      @structs ||= doc.xpath(%Q{/doxygen/compounddef/innerclass}).select { |c| c["refid"].start_with?("struct") }.map { |node| Doxyparser::Struct.new(dir: @dir, node: node) }
     end
 
+		# @return [Array<Class>] classes declared inside this header file
     def classes
-      lst=doc.xpath(%Q{/doxygen/compounddef/innerclass})
-      lst = lst.select { |c| c["refid"].start_with?("class") }
-      lst.map { |node| Doxyparser::Class.new(dir: @dir, node: node) }
+      @classes ||= doc.xpath(%Q{/doxygen/compounddef/innerclass}).select { |c| c["refid"].start_with?("class") }.map { |node| Doxyparser::Class.new(dir: @dir, node: node) }
     end
-
+		
+		# @return [Array<Namespace>] namespaces declared inside this header file
     def namespaces
-      lst=doc.xpath(%Q{/doxygen/compounddef/innernamespace})
-      lst.map { |node| Doxyparser::Namespace.new(dir: @dir, node: node) }
+      @namespaces ||= doc.xpath(%Q{/doxygen/compounddef/innernamespace}).map { |node| Doxyparser::Namespace.new(dir: @dir, node: node) }
     end
-
+	
+	  # @return [Array<Function>] functions declared inside this header file	
     def functions
-      lst=doc.xpath(%Q{/doxygen/compounddef/sectiondef[@kind="func"]/memberdef[@kind="function"]})
-      lst.map { |node| Doxyparser::Function.new(parent: self, node: node) }
+      @functions ||= doc.xpath(%Q{/doxygen/compounddef/sectiondef[@kind="func"]/memberdef[@kind="function"]}).map { |node| Doxyparser::Function.new(parent: self, node: node) }
     end
-
+		
+		# @return [Array<Variable>] variables declared inside this header file
     def variables
-      lst=doc.xpath(%Q{/doxygen/compounddef/sectiondef[@kind="var"]/memberdef[@kind="variable"]})
-      lst.map { |node| Doxyparser::Variable.new(parent: self, node: node) }
+      @variables ||= doc.xpath(%Q{/doxygen/compounddef/sectiondef[@kind="var"]/memberdef[@kind="variable"]}).map { |node| Doxyparser::Variable.new(parent: self, node: node) }
     end
-
+		
+		# @return [Array<Enum>] enums declared inside this header file
     def enums
-      lst=doc.xpath(%Q{/doxygen/compounddef/sectiondef[@kind="enum"]/memberdef[@kind="enum"]})
-      lst.map { |node| Doxyparser::Enum.new(parent: self, node: node) }
+      @enums ||= doc.xpath(%Q{/doxygen/compounddef/sectiondef[@kind="enum"]/memberdef[@kind="enum"]}).map { |node| Doxyparser::Enum.new(parent: self, node: node) }
     end
 
+		# @return [Array<Typedef>] typedefs declared inside this header file
     def typedefs
-      lst=doc.xpath(%Q{/doxygen/compounddef/sectiondef[@kind="typedef"]/memberdef[@kind="typedef"]})
-      lst.map { |node| Doxyparser::Typedef.new(parent: self, node: node) }
+      @typedefs ||= doc.xpath(%Q{/doxygen/compounddef/sectiondef[@kind="typedef"]/memberdef[@kind="typedef"]}).map { |node| Doxyparser::Typedef.new(parent: self, node: node) }
     end
 
     private

data/lib/nodes/member.rb

@@ -9,6 +9,7 @@ module Doxyparser
     attr_reader :static
     attr_reader :params
 
+		# @return [HFile] header file where the declaration of this member was done
     def file
       Doxyparser::HFile.new(:name => @filename, :dir => @dir)
     end

data/lib/nodes/namespace.rb

@@ -1,59 +1,75 @@
 module Doxyparser
 
+	# A C/C++ Namespace
   class Namespace < Compound
 
+		# @return [Array<Function>] list of functions defined inside this namespace but outside any {Class} or {Struct} 
     def functions(filter=nil)
+    	return @functions if @functions
       lst = doc.xpath(%Q{/doxygen/compounddef/sectiondef[@kind="func"]/memberdef[@kind="function"]})
-      do_filter(filter, lst, Doxyparser::Function) { |node|
+      @functions = do_filter(filter, lst, Doxyparser::Function) { |node|
         node.xpath("name")[0].child.content.strip
       }
     end
 
+		# @return [Array<Enum>] list of enums defined inside this namespace but outside any {Class} or {Struct}
     def enums(filter=nil)
+    	return @enums if @enums 
       lst = doc.xpath(%Q{/doxygen/compounddef/sectiondef[@kind="enum"]/memberdef[@kind="enum"]})
-      filter.map! { |exp| exp =~ /^_Enum/ ? /@\d*/ : exp } unless filter.nil?
-      do_filter(filter, lst, Doxyparser::Enum) { |node|
+      filter.map! { |exp| exp =~ /^#{@basename}_Enum/ ? /@\d*/ : exp } unless filter.nil?
+      @enums = do_filter(filter, lst, Doxyparser::Enum) { |node|
         node.xpath("name")[0].child.content.strip
       }
     end
 
-    def variables(filter=nil)
+		# @return [Array<Variable>] list of variables defined inside this namespace but are not attributes of any {Class} or {Struct}
+		  def variables(filter=nil)
+    	return @variables if @variables
       lst = doc.xpath(%Q{/doxygen/compounddef/sectiondef[@kind="var"]/memberdef[@kind="variable"]})
-      do_filter(filter, lst, Doxyparser::Variable) { |node|
+      @variables = do_filter(filter, lst, Doxyparser::Variable) { |node|
         node.xpath("name")[0].child.content.strip
       }
     end
 
+		# @return [Array<Typedef>] list of typedefs defined inside this namespace but outside any {Class} or {Struct}
     def typedefs(filter=nil)
+    	return @typedefs if @typedefs
       lst = doc.xpath(%Q{/doxygen/compounddef/sectiondef[@kind="typedef"]/memberdef[@kind="typedef"]})
-      do_filter(filter, lst, Doxyparser::Typedef) { |node| 
+      @typedefs = do_filter(filter, lst, Doxyparser::Typedef) { |node| 
       	del_spaces(node.xpath("name")[0].child.content)
       }
     end
-
+	
+		# @return [Array<Namespace>] list of namespaces defined inside this one
     def innernamespaces(filter=nil)
+    	return @innernamespaces if @innernamespaces
       lst = doc.xpath(%Q{/doxygen/compounddef/innernamespace})
-      do_filter(filter, lst, Doxyparser::Namespace) { |node|
+      @innernamespaces = do_filter(filter, lst, Doxyparser::Namespace) { |node|
         del_spaces del_prefix_class(node.child.content)
       }
     end
 
+		# @return [Array<Struct>] list of structs defined in this namespace
     def structs(filter=nil)
+			return @structs if @structs
       lst = doc.xpath(%Q{/doxygen/compounddef/innerclass})
       lst = lst.select { |c| c["refid"].start_with?("struct") }
-      do_filter(filter, lst, Doxyparser::Struct) { |node|
+      @structs = do_filter(filter, lst, Doxyparser::Struct) { |node|
         del_spaces del_prefix_class(node.child.content)
       }
     end
 
+		# @return [Array<Class>] list of classes defined in this namespace
     def classes(filter=nil)
+    	return @classes if @classes
       lst = doc.xpath(%Q{/doxygen/compounddef/innerclass})
       lst = lst.select { |c| c["refid"].start_with?("class") }
-      do_filter(filter, lst, Doxyparser::Class) { |node|
+      @classes = do_filter(filter, lst, Doxyparser::Class) { |node|
         del_spaces del_prefix_class(node.child.content)
       }
     end
 
+	  # @return nil always 
     def file
       nil
     end

data/lib/nodes/node.rb

@@ -1,14 +1,16 @@
 module Doxyparser
 
+	# A Node can be any member of the tree-like structure of a C/C++ header file.
+	# 	examples are namespaces, classes, methods, params, etc  
   class Node
     include Doxyparser::Util
-
+    
     attr_reader :dir
     attr_reader :name
     attr_reader :basename
     attr_reader :node
     attr_reader :doc
-    attr_reader :parent
+    attr_accessor :parent
 
     def == another
       self.name == another.name
@@ -31,24 +33,30 @@ module Doxyparser
       @dir = hash[:dir]
       @name = hash[:name]
       if hash[:node] # If a reference to an xml declaration (node) is given
-        # then...
         @node = hash[:node]
         @parent = hash[:parent]
         @name = find_name
+        if @name =~ /PxVec3.h/
+        	@name = find_name
+        end
         @dir ||= @parent.dir unless @parent.nil?
       end
       raise "No name given for node: #{self.class.name}" unless @name
       raise "No xml directory given for node: #{self.class.name}" unless @dir
       init_attributes
     end
+    
+    def escaped_name
+    	name
+    end
 
     private
 
     def method_missing(sym, *args)
       if @node.respond_to?(sym)
-      @node.send(sym, *args)
+      	@node.send(sym, *args)
       else
-      @node[sym.to_s] || super
+      	@node[sym.to_s] || super
       end
     end
 

data/lib/nodes/param.rb

@@ -1,9 +1,13 @@
 module Doxyparser
 
+	# Each of the input parameters of a {Function}
 	class Param < Node
 
+		# Type of parameter
 		attr_reader :type
+		# Declared name of parameter
 		attr_reader :declname
+		# Default value of parameter
 		attr_reader :value
 		
 		private

data/lib/nodes/struct.rb

@@ -1,60 +1,105 @@
 module Doxyparser
 
+	# A plain old OOP Class 
   class Struct < Compound
-
-    def file
-      n=doc.xpath("/doxygen/compounddef/includes")[0]
-      raise "#{self.name} #{self.class.name} does not have correctly generated documentation. Use 'EXTRACT_ALL' Doxygen flag" unless n
-      HFile.new(dir: @dir, node: n)
+  	
+  	# @return [bool] true if any of its methods is 'pure virtual'
+    def abstract?
+    	@is_abstract ||= methods(:all).any? { |m| m.virt == 'pure-virtual'}
     end
-
-    def friends
-      lst=doc.xpath(%Q{/doxygen/compounddef/sectiondef[@kind="friend"]/memberdef[@kind="friend"]})
-      lst.map { |node|
-        Doxyparser::Friend.new(parent: self, node: node)
-      }
+    
+    # @param access [Symbol] access modifier (:public, :protected, :private, :all) 
+    # @return [Array<Function>] declared constructors
+    def constructors(access = :public)
+    	return case access
+    	when :public
+      	@public_constructors ||= methods(:public, nil, [@basename])
+    	when :protected
+      	@protected_constructors ||= methods(:protected, nil, [@basename])
+    	when :private
+      	@private_constructors ||= methods(:private, nil, [@basename])
+    	when :all
+    		constructors(:public) + constructors(:protected) + constructors(:private)
+   		end
     end
-
-    def template_params
-      params=doc.xpath(%Q{/doxygen/compounddef/templateparamlist/param})
-      params.map { |param|
-        Doxyparser::Param.new(parent: self, node: param)
-      }
+    
+    # @param access [Symbol] access modifier (:public, :protected, :private, :all) 
+    # @return [Array<Function>] declared destructors
+    def destructors(access = :public)
+    	return case access
+    	when :public
+      	@public_destructors ||= methods(:public, nil, [/^~/])
+    	when :protected
+      	@protected_destructors ||= methods(:protected, nil, [/^~/])
+    	when :private
+      	@private_destructors ||= methods(:private, nil, [/^~/])
+    	when :all
+    		destructors(:public) + destructors(:protected) + destructors(:private)
+   		end
     end
-
+    
+    # @param access [Symbol] access modifier (:public, :protected, :private, :all)
+    # @param static If nil are static members excluded. If not nil only static members are returned
+    # @param filter [Array<String>] list of Regex. Members whose name does not match any of the regexes will be excluded
+    # @return [Array<Function>] declared methods
     def methods(access = :public, static = nil, filter = nil)
     	if access == :all
     		return methods(:public, static, filter) + methods(:protected, static, filter) + methods(:private, static, filter)
     	end
-      if static.nil?
-        static = "-"
-      else
-        static = "-static-"
-      end
-      sectiondef = %Q{#{access}#{static}func}
-      lst = doc.xpath(%Q{/doxygen/compounddef/sectiondef[@kind="#{sectiondef}"]/memberdef[@kind="function"][@prot="#{access}"]})
-      do_filter(filter, lst, Doxyparser::Function) { |node|
-        node.xpath("name")[0].child.content
-      }
+    	if access == :public && filter.nil? # Caches public methods
+    	 	if static.nil?
+    			@public_methods ||= _methods(:public, nil, nil)
+    			return @public_methods
+    		end
+    		@public_static_methods ||= _methods(:public, true, nil)
+    		return @public_static_methods
+    	end
+      _methods(access, static, filter)
     end
 
+		# @param access [Symbol] access modifier (:public, :protected, :private, :all)
+    # @param static If nil are static members excluded. If not nil only static members are returned
+    # @param filter [Array<String>] list of Regex. Members whose name does not match any of the regexes will be excluded
+    # @return [Array<Variable>] declared attributes
     def attributes(access = :public, static = nil, filter = nil)
     	if access == :all
     		return attributes(:public, static, filter) + attributes(:protected, static, filter) + attributes(:private, static, filter) 
     	end
-      if static.nil?
-        static = "-"
-      else
-        static = "-static-"
-      end
-      sectiondef = %Q{#{access}#{static}attrib}
-      lst = doc.xpath(%Q{/doxygen/compounddef/sectiondef[@kind="#{sectiondef}"]/memberdef[@kind="variable"][@prot="#{access}"]})
-      do_filter(filter, lst, Doxyparser::Variable) { |node|
-        node.xpath("name")[0].child.content
-      }
+    	if access == :public && filter.nil? # Caches public attributes
+    	 	if static.nil?
+    			@public_attributes ||= _attributes(:public, nil, nil)
+    			return @public_attributes
+    		end
+  			@public_static_attributes ||= _attributes(:public, true, nil)
+   			return @public_static_attributes
+    	end
+	    _attributes(access, static, filter)
     end
-
+    
+    # @param access [Symbol] access modifier (:public, :protected, :private, :all)
+    # @param filter [Array<String>] list of Regex. Members whose name does not match any of the regexes will be excluded
+    # @return [Array<Struct>] declared inner-classes and inner-structs
     def innerclasses(access = :public, filter = nil)
+  		if filter.nil?
+	    	if access == :all
+    			@all_innerclasses ||= innerclasses(:public) + innerclasses(:protected) + innerclasses(:private)
+    			return @all_innerclasses	
+    		end
+	    	if access == :public
+  	  		@public_innerclasses ||= only_innerclasses(:public) + only_innerstructs(:public)
+    			return @public_innerclasses
+    		end
+    	end
+    	if access == :all
+   			return innerclasses(:public, filter) + innerclasses(:protected, filter) + innerclasses(:private, filter)
+   		end
+    	only_innerclasses(access, filter) + only_innerstructs(access, filter)
+    end
+
+		# @param access [Symbol] access modifier (:public, :protected, :private, :all)
+    # @param filter [Array<String>] list of Regex. Members whose name does not match any of the regexes will be excluded
+    # @return [Array<Struct>] declared inner-classes (inner-structs are excluded)
+    def only_innerclasses(access = :public, filter = nil)
     	if access == :all
     		return innerclasses(:public, filter) + innerclasses(:protected, filter) + innerclasses(:private, filter) 
     	end
@@ -64,18 +109,11 @@ module Doxyparser
         del_prefix(node.child.content)
       }
     end
-    
-    def parent_types(access = :public, filter = nil)
-    	if access == :all
-    		return parent_types(:public, filter) + parent_types(:protected, filter) + parent_types(:private, filter) 
-    	end
-      types = doc.xpath(%Q{/doxygen/compounddef/basecompoundref[@prot="#{access}"]})
-      types.map { |t|
-      	Doxyparser::Type.new(name: t.child.content, dir: @dir)
-      }
-    end
 
-    def innerstructs(access = :public, filter = nil)
+	  # @param access [Symbol] access modifier (:public, :protected, :private, :all)
+    # @param filter [Array<String>] list of Regex. Members whose name does not match any of the regexes will be excluded
+    # @return [Array<Struct>] declared inner-structs (inner-classes are excluded)
+    def only_innerstructs(access = :public, filter = nil)
     	if access == :all
     		return innerstructs(:public, filter) + innerstructs(:protected, filter) + innerstructs(:private, filter) 
     	end
@@ -85,35 +123,134 @@ module Doxyparser
         del_prefix(node.child.content)
       }
     end
-
-    def innerenums(access = :public, filter = nil)
+    
+    # @param access [Symbol] access modifier (:public, :protected, :private, :all)
+    # @return [Array<Type>] declared super-types for this struct/class
+    def parent_types(access = :public)
+    	if access == :public
+    		@public_parent_types ||= _parent_types(:public)
+    		return @public_parent_types
+    	end
     	if access == :all
-    		return innerenums(:public, filter) + innerenums(:protected, filter) + innerenums(:private, filter) 
+    			@all_parent_types ||= parent_types(:public) + parent_types(:protected) + parent_types(:private)
+    			return @all_parent_types	
     	end
-      sectiondef = %Q{#{access}-type}
-      lst = doc.xpath(%Q{/doxygen/compounddef/sectiondef[@kind="#{sectiondef}"]/memberdef[@kind="enum"][@prot="#{access}"]})
-      filter.map!{ |exp| exp =~ /^_Enum/ ? /@\d*/ : exp} unless filter.nil?
-      do_filter(filter, lst, Doxyparser::Enum) { |node|
+      _parent_types(access)
+    end
+    
+    # @param access [Symbol] access modifier (:public, :protected, :private, :all)
+    # @param filter [Array<String>] list of Regex. Members whose name does not match any of the regexes will be excluded
+    # @return [Array<Enum>] declared enums
+    def enums(access = :public, filter = nil)
+    	if access == :public && filter.nil?
+    		@public_enums ||= _enums(:public)
+    		return @public_enums 
+    	end
+    	if access == :all && filter.nil?
+    		@all_enums ||= enums(:public) + enums(:protected) + enums(:private)
+    		return @all_enums  
+    	end
+      _enums(access, filter)
+    end
+    
+	  # @param access [Symbol] access modifier (:public, :protected, :private, :all)
+    # @param filter [Array<String>] list of Regex. Members whose name does not match any of the regexes will be excluded
+    # @return [Array<Typedef>] declared typedefs
+    def typedefs(access = :public, filter = nil)
+    	if access == :public && filter.nil?
+    		@public_typedefs ||= _typedefs(:public)
+    		return @public_typedefs 
+    	end
+    	if access == :all && filter.nil?
+    		@all_typedefs ||= typedefs(:public) + typedefs(:protected) + typedefs(:private)
+    		return @all_typedefs 
+    	end
+      _typedefs(access, filter)
+    end
+
+    private
+    
+   	attr_reader :file
+  	attr_reader :friends
+  	attr_reader :template_params
+
+    
+    def _methods(access = :public, static = nil, filter = nil)
+    	if static.nil?
+        static = "-"
+      else
+        static = "-static-"
+      end
+      sectiondef = %Q{#{access}#{static}func}
+      lst = doc.xpath(%Q{/doxygen/compounddef/sectiondef[@kind="#{sectiondef}"]/memberdef[@kind="function"][@prot="#{access}"]})
+      do_filter(filter, lst, Doxyparser::Function) { |node|
+        node.xpath("name")[0].child.content
+      }
+    end
+    
+    def _attributes(access = :public, static = nil, filter = nil)
+    	if static.nil?
+        static = "-"
+      else
+        static = "-static-"
+      end
+      sectiondef = %Q{#{access}#{static}attrib}
+      lst = doc.xpath(%Q{/doxygen/compounddef/sectiondef[@kind="#{sectiondef}"]/memberdef[@kind="variable"][@prot="#{access}"]})
+      do_filter(filter, lst, Doxyparser::Variable) { |node|
         node.xpath("name")[0].child.content
       }
     end
 
-    def typedefs(access = :public, filter = nil)
-    	if access == :all
-    		return typedefs(:public, filter) + typedefs(:protected, filter) + typedefs(:private, filter) 
-    	end
-      sectiondef = %Q{#{access}-type}
+    def compute_path
+      aux = escape_class_name(@name)
+      @xml_path = %Q{#{@dir}/struct#{aux}.xml}
+    end
+    
+    def _typedefs(access, filter=nil)
+    	sectiondef = %Q{#{access}-type}
       lst = doc.xpath(%Q{/doxygen/compounddef/sectiondef[@kind="#{sectiondef}"]/memberdef[@kind="typedef"][@prot="#{access}"]})
       do_filter(filter, lst, Doxyparser::Typedef) { |node| 
       	del_spaces node.xpath("name")[0].child.content
       }
     end
+    
+    def _enums(access, filter=nil)
+    	sectiondef = %Q{#{access}-type}
+      lst = doc.xpath(%Q{/doxygen/compounddef/sectiondef[@kind="#{sectiondef}"]/memberdef[@kind="enum"][@prot="#{access}"]})
+      filter.map!{ |exp| exp =~ /^#{@basename}_Enum/ ? /@\d*/ : exp} unless filter.nil?
+      do_filter(filter, lst, Doxyparser::Enum) { |node|
+        node.xpath("name")[0].child.content
+      }
+    end
+    
+    def _parent_types(access)
+    	doc.xpath(%Q{/doxygen/compounddef/basecompoundref[@prot="#{access}"]}).map { |t| 	Doxyparser::Type.new(name: t.child.content, dir: @dir) }
+    end
+    
+    def init_attributes
+  		super
+  		@file = init_file
+  		@friends = init_friends
+  		@template_params = init_template_params
+  	end
 
-    private
+    def init_file
+      n = doc.xpath("/doxygen/compounddef/includes")[0]
+      return n ? HFile.new(dir: @dir, node: n) : nil 
+    end
 
-    def compute_path
-      aux = escape_class_name(@name)
-      @xml_path = %Q{#{@dir}/struct#{aux}.xml}
+    def init_friends
+      lst=doc.xpath(%Q{/doxygen/compounddef/sectiondef[@kind="friend"]/memberdef[@kind="friend"]})
+      lst.map { |node|
+        Doxyparser::Friend.new(parent: self, node: node)
+      }
+    end
+    
+    def init_template_params
+      params=doc.xpath(%Q{/doxygen/compounddef/templateparamlist/param})
+      params.map { |param|
+        Doxyparser::Param.new(parent: self, node: param)
+      }
     end
   end
-end
+end

data/lib/nodes/type.rb

@@ -1,7 +1,17 @@
 module Doxyparser
 
+	# Type of the parameters and return value of a {Function}. Parent Type of a {Class} or {Struct}. 
+	# 	Supports type parameters (aka. generics) 
   class Type < Node
+  	
+  	# Name of this {Type} without any reference/pointer symbols '* &' or 'const' modifiers
+  	attr_reader :escaped_name
 
+		# If this {Type} has type parameters (aka. template params) finds nested {Type}s 
+		#    for other {Classes} or {Structs} parsed by Doxyparser.
+		#  	The 'main' type is always included, so for templates two or more types will be returned. 
+		# Example: for MyNamespace::map<std::string, MyClass> the result is: [MyNamespace::map, MyNamespace::MyClass]  
+		# @return [Array<Type>] Nested types
     def nested_local_types
       return [] if @node.nil?
       refs = @node.xpath("ref")
@@ -9,35 +19,57 @@ module Doxyparser
       refs.map { |r| Type.new(node: r, dir: @dir) }
     end
 
+		# If this {Type} has type parameters (aka. template params), returns the names for
+		# 	 types nested in this type's name
+		#  	The 'main' type is always included, so for templates two or more names will be returned.
+		# Example: for MyNamespace::map<std::string, MyClass, 4> the result is: [MyNamespace::map, std::string, MyClass]  
+		# @return [Array<String>] Names of nested types
     def nested_typenames
-      Type.nested_typenames(@name)
+      Type.nested_typenames(@escaped_name)
     end
 
+		# Returns the names for types nested in the parameter.
+		#  	The 'main' type is always included, so for templates two or more names will be returned.
+		# Example: for mymap<std::string, MyClass, 4> the result is: [mymap, std::string, MyClass]
+		# @param typename [String] Type name  
+		# @return [Array<String>] Names of nested types
     def self.nested_typenames(typename)
-      typename.split(%r{[<,>]}).map{ |s|
-      	 s.gsub(/^ *const /,'').gsub(/ +(const)* *[&*] *(const)* *$/,'').strip 
+    	escaped_typename = Doxyparser::Util.escape_const_ref_ptr(typename)
+      escaped_typename.split(%r{[<,>]}).map{ |s|
+      	 Doxyparser::Util.escape_const_ref_ptr(s)
       }.reject { |s| 
       		s.nil? || !valid_type?(s) 
-      	}
+      }
     end
 
+		# @return true if this type has type parameters, false otherwise
     def template?
-      Type.template?(@name)
+      Type.template?(@escaped_name)
     end
 
+		# @param typename [String] Type name
+		# @return true if the given type name has type parameters, false otherwise 
     def self.template?(typename)
       typename.include? '<'
     end
+    
+    # Setter for the name of this {Type}. Use at your own risk!
+    def name=(new_name)
+    	@name = new_name
+    	@escaped_name = escape_const_ref_ptr(@name)
+      @basename = del_prefix_class(escape_template(@escaped_name))
+    end
 
     private
 
     def init_attributes
-      @basename = @name
+      @escaped_name = escape_const_ref_ptr(@name)
+      @basename = del_prefix_class(escape_template(@escaped_name))
     end
 
     def find_name
       return '' if @node.nil?
-      @node.content
+      @node.content.gsub('friend', '').strip
     end
 
     def self.valid_type?(str)

data/lib/nodes/typedef.rb

@@ -1,5 +1,6 @@
 module Doxyparser
 
+	# A C/C++ type definition (aka. alias)
   class Typedef < Member
 
   end

data/lib/nodes/variable.rb

@@ -1,5 +1,6 @@
 module Doxyparser
 
+	# A plain old variable
   class Variable < Member
 
   end

data/lib/util.rb

@@ -9,8 +9,24 @@ module Doxyparser
     def del_spaces(n)
       n.gsub(/\s+/, "")
     end
-
-    def del_prefix_class(n)
+    
+    def escape_all(typename)
+    	return del_prefix_class(escape_template(escape_const_ref_ptr(typename)))
+    end
+    
+    def escape_template(typename)
+      typename.gsub(/<.+$/,'').strip
+    end
+    
+    def escape_const_ref_ptr(typename)
+      typename.gsub(/^ *const /,'').gsub(/ +(const)* *[&*]* *(const)* *$/,'').strip
+    end
+    
+    def self.escape_const_ref_ptr(typename)
+      typename.gsub(/^ *const /,'').gsub(/ +(const)* *[&*]* *(const)* *$/,'').strip
+    end
+    
+    def del_prefix_class(n) # Previuously escaped for const
 	     n.gsub(%r{^[^<]*[:]}, "")
     end
     
@@ -54,8 +70,10 @@ module Doxyparser
         filtered_lst = []
         filter.each { |val|
           found = lst.select { |node| match(val, yield(node)) }
-          raise "The object: #{val} #{clazz} could not be found while parsing" if found.nil? || found.empty?
-          filtered_lst.push(*found)
+          unless found.nil? || found.empty?
+	          filtered_lst.push(*found)
+          end
+         	#puts "The object: #{val} #{clazz} could not be found while parsing" # TODO Log this?
         }
       else
       filtered_lst=lst

data/spec/class_spec.rb

@@ -1,6 +1,6 @@
 require 'rubygems'
 require 'rspec'
-require 'doxyparser'
+require_relative '../lib/doxyparser'
 
 require_relative 'custom_spec_helper'
 
@@ -77,8 +77,8 @@ describe "Doxyparser::Class" do
 		end
 
 		it "should correctly create inner classes and structs" do
-			innerstruct = @class.innerstructs
-			innerclass = @class.innerclasses
+			innerstruct = @class.only_innerstructs
+			innerclass = @class.only_innerclasses
 			innerstruct.size.should eql 1
 			innerclass.size.should eql 1
 			innerstruct= innerstruct[0]
@@ -97,6 +97,28 @@ describe "Doxyparser::Class" do
 			compare_members methods, expected_methods
 		end
 		
+		it "should correctly create destructors" do			
+			@class.destructors(:protected).should be_empty
+			expected_methods=['~MyClass']
+			methods = @class.destructors(:all)
+			methods.size.should eql 1
+			compare_members methods, expected_methods
+			methods = @class.destructors(:public)
+			methods.size.should eql 1
+			compare_members methods, expected_methods
+		end
+		
+		it "should correctly create constructors" do
+			@class.constructors(:protected).should be_empty		
+			expected_methods=['MyClass']
+			methods = @class.constructors(:all)
+			methods.size.should eql 2
+			compare_members methods, expected_methods
+			methods = @class.constructors(:public)
+			methods.size.should eql 2
+			compare_members methods, expected_methods
+		end
+		
 		it "should correctly create static methods " do			
 			expected_methods=['publicStaticMethod', 'getStaticProp', 'setStaticProp']
 			methods = @class.methods(:public, :static)
@@ -134,8 +156,8 @@ describe "Doxyparser::Class" do
 		end
 		
 		it "should correctly create public enums " do			
-			expected_enums=['_Enum', 'InnerEnum']
-			enums = @class.innerenums
+			expected_enums=["MyClass_Enum", 'InnerEnum']
+			enums = @class.enums
 			compare_members enums, expected_enums, Doxyparser::Enum
 		end
 		

data/spec/doxyparser_spec.rb

@@ -1,6 +1,6 @@
 require 'rubygems'
 require 'rspec'
-require 'doxyparser'
+require_relative '../lib/doxyparser'
 
 require_relative 'custom_spec_helper'
 
@@ -13,7 +13,6 @@ describe "Doxyparser" do
 		hfile=Doxyparser::parse_file("test.h", xml_dir)
 		output = Doxyparser::gen_xml_docs(home_dir + '/spec/headers', home_dir + '/spec/test_gen', true, ['usr/local/include', 'usr/gato'])
 		output.should_not be_empty
-		FileUtils.rm_r(home_dir + '/spec/test_gen')
 		clazz.name.should_not be_empty
 		namespace.name.should_not be_empty
 		struct.name.should_not be_empty

data/spec/enum_spec.rb

@@ -1,18 +1,18 @@
 require 'rubygems'
 require 'rspec'
-require 'doxyparser'
+require_relative '../lib/doxyparser'
 
 require_relative 'custom_spec_helper'
 
 describe "Doxyparser::Enum" do
 
 		it "should create consistently enums" do
-
 			clazz = Doxyparser::parse_class('MyNamespace::MyClass', xml_dir)
-			enum = clazz.innerenums(:public, ['_Enum'])
+			enum = clazz.enums(:public, ["MyClass_Enum"])
 			enum.size.should eql 1
-			enum[0].values.should eql ['value1', 'value2','value3']
-			enum = clazz.innerenums(:public, ['InnerEnum'])
-			enum[0].values.should eql ['A', 'B','C']	
+			enum[0].values.map{ |v| v.basename}.should eql ['value1', 'value2','value3']
+			enum = clazz.enums(:public, ['InnerEnum'])
+			enum[0].values.map{ |v| v.basename}.should eql ['A', 'B','C']
+			enum[0].values.map{ |v| v.initializer}.should eql ['23', 'A + 1','A + B']	
 		end
 end

data/spec/file_spec.rb

@@ -1,6 +1,6 @@
 require 'rubygems'
 require 'rspec'
-require 'doxyparser'
+require_relative '../lib/doxyparser'
 
 require_relative 'custom_spec_helper'
 

data/spec/method_spec.rb

@@ -1,6 +1,6 @@
 require 'rubygems'
 require 'rspec'
-require 'doxyparser'
+require_relative '../lib/doxyparser'
 
 require_relative 'custom_spec_helper'
 
@@ -45,6 +45,10 @@ describe "Doxyparser::Method" do
 			setter.setter_for.should eql 'prop2set_2'
 			setter.getter_for.should be_nil
 			setter.static.should be_nil
+			
+			getter = @class.methods(:private, nil, ['getIndeedAProp'])[0]
+			getter.getter_for.should eql 'indeedAProp'
+			getter.setter_for.should be_nil
 		end
 		
 		it "should create standard Uppercase getters and setters" do
@@ -64,6 +68,18 @@ describe "Doxyparser::Method" do
 			setter = @class.methods(:private, nil, ['setNotAProp'])[0]
 			setter.setter_for.should be_nil
 			setter.getter_for.should be_nil
+			
+		end
+		
+		it "should ignore malformed getters and setters Pt. 3" do
+			
+			getter = @class.methods(:private, nil, ['getAgainNotAProp'])[0]
+			getter.getter_for.should be_nil
+			getter.setter_for.should be_nil
+			setter = @class.methods(:private, nil, ['setAgainNotAProp'])[0]
+			setter.setter_for.should be_nil
+			setter.getter_for.should be_nil
+			
 		end
 		
 		it "should ignore malformed getters and setters Pt. 2" do

data/spec/namespace_spec.rb

@@ -1,6 +1,6 @@
 require 'rubygems'
 require 'rspec'
-require 'doxyparser'
+require_relative '../lib/doxyparser'
 
 require_relative 'custom_spec_helper'
 

data/spec/type_spec.rb

@@ -1,6 +1,6 @@
 require 'rubygems'
 require 'rspec'
-require 'doxyparser'
+require_relative '../lib/doxyparser'
 
 require_relative 'custom_spec_helper'
 

metadata

@@ -1,31 +1,20 @@
 --- !ruby/object:Gem::Specification
 name: doxyparser
 version: !ruby/object:Gem::Version
-  version: '1.3'
-  prerelease: 
+  version: '1.5'
 platform: ruby
 authors:
 - David Fuenmayor
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-07-05 00:00:00.000000000 Z
+date: 2014-04-18 00:00:00.000000000 Z
 dependencies: []
-description: ! 'Ruby Gem for parsing C++ header files.
-
-  This library is based on Nokogiri (http://nokogiri.org) and takes as input the xml
-  files generated by Doxygen (www.doxygen.org).
-
-  Parsing with Doxygen allows us to parse even a set of non-compilable include files.
-  This is very useful in case you need to parse only a subset of a big library which
-  won''t normally compile because of being incomplete or needing further build configuration
-  (e.g Makefiles, VS, SCons, etc).
-
-  By using other tools which rely on a real C/C++ processor like gccxml or swig, you
-  would normally get lots of compilation-related errors (which is undesired because
-  we don''t want to compile anything!!). Doxyparser is, in such cases, the lean alternative.
-
-'
+description: |
+  Ruby Gem for parsing C++ header files.
+  This library is based on Nokogiri (http://nokogiri.org) and takes as input the xml files generated by Doxygen (www.doxygen.org).
+  Parsing with Doxygen allows us to parse even a set of non-compilable include files. This is very useful in case you need to extract metadata for a big library which won't normally compile because of being incomplete or needing further build configuration (think of Makefiles, Visual Studio and similar).
+  By using other tools which rely on a real C/C++ processor like gccxml or swig, you would normally get lots of compilation-related errors (which is undesired because we don't want to compile anything!). Doxyparser is, in such cases, the lean alternative.
 email:
 - davfuenmayor@gmail.com
 executables: []
@@ -39,8 +28,8 @@ files:
 - lib/nodes/function.rb
 - lib/nodes/variable.rb
 - lib/nodes/type.rb
+- lib/nodes/enum_value.rb
 - lib/nodes/class.rb
-- lib/nodes/group.rb
 - lib/nodes/friend.rb
 - lib/nodes/struct.rb
 - lib/nodes/compound.rb
@@ -62,27 +51,26 @@ files:
 homepage: https://github.com/davfuenmayor/ruby-doxygen-parser
 licenses:
 - MIT
+metadata: {}
 post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.25
+rubygems_version: 2.1.9
 signing_key: 
-specification_version: 3
+specification_version: 4
 summary: Library for parsing C++ header files
 test_files:
 - spec/namespace_spec.rb
@@ -93,3 +81,4 @@ test_files:
 - spec/doxyparser_spec.rb
 - spec/class_spec.rb
 - spec/type_spec.rb
+has_rdoc: 

data/lib/nodes/group.rb

@@ -1,6 +0,0 @@
-module Doxyparser
-
-  class Group < Compound
-
-  end
-end