doxyparser 1.2 → 1.3

data/lib/nodes/member.rb

@@ -1,61 +1,65 @@
 module Doxyparser
 
-	class Member < Node
-
-		attr_reader :location
-		attr_reader :definition
-		attr_reader :args
-		attr_reader :type
-		attr_reader :static
-		attr_reader :params
-
-		def file
-			HFile.new(:name => @filename, :dir => @dir)
-		end
-
-		private
-
-		def init_attributes
-			super
-			raise "No XML node was associated to this member" if @node.nil?
-			@xml_path=parent.xml_path
-			if @node['static']
-				@static = (@node['static'] == 'yes') ? 'static' : nil
-			end
-			aux= self.xpath("location")[0]
-			@filename=File.basename(aux["file"])
-			@location="#{aux["file"]}:#{aux["line"]}"
-			temp=self.xpath("definition")
-			if temp == nil || temp.empty? || temp[0].child==nil
-				@definition = ""
-			else
-				@definition = temp[0].child.content
-			end
-			temp = self.xpath("argsstring")
-			if temp == nil || temp.empty? || temp[0].child==nil
-				@args = ""
-			else
-				@args = temp[0].child.content
-			end
-			@type = find_type @node
-
-			@params=[]
-			all_params= self.xpath("param")
-			return if all_params == nil || all_params.empty? || all_params[0].child==nil
-
-			all_params.each { |param|
-				@params << Doxyparser::Param.new(node: param, parent: self, name: 'param''param')
-			}
-		end
-
-		def find_name
-			@parent.name + '::' + @node.xpath("name")[0].child.content
-		end
-
-		def find_type n
-			type = n.xpath("type")
-			return "" if type.nil? || type.empty? || type[0].child==nil
-			Type.new node: type[0], dir: @dir
-		end
-	end
+  class Member < Node
+
+    attr_reader :location
+    attr_reader :definition
+    attr_reader :args
+    attr_reader :type
+    attr_reader :static
+    attr_reader :params
+
+    def file
+      Doxyparser::HFile.new(:name => @filename, :dir => @dir)
+    end
+
+    private
+
+    def init_attributes
+      super
+      raise "No XML node was associated to this member" if @node.nil?
+      @xml_path = parent.xml_path
+
+      if @node['static'] && @node['static'] == 'yes'
+        @static = 'static'
+      else
+        @static = nil
+      end
+
+      aux = self.xpath("location")[0]
+      @filename = File.basename(aux["file"])
+      @location = "#{aux["file"]}:#{aux["line"]}"
+      temp = self.xpath("definition")
+      if temp == nil || temp.empty? || temp[0].child==nil
+        @definition = ""
+      else
+        @definition = temp[0].child.content
+      end
+      temp = self.xpath("argsstring")
+      if temp == nil || temp.empty? || temp[0].child==nil
+        @args = ""
+      else
+        @args = temp[0].child.content
+      end
+      @type = find_type(@node)
+
+      @params = []
+      all_params = self.xpath("param")
+      return if all_params == nil || all_params.empty? || all_params[0].child==nil
+
+      all_params.each { |param|
+        @params << Doxyparser::Param.new(node: param, parent: self, name: 'param')
+      }
+    end
+
+    def find_name
+      @parent.name + '::' + @node.xpath("name")[0].child.content
+    end
+
+    def find_type(n)
+      type = n.xpath("type")
+      return Doxyparser::Type.new(name: '', dir: @dir) if type.nil? || type.empty? || type[0].child == nil
+      Doxyparser::Type.new(node: type[0], dir: @dir)
+    end
+  end
 end

data/lib/nodes/namespace.rb

@@ -2,55 +2,57 @@ module Doxyparser
 
   class Namespace < Compound
 
-    def functions filter=nil
-      lst=doc.xpath(%Q{/doxygen/compounddef/sectiondef[@kind="func"]/memberdef[@kind="function"]})
+    def functions(filter=nil)
+      lst = doc.xpath(%Q{/doxygen/compounddef/sectiondef[@kind="func"]/memberdef[@kind="function"]})
       do_filter(filter, lst, Doxyparser::Function) { |node|
-         node.xpath("name")[0].child.content.strip
+        node.xpath("name")[0].child.content.strip
       }
     end
