Ruby Language and some applications - Dott. Giovanni Nigita

Ruby Language and some
      applications

     Dott. Giovanni Nigita

Panoramica
u   Introduzione
u   Gli strumenti in Ruby
u   Convenzioni e programmazione ad oggetti
u   Tipi di dati
u   Strutture di controllo
u   Ereditarietà ?!?
u   Gestione file e directory
u   Espressioni regolari
u   Altre cose…
u   Pacchetti di Ruby
u   Il pacchetto “HPRICOT”

Introduzione – La storia (I)
•   Il linguaggio di programmazione Ruby è stato progettato nel
    1993 dal giapponese Yukihiro Matsumoto

•   Ma inizialmente non ebbe molto successo!

Introduzione – La storia (II)
•   Per più di un decennio non prese mai il decollo

•   Inizialmente la documentazione era esclusivamente in
    giapponese!!!

Introduzione – La storia (III)
•   L’anno di svolta fu il 2006!
•   Anno in cui si affermarono i framework Ruby on Rails.

                  http://rubyonrails.org/

Introduzione – La storia (IV)
•   Adesso abbiamo veramente tanta documentazione, sia
    in inglese

               http://www.ruby-lang.org/en/

•   che in italiano!

               http://www.ruby-lang.org/it/

Introduzione – Alcune
                  caratteristiche (I)
•   Ruby è un linguaggio:
    • open source
    • general purpose
    • interpretato
    • orientato agli oggetti

•   Possiamo definirlo come un linguaggio che ha acquisito tanto da parte
    di altri linguaggi come: Smalltalk, Perl, Python, C, C++, PHP, Phyton
    …

http://www.ruby-lang.org/en/documentation/ruby-from-other-languages/

•   Infatti uno dei primi slogan era il seguente:

                            (Smalltalk + Perl) / 2

Introduzione – Alcune
           caratteristiche (II)
•   Per cui avendo preso qualcosa da altri linguaggi di certo
    molti aspetti sintattici ritorneranno familiari.

•   Per cui dovrebbe essere relativamente semplice la
    comprensione di tale linguaggio!

Gli strumenti in Ruby –
        Interprete di Ruby (I)

•   Quello di cui abbiamo bisogno è di un editor di teso e
    di un interprete.

•   Per vedere le varie opzioni dell’interprete lanciamo
    dalla shell il comando - -help

                        ruby --help

Gli strumenti in Ruby –
         Interprete di Ruby (II)
•   -c: avviene un controllo della sintassi del codice, e se tutto
    corretto ritorna “Syntax OK”. In questo caso il codice non
    viene eseguito.
•   -d, -debug: se si vuole effettuare un debug
•   -e ‘command’: avviene l’esecuzione del comando passato
    come argomento
•   -v, --verbose: vengono mostrate in output delle
    informazioni addizionali quali la versione dell’interprete,
    warning in fase di compilazione,
•   …

Gli strumenti in Ruby –
            Interactive Ruby
•   Oltre all’interprete troviamo pure una shell interattiva!
•   Permette di sperimentare in real time le potenzialità di questo
    linguaggio ed è molto utile in fasi di sperimentazione.
•   Tra le funzionalità di questa shell abbiamo la “Tab
    Completation”!
•   Per sfruttare questo utile strumento, basta eseguire da
    terminare il comando “irb”
•   In particolare con il comando “irb -- help”, è possibile
    avere una lista di opzioni che si possono affiancare al
    comando irb.

Gli strumenti in Ruby – RDoc
              and Ri (I)
•    Tramite lo strumento RDoc (Ruby Documentation System) si
     può avere la documentazione completa estratta dai file
     sorgenti

•    Tale documentazione viene fornita sia in formato html sia
     formattata per l’utility “ri”, quest’ultimo è un tool che
     permette di visualizzare di visualizzare la documetazione da
     linea di comando

•    Potete scaricare l’ultima versione andando nel seguente link:

                    http://rdoc.rubyforge.org/

Gli strumenti in Ruby – RDoc
             and Ri (II)
•    Esempio, eseguendo dal terminale il comando:

                      ri String.chomp

•    otterremo la documentazione relativa alla funzione
     chomp:

Gli strumenti in Ruby – eRuby (I)
 •   Tramite lo strumento eRuby (embedded Ruby) è
     possibile inserire codice Ruby all’interno di pagine
     HTML. Per cui, come nel caso di PHP, si possono
     creare delle pagine dinamiche.

 •   Il codice Ruby viene incorporato all’interno dei
     delimitatori 

 •   Ovviamente, i blocchi di codici inseriti vengono
     valutati sul posto e vengono sostituiti dal risultato della
     loro valutazione.

Gli strumenti in Ruby – eRuby (II)
 •   Una linea di Ruby:
                          
 •   Linee multiple:

            Hello guys
       
       Output:
          • Hello guys
          • Hello guys

Gli strumenti in Ruby – eRuby (III)
 •   Se si incontra la linea di codice:
                     
 •   allora viene valutata l’espressione e ne restituisce il
     valore, inoltre ogni linea di questo tipo
                          
 •   rappresenta un commento.

Gli strumenti in Ruby – eRuby (IV)
 •   Abbiamo diverse implementazioni di eRuby:
     • eruby: è un implementazione di eRuby scritta in C
     • erb: è una implementazione di eRuby scritto
        puramente Ruby ed include le sue librerie standard
     • erubis: è una implementazione di eRuby in Ruby e
        in Java
 •   Queste implementazioni rappresenta una buona
     alternativi agli altri linguaggi come PHP, Perl,
     ASP…

Gli strumenti in Ruby – Le
                 librerie di base
•   In ambiente Unix le librerie di base si troveranno nel seguente percorso:

                                    /usr/lib/ruby

•   mentre in ambiente Windows risiedono nella directory

                                 c:\ruby\lib\ruby\

•   In entrambi i percorsi possiamo trovare le seguenti cartelle:
    •   1.8: (attualmente siamo alla versione 1.9, anche se vi ritroverete sicuramente
        pre-installata la 1.8) contiene i moduli e le estensioni standard
    •   gems: contiene le librerie e le applicazioni installate con l’utility RubyGems
    •   site_ruby: contiene i moduli e le estensioni aggiunte dal programmatore e che
        non sono incluse nella distribuzione di base

Gli strumenti in Ruby – RubyGems
 •   RubyGems è un framework che gestisce le applicazioni
     e le librerie sotto forma di pacchetti chiamati “gems”.

 •   Esso permette di cercare, installare, disinstallare e
     aggiornare le librerie.

 •   Nel link sottostante si possono trovare le librerie dalla
     A allo Zinco… 

                    http://rubygems.org/

Convenzioni e
           programmazione OO –
                  I nomi(I)
•   I nomi in Ruby fanno riferimento a costanti, variabili, metodi, classsi
    e moduli, nonostante alcune parole sono riservate:

•   Tramite il primo carattere del nome, Ruby distingue il modo in
    cui viene utilizzato.
•   Un nome può essere una lettera minuscola, maiuscola o un
    underscore, seguito da qualsiasi altro carattere che sia una
    combinazione dei simboli appartenenti alle tre precedenti
    categorie.

Convenzioni e
          programmazione OO –
                I nomi(II)
•   Le variabili non sono tipizzate, per cui possono contenere
    qualsiasi tipo di dato.
•   Dal nome della variabile viene dedotto il suo scopo, ossia se
    essa stessa sia locale, globale, istanza, ecc…:
    •   il nome di variabili locali devono essere dichiarate con un
        lettera minuscola o con un carattere underscore
    •   le variabili globali iniziano con il simbolo $
    •   le variabili di istanza con il simbolo @
    •   quelle di classe con due simboli @
    •   se si vuole specificare una costante il nome deve iniziare con
        una lettera maiuscola

Convenzioni e
          programmazione OO –
                I nomi(III)
•   Il nome di classe e di modulo sono costanti, e seguono la
    convenzione utilizzata per le variabili costanti.

•   Il nome del metodo inizia con un lettera minuscola seguita
    da altri caratteri. Come caratteri speciali possono contenere,
    come suffisso, solo il simbolo “!” e quello “?”.

Convenzioni e
          programmazione OO –
                I commenti
