liri 0.3.1 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b30998dd0b5a8393fd498a7e860a9d7f3a3c61b6b55c7c06d832aa83a5104482
-  data.tar.gz: 41a2b382eb25a400529b236ddba38e81c1ea01cf81bc184e0b8615e66f33657e
+  metadata.gz: d28f136456100f5326e4434296950754e7ec7246504de6152ae0941e3955dc35
+  data.tar.gz: b91ee07874e27b8dce462a593c8cde523da893355fd1fcbf12a362e0903af306
 SHA512:
-  metadata.gz: e4d65b549bc22186954fad36d3d96715335e7513f5aab7e9f429afc657f9945da0be95c20ccb320ca6c213b54bb1e96d58caa1136ae056ba477583c198988cdb
-  data.tar.gz: d421828fefa0c2ef94eaccb857e7095d35d27ffadfafcebe817134cfb4b0e9f93fd4333daf834e46ef03e289f95af2218dbbd2aae194dcca7c25bb0bdc587b75
+  metadata.gz: b42a37864b77d875ae48576a54199f244326d2b2132bcbebc35412f19a805634ac65aca61d3dd172c40c6c21eeea21059b97288af979abb65aed1d4c87ee69a1
+  data.tar.gz: 575c5765c9aa4a2f558a6ee2a33b1559babb85c3ca5849aaa32f93ea65f98b647893683680a96658f2947baebdf2ff86de015235e2b94feba4b1788b89983491

data/.gitignore

@@ -5,9 +5,9 @@
 /tmp
 
 *.log
-*.gem
 .rspec_status
 
 *.odt#
 
-spec_credentials.yml
+spec_credentials.yml
+*.gem

data/Gemfile.lock

@@ -1,15 +1,15 @@
 PATH
   remote: .
   specs:
-    liri (0.3.1)
+    liri (0.4.0)
+      chronic_duration (~> 0)
       commander (~> 4)
       highline (~> 2)
-      i18n (~> 1)
       net-scp (~> 3)
       ruby-progressbar (~> 1)
       rubyzip (~> 2)
       terminal-table (~> 3)
-      to_duration (~> 1)
+      tty-progressbar (~> 0)
 
 GEM
   remote: https://rubygems.org/
@@ -21,12 +21,13 @@ GEM
       descendants_tracker (~> 0.0.4)
       ice_nine (~> 0.11.0)
       thread_safe (~> 0.3, >= 0.3.1)
+    chronic_duration (0.10.6)
+      numerizer (~> 0.1.1)
     coderay (1.1.3)
     coercible (1.0.0)
       descendants_tracker (~> 0.0.1)
     commander (4.6.0)
       highline (~> 2.0.0)
-    concurrent-ruby (1.1.9)
     descendants_tracker (0.0.4)
       thread_safe (~> 0.3, >= 0.3.1)
     diff-lcs (1.4.4)
@@ -43,8 +44,6 @@ GEM
       ruby_parser (~> 3.1, > 3.1.0)
       sexp_processor (~> 4.8)
     highline (2.0.3)
-    i18n (1.10.0)
-      concurrent-ruby (~> 1.0)
     ice_nine (0.11.2)
     kwalify (0.7.2)
     launchy (2.5.0)
@@ -52,6 +51,7 @@ GEM
     net-scp (3.0.0)
       net-ssh (>= 2.6.5, < 7.0.0)
     net-ssh (6.1.0)
+    numerizer (0.1.1)
     parallel (1.22.1)
     parser (3.1.2.0)
       ast (~> 2.4.1)
@@ -111,10 +111,17 @@ GEM
       simplecov_json_formatter (~> 0.1)
     simplecov-html (0.12.3)
     simplecov_json_formatter (0.1.4)
+    strings-ansi (0.2.0)
     terminal-table (3.0.2)
       unicode-display_width (>= 1.1.1, < 3)
     thread_safe (0.3.6)
