diggit 2.0.0 → 2.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: ab5b0bd0d5959100238fb8bdcd2d6471a660bc94
-  data.tar.gz: 41bcf9e0cea8e6110faded4f51b37caa8475adf2
+  metadata.gz: 9fbc5e12f3c7806df481b5627dc5f904f89428c5
+  data.tar.gz: 6600fc64a91b44b386795d16a792caa11f12d932
 SHA512:
-  metadata.gz: 2d11da8a99ed2706e882bbdaf9a95e011f46fb3f3e1941c6728311de15b7796ab624ce62ac0220e778094f6a8f29e0b798e79efa6c5916de8cce471a8f9b0b8f
-  data.tar.gz: f7272bb6679af26829ee4ccbc1b013f2f6d6c1e2026b01e0501335a0cd726e82b117c42fc8f2a28fbc24bae2ef988c86b37fd54f06581f3b78520cee010850a1
+  metadata.gz: 5defc137d1d9cd066c730c4c2d01b2da01bd7f848866cd01888caf6b97fea24377e293ddfc66ade5f03f9b6742ca3bc177b611762a30deb697b9fe6ff894f326
+  data.tar.gz: 535718d8f71f8f088f08c08bab2edb33e8e270db0e928a208d26c273c4a71b445863060ec2157175adb33fc33292e8120ba4d0df94931f96a1589db783a800ed

data/CHANGELOG.md

@@ -0,0 +1,20 @@
+# Changelog of Diggit
+
+### Version 2.0.1
+* Removed `errors`command, merged with subcommands of `sources`
+* Added a lot of documentation
+* Now the `init` command creates the directory for plugins and skips creating already existing folders
+* Fixed plugins not shipped with the gem
+* Removed useless dependency on `mongo`
+
+## Version 2.0.0 (Beardfish)
+* huge refactoring of the code
+* now addons are lazy loaded
+* `require_addons` to include addons in analyses and joins
+* addons are now accessible using a method with the name of the addon inside an analysis or a join
+* improved command line: now uses the GLI library
+* addition of run modes: `:run`, `:rerun` and `:clean`
+* more detailed journaling
+
+## Version 1.0.0 (Anchovy)
+* initial version

data/README.md

@@ -1,4 +1,4 @@
-# Diggit
+# Diggit [![Build Status](https://travis-ci.org/jrfaller/diggit.svg?branch=master)](https://travis-ci.org/jrfaller/diggit) [![Coverage Status](https://coveralls.io/repos/jrfaller/diggit/badge.svg?branch=master)](https://coveralls.io/r/jrfaller/diggit?branch=master) [![Inline docs](http://inch-ci.org/github/jrfaller/diggit.svg?branch=master)](http://inch-ci.org/github/jrfaller/diggit) [![Dependency Status](https://gemnasium.com/jrfaller/diggit.svg)](https://gemnasium.com/jrfaller/diggit)
 
 A ruby tool to analyze Git repositories
 
