ghazel-ffi-clang 0.2.0.2 → 0.2.1

data/lib/ffi/clang/lib/compilation_database.rb

@@ -0,0 +1,58 @@
+# 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.
+
+module FFI
+	module Clang
+		module Lib
+			typedef :pointer, :CXCompilationDatabase
+			typedef :pointer, :CXCompileCommands
+			typedef :pointer, :CXCompileCommand
+
+			CompilationDatabaseError = enum [
+				:no_error, 0,
+				:can_not_load_database, 1,
+			]
+
+			# CompilationDatabase
+			attach_function :compilation_database_from_directory, :clang_CompilationDatabase_fromDirectory, [:string, :pointer], :CXCompilationDatabase
+			attach_function :compilation_database_dispose, :clang_CompilationDatabase_dispose, [:CXCompilationDatabase], :uint
+			attach_function :compilation_database_get_compile_commands, :clang_CompilationDatabase_getCompileCommands, [:CXCompilationDatabase, :string], :CXCompileCommands
+			if FFI::Clang::Utils.satisfy_version?('3.3')
+				attach_function :compilation_database_get_all_compile_commands, :clang_CompilationDatabase_getAllCompileCommands, [:CXCompilationDatabase], :CXCompileCommands
+			end
+
+			# CompilationDatabase::CompileCommands
+			attach_function :compile_commands_dispose, :clang_CompileCommands_dispose, [:CXCompileCommands], :void
+			attach_function :compile_commands_get_size, :clang_CompileCommands_getSize, [:CXCompileCommands], :uint
+			attach_function :compile_commands_get_command, :clang_CompileCommands_getCommand, [:CXCompileCommands, :uint], :CXCompileCommand
+
+			# CompilationDatabase::CompileCommand
+			attach_function :compile_command_get_directory, :clang_CompileCommand_getDirectory, [:CXCompileCommand], CXString.by_value
+			attach_function :compile_command_get_num_args, :clang_CompileCommand_getNumArgs, [:CXCompileCommand], :uint
+			attach_function :compile_command_get_arg, :clang_CompileCommand_getArg, [:CXCompileCommand, :uint], CXString.by_value
+			if FFI::Clang::Utils.satisfy_version?('3.4')
+				# Thease functions are not exposed by libclang.so privided by packages.
+				# attach_function :compile_command_get_num_mapped_sources, :clang_CompileCommand_getNumMappedSources, [:CXCompileCommand], :uint
+				# attach_function :compile_command_get_mapped_source_path, :clang_CompileCommand_getMappedSourcePath, [:CXCompileCommand, :uint], CXString.by_value
+				# attach_function :compile_command_get_mapped_source_content, :clang_CompileCommand_getMappedSourceContent, [:CXCompileCommand, :uint], CXString.by_value
+			end
+		end
+	end
+end

data/lib/ffi/clang/lib/cursor.rb

@@ -30,7 +30,7 @@ require 'ffi/clang/utils'
 module FFI
 	module Clang
 		module Lib
