diggit 2.1.0 → 2.1.1

data/plugins/addon/src_opt.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 # encoding: utf-8
 #
 # This file is part of Diggit.
@@ -20,7 +21,7 @@
 
 # Manages options that are specific to a given source
 class SrcOpt < Diggit::Addon
-	SOURCES_OPTIONS_FILE = 'sources_options'
+	SOURCES_OPTIONS_FILE = 'sources_options'.freeze
 
 	def initialize(*args)
 		super

data/plugins/analysis/conflict_merge.rb

@@ -0,0 +1,118 @@
+# encoding: utf-8
+#
+# This file is part of Diggit.
+#
+# Diggit is free software: you can redistribute it and/or modify
+# it under the terms of the GNU Lesser General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# Diggit is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public License
+# along with Diggit.  If not, see <http://www.gnu.org/licenses/>.
+#
+# Copyright 2016 Jean-Rémy Falleri <jr.falleri@gmail.com>
+# Copyright 2016 Floréal Morandat
+# Copyright 2016 Benjamin Benni
+
+require 'yaml'
+
+class ConflictMerge < Diggit::Analysis
+	require_addons 'out'
+
+	DIFF3 = 'diff3'.freeze
+
+	def initialize(options)
+		super(options)
+	end
+
+	def run
+		walker = Rugged::Walker.new(repo)
+		walker.sorting(Rugged::SORT_TOPO | Rugged::SORT_REVERSE)
+		walker.push(repo.head.name)
+		walker.each do |commit|
+			out_dir = out.out_path(source.id, commit.oid)
+			parents = commit.parents
+			next unless parents.size > 1
+			left = parents[0]
+			right = parents[1]
+			next if repo.merge_base(left, right).nil?
+			base = repo.lookup(repo.merge_base(left, right))
+			%w(m b l r).each { |p| FileUtils.mkdir_p(File.join(out_dir, p)) }
+			populate_merge_directory(out_dir, commit, base, left, right)
+		end
+	end
+
+	def populate_merge_directory(out_dir, commit, base, left, right)
+		commit.tree.walk(:preorder) do |r, e|
+			next if e[:type] == :tree
+			next if base.tree.get_entry_by_oid(e[:oid])
+			oids = find_oids(r, e[:name], base, left, right)
+			next if oids[:left].nil? || oids[:right].nil? # This would result in a trivial merge
+
+			fname = flatten_name(r + e[:name])
+			write(e[:oid], fname, out_dir, 'm')
+			if oids[:base].nil?
+				write_file("", fname, out_dir, 'b') # Create a fake file in base
+			else
+				write(oids[:base], fname, out_dir, 'b')
+			end
+			write(oids[:left], fname, out_dir, 'l')
+			write(oids[:right], fname, out_dir, 'r')
+
+			write_commit_log(out_dir, commit, base, left, right)
+
+			diff_file = File.join(out_dir, "#{fname}.diff3")
+			File.unlink diff_file unless system(
+					DIFF3,
+					"-m",
+					File.join(out_dir, 'l', fname),
+					File.join(out_dir, 'b', fname),
+					File.join(out_dir, 'r', fname),
+					out: diff_file
+			) == false
+		end
+	end
+
+	def find_oids(root, name, base, left, right)
+		components = root == "" ? [] : root.split(File::SEPARATOR)
+		{
+		  base: find_oid(base.tree, components, name),
+		  left: find_oid(left.tree, components, name),
+		  right: find_oid(right.tree, components, name)
+		}
+	end
+
+	def find_oid(tree, components, name)
+		components.each { |c| tree = repo.lookup(tree[c][:oid]) }
+		tree[name][:oid]
+	rescue
+		nil
+	end
+
+	def write(oid, name, *kind)
+		write_file repo.lookup(oid).content, name, *kind
+	end
+
+	def write_file(data, name, *kind)
+		File.write(File.join(kind, name), data)
+	end
+
+	def write_commit_log(out_dir, *commits)
+		File.open(File.join(out_dir, "commits.txt"), "w") do |file|
+			commits.each { |c| file.write("#{c.oid}\n") }
+		end
+	end
+
+	def flatten_name(name)
+		name.gsub(/_/, '__').gsub(%r{/}, '_')
+	end
+
+	def clean
+		out.clean
+	end
+end

data/plugins/analysis/javadoc.rb

@@ -17,27 +17,169 @@
 #
 # Copyright 2015 Jean-Rémy Falleri <jr.falleri@gmail.com>
 
-require 'jsonpath'
+require 'nokogiri'
+require 'oj'
 
 class Javadoc < Diggit::Analysis