•   I commenti all’interno di un codice vengono inseriti
    attraverso il carattere “#”. Tutto quello che seguirà tale
    carattere non verrà considerato.

•   Inoltre, è possibile fare un commento multiriga, e questo è
    possibile farlo mettendo il testo che si vuole commentare tra
    i tag =begin e =end:

Convenzioni e
    programmazione OO –
Qualche nozione non guasta mai! (I)
          In Ruby ogni cosa è un
                oggetto!!!

Convenzioni e
        programmazione OO –
Qualche nozione non guasta mai! (II)
•   Questo paradigma di programmazione prevede di
    raggruppare in un porzione circoscritta (classe) del codice
    sorgente la dichiarazione delle strutture dati e delle procedure
    che operano su di esse.
•   Nella programmazione orientata agli oggetti (OOP, Object
    Oriented Programming) un oggetto può essere visto come un
    contenitore di dati dotato di attributi (dati) dotato di una
    serie di metodi (procedure) secondo quanto dichiarato dalle
    rispettive classi.
•   Un linguaggio è definito ad oggetti quando permette di
    implementare tre meccanismi chiamati incapsulamento,
    ereditarietà e polimorfismo.

Convenzioni e
       programmazione OO –
Qualche nozione non guasta mai! (III)
•   L’oggetto è una istanza di una classe!
•   Esso è dotato di tutti gli attributi e i metodi definiti
    dalla classe.
•   Dal lato del calcolatore, ogni oggetto è rappresentato
    da un certa locazione di memoria, nella quale si trovano
    memorizzati gli attributi, il valore di questi determinano
    lo stato interno di una dell’oggetto.
•   Istanziare un oggetto vuol dire allocare memoria ed
    inizializzarla in base alle specifiche della classe
    definisce.

Convenzioni e
      programmazione OO –
       Gli oggetti in Ruby (I)
•   Riportiamo un semplice esempio…

Convenzioni e
      programmazione OO –
       Gli oggetti in Ruby (II)
•   Ancora un altro esempio…

Convenzioni e
         programmazione OO –
          Gli oggetti in Ruby (III)
                         Gestione degli attributi

•   Ruby fornisce delle scorciatoie per la gestione degli attributi: attr_reader,
    attr_writer, attr_accessor e attr.

•   Il valore true che segue il nome dell’attributo indica che la variabile è
    pure scrivibile, in modo analogo avremmo potuto utilizzare attr_accessor

Tipi di dati – I numeri (I)
         Le classi che definiscono i numeri
•   Nel linguaggio Ruby abbiamo la presenza di numeri interi e
    in virgola mobile.

•   I numeri interi sono oggetti o della classe Fixnum o della
    classe Bignum
    •   i numeri che possono essere rappresentati da una word sono
        oggetti della classe Fixnum, altrimenti appartengono alla classe
        Bignum.

•   I numeri in virgola mobile sono oggetti della classe Float.

Tipi di dati – I numeri (II)
Rappresentazione di numeri non decimali
•   Affinché si abbia una rappresentazione non decimale
    di un numero, a quest’ultimo bisogna far precedere un
    indicatore di base, in particolare:

    •    0b per i binari;
    •    0 per gli ottali;
    •    0d per i decimali;
    •    0x per gli esadecimali

Tipi di dati – I numeri (III)
    Alcuni metodi per le classi Fixnum e Bignum
•    Operazioni aritmetiche (+,-,*,/,div,%,modulo,**)

•    Operazioni bitwise (~,|,&,^,)

•    Altre operazione:
     •    dimensione in byte (size): 1.size => 4
     •    operazioni di conversione (to_f, to_s)
     •    valore assoluto (abs)

Tipi di dati – I numeri (IV)
                             La classe Float
•   I numeri in virgola mobile appartengono alla classe Float
•   Questa classe, oltre ad avere i metodi poc’anzi visto, ha:
    •   infinite? : tale metodo restituisce
        •   -1 se il numero è meno infinito,
        •   +1 se il numero è più infinito,
        •   nil se il numero è finito.
    •   nan? : ritorna
        •   true se il valore è un numero non valido,
        •   false altrimenti

