diggit 2.0.2 → 2.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: ea02ededd6c7a3836496975d8d994a75e131c4dc
-  data.tar.gz: efb7cd6e4cabca46c43449a71de61ed52b9233e9
+  metadata.gz: 2fa14be04009f4668ce08541bcc05aa050308de7
+  data.tar.gz: 2f956728d1a7d6e2ea999a0d2aa59d60ecbad58a
 SHA512:
-  metadata.gz: a4eddd07d9a7102df17b2b8841d3f3c10ef11c1c60cb3d035cf43c3af5bcdc91c4adb5caa4ed814ab8d74dc97c8f6ff41ed0c98d43af3f9e76395163cb85d861
-  data.tar.gz: 59a4947128381985ad25d2b27aaa52b12ec48362c4cda8c0b885919fdab9504d54579dc15f29e5f841682e20c536e9e622c36df86fd82980d64a36dfa7e4bd13
+  metadata.gz: 53da80f0affd555bb133b5b36129772d1a915fb5d04661f1d5b7a7c94d00a1cf347d092d5775f05372bd7b434ee28a21e6b3c0822d4a84485e4d94c4e2c20d7c
+  data.tar.gz: 44488dca2f0ad7d39b788012e73c1ee17c608d958bde77be62cdb1cd6d20c5f84f11a6ac022e0e8663d0ad054a63f6bd89ce730e0a8d16d760ef477adbb82d90

data/CHANGELOG.md

@@ -1,5 +1,11 @@
 # Changelog of Diggit
 
+### Version 2.1.0
+* Now repositories are reseted to master by default
+* Journal infrastructure has been vastly improved
+* Journal now records time for analyses and joins
+* Journal now handles runnables with clean errors
+
 ### Version 2.0.2
 * Fixed analysis cleaning
 * Fixed error in gemspec

data/bin/dgit

@@ -75,7 +75,7 @@ module Diggit
 				sources = Diggit::Dig.it.journal.sources
 				sources.each_index do |idx|
 					msg = "#{idx}	#{sources[idx].url} (#{sources[idx].state})"
-					sources[idx].error? ? Log.error(msg) : Log.ok(msg)
+					sources[idx].entry.error? ? Log.error(msg) : Log.ok(msg)
 				end
 			end
 		end
@@ -98,8 +98,8 @@ module Diggit
 			errors.action do |_global_options, _options, _args|
 				sources = Diggit::Dig.it.journal.sources
 				sources.each_index do |idx|
-					msg = "#{idx}	#{sources[idx].url} (#{sources[idx].state})"
-					Log.error msg if sources[idx].error?
+					msg = "#{idx}	#{sources[idx].url} (#{sources[idx].entry.state})"
+					Log.error msg if sources[idx].entry.error?
 				end
 			end
 		end
@@ -108,16 +108,22 @@ module Diggit
 		c.command :info do |info|
 			info.action do |_global_options, _options, args|
 				src = Diggit::Dig.it.journal.sources_by_ids(args[0].to_i)[0]
-				url = "URL: #{src.url}"
-				src.error? ? Log.error(url) : Log.info(url)
-				Log.info "State: #{src.state}"
-				Log.info "Performed analyses: #{src.performed_analyses.join(', ')}" unless src.performed_analyses.empty?
-				Log.error "Ongoing analyses: #{src.ongoing_analyses.join(', ')}" unless src.ongoing_analyses.empty?
-				if src.error?
-					error = src.error
+				Log.info "URL: #{src.url}"
+				Log.info "State: #{src.entry.state}"
+				Log.info "Performed analyses:" unless src.entry.performed.empty?
+				src.entry.performed.each do |e|
+					Log.indent do
+						Log.info "#{e.name}, time: #{e.duration}"
+					end
+				end
+				Log.info "Canceled analyses:" unless src.entry.canceled.empty?
+				src.entry.canceled.each do |e|
 					Log.indent do
