ffi-clang 0.3.0 → 0.5.0

data/spec/{clang → ffi/clang}/diagnostic_spec.rb

@@ -1,4 +1,3 @@
-require 'spec_helper'
 
 describe Diagnostic do
 	let(:diagnostics) { Index.new.parse_translation_unit(fixture_path("list.c")).diagnostics }
@@ -6,32 +5,32 @@ describe Diagnostic do
 
 	it "returns a string representation of the diagnostic" do
 		str = diagnostic.format
-		str.should be_kind_of(String)
-		str.should =~ /does not match previous/
+		expect(str).to be_kind_of(String)
+		expect(str).to match(/does not match previous/)
 	end
 
 	it "returns a string representation according to the given opts" do
-		diagnostic.format(:source_location => true).should include("list.c:5")
+		expect(diagnostic.format(:source_location => true)).to include("list.c:5")
 	end
 
 	it "returns the text of the diagnostic" do
-		diagnostic.spelling.should be_kind_of(String)
+		expect(diagnostic.spelling).to be_kind_of(String)
 	end
 
 	it "returns the severity of the diagnostic" do
-		diagnostic.severity.should == :error
+		expect(diagnostic.severity).to eq(:error)
 	end
 
 	it "returns the ranges of the diagnostic" do
 		rs = diagnostics[1].ranges
-		rs.should be_kind_of(Array)
-		rs.should_not be_empty
-		rs.first.should be_kind_of(SourceRange)
+		expect(rs).to be_kind_of(Array)
+		expect(rs).not_to be_empty
+		expect(rs.first).to be_kind_of(SourceRange)
 	end
 
 	it "calls dispose_diagnostic on GC" do
 		diagnostic.autorelease = false
-		expect(Lib).to receive(:dispose_diagnostic).with(diagnostic).once
+		# expect(Lib).to receive(:dispose_diagnostic).with(diagnostic).once
 		expect{diagnostic.free}.not_to raise_error
 	end
 

data/spec/{clang → ffi/clang}/file_spec.rb

@@ -18,8 +18,6 @@
 # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 # THE SOFTWARE.
 
-require 'spec_helper'
-
 describe File do
 	let(:file_list) { Index.new.parse_translation_unit(fixture_path("list.c")).file(fixture_path("list.c")) }
 	let(:file_docs) { Index.new.parse_translation_unit(fixture_path("docs.c")).file(fixture_path("docs.h")) }
@@ -64,19 +62,19 @@ describe File do
 		end
 	end
 
-	describe "#device", from_3_3: true do
+	describe "#device" do
 		it 'returns device from CXFileUniqueID' do
 			expect(file_list.device).to be_kind_of(Integer)
 		end
 	end
 
-	describe "#inode", from_3_3: true do
+	describe "#inode" do
 		it 'returns inode from CXFileUniqueID' do
 			expect(file_list.inode).to be_kind_of(Integer)
 		end
 	end
 
-	describe "#modification", from_3_3: true do
+	describe "#modification" do
 		it 'returns modification time as Time from CXFileUniqueID' do
 			expect(file_list.modification).to be_kind_of(Time)
 		end

data/spec/ffi/clang/fixtures/class.cpp

@@ -0,0 +1,8 @@
+struct Factory {
+  void create();
+};
+
+void Factory::create()
+{
+  this->create();
+}

data/spec/{clang → ffi/clang}/index_spec.rb

@@ -18,54 +18,57 @@
 # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 # THE SOFTWARE.
 
-require 'spec_helper'
-
 describe Index do
 	before :all do
 		FileUtils.mkdir_p TMP_DIR
 	end
 
 	after :all do
-		FileUtils.rm_rf TMP_DIR
+		# FileUtils.rm_rf TMP_DIR
 	end
 
 	let(:index) { Index.new }
 
-	it "calls dispose_index_debug_unit on GC" do
+	it "calls dispose_index on GC" do
 		index.autorelease = false
-		expect(Lib).to receive(:dispose_index).with(index).once
+		# It's possible for this to be called multiple times if there are other Index instances created during test
+		# expect(Lib).to receive(:dispose_index).with(index).once
 		expect{index.free}.not_to raise_error
 	end
 
 	describe '#parse_translation_unit' do
 		it "can parse a source file" do
-			tu = index.parse_translation_unit fixture_path("a.c")
-			expect(tu).to be_kind_of(TranslationUnit)
+			translation_unit = index.parse_translation_unit fixture_path("a.c")
+			expect(translation_unit).to be_kind_of(TranslationUnit)
 		end
 
 		it "raises error when file is not found" do
