kotovalexarian-likes-github/ruby--ruby
1
0
Fork 0
mirror of https://github.com/ruby/ruby.git synced 2022-11-09 12:17:21 -05:00
Code Releases Activity

* lib/rss/: untabified.

Browse source 
* test/rss/: untabified.
* lib/rss/0.9.rb (RSS::Rss#to_s): inent -> indent.


git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@7048 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
This commit is contained in:
kou 2004-10-16 04:51:15 +00:00
parent 0ebac90b0e
commit 891ad83098
27 changed files with 3937 additions and 3931 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

6
ChangeLog
View file

@ -1,3 +1,9 @@
Sat Oct 16 13:42:49 2004 Kouhei Sutou <kou@cozmixng.org>
* lib/rss/: untabified.
* test/rss/: untabified.
* lib/rss/0.9.rb (RSS::Rss#to_s): inent -> indent.
Sat Oct 16 13:34:56 2004 Kouhei Sutou <kou@cozmixng.org> Sat Oct 16 13:34:56 2004 Kouhei Sutou <kou@cozmixng.org>
* lib/rss: supported prety print. * lib/rss: supported prety print.

774
lib/rss/0.9.rb
View file

@ -2,144 +2,144 @@ require "rss/parser"
module RSS module RSS
module RSS09 module RSS09
NSPOOL = {} NSPOOL = {}
ELEMENTS = [] ELEMENTS = []
def self.append_features(klass) def self.append_features(klass)
super super
klass.install_must_call_validator('', nil) klass.install_must_call_validator('', nil)
end end
end end
class Rss < Element class Rss < Element
include RSS09 include RSS09
include RootElementMixin include RootElementMixin
include XMLStyleSheetMixin include XMLStyleSheetMixin
[ [
["channel", nil], ["channel", nil],
].each do |tag, occurs| ].each do |tag, occurs|
install_model(tag, occurs) install_model(tag, occurs)
end end
%w(channel).each do |x| %w(channel).each do |x|
install_have_child_element(x) install_have_child_element(x)
end end
attr_accessor :rss_version, :version, :encoding, :standalone attr_accessor :rss_version, :version, :encoding, :standalone
def initialize(rss_version, version=nil, encoding=nil, standalone=nil) def initialize(rss_version, version=nil, encoding=nil, standalone=nil)
super super
end end
def items def items
if @channel if @channel
@channel.items @channel.items
else else
[] []
end end
end end
def image def image
if @channel if @channel
@channel.image @channel.image
else else
nil nil
end end
end end
def to_s(convert=true, indent=calc_indent) def to_s(convert=true, indent=calc_indent)
next_indent = indent + INDENT next_indent = indent + INDENT
rv = <<-EOR rv = <<-EOR
#{xmldecl} #{xmldecl}
#{xml_stylesheet_pi} #{xml_stylesheet_pi}
#{indent}<rss version="#{@rss_version}"#{ns_declaration(next_indent)}> #{indent}<rss version="#{@rss_version}"#{ns_declaration(next_indent)}>
#{channel_element(false, next_indent)} #{channel_element(false, next_indent)}
#{other_element(false, next_indent)} #{other_element(false, next_indent)}
#{inent}}</rss> #{indent}}</rss>
EOR EOR
rv = @converter.convert(rv) if convert and @converter rv = @converter.convert(rv) if convert and @converter
remove_empty_newline(rv) remove_empty_newline(rv)
end end
private private
def children def children
[@channel] [@channel]
end end
def _tags def _tags
[ [
[nil, 'channel'], [nil, 'channel'],
].delete_if {|x| send(x[1]).nil?} ].delete_if {|x| send(x[1]).nil?}
end end
def _attrs def _attrs
[ [
["version", true], ["version", true],
] ]
end end
class Channel < Element class Channel < Element
include RSS09 include RSS09
[ [
["title", nil], ["title", nil],
["link", nil], ["link", nil],
["description", nil], ["description", nil],
["language", nil], ["language", nil],
["copyright", "?"], ["copyright", "?"],
["managingEditor", "?"], ["managingEditor", "?"],
["webMaster", "?"], ["webMaster", "?"],
["rating", "?"], ["rating", "?"],
["docs", "?"], ["docs", "?"],
["skipDays", "?"], ["skipDays", "?"],
["skipHours", "?"], ["skipHours", "?"],
].each do |x, occurs| ].each do |x, occurs|
install_text_element(x) install_text_element(x)
install_model(x, occurs) install_model(x, occurs)
end end
[ [
["pubDate", "?"], ["pubDate", "?"],
["lastBuildDate", "?"], ["lastBuildDate", "?"],
].each do |x, occurs| ].each do |x, occurs|
install_date_element(x, 'rfc822') install_date_element(x, 'rfc822')
install_model(x, occurs) install_model(x, occurs)
end end
[ [
["image", nil], ["image", nil],
["textInput", "?"], ["textInput", "?"],
].each do |x, occurs| ].each do |x, occurs|
install_have_child_element(x) install_have_child_element(x)
install_model(x, occurs) install_model(x, occurs)
end end
[ [
["cloud", "?"] ["cloud", "?"]
].each do |x, occurs| ].each do |x, occurs|
install_have_attribute_element(x) install_have_attribute_element(x)
install_model(x, occurs) install_model(x, occurs)
end end
[ [
["item", "*"] ["item", "*"]
].each do |x, occurs| ].each do |x, occurs|
install_have_children_element(x) install_have_children_element(x)
install_model(x, occurs) install_model(x, occurs)
end end
def initialize() def initialize()
super() super()
end end
def to_s(convert=true, indent=calc_indent) def to_s(convert=true, indent=calc_indent)
next_indent = indent + INDENT next_indent = indent + INDENT
rv = <<-EOT rv = <<-EOT
#{indent}<channel> #{indent}<channel>
#{title_element(false, next_indent)} #{title_element(false, next_indent)}
#{link_element(false, next_indent)} #{link_element(false, next_indent)}
@ -160,60 +160,60 @@ EOR
#{other_element(false, next_indent)} #{other_element(false, next_indent)}
#{indent}</channel> #{indent}</channel>
EOT EOT
rv = @converter.convert(rv) if convert and @converter rv = @converter.convert(rv) if convert and @converter
rv rv
end end
private private
def children def children
[@image, @textInput, @cloud, *@item] [@image, @textInput, @cloud, *@item]
end end
def _tags def _tags
rv = [ rv = [
"title", "title",
"link", "link",
"description", "description",
"language", "language",
"copyright", "copyright",
"managingEditor", "managingEditor",
"webMaster", "webMaster",
"rating", "rating",
"docs", "docs",
"skipDays", "skipDays",
"skipHours", "skipHours",
"image", "image",
"textInput", "textInput",
"cloud", "cloud",
].delete_if do |x| ].delete_if do |x|
send(x).nil? send(x).nil?
end.collect do |elem| end.collect do |elem|
[nil, elem] [nil, elem]
end end
@item.each do @item.each do
rv << [nil, "item"] rv << [nil, "item"]
end end
rv rv
end end
class Image < Element class Image < Element
include RSS09 include RSS09
%w(url title link).each do |x| %w(url title link).each do |x|
install_text_element(x) install_text_element(x)
install_model(x, nil) install_model(x, nil)
end end
%w(width height description).each do |x| %w(width height description).each do |x|
install_text_element(x) install_text_element(x)
install_model(x, "?") install_model(x, "?")
end end
def to_s(convert=true, indent=calc_indent) def to_s(convert=true, indent=calc_indent)
next_indent = indent + INDENT next_indent = indent + INDENT
rv = <<-EOT rv = <<-EOT
#{indent}<image> #{indent}<image>
#{url_element(false, next_indent)} #{url_element(false, next_indent)}
#{title_element(false, next_indent)} #{title_element(false, next_indent)}
@ -224,46 +224,46 @@ EOT
#{other_element(false, next_indent)} #{other_element(false, next_indent)}
#{indent}</image> #{indent}</image>
EOT EOT
rv = @converter.convert(rv) if convert and @converter rv = @converter.convert(rv) if convert and @converter
rv rv
end end
private private
def _tags def _tags
%w(url title link width height description).delete_if do |x| %w(url title link width height description).delete_if do |x|
send(x).nil? send(x).nil?
end.collect do |elem| end.collect do |elem|
[nil, elem] [nil, elem]
end end
end end
end end
class Cloud < Element class Cloud < Element
include RSS09 include RSS09
[ [
["domain", nil, true], ["domain", nil, true],
["port", nil, true], ["port", nil, true],
["path", nil, true], ["path", nil, true],
["registerProcedure", nil, true], ["registerProcedure", nil, true],
["protocol", nil ,true], ["protocol", nil ,true],
].each do |name, uri, required| ].each do |name, uri, required|
install_get_attribute(name, uri, required) install_get_attribute(name, uri, required)
end end
def initialize(domain, port, path, rp, protocol) def initialize(domain, port, path, rp, protocol)
super() super()
@domain = domain @domain = domain
@port = port @port = port
@path = path @path = path
@registerProcedure = rp @registerProcedure = rp
@protocol = protocol @protocol = protocol
end end
def to_s(convert=true, indent=calc_indent) def to_s(convert=true, indent=calc_indent)
next_indent = indent + INDENT next_indent = indent + INDENT
rv = <<-EOT rv = <<-EOT
#{indent}<cloud #{indent}<cloud
#{next_indent}domain="#{h @domain}" #{next_indent}domain="#{h @domain}"
#{next_indent}port="#{h @port}" #{next_indent}port="#{h @port}"
@ -271,45 +271,45 @@ EOT
#{next_indent}registerProcedure="#{h @registerProcedure}" #{next_indent}registerProcedure="#{h @registerProcedure}"
#{next_indent}protocol="#{h @protocol}"/> #{next_indent}protocol="#{h @protocol}"/>
EOT EOT
rv = @converter.convert(rv) if convert and @converter rv = @converter.convert(rv) if convert and @converter
rv rv
end end
private private
def _attrs def _attrs
%w(domain port path registerProcedure protocol).collect do |attr| %w(domain port path registerProcedure protocol).collect do |attr|
[attr, true] [attr, true]
end end
end end
end end
class Item < Element class Item < Element
include RSS09 include RSS09
%w(title link description).each do |x| %w(title link description).each do |x|
install_text_element(x) install_text_element(x)
end end
%w(category source enclosure).each do |x| %w(category source enclosure).each do |x|
install_have_child_element(x) install_have_child_element(x)
end end
[ [
["title", '?'], ["title", '?'],
["link", '?'], ["link", '?'],
["description", '?'], ["description", '?'],
["category", '?'], ["category", '?'],
["source", '?'], ["source", '?'],
["enclosure", '?'], ["enclosure", '?'],
].each do |tag, occurs| ].each do |tag, occurs|
install_model(tag, occurs) install_model(tag, occurs)
end end
def to_s(convert=true, indent=calc_indent) def to_s(convert=true, indent=calc_indent)
next_indent = indent + INDENT next_indent = indent + INDENT
rv = <<-EOT rv = <<-EOT
#{indent}<item> #{indent}<item>
#{title_element(false, next_indent)} #{title_element(false, next_indent)}
#{link_element(false, next_indent)} #{link_element(false, next_indent)}
@ -320,159 +320,159 @@ EOT
#{other_element(false, next_indent)} #{other_element(false, next_indent)}
#{indent}</item> #{indent}</item>
EOT EOT
rv = @converter.convert(rv) if convert and @converter rv = @converter.convert(rv) if convert and @converter
rv rv
end end
private private
def children def children
[@category, @source, @enclosure,].compact [@category, @source, @enclosure,].compact
end end
def _tags def _tags
%w(title link description author comments category %w(title link description author comments category
source enclosure).delete_if do |x| source enclosure).delete_if do |x|
send(x).nil? send(x).nil?
end.collect do |x| end.collect do |x|
[nil, x] [nil, x]
end end
end end
class Source < Element class Source < Element
include RSS09 include RSS09
[ [
["url", nil, true] ["url", nil, true]
].each do |name, uri, required| ].each do |name, uri, required|
install_get_attribute(name, uri, required) install_get_attribute(name, uri, required)
end end
content_setup content_setup
def initialize(url=nil, content=nil) def initialize(url=nil, content=nil)
super() super()
@url = url @url = url
@content = content @content = content
end end
def to_s(convert=true, indent=calc_indent) def to_s(convert=true, indent=calc_indent)
if @url if @url
rv = %Q! <source url="#{@url}">! rv = %Q! <source url="#{@url}">!
rv << %Q!#{@content}</source>! rv << %Q!#{@content}</source>!
rv = @converter.convert(rv) if convert and @converter rv = @converter.convert(rv) if convert and @converter
rv rv
else else
'' ''
end end
end end
private private
def _tags def _tags
[] []
end end
def _attrs def _attrs
[ [
["url", true] ["url", true]
] ]
end end
end end
class Enclosure < Element class Enclosure < Element
include RSS09 include RSS09
[ [
["url", nil, true], ["url", nil, true],
["length", nil, true], ["length", nil, true],
["type", nil, true], ["type", nil, true],
].each do |name, uri, required| ].each do |name, uri, required|
install_get_attribute(name, uri, required) install_get_attribute(name, uri, required)
end end
def initialize(url=nil, length=nil, type=nil) def initialize(url=nil, length=nil, type=nil)
super() super()
@url = url @url = url
@length = length @length = length
@type = type @type = type
end end
def to_s(convert=true, indent=calc_indent) def to_s(convert=true, indent=calc_indent)
if @url and @length and @type if @url and @length and @type
rv = %Q!<enclosure url="#{h @url}" ! rv = %Q!<enclosure url="#{h @url}" !
rv << %Q!length="#{h @length}" type="#{h @type}"/>! rv << %Q!length="#{h @length}" type="#{h @type}"/>!
rv = @converter.convert(rv) if convert and @converter rv = @converter.convert(rv) if convert and @converter
rv rv
else else
'' ''
end end
end end
private private
def _attrs def _attrs
[ [
["url", true], ["url", true],
["length", true], ["length", true],
["type", true], ["type", true],
] ]
end end
end end
class Category < Element class Category < Element
include RSS09 include RSS09
[ [
["domain", nil, true] ["domain", nil, true]
].each do |name, uri, required| ].each do |name, uri, required|
install_get_attribute(name, uri, required) install_get_attribute(name, uri, required)
end end
content_setup content_setup
def initialize(domain=nil, content=nil) def initialize(domain=nil, content=nil)
super() super()
@domain = domain @domain = domain
@content = content @content = content
end end
def to_s(convert=true, indent=calc_indent) def to_s(convert=true, indent=calc_indent)
if @domain if @domain
rv = %Q!<category domain="#{h @domain}">! rv = %Q!<category domain="#{h @domain}">!
rv << %Q!#{h @content}</category>! rv << %Q!#{h @content}</category>!
rv = @converter.convert(rv) if convert and @converter rv = @converter.convert(rv) if convert and @converter
rv rv
else else
'' ''
end end
end end
private private
def _attrs def _attrs
[ [
["domain", true] ["domain", true]
] ]
end end
end end
end end
class TextInput < Element class TextInput < Element
include RSS09 include RSS09
%w(title description name link).each do |x| %w(title description name link).each do |x|
install_text_element(x) install_text_element(x)
install_model(x, nil) install_model(x, nil)
end end
def to_s(convert=true, indent=calc_indent) def to_s(convert=true, indent=calc_indent)
next_indent = indent + INDENT next_indent = indent + INDENT
rv = <<-EOT rv = <<-EOT
#{indent}<textInput> #{indent}<textInput>
#{title_element(false, next_indent)} #{title_element(false, next_indent)}
#{description_element(false, next_indent)} #{description_element(false, next_indent)}
@ -481,42 +481,42 @@ EOT
#{other_element(false, next_indent)} #{other_element(false, next_indent)}
#{indent}</textInput> #{indent}</textInput>
EOT EOT
rv = @converter.convert(rv) if convert and @converter rv = @converter.convert(rv) if convert and @converter
rv rv
end end
private private
def _tags def _tags
%w(title description name link).each do |x| %w(title description name link).each do |x|
send(x).nil? send(x).nil?
end.collect do |elem| end.collect do |elem|
[nil, elem] [nil, elem]
end end
end end
end end
end end
end end
RSS09::ELEMENTS.each do |x| RSS09::ELEMENTS.each do |x|
BaseListener.install_get_text_element(x, nil, "#{x}=") BaseListener.install_get_text_element(x, nil, "#{x}=")
end end
module ListenerMixin module ListenerMixin
private private
def start_rss(tag_name, prefix, attrs, ns) def start_rss(tag_name, prefix, attrs, ns)
check_ns(tag_name, prefix, ns, nil) check_ns(tag_name, prefix, ns, nil)
@rss = Rss.new(attrs['version'], @version, @encoding, @standalone) @rss = Rss.new(attrs['version'], @version, @encoding, @standalone)
@rss.do_validate = @do_validate @rss.do_validate = @do_validate
@rss.xml_stylesheets = @xml_stylesheets @rss.xml_stylesheets = @xml_stylesheets
@last_element = @rss @last_element = @rss
@proc_stack.push Proc.new { |text, tags| @proc_stack.push Proc.new { |text, tags|
@rss.validate_for_stream(tags) if @do_validate @rss.validate_for_stream(tags) if @do_validate
} }
end end
end end
end end

986
lib/rss/1.0.rb
View file

File diff suppressed because it is too large Load diff

224
lib/rss/2.0.rb
View file

@ -2,149 +2,149 @@ require "rss/0.9"
module RSS module RSS
class Rss class Rss
class Channel class Channel
%w(generator ttl).each do |x| %w(generator ttl).each do |x|
install_text_element(x) install_text_element(x)
install_model(x, '?') install_model(x, '?')
end end
%w(category).each do |x| %w(category).each do |x|
install_have_child_element(x) install_have_child_element(x)
install_model(x, '?') install_model(x, '?')
end end
[ [
["image", "?"], ["image", "?"],
["language", "?"], ["language", "?"],
].each do |x, occurs| ].each do |x, occurs|
install_model(x, occurs) install_model(x, occurs)
end end
def other_element(convert, indent) def other_element(convert, indent)
rv = <<-EOT rv = <<-EOT
#{category_element(convert, indent)} #{category_element(convert, indent)}
#{generator_element(convert, indent)} #{generator_element(convert, indent)}
#{ttl_element(convert, indent)} #{ttl_element(convert, indent)}
EOT EOT
rv << super rv << super
end end
private private
alias children09 children alias children09 children
def children def children
children09 + [@category].compact children09 + [@category].compact
end end
alias _tags09 _tags alias _tags09 _tags
def _tags def _tags
%w(generator ttl category).delete_if do |x| %w(generator ttl category).delete_if do |x|
send(x).nil? send(x).nil?
end.collect do |elem| end.collect do |elem|
[nil, elem] [nil, elem]
end + _tags09 end + _tags09
end end
Category = Item::Category Category = Item::Category
class Item class Item
[ [
["comments", "?"], ["comments", "?"],
["author", "?"], ["author", "?"],
].each do |x, occurs| ].each do |x, occurs|
install_text_element(x) install_text_element(x)
install_model(x, occurs) install_model(x, occurs)
end end
[ [
["pubDate", '?'], ["pubDate", '?'],
].each do |x, occurs| ].each do |x, occurs|
install_date_element(x, 'rfc822') install_date_element(x, 'rfc822')
install_model(x, occurs) install_model(x, occurs)
end end
[ [
["guid", '?'], ["guid", '?'],
].each do |x, occurs| ].each do |x, occurs|
install_have_child_element(x) install_have_child_element(x)
install_model(x, occurs) install_model(x, occurs)
end end
def other_element(convert, indent) def other_element(convert, indent)
rv = <<-EOT rv = <<-EOT
#{author_element(false, indent)} #{author_element(false, indent)}
#{comments_element(false, indent)} #{comments_element(false, indent)}
#{pubDate_element(false, indent)} #{pubDate_element(false, indent)}
#{guid_element(false, indent)} #{guid_element(false, indent)}
EOT EOT
rv << super rv << super
end end
private private
alias children09 children alias children09 children
def children def children
children09 + [@guid].compact children09 + [@guid].compact
end end
alias _tags09 _tags alias _tags09 _tags
def _tags def _tags
%w(comments author pubDate guid).delete_if do |x| %w(comments author pubDate guid).delete_if do |x|
send(x).nil? send(x).nil?
end.collect do |elem| end.collect do |elem|
[nil, elem] [nil, elem]
end + _tags09 end + _tags09
end end
class Guid < Element class Guid < Element
include RSS09 include RSS09
[ [
["isPermaLink", nil, false] ["isPermaLink", nil, false]
].each do |name, uri, required| ].each do |name, uri, required|
install_get_attribute(name, uri, required) install_get_attribute(name, uri, required)
end end
content_setup content_setup
def initialize(isPermaLink=nil, content=nil) def initialize(isPermaLink=nil, content=nil)
super() super()
@isPermaLink = isPermaLink @isPermaLink = isPermaLink
@content = content @content = content
end end
def to_s(convert=true, indent=calc_indent) def to_s(convert=true, indent=calc_indent)
if @content if @content
rv = %Q!<guid! rv = %Q!<guid!
rv << %Q! isPermaLink="#{h @isPermaLink}"! if @isPermaLink rv << %Q! isPermaLink="#{h @isPermaLink}"! if @isPermaLink
rv << %Q!>#{h @content}</guid>! rv << %Q!>#{h @content}</guid>!
rv = @converter.convert(rv) if convert and @converter rv = @converter.convert(rv) if convert and @converter
rv rv
else else
'' ''
end end
end end
private private
def _attrs def _attrs
[ [
["isPermaLink", false] ["isPermaLink", false]
] ]
end end
end end
end end
end end
end end
RSS09::ELEMENTS.each do |x| RSS09::ELEMENTS.each do |x|
BaseListener.install_get_text_element(x, nil, "#{x}=") BaseListener.install_get_text_element(x, nil, "#{x}=")
end end
end end

72
lib/rss/content.rb
View file

@ -2,51 +2,51 @@ require "rss/1.0"
module RSS module RSS
CONTENT_PREFIX = 'content' CONTENT_PREFIX = 'content'
CONTENT_URI = "http://purl.org/rss/1.0/modules/content/" CONTENT_URI = "http://purl.org/rss/1.0/modules/content/"
RDF.install_ns(CONTENT_PREFIX, CONTENT_URI) RDF.install_ns(CONTENT_PREFIX, CONTENT_URI)
module ContentModel module ContentModel
extend BaseModel extend BaseModel
ELEMENTS = [] ELEMENTS = []
def self.append_features(klass) def self.append_features(klass)
super super
klass.module_eval(<<-EOC) klass.module_eval(<<-EOC)
%w(encoded).each do |x| %w(encoded).each do |x|
install_text_element("\#{CONTENT_PREFIX}_\#{x}") install_text_element("\#{CONTENT_PREFIX}_\#{x}")
end end
EOC EOC
end end
def content_validate(tags) def content_validate(tags)
counter = {} counter = {}
ELEMENTS.each do |x| ELEMENTS.each do |x|
counter[x] = 0 counter[x] = 0
end end
tags.each do |tag| tags.each do |tag|
key = "#{CONTENT_PREFIX}_#{tag}" key = "#{CONTENT_PREFIX}_#{tag}"
raise UnknownTagError.new(tag, CONTENT_URI) unless counter.has_key?(key) raise UnknownTagError.new(tag, CONTENT_URI) unless counter.has_key?(key)
counter[key] += 1 counter[key] += 1
raise TooMuchTagError.new(tag, tag_name) if counter[key] > 1 raise TooMuchTagError.new(tag, tag_name) if counter[key] > 1
end end
end end
end end
class RDF class RDF
class Item; include ContentModel; end class Item; include ContentModel; end
end end
prefix_size = CONTENT_PREFIX.size + 1 prefix_size = CONTENT_PREFIX.size + 1
ContentModel::ELEMENTS.uniq! ContentModel::ELEMENTS.uniq!
ContentModel::ELEMENTS.each do |x| ContentModel::ELEMENTS.each do |x|
BaseListener.install_get_text_element(x[prefix_size..-1], CONTENT_URI, "#{x}=") BaseListener.install_get_text_element(x[prefix_size..-1], CONTENT_URI, "#{x}=")
end end
end end

286
lib/rss/converter.rb
View file

@ -2,154 +2,154 @@ require "rss/utils"
module RSS module RSS
class Converter class Converter
include Utils include Utils
def initialize(to_enc, from_enc=nil) def initialize(to_enc, from_enc=nil)
normalized_to_enc = to_enc.downcase.gsub(/-/, '_') normalized_to_enc = to_enc.downcase.gsub(/-/, '_')
from_enc ||= 'utf-8' from_enc ||= 'utf-8'
normalized_from_enc = from_enc.downcase.gsub(/-/, '_') normalized_from_enc = from_enc.downcase.gsub(/-/, '_')
if normalized_to_enc == normalized_from_enc if normalized_to_enc == normalized_from_enc
def_same_enc() def_same_enc()
else else
def_diff_enc = "def_to_#{normalized_to_enc}_from_#{normalized_from_enc}" def_diff_enc = "def_to_#{normalized_to_enc}_from_#{normalized_from_enc}"
if respond_to?(def_diff_enc) if respond_to?(def_diff_enc)
__send__(def_diff_enc) __send__(def_diff_enc)
else else
def_else_enc(to_enc, from_enc) def_else_enc(to_enc, from_enc)
end end
end end
end end
def convert(value) def convert(value)
value value
end end
def def_convert(depth=0) def def_convert(depth=0)
instance_eval(<<-EOC, *get_file_and_line_from_caller(depth)) instance_eval(<<-EOC, *get_file_and_line_from_caller(depth))
def convert(value) def convert(value)
if value.kind_of?(String) if value.kind_of?(String)
#{yield('value')} #{yield('value')}
else else
value value
end end
end end
EOC EOC
end end
def def_iconv_convert(to_enc, from_enc, depth=0) def def_iconv_convert(to_enc, from_enc, depth=0)
begin begin
require "iconv" require "iconv"
@iconv = Iconv.new(to_enc, from_enc) @iconv = Iconv.new(to_enc, from_enc)
def_convert(depth+1) do |value| def_convert(depth+1) do |value|
<<-EOC <<-EOC
begin begin
@iconv.iconv(#{value}) @iconv.iconv(#{value})
rescue Iconv::Failure rescue Iconv::Failure
raise ConversionError.new(#{value}, "#{to_enc}", "#{from_enc}") raise ConversionError.new(#{value}, "#{to_enc}", "#{from_enc}")
end end
EOC EOC
end end
rescue LoadError, ArgumentError, SystemCallError rescue LoadError, ArgumentError, SystemCallError
raise UnknownConversionMethodError.new(to_enc, from_enc) raise UnknownConversionMethodError.new(to_enc, from_enc)
end end
end end
def def_else_enc(to_enc, from_enc) def def_else_enc(to_enc, from_enc)
def_iconv_convert(to_enc, from_enc, 0) def_iconv_convert(to_enc, from_enc, 0)
end end
def def_same_enc() def def_same_enc()
def_convert do |value| def_convert do |value|
value value
end end
end end
def def_uconv_convert_if_can(meth, to_enc, from_enc) def def_uconv_convert_if_can(meth, to_enc, from_enc)
begin begin
require "uconv" require "uconv"
def_convert(1) do |value| def_convert(1) do |value|
<<-EOC <<-EOC
begin begin
Uconv.#{meth}(#{value}) Uconv.#{meth}(#{value})
rescue Uconv::Error rescue Uconv::Error
raise ConversionError.new(#{value}, "#{to_enc}", "#{from_enc}") raise ConversionError.new(#{value}, "#{to_enc}", "#{from_enc}")
end end
EOC EOC
end end
rescue LoadError rescue LoadError
def_iconv_convert(to_enc, from_enc, 1) def_iconv_convert(to_enc, from_enc, 1)
end end
end end
def def_to_euc_jp_from_utf_8 def def_to_euc_jp_from_utf_8
def_uconv_convert_if_can('u8toeuc', 'EUC-JP', 'UTF-8') def_uconv_convert_if_can('u8toeuc', 'EUC-JP', 'UTF-8')
end end
def def_to_utf_8_from_euc_jp def def_to_utf_8_from_euc_jp
def_uconv_convert_if_can('euctou8', 'UTF-8', 'EUC-JP') def_uconv_convert_if_can('euctou8', 'UTF-8', 'EUC-JP')
end end
def def_to_shift_jis_from_utf_8 def def_to_shift_jis_from_utf_8
def_uconv_convert_if_can('u8tosjis', 'Shift_JIS', 'UTF-8') def_uconv_convert_if_can('u8tosjis', 'Shift_JIS', 'UTF-8')
end end
def def_to_utf_8_from_shift_jis def def_to_utf_8_from_shift_jis
def_uconv_convert_if_can('sjistou8', 'UTF-8', 'Shift_JIS') def_uconv_convert_if_can('sjistou8', 'UTF-8', 'Shift_JIS')
end end
def def_to_euc_jp_from_shift_jis def def_to_euc_jp_from_shift_jis
require "nkf" require "nkf"
def_convert do |value| def_convert do |value|
"NKF.nkf('-Se', #{value})" "NKF.nkf('-Se', #{value})"
end end
end end
def def_to_shift_jis_from_euc_jp def def_to_shift_jis_from_euc_jp
require "nkf" require "nkf"
def_convert do |value| def_convert do |value|
"NKF.nkf('-Es', #{value})" "NKF.nkf('-Es', #{value})"
end end
end end
def def_to_euc_jp_from_iso_2022_jp def def_to_euc_jp_from_iso_2022_jp
require "nkf" require "nkf"
def_convert do |value| def_convert do |value|
"NKF.nkf('-Je', #{value})" "NKF.nkf('-Je', #{value})"
end end
end end
def def_to_iso_2022_jp_from_euc_jp def def_to_iso_2022_jp_from_euc_jp
require "nkf" require "nkf"
def_convert do |value| def_convert do |value|
"NKF.nkf('-Ej', #{value})" "NKF.nkf('-Ej', #{value})"
end end
end end
def def_to_utf_8_from_iso_8859_1 def def_to_utf_8_from_iso_8859_1
def_convert do |value| def_convert do |value|
"#{value}.unpack('C*').pack('U*')" "#{value}.unpack('C*').pack('U*')"
end end
end end
def def_to_iso_8859_1_from_utf_8 def def_to_iso_8859_1_from_utf_8
def_convert do |value| def_convert do |value|
<<-EOC <<-EOC
array_utf8 = #{value}.unpack('U*') array_utf8 = #{value}.unpack('U*')
array_enc = [] array_enc = []
array_utf8.each do |num| array_utf8.each do |num|
if num <= 0xFF if num <= 0xFF
array_enc << num array_enc << num
else else
array_enc.concat "&\#\#{num};".unpack('C*') array_enc.concat "&\#\#{num};".unpack('C*')
end end
end end
array_enc.pack('C*') array_enc.pack('C*')
EOC EOC
end end
end end
end end
end end

94
lib/rss/dublincore.rb
View file

@ -2,63 +2,63 @@ require "rss/1.0"
module RSS module RSS
DC_PREFIX = 'dc' DC_PREFIX = 'dc'
DC_URI = "http://purl.org/dc/elements/1.1/" DC_URI = "http://purl.org/dc/elements/1.1/"
RDF.install_ns(DC_PREFIX, DC_URI) RDF.install_ns(DC_PREFIX, DC_URI)
module DublinCoreModel module DublinCoreModel
extend BaseModel extend BaseModel
ELEMENTS = [] ELEMENTS = []
def self.append_features(klass) def self.append_features(klass)
super super
klass.module_eval(<<-EOC) klass.module_eval(<<-EOC)
%w(title description creator subject publisher %w(title description creator subject publisher
contributor type format identifier source contributor type format identifier source
language relation coverage rights).each do |x| language relation coverage rights).each do |x|
install_text_element("\#{DC_PREFIX}_\#{x}") install_text_element("\#{DC_PREFIX}_\#{x}")
end end
%w(date).each do |x| %w(date).each do |x|
install_date_element("\#{DC_PREFIX}_\#{x}", 'w3cdtf', x) install_date_element("\#{DC_PREFIX}_\#{x}", 'w3cdtf', x)
end end
EOC EOC
end end
def dc_validate(tags) def dc_validate(tags)
counter = {} counter = {}
ELEMENTS.each do |x| ELEMENTS.each do |x|
counter[x] = 0 counter[x] = 0
end end
tags.each do |tag| tags.each do |tag|
key = "#{DC_PREFIX}_#{tag}" key = "#{DC_PREFIX}_#{tag}"
raise UnknownTagError.new(tag, DC_URI) unless counter.has_key?(key) raise UnknownTagError.new(tag, DC_URI) unless counter.has_key?(key)
counter[key] += 1 counter[key] += 1
raise TooMuchTagError.new(tag, tag_name) if counter[key] > 1 raise TooMuchTagError.new(tag, tag_name) if counter[key] > 1
end end
end end
end end
# For backward compatibility # For backward compatibility
DublincoreModel = DublinCoreModel DublincoreModel = DublinCoreModel
class RDF class RDF
class Channel; include DublinCoreModel; end class Channel; include DublinCoreModel; end
class Image; include DublinCoreModel; end class Image; include DublinCoreModel; end
class Item; include DublinCoreModel; end class Item; include DublinCoreModel; end
class Textinput; include DublinCoreModel; end class Textinput; include DublinCoreModel; end
end end
prefix_size = DC_PREFIX.size + 1 prefix_size = DC_PREFIX.size + 1
DublinCoreModel::ELEMENTS.uniq! DublinCoreModel::ELEMENTS.uniq!
DublinCoreModel::ELEMENTS.each do |x| DublinCoreModel::ELEMENTS.each do |x|
BaseListener.install_get_text_element(x[prefix_size..-1], DC_URI, "#{x}=") BaseListener.install_get_text_element(x[prefix_size..-1], DC_URI, "#{x}=")
end end
end end

650
lib/rss/parser.rb
View file

@ -4,393 +4,393 @@ require "rss/rss"
module RSS module RSS
class NotWellFormedError < Error class NotWellFormedError < Error
attr_reader :line, :element attr_reader :line, :element
def initialize(line=nil, element=nil) def initialize(line=nil, element=nil)
message = "This is not well formed XML" message = "This is not well formed XML"
if element or line if element or line
message << "\nerror occurred" message << "\nerror occurred"
message << " in #{element}" if element message << " in #{element}" if element
message << " at about #{line} line" if line message << " at about #{line} line" if line
end end
message << "\n#{yield}" if block_given? message << "\n#{yield}" if block_given?
super(message) super(message)
end end
end end
class XMLParserNotFound < Error class XMLParserNotFound < Error
def initialize def initialize
super("available XML parser does not found in " << super("available XML parser does not found in " <<
"#{AVAILABLE_PARSER_LIBRARIES.inspect}.") "#{AVAILABLE_PARSER_LIBRARIES.inspect}.")
end end
end end
class NotValidXMLParser < Error class NotValidXMLParser < Error
def initialize(parser) def initialize(parser)
super("#{parser} is not available XML parser. " << super("#{parser} is not available XML parser. " <<
"available XML parser is " << "available XML parser is " <<
"#{AVAILABLE_PARSERS.inspect}.") "#{AVAILABLE_PARSERS.inspect}.")
end end
end end
class NSError < InvalidRSSError class NSError < InvalidRSSError
attr_reader :tag, :prefix, :uri attr_reader :tag, :prefix, :uri
def initialize(tag, prefix, require_uri) def initialize(tag, prefix, require_uri)
@tag, @prefix, @uri = tag, prefix, require_uri @tag, @prefix, @uri = tag, prefix, require_uri
super("prefix <#{prefix}> doesn't associate uri " << super("prefix <#{prefix}> doesn't associate uri " <<
"<#{require_uri}> in tag <#{tag}>") "<#{require_uri}> in tag <#{tag}>")
end end
end end
class Parser class Parser
extend Forwardable extend Forwardable
class << self class << self
@@default_parser = nil @@default_parser = nil
def default_parser def default_parser
@@default_parser || AVAILABLE_PARSERS.first @@default_parser || AVAILABLE_PARSERS.first
end end
def default_parser=(new_value) def default_parser=(new_value)
if AVAILABLE_PARSERS.include?(new_value) if AVAILABLE_PARSERS.include?(new_value)
@@default_parser = new_value @@default_parser = new_value
else else
raise NotValidXMLParser.new(new_value) raise NotValidXMLParser.new(new_value)
end end
end end
def parse(rss, do_validate=true, ignore_unknown_element=true, parser_class=default_parser) def parse(rss, do_validate=true, ignore_unknown_element=true, parser_class=default_parser)
parser = new(rss, parser_class) parser = new(rss, parser_class)
parser.do_validate = do_validate parser.do_validate = do_validate
parser.ignore_unknown_element = ignore_unknown_element parser.ignore_unknown_element = ignore_unknown_element
parser.parse parser.parse
end end
end end
def_delegators(:@parser, :parse, :rss, def_delegators(:@parser, :parse, :rss,
:ignore_unknown_element, :ignore_unknown_element,
:ignore_unknown_element=, :do_validate, :ignore_unknown_element=, :do_validate,
:do_validate=) :do_validate=)
def initialize(rss, parser_class=self.class.default_parser) def initialize(rss, parser_class=self.class.default_parser)
@parser = parser_class.new(rss) @parser = parser_class.new(rss)
end end
end end
class BaseParser class BaseParser
def initialize(rss) def initialize(rss)
@listener = listener.new @listener = listener.new
@rss = rss @rss = rss
end end
def rss def rss
@listener.rss @listener.rss
end end
def ignore_unknown_element def ignore_unknown_element
@listener.ignore_unknown_element @listener.ignore_unknown_element
end end
def ignore_unknown_element=(new_value) def ignore_unknown_element=(new_value)
@listener.ignore_unknown_element = new_value @listener.ignore_unknown_element = new_value
end end
def do_validate def do_validate
@listener.do_validate @listener.do_validate
end end
def do_validate=(new_value) def do_validate=(new_value)
@listener.do_validate = new_value @listener.do_validate = new_value
end end
def parse def parse
if @listener.rss.nil? if @listener.rss.nil?
_parse _parse
end end
@listener.rss @listener.rss
end end
end end
class BaseListener class BaseListener
extend Utils extend Utils
class << self class << self
@@setter = {} @@setter = {}
@@registered_uris = {} @@registered_uris = {}
def install_setter(uri, tag_name, setter) def install_setter(uri, tag_name, setter)
@@setter[uri] = {} unless @@setter.has_key?(uri) @@setter[uri] = {} unless @@setter.has_key?(uri)
@@setter[uri][tag_name] = setter @@setter[uri][tag_name] = setter
end end
def register_uri(name, uri) def register_uri(name, uri)
@@registered_uris[name] = {} unless @@registered_uris.has_key?(name) @@registered_uris[name] = {} unless @@registered_uris.has_key?(name)
@@registered_uris[name][uri] = nil @@registered_uris[name][uri] = nil
end end
def uri_registered?(name, uri) def uri_registered?(name, uri)
@@registered_uris[name].has_key?(uri) @@registered_uris[name].has_key?(uri)
end end
def setter(uri, tag_name) def setter(uri, tag_name)
begin begin
@@setter[uri][tag_name] @@setter[uri][tag_name]
rescue NameError rescue NameError
nil nil
end end
end end
def available_tags(uri) def available_tags(uri)
begin begin
@@setter[uri].keys @@setter[uri].keys
rescue NameError rescue NameError
[] []
end end
end end
def install_get_text_element(name, uri, setter) def install_get_text_element(name, uri, setter)
install_setter(uri, name, setter) install_setter(uri, name, setter)
def_get_text_element(uri, name, *get_file_and_line_from_caller(1)) def_get_text_element(uri, name, *get_file_and_line_from_caller(1))
end end
private private
def def_get_text_element(uri, name, file, line) def def_get_text_element(uri, name, file, line)
register_uri(name, uri) register_uri(name, uri)
unless private_instance_methods(false).include?("start_#{name}") unless private_instance_methods(false).include?("start_#{name}")
module_eval(<<-EOT, file, line) module_eval(<<-EOT, file, line)
def start_#{name}(name, prefix, attrs, ns) def start_#{name}(name, prefix, attrs, ns)
uri = ns[prefix] uri = ns[prefix]
if self.class.uri_registered?(#{name.inspect}, uri) if self.class.uri_registered?(#{name.inspect}, uri)
if @do_validate if @do_validate
tags = self.class.available_tags(uri) tags = self.class.available_tags(uri)
unless tags.include?(name) unless tags.include?(name)
raise UnknownTagError.new(name, uri) raise UnknownTagError.new(name, uri)
end end
end end
start_get_text_element(name, prefix, ns, uri) start_get_text_element(name, prefix, ns, uri)
else else
start_else_element(name, prefix, attrs, ns) start_else_element(name, prefix, attrs, ns)
end end
end end
EOT EOT
send("private", "start_#{name}") send("private", "start_#{name}")
end end
end end
end end
end end
module ListenerMixin module ListenerMixin
attr_reader :rss attr_reader :rss
attr_accessor :ignore_unknown_element attr_accessor :ignore_unknown_element
attr_accessor :do_validate attr_accessor :do_validate
def initialize def initialize
@rss = nil @rss = nil
@ignore_unknown_element = true @ignore_unknown_element = true
@do_validate = true @do_validate = true
@ns_stack = [{}] @ns_stack = [{}]
@tag_stack = [[]] @tag_stack = [[]]
@text_stack = [''] @text_stack = ['']
@proc_stack = [] @proc_stack = []
@last_element = nil @last_element = nil
@version = @encoding = @standalone = nil @version = @encoding = @standalone = nil
@xml_stylesheets = [] @xml_stylesheets = []
end end
def xmldecl(version, encoding, standalone) def xmldecl(version, encoding, standalone)
@version, @encoding, @standalone = version, encoding, standalone @version, @encoding, @standalone = version, encoding, standalone
end end
def instruction(name, content) def instruction(name, content)
if name == "xml-stylesheet" if name == "xml-stylesheet"
params = parse_pi_content(content) params = parse_pi_content(content)
if params.has_key?("href") if params.has_key?("href")
@xml_stylesheets << XMLStyleSheet.new(*params) @xml_stylesheets << XMLStyleSheet.new(*params)
end end
end end
end end
def tag_start(name, attributes) def tag_start(name, attributes)
@text_stack.push('') @text_stack.push('')
ns = @ns_stack.last.dup ns = @ns_stack.last.dup
attrs = {} attrs = {}
attributes.each do |n, v| attributes.each do |n, v|
if n =~ /\Axmlns:?/ if n =~ /\Axmlns:?/
ns[$POSTMATCH] = v ns[$POSTMATCH] = v
else else
attrs[n] = v attrs[n] = v
end end
end end
@ns_stack.push(ns) @ns_stack.push(ns)
prefix, local = split_name(name) prefix, local = split_name(name)
@tag_stack.last.push([ns[prefix], local]) @tag_stack.last.push([ns[prefix], local])
@tag_stack.push([]) @tag_stack.push([])
if respond_to?("start_#{local}", true) if respond_to?("start_#{local}", true)
send("start_#{local}", local, prefix, attrs, ns.dup) send("start_#{local}", local, prefix, attrs, ns.dup)
else else
start_else_element(local, prefix, attrs, ns.dup) start_else_element(local, prefix, attrs, ns.dup)
end end
end end
def tag_end(name) def tag_end(name)
if DEBUG if DEBUG
p "end tag #{name}" p "end tag #{name}"
p @tag_stack p @tag_stack
end end
text = @text_stack.pop text = @text_stack.pop
tags = @tag_stack.pop tags = @tag_stack.pop
pr = @proc_stack.pop pr = @proc_stack.pop
pr.call(text, tags) unless pr.nil? pr.call(text, tags) unless pr.nil?
end end
def text(data) def text(data)
@text_stack.last << data @text_stack.last << data
end end
private private
CONTENT_PATTERN = /\s*([^=]+)=(["'])([^\2]+?)\2/ CONTENT_PATTERN = /\s*([^=]+)=(["'])([^\2]+?)\2/
def parse_pi_content(content) def parse_pi_content(content)
params = {} params = {}
content.scan(CONTENT_PATTERN) do |name, quote, value| content.scan(CONTENT_PATTERN) do |name, quote, value|
params[name] = value params[name] = value
end end
params params
end end
def start_else_element(local, prefix, attrs, ns) def start_else_element(local, prefix, attrs, ns)
class_name = local[0,1].upcase << local[1..-1] class_name = local[0,1].upcase << local[1..-1]
current_class = @last_element.class current_class = @last_element.class
# begin # begin
if current_class.constants.include?(class_name) if current_class.constants.include?(class_name)
next_class = current_class.const_get(class_name) next_class = current_class.const_get(class_name)
start_have_something_element(local, prefix, attrs, ns, next_class) start_have_something_element(local, prefix, attrs, ns, next_class)
# rescue NameError # rescue NameError
else else
if @ignore_unknown_element if @ignore_unknown_element
@proc_stack.push(nil) @proc_stack.push(nil)
else else
parent = "ROOT ELEMENT???" parent = "ROOT ELEMENT???"
if current_class.tag_name if current_class.tag_name
parent = current_class.tag_name parent = current_class.tag_name
end end
raise NotExceptedTagError.new(local, parent) raise NotExceptedTagError.new(local, parent)
end end
end end
end end
NAMESPLIT = /^(?:([\w:][-\w\d.]*):)?([\w:][-\w\d.]*)/ NAMESPLIT = /^(?:([\w:][-\w\d.]*):)?([\w:][-\w\d.]*)/
def split_name(name) def split_name(name)
name =~ NAMESPLIT name =~ NAMESPLIT
[$1 || '', $2] [$1 || '', $2]
end end
def check_ns(tag_name, prefix, ns, require_uri) def check_ns(tag_name, prefix, ns, require_uri)
if @do_validate if @do_validate
if ns[prefix] == require_uri if ns[prefix] == require_uri
#ns.delete(prefix) #ns.delete(prefix)
else else
raise NSError.new(tag_name, prefix, require_uri) raise NSError.new(tag_name, prefix, require_uri)
end end
end end
end end
def start_get_text_element(tag_name, prefix, ns, required_uri) def start_get_text_element(tag_name, prefix, ns, required_uri)
@proc_stack.push Proc.new {|text, tags| @proc_stack.push Proc.new {|text, tags|
setter = self.class.setter(required_uri, tag_name) setter = self.class.setter(required_uri, tag_name)
setter ||= "#{tag_name}=" setter ||= "#{tag_name}="
if @last_element.respond_to?(setter) if @last_element.respond_to?(setter)
@last_element.send(setter, text.to_s) @last_element.send(setter, text.to_s)
else else
if @do_validate and not @ignore_unknown_element if @do_validate and not @ignore_unknown_element
raise NotExceptedTagError.new(tag_name, @last_element.tag_name) raise NotExceptedTagError.new(tag_name, @last_element.tag_name)
end end
end end
} }
end end
def start_have_something_element(tag_name, prefix, attrs, ns, klass) def start_have_something_element(tag_name, prefix, attrs, ns, klass)
check_ns(tag_name, prefix, ns, klass.required_uri) check_ns(tag_name, prefix, ns, klass.required_uri)
args = [] args = []
klass.get_attributes.each do |a_name, a_uri, required| klass.get_attributes.each do |a_name, a_uri, required|
if a_uri.is_a?(String) or !a_uri.respond_to?(:include?) if a_uri.is_a?(String) or !a_uri.respond_to?(:include?)
a_uri = [a_uri] a_uri = [a_uri]
end end
unless a_uri == [nil] unless a_uri == [nil]
for prefix, uri in ns for prefix, uri in ns
if a_uri.include?(uri) if a_uri.include?(uri)
val = attrs["#{prefix}:#{a_name}"] val = attrs["#{prefix}:#{a_name}"]
break if val break if val
end end
end end
end end
if val.nil? and a_uri.include?(nil) if val.nil? and a_uri.include?(nil)
val = attrs[a_name] val = attrs[a_name]
end end
if @do_validate and required and val.nil? if @do_validate and required and val.nil?
raise MissingAttributeError.new(tag_name, a_name) raise MissingAttributeError.new(tag_name, a_name)
end end
args << val args << val
end end
previous = @last_element previous = @last_element
next_element = klass.send(:new, *args) next_element = klass.send(:new, *args)
next_element.do_validate = @do_validate next_element.do_validate = @do_validate
setter = "" setter = ""
setter << "#{klass.required_prefix}_" if klass.required_prefix setter << "#{klass.required_prefix}_" if klass.required_prefix
setter << "#{tag_name}=" setter << "#{tag_name}="
@last_element.send(setter, next_element) @last_element.send(setter, next_element)
@last_element = next_element @last_element = next_element
@proc_stack.push Proc.new { |text, tags| @proc_stack.push Proc.new { |text, tags|
p(@last_element.class) if DEBUG p(@last_element.class) if DEBUG
@last_element.content = text if klass.have_content? @last_element.content = text if klass.have_content?
@last_element.validate_for_stream(tags) if @do_validate @last_element.validate_for_stream(tags) if @do_validate
@last_element = previous @last_element = previous
} }
end end
end end
unless const_defined? :AVAILABLE_PARSER_LIBRARIES unless const_defined? :AVAILABLE_PARSER_LIBRARIES
AVAILABLE_PARSER_LIBRARIES = [ AVAILABLE_PARSER_LIBRARIES = [
["rss/xmlparser", :XMLParserParser], ["rss/xmlparser", :XMLParserParser],
["rss/xmlscanner", :XMLScanParser], ["rss/xmlscanner", :XMLScanParser],
["rss/rexmlparser", :REXMLParser], ["rss/rexmlparser", :REXMLParser],
] ]
end end
AVAILABLE_PARSERS = [] AVAILABLE_PARSERS = []
AVAILABLE_PARSER_LIBRARIES.each do |lib, parser| AVAILABLE_PARSER_LIBRARIES.each do |lib, parser|
begin begin
require lib require lib
AVAILABLE_PARSERS.push(const_get(parser)) AVAILABLE_PARSERS.push(const_get(parser))
rescue LoadError rescue LoadError
end end
end end
if AVAILABLE_PARSERS.empty? if AVAILABLE_PARSERS.empty?
raise XMLParserNotFound raise XMLParserNotFound
end end
end end

62
lib/rss/rexmlparser.rb
View file

@ -3,45 +3,45 @@ require "rexml/streamlistener"
/\A(\d+)\.(\d+)(?:\.\d+)+\z/ =~ REXML::Version /\A(\d+)\.(\d+)(?:\.\d+)+\z/ =~ REXML::Version
if ([$1.to_i, $2.to_i] <=> [2, 5]) < 0 if ([$1.to_i, $2.to_i] <=> [2, 5]) < 0
raise LoadError, "needs REXML 2.5 or later (#{REXML::Version})" raise LoadError, "needs REXML 2.5 or later (#{REXML::Version})"
end end
module RSS module RSS
class REXMLParser < BaseParser class REXMLParser < BaseParser
private private
def listener def listener
REXMLListener REXMLListener
end end
def _parse def _parse
begin begin
REXML::Document.parse_stream(@rss, @listener) REXML::Document.parse_stream(@rss, @listener)
rescue RuntimeError => e rescue RuntimeError => e
raise NotWellFormedError.new{e.message} raise NotWellFormedError.new{e.message}
rescue REXML::ParseException => e rescue REXML::ParseException => e
context = e.context context = e.context
line = context[0] if context line = context[0] if context
raise NotWellFormedError.new(line){e.message} raise NotWellFormedError.new(line){e.message}
end end
end end
end end
class REXMLListener < BaseListener class REXMLListener < BaseListener
include REXML::StreamListener include REXML::StreamListener
include ListenerMixin include ListenerMixin
def xmldecl(version, encoding, standalone) def xmldecl(version, encoding, standalone)
super super
# Encoding is converted to UTF-8 when REXML parse XML. # Encoding is converted to UTF-8 when REXML parse XML.
@encoding = 'UTF-8' @encoding = 'UTF-8'
end end
alias_method(:cdata, :text) alias_method(:cdata, :text)
end end
end end

1216
lib/rss/rss.rb
View file

File diff suppressed because it is too large Load diff

134
lib/rss/syndication.rb
View file

@ -2,84 +2,84 @@ require "rss/1.0"
module RSS module RSS
SY_PREFIX = 'sy' SY_PREFIX = 'sy'
SY_URI = "http://purl.org/rss/1.0/modules/syndication/" SY_URI = "http://purl.org/rss/1.0/modules/syndication/"
RDF.install_ns(SY_PREFIX, SY_URI) RDF.install_ns(SY_PREFIX, SY_URI)
module SyndicationModel module SyndicationModel
extend BaseModel extend BaseModel
ELEMENTS = [] ELEMENTS = []
def self.append_features(klass) def self.append_features(klass)
super super
klass.module_eval(<<-EOC) klass.module_eval(<<-EOC)
%w(updatePeriod updateFrequency).each do |x| %w(updatePeriod updateFrequency).each do |x|
install_text_element("\#{SY_PREFIX}_\#{x}") install_text_element("\#{SY_PREFIX}_\#{x}")
end end
%w(updateBase).each do |x| %w(updateBase).each do |x|
install_date_element("\#{SY_PREFIX}_\#{x}", 'w3cdtf', x) install_date_element("\#{SY_PREFIX}_\#{x}", 'w3cdtf', x)
end end
alias_method(:_sy_updatePeriod=, :sy_updatePeriod=) alias_method(:_sy_updatePeriod=, :sy_updatePeriod=)
def sy_updatePeriod=(new_value) def sy_updatePeriod=(new_value)
new_value = new_value.strip new_value = new_value.strip
validate_sy_updatePeriod(new_value) if @do_validate validate_sy_updatePeriod(new_value) if @do_validate
self._sy_updatePeriod = new_value self._sy_updatePeriod = new_value
end end
alias_method(:_sy_updateFrequency=, :sy_updateFrequency=) alias_method(:_sy_updateFrequency=, :sy_updateFrequency=)
def sy_updateFrequency=(new_value) def sy_updateFrequency=(new_value)
new_value = new_value.strip new_value = new_value.strip
validate_sy_updateFrequency(new_value) if @do_validate validate_sy_updateFrequency(new_value) if @do_validate
self._sy_updateFrequency = new_value.to_i self._sy_updateFrequency = new_value.to_i
end end
EOC EOC
end end
def sy_validate(tags) def sy_validate(tags)
counter = {} counter = {}
ELEMENTS.each do |x| ELEMENTS.each do |x|
counter[x] = 0 counter[x] = 0
end end
tags.each do |tag| tags.each do |tag|
key = "#{SY_PREFIX}_#{tag}" key = "#{SY_PREFIX}_#{tag}"
raise UnknownTagError.new(tag, SY_URI) unless counter.has_key?(key) raise UnknownTagError.new(tag, SY_URI) unless counter.has_key?(key)
counter[key] += 1 counter[key] += 1
raise TooMuchTagError.new(tag, tag_name) if counter[key] > 1 raise TooMuchTagError.new(tag, tag_name) if counter[key] > 1
end end
end end
private private
SY_UPDATEPERIOD_AVAILABLE_VALUES = %w(hourly daily weekly monthly yearly) SY_UPDATEPERIOD_AVAILABLE_VALUES = %w(hourly daily weekly monthly yearly)
def validate_sy_updatePeriod(value) def validate_sy_updatePeriod(value)
unless SY_UPDATEPERIOD_AVAILABLE_VALUES.include?(value) unless SY_UPDATEPERIOD_AVAILABLE_VALUES.include?(value)
raise NotAvailableValueError.new("updatePeriod", value) raise NotAvailableValueError.new("updatePeriod", value)
end end
end end
SY_UPDATEFREQUENCY_AVAILABLE_RE = /\A\s*\+?\d+\s*\z/ SY_UPDATEFREQUENCY_AVAILABLE_RE = /\A\s*\+?\d+\s*\z/
def validate_sy_updateFrequency(value) def validate_sy_updateFrequency(value)
if SY_UPDATEFREQUENCY_AVAILABLE_RE !~ value if SY_UPDATEFREQUENCY_AVAILABLE_RE !~ value
raise NotAvailableValueError.new("updateFrequency", value) raise NotAvailableValueError.new("updateFrequency", value)
end end
end end
end end
class RDF class RDF
class Channel; include SyndicationModel; end class Channel; include SyndicationModel; end
end end
prefix_size = SY_PREFIX.size + 1 prefix_size = SY_PREFIX.size + 1
SyndicationModel::ELEMENTS.uniq! SyndicationModel::ELEMENTS.uniq!
SyndicationModel::ELEMENTS.each do |x| SyndicationModel::ELEMENTS.each do |x|
BaseListener.install_get_text_element(x[prefix_size..-1], SY_URI, "#{x}=") BaseListener.install_get_text_element(x[prefix_size..-1], SY_URI, "#{x}=")
end end
end end

44
lib/rss/taxonomy.rb
View file

@ -4,29 +4,29 @@ require "rss/1.0"
module RSS module RSS
TAXO_PREFIX = "taxo" TAXO_PREFIX = "taxo"
TAXO_NS = "http://purl.org/rss/1.0/modules/taxonomy/" TAXO_NS = "http://purl.org/rss/1.0/modules/taxonomy/"
Element.install_ns(TAXO_PREFIX, TAXO_NS) Element.install_ns(TAXO_PREFIX, TAXO_NS)
TAXO_ELEMENTS = [] TAXO_ELEMENTS = []
%w(link).each do |x| %w(link).each do |x|
if const_defined? :Listener if const_defined? :Listener
Listener.install_get_text_element(x, TAXO_NS, "#{TAXO_PREFIX}_#{x}=") Listener.install_get_text_element(x, TAXO_NS, "#{TAXO_PREFIX}_#{x}=")
end end
TAXO_ELEMENTS << "#{TAXO_PREFIX}_#{x}" TAXO_ELEMENTS << "#{TAXO_PREFIX}_#{x}"
end end
module TaxonomyModel module TaxonomyModel
attr_writer(*%w(title description creator subject publisher attr_writer(*%w(title description creator subject publisher
contributor date format identifier source contributor date format identifier source
language relation coverage rights).collect{|x| "#{TAXO_PREFIX}_#{x}"}) language relation coverage rights).collect{|x| "#{TAXO_PREFIX}_#{x}"})
end end
class Channel; extend TaxonomyModel; end class Channel; extend TaxonomyModel; end
class Item; extend TaxonomyModel; end class Item; extend TaxonomyModel; end
class Image; extend TaxonomyModel; end class Image; extend TaxonomyModel; end
class TextInput; extend TaxonomyModel; end class TextInput; extend TaxonomyModel; end
end end

510
lib/rss/trackback.rb
View file

@ -3,304 +3,304 @@ require 'rss/2.0'
module RSS module RSS
TRACKBACK_PREFIX = 'trackback' TRACKBACK_PREFIX = 'trackback'
TRACKBACK_URI = 'http://madskills.com/public/xml/rss/module/trackback/' TRACKBACK_URI = 'http://madskills.com/public/xml/rss/module/trackback/'
RDF.install_ns(TRACKBACK_PREFIX, TRACKBACK_URI) RDF.install_ns(TRACKBACK_PREFIX, TRACKBACK_URI)
Rss.install_ns(TRACKBACK_PREFIX, TRACKBACK_URI) Rss.install_ns(TRACKBACK_PREFIX, TRACKBACK_URI)
module BaseTrackBackModel module BaseTrackBackModel
def trackback_validate(tags) def trackback_validate(tags)
counter = {} counter = {}
%w(ping about).each do |x| %w(ping about).each do |x|
counter["#{TRACKBACK_PREFIX}_#{x}"] = 0 counter["#{TRACKBACK_PREFIX}_#{x}"] = 0
end end
tags.each do |tag| tags.each do |tag|
key = "#{TRACKBACK_PREFIX}_#{tag}" key = "#{TRACKBACK_PREFIX}_#{tag}"
raise UnknownTagError.new(tag, TRACKBACK_URI) unless counter.has_key?(key) raise UnknownTagError.new(tag, TRACKBACK_URI) unless counter.has_key?(key)
counter[key] += 1 counter[key] += 1
if tag != "about" and counter[key] > 1 if tag != "about" and counter[key] > 1
raise TooMuchTagError.new(tag, tag_name) raise TooMuchTagError.new(tag, tag_name)
end end
end end
if counter["#{TRACKBACK_PREFIX}_ping"].zero? and if counter["#{TRACKBACK_PREFIX}_ping"].zero? and
counter["#{TRACKBACK_PREFIX}_about"].nonzero? counter["#{TRACKBACK_PREFIX}_about"].nonzero?
raise MissingTagError.new("#{TRACKBACK_PREFIX}:ping", tag_name) raise MissingTagError.new("#{TRACKBACK_PREFIX}:ping", tag_name)
end end
end end
end end
module TrackBackModel10 module TrackBackModel10
extend BaseModel extend BaseModel
include BaseTrackBackModel include BaseTrackBackModel
def self.append_features(klass) def self.append_features(klass)
super super
unless klass.class == Module unless klass.class == Module
%w(ping).each do |x| %w(ping).each do |x|
klass.install_have_child_element("#{TRACKBACK_PREFIX}_#{x}") klass.install_have_child_element("#{TRACKBACK_PREFIX}_#{x}")
end end
%w(about).each do |x| %w(about).each do |x|
klass.install_have_children_element("#{TRACKBACK_PREFIX}_#{x}") klass.install_have_children_element("#{TRACKBACK_PREFIX}_#{x}")
end end
end end
end end
class Ping < Element class Ping < Element
include RSS10 include RSS10
class << self class << self
def required_prefix def required_prefix
TRACKBACK_PREFIX TRACKBACK_PREFIX
end end
def required_uri def required_uri
TRACKBACK_URI TRACKBACK_URI
end end
end end
[ [
["resource", ::RSS::RDF::URI, true] ["resource", ::RSS::RDF::URI, true]
].each do |name, uri, required| ].each do |name, uri, required|
install_get_attribute(name, uri, required) install_get_attribute(name, uri, required)
end end
def initialize(resource=nil) def initialize(resource=nil)
super() super()
@resource = resource @resource = resource
end end
def to_s(convert=true, indent=calc_indent) def to_s(convert=true, indent=calc_indent)
if @resource if @resource
rv = %Q[#{indent}<#{TRACKBACK_PREFIX}:ping ] rv = %Q[#{indent}<#{TRACKBACK_PREFIX}:ping ]
rv << %Q[#{::RSS::RDF::PREFIX}:resource="#{h @resource}"/>] rv << %Q[#{::RSS::RDF::PREFIX}:resource="#{h @resource}"/>]
rv = @converter.convert(rv) if convert and @converter rv = @converter.convert(rv) if convert and @converter
rv rv
else else
'' ''
end end
end end
private private
def _attrs def _attrs
[ [
["resource", true], ["resource", true],
] ]
end end
end end
class About < Element class About < Element
include RSS10 include RSS10
class << self class << self
def required_prefix def required_prefix
TRACKBACK_PREFIX TRACKBACK_PREFIX
end end
def required_uri def required_uri
TRACKBACK_URI TRACKBACK_URI
end end
end end
[ [
["resource", ::RSS::RDF::URI, true] ["resource", ::RSS::RDF::URI, true]
].each do |name, uri, required| ].each do |name, uri, required|
install_get_attribute(name, uri, required) install_get_attribute(name, uri, required)
end end
def initialize(resource=nil) def initialize(resource=nil)
super() super()
@resource = resource @resource = resource
end end
def to_s(convert=true, indent=calc_indent) def to_s(convert=true, indent=calc_indent)
if @resource if @resource
rv = %Q[#{indent}<#{TRACKBACK_PREFIX}:about ] rv = %Q[#{indent}<#{TRACKBACK_PREFIX}:about ]
rv << %Q[#{::RSS::RDF::PREFIX}:resource="#{h @resource}"/>] rv << %Q[#{::RSS::RDF::PREFIX}:resource="#{h @resource}"/>]
rv = @converter.convert(rv) if convert and @converter rv = @converter.convert(rv) if convert and @converter
rv rv
else else
'' ''
end end
end end
private private
def _attrs def _attrs
[ [
["resource", true], ["resource", true],
] ]
end end
end end
end end
module TrackBackModel20 module TrackBackModel20
include BaseTrackBackModel include BaseTrackBackModel
extend BaseModel extend BaseModel
def self.append_features(klass) def self.append_features(klass)
super super
unless klass.class == Module unless klass.class == Module
%w(ping).each do |x| %w(ping).each do |x|
var_name = "#{TRACKBACK_PREFIX}_#{x}" var_name = "#{TRACKBACK_PREFIX}_#{x}"
klass.install_have_child_element(var_name) klass.install_have_child_element(var_name)
klass.module_eval(<<-EOC) klass.module_eval(<<-EOC)
alias _#{var_name} #{var_name} alias _#{var_name} #{var_name}
def #{var_name} def #{var_name}
@#{var_name} and @#{var_name}.content @#{var_name} and @#{var_name}.content
end end
alias _#{var_name}= #{var_name}= alias _#{var_name}= #{var_name}=
def #{var_name}=(content) def #{var_name}=(content)
@#{var_name} = new_with_content_if_need(#{x.capitalize}, content) @#{var_name} = new_with_content_if_need(#{x.capitalize}, content)
end end
EOC EOC
end end
[%w(about s)].each do |x, postfix| [%w(about s)].each do |x, postfix|
var_name = "#{TRACKBACK_PREFIX}_#{x}" var_name = "#{TRACKBACK_PREFIX}_#{x}"
klass.install_have_children_element(var_name) klass.install_have_children_element(var_name)
klass.module_eval(<<-EOC) klass.module_eval(<<-EOC)
alias _#{var_name}#{postfix} #{var_name}#{postfix} alias _#{var_name}#{postfix} #{var_name}#{postfix}
def #{var_name}#{postfix} def #{var_name}#{postfix}
@#{var_name}.collect {|x| x.content} @#{var_name}.collect {|x| x.content}
end end
alias _#{var_name} #{var_name} alias _#{var_name} #{var_name}
def #{var_name}(*args) def #{var_name}(*args)
if args.empty? if args.empty?
@#{var_name}.first and @#{var_name}.first.content @#{var_name}.first and @#{var_name}.first.content
else else
ret = @#{var_name}.send("[]", *args) ret = @#{var_name}.send("[]", *args)
if ret.is_a?(Array) if ret.is_a?(Array)
ret.collect {|x| x.content} ret.collect {|x| x.content}
else else
ret.content ret.content
end end
end end
end end
alias _#{var_name}= #{var_name}= alias _#{var_name}= #{var_name}=
alias _set_#{var_name} set_#{var_name} alias _set_#{var_name} set_#{var_name}
def #{var_name}=(*args) def #{var_name}=(*args)
if args.size == 1 if args.size == 1
item = new_with_content_if_need(#{x.capitalize}, args[0]) item = new_with_content_if_need(#{x.capitalize}, args[0])
@#{var_name}.push(item) @#{var_name}.push(item)
else else
new_val = args.last new_val = args.last
if new_val.is_a?(Array) if new_val.is_a?(Array)
new_val = new_value.collect do |val| new_val = new_value.collect do |val|
new_with_content_if_need(#{x.capitalize}, val) new_with_content_if_need(#{x.capitalize}, val)
end end
else else
new_val = new_with_content_if_need(#{x.capitalize}, new_val) new_val = new_with_content_if_need(#{x.capitalize}, new_val)
end end
@#{var_name}.send("[]=", *(args[0..-2] + [new_val])) @#{var_name}.send("[]=", *(args[0..-2] + [new_val]))
end end
end end
alias set_#{var_name} #{var_name}= alias set_#{var_name} #{var_name}=
EOC EOC
end end
end end
end end
private private
def new_with_content(klass, content) def new_with_content(klass, content)
obj = klass.new obj = klass.new
obj.content = content obj.content = content
obj obj
end end
def new_with_content_if_need(klass, content) def new_with_content_if_need(klass, content)
if content.is_a?(klass) if content.is_a?(klass)
content content
else else
new_with_content(klass, content) new_with_content(klass, content)
end end
end end
class Ping < Element class Ping < Element
include RSS09 include RSS09
content_setup content_setup
class << self class << self
def required_prefix def required_prefix
TRACKBACK_PREFIX TRACKBACK_PREFIX
end end
def required_uri def required_uri
TRACKBACK_URI TRACKBACK_URI
end end
end end
def to_s(convert=true, indent=calc_indent) def to_s(convert=true, indent=calc_indent)
if @content if @content
rv = %Q[#{indent}<#{TRACKBACK_PREFIX}:ping>] rv = %Q[#{indent}<#{TRACKBACK_PREFIX}:ping>]
rv << h(@content) rv << h(@content)
rv << %Q[</#{TRACKBACK_PREFIX}:ping>] rv << %Q[</#{TRACKBACK_PREFIX}:ping>]
rv = @converter.convert(rv) if convert and @converter rv = @converter.convert(rv) if convert and @converter
rv rv
else else
'' ''
end end
end end
end end
class About < Element class About < Element
include RSS09 include RSS09
content_setup content_setup
class << self class << self
def required_prefix def required_prefix
TRACKBACK_PREFIX TRACKBACK_PREFIX
end end
def required_uri def required_uri
TRACKBACK_URI TRACKBACK_URI
end end
end end
def to_s(convert=true, indent=calc_indent) def to_s(convert=true, indent=calc_indent)
if @content if @content
rv = %Q[#{indent}<#{TRACKBACK_PREFIX}:about>] rv = %Q[#{indent}<#{TRACKBACK_PREFIX}:about>]
rv << h(@content) rv << h(@content)
rv << %Q[</#{TRACKBACK_PREFIX}:about>] rv << %Q[</#{TRACKBACK_PREFIX}:about>]
rv = @converter.convert(rv) if convert and @converter rv = @converter.convert(rv) if convert and @converter
rv rv
else else
'' ''
end end
end end
end end
end end
class RDF class RDF
class Item; include TrackBackModel10; end class Item; include TrackBackModel10; end
end end
class Rss class Rss
class Channel class Channel
class Item; include TrackBackModel20; end class Item; include TrackBackModel20; end
end end
end end
end end

22
lib/rss/utils.rb
View file

@ -1,17 +1,17 @@
module RSS module RSS
module Utils module Utils
def get_file_and_line_from_caller(i=0) def get_file_and_line_from_caller(i=0)
file, line, = caller[i].split(':') file, line, = caller[i].split(':')
[file, line.to_i] [file, line.to_i]
end end
def html_escape(s) def html_escape(s)
s.to_s.gsub(/&/, "&amp;").gsub(/\"/, "&quot;").gsub(/>/, "&gt;").gsub(/</, "&lt;") s.to_s.gsub(/&/, "&amp;").gsub(/\"/, "&quot;").gsub(/>/, "&gt;").gsub(/</, "&lt;")
end end
alias h html_escape alias h html_escape
end end
end end

158
lib/rss/xml-stylesheet.rb
View file

@ -2,93 +2,93 @@ require "rss/utils"
module RSS module RSS
module XMLStyleSheetMixin module XMLStyleSheetMixin
attr_accessor :xml_stylesheets attr_accessor :xml_stylesheets
def initialize(*args) def initialize(*args)
super super
@xml_stylesheets = [] @xml_stylesheets = []
end end
private private
def xml_stylesheet_pi def xml_stylesheet_pi
xsss = @xml_stylesheets.collect do |xss| xsss = @xml_stylesheets.collect do |xss|
pi = xss.to_s pi = xss.to_s
pi = nil if /\A\s*\z/ =~ pi pi = nil if /\A\s*\z/ =~ pi
pi pi
end.compact end.compact
xsss.push("") unless xsss.empty? xsss.push("") unless xsss.empty?
xsss.join("\n") xsss.join("\n")
end end
end end
class XMLStyleSheet class XMLStyleSheet
include Utils include Utils
ATTRIBUTES = %w(href type title media charset alternate) ATTRIBUTES = %w(href type title media charset alternate)
GUESS_TABLE = { GUESS_TABLE = {
"xsl" => "text/xsl", "xsl" => "text/xsl",
"css" => "text/css", "css" => "text/css",
} }
attr_accessor(*ATTRIBUTES) attr_accessor(*ATTRIBUTES)
attr_accessor(:do_validate) attr_accessor(:do_validate)
def initialize(*attrs) def initialize(*attrs)
@do_validate = true @do_validate = true
ATTRIBUTES.each do |attr| ATTRIBUTES.each do |attr|
self.send("#{attr}=", nil) self.send("#{attr}=", nil)
end end
vars = ATTRIBUTES.dup vars = ATTRIBUTES.dup
vars.unshift(:do_validate) vars.unshift(:do_validate)
attrs.each do |name, value| attrs.each do |name, value|
if vars.include?(name.to_s) if vars.include?(name.to_s)
self.send("#{name}=", value) self.send("#{name}=", value)
end end
end end
end end
def to_s def to_s
rv = "" rv = ""
if @href if @href
rv << %Q[<?xml-stylesheet] rv << %Q[<?xml-stylesheet]
ATTRIBUTES.each do |name| ATTRIBUTES.each do |name|
if self.send(name) if self.send(name)
rv << %Q[ #{name}="#{h self.send(name)}"] rv << %Q[ #{name}="#{h self.send(name)}"]
end end
end end
rv << %Q[?>] rv << %Q[?>]
end end
rv rv
end end
remove_method(:href=) remove_method(:href=)
def href=(value) def href=(value)
@href = value @href = value
if @href and @type.nil? if @href and @type.nil?
@type = guess_type(@href) @type = guess_type(@href)
end end
@href @href
end end
remove_method(:alternate=) remove_method(:alternate=)
def alternate=(value) def alternate=(value)
if value.nil? or /\A(?:yes|no)\z/ =~ value if value.nil? or /\A(?:yes|no)\z/ =~ value
@alternate = value @alternate = value
else else
if @do_validate if @do_validate
args = ["?xml-stylesheet?", %Q[alternate="#{value}"]] args = ["?xml-stylesheet?", %Q[alternate="#{value}"]]
raise NotAvailableValueError.new(*args) raise NotAvailableValueError.new(*args)
end end
end end
@alternate @alternate
end end
private private
def guess_type(filename) def guess_type(filename)
/\.([^.]+)/ =~ filename /\.([^.]+)/ =~ filename
GUESS_TABLE[$1] GUESS_TABLE[$1]
end end
end end
end end

132
lib/rss/xmlparser.rb
View file

@ -1,91 +1,91 @@
begin begin
require "xml/parser" require "xml/parser"
rescue LoadError rescue LoadError
require "xmlparser" require "xmlparser"
end end
begin begin
require "xml/encoding-ja" require "xml/encoding-ja"
rescue LoadError rescue LoadError
require "xmlencoding-ja" require "xmlencoding-ja"
if defined?(Kconv) if defined?(Kconv)
module XMLEncoding_ja module XMLEncoding_ja
class SJISHandler class SJISHandler
include Kconv include Kconv
end end
end end
end end
end end
module XML module XML
class Parser class Parser
unless defined?(Error) unless defined?(Error)
Error = ::XMLParserError Error = ::XMLParserError
end end
end end
end end
module RSS module RSS
class REXMLLikeXMLParser < ::XML::Parser class REXMLLikeXMLParser < ::XML::Parser
include ::XML::Encoding_ja include ::XML::Encoding_ja
def listener=(listener) def listener=(listener)
@listener = listener @listener = listener
end end
def startElement(name, attrs) def startElement(name, attrs)
@listener.tag_start(name, attrs) @listener.tag_start(name, attrs)
end end
def endElement(name) def endElement(name)
@listener.tag_end(name) @listener.tag_end(name)
end end
def character(data) def character(data)
@listener.text(data) @listener.text(data)
end end
def xmlDecl(version, encoding, standalone) def xmlDecl(version, encoding, standalone)
@listener.xmldecl(version, encoding, standalone == 1) @listener.xmldecl(version, encoding, standalone == 1)
end end
def processingInstruction(target, content) def processingInstruction(target, content)
@listener.instruction(target, content) @listener.instruction(target, content)
end end
end end
class XMLParserParser < BaseParser class XMLParserParser < BaseParser
private private
def listener def listener
XMLParserListener XMLParserListener
end end
def _parse def _parse
begin begin
parser = REXMLLikeXMLParser.new parser = REXMLLikeXMLParser.new
parser.listener = @listener parser.listener = @listener
parser.parse(@rss) parser.parse(@rss)
rescue ::XML::Parser::Error => e rescue ::XML::Parser::Error => e
raise NotWellFormedError.new(parser.line){e.message} raise NotWellFormedError.new(parser.line){e.message}
end end
end end
end end
class XMLParserListener < BaseListener class XMLParserListener < BaseListener
include ListenerMixin include ListenerMixin
def xmldecl(version, encoding, standalone) def xmldecl(version, encoding, standalone)
super super
# Encoding is converted to UTF-8 when XMLParser parses XML. # Encoding is converted to UTF-8 when XMLParser parses XML.
@encoding = 'UTF-8' @encoding = 'UTF-8'
end end
end end
end end

94
lib/rss/xmlscanner.rb
View file

@ -1,102 +1,102 @@
require 'xmlscan/scanner' require 'xmlscan/scanner'
module RSS module RSS
class XMLScanParser < BaseParser class XMLScanParser < BaseParser
private private
def listener def listener
XMLScanListener XMLScanListener
end end
def _parse def _parse
begin begin
XMLScan::XMLScanner.new(@listener).parse(@rss) XMLScan::XMLScanner.new(@listener).parse(@rss)
rescue XMLScan::Error => e rescue XMLScan::Error => e
raise NotWellFormedError.new(e.lineno){e.message} raise NotWellFormedError.new(e.lineno){e.message}
end end
end end
end end
class XMLScanListener < BaseListener class XMLScanListener < BaseListener
include XMLScan::Visitor include XMLScan::Visitor
include ListenerMixin include ListenerMixin
ENTITIES = { ENTITIES = {
'lt' => '<', 'lt' => '<',
'gt' => '>', 'gt' => '>',
'amp' => '&', 'amp' => '&',
'quot' => '"', 'quot' => '"',
'apos' => '\'' 'apos' => '\''
} }
def on_xmldecl_version(str) def on_xmldecl_version(str)
@version = str @version = str
end end
def on_xmldecl_encoding(str) def on_xmldecl_encoding(str)
@encoding = str @encoding = str
end end
def on_xmldecl_standalone(str) def on_xmldecl_standalone(str)
@standalone = str @standalone = str
end end
def on_xmldecl_end def on_xmldecl_end
xmldecl(@version, @encoding, @standalone) xmldecl(@version, @encoding, @standalone)
end end
alias_method(:on_pi, :instruction) alias_method(:on_pi, :instruction)
alias_method(:on_chardata, :text) alias_method(:on_chardata, :text)
alias_method(:on_cdata, :text) alias_method(:on_cdata, :text)
def on_etag(name) def on_etag(name)
tag_end(name) tag_end(name)
end end
def on_entityref(ref) def on_entityref(ref)
text(ENTITIES[ref]) text(ENTITIES[ref])
end end
def on_charref(code) def on_charref(code)
text([code].pack('U')) text([code].pack('U'))
end end
alias_method(:on_charref_hex, :on_charref) alias_method(:on_charref_hex, :on_charref)
def on_stag(name) def on_stag(name)
@attrs = {} @attrs = {}
end end
def on_attribute(name) def on_attribute(name)
@attrs[name] = @current_attr = '' @attrs[name] = @current_attr = ''
end end
def on_attr_value(str) def on_attr_value(str)
@current_attr << str @current_attr << str
end end
def on_attr_entityref(ref) def on_attr_entityref(ref)
@current_attr << ENTITIES[ref] @current_attr << ENTITIES[ref]
end end
def on_attr_charref(code) def on_attr_charref(code)
@current_attr << [code].pack('U') @current_attr << [code].pack('U')
end end
alias_method(:on_attr_charref_hex, :on_attr_charref) alias_method(:on_attr_charref_hex, :on_attr_charref)
def on_stag_end(name) def on_stag_end(name)
tag_start(name, @attrs) tag_start(name, @attrs)
end end
def on_stag_end_empty(name) def on_stag_end_empty(name)
tag_start(name, @attrs) tag_start(name, @attrs)
tag_end(name) tag_end(name)
end end
end end
end end

266
test/rss/rss-assertions.rb
View file

@ -1,139 +1,139 @@
# -*- tab-width: 2 -*- vim: ts=2 # -*- tab-width: 2 -*- vim: ts=2
module Test module Test
module Unit module Unit
module Assertions module Assertions
# For backward compatibility # For backward compatibility
unless instance_methods.include?("assert_raise") unless instance_methods.include?("assert_raise")
def assert_raise(*args, &block) def assert_raise(*args, &block)
assert_raises(*args, &block) assert_raises(*args, &block)
end end
end end
end end
end end
end end
module RSS module RSS
module Assertions module Assertions
def assert_parse(rss, assert_method, *args) def assert_parse(rss, assert_method, *args)
send("assert_#{assert_method}", *args) do send("assert_#{assert_method}", *args) do
::RSS::Parser.parse(rss) ::RSS::Parser.parse(rss)
end end
send("assert_#{assert_method}", *args) do send("assert_#{assert_method}", *args) do
::RSS::Parser.parse(rss, false).validate ::RSS::Parser.parse(rss, false).validate
end end
end end
def assert_ns(prefix, uri) def assert_ns(prefix, uri)
_wrap_assertion do _wrap_assertion do
begin begin
yield yield
flunk("Not raise NSError") flunk("Not raise NSError")
rescue ::RSS::NSError => e rescue ::RSS::NSError => e
assert_equal(prefix, e.prefix) assert_equal(prefix, e.prefix)
assert_equal(uri, e.uri) assert_equal(uri, e.uri)
end end
end end
end end
def assert_missing_tag(tag, parent) def assert_missing_tag(tag, parent)
_wrap_assertion do _wrap_assertion do
begin begin
yield yield
flunk("Not raise MissingTagError") flunk("Not raise MissingTagError")
rescue ::RSS::MissingTagError => e rescue ::RSS::MissingTagError => e
assert_equal(tag, e.tag) assert_equal(tag, e.tag)
assert_equal(parent, e.parent) assert_equal(parent, e.parent)
end end
end end
end end
def assert_too_much_tag(tag, parent) def assert_too_much_tag(tag, parent)
_wrap_assertion do _wrap_assertion do
begin begin
yield yield
flunk("Not raise TooMuchTagError") flunk("Not raise TooMuchTagError")
rescue ::RSS::TooMuchTagError => e rescue ::RSS::TooMuchTagError => e
assert_equal(tag, e.tag) assert_equal(tag, e.tag)
assert_equal(parent, e.parent) assert_equal(parent, e.parent)
end end
end end
end end
def assert_missing_attribute(tag, attrname) def assert_missing_attribute(tag, attrname)
_wrap_assertion do _wrap_assertion do
begin begin
yield yield
flunk("Not raise MissingAttributeError") flunk("Not raise MissingAttributeError")
rescue ::RSS::MissingAttributeError => e rescue ::RSS::MissingAttributeError => e
assert_equal(tag, e.tag) assert_equal(tag, e.tag)
assert_equal(attrname, e.attribute) assert_equal(attrname, e.attribute)
end end
end end
end end
def assert_not_excepted_tag(tag, parent) def assert_not_excepted_tag(tag, parent)
_wrap_assertion do _wrap_assertion do
begin begin
yield yield
flunk("Not raise NotExceptedTagError") flunk("Not raise NotExceptedTagError")
rescue ::RSS::NotExceptedTagError => e rescue ::RSS::NotExceptedTagError => e
assert_equal(tag, e.tag) assert_equal(tag, e.tag)
assert_equal(parent, e.parent) assert_equal(parent, e.parent)
end end
end end
end end
def assert_not_available_value(tag, value) def assert_not_available_value(tag, value)
_wrap_assertion do _wrap_assertion do
begin begin
yield yield
flunk("Not raise NotAvailableValueError") flunk("Not raise NotAvailableValueError")
rescue ::RSS::NotAvailableValueError => e rescue ::RSS::NotAvailableValueError => e
assert_equal(tag, e.tag) assert_equal(tag, e.tag)
assert_equal(value, e.value) assert_equal(value, e.value)
end end
end end
end end
def assert_xml_stylesheet_attrs(xsl, attrs) def assert_xml_stylesheet_attrs(xsl, attrs)
_wrap_assertion do _wrap_assertion do
normalized_attrs = {} normalized_attrs = {}
attrs.each do |name, value| attrs.each do |name, value|
normalized_attrs[name.to_s] = value normalized_attrs[name.to_s] = value
end end
::RSS::XMLStyleSheet::ATTRIBUTES.each do |name| ::RSS::XMLStyleSheet::ATTRIBUTES.each do |name|
assert_equal(normalized_attrs[name], xsl.send(name)) assert_equal(normalized_attrs[name], xsl.send(name))
end end
end end
end end
def assert_xml_stylesheet(target, xsl, attrs) def assert_xml_stylesheet(target, xsl, attrs)
_wrap_assertion do _wrap_assertion do
if attrs.has_key?(:href) if attrs.has_key?(:href)
if !attrs.has_key?(:type) and attrs.has_key?(:guess_type) if !attrs.has_key?(:type) and attrs.has_key?(:guess_type)
attrs[:type] = attrs[:guess_type] attrs[:type] = attrs[:guess_type]
end end
assert_equal("xml-stylesheet", target) assert_equal("xml-stylesheet", target)
assert_xml_stylesheet_attrs(xsl, attrs) assert_xml_stylesheet_attrs(xsl, attrs)
else else
assert_nil(target) assert_nil(target)
assert_equal("", xsl.to_s) assert_equal("", xsl.to_s)
end end
end end
end end
def assert_xml_stylesheet_pis(attrs_ary) def assert_xml_stylesheet_pis(attrs_ary)
rdf = ::RSS::RDF.new() rdf = ::RSS::RDF.new()
xss_strs = [] xss_strs = []
attrs_ary.each do |attrs| attrs_ary.each do |attrs|
xss = ::RSS::XMLStyleSheet.new(*attrs) xss = ::RSS::XMLStyleSheet.new(*attrs)
xss_strs.push(xss.to_s) xss_strs.push(xss.to_s)
rdf.xml_stylesheets.push(xss) rdf.xml_stylesheets.push(xss)
end end
pi_str = rdf.to_s.gsub(/<\?xml .*\n/, "").gsub(/\s*<rdf:RDF.*\z/m, "") pi_str = rdf.to_s.gsub(/<\?xml .*\n/, "").gsub(/\s*<rdf:RDF.*\z/m, "")
assert_equal(xss_strs.join("\n"), pi_str) assert_equal(xss_strs.join("\n"), pi_str)
end end
end end
end end

218
test/rss/rss-testcase.rb
View file

@ -4,182 +4,182 @@ require "test/unit"
require 'rss-assertions' require 'rss-assertions'
module RSS module RSS
class TestCase < Test::Unit::TestCase class TestCase < Test::Unit::TestCase
include RSS include RSS
include Assertions include Assertions
XMLDECL_VERSION = "1.0" XMLDECL_VERSION = "1.0"
XMLDECL_ENCODING = "UTF-8" XMLDECL_ENCODING = "UTF-8"
XMLDECL_STANDALONE = "no" XMLDECL_STANDALONE = "no"
RDF_ABOUT = "http://www.xml.com/xml/news.rss" RDF_ABOUT = "http://www.xml.com/xml/news.rss"
RDF_RESOURCE = "http://xml.com/universal/images/xml_tiny.gif" RDF_RESOURCE = "http://xml.com/universal/images/xml_tiny.gif"
TITLE_VALUE = "XML.com" TITLE_VALUE = "XML.com"
LINK_VALUE = "http://xml.com/pub" LINK_VALUE = "http://xml.com/pub"
URL_VALUE = "http://xml.com/universal/images/xml_tiny.gif" URL_VALUE = "http://xml.com/universal/images/xml_tiny.gif"
NAME_VALUE = "hogehoge" NAME_VALUE = "hogehoge"
LANGUAGE_VALUE = "ja" LANGUAGE_VALUE = "ja"
DESCRIPTION_VALUE = " DESCRIPTION_VALUE = "
XML.com features a rich mix of information and services XML.com features a rich mix of information and services
for the XML community. for the XML community.
" "
RESOURCES = [ RESOURCES = [
"http://xml.com/pub/2000/08/09/xslt/xslt.html", "http://xml.com/pub/2000/08/09/xslt/xslt.html",
"http://xml.com/pub/2000/08/09/rdfdb/index.html", "http://xml.com/pub/2000/08/09/rdfdb/index.html",
] ]
CLOUD_DOMAIN = "data.ourfavoritesongs.com" CLOUD_DOMAIN = "data.ourfavoritesongs.com"
CLOUD_PORT = "80" CLOUD_PORT = "80"
CLOUD_PATH = "/RPC2" CLOUD_PATH = "/RPC2"
CLOUD_REGISTER_PROCEDURE = "ourFavoriteSongs.rssPleaseNotify" CLOUD_REGISTER_PROCEDURE = "ourFavoriteSongs.rssPleaseNotify"
CLOUD_PROTOCOL = "xml-rpc" CLOUD_PROTOCOL = "xml-rpc"
ENCLOSURE_URL = "http://www.scripting.com/mp3s/weatherReportSuite.mp3" ENCLOSURE_URL = "http://www.scripting.com/mp3s/weatherReportSuite.mp3"
ENCLOSURE_LENGTH = "12216320" ENCLOSURE_LENGTH = "12216320"
ENCLOSURE_TYPE = "audio/mpeg" ENCLOSURE_TYPE = "audio/mpeg"
CATEGORY_DOMAIN = "http://www.superopendirectory.com/" CATEGORY_DOMAIN = "http://www.superopendirectory.com/"
def default_test def default_test
# This class isn't tested # This class isn't tested
end end
private private
def make_xmldecl(v=XMLDECL_VERSION, e=XMLDECL_ENCODING, s=XMLDECL_STANDALONE) def make_xmldecl(v=XMLDECL_VERSION, e=XMLDECL_ENCODING, s=XMLDECL_STANDALONE)
rv = "<?xml version='#{v}'" rv = "<?xml version='#{v}'"
rv << " encoding='#{e}'" if e rv << " encoding='#{e}'" if e
rv << " standalone='#{s}'" if s rv << " standalone='#{s}'" if s
rv << "?>" rv << "?>"
rv rv
end end
def make_RDF(content=nil, xmlns=[]) def make_RDF(content=nil, xmlns=[])
<<-EORSS <<-EORSS
#{make_xmldecl} #{make_xmldecl}
<rdf:RDF xmlns="#{URI}" xmlns:rdf="#{RDF::URI}" <rdf:RDF xmlns="#{URI}" xmlns:rdf="#{RDF::URI}"
#{xmlns.collect {|pre, uri| "xmlns:#{pre}='#{uri}'"}.join(' ')}> #{xmlns.collect {|pre, uri| "xmlns:#{pre}='#{uri}'"}.join(' ')}>
#{block_given? ? yield : content} #{block_given? ? yield : content}
</rdf:RDF> </rdf:RDF>
EORSS EORSS
end end
def make_channel(content=nil) def make_channel(content=nil)
<<-EOC <<-EOC
<channel rdf:about="#{RDF_ABOUT}"> <channel rdf:about="#{RDF_ABOUT}">
<title>#{TITLE_VALUE}</title> <title>#{TITLE_VALUE}</title>
<link>#{LINK_VALUE}</link> <link>#{LINK_VALUE}</link>
<description>#{DESCRIPTION_VALUE}</description> <description>#{DESCRIPTION_VALUE}</description>
<image rdf:resource="#{RDF_RESOURCE}" /> <image rdf:resource="#{RDF_RESOURCE}" />
<items> <items>
<rdf:Seq> <rdf:Seq>
#{RESOURCES.collect do |res| '<rdf:li resource="' + res + '" />' end.join("\n")} #{RESOURCES.collect do |res| '<rdf:li resource="' + res + '" />' end.join("\n")}
</rdf:Seq> </rdf:Seq>
</items> </items>
<textinput rdf:resource="#{RDF_RESOURCE}" /> <textinput rdf:resource="#{RDF_RESOURCE}" />
#{block_given? ? yield : content} #{block_given? ? yield : content}
</channel> </channel>
EOC EOC
end end
def make_image(content=nil) def make_image(content=nil)
<<-EOI <<-EOI
<image rdf:about="#{RDF_ABOUT}"> <image rdf:about="#{RDF_ABOUT}">
<title>#{TITLE_VALUE}</title> <title>#{TITLE_VALUE}</title>
<url>#{URL_VALUE}</url> <url>#{URL_VALUE}</url>
<link>#{LINK_VALUE}</link> <link>#{LINK_VALUE}</link>
#{block_given? ? yield : content} #{block_given? ? yield : content}
</image> </image>
EOI EOI
end end
def make_item(content=nil) def make_item(content=nil)
<<-EOI <<-EOI
<item rdf:about="#{RDF_ABOUT}"> <item rdf:about="#{RDF_ABOUT}">
<title>#{TITLE_VALUE}</title> <title>#{TITLE_VALUE}</title>
<link>#{LINK_VALUE}</link> <link>#{LINK_VALUE}</link>
<description>#{DESCRIPTION_VALUE}</description> <description>#{DESCRIPTION_VALUE}</description>
#{block_given? ? yield : content} #{block_given? ? yield : content}
</item> </item>
EOI EOI
end end
def make_textinput(content=nil) def make_textinput(content=nil)
<<-EOT <<-EOT
<textinput rdf:about="#{RDF_ABOUT}"> <textinput rdf:about="#{RDF_ABOUT}">
<title>#{TITLE_VALUE}</title> <title>#{TITLE_VALUE}</title>
<description>#{DESCRIPTION_VALUE}</description> <description>#{DESCRIPTION_VALUE}</description>
<name>#{NAME_VALUE}</name> <name>#{NAME_VALUE}</name>
<link>#{LINK_VALUE}</link> <link>#{LINK_VALUE}</link>
#{block_given? ? yield : content} #{block_given? ? yield : content}
</textinput> </textinput>
EOT EOT
end end
def make_sample_RDF def make_sample_RDF
make_RDF(<<-EOR) make_RDF(<<-EOR)
#{make_channel} #{make_channel}
#{make_image} #{make_image}
#{make_item} #{make_item}
#{make_textinput} #{make_textinput}
EOR EOR
end end
def make_rss20(content=nil, xmlns=[]) def make_rss20(content=nil, xmlns=[])
<<-EORSS <<-EORSS
#{make_xmldecl} #{make_xmldecl}
<rss version="2.0" <rss version="2.0"
#{xmlns.collect {|pre, uri| "xmlns:#{pre}='#{uri}'"}.join(' ')}> #{xmlns.collect {|pre, uri| "xmlns:#{pre}='#{uri}'"}.join(' ')}>
#{block_given? ? yield : content} #{block_given? ? yield : content}
</rss> </rss>
EORSS EORSS
end end
def make_channel20(content=nil) def make_channel20(content=nil)
<<-EOC <<-EOC
<channel> <channel>
<title>#{TITLE_VALUE}</title> <title>#{TITLE_VALUE}</title>
<link>#{LINK_VALUE}</link> <link>#{LINK_VALUE}</link>
<description>#{DESCRIPTION_VALUE}</description> <description>#{DESCRIPTION_VALUE}</description>
<language>#{LANGUAGE_VALUE}</language> <language>#{LANGUAGE_VALUE}</language>
<image> <image>
<url>#{RDF_RESOURCE}</url> <url>#{RDF_RESOURCE}</url>
<title>#{TITLE_VALUE}</title> <title>#{TITLE_VALUE}</title>
<link>#{LINK_VALUE}</link> <link>#{LINK_VALUE}</link>
</image> </image>
#{RESOURCES.collect do |res| '<item><link>' + res + '</link></item>' end.join("\n")} #{RESOURCES.collect do |res| '<item><link>' + res + '</link></item>' end.join("\n")}
<textInput> <textInput>
<title>#{TITLE_VALUE}</title> <title>#{TITLE_VALUE}</title>
<description>#{DESCRIPTION_VALUE}</description> <description>#{DESCRIPTION_VALUE}</description>
<name>#{NAME_VALUE}</name> <name>#{NAME_VALUE}</name>
<link>#{RDF_RESOURCE}</link> <link>#{RDF_RESOURCE}</link>
</textInput> </textInput>
#{block_given? ? yield : content} #{block_given? ? yield : content}
</channel> </channel>
EOC EOC
end end
def make_item20(content=nil) def make_item20(content=nil)
<<-EOI <<-EOI
<item> <item>
<title>#{TITLE_VALUE}</title> <title>#{TITLE_VALUE}</title>
<link>#{LINK_VALUE}</link> <link>#{LINK_VALUE}</link>
<description>#{DESCRIPTION_VALUE}</description> <description>#{DESCRIPTION_VALUE}</description>
#{block_given? ? yield : content} #{block_given? ? yield : content}
</item> </item>
EOI EOI
end end
def make_cloud20 def make_cloud20
<<-EOC <<-EOC
<cloud <cloud
domain="#{CLOUD_DOMAIN}" domain="#{CLOUD_DOMAIN}"
port="#{CLOUD_PORT}" port="#{CLOUD_PORT}"
@ -187,7 +187,7 @@ EOI
registerProcedure="#{CLOUD_REGISTER_PROCEDURE}" registerProcedure="#{CLOUD_REGISTER_PROCEDURE}"
protocol="#{CLOUD_PROTOCOL}" /> protocol="#{CLOUD_PROTOCOL}" />
EOC EOC
end end
end end
end end

518
test/rss/test_1.0.rb
View file

@ -7,264 +7,264 @@ require "rss-testcase"
require "rss/1.0" require "rss/1.0"
module RSS module RSS
class TestCore < TestCase class TestCore < TestCase
def setup
@rdf_prefix = "rdf"
@rdf_uri = "http://www.w3.org/1999/02/22-rdf-syntax-ns#"
@uri = "http://purl.org/rss/1.0/"
end
def test_RDF
version = "1.0"
encoding = "UTF-8"
standalone = "no"
rdf = RDF.new(version, encoding, standalone)
doc = REXML::Document.new(rdf.to_s(false))
xmldecl = doc.xml_decl
%w(version encoding standalone).each do |x|
assert_equal(instance_eval(x), xmldecl.send(x))
end
assert_equal(@rdf_uri, doc.root.namespace)
end
def test_not_displayed_xml_stylesheets
rdf = RDF.new()
plain_rdf = rdf.to_s
3.times do
rdf.xml_stylesheets.push(XMLStyleSheet.new)
assert_equal(plain_rdf, rdf.to_s)
end
end
def test_xml_stylesheets
[
[{:href => "a.xsl", :type => "text/xsl"}],
[
{:href => "a.xsl", :type => "text/xsl"},
{:href => "a.css", :type => "text/css"},
],
].each do |attrs_ary|
assert_xml_stylesheet_pis(attrs_ary)
end
end
def test_channel
about = "http://hoge.com"
title = "fugafuga"
link = "http://hoge.com"
description = "fugafugafugafuga"
resource = "http://hoge.com/hoge.png"
image = RDF::Channel::Image.new(resource)
items = RDF::Channel::Items.new
textinput = RDF::Channel::Textinput.new(resource)
channel = RDF::Channel.new(about)
%w(title link description image items textinput).each do |x|
channel.send("#{x}=", instance_eval(x))
end
doc = REXML::Document.new(make_RDF(channel.to_s))
c = doc.root.elements[1]
assert_equal(about, c.attributes["about"])
%w(title link description image textinput).each do |x|
elem = c.elements[x]
assert_equal(x, elem.name)
assert_equal(@uri, elem.namespace)
if x == "image" or x == "textinput"
excepted = resource
res = elem.attributes.get_attribute("resource")
assert_equal(@rdf_uri, res.namespace)
value = res.value
else
excepted = instance_eval(x)
value = elem.text
end
assert_equal(excepted, value)
end
assert_equal(@uri, c.elements["items"].namespace)
assert_equal("items", c.elements["items"].name)
end
def test_channel_image
resource = "http://hoge.com/hoge.png"
image = RDF::Channel::Image.new(resource)
doc = REXML::Document.new(make_RDF(image.to_s))
i = doc.root.elements[1]
assert_equal("image", i.name)
assert_equal(@uri, i.namespace)
res = i.attributes.get_attribute("resource")
assert_equal(@rdf_uri, res.namespace)
assert_equal(resource, res.value)
end
def test_channel_textinput
resource = "http://hoge.com/hoge.png"
textinput = RDF::Channel::Textinput.new(resource)
doc = REXML::Document.new(make_RDF(textinput.to_s))
t = doc.root.elements[1]
assert_equal("textinput", t.name)
assert_equal(@uri, t.namespace)
res = t.attributes.get_attribute("resource")
assert_equal(@rdf_uri, res.namespace)
assert_equal(resource, res.value)
end
def test_items
items = RDF::Channel::Items.new
doc = REXML::Document.new(make_RDF(items.to_s))
i = doc.root.elements[1]
assert_equal("items", i.name)
assert_equal(@uri, i.namespace)
assert_equal(1, i.elements.size)
assert_equal("Seq", i.elements[1].name)
assert_equal(@rdf_uri, i.elements[1].namespace)
end
def test_seq
seq = RDF::Seq.new
doc = REXML::Document.new(make_RDF(seq.to_s))
s = doc.root.elements[1]
assert_equal("Seq", s.name)
assert_equal(@rdf_uri, s.namespace)
end
def test_li
resource = "http://hoge.com/"
li = RDF::Li.new(resource)
doc = REXML::Document.new(make_RDF(li.to_s))
l = doc.root.elements[1]
assert_equal("li", l.name)
assert_equal(@rdf_uri, l.namespace(l.prefix))
res = l.attributes.get_attribute("resource")
assert_equal('', res.instance_eval("@prefix"))
assert_equal(resource, res.value)
end
def test_image
about = "http://hoge.com"
title = "fugafuga"
url = "http://hoge.com/hoge"
link = "http://hoge.com/fuga"
image = RDF::Image.new(about)
%w(title url link).each do |x|
image.send("#{x}=", instance_eval(x))
end
doc = REXML::Document.new(make_RDF(image.to_s))
i = doc.root.elements[1]
assert_equal(about, i.attributes["about"])
%w(title url link).each do |x|
elem = i.elements[x]
assert_equal(x, elem.name)
assert_equal(@uri, elem.namespace)
assert_equal(instance_eval(x), elem.text)
end
end
def test_item
about = "http://hoge.com"
title = "fugafuga"
link = "http://hoge.com/fuga"
description = "hogehogehoge"
item = RDF::Item.new(about)
%w(title link description).each do |x|
item.send("#{x}=", instance_eval(x))
end
doc = REXML::Document.new(make_RDF(item.to_s))
i = doc.root.elements[1]
assert_equal(about, i.attributes["about"])
%w(title link description).each do |x|
elem = i.elements[x]
assert_equal(x, elem.name)
assert_equal(@uri, elem.namespace)
assert_equal(instance_eval(x), elem.text)
end
end
def test_textinput
about = "http://hoge.com"
title = "fugafuga"
link = "http://hoge.com/fuga"
name = "foo"
description = "hogehogehoge"
textinput = RDF::Textinput.new(about)
%w(title link name description).each do |x|
textinput.send("#{x}=", instance_eval(x))
end
doc = REXML::Document.new(make_RDF(textinput.to_s))
t = doc.root.elements[1]
assert_equal(about, t.attributes["about"])
%w(title link name description).each do |x|
elem = t.elements[x]
assert_equal(x, elem.name)
assert_equal(@uri, elem.namespace)
assert_equal(instance_eval(x), elem.text)
end
end
def test_indent_size
assert_equal(0, RDF.indent_size)
assert_equal(1, RDF::Channel.indent_size)
assert_equal(2, RDF::Channel::Image.indent_size)
assert_equal(2, RDF::Channel::Textinput.indent_size)
assert_equal(2, RDF::Channel::Items.indent_size)
assert_equal(1, RDF::Image.indent_size)
assert_equal(1, RDF::Item.indent_size)
assert_equal(1, RDF::Textinput.indent_size)
end
end def setup
@rdf_prefix = "rdf"
@rdf_uri = "http://www.w3.org/1999/02/22-rdf-syntax-ns#"
@uri = "http://purl.org/rss/1.0/"
end
def test_RDF
version = "1.0"
encoding = "UTF-8"
standalone = "no"
rdf = RDF.new(version, encoding, standalone)
doc = REXML::Document.new(rdf.to_s(false))
xmldecl = doc.xml_decl
%w(version encoding standalone).each do |x|
assert_equal(instance_eval(x), xmldecl.send(x))
end
assert_equal(@rdf_uri, doc.root.namespace)
end
def test_not_displayed_xml_stylesheets
rdf = RDF.new()
plain_rdf = rdf.to_s
3.times do
rdf.xml_stylesheets.push(XMLStyleSheet.new)
assert_equal(plain_rdf, rdf.to_s)
end
end
def test_xml_stylesheets
[
[{:href => "a.xsl", :type => "text/xsl"}],
[
{:href => "a.xsl", :type => "text/xsl"},
{:href => "a.css", :type => "text/css"},
],
].each do |attrs_ary|
assert_xml_stylesheet_pis(attrs_ary)
end
end
def test_channel
about = "http://hoge.com"
title = "fugafuga"
link = "http://hoge.com"
description = "fugafugafugafuga"
resource = "http://hoge.com/hoge.png"
image = RDF::Channel::Image.new(resource)
items = RDF::Channel::Items.new
textinput = RDF::Channel::Textinput.new(resource)
channel = RDF::Channel.new(about)
%w(title link description image items textinput).each do |x|
channel.send("#{x}=", instance_eval(x))
end
doc = REXML::Document.new(make_RDF(channel.to_s))
c = doc.root.elements[1]
assert_equal(about, c.attributes["about"])
%w(title link description image textinput).each do |x|
elem = c.elements[x]
assert_equal(x, elem.name)
assert_equal(@uri, elem.namespace)
if x == "image" or x == "textinput"
excepted = resource
res = elem.attributes.get_attribute("resource")
assert_equal(@rdf_uri, res.namespace)
value = res.value
else
excepted = instance_eval(x)
value = elem.text
end
assert_equal(excepted, value)
end
assert_equal(@uri, c.elements["items"].namespace)
assert_equal("items", c.elements["items"].name)
end
def test_channel_image
resource = "http://hoge.com/hoge.png"
image = RDF::Channel::Image.new(resource)
doc = REXML::Document.new(make_RDF(image.to_s))
i = doc.root.elements[1]
assert_equal("image", i.name)
assert_equal(@uri, i.namespace)
res = i.attributes.get_attribute("resource")
assert_equal(@rdf_uri, res.namespace)
assert_equal(resource, res.value)
end
def test_channel_textinput
resource = "http://hoge.com/hoge.png"
textinput = RDF::Channel::Textinput.new(resource)
doc = REXML::Document.new(make_RDF(textinput.to_s))
t = doc.root.elements[1]
assert_equal("textinput", t.name)
assert_equal(@uri, t.namespace)
res = t.attributes.get_attribute("resource")
assert_equal(@rdf_uri, res.namespace)
assert_equal(resource, res.value)
end
def test_items
items = RDF::Channel::Items.new
doc = REXML::Document.new(make_RDF(items.to_s))
i = doc.root.elements[1]
assert_equal("items", i.name)
assert_equal(@uri, i.namespace)
assert_equal(1, i.elements.size)
assert_equal("Seq", i.elements[1].name)
assert_equal(@rdf_uri, i.elements[1].namespace)
end
def test_seq
seq = RDF::Seq.new
doc = REXML::Document.new(make_RDF(seq.to_s))
s = doc.root.elements[1]
assert_equal("Seq", s.name)
assert_equal(@rdf_uri, s.namespace)
end
def test_li
resource = "http://hoge.com/"
li = RDF::Li.new(resource)
doc = REXML::Document.new(make_RDF(li.to_s))
l = doc.root.elements[1]
assert_equal("li", l.name)
assert_equal(@rdf_uri, l.namespace(l.prefix))
res = l.attributes.get_attribute("resource")
assert_equal('', res.instance_eval("@prefix"))
assert_equal(resource, res.value)
end
def test_image
about = "http://hoge.com"
title = "fugafuga"
url = "http://hoge.com/hoge"
link = "http://hoge.com/fuga"
image = RDF::Image.new(about)
%w(title url link).each do |x|
image.send("#{x}=", instance_eval(x))
end
doc = REXML::Document.new(make_RDF(image.to_s))
i = doc.root.elements[1]
assert_equal(about, i.attributes["about"])
%w(title url link).each do |x|
elem = i.elements[x]
assert_equal(x, elem.name)
assert_equal(@uri, elem.namespace)
assert_equal(instance_eval(x), elem.text)
end
end
def test_item
about = "http://hoge.com"
title = "fugafuga"
link = "http://hoge.com/fuga"
description = "hogehogehoge"
item = RDF::Item.new(about)
%w(title link description).each do |x|
item.send("#{x}=", instance_eval(x))
end
doc = REXML::Document.new(make_RDF(item.to_s))
i = doc.root.elements[1]
assert_equal(about, i.attributes["about"])
%w(title link description).each do |x|
elem = i.elements[x]
assert_equal(x, elem.name)
assert_equal(@uri, elem.namespace)
assert_equal(instance_eval(x), elem.text)
end
end
def test_textinput
about = "http://hoge.com"
title = "fugafuga"
link = "http://hoge.com/fuga"
name = "foo"
description = "hogehogehoge"
textinput = RDF::Textinput.new(about)
%w(title link name description).each do |x|
textinput.send("#{x}=", instance_eval(x))
end
doc = REXML::Document.new(make_RDF(textinput.to_s))
t = doc.root.elements[1]
assert_equal(about, t.attributes["about"])
%w(title link name description).each do |x|
elem = t.elements[x]
assert_equal(x, elem.name)
assert_equal(@uri, elem.namespace)
assert_equal(instance_eval(x), elem.text)
end
end
def test_indent_size
assert_equal(0, RDF.indent_size)
assert_equal(1, RDF::Channel.indent_size)
assert_equal(2, RDF::Channel::Image.indent_size)
assert_equal(2, RDF::Channel::Textinput.indent_size)
assert_equal(2, RDF::Channel::Items.indent_size)
assert_equal(1, RDF::Image.indent_size)
assert_equal(1, RDF::Item.indent_size)
assert_equal(1, RDF::Textinput.indent_size)
end
end
end end

34
test/rss/test_accessor.rb
View file

@ -6,21 +6,21 @@ require "rss/1.0"
require "rss/2.0" require "rss/2.0"
module RSS module RSS
class TestAccessor < TestCase class TestAccessor < TestCase
def test_date def test_date
channel = Rss::Channel.new channel = Rss::Channel.new
channel.do_validate = false channel.do_validate = false
channel.pubDate = nil channel.pubDate = nil
assert_nil(channel.pubDate) assert_nil(channel.pubDate)
time = Time.now time = Time.now
channel.pubDate = time channel.pubDate = time
assert_equal(time, channel.pubDate) assert_equal(time, channel.pubDate)
channel.pubDate = nil channel.pubDate = nil
assert_nil(channel.pubDate) assert_nil(channel.pubDate)
end end
end end
end end

142
test/rss/test_content.rb
View file

@ -9,89 +9,89 @@ require "rss/1.0"
require "rss/content" require "rss/content"
module RSS module RSS
class TestContent < TestCase class TestContent < TestCase
def setup def setup
@prefix = "content" @prefix = "content"
@uri = "http://purl.org/rss/1.0/modules/content/" @uri = "http://purl.org/rss/1.0/modules/content/"
@parents = %w(item) @parents = %w(item)
@elems = { @elems = {
:encoded => "<em>ATTENTION</em>", :encoded => "<em>ATTENTION</em>",
} }
@content_nodes = @elems.collect do |name, value| @content_nodes = @elems.collect do |name, value|
"<#{@prefix}:#{name}>#{CGI.escapeHTML(value.to_s)}</#{@prefix}:#{name}>" "<#{@prefix}:#{name}>#{CGI.escapeHTML(value.to_s)}</#{@prefix}:#{name}>"
end.join("\n") end.join("\n")
@rss_source = make_RDF(<<-EOR, {@prefix => @uri}) @rss_source = make_RDF(<<-EOR, {@prefix => @uri})
#{make_channel()} #{make_channel()}
#{make_image()} #{make_image()}
#{make_item(@content_nodes)} #{make_item(@content_nodes)}
#{make_textinput()} #{make_textinput()}
EOR EOR
@rss = Parser.parse(@rss_source) @rss = Parser.parse(@rss_source)
end end
def test_parser def test_parser
assert_nothing_raised do assert_nothing_raised do
Parser.parse(@rss_source) Parser.parse(@rss_source)
end end
@elems.each do |tag, value| @elems.each do |tag, value|
assert_too_much_tag(tag.to_s, "item") do assert_too_much_tag(tag.to_s, "item") do
Parser.parse(make_RDF(<<-EOR, {@prefix => @uri})) Parser.parse(make_RDF(<<-EOR, {@prefix => @uri}))
#{make_channel()} #{make_channel()}
#{make_item(("<" + @prefix + ":" + tag.to_s + ">" + #{make_item(("<" + @prefix + ":" + tag.to_s + ">" +
CGI.escapeHTML(value.to_s) + CGI.escapeHTML(value.to_s) +
"</" + @prefix + ":" + tag.to_s + ">") * 2)} "</" + @prefix + ":" + tag.to_s + ">") * 2)}
EOR EOR
end end
end end
end end
def test_accessor def test_accessor
new_value = { new_value = {
:encoded => "<![CDATA[<it>hoge</it>]]>", :encoded => "<![CDATA[<it>hoge</it>]]>",
} }
@elems.each do |name, value| @elems.each do |name, value|
@parents.each do |parent| @parents.each do |parent|
meth = "#{RSS::CONTENT_PREFIX}_#{name}" meth = "#{RSS::CONTENT_PREFIX}_#{name}"
assert_equal(value, @rss.send(parent).send(meth)) assert_equal(value, @rss.send(parent).send(meth))
@rss.send(parent).send("#{meth}=", new_value[name].to_s) @rss.send(parent).send("#{meth}=", new_value[name].to_s)
assert_equal(new_value[name], @rss.send(parent).send(meth)) assert_equal(new_value[name], @rss.send(parent).send(meth))
end end
end end
end end
def test_to_s def test_to_s
@elems.each do |name, value| @elems.each do |name, value|
excepted = "<#{@prefix}:#{name}>#{CGI.escapeHTML(value)}</#{@prefix}:#{name}>" excepted = "<#{@prefix}:#{name}>#{CGI.escapeHTML(value)}</#{@prefix}:#{name}>"
@parents.each do |parent| @parents.each do |parent|
meth = "#{RSS::CONTENT_PREFIX}_#{name}_element" meth = "#{RSS::CONTENT_PREFIX}_#{name}_element"
assert_equal(excepted, @rss.send(parent).send(meth)) assert_equal(excepted, @rss.send(parent).send(meth))
end end
end end
REXML::Document.new(@rss_source).root.each_element do |parent| REXML::Document.new(@rss_source).root.each_element do |parent|
if @parents.include?(parent.name) if @parents.include?(parent.name)
parent.each_element do |elem| parent.each_element do |elem|
if elem.namespace == @uri if elem.namespace == @uri
assert_equal(elem.text, @elems[elem.name.intern].to_s) assert_equal(elem.text, @elems[elem.name.intern].to_s)
end end
end end
end end
end end
end end
end end
end end

192
test/rss/test_dublincore.rb
View file

@ -9,118 +9,118 @@ require "rss/1.0"
require "rss/dublincore" require "rss/dublincore"
module RSS module RSS
class TestDublinCore < TestCase class TestDublinCore < TestCase
def setup def setup
@prefix = "dc" @prefix = "dc"
@uri = "http://purl.org/dc/elements/1.1/" @uri = "http://purl.org/dc/elements/1.1/"
@parents = %w(channel image item textinput) @parents = %w(channel image item textinput)
t = Time.iso8601("2000-01-01T12:00:05+00:00") t = Time.iso8601("2000-01-01T12:00:05+00:00")
class << t class << t
alias_method(:to_s, :iso8601) alias_method(:to_s, :iso8601)
end end
@elems = { @elems = {
:title => "hoge", :title => "hoge",
:description => :description =>
" XML is placing increasingly heavy loads on " XML is placing increasingly heavy loads on
the existing technical infrastructure of the Internet.", the existing technical infrastructure of the Internet.",
:creator => "Rael Dornfest (mailto:rael@oreilly.com)", :creator => "Rael Dornfest (mailto:rael@oreilly.com)",
:subject => "XML", :subject => "XML",
:publisher => "The O'Reilly Network", :publisher => "The O'Reilly Network",
:contributor => "hogehoge", :contributor => "hogehoge",
:type => "fugafuga", :type => "fugafuga",
:format => "hohoho", :format => "hohoho",
:identifier => "fufufu", :identifier => "fufufu",
:source => "barbar", :source => "barbar",
:language => "ja", :language => "ja",
:relation => "cococo", :relation => "cococo",
:rights => "Copyright (c) 2000 O'Reilly &amp; Associates, Inc.", :rights => "Copyright (c) 2000 O'Reilly &amp; Associates, Inc.",
:date => t, :date => t,
} }
@dc_nodes = @elems.collect do |name, value| @dc_nodes = @elems.collect do |name, value|
"<#{@prefix}:#{name}>#{value}</#{@prefix}:#{name}>" "<#{@prefix}:#{name}>#{value}</#{@prefix}:#{name}>"
end.join("\n") end.join("\n")
@rss_source = make_RDF(<<-EOR, {@prefix => @uri}) @rss_source = make_RDF(<<-EOR, {@prefix => @uri})
#{make_channel(@dc_nodes)} #{make_channel(@dc_nodes)}
#{make_image(@dc_nodes)} #{make_image(@dc_nodes)}
#{make_item(@dc_nodes)} #{make_item(@dc_nodes)}
#{make_textinput(@dc_nodes)} #{make_textinput(@dc_nodes)}
EOR EOR
@rss = Parser.parse(@rss_source) @rss = Parser.parse(@rss_source)
end end
def test_parser def test_parser
assert_nothing_raised do assert_nothing_raised do
Parser.parse(@rss_source) Parser.parse(@rss_source)
end end
@elems.each do |tag, value| @elems.each do |tag, value|
assert_too_much_tag(tag.to_s, "channel") do assert_too_much_tag(tag.to_s, "channel") do
Parser.parse(make_RDF(<<-EOR, {@prefix => @uri})) Parser.parse(make_RDF(<<-EOR, {@prefix => @uri}))
#{make_channel(("<" + @prefix + ":" + tag.to_s + ">" + #{make_channel(("<" + @prefix + ":" + tag.to_s + ">" +
value.to_s + value.to_s +
"</" + @prefix + ":" + tag.to_s + ">") * 2)} "</" + @prefix + ":" + tag.to_s + ">") * 2)}
#{make_item} #{make_item}
EOR EOR
end end
end end
end end
def test_accessor def test_accessor
new_value = "hoge" new_value = "hoge"
@elems.each do |name, value| @elems.each do |name, value|
@parents.each do |parent| @parents.each do |parent|
parsed_value = @rss.send(parent).send("dc_#{name}") parsed_value = @rss.send(parent).send("dc_#{name}")
if parsed_value.kind_of?(String) if parsed_value.kind_of?(String)
parsed_value = CGI.escapeHTML(parsed_value) parsed_value = CGI.escapeHTML(parsed_value)
end end
assert_equal(value, parsed_value) assert_equal(value, parsed_value)
if name == :date if name == :date
t = Time.iso8601("2003-01-01T02:30:23+09:00") t = Time.iso8601("2003-01-01T02:30:23+09:00")
class << t class << t
alias_method(:to_s, :iso8601) alias_method(:to_s, :iso8601)
end end
@rss.send(parent).send("dc_#{name}=", t.iso8601) @rss.send(parent).send("dc_#{name}=", t.iso8601)
assert_equal(t, @rss.send(parent).send("dc_#{name}")) assert_equal(t, @rss.send(parent).send("dc_#{name}"))
else else
@rss.send(parent).send("dc_#{name}=", new_value) @rss.send(parent).send("dc_#{name}=", new_value)
assert_equal(new_value, @rss.send(parent).send("dc_#{name}")) assert_equal(new_value, @rss.send(parent).send("dc_#{name}"))
end end
end end
end end
end end
def test_to_s def test_to_s
@elems.each do |name, value| @elems.each do |name, value|
excepted = "<#{@prefix}:#{name}>#{value}</#{@prefix}:#{name}>" excepted = "<#{@prefix}:#{name}>#{value}</#{@prefix}:#{name}>"
@parents.each do |parent| @parents.each do |parent|
assert_equal(excepted, @rss.send(parent).send("dc_#{name}_element")) assert_equal(excepted, @rss.send(parent).send("dc_#{name}_element"))
end end
end end
REXML::Document.new(@rss_source).root.each_element do |parent| REXML::Document.new(@rss_source).root.each_element do |parent|
if @parents.include?(parent.name) if @parents.include?(parent.name)
parent.each_element do |elem| parent.each_element do |elem|
if elem.namespace == @uri if elem.namespace == @uri
assert_equal(CGI.escapeHTML(elem.text), @elems[elem.name.intern].to_s) assert_equal(CGI.escapeHTML(elem.text), @elems[elem.name.intern].to_s)
end end
end end
end end
end end
end end
end end
end end

428
test/rss/test_parser.rb
View file

@ -7,139 +7,139 @@ require "rss/2.0"
require "rss/dublincore" require "rss/dublincore"
module RSS module RSS
class TestParser < TestCase class TestParser < TestCase
def setup def setup
@_default_parser = Parser.default_parser @_default_parser = Parser.default_parser
end end
def teardown def teardown
Parser.default_parser = @_default_parser Parser.default_parser = @_default_parser
end end
def test_RDF def test_RDF
assert_ns("", RDF::URI) do assert_ns("", RDF::URI) do
Parser.parse(<<-EOR) Parser.parse(<<-EOR)
#{make_xmldecl} #{make_xmldecl}
<RDF/> <RDF/>
EOR EOR
end end
assert_ns("", RDF::URI) do assert_ns("", RDF::URI) do
Parser.parse(<<-EOR) Parser.parse(<<-EOR)
#{make_xmldecl} #{make_xmldecl}
<RDF xmlns="hoge"/> <RDF xmlns="hoge"/>
EOR EOR
end end
assert_ns("rdf", RDF::URI) do assert_ns("rdf", RDF::URI) do
Parser.parse(<<-EOR) Parser.parse(<<-EOR)
#{make_xmldecl} #{make_xmldecl}
<rdf:RDF xmlns:rdf="hoge"/> <rdf:RDF xmlns:rdf="hoge"/>
EOR EOR
end end
assert_parse(<<-EOR, :missing_tag, "channel", "RDF") assert_parse(<<-EOR, :missing_tag, "channel", "RDF")
#{make_xmldecl} #{make_xmldecl}
<rdf:RDF xmlns:rdf="#{RSS::RDF::URI}"/> <rdf:RDF xmlns:rdf="#{RSS::RDF::URI}"/>
EOR EOR
assert_parse(<<-EOR, :missing_tag, "channel", "RDF") assert_parse(<<-EOR, :missing_tag, "channel", "RDF")
#{make_xmldecl} #{make_xmldecl}
<RDF xmlns="#{RSS::RDF::URI}"/> <RDF xmlns="#{RSS::RDF::URI}"/>
EOR EOR
assert_parse(<<-EOR, :missing_tag, "channel", "RDF") assert_parse(<<-EOR, :missing_tag, "channel", "RDF")
#{make_xmldecl} #{make_xmldecl}
<RDF xmlns="#{RSS::RDF::URI}"/> <RDF xmlns="#{RSS::RDF::URI}"/>
EOR EOR
assert_parse(make_RDF(<<-EOR), :missing_tag, "item", "RDF") assert_parse(make_RDF(<<-EOR), :missing_tag, "item", "RDF")
#{make_channel} #{make_channel}
EOR EOR
assert_parse(make_RDF(<<-EOR), :missing_tag, "item", "RDF") assert_parse(make_RDF(<<-EOR), :missing_tag, "item", "RDF")
#{make_channel} #{make_channel}
#{make_image} #{make_image}
EOR EOR
assert_parse(make_RDF(<<-EOR), :missing_tag, "item", "RDF") assert_parse(make_RDF(<<-EOR), :missing_tag, "item", "RDF")
#{make_channel} #{make_channel}
#{make_textinput} #{make_textinput}
EOR EOR
assert_too_much_tag("image", "RDF") do assert_too_much_tag("image", "RDF") do
Parser.parse(make_RDF(<<-EOR)) Parser.parse(make_RDF(<<-EOR))
#{make_channel} #{make_channel}
#{make_image} #{make_image}
#{make_image} #{make_image}
#{make_item} #{make_item}
#{make_textinput} #{make_textinput}
EOR EOR
end end
assert_parse(make_RDF(<<-EOR), :nothing_raised) assert_parse(make_RDF(<<-EOR), :nothing_raised)
#{make_channel} #{make_channel}
#{make_item} #{make_item}
#{make_image} #{make_image}
#{make_textinput} #{make_textinput}
EOR EOR
assert_parse(make_RDF(<<-EOR), :nothing_raised) assert_parse(make_RDF(<<-EOR), :nothing_raised)
#{make_channel} #{make_channel}
#{make_item} #{make_item}
#{make_textinput} #{make_textinput}
#{make_image} #{make_image}
EOR EOR
assert_parse(make_RDF(<<-EOR), :nothing_raised) assert_parse(make_RDF(<<-EOR), :nothing_raised)
#{make_channel} #{make_channel}
#{make_image} #{make_image}
#{make_item} #{make_item}
EOR EOR
assert_parse(make_RDF(<<-EOR), :nothing_raised) assert_parse(make_RDF(<<-EOR), :nothing_raised)
#{make_channel} #{make_channel}
#{make_image} #{make_image}
#{make_item} #{make_item}
#{make_textinput} #{make_textinput}
EOR EOR
1.step(15, 3) do |i| 1.step(15, 3) do |i|
rss = make_RDF() do rss = make_RDF() do
res = make_channel res = make_channel
i.times { res << make_item } i.times { res << make_item }
res res
end end
assert_parse(rss, :nothing_raised) assert_parse(rss, :nothing_raised)
end end
end end
def test_channel def test_channel
assert_parse(make_RDF(<<-EOR), :missing_attribute, "channel", "about") assert_parse(make_RDF(<<-EOR), :missing_attribute, "channel", "about")
<channel /> <channel />
EOR EOR
assert_parse(make_RDF(<<-EOR), :missing_tag, "title", "channel") assert_parse(make_RDF(<<-EOR), :missing_tag, "title", "channel")
<channel rdf:about="http://example.com/"/> <channel rdf:about="http://example.com/"/>
EOR EOR
assert_parse(make_RDF(<<-EOR), :missing_tag, "link", "channel") assert_parse(make_RDF(<<-EOR), :missing_tag, "link", "channel")
<channel rdf:about="http://example.com/"> <channel rdf:about="http://example.com/">
<title>hoge</title> <title>hoge</title>
</channel> </channel>
EOR EOR
assert_parse(make_RDF(<<EOR), :missing_tag, "description", "channel") assert_parse(make_RDF(<<EOR), :missing_tag, "description", "channel")
<channel rdf:about="http://example.com/"> <channel rdf:about="http://example.com/">
<title>hoge</title> <title>hoge</title>
<link>http://example.com/</link> <link>http://example.com/</link>
</channel> </channel>
EOR EOR
assert_parse(make_RDF(<<-EOR), :missing_tag, "items", "channel") assert_parse(make_RDF(<<-EOR), :missing_tag, "items", "channel")
<channel rdf:about="http://example.com/"> <channel rdf:about="http://example.com/">
<title>hoge</title> <title>hoge</title>
<link>http://example.com/</link> <link>http://example.com/</link>
@ -147,7 +147,7 @@ EOR
</channel> </channel>
EOR EOR
assert_parse(make_RDF(<<-EOR), :missing_attribute, "image", "resource") assert_parse(make_RDF(<<-EOR), :missing_attribute, "image", "resource")
<channel rdf:about="http://example.com/"> <channel rdf:about="http://example.com/">
<title>hoge</title> <title>hoge</title>
<link>http://example.com/</link> <link>http://example.com/</link>
@ -156,7 +156,7 @@ EOR
</channel> </channel>
EOR EOR
assert_parse(make_RDF(<<-EOR), :missing_tag, "items", "channel") assert_parse(make_RDF(<<-EOR), :missing_tag, "items", "channel")
<channel rdf:about="http://example.com/"> <channel rdf:about="http://example.com/">
<title>hoge</title> <title>hoge</title>
<link>http://example.com/</link> <link>http://example.com/</link>
@ -165,7 +165,7 @@ EOR
</channel> </channel>
EOR EOR
rss = make_RDF(<<-EOR) rss = make_RDF(<<-EOR)
<channel rdf:about="http://example.com/"> <channel rdf:about="http://example.com/">
<title>hoge</title> <title>hoge</title>
<link>http://example.com/</link> <link>http://example.com/</link>
@ -175,15 +175,15 @@ EOR
</channel> </channel>
EOR EOR
assert_missing_tag("Seq", "items") do assert_missing_tag("Seq", "items") do
Parser.parse(rss) Parser.parse(rss)
end end
assert_missing_tag("item", "RDF") do assert_missing_tag("item", "RDF") do
Parser.parse(rss, false).validate Parser.parse(rss, false).validate
end end
assert_parse(make_RDF(<<-EOR), :missing_tag, "item", "RDF") assert_parse(make_RDF(<<-EOR), :missing_tag, "item", "RDF")
<channel rdf:about="http://example.com/"> <channel rdf:about="http://example.com/">
<title>hoge</title> <title>hoge</title>
<link>http://example.com/</link> <link>http://example.com/</link>
@ -196,7 +196,7 @@ EOR
</channel> </channel>
EOR EOR
assert_parse(make_RDF(<<-EOR), :missing_attribute, "textinput", "resource") assert_parse(make_RDF(<<-EOR), :missing_attribute, "textinput", "resource")
<channel rdf:about="http://example.com/"> <channel rdf:about="http://example.com/">
<title>hoge</title> <title>hoge</title>
<link>http://example.com/</link> <link>http://example.com/</link>
@ -210,7 +210,7 @@ EOR
</channel> </channel>
EOR EOR
assert_parse(make_RDF(<<-EOR), :missing_tag, "item", "RDF") assert_parse(make_RDF(<<-EOR), :missing_tag, "item", "RDF")
<channel rdf:about="http://example.com/"> <channel rdf:about="http://example.com/">
<title>hoge</title> <title>hoge</title>
<link>http://example.com/</link> <link>http://example.com/</link>
@ -224,11 +224,11 @@ EOR
</channel> </channel>
EOR EOR
end end
def test_rdf_li def test_rdf_li
rss = make_RDF(<<-EOR) rss = make_RDF(<<-EOR)
<channel rdf:about="http://example.com/"> <channel rdf:about="http://example.com/">
<title>hoge</title> <title>hoge</title>
<link>http://example.com/</link> <link>http://example.com/</link>
@ -244,41 +244,41 @@ EOR
#{make_item} #{make_item}
EOR EOR
source = Proc.new do |rdf_li_attr| source = Proc.new do |rdf_li_attr|
eval(%Q[%Q[#{rss}]], binding) eval(%Q[%Q[#{rss}]], binding)
end end
attr = %q[resource="http://example.com/hoge"] attr = %q[resource="http://example.com/hoge"]
assert_parse(source.call(attr), :nothing_raised) assert_parse(source.call(attr), :nothing_raised)
attr = %q[rdf:resource="http://example.com/hoge"] attr = %q[rdf:resource="http://example.com/hoge"]
assert_parse(source.call(attr), :nothing_raised) assert_parse(source.call(attr), :nothing_raised)
assert_parse(source.call(""), :missing_attribute, "li", "resource") assert_parse(source.call(""), :missing_attribute, "li", "resource")
end end
def test_image def test_image
assert_parse(make_RDF(<<-EOR), :missing_attribute, "image", "about") assert_parse(make_RDF(<<-EOR), :missing_attribute, "image", "about")
#{make_channel} #{make_channel}
<image> <image>
</image> </image>
EOR EOR
assert_parse(make_RDF(<<-EOR), :missing_tag, "title", "image") assert_parse(make_RDF(<<-EOR), :missing_tag, "title", "image")
#{make_channel} #{make_channel}
<image rdf:about="http://example.com/hoge.png"> <image rdf:about="http://example.com/hoge.png">
</image> </image>
EOR EOR
assert_parse(make_RDF(<<-EOR), :missing_tag, "url", "image") assert_parse(make_RDF(<<-EOR), :missing_tag, "url", "image")
#{make_channel} #{make_channel}
<image rdf:about="http://example.com/hoge.png"> <image rdf:about="http://example.com/hoge.png">
<title>hoge</title> <title>hoge</title>
</image> </image>
EOR EOR
assert_parse(make_RDF(<<-EOR), :missing_tag, "link", "image") assert_parse(make_RDF(<<-EOR), :missing_tag, "link", "image")
#{make_channel} #{make_channel}
<image rdf:about="http://example.com/hoge.png"> <image rdf:about="http://example.com/hoge.png">
<title>hoge</title> <title>hoge</title>
@ -286,7 +286,7 @@ EOR
</image> </image>
EOR EOR
assert_parse(make_RDF(<<-EOR), :missing_tag, "item", "RDF") assert_parse(make_RDF(<<-EOR), :missing_tag, "item", "RDF")
#{make_channel} #{make_channel}
<image rdf:about="http://example.com/hoge.png"> <image rdf:about="http://example.com/hoge.png">
<title>hoge</title> <title>hoge</title>
@ -295,7 +295,7 @@ EOR
</image> </image>
EOR EOR
rss = make_RDF(<<-EOR) rss = make_RDF(<<-EOR)
#{make_channel} #{make_channel}
<image rdf:about="http://example.com/hoge.png"> <image rdf:about="http://example.com/hoge.png">
<link>http://example.com/</link> <link>http://example.com/</link>
@ -304,33 +304,33 @@ EOR
</image> </image>
EOR EOR
assert_missing_tag("item", "RDF") do assert_missing_tag("item", "RDF") do
Parser.parse(rss) Parser.parse(rss)
end end
assert_missing_tag("item", "RDF") do assert_missing_tag("item", "RDF") do
Parser.parse(rss, false).validate Parser.parse(rss, false).validate
end end
end end
def test_item def test_item
assert_parse(make_RDF(<<-EOR), :missing_attribute, "item", "about") assert_parse(make_RDF(<<-EOR), :missing_attribute, "item", "about")
#{make_channel} #{make_channel}
#{make_image} #{make_image}
<item> <item>
</item> </item>
EOR EOR
assert_parse(make_RDF(<<-EOR), :missing_tag, "title", "item") assert_parse(make_RDF(<<-EOR), :missing_tag, "title", "item")
#{make_channel} #{make_channel}
#{make_image} #{make_image}
<item rdf:about="http://example.com/hoge.html"> <item rdf:about="http://example.com/hoge.html">
</item> </item>
EOR EOR
assert_parse(make_RDF(<<-EOR), :missing_tag, "link", "item") assert_parse(make_RDF(<<-EOR), :missing_tag, "link", "item")
#{make_channel} #{make_channel}
#{make_image} #{make_image}
<item rdf:about="http://example.com/hoge.html"> <item rdf:about="http://example.com/hoge.html">
@ -338,8 +338,8 @@ EOR
</item> </item>
EOR EOR
assert_too_much_tag("title", "item") do assert_too_much_tag("title", "item") do
Parser.parse(make_RDF(<<-EOR)) Parser.parse(make_RDF(<<-EOR))
#{make_channel} #{make_channel}
#{make_image} #{make_image}
<item rdf:about="http://example.com/hoge.html"> <item rdf:about="http://example.com/hoge.html">
@ -348,9 +348,9 @@ EOR
<link>http://example.com/hoge.html</link> <link>http://example.com/hoge.html</link>
</item> </item>
EOR EOR
end end
assert_parse(make_RDF(<<-EOR), :nothing_raised) assert_parse(make_RDF(<<-EOR), :nothing_raised)
#{make_channel} #{make_channel}
#{make_image} #{make_image}
<item rdf:about="http://example.com/hoge.html"> <item rdf:about="http://example.com/hoge.html">
@ -359,7 +359,7 @@ EOR
</item> </item>
EOR EOR
assert_parse(make_RDF(<<-EOR), :nothing_raised) assert_parse(make_RDF(<<-EOR), :nothing_raised)
#{make_channel} #{make_channel}
#{make_image} #{make_image}
<item rdf:about="http://example.com/hoge.html"> <item rdf:about="http://example.com/hoge.html">
@ -369,11 +369,11 @@ EOR
</item> </item>
EOR EOR
end end
def test_textinput def test_textinput
assert_parse(make_RDF(<<-EOR), :missing_attribute, "textinput", "about") assert_parse(make_RDF(<<-EOR), :missing_attribute, "textinput", "about")
#{make_channel} #{make_channel}
#{make_image} #{make_image}
#{make_item} #{make_item}
@ -381,7 +381,7 @@ EOR
</textinput> </textinput>
EOR EOR
assert_parse(make_RDF(<<-EOR), :missing_tag, "title", "textinput") assert_parse(make_RDF(<<-EOR), :missing_tag, "title", "textinput")
#{make_channel} #{make_channel}
#{make_image} #{make_image}
#{make_item} #{make_item}
@ -389,7 +389,7 @@ EOR
</textinput> </textinput>
EOR EOR
assert_parse(make_RDF(<<-EOR), :missing_tag, "description", "textinput") assert_parse(make_RDF(<<-EOR), :missing_tag, "description", "textinput")
#{make_channel} #{make_channel}
#{make_image} #{make_image}
#{make_item} #{make_item}
@ -398,8 +398,8 @@ EOR
</textinput> </textinput>
EOR EOR
assert_too_much_tag("title", "textinput") do assert_too_much_tag("title", "textinput") do
Parser.parse(make_RDF(<<-EOR)) Parser.parse(make_RDF(<<-EOR))
#{make_channel} #{make_channel}
#{make_image} #{make_image}
#{make_item} #{make_item}
@ -409,9 +409,9 @@ EOR
<description>hogehoge</description> <description>hogehoge</description>
</textinput> </textinput>
EOR EOR
end end
assert_parse(make_RDF(<<-EOR), :missing_tag, "name", "textinput") assert_parse(make_RDF(<<-EOR), :missing_tag, "name", "textinput")
#{make_channel} #{make_channel}
#{make_image} #{make_image}
#{make_item} #{make_item}
@ -421,7 +421,7 @@ EOR
</textinput> </textinput>
EOR EOR
assert_parse(make_RDF(<<-EOR), :missing_tag, "link", "textinput") assert_parse(make_RDF(<<-EOR), :missing_tag, "link", "textinput")
#{make_channel} #{make_channel}
#{make_image} #{make_image}
#{make_item} #{make_item}
@ -432,7 +432,7 @@ EOR
</textinput> </textinput>
EOR EOR
assert_parse(make_RDF(<<-EOR), :nothing_raised) assert_parse(make_RDF(<<-EOR), :nothing_raised)
#{make_channel} #{make_channel}
#{make_image} #{make_image}
#{make_item} #{make_item}
@ -444,170 +444,170 @@ EOR
</textinput> </textinput>
EOR EOR
end end
def test_rss20 def test_rss20
assert_parse(make_rss20(<<-EOR), :missing_tag, "channel", "rss") assert_parse(make_rss20(<<-EOR), :missing_tag, "channel", "rss")
EOR EOR
assert_parse(make_rss20(<<-EOR), :nothing_raised) assert_parse(make_rss20(<<-EOR), :nothing_raised)
#{make_channel20("")} #{make_channel20("")}
EOR EOR
end end
def test_cloud20 def test_cloud20
attrs = [ attrs = [
["domain", CLOUD_DOMAIN], ["domain", CLOUD_DOMAIN],
["port", CLOUD_PORT], ["port", CLOUD_PORT],
["path", CLOUD_PATH], ["path", CLOUD_PATH],
["registerProcedure", CLOUD_REGISTER_PROCEDURE], ["registerProcedure", CLOUD_REGISTER_PROCEDURE],
["protocol", CLOUD_PROTOCOL], ["protocol", CLOUD_PROTOCOL],
] ]
(attrs.size + 1).times do |i| (attrs.size + 1).times do |i|
missing_attr = attrs[i] missing_attr = attrs[i]
if missing_attr if missing_attr
meth = :missing_attribute meth = :missing_attribute
args = ["cloud", missing_attr[0]] args = ["cloud", missing_attr[0]]
else else
meth = :nothing_raised meth = :nothing_raised
args = [] args = []
end end
cloud_attrs = [] cloud_attrs = []
attrs.each_with_index do |attr, j| attrs.each_with_index do |attr, j|
unless i == j unless i == j
cloud_attrs << %Q[#{attr[0]}="#{attr[1]}"] cloud_attrs << %Q[#{attr[0]}="#{attr[1]}"]
end end
end end
assert_parse(make_rss20(<<-EOR), meth, *args) assert_parse(make_rss20(<<-EOR), meth, *args)
#{make_channel20(%Q[<cloud #{cloud_attrs.join("\n")}/>])} #{make_channel20(%Q[<cloud #{cloud_attrs.join("\n")}/>])}
EOR EOR
end end
end end
def test_source20 def test_source20
assert_parse(make_rss20(<<-EOR), :missing_attribute, "source", "url") assert_parse(make_rss20(<<-EOR), :missing_attribute, "source", "url")
#{make_channel20(make_item20(%Q[<source>Example</source>]))} #{make_channel20(make_item20(%Q[<source>Example</source>]))}
EOR EOR
assert_parse(make_rss20(<<-EOR), :nothing_raised) assert_parse(make_rss20(<<-EOR), :nothing_raised)
#{make_channel20(make_item20(%Q[<source url="http://example.com/" />]))} #{make_channel20(make_item20(%Q[<source url="http://example.com/" />]))}
EOR EOR
assert_parse(make_rss20(<<-EOR), :nothing_raised) assert_parse(make_rss20(<<-EOR), :nothing_raised)
#{make_channel20(make_item20(%Q[<source url="http://example.com/">Example</source>]))} #{make_channel20(make_item20(%Q[<source url="http://example.com/">Example</source>]))}
EOR EOR
end end
def test_enclosure20 def test_enclosure20
attrs = [ attrs = [
["url", ENCLOSURE_URL], ["url", ENCLOSURE_URL],
["length", ENCLOSURE_LENGTH], ["length", ENCLOSURE_LENGTH],
["type", ENCLOSURE_TYPE], ["type", ENCLOSURE_TYPE],
] ]
(attrs.size + 1).times do |i| (attrs.size + 1).times do |i|
missing_attr = attrs[i] missing_attr = attrs[i]
if missing_attr if missing_attr
meth = :missing_attribute meth = :missing_attribute
args = ["enclosure", missing_attr[0]] args = ["enclosure", missing_attr[0]]
else else
meth = :nothing_raised meth = :nothing_raised
args = [] args = []
end end
enclosure_attrs = [] enclosure_attrs = []
attrs.each_with_index do |attr, j| attrs.each_with_index do |attr, j|
unless i == j unless i == j
enclosure_attrs << %Q[#{attr[0]}="#{attr[1]}"] enclosure_attrs << %Q[#{attr[0]}="#{attr[1]}"]
end end
end end
assert_parse(make_rss20(<<-EOR), meth, *args) assert_parse(make_rss20(<<-EOR), meth, *args)
#{make_channel20(%Q[ #{make_channel20(%Q[
#{make_item20(%Q[ #{make_item20(%Q[
<enclosure <enclosure
#{enclosure_attrs.join("\n")} /> #{enclosure_attrs.join("\n")} />
])} ])}
])} ])}
EOR EOR
end end
end end
def test_category20 def test_category20
attrs = [ attrs = [
["domain", CATEGORY_DOMAIN], ["domain", CATEGORY_DOMAIN],
] ]
(attrs.size + 1).times do |i| (attrs.size + 1).times do |i|
missing_attr = attrs[i] missing_attr = attrs[i]
if missing_attr if missing_attr
meth = :missing_attribute meth = :missing_attribute
args = ["category", missing_attr[0]] args = ["category", missing_attr[0]]
else else
meth = :nothing_raised meth = :nothing_raised
args = [] args = []
end end
category_attrs = [] category_attrs = []
attrs.each_with_index do |attr, j| attrs.each_with_index do |attr, j|
unless i == j unless i == j
category_attrs << %Q[#{attr[0]}="#{attr[1]}"] category_attrs << %Q[#{attr[0]}="#{attr[1]}"]
end end
end end
["", "Example Text"].each do |text| ["", "Example Text"].each do |text|
assert_parse(make_rss20(<<-EOR), meth, *args) assert_parse(make_rss20(<<-EOR), meth, *args)
#{make_channel20(%Q[ #{make_channel20(%Q[
#{make_item20(%Q[ #{make_item20(%Q[
<category <category
#{category_attrs.join("\n")}>#{text}</category> #{category_attrs.join("\n")}>#{text}</category>
])} ])}
])} ])}
EOR EOR
end end
end end
end end
def test_ignore def test_ignore
rss = make_RDF(<<-EOR) rss = make_RDF(<<-EOR)
#{make_channel} #{make_channel}
#{make_item} #{make_item}
<a/> <a/>
EOR EOR
assert_parse(rss, :nothing_raised) assert_parse(rss, :nothing_raised)
assert_not_excepted_tag("a", "RDF") do assert_not_excepted_tag("a", "RDF") do
Parser.parse(rss, true, false) Parser.parse(rss, true, false)
end end
end end
def test_default_parser def test_default_parser
assert_nothing_raised() do assert_nothing_raised() do
Parser.default_parser = RSS::AVAILABLE_PARSERS.first Parser.default_parser = RSS::AVAILABLE_PARSERS.first
end end
assert_raise(RSS::NotValidXMLParser) do assert_raise(RSS::NotValidXMLParser) do
Parser.default_parser = RSS::Parser Parser.default_parser = RSS::Parser
end end
end end
end end
end end

