doxyparser 1.2

data/spec/method_spec.rb

@@ -0,0 +1,86 @@
+require 'rubygems'
+require 'rspec'
+require 'doxyparser'
+
+require_relative 'custom_spec_helper'
+
+describe "Doxyparser::Method" do
+	
+	before(:all) do
+			@class=Doxyparser::parse_class("AccessorsClass", xml_dir)
+		end
+
+		it "should create consistently methods" do
+			method = @class.methods(:private, nil, ['isBoolProp'])
+			method.size.should eql 1
+			method = method[0]
+			method.type.name.should eql 'bool'
+			method.args.should eql '()'
+			method.location.should match /test2.h:\d+$/			
+			method.file.basename.should eql 'test2.h'
+			method.params.should be_empty
+			method.static.should be_nil
+			method.definition.should eql 'bool AccessorsClass::isBoolProp'
+		end
+		
+		it "should create standard getters and setters" do
+			getter = @class.methods(:private, nil, ['getProp'])[0]
+			getter.getter_for.should eql 'prop'
+			getter.setter_for.should be_nil
+			setter = @class.methods(:private, nil, ['setProp'])[0]
+			setter.setter_for.should eql 'prop'
+			setter.getter_for.should be_nil
+			setter.static.should be_nil
+			
+			getter = @class.methods(:private, nil, ['isBoolProp'])[0]
+			getter.getter_for.should eql 'boolProp'
+			getter.setter_for.should be_nil
+		end
+		
+		it "should create non standard getters and setters" do
+			getter = @class.methods(:private, nil, ['get_Prop2'])[0]
+			getter.getter_for.should eql 'prop2'
+			getter.setter_for.should be_nil
+			setter = @class.methods(:private, nil, ['set_Prop2'])[0]
+			setter.setter_for.should eql 'prop2'
+			setter.getter_for.should be_nil
+			setter.static.should be_nil
+		end
+		
+		it "should create standard Uppercase getters and setters" do
+			getter = @class.methods(:private, nil, ['GetProp3'])[0]
+			getter.getter_for.should eql 'prop3'
+			getter.setter_for.should be_nil
+			setter = @class.methods(:private, nil, ['SetProp3'])[0]
+			setter.setter_for.should eql 'prop3'
+			setter.getter_for.should be_nil
+			setter.static.should be_nil
+		end
+		
+		it "should ignore malformed getters and setters" do
+			getter = @class.methods(:private, nil, ['getNotAProp'])[0]
+			getter.getter_for.should be_nil
+			getter.setter_for.should be_nil
+			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. 2" do
+			getter = @class.methods(:private, nil, ['isNotAProp'])[0]
+			getter.getter_for.should be_nil
+			getter.setter_for.should be_nil
+			setter = @class.methods(:private, nil, ['isAlsoNotAProp'])[0]
+			setter.setter_for.should be_nil
+			setter.getter_for.should be_nil
+		end
+		
+		it "should create static getters and setters" do			
+			static_getter = @class.methods(:private, true, ['getStaticProp'])[0]
+			static_getter.getter_for.should eql 'staticProp'
+			static_getter.setter_for.should be_nil
+			static_setter = @class.methods(:private, :x, ['setStaticProp'])[0]
+			static_setter.setter_for.should eql 'staticProp'
+			static_setter.getter_for.should be_nil
+		end
+end

data/spec/namespace_spec.rb

