Latest web development tutorials

Ruby XML, XSLT et XPath Tutorial

Qu'est-ce que XML?

Elle se réfère à Extensible Markup Language XML (eXtensible Markup Language).

Extensible Markup Language, un sous-ensemble de la Standard Generalized Markup Language, un procédé de marquage d'un document électronique d'avoir un langage de balisage structuré.

Il peut être utilisé pour baliser les données, la définition des types de données, est une technologie qui permet aux utilisateurs de définir leur propre langue source de langage de balisage. Il est idéal pour la transmission Web, fournissant une approche unifiée à la description et l'échange indépendant des applications ou des fournisseurs de données structurées.

Pour plus d' informations, s'il vous plaît voir notre tutoriel XML

analyseur XML et la structure de l'API

Analyseur XML SAX et DOM sont principalement de deux types.

  • parser SAX est un traitement à base d'événements, le document XML numérisation doit, du début à la fin de nouveau, dans le processus de numérisation, chaque fois que l'expérience d'une structure grammaticale, il appellera la structure grammaticale spécifique de gestionnaire d'événements, envoyer la demande un événement.
  • Document DOM analyse Object Model, construction hiérarchique structure grammaticale du document, établir arbre DOM dans le nœud d'arborescence DOM mémoire comme un objet à identifier, documenter l'analyse Wencheng, l'ensemble de l'arborescence DOM documentera en mémoire.

Ruby pour analyser et créer XML

RUBY analyse des documents XML peut utiliser cette bibliothèque de REXML bibliothèque.

bibliothèque REXML est un rubis boîte à outils XML est d'utiliser un langage Ruby pure, suivre les normes de XML1.0.

Dans les versions ruby1.8 et plus tard, la bibliothèque contiendra RUBY REXML.

bibliothèque Path REXML est: rexml / document

Toutes les méthodes et les classes sont regroupés dans un module de REXML.

REXML analyseur présente les avantages suivants par rapport aux autres parseurs:

  • 100% écrit par Ruby.
  • Applicable à SAX et DOM parser.
  • Il est léger, moins de 2000 lignes de code.
  • Facile à comprendre les méthodes et les classes.
  • API SAX2 Basé et le plein soutien de XPath.
  • Utilisez l'installation Ruby, sans nécessiter des installations séparées.

Ce qui suit est un exemple de code XML, enregistrez-le sous movies.xml: 

<collection shelf="New Arrivals">
<movie title="Enemy Behind">
   <type>War, Thriller</type>
   <format>DVD</format>
   <year>2003</year>
   <rating>PG</rating>
   <stars>10</stars>
   <description>Talk about a US-Japan war</description>
</movie>
<movie title="Transformers">
   <type>Anime, Science Fiction</type>
   <format>DVD</format>
   <year>1989</year>
   <rating>R</rating>
   <stars>8</stars>
   <description>A schientific fiction</description>
</movie>
   <movie title="Trigun">
   <type>Anime, Action</type>
   <format>DVD</format>
   <episodes>4</episodes>
   <rating>PG</rating>
   <stars>10</stars>
   <description>Vash the Stampede!</description>
</movie>
<movie title="Ishtar">
   <type>Comedy</type>
   <format>VHS</format>
   <rating>PG</rating>
   <stars>2</stars>
   <description>Viewable boredom</description>
</movie>
</collection>

DOM parser

Commençons pour analyser les données XML d'abord, nous avons introduit la bibliothèque rexml / document, nous pouvons habituellement dans l'espace de noms REXML de haut niveau mis en place: 

#!/usr/bin/ruby -w

require 'rexml/document'
include REXML

xmlfile = File.new("movies.xml")
xmldoc = Document.new(xmlfile)

# 获取 root 元素
root = xmldoc.root
puts "Root element : " + root.attributes["shelf"]

# 以下将输出电影标题
xmldoc.elements.each("collection/movie"){ 
   |e| puts "Movie Title : " + e.attributes["title"] 
}

# 以下将输出所有电影类型
xmldoc.elements.each("collection/movie/type") {
   |e| puts "Movie Type : " + e.text 
}

# 以下将输出所有电影描述
xmldoc.elements.each("collection/movie/description") {
   |e| puts "Movie Description : " + e.text 
}

L'exemple ci-dessus sortie 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:

parser SAX

Traitement du même fichier de données: movies.xml, analyse SAX est pas recommandé comme un petit fichier, ce qui suit est un exemple simple: 

#!/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, list)

Au-dessus de sortie est la suivante: 

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 voir XML, XPath pour trouver l' information est un document en langage XML (Voir: Tutoriel XPath ).

XPath est le langage XML Path, il est une méthode utilisée pour déterminer le XML (un sous-ensemble de la Standard Generalized Markup Language) langue du document une partie de l'emplacement. XPath-arborescente de XML, et offre la possibilité de rechercher dans les noeuds de structure de données dans l'arborescence.

XPath support de XPath Ruby par classe REXML, qui est basé sur l'arbre d'analyse (Document Object Model). 

#!/usr/bin/ruby -w

require 'rexml/document'
include REXML

xmlfile = File.new("movies.xml")
xmldoc = Document.new(xmlfile)

# 第一个电影的信息
movie = XPath.first(xmldoc, "//movie")
p movie

# 打印所有电影类型
XPath.each(xmldoc, "//type") { |e| puts e.text }

# 获取所有电影格式的类型，返回数组
names = XPath.match(xmldoc, "//format").map {|x| x.text }
p names

L'exemple ci-dessus sortie est: 

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

XSLT et Ruby

Ruby a deux parseur XSLT, une brève description est donnée ci-dessous:

Ruby-Sablotron

Cet analyseur est écrit et maintenu par la justice Masayoshi Takahash. Ceci est principalement écrit pour le système d'exploitation Linux, vous avez besoin des bibliothèques suivantes:

  • sablot
  • iconv
  • Expat

Vous pouvez Ruby-Sablotron trouver ces bibliothèques.

XSLT4R

XSLT4R écrit par Michael Neumann. XSLT4R pour interaction simple ligne de commande, les applications tierces peut être utilisé pour transformer des documents XML.

XSLT4R besoin XMLScan opération, y compris les archives XSLT4R, qui est un module Ruby 100%. Ces modules peuvent utiliser la méthode d'installation Ruby standard (Ruby install.rb) d'installation.

syntaxe XSLT4R est la suivante: 

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

Si vous souhaitez utiliser XSLT4R dans votre application, vous pouvez introduire XSLT et d'entrée des paramètres dont vous avez besoin. Des exemples sont les suivants: 

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 )

Plus d'informations