Tipi di dati – Le stringhe (I)
•   Le stringhe sono delle istanze della classe String, e sono
    rappresentate da un successione di caratteri racchiusi tra singoli
    apici (‘) o tra le virgolette (“)

•   Si può accedere ad ogni singolo carattere della stringa []:

Tipi di dati – Le stringhe (II)
•   Esempio:

•   Per visualizzare un carattere invece del codice ASCII, possiamo
    utilizzare il metodo chr:

Tipi di dati – Le stringhe (III)
                  Accedere a sottostringhe (I)
•   Per questo utilizziamo le []:

•   Se utilizziamo i “…” escludiamo il secondo estremo:

•   Possiamo pure specificare il range tramite un qualsiasi numero
    intero:

Tipi di dati – Le stringhe (IV)
                 Accedere a sottostringhe (II)
•   Può essere specificata all’interno delle [] la sottostringa da
    ricercare:

•   Inoltre, possono essere specificate delle espressioni regolari J!

•   Ci ritorneremo!!

Tipi di dati – Le stringhe (V)
•   L’assegnazione viene effettuata attraverso il metodo []=, abbiamo
    una situazione analoga a metodo [] visto prima…

•   Giusto qualche esempio…

Tipi di dati – Le stringhe (VI)
        Alcuni importanti metodi applicabili alle
                      stringhe (I)

•   *

•   +

•

Tipi di dati – Le stringhe (VI)
     Alcuni importanti metodi applicabili alle
                  stringhe (II)
•   downcase

•   swapcase

•   chop

•   chomp

Tipi di dati – Le stringhe (VI)
     Alcuni importanti metodi applicabili alle
                  stringhe (III)
•   sub e gsub

•   split

•   tr

Tipi di dati – Le stringhe (VII)
    Alcuni importanti metodi applicabili alle stringhe (IV)
•   strip

•   lstrip

•   rstrip

•   ljust

•   rjust

•   center

Tipi di dati – Blocchi e iteratori (I)
•    I blocchi sono delle regioni di codice racchiuse tra due parole do e end
     oppure tra due parentesi { }.

•    Un iteratore è un un metodo che prende come argomento un blocco.

•    Esempio…

•    Possiamo inoltre passare dei parametri all’iteratore. Ad esempio, l’iteratore
     each della classe String prende come parametro il separatore, che di default è
     il carattere \n. Riprendendo l’esempio avremo:

Tipi di dati – Blocchi e iteratori (II)
•    Vediamo adesso un esempio in cui possiamo richiamare un
     blocco all’interno di un metodo, attraverso l’istruzione yield:

Tipi di dati – Array (I)
•   Gli array sono istanze della classe Array e vengono creati in questo
    modo:

•   o in alternativa:

•   In questi due casi creeremo un array vuoto, per la creazione di un
    array non vuoto basta semplicemente passare i valori separati da
    virgole:

•   N.B. Un array è una lista di oggetti non necessariamente dello stesso
    tipo

Tipi di dati – Array (II)
•   Al comando new è possibile passare due parametri, il primo
    indica la dimensione dell’array mentre il secondo il valore con il
    quale verrà inizializzato:

•   Attraverso il metodo []= è possibile inserire nell’array nuovi
    elementi o modificare quelli già presenti:

Tipi di dati – Array (III)
•   E’ possibile indicare come indice due interi che rappresentano
    rispettivamente l’inizio e il numero di elementi da sostituire con
    il valore passato:

•   Allo stesso modo può essere usato il range:

Tipi di dati – Array (IV)
•   Un metodo alternativo per inserire elementi in un array è dato
    dai metodi

Tipi di dati – Array (V)
•   Adesso vediamo un ultima tecnica per l’inserimento di elementi
    all’interno di un array. Per fare questo, utilizziamo il metodo
    insert:

•   inoltre è possibile inserire più elementi a partire dall’indice
    specificato come primo parametro:

Tipi di dati – Array (VI)
                      Operazioni sugli array (I)
•   “+” concatenazione:

•   “-” differenza:

Tipi di dati – Array (VII)
                     Operazioni sugli array (II)
•   “&” intersezione:

•   “*”: questo metodo si comporta modo differente in base al parametro
    che gli si viene passato.