@@ -0,0 +1,165 @@
+require 'rubygems'
+require 'rspec'
+require 'doxyparser'
+
+require_relative 'custom_spec_helper'
+
+describe "Doxyparser::Namespace" do
+
+	context "Basic" do
+
+		before(:all) do
+			@namespace=Doxyparser::parse_namespace("Ogre", xml_dir)
+		end
+
+		it "should be created consistently from name and directory" do
+			namespace_data = {name: "Ogre", basename:  "Ogre", node: nil, parent: nil, path: xml_dir+'/namespaceOgre.xml'}
+			@namespace.class.should eql Doxyparser::Namespace
+			@namespace.name.should eql namespace_data[:name]
+			@namespace.basename.should eql namespace_data[:basename]
+			@namespace.xml_path.should eql namespace_data[:path]
+			@namespace.file.should be_nil
+		end
+
+		it "should create the right typedefs according to a specified list" do
+			expected_typedefs=['AnimableValuePtr', 'AnimationStateMap', 'ConstAnimationStateIterator']
+			ns_typedefs = @namespace.typedefs(expected_typedefs)
+			ns_typedefs.size.should eql expected_typedefs.size
+			ns_typedefs.uniq.should eql ns_typedefs
+			ns_typedefs.each{|t|
+				t.class.should eql Doxyparser::Typedef # Class must be correct
+				t.parent.should eql @namespace # Parent must be correct
+				expected_typedefs.should include t.basename
+				t.name.should be_start_with("#{@namespace.name}::")
+			}
+		end
+
+		it "should create the right functions according to a specified list" do
+			expected_functions=['operator>', 'operator<=', 'intersect', 'advanceRawPointer', 'any_cast']
+			ns_functions = @namespace.functions(expected_functions)
+			# Should return more elements than the list (because any_cast() is overloaded)
+			ns_functions.size.should be.>expected_functions.size
+			ns_functions.uniq.should eql ns_functions# Function overrides "==" and therefore
+			# no element should be repeated
+			ns_functions.each{|f|
+				f.class.should eql Doxyparser::Function# Class must be correct
+				f.parent.should eql @namespace# Parent must be correct
+				expected_functions.should include f.basename# Each function must be included in
+				# the given list
+				f.name.should be_start_with("#{@namespace.name}::")
+			}
+		end
+
+		it "should create the right enums according to a specified list" do
+			expected_enums=['LayerBlendOperationEx', 'ShadowTechnique', 'GpuConstantType', 'MeshChunkID']
+			ns_enums = @namespace.enums(expected_enums)
+			ns_enums.size.should eql expected_enums.size# Should return same number of
+			# elements as the list
+			ns_enums.uniq.should eql ns_enums# No element should be repeated
+			ns_enums.each{|e|
+				e.class.should eql Doxyparser::Enum# Class must be correct
+				e.parent.should eql @namespace# Parent must be correct
+				expected_enums.should include e.basename# Each function must be included in the
+				# given list
+				e.name.should be_start_with("#{@namespace.name}::")
+			}
+		end
+
+		it "should create the right variables according to a specified list" do
+			expected_vars=['pi', 'SPOT_SHADOW_FADE_PNG', 'RENDER_QUEUE_COUNT']
+			ns_vars = @namespace.variables(expected_vars)
+			ns_vars.size.should eql expected_vars.size# Should return same number of elements
+			# as the list
+			ns_vars.uniq.should eql ns_vars# No element should be repeated
+			ns_vars.each{ |v|
+				v.class.should eql Doxyparser::Variable# Class must be correct
+				v.parent.should eql @namespace# Parent must be correct
+				expected_vars.should include v.basename# Each function must be included in the
+				# given list
+				v.name.should be_start_with("#{@namespace.name}::")
+			}
+		end
+
+		it "should correctly create the right classes and structs according to a specified list" do
+
+			expected_classes=['AnimationTrack', "Root", "RibbonTrail", "SceneManager"]
+			expected_structs=["isPodLike", "ViewPoint", "RenderablePass"]
+
+			ns_classes = @namespace.classes(expected_classes)
+			ns_structs = @namespace.structs(expected_structs)
+			ns_classes.size.should eql expected_classes.size
+			ns_structs.size.should eql expected_structs.size#
+
+			ns_all = ns_classes + ns_structs
+			ns_all.uniq.should eql ns_all# No element should be repeated among classes and
+			# structs
+
+			ns_classes.each{|c|
+				c.class.should eql Doxyparser::Class
+				expected_classes.should include c.basename
+			}
+			ns_structs.each{|c|
+				c.class.should eql Doxyparser::Struct
+				expected_structs.should include c.basename
+			}
+			ns_all.each{|c|
+				c.parent.should eql @namespace
+				c.xml_path.should eql xml_dir+"/#{c.refid}.xml"
+				c.name.should be_start_with("#{@namespace.name}::")
+			}
+		end
+
+		it "should correctly create the right inner namespaces according to a specified list" do
+			expected_inner_ns=['EmitterCommands', 'OverlayElementCommands']
+			inner_ns = @namespace.innernamespaces(expected_inner_ns)
+			inner_ns.size.should eql expected_inner_ns.size# Should return same name of
+			# elements as expected...
+			inner_ns.uniq.should eql inner_ns# ... and no element should be repeated
+
+			inner_ns.each{|ns|
+			# Class must be correct
+				ns.class.should eql Doxyparser::Namespace
+
+				# Class should have a correct parent
+				ns.parent.should eql @namespace
+
+				# XML File path must be correct
+				ns.xml_path.should eql xml_dir+%Q{/#{ns.refid}.xml}
+
+				# The classes must be included in the given filter
+				expected_inner_ns.should include ns.basename
+				ns.name.should be_start_with("#{@namespace.name}::")
+			}
+		end
+	end
+	context "Advanced" do
+		
+		before(:all) do
+			@myNamespace=Doxyparser::parse_namespace("MyNamespace", xml_dir)
+		end
+
+		it "should correctly create nested inner-namespace hierarchies" do
+			@myNamespace=Doxyparser::parse_namespace("MyNamespace", xml_dir)
+			inner_ns = @myNamespace.innernamespaces
+			inner_ns.size.should eql 1			
+			myInnerNamespace = inner_ns[0]
+			myInnerNamespace.parent.should eql @myNamespace
+			myInnerNamespace.xml_path.should eql xml_dir+%Q{/#{myInnerNamespace.refid}.xml}
+			myInnerNamespace.name.should eql "#{@myNamespace.name}::MyInnerNamespace"
+			
+			inner_ns = myInnerNamespace.innernamespaces
+			inner_ns.size.should eql 1			
+			myMostInnerNamespace = inner_ns[0]
+			myMostInnerNamespace.parent.should eql myInnerNamespace
+			myMostInnerNamespace.xml_path.should eql xml_dir+%Q{/#{myMostInnerNamespace.refid}.xml}
+			myMostInnerNamespace.name.should eql "#{myInnerNamespace.name}::MyMostInnerNamespace"
+			
+			myClass = myMostInnerNamespace.classes[0]
+			myEnum = myMostInnerNamespace.enums[0]
+			
+			myClass.name.should eql "#{myMostInnerNamespace.name}::MyClass"
+			myEnum.name.should eql "#{myMostInnerNamespace.name}::MyEnum"		
+			
+		end
+	end
+end

data/spec/type_spec.rb

@@ -0,0 +1,34 @@
+require 'rubygems'
+require 'rspec'
+require 'doxyparser'
+
+require_relative 'custom_spec_helper'
+
+describe "Doxyparser::Type" do
+
+	before(:all) do
+		@class=Doxyparser::parse_class('MyNamespace::MyClass', xml_dir)
+	end
+
+	it "should create consistently simple types" do
+		typedef = @class.typedefs(:public, ['MapShortVectorInt'])[0]
+		type = typedef.type
+		type.name.should eql 'std::map< unsigned short, std::vector< int * > >'
+		type.should be_template
+		
+		typedef = @class.typedefs(:public, ['VectorMapShortVectorInt'])[0]
+		type = typedef.type
+		type.name.should eql 'std::vector< MapShortVectorInt >'
+		type.should be_template
+	end
+	
+	it "should create consistently complex types" do
+		typedef = @class.typedefs(:private, ['privateTypedef'])[0]
+		type = typedef.type
+		type.name.should eql 'std::map< MyMostInnerClass, TemplateClass< OuterStruct,::noNsClass, 8 > >'
+		type.should be_template
+		type.nested_local_types.map{|t| t.name}.should eql ['MyMostInnerClass', 'TemplateClass', 'OuterStruct', 'noNsClass']
+		type.nested_typenames.should eql ['std::map', 'MyMostInnerClass' , 'TemplateClass', 'OuterStruct', '::noNsClass']
+	end
+
+end

metadata

@@ -0,0 +1,83 @@
+--- !ruby/object:Gem::Specification
+name: doxyparser
+version: !ruby/object:Gem::Version
+  version: '1.2'
+platform: ruby
+authors:
+- David Fuenmayor
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-05-25 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.
+email:
+- davfuenmayor@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- MIT_LICENSE
+- lib/util.rb
+- lib/nodes/hfile.rb
+- lib/nodes/function.rb
+- lib/nodes/variable.rb
+- lib/nodes/type.rb
+- lib/nodes/class.rb
+- lib/nodes/group.rb
+- lib/nodes/friend.rb
+- lib/nodes/struct.rb
+- lib/nodes/compound.rb
+- lib/nodes/enum.rb
+- lib/nodes/node.rb
+- lib/nodes/member.rb
+- lib/nodes/param.rb
+- lib/nodes/namespace.rb
+- lib/nodes/typedef.rb
+- lib/doxyparser.rb
+- spec/namespace_spec.rb
+- spec/enum_spec.rb
+- spec/custom_spec_helper.rb
+- spec/file_spec.rb
+- spec/method_spec.rb
+- spec/doxyparser_spec.rb
+- spec/class_spec.rb
+- spec/type_spec.rb
+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
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.0.2
+signing_key: 
+specification_version: 4
+summary: Library for parsing C++ header files
+test_files:
+- spec/namespace_spec.rb
+- spec/enum_spec.rb
+- spec/custom_spec_helper.rb
+- spec/file_spec.rb
+- spec/method_spec.rb
+- spec/doxyparser_spec.rb
+- spec/class_spec.rb
+- spec/type_spec.rb