-						Log.error error[:message]
-						Log.info error[:backtrace].join("\n")
+						Log.info "#{e.name}, time: #{e.duration}"
+						Log.indent do
+							Log.error e.error.message
+							Log.error e.error.backtrace.join("\n")
+						end
 					end
 				end
 			end

data/lib/dgit.rb

@@ -21,3 +21,4 @@ require_relative 'dgit/core'
 require_relative 'dgit/plugins'
 require_relative 'dgit/version'
 require_relative 'dgit/log'
+require_relative 'dgit/entries'

data/lib/dgit/core.rb

@@ -22,6 +22,7 @@ require 'oj'
 require 'rugged'
 require 'singleton'
 require_relative 'log'
+require_relative 'entries'
 
 class String
 	# Returns a underscore cased version of the string.
@@ -56,12 +57,11 @@ end
 
 module Diggit
 	class Source
-		attr_reader :url, :repository
-		attr_accessor :entry
+		attr_reader :url, :repository, :entry
 
 		def initialize(url)
 			@url = url
-			@entry = Journal.new_source_entry
+			@entry = SourceEntry.new
 			@repository = nil
 		end
 
@@ -73,81 +73,32 @@ module Diggit
 			Dig.it.file_path("sources/#{id}")
 		end
 
-		def error?
-			!(@entry[:last_error].nil? || @entry[:last_error].empty?)
-		end
-
-		def error
-			@entry[:last_error]
-		end
-
-		def error=(error)
-			@entry[:last_error] = error
-		end
-
-		def state
-			@entry[:state]
-		end
-
-		def state=(state)
-			@entry[:state] = state
-		end
-
-		def new?
-			@entry[:state] == :new
-		end
-
-		def cloned?
-			@entry[:state] == :cloned
-		end
-
-		def all_analyses
-			performed_analyses + ongoing_analyses
-		end
-
-		def performed_analyses
-			@entry[:performed_analyses]
-		end
-
-		def ongoing_analyses
-			@entry[:ongoing_analyses]
-		end
-
-		def clean_analysis(analysis)
-			performed_analyses.delete_if { |e| e == analysis.name }
-			ongoing_analyses.delete_if { |e| e == analysis.name }
-		end
-
 		def clone
+			@entry.error = nil
 			if File.exist?(folder)
 				Rugged::Repository.new(folder)
 			else
 				Rugged::Repository.clone_at(url, folder)
 			end
-			self.state = :cloned
-			self.error = nil
+			@entry.state = :cloned
 		rescue => e
 			Log.error "Error cloning #{url}."
-			self.error = Journal.dump_error(e)
+			@entry.error = e
 		end
 
 		def load_repository
-			fail "Source not cloned #{url}." if new?
+			fail "Source not cloned #{url}." if @entry.new?
 			@repository = Rugged::Repository.new(folder)
+			@repository.checkout("origin/master")
 		end
 	end
 
 	class Journal
-		def initialize(hash)
+		attr_reader :sources, :workspace
+
+		def initialize
 			@sources = {}
-			@workspace = {}
-			hash[:urls].each do |u|
-				s = Source.new(u)
-				s.entry = hash[:sources][u] if !hash[:sources].nil? && hash[:sources].key?(u)
-				@sources[u] = s
-			end
-			@workspace = hash[:workspace]
-			@workspace = Journal.new_workspace_entry if hash[:workspace].nil? || hash[:workspace].empty?
+			@workspace = WorkspaceEntry.new
 		end
 
 		def sources
@@ -155,7 +106,7 @@ module Diggit
 		end
 
 		def sources_by_state(state, error = false)
-			@sources.select { |_u, s| s.state == state && s.error? == error }.values
+			@sources.select { |_u, s| s.entry.state == state && s.entry.error? == error }.values
 		end
 
 		def sources_by_ids(*ids)
@@ -169,56 +120,14 @@ module Diggit
 			result
 		end
 