Tipi di dati – Array (VIII)
    Alcuni importanti metodi applicabili alle stringhe (I)

•   clear

•   compact

•   delete

•   empty?

•   include?

Tipi di dati – Array (IX)
    Alcuni importanti metodi applicabili alle stringhe (II)

•    index

•    join

•    lenght, nitems

•    reverse

•    sort

Tipi di dati – Array (IX)
                   Altri metodi…

•   each

•   reverse_each

•   each_index

•   collect!

•   delete_if

Tipi di dati – Hash (I)
•   Sono liste di coppie di chiavi e valori e sono istanze della classe
    Hash

•   Ogni coppia è separata dall’altra tramite una virgola, inoltre tra le
    chiavi e il valore deve esserci il simbolo “=>”

•   A differenza degli array gli indici possono essere di qualsiasi tipo

•   Gli hash in Ruby sono racchiusi tra le parentesi { e }

•   Come creare un array:

Tipi di dati – Hash (II)
•   Per popolare un hash basta utilizzare il metodo []=, visto nel caso degli array
    con la differenza che al posto dell’indice bisogna specificare la chiave:

•   Per accedere ad un specifico valore si utilizza il metodo []:

•   Tramite il metodo keys e values possibile elencare rispettivamente tutti le
    chiavi e tutti i valori:

Tipi di dati – Hash (III)
•   Diversi metodi visti in precedenza per gli array sono presenti
    anche negli hash!

•   Uno in particolare che possiamo vedere, molto utile, è il metodo
    each che passa al blocco come parametri sia la chiave che il valore
    dell’hash. Inoltre, esistono i metodi each_key e each_value che
    passano rispettivamente al blocco la chiave e il valore.

Strutture di controllo – if e unless (I)
                                If (I)
•   Ovviamente chiunque il significato di tale costrutto, per cui
    evitiamo di parlarne e la sua sintassi:

Strutture di controllo – if e unless (II)
                             If (II)
•   Osserviamo un rapido esempio J:

Strutture di controllo – if e unless (III)
                                If (III)
•   Se il nostro if si trova in più linee allora si può anche omettere a
    per cui il nostro esempio diventa:

•   Inoltre, è possibile inserire un’espressione if anche in coda ad
    una istruzione:

Strutture di controllo – if e unless (IV)
                                Unless (I)
 •   L’opposto dell’if esiste il costrutto unless che esegue le istruzioni
     associati all’espressione booleana che risulta falsa:

Strutture di controllo – if e unless (V)
                            Unless (II)
•   Vediamo un piccolo esempio…

•   Anche in questo caso possiamo mettere il costrutto unless alla
    fine dell’istruzione:

Strutture di controllo – if e unless (VI)

 •   Vediamo adesso un’altra forma più particolare che richiede l’uso
     dell’operatore “?”:

 •   In questo caso assegneremo alla variabile segno la stringa
     “negativo” se la variabile numero è negativa, altrimenti
     assegneremo la stringa “positivo”.

Strutture di controllo – case (I)
•   A volte per una questione di comodità e di chiarezza nel codice
    si preferisce utilizzare l’istruzione case in alternativa a if e unless.
    Il costrutto case ha la seguente sintassi:

Strutture di controllo – case (II)
•   Vediamo subito un esempio…

•   L’istruzione che si trova dopo la parola else è quella che viene
    eseguita di default nel momento in cui falliscono tutte le altre
    istruzioni.

Strutture di controllo – case (III)
•   E’ possibile fare uso della parola chiave then e dei due punti
    qualora la condizione si trovi nella stessa linea dell’istruzione:

Strutture di controllo – case (IV)
•   In ultima analisi, considerando che il costrutto case restituisce il
    valore dell’ultima espressione valutata allora è possibile assegnare
    tale risultato ad un variabile:

Strutture di controllo –
              while, until e for (I)
                      While

•   Esempio:

Strutture di controllo –
               while, until e for (II)
                              Until

•   Esempio:

•   In questo caso viene eseguita l’espressione finché è falsa

Strutture di controllo –
             while, until e for (III)
                       For

•   Esempio:

Strutture di controllo –
               while, until e for (IV)
                 Come uscire dai cicli – break
