italian-ruby 0.9.14 → 1.0.0

data/lib/italian/ruby/metodi/string.rb

@@ -0,0 +1,142 @@
+# frozen_string_literal: true
+
+class String
+
+  ##
+  # Metodi per la colorizzazione delle stringhe,
+  # quando stampate a terminale.
+  def colorize(color_code)
+    "\e[#{color_code}m#{self}\e[0m"
+  end
+
+    def bianco
+      self
+    end
+
+    def rosso
+      colorize(31)
+    end
+
+    def verde
+      colorize(32)
+    end
+
+    def giallo
+      colorize(33)
+    end
+
+    def blu
+      colorize(34)
+    end
+
+    def magenta
+      colorize(35)
+    end
+
+    def azzurro
+      colorize(36)
+    end
+
+    def arancione
+      colorize("38;5;214")
+    end
+
+  ##
+  # Determina se la stringa esiste e non è vuota.
+  def esiste?
+    !nil? and self != ""
+  end
+
+  ##
+  # Determina se la stringa non include un'altra stringa.
+  def non_include?(*args)
+    !include? *args
+  end
+
+  ##
+  # Determina se la stringa non inizia con un'altra stringa.
+  def non_inizia_con?(*args)
+    !inizia_con? *args
+  end
+
+  ##
+  # Determina se la stringa non finisce con un'altra stringa.
+  def non_finisce_con?(*args)
+    !finisce_con? *args
+  end
+
+  ##
+  # Converte la stringa in data.
+  def in_data
+    return unless defined? Date
+    Date.parse self
+  end
+
+  ##
+  # Converte la stringa in tempo.
+  def in_tempo
+    return unless defined? Time
+    Time.parse self
+  end
+
+  ##
+  # Converte la stringa nella classe con lo steso nome.
+  def in_classe
+    Object.const_get self
+  end
+
+  ##
+  # Restituisce i primi n caratteri della stringa.
+  def primi(n)
+    self[0..(n - 1)]
+  end
+
+  ##
+  # Restituisce il primo carattere della stringa.
+  def primo_carattere
+    self[0]
+  end
+
+  ##
+  # Restituisce l'ultimo carattere della stringa.
+  def ultimo_carattere
+    self[-1]
+  end
+
+  ##
+  # Restituisce la stringa escludendo i primi n caratteri.
+  def salta_caratteri(n)
+    self[(n - 1)..-1]
+  end
+
+  ##
+  # Restituisce la stringa escludendo il primo carattere.
+  def salta_il_primo_carattere
+    self[1..-1]
+  end
+
+  ##
+  # Restituisce la stringa togliendo gli ultimi n caratteri.
+  def tronca_caratteri(n)
+    self[0..(-1 - n)]
+  end
+
+  ##
+  # Restituisce la stringa togliendo l'ultimo carattere.
+  def tronca
+    self[0..-2]
+  end
+
+  ##
+  # Adatta la stringa alla lunghezza specificata.
+  # Se la stringa è più lunga, la tronca e mette dei puntini di sospensione.
+  # Se la stringa è più corta, aggiunge n spazi vuoti alla fine per coprire.
+  def adatta(l)
+    if self.length > l
+      "#{self[0..l - 3]}.."
+    else
+      self.ljust l, " "
+    end
+  end
+
+end