-		def update_source(source)
-			fail "No such source #{source}." unless @sources.key?(source.url)
-			@sources[source.url] = source
-			Dig.it.save_journal
+		def source?(url)
+			@sources.key?(url)
 		end
 
 		def add_source(url)
 			@sources[url] = Source.new(url) unless @sources.key?(url)
 			Dig.it.save_journal
 		end
-
-		def join?(name)
-			@workspace[:performed_joins].include?(name)
-		end
-
-		def add_join(name)
-			@workspace[:performed_joins] << name
-			Dig.it.save_journal
-		end
-
-		def join_error?
-			!@workspace[:last_error].nil?
-		end
-
-		def join_error
-			@workspace[:last_error]
-		end
-
-		def join_error=(error)
-			@workspace[:last_error] = Journal.dump_error(error)
-			Dig.it.save_journal
-		end
-
-		def to_hash
-			entry_hash = {}
-			@sources.each { |entry| entry_hash[entry[0]] = entry[1].entry }
-			{ urls: @sources.keys, sources: entry_hash, workspace: @workspace }
-		end
-
-		def self.new_source_entry
-			{ state: :new, performed_analyses: [], error_analyses: [], ongoing_analyses: [], last_error: {} }
-		end
-
-		def self.new_workspace_entry
-			{ performed_joins: [], last_error: {} }
-		end
-
-		def self.dump_error(error)
-			{ name: error.class.name, message: error.to_s, backtrace: error.backtrace }
-		end
 	end
 
 	class Config
@@ -249,6 +158,11 @@ module Diggit
 			Dig.it.save_config
 		end
 
+		def del_all_analyses
+			@analyses = []
+			Dig.it.save_config
+		end
+
 		def get_analyses(*names)
 			return analyses if names.empty?
 			analyses.select { |a| names.include?(a.simple_name) }
@@ -268,6 +182,11 @@ module Diggit
 			Dig.it.save_config
 		end
 
+		def del_all_joins
+			@joins = []
+			Dig.it.save_config
+		end
+
 		def get_joins(*names)
 			return joins if names.empty?
 			joins.select { |j| joins.include?(j.simple_name) }
@@ -416,7 +335,7 @@ module Diggit
 				Oj.to_file(File.expand_path(DGIT_CONFIG, dgit_folder), Config.empty_config)
 				Oj.to_file(File.expand_path(DGIT_OPTIONS, dgit_folder), {})
 				FileUtils.touch(File.expand_path(DGIT_SOURCES, dgit_folder))
-				Oj.to_file(File.expand_path(DGIT_JOURNAL, dgit_folder), {})
+				Oj.to_file(File.expand_path(DGIT_JOURNAL, dgit_folder), Journal.new)
 			end
 			FileUtils.mkdir(File.expand_path('sources', folder)) unless File.exist?(File.expand_path('sources', folder))
 			unless File.exist?(File.expand_path("plugins", folder))
@@ -455,17 +374,17 @@ module Diggit
 		def load_journal
 			url_array = []
 			IO.readlines(config_path(DGIT_SOURCES)).each { |l| url_array << l.strip }
-			saved_hash = Oj.load_file(config_path(DGIT_JOURNAL))
-			hash = { urls: url_array, sources: saved_hash[:sources], workspace: saved_hash[:workspace] }
-			@journal = Journal.new(hash)
+			@journal = Oj.load_file(config_path(DGIT_JOURNAL))
+			url_array.each do |url|
+				@journal.add_source(url)
+			end
 		end
 
 		# Save the journal to +.dgit/journal+
 		# @return [void]
 		def save_journal
-			hash = @journal.to_hash
-			File.open(config_path(DGIT_SOURCES), "w") { |f| hash[:urls].each { |u| f.puts(u) } }
-			Oj.to_file(config_path(DGIT_JOURNAL), { sources: hash[:sources], workspace: hash[:workspace] })
+			File.open(config_path(DGIT_SOURCES), "w") { |f| @journal.sources.each { |source| f.puts(source.url) } }
+			Oj.to_file(config_path(DGIT_JOURNAL), @journal, indent: 2)
 		end
 
 		# Load the options from +.dgit/options+