•   Il comando break fa terminare il ciclo e l’esecuzione del
    programma riparte dall’istruzione che segue il ciclo:

Strutture di controllo –
              while, until e for (V)
              Come saltare una iterazione – next
•   Attraverso il comando next è possibile saltare una
    iterazione del ciclo e il programma riprenderà
    dall’iterazione successiva:

Gestione File – Apertura e chiusura (I)
•   File è la classe che contiene i metodi per la gestione dei file
    (apertura, chiusura, lettura, scrittura…)

•   Abbiamo a disposizione due metodi per aprire un file:

                    Metodo classico – File.new

•   A questo punto tutto le operazioni vanno eseguite sull’oggetto
    my_file di tipo File.

•   Una volta concluse le operazioni, per chiudere il file basta
    semplicemente il seguente comando

Gestione File – Apertura e chiusura (II)

•   Il metodo File.new ha la seguente sintassi:

•   Tale metodo può prendere da uno a tre parametri:
    •   il primo rappresenta il nome del file da aprire,
    •   il secondo la modalità di apertura,
    •   il terzo i permessi che verranno associati al file.

•   Di default il file viene aperto in solo lettura.

Gestione File – Apertura e chiusura (III)
•    La modalità di apertura può essere espressa sia come stringa:
     •   r: apertura a solo lettura
     •   r+: apertura per lettura e scrittura dall’inizio del file
     •   w: apertura a solo scrittura, in particolare se il file non esiste ne viene creato uno
         nuovo, altrimenti viene azzerato
     •   w+: apertura per lettura e scrittura, se il file non esiste ne viene creato uno nuovo,
         altrimenti viene azzerato
     •   a: apertura a solo scrittura dalla fine del file, inoltre se il file non esiste allora viene
         creato
     •   a+: apertura

•    sia come “or” di flag (sono costanti della classe File)
     •   APPEND: apertura in modalità append;
     •   CREAT: viene creato il file se non esiste;
     •   RDONLY: apertura a solo lettura;
     •   RDWR: apertura per lettura e scrittura;
     •   TRUNC: apre il file e se già esiste lo azzera;
     •   WRONLY: apertura a solo scrittura.

Gestione File – Apertura e chiusura (IV)
•    Per quanto riguarda il terzo argomento, i permessi vengono
     indicati, nei sistemi Unix-like, nella forma Owner-Group-Other.

•    Vediamo subito un piccolo esempio…

•    In questo caso, il file se non esiste viene creato, se esiste lo apre e lo
     azzera, ed inoltre viene aperto in lettura e scrittura.
•    Per quanto riguarda i permessi, possiamo leggere e scrivere nel file,
     mentre il nostro gruppo e chiunque altro può solamente leggerlo.

Gestione File – Apertura e chiusura (V)
                  Apertura tramite il metodo open
•    Al metodo open può essere associato un blocco al quale viene
     passato il file appena aperto. Senza il blocco associato open è
     sinonimo di File.new.

•    Quando viene utilizzato open non è richiesta la chiamata di close al
     termine delle operazioni, in quanto esso verrà chiuso
     automaticamente all’uscita del blocco.

Gestione File – Lettura e scrittura (I)
•   Le operazioni base sui file appena aperto sono la lettura e la scrittura.

•   Per la lettura possiamo utilizzare il metodo gets che viene ereditato dalla
    classe IO (precisiamo che la classe File è un sottoclasse della classe IO).

•   Altrimenti possiamo fare ricorso agli iteratori nel momento in cui
    utilizziamo il metodo open per aprire il file:
    •   each_byte: chiama il blocco per ogni byte
    •   each_line (anche each): chiama il blocco per ogni riga

Gestione File – Lettura e scrittura (II)
•   Attraverso gli iteratori each_line e each possiamo iterare su ogni
    linea del file:

•   risparmiamo qualche riga di codice J …

Gestione File – Lettura e scrittura (III)
•   Un ulteriore modo al quanto elegante per aprire un file è dato dal
    metodo foreach della classe IO. Ad esso viene passato come
    argomento un file, il metodo apre tale file, chiama il blocco per
    ogni linea e alla fine chiude automaticamente il file:

•   Per la scrittura su un file viene utilizzato il metodo write il quale
    prende come argomento la stringa da scrivere sul file:

Gestione File – Lettura e scrittura (IV)
•   In alternativa a write possiamo utilizzare:
    •   l’operatore

Gestione File – Alcuni metodi utili (I)
•   Vediamo alcuni metodi utili per la gestione di file:

    •   atime, ctime, mtime: rispettivamente restituisco la data di ultimo
        accesso, di creazione e di modifica.

    •   chmod, chown: modificano i permessi di proprietariorename:
    •   delete: cancella il file
    •   rename: rinomina il file
    •   size: restituisce la dimensione del file in byte
    •   read: restituisce il contenuto del file in un’unica stringa
    •   readlines: restituisce in un array le linee del file

Gestione File – Alcuni metodi utili (II)
•   Vi sono alcuni metodi interrogativi come:

    •   exist? : restituisce true se il file esiste
    •   executable? : restituisce true se il file è eseguibile
    •   readable? : restituisce true se il file è leggibile
    •   writable? : restituisce true se il file è scrivibile
    •   file? : restituisce true se il file è regolare, ossia se non è una directory,
        ecc.
    •   owned? : restituisce true se l’user ID del processo è lo stesso del file.

Gestione directory
•   La classe della gestione delle directory è Dir.

•   Per questa classe esistono pure i metodi new, open e close visti
    in precedenza per la classe File:

•   Anche in questo caso si può utilizzare il metodo open senza
    ricorrere successivamente a close per chiudere la directory una
    volta concluse le operazioni

Espressioni Regolari (I)
•   Le espressioni regolari sono uno strumento molto
    potente per la gestione del testo. Esse forniscono dei
    modelli per ricercare all’interno di un testo espressioni
    letterali.

•   Come nel caso degli array e degli hash, gli oggetti della
    classe Regexp possono essere creati in diversi modi:
    •   utilizzando il metodo new nel quale viene passata
        l’espressione regolare:

    •   oppure tra i doppi slash //:

Espressioni Regolari (II)
•   Nel momento in cui viene creata un’espressione
    regolare possiamo confrontarla con una stringa. Questo
    lo possiamo fare attraverso l’operatore =~ o il suo
    negato !~

•   L’operatore =~ restituisce la posizione del primo
    carattere che fa match con l’espressione regolare

Espressioni Regolari (III)
•   Nelle espressioni oltre ai normali caratteri possono
    essere usate delle sequenze di simboli che indicano
    determinate categorie di caratteri

            .     un carattere qualsiasi
            \w    lettera o numero
           \W     il contrario di \W, né lettera né cifra
            \s    spazio, come \t \n \r, ecc..
            \S    carattere non spazio
            \d    cifra numerica
           \D     carattere non numerico
            \A    match con l’inizio della stringa
            \Z    match con la fine della stringa

Espressioni Regolari (IV)
•   Come nel caso di \A e \Z, esistono due particolari
    elementi ^ e $ che vengono usati rispettivamente per
    cercare l’espressione regolare all’inizio della stringa o
    alla fine.+

•   Esistono anche dei simboli di quantità
         *      zero o più ripetizioni del carattere precedente
         +      una o più ripetizioni del carattere precedente
       {m,n}    almeno m e massimo n ripetizioni del carattere
                precedente
         ?      al massimo una ripetizione del carattere precedente

Espressioni Regolari (V)
•   Possiamo indicare la classe di caratteri all’interno di un
    espressione regolare nel seguente modo:

       /[Rr]uby/      “Ruby” o “ruby”
        /rub[ye]/     “ruby” o “rube”
        /[aeiou]/     una qualsiasi vocale minuscola
         /[0-9]/      un qualsiasi numero compreso fra 0 e 9
         /[a-z]/      una qualsiasi lettera minuscola
         /[A-Z]/      una qualsiasi lettera maiuscola
      /[a-zA-Z0-9]/   la qualunque cosa
       /[^aeiou]/     qualcos’altro rispetto ad una vocale minuscola
        /[^0-9]/      qualcos’altro rispetto ad un numero compreso
                      fra 0 e 9

Espressioni Regolari (VI)
                    La classe String (I)
