liri 0.2.1 → 0.4.0

data/lib/all_libraries.rb

@@ -19,14 +19,19 @@ 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'
 require 'common/unit_test/rspec'
+require 'common/unit_test/rspec_result_parser'
 require 'common/tests_result'
+require 'common/text_time_parser'
 
 require 'manager/manager'
 require 'manager/credential'

data/lib/common/benchmarking.rb

@@ -1,31 +1,26 @@
+# frozen_string_literal: true
+
 # = benchmarking.rb
 #
 # @author Rodrigo Fernández
-#
-# == Módulo Benchmarking
-# Este módulo se encarga de medir el tiempo de ejecución de algunos bloques de código
-
-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
+    # == Módulo Benchmarking
+    # Este módulo se encarga de medir el tiempo de ejecución de algunos bloques de código
     module Benchmarking
       class << self
-        def start(start_msg: nil, end_msg: 'Duración: ', stdout: true)
+        def start(start_msg: nil, end_msg: 'Duration: ', stdout: true, &block)
           Liri.logger.info(start_msg, stdout)
-          seconds = Benchmark.realtime do
-            yield
-          end
-          Liri.logger.info("#{end_msg}#{seconds.to_duration}", stdout)
+
+          seconds = Benchmark.realtime(&block)
+
+          Liri.logger.info("#{end_msg}#{Duration.humanize(seconds, times_round: Liri.times_round, times_round_type: Liri.times_round_type)}", stdout)
           seconds
         end
       end
     end
   end
-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/manager_data.rb

@@ -8,10 +8,10 @@ module Liri
   module Common
     # Esta clase guarda los datos del Manager
     class ManagerData
-      attr_accessor :folder_path, :compressed_file_path, :user, :password
+      attr_accessor :tests_results_folder_path, :compressed_file_path, :user, :password
 
-      def initialize(folder_path:, compressed_file_path:, user:, password:)
-        @folder_path = folder_path
+      def initialize(tests_results_folder_path:, compressed_file_path:, user:, password:)
+        @tests_results_folder_path = tests_results_folder_path
         @compressed_file_path = compressed_file_path
         @user = user
         @password = password
