Rubi XML, XSLT e XPath Tutorial

Seguinte: rubi Web Services Applications - soap4r

O que é XML?

Refere-se a Extensible Markup Language XML (eXtensible Markup Language).

Extensible Markup Language, um subconjunto da Standard Generalized Markup Language, um método para a marcação de um documento eletrônico para ter uma linguagem de marcação estruturada.

Ele pode ser usado para marcar de dados, definição de tipos de dados, é uma tecnologia que permite aos usuários definir o seu próprio idioma de origem linguagem de marcação. É ideal para a transmissão Web, proporcionando uma abordagem unificada para descrever e trocar independentes de aplicativos ou fornecedores de dados estruturados.

Para mais informações, por favor veja nosso tutorial XML

parser XML e da estrutura API

XML parser SAX e DOM são principalmente dois tipos.

parser SAX é o processamento baseado em eventos, a digitalização de documentos XML precisa do início ao fim mais uma vez, no processo de digitalização, cada vez passando por uma estrutura gramatical, ele irá chamar a estrutura gramatical específica manipulador de eventos, enviar o pedido um evento.
DOM Document Object Model análise, construção de estrutura gramatical hierárquica do documento, estabelecer árvore DOM no nó da árvore DOM memória como um objeto para identificar, documentar a análise Wencheng, toda a árvore DOM irá documentar na memória.

Ruby para analisar e criar XML

RUBY análise de documentos XML pode usar esta biblioteca REXML biblioteca.

biblioteca REXML é um rubi kit de ferramentas XML é usar linguagem Ruby puro, seguir as normas XML1.0.

Em versões ruby1.8 e posteriores, a biblioteca irá conter RUBY REXML.

biblioteca caminho REXML é: rexml / documento

Todos os métodos e classes são empacotados em um módulo REXML.

REXML analisador tem as seguintes vantagens em relação a outros analisadores:

100% escrito por Ruby.
Aplicável a sax e analisador DOM.
É leve, menos de 2000 linhas de código.
Fácil de entender métodos e classes.
Com base API SAX2 e suporte XPath completo.
Use a instalação Ruby, sem a necessidade de instalações separadas.

O que se segue é um exemplo de código XML, salve-o 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>

parser DOM

Vamos começar a analisar dados XML Primeiro introduzimos biblioteca rexml / documento, nós geralmente pode estar na REXML namespace de nível superior introduzidas:

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

O exemplo acima saída é:

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

Processando o mesmo arquivo de dados: movies.xml, análise SAX não é recomendado como um arquivo pequeno, o seguinte é um exemplo simples:

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

Acima de saída é:

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

Podemos usar XPath para ver XML, XPath para encontrar a informação é um documento em linguagem XML (Veja: XPath Tutorial ).

XPath é a linguagem XML Path, é um método utilizado para determinar o XML (um subconjunto da Standard Generalized Markup Language) linguagem do documento uma parte do local. árvore XML XPath-based, e fornece a capacidade de olhar para nos nós de estrutura de dados na árvore.

XPath suporte XPath de Ruby por classe de REXML, que é baseada na árvore de análise (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

O exemplo acima saída é:

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

XSLT e Ruby

Ruby tem duas analisador XSLT, uma breve descrição é dada abaixo:

Rubi-Sablotron

Este analisador é escrito e mantido pela justiça Masayoshi Takahash. Isto é escrito principalmente para o sistema operacional Linux, são necessários os seguintes bibliotecas:

sablot
iconv
Expat

Você pode Rubi-Sablotron localizar essas bibliotecas.

XSLT4R

XSLT4R escrito por Michael Neumann. XSLT4R para interação simples linha de comando, aplicativos de terceiros pode ser usado para transformar documentos XML.

XSLT4R precisa XMLScan operação, incluindo arquivo XSLT4R, que é um módulo de 100% do rubi. Estes módulos podem usar o método padrão de instalação do Ruby (ou seja install.rb rubi) de instalação.

sintaxe XSLT4R é como se segue:

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

Se você quiser usar XSLT4R em seu aplicativo, você pode introduzir XSLT e entrada parâmetros que você precisa. Exemplos são os seguintes:

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 )

mais informações

analisador REXML completa, consulte a documentação do analisador documento REXML .
Você pode começar com RAA Conhecimento de download XSLT4R in.

Anterior: Programming Ruby soquete