204
test/rss/test_syndication.rb
View file

@ -9,117 +9,117 @@ require "rss/1.0"
require "rss/syndication" require "rss/syndication"
module RSS module RSS
class TestSyndication < TestCase class TestSyndication < TestCase
def setup def setup
@prefix = "sy" @prefix = "sy"
@uri = "http://purl.org/rss/1.0/modules/syndication/" @uri = "http://purl.org/rss/1.0/modules/syndication/"
@parents = %w(channel) @parents = %w(channel)
t = Time.iso8601("2000-01-01T12:00:05+00:00") t = Time.iso8601("2000-01-01T12:00:05+00:00")
class << t class << t
alias_method(:to_s, :iso8601) alias_method(:to_s, :iso8601)
end end
@elems = { @elems = {
:updatePeriod => "hourly", :updatePeriod => "hourly",
:updateFrequency => 2, :updateFrequency => 2,
:updateBase => t, :updateBase => t,
} }
@sy_nodes = @elems.collect do |name, value| @sy_nodes = @elems.collect do |name, value|
"<#{@prefix}:#{name}>#{CGI.escapeHTML(value.to_s)}</#{@prefix}:#{name}>" "<#{@prefix}:#{name}>#{CGI.escapeHTML(value.to_s)}</#{@prefix}:#{name}>"
end.join("\n") end.join("\n")
@rss_source = make_RDF(<<-EOR, {@prefix => @uri}) @rss_source = make_RDF(<<-EOR, {@prefix => @uri})
#{make_channel(@sy_nodes)} #{make_channel(@sy_nodes)}
#{make_image()} #{make_image()}
#{make_item()} #{make_item()}
#{make_textinput()} #{make_textinput()}
EOR EOR
@rss = Parser.parse(@rss_source) @rss = Parser.parse(@rss_source)
end end
def test_parser def test_parser
assert_nothing_raised do assert_nothing_raised do
Parser.parse(@rss_source) Parser.parse(@rss_source)
end end
@elems.each do |tag, value| @elems.each do |tag, value|
assert_too_much_tag(tag.to_s, "channel") do assert_too_much_tag(tag.to_s, "channel") do
Parser.parse(make_RDF(<<-EOR, {@prefix => @uri})) Parser.parse(make_RDF(<<-EOR, {@prefix => @uri}))
#{make_channel(("<" + @prefix + ":" + tag.to_s + ">" + #{make_channel(("<" + @prefix + ":" + tag.to_s + ">" +
CGI.escapeHTML(value.to_s) + CGI.escapeHTML(value.to_s) +
"</" + @prefix + ":" + tag.to_s + ">") * 2)} "</" + @prefix + ":" + tag.to_s + ">") * 2)}
#{make_item} #{make_item}
EOR EOR
end end
end end
end end
def test_accessor def test_accessor
t = Time.iso8601("2003-01-01T12:00:23+09:00") t = Time.iso8601("2003-01-01T12:00:23+09:00")
class << t class << t
alias_method(:to_s, :iso8601) alias_method(:to_s, :iso8601)
end end
new_value = { new_value = {
:updatePeriod => "daily", :updatePeriod => "daily",
:updateFrequency => +11, :updateFrequency => +11,
:updateBase => t, :updateBase => t,
} }
@elems.each do |name, value| @elems.each do |name, value|
@parents.each do |parent| @parents.each do |parent|
assert_equal(value, @rss.send(parent).send("sy_#{name}")) assert_equal(value, @rss.send(parent).send("sy_#{name}"))
@rss.send(parent).send("sy_#{name}=", new_value[name].to_s) @rss.send(parent).send("sy_#{name}=", new_value[name].to_s)
assert_equal(new_value[name], @rss.send(parent).send("sy_#{name}")) assert_equal(new_value[name], @rss.send(parent).send("sy_#{name}"))
end end
end end
%w(hourly daily weekly monthly yearly).each do |x| %w(hourly daily weekly monthly yearly).each do |x|
@parents.each do |parent| @parents.each do |parent|
assert_nothing_raised do assert_nothing_raised do
@rss.send(parent).sy_updatePeriod = x @rss.send(parent).sy_updatePeriod = x
end end
end end
end end
%w(-2 0.3 -0.4).each do |x| %w(-2 0.3 -0.4).each do |x|
@parents.each do |parent| @parents.each do |parent|
assert_not_available_value("updateBase", x) do assert_not_available_value("updateBase", x) do
@rss.send(parent).sy_updateBase = x @rss.send(parent).sy_updateBase = x
end end
end end
end end
end end
def test_to_s def test_to_s
@elems.each do |name, value| @elems.each do |name, value|
excepted = "<#{@prefix}:#{name}>#{value}</#{@prefix}:#{name}>" excepted = "<#{@prefix}:#{name}>#{value}</#{@prefix}:#{name}>"
@parents.each do |parent| @parents.each do |parent|
assert_equal(excepted, @rss.send(parent).send("sy_#{name}_element")) assert_equal(excepted, @rss.send(parent).send("sy_#{name}_element"))
end end
end end
REXML::Document.new(@rss_source).root.each_element do |parent| REXML::Document.new(@rss_source).root.each_element do |parent|
if @parents.include?(parent.name) if @parents.include?(parent.name)
parent.each_element do |elem| parent.each_element do |elem|
if elem.namespace == @uri if elem.namespace == @uri
assert_equal(elem.text, @elems[elem.name.intern].to_s) assert_equal(elem.text, @elems[elem.name.intern].to_s)
end end
end end
end end
end end
end end
end end
end end