@@ -19,7 +19,7 @@ module Liri
 
       def to_h
         {
-          folder_path: @folder_path,
+          tests_results_folder_path: @tests_results_folder_path,
           compressed_file_path: @compressed_file_path,
           user: @user,
           password: @password

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/setup.rb

@@ -14,21 +14,31 @@ module Liri
       MANAGER_FOLDER_NAME = 'manager'
       AGENT_FOLDER_NAME = 'agent'
 
-      attr_reader :setup_folder_path, :setup_file_path, :logs_folder_path, :manager_folder_path, :agent_folder_path
+      attr_reader :setup_folder_path, :setup_file_path, :logs_folder_path, :manager_folder_path,
+                  :manager_tests_results_folder_path, :agent_folder_path
 
-      def initialize(destination_folder_path)
+      def initialize(destination_folder_path, program, manager_tests_results_folder_time: nil)
         @setup_folder_path = File.join(destination_folder_path, '/', SETUP_FOLDER_NAME)
         @setup_file_path = File.join(@setup_folder_path, '/', SETUP_FILE_NAME)
         @logs_folder_path = File.join(@setup_folder_path, '/', LOGS_FOLDER_NAME)
         @manager_folder_path = File.join(@setup_folder_path, '/', MANAGER_FOLDER_NAME)
+        @manager_tests_results_folder_path = File.join(@manager_folder_path, '/', "#{manager_tests_results_folder_time}_tests_results") if manager_tests_results_folder_time
         @agent_folder_path = File.join(@setup_folder_path, '/', AGENT_FOLDER_NAME)
+        @program = program
       end
 
       def init
         create_folder(@setup_folder_path)
         create_folder(@logs_folder_path)
-        create_folder(@manager_folder_path)
-        create_folder(@agent_folder_path)
+
+        case @program
+        when :manager
+          create_folder(@manager_folder_path)
+          create_folder(@manager_tests_results_folder_path) if @manager_tests_results_folder_path
+        when :agent
+          create_folder(@agent_folder_path)
+        end
+
         create_setup_file
       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

data/lib/common/tests_result.rb

@@ -8,12 +8,19 @@ module Liri
   module Common
     # Esta clase se encarga de guardar y procesar el archivo de resultados
     class TestsResult
+      attr_reader :examples, :failures, :pending, :passed
+
       def initialize(folder_path)
         @folder_path = folder_path
-        @example_quantity = 0
-        @failure_quantity = 0
-        @passed_quantity = 0
-        @failures = ''
+        @examples = 0
+        @failures = 0
+        @pending = 0
+        @passed = 0
+        @finish_in = 0
+        @files_load = 0
+        @failures_list = ''
+        @failed_examples = ''
+        @failed_files = ''
       end
 
       def save(file_name, raw_tests_result)
@@ -22,28 +29,36 @@ module Liri
         file_path
       end
 
-      def build_file_name(agent_ip_address, tests_batch_number)
-        "batch_#{tests_batch_number}_agent_#{agent_ip_address}_tests_results"
+      def build_file_name(agent_ip_address, batch_num)
+        "batch_#{batch_num}_agent_#{agent_ip_address}_tests_results"
       end
 
       # Procesa el resultado crudo de las pruebas unitarias y lo devuelve en formato hash manejable
       # Ejemplo del hash retornado:
-      # {example_quantity: 2, failure_quantity: 1}
+      # { examples: 0, failures: 0, pending: 0, passed: 0, finish_in: 0, files_load: 0,
+      #   failures_list: '', failed_examples: '' }
       def process(tests_result_file_name)
         file_path = File.join(@folder_path, '/', tests_result_file_name)
+        # A veces no se encuentra el archivo de resultados, la siguiente condicional es para evitar errores relativos a esto
+        return {} unless File.exist?(file_path)
+
         result_hash = process_tests_result_file(file_path)
         update_partial_result(result_hash)
-        #print_partial_result(result_hash)
         result_hash
       end
 
       def print_summary
-        puts "\n#{@example_quantity} examples, #{@failure_quantity} failures\n"
+        Liri.logger.info("\n#{@examples} examples, #{@passed} passed, #{@failures} failures\n", true)
+      end
+
+      def print_detailed_failures
+        Liri.logger.info("\nFailures: ", true) unless @failures_list.empty?
+        Liri.logger.info(@failures_list, true)
       end
 
-      def print_failures
-        puts "\nFailures: " if !@failures.empty?
-        puts @failures
+      def print_summary_failures
+        Liri.logger.info("\nFailed examples: ", true) unless @failed_examples.empty?
+        Liri.logger.info(@failed_examples, true)
       end
 
       private
@@ -51,10 +66,12 @@ module Liri
       # Recibe el resultado crudo de las pruebas unitarias
       # Procesa el archivo con los resultados crudos y lo devuelve en formato hash manejable
       # Ejemplo del hash retornado:
-      # {result: '.F', failures: '', example_quantity: 2, failure_quantity: 1, failed_examples: ''}
+      # {result: '.F', failures: '', examples: 2, failures: 1, failed_examples: ''}
       def process_tests_result_file(file_path)
-        result_hash = {failures: '', example_quantity: 0, failure_quantity: 0, passed_quantity: 0, failed_examples: ''}
+        result_hash = { examples: 0, failures: 0, pending: 0, passed: 0, finish_in: 0, files_load: 0,
+                        failures_list: '', failed_examples: '', failed_files: '' }
         flag = ''
+        @failures_lists_count = @failures
         File.foreach(file_path) do |line|
           if flag == '' && line.strip.start_with?('Randomized')
             flag = 'Randomized'
@@ -67,6 +84,9 @@ module Liri
           end
 
           if ['Randomized', 'Failures', ''].include?(flag) && line.strip.start_with?('Finished')
+            values = finish_in_values(line)
+            result_hash[:finish_in] = values[:finish_in]
+            result_hash[:files_load] = values[:files_load]
             flag = 'Finished'
             next
           end
@@ -78,15 +98,20 @@ module Liri
 
           case flag
           when 'Failures'
-            result_hash[:failures] << line
+            line = fix_failure_number(line)
+            result_hash[:failures_list] << line
           when 'Finished'
-            values = line.to_s.match(/([\d]+) example.?, ([\d]+) failure.?/)
-            result_hash[:example_quantity] = values[1].to_i
-            result_hash[:failure_quantity] = values[2].to_i
-            result_hash[:passed_quantity] = result_hash[:example_quantity] - result_hash[:failure_quantity]
+            values = finished_summary_values(line)
+            result_hash[:examples] = values[:examples]
+            result_hash[:failures] = values[:failures]
+            result_hash[:passed] = result_hash[:examples] - result_hash[:failures]
+            result_hash[:pending] = values[:pending]
             flag = ''
           when 'Failed'
-            result_hash[:failed_examples] << line
+            if line.strip.start_with?('rspec')
+              result_hash[:failed_examples] << line
+              result_hash[:failed_files] << "#{failed_example(line)}\n"
+            end
           end
         end
 
@@ -94,22 +119,38 @@ module Liri
       end
 
       def update_partial_result(hash_result)
-        @example_quantity += hash_result[:example_quantity]
-        @failure_quantity += hash_result[:failure_quantity]
-        @passed_quantity += hash_result[:passed_quantity]
-        @failures << hash_result[:failures]
+        @examples += hash_result[:examples]
+        @failures += hash_result[:failures]
+        @pending += hash_result[:pending]
+        @passed += hash_result[:passed]
+        @failures_list << hash_result[:failures_list]
+        @failed_examples << hash_result[:failed_examples]
+        @failed_files << hash_result[:failed_files]
       end
 
-      def print_partial_result(result_hash)
-        result_hash[:passed_quantity].times do
-          print '.'
-        end
+      def finish_in_values(line)
+        UnitTest::RspecResultParser.finish_in_values(line)
+      end
 
-        result_hash[:failure_quantity].times do
-          print 'F'
-        end
+      def finished_summary_values(line)
+        UnitTest::RspecResultParser.finished_summary_values(line)
+      end
+
+      def failed_example(line)
+        # get string like this "/spec/failed_spec.rb:4"
+        failed_example = UnitTest::RspecResultParser.failed_example(line)
+        # return "failed_spec.rb:4"
+        failed_example.split("/").last
       end
 
+      def fix_failure_number(line)
+        line_number_regex = /(\d+\))/
+        if line.strip.start_with?(line_number_regex)
+          @failures_lists_count += 1
+          line.gsub!(line_number_regex, "#{@failures_lists_count})")
+        end
+        line
+      end
     end
   end
 end

