ghazel-ffi-clang 0.2.0.1

data/spec/clang/token_spec.rb

@@ -0,0 +1,83 @@
+# 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 Tokens do
+	let(:tu) { Index.new.parse_translation_unit(fixture_path("list.c")) }
+	let(:cursor) { tu.cursor }
+	let(:range) { find_first(cursor, :cursor_struct).extent }
+	let(:tokens) { tu.tokenize(range) }
+
+	it "can be obtained from a translation unit" do
+		expect(tokens).to be_kind_of(Tokens)
+		expect(tokens.size).to eq(13)
+		expect(tokens.tokens).to be_kind_of(Array)
+		expect(tokens.tokens.first).to be_kind_of(Token)
+	end
+
+	it "calls dispose_tokens on GC" do
+		expect(Lib).to receive(:dispose_tokens).at_least(:once)
+		expect{tokens.free}.not_to raise_error
+	end
+
+	it "#each" do
+		spy = double(stub: nil)
+		expect(spy).to receive(:stub).exactly(tokens.size).times
+		tokens.each { spy.stub }
+	end
+
+	it "#cursors" do
+		expect(tokens.cursors).to be_kind_of(Array)
+		expect(tokens.cursors.size).to eq(tokens.size)
+		expect(tokens.cursors.first).to be_kind_of(Cursor)
+	end
+end
+
+describe Token do
+	let(:tu) { Index.new.parse_translation_unit(fixture_path("list.c")) }
+	let(:cursor) { tu.cursor }
+	let(:range) { find_first(cursor, :cursor_struct).extent }
+	let(:token) { tu.tokenize(range).first }
+
+	it "can be obtained from a translation unit" do
+		expect(token).to be_kind_of(Token)
+	end
+
+	it "#kind" do
+		expect(token.kind).to be_kind_of(Symbol)
+		expect(token.kind).to eq(:keyword)
+	end
+
+	it "#spelling" do
+		expect(token.spelling).to be_kind_of(String)
+		expect(token.spelling).to eq('struct')
+	end
+
+	it "#location" do
+		expect(token.location).to be_kind_of(SourceLocation)
+		expect(token.location.line).to eq(1)
+	end
+
+	it "#extent" do
+		expect(token.extent).to be_kind_of(SourceRange)
+		expect(token.extent.start.line).to eq(1)
+	end
+end

data/spec/clang/translation_unit_spec.rb