204
test/rss/test_trackback.rb
View file

@ -10,128 +10,128 @@ require "rss/2.0"
require "rss/trackback" require "rss/trackback"
module RSS module RSS
class TestTrackBack < TestCase class TestTrackBack < TestCase
def setup def setup
@prefix = "trackback" @prefix = "trackback"
@uri = "http://madskills.com/public/xml/rss/module/trackback/" @uri = "http://madskills.com/public/xml/rss/module/trackback/"
@parents = %w(item) @parents = %w(item)
@elems = { @elems = {
:ping => "http://bar.com/tb.cgi?tb_id=rssplustrackback", :ping => "http://bar.com/tb.cgi?tb_id=rssplustrackback",
:about => "http://foo.com/trackback/tb.cgi?tb_id=20020923", :about => "http://foo.com/trackback/tb.cgi?tb_id=20020923",
} }
@content_nodes = @elems.collect do |name, value| @content_nodes = @elems.collect do |name, value|
"<#{@prefix}:#{name} rdf:resource=\"#{CGI.escapeHTML(value.to_s)}\"/>" "<#{@prefix}:#{name} rdf:resource=\"#{CGI.escapeHTML(value.to_s)}\"/>"
end.join("\n") end.join("\n")
@content_nodes2 = @elems.collect do |name, value| @content_nodes2 = @elems.collect do |name, value|
"<#{@prefix}:#{name}>#{CGI.escapeHTML(value.to_s)}</#{@prefix}:#{name}>" "<#{@prefix}:#{name}>#{CGI.escapeHTML(value.to_s)}</#{@prefix}:#{name}>"
end.join("\n") end.join("\n")
@rss_source = make_RDF(<<-EOR, {@prefix => @uri}) @rss_source = make_RDF(<<-EOR, {@prefix => @uri})
#{make_channel()} #{make_channel()}
#{make_image()} #{make_image()}
#{make_item(@content_nodes)} #{make_item(@content_nodes)}
#{make_textinput()} #{make_textinput()}
EOR EOR
@rss = Parser.parse(@rss_source) @rss = Parser.parse(@rss_source)
@rss20_source = make_rss20(nil, {@prefix => @uri}) do @rss20_source = make_rss20(nil, {@prefix => @uri}) do
make_channel20(nil) do make_channel20(nil) do
make_item20(@content_nodes2) make_item20(@content_nodes2)
end end
end end
@rss20 = Parser.parse(@rss20_source, false) @rss20 = Parser.parse(@rss20_source, false)
end end
def test_parser def test_parser
assert_nothing_raised do assert_nothing_raised do
Parser.parse(@rss_source) Parser.parse(@rss_source)
end end
@elems.find_all{|k, v| k == :ping}.each do |tag, value| @elems.find_all{|k, v| k == :ping}.each do |tag, value|
assert_too_much_tag(tag.to_s, "item") do assert_too_much_tag(tag.to_s, "item") do
Parser.parse(make_RDF(<<-EOR, {@prefix => @uri})) Parser.parse(make_RDF(<<-EOR, {@prefix => @uri}))
#{make_channel()} #{make_channel()}
#{make_item(("<" + @prefix + ":" + tag.to_s + " rdf:resource=\"" + #{make_item(("<" + @prefix + ":" + tag.to_s + " rdf:resource=\"" +
CGI.escapeHTML(value.to_s) + CGI.escapeHTML(value.to_s) +
"\"/>") * 2)} "\"/>") * 2)}
EOR EOR
end end
end end
@elems.find_all{|k, v| k == :about}.each do |tag, value| @elems.find_all{|k, v| k == :about}.each do |tag, value|
assert_missing_tag("trackback:ping", "item") do assert_missing_tag("trackback:ping", "item") do
Parser.parse(make_RDF(<<-EOR, {@prefix => @uri})) Parser.parse(make_RDF(<<-EOR, {@prefix => @uri}))
#{make_channel()} #{make_channel()}
#{make_item(("<" + @prefix + ":" + tag.to_s + " rdf:resource=\"" + #{make_item(("<" + @prefix + ":" + tag.to_s + " rdf:resource=\"" +
CGI.escapeHTML(value.to_s) + CGI.escapeHTML(value.to_s) +
"\"/>") * 2)} "\"/>") * 2)}
EOR EOR
end end
end end
end end
def test_accessor def test_accessor
new_value = { new_value = {
:ping => "http://baz.com/trackback/tb.cgi?tb_id=20030808", :ping => "http://baz.com/trackback/tb.cgi?tb_id=20030808",
:about => "http://hoge.com/trackback/tb.cgi?tb_id=90030808", :about => "http://hoge.com/trackback/tb.cgi?tb_id=90030808",
} }
@elems.each do |name, value| @elems.each do |name, value|
@parents.each do |parent| @parents.each do |parent|
accessor = "#{RSS::TRACKBACK_PREFIX}_#{name}" accessor = "#{RSS::TRACKBACK_PREFIX}_#{name}"
target_accessor = "resource" target_accessor = "resource"
target = @rss.send(parent).send(accessor) target = @rss.send(parent).send(accessor)
target20 = @rss20.channel.send(parent, -1) target20 = @rss20.channel.send(parent, -1)
assert_equal(value, target.send(target_accessor)) assert_equal(value, target.send(target_accessor))
assert_equal(value, target20.send(accessor)) assert_equal(value, target20.send(accessor))
target.send("#{target_accessor}=", new_value[name].to_s) target.send("#{target_accessor}=", new_value[name].to_s)
if name == :about if name == :about
# abount is zero or more # abount is zero or more
target20.send("#{accessor}=", 0, new_value[name].to_s) target20.send("#{accessor}=", 0, new_value[name].to_s)
else else
target20.send("#{accessor}=", new_value[name].to_s) target20.send("#{accessor}=", new_value[name].to_s)
end end
assert_equal(new_value[name], target.send(target_accessor)) assert_equal(new_value[name], target.send(target_accessor))
assert_equal(new_value[name], target20.send(accessor)) assert_equal(new_value[name], target20.send(accessor))
end end
end end
end end
def test_to_s def test_to_s
@elems.each do |name, value| @elems.each do |name, value|
excepted = %Q!<#{@prefix}:#{name} rdf:resource="#{CGI.escapeHTML(value)}"/>! excepted = %Q!<#{@prefix}:#{name} rdf:resource="#{CGI.escapeHTML(value)}"/>!
@parents.each do |parent| @parents.each do |parent|
meth = "#{RSS::TRACKBACK_PREFIX}_#{name}_element" meth = "#{RSS::TRACKBACK_PREFIX}_#{name}_element"
meth << "s" if name == :about meth << "s" if name == :about
assert_equal(excepted, @rss.send(parent).send(meth)) assert_equal(excepted, @rss.send(parent).send(meth))
end end
end end
REXML::Document.new(@rss_source).root.each_element do |parent| REXML::Document.new(@rss_source).root.each_element do |parent|
if @parents.include?(parent.name) if @parents.include?(parent.name)
parent.each_element do |elem| parent.each_element do |elem|
if elem.namespace == @uri if elem.namespace == @uri
assert_equal(elem.attributes["resource"], @elems[elem.name.intern]) assert_equal(elem.attributes["resource"], @elems[elem.name.intern])
end end
end end
end end
end end
end end
end end
end end