-    to_duration (1.2.1)
+    tty-cursor (0.7.1)
+    tty-progressbar (0.18.2)
+      strings-ansi (~> 0.2)
+      tty-cursor (~> 0.7)
+      tty-screen (~> 0.8)
+      unicode-display_width (>= 1.6, < 3.0)
+    tty-screen (0.8.1)
     tty-which (0.4.2)
     unicode-display_width (2.1.0)
     virtus (1.0.5)

data/Rakefile

@@ -47,6 +47,11 @@ task :install => [:build, :update_agent_installer, :compress_agent_installer] do
   system "gem install " + Liri::NAME + "-" + Liri::VERSION + ".gem"
 end
 
+# Borra la gema despues de llamar a la tarea install
+Rake::Task[:install].enhance do
+  Rake::Task[:clean].invoke
+end
+
 # Publica la gema después de compilar.
 # > rake publish
 task :publish => :build do

data/lib/agent/agent.rb

@@ -16,39 +16,39 @@ module Liri
         agent_folder_path = setup_manager.agent_folder_path
 
         Liri.set_logger(setup_manager.logs_folder_path, 'liriagent.log')
-        Liri.logger.info("Agent process started")
+        Liri.logger.info("Agent process started", true)
         Liri.logger.info("Press Ctrl + c to finish Agent process manually\n", true)
 
-        decompressed_source_code_path = File.join(agent_folder_path, '/', Common::SourceCode::DECOMPRESSED_FOLDER_NAME)
-        source_code = Common::SourceCode.new(decompressed_source_code_path, agent_folder_path, Liri.compression_class, Liri.unit_test_class)
-        runner = Agent::Runner.new(Liri.unit_test_class, source_code.decompressed_file_folder_path)
-        tests_result = Common::TestsResult.new(agent_folder_path)
-        agent = Agent.new(Liri.udp_port, Liri.tcp_port, source_code, runner, tests_result, agent_folder_path)
+        agent = Agent.new(Liri.udp_port, Liri.tcp_port, agent_folder_path)
         threads = []
         threads << agent.start_server_socket_to_process_manager_connection_request # Esperar y procesar la petición de conexión del Manager
 
-        Liri.init_exit(stop, threads, 'Agent')
-        Liri.logger.info("Agent process finished")
-      rescue SignalException => e
-        Liri.logger.info("Exception(#{e}) Agent process finished manually")
-        Liri.kill(threads)
+        Liri.init_exit(stop, threads)
+      rescue SignalException
+        Liri.logger.info("Agent process finished manually", true)
+      rescue InxiCommandNotFoundError => e
+        Liri.logger.error("Exception(#{e}) Please, install inxi in your operating system", true)
+      ensure
+        # Siempre se ejecutan estos comandos, haya o no excepción
+        Liri.kill(threads) if threads && threads.any?
+        Liri.logger.info("Agent process finished", true)
       end
     end
 
-    def initialize(udp_port, tcp_port, source_code, runner, tests_result, agent_folder_path)
+    def initialize(udp_port, tcp_port, agent_folder_path)
       @udp_port = udp_port
       @udp_socket = UDPSocket.new
       @tcp_port = tcp_port
 
-      @source_code = source_code
-      @runner = runner
-      @tests_result = tests_result
-
       @all_tests = {}
 
       @managers = {}
 
       @agent_folder_path = agent_folder_path
+
+      @processing = true
+
+      @hardware_specs = hardware_specs
     end
 
     # Inicia un servidor udp que se mantiene en espera de la primera petición de conexión del Manager
@@ -60,15 +60,17 @@ module Liri
         begin
           @udp_socket.bind('0.0.0.0', @udp_port)
         rescue Errno::EADDRINUSE => e
-          Liri.logger.error("Exception(#{e}) Busy UDP port #{@udp_port}")
+          Liri.logger.error("Exception(#{e}) Busy UDP port #{@udp_port}", true)
           Thread.exit
         end
         Liri.logger.info("Waiting managers request in UDP port #{@udp_port}")
 