@@ -0,0 +1,214 @@
+# 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 TranslationUnit do
+	before :all do
+		FileUtils.mkdir_p TMP_DIR
+	end
+
+	after :all do
+		FileUtils.rm_rf TMP_DIR
+	end
+
+	let(:tu) { Index.new.parse_translation_unit fixture_path("a.c") }
+
+	it "returns a list of diagnostics" do
+		diags = tu.diagnostics
+		expect(diags).to be_kind_of(Array)
+		expect(diags).to_not be_empty
+	end
+
+	it "returns a list of diagnostics from an unsaved file" do
+		file = UnsavedFile.new("a.c", File.read(fixture_path("a.c")))
+		tu = Index.new.parse_translation_unit("a.c", nil,[file])
+		diags = tu.diagnostics
+		expect(diags).to be_kind_of(Array)
+		expect(diags).to_not be_empty
+	end
+
+	it "calls dispose_translation_unit on GC" do
+		expect(Lib).to receive(:dispose_translation_unit).with(tu)
+		expect{tu.free}.not_to raise_error
+	end
+
+	describe "#spelling" do
+		let (:spelling) { tu.spelling }
+
+		it "returns own filename" do
+			expect(spelling).to be_kind_of(String)
+			expect(spelling).to eq(fixture_path("a.c"))
+		end
+	end
+
+	describe "#file" do
+		let (:file) { tu.file(fixture_path("a.c")) }
+
+		it "returns File instance" do
+			expect(file).to be_kind_of(FFI::Clang::File)
+		end
+	end
+
+	describe "#location" do
+		let(:file) { tu.file(fixture_path("a.c")) }
+		let(:column) { 12 }
+		let(:location) { tu.location(file, 1, column) }
+
+		it "returns source location at a specific point" do
+			expect(location).to be_kind_of(SourceLocation)
+			expect(location.file).to eq(fixture_path("a.c"))
+			expect(location.line).to eq(1)
+			expect(location.column).to eq(column)
+		end
+	end
+
+	describe "#location_offset" do
+		let(:file) { tu.file(fixture_path("a.c")) }
+		let(:offset) { 10 }
+		let(:location) { tu.location_offset(file, offset) }
+
+		it "returns source location at a specific offset point" do
+			expect(location).to be_kind_of(SourceLocation)
+			expect(location.file).to eq(fixture_path("a.c"))
+			expect(location.column).to eq(offset+1)
+		end
+	end
+
+	describe "#cursor" do
+		let(:cursor) { tu.cursor }
+		let(:location) { tu.location(tu.file(fixture_path("a.c")), 1, 10) }
+		let(:cursor_with_loc) { tu.cursor(location) }
+
+		it "returns translation unit cursor if no arguments are specified" do
+			expect(cursor).to be_kind_of(Cursor)
+			expect(cursor.kind).to eq(:cursor_translation_unit)
+		end
+
+		it "returns a correspond cursor if a source location is passed" do
+			expect(cursor_with_loc).to be_kind_of(Cursor)
+			expect(cursor_with_loc.kind).to eq(:cursor_parm_decl)
+		end
+	end
+
+	describe "#self.default_editing_translation_unit_options" do
+		let (:opts) { FFI::Clang::TranslationUnit.default_editing_translation_unit_options }
+		it "returns hash with symbols of TranslationUnitFlags" do
+			expect(opts).to be_kind_of(Hash)
+			opts.keys.each { |key|
+				expect(FFI::Clang::Lib::TranslationUnitFlags.symbols).to include(key)
+			}
+		end
+	end
+
+	describe "#default_save_options" do
+		let (:opts) { tu.default_save_options }
+		it "returns hash with symbols of SaveTranslationUnitFlags" do
+			expect(opts).to be_kind_of(Hash)
+			opts.keys.each { |key|
+				expect(FFI::Clang::Lib::SaveTranslationUnitFlags.symbols).to include(key)
+			}
+		end
+	end
+
+	describe "#save" do
+		let (:filepath) { "#{TMP_DIR}/save_translation_unit" }
+		let (:may_not_exist_filepath) { "#{TMP_DIR}/not_writable_directory/save_translation_unit" }
+		it "saves translation unit as a file" do
+			expect{tu.save(filepath)}.not_to raise_error
+			expect(FileTest.exist?(filepath)).to be_true
+		end
+
+		it "raises exception if save path is not writable" do
+			FileUtils.mkdir_p File.dirname(may_not_exist_filepath)
+			File.chmod(0444, File.dirname(may_not_exist_filepath))
+			expect{tu.save(may_not_exist_filepath)}.to raise_error
+			expect(FileTest.exist?(may_not_exist_filepath)).to be_false
+		end
+	end
+
+	describe "#default_reparse_options" do
+		let (:opts) { tu.default_reparse_options }
+		it "returns hash with symbols of ReparseFlags" do
+			expect(opts).to be_kind_of(Hash)
+			opts.keys.each { |key|
+				expect(FFI::Clang::Lib::ReparseFlags.symbols).to include(key)
+			}
+		end
+	end
+
+	describe "#reparse" do
+		let (:path) { "#{TMP_DIR}/reparse_tmp.c" }
+		before :each do
+			FileUtils.touch path
+			@reparse_tu = Index.new.parse_translation_unit(path)
+		end
+		after :each do
+			FileUtils.rm path, :force => true
+		end
+
+		it "recretes translation unit" do
+			File::open(path, "w+") { |io|
+			   io.write("int a;")
+			}
+			expect(find_first(@reparse_tu.cursor, :cursor_variable)).to be_false
+			expect{@reparse_tu.reparse}.not_to raise_error
+			expect(find_first(@reparse_tu.cursor, :cursor_variable).spelling).to eq("a")
+		end
+
+		it "raises exception if the file is not found when reparsing" do
+			FileUtils.rm path, :force => true
+			expect{@reparse_tu.reparse}.to raise_error
+		end
+	end
+
+	describe "#resource_usage" do
+		let (:ru) { tu.resource_usage }
+		it "returns ResourceUsage instance that represents memory usage of TU" do
+			expect(ru).to be_kind_of(TranslationUnit::ResourceUsage)
+		end
+	end
+
+	describe TranslationUnit::ResourceUsage do
+		let (:ru) { tu.resource_usage }
+		describe "#entries" do
+			let (:entries) { tu.resource_usage.entries }
+			it "returns array of CXTUResourceUsageEntry" do
+				expect(entries).to be_kind_of(Array)
+				expect(entries.first).to be_kind_of(Lib::CXTUResourceUsageEntry)
+				expect(entries.first[:kind]).to be_kind_of(Symbol)
+				expect(entries.first[:amount]).to be_kind_of(Integer)
+			end
+		end
+
+		describe "#self.name" do
+			let(:name) { FFI::Clang::TranslationUnit::ResourceUsage.name(:ast) }
+			it "returns the name of the memory category" do
+				expect(name).to be_kind_of(String)
+			end
+		end
+
+		describe "#self.release" do
+			it "releases data by calling 'clang_disposeCXTUResourceUsage'" do
+				expect{ ru.free }.not_to raise_error
+			end
+		end
+	end
+end