-			expect { index.parse_translation_unit fixture_path("xxxxxxxxx.c") }.to raise_error
+			expect { index.parse_translation_unit fixture_path("xxxxxxxxx.c") }.to raise_error(FFI::Clang::Error)
 		end
 
 		it "can handle command line options" do
-		   expect{index.parse_translation_unit(fixture_path("a.c"), ["-std=c++11"])}.not_to raise_error
+			expect{index.parse_translation_unit(fixture_path("a.c"), ["-std=c++11"])}.not_to raise_error
 		end
 	end
 
 	describe '#create_translation_unit' do
-		before :all do
-			system("#{CLANG_COMPILER} -c #{fixture_path('simple.c')} -emit-ast -o #{TMP_DIR}/simple.ast")
+		let(:simple_ast_path) {"#{TMP_DIR}/simple.ast"}
+		
+		before :each do
+			translation_unit = index.parse_translation_unit fixture_path("simple.c")
+			
+			translation_unit.save(simple_ast_path)
 		end
 
 		it "can create translation unit from a ast file" do
 			expect(FileTest.exist?("#{TMP_DIR}/simple.ast")).to be true
-			tu = index.create_translation_unit "#{TMP_DIR}/simple.ast"
-			expect(tu).to be_kind_of(TranslationUnit)
+			translation_unit = index.create_translation_unit "#{TMP_DIR}/simple.ast"
+			expect(translation_unit).to be_kind_of(TranslationUnit)
 		end
 
 		it "raises error when file is not found" do
 			expect(FileTest.exist?('not_found.ast')).to be false
-			expect { index.create_translation_unit 'not_found.ast' }.to raise_error
+			expect { index.create_translation_unit 'not_found.ast' }.to raise_error(FFI::Clang::Error)
 		end
 	end
 end

data/spec/{clang → ffi/clang}/source_location_spec.rb

@@ -21,18 +21,16 @@
 # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 # THE SOFTWARE.
 
-require 'spec_helper'
-
 describe SourceLocation do
-	let(:tu)                   { Index.new.parse_translation_unit(fixture_path("list.c")) }
-	let(:tu_location)          { tu.cursor.location }
-	let(:diagnostic_location)  { tu.diagnostics.first.location }
-	let(:loc1_tu)              { Index.new.parse_translation_unit(fixture_path("location1.c")) }
-	let(:loc1_cursor)          { find_first(loc1_tu.cursor, :cursor_function) }
-	let(:docs_cursor)          { Index.new.parse_translation_unit(fixture_path("docs.c")).cursor }
+	let(:translation_unit) { Index.new.parse_translation_unit(fixture_path("list.c")) }
+	let(:translation_unit_location) { translation_unit.cursor.location }
+	let(:diagnostic_location) { translation_unit.diagnostics.first.location }
+	let(:loc1_translation_unit) { Index.new.parse_translation_unit(fixture_path("location1.c")) }
+	let(:loc1_cursor) { find_first(loc1_translation_unit.cursor, :cursor_function) }
+	let(:docs_cursor) { Index.new.parse_translation_unit(fixture_path("docs.c")).cursor }
 
 	it "should have a nil File if the SourceLocation is for a Translation Unit" do
-		expect(tu_location.file).to be_nil
+		expect(translation_unit_location.file).to be_nil
 	end
 
 	it "should provide a File, line and column for a Diagnostic" do
@@ -42,8 +40,8 @@ describe SourceLocation do
 	end
 
 	it "should be ExpansionLocation" do
-		expect(tu_location).to be_kind_of(SourceLocation)
-		expect(tu_location).to be_kind_of(ExpansionLocation)
+		expect(translation_unit_location).to be_kind_of(SourceLocation)
+		expect(translation_unit_location).to be_kind_of(ExpansionLocation)
 	end
 
 	describe "Null Location" do
@@ -65,7 +63,7 @@ describe SourceLocation do
 		end
 	end
 
-	describe "#from_main_file?", from_3_4: true do
+	describe "#from_main_file?" do
 		it "returns true if the cursor location is in main file" do
 			expect(loc1_cursor.location.from_main_file?).to be true
 		end
@@ -75,7 +73,7 @@ describe SourceLocation do
 		end
 	end
 
-	describe "#in_system_header?", from_3_4: true do
+	describe "#in_system_header?" do
 		it "returns false if the cursor location is not in system header" do
 			expect(loc1_cursor.location.in_system_header?).to be false
 		end
@@ -111,7 +109,7 @@ describe SourceLocation do
 		end
 	end
 
-	describe "#file_location", from_3_3: true do
+	describe "#file_location" do
 		let (:file_location) { loc1_cursor.location.file_location }
 
 		it "should be FileLocaion" do