-        loop do
+        while @processing
           @manager_request = @udp_socket.recvfrom(1024)
           manager_ip_address = @manager_request.last.last
           manager_data = get_manager_data(JSON.parse(@manager_request.first))
+          # TODO: El cliente TCP debería inicicarse en otro hilo, de este modo se tendrá un cliente TCP para cada Manager
+          # y se evita que un mismo cliente procese la ejecución de varios Manager
           process_manager_connection_request(manager_ip_address, manager_data)
         end
       end
@@ -78,7 +80,13 @@ module Liri
     def start_client_socket_to_process_tests(manager_ip_address, manager_data)
       tcp_socket = TCPSocket.open(manager_ip_address, @tcp_port)
       agent_ip_address = tcp_socket.addr[2]
-      tcp_socket.puts({ msg: 'get_source_code', hardware_model: get_hardware_model }.to_json)
+      tcp_socket.puts({ msg: 'get_source_code', hardware_specs: @hardware_specs }.to_json)
+
+      # Las siguientes variables se usan para guardar momentaneamente los resultados mientras se hace un chequeo de que
+      # el Manager siga ejecutandose o que ya no haya procesado los mismos tests ya ejecutados por otro agente
+      tests_result_file_name = ""
+      tests_result_file_path = ""
+      tests_result = {}
 
       while line = tcp_socket.gets
         tcp_socket_data = JSON.parse(line.chop)
@@ -89,6 +97,7 @@ module Liri
         end
 
         if msg == 'proceed_get_source_code'
+          init_work_folders(manager_ip_address)
           result = get_source_code(manager_ip_address, manager_data)
           tcp_socket.puts({ msg: result }.to_json)
         end
@@ -96,32 +105,35 @@ module Liri
         if msg == 'process_tests'
           tests_batch = tcp_socket_data
           tests = get_tests(tests_batch, manager_ip_address)
-          raw_tests_result = @runner.run_tests(tests)
-          tests_batch_number = tests_batch['tests_batch_number']
-          tests_result_file_name = @tests_result.build_file_name(agent_ip_address, tests_batch_number)
-          tests_result_file_path = @tests_result.save(tests_result_file_name, raw_tests_result)
 
+          compressed_file_folder_path = @managers[manager_ip_address][:compressed_file_folder_path]
+          decompressed_file_folder_path = @managers[manager_ip_address][:decompressed_file_folder_path]
+
+          runner = Agent::Runner.new(Liri.unit_test_class, decompressed_file_folder_path)
+          raw_tests_result = runner.run_tests(tests)
+          batch_num = tests_batch['batch_num']
+          tests_result = Common::TestsResult.new(compressed_file_folder_path)
+          tests_result_file_name = tests_result.build_file_name(agent_ip_address, batch_num)
+          tests_result_file_path = tests_result.save(tests_result_file_name, raw_tests_result)
+          # TODO No se debería enviar el resultado si otro agente ya lo procesó, porque osinó reemplazaría el archivo de resultados
+          # ya procesado. ACTUALIZACION: Puede que esto ya se haya arreglado
           send_tests_results_file(manager_ip_address, manager_data, tests_result_file_path)
-          result = { msg: 'processed_tests', tests_batch_number: tests_batch_number, tests_result_file_name: tests_result_file_name, tests_batch_keys_size: tests_batch['tests_batch_keys'].size}
-          tcp_socket.puts(result.to_json) # Envía el número de lote y el nombre del archivo de resultados.
+          tests_result = { msg: 'processed_tests', batch_num: batch_num, tests_result_file_name: tests_result_file_name}
+          tcp_socket.puts(tests_result.to_json) # Envía el número de lote y el nombre del archivo de resultados.
         end
       end
 