data/lib/italian/ruby/metodi/time.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+class Time
+
+  ##
+  # Converte il tempo in data.
+  def in_data
+    self.to_date
+  end
+
+  ##
+  # Converte il tempo in se stesso.
+  def in_tempo
+    self
+  end
+
+  ##
+  # Formatta il tempo secondo la stringa passata.
+  def formatta_locale(format)
+    if defined? I18n
+      I18n.l self, format: format
+    else
+      strftime format
+    end
+  end
+
+  ##
+  # Ritorna il tempo all'inizio dell'ora.
+  def inizio_ora
+    Time.new(self.year, self.month, self.day, self.hour)
+  end
+
+  ##
+  # Ritorna il tempo alla fine dell'ora.
+  def fine_ora
+    Time.new(self.year, self.month, self.day, self.hour, 59, 59)
+  end
+
+  ##
+  # Ritorna il tempo all'inizio del minuto.
+  def inizio_minuto
+    Time.new(self.year, self.month, self.day, self.hour, self.min)
+  end
+
+  ##
+  # Ritorna il tempo alla fine del minuto.
+  def fine_minuto
+    Time.new(self.year, self.month, self.day, self.hour, self.min, 59)
+  end
+
+end

data/lib/italian/ruby/traduttore.rb

@@ -1,143 +1,114 @@
 # frozen_string_literal: true
-require           "rainbow"
-require_relative  "utils/debug"
-require_relative  "errore"
-
+require_relative "errori"
+require_relative "traduttore/linea"
+
+##
+# Traduttore per codice sorgente ItalianRuby.
+#
+# Il traduttore espone un metodo di classe `traduci`, che può
+# essere chiamato passando un archivio o un blocco.
+# Viene restituito lo stesso archivio o blocco tradotto in sorgente Ruby.
+#
+# Nella traduzione viene mantenuta la perfetta corrispondenza
+# fra i numeri di linea, in modo tale da facilitare la lettura delle
+# eventuali tracce di errore.
 module Italian
   module Ruby
     class Traduttore
 
+      ##
+      # Bandierina per stampare o meno i dettagli della traduzione,
+      # mentre questa viene eseguita.
       STAMPA_DETTAGLI_TRADUZIONE = false
 
-      class << self
-
-        def traduci(file = nil, &block)
-          if not file.nil?
-            codice_tradotto = File.readlines(file).map.with_index do |linea, riga|
-              traduci_linea file, linea, riga
-            end
-            codice_tradotto.join
-          else
-            if block_given?
-              begin
-                block.call
-              rescue StandardError => errore
-                Italian::Ruby::Errore.new([ errore.message, errore.backtrace ].join("\n"), "-", 0, 0).stampa
-              end
-            end
-          end
-        end
+      ##
+      # Punto d'ingresso del traduttore. Questo metodo esegue del codice Ruby
+      # presente in un archivio. Il codice può essere stato precedentemente
+      # tradotto dal metodo `traduci` del traduttore ItalianRuby.
+      def self.esegui(percorso_archivio_tradotto)
+        load percorso_archivio_tradotto
+      rescue SyntaxError => errore
+        Italian::Ruby::Errori.recupera errore, percorso_archivio_tradotto
+      rescue StandardError => errore
+        Italian::Ruby::Errori.recupera errore, percorso_archivio_tradotto
+      end
 