data/spec/{clang → ffi/clang}/source_range_spec.rb

@@ -18,22 +18,20 @@
 # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 # THE SOFTWARE.
 
-require 'spec_helper'
-
 describe SourceRange do
-	let(:tu) { Index.new.parse_translation_unit(fixture_path("list.c")) }
-	let(:tu_range) { tu.cursor.extent }
+	let(:translation_unit) { Index.new.parse_translation_unit(fixture_path("list.c")) }
+	let(:translation_unit_range) { translation_unit.cursor.extent }
 
 	it "can be obtained from a cursor" do
-		expect(tu_range).to be_kind_of(SourceRange)
-		expect(tu_range.null?).to be false
+		expect(translation_unit_range).to be_kind_of(SourceRange)
+		expect(translation_unit_range.null?).to be false
 	end
 
 	it "has start and end source location" do
-		expect(tu_range.start).to be_kind_of(SourceLocation)
-		expect(tu_range.start.null?).to be false
-		expect(tu_range.end).to be_kind_of(SourceLocation)
-		expect(tu_range.end.null?).to be false
+		expect(translation_unit_range.start).to be_kind_of(SourceLocation)
+		expect(translation_unit_range.start.null?).to be false
+		expect(translation_unit_range.end).to be_kind_of(SourceLocation)
+		expect(translation_unit_range.end.null?).to be false
 	end
 
 	describe "Null Range" do
@@ -57,7 +55,7 @@ describe SourceRange do
 	end
 
     describe "Get Range" do
-        let(:range) { SourceRange.new(tu_range.start, tu_range.end) }
+        let(:range) { SourceRange.new(translation_unit_range.start, translation_unit_range.end) }
 
         it "can be obtained from two source locations" do
 			expect(range).to be_kind_of(SourceRange)
@@ -65,12 +63,12 @@ describe SourceRange do
         end
 
         it "is same to original source range" do
-			expect(range).to eq(tu_range)
+			expect(range).to eq(translation_unit_range)
         end
 
         it "is same to original source range's locations" do
-			expect(range.start).to eq(tu_range.start)
-			expect(range.end).to eq(tu_range.end)
+			expect(range.start).to eq(translation_unit_range.start)
+			expect(range.end).to eq(translation_unit_range.end)
         end
     end
 end

data/spec/{clang → ffi/clang}/token_spec.rb

@@ -18,13 +18,11 @@
 # 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(:translation_unit) { Index.new.parse_translation_unit(fixture_path("list.c")) }
+	let(:cursor) { translation_unit.cursor }
 	let(:range) { find_first(cursor, :cursor_struct).extent }
-	let(:tokens) { tu.tokenize(range) }
+	let(:tokens) { translation_unit.tokenize(range) }
 
 	it "can be obtained from a translation unit" do
 		expect(tokens).to be_kind_of(Tokens)
@@ -53,10 +51,10 @@ describe Tokens do
 end
 
 describe Token do
-	let(:tu) { Index.new.parse_translation_unit(fixture_path("list.c")) }
-	let(:cursor) { tu.cursor }
+	let(:translation_unit) { Index.new.parse_translation_unit(fixture_path("list.c")) }
+	let(:cursor) { translation_unit.cursor }
 	let(:range) { find_first(cursor, :cursor_struct).extent }
-	let(:token) { tu.tokenize(range).first }
+	let(:token) { translation_unit.tokenize(range).first }
 
 	it "can be obtained from a translation unit" do
 		expect(token).to be_kind_of(Token)

data/spec/{clang → ffi/clang}/translation_unit_spec.rb

@@ -18,8 +18,6 @@
 # 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
@@ -29,30 +27,30 @@ describe TranslationUnit do
 		FileUtils.rm_rf TMP_DIR
 	end
 
-	let(:tu) { Index.new.parse_translation_unit fixture_path("a.c") }
+	let(:translation_unit) { Index.new.parse_translation_unit fixture_path("a.c") }
 
 	it "returns a list of diagnostics" do
-		diags = tu.diagnostics
+		diags = translation_unit.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
+		translation_unit = Index.new.parse_translation_unit("a.c", nil,[file])
+		diags = translation_unit.diagnostics
 		expect(diags).to be_kind_of(Array)
 		expect(diags).to_not be_empty
 	end
 
 	it "calls dispose_translation_unit on GC" do
-		tu.autorelease = false
-		expect(Lib).to receive(:dispose_translation_unit).with(tu).once
-		expect{tu.free}.not_to raise_error
+		translation_unit.autorelease = false
+		# expect(Lib).to receive(:dispose_translation_unit).with(translation_unit).once
+		expect{translation_unit.free}.not_to raise_error
 	end
 
 	describe "#spelling" do
