italian-ruby 0.1.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: e77bc57386211592f254fc0a17f9b2ce05c31453d5115bb23aacb3fa56759192
+  data.tar.gz: 03b44542875df8c82407332db861544a5766fd12551e0dc1dbcb8ad8f9697b7e
+SHA512:
+  metadata.gz: d0b5e0f98b9333652a89af5cb893f1e9e8aab144882053bfc27eb85f000870d0f3a4dea38be185d191f1cbb0c2f11e2af942f0ea92858fb7368b5806a51fb69d
+  data.tar.gz: 717a0ebc33dc4ab89e3df7c1cb739ce1238121a5e705db031cef09e59b39c6725692a0ebd393e0c7bb992bc85fb3274afd5ac49ffeafbe3dc2295f526773c87d

data/.gitignore

@@ -0,0 +1,11 @@
+/.bundle/
+/.yardoc
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+
+# rspec failure tracking
+.rspec_status

data/.rspec

@@ -0,0 +1,3 @@
+--format documentation
+--color
+--require spec_helper

data/.ruby-version

@@ -0,0 +1 @@
+2.7.0

data/Gemfile

@@ -0,0 +1,4 @@
+source "https://rubygems.org"
+
+# Specify your gem's dependencies in italian-ruby.gemspec
+gemspec

data/Gemfile.lock

@@ -0,0 +1,42 @@
+PATH
+  remote: .
+  specs:
+    italian-ruby (0.1.0)
+      ruby2ruby (~> 2.4)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    diff-lcs (1.3)
+    rake (13.0.1)
+    rspec (3.9.0)
+      rspec-core (~> 3.9.0)
+      rspec-expectations (~> 3.9.0)
+      rspec-mocks (~> 3.9.0)
+    rspec-core (3.9.1)
+      rspec-support (~> 3.9.1)
+    rspec-expectations (3.9.0)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.9.0)
+    rspec-mocks (3.9.1)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.9.0)
+    rspec-support (3.9.2)
+    ruby2ruby (2.4.4)
+      ruby_parser (~> 3.1)
+      sexp_processor (~> 4.6)
+    ruby_parser (3.14.2)
+      sexp_processor (~> 4.9)
+    sexp_processor (4.14.1)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler (~> 2.1)
+  italian-ruby!
+  rake (~> 13.0)
+  rspec (~> 3.9)
+
+BUNDLED WITH
+   2.1.2

data/README.md