data/spec/clang/type_spec.rb

@@ -0,0 +1,289 @@
+# -*- coding: utf-8 -*-
+# Copyright, 2013, by Carlos Martín Nieto <cmn@dwim.me>
+# 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 Type do
+	let(:cursor) { Index.new.parse_translation_unit(fixture_path("a.c")).cursor }
+	let(:cursor_cxx) { Index.new.parse_translation_unit(fixture_path("test.cxx")).cursor }
+	let(:cursor_list) { Index.new.parse_translation_unit(fixture_path("list.c")).cursor }
+	let(:type) { find_first(cursor, :cursor_function).type }
+
+	it "can tell us about the main function", from_3_3: true do
+		type.variadic?.should equal(false)
+
+		type.num_arg_types.should equal(2)
+		type.arg_type(0).spelling.should eq("int")
+		type.arg_type(1).spelling.should eq("const char *")
+		type.result_type.spelling.should eq("int")
+	end
+
+  describe '#kind_spelling' do
+    let(:kind_spelling_type) { find_matching(cursor_cxx) { |child, parent|
+      child.kind == :cursor_typedef_decl and child.spelling == 'const_int_ptr'}.type }
+
+    it 'returns type kind name with string' do
+      kind_spelling_type.kind_spelling.should eq 'Typedef'
+    end
+  end
+
+  describe '#canonical' do
+    let(:canonical_type) { find_matching(cursor_cxx) { |child, parent|
+        child.kind == :cursor_typedef_decl and child.spelling == 'const_int_ptr'
+      }.type.canonical }
+
+    it 'extracts typedef', upto_3_2: true do
+      expect(canonical_type).to be_kind_of(Type)
+      expect(canonical_type.kind).to be(:type_pointer)
+    end
+
+    it 'extracts typedef', from_3_3: true do
+      expect(canonical_type).to be_kind_of(Type)
+      expect(canonical_type.kind).to be(:type_pointer)
+      expect(canonical_type.spelling).to eq('const int *')
+    end
+  end
+
+  describe '#pointee' do
+    let(:pointee_type) { find_matching(cursor_cxx) { |child, parent|
+        child.kind == :cursor_typedef_decl and child.spelling == 'const_int_ptr'
+      }.type.canonical.pointee }
+
+    it 'gets pointee type of pointer, C++ reference', upto_3_2: true do
+      expect(pointee_type).to be_kind_of(Type)
+      expect(pointee_type.kind).to be(:type_int)
+    end
+
+    it 'gets pointee type of pointer, C++ reference', from_3_3: true do
+      expect(pointee_type).to be_kind_of(Type)
+      expect(pointee_type.kind).to be(:type_int)
+      expect(pointee_type.spelling).to eq('const int')
+    end
+  end
+
+  describe '#const_qualified?' do
+    let(:pointer_type) { find_matching(cursor_cxx) { |child, parent|
+        child.kind == :cursor_typedef_decl and child.spelling == 'const_int_ptr'
+      }.type.canonical }
+
+    let(:pointee_type) { find_matching(cursor_cxx) { |child, parent|
+        child.kind == :cursor_typedef_decl and child.spelling == 'const_int_ptr'
+      }.type.canonical.pointee }
+
+    it 'checks type is const qualified' do
+      pointee_type.const_qualified?.should equal true
+    end
+
+    it 'cannot check whether pointee type is const qualified' do
+      pointer_type.const_qualified?.should equal false
+    end
+  end
+
+  describe '#volatile_qualified?' do
+    let(:pointer_type) { find_matching(cursor) { |child, parent|
+        child.kind == :cursor_variable and child.spelling == 'volatile_int_ptr'
+      }.type }
+
+    it 'checks type is volatile qualified' do
+      expect(pointer_type.volatile_qualified?).to be_true
+    end
+  end
+
+  describe '#restrict_qualified?' do
+    let(:pointer_type) { find_matching(cursor) { |child, parent|
+        child.kind == :cursor_variable and child.spelling == 'restrict_int_ptr'
+      }.type }
+
+    it 'checks type is restrict qualified' do
+      expect(pointer_type.restrict_qualified?).to be_true
+    end
+  end
+
+  describe '#element_type' do
+    let(:array_type) { find_matching(cursor_cxx) { |child, parent|
+        child.kind == :cursor_variable and child.spelling == 'int_array'
+      }.type }
+
+    it 'returns the element type of the array type' do
+      expect(array_type.element_type).to be_kind_of(Type)
+      expect(array_type.element_type.kind).to eq(:type_int)
+    end
+  end
+
+  describe '#num_elements' do
+    let(:array_type) { find_matching(cursor_cxx) { |child, parent|
+        child.kind == :cursor_variable and child.spelling == 'int_array'
+      }.type }
+
+    it 'returns the number of elements of the array' do
+      expect(array_type.num_elements).to eq(8)
+    end
+  end
+
+  describe '#array_element_type' do
+    let(:array_type) { find_matching(cursor_cxx) { |child, parent|
+        child.kind == :cursor_variable and child.spelling == 'int_array'
+      }.type }
+
+    it 'returns the array element type of the array type' do
+      expect(array_type.array_element_type).to be_kind_of(Type)
+      expect(array_type.array_element_type.kind).to eq(:type_int)
+    end
+  end
+
+  describe '#array_size' do
+    let(:array_type) { find_matching(cursor_cxx) { |child, parent|
+        child.kind == :cursor_variable and child.spelling == 'int_array'
+      }.type }
+
+    it 'returns the number of elements of the array' do
+      expect(array_type.array_size).to eq(8)
+    end
+  end
+
+  describe '#alignof', from_3_3: true do
+    let(:array_type) { find_matching(cursor_cxx) { |child, parent|
+        child.kind == :cursor_variable and child.spelling == 'int_array'
+      }.type }
+
+    it 'returns the alignment of the type in bytes' do
+      expect(array_type.alignof).to be_kind_of(Integer)
+      expect(array_type.alignof).to be > 0
+    end
+  end
+
+  describe '#sizeof', from_3_3: true do
+    let(:array_type) { find_matching(cursor_cxx) { |child, parent|
+        child.kind == :cursor_variable and child.spelling == 'int_array'
+      }.type }
+
+    it 'returns the size of the type in bytes' do
+      expect(array_type.sizeof).to be_kind_of(Integer)
+      expect(array_type.sizeof).to be(32)
+    end
+  end
+
+  describe '#offsetof', from_3_3: true do
+    let(:struct) { find_matching(cursor_list) { |child, parent|
+        child.kind == :cursor_struct and child.spelling == 'List'
+      }.type }
+
+    it 'returns the offset of a field in a record of the type in bits' do
+      expect(struct.offsetof('Next')).to be_kind_of(Integer)
+      expect(struct.offsetof('Next')).to be(64)
+    end
+  end
+
+  describe '#ref_qualifier', from_3_4: true do
+    let(:lvalue) { find_matching(cursor_cxx) { |child, parent|
+        child.kind == :cursor_cxx_method and child.spelling == 'func_lvalue_ref'
+      }.type }
+    let(:rvalue) { find_matching(cursor_cxx) { |child, parent|
+        child.kind == :cursor_cxx_method and child.spelling == 'func_rvalue_ref'
+      }.type }
+    let(:none) { find_matching(cursor_cxx) { |child, parent|
+        child.kind == :cursor_cxx_method and child.spelling == 'func_none'
+      }.type }
+
+    it 'returns :ref_qualifier_lvalue the type is ref-qualified with lvalue' do
+      expect(lvalue.ref_qualifier).to be(:ref_qualifier_lvalue)
+    end
+
+    it 'returns :ref_qualifier_rvalue the type is ref-qualified with rvalue' do
+      expect(rvalue.ref_qualifier).to be(:ref_qualifier_rvalue)
+    end
+
+    it 'returns :ref_qualifier_none the type is not ref-qualified' do
+      expect(none.ref_qualifier).to be(:ref_qualifier_none)
+    end
+  end
+
+  describe '#pod?' do
+    let(:struct) { find_matching(cursor_list) { |child, parent|
+        child.kind == :cursor_struct and child.spelling == 'List'
+      }.type }
+
+    it 'returns true if the type is a POD type' do
+      expect(struct.pod?).to be_true
+    end
+  end
+
+  describe '#class_type', from_3_4: true do
+    let(:member_pointer) { find_matching(cursor_cxx) { |child, parent|
+        child.kind == :cursor_variable and child.spelling == 'member_pointer'
+      }.type }
+
+    it 'returns the class type of the member pointer type' do
+      expect(member_pointer.class_type).to be_kind_of(Type)
+      expect(member_pointer.class_type.kind).to be(:type_record)
+      expect(member_pointer.class_type.spelling).to eq('A')
+    end
+  end
+
+  describe '#declaration' do
+    let(:struct_ref) { find_matching(cursor_cxx) { |child, parent|
+        child.kind == :cursor_type_ref and child.spelling == 'struct D'
+      }.type }
+    let(:struct_decl) { find_matching(cursor_cxx) { |child, parent|
+        child.kind == :cursor_struct and child.spelling == 'D'
+      } }
+    let(:no_decl) { find_first(cursor_cxx, :cursor_cxx_method).type }
+
+    it 'returns the class type of the member pointer type' do
+      expect(struct_ref.declaration).to be_kind_of(Cursor)
+      expect(struct_ref.declaration.kind).to be(:cursor_struct)
+      expect(struct_ref.declaration).to eq(struct_decl)
+    end
+
+    it 'returns :cursor_no_decl_found if the type has no declaration' do
+      expect(no_decl.declaration).to be_kind_of(Cursor)
+      expect(no_decl.declaration.kind).to be(:cursor_no_decl_found)
+    end
+  end
+
+  describe '#calling_conv' do
+    let(:function) { find_matching(cursor_cxx) { |child, parent|
+        child.kind == :cursor_function and child.spelling == 'f_variadic'
+      }.type }
+
+    it 'returns the calling convention associated with the function type', from_3_4: true do
+      expect(function.calling_conv).to be(:calling_conv_c)
+    end
+
+    it 'returns the calling convention associated with the function type', upto_3_3: true do
+      expect(function.calling_conv).to be(:calling_conv_default)
+    end
+  end
+
+  describe '#==' do
+    let(:type_decl) { find_matching(cursor_cxx) { |child, parent|
+        child.kind == :cursor_field_decl and child.spelling == 'int_member_a'
+      }.type }
+    let(:type_ref) { find_matching(cursor_cxx) { |child, parent|
+        child.kind == :cursor_decl_ref_expr and child.spelling == 'int_member_a'
+      }.type }
+
+    it 'checks if two types represent the same type' do
+      expect(type_decl == type_ref).to be_true
+    end
+  end
+end