ffi-clang 0.7.0 → 0.8.0

data/spec/ffi/clang/comment_spec.rb

@@ -1,453 +0,0 @@
-# -*- coding: utf-8 -*-
-# Copyright, 2013, by Carlos Martín Nieto <cmn@dwim.me>
-# 
-# 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.
-
-describe Comment do
-	let(:cursor) { Index.new.parse_translation_unit(fixture_path("docs.cc")).cursor }
-	let (:comment) { find_first(cursor, :cursor_function).comment }
-
-	it "can be obtained from a cursor" do
-		expect(comment).to be_kind_of(Comment)
-		expect(comment).to be_kind_of(FullComment)
-		expect(comment.kind).to equal(:comment_full)
-	end
-
-	it "can parse the brief description" do
-		para = comment.child
-		expect(para.kind).to equal(:comment_paragraph)
-		expect(para).to be_kind_of(ParagraphComment)
-		text = para.child
-		expect(text.kind).to equal(:comment_text)
-		expect(text).to be_kind_of(TextComment)
-		expect(text.text.strip).to eq("Short explanation")
-	end
-
-	it "can parse the longer description" do
-		para = comment.child(1)
-		expect(para.kind).to equal(:comment_paragraph)
-		expect(para.num_children).to equal(2)
-
-		lines = (0..para.num_children-1).map do |i|
-			para.child(i).text
-		end
-
-		expect(lines).to eq([" This is a longer explanation",
-				 " that spans multiple lines"])
-	end
-
-	it "has working helpers" do
-		expect(comment.num_children).to equal(8)
-
-		para = comment.child(1)
-		expect(para.text).to eq(" This is a longer explanation\n that spans multiple lines")
-	end
-
-	it "understands params" do
-		[['input', " some input\n "], ['flags', " some flags\n "]].each_with_index do |v, child_idx|
-			param = comment.child(3 + child_idx)
-			expect(param).to be_kind_of(ParamCommandComment)
-
-			expect(param.valid_index?).to be_truthy
-			expect(param.index).to be == child_idx
-			expect(param.name).to be == v[0]
-			expect(param.child.text).to be == v[1]
-			expect(param.comment).to be == v[1]
-		end
-	end
-
-	describe "#whitespace?" do
-		it "checks the comment is whitespace" do
-			expect(comment.child.whitespace?).to be false
-		end
-	end
-
-	describe "#has_trailing_newline?" do
-		it "checks the content has a traling newline" do
-			expect(comment.child.has_trailing_newline?).to be false
-		end
-	end
-
-	context 'comment_null' do
-		let(:comment_cursor) { find_matching(cursor) { |child, parent|
-				child.kind == :cursor_function and child.spelling == 'no_comment_function' } }
-		let(:comment) { comment_cursor.comment }
-
-		it "is null comment" do
-			expect(comment).to be_kind_of(Comment)
-			expect(comment.kind).to eq(:comment_null)
-			expect(comment.text).to eq('')
-		end
-	end
-
-	context 'unknown comment type' do
-		let(:comment) { 'foobar' }
-		it "raises NotImplementedError" do
-			expect(Lib).to receive(:comment_get_kind).with(comment).and_return(:xxx_yyy_zzzz)
-			expect{Comment.build_from(comment)}.to raise_error(NotImplementedError)
-		end
-	end
-
-	describe HTMLStartTagComment do
-		let(:comment_cursor) { find_matching(cursor) { |child, parent|
-				child.kind == :cursor_function and child.spelling == 'b_function' } }
-		let(:comment) { comment_cursor.comment }
-		let(:paragraph) { comment_cursor.comment.child }
-		let(:html_start_tag_comments) { paragraph.children.select{|c| c.kind == :comment_html_start_tag} }
-
-		it "can be obtained from cursor" do
-			expect(comment).to be_kind_of(FullComment)
-			expect(comment.kind).to equal(:comment_full)
-			expect(paragraph).to be_kind_of(ParagraphComment)
-			expect(html_start_tag_comments.first).to be_kind_of(HTMLStartTagComment)
-			expect(html_start_tag_comments.size).to eq(2)
-		end
-
-		describe "#tag" do
-			it "returns HTML tag name" do
-				expect(html_start_tag_comments[0].tag).to eq('br')
-				expect(html_start_tag_comments[1].tag).to eq('a')
-			end
-
-			it "is alias method of #name" do
-				expect(html_start_tag_comments[0].name).to eq('br')
-				expect(html_start_tag_comments[1].name).to eq('a')
-			end
-		end
-
-		describe "#text" do
-			it "returns HTML tag as string" do
-				expect(html_start_tag_comments[0].text.strip).to eq('<br/>')
-				expect(html_start_tag_comments[1].text.strip).to eq('<a href="http://example.org/">')
-			end
-		end
-
-		describe "#self_closing?" do
-			it "checks the tag is self-closing" do
-				expect(html_start_tag_comments[0].self_closing?).to be true
-				expect(html_start_tag_comments[1].self_closing?).to be false
-			end
-		end
-
-		describe "#num_attrs" do
-			it "returns the number of attributes" do
-				expect(html_start_tag_comments[0].num_attrs).to eq(0)
-				expect(html_start_tag_comments[1].num_attrs).to eq(1)
-			end
-		end
-
-		describe "#attrs" do
-			it "returns attributes as Array of Hash" do
-				expect(html_start_tag_comments[0].attrs).to eq([])
-                expect(html_start_tag_comments[1].attrs).to eq([{name: 'href', value: 'http://example.org/'}])
-			end
-		end
-	end
-
-	describe HTMLEndTagComment do
-		let(:comment_cursor) { find_matching(cursor) { |child, parent|
-				child.kind == :cursor_function and child.spelling == 'b_function' } }
-		let(:comment) { comment_cursor.comment }
-		let(:paragraph) { comment_cursor.comment.child }
-		let(:html_end_tag_comment) { paragraph.children.select{|c| c.kind == :comment_html_end_tag}.first }
-
-		it "can be obtained from cursor" do
-			expect(comment).to be_kind_of(FullComment)
-			expect(comment.kind).to equal(:comment_full)
-			expect(paragraph).to be_kind_of(ParagraphComment)
-			expect(html_end_tag_comment).to be_kind_of(HTMLEndTagComment)
-		end
-
-		describe "#tag" do
-			it "returns HTML tag name" do
-				expect(html_end_tag_comment.tag).to eq('a')
-			end
-
-			it "is alias method of #name" do
-				expect(html_end_tag_comment.name).to eq('a')
-			end
-		end
-
-		describe "#text" do
-			it "returns HTML tag as string" do
-				expect(html_end_tag_comment.text.strip).to eq('</a>')
-			end
-		end
-	end
-
-	describe FullComment do
-		let(:comment_cursor) { find_matching(cursor) { |child, parent|
-				child.kind == :cursor_function and child.spelling == 'f_function' } }
-		let(:comment) { comment_cursor.comment }
-
-		it "can be obtained from cursor" do
-			expect(comment).to be_kind_of(FullComment)
-			expect(comment.kind).to equal(:comment_full)
-		end
-
-		describe "#to_html" do
-			it "converts a given full parsed comment to an HTML fragment" do
-				expect(comment.to_html).to be_kind_of(String)
-				expect(comment.to_html).to eq('<p class="para-brief"> this is a function.</p>')
-			end
-		end
-
-		describe "#to_xml" do
-			it "converts a given full parsed comment to an XML document" do
-				expect(comment.to_xml).to be_kind_of(String)
-			end
-		end
-	end
-
-	describe BlockCommandComment do
-		let(:comment_cursor) { find_matching(cursor) { |child, parent|
-				child.kind == :cursor_function and child.spelling == 'f_function' } }
-		let(:comment) { comment_cursor.comment }
-		let(:block_cmd_comment) { comment.children.select{|c| c.kind == :comment_block_command}.first }
-
-		it "can be obtained from cursor" do
-			expect(comment).to be_kind_of(FullComment)
-			expect(comment.kind).to equal(:comment_full)
-			expect(block_cmd_comment).to be_kind_of(BlockCommandComment)
-			expect(block_cmd_comment.child).to be_kind_of(ParagraphComment)
-		end
-
-		describe "#name" do
-			it "returns the name of the block command" do
-				expect(block_cmd_comment.name).to eq("brief")
-			end
-		end
-
-		describe "#paragraph" do
-			it "returns the paragraph" do
-				expect(block_cmd_comment.paragraph).to be_kind_of(ParagraphComment)
-			end
-		end
-
-		describe "#num_args" do
-			it "returns the number of word-like arguments" do
-				expect(block_cmd_comment.num_args).to eq(0)
-			end
-		end
-
-		describe "#args" do
-			it "returns word-like arguments" do
-				expect(block_cmd_comment.args).to be_kind_of(Array)
-				expect(block_cmd_comment.args).to eq([])
-			end
-
-			#TODO: needs tests with comments which have arguments
-		end
-
-		describe "#text" do
-			it "returns readble text that includes children's comments" do
-				expect(block_cmd_comment.text).to be_kind_of(String)
-				expect(block_cmd_comment.text.strip).to eq('this is a function.')
-			end
-
-			it "is a alias method of #comment" do
-				expect(block_cmd_comment.comment).to eq(block_cmd_comment.text)
-			end
-		end
-	end
-
-	describe InlineCommandComment do
-		let(:comment_cursor) { find_matching(cursor) { |child, parent|
-				child.kind == :cursor_function and child.spelling == 'd_function' } }
-		let(:comment) { comment_cursor.comment }
-		let(:inline_command_comments) { comment.child.children.select{|c| c.kind == :comment_inline_command} }
-
-		it "can be obtained from cursor" do
-			expect(comment).to be_kind_of(FullComment)
-			expect(comment.kind).to equal(:comment_full)
-			expect(comment.child).to be_kind_of(ParagraphComment)
-			expect(inline_command_comments.size).to eq(2)
-		end
-
-		describe "#name" do
-			it "returns the name of the inline command" do
-				expect(inline_command_comments[0].name).to eq("em")
-				expect(inline_command_comments[1].name).to eq("b")
-			end
-		end
-
-		describe "#render_kind" do
-			it "returns the most appropriate rendering mode" do
-				expect(inline_command_comments[0].render_kind).to eq(:emphasized)
-				expect(inline_command_comments[1].render_kind).to eq(:bold)
-			end
-		end
-
-		describe "#num_args" do
-			it "returns number of command arguments" do
-				expect(inline_command_comments[0].num_args).to eq(1)
-				expect(inline_command_comments[1].num_args).to eq(1)
-			end
-		end
-
-		describe "#args" do
-			it "returns arguments as Array" do
-				expect(inline_command_comments[0].args).to eq(["foo"])
-				expect(inline_command_comments[1].args).to eq(["bar"])
-			end
-		end
-
-		describe "#text" do
-			it "returns readble text" do
-				expect(inline_command_comments[0].text.strip).to eq("foo")
-				expect(inline_command_comments[1].text.strip).to eq("bar")
-			end
-		end
-	end
-
-	describe VerbatimBlockCommandComment do
-		let(:comment_cursor) { find_matching(cursor) { |child, parent|
-				child.kind == :cursor_function and child.spelling == 'e_function' } }
-		let(:comment) { comment_cursor.comment }
-		let(:verb_block_cmd_comment) { comment.children.select{|c| c.kind == :comment_verbatim_block_command}.first }
-
-		it "can be obtained from cursor" do
-			expect(comment).to be_kind_of(FullComment)
-			expect(comment.kind).to equal(:comment_full)
-			expect(verb_block_cmd_comment).to be_kind_of(VerbatimBlockCommandComment)
-		end
-
-		describe "#text" do
-			it "returns readble text" do
-				expect(verb_block_cmd_comment.text).to eq("  foo bar\n  baz")
-			end
-		end
-	end
-
-	describe VerbatimBlockLineComment do
-		let(:comment_cursor) { find_matching(cursor) { |child, parent|
-				child.kind == :cursor_function and child.spelling == 'e_function' } }
-		let(:comment) { comment_cursor.comment }
-		let(:verb_block_cmd_comment) { comment.children.select{|c| c.kind == :comment_verbatim_block_command}.first }
-		let(:verb_block_line_comments) { verb_block_cmd_comment.children }
-
-		it "can be obtained from cursor" do
-			expect(comment).to be_kind_of(FullComment)
-			expect(comment.kind).to equal(:comment_full)
-			expect(verb_block_cmd_comment).to be_kind_of(VerbatimBlockCommandComment)
-			expect(verb_block_line_comments.first).to be_kind_of(VerbatimBlockLineComment)
-			expect(verb_block_line_comments.size).to eq(2)
-		end
-
-		describe "#text" do
-			it "returns readble text" do
-				expect(verb_block_line_comments[0].text.strip).to eq("foo bar")
-				expect(verb_block_line_comments[1].text.strip).to eq("baz")
-			end
-		end
-	end
-
-	describe VerbatimLine do
-	# TODO: how to generate this comment?
-	end
-
-	describe ParamCommandComment do
-		let(:comment_cursor) { find_matching(cursor) { |child, parent|
-				child.kind == :cursor_function and child.spelling == 'a_function' } }
-		let(:comment) { comment_cursor.comment }
-		let(:param_cmd_comments) { comment.children.select{|c| c.kind == :comment_param_command} }
-
-		it "can be obtained from cursor" do
-			expect(comment).to be_kind_of(FullComment)
-			expect(comment.kind).to equal(:comment_full)
-			expect(param_cmd_comments.first).to be_kind_of(ParamCommandComment)
-			expect(param_cmd_comments.size).to eq(4)
-		end
-
-		describe "#text" do
-			it "returns readble text" do
-				expect(param_cmd_comments[0].text.strip).to eq("some input")
-				expect(param_cmd_comments[1].text.strip).to eq("some flags")
-			end
-		end
-
-		describe "#direction_explicit?" do
-			it "checks the direction is specified explicitly" do
-				expect(param_cmd_comments[0].direction_explicit?).to be true
-				expect(param_cmd_comments[3].direction_explicit?).to be false
-			end
-		end
-
-		describe "#direction" do
-			it "returns parameter passing direction" do
-				expect(param_cmd_comments[0].direction).to eq(:pass_direction_in)
-				expect(param_cmd_comments[1].direction).to eq(:pass_direction_out)
-				expect(param_cmd_comments[2].direction).to eq(:pass_direction_inout)
-				expect(param_cmd_comments[3].direction).to eq(:pass_direction_in)
-			end
-		end
-	end
-
-	describe TParamCommandComment do
-		let(:comment_cursor) { find_matching(cursor) { |child, parent|
-				child.kind == :cursor_function_template and child.spelling == 'c_function' } }
-		let(:comment) { comment_cursor.comment }
-		let(:tparam_cmd_comments) { comment.children.select{|c| c.kind == :comment_tparam_command} }
-
-		it "can be obtained from cursor" do
-			expect(comment).to be_kind_of(FullComment)
-			expect(comment.kind).to equal(:comment_full)
-			expect(tparam_cmd_comments.first).to be_kind_of(TParamCommandComment)
-			expect(tparam_cmd_comments.size).to eq(3)
-		end
-
-		describe "#text" do
-			it "returns readble text" do
-				expect(tparam_cmd_comments[0].text.strip).to eq("some type of foo")
-				expect(tparam_cmd_comments[1].text.strip).to eq("some type of bar")
-			end
-		end
-
-		describe "#name" do
-			it "returns template parameter name" do
-				expect(tparam_cmd_comments[0].name).to eq("T1")
-				expect(tparam_cmd_comments[1].name).to eq("T2")
-				expect(tparam_cmd_comments[2].name).to eq("T3")
-			end
-		end
-
-		describe "#valid_position?" do
-			it "checks this parameter has valid position" do
-				expect(tparam_cmd_comments[0].valid_position?).to be true
-			end
-		end
-
-		describe "#depth" do
-			it "returns nesting depth of this parameter" do
-				expect(tparam_cmd_comments[0].depth).to eq(1)
-				expect(tparam_cmd_comments[1].depth).to eq(2)
-				expect(tparam_cmd_comments[2].depth).to eq(1)
-			end
-		end
-
-		describe "#index" do
-			it "returns index of the parameter at the given nesting depth" do
-				expect(tparam_cmd_comments[0].index(0)).to eq(0)
-				expect(tparam_cmd_comments[1].index(0)).to eq(1)
-				expect(tparam_cmd_comments[1].index(1)).to eq(0)
-				expect(tparam_cmd_comments[2].index(0)).to eq(1)
-			end
-		end
-	end
-end

data/spec/ffi/clang/compilation_database_spec.rb

@@ -1,180 +0,0 @@
-# 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.
-
-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)
-			if FFI::Clang.clang_version_string[/\d+/].to_i >= 10
-				expect(cdb.compile_commands(not_found_file).size).to eq(1)
-			else
-				expect(cdb.compile_commands(not_found_file).size).to eq(0)
-			end
-		end
-	end
-
-	describe '#all_compile_commands' 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" 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 be >= 31 # clang may insert additional args
-			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' 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' 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' 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' 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