reviser 0.0.1.1.pre.beta

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 3ad369beae7c279013559eaca2a371be84de43a0
+  data.tar.gz: d08c27df554743428484267bf53872053bf75fb0
+SHA512:
+  metadata.gz: 27115ae008fd154acc4e3c0ff6ee9b7cb0da06578634d78f14817b790a3a2bf1e30ba4c376f2d90f9e8becabeccf9bc3882f64cdea7c559ee44764877a5a3181
+  data.tar.gz: fda1bc73fb4ff4bb9d90e9a005554dab160601a9cef5a6eb8c8ed2768a9e2ea35452862b5ec9102b84c8ab25ab8f005aca23c6a1db1e3812e33ebc54926e09ee

data/bin/reviser

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby
+
+require 'scrub_rb' unless RUBY_VERSION.split('.')[0] == '2'
+
+# Command line interface
+require_relative '../lib/exec'

data/config.yml

@@ -0,0 +1,80 @@
+---
+
+################################################
+# 	           Config file   	       #
+################################################
+
+
+########	Archiver config 	########
+
+# File name of the archive containing all projects
+src: projects.zip
+
+# The destination directory for these projects
+dest: projects
+
+
+########	Organiser config 	########
+
+# Conventiong naming of projects, useful to rename folders 
+# You have to write a pseudo-regex with some constants:
+# 	      [ GROUP, FIRSTN, NAME ]
+#
+# '^GROUP_NAME_NAME'		=> Project starts with GROUP (S2A for example) and contains two names.
+# '^GROUP_NAME(_NAME)*'	   	=> Project starts with GROUP and contains minimum one name.
+# '^TP_html_NAME_FIRSTN' 	=> name starts by 'TP_html_' and contains a name and firstname.
+projects_names: '^FIRSTN NAME'
+
+
+########	Generator config 	########
+
+# The file name for results which will be generated
+out: results
+
+# The type/format of the previous file => currently supported: [csv, html, xls]
+out_format:
+- csv
+- html
+
+# Ressources directory
+# (needed for html format)
+res_dir: res
+
+
+########	Reviser config		########
+
+# The type of project (<type>.yml must exists)
+type: Labyrinthe
+
+# Default timeout
+# shall be overriden in sorts
+timeout: 5
+
+
+########	Global config		########
+
+# Criteria you want for analysis
+# Can be overriden or declared in
+# project's config file
+#
+# Basics criteria, available in lib/helpers
+criteria:
+  - all_files
+  - src_files
+  - lines_count
+  - comments_count
+  - compile
+  - execute
+
+# Extensions you want to use, available in ext/
+extensions:
+  - memleaks
+
+
+# Options of all components
+# For the moment, there is just verbose option (for logger)
+options:
+  :verbose: true
+  :log_dir: logs
+  # mode of logger	=> [org, txt ...]
+  :log_mode: org

data/ext/html_validator.rb

@@ -0,0 +1,21 @@
+require 'html5_validator/validator'
+
+module Extensions
+	module HtmlValidator
+		include Helpers::CodeAnalysis
+		
+		def validate_html
+			validator = Html5Validator::Validator.new
+
+			results = {}
+			# Might need to take care of other extensions
+			sources.each do |f|
+				validator.validate_text File.read(f)
+				results.store f, validator.errors
+			end
+
+			results
+		end
+	end
+
+end

data/ext/valgrind.rb

@@ -0,0 +1,24 @@
+module Extensions
+	module Valgrind
+
+		include Helpers::Execution
+		include Helpers::System
+
+		VALGRIND_FILE = "valgrind.txt"
+
+		#
+		# Check memory leaks of the program
+		# The module uses execution value written in the config file of the project 
+		#
+		def memleaks
+			executable = find_executable
+			program = "#{Cfg[:program_prefix]}#{executable}"
+			param = Cfg.has_key?(:execution_value) ? Cfg[:execution_value].first : ''
+			cmd = "valgrind --leak-check=full --track-origins=yes --show-reachable=yes #{program} #{param}"
+			out = exec_with_timeout cmd
+			File.open(VALGRIND_FILE, 'w') { |f| f.write "$ #{cmd}\r#{out[:stdout]}\r#{out[:stderr]}" }
+			File.join(FileUtils.pwd, VALGRIND_FILE)
+		end
+
+	end
+end