-    
-    def enums filter=nil
-      lst=doc.xpath(%Q{/doxygen/compounddef/sectiondef[@kind="enum"]/memberdef[@kind="enum"]})
-      filter.map!{ |exp| exp =~ /^_Enum/ ? /@\d*/ : exp} unless filter.nil?
+
+    def enums(filter=nil)
+      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|
-      	node.xpath("name")[0].child.content.strip
+        node.xpath("name")[0].child.content.strip
       }
     end
 
-    def variables filter=nil
-      lst=doc.xpath(%Q{/doxygen/compounddef/sectiondef[@kind="var"]/memberdef[@kind="variable"]})
+    def variables(filter=nil)
+      lst = doc.xpath(%Q{/doxygen/compounddef/sectiondef[@kind="var"]/memberdef[@kind="variable"]})
       do_filter(filter, lst, Doxyparser::Variable) { |node|
         node.xpath("name")[0].child.content.strip
       }
     end
-    
-    def typedefs filter=nil
-    	lst=doc.xpath(%Q{/doxygen/compounddef/sectiondef[@kind="typedef"]/memberdef[@kind="typedef"]})
-      do_filter(filter, lst, Doxyparser::Typedef) { |node| del_spaces node.xpath("name")[0].child.content }
+
+    def typedefs(filter=nil)
+      lst = doc.xpath(%Q{/doxygen/compounddef/sectiondef[@kind="typedef"]/memberdef[@kind="typedef"]})
+      do_filter(filter, lst, Doxyparser::Typedef) { |node| 
+      	del_spaces(node.xpath("name")[0].child.content)
+      }
     end
-    
-    def innernamespaces filter=nil
-      lst=doc.xpath(%Q{/doxygen/compounddef/innernamespace})
+
+    def innernamespaces(filter=nil)
+      lst = doc.xpath(%Q{/doxygen/compounddef/innernamespace})
       do_filter(filter, lst, Doxyparser::Namespace) { |node|
-        del_spaces del_prefix(node.child.content)
+        del_spaces del_prefix_class(node.child.content)
       }
     end
-    
-    def structs filter=nil
-      lst=doc.xpath(%Q{/doxygen/compounddef/innerclass})
+
+    def structs(filter=nil)
+      lst = doc.xpath(%Q{/doxygen/compounddef/innerclass})
       lst = lst.select { |c| c["refid"].start_with?("struct") }
       do_filter(filter, lst, Doxyparser::Struct) { |node|
-        del_spaces del_prefix(node.child.content)
+        del_spaces del_prefix_class(node.child.content)
       }
     end
 
-    def classes filter=nil
-    	 lst=doc.xpath(%Q{/doxygen/compounddef/innerclass})
+    def classes(filter=nil)
+      lst = doc.xpath(%Q{/doxygen/compounddef/innerclass})
       lst = lst.select { |c| c["refid"].start_with?("class") }
       do_filter(filter, lst, Doxyparser::Class) { |node|
-        del_spaces del_prefix(node.child.content)
+        del_spaces del_prefix_class(node.child.content)
       }
-    end   
+    end
 
     def file
       nil

data/lib/nodes/node.rb

@@ -1,63 +1,68 @@
 module Doxyparser
 
-	class Node
-		include Doxyparser::Util
-
-		attr_reader :dir
-		attr_reader :name
-		attr_reader :basename
-		attr_reader :node
-		attr_reader :doc
-		attr_reader :parent
-
-		def == another
-			self.name == another.name
-		end
-
-		def eql? another
-			self.name == another.name
-		end
-
-		def to_str
-			@name
-		end
-
-		def to_s
-			@name
-		end
-
-		# Takes a hash as input with following keys: :node, :parent, :dir, :name
-		def initialize hash
-			@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
-				@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
-
-		private
-
-		def method_missing sym, *args
-			if @node.respond_to? sym
-			@node.send(sym, *args)
-			else
-			@node[sym.to_s] || super
-			end
-		end
-
-		def init_attributes
-			@basename ||= del_prefix @name
-		end
-
-		def find_name
-			# For Inheritance
-		end
-
-	end
+  class Node
+    include Doxyparser::Util
+
+    attr_reader :dir
+    attr_reader :name
+    attr_reader :basename
+    attr_reader :node
+    attr_reader :doc
+    attr_reader :parent
+
+    def == another
+      self.name == another.name
+    end
+
+    def eql?(another)
+      self.name == another.name
+    end
+
+    def to_str
+      @name
+    end
+
+    def to_s
+      @name
+    end
+
+    # Takes a hash as input with following keys: :node, :parent, :dir, :name
+    def initialize(hash)
+      @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
+        @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
+
+    private
+
+    def method_missing(sym, *args)
+      if @node.respond_to?(sym)
+      @node.send(sym, *args)
+      else
+      @node[sym.to_s] || super
+      end
+    end
+
+    def init_attributes
+      @basename ||= del_prefix_for(@name)
+    end
+
+    def find_name
+      # For Inheritance
+    end
+    
+    def del_prefix_for(str)
+      del_prefix_class(str)
+    end
+
+  end
 end

