ffi-clang 0.2.0 → 0.2.1

data/spec/clang/compilation_database_spec.rb

@@ -0,0 +1,178 @@
+# Copyright, 2014, by Masahiro Sano.
+# 
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+# 
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+# THE SOFTWARE.
+
+require 'spec_helper'
+
+describe CompilationDatabase do
+	let(:dirpath) { fixture_path('') }
+	let(:cdb) { CompilationDatabase.new(dirpath) }
+	let(:file) { '/home/xxxxx/src/llvm-trunk/lib/Support/APFloat.cpp' }
+
+	it "can be created" do
+		expect(cdb).to be_kind_of(CompilationDatabase)
+	end
+
+	it "raises DatabaseLoadError if cannot be created" do
+		expect{CompilationDatabase.new('/not/exist/directory')}.to raise_error FFI::Clang::CompilationDatabase::DatabaseLoadError
+	end
+
+	it "calls compilation_database_dispose on GC" do
+		cdb.autorelease = false
+		expect(Lib).to receive(:compilation_database_dispose).with(cdb).once
+		expect{cdb.free}.not_to raise_error
+	end
+
+	describe '#compile_commands' do
+		let(:not_found_file) { '/home/xxxxx/not_found_file_path' }
+
+		it "returns compile commands used for a file" do
+			expect(cdb.compile_commands(file)).to be_kind_of(CompilationDatabase::CompileCommands)
+			expect(cdb.compile_commands(file).size).to eq(1)
+		end
+
+		it "returns compile commands if the specified file is not found" do
+			expect(cdb.compile_commands(not_found_file)).to be_kind_of(CompilationDatabase::CompileCommands)
+			expect(cdb.compile_commands(not_found_file).size).to eq(0)
+		end
+	end
+
+	describe '#all_compile_commands', from_3_3: true do
+		it "returns all compile commands in the database" do
+			expect(cdb.all_compile_commands).to be_kind_of(CompilationDatabase::CompileCommands)
+			expect(cdb.all_compile_commands.size).to eq(3)
+		end
+	end
+
+	describe CompilationDatabase::CompileCommands do
+		let(:commands) { cdb.compile_commands(file) }
+
+		it "calls compile_commands_dispose on GC" do
+			commands.autorelease = false
+			expect(Lib).to receive(:compile_commands_dispose).with(commands).once
+			expect{commands.free}.not_to raise_error
+		end
+
+		describe '#size' do
+			it "returns the number of CompileCommand" do
+				expect(commands.size).to be_kind_of(Integer)
+				expect(commands.size).to eq(1)
+			end
+
+			it "returns the number of CompileCommand", from_3_3: true do
+				expect(cdb.all_compile_commands.size).to eq(3)
+			end
+		end
+
+		describe '#command' do
+			it "returns the I'th CompileCommand" do
+				expect(commands.command(0)).to be_kind_of(CompilationDatabase::CompileCommand)
+			end
+		end
+
+		describe "#commands" do
+			it "returns all CompileCommand as Array" do
+				expect(commands.commands).to be_kind_of(Array)
+				expect(commands.commands.first).to be_kind_of(CompilationDatabase::CompileCommand)
+				expect(commands.commands.size).to eq(commands.size)
+			end
+		end
+
+		describe "#each" do
+			let(:spy) { double(stub: nil) }
+			it "calls block once for each CompileCommand" do
+				expect(spy).to receive(:stub).exactly(commands.size).times
+				commands.each { spy.stub }
+			end
+		end
+	end
+
+	describe CompilationDatabase::CompileCommand do
+		let(:cmd) { cdb.compile_commands(file).first }
+
+		describe '#directory' do
+			it "returns the working directory" do
+				expect(cmd.directory).to be_kind_of(String)
+				expect(cmd.directory).to eq('/home/xxxxx/src/build-trunk/lib/Support')
+			end
+		end
+
+		describe '#num_args' do
+			it "returns the number of CompileCommand" do
+				expect(cmd.num_args).to be_kind_of(Integer)
+				expect(cmd.num_args).to eq(31)
+			end
+		end
+
+		describe '#arg' do
+			it "returns the I'th argument value" do
+				expect(cmd.arg(0)).to be_kind_of(String)
+				expect(cmd.arg(0)).to eq('/opt/llvm/3.4/bin/clang++')
+			end
+		end
+
+		describe '#args' do
+			it "returns all argument values as Array" do
+				expect(cmd.args).to be_kind_of(Array)
+				expect(cmd.args.first).to be_kind_of(String)
+				expect(cmd.args.size).to eq(cmd.num_args)
+			end
+		end
+
+		describe '#num_mapped_sources', from_3_4: true do
+			# TODO: a case which has mapped sources
+
+			it "returns the number of source mappings" do
+				# expect(cmd.num_mapped_sources).to be_kind_of(Integer)
+				# expect(cmd.num_mapped_sources).to eq(0)
+			end
+		end
+
+		describe '#mapped_source_path', from_3_4: true do
+			it "returns the I'th mapped source path" do
+				# TODO: a case which returns real source path
+				# expect(cmd.mapped_source_path(0)).to be_kind_of(String)
+			end
+
+			it "returns nil if the index exceeds element size" do
+				# expect(cmd.mapped_source_path(1000)).to be_nil
+			end
+		end
+
+		describe '#mapped_source_content', from_3_4: true do
+			it "returns the I'th mapped source content" do
+				# TODO: a case which returns real source path
+				# expect(cmd.mapped_source_content(0)).to be_kind_of(String)
+			end
+
+			it "returns nil if the index exceeds element size" do
+				# expect(cmd.mapped_source_content(1000)).to be_nil
+			end
+		end
+
+		describe '#mapped_sources', from_3_4: true do
+			# TODO: a case which has mapped sources
+
+			it "returns all mapped sources as Array" do
+				# expect(cmd.mapped_sources).to be_kind_of(Array)
+				# expect(cmd.mapped_sources.size).to eq(cmd.num_mapped_sources)
+			end
+		end
+	end
+end

