doxyparser 1.2

data/lib/nodes/type.rb

@@ -0,0 +1,29 @@
+module Doxyparser
+
+	class Type < Node
+		
+		def nested_local_types
+			refs = @node.xpath("ref")
+			return [] if refs.nil? || refs.empty?
+			refs.map { |r| Type.new(node: r, dir: @dir) }
+		end
+		
+		def nested_typenames
+			splitted = @name.split(%r{[<,>]}).map{|s| s.strip}.reject!{|s| s.nil? || !(s =~ /^\D[\w:]*\w$/)}
+		end
+		
+		def template?
+			@name.include? '<'
+		end
+		
+		private
+
+		def init_attributes
+			@basename = @name
+		end
+		
+		def find_name
+    		@node.content
+    	end
+	end
+end

data/lib/nodes/typedef.rb

@@ -0,0 +1,6 @@
+module Doxyparser
+
+  class Typedef < Member
+
+  end
+end

data/lib/nodes/variable.rb

@@ -0,0 +1,6 @@
+module Doxyparser
+
+  class Variable < Member
+
+  end
+end

data/lib/util.rb

@@ -0,0 +1,69 @@
+module Doxyparser
+
+	module Util
+
+		def self.home_dir
+			File.expand_path('..', File.dirname(__FILE__))
+		end
+
+		def del_spaces n
+			n.gsub(/\s+/, "")
+		end
+
+		def del_prefix n
+			n.gsub(%r{.*[:/]}, "")
+		end
+
+		def escape_file_name filename
+			if filename =~ %r{[\./]}
+				return filename.gsub('.', '_8').gsub('/', '_2')
+			else
+				return filename.gsub('_8', '.').gsub('_2', '/')
+			end
+		end
+
+		def escape_class_name filename
+			if filename.include? '::'
+				return filename.gsub('::','_1_1')
+			else
+				return filename.gsub('_1_1','::')
+			end
+		end
+
+		def self.read_file file_name
+			file = File.open(file_name, "r")
+			data = file.read
+			file.close
+			return data
+		end
+
+		def self.write_file file_name, data
+			file = File.open(file_name, "w")
+			count = file.write(data)
+			file.close
+			return count
+		end
+
+		def do_filter filter, lst, clazz
+			if filter
+				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)
+				}
+			else
+			filtered_lst=lst
+			end
+			filtered_lst.map { |node| clazz.new(parent: self, node: node) }
+		end
+
+		def match val, aux_name
+			if val.is_a? Regexp
+			return aux_name =~ val
+			else
+			return aux_name == val
+			end
+		end
+	end
+end

data/spec/class_spec.rb

