English | 简体中文 | 繁體中文 | Русский язык | Français | Español | Português | Deutsch | 日本語 | 한국어 | Italiano | بالعربية

Tutorial básico de Ruby

Tutorial avançado de Ruby

Tutorial XML, XSLT e XPath Ruby

O que é XML?

XML significa Linguagem de Marcação Extensível (eXtensible Markup Language).

Linguagem de marcação extensível, subconjunto do linguagem de marcação geral, uma linguagem de marcação usada para marcar documentos eletrônicos para que tenham estrutura.

Pode ser usado para marcar dados, definir tipos de dados, é uma linguagem de origem que permite que os usuários definam sua própria linguagem de marcação. É muito adequado para a transmissão da web, fornecendo um método uniforme para descrever e trocar dados estruturados independentes de aplicativos ou fornecedores.

Para mais conteúdo, consulte nossa Tutorial de XML

Estrutura e API do analisador XML

Os analisadores de XML principais são DOM e SAX.

  • O analisador SAX é baseado no processamento de eventos, é necessário varrer o documento XML de cabeça a pé, durante o processo de varredura, toda vez que encontrar uma estrutura sintática, será chamado o programa de tratamento de eventos dessa estrutura sintática específica, enviando um evento para o aplicativo.

  • DOM é a análise do modelo de objeto de documento, constrói a estrutura sintática hierárquica do documento, cria uma árvore DOM em memória, os nós da árvore DOM são identificados como objetos, após a análise do documento, toda a árvore DOM do documento será colocada na memória.

Análise e criação de XML no Ruby

A análise de documentos XML no RUBY pode ser feita usando a biblioteca REXML.

A biblioteca REXML é um pacote de XML do ruby, escrita em Ruby puro, que observa a especificação XML.1.0 especificação.

Em Ruby1.8Versão e posteriores, o RUBY padrão incluirá REXML.

O caminho para a biblioteca REXML é: rexml/documento

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

Os pontos fortes do parser REXML em comparação com outros são:

  • 100% escrito em Ruby.

  • Aplicável a parsers SAX e DOM.

  • É leve, menos de2000 linhas de código.

  • Métodos e classes fácilmente compreensíveis.

  • Baseado em SAX2 Suporte completo para API e XPath.

  • Instale usando Ruby, sem a necessidade de instalação separada.

A seguir está o código XML de exemplo, salve como movies.xml:

<collection shelf="Novos Chegados">
<movie title="Enemy Behind">
　　　<type>Guerra, Thriller</type>
　　　<format>DVD</format>
　　　<year>2003</year>
　　　<rating>PG</rating>
　　　<stars>10</stars>
　　　<description>Falar sobre um EUA-Guerra japonesa</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>
</coleção>

Parser DOM

Vamos primeiro analisar os dados XML, antes de tudo precisamos importar o rexml/Biblioteca de documento, geralmente podemos importar o REXML no espaço de nomes superior:

Exemplo Online

#!/usr/bin/ruby　-w
　
require 'rexml'/documento
include REXML
　
xmlfile = File.new("movies.xml")
xmldoc = Document.new(xmlfile)
　
# Obter o elemento root
root = xmldoc.root
puts "Elemento raiz: "　+　root.attributes["shelf"]
　
root.attributes["shelf"]
xmldoc.elements.each("collection"/# A seguir, será impresso o título do filme　
　　　movie"){　+　|e| puts "Título do Filme: "　
}
　
e.attributes["title"]
xmldoc.elements.each("collection"/movie/# A seguir, será impressa todos os tipos de filmes
　　　|e| puts "Tipo de Filme: "　+　e.text　
}
　
# A seguir, será impressa todas as descrições de filmes
xmldoc.elements.each("collection"/movie/description) {
　　　|e| puts "Descrição do Filme: "　+　e.text　
}

O resultado da saída do exemplo acima é:

Elemento raiz: Novos Chegadas
Título do Filme: Enemy Behind
Título do Filme: Transformers
Título do Filme: Trigun
Título do Filme: Ishtar
Tipo de Filme: Guerra, Thriller
Tipo de Filme: Anime, Ficção Científica
Tipo de Filme: Anime, Ação
Tipo de Filme: Comédia
Descrição do Filme: Fale sobre um EUA-Guerra do Japão
Descrição do Filme: Uma ficção científica
Descrição do Filme: Vash the Stampede!
Descrição do Filme: Boredom visível
SAX-como Parsing:

Parser SAX

Tratar o mesmo arquivo de dados: movies.xml, não é recomendável a análise SAX para um arquivo pequeno, aqui está um exemplo simples:

Exemplo Online

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

O resultado da saída acima é：

tag_start:　"collection",　{"shelf"=>"Novos　Chegados"}
tag_start:　"movie",　{"title"=>"Inimigo　Atrás"}
tag_start:　"type",　{}
　　text　　　:　　　"Guerra,　Thriller"
tag_start:　"format",　{}
tag_start:　"year",　{}
tag_start:　"rating",　{}
tag_start:　"stars",　{}
tag_start:　"description",　{}
　　text　　　:　　　"Fale　sobre　uma　guerra　dos　EUA-Guerra　do　Japão"
tag_start:　"movie",　{"title"=>"Transformers"}
tag_start:　"type",　{}
　　text　　　:　　　"Anime,　Ficção　Científica"
tag_start:　"format",　{}
tag_start:　"year",　{}
tag_start:　"rating",　{}
tag_start:　"stars",　{}
tag_start:　"description",　{}
　　text　　　:　　　"Uma　ficção　científica"
tag_start:　"movie",　{"title"=>"Trigun"}
tag_start:　"type",　{}
　　text　　　:　　　"Anime,　Ação"
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　　　:　　　"Visualmente　monótono"

XPath e Ruby

Podemos usar XPath para visualizar XML, XPath é uma linguagem usada para encontrar informações em documentos XML (ver:Tutorial de XPath)。

XPath é a linguagem de caminho XML, uma linguagem usada para determinar a posição de uma parte de um documento XML (subconjunto do linguagem de marcação de documentos padrão). XPath está baseado na estrutura em árvore do XML, fornecendo a capacidade de encontrar nós em uma estrutura de dados em árvore.

O Ruby suporta XPath através da classe REXML, que é uma análise baseada em árvore (Modelo de Objetos de Documento).

Exemplo Online

#!/usr/bin/ruby　-w
　
require 'rexml'/documento
include REXML
　
xmlfile = File.new("movies.xml")
xmldoc = Document.new(xmlfile)
　
# Informações do primeiro filme
movie = XPath.first(xmldoc, ""//movie)
p movie
　
# Imprime todos os tipos de filmes
XPath.each(xmldoc, ""//type) { |e| puts e.text }
　
# Obtém todos os tipos de formatos de filmes, retorna um array
names = XPath.match(xmldoc, ""//format).map { |x| x.text }
p names

O resultado da saída do exemplo acima é:

<movie title='Inimigo por Trás'> ... </>
Guerra, Thriller
Anime, Ficção Científica
Anime, Ação
Comédia
["DVD", "DVD", "DVD", "VHS"]

XSLT e Ruby

Existem dois analisadores XSLT no Ruby, aqui está uma descrição breve:

Ruby-Sablotron

Este analisador é escrito e mantido por Masayoshi Takahashi. Ele é principalmente escrito para o sistema operacional Linux e requer as seguintes bibliotecas:

  • Sablot

  • Iconv

  • Expat

Você pode encontrar Ruby-Sablotron Encontre essas bibliotecas.

XSLT4R

XSLT4O R foi escrito por Michael Neumann. XSLT4O R é usado para interação de linha de comando simples e pode ser usado por aplicações de terceiros para converter documentos XML.

XSLT4O R necessita da operação XMLScan, que inclui XSLT4Arquivo R, que é um100% dos módulos do Ruby. Esses módulos podem ser instalados usando o método de instalação padrão do Ruby (ou seja, Ruby install.rb).

XSLT4O formato de sintaxe do R é o seguinte:

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

Se você quiser usar XSLT em seu aplicativo4R, você pode introduzir XSLT e fornecer os parâmetros necessários. Veja o exemplo a seguir:

Exemplo 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　)

Mais informações

Web Service RubyProgramação de Socket Ruby