@@ -497,7 +416,7 @@ module Diggit
 		# @param source_ids [Array<Integer>] the ids of the sources.
 		# @return [void]
 		def clone(*source_ids)
-			@journal.sources_by_ids(*source_ids).select(&:new?).each(&:clone)
+			@journal.sources_by_ids(*source_ids).select { |s| s.entry.new? }.each(&:clone)
 		ensure
 			save_journal
 		end
@@ -508,13 +427,13 @@ module Diggit
 		# @param mode [Symbol] the mode: +:run+, +:rerun+ or +:clean+.
 		# @return [void]
 		def analyze(source_ids = [], analyses = [], mode = :run)
-			@journal.sources_by_ids(*source_ids).select(&:cloned?).each do |s|
+			@journal.sources_by_ids(*source_ids).select { |s| s.entry.cloned? }.each do |s|
 				@config.get_analyses(*analyses).each do |klass|
 					a = klass.new(@options)
 					s.load_repository
 					a.source = s
-					clean_analysis(s, a) if clean_mode?(mode) && s.all_analyses.include?(a.name)
-					run_analysis(s, a) if run_mode?(mode) && !s.performed_analyses.include?(a.name)
+					clean(a, s.entry) if clean_mode?(mode) && s.entry.has?(a)
+					run(a, s.entry) if run_mode?(mode) && !s.entry.has?(a)
 				end
 			end
 		end
@@ -527,11 +446,12 @@ module Diggit
 		def join(source_ids = [], joins = [], mode = :run)
 			@config.get_joins(*joins).each do |klass|
 				j = klass.new(@options)
-				j.clean if clean_mode?(mode)
+				clean(j, @journal.workspace) if clean_mode?(mode) && @journal.workspace.has?(j)
 				source_array = @journal.sources_by_ids(*source_ids).select do |s|
-					s.cloned? && (klass.required_analyses - s.performed_analyses).empty?
+					s.entry.cloned? && (klass.required_analyses - s.entry.performed.map(&:name)).empty?
 				end
-				run_join(j, source_array) if run_mode?(mode) && !source_array.empty?
+				j.sources = source_array
+				run(j, @journal.workspace) if run_mode?(mode) && !source_array.empty? && !@journal.workspace.has?(j)
 			end
 		end
 
@@ -545,34 +465,36 @@ module Diggit
 			mode == :rerun || mode == :run
 		end
 
-		def clean_analysis(s, a)
-			a.clean
-			s.clean_analysis(a)
-		ensure
-			save_journal
-		end
-
-		def run_analysis(s, a)
-			s.ongoing_analyses << a.name
-			a.run
-			s.ongoing_analyses.pop
-			s.performed_analyses << a.name
-		rescue => e
-			Log.error "Error applying analysis #{a.name} on #{s.url}"
-			s.error = Journal.dump_error(e)
-		ensure
-			save_journal
+		def clean(runnable, placeholder)
+			placeholder.clean(runnable)
+			entry = RunnableEntry.new(runnable)
+			begin
+				runnable.clean
+			rescue => e
+				entry.toc
+				entry.error = e
+				placeholder.canceled << entry
+				Log.error "Error cleaning #{runnable.name}"
+			ensure
+				save_journal
+			end
 		end
 
-		def run_join(j, source_array)
-			j.sources = source_array
-			j.run
-			@journal.add_join(j.name)
-		rescue => e
-			Log.error "Error applying join #{j.name}"
-			@journal.join_error = e
-		ensure
-			save_journal
+		def run(runnable, placeholder)
+			entry = RunnableEntry.new(runnable)
+			begin
+				runnable.run
+			rescue => e
+				entry.toc
+				entry.error = e
+				placeholder.canceled << entry
+				Log.error "Error running #{runnable.name}"
+			else
+				entry.toc
+				placeholder.performed << entry
+			ensure
+				save_journal
+			end
 		end
 	end
 end

data/lib/dgit/entries.rb