data/spec/clang/cursor_spec.rb

@@ -1,6 +1,7 @@
 # Copyright, 2010-2012 by Jari Bakken.
 # Copyright, 2013, by Samuel G. D. Williams. <http://www.codeotaku.com>
 # Copyright, 2013, by Garry C. Marshall. <http://www.meaningfulname.net>
+# Copyright, 2014, by Masahiro Sano.
 # 
 # Permission is hereby granted, free of charge, to any person obtaining a copy
 # of this software and associated documentation files (the "Software"), to deal
@@ -26,6 +27,7 @@ describe Cursor do
 	let(:cursor) { Index.new.parse_translation_unit(fixture_path("list.c")).cursor }
 	let(:cursor_cxx) { Index.new.parse_translation_unit(fixture_path("test.cxx")).cursor }
 	let(:cursor_canon) { Index.new.parse_translation_unit(fixture_path("canonical.c")).cursor }
+	let(:cursor_pp) { Index.new.parse_translation_unit(fixture_path("docs.c"),[],[],{detailed_preprocessing_record: true}).cursor }
 
 	it "can be obtained from a translation unit" do
 		cursor.should be_kind_of(Cursor)
@@ -52,12 +54,12 @@ describe Cursor do
 
 		it 'has filename and posion at end point', from_3_4: true do
 			expect(extent.end.file).to eq(fixture_path("list.c"))
-			expect(extent.end.line).to equal(11)
+			expect(extent.end.line).to equal(12)
 		end
 
 		it 'has filename and posion at end point', upto_3_3: true do
 			expect(extent.end.file).to eq(fixture_path("list.c"))
-			expect(extent.end.line).to equal(10)
+			expect(extent.end.line).to equal(11)
 		end
 	end
 
@@ -142,6 +144,110 @@ describe Cursor do
 
 	end
 