@@ -0,0 +1,166 @@
+require 'rubygems'
+require 'rspec'
+require 'doxyparser'
+
+require_relative 'custom_spec_helper'
+
+describe "Doxyparser::Class" do
+
+	context "Basic - Creation" do
+
+		it "should create consistently classes from diferent namespaces" do
+
+			klass_syms = { templateClass: "MyNamespace::TemplateClass",
+				myClass: "MyNamespace::MyClass",
+				myClass_inner: "MyNamespace::MyInnerNamespace::MyMostInnerNamespace::MyClass",
+				innerClass: "MyNamespace::MyClass::InnerClass"}
+
+			struct_syms = { outerStruct: "MyNamespace::OuterStruct",
+				innerStruct: "MyNamespace::MyClass::InnerStruct"}
+
+			klasses = {}
+
+			klass_syms.each_key {|k|
+				klasses[k] = Doxyparser::parse_class(klass_syms[k], xml_dir)
+			}
+
+			struct_syms.each_key {|k|
+				klasses[k] = Doxyparser::parse_struct(struct_syms[k], xml_dir)
+			}
+
+			klasses.each {|k, v|
+				v.file.basename.should eql "test1.h"
+				v.file.xml_path.should eql "#{xml_dir}/test1_8h.xml"
+				v.name.should eql (klass_syms[k] || struct_syms[k])
+			}
+
+		end
+				
+		it "should correctly create template classes" do
+			template_class = Doxyparser::parse_class('MyNamespace::TemplateClass', xml_dir)
+			params = template_class.template_params
+			params.size.should eql 3
+			params.each {|param|
+				param.class.should eql Doxyparser::Param				
+				param.type.class.should eql Doxyparser::Type
+			}
+			params[0].declname.should eql 'TYPE'
+			params[1].declname.should eql 'TYPE2'
+			params[2].declname.should eql 'entero'
+			params[2].value.should eql '5'
+			params[0].type.basename.should eql 'typename'
+			params[1].type.basename.should eql 'class'
+			params[2].type.basename.should eql 'int'
+			params[0].type.basename.should eql 'typename'
+			params[1].type.basename.should eql 'class'
+			params[2].type.basename.should eql 'int'
+		end
+		
+		it "should correctly create classes in subdirectories" do
+			clazz=Doxyparser::parse_class("MyNamespace::SubDirClass", xml_dir)
+			file = clazz.file
+			file.name.should eql 'subdir/test1.h'
+			file.basename.should eql 'test1.h'
+		end
+	end
+
+	context "Basic - Members" do
+
+		before(:all) do
+			@class=Doxyparser::parse_class("MyNamespace::MyClass", xml_dir)
+		end
+		
+		it "should correctly create file " do			
+			file = @class.file
+			file.name.should eql 'test1.h'
+			file.basename.should eql 'test1.h'
+		end
+
+		it "should correctly create inner classes and structs" do
+			innerstruct = @class.innerstructs
+			innerclass = @class.innerclasses
+			innerstruct.size.should eql 1
+			innerclass.size.should eql 1
+			innerstruct= innerstruct[0]
+			innerclass= innerclass[0]
+
+			innerstruct.class.should eql Doxyparser::Struct
+			innerclass.class.should eql Doxyparser::Class
+			innerclass.parent.should eql @class
+			innerclass.xml_path.should eql xml_dir+"/#{innerclass.refid}.xml"
+			innerclass.name.should be_start_with("#{@class.name}::")
+		end
+
+		it "should correctly create methods " do			
+			expected_methods=['MyClass', 'virtualMethod', 'method', 'operator-', '~MyClass']
+			methods = @class.methods
+			compare_members methods, expected_methods
+		end
+		
+		it "should correctly create static methods " do			
+			expected_methods=['publicStaticMethod', 'getStaticProp', 'setStaticProp']
+			methods = @class.methods(:public, :static)
+			compare_members methods, expected_methods
+		end
+		
+		it "should correctly create private methods " do			
+			expected_methods=['privateMethod1', 'privateMethod2']
+			methods = @class.methods(:private)
+			compare_members methods, expected_methods
+		end
+		
+		it "should correctly create private static methods " do			
+			expected_methods=['privateStaticMethod']
+			methods = @class.methods(:private, :static)
+			compare_members methods, expected_methods
+		end
+		
+		it "should correctly create protected methods " do			
+			expected_methods=['protectedMethod1', 'protectedMethod2']
+			methods = @class.methods(:protected)
+			compare_members methods, expected_methods
+		end
+		
+		it "should correctly create static attributes " do			
+			expected_attributes=['publicStaticField1']
+			attributes = @class.attributes(:public, :static)
+			compare_members attributes, expected_attributes, Doxyparser::Variable
+		end
+		
+		it "should correctly create private attributes " do			
+			expected_attributes=['privateField1', 'privateField2']
+			attributes = @class.attributes(:private)
+			compare_members attributes, expected_attributes, Doxyparser::Variable
+		end
+		
+		it "should correctly create public enums " do			
+			expected_enums=['_Enum', 'InnerEnum']
+			enums = @class.innerenums
+			compare_members enums, expected_enums, Doxyparser::Enum
+		end
+		
+		it "should correctly create public typedefs " do			
+			expected_typedefs=['VectorMapShortVectorInt', 'MapShortVectorInt']
+			typedefs = @class.typedefs :public
+			compare_members typedefs, expected_typedefs, Doxyparser::Typedef
+		end
+		
+		it "should correctly create private typedefs " do			
+			expected_typedefs=['privateTypedef']
+			typedefs = @class.typedefs :private
+			compare_members typedefs, expected_typedefs, Doxyparser::Typedef
+		end
+		
+		it "should correctly create friends" do			
+			expected_friends=['operator*', 'MyNamespace::friendMethod', 'OuterStruct']
+			friends = @class.friends
+			compare_members friends, expected_friends, Doxyparser::Friend
+			friend_classes = friends.select{|f| f.is_class?}
+			friend_classes.size.should eql 1
+			'OuterStruct'.should eql friend_classes[0].basename
+			qualified_friends = friends.select{|f| f.is_qualified?}
+			qualified_friends.size.should eql 1
+			'MyNamespace::friendMethod'.should eql qualified_friends[0].basename
+		end
+	end
+end

data/spec/custom_spec_helper.rb

@@ -0,0 +1,21 @@
+def home_dir
+	File.expand_path('..', File.dirname(__FILE__))
+end
+
+def xml_dir
+	home_dir + '/spec/xml'
+end
+
+def compare_members members, expected_members, clazz = Doxyparser::Function
+	basename_members = members.map{|m| m.basename}.uniq.sort
+	expected_members.sort!
+	
+	basename_members.should eql expected_members
+	
+	members.each{ |m|
+		m.class.should eql clazz
+		m.name.should be_start_with("#{@class.name}::")
+		m.parent.should eql @class
+		m.location.should match %r{#{home_dir}/spec/headers/test1.h:\d+}
+	}
+end

data/spec/doxyparser_spec.rb

@@ -0,0 +1,23 @@
+require 'rubygems'
+require 'rspec'
+require 'doxyparser'
+
+require_relative 'custom_spec_helper'
+
+describe "Doxyparser" do
+
+	it "should not burn with api calls" do
+		clazz=Doxyparser::parse_class("MyNamespace::MyClass", xml_dir)
+		namespace=Doxyparser::parse_namespace("MyNamespace", xml_dir)
+		struct=Doxyparser::parse_struct("MyNamespace::MyClass::InnerStruct", xml_dir)
+		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
+		hfile.name.should_not be_empty
+		hfile.basename.should_not be_empty
+	end
+end

data/spec/enum_spec.rb

@@ -0,0 +1,18 @@
+require 'rubygems'
+require 'rspec'
+require '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.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']	
+		end
+end