@@ -0,0 +1,159 @@
+# 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>
+
+module Diggit
+	# Journal entry for elements that can have error.
+	#
+	# @!attribute [r] error
+	# 	@return [ErrorEntry, nil] the error entry.
+	module EntryWithError
+		attr_reader :error
+
+		# Set the error of the entry.
+		# @param e [Exception, nil] the error, to indicate an absence of error, pass +nil+.
+		# @return [void]
+		def error=(e)
+			if e.nil?
+				@error = nil
+			else
+				@error = ErrorEntry.new(e)
+			end
+		end
+	end
+
+	# Journal entry for elements that can launch runnables.
+	#
+	# @!attribute [r] performed
+	# 	@return [Array<RunnableEntry>] the list of performed runnables.
+	# @!attribute [r] canceled
+	# 	@return [Array<RunnableEntry>] the list of canceled runnables.
+	class EntryWithRunnables
+		attr_reader :performed, :canceled
+
+		def initialize
+			@performed = []
+			@canceled = []
+		end
+
+		# Error status of the element.
+		# @return [Boolean]
+		def error?
+			@canceled.size > 0
+		end
+
+		# Check if a runnable has been performed or canceled.
+		# @param runnable_or_string [Runnable, String] the runnable or the name of the runnable.
+		# @param state [Symbol] the status of the runnable: +:performed+, +:canceled+ or +:all+.
+		# @return [Boolean]
+		def has?(runnable_or_string, state = :all)
+			name = retrieve_name(runnable_or_string)
+			if state == :performed
+				return @performed.count { |e| e.name == name } > 0
+			elsif state == :canceled
+				return @canceled.count { |e| e.name == name } > 0
+			elsif state == :all
+				return (@performed + @canceled).count { |e| e.name == name } > 0
+			end
+		end
+
+		# Remove a runnable from all the entries.
+		# @param runnable_or_string [Runnable, String] the runnable or the name of the runnable
+		# @return [void]
+		def clean(runnable_or_string)
+			name = retrieve_name(runnable_or_string)
+			@performed.delete_if { |e| e.name == name }
+			@canceled.delete_if { |e| e.name == name }
+		end
+
+			private
+
+		def retrieve_name(runnable_or_string)
+			if runnable_or_string.is_a? String
+				return runnable_or_string
+			else
+				return runnable_or_string.name
+			end
+		end
+	end
+
+	class ErrorEntry
+		attr_reader :name, :message, :backtrace
+
+		def initialize(error)
+			@name = error.class.name
+			@message = error.to_s
+			@backtrace = error.backtrace
+		end
+	end
+
+	class RunnableEntry
+		include EntryWithError
+		attr_accessor :start, :end, :name
+
+		def initialize(runnable)
+			@name = runnable.name
+			@end = nil
+			tic
+		end
+
+		def error?
+			!@error.nil?
+		end
+
+		def tic
+			@start = Time.now
+		end
+
+		def toc
+			@end = Time.now
+		end
+
+		def duration
+			@end - @start
+		end
+	end
+
+	class SourceEntry < EntryWithRunnables
+		include EntryWithError
+		attr_accessor :state
+
+		def initialize
+			super
+			@state = :new
+		end
+
+		def error?
+			super || !@error.nil?
+		end
+
+		def new?
+			@state == :new
+		end
+
+		def cloned?
+			@state == :cloned
+		end
+	end
+
+	class WorkspaceEntry < EntryWithRunnables
+		def initialize
+			super
+		end
+	end
+end

data/lib/dgit/version.rb

@@ -18,5 +18,5 @@
 # Copyright 2015 Jean-Rémy Falleri <jr.falleri@gmail.com>
 
 module Diggit
-	VERSION = "2.0.2"
+	VERSION = '2.1.0'
 end

data/plugins/analysis/cloc.rb

@@ -43,6 +43,5 @@ class Cloc < Diggit::Analysis
 
 	def clean
 		db.client['cloc'].find({ source: @source.url }).delete_many
-		repo.checkout('master')
 	end
 end

data/plugins/analysis/javadoc.rb