+	describe '#kind_spelling' do
+		let (:struct) { find_first(cursor, :cursor_struct) }
+
+		it "returns the spelling of the given kind" do
+			expect(struct.kind_spelling).to eq('StructDecl')
+		end
+	end
+
+	describe '#declaration?' do
+		let (:struct) { find_first(cursor, :cursor_struct) }
+
+		it "checks the cursor is declaration" do
+			expect(struct.declaration?).to be true
+		end
+	end
+
+	describe '#reference?' do
+		let (:ref) { find_first(cursor, :cursor_type_ref) }
+
+		it "checks the cursor is reference" do
+			expect(ref.reference?).to be true
+		end
+	end
+
+	describe '#expression?' do
+		let (:literal) { find_first(cursor, :cursor_integer_literal) }
+
+		it "checks the cursor is expression" do
+			expect(literal.expression?).to be true
+		end
+	end
+
+	describe '#statement?' do
+		let (:return_stmt) { find_first(cursor, :cursor_return_stmt) }
+
+		it "checks the cursor is statement" do
+			expect(return_stmt.statement?).to be true
+		end
+	end
+
+	describe '#attribute?' do
+		let (:attr) { find_first(cursor_cxx, :cursor_unexposed_attr) }
+
+		it "checks the cursor is attribute" do
+			expect(attr.attribute?).to be true
+		end
+	end
+
+	describe '#public?' do
+		let(:public_cursor) { find_matching(cursor_cxx) { |child, parent|
+				child.kind == :cursor_field_decl and child.spelling == 'public_member_int' } }
+
+		it 'checks access control level is public', from_3_3: true do
+			expect(public_cursor.public?).to be true
+		end
+
+		it 'returns false on clang 3.2', upto_3_2: true do
+			expect(public_cursor.public?).to be false
+		end
+	end
+
+	describe '#private?' do
+		let(:private_cursor) { find_matching(cursor_cxx) { |child, parent|
+				child.kind == :cursor_field_decl and child.spelling == 'private_member_int' } }
+
+		it 'checks access control level is private', from_3_3: true do
+			expect(private_cursor.private?).to be true
+		end
+
+		it 'returns false on clang 3.2', upto_3_2: true do
+			expect(private_cursor.private?).to be false
+		end
+	end
+
+	describe '#protected?' do
+		let(:protected_cursor) { find_matching(cursor_cxx) { |child, parent|
+				child.kind == :cursor_field_decl and child.spelling == 'protected_member_int' } }
+
+		it 'checks access control level is protected', from_3_3: true do
+			expect(protected_cursor.protected?).to be true
+		end
+
+		it 'returns false on clang 3.2', upto_3_2: true do
+			expect(protected_cursor.protected?).to be false
+		end
+	end
+
+	describe '#preprocessing?' do
+		let (:pp) { find_first(cursor_pp, :cursor_macro_definition) }
+
+		it 'checks the cursor is preprocessing' do
+			expect(pp.preprocessing?).to be true
+		end
+	end
+
+	describe '#unexposed?' do
+		let(:unexposed_cursor) { find_matching(cursor_cxx) { |child, parent|
+				child.kind == :cursor_unexposed_expr and child.spelling == 'func_overloaded' } }
+
+		it 'checks the cursor is unexposed' do
+			expect(unexposed_cursor.unexposed?).to be true
+		end
+	end
+
 	describe '#virtual_base?' do
 		let(:virtual_base_cursor) { find_matching(cursor_cxx) { |child, parent|
 				child.kind == :cursor_cxx_base_specifier and parent.spelling == 'B' } }
@@ -188,12 +294,33 @@ describe Cursor do
 		end
 	end
 
+	describe '#enum_unsigned_value' do
+		let(:enum_value_cursor) { find_matching(cursor_cxx) { |child, parent|
+			child.kind == :cursor_enum_constant_decl and child.spelling == 'EnumC' } }
+
+		it 'returns enum unsigned value' do
+			expect(enum_value_cursor.enum_unsigned_value).to eq(100)
+		end
+	end
+
 	describe '#dynamic_call?' do
-		# TODO
+		let(:dynamic_call) { find_matching(cursor_cxx) { |child, parent|
+				child.kind == :cursor_call_expr and child.spelling == 'func_a' and 
+				child.semantic_parent.spelling == 'f_dynamic_call' } }
+
+		it 'checks if the method call is dynamic' do
+			expect(dynamic_call.dynamic_call?).to be true
+		end
 	end
 
-	describe '#specialized_template' do
-		# TODO
+	describe '#specialized_template', from_3_3: true do # looks not working on 3.2
+		let(:cursor_function) { find_matching(cursor_cxx) { |child, parent|
+				child.kind == :cursor_function and child.spelling == 'func_overloaded' } }
+
+		it "returns a cursor that may represent a specialization or instantiation of a template" do
+			expect(cursor_function.specialized_template).to be_kind_of(Cursor)
+			expect(cursor_function.specialized_template.kind).to be(:cursor_function_template)
+		end
 	end
 
 	describe '#canonical' do
@@ -224,8 +351,14 @@ describe Cursor do
 		end
 	end
 
-	describe '#template_kind' do
-		# TODO
+	describe '#template_kind', from_3_3: true do # looks not working on 3.2
+		let(:template) { find_matching(cursor_cxx) { |child, parent|
+				child.kind == :cursor_function_template and child.spelling == 'func_overloaded' } }
+
+		it "returns the cursor kind of the specializations would be generated" do
+			expect(template.template_kind).to be_kind_of(Symbol)
+			expect(template.template_kind).to be(:cursor_function)
+		end
 	end
 
 	describe '#access_specifier' do
@@ -263,6 +396,7 @@ describe Cursor do
 
 		it "returns the translation unit that a cursor originated from" do
 			struct.translation_unit.should be_kind_of(TranslationUnit)