data/spec/file_spec.rb

@@ -0,0 +1,108 @@
+require 'rubygems'
+require 'rspec'
+require 'doxyparser'
+
+require_relative 'custom_spec_helper'
+
+describe "Doxyparser::HFile" do
+
+	before(:all) do
+		@file = Doxyparser::parse_file('test1.h', xml_dir)
+	end
+	
+	it "should correctly create files in subdirectories" do
+		subdir_file = Doxyparser::parse_file('subdir/test1.h', xml_dir)
+		subdir_file.name.should eql 'subdir/test1.h'
+		subdir_file.basename.should eql 'test1.h'
+		subdir_file.xml_path.should eql xml_dir+'/subdir_2test1_8h.xml'
+	end
+	
+	it "should be created correctly" do
+			@file.name.should eql 'test1.h'
+			@file.basename.should eql 'test1.h'
+			@file.xml_path.should eql xml_dir+'/test1_8h.xml'
+	end
+
+	it "should correctly generate includes and included_by listing" do
+		expected_included= ['stdlib.h', 'vector', 'list', 'map', 'iostream', 'test3.h', 'subdir/test1.h'].sort
+		expected_including= ['test3.h', 'test2.h', 'test4.h', 'subdir/test2.h'].sort
+		@file.list_included.sort.should eql expected_included
+		@file.list_including.sort.should eql expected_including
+	end
+
+	it "should correctly generate includes and included_by files" do
+		expected_included= ['test3.h', 'subdir/test1.h'].sort
+		expected_including= ['test3.h', 'test2.h', 'test4.h', 'subdir/test2.h'].sort
+		@file.files_included.map{|f| f.name}.sort.should eql expected_included
+		@file.files_including.map{|f| f.name}.sort.should eql expected_including
+	end
+
+	it "should create the right classes and structs" do
+		expected_classes=['noNsClass', "MyNamespace::MyInnerNamespace::MyMostInnerNamespace::MyClass", "MyNamespace::TemplateClass", "MyNamespace::MyClass", "MyNamespace::MyClass::InnerClass"]
+		expected_structs=["noNsStruct", "MyNamespace::OuterStruct", "MyNamespace::MyClass::InnerStruct"]
+
+		file_classes = @file.classes
+		file_structs = @file.structs
+		file_classes.size.should eql expected_classes.size
+		file_structs.size.should eql expected_structs.size
+
+		file_all = file_classes + file_structs
+		file_all.uniq.should eql file_all# No element should be repeated
+
+		file_classes.each{|c|
+			c.class.should eql Doxyparser::Class
+			expected_classes.should include c.name
+			c.parent.should be_nil
+			c.xml_path.should be_start_with xml_dir
+		}
+		file_structs.each{|c|
+			c.class.should eql Doxyparser::Struct
+			expected_structs.should include c.name
+			c.parent.should be_nil
+			c.xml_path.should be_start_with xml_dir
+		}
+	end
+	
+	it "should create the right namespaces" do
+		expected_namespaces=['MyNamespace', "MyNamespace::MyInnerNamespace", "MyNamespace::MyInnerNamespace::MyMostInnerNamespace", "std"]
+		file_namespaces = @file.namespaces
+		file_namespaces.size.should eql expected_namespaces.size
+
+		file_namespaces.uniq.should eql file_namespaces # No element should be repeated
+
+		file_namespaces.each{|c|
+			c.class.should eql Doxyparser::Namespace
+			expected_namespaces.should include c.name
+			c.parent.should be_nil
+			c.xml_path.should be_start_with xml_dir
+		}
+	end
+	
+	it "should create functions" do
+		functions = @file.functions
+		functions.size.should eql 1
+		functions[0].name.should eql 'test1.h::noNsFunction'
+		functions[0].basename.should eql 'noNsFunction'
+	end
+	
+	it "should create variables" do
+		variables = @file.variables
+		variables.size.should eql 1
+		variables[0].name.should eql 'test1.h::noNsVariable'
+		variables[0].basename.should eql 'noNsVariable'
+	end
+	
+	it "should create enums" do
+		enums = @file.enums
+		enums.size.should eql 1
+		enums[0].name.should eql 'test1.h::noNsEnum'
+		enums[0].basename.should eql 'noNsEnum'
+	end
+	
+	it "should create typedefs" do
+		typedefs = @file.typedefs
+		typedefs.size.should eql 1
+		typedefs[0].name.should eql 'test1.h::noNsTypedef'
+		typedefs[0].basename.should eql 'noNsTypedef'
+	end
+end