data/lib/common/text_time_parser.rb

@@ -0,0 +1,51 @@
+# = text_time_parser.rb
+#
+# @author Rodrigo Fernández
+#
+# == Clase TextTimeParser
+
+require 'bigdecimal'
+
+module Liri
+  module Common
+    # Esta clase parsea texto en horas, minutos y segundos a un valor decimal en segundos
+    class TextTimeParser
+      class << self
+        def to_seconds(text_time)
+          values = text_time.split(' ')
+          case values.size
+          when 2 # cuando se tiene por ejemplo '15 minutes'
+            text_time_to_seconds(values[0], values[1])
+          when 4 # cuando se tiene por ejemplo '1 minute 5 seconds'
+            text_time_to_seconds(values[0], values[1]) + text_time_to_seconds(values[2], values[3])
+          when 6 # cuando se tiene por ejemplo '1 hour 30 minutes 25 seconds'
+            text_time_to_seconds(values[0], values[1]) +
+              text_time_to_seconds(values[2], values[3]) +
+              text_time_to_seconds(values[4], values[5])
+          end
+          # queda pendiente agregar el caso de dias, horas, minutos y segundos, además hace falta verificar como lo muestra Rspec
+        end
+
+        private
+
+        def text_time_to_seconds(number, text)
+          # Se usa BigDecimal porque
+          # En una multiplicación normal: (203.033*3600).to_f = 730918.7999999999
+          # Con BigDecimal: (BigDecimal('203.033') * 3600).to_f = 730918.8
+          time = BigDecimal(number)
+          time_in_seconds = case text
+          when 'second', 'seconds' then time
+          when 'minute', 'minutes' then time * 60
+          when 'hour', 'hours' then time * 3600
+          when 'day', 'days' then time * 86_400
+          end
+
+          # time in seconds puede contener valores BigDecimal como este 0.744e2 que al hacerle to_f devuelve 74.4
+          # Aún así conviene mantener el valor en BigDecimal para las operaciones matematicas y solo cuando se va a mostrar
+          # los datos en pantalla se debe hacer el to_f
+          time_in_seconds
+        end
+      end
+    end
+  end
+end

