italian-ruby 0.9.17 → 1.0.3

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

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+require "date"
+
+class Date
+  class << self
+
+    ##
+    # Restituisce la data di domani.
+    def domani
+      oggi + 1
+    end
+  
+    ##
+    # Restituisce la data di ieri.
+    def ieri
+      oggi - 1
+    end
+
+  end
+
+  ##
+  # Restituisce la data di oggi a due anni fa.
+  def due_anni_fa
+    self.prev_year.prev_year
+  end
+
+  ##
+  # Formatta la data secondo la rappresentazione passata.
+  def formatta_locale(format)
+    formattazione = strftime format
+    formattazione
+      .gsub(/January/i,     "Gennaio")
+      .gsub(/February/i,    "Febbraio")
+      .gsub(/March/i,       "Marzo")
+      .gsub(/April/i,       "Aprile")
+      .gsub(/May/i,         "Maggio")
+      .gsub(/June/i,        "Giugno")
+      .gsub(/July/i,        "Luglio")
+      .gsub(/August/i,      "Agosto")
+      .gsub(/September/i,   "Settembre")
+      .gsub(/October/i,     "Ottobre")
+      .gsub(/November/i,    "Novembre")
+      .gsub(/December/i,    "Dicembre")
+  end
+
+end

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

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+class Hash
+
+  ##
+  # Determina se una mappa non è nulla e non è vuota.
+  def esiste?
+    !nil? && !empty?
+  end
+
+  ##
+  # Determina se una mappa è nulla o è vuota.
+  def non_esiste?
+    !esiste?
+  end
+
+  ##
+  # Determina se una mappa non ha una data chiave.
+  def non_ha_chiave?(key)
+    !has_key? key
+  end
+
+  ##
+  # Restituisce la mappa con le chiavi convertite in simbolo.
+  # Viene sostituita la mappa esistente.
+  def simbolizza!
+    keys.each do |key|
+      value = delete key
+      value.simbolizza! if value.is_a? Hash or value.is_a? Array
+      self[key.to_sym] = value
+    end
+    self
+  end
+
+  ##
+  # Restituisce la mappa con le chiavi convertite in simbolo.
+  # Viene creata una nuova mappa.
+  def simbolizza
+    copy = Hash.new
+    self.each do |key, value|
+      if value.is_a? Hash or value.is_a? Array
+        copy[key.to_sym] = value.simbolizza
+      else
+        copy[key.to_sym] = value
+      end
+    end
+    copy
+  end
+
+  ##
+  # Espone le chiavi passate in una nuova mappa.
+  def esponi(*keys)
+    return self if keys.none?
+    self.select { |key, value| key.in? keys }
+  end
+
+end

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

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+class Integer
+
+  ##
+  # Restituisce l'ammontare di secondi corrispondenti
+  # al numero passato.
+  def secondi
+    self
+  end
+
+  ##
+  # Restituisce l'ammontare di minuti corrispondenti
+  # al numero passato.
+  def minuti
+    self.secondi * 60
+  end
+
+  ##
+  # Restituisce l'ammontare di ore corrispondenti
+  # al numero passato.
+  def ore
+    self.minuti * 60
+  end
+
+  ##
+  # Restituisce l'ammontare di giorni corrispondenti
+  # al numero passato.
+  def giorni
+    self.ore * 24
+  end
+
+  ##
+  # Sottrae il numero di secondi dal tempo attuale.
+  def fa
+    Time.now - self
+  end
+
+  ##
+  # Aggiunge il numero di secondi dal tempo attuale.
+  def da_ora
+    Time.now + self
+  end
+
+end

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

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module JSON
+
+  ##
+  # Processa la stringa come JSON.
+  def self.processa(*args)
+    self.parse(*args)
+  end
+
+  ##
+  # Converte l'oggetto in una stringa JSON.
+  def self.in_stringa(*args)
+    self.dump(*args)
+  end
+
+end

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

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+require_relative "../errori"
+
+##
+# Aggiunge i metodi :richiedi e :richiedi_relativo, che permettono di caricare
+# un file sorgente scritto in Italian Ruby e usarlo allo stesso modo di come
+# funzionano :require e :require_relative di Ruby standard.
+#
+# È possibile utilizzare :richiedi e :richiedi_relativo sia in file sorgenti
+# scritti in Italian Ruby che in file sorgenti scritti in Ruby standard.
+module Kernel
+
+  ##
+  # Richiede un archivio da caricare in memoria.
+  # Se l'archivio è trovato nei percorsi di caricamento presenti in memoria,
+  # e scritto in ItalianRuby, allora viene tradotto e caricato.
+  # Altrimenti viene cercato e caricato come un archivio Ruby standard.
+  def richiedi(archivio)
+    archivi_in_memoria = $:.map do |cartella|
+      Dir["#{cartella}/**/#{archivio}.ir"]
+    end
+    archivio_in_italiano_da_richiedere = archivi_in_memoria.flatten.compact.first
+    return traduci_e_carica archivio_in_italiano_da_richiedere if archivio_in_italiano_da_richiedere != nil
+
+    # Non è stato trovato nessun archivio in italiano corrispondente al nome
+    # passato. Viene ora tentato il caricamento di un file Ruby originale con
+    # lo stesso nome.
+    require archivio
+  rescue LoadError => errore
+    sorgenti_chiamanti = caller_locations.reject do |locazione|
+      locazione.absolute_path.include? "lib/italian/ruby/metodi/kernel"
+    end
+    sorgente_chiamante  = sorgenti_chiamanti.first.absolute_path
+    numero_linea_errata = sorgenti_chiamanti.first.lineno
+    Italian::Ruby::Errori.recupera errore, sorgente_chiamante, numero_linea_errata
+  end
+
+  ##
+  # Richiede un archivio cercandolo come percorso relativo.
+  def richiedi_relativo(percorso_archivio)
+    sorgente_chiamante      = Italian::Ruby.percorso_archivio_non_tradotto caller_locations.first.absolute_path
+    linea_chiamante         = caller_locations.first.lineno
+    cartella_chiamante      = File.dirname sorgente_chiamante
+    archivio_da_richiedere  = File.expand_path File.join(cartella_chiamante, percorso_archivio)
+    archivio_da_richiedere  = Dir["#{archivio_da_richiedere}.{ir,rb}"].compact.first
+
+    raise LoadError, "cannot load such file -- #{percorso_archivio}" if archivio_da_richiedere.nil?
+    traduci_e_richiedi archivio_da_richiedere
+  rescue LoadError => errore
+    Italian::Ruby::Errori.recupera errore, sorgente_chiamante, linea_chiamante
+  end
+
+  ##
+  # Richiede tutti gli archivi di una cartella.
+  def richiedi_tutti(percorso_cartella)
+    sorgente_chiamante      = Italian::Ruby.percorso_archivio_non_tradotto caller_locations.first.absolute_path
+    linea_chiamante         = caller_locations.first.lineno
+    cartella_chiamante      = File.dirname sorgente_chiamante
+    cartella_da_richiedere  = File.expand_path File.join(cartella_chiamante, percorso_cartella)
+    cartella_da_richiedere  = nil unless Dir.exist? cartella_da_richiedere
+
+    raise LoadError, "cannot load such directory -- #{percorso_cartella}" if cartella_da_richiedere.nil?
+    Dir["#{cartella_da_richiedere}/**/*.ir"].sort_by { |file| file.count("/") }.each do |archivio|
+      traduci_e_richiedi archivio
+    end
+  rescue LoadError => errore
+    Italian::Ruby::Errori.recupera errore, sorgente_chiamante, linea_chiamante
+  end
+
+  private
+
+    ##
+    # Traduce un file da ItalianRuby a Ruby e lo carica in memoria.
+    def traduci_e_carica(archivio)
+      archivio_tradotto = Italian::Ruby::Traduttore.traduci archivio
+      load archivio_tradotto
+    end
+
+    ##
+    # Traduce un file da ItalianRuby a Ruby e lo richiede.
+    def traduci_e_richiedi(archivio)
+      archivio_tradotto = Italian::Ruby::Traduttore.traduci archivio
+      require archivio_tradotto
+    end
+
+end

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

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+##
+# Include un modulo.
+def includi(*args)
+  include *args
+end
+
+##
+# Prepone un modulo.
+def preponi(*args)
+  prepend *args
+end
+
+##
+# Estende con un modulo.
+def estendi(*args)
+  extend *args
+end
+
+##
+# Solleva un errore.
+def alza(*args)
+  raise *args
+end
+
+##
+# Termina il programma.
+def fallisci(*args)
+  fail *args
+end

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

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+class Module
+
+  private
+
+    ##
+    # Metodo delegato per la chiamata di ritorno da
+    # avviare quando il modulo viene incluso.
+    def quando_incluso(*args)
+    end
+
+    ##
+    # Metodo delegato per la chiamata di ritorno da
+    # avviare quando il modulo viene esteso.
+    def quando_esteso(*args)
+    end
+
+    ##
+    # Metodo delegato per la chiamata di ritorno da
+    # avviare quando il modulo viene preposto.
+    def quando_preposto(*args)
+    end
+
+    ##
+    # Sovrascrive il metodo originale in modo che chiami
+    # il metodo delegato.
+    def included(*args)
+      quando_incluso *args
+    end
+
+    ##
+    # Sovrascrive il metodo originale in modo che chiami
+    # il metodo delegato.
+    def extended(*args)
+      quando_esteso *args
+    end
+
+    ##
+    # Sovrascrive il metodo originale in modo che chiami
+    # il metodo delegato.
+    def prepended(*args)
+      quando_preposto *args
+    end
+
+end

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

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+class NilClass
+
+  ##
+  # Determina se il nullo non è tale.
+  def esiste?
+    !nil?
+  end
+
+end

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

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+class Object
+
+  ##
+  # Assegna il valore chiamando il metodo passato come
+  # un metodo di assegnamento.
+  def assegna(method, value)
+    self.send "#{method}=", value
+  end
+
+  ##
+  # Determina se l'oggetto non è nullo.
+  def esiste?
+    !nil?
+  end
+
+  ##
+  # Determina se l'oggetto è nullo.
+  def non_esiste?
+    !esiste?
+  end
+
+  ##
+  # Determina se l'oggetto non è istanza di una data classe.
+  def non_è_un?(arg)
+    !is_a? arg
+  end
+
+  ##
+  # Determina se l'oggetto non risponde a un dato metodo.
+  def non_risponde_a?(method)
+    !respond_to? method
+  end
+
+  ##
+  # Determina se l'oggetto è incluso in una lista.
+  def in?(array)
+    raise ArgumentError.new("Argument passed to `in?` must respond to `include?`") unless
+      array.respond_to? :include?
+    array.include? self
+  end
+
+  ##
+  # Determina se l'oggetto non è incluso in una lista.
+  def non_in?(array)
+    !in? array
+  end
+
+  ##
+  # Converte l'oggetto in JSON.
+  def in_json
+    to_json
+  end
+
+  private
+
+    ##
+    # Metodo per riferire l'oggetto stesso.
+    def istanza
+      self
+    end
+
+end

data/lib/italian/ruby/{core_ext → metodi}/open_struct.rb

@@ -1,11 +1,10 @@
+# frozen_string_literal: true
 require "ostruct"
 
-##
-# Core Ext - OpenStruct
-#
-# Alias di metodi della classe OpenStruct.
-
 class OpenStruct
+
+  ##
+  # Converte la mappa aperta in una mappa normale.
   def in_mappa(*args)
     hash = to_h *args
     hash.in_mappa do |key, value|
@@ -16,6 +15,5 @@ class OpenStruct
       end
     end
   end
-end
 
-Archivio = OpenStruct
+end

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

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+class Range
+
+  ##
+  # Determina se un intervallo non include un valore.
+  def non_include?(*args)
+    !include? *args
+  end
+
+end