@@ -14,6 +14,8 @@ Clone diggit using the following command: `git clone https://github.com/jrfaller
 
 # Usage
 
+Don't forget that dgit binary has an associated help that can be consulted using `dgit help`.
+
 ## Configuration
 
 The diggit tool is designed to help you analyze software repositories. Firstly you have to create a new folder in which you launch the `dgit init` command. This way, the folder becomes a diggit folder in which you can configure repositories and analyses.

data/bin/dgit

@@ -1,5 +1,23 @@
 #!/usr/bin/env ruby
 # 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 'gli'
 require_relative '../lib/dgit'
@@ -8,6 +26,8 @@ include GLI::App
 
 program_desc 'A git repository analysis tool.'
 
+switch [:v, :verbose], default_value: false, negatable: false, desc: "Indicates if the debug information are visible."
+
 version Diggit::VERSION
 
 subcommand_option_handling :normal
@@ -71,6 +91,35 @@ command :sources do |c|
 			File.open(args[0]).each { |line| Diggit::Dig.it.journal.add_source(line) }
 		end
 	end
+	c.desc 'Display all sources in error.'
+	c.command :errors do |errors|
+		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?
+			end
+		end
+	end
+	c.desc 'Display information on a source'
+	c.arg_name 'id'
+	c.command :info do |info|
+		info.action do |_global_options, _options, args|
+			src = Diggit::Dig.it.journal.sources_by_ids(args.to_i)
+			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.emtpy?
+			if src.error?
+				error = src.error
+				Log.indent do
+					Log.error error[:message]
+					Log.info error[:backtrace].join("\n")
+				end
+			end
+		end
+	end
 	c.default_command :list
 end
 
@@ -117,6 +166,13 @@ command :analyses do |c|
 			Diggit::Dig.it.config.add_analysis args[0]
 		end
 	end
+	c.desc 'Delete an analysis.'
+	c.arg_name 'name'
+	c.command :del do |add|
+		add.action do |_global_options, _options, args|
+			Diggit::Dig.it.config.del_analysis args[0]
+		end
+	end
 	c.desc 'Perform analyses.'
 	c.command :perform do |perform|
 		perform.flag [:s, :sources], desc: "list of sources", type: Array, default_value: []
@@ -142,39 +198,10 @@ command :clone do |c|
 	c.default_command :perform
 end
 
-desc 'Display errors.'
-command :errors do |c|
-	c.desc 'Display the list of errors.'
-	c.command :list do |list|
-		list.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?
-			end
-		end
-	end
-	c.desc 'Display a source error.'
-	c.arg_name 'id'
-	c.command :show do |show|
-		show.action do |_global_options, _options, args|
-			source = Diggit::Dig.it.journal.sources_by_ids(args[0].to_i)[0]
-			Log.ok "Error summary for source #{args[0]}"
-			error = source.error
-			Log.info "URL: #{source.url}"
-			Log.info "State: #{source.state}"
-			Log.info "Error:"
-			Log.indent do
-				Log.error error[:message]
-				Log.info error[:backtrace].join("\n")
-			end
-		end
-	end
-	c.default_command :list
-end
-
-pre do |_global, _command, _options, _args|
+pre do |global, _command, _options, _args|
 	Diggit::Dig.init
+	Log.level = :fine if global[:v]
+	true
 end
 
 post do |_global, _command, _options, _args|

data/lib/dgit.rb

@@ -1,6 +1,24 @@
 # 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_relative "dgit/core"
 require_relative "dgit/plugins"
 require_relative "dgit/version"
-require_relative "dgit/formatador"
+require_relative "dgit/log"

data/lib/dgit/core.rb

@@ -1,26 +1,59 @@
 # 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 'oj'
 require 'rugged'
 require 'singleton'
-require_relative 'formatador'
+require_relative 'log'
 
 class String
+	# Returns a underscore cased version of the string.
+	# @return [String]
 	def underscore
 		gsub(/::/, '/').gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2')
 				.gsub(/([a-z\d])([A-Z])/, '\1_\2'). tr("-", "_").downcase
 	end
 
+	# Returns a camel cased version of the string.
+	# @return [String]
 	def camel_case
 		return self if self !~ /_/ && self =~ /[A-Z]+.*/
 		split('_').map(&:capitalize).join
 	end
 
+	# Returns a version of the string that can be safely used as a folder name.
+	# @return [string]
 	def id
 		gsub(/[^[\w-]]+/, "_")
 	end
 end
 
+class Module
+	# Return the simple name of a module.
+	# The simple name is the underscore cased name of the module without namespaces.
+	# FIXME: name returns module/class instead of module::class.
+	def simple_name
+		to_s.gsub(/^.*::/, '').underscore
+	end
+end
+
 module Diggit
 	class Source
 		attr_reader :url, :repository
@@ -68,45 +101,16 @@ module Diggit
 			@entry[:state] == :cloned
 		end
 
-		def add_performed_analysis(name)
-			@entry[:performed_analyses] << name
-		end
-
-		def analysis_performed?(name)
-			@entry[:performed_analyses].include?(name)
+		def all_analyses
+			performed_analyses + ongoing_analyses
 		end
 
-		def analyses_performed?(*names)
-			(names - @entry[:performed_analyses]).empty?
+		def performed_analyses
+			@entry[:performed_analyses]
 		end
 
-		def del_performed_analysis(name)
-			@entry[:performed_analyses].delete_if { |a| a == name }
-		end
-
-		def add_ongoing_analysis(name)
-			@entry[:ongoing_analyses].include?(name)
-		end
-
-		def del_ongoing_analysis(name)
-			@entry[:ongoing_analyses].delete_if { |a| a == name }
-		end
-
-		def analysis_ongoing?(name)
-			@entry[:ongoing_analyses].include?(name)
-		end
-
-		def analyses_ongoing?(*names)
-			(names - @entry[:ongoing_analyses]).empty?
-		end
-
-		def analysis?(name)
-			analysis_ongoing?(name) || analysis_performed?(name)
-		end
-
-		def del_analysis(name)
-			del_ongoing_analysis(name)
-			del_performed_analysis(name)
+		def ongoing_analyses
+			@entry[:ongoing_analyses]
 		end
 
 		def clone
@@ -268,11 +272,23 @@ module Diggit
 		end
 	end
 
+	# Class to handle loading of diggit plugins.
+	# Diggit plugins are defined in camel cased classes derived from Plugin.
+	# Their name is the underscore cased version of the class name (example +MyPlugin+ becomes +my_plugin+).
+	# It uses a singleton pattern, so you have to create an instance like that:
+	# @example
+	# 	PluginLoader.instance
+	# @see Plugin
 	class PluginLoader
 		include Singleton
 
 		PLUGINS_TYPES = [:addon, :analysis, :join]
 
+		# Load the plugin with the given name and type.
+		# @param name [String] the name of the plugin
+		# @param type [Symbol] the type of the plugin: +:addon+, +:analysis+ or +:join+.
+		# @param instance [Boolean] +true+ for retrieving an instance or +false+ for retrieving the class.
+		# @return [Plugin, Class] the instance or class of the plugin.
 		def load_plugin(name, type, instance = false)
 			plugin = search_plugin(name, type)
 			if plugin
@@ -286,51 +302,69 @@ module Diggit
 			end
 		end
 
+		def self.plugin_paths(name, type, root)
+			Dir.glob(File.join(root, 'plugins', type.to_s, '**', "#{name}.rb"))
+		end
+
+		# Constructor. Should not be called directly. Use {.instance} instead.
+		# @return [PluginLoader]
+		def initialize
+			@plugins = {}
+		end
+
+			private
+
 		def search_plugin(name, type)
-			plugin = nil
-			if @plugins.key?(name)
-				plugin = @plugins[name]
-			else
-				fail "Unknown plugin type #{type}." unless PLUGINS_TYPES.include?(type)
-				if load_file(name, type)
-					plugin = Object.const_get(name.camel_case)
-					base_class = Object.const_get("Diggit::#{type.to_s.camel_case}")
-					if plugin < base_class
-						@plugins[name] = plugin
-					else
-						fail "Plugin #{name} not of kind #{type}."
-					end
-				end
-			end
-			plugin
+			return @plugins[name] if @plugins.key?(name)
+			fail "Unknown plugin type #{type}." unless PLUGINS_TYPES.include?(type)
+			fail "File #{name}.rb in #{type} directories not found." unless load_file(name, type)
+
+			base_class = Object.const_get("Diggit::#{type.to_s.camel_case}")
+			plugins = ObjectSpace.each_object(Class).select { |c| c < base_class && c.simple_name == name }
+
+			fail "No plugin #{name} of kind #{type} found." if plugins.empty?
+			warn "Ambiguous plugin name: several plugins of kind #{type} named #{name} were found." if plugins.size > 1
+
+			@plugins[name] = plugins[0]
+			plugins[0]
 		end
 
 		def load_file(name, type)
-			f_glob = PluginLoader.plugin_path(name, type, File.expand_path('../..', File.dirname(File.realpath(__FILE__))))
-			f_home = PluginLoader.plugin_path(name, type, File.expand_path(Dig::DGIT_FOLDER, Dir.home))
-			f_local = PluginLoader.plugin_path(name, type, Dig.it.folder)
+			f_glob = PluginLoader.plugin_paths(name, type, File.expand_path('../..', File.dirname(File.realpath(__FILE__))))
+			f_home = PluginLoader.plugin_paths(name, type, File.join(Dir.home, Dig::DGIT_FOLDER))
+			f_local = PluginLoader.plugin_paths(name, type, Dig.it.folder)
+			Log.debug "Plugin files in global: #{f_glob}."
+			Log.debug "Plugin files in home: #{f_home}."
+			Log.debug "Plugin files in local directory: #{f_local}."
 			found = true
-			if File.exist?(f_local)
-				require f_local
-			elsif File.exist?(f_home)
-				require f_home
-			elsif File.exist?(f_glob)
-				require f_glob
+			if !f_local.empty?
+				f_local.each { |f| require File.expand_path(f) }
+			elsif !f_home.empty?
+				f_home.each { |f| require File.expand_path(f) }
+			elsif !f_glob.empty?
+				f_glob.each { |f| require File.expand_path(f) }
 			else
 				found = false
 			end
 			found
 		end
-
-		def self.plugin_path(name, type, root)
-			File.expand_path("#{name}.rb", File.expand_path(type.to_s, File.expand_path('plugins', root)))
-		end
-
-		def initialize
-			@plugins = {}
-		end
 	end
 
+	# Main diggit class.
+	# It must be runned in a folder containing a +.dgit+ folder with a proper configuration.
+	# Access configuration, options, sources and journal from this object.
+	# It implements the singleton pattern.
+	# You can initialize it via {.init} and retrieve the instance via {.it}.
+	# @!attribute [r] config
+	# 	@return [Config] the config.
+	# @!attribute [r] options
+	# 	@return [Hash<String,Object>] the options.
+	# @!attribute [r] journal
+	# 	@return [Journal] the journal.
+	# @!attribute [r] folder
+	# 	@return [String] the folder in which diggit is running.
+	# @!attribute [r] plugin_loader
+	# 	@return [PluginLoader] utility classes to load plugins.
 	class Dig
 		DGIT_FOLDER = ".dgit"
 		DGIT_SOURCES = "sources"
@@ -338,15 +372,22 @@ module Diggit
 		DGIT_OPTIONS = "options"
 		DGIT_JOURNAL = "journal"
 
+		private_constant :DGIT_SOURCES, :DGIT_CONFIG, :DGIT_OPTIONS, :DGIT_JOURNAL
+
 		attr_reader :config, :options, :journal, :plugin_loader, :folder
 
 		@diggit = nil
 
+		# Returns the diggit instance.
+		# @return [Dig] the instance.
 		def self.it
 			fail "Diggit has not been initialized." if @diggit.nil?
 			@diggit
 		end
 
+		# Initialize and return the diggit instance into the given folder.
+		# @param folder the path to the folder.
+		# @return [Dig] the instance.
 		def self.init(folder = '.')
 			@diggit = Dig.new(folder)
 			@diggit.load_options
@@ -355,22 +396,56 @@ module Diggit
 			@diggit
 		end
 
+		# Initialize a folder to be a diggit folder by creating an empty configuration.
+		# It creates a +.dgit+ folder containing a +journal+, +config+, +options+ files.
+		# It creates a +sources+ folder.
+		# It creates a +plugins+ folder.
+		# Directory creation is skipped if folder already exist.
+		# @param folder the path to the folder.
+		# @return [void]
 		def self.init_dir(folder = '.')
 			dgit_folder = File.expand_path(DGIT_FOLDER, folder)
-			FileUtils.mkdir(dgit_folder)
-			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), {})
-			FileUtils.mkdir(File.expand_path('sources', folder))
+			unless File.exist?(dgit_folder)
+				FileUtils.mkdir(dgit_folder)
+				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), {})
+			end
+			FileUtils.mkdir(File.expand_path('sources', folder)) unless File.exist?(File.expand_path('sources', folder))
+			unless File.exist?(File.expand_path("plugins", folder))
+				FileUtils.mkdir_p(File.expand_path("plugins", folder))
+				FileUtils.mkdir_p(File.expand_path("plugins/analysis", folder))
+				FileUtils.mkdir_p(File.expand_path("plugins/addon", folder))
+				FileUtils.mkdir_p(File.expand_path("plugins/join", folder))
+			end
+		end
+
+		# Return the path of the given config file
+		# @param name [String] name of the file
+		# @return [String] the path to the file.
+		def config_path(name)
+			File.expand_path(name, File.expand_path(DGIT_FOLDER, @folder))
 		end
 
+		# Return the path of the given file in the diggit folder
+		# @param name [String] name of the file
+		# @return [String] the path to the file.
+		def file_path(name)
+			File.expand_path(name, @folder)
+		end
+
+		# Constructor. Should not be called directly.
+		# Use {.init} and {.it} instead.
+		# @return [Dig] a diggit object.
 		def initialize(folder)
 			fail "Folder #{folder} is not a diggit folder." unless File.exist?(File.expand_path(DGIT_FOLDER, folder))
 			@plugin_loader = PluginLoader.instance
 			@folder = folder
 		end
 
+		# Load the journal from +.dgit/journal+
+		# @return [void]
 		def load_journal
 			url_array = []
 			IO.readlines(config_path(DGIT_SOURCES)).each { |l| url_array << l.strip }
@@ -379,47 +454,83 @@ module Diggit
 			@journal = Journal.new(hash)
 		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] })
 		end
 
+		# Load the options from +.dgit/options+
+		# @return [void]
 		def load_options
 			@options = Oj.load_file(config_path(DGIT_OPTIONS))
 		end
 
+		# Save the options to +.dgit/options+
+		# @return [void]
 		def save_options
 			Oj.to_file(config_path(DGIT_OPTIONS), options)
 		end
 
+		# Load the config from +.dgit/config+
+		# @return [void]
 		def load_config
 			@config = Config.new(Oj.load_file(config_path(DGIT_CONFIG)))
 		end
 
+		# Save the config to +.dgit/config+
+		# @return [void]
 		def save_config
 			config_hash = @config.to_hash
 			Oj.to_file(config_path(DGIT_CONFIG), config_hash)
 		end
 
+		# Clone the repository of all sources with the given source ids.
+		# @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)
 		ensure
 			save_journal
 		end
 
+		# Perform the given analyses on sources with the given ids using the given mode.
+		# @param source_ids [Array<Integer>] the ids of the sources.
+		# @param analyses [Array<String>] the names of the analyses.
+		# @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|
 				@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.analysis?(a.name)
-					run_analysis(s, a) if run_mode?(mode) && !s.analysis_performed?(a.name)
+					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)
 				end
 			end
 		end
 
+		# Perform the given joins on sources with the given ids using the given mode.
+		# @param source_ids [Array<Integer>] the ids of the sources.
+		# @param joins [Array<String>] the names of the analyses.
+		# @param mode [Symbol] the mode: +:run+, +:rerun+ or +:clean+.
+		# @return [void]
+		def join(source_ids = [], joins = [], mode = :run)
+			@config.get_joins(*joins).each do |klass|
+				j = klass.new(@options)
+				j.clean if clean_mode?(mode)
+				source_array = @journal.sources_by_ids(*source_ids).select do |s|
+					s.cloned? && (klass.required_analyses - s.performed_analyses).empty?
+				end
+				run_join(j, source_array) if run_mode?(mode) && !source_array.empty?
+			end
+		end
+
+			private
+
 		def clean_mode?(mode)
 			mode == :rerun || mode == :clean
 		end
@@ -436,10 +547,10 @@ module Diggit
 		end
 
 		def run_analysis(s, a)
-			s.add_ongoing_analysis(a.name)
+			s.ongoing_analyses << a.name
 			a.run
-			s.del_ongoing_analysis(a.name)
-			s.add_performed_analysis(a.name)
+			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)
@@ -447,16 +558,6 @@ module Diggit
 			save_journal
 		end
 
-		def join(source_ids = [], joins = [], mode = :run)
-			@config.get_joins(*joins).each do |klass|
-				j = klass.new(@options)
-				j.clean if clean_mode?(mode)
-				source_array = @journal.sources_by_ids(*source_ids)
-						.select { |s| s.cloned? && s.analyses_performed?(*klass.required_analyses) }
-				run_join(j, source_array) if run_mode?(mode) && !source_array.empty?
-			end
-		end
-
 		def run_join(j, source_array)
 			j.sources = source_array
 			j.run
@@ -467,13 +568,5 @@ module Diggit
 		ensure
 			save_journal
 		end
-
-		def config_path(name)
-			File.expand_path(name, File.expand_path(DGIT_FOLDER, @folder))
-		end
-
-		def file_path(name)
-			File.expand_path(name, @folder)
-		end
 	end
 end