ffi-clang/spec/ffi/clang/code_completion_spec.rb

# frozen_string_literal: true

# Released under the MIT License.
# Copyright, 2014, by Masahiro Sano.
# Copyright, 2014-2025, by Samuel Williams.
# Copyright, 2023, by Charlie Savage.

describe CodeCompletion do
	let(:filename) {fixture_path("completion.cxx")}
	let(:translation_unit) {Index.new.parse_translation_unit(filename)}
	let(:line) {7}
	let(:column) {6}
	let(:results) {translation_unit.code_complete(filename, line, column)}
	
	describe "self.default_code_completion_options" do
		let(:options) {FFI::Clang::CodeCompletion.default_code_completion_options}
		it "returns a default set of code-completion options" do
			expect(options).to be_kind_of(Array)
			options.each {|symbol|
				expect(FFI::Clang::Lib::CodeCompleteFlags.symbols).to include(symbol)
			}
		end
	end
	
	describe CodeCompletion::Results do
		it "can be obtained from a translation unit" do
			expect(results).to be_kind_of(CodeCompletion::Results)
			
			# At least 40 results, depends on standard library implementation:
			expect(results.size).to be >= 40
			
			expect(results.results).to be_kind_of(Array)
			expect(results.results.first).to be_kind_of(CodeCompletion::Result)
		end
		
		it "calls dispose_code_complete_results on GC" do
			expect(Lib).to receive(:dispose_code_complete_results).at_least(:once)
			expect{results.free}.not_to raise_error
		end
		
		it "#each" do
			spy = double(stub: nil)
			expect(spy).to receive(:stub).exactly(results.size).times
			results.each {spy.stub}
		end
		
		it "#num_diagnostics" do
			expect(results.num_diagnostics).to eq(2)
		end
		
		it "#diagnostic" do
			expect(results.diagnostic(0)).to be_kind_of(Diagnostic)
		end
		
		it "#diagnostics" do
			expect(results.diagnostics).to be_kind_of(Array)
			expect(results.diagnostics.first).to be_kind_of(Diagnostic)
			expect(results.diagnostics.size).to eq(results.num_diagnostics)
		end
		
		it "#contexts" do
			expect(results.contexts).to be_kind_of(Array)
			results.contexts.each {|symbol|
				expect(FFI::Clang::Lib::CompletionContext.symbols).to include(symbol)
			}
		end
		
		it "#container_usr" do
			expect(results.container_usr).to be_kind_of(String)
			expect(results.container_usr).to match(/std.+vector/)
		end
		
		it "#container_kind" do
			expect(results.container_kind).to be_kind_of(Symbol)
			expect(results.container_kind).to eq(:cursor_class_decl)
		end
		
		it "#incomplete?" do
			expect(results.incomplete?).to be false
		end
		
		it "#objc_selector" do
			#TODO
		end
		
		it "#sort!" do
			results.sort!
			
			possibilities = results.first.string.chunks.select{|x| x[:kind] == :typed_text}.collect{|chunk| chunk[:text]}
			
			# may be sorted with typed_text kind, first result will start with 'a'.. not necessarily
			expect(possibilities).to be == possibilities.sort
		end
	end
	
	describe CodeCompletion::Result do
		let(:result) {results.results.first}
		it "#string" do
			expect(result.string).to be_kind_of(CodeCompletion::String)
		end
		
		it "#kind" do
			expect(result.kind).to be_kind_of(Symbol)
		end
	end
	
	describe CodeCompletion::String do
		let(:str) {results.sort!; results.find{|x| x.string.chunk_text(1) == "assign"}.string}
		
		it "#num_chunks" do
			expect(str.num_chunks).to be >= 5
		end
		
		it "#chunk_kind" do
			expect(str.chunk_kind(0)).to eq(:result_type)
			expect(str.chunk_kind(1)).to eq(:typed_text)
		end
		
		it "#chunk_text" do
			expect(str.chunk_text(0)).to be =~ /void/
			expect(str.chunk_text(1)).to eq("assign")
		end
		
		it "#chunk_completion" do
			expect(str.chunk_completion(0)).to be_kind_of(CodeCompletion::String)
		end
		
		it "#chunks" do
			expect(str.chunks).to be_kind_of(Array)
			expect(str.chunks.first).to be_kind_of(Hash)
			expect(str.chunks.size).to eq(str.num_chunks)
		end
		
		it "#priority" do
			expect(str.priority).to be_kind_of(Integer)
		end
		
		it "#availability" do
			expect(str.availability).to be_kind_of(Symbol)
			expect(str.availability).to eq(:available)
		end
		
		it "#num_annotations" do
			expect(str.num_annotations).to be_kind_of(Integer)
			expect(str.num_annotations).to eq(0)
		end
		
		it "#annotation" do
			expect(str.annotation(100)).to be_nil
			# TODO: need tests for String which has annotation
		end
		
		it "#annotations" do
			expect(str.annotations).to be_kind_of(Array)
			# TODO: need tests for String which has annotation
		end
		
		it "#parent" do
			expect(str.parent).to be_kind_of(String)
			expect(str.parent).to be =~ /std.+vector/
		end
		
		it "#comment" do
			expect(str.comment).to be_nil
			# TODO: need tests for String which has real comment
		end
	end
end