Tutoriel Ruby XML, XSLT et XPath


Qu'est-ce que XML ?

XML signifie eXtensible Markup Language.

Le langage de balisage extensible, un sous-ensemble du Standard Generalized Markup Language, est un langage de balisage utilisé pour baliser des documents électroniques afin de leur donner une structure.

Il peut être utilisé pour baliser des données et définir des types de données. C'est un langage source qui permet aux utilisateurs de définir leur propre langage de balisage. Il est très adapté à la transmission sur le World Wide Web, en fournissant une méthode unifiée pour décrire et échanger des données structurées indépendantes des applications ou des fournisseurs.

Pour plus de contenu, veuillez consulter notreTutoriel XML


Structure et API du parseur XML

Il existe principalement deux types de parseurs XML : DOM et SAX.

  • Le parseur SAX est basé sur le traitement d'événements. Il parcourt le document XML du début à la fin. Pendant le processus de parcours, chaque fois qu'une structure syntaxique est rencontrée, le gestionnaire d'événements de cette structure syntaxique spécifique est appelé pour envoyer un événement à l'application.
  • DOM est l'analyse du Document Object Model. Il construit une structure syntaxique hiérarchique du document et crée un arbre DOM en mémoire. Les nœuds de l'arbre DOM sont identifiés sous forme d'objets. Une fois le document analysé, l'intégralité de l'arbre DOM du document est placée en mémoire.

Analyse et création de XML en Ruby

En Ruby, la bibliothèque REXML peut être utilisée pour analyser des documents XML.

La bibliothèque REXML est une boîte à outils XML pour Ruby. Elle est écrite en Ruby pur et est conforme à la spécification XML 1.0.

Dans Ruby 1.8 et les versions ultérieures, REXML est inclus dans la bibliothèque standard de Ruby.

Le chemin de la bibliothèque REXML est : rexml/document

Toutes les méthodes et classes sont encapsulées dans un module REXML.

L'analyseur REXML présente les avantages suivants par rapport aux autres analyseurs :

  • 100% écrit en Ruby.
  • Applicable aux analyseurs SAX et DOM.
  • Il est léger, avec moins de 2000 lignes de code.
  • Des méthodes et des classes faciles à comprendre.
  • Basé sur l'API SAX2 et la prise en charge complète de XPath.
  • Installé avec Ruby, aucune installation distincte n'est nécessaire.

Voici le code XML de l'exemple, enregistré sous movies.xml :

<collection shelf="Nouveautés"> <movie titre="Enemy Behind"> <type>Guerre, Thriller</type> <format>DVD</format> <année>2003</année> <classification>PG</classification> <étoiles>10</étoiles> <description>Parle d'une guerre entre les États-Unis et le Japon</description> </film> <film titre="Transformers"> <type>Anime, Science-fiction</type> <format>DVD</format> <année>1989</année> <classification>R</classification> <étoiles>8</étoiles> <description>Une fiction scientifique</description> </film> <film titre="Trigun"> <type>Anime, Action</type> <format>DVD</format> <épisodes>4</épisodes> <classification>PG</classification> <étoiles>10</étoiles> <description>Vash the Stampede!</description> </film> <film titre="Ishtar"> <type>Comédie</type> <format>VHS</format> <classification>PG</note> <étoiles>2</étoiles> <description>Ennui regardable</description> </film> </collection>

Analyseur DOM

Commençons par analyser les données XML. D'abord, nous importons la bibliothèque rexml/document. Habituellement, nous pouvons importer REXML dans l'espace de noms de premier niveau :

Exemple

#!/usr/bin/ruby -w require 'rexml/document' include REXML xmlfile = File.new("movies.xml") xmldoc = Document.new(xmlfile) #Obtenir l'élément racine root = xmldoc.root puts "Élément racine : " + root.attributes["shelf"] #Ce qui suit affichera les titres des films xmldoc.elements.each("collection/movie"){ |e| puts "Titre du film : " + e.attributes["title"] } #Ce qui suit affichera tous les types de films xmldoc.elements.each("collection/movie/type") { |e| puts "Type de film : " + e.text } #Ce qui suit affichera toutes les descriptions de films xmldoc.elements.each("collection/movie/description") { |e| puts "Description du film : " + e.text }