data/lib/common/tty_progressbar.rb

@@ -0,0 +1,70 @@
+# = tty_progressbar.rb
+#
+# @author Rodrigo Fernández
+#
+# == Módulo TtyProgressbar
+require "tty-progressbar"
+
+module Liri
+  module Common
+    # Este módulo se encarga de mostrar una barra de progreso
+    module TtyProgressbar
+      ANIMATION = [
+        "■□□□■□□□■□□□■□□□■□□□■□□□■□□□■□□□■□□□■□□□■□□□■□□□■□□□■□□□■□□□■□□□■□□□■□□□■□□□■□",
+        "□■□□□■□□□■□□□■□□□■□□□■□□□■□□□■□□□■□□□■□□□■□□□■□□□■□□□■□□□■□□□■□□□■□□□■□□□■□□□■",
+        "□□■□□□■□□□■□□□■□□□■□□□■□□□■□□□■□□□■□□□■□□□■□□□■□□□■□□□■□□□■□□□■□□□■□□□■□□□■□□□",
+        "□□□■□□□■□□□■□□□■□□□■□□□■□□□■□□□■□□□■□□□■□□□■□□□■□□□■□□□■□□□■□□□■□□□■□□□■□□□■□□",
+      ]
+
+      ANIMATION2 = [
+          "■□□□■□□□■□□□■□□□■□□",
+          "□■□□□■□□□■□□□■□□□■□",
+          "□□■□□□■□□□■□□□■□□□■",
+          "□□□■□□□■□□□■□□□■□□□",
+      ]
+      class << self
+        # Example:
+        #   Common::TtyProgressbar.start("Compressing source code |:bar| Time: :elapsed", total: nil, width: 80) do
+        #     ...code
+        #   end
+        def start(format, params = {})
+          params[:unknown] = ANIMATION[0]
+          progressbar = TTY::ProgressBar.new(format, params)
+          # Es importante iniciar la barra porque TimeFormatter.call accede a su start_time y si no se inició la barra
+          # entonces ocurre un error
+          progressbar.start
+          progressbar.use(Common::TtyProgressbar::TimeFormatter)
+
+          Thread.new do
+            animation_count = 0
+            while !progressbar.stopped?
+              progressbar.advance
+
+              progressbar.update(unknown: ANIMATION[animation_count])
+              animation_count += 1
+              animation_count = 0 if animation_count == 3
+
+              sleep(0.1)
+            end
+          end
+          yield
+          progressbar.update(total: 1) # Esto hace que la barra cambie a al estilo completado con un porcentaje del 100%
+          progressbar.stop
+        rescue TypeError
+          # Se captura la excepción solo para evitar un error en start_time mas abajo
+        end
+      end
+
+      # From
+      class TimeFormatter
+        include TTY::ProgressBar::Formatter[/:time/i]
+
+        def call(value) # specify how display string is formatted
+          # access current progress bar instance to read start time
+          elapsed = Duration.humanize(Time.now - progress.start_time, times_round: Liri.times_round, times_round_type: Liri.times_round_type)
+          value.gsub(matcher, elapsed)   # replace :time token with a value
+        end
+      end
+    end
+  end
+end