-      Liri.logger.info("Finish connection with Manager #{manager_ip_address} in TCP port: #{@tcp_port}")
       tcp_socket.close
-      Liri.clean_folder_content(@agent_folder_path)
-
       unregister_manager(manager_ip_address)
     rescue Errno::EADDRINUSE => e
       Liri.logger.error("Exception(#{e}) Busy UDP port #{@udp_port}")
+      @processing = false
     rescue Errno::ECONNRESET => e
       tcp_socket.close
-      Liri.logger.error("Exception(#{e}) Closed connection in TCP port #{@tcp_port}")
-      Liri.logger.info("Finish connection with Manager #{manager_ip_address} in TCP port: #{@tcp_port}")
+      Liri.logger.error("Exception(#{e}) Closed connection in TCP port #{@tcp_port}", true)
       unregister_manager(manager_ip_address)
     rescue Errno::ECONNREFUSED => e
-      Liri.logger.error("Exception(#{e}) Rejected connection in TCP port #{@tcp_port}")
-      Liri.logger.info("Finish connection with Manager #{manager_ip_address} in TCP port: #{@tcp_port}")
+      Liri.logger.error("Exception(#{e}) Rejected connection in TCP port #{@tcp_port}", true)
       unregister_manager(manager_ip_address)
     end
 
@@ -140,25 +152,29 @@ module Liri
 
     def get_source_code(manager_ip_address, manager_data)
       puts ''
+      compressed_file_folder_path = @managers[manager_ip_address][:compressed_file_folder_path]
+      decompressed_file_folder_path = @managers[manager_ip_address][:decompressed_file_folder_path]
+      source_code = Liri::Common::SourceCode.new(decompressed_file_folder_path,compressed_file_folder_path, "", Liri.compression_class, Liri.unit_test_class)
+
       Liri::Common::Benchmarking.start(start_msg: "Getting source code. Wait... ", stdout: true) do
         puts ''
         Net::SCP.start(manager_ip_address, manager_data.user, password: manager_data.password) do |scp|
-          scp.download!(manager_data.compressed_file_path, @source_code.compressed_file_folder_path)
+          scp.download!(manager_data.compressed_file_path, compressed_file_folder_path)
         end
       end
       puts ''
 
       downloaded_file_name = manager_data.compressed_file_path.split('/').last
-      downloaded_file_path = File.join(@source_code.compressed_file_folder_path, '/', downloaded_file_name)
+      downloaded_file_path = File.join(compressed_file_folder_path, '/', downloaded_file_name)
 
       Liri::Common::Benchmarking.start(start_msg: "Uncompressing source code. Wait... ", stdout: true) do
-        @source_code.decompress_file(downloaded_file_path)
-        @all_tests = @source_code.all_tests
+        source_code.decompress_file(downloaded_file_path)
+        @all_tests = source_code.all_tests
       end
       puts ''
 
       # Se cambia temporalmente la carpeta de trabajo a la carpeta de código fuente descomprimida
-      Dir.chdir(@source_code.decompressed_file_folder_path) do
+      Dir.chdir(decompressed_file_folder_path) do
         # Se borra el directorio .git para evitar el siguiente error al ejecutar las pruebas: fatal: not a git repository (or any of the parent directories): .git
         # Una mejor alternativa es no traer siquiera esa carpeta junto al código fuente excluyendo la carpeta .git al comprimir el código fuente.
         # Por cuestiones de tiempo se procede a borrar la carpeta .git por ahora, aunque al parecer el error mostrado no afecta la ejecución del Agent
@@ -235,9 +251,8 @@ module Liri
       tests_keys.map { |test_key| @all_tests[test_key] }
     end
 
-    def get_hardware_model
-      hardware_model = %x|cat /sys/devices/virtual/dmi/id/product_name|
-      hardware_model.strip[0..14] # remove \n from string
+    def hardware_specs
+      "#{Common::Hardware.cpu} #{Common::Hardware.memory}GB"
     end
 
     def registered_manager?(manager_ip_address)
