Corso di base Ruby

Corso avanzato Ruby

Ruby Web Service Ruby Socket Programming

Ruby XML, XSLT and XPath Tutorial

Cos'è XML?

XML sta per linguaggio di markup estensibile (eXtensible Markup Language).

Linguaggio di markup estensibile, un sottoinsieme del linguaggio di markup generale, un linguaggio di markup utilizzato per etichettare file elettronici in modo che abbiano una struttura.

Può essere utilizzato per etichettare dati, definire tipi di dati, è una fonte linguistica che permette agli utenti di definire il proprio linguaggio di markup. È particolarmente adatto per il trasporto del web, fornendo un metodo uniforme per descrivere e scambiare dati strutturati indipendenti dall'applicazione o dal fornitore.

Per ulteriori informazioni, consulta la nostra Corso XML

Struttura e API del parser XML

I principali parser XML sono DOM e SAX.

Il parser SAX è basato sul trattamento degli eventi, è necessario scansionare l'intero documento XML da capo a fondo, durante la scansione, ogni volta che si incontra una struttura grammaticale, viene chiamato il programma di gestione eventi della struttura grammaticale specifica, inviando un evento all'applicazione.
DOM è il parser modello oggetto documento, costruisce la struttura grammaticale gerarchica del documento, costruisce un albero DOM in memoria, i nodi dell'albero DOM sono identificati come oggetti, dopo la解析del documento, l'intero albero DOM del documento viene messo in memoria.

解析e creazione XML in Ruby

La解析e la creazione di documenti XML in Ruby possono utilizzare questa libreria REXML.

La libreria REXML è un pacchetto di strumenti XML per Ruby, scritto interamente in Ruby, che segue la specifica XML 1.0.

A partire dalla versione Ruby 1.8 e successive, la libreria standard Ruby conterrà REXML.

Il percorso della libreria REXML è: rexml/document

Tutti i metodi e le classi sono encapsulati in un modulo REXML.

I vantaggi del parser REXML rispetto agli altri parser sono i seguenti:

100% scritto in Ruby.
Apportabile per parser SAX e DOM.
È leggero, con meno di 2000 righe di codice.
Metodi e classi facili da comprendere.
Basato API SAX2 e supporto completo XPath.
Installare　Ruby　senza　bisogno　di　installare　separatamente。

Ecco　un　esempio　di　codice　XML，salvare　come　movies.xml:

<collection　shelf="Nuovi　Arrivi">
<movie　title="Enemy　Behind">
　　　<type>Guerra,　Thriller</type>
　　　<format>DVD</format>
　　　<year>2003</year>
　　　<rating>PG</rating>
　　　<stars>10</stars>
　　　<description>Parlare　di　una　guerra　US-Japan</description>
</movie>
<movie　title="Transformers">
　　　<type>Animazione,　Fantascienza</type>
　　　<format>DVD</format>
　　　<year>1989</year>
　　　<rating>R</rating>
　　　<stars>8</stars>
　　　<description>Un　romanzo　scientifico</description>
</movie>
　　　<movie　title="Trigun">
　　　<type>Animazione,　Azione</type>
　　　<format>DVD</format>
　　　<episodes>4</episodes>
　　　<rating>PG</rating>
　　　<stars>10</stars>
　　　<description>Vash　the　Stampede!</description>
</movie>
<movie　title="Ishtar">
　　　<type>Commedia</type>
　　　<format>VHS</format>
　　　<rating>PG</rating>
　　　<stars>2</stars>
　　　<description>Tristezza　visibile</description>
</movie>
</collection>

Analizzatore DOM

Prima　di　 tutto，analizziamo　i　dati　XML，prima　di　tutto　importiamo　la　libreria　rexml/document，solitamente　possiamo　importare　REXML nel　namespace　principale:

Esempio online

#!/usr/bin/ruby -w
　
require 'rexml/document'
include REXML
　
xmlfile = File.new("movies.xml")
xmldoc = Document.new(xmlfile)
　
#　Ottenere　l'elemento　root
root　=　xmldoc.root
puts　"Elemento　radice　:　"　+　root.attributes["shelf"]
　
#　Ecco　l'output　del　titolo　del　film
xmldoc.elements.each("collection/movie"){　
　　　|e|　puts　"Titolo　del　Film　:　"　+　e.attributes["title"]　
}
　
# Ecco i tipi di tutti i film
xmldoc.elements.each("collection/movie/type") {
　　　|e| puts "Movie Type: " + e.text　
}
　
# Ecco le descrizioni di tutti i film
xmldoc.elements.each("collection/movie/description") {
　　　|e| puts "Movie Description: " + e.text　
}

Il risultato dell'esempio sopra è:

Root element: New Arrivals
Movie Title: Enemy Behind
Movie Title: Transformers
Movie Title: Trigun
Movie Title: Ishtar
Movie Type: War, Thriller
Movie Type: Anime, Science Fiction
Movie Type: Anime, Action
Movie Type: Comedy
Movie Description: Talk about a US-Japan war
Movie Description: A scientific fiction
Movie Description: Vash the Stampede!
Movie Description: Visibile boredom
SAX-like Parsing:

SAX 解析器