data/labels.yml

@@ -0,0 +1,8 @@
+---
+all_files: Fichiers
+src_files: Fichiers sources
+lines_count: Nombre de lignes de code
+comments_count: Nombre de lignes de commentaires
+compile: Resultats compilation
+execute: Resultats execution
+memleaks: Fuites memoires

data/lang/C.yml

@@ -0,0 +1,22 @@
+---
+# C language
+
+# List of source files extensions
+extension:
+- .c
+- .h
+
+# Whether it's a compiled or an interpreted language
+compiled: true
+
+# Program prefix, needed especially for C
+# The execution command will look like this :
+# [execute_command=(java, ruby, python, ...)] [program_prefix]<program> [args]
+# [] are optionals, whereas <> mandatory
+program_prefix: ./
+
+# Fallback if no command is specified in project type
+default_build_command: gcc -ansi -pedantic -Wall -g *.c
+
+# Ruby regex to find C-style comments
+regex_comments: !ruby/regexp '/(\/\/(.*?)^)|(\/\*(.*?)\*\/)/m'

data/lang/HTML.yml

@@ -0,0 +1,49 @@
+---
+
+# HTML language
+
+# List of source files extensions
+# !!!!! Recent changes make me think
+# we should actually think about
+# renaming it to ext for instance !!!!!!!!
+
+# HTML
+
+# List of source files extensions
+extension:
+- .html
+
+# Whether it's a compiled or an interpreted language
+compiled: false
+
+#
+# In all HTML projects, we'll need
+# the html_validator extension
+#
+extensions:
+  html_validator:
+    :valid: Validite HTML 5
+
+# Program prefix, needed especially for C
+# The execution command will look like this :
+# [execute_command=(java, ruby, python, ...)] [program_prefix]<program> [args]
+# [] are optionals, whereas <> mandatory
+# program_prefix:
+
+# For interpreted languages
+# execute_command: ruby
+
+# If not specified, the first
+# executable file found will be executed
+# program_name: main.rb
+
+regex_comments: !ruby/regexp '/#([^{].*)$/'
+
+criteria:
+  - all_files
+  - src_files
+  - lines_count
+  - comments_count
+
+extensions:
+  - validate_html

data/lang/Java.yml

@@ -0,0 +1,15 @@
+---
+# Java language
+
+# List of source files extensions
+extension:
+- .java
+
+# Whether it's a compiled or an interpreted language
+compiled: true
+
+# Fallback if no command is specified in project type
+default_build_command: javac *.java
+
+# Ruby regex to find C-style comments
+regex_comments: !ruby/regexp '/(\/\/(.*?)^)|(\/\*(.*?)\*\/)/m'

data/lang/Ruby.yml

@@ -0,0 +1,26 @@
+---
+# Ruby language
+
+# List of source files extensions
+extension:
+- .rb
+
+# Whether it's a compiled or an interpreted language
+compiled: false
+
+# Program prefix, needed especially for C
+# The execution command will look like this :
+# [execute_command=(java, ruby, python, ...)] [program_prefix]<program> [args]
+# [] are optionals, whereas <> mandatory
+# program_prefix:
+
+# For interpreted languages
+execute_command: ruby
+
+# If not specified, the first
+# executable file found will be executed
+program_name: main.rb
+
+regex_comments: !ruby/regexp '/#([^{].*)$/'
+
+timeout: 1

data/lib/component.rb