+	require_addons 'out'
+
+	VALID_TYPES = %w(
+			root CompilationUnit TypeDeclaration FieldDeclaration MethodDeclaration SimpleName QualifiedName
+			QualifiedName SimpleType PrimitiveType ArrayType SingleVariableDeclaration VariableDeclarationFragment
+			Modifier Javadoc TagElement TextElement MarkerAnnotation MethodRef
+	).freeze
+
 	def initialize(options)
 		super(options)
 	end
 
 	def run
-		path_md = JsonPath.new("$..*[?(@.typeLabel == 'MethodDeclaration')]")
-		files = Dir['**/*.java']
-		files.each do |file|
-			puts file
-			json = `gumtree parse "#{file}"`
-			md = path_md.on(json)
-			md.each do |m|
-				puts m
-				exit
+		files = Dir["#{@source.folder}/src/main/java/**/*.java"]
+		puts "#{files.length} files to process"
+		db = {}
+
+		files.each do |f|
+			puts "processing #{f}"
+			xml = `gumtree parse -f XML "#{f}"`
+			doc = strip(Nokogiri::XML(xml))
+			db[f] = index_methods(doc)
+		end
+
+		Oj.to_file("#{out.out}/#{@source.id}.json", db)
+	end
+
+	def index_methods(doc)
+		res = {}
+
+		override_count = 0
+		override_inherit_count = 0
+
+		# Partie Metrics
+
+		data = {}
+		data["nb_class"] = count_classes(doc)
+		data["nb_method"] = count_methods(doc)
+		data["nb_class_commented"] = count_commented_classes(doc)
+		data["nb_method_commented"] = count_commented_methods(doc)
+
+		res["metrics"] = data
+
+		# Partie methodes
+		res["methods"] = []
+
+		doc.xpath("//MethodDeclaration").each do |m|
+			id = method_id(m)
+			javadoc = {}
+			javadoc['main'] = m.xpath("Javadoc/TagElement[not(@label)]/TextElement/@label").to_s
+			javadoc['params'] = {}
+
+			javadoc['override'] = false
+			javadoc['inheritDoc'] = false
+
+			m.xpath("MarkerAnnotation/SimpleName/@label").each do |k|
+				next unless k.to_s.casecmp("override")
+				javadoc['override'] = true
+				override_count += 1
+
+				if m.xpath("Javadoc/TagElement/TagElement[@label='@inheritDoc']").count > 0
+					javadoc['inheritDoc'] = true
+					override_inherit_count += 1
+				end
 			end
+
+			javadoc["params"] = get_params(m)
+			javadoc["see"] = get_see(m)
+			javadoc["throws"] = get_throws(m)
+			javadoc["links"] = get_links(m)
+			javadoc['return'] = m.xpath("Javadoc/TagElement[@label='@return']/TextElement/@label").to_s
+
+			res["methods"] << [id, javadoc]
+			res["metrics"]["nb_method_override"] = override_count
+			res["metrics"]["nb_method_override_inheritdoc"] = override_inherit_count
 		end
+
+		res
+	end
+
+	def method_id(m)
+		res = ""
+		modifiers = m.xpath("Modifier/@label")
+		res += "#{modifiers} " unless modifiers.empty?
+		res += "#{type(m)} #{m.at_xpath('SimpleName/@label')}("
+		params = m.xpath("SingleVariableDeclaration").map { |p| "#{type(p)} #{p.at_xpath('SimpleName/@label')}" }.join(',')
+		res += "#{params})"
+		res
+	end
+
+	def type(e)
+		return e.at_xpath('SimpleType/@label').to_s unless e.at_xpath('SimpleType').nil?
+		return e.at_xpath('PrimitiveType/@label').to_s unless e.at_xpath('PrimitiveType').nil?
+		return e.at_xpath('ArrayType/@label').to_s unless e.at_xpath('ArrayType').nil?
+		""
+	end
+
+	def strip(doc)
+		active = []
+		doc.children.each do |c|
+			if VALID_TYPES.include?(c.name)
+				active << c
+			else
+				c.unlink
+			end
+		end
+		active.each { |a| strip(a) }
+		doc
+	end
+
+	def get_params(m)
+		data = {}
+		m.xpath("Javadoc/TagElement[@label='@param']").each do |p|
+			if data[p.at_xpath("SimpleName/@label").to_s].nil?
+				data[p.at_xpath("SimpleName/@label").to_s] = []
+			end
+
+			data[p.at_xpath("SimpleName/@label").to_s].push(p.xpath("TextElement/@label").to_s)
+		end
+		data
+	end
+
+	def get_links(m)
+		m.xpath("Javadoc/TagElement/TagElement[@label='@link']").map { |p| p.xpath('QualifiedName/@label').to_s }
+	end
+
+	def get_throws(m)
+		throws = {}
+		m.xpath("Javadoc/TagElement[@label='@throws']").each do |p|
+			throws[p.at_xpath("SimpleName/@label").to_s] = p.xpath("TextElement/@label").to_s
+		end
+		throws
+	end
+
+	def get_see(m)
+		m.xpath("Javadoc/TagElement[@label='@see']/MethodRef").map { |p| p.xpath('SimpleName/@label').to_s }
+	end
+
+	def count_classes(doc)
+		doc.xpath("//TypeDeclaration").count
+	end
+
+	def count_methods(doc)
+		doc.xpath("//MethodDeclaration").count
+	end
+
+	def count_commented_classes(doc)
+		doc.xpath("//TypeDeclaration/Javadoc").count
+	end
+
+	def count_commented_methods(doc)
+		doc.xpath("//MethodDeclaration/Javadoc").count
+	end
+
+	def class_comment(doc)
+		doc.xpath("//MethodDeclaration/Javadoc").to_s
 	end
 
 	def clean