198
test/rss/test_xml-stylesheet.rb
View file

@ -8,103 +8,103 @@ require "rss/1.0"
require "rss/xml-stylesheet" require "rss/xml-stylesheet"
module RSS module RSS
class TestXMLStyleSheet < TestCase class TestXMLStyleSheet < TestCase
def test_accessor def test_accessor
[ [
{:href => "a.xsl", :type => "text/xsl"}, {:href => "a.xsl", :type => "text/xsl"},
{:media => "print", :title => "FOO"}, {:media => "print", :title => "FOO"},
{:charset => "UTF-8", :alternate => "yes"}, {:charset => "UTF-8", :alternate => "yes"},
].each do |attrs| ].each do |attrs|
assert_xml_stylesheet_attrs(XMLStyleSheet.new(*attrs), attrs) assert_xml_stylesheet_attrs(XMLStyleSheet.new(*attrs), attrs)
end end
end end
def test_to_s def test_to_s
[ [
{:href => "a.xsl", :type => "text/xsl"}, {:href => "a.xsl", :type => "text/xsl"},
{:type => "text/xsl"}, {:type => "text/xsl"},
{:href => "a.xsl", :guess_type => "text/xsl"}, {:href => "a.xsl", :guess_type => "text/xsl"},
{:href => "a.css", :type => "text/css"}, {:href => "a.css", :type => "text/css"},
{:href => "a.css", :type => "text/xsl", {:href => "a.css", :type => "text/xsl",
:guess_type => "text/css"}, :guess_type => "text/css"},
{:href => "a.xsl", :type => "text/xsl", {:href => "a.xsl", :type => "text/xsl",
:title => "sample", :media => "printer", :title => "sample", :media => "printer",
:charset => "UTF-8", :alternate => "yes"}, :charset => "UTF-8", :alternate => "yes"},
{:href => "a.css", :guess_type => "text/css", {:href => "a.css", :guess_type => "text/css",
:alternate => "no"}, :alternate => "no"},
{:type => "text/xsl", :title => "sample", {:type => "text/xsl", :title => "sample",
:media => "printer", :charset => "UTF-8", :media => "printer", :charset => "UTF-8",
:alternate => "yes"}, :alternate => "yes"},
].each do |attrs| ].each do |attrs|
target, contents = parse_pi(XMLStyleSheet.new(*attrs).to_s) target, contents = parse_pi(XMLStyleSheet.new(*attrs).to_s)
assert_xml_stylesheet(target, XMLStyleSheet.new(*contents), attrs) assert_xml_stylesheet(target, XMLStyleSheet.new(*contents), attrs)
end end
end end
def test_bad_alternate def test_bad_alternate
%w(a ___ ??? BAD_ALTERNATE).each do |value| %w(a ___ ??? BAD_ALTERNATE).each do |value|
xss = XMLStyleSheet.new xss = XMLStyleSheet.new
assert_raise(NotAvailableValueError) do assert_raise(NotAvailableValueError) do
xss.alternate = value xss.alternate = value
end end
xss.do_validate = false xss.do_validate = false
assert_nothing_raised do assert_nothing_raised do
xss.alternate = value xss.alternate = value
end end
assert_nil(xss.alternate) assert_nil(xss.alternate)
end end
end end
def test_parse def test_parse
[ [
[{:href => "a.xsl", :type => "text/xsl"},], [{:href => "a.xsl", :type => "text/xsl"},],
[{:media => "print", :title => "FOO"},], [{:media => "print", :title => "FOO"},],
[{:charset => "UTF-8", :alternate => "yes"},], [{:charset => "UTF-8", :alternate => "yes"},],
[{:href => "a.xsl", :type => "text/xsl"}, [{:href => "a.xsl", :type => "text/xsl"},
{:type => "text/xsl"}, {:type => "text/xsl"},
{:href => "a.xsl", :guess_type => "text/xsl"}, {:href => "a.xsl", :guess_type => "text/xsl"},
{:href => "a.css", :type => "text/css"}, {:href => "a.css", :type => "text/css"},
{:href => "a.css", :type => "text/xsl", {:href => "a.css", :type => "text/xsl",
:guess_type => "text/css"}, :guess_type => "text/css"},
{:href => "a.xsl", :type => "text/xsl", {:href => "a.xsl", :type => "text/xsl",
:title => "sample", :media => "printer", :title => "sample", :media => "printer",
:charset => "UTF-8", :alternate => "yes"}, :charset => "UTF-8", :alternate => "yes"},
{:href => "a.css", :guess_type => "text/css", {:href => "a.css", :guess_type => "text/css",
:alternate => "no"}, :alternate => "no"},
{:type => "text/xsl", :title => "sample", {:type => "text/xsl", :title => "sample",
:media => "printer", :charset => "UTF-8", :media => "printer", :charset => "UTF-8",
:alternate => "yes"},], :alternate => "yes"},],
].each do |xsss| ].each do |xsss|
doc = REXML::Document.new(make_sample_RDF) doc = REXML::Document.new(make_sample_RDF)
root = doc.root root = doc.root
xsss.each do |xss| xsss.each do |xss|
content = xss.collect do |key, name| content = xss.collect do |key, name|
%Q[#{key}="#{name}"] %Q[#{key}="#{name}"]
end.join(" ") end.join(" ")
pi = REXML::Instruction.new("xml-stylesheet", content) pi = REXML::Instruction.new("xml-stylesheet", content)
root.previous_sibling = pi root.previous_sibling = pi
end end
rss = Parser.parse(doc.to_s) rss = Parser.parse(doc.to_s)
have_href_xsss = xsss.find_all {|xss| xss.has_key?(:href)} have_href_xsss = xsss.find_all {|xss| xss.has_key?(:href)}
assert_equal(have_href_xsss.size, rss.xml_stylesheets.size) assert_equal(have_href_xsss.size, rss.xml_stylesheets.size)
rss.xml_stylesheets.each_with_index do |stylesheet, i| rss.xml_stylesheets.each_with_index do |stylesheet, i|
target, = parse_pi(stylesheet.to_s) target, = parse_pi(stylesheet.to_s)
assert_xml_stylesheet(target, stylesheet, have_href_xsss[i]) assert_xml_stylesheet(target, stylesheet, have_href_xsss[i])
end end
end end
end end
def parse_pi(pi) def parse_pi(pi)
/\A\s*<\?(\S+)([^(?:\?>)]+)\?>\s*\z/ =~ pi /\A\s*<\?(\S+)([^(?:\?>)]+)\?>\s*\z/ =~ pi
target = $1 target = $1
dummy = REXML::Document.new("<dummy #{$2}/>").root dummy = REXML::Document.new("<dummy #{$2}/>").root
contents = {} contents = {}
dummy.attributes.each do |name, value| dummy.attributes.each do |name, value|
contents[name] = value contents[name] = value
end end
[target, contents] [target, contents]
end end
end end
end end