@@ -0,0 +1,53 @@
+#
+# Author:: Renan Strauss
+#
+require 'yaml'
+require_relative 'loggers/logger'
+
+class Component
+	
+	# Each component has a logger (currently a txt file)
+	# $logger
+
+	#
+	# Don't forget to call super in your component's initializer !
+	# This method is all about : it stores the data from another
+	# component accordingly to what you told to Reviser, and
+	# creates a hash for child to easily access config file values
+	#
+	def initialize(data = nil)
+		@data = data
+		ext = options.has_key?(:log_mode) && options[:log_mode] || 'txt'
+		log_file = File.join(options.has_key?(:log_dir) && options[:log_dir] || '.', "#{ self.class.name.split('::').last || ''}.#{ext}")
+
+		# For now, we output to stderr if verbose option is not set
+		# In the future, it would be a good idea to always have logs,
+		# but to let the user change the level
+		@logger = Loggers::Logger.new(options[:verbose] && log_file || STDERR)
+	end 
+
+	# Place-holder
+	# Just like an abstract method
+	def run
+		raise NotImplementedError, 'All components must implement a run method'
+	end
+
+	# Method template
+	# So that when somebody implements a custom
+	# Component, he doesn't have to carry about
+	# logger being closed or not.
+	# Might be even more useful at some point
+	def work
+		data = run
+		@logger.close
+
+		data
+	end
+
+protected
+	#
+	# @return all options for all components if they exist in config file.
+	def options
+		(Cfg.has_key? :options) && Cfg[:options] || { :verbose => false }
+	end
+end

data/lib/components/archiver.rb

@@ -0,0 +1,118 @@
+require 'fileutils'
+require_relative 'extractors'
+
+
+module Components
+
+	# Manages uncompression of archive.
+	# Archiver extracts all data in a given compressed file.
+	#
+	# In case of the University of Lorraine,
+	# the archive contains all computing projects, compressed too.
+	#
+	# @example The simple way to extract a compressed file is :
+	#		Archiver.extract(myFile, myDirectory)
+	#
+	# @author	Yann Prono
+	#
+	class Archiver < Component
+
+		# methods for each different archive format
+		extend Extractors
+
+		# Ignored entries
+		$rejected = ['.','..']
+		
+		# Initialize archive file and the directory of destination.
+		def initialize(data)
+			super data
+			@src = Cfg[:src]
+			@destination = Cfg[:dest]
+			@results = []
+		end
+
+
+		# Check if the directory destination exists.
+		# else create it.
+		# For the moment, if the directory exists // TODO little input to confirm
+		# @param destination [String] the destination directory
+		#
+		def self.destination?(destination)
+			unless $rejected.include? File.basename destination
+				FileUtils.rm_rf(destination) if Dir.exists? destination
+				FileUtils.mkdir_p destination, :mode => 0700
+			end
+		end
+		
+
+		# Extract the archive into the destination directory.
+		# @param file_name 		[String] The name of the archive.
+		# @param destination 	[String] The destination directory.
+		#
+		def self.extract(file_name, destination = '.')
+			raise Errno::ENOENT unless File.exist? file_name
+
+			# Get extension of file_name to know which method calls
+			ext = File.extname(file_name)
+			ext = ext.delete('.')
+
+			# Raise exception if the format is unknown by Archiver
+			raise "Unknown format '#{r}'" unless respond_to?(ext)
+			# Check if destination exists
+			self::destination? destination
+
+			# Run extraction!
+			send(ext,file_name, destination)
+		end
+
+
+		# Method which extract an archive
+		# which contains all computing projects.
+		#
+		# This method extracts,in first time,the archive
+		# given in the constructor and after, all extracted files.
+		#
+		# Use this method in a global usage of Reviser!
+		# Options are for the moment :verbose
+		#
+		def run
+			@logger.h1 Logger::INFO,"First extraction - #{@src}"
+			# Extract the original archive
+			Archiver.extract(@src, @destination)
+
+			@logger.h1 Logger::INFO,'Extraction of sub archives'
+			
+			# Extract all sub archives
+			entries = Dir.entries(@destination) - $rejected
+			extracted = 0
+
+			entries.each do |entry|
+
+				ext = File.extname entry
+				basename = File.basename entry, ext
+				begin
+					file_name = File.join(@destination,File.basename(entry))
+					destination = File.join(@destination,basename)
+
+					# Run extraction!
+	  				Archiver.extract(file_name, destination)
+					extracted += 1
+
+					@logger.h2 Logger::INFO, "extracting #{file_name} to #{destination}"
+					@results << basename
+
+				# In case of it can't extract the file
+	  			rescue => e
+	  				@logger.h2 Logger::ERROR, "Can't extract #{entry}: #{e.message}"
+	  				puts e
+	  			end
+				# Delete in all case the archive (useless after this step				
+				FileUtils.rm_rf file_name
+	  		end
+	  		@logger.h1 Logger::INFO, "[#{extracted}/#{entries.size}] projects have been processed"
+
+			@results
+		end
+	end
+
+end