+			struct.translation_unit.spelling.should eq(fixture_path("list.c"))
 		end
 	end
 
@@ -305,7 +439,7 @@ describe Cursor do
 		let (:struct) { find_all(cursor_canon, :cursor_struct).at(2) }
 
 		it "checks cursor is a definition" do
-			struct.definition?.should be_true
+			struct.definition?.should be true
 		end
 	end
 
@@ -322,7 +456,7 @@ describe Cursor do
 				child.kind == :cursor_function and child.spelling == 'f_variadic' } }
 
 		it "checks cursor is a variadic function" do
-			func.variadic?.should be_true
+			func.variadic?.should be true
 		end
 	end
 
@@ -372,15 +506,204 @@ describe Cursor do
 		end
 	end
 
+	describe '#bitfield?', from_3_3: true do
+		let(:bitfield) { find_matching(cursor_cxx) { |child, parent|
+				child.kind == :cursor_field_decl and child.spelling == 'bit_field_a' } }
+		let(:non_bitfield) { find_matching(cursor_cxx) { |child, parent|
+				child.kind == :cursor_field_decl and child.spelling == 'non_bit_field_c' } }
+
+		it "returns true if the cursor is bitfield" do
+			expect(bitfield.bitfield?).to be true
+		end
+
+		it "returns false if the cursor is not bitfield" do
+			expect(non_bitfield.bitfield?).to be false
+		end
+	end
+
+	describe '#bitwidth', from_3_3: true do
+		let(:bitfield) { find_matching(cursor_cxx) { |child, parent|
+				child.kind == :cursor_field_decl and child.spelling == 'bit_field_a' } }
+		let(:non_bitfield) { find_matching(cursor_cxx) { |child, parent|
+				child.kind == :cursor_field_decl and child.spelling == 'non_bit_field_c' } }
+
+		it "returns the bit width of the bit field if the cursor is bitfield" do
+			expect(bitfield.bitwidth).to be_kind_of(Integer)
+			expect(bitfield.bitwidth).to eq(2)
+		end
+
+		it "returns -1 if the cursor is not bitfield" do
+			expect(non_bitfield.bitwidth).to eq(-1)
+		end
+	end
+
 	describe '#enum_decl_integer_type' do
-		#TODO
+		let(:enum) { find_matching(cursor_cxx) { |child, parent|
+				child.kind == :cursor_enum_decl and child.spelling == 'normal_enum' } }
+
+		it "returns the integer type of the enum declaration" do
+			expect(enum.enum_decl_integer_type).to be_kind_of(Type)
+			expect(enum.enum_decl_integer_type.kind).to be(:type_uint)
+		end
 	end
 
 	describe '#platform_availability' do
-		#TODO
+		let(:func) { find_matching(cursor_cxx) { |child, parent|
+				child.kind == :cursor_function and child.spelling == 'availability_func'} }
+		let(:availability) { func.platform_availability }
+
+		it "returns the availability of the entity as Hash" do
+			expect(availability).to be_kind_of(Hash)
+			expect(availability[:always_deprecated]).to be_kind_of(Integer)
+			expect(availability[:always_unavailable]).to be_kind_of(Integer)
+			expect(availability[:deprecated_message]).to be_kind_of(String)
+			expect(availability[:unavailable_message]).to be_kind_of(String)
+			expect(availability[:availability]).to be_kind_of(Array)
+		end
+	end
+
+	describe '#overriddens' do
+		let(:override_cursor) { find_matching(cursor_cxx) { |child, parent|
+				child.kind == :cursor_cxx_method and
+				child.spelling == 'func_a' and parent.spelling == 'D' } }
+
+		it "returns the set of methods which are overridden by this cursor method" do
+			expect(override_cursor.overriddens).to be_kind_of(Array)
+			expect(override_cursor.overriddens.size).to eq(2)
+			expect(override_cursor.overriddens.map{|cur| cur.semantic_parent.spelling}).to eq(["B", "C"])
+		end
+	end
+
+	describe '#overloaded_decl' do
+		let(:overloaded) { find_matching(cursor_cxx) { |child, parent|
+				child.kind == :cursor_overloaded_decl_ref and child.spelling == 'func_overloaded' } }
+
+		it "returns a cursor for one of the overloaded declarations" do
+			expect(overloaded.overloaded_decl(0)).to be_kind_of(Cursor)
+			expect(overloaded.overloaded_decl(0).kind).to be(:cursor_function_template)
+			expect(overloaded.overloaded_decl(0).spelling).to eq('func_overloaded')
+		end
+	end
+
+	describe '#num_overloaded_decls' do
+		let(:overloaded) { find_matching(cursor_cxx) { |child, parent|
+				child.kind == :cursor_overloaded_decl_ref and child.spelling == 'func_overloaded' } }
+
+		it "returns the number of overloaded declarations" do
+			expect(overloaded.num_overloaded_decls).to be_kind_of(Integer)
+			expect(overloaded.num_overloaded_decls).to be(2)
+		end
 	end
 