data/lib/nodes/param.rb

@@ -15,15 +15,13 @@ module Doxyparser
 		def init_attributes
 			type_temp = @node.xpath("type")
 			return if type_temp.nil? || type_temp.empty?
-			@type = Type.new node: type_temp[0], parent: @parent
+			@type = Type.new(node: type_temp[0], parent: @parent)
 			@name = @type.name			
 
 			declname_temp = @node.xpath("declname")
 			return if declname_temp.nil? || declname_temp.empty?
-			@declname = declname_temp[0].content
-			
-			@name += @declname
-			
+			@declname = declname_temp[0].content			
+			@name += @declname			
 			@basename = @declname
 
 			value_temp = @node.xpath("defval")

data/lib/nodes/struct.rb

@@ -1,89 +1,119 @@
 module Doxyparser
 
-	class Struct < Compound
+  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)
-		end
+    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)
+    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)
-			}
-		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)
+      }
+    end
 
-		def template_params
-			params=doc.xpath(%Q{/doxygen/compounddef/templateparamlist/param})
-			params.map { |param|
-				Doxyparser::Param.new(parent: self, node: param)
-			}
-		end
+    def template_params
+      params=doc.xpath(%Q{/doxygen/compounddef/templateparamlist/param})
+      params.map { |param|
+        Doxyparser::Param.new(parent: self, node: param)
+      }
+    end
 
-		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 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
+      }
+    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 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
+      }
+    end
 
-		def innerclasses access=:public, filter=nil
-			lst=doc.xpath(%Q{/doxygen/compounddef/innerclass[@prot="#{access}"]})
-			lst = lst.select { |c| c["refid"].start_with?("class") }
-			do_filter(filter, lst, Doxyparser::Class) { |node|
-				del_prefix(node.child.content)
-			}
-		end
+    def innerclasses(access = :public, filter = nil)
+    	if access == :all
+    		return innerclasses(:public, filter) + innerclasses(:protected, filter) + innerclasses(:private, filter) 
+    	end
+      lst = doc.xpath(%Q{/doxygen/compounddef/innerclass[@prot="#{access}"]})
+      lst = lst.select { |c| c["refid"].start_with?("class") }
+      do_filter(filter, lst, Doxyparser::Class) { |node|
+        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
-			lst=doc.xpath(%Q{/doxygen/compounddef/innerclass[@prot="#{access}"]})
-			lst = lst.select { |c| c["refid"].start_with?("struct") }
-			do_filter(filter, lst, Doxyparser::Struct) { |node|
-				del_prefix(node.child.content)
-			}
-		end
+    def innerstructs(access = :public, filter = nil)
+    	if access == :all
+    		return innerstructs(:public, filter) + innerstructs(:protected, filter) + innerstructs(:private, filter) 
+    	end
+      lst = doc.xpath(%Q{/doxygen/compounddef/innerclass[@prot="#{access}"]})
+      lst = lst.select { |c| c["refid"].start_with?("struct") }
+      do_filter(filter, lst, Doxyparser::Struct) { |node|
+        del_prefix(node.child.content)
+      }
+    end
 
-		def innerenums access=:public, filter=nil
-			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|
-				node.xpath("name")[0].child.content
-			}
-		end
+    def innerenums(access = :public, filter = nil)
+    	if access == :all
+    		return innerenums(:public, filter) + innerenums(:protected, filter) + innerenums(:private, filter) 
+    	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|
+        node.xpath("name")[0].child.content
+      }
+    end
 
-		def typedefs access=:public, 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 typedefs(access = :public, filter = nil)
+    	if access == :all
+    		return typedefs(:public, filter) + typedefs(:protected, filter) + typedefs(:private, filter) 
+    	end
+      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
 
-		private
+    private
 
-		def compute_path
-			aux = escape_class_name @name
-			@xml_path = %Q{#{@dir}/struct#{aux}.xml}
-		end
-	end
+    def compute_path
+      aux = escape_class_name(@name)
+      @xml_path = %Q{#{@dir}/struct#{aux}.xml}
+    end
+  end
 end