data/lib/components/checker.rb

@@ -0,0 +1,78 @@
+#
+# Author:: Renan Strauss
+#
+# The Checker is a component that wraps
+# all required tools to do the analysis.
+# It adapts itself dynamically
+# to the language Cfg.
+#
+#
+require 'open3'
+
+require_relative '../helpers/criteria'
+
+module Components
+	class Checker < Component
+		include Helpers::Criteria
+
+		def initialize(data)
+			super data
+
+			init_criteria_helper
+
+			@results = {}
+		end
+
+		# Yann : je ne recupere pas les datas de l'organiser,
+		# Je considere que tous les projets sont dans le dossier courant.
+		# TODO a voir si cela marche dans certains cas particuliers
+		def run
+			# We'll work in the dest directory
+			Dir.chdir Cfg[:dest] do
+				projects = Dir.entries('.') - ['.','..']
+				projects.each_with_index do |proj, i| 
+					puts "\t[#{i+1}/#{projects.size}]\t#{proj}"
+					Dir.chdir(proj) { check proj }
+				end
+			end
+
+			@results
+		end
+
+	private
+
+		#
+		# Being called in the project's directory,
+		# this methods maps all the criterias to
+		# their analysis value
+		#
+		def check(proj)		
+			# Init results
+			@results[proj] = {}
+			
+			# for each method asked by user with its label
+			@output.each do |meth, label|
+				if @criteria.has_key? meth
+					@results[proj][label] = call meth 
+				else
+					@logger.h1(Logger::ERROR, "Unknown method '#{meth}'' for project #{proj}")
+				end
+			end
+		end
+
+		#
+		# This method is what would be the constructor
+		# of criteria_helper if it was a class
+		#
+		def init_criteria_helper
+			@criteria = Hash.new
+			@output = Hash.new
+			@logger.h1 Logger::INFO, "Loading modules"
+			load PWD, '../helpers/*'
+			load EXT, '*'
+			@logger.h1 Logger::INFO, "Loading labels"
+			[:criteria, :extensions].each { |x| load_labels x }
+		end
+
+	end
+end

data/lib/components/extractors.rb

@@ -0,0 +1,139 @@
+require 'rubygems'
+require 'fileutils'
+
+module Components
+
+	# The module contains all methods to extract an archive
+	# regardless the format.
+	#
+	# Convention over configuration !
+	#
+	# To add a new format, maybe you need to install the a gem.
+	# Find your  gem which uncompress a specified format on rubygems.org.
+	# Add the line "gem <gem>" in the Gemfile and execute "bundle install"
+	#
+	# Now, you can write the method corresponding to the format.
+	# The name of the method corresponds to the format.
+	# For example, if you want to use 'rar' format, the name of the method will be: "rar"
+	# Don't forget to require the gem: "require <gem>" at the beginning of the method!
+	# the header of method looks like the following block:
+	#
+	#  		def <format> (archive, destination)
+	# 			require <gem>
+	# 			...
+	# 		end
+	#
+	# @author 	Anthony Cerf
+	# @author 	Yann Prono
+	#
+	module Extractors	
+
+		# Method which unzip a file.
+		# @param zip_file 		[String] the zip file.
+		# @param destination 	[String] Destination of extracted data.
+		def zip zip_file, destination
+			require 'zip'
+			# Cfg the gem
+			Zip.on_exists_proc = true
+			Zip.continue_on_exists_proc = true
+
+			Zip::File.open(zip_file) do |archive|
+				#Entry = file or directory
+				archive.each do |entry|
+	  				#Create filepath
+	 				filepath = File.join(destination, entry.name)
+
+		  			# Check if it doesn't exist because of directories (overwrite)
+					unless File.exist?(filepath)
+						# Create directories to access file
+						FileUtils.mkdir_p(File.dirname(filepath))
+						entry.extract(filepath)
+					end
+	  			end
+			end
+		end
+		
+		# Method which ungz a file.
+		# @param gz_file 		[String] the gz file.
+		# @param destination 	[String] Destination of extracted data.
+		def gz gz_file, destination
+			require 'zlib'
+			file = Zlib::GzipReader.open(gz_file)
+			unzipped = StringIO.new(file.read)
+			file.close
+			tar(unzipped, destination)
+		end
+
+		# Alias for format shortcut
+		# CC Dominique Colnet!
+		alias :tgz :gz 
+	    
+	    # Method which untar a tarfile.
+		# @param tar_file 		[String] the tar file.
+		# @param destination 	[String] Destination of extracted data.
+		def tar tar_file, destination
+			require 'rubygems/package'
+	    	# test if src is String (filename) or IO stream
+			if tar_file.is_a? String
+				stream = File.open(tar_file)
+			else
+				stream = tar_file
+			end
+
+	    	Gem::Package::TarReader.new(stream) do |tar|
+		        tar.each do |tarfile|
+		          	destination_file = File.join destination, tarfile.full_name
+		          	if tarfile.directory?
+		            	FileUtils.mkdir_p destination_file
+					else
+			            destination_directory = File.dirname(destination_file)
+			            FileUtils.mkdir_p destination_directory unless File.directory?(destination_directory)
+			            File.open destination_file, 'wb' do |f|
+			              	f.print tarfile.read
+			          	end
+		     		end
+		     		tarfile.close unless tarfile.closed?
+		  		end
+		  		tar.close
+	  		end
+	  		stream.close
+		end
+
+		# Method which unrar a rar file, if it is possible (proprietary format grr ...)
+		# @param rar_file 		[String] the rar file.
+		# @param destination 	[String] Destination of extracted data.
+		def rar rar_file, destination
+			require 'shellwords'
+	 		`which unrar`
+	 		if $?.success?
+	 			src = Shellwords.escape(rar_file)
+	 			destination = Shellwords.escape(destination)
+	 			`unrar e #{src} #{destination}`
+			else
+				puts 'Please install unrar : sudo apt-get install unrar'
+			end
+		end
+
+		# Method which un7zip a 7zip file.
+		# @param seven_zip_file	[String] the 7zip file.
+		# @param destination 	[String] Destination of extracted data.
+		def seven_zip seven_zip_file, destination
+			require 'seven_zip_ruby'
+			File.open(seven_zip_file, 'rb') do |file|
+	  			SevenZipRuby::Reader.open(file) do |szr|
+	    			szr.extract_all destination
+	  			end
+			end
+		end
+
+		# Use first of all for seven zip format (little tip, can't call it directly).
+		def method_missing(m, *args, &block)
+	    	if (ext = File.extname(args[0]).delete('.') == '7z')
+	    		seven_zip(args[0], args[1])
+	    	else 
+	    		raise "Format '#{ext.delete('.')}' not supported"
+	    	end
+	  	end
+
+	end
+end