处理相同的数据文件：movies.xml，不建议SAX的解析为一个小文件，以下是个简单的示例：

Esempio online

#!/usr/bin/ruby -w
　
require 'rexml/document'
require 'rexml/streamlistener'
include REXML
　
　
class MyListener
　　include REXML::StreamListener
　　def tag_start(*args)
　　　　puts "tag_start: #{args.map {|x| x.inspect}.join(', ')}"
　　fine
　
　　def text(data)
　　　　return if data =~ /^\w*$/ # solo spazi bianchi
　　　　abbrev = data[0..40] + (data.length > 40 ? "..." : "")
　　　　puts "    text: #{abbrev.inspect}"
　　fine
fine
　
list = MyListener.new
xmlfile = File.new("movies.xml")
Document.parse_stream(xmlfile, list)

Il risultato di output sopra è:

tag_start: "collection", {"shelf": "Nuovi Arrivi"}
tag_start: "movie", {"title": "Enemy Behind"}
tag_start: "type", {}
　　text: "Guerra, Thriller"
tag_start: "format", {}
tag_start: "year", {}
tag_start: "rating", {}
tag_start: "stars", {}
tag_start: "description", {}
　　text: "Parlare di una guerra tra Stati Uniti e Giappone"
tag_start: "movie", {"title": "Transformers"}
tag_start: "type", {}
　　text: "Anime, Science Fiction"
tag_start: "format", {}
tag_start: "year", {}
tag_start: "rating", {}
tag_start: "stars", {}
tag_start: "description", {}
　　text: "Una scienza di fantasia"
tag_start: "movie", {"title": "Trigun"}
tag_start: "type", {}
　　text: "Anime, Action"
tag_start: "format", {}
tag_start: "episodes", {}
tag_start: "rating", {}
tag_start: "stars", {}
tag_start: "description", {}
　　text: "Vash the Stampede!"
tag_start: "movie", {"title": "Ishtar"}
tag_start: "type", {}
tag_start: "format", {}
tag_start: "rating", {}
tag_start: "stars", {}
tag_start: "description", {}
　　text: "Visibile noia"

XPath e Ruby

Possiamo utilizzare XPath per visualizzare XML, XPath è un linguaggio utilizzato per trovare informazioni nei documenti XML (vedi:)Tutorial XPath)。

XPath è il linguaggio di percorso XML, un linguaggio utilizzato per determinare la posizione di una parte di un documento XML (sottoinsieme del linguaggio di markup generale standard). XPath si basa sulla struttura ad albero dell'XML, fornendo la capacità di trovare nodi in una struttura ad albero di dati.

Ruby supporta XPath tramite la classe REXML, che è basata sull'analisi a albero (modello oggetto documento).

Esempio online

#!/usr/bin/ruby -w
　
require 'rexml/document'
include REXML
　
xmlfile = File.new("movies.xml")
xmldoc = Document.new(xmlfile)
　
# Informazioni del primo film
movie = XPath.first(xmldoc, "//movie")
p movie
　
# Stampa il primo film
# Stampa tutti i tipi di film
　
# Ottieni tutti i tipi di formato dei film, restituisci un array
names = XPath.match(xmldoc, "//format").map {|x| x.text}
p names

Il risultato dell'esempio sopra è:

<movie title='Enemy Behind'>...</movie>
Guerra, Thriller
Anime, Fantascienza
Anime, Azione
Commedia
["DVD", "DVD", "DVD", "VHS"]

XSLT e Ruby

Ci sono due parser XSLT in Ruby, ecco una breve descrizione:

Ruby-Sablotron

Questo parser è stato scritto e mantenuto da Masayoshi Takahashi. È stato principalmente scritto per il sistema operativo Linux e richiede le seguenti librerie:

Sablot
Iconv
Expat

Puoi trovare Ruby-Sablotron Trova queste librerie.

XSLT4R

XSLT4R è stato scritto da Michael Neumann. XSLT4R è utilizzato per interazioni semplici da riga di comando e può essere utilizzato da applicazioni di terze parti per convertire documenti XML.

XSLT4R richiede l'operazione XMLScan, include l'archivio XSLT4R, che è un modulo al 100% in Ruby. Questi moduli possono essere installati utilizzando il metodo standard di installazione di Ruby (ovvero Ruby install.rb).

La sintassi di XSLT4R è la seguente:

ruby xslt.rb stylesheet.xsl document.xml [arguments]

Se desideri utilizzare XSLT4R nel tuo applicativo, puoi includere XSLT e fornire i parametri necessari. Ecco un esempio:

Esempio online

require "xslt"
　
stylesheet = File.readlines("stylesheet.xsl").to_s
xml_doc　=　File.readlines("document.xml").to_s
arguments　=　{　'image_dir'　=>　'/....'　}
　
sheet　=　XSLT::Stylesheet.new(　stylesheet,　arguments　)
　
#　output　to　StdOut
sheet.apply(　xml_doc　)
　
#　output　to　'str'
str　=　""
sheet.output　=　[　str　]
sheet.apply(　xml_doc　)

More Information

Complete REXML Parser, please see the documentation REXML Parser Documentation.
You can find from RAA Knowledge Base Download XSLT4R here.

Ruby Web Service Ruby Socket Programming