-        def traduci_linea(file, linea, riga)
-          puts "Traduco linea  [#{riga}]: #{linea.inspect}".magenta if STAMPA_DETTAGLI_TRADUZIONE
-          posizione_commento         = linea.index(%{#}) || linea.length
-          posizione_stringa_singola  = linea.index(%{'}) || linea.length
-          posizione_stringa_doppia   = linea.index(%{"}) || linea.length
-          contesto = [
-            file, linea, riga,
-            posizione_commento,
-            posizione_stringa_singola,
-            posizione_stringa_doppia ]
-
-          controlla_stringa_singola *contesto
-          controlla_stringa_doppia  *contesto
-
-          if posizione_commento < posizione_stringa_doppia
-            pezzi_da_tradurre = [
-              linea[0..posizione_commento],
-              linea[posizione_commento + 1..]
-            ]
-          elsif posizione_stringa_doppia < posizione_commento
-            pezzi_da_tradurre = linea.scan( /([^"]*)("[^"]*")([^"]*)/ ).flatten
-          else
-            pezzi_da_tradurre = [ linea ]
-          end
+      ##
+      # Punto d'ingresso del traduttore. Questo metodo accetta un archivio 
+      # come argomento principale, oppure un blocco di codice. 
+      def self.traduci(archivio = nil, sorgente = nil, &blocco)
+        return traduci_archivio   archivio  if archivio != nil
+        return traduci_sorgente   sorgente  if sorgente != nil
+        return traduci_blocco     &blocco   if block_given?
+      end
+
+      private
+
+        ##
+        # Traduce un archivio sorgente da ItalianRuby a Ruby.
+        # Salva la versione tradotta dell'archivio originale nel percorso
+        # delle traduzioni.
+        def self.traduci_archivio(archivio)
+          puts "Traduzione archivio: #{archivio}"             if STAMPA_DETTAGLI_TRADUZIONE
 
-          debug pezzi_da_tradurre if STAMPA_DETTAGLI_TRADUZIONE
-          linea_tradotta = pezzi_da_tradurre.map { |pezzo| traduci_pezzo pezzo }.join
+          linee_sorgente = File.readlines archivio
+          linee_tradotte = linee_sorgente.map.with_index do |linea, numero_linea|
+            linea_da_tradurre = Italian::Ruby::Traduttore::Linea.new linea, numero_linea, archivio
+            linea_tradotta = linea_da_tradurre.traduci
 
-          if STAMPA_DETTAGLI_TRADUZIONE
-            puts "Linea tradotta [#{riga}]: #{linea_tradotta.inspect}".verde_lime
-            puts
+            puts "\t[#{numero_linea}] <- #{linea}"            if STAMPA_DETTAGLI_TRADUZIONE
+            puts "\t[#{numero_linea}] -> #{linea_tradotta}"   if STAMPA_DETTAGLI_TRADUZIONE
+
+            linea_tradotta.chomp
           end
-          linea_tradotta
+
+          puts "Traduzione terminata."                        if STAMPA_DETTAGLI_TRADUZIONE
+          puts                                                if STAMPA_DETTAGLI_TRADUZIONE
+
+          linee_tradotte              = linee_tradotte.join("\n").freeze
+          archivio_tradotto           = Italian::Ruby.percorso_archivio_tradotto archivio
+          cartella_archivio_tradotto  = File.dirname archivio_tradotto
+          FileUtils.mkdir_p cartella_archivio_tradotto unless Dir.exist? cartella_archivio_tradotto
+
+          File.write archivio_tradotto, linee_tradotte
+          archivio_tradotto
+        rescue SyntaxError => errore
+          Italian::Ruby::Errori.recupera errore, archivio
         end
 
-        private
+        ##
+        # Traduce un pezzo di sorgente da ItalianRuby a Ruby.
+        def self.traduci_sorgente(sorgente)
+          puts "Traduzione sorgente."                         if STAMPA_DETTAGLI_TRADUZIONE
 
-          def controlla_stringa_singola(file, linea, riga, posizione_commento, posizione_stringa_singola, posizione_stringa_doppia)
-            if posizione_stringa_singola < posizione_commento and posizione_stringa_singola < posizione_stringa_doppia
-              Italian::Ruby::Errore::NonSupportato.new(
-                "Le stringhe con singolo apice non sono supportate.",
-                file, riga, posizione_stringa_singola).stampa
-            end
-          end
+          linee_sorgente  = sorgente.split "\n"
+          linee_tradotte  = linee_sorgente.map.with_index do |linea, numero_linea|
+            linea_da_tradurre = Italian::Ruby::Traduttore::Linea.new linea, numero_linea, nil
+            linea_tradotta = linea_da_tradurre.traduci
 
-          def controlla_stringa_doppia(file, linea, riga, posizione_commento, posizione_stringa_singola, posizione_stringa_doppia)
-            return if posizione_commento <= posizione_stringa_doppia
-          
-            prossima_posizione_stringa_doppia = linea[posizione_stringa_doppia + 1..].index %{"}
-            if prossima_posizione_stringa_doppia.nil?
-              Italian::Ruby::Errore::IndividuazioneStringa.new(
-                "Non è stato possibile trovare la terminazione della stringa.",
-                file, riga, posizione_stringa_doppia).stampa
-            end
-          end
+            puts "\t[#{numero_linea}] <- #{linea}"            if STAMPA_DETTAGLI_TRADUZIONE
+            puts "\t[#{numero_linea}] -> #{linea_tradotta}"   if STAMPA_DETTAGLI_TRADUZIONE
 
-          def traduci_pezzo(pezzo)
-            return pezzo if pezzo.nil? or pezzo.length == 0
-            return pezzo if pezzo.start_with? %{#}
-            return pezzo if pezzo.start_with? %{"}
-
-            pezzo.gsub! /(\b)e(\b)/,                      "\\1and\\2"
-            pezzo.gsub! /(\b)inizia(\b)/,                 "\\1begin\\2"
-            pezzo.gsub! /(\b)blocco_dato\?(\b)/,          "\\1block_given?\\2"
-            pezzo.gsub! /(\b)esci(\b)/,                   "\\1break\\2"
-            pezzo.gsub! /(\b)considera(\b)/,              "\\1case\\2"
-            pezzo.gsub! /(\b)classe([\s]+[A-Z][\w]*)/,    "\\1class\\2"
-            pezzo.gsub! /(\b)classe([\s]+)(<<)([\s]+)/,   "\\1class\\2\\3\\4"
-            pezzo.gsub! /(\b)definisci([\s]+[^\s]+)/,     "\\1def\\2"
-            pezzo.gsub! /(\b)definito\?([\s]+[^\s]+)/,    "\\1defined?\\2"
-            pezzo.gsub! /(\b)definita\?([\s]+[^\s]+)/,    "\\1defined?\\2"
-            pezzo.gsub! /(\b)esegui(\b)/,                 "\\1do\\2"
-            pezzo.gsub! /(\b)altrimenti(\b)/,             "\\1else\\2"
-            pezzo.gsub! /(\b)altrimenti_se(\b)/,          "\\1elsif\\2"
-            pezzo.gsub! /(\b)fine(\b)/,                   "\\1end\\2"
-            pezzo.gsub! /(\b)assicura(\b)/,               "\\1ensure\\2"
-            pezzo.gsub! /(\b)estendi([\s]+[A-Z][\w]*)/,   "\\1extend\\2"
-            pezzo.gsub! /(\b)no(\b)/,                     "\\1false\\2"
-            pezzo.gsub! /(\b)falso(\b)/,                  "\\1false\\2"
-            pezzo.gsub! /(\b)per(\b)/,                    "\\1for\\2"
-            pezzo.gsub! /(\b)se(\b)/,                     "\\1if\\2"
-            pezzo.gsub! /(\b)includi([\s]+[A-Z][\w]*)/,   "\\1include\\2"
-            pezzo.gsub! /(\b)modulo([\s]+[A-Z][\w]*)/,    "\\1module\\2"
-            pezzo.gsub! /(\b)prossimo(\b)/,               "\\1next\\2"
-            pezzo.gsub! /(\b)prossima(\b)/,               "\\1next\\2"
-            pezzo.gsub! /(\b)nullo(\b)/,                  "\\1nil\\2"
-            pezzo.gsub! /(\b)nulla(\b)/,                  "\\1nil\\2"
-            pezzo.gsub! /(\b)non(\b)/,                    "\\1not\\2"
-            pezzo.gsub! /(\b)o(\b)/,                      "\\1or\\2"
-            pezzo.gsub! /(\b)preponi([\s]+[A-Z][\w]*)/,   "\\1prepend\\2"
-            pezzo.gsub! /(\b)riesegui(\b)/,               "\\1redo\\2"
-            pezzo.gsub! /(\b)recupera(\b)/,               "\\1rescue\\2"
-            pezzo.gsub! /(\b)riprova(\b)/,                "\\1retry\\2"
-            pezzo.gsub! /(\b)ritorna(\b)/,                "\\1return\\2"
-            pezzo.gsub! /(\b)istanza/,                    "\\1self"
-            pezzo.gsub! /(\b)se_stesso/,                  "\\1self"
-            pezzo.gsub! /(\b)se_stessa/,                  "\\1self"
-            pezzo.gsub! /(\b)allora(\b)/,                 "\\1then\\2"
-            pezzo.gsub! /(\b)si(\b)/,                     "\\1true\\2"
-            pezzo.gsub! /(\b)vero(\b)/,                   "\\1true\\2"
-            pezzo.gsub! /(\b)a_meno_che(\b)/,             "\\1unless\\2"
-            pezzo.gsub! /(\b)finché(\b)/,                 "\\1until\\2"
-            pezzo.gsub! /(\b)quando(\b)/,                 "\\1when\\2"
-            pezzo.gsub! /(\b)mentre(\b)/,                 "\\1while\\2"
-            pezzo.gsub! /(\b)rilascia(\b)/,               "\\1yield\\2"
-            pezzo
+            linea_tradotta.chomp
           end
 
-      end
+          puts "Traduzione terminata."                        if STAMPA_DETTAGLI_TRADUZIONE
+          puts                                                if STAMPA_DETTAGLI_TRADUZIONE
+
+          sorgente_tradotto = linee_tradotte.join("\n").freeze
+          sorgente_tradotto
+        end
+
+        ##
+        # Traduce un blocco di codice da ItalianRuby a Ruby.
+        def self.traduci_blocco(&blocco)
+          blocco.call
+        rescue SyntaxError => errore
+          Italian::Ruby::Errori.recupera errore
+        rescue StandardError => errore
+          Italian::Ruby::Errori.recupera errore
+        end
 
     end
   end
-end
+end

data/lib/italian/ruby/traduttore/linea.rb

@@ -0,0 +1,144 @@
+# frozen_string_literal: true
+require_relative "stringa"
+require_relative "pezzo"
+
+##
+# La classe Linea rappresenta una linea di codice sorgente scritta
+# in ItalianRuby.
+#
+# Una Linea espone il metodo `traduci`, che quando chiamato, effettua
+# la traduzione della linea in sorgente Ruby.
+#
+# La traduzione viene fatta cercando se nella linea ci sono stringhe
+# o commenti. Nel caso in cui siano presenti commenti, che iniziano prima di
+# ogni altra stringa, tutta la parte di commento viene restituita come tale.
+# Se invece vengono trovate delle stringhe, che iniziano prima
+# dell'eventuale commento, esse vengono gestite in modo separato.
+#
+# Per ogni stringa, se essa è interpolabile, viene ricercato se è presente
+# un'interpolazione. Se trovata, essa viene re-interpretata come
+# una nuova Linea. Altrimenti, la stringa viene restituita come tale.
+module Italian
+  module Ruby
+    class Traduttore
+      class Linea
+
+        def initialize(contenuto, indice, nome_archivio)
+          @contenuto      = contenuto
+          @indice         = indice
+          @nome_archivio  = nome_archivio
+
+          trova_posizione_primo_commento
+          trova_posizioni_stringhe
+        end
+
+        ##
+        # Traduce la linea in codice Ruby.
+        def traduci
+          @pezzi_da_tradurre = []
+
+          if @posizione_primo_commento != nil
+            if @stringhe.none? or @posizione_primo_commento < @stringhe[0].posizione_iniziale
+              dividi_usando_posizione_commento
+            else
+              dividi_usando_posizioni_stringhe
+            end
+          else
+            if @stringhe.none?
+              dividi_in_pezzo_unico
+            else
+              dividi_usando_posizioni_stringhe
+            end
+          end
+
+          @pezzi_da_tradurre.map(&:traduci).join
+        end
+
+        private
+
+          ##
+          # Trova la posizione del primo commento all'interno della linea.
+          def trova_posizione_primo_commento
+            @posizione_primo_commento = @contenuto.index "#"
+          end
+
+          ##
+          # Trova le strighe all'interno della linea. Le stringhe possono iniziare
+          # con il doppio apice ("), il singolo apice ('), o il percentuale-graffa (%{).
+          def trova_posizioni_stringhe
+            @stringhe = []
+
+            stringa_trovata = trova_prossima_stringa_partendo_da 0
+
+            while stringa_trovata != nil
+              @stringhe << stringa_trovata
+
+              inizio_nuova_ricerca = stringa_trovata.posizione_finale + 1
+              stringa_trovata = trova_prossima_stringa_partendo_da inizio_nuova_ricerca
+            end
+          end
+
+          ##
+          # Trova la prossima stringa sul contenuto, partendo dalla posizione indicata.
+          def trova_prossima_stringa_partendo_da(posizione_partenza)
+            tipo_stringa_corrente     = nil
+            posizione_inizio_stringa  = @contenuto.index /['"]|%\{/, posizione_partenza
+            return nil if posizione_inizio_stringa.nil?
+            return nil if @posizione_primo_commento != nil && @posizione_primo_commento < posizione_inizio_stringa
+
+            stringa_da_chiudere = Italian::Ruby::Traduttore::Stringa.new @contenuto, posizione_inizio_stringa
+            stringa_da_chiudere.ricerca_chiusura
+            stringa_da_chiudere
+          rescue Italian::Ruby::Errori::StringaNonTerminata => errore
+            Italian::Ruby::Errori.recupera errore, @nome_archivio, @indice + 1
+          end
+
+          ##
+          # Divide la linea in un pezzo unico, che contiene se stessa.
+          def dividi_in_pezzo_unico
+            @pezzi_da_tradurre = [ Italian::Ruby::Traduttore::Pezzo.new(@contenuto) ]
+          end
+
+          ##
+          # Divide la linea in pezzi, usando la posizione del commento.
+          def dividi_usando_posizione_commento
+            if @posizione_primo_commento == 0
+              @pezzi_da_tradurre = [ Italian::Ruby::Traduttore::Pezzo.new(@contenuto) ]
+              return
+            end
+
+            @pezzi_da_tradurre = [
+              Italian::Ruby::Traduttore::Pezzo.new(@contenuto[0..@posizione_primo_commento - 1]),
+              Italian::Ruby::Traduttore::Pezzo.new(@contenuto[@posizione_primo_commento..])
+            ]
+          end
+
+          ##
+          # Divide la linea in pezzi, usando le posizioni delle stringhe trovate.
+          def dividi_usando_posizioni_stringhe
+            @pezzi_da_tradurre  = []
+            cursore_contenuto   = 0
+
+            @stringhe.each do |stringa|
+              unless stringa.posizione_iniziale == cursore_contenuto
+                pezzo_non_stringa = @contenuto[cursore_contenuto..stringa.posizione_iniziale - 1]
+                @pezzi_da_tradurre << Italian::Ruby::Traduttore::Pezzo.new(pezzo_non_stringa)
+              end
+
+              pezzo_stringa = @contenuto[stringa.posizione_iniziale..stringa.posizione_finale]
+              @pezzi_da_tradurre << Italian::Ruby::Traduttore::Pezzo.new(pezzo_stringa)
+              cursore_contenuto = stringa.posizione_finale + 1
+            end
+
+            if cursore_contenuto < @contenuto.length - 1
+              pezzo_non_stringa = @contenuto[cursore_contenuto..]
+              @pezzi_da_tradurre << Italian::Ruby::Traduttore::Pezzo.new(pezzo_non_stringa)
+            end
+
+            @pezzi_da_tradurre
+          end
+
+      end
+    end
+  end
+end