italian-ruby 0.9.18 → 1.0.4

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

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+require "rspec"
+require "rspec/mocks"
+
+module RSpec
+
+  def self.descrivi(*args, &block)
+    describe *args, &block
+  end
+  def self.variabili_condivise(*args, &block)
+    shared_context *args, &block
+  end
+  def self.contesto_condiviso(*args, &block)
+    shared_context *args, &block
+  end
+
+  module Core
+    class ExampleGroup
+      define_example_group_method     :contesto
+
+      def classe_descritta
+        described_class
+      end
+
+      def risposta(*args, &block)
+        last_response *args, &block
+      end
+    end
+  end
+
+  module Expectations
+    class ExpectationTarget
+      module InstanceMethods
+        def che(*args, &block)
+          to *args, &block
+        end
+
+        def che_non(*args, &block)
+          not_to *args, &block
+        end
+      end
+    end
+  end
+
+  module Mocks
+    class TargetBase
+      def che(*args)
+        to *args
+      end
+      def che_non(*args)
+        not_to *args
+      end
+
+      private
+
+        def matcher_allowed?(matcher)
+          matcher.class.name.start_with?("RSpec::Mocks::Matchers".freeze) or
+          matcher.class.name.start_with?("RSpec::Matchers::AliasedMatcher".freeze)
+        end
+
+    end
+
+  end
+end

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

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+require "socket"
+
+class UNIXSocket
+
+  def guarda(maxlen)
+    recv_nonblock maxlen, Socket::MSG_PEEK
+  end
+
+end
+
+class TCPSocket
+
+  def guarda(maxlen)
+    recv_nonblock maxlen, Socket::MSG_PEEK
+  end
+
+end

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

@@ -0,0 +1,174 @@
+# frozen_string_literal: true
+
+class String
+
+  ##
+  # Codici colori.
+  CODICI_COLORI = Hash[
+    rosso:      "31",
+    verde:      "32",
+    giallo:     "33",
+    blu:        "34",
+    magenta:    "35",
+    azzurro:    "36",
+    arancione:  "38;5;214"
+  ].freeze
+
+  ##
+  # 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 CODICI_COLORI[:rosso]
+    end
+
+    def verde
+      colorize CODICI_COLORI[:verde]
+    end
+
+    def giallo
+      colorize CODICI_COLORI[:giallo]
+    end
+
+    def blu
+      colorize CODICI_COLORI[:blu]
+    end
+
+    def magenta
+      colorize CODICI_COLORI[:magenta]
+    end
+
+    def azzurro
+      colorize CODICI_COLORI[:azzurro]
+    end
+
+    def arancione
+      colorize CODICI_COLORI[:arancione]
+    end
+
+    def decolorizza
+      self.gsub /(\u001b\[3\dm|\u001b\[3\d;\d;\d\d\dm|\u001b\[0m)/, ""
+    end
+
+    def disaccoppia_colore
+      indice_inizio_colore    = self.index "m"
+      codice_colore           = self[2..indice_inizio_colore - 1]
+
+      porzione_decolorizzata  = self[indice_inizio_colore + 1..-5]
+      colore                  = CODICI_COLORI.invert.fetch codice_colore
+
+      [ colore, porzione_decolorizzata ]
+    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
+
+  ##
+  # Restituisce l'ultimo indice della stringa.
+  def ultimo_indice
+    self.length - 1
+  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