@@ -0,0 +1,107 @@
+# Italian::Ruby
+
+Benvenuti nella gemma `italian/ruby`.
+Scrivo questo tutorial in italiano, perché, diciamocelo, chi sarebbe interessato a questa gemma se non fosse italiano? La gemma è semplice. Ti permette di scrivere Ruby, ma usando la nostra cara lingua madre.
+
+Son da sempre convinto che una delle difficoltà della programmazione sia pensare e leggere il codice sorgente scritto in una lingua che non ti è nativa. Infatti, per quanto vogliamo raccontarcela e per quanti film in inglese scegliamo di guardare, finché viviamo in Italia, penseremo e parleremo in italiano.
+Questo vuol dire che, quando programmiamo software, dobbiamo pensare l'algoritmo, tradurlo in inglese, tradurlo in Ruby e poi scriverlo a tastiera. Allo stesso modo, quando leggiamo software, dobbiamo tradurre dall'inglese, tradurre dal Ruby e poi ricostruire l'algoritmo in testa.
+
+E se eliminassimo un passaggio? Beh diciamo che più che eliminarlo, lo facciamo fare ad una macchina. D'altra parte le macchine fan questo: attività ripetitive, banali, e stupide. Sì perché le macchine sono e resteranno sempre stupide. E non fatemi iniziare a parlare di "intelligenza" artificiale.. !
+Ecco il motivo della nascita di Italian Ruby.
+
+## Installazione
+
+Al solito.
+
+```ruby
+gem 'italian-ruby'
+```
+
+Oppure.
+
+```bash
+gem install italian-ruby
+```
+
+Per poterla usare bisogna caricarla.
+
+```ruby
+require "italian/ruby"
+```
+
+## Utilizzo
+
+Il codice sorgente in Italian Ruby è scritto in file con estensione `.ir`. Ho fatto anche una grammatica per l'evidenziazione della sintassi, funziona per VS Code, penso anche per altri editor, la trovate nel file `vscode/italianruby.tmGrammar.json` in questo repository.
+
+A questo punto ci sono due strade. Prima strada, usare l'eseguibile `italian-ruby`:
+
+```ruby
+# persona.ir
+classe Persona
+  def inizializzatore(nome)
+    @nome = nome
+  fine
+
+  def come_ti_chiami?
+    stampa "Ciao, mi chiamo #{@nome}."
+  fine
+fine
+
+toni = Persona.nuova("Toni")
+toni.come_ti_chiami?
+```
+
+Eseguendolo così:
+
+```bash
+italian-ruby persona.ir
+# Ciao, mi chiamo Toni.
+```
+
+Oppure si può richiedere all'interno di codice sorgente Ruby standard, in modo che venga caricato esattamente come fa il `require` di Ruby standard. Esempio:
+
+```ruby
+# libreria_interessantissima.rb
+modulo LibreriaInteressantissima
+  def se_stesso.metodo_interessantissimo
+    stampa "Che roba!"
+  fine
+fine
+
+# tuo_file_ruby.rb
+require "italian/ruby"
+richiedi_relativo "libreria_interessantissima"
+
+LibreriaInteressantissima.metodo_interessantissimo
+# Che roba!
+```
+
+È possibile anche utilizzare il `richiedi`, che funziona come il `require` di Ruby, nel remoto caso in cui _qualcuno_ faccia una gemma in Italian Ruby, la pubblichi su rubygems.org e _qualcun'altro_ la scarichi e la installi. Se mai succedesse, funzionerebbe così:
+
+```ruby
+# tuo_file_ruby.rb
+require "italian/ruby"
+richiedi "gemma_impossibile"
+
+GemmaImpossibile.esiste?
+# false
+```
+
+## Come funziona?
+
+> Vuoi sapere la verità su una cosa? Allora devi sapere **come funziona**.
+>
+> \- un tizio saggio, qualche anno fa.
+
+Volete sapere la verità su Italian Ruby? Ecco come funziona. Ho preso ispirazione da questa gemma che si chiama [Bato](https://github.com/jjuliano/bato). Praticamente è la stessa cosa di Italian Ruby solo che in filippino. Bato vuole dire "Roccia" in filippino. Bato funziona usando la gemma [RubyParser](https://github.com/seattlerb/ruby_parser) che parsa codice Ruby e lo converte in espressioni sexp, e la gemma [Ruby2Ruby](https://github.com/seattlerb/ruby2ruby) che converte espressioni sexp in codice Ruby.
+In mezzo a queste due, ci infiliamo la nostra gemma, che, patchando il ruby parser, legge codice in italiano e lo converte in espressioni sexp. Il trucco sta nel file `lib/italian/ruby/ruby_parser_patches.rb` dove vengono definite nuove keywords al posto di quelle originali (es. `classe` al posti di `class`).
+
+Bato però ha solo un binario che permette di eseguire codice filippino. Italian Ruby, invece, permette di inglobare codice italiano all'interno di progetti Ruby già esistenti. Avete un gigantesco codebase con megabyte di codice, ma volete riscrivere un solo piccolo pezzettino in italiano? Con Italian Ruby si può.
+
+Per concludere, ci sono degli avvertimenti.
+1. il namespace verrà sporcato. Ho fatto del mio meglio per essere più chirurgico possibile, ma se fate `require "italian/ruby"` sappiate che verranno su un sacco di classi e di alias nuovi (es. `Oggetto.nuovo` ecc.).
+2. il `richiedi` e `richiedi_relativo` funzionano traducendo un file sorgente in italiano nella stessa cartella in cui si trova, caricandolo in memoria con il `require` di Ruby, e poi cancellandolo. Non so se questo possa creare problemi. Immagino di no. Ma vi ho avvertito!
+
+## Contribuire
+
+Bug e issue qui -> https://github.com/[USERNAME]/italian-ruby.

data/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/bin/italian-rspec

@@ -0,0 +1,29 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "rspec"
+require "italian/ruby"
+
+def translate_spec(file)
+  spec_file = "#{File.dirname file}/#{File.basename(file, ".ir")}.rb"
+  File.write spec_file, Italian::Ruby::Traduttore.traduci(file)
+end
+
+def destroy_spec(file)
+  spec_file = "#{File.dirname file}/#{File.basename(file, ".ir")}.rb"
+  File.delete spec_file if File.exist? spec_file
+end
+
+if ARGV[0].nil?
+  spec_files = Dir["spec/**/*_spec.ir"]
+  if spec_files.empty?
+    "Nessun file *_spec.ir trovato."
+    return
+  end
+else
+  spec_files = ARGV
+end
+
+spec_files.each { |file| translate_spec file }
+RSpec::Core::Runner.run([ "spec" ], STDIN, STDOUT)
+spec_files.each { |file| destroy_spec file }

data/bin/italian-ruby

@@ -0,0 +1,18 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "italian/ruby"
+
+if ARGV[0].nil?
+  puts <<~EOS
+    Esegue un file scritto in Italian Ruby. Sintassi:
+    italian-ruby file.ir
+  EOS
+else
+  ARGV.each do |file|
+    next unless file
+
+    codice_ruby = Italian::Ruby::Traduttore.traduci file
+    eval codice_ruby
+  end
+end

data/italian-ruby.gemspec

@@ -0,0 +1,36 @@
+require_relative 'lib/italian/ruby/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "italian-ruby"
+  spec.version       = Italian::Ruby::VERSION
+  spec.authors       = ["Francesco Ballardin"]
+  spec.email         = ["francesco.ballardin@gmail.com"]
+  spec.licenses      = ["MIT"]
+
+  spec.summary       = %q{Program in Ruby writing in Italian.}
+  spec.description   = %q{Program in Ruby writing in Italian. Yay!}
+  spec.homepage      = "https://github.com/Pluvie/italian-ruby"
+  spec.required_ruby_version = Gem::Requirement.new(">= 2.3.0")
+
+  spec.metadata["allowed_push_host"] = "https://rubygems.org"
+
+  spec.metadata["homepage_uri"] = spec.homepage
+  spec.metadata["source_code_uri"] = "https://github.com/Pluvie/italian-ruby"
+  spec.metadata["changelog_uri"] = "https://github.com/Pluvie/italian-ruby/CHANGELOG.md"
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files         = Dir.chdir(File.expand_path('..', __FILE__)) do
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  end
+  spec.bindir        = "bin"
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency 'ruby2ruby',    '~> 2.4'
+
+  spec.add_development_dependency 'bundler',    '~> 2.1'
+  spec.add_development_dependency 'rake',       '~> 13.0'
+  spec.add_development_dependency 'rspec',      '~> 3.9'
+end

data/lib/italian/ruby/core_ext/array.rb

@@ -0,0 +1,23 @@
+##
+# Core Ext - Array
+#
+# Alias di metodi della classe Array.
+
+class Array
+  alias         :per_ogni             :each
+  alias         :per_ognuno           :each
+  alias         :per_ognuna           :each
+  alias         :mappa                :map
+  alias         :vuoto?               :empty?
+  alias         :vuota?               :empty?
+  alias         :primo                :first
+  alias         :prima                :first
+  alias         :ultimo               :last
+  alias         :ultima               :last
+
+  def esiste?
+    !nil? && !empty?
+  end
+end
+
+Lista = Array

data/lib/italian/ruby/core_ext/hanami/interactor.rb

@@ -0,0 +1,50 @@
+##
+# Core Ext - Hanami::Interactor
+
+module Hanami
+  module Interactor
+    alias               :fallisci!          :error!
+    alias               :errore!            :error!
+    alias               :errore             :error
+
+    module LegacyInterface
+      def chiama
+        _call { super }
+      end
+    end
+    module Interface
+      def chiama(*args)
+        @__result = ::Hanami::Interactor::Result.new
+        _call(*args) { super }
+      end
+    end
+
+    class Result
+      alias             :riuscito?          :successful?
+      alias             :errore             :error
+  
+      def fallito?
+        !successful?
+      end
+    end
+
+    Risultato = Result
+  end
+
+  Interattore = Interactor
+
+  module ClassMethods
+    alias             :esponi             :expose
+
+    def method_added(method_name)
+      super
+      return unless method_name == :chiama
+
+      if instance_method(:chiama).arity.zero?
+        prepend Hanami::Interactor::LegacyInterface
+      else
+        prepend Hanami::Interactor::Interface
+      end
+    end
+  end
+end

data/lib/italian/ruby/core_ext/hanami/mongoid.rb

@@ -0,0 +1,14 @@
+##
+# Core Ext - Hanami Mongoid
+
+module Hanami
+  module Mongoid
+    class Repository
+
+      def tutti(*args, &block)
+        all *args, &block
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,25 @@
+##
+# Core Ext - Hash
+#
+# Alias di metodi della classe Hash.
+
+class Hash
+  alias         :per_ogni             :each
+  alias         :per_ognuno           :each
+  alias         :per_ognuna           :each
+  alias         :chiavi               :keys
+  alias         :valori               :values
+  alias         :mappa                :map
+  alias         :vuoto?               :empty?
+  alias         :vuota?               :empty?
+  alias         :ottieni              :fetch
+  alias         :scava                :dig
+  alias         :trasforma_chiavi     :transform_keys
+  alias         :trasforma_valori     :transform_values
+
+  def esiste?
+    !nil? && !empty?
+  end
+end
+
+Mappa = Hash

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

@@ -0,0 +1,56 @@
+##
+# CoreExt - Kernel
+#
+# 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
+
+  def richiedi(name)
+    file_to_require = $:.map { |dir|  Dir["#{dir}/**/#{name}.ir"] }.flatten.compact.first
+    raise LoadError.new("cannot load such file -- #{name}") if file_to_require.nil?
+
+    traduci_carica_e_distruggi file_to_require
+  end
+
+  def richiedi_relativo(name)
+    caller_location_dir = File.dirname caller_locations.first.absolute_path
+    file_to_require = File.expand_path "#{caller_location_dir}/#{name}.ir"
+    raise LoadError.new("cannot load such file -- #{name}") unless File.exist? file_to_require
+
+    traduci_carica_e_distruggi file_to_require
+  end
+
+  def richiedi_assoluto(file)
+    raise LoadError.new("cannot load suc file -- #{file}") unless File.exist? file
+    traduci_carica_e_distruggi file
+  end
+
+  def richiedi_tutti(dir)
+    caller_location_dir = File.dirname caller_locations.first.absolute_path
+    raise LoadError.new("cannot load such directory -- #{dir}") unless Dir.exist? caller_location_dir
+
+    Dir["#{caller_location_dir}/**/*.ir"].each do |file|
+      richiedi_assoluto file
+    end
+  end
+
+  private
+
+    def traduci_carica_e_distruggi(file_to_require)
+      parsed_code = Italian::Ruby::Traduttore.traduci file_to_require
+      file_to_require_dir = File.dirname(file_to_require)
+      file_to_require_basename = File.basename(file_to_require, ".ir")
+      tmp_parsed_file = "#{file_to_require_dir}/#{file_to_require_basename}.rb"
+
+      File.write tmp_parsed_file, parsed_code
+      require_output = require tmp_parsed_file
+      File.delete tmp_parsed_file if File.exist? tmp_parsed_file
+      require_output
+    end
+
+end

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

@@ -0,0 +1,39 @@
+##
+# Core Ext - Main
+#
+# Alias di metodi del namespace principale.
+
+alias     :stampa                       :puts
+alias     :cicla                        :loop
+alias     :definisci_metodo_singolo     :define_singleton_method
+
+def includi(*args)
+  include *args
+end
+def preponi(*args)
+  prepend *args
+end
+def estendi(*args)
+  extend *args
+end
+
+def privati(*args)
+  private
+end
+def protetti(*args)
+  protected
+end
+def pubblici(*args)
+  public
+end
+
+def alza(*args)
+  raise *args
+end
+def fallisci(*args)
+  fail *args
+end
+
+def non_in?(*args)
+  !in? *args
+end

data/lib/italian/ruby/core_ext/mongoid/criteria.rb

@@ -0,0 +1,19 @@
+##
+# Core Ext - Mongoid Criteria
+
+module Mongoid
+  class Criteria
+    def tutti(*args, &block)
+      all *args, &block
+    end
+
+    def dove(*args, &block)
+      where *args, &block
+    end
+
+    def dati
+      entries
+    end
+    alias       :voci         :dati
+  end
+end

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

@@ -0,0 +1,31 @@
+##
+# Core Ext - Oggetti
+#
+# Alias di metodi della classe Object.
+
+class Object
+  class << self
+    alias_method      :nuovo,               :new
+    alias_method      :nuova,               :new
+  end
+
+  alias               :nullo?               :nil?
+  alias               :nulla?               :nil?
+  alias               :risponde_a?          :respond_to?
+
+  def esiste?
+    !nil?
+  end
+
+  private
+
+    def inizializzatore(*args, &block)
+    end
+
+    def initialize(*args, &block)
+      inizializzatore *args, &block
+    end
+
+end
+
+Oggetto = Object

data/lib/italian/ruby/core_ext/rspec/core.rb

@@ -0,0 +1,27 @@
+##
+# Core Ext - Rspec Core
+
+module RSpec
+  def self.descrivi(*args, &block)
+    describe *args, &block
+  end
+
+  module Core
+    module Hooks
+      alias_method    :prima,       :before
+      alias_method    :dopo,        :after
+    end
+  end
+end
+
+RSpec.configure do |config|
+  RSpec::Matchers.alias_matcher :sia,               :be
+  RSpec::Matchers.alias_matcher :equivalga_a,       :eq
+
+  config.alias_example_to :esso
+  config.alias_example_to :essa
+
+  config.before :each do
+    alias         :verifica           :expect
+  end
+end

data/lib/italian/ruby/core_ext/rspec/expectations.rb

@@ -0,0 +1,18 @@
+##
+# Core Ext - Rspec Expectations
+
+module RSpec
+  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
+end

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

@@ -0,0 +1,8 @@
+##
+# Core Ext - Stringhe
+#
+# Alias di metodi della classe String.
+
+class String
+  alias       :congela        :freeze
+end

data/lib/italian/ruby/core_ext.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+original_verbosity = $VERBOSE
+$VERBOSE = nil
+
+require_relative "core_ext/kernel"
+require_relative "core_ext/main"
+require_relative "core_ext/object"
+require_relative "core_ext/array"
+require_relative "core_ext/hash"
+require_relative "core_ext/string"
+
+$VERBOSE = original_verbosity

data/lib/italian/ruby/richiedi_test.ir

@@ -0,0 +1,5 @@
+modulo RichiediTest
+  def se_stesso.funziona?
+    stampa "si, funziona!"
+  fine
+fine