-			enum :kind, [
+			enum :cursor_kind, [
 				:cursor_unexposed_decl, 1,
 				:cursor_struct, 2,
 				:cursor_union, 3,
@@ -206,7 +206,7 @@ module FFI
 
 			class CXCursor < FFI::Struct
 				layout(
-					:kind, :kind,
+					:kind, :cursor_kind,
 					:xdata, :int,
 					:data, [:pointer, 3]
 				)
@@ -277,7 +277,7 @@ module FFI
 			attach_function :get_canonical_cursor, :clang_getCanonicalCursor, [CXCursor.by_value], CXCursor.by_value
 			attach_function :get_cursor_definition, :clang_getCursorDefinition, [CXCursor.by_value], CXCursor.by_value
 			attach_function :get_specialized_cursor_template, :clang_getSpecializedCursorTemplate, [CXCursor.by_value], CXCursor.by_value
-			attach_function :get_template_cursor_kind, :clang_getTemplateCursorKind, [CXCursor.by_value], :kind
+			attach_function :get_template_cursor_kind, :clang_getTemplateCursorKind, [CXCursor.by_value], :cursor_kind
 
 			attach_function :get_translation_unit_cursor, :clang_getTranslationUnitCursor, [:CXTranslationUnit], CXCursor.by_value
 			attach_function :cursor_get_translation_unit, :clang_Cursor_getTranslationUnit, [CXCursor.by_value], :CXTranslationUnit
@@ -296,19 +296,19 @@ module FFI
 			attach_function :get_cursor_display_name, :clang_getCursorDisplayName, [CXCursor.by_value], CXString.by_value
 			attach_function :get_cursor_spelling, :clang_getCursorSpelling, [CXCursor.by_value], CXString.by_value
 			attach_function :get_cursor_usr, :clang_getCursorUSR, [CXCursor.by_value], CXString.by_value
-			attach_function :get_cursor_kind_spelling, :clang_getCursorKindSpelling, [:kind], CXString.by_value
+			attach_function :get_cursor_kind_spelling, :clang_getCursorKindSpelling, [:cursor_kind], CXString.by_value
 
 			attach_function :are_equal, :clang_equalCursors, [CXCursor.by_value, CXCursor.by_value], :uint
 
-			attach_function :is_declaration, :clang_isDeclaration, [:kind], :uint
-			attach_function :is_reference, :clang_isReference, [:kind], :uint
-			attach_function :is_expression, :clang_isExpression, [:kind], :uint
-			attach_function :is_statement, :clang_isStatement, [:kind], :uint
-			attach_function :is_attribute, :clang_isAttribute, [:kind], :uint
-			attach_function :is_invalid, :clang_isInvalid, [:kind], :uint
-			attach_function :is_translation_unit, :clang_isTranslationUnit, [:kind], :uint
-			attach_function :is_preprocessing, :clang_isPreprocessing, [:kind], :uint
-			attach_function :is_unexposed, :clang_isUnexposed, [:kind], :uint
+			attach_function :is_declaration, :clang_isDeclaration, [:cursor_kind], :uint
+			attach_function :is_reference, :clang_isReference, [:cursor_kind], :uint
+			attach_function :is_expression, :clang_isExpression, [:cursor_kind], :uint
+			attach_function :is_statement, :clang_isStatement, [:cursor_kind], :uint
+			attach_function :is_attribute, :clang_isAttribute, [:cursor_kind], :uint
+			attach_function :is_invalid, :clang_isInvalid, [:cursor_kind], :uint
+			attach_function :is_translation_unit, :clang_isTranslationUnit, [:cursor_kind], :uint
+			attach_function :is_preprocessing, :clang_isPreprocessing, [:cursor_kind], :uint
+			attach_function :is_unexposed, :clang_isUnexposed, [:cursor_kind], :uint
 
 			enum :child_visit_result, [:break, :continue, :recurse]
 
@@ -331,14 +331,8 @@ module FFI
 			attach_function :get_cursor_hash, :clang_hashCursor, [CXCursor.by_value], :uint
 
 			if FFI::Clang::Utils.satisfy_version?('3.3')
-				begin
-					attach_function :is_bit_field,:clang_Cursor_isBitField, [CXCursor.by_value], :uint
-				rescue FFI::NotFoundError => e
-				end
-				begin
-					attach_function :get_field_decl_bit_width, :clang_getFieldDeclBitWidth, [CXCursor.by_value], :int
-				rescue FFI::NotFoundError => e
-				end
+				attach_function :is_bit_field,:clang_Cursor_isBitField, [CXCursor.by_value], :uint
+				attach_function :get_field_decl_bit_width, :clang_getFieldDeclBitWidth, [CXCursor.by_value], :int
 			end
 
 			attach_function :get_overloaded_decl, :clang_getOverloadedDecl, [CXCursor.by_value, :uint], CXCursor.by_value

data/lib/ffi/clang/lib/inclusions.rb

@@ -0,0 +1,32 @@
+# Copyright, 2014, by Greg Hazel
+# 
+# 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 'ffi/clang/lib/file'
+require 'ffi/clang/lib/source_location'
+
+module FFI
+	module Clang
+		module Lib
+			# Source code inclusions:
+			callback :visit_inclusion_function, [:CXFile, :pointer, :uint, :pointer], :void
+			attach_function :get_inclusions, :clang_getInclusions, [:CXTranslationUnit, :visit_inclusion_function, :pointer], :void      
+		end
+	end
+end

data/lib/ffi/clang/lib/type.rb

@@ -138,18 +138,9 @@ module FFI
 			attach_function :get_array_element_type ,:clang_getArrayElementType, [CXType.by_value], CXType.by_value
 
 			if FFI::Clang::Utils.satisfy_version?('3.3')
-				begin
-					attach_function :type_get_align_of, :clang_Type_getAlignOf, [CXType.by_value], :long_long
-				rescue FFI::NotFoundError => e
-				end
-				begin
-					attach_function :type_get_size_of, :clang_Type_getSizeOf, [CXType.by_value], :long_long
-				rescue FFI::NotFoundError => e
-				end
-				begin
-					attach_function :type_get_offset_of, :clang_Type_getOffsetOf, [CXType.by_value, :string], :long_long
-				rescue FFI::NotFoundError => e
-				end
+				attach_function :type_get_align_of, :clang_Type_getAlignOf, [CXType.by_value], :long_long
+				attach_function :type_get_size_of, :clang_Type_getSizeOf, [CXType.by_value], :long_long
+				attach_function :type_get_offset_of, :clang_Type_getOffsetOf, [CXType.by_value, :string], :long_long
 			end
 
 			if FFI::Clang::Utils.satisfy_version?('3.4')

data/lib/ffi/clang/translation_unit.rb

@@ -21,6 +21,7 @@
 # THE SOFTWARE.
 
 require 'ffi/clang/lib/translation_unit'
+require 'ffi/clang/lib/inclusions'
 require 'ffi/clang/cursor'
 require 'ffi/clang/file'
 require 'ffi/clang/token'
@@ -109,6 +110,29 @@ module FFI
 				Tokens.new(token_ptr.get_pointer(0), uint_ptr.get_uint(0), self)
 			end
 
+			def code_complete(source_file, line, column, unsaved = [], opts = nil)
+				opts = CodeCompletion.default_code_completion_options if opts.nil?
+				unsaved_files = UnsavedFile.unsaved_pointer_from(unsaved)
+				option_bitmask = Lib.bitmask_from(Lib::CodeCompleteFlags, opts)
+				ptr = Lib.code_complete_at(self, source_file, line, column, unsaved_files, unsaved.length, option_bitmask)
+				CodeCompletion::Results.new ptr, self
+			end
+
+			def inclusions(&block)
+				adapter = Proc.new do |included_file, inclusion_stack, include_len, unused|
+					file = Lib.extract_string Lib.get_file_name(included_file)
+					cur_ptr = inclusion_stack
+					inclusions = []
+					include_len.times {
+						inclusions << SourceLocation.new(Lib::CXSourceLocation.new(cur_ptr))
+						cur_ptr += Lib::CXSourceLocation.size
+					}
+					block.call file, inclusions
+				end
+				
+				Lib.get_inclusions(self, adapter, nil)
+			end
+
 			class ResourceUsage < AutoPointer
 				def initialize(resource_usage)
 					# CXResourceUsage is returned by value and should be freed explicitly.

data/lib/ffi/clang/utils.rb

@@ -1,4 +1,5 @@
 # Copyright, 2014 by Masahiro Sano.
+# Copyright, 2014 by Samuel Williams.
 # 
 # Permission is hereby granted, free of charge, to any person obtaining a copy
 # of this software and associated documentation files (the "Software"), to deal
@@ -23,35 +24,60 @@ require 'ffi/clang/lib/string'
 
 module FFI
 	module Clang
-		class Utils
+		module Utils
+			@@clang_version = nil
+			
 			def self.clang_version_string
 				Lib.extract_string Lib.get_clang_version
 			end
 
 			def self.clang_version
-				version = clang_version_string
-				version.match(/based on LLVM (\d+\.\d+)/).values_at(1).first
+				unless @@clang_version
+					# Version string vary wildy:
+					# Ubuntu: "Ubuntu clang version 3.0-6ubuntu3 (tags/RELEASE_30/final) (based on LLVM 3.0)"
+					# Mac OS X: "Apple LLVM version 5.0 (clang-500.2.79) (based on LLVM 3.3svn)"
+					# Linux: "clang version 3.3"
+				
+					if parts = clang_version_string.match(/(?:clang version|based on LLVM) (\d+)\.(\d+)(svn)?/)
+						major = parts[1].to_i
+						minor = parts[2].to_i
+						rc = parts[3]
+					
+						# Mac OS X currently reports support for 3.3svn, but this support is broken in some ways, so we revert it back to 3.2 which it supports completely.
+						if rc == 'svn'
+							minor -= 1
+						end
+					
+						@@clang_version = [major, minor]
+						
+						puts "Clang version detected: #{@@clang_version.inspect}"
+					else
+						abort "Invalid/unsupported clang version string."
+					end
+				end
+				
+				return @@clang_version
 			end
 
 			def self.clang_version_symbol
-				version = "clang_" + clang_version.tr('.', '_')
-				version.intern
+				"clang_#{clang_version.join('_')}".to_sym
 			end
 
 			def self.clang_major_version
-				version = clang_version_string
-				version.match(/based on LLVM (\d+)\./).values_at(1).first.to_i
+				clang_version[0]
 			end
 
 			def self.clang_minor_version
-				version = clang_version_string
-				version.match(/based on LLVM \d+\.(\d+)/).values_at(1).first.to_i
+				clang_version[1]
 			end
 
+			# Returns true if the current clang version is >= min version and optionally <= max_version
 			def self.satisfy_version?(min_version, max_version = nil)
-				Gem::Version.create(self.clang_version) >= Gem::Version.create(min_version) and
-					(max_version.nil? or
-					Gem::Version.create(self.clang_version) <= Gem::Version.create(max_version))
+				min_version = Gem::Version.create(min_version)
+				max_version = Gem::Version.create(max_version) if max_version
+				current_version = Gem::Version.create(self.clang_version.join('.'))
+				
+				return (current_version >= min_version) && (!max_version || current_version <= max_version)
 			end
 		end
 	end

data/lib/ffi/clang/version.rb

@@ -21,6 +21,6 @@
 
 module FFI
 	module Clang
-		VERSION = "0.2.0.2"
+		VERSION = "0.2.1"
 	end
 end

data/spec/clang/code_completion_spec.rb

@@ -0,0 +1,179 @@
+# 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 CodeCompletion do
+	let(:filename) { fixture_path("completion.cxx") }
+	let(:tu) { Index.new.parse_translation_unit(filename) }
+	let(:line) { 7 }
+	let(:column) { 6 }
+	let(:results) { tu.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(Hash)
+			options.keys.each { |key|
+				expect(FFI::Clang::Lib::CodeCompleteFlags.symbols).to include(key)
+			}
+		end
+	end
+
+	describe CodeCompletion::Results do
+		it "can be obtained from a translation unit" do
+			expect(results).to be_kind_of(CodeCompletion::Results)
+			expect(results.size).to eq(42)
+			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(Hash)
+			results.contexts.keys.each { |key|
+				expect(FFI::Clang::Lib::CompletionContext.symbols).to include(key)
+			}
+		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!
+			# may be sorted with typed_text kind, first result will start with 'a'
+			expect(results.results.first.string.chunks.select{|x| x[:kind] == :typed_text}.first[:text]).to eq('assign')
+		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.results.first.string }
+
+
+		it "#num_chunks" do
+			expect(str.num_chunks).to eq(7)
+		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 eq('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 eq('std::vector')
+		end
+
+		it "#comment" do
+			expect(str.comment).to be_nil
+			# TODO: need tests for String which has real comment
+		end
+	end
+end