Le résultat de sortie de l'exemple ci-dessus est :

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 schientific fiction
Movie Description : Vash the Stampede!
Movie Description : Viewable boredom
SAX-like Parsing:

Analyseur SAX

Pour traiter le même fichier de données : movies.xml, l'analyse SAX n'est pas recommandée pour un petit fichier. Ce qui suit est un exemple simple :

Exemple

#!/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(', ')}" end def text(data) return if data =~ /^\w*$/ # whitespace only abbrev = data[0..40] + (data.length > 40 ? "..." : "") puts " text : #{abbrev.inspect}" end end list = MyListener.new xmlfile = File.new("movies.xml") Document.parse_stream(xmlfile, liste)

Le résultat de sortie ci-dessus est :

tag_start: "collection", {"shelf"=>"New Arrivals"}
tag_start: "movie", {"title"=>"Enemy Behind"}
tag_start: "type", {}
  text   :   "War, Thriller"
tag_start: "format", {}
tag_start: "year", {}
tag_start: "rating", {}
tag_start: "stars", {}
tag_start: "description", {}
  text   :   "Talk about a US-Japan war"
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   :   "A schientific fiction"
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   :   "Viewable boredom"

XPath et Ruby

Nous pouvons utiliser XPath pour visualiser du XML. XPath est un langage pour trouver des informations dans des documents XML (voir:Tutoriel XPath)。

XPath est le langage de chemin XML. C'est un langage utilisé pour déterminer la position d'une partie dans un document XML (un sous-ensemble du Standard Generalized Markup Language). XPath est basé sur la structure arborescente de XML et offre la possibilité de trouver des nœuds dans l'arbre de structure de données.

Ruby prend en charge XPath via la classe XPath de REXML, qui est basée sur l'analyse d'arborescence (Document Object Model).

Exemple

#!/usr/bin/ruby -w require 'rexml/document' include REXML xmlfile = File.new("movies.xml") xmldoc = Document.new(xmlfile) #Les informations du premier film movie = XPath.first(xmldoc, "//movie") p movie #Afficher tous les types de film XPath.each(xmldoc, "//type") { |e| puts e.text } #Obtenir tous les types de format de film et renvoyer un tableau names = XPath.match(xmldoc, "//format").map {|x| x.text } p names

Le résultat de sortie de l'exemple ci-dessus est :

<movie title='Enemy Behind'> ... </>
War, Thriller
Anime, Science Fiction
Anime, Action
Comedy
["DVD", "DVD", "DVD", "VHS"]

XSLT et Ruby

Il existe deux parseurs XSLT en Ruby. Une brève description est donnée ci-dessous :

Ruby-Sablotron

Ce parseur a été écrit et maintenu par Masayoshi Takahash. Il est principalement écrit pour le système d'exploitation Linux et nécessite les bibliothèques suivantes :

  • Sablot
  • Iconv
  • Expat

Vous pouvez trouver ces bibliothèques :Ruby-Sablotron.

XSLT4R

XSLT4R a été écrit par Michael Neumann. XSLT4R est utilisé pour une interaction simple en ligne de commande et peut être utilisé par des applications tierces pour transformer des documents XML.

XSLT4R nécessite XMLScan pour fonctionner ; XMLScan est inclus dans l'archive XSLT4R. C'est un module 100% Ruby. Ces modules peuvent être installés en utilisant la méthode d'installation standard de Ruby (c'est-à-dire ruby install.rb).

Le format de syntaxe XSLT4R est le suivant :

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

Si vous souhaitez utiliser XSLT4R dans votre application, vous pouvez inclure XSLT et saisir les paramètres dont vous avez besoin. L'exemple est le suivant :

Exemple

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 ) # sortie vers StdOut sheet.apply( xml_doc ) # sortie vers 'str' str = "" sheet.output = [ str ] sheet.apply( xml_doc )

Ressources supplémentaires

Autres extensions