+		out.clean
 	end
 end

data/plugins/analysis/tex.rb

@@ -38,7 +38,7 @@ class Tex < Diggit::Analysis
 	end
 
 	def clean
-		FileUtils.rm_rf(file)
+		out.clean
 	end
 
 	def file

data/spec/cli_spec.rb

@@ -0,0 +1,114 @@
+# encoding: utf-8
+#
+# This file is part of Diggit.
+#
+# Diggit is free software: you can redistribute it and/or modify
+# it under the terms of the GNU Lesser General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# Diggit is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public License
+# along with Diggit.  If not, see <http://www.gnu.org/licenses/>.
+#
+# Copyright 2015 Jean-Rémy Falleri <jr.falleri@gmail.com>
+
+require 'spec_helper'
+require 'fileutils'
+
+RSpec.describe Diggit do
+	it "should init a dgit folder" do
+		out = `bin/dgit -f spec/dgit init`
+		expect(out).to match(/Diggit folder initialized/)
+	end
+
+	it "should display status" do
+		out = `bin/dgit -f spec/dgit status`
+		expect(out).to match(/Config/)
+	end
+
+	it "should add a source" do
+		`bin/dgit -f spec/dgit sources add "#{TEST_URL}"`
+		out = `bin/dgit -f spec/dgit sources list`
+		expect(out).to match(/#{TEST_URL_INFO1}/)
+		expect(out).to match(/new/)
+	end
+
+	it "should del a source" do
+		`bin/dgit -f spec/dgit sources add http://foo`
+		out = `bin/dgit -f spec/dgit sources list`
+		expect(out).to match(/foo/)
+		out = `bin/dgit -f spec/dgit sources del 1`
+		expect(out).to_not match(/foo/)
+	end
+
+	it "should perform clones" do
+		`bin/dgit -f spec/dgit clones perform`
+		out = `bin/dgit -f spec/dgit sources list`
+		expect(out).to match(/cloned/)
+	end
+
+	it "should add an analysis" do
+		`bin/dgit -f spec/dgit analyses add test_analysis`
+		out = `bin/dgit -f spec/dgit status`
+		expect(out).to match(/test_analysis/)
+	end
+
+	it "should perform the analyses" do
+		`bin/dgit -f spec/dgit analyses perform`
+		out = `bin/dgit -f spec/dgit sources info 0`
+		expect(out).to match(/test_analysis/)
+		expect(out).to match(/Performed/)
+		expect(out).to_not match(/Canceled/)
+	end
+
+	it "should handle analyses with errors" do
+		`bin/dgit -f spec/dgit analyses add test_analysis_with_error`
+		`bin/dgit -f spec/dgit analyses perform`
+		out = `bin/dgit -f spec/dgit sources info 0`
+		expect(out).to match(/test_analysis_with_error/)
+		expect(out).to match(/Canceled/)
+		expect(out).to match(/Error!/)
+	end
+
+	it "should add joins" do
+		`bin/dgit -f spec/dgit joins add test_join`
+		out = `bin/dgit -f spec/dgit status`
+		expect(out).to match(/test_join/)
+		expect(out).to_not match(/Performed joins/)
+	end
+
+	it "should perform joins" do
+		`bin/dgit -f spec/dgit joins perform`
+		out = `bin/dgit -f spec/dgit status`
+		expect(out).to match(/test_join/)
+		expect(out).to match(/Performed joins/)
+	end
+
+	it "should handle joins with errors" do
+		`bin/dgit -f spec/dgit joins add test_join_with_error`
+		`bin/dgit -f spec/dgit joins perform`
+		out = `bin/dgit -f spec/dgit status`
+		expect(out).to match(/test_join_with_error/)
+		expect(out).to match(/Canceled/)
+		expect(out).to match(/Error!/)
+	end
+
+	it "should clean joins" do
+		`bin/dgit -f spec/dgit joins perform -m clean`
+		out = `bin/dgit -f spec/dgit status`
+		expect(out).to_not match(/Canceled/)
+		expect(out).to_not match(/Performed/)
+	end
+
+	it "should clean anlyses" do
+		`bin/dgit -f spec/dgit analyses perform -m clean`
+		out = `bin/dgit -f spec/dgit sources info 0`
+		expect(out).to_not match(/Canceled/)
+		expect(out).to_not match(/Performed/)
+	end
+end

data/spec/core_spec.rb

@@ -9,19 +9,30 @@
 #
 # Diggit is distributed in the hope that it will be useful,
 # but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.	See the
 # GNU Lesser General Public License for more details.
 #
 # You should have received a copy of the GNU Lesser General Public License
-# along with Diggit.  If not, see <http://www.gnu.org/licenses/>.
+# along with Diggit.	If not, see <http://www.gnu.org/licenses/>.
 #
 # Copyright 2015 Jean-Rémy Falleri <jr.falleri@gmail.com>
 
 require 'spec_helper'
 require 'fileutils'
 
-FileUtils.rm_rf('spec/dgit/.dgit')
-FileUtils.rm_rf('spec/dgit/sources')
+RSpec.configure do |config|
+	original_stderr = $stderr
+	original_stdout = $stdout
+	config.before(:all) do
+		# Redirect stderr and stdout
+		$stderr = File.open(File::NULL, "w")
+		$stdout = File.open(File::NULL, "w")
+	end
+	config.after(:all) do
+		$stderr = original_stderr
+		$stdout = original_stdout
+	end
+end
 
 RSpec.describe Diggit::Dig do
 	it "should refuse to be launched outside a dgit folder" do
@@ -69,6 +80,9 @@ RSpec.describe Diggit::Dig do
 	it "should load a join" do
 		join = Diggit::Dig.it.plugin_loader.load_plugin("test_join", :join)
 		expect(join.to_s).to eq('TestJoin')
+	end
+
+	it "should load a join with addons" do
 		join = Diggit::Dig.it.plugin_loader.load_plugin("test_join_with_addon", :join)
 		expect(join.to_s).to eq('TestJoinWithAddon')
 		join_instance = join.new({})
@@ -93,18 +107,34 @@ RSpec.describe Diggit::Dig do
 	it "should store sources" do
 		Diggit::Dig.it.journal.add_source(TEST_URL)
 		Diggit::Dig.init("spec/dgit")
-		expect(Diggit::Dig.it.journal.sources_by_ids(0)[0].url).to eq TEST_URL
+		expect(Diggit::Dig.it.journal.sources_by_ids.first.url).to eq TEST_URL_INFO1
+		expect(Diggit::Dig.it.journal.sources_by_ids.first.oid).to eq TEST_URL_INFO2
+	end
+
+	it "should delete sources" do
+		Diggit::Dig.it.journal.add_source('http://foo')
+		Diggit::Dig.init("spec/dgit")
+		expect(Diggit::Dig.it.journal.sources_by_ids.size).to eq 2
+		Diggit::Dig.it.journal.del_source(1)
+		Diggit::Dig.init("spec/dgit")
+		expect(Diggit::Dig.it.journal.sources_by_ids.size).to eq 1
 	end
 
 	it "should clone sources" do
 		Diggit::Dig.it.clone
-		expect(File.exist?("spec/dgit/sources/#{TEST_URL.id}/.git")).to be true
-		expect(Diggit::Dig.it.journal.sources_by_ids(0)[0].url).to eq TEST_URL
-		Diggit::Dig.it.journal.sources_by_ids(0)[0].entry.state = :new
+		expect(File.exist?("spec/dgit/sources/#{TEST_URL_INFO1.id}/.git")).to be true
+		expect(File.exist?("spec/dgit/sources/#{TEST_URL_INFO1.id}/test/src/foo/Bar.java")).to be false
+		src = Diggit::Dig.it.journal.sources_by_ids.first
+		expect(src.url).to eq TEST_URL_INFO1
+		expect(src.oid).to eq TEST_URL_INFO2
+		src.entry.state = :new
 		Diggit::Dig.it.clone
-		expect(Diggit::Dig.it.journal.sources_by_ids(0)[0].url).to eq TEST_URL
+		expect(src.url).to eq TEST_URL_INFO1
+		expect(src.oid).to eq TEST_URL_INFO2
 		Diggit::Dig.init("spec/dgit")
-		expect(Diggit::Dig.it.journal.sources_by_ids(0)[0].url).to eq TEST_URL
+		src = Diggit::Dig.it.journal.sources_by_ids.first
+		expect(src.url).to eq TEST_URL_INFO1
+		expect(src.oid).to eq TEST_URL_INFO2
 	end
 
 	it "should perform analyses in order" do
@@ -113,11 +143,11 @@ RSpec.describe Diggit::Dig do
 		Diggit::Dig.it.config.add_analysis("test_analysis_with_addon")
 		expect_any_instance_of(TestAnalysisWithAddon).to receive(:run)
 		Diggit::Dig.it.analyze
-		src = Diggit::Dig.it.journal.sources_by_ids(0)[0]
+		src = Diggit::Dig.it.journal.sources_by_ids.first
 		expect(src.entry.has?("test_analysis", :performed)).to be true
 		expect(src.entry.has?("test_analysis_with_addon", :performed)).to be true
 		Diggit::Dig.init("spec/dgit")
-		src = Diggit::Dig.it.journal.sources_by_ids(0)[0]
+		src = Diggit::Dig.it.journal.sources_by_ids.first
 		expect(src.entry.has?("test_analysis", :performed)).to be true
 		expect(src.entry.has?("test_analysis_with_addon", :performed)).to be true
 	end
@@ -125,11 +155,11 @@ RSpec.describe Diggit::Dig do
 	it "should handle analyses with error" do
 		Diggit::Dig.it.config.add_analysis("test_analysis_with_error")
 		Diggit::Dig.it.analyze
-		src = Diggit::Dig.it.journal.sources_by_ids(0)[0]
+		src = Diggit::Dig.it.journal.sources_by_ids.first
 		expect(src.entry.has?("test_analysis_with_error", :performed)).to be false
 		expect(src.entry.has?("test_analysis_with_error", :canceled)).to be true
 		expect(src.entry.error?).to be true
-		expect(src.entry.canceled[0].error.message).to eq("Error!")
+		expect(src.entry.canceled.first.error.message).to eq("Error!")
 	end
 
 	it "should perform joins" do
@@ -148,7 +178,7 @@ RSpec.describe Diggit::Dig do
 		expect(Diggit::Dig.it.journal.workspace.has?("test_join_with_error", :performed)).to be false
 		expect(Diggit::Dig.it.journal.workspace.has?("test_join_with_error", :canceled)).to be true
 		expect(Diggit::Dig.it.journal.workspace.error?).to be true
-		expect(Diggit::Dig.it.journal.workspace.canceled[0].error.message).to eq("Error!")
+		expect(Diggit::Dig.it.journal.workspace.canceled.first.error.message).to eq("Error!")
 	end
 
 	it "should clean joins" do
@@ -173,7 +203,7 @@ RSpec.describe Diggit::Dig do
 		expect_any_instance_of(TestAnalysis).to receive(:clean)
 		expect_any_instance_of(TestAnalysisWithAddon).to receive(:clean)
 		Diggit::Dig.it.analyze([], [], :clean)
-		src = Diggit::Dig.it.journal.sources_by_ids(0)[0]
+		src = Diggit::Dig.it.journal.sources_by_ids.first
 		expect(src.entry.has?("test_analysis")).to be false
 		expect(src.entry.has?("test_analysis_with_addon")).to be false
 		Diggit::Dig.it.config.del_all_analyses
@@ -182,7 +212,7 @@ RSpec.describe Diggit::Dig do
 	it "should handle analyses with clean errors" do
 		Diggit::Dig.it.config.add_analysis("test_analysis_with_clean_error")
 		Diggit::Dig.it.analyze([], ["test_analysis_with_clean_error"])
-		src = Diggit::Dig.it.journal.sources_by_ids(0)[0]
+		src = Diggit::Dig.it.journal.sources_by_ids.first
 		expect(src.entry.has?("test_analysis_with_clean_error", :performed)).to be true
 		Diggit::Dig.it.analyze([], [], :clean)
 		expect(src.entry.has?("test_analysis_with_clean_error", :performed)).to be false