Rubí XML, XSLT y XPath Tutorial

Siguiente: Servicios de Aplicaciones Web Ruby - soap4r

¿Qué es XML?

Se refiere al lenguaje de marcado extensible XML (eXtensible Markup Language).

Extensible Markup Language, un subconjunto del lenguaje de marcado generalizado estándar, un método para marcar un documento electrónico para tener un lenguaje de marcado estructurado.

Puede ser utilizado para identificar datos, la definición de tipos de datos, es una tecnología que permite a los usuarios definir su propio idioma fuente de lenguaje de marcas. Es ideal para la transmisión Web, proporcionando un enfoque unificado para describir e intercambiar independiente de las aplicaciones o los proveedores de datos estructurados.

Para obtener más información, consulte nuestro tutorial XML

analizador de XML y la estructura de la API

XML parser SAX y DOM son principalmente dos tipos.

analizador SAX es el procesamiento basado en eventos, el escaneo de documentos XML necesita de principio a fin una vez más, en el proceso de exploración, cada vez que experimenta una estructura gramatical, se llamará a la estructura gramatical específica controlador de eventos, enviar la solicitud un evento.
El análisis del modelo de objetos de documento DOM, construcción jerárquica estructura gramatical del documento, establecer árbol DOM en el nodo del árbol DOM memoria como un objeto de identificar, analizar el documento Wencheng, todo el árbol DOM documentará en la memoria.

Ruby a analizar y crear XML

RUBY análisis de documentos XML se puede utilizar esta biblioteca REXML biblioteca.

REXML biblioteca es un conjunto de herramientas XML rubí es utilizar lenguaje Ruby puro, seguir las normas XML1.0.

En ruby1.8 y versiones posteriores, la biblioteca contendrá RUBY REXML.

REXML vía de la biblioteca es: rexml / documento

Todos los métodos y clases se empaquetan en un módulo REXML.

analizador REXML tiene las siguientes ventajas sobre otros programas de análisis:

100% escrito por Ruby.
Aplicable a Sax y analizador DOM.
Es ligero, menos de 2000 líneas de código.
Fácil de entender los métodos y clases.
API de SAX2 En base y el apoyo completo de XPath.
Utilizar la instalación de Ruby, sin requerir instalaciones separadas.

El siguiente es un ejemplo de código XML, guárdelo como 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>

analizador DOM

Vamos a empezar a analizar los datos XML En primer lugar hemos introducido biblioteca rexml / documento, por lo general podemos estar en el espacio de nombres REXML de nivel superior introducido:

#!/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 
}

La salida del ejemplo anterior es:

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:

analizador SAX

El procesamiento de la misma fichero de datos: movies.xml, análisis SAX no se recomienda como un pequeño archivo, el siguiente es un ejemplo sencillo:

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

Por encima de salida es:

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 y Ruby

Podemos utilizar XPath para ver XML, XPath para encontrar la información es un documento en lenguaje XML (Ver: XPath Tutorial ).

XPath es el XML Path Language, es un método utilizado para determinar el XML (un subconjunto del lenguaje de marcado generalizado estándar) lenguaje del documento una parte de la ubicación. árbol XML XPath de base, y proporciona la capacidad de buscar en los nudos de la estructura de datos en el árbol.

apoyo XPath XPath de Ruby por clase REXML, que se basa en el árbol de análisis (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

La salida del ejemplo anterior es:

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

XSLT y Ruby

Ruby tiene dos analizador XSLT, una breve descripción es la siguiente:

Rubí-Sablotron

Este analizador está escrito y mantenido por la justicia Masayoshi Takahash. Esto está escrito principalmente para el sistema operativo Linux, necesita las siguientes bibliotecas:

Sablot
iconv
Expat

Puede Rubí-Sablotron encontrar estas bibliotecas.

XSLT4R

XSLT4R escrito por Michael Neumann. XSLT4R para la interacción sencilla línea de comandos, las aplicaciones de terceros puede ser utilizado para transformar documentos XML.

XSLT4R necesita operación XMLScan, incluyendo archivo XSLT4R, que es un módulo de Ruby 100%. Estos módulos pueden utilizar el método estándar de instalación de Ruby (es decir install.rb rubí) de la instalación.

sintaxis XSLT4R es el siguiente:

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

Si desea utilizar XSLT4R en su aplicación, puede introducir parámetros XSLT y de entrada que necesita. Ejemplos son los siguientes:

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 )

más información

REXML completa analizador, consulte la documentación del programa de análisis de documentos REXML .
Puede comenzar con RAA Conocimiento descarga XSLT4R en.

Anterior: programación Ruby Socket