-	describe '#get_overridden_cursors' do
+	describe '#objc_type_encoding' do
 		#TODO
 	end
+
+	describe '#argument' do
+		let(:func) { find_matching(cursor_cxx) { |child, parent|
+				child.kind == :cursor_function and child.spelling == 'f_non_variadic' } }
+
+		it "returns the argument cursor of the function" do
+			expect(func.argument(0)).to be_kind_of(Cursor)
+			expect(func.argument(0).spelling).to eq('a')
+		end
+	end
+
+	describe '#num_arguments' do
+	    let(:cursor_cxx) { Index.new.parse_translation_unit(fixture_path("test.cxx")).cursor }
+		let(:func) { find_matching(cursor_cxx) { |child, parent|
+				child.kind == :cursor_function and child.spelling == 'f_non_variadic' } }
+
+		it "returns the number of non-variadic arguments" do
+			expect(func.num_arguments).to be_kind_of(Integer)
+			expect(func.num_arguments).to be(3)
+		end
+	end
+
+	describe '#result_type' do
+		let(:func) { find_matching(cursor_cxx) { |child, parent|
+				child.kind == :cursor_function and child.spelling == 'f_non_variadic' } }
+
+		it "result the result type of the function" do
+			expect(func.result_type).to be_kind_of(Type)
+			expect(func.result_type.kind).to be(:type_void)
+		end
+	end
+
+	describe '#raw_comment_text' do
+		let(:func) { find_matching(cursor_pp) { |child, parent|
+				child.kind == :cursor_function and child.spelling == 'a_function' } }
+
+		it "checks the cursor is declaration" do
+			expect(func.raw_comment_text).to be_kind_of(String)
+			expect(func.raw_comment_text).not_to be_empty
+		end
+	end
+
+	describe '#comment' do
+		let(:func) { find_matching(cursor_pp) { |child, parent|
+				child.kind == :cursor_function and child.spelling == 'a_function' } }
+
+		it "checks the cursor is declaration" do
+			expect(func.comment).to be_kind_of(Comment)
+		end
+	end
+
+	describe '#included_file' do
+		let (:inclusion) { find_first(cursor_pp, :cursor_inclusion_directive) }
+
+		it 'returns the file that is included by the given inclusion directive cursor' do
+			expect(inclusion.included_file).to be_kind_of(FFI::Clang::File)
+			expect(File.basename(inclusion.included_file.name)).to eq("docs.h")
+		end
+	end
+
+	describe Cursor::PlatformAvailability do
+		let(:func) { find_matching(cursor_cxx) { |child, parent|
+				child.kind == :cursor_function and child.spelling == 'availability_func'} }
+		let(:availability) { func.platform_availability[:availability].first }
+
+		it "can be obtained by Cursor#platform_availability" do
+			expect(availability).to be_kind_of(Cursor::PlatformAvailability)
+		end
+
+		describe "#platform" do
+			it "returns availability information for the platform" do
+				expect(availability.platform).to be_kind_of(String)
+			end
+		end
+
+		describe "#introduced" do
+			it "returns the version number in which this entity was introduced" do
+				expect(availability.introduced).to be_kind_of(Lib::CXVersion)
+				expect(availability.introduced.to_s).to eq("10.4.1")
+			end
+		end
+
+		describe "#deprecated" do
+			it "returns the version number in which this entity was deprecated" do
+				expect(availability.deprecated).to be_kind_of(Lib::CXVersion)
+				expect(availability.deprecated.to_s).to eq("10.6")
+			end
+		end
+
+		describe "#obsoleted" do
+			it "returns the version number in which this entity was obsoleted" do
+				expect(availability.obsoleted).to be_kind_of(Lib::CXVersion)
+				expect(availability.obsoleted.to_s).to eq("10.7")
+			end
+		end
+
+		describe "#unavailable" do
+			it "returns whether the entity is unavailable on this platform" do
+				expect(availability.unavailable).to be false
+			end
+		end
+
+		describe "#message" do
+			it "returns an optional message to provide to a user of this API" do
+				expect(availability.message).to be_kind_of(String)
+			end
+		end
+	end
 end