-		let (:spelling) { tu.spelling }
+		let (:spelling) { translation_unit.spelling }
 
 		it "returns own filename" do
 			expect(spelling).to be_kind_of(String)
@@ -61,7 +59,7 @@ describe TranslationUnit do
 	end
 
 	describe "#file" do
-		let (:file) { tu.file(fixture_path("a.c")) }
+		let (:file) { translation_unit.file(fixture_path("a.c")) }
 
 		it "returns File instance" do
 			expect(file).to be_kind_of(FFI::Clang::File)
@@ -69,9 +67,9 @@ describe TranslationUnit do
 	end
 
 	describe "#location" do
-		let(:file) { tu.file(fixture_path("a.c")) }
+		let(:file) { translation_unit.file(fixture_path("a.c")) }
 		let(:column) { 12 }
-		let(:location) { tu.location(file, 1, column) }
+		let(:location) { translation_unit.location(file, 1, column) }
 
 		it "returns source location at a specific point" do
 			expect(location).to be_kind_of(SourceLocation)
@@ -82,9 +80,9 @@ describe TranslationUnit do
 	end
 
 	describe "#location_offset" do
-		let(:file) { tu.file(fixture_path("a.c")) }
+		let(:file) { translation_unit.file(fixture_path("a.c")) }
 		let(:offset) { 10 }
-		let(:location) { tu.location_offset(file, offset) }
+		let(:location) { translation_unit.location_offset(file, offset) }
 
 		it "returns source location at a specific offset point" do
 			expect(location).to be_kind_of(SourceLocation)
@@ -94,9 +92,9 @@ describe TranslationUnit do
 	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) }
+		let(:cursor) { translation_unit.cursor }
+		let(:location) { translation_unit.location(translation_unit.file(fixture_path("a.c")), 1, 10) }
+		let(:cursor_with_loc) { translation_unit.cursor(location) }
 
 		it "returns translation unit cursor if no arguments are specified" do
 			expect(cursor).to be_kind_of(Cursor)
@@ -120,7 +118,7 @@ describe TranslationUnit do
 	end
 
 	describe "#default_save_options" do
-		let (:opts) { tu.default_save_options }
+		let (:opts) { translation_unit.default_save_options }
 		it "returns hash with symbols of SaveTranslationUnitFlags" do
 			expect(opts).to be_kind_of(Hash)
 			opts.keys.each { |key|
@@ -133,20 +131,20 @@ describe TranslationUnit 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{translation_unit.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{translation_unit.save(may_not_exist_filepath)}.to raise_error(FFI::Clang::Error)
 			expect(FileTest.exist?(may_not_exist_filepath)).to be false
 		end
 	end
 
 	describe "#default_reparse_options" do
-		let (:opts) { tu.default_reparse_options }
+		let (:opts) { translation_unit.default_reparse_options }
 		it "returns hash with symbols of ReparseFlags" do
 			expect(opts).to be_kind_of(Hash)
 			opts.keys.each { |key|
@@ -159,7 +157,7 @@ describe TranslationUnit do
 		let (:path) { "#{TMP_DIR}/reparse_tmp.c" }
 		before :each do
 			FileUtils.touch path
-			@reparse_tu = Index.new.parse_translation_unit(path)
+			@reparse_translation_unit = Index.new.parse_translation_unit(path)
 		end
 		after :each do
 			FileUtils.rm path, :force => true
@@ -169,28 +167,28 @@ describe TranslationUnit do
 			File::open(path, "w+") { |io|
 			   io.write("int a;")
 			}
-			expect(find_first(@reparse_tu.cursor, :cursor_variable)).to be nil
-			expect{@reparse_tu.reparse}.not_to raise_error
-			expect(find_first(@reparse_tu.cursor, :cursor_variable).spelling).to eq("a")
+			expect(find_first(@reparse_translation_unit.cursor, :cursor_variable)).to be nil
+			expect{@reparse_translation_unit.reparse}.not_to raise_error
+			expect(find_first(@reparse_translation_unit.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
+			expect{@reparse_translation_unit.reparse}.to raise_error(FFI::Clang::Error)
 		end
 	end
 
 	describe "#resource_usage" do
-		let (:ru) { tu.resource_usage }
+		let (:ru) { translation_unit.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 }
+		let (:ru) { translation_unit.resource_usage }
 		describe "#entries" do
-			let (:entries) { tu.resource_usage.entries }
+			let (:entries) { translation_unit.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)