@@ -245,11 +260,29 @@ module Liri
     end
 
     def register_manager(manager_ip_address)
-      @managers[manager_ip_address] = manager_ip_address
+      unless registered_manager?(manager_ip_address)
+        @managers[manager_ip_address] = {
+          manager_ip_address: @managers[manager_ip_address]
+        }
+      end
     end
 
     def unregister_manager(manager_ip_address)
       @managers.remove!(manager_ip_address)
+      Liri.logger.info("Finish connection with Manager #{manager_ip_address} in TCP port: #{@tcp_port}")
+    end
+
+    def init_work_folders(manager_ip_address)
+      return if @managers[manager_ip_address][:compressed_file_folder_path]
+
+      compressed_file_folder_path = File.join(@agent_folder_path, '/', "#{DateTime.now.strftime("%d_%m_%y_%H_%M_%S")}_work")
+      Dir.mkdir(compressed_file_folder_path) unless Dir.exist?(compressed_file_folder_path)
+      decompressed_file_folder_path = File.join(compressed_file_folder_path, '/', Common::SourceCode::DECOMPRESSED_FOLDER_NAME)
+
+      @managers[manager_ip_address] = {
+        compressed_file_folder_path: compressed_file_folder_path,
+        decompressed_file_folder_path: decompressed_file_folder_path
+      }
     end
   end
 end

data/lib/all_libraries.rb

@@ -19,9 +19,12 @@ require 'agent/agent'
 require 'agent/runner'
 
 require 'common/benchmarking'
+require 'common/duration'
+require 'common/hardware'
 require 'common/log'
 require 'common/manager_data'
 require 'common/progressbar'
+require 'common/tty_progressbar'
 require 'common/setup'
 require 'common/source_code'
 require 'common/compressor/zip'

data/lib/common/benchmarking.rb

@@ -4,13 +4,7 @@
 #
 # @author Rodrigo Fernández
 
-require 'benchmark'
-require 'i18n' # requerimiento de la gema to_duration
-require 'to_duration'
-
-# Se configura la ubicación del archivo de internacionalización de la gema to_duration
-I18n.load_path << Dir["#{File.join(File.dirname(File.dirname(File.dirname(__FILE__))), 'config/locales')}/*.yml"]
-I18n.default_locale = :es
+require "benchmark"
 
 module Liri
   module Common
@@ -23,7 +17,7 @@ module Liri
 
           seconds = Benchmark.realtime(&block)
 
-          Liri.logger.info("#{end_msg}#{seconds.to_duration}", stdout)
+          Liri.logger.info("#{end_msg}#{Duration.humanize(seconds, times_round: Liri.times_round, times_round_type: Liri.times_round_type)}", stdout)
           seconds
         end
       end

data/lib/common/compressor/zip.rb

@@ -8,15 +8,16 @@ module Liri
     module Compressor
       class Zip
         # Inicializa la carpeta a comprimir y la ubicación en donde se guardará el archivo comprimido
-        def initialize(input_dir, output_file)
+        def initialize(input_dir, output_file, ignored_folders)
           @input_dir = input_dir
           @output_file = output_file
+          @ignored_folders = ignored_folders.split(",")
         end
 
         # Comprime el directorio de entrada @input_dir en un archivo con extensión zip.
         def compress
           clear_output_file
-          entries = Dir.entries(@input_dir) - %w[. ..]
+          entries = Dir.entries(@input_dir) - (%w[. ..] + @ignored_folders)
 
           ::Zip::File.open(@output_file, ::Zip::File::CREATE) do |zipfile|
             write_entries(entries, '', zipfile)