@@ -0,0 +1,43 @@
+# 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 'jsonpath'
+
+class Javadoc < Diggit::Analysis
+	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
+			end
+		end
+	end
+
+	def clean
+	end
+end

data/plugins/analysis/tex.rb

@@ -39,7 +39,6 @@ class Tex < Diggit::Analysis
 
 	def clean
 		FileUtils.rm_rf(file)
-		repo.checkout("master")
 	end
 
 	def file

data/spec/core_spec.rb

@@ -100,7 +100,7 @@ RSpec.describe Diggit::Dig 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].state = :new
+		Diggit::Dig.it.journal.sources_by_ids(0)[0].entry.state = :new
 		Diggit::Dig.it.clone
 		expect(Diggit::Dig.it.journal.sources_by_ids(0)[0].url).to eq TEST_URL
 		Diggit::Dig.init("spec/dgit")
@@ -113,18 +113,23 @@ 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
-		expect(Diggit::Dig.it.journal.sources_by_ids(0)[0].all_analyses).to eq(%w(test_analysis test_analysis_with_addon))
+		src = Diggit::Dig.it.journal.sources_by_ids(0)[0]
+		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")
-		expect(Diggit::Dig.it.journal.sources_by_ids(0)[0].all_analyses).to eq(%w(test_analysis test_analysis_with_addon))
+		src = Diggit::Dig.it.journal.sources_by_ids(0)[0]
+		expect(src.entry.has?("test_analysis", :performed)).to be true
+		expect(src.entry.has?("test_analysis_with_addon", :performed)).to be true
 	end
 
 	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]
-		expect(src.all_analyses).to include("test_analysis")
-		expect(src.error?).to be true
-		expect(src.error[:message]).to eq("Error!")
+		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!")
 	end
 
 	it "should perform joins" do
@@ -133,21 +138,55 @@ RSpec.describe Diggit::Dig do
 		expect_any_instance_of(TestJoin).to receive(:run)
 		expect_any_instance_of(TestJoinWithAddon).not_to receive(:run)
 		Diggit::Dig.it.join
-		expect(Diggit::Dig.it.journal.join?("test_join")).to be true
-		expect(Diggit::Dig.it.journal.join?("test_join_with_addon")).to be false
+		expect(Diggit::Dig.it.journal.workspace.has?("test_join", :performed)).to be true
+		expect(Diggit::Dig.it.journal.workspace.has?("test_join_with_addon", :performed)).to be false
+	end
+
+	it "should handle joins with error" do
+		Diggit::Dig.it.config.add_join("test_join_with_error")
+		Diggit::Dig.it.join
+		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!")
 	end
 
 	it "should clean joins" do
 		expect_any_instance_of(TestJoin).to receive(:clean)
-		expect_any_instance_of(TestJoinWithAddon).to receive(:clean)
+		expect_any_instance_of(TestJoinWithAddon).not_to receive(:clean)
 		Diggit::Dig.it.join([], [], :clean)
+		expect(Diggit::Dig.it.journal.workspace.has?("test_join")).to be false
+		expect(Diggit::Dig.it.journal.workspace.has?("test_join_with_addon")).to be false
+		Diggit::Dig.it.config.del_all_joins
+	end
+
+	it "should handle joins with clean errors" do
+		Diggit::Dig.it.config.add_join("test_join_with_clean_error")
+		Diggit::Dig.it.join
+		expect(Diggit::Dig.it.journal.workspace.has?("test_join_with_clean_error", :performed)).to be true
+		Diggit::Dig.it.join([], [], :clean)
+		expect(Diggit::Dig.it.journal.workspace.has?("test_join_with_clean_error", :performed)).to be false
+		expect(Diggit::Dig.it.journal.workspace.has?("test_join_with_clean_error", :canceled)).to be true
 	end
 
 	it "should clean analyses" do
 		expect_any_instance_of(TestAnalysis).to receive(:clean)
 		expect_any_instance_of(TestAnalysisWithAddon).to receive(:clean)
 		Diggit::Dig.it.analyze([], [], :clean)