•   Vediamo adesso come possiamo utilizzare le espressioni
    regolare per le stringhe

•   In questo caso index restituisce l’indice della prima
    occorrenza della sottostringa che verifica il pattern, in
    modo analogo il metodo rindex restituisce l’ultima
    occorrenza:

Espressioni Regolari (VI)
                    La classe String (II)
•   E’ possibile utilizzare le espressioni regolari anche con
    il metodo split:

•   Infine, possiamo sfruttare le potenzialità delle regexp
    con il metodo scan, in questo caso tale metodo
    scansiona tutta la stringa presa in esame e inserisce in
    un array tutti i risultati che verificano il pattern:

Pacchetti in Ruby – Introduzione a RubyGems (I)

   •   RubyGems è un framework per la gestione in modo automatica
       dei pacchetti.

   •   Esso si occupa dell’installazione, dell’aggiornamento e della
       distruzione…

   •   Esso va installato a parte in quanto non fa parte dei programmi
       distribuiti direttamente da Ruby

   •   Nel seguente link trovate i sorgenti attualmente disponibili:

                        http://docs.rubygems.org/

Pacchetti in Ruby – Introduzione a RubyGems (II)

    •   Per l’installazione di RubyGems basta eseguire il
        seguente comando:

    •   Se eseguiamo dal terminale in comando gem senza
        alcuna opzione figurerà lista di informazioni per l’uso
        di RubyGems

    •   Per avere una lista completa dei comandi basta lanciare
        il seguente comando

Pacchetti in Ruby – Comandi per RubyGems (I)

   •   Per installare una nuova gemma basta utilizzare il
       comando install:

   •   Per avere una lista completa delle opzioni che si
       possono utilizzare con il comando install basta lanciare
       il seguente comando:

Pacchetti in Ruby – Comandi per RubyGems (II)
•   Per poter utilizzare le librerie nel codice sorgente occorre caricare la
    gemma, per fare ciò si utilizza il comando require:

•   Per disinstallare un pacchetto attraverso RubyGems basta utilizzare il
    comando unistall
•   Attraverso il comando list invece è possibile vedere le gemme installate
    attualmente nella propria macchina.
•   Indicando l’opzione –remote è possibile avere una lista completa dei
    pacchetti presenti nel repository. Di default quello ufficiale è
    rubyforge.org
•   Infine, attraverso il comando update possiamo aggiornare la versione di
    un pacchetto se viene specificato il suo nome, altrimenti vengono
    aggiornati tutti quelli presenti nella propria macchina.

Pacchetto “HPRICOT” (I)
•   Hpricot (v 0.8.6) è una gemma che può essere scaricata
    dal sito: http://rubygems.org/

•   Al link http://rubygems.org/gems/hpricot

•   In alternativa può essere installato dalla shell di ruby
    con il seguente comando:

                   gem install hpricot

Pacchetto “HPRICOT” (II)
•   Hpricot è un parser HTML, scritto in C, veloce e
    flessibile.

•   Le ricerche possono basarsi su diversi elementi:
    •   ID degli elementi
    •   Selettori CSS
    •   Tag
    •   Ed in generale tutti gli elementi che compongono una
        pagina html

Pacchetto “HPRICOT” (III)
•   Documentazione
    •   http://rubydoc.info/gems/hpricot/0.8.6/frames

•   Demo on line
    •   http://hpricot.com/

•   Competitor, sempre una ruby gems:
    •   Nokogiri (http://nokogiri.org/)

Pacchetto “HPRICOT” (IV)
•   Input:
    •   Dal www
        require 'open-uri'
        doc = open("http://www.sdai.unict.it/") { |f| Hpricot(f) }
    •   Da file locali
        doc = open("index.html") { |f| Hpricot(f) }
    •   Oppure una generica stringa
        doc = Hpricot("A simple test string.“)

Pacchetto “HPRICOT” (V)
•   Ricerca degli elementi all’interno del documento
    vengono effettuati tramite il comando d o c . s e a r c h

•   Per ottenere il contenuto dell’elemento cercato si usa il
    comando . i n n e r _ h t m l

                         ADESSO

                SCRIPT DI ESEMPIO