data/lib/common/duration.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+# = duration.rb
+#
+# @author Rodrigo Fernández
+
+require "chronic_duration"
+
+module Liri
+  module Common
+    # == Módulo Duration
+    # Este módulo se encarga de convertir el tiempo en segundos a un formato legible
+    module Duration
+      class << self
+        def humanize(time, times_round:, times_round_type:)
+          # El time puede ser un BigDecimal y aunque se redondee puede responder con un formato 0.744e2, por eso
+          # es imporantes hacerle un to_f para convertirlo a 74.4 antes de proceder a humanizarlo
+          time = time.to_f
+          case times_round_type
+          when :floor then ChronicDuration.output(time.truncate(times_round), format: :short, keep_zero: true)
+          when :roof then ChronicDuration.output(time.round(times_round), format: :short, keep_zero: true)
+          else raise "Invalid times_round_type. Expected: floor or roof. Received: #{times_round_type}"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/common/hardware.rb

@@ -0,0 +1,29 @@
+# = hardware.rb
+#
+# @author Rodrigo Fernández
+
+module Liri
+  module Common
+    # == Módulo Hardware
+    # Este módulo se encarga de obtener información del hardware
+    module Hardware
+      class << self
+        def cpu
+          cpu = %x|inxi -C|
+          cpu = cpu.to_s.match(/model(.+)bits/)
+          cpu = cpu[1].gsub("12", "")
+          cpu = cpu.gsub(":", "")
+          cpu.strip
+        rescue Errno::ENOENT
+          raise InxiCommandNotFoundError.new
+        end
+
+        def memory
+          memory = %x|grep MemTotal /proc/meminfo|
+          memory = memory.to_s.match(/(\d+)/)
+          (memory[1].to_i * 0.000001).to_i
+        end
+      end
+    end
+  end
+end

data/lib/common/log.rb

@@ -14,6 +14,8 @@ module Liri
       FOLDER_PATH = File.join(Dir.pwd, "/#{FOLDER_NAME}")
       FILE_NAME = 'liri.log'
 
+      attr_reader :folder_path
+
       def initialize(shift_age, folder_path:, file_name:, stdout: true)
         @stdout = stdout
         @shift_age = shift_age
@@ -27,37 +29,37 @@ module Liri
       end
 
       def debug(text, stdout = false)
-        puts(text) if stdout
+        puts(ColorizeText.debug(text)) if stdout
         @stdout_logger.debug(text) if @stdout
         @file_logger.debug(text)
       end
 
       def info(text, stdout = false)
-        puts(text) if stdout
+        puts(ColorizeText.default(text)) if stdout
         @stdout_logger.info(text) if @stdout
         @file_logger.info(text)
       end
 
       def warn(text, stdout = false)
-        puts(text) if stdout
+        puts(ColorizeText.warn(text)) if stdout
         @stdout_logger.warn(text) if @stdout
         @file_logger.warn(text)
       end
 
       def error(text, stdout = false)
-        puts(text) if stdout
+        puts(ColorizeText.error(text)) if stdout
         @stdout_logger.error(text) if @stdout
         @file_logger.error(text)
       end
 
       def fatal(text, stdout = false)
-        puts(text) if stdout
+        puts(ColorizeText.fatal(text)) if stdout
         @stdout_logger.fatal(text) if @stdout
         @file_logger.fatal(text)
       end
 
       def unknown(text, stdout = false)
-        puts(text) if stdout
+        puts(ColorizeText.unknown(text)) if stdout
         @stdout_logger.unknown(text) if @stdout
         @file_logger.unknown(text)
       end
@@ -65,12 +67,12 @@ module Liri
       private
       def create_stdout_logger
         @stdout_logger = Logger.new(STDOUT, @shift_age)
-        @stdout_logger.formatter = Liri::Common::LogFormatter.colorize(Liri.setup.log.stdout.colorize)
+        @stdout_logger.formatter = Liri::Common::LogFormatter.colorize(Liri.setup.general.log.stdout.colorize)
       end
 
       def create_file_logger
         @file_logger = Logger.new(@file_path, @shift_age)