-		expect(Diggit::Dig.it.journal.sources_by_ids(0)[0].all_analyses).to eq([])
+		src = Diggit::Dig.it.journal.sources_by_ids(0)[0]
+		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
+	end
+
+	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]
+		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
+		expect(src.entry.has?("test_analysis_with_clean_error", :canceled)).to be true
 	end
 
 	it "should read source options" do
@@ -161,7 +200,6 @@ RSpec.describe Diggit::Dig do
 
 		Diggit::Dig.it.config.add_analysis("test_analysis_with_sources_options")
 		expect { Diggit::Dig.it.analyze }.to output(/myValue/).to_stdout
-		Diggit::Dig.it.analyze([], [], :clean)
-		Diggit::Dig.it.config.del_analysis("test_analysis_with_sources_options")
+		Diggit::Dig.it.config.del_all_analyses
 	end
 end

data/spec/dgit/plugins/analysis/test_analysis_with_clean_error.rb

@@ -0,0 +1,27 @@
+# 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>
+
+class TestAnalysisWithCleanError < Diggit::Analysis
+	def run
+	end
+
+	def clean
+		fail "Error!"
+	end
+end

data/spec/dgit/plugins/analysis/test_analysis_with_sources_options.rb

@@ -26,7 +26,7 @@ class TestAnalysisWithSourcesOptions < Diggit::Analysis
 	end
 
 	def run
-		p(src_opt[@source]["myOption"])
+		puts src_opt[@source]["myOption"]
 	end
 
 	def clean

data/spec/dgit/plugins/join/test_join_with_clean_error.rb

@@ -0,0 +1,29 @@
+# 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>
+
+class TestJoinWithCleanError < Diggit::Join
+	require_analyses 'test_analysis'
+
+	def run
+	end
+
+	def clean
+		fail "Error!"
+	end
+end

data/spec/dgit/plugins/join/test_join_with_error.rb

@@ -0,0 +1,29 @@
+# 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>
+
+class TestJoinWithError < Diggit::Join
+	require_analyses 'test_analysis'
+
+	def run
+		fail "Error!"
+	end
+
+	def clean
+	end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: diggit
 version: !ruby/object:Gem::Version
-  version: 2.0.2
+  version: 2.1.0
 platform: ruby
 authors:
 - Jean-Rémy Falleri
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-10-13 00:00:00.000000000 Z
+date: 2015-11-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rugged
@@ -167,6 +167,7 @@ files:
 - bin/dgit
 - lib/dgit.rb
 - lib/dgit/core.rb
+- lib/dgit/entries.rb
 - lib/dgit/log.rb
 - lib/dgit/plugins.rb
 - lib/dgit/version.rb
@@ -176,6 +177,7 @@ files:
 - plugins/addon/src_opt.rb
 - plugins/analysis/cloc.rb
 - plugins/analysis/cloc_per_file.rb
+- plugins/analysis/javadoc.rb
 - plugins/analysis/tex.rb
 - spec/core_spec.rb
 - spec/dgit/plugins/addon/test_addon.rb
@@ -184,10 +186,13 @@ files:
 - spec/dgit/plugins/analysis/my_module/other_analysis.rb
 - spec/dgit/plugins/analysis/test_analysis.rb
 - spec/dgit/plugins/analysis/test_analysis_with_addon.rb
+- spec/dgit/plugins/analysis/test_analysis_with_clean_error.rb
 - spec/dgit/plugins/analysis/test_analysis_with_error.rb
 - spec/dgit/plugins/analysis/test_analysis_with_sources_options.rb
 - spec/dgit/plugins/join/test_join.rb
 - spec/dgit/plugins/join/test_join_with_addon.rb
+- spec/dgit/plugins/join/test_join_with_clean_error.rb
+- spec/dgit/plugins/join/test_join_with_error.rb
 - spec/spec_helper.rb
 homepage: https://github.com/jrfaller/diggit
 licenses: