reviser 0.0.1.1.pre.beta

data/lib/helpers/criteria.rb

@@ -0,0 +1,186 @@
+require_relative '../config'
+
+# Manage criteria and labels.
+
+# @example Call a criterion (in the config File):
+#   criteria:
+#     - :count_lines: Number of lines
+#     - :list_files: List of all files
+#     - :<method>: <label of method>
+#
+# @author Yann Prono
+# @author Renan Strauss
+#
+module Helpers
+	# This module enables to 
+	# imports automaticlly all modules for the analysis
+	#
+	# Convention over configuration !
+	# A analysis module contains the word 'tool' in its filename.
+	# You also have the possibility to put code in the ext folder.
+	#
+	# @example Call a criterion during analysis (in the config File):
+	#   criteria:
+	#     - :count_lines
+	#     - :list_files
+	#     - :<method>: <custom label>
+	#
+	# In the last item of the list, the custom label will overwrite the label 
+	# in labels.yml if it exist.
+	# 
+	module Criteria
+		
+		# Where I am ?	
+		PWD = File.dirname __FILE__
+		# Path of extensions
+		EXT = File.join File.dirname(File.dirname(PWD)), 'ext'
+
+		attr_reader :criteria
+		attr_reader :output
+
+		# All criterias available.
+		# :criterion => Name of the module
+		@criteria
+
+		# :criterion => label of criterion
+		@output
+
+		# Enable to call a specified method.
+		# @param meth [String] Method to call.
+		# @return results of the method.
+		def call meth
+			if @criteria.key? meth
+				@logger.h1(Logger::INFO, "Include methods of #{@criteria[meth]}") unless respond_to? meth
+				self.class.send(:include, @criteria[meth]) unless respond_to? meth
+
+				send meth 
+			else
+				nil
+			end
+		end
+
+
+	protected
+
+		# Get all criteria which can be used.
+		# @return [Array] all criteria
+		def all
+			@criteria.keys.map &:to_sym
+		end
+
+		#  from Cfg file to symbols
+		# @param criterion The criteria
+		# @param module_name The name of the module.
+		def populate criterion, module_name
+			raise "Criterion '#{criterion}' is already defined in #{@criteria[criterion.to_sym]} (#{criterion}/#{module_name}).\nPlease change the name of the method in one of modules." if @criteria.has_key? criterion.to_sym
+			@criteria[criterion.to_sym] = module_name
+		end
+
+		# Load all of modules available for the analysis
+		# @param directory Directory where search of modules is done.
+		# @param regex regex to find name of modules.
+		def load directory, regex = '*'
+			@logger.h2 Logger::INFO, "Modules of #{directory}"
+			modules =  Dir[File.join(directory, regex)]
+
+			namespace = directory == EXT && 'Extensions' || 'Helpers'
+			modules.each do |m|
+				next if m =~ /(criteria)/
+
+				require_relative m
+				ext = File.extname m
+				module_name = Object.const_get "#{namespace}::#{camelize(File.basename(m,ext))}", false
+				@logger.h3 Logger::INFO, "Load #{module_name}"
+				methods = module_name.instance_methods false
+				methods.each { |method| populate(method, module_name) }
+	 		end	
+	 	end
+
+		# Gets the name of module 
+		# @param file_module Name of the file module.
+		def camelize file_module
+			file_module.split('_').each {|s| s.capitalize! }.join('')
+		end
+
+		# Load labels given by the user.
+		# If the label doesn't exist, it will created with the name of the method.
+		# @param key Key of criteria in config file
+		def load_labels key
+			labels = Labels.load
+
+			if Cfg.has_key?(key) && Cfg[key].respond_to?('each')
+				Cfg[key].each do |meth|
+					if meth.respond_to?('each') && meth.respond_to?('[]')
+						label =  meth[meth.keys[0]]
+						@logger.h2(Logger::ERROR, "Undefined label for #{meth.keys[0]}, check your config file") if label == nil
+						label = create_label(meth.keys[0]) if label == nil
+						@output[meth.keys[0].to_sym] = label
+					else
+						label = (labels.respond_to?('[]') && labels.key?(meth.to_sym)) ? labels[meth.to_sym] : create_label(meth)
+						@output[meth.to_sym] = label
+					end
+				end
+			end
+		end
+
+		# Create label for a method.
+		# @param meth [String] method linked to the label
+		# @return [String] Renamed Label inspired of the name of the method
+		def create_label meth
+			@logger.h2 Logger::ERROR, "Create label for #{meth}. You should custom your label (see 'reviser add')"
+			meth.to_s.split('_').each {|s| s.capitalize! }.join(' ')
+		end
+	end
+
+
+	# Manage all actions for adding, updating or getting labels of Reviser.
+	# A label is a a group of words, describing the associated criterion (method).
+	#
+	# @example  
+	#  	criterion => label
+	# 	all_files => all files of project
+	#
+	# known Labels are in the labels.yml file.
+	#
+	# @author Yann Prono
+	class Labels
+
+		# Current directory of this file
+		PWD = File.dirname __FILE__
+
+		# Path of label.yml file
+		LABELS = File.join(File.dirname(File.dirname(PWD)), 'labels.yml')
+
+		#
+		# Enable to associate a label to a criterion (method).
+		# The label will be saved in the 'labels.yml' file
+		# @param meth Method to link.
+		# @param label Label to link with the method.
+	    def self.add meth, label
+	    	res = "Create"
+			labels = YAML.load File.open(LABELS)
+			if labels.respond_to? '[]'
+				res = "Update" if labels.key? meth
+				labels[meth] = label
+				File.open(LABELS, 'w') { |f| f.write labels.to_yaml }
+			end
+			res
+		end
+
+		# @return Hash all known labels by reviser.
+		# :criterion => label
+		def self.load
+			Labels.populate(YAML.load(File.open(LABELS)))
+		end
+
+		def self.populate hash
+			labels = {}
+			if hash.respond_to?('each')
+				hash.each do |meth, label|
+					labels[meth.to_sym] = label
+				end
+			end
+			labels
+		end
+  	end
+end

data/lib/helpers/execution.rb

@@ -0,0 +1,83 @@
+#
+# @Author Renan Strauss
+#
+# Needed stuff for Checker
+# when it comes to executing
+# both compiled and interpreted
+# languages
+#
+
+require 'timeout'
+
+module Helpers
+	module Execution
+		#
+		# Determines how to execute the program
+		# thanks to Cfg, then returns its exec
+		# status(es)
+		#
+		def execute
+			outputs = []
+			if  Cfg.has_key? :execution_value
+				if Cfg[:execution_value].respond_to? 'each'
+					Cfg[:execution_value].each do |v|
+						outputs << exec(v)
+					end
+				else
+					if Cfg.has_key? :execution_count
+						outputs[Cfg[:execution_value]] = []
+						Cfg[:execution_count].times do
+							outputs << exec(Cfg[:execution_value])
+						end
+					else
+						outputs << exec(Cfg[:execution_value])
+					end
+				end
+			else
+					if Cfg.has_key? :execution_count
+						Cfg[:execution_count].times do
+							outputs << exec
+						end
+					else
+						return exec
+					end
+			end
+
+			outputs.join("\r")
+		end
+
+	private
+
+		#
+		# The method that actually
+		# executes the program.
+		# If no program name is specified
+		# in the Cfg, it executes the
+		# first executable found.
+		# It helps with C (a.out) when no 
+		# Makefile is avalaible, but it
+		# might not be a good idea regarding
+		# security
+		#
+		def exec(param = nil)
+			program = (Cfg.has_key? :program_name) && Cfg[:program_name] || find_executable
+
+			return 'Program not found' unless program != nil
+
+			program = "#{Cfg[:program_prefix]}#{program}"
+			argument = (param == nil) && '' || param
+
+			cmd = "#{(Cfg.has_key? :execute_command) && Cfg[:execute_command] || ''} #{program} #{argument}"
+			out = exec_with_timeout cmd
+			
+			"$ #{cmd}\r#{out[:stdout]}\r#{out[:stderr]}"
+		end
+
+		#
+		# @return the first executable found
+		#
+		def find_executable
+			Dir.glob('*').select {|f| File.executable?(f) && !File.directory?(f)}.first
+		end
+	end
+end

data/lib/helpers/git.rb

@@ -0,0 +1,37 @@
+# Class which organizes all directories for use them with git.
+# Its another component of the project
+#
+# @author Romain Ruez
+# @author Anthony Cerf
+#
+require 'git'
+
+module Helpers
+	module Git
+		# method which initialize a git repository
+		def git_init
+			@git = ::Git.init
+		end
+
+		# method which allows the user to add something on the repository
+		def git_add
+			@git.add(:all=>true)
+		end
+
+		# method for displaying a message when the repository is configured
+		def git_commit
+			@git.commit_all('initialization of git repertory')		 
+		end
+
+		def git_push
+			@git.push
+		end
+
+		# method which allows the user to see the differences between two last commits
+		# I have to know the current commit and the last but how ?
+		# and do a diff between these 2 commits.
+		def git_diff
+
+		end
+	end
+end

data/lib/helpers/project.rb

@@ -0,0 +1,39 @@
+#
+# Provide important methods
+# for compilation or something like that.
+#
+# @author Renan Strauss
+# @author Yann Prono
+#
+module Helpers
+	module Project
+		#
+		# For interpreted languages
+		# We only check for missing files
+		#
+		def prepare
+			missing_files.empty? && 'None' || res
+		end
+
+		# Check if the project has all files needed
+		def missing_files
+			return [] unless Cfg =~ :required_files
+
+			dir = Dir['*']
+
+			#
+			# Check if there is any regexp
+			# If it's the case, if any file
+			# matches, we delete the entry
+			# for diff to work properly
+			#
+			Cfg[:required_files].each_with_index do |e, i|
+				if dir.any? { |f| (e.respond_to?(:match)) && (e =~ f) }
+					Cfg[:required_files].delete_at i
+				end
+			end
+
+			Cfg[:required_files] - dir
+		end
+	end
+end

data/lib/helpers/system.rb

@@ -0,0 +1,56 @@
+#
+# @author Renan Strauss
+#
+
+module Helpers
+	module System
+		#
+		# Executes the given command
+		# and kills it if its execution
+		# time > timeout
+		# @returns stdout, stderr & process_status
+		#
+		def exec_with_timeout(cmd, timeout = Cfg[:timeout])
+			stdin, stdout, stderr, wait_thr = Open3.popen3(cmd)
+			process_status = -1
+
+			stdin.close
+			#
+			# We try to wait for the thread to join
+			# during the given timeout.
+			# When the thread has joined, process_status
+			# will be an object, so we can check and
+			# return at the end if it failed to complete
+			# before time runs out.
+			#
+			begin
+				Timeout.timeout(timeout) do
+					process_status = wait_thr.value
+				end
+			rescue Timeout::Error
+				#
+				# Then whether it suceeded or not,
+				# we kill the process
+				#
+				begin
+					Process.kill('KILL', wait_thr[:pid])
+				rescue Object => e
+					$stderr << "Unable to kill process : #{e.to_s}"
+				end
+			end
+
+			result = {
+				:stdout => process_status == -1 && 'Timeout' || stdout.read,
+				:stderr => process_status == -1 && 'Timeout' || stderr.read,
+				:process_status => process_status == -1 && 'Timeout' || process_status
+			}
+			
+			result.delete :process_status unless process_status != -1
+
+			stdout.close
+			stderr.close
+
+			result
+		end
+	end
+end

data/lib/loggers/logger.rb

@@ -0,0 +1,41 @@
+require 'logger'
+require_relative 'modes'
+
+# Custom logger of Reviser.
+# This class is a adapter.
+# We used the standard Logger included in Ruby.
+#
+# @author Yann Prono
+#
+module Loggers
+	class Logger
+
+		# Create logger.
+		# The extension determines the mode to use (logger mode).
+		# @filename
+		def initialize filename
+
+			ext = File.extname(filename).delete '.'
+			# Include mode aksed by user (config file)
+			begin
+				self.class.send :include, Modes.const_get("#{ext.downcase.capitalize}")
+			rescue => e
+				self.class.send :include, Modes::Txt
+			end
+
+			@logger = ::Logger.new filename
+			@logger.level = ::Logger::DEBUG
+	  	end
+
+	  	# Close the logger
+	  	def close
+	  		@logger.close
+	  	end
+
+	  	# In case of someone want to use methods of standard Logger ...
+	  	def method_missing(m, *args, &block)
+				@logger.send(m,*args, &block)
+	  	end
+
+	end
+end

data/lib/loggers/modes.rb

@@ -0,0 +1,74 @@
+require 'logger'
+
+#
+# Modules containing all methods to custom logger.
+# 
+# There are 3 main level of logger (as in HTML)
+# => h1
+# => h2
+# => h3
+
+# @author Yann Prono
+# @author Anthony Cerf
+module Loggers
+	module Modes
+
+		module Txt
+
+			include Modes
+
+			def h1 severity, msg
+				change_formatter ''
+				@logger.add severity, msg
+			end
+
+			def h2 severity, msg
+				change_formatter "\t\t"
+				@logger.add severity, msg
+			end
+
+			def h3 severity, msg
+				change_formatter "\t\t\t"
+				@logger.add severity, msg
+			end
+		end
+
+		module Org
+
+			include Modes
+			
+			def h1 severity, msg
+				change_formatter '*'
+				@logger.add severity, msg
+			end
+
+			def h2 severity, msg
+				change_formatter "**"
+				@logger.add severity, msg
+			end
+
+			def h3 severity, msg
+				change_formatter "***"
+				@logger.add severity, msg
+			end
+
+		end
+
+		# Change formatter
+		# @param prefix Prefix to put before all content
+		def change_formatter prefix
+			@logger.formatter = proc do |severity, datetime, progname, msg|
+				"\n#{prefix} #{severity} #{msg}"
+			end
+		end
+
+		# Create new line
+		def newline
+			@logger.formatter = proc do |severity, datetime, progname, msg|
+				"\n#{msg}"
+			end
+			@logger.add(nil,"\n")
+		end
+
+	end
+end

data/lib/project.rb

@@ -0,0 +1,155 @@
+# This modules is used to scan the name of project
+# in order to get all students who worked.
+# This analysis uses regex of convention given by teachers (config file).
+#
+# @author Yann Prono
+#
+module Project
+
+	# Dictionnary for regex in config file
+	SYMBOLS = {
+		:group 		=> 'GROUP',
+		:firstname 	=> 'FIRSTN',
+		:name 		=> 'NAME',
+		:user		=> 'USER',
+		:lambda		=> 'LAMBDA'
+	}
+
+	# Regex to associate, depending the used word in Cfg
+	REGEX = {
+		:group 		=> '([A-Za-z0-9]+)',
+		:firstname 	=> '([A-Za-z\-]+)',
+		:name 		=> '([A-Za-z]+)',
+		:user 		=> '([^_]*)',
+		:lambda 	=> '[a-zA-Z0-9 _]*'
+	}
+
+
+	# Get formatter written in the config file
+	# and count occurences of each word in the dictionnary SYMBOLS.
+	# @return [Hash] sym => count.
+	#
+	def analyze_formatter
+		regex = Cfg[:projects_names]
+		# Foreach known symbols
+		SYMBOLS.each do |k, _|
+			# Get numbers of occurences of the word k in regex 
+			matches = regex.scan(SYMBOLS[k]).size
+			# the word K => number of occurences
+			@count_patterns[k] = matches if matches > 0
+		end
+	end
+
+
+	# Analyze et get all informations 
+	# that could be useful in the name of the
+	# directory project.
+	# @param entry [String] name of directory to analysis.
+	#
+	def format entry
+		ext = File.extname entry
+		entry = File.basename entry, ext
+
+		analyze_formatter if @count_patterns.empty?
+
+    	group = check_entry_name entry
+		generate_label group
+	end
+
+
+	# Generate new name of project.
+	# @param infos [Hash] All informations used for generate a name for the directory.
+	# @return [String] the formatted name for directory project
+	#
+	def generate_label infos
+    unless infos.empty?
+      label = ''
+      infos.reject { |k| k == :group }.each { |_, v|
+        if v.respond_to?('each')
+          v.each { |data|
+            label += data +' ' }
+        else
+          label += v + ' '
+        end
+      }
+      # Inject group of project before name : group/name
+      label = infos.key?(:group) && File.join(infos[:group], label) || label
+      label
+    end
+	end
+
+	# I'm not pround of this method ...
+	# associate to a symbol, his position in the regex
+	# @example NAME_FIRSTN
+	# will give : {
+	#	1 => :name,
+	#	2 => :firstname
+	#}
+	def get_position regex
+		res = {}
+		SYMBOLS.each do |k,v|
+			regex.scan(v) do |_|
+				res[$~.offset(0)[0]] = k
+			end
+		end
+
+		res = (res.sort_by { |k, _| k }).to_h
+		tmp = {}
+
+		index = 1
+		res.each do |_,v|
+			tmp[index] = v
+			index += 1
+		end
+		tmp
+	end
+
+
+	# Apply regex of user on the entry name
+	# and try to get all interested matched values.
+	def check_entry_name entry
+		regex = Cfg[:projects_names]
+		# who work on the current project (entry) ?
+		position = get_position regex
+
+		@count_patterns.each do |k, _|
+			regex = regex.gsub SYMBOLS[k], REGEX[k]
+		end
+		
+		# Apply created regex
+		entry.match Regexp.new(regex)
+		pos = 1
+		infos = {}		
+
+		# Get matched values
+		begin
+			tmp = eval "$#{pos}"
+			if tmp != nil && tmp != ''
+				tmp = tmp.delete '_'
+				infos.has_key?(position[pos]) && infos[position[pos]] << tmp || infos[position[pos]] = [tmp]
+			else
+				ask entry
+			end
+			pos += 1
+		end while pos <= position.size
+				
+		sort_infos infos
+		infos
+	end
+
+
+	# Put all datas found in respective variables (students, groups, teams ...).
+	# @param infos [Hash] Informations found by regex.
+	def sort_infos infos
+		infos[:name].respond_to?('each') && infos[:name].each { |n| @students << n } || @students << infos[:name]
+		infos[:group] = infos[:group][0].upcase if infos.key? :group
+		@groups << infos[:group] if infos.has_key?(:group) && !@groups.include?(infos[:group])
+		@binoms << infos[:name]
+	end
+
+
+	def ask entry
+		# TODO, ask to user if the entry is correctly written
+	end
+
+end