diggit 1.0.3 → 2.0.0

data/lib/diggit_core.rb

@@ -1,343 +0,0 @@
-#!/usr/bin/env ruby
-# encoding: utf-8
-
-require 'rugged'
-require 'oj'
-
-module Diggit
-
-	DIGGIT_RC = '.dgitrc'
-	DIGGIT_LOG = '.dgitlog'
-	DIGGIT_SOURCES = '.dgitsources'
-
-	SOURCES_FOLDER = 'sources'
-	INCLUDES_FOLDER = 'includes'
-	DIGGIT_FOLDER = ".diggit"
-
-	# Base class for Diggit addons.
-	# @abstract Subclass and override name to implement custom Diggit addons.
-	#
-	# @!attribute [r] options
-	# 	@return [Hash] the Diggit options.
-	class Addon
-
-		# Create a new addon.
-		#
-		# @param options [Hash] a hash containing the Diggit options.
-		def initialize(options)
-			@options = options
-		end
-
-		# Returns the name of the addon.
-		# @abstract The name must be overrided.
-		#
-		# @return [Symbol] the name of the addon.
-		def name
-			raise NoMethodError.new "Subclass responsability"
-		end
-
-	end
-
-	# Base class for Diggit analyses. Diggit analyses are applied on each source that has been succesfully cloned. They can access the Diggit addons through the addons attribute.
-	# @see Addon
-	# @abstract Subclass and override run and clean to implement
-	# 	a custom analysis class.
-	# @!attribute [r] source
-	# 	@return [String] the URL of the source to be analyzed.
-	# @!attribute [r] repo
-	# 	@return [Rugged::Repository] the Rugged Repository object corresponding to the source.
-	# @!attribute [r] options
-	# 	@return [Hash] a hash containing the Diggit options.
-	# @!attribute [r] addons
-	# 	@return [Hash{Symbol => Addon}] a hash containing the loaded Diggit addons, indexed by names.
-	# @!attribute globs
-	# 	@return [Hash] a hash shared between all analyses of a source.
-	class Analysis
-
-		# Create a new analysis.
-		#
-		# @param source [String] the URL of the source to be analyzed.
-		# @param repo [Rugged::Repository] the Rugged Repository object corresponding to the source.
-		# @param options [Hash] a hash containing the Diggit options.
-		# @param addons [Hash{Symbol => Addon}] a hash containing the loaded Diggit addons, indexed by names.
-		# @param globs [Hash] a hash shared between all analyses of a source.
-		def initialize(source, repo, options, addons, globs)
-			@source = source
-			@repo = repo
-			@options = options
-			@addons = addons
-			@globs = globs
-		end
-
-		# Run the analysis.
-		# @abstract
-		def run
-			raise NoMethodError.new "Subclass responsability"
-		end
-
-		# Clean the data produced by the analysis.
-		# @abstract
-		def clean
-			raise NoMethodError.new "Subclass responsability"
-		end
-
-	end
-
-	# Base class for Diggit joins. Joins are applied after each source have been analyzed. They can access the Diggit addons through the addons attribute.
-	# @see Addon
-	# @abstract Subclass and override cleand and run to implement custom Diggit join.
-	# @!attribute [r] sources
-	# 	@return [Array]  an array containing the finished sources.
-	# @!attribute [r] options
-	# 	@return [Hash] a hash containing the Diggit options.
-	# @!attribute [r] addons
-	# 	@return [Hash{Symbol => Addon}] a hash containing the loaded Diggit addons, indexed by names.
-	# @!attribute globs
-	# 	@return [Hash] a hash shared between all analyses of a source.
-	class Join
-
-		# Create a new join.
-		#
-		# @param sources [Array] an array containing the finished sources.
-		# @param options [Hash] a hash containing the Diggit options.
-		# @param addons [Hash{Symbol => Addon}] a hash containing the loaded Diggit addons, indexed by names.
-		# @param globs [Hash] a hash shared between all analyses of a source.
-		def initialize(sources, options, addons, globs)
-			@sources = sources
-			@options = options
-			@addons = addons
-			@globs = globs
-		end
-
-		# Run the join
-		# @abstract
-		def run
-			raise NoMethodError.new "Subclass responsability"
-		end
-
-		# Clean the data produced by the join
-		# @abstract
-		def clean
-			raise NoMethodError.new "Subclass responsability"
-		end
-
-	end
-
-	class Config
-
-		def initialize
-			@config = Oj.load_file(DIGGIT_RC)
-		end
-
-		def save
-			Oj.to_file(DIGGIT_RC, @config)
-		end
-
-		def analyses
-			@config[:analyses]
-		end
-
-		def add_analysis(analysis)
-			analyses << analysis unless analyses.include?(analysis)
-			save
-		end
-
-		def rem_analysis(analysis)
-			analyses.delete(analysis)
-			save
-		end
-
-		def load_analyses(source, repo, addons, globs)
-			analyses.map{ |a| Object::const_get(a).new(source, repo, options, addons, globs) }
-		end
-
-		def addons
-			return @config[:addons]
-		end
-
-		def add_addon(addon)
-			addons << addon unless addons.include?(addon)
-			save
-		end
-
-		def rem_addon(addon)
-			addons.delete(addon)
-			save
-		end
-
-		def load_addons
-			result = {}
-			addons.each do |a|
-				obj = Object::const_get(a).new(options)
-				result[obj.name] = obj
-			end
-			return result
-		end
-
-		def joins
-			return @config[:joins]
-		end
-
-		def add_join(join)
-			joins << join unless joins.include?(join)
-			save
-		end
-
-		def rem_join(join)
-			joins.delete(join)
-			save
-		end
-
-		def load_joins(finished_sources, addons, globs)
-			return joins.map{ |j| Object::const_get(j).new(finished_sources, options, addons, globs) }
-		end
-
-		def options
-			return @config[:options]
-		end
-
-	end
-
-	class Sources
-
-		def initialize
-			@log = Log.new
-			@sources = []
-			IO.readlines(DIGGIT_SOURCES).each{ |line| @sources << line.strip }
-		end
-
-		def size
-			return @sources.size
-		end
-
-		def save
-			File.open(DIGGIT_SOURCES, "w") do |f|
-				@sources.each{ |s| f.puts(s) }
-			end
-		end
-
-		def add(url)
-			unless @sources.include?(url)
-				@sources << url
-				@log.init(url)
-				save
-			end
-		end
-
-		def rem(source_def)
-			url = url(source_def)
-			@sources.delete(url)
-			@log.rem(url)
-			save
-		end
-
-		def get(source_def)
-			hash(url(source_def))
-		end
-
-		def get_all(source_defs, filter={})
-			sources = []
-			if source_defs.nil? || source_defs.empty?
-				sources = hashes
-			else
-				sources = source_defs.map{ |d| get(d) }
-			end
-			sources = sources.select{ |s| s[:log][:state] == filter[:state] } if (filter.has_key?(:state))
-			sources = sources.select{ |s| s[:log][:error].empty? != filter[:error] } if (filter.has_key?(:error))
-			return sources
-		end
-
-		def update(source_hash)
-			@log.update(source_hash)
-		end
-
-		def url(source_def)
-			url = source_def
-			if /^\d+$/.match(source_def)
-				idx = source_def.to_i - 1
-				raise "Wrong source identifier: #{source_def}" if idx < 0 || idx >= @sources.size
-				url = @sources[source_def.to_i - 1]
-			end
-			url
-		end
-
-		def hashes
-			@sources.map{ |s| hash(s) }
-		end
-
-		def hash(url)
-			{url: url, id: id(url), folder: folder(url), log: @log.log(url)}
-		end
-
-		def id(url)
-			url.gsub(/[^[\w-]]+/, "_")
-		end
-
-		def folder(url)
-			File.expand_path(id(url), SOURCES_FOLDER)
-		end
-
-	end
-
-	class Log
-
-		def initialize
-			@log = Oj.load_file(DIGGIT_LOG)
-		end
-
-		def save
-			Oj.to_file(DIGGIT_LOG, @log)
-		end
-
-		def init(url)
-			unless @log.has_key?(url)
-				@log[url] = default_log
-				save
-			end
-		end
-
-		def update(hash)
-			@log[hash[:url]] = hash[:log]
-			save
-		end
-
-		def rem(url)
-			@log.delete(url)
-			save
-		end
-
-		def log(url)
-			return @log[url]
-		end
-
-		def default_log
-			return {state: :new, error: [], analyses: []}
-		end
-
-	end
-
-	class Diggit
-		attr_accessor :sources, :config, :root
-
-		def initialize(*args)
-			super
-			@root = FileUtils.pwd
-			@sources = Sources.new
-			@config = Config.new
-			load_plugins
-		end
-
-		def load_plugins
-			global = File.expand_path(INCLUDES_FOLDER,File.expand_path('..',File.dirname(File.realpath(__FILE__))))
-			Dir["#{global}/**/*.rb"].each{ |f| require f }
-
-			home = File.expand_path(INCLUDES_FOLDER,File.expand_path(DIGGIT_FOLDER,Dir.home))
-			Dir["#{home}/**{,/*/**}/*.rb"].each{ |f| require f }
-
-			local = File.expand_path(INCLUDES_FOLDER)
-			Dir["#{local}/**{,/*/**}/*.rb"].each{ |f| require f }
-		end
-
-	end
-
-end