-        @file_logger.formatter = Liri::Common::LogFormatter.colorize(Liri.setup.log.file.colorize)
+        @file_logger.formatter = Liri::Common::LogFormatter.colorize(Liri.setup.general.log.file.colorize)
       end
 
       def create_log_folder
@@ -78,18 +80,58 @@ module Liri
       end
     end
 
+    class ColorizeText
+      COLORS = {
+        DEBUG: '0;36',  # cyan
+        ERROR: '0;31',  # red
+        INFO: '0;32',   # green
+        WARN: '0;33',   # orange
+        FATAL: '0;35',  # pink
+        ANY: '0;36',    # cyan
+        DEFAULT: '1;0'  # white
+      }
+
+      class << self
+        def default(text)
+          colorize(text, :DEFAULT)
+        end
+
+        def debug(text)
+          colorize(text, :DEBUG)
+        end
+
+        def info(text)
+          colorize(text, :INFO)
+        end
+
+        def warn(text)
+          colorize(text, :WARN)
+        end
+
+        def error(text)
+          colorize(text, :ERROR)
+        end
+
+        def fatal(text)
+          colorize(text, :FATAL)
+        end
+
+        def unknown(text)
+          colorize(text, :ANY)
+        end
+
+        private
+
+        def colorize(text, color)
+          "\e[#{COLORS[color]}m#{text}\e[0m"
+        end
+      end
+    end
+
     class LogFormatter
       DATETIME_FORMAT = "%d-%m-%Y %H:%M"
 
-      SEVERITY_COLORS = {
-          DEBUG: '0;36',  # cyan
-          ERROR: '0;31',  # red
-          INFO: '0;32',   # green
-          WARN: '0;33',   # orange
-          FATAL: '0;35',  # pink
-          ANY: '0;36',    # cyan
-          DEFAULT: '1;0'  # white
-      }
+      SEVERITY_COLORS = ColorizeText::COLORS
 
       class << self
         def colorize(type)

data/lib/common/progressbar.rb

@@ -12,16 +12,16 @@ module Liri
     module Progressbar
       class << self
         def start(params = {})
-          @compressing = true
+          @progressing = true
           progressbar = ProgressBar.create(params)
           Thread.new do
-            while @compressing
+            while @progressing
               progressbar.increment
               sleep(0.1)
             end
           end
           yield
-          @compressing = false
+          @progressing = false
         end
       end
     end

data/lib/common/source_code.rb

@@ -8,7 +8,7 @@ module Liri
       DECOMPRESSED_FOLDER_NAME = 'decompressed'
       attr_reader :folder_path, :compressed_file_folder_path, :compressed_file_path, :decompressed_file_folder_path
 
-      def initialize(folder_path, compressed_file_folder_path, compression_class, unit_test_class)
+      def initialize(folder_path, compressed_file_folder_path, ignored_folders, compression_class, unit_test_class)
         @folder_path = folder_path
         @folder_name = @folder_path.split('/').last
         @compressed_file_folder_path = compressed_file_folder_path
@@ -17,7 +17,7 @@ module Liri
         # Inicializa un compresor acorde a compression_class, la siguiente línea en realidad hace lo siguiente:
         # @compressor = Liri::Common::Compressor::Zip.new(input_dir, output_file)
         # compression_class en este caso es Zip pero podría ser otro si existiera la implementación, por ejemplo Rar
-        @compressor = Object.const_get(compression_class).new(@folder_path, @compressed_file_path)
+        @compressor = Object.const_get(compression_class).new(@folder_path, @compressed_file_path, ignored_folders)
         # Inicializa un ejecutor de pruebas acorde a unit_test_class, la siguiente línea en realidad hace lo siguiente:
         # @unit_test = Liri::Common::UnitTest::Rspec.new(source_code_folder_path)
         # unit_test_class en este caso es Rspec pero podría ser otro si existiera la implementación, por ejemplo UnitTest