data/spec/diggit_spec.rb

@@ -1,135 +0,0 @@
-require 'spec_helper'
-require 'fileutils'
-require 'oj'
-
-FileUtils.rm_rf('tmp')
-FileUtils.mkdir('tmp')
-FileUtils.cd('tmp')
-
-TEST_URL = "https://github.com/jrfaller/test-git"
-TEST_FOLDER = "https_github_com_jrfaller_test-git"
-WRONG_URL = "foo"
-
-RSpec.describe Diggit::Cli::DiggitCli do
-
-	it "should init a diggit folder" do
-		result = capture(:stdout) { Diggit::Cli::DiggitCli.start(["init"]) }
-		expect(result).to include("folder successfully initialized")
-		expect(sources).to be_empty
-		expect(log).to be_empty
-		expect(config).to eq({analyses: [], addons: [], joins: [],  options: {}})
-	end
-
-	it "should add an url" do
-		Diggit::Cli::DiggitCli.start(["sources", "add", TEST_URL])
-		expect(sources).to include(TEST_URL)
-	end
-
-	it "should add another url" do
-		Diggit::Cli::DiggitCli.start(["sources", "add", WRONG_URL])
-		expect(sources).to include(WRONG_URL)
-	end
-
-	it "should list the sources" do
-		result = capture(:stdout) { Diggit::Cli::DiggitCli.start(["sources", "list"]) }
-		expect(result).to include(TEST_URL)
-		expect(result).to include(WRONG_URL)
-	end
-
-	it "should display the status" do
-		result = capture(:stdout) { Diggit::Cli::DiggitCli.start(["status"]) }
-		expect(result).to include("2 new (0 errors)")
-	end
-
-	it "should add an analysis" do
-		Diggit::Cli::DiggitCli.start(["analyses", "add", "TestAnalysis"])
-		expect(config[:analyses]).to eq(["TestAnalysis"])
-	end
-
-	it "should add an addon" do
-		Diggit::Cli::DiggitCli.start(["addons", "add", "TestAddon"])
-		expect(config[:addons]).to eq(["TestAddon"])
-	end
-
-	it "should add a join" do
-		Diggit::Cli::DiggitCli.start(["joins", "add", "TestJoin"])
-		expect(config[:joins]).to eq(["TestJoin"])
-	end
-
-	it "should perform clones on all urls, handling errors" do
-		results = capture(:stdout) { Diggit::Cli::DiggitCli.start(["perform", "clones"]) }
-		expect(results).to include("#{TEST_URL} cloned")
-		expect(log[TEST_URL]).to include(state: :cloned, error: {})
-		expect(File.exist?(File.expand_path(TEST_FOLDER,Diggit::SOURCES_FOLDER))).to be true
-		expect(results).to include("error cloning foo")
-		expect(log[WRONG_URL][:state]).to eq(:new)
-		expect(log[WRONG_URL][:error]).to include(name: "Rugged::NetworkError")
-	end
-
-	it "should display info on a regular url" do
-		results = capture(:stdout) { Diggit::Cli::DiggitCli.start(["sources", "info", TEST_URL]) }
-		expect(results).to include("cloned")
-		expect(results).to include(TEST_URL)
-	end
-
-	it "should display info and error on an url in error" do
-		results = capture(:stdout) { Diggit::Cli::DiggitCli.start(["sources", "info", WRONG_URL]) }
-		expect(results).to include("new")
-		expect(results).to include(WRONG_URL)
-		expect(results).to include("error")
-		expect(results).to include("Rugged::NetworkError")
-	end
-
-	it "should display all errors" do
-		results = capture(:stdout) { Diggit::Cli::DiggitCli.start(["sources", "errors"]) }
-		expect(results).to include("new")
-		expect(results).to include(WRONG_URL)
-		expect(results).to include("error")
-		expect(results).to include("Rugged::NetworkError")
-	end
-
-	it "should remove urls" do
-		Diggit::Cli::DiggitCli.start(["sources", "rem", WRONG_URL])
-		expect(sources).to_not include(WRONG_URL)
-	end
-
-	it "should perform analyses" do
-		results = capture(:stdout) { Diggit::Cli::DiggitCli.start(["perform", "analyses"]) }
-		expect(results).to include("TestAnalysis performed")
-		expect(results).to include("source #{TEST_URL} analyzed")
-		expect(log[TEST_URL][:state]).to eq(:finished)
-	end
-
-	it "should perform joins" do
-		results = capture(:stdout) { Diggit::Cli::DiggitCli.start(["perform", "joins"]) }
-		expect(results).to include("TestJoin performed")
-		expect(results).to include("joins performed")
-	end
-
-	it "should clean joins" do
-		results = capture(:stdout) { Diggit::Cli::DiggitCli.start(["clean", "joins"]) }
-		expect(results).to include("TestJoin cleaned")
-	end
-
-	it "should clean analyses" do
-		results = capture(:stdout) { Diggit::Cli::DiggitCli.start(["clean", "analyses"]) }
-		expect(results).to include("TestAnalysis cleaned on #{TEST_URL}")
-		expect(log[TEST_URL][:state]).to eq(:cloned)
-	end
-
-	it "should remove a join" do
-		Diggit::Cli::DiggitCli.start(["joins", "rem", "TestJoin"])
-		expect(config[:addons]).not_to include("TestJoin")
-	end
-
-	it "should remove an analysis" do
-		Diggit::Cli::DiggitCli.start(["analyses", "rem", "TestAnalysis"])
-		expect(config[:analyses]).not_to include("TestAnalysis")
-	end
-
-	it "should remove an addon" do
-		Diggit::Cli::DiggitCli.start(["addons", "rem", "TestAddon"])
-		expect(config[:addons]).not_to include("TestAddon")
-	end
-
-end