github
/
ruby
зеркало из https://github.com/github/ruby.git
1
0
Форкнуть 0
Код Задачи Пакеты Проекты Релизы Вики Активность

Make rss library to the bundle gems 

[Feature #16485][ruby-core:96683]
This commit is contained in:
Hiroshi SHIBATA 2020-01-11 21:48:06 +09:00 коммит произвёл SHIBATA Hiroshi
Родитель c3ccf23d58
Коммит 83240f315a
92 изменённых файлов: 5 добавлений и 23496 удалений
Показать статистику Скачать Patch файл Скачать Diff файл Показать все файлы Свернуть все файлы

6
doc/maintainers.rdoc
Просмотреть файл

@ -239,10 +239,6 @@ Zachary Scott (zzak)
aycabta
https://github.com/ruby/reline
https://rubygems.org/gems/reline
[lib/rss.rb, lib/rss/*]
Kouhei Sutou (kou)
https://github.com/ruby/rss
https://rubygems.org/gems/rss
[lib/singleton.rb]
Yukihiro Matsumoto (matz)
https://github.com/ruby/singleton
@ -355,3 +351,5 @@ Zachary Scott (zzak)
https://github.com/ruby/xmlrpc
[rexml]
https://github.com/ruby/rexml
[rss]
https://github.com/ruby/rss

2
doc/standard_library.rdoc
Просмотреть файл

@ -80,7 +80,6 @@ Prime:: Prime numbers and factorization library
PStore:: Implements a file based persistence mechanism based on a Hash
Racc:: A LALR(1) parser generator written in Ruby.
RDoc:: Produces HTML and command-line documentation for Ruby
RSS:: Family of libraries that support various formats of XML "feeds"
Singleton:: Implementation of the Singleton pattern for Ruby
Timeout:: Auto-terminate potentially long-running operations in Ruby
Tracer:: Outputs a source level execution trace of a Ruby program
@ -119,3 +118,4 @@ Rake:: Ruby build program with capabilities similar to make
Test::Unit:: A compatibility layer for MiniTest
XMLRPC:: Remote Procedure Call over HTTP support for Ruby
REXML:: An XML toolkit for Ruby
RSS:: Family of libraries that support various formats of XML "feeds"

1
gems/bundled_gems
Просмотреть файл

@ -5,3 +5,4 @@ rake 13.0.1 https://github.com/ruby/rake
test-unit 3.3.4 https://github.com/test-unit/test-unit
xmlrpc 0.3.0 https://github.com/ruby/xmlrpc
rexml 3.2.3 https://github.com/ruby/rexml
rss 0.2.8 https://github.com/ruby/rss

462
lib/rss/0.9.rb
Просмотреть файл

@ -1,462 +0,0 @@
# frozen_string_literal: false
require_relative "parser"
module RSS
##
# = RSS 0.9 support
#
# RSS has three different versions. This module contains support for version
# 0.9.1[http://www.rssboard.org/rss-0-9-1-netscape].
#
# == Producing RSS 0.9
#
# Producing our own RSS feeds is easy as well. Let's make a very basic feed:
#
# require "rss"
#
# rss = RSS::Maker.make("0.91") do |maker|
# maker.channel.language = "en"
# maker.channel.author = "matz"
# maker.channel.updated = Time.now.to_s
# maker.channel.link = "http://www.ruby-lang.org/en/feeds/news.rss"
# maker.channel.title = "Example Feed"
# maker.channel.description = "A longer description of my feed."
# maker.image.url = "http://www.ruby-lang.org/images/logo.gif"
# maker.image.title = "An image"
# maker.items.new_item do |item|
# item.link = "http://www.ruby-lang.org/en/news/2010/12/25/ruby-1-9-2-p136-is-released/"
# item.title = "Ruby 1.9.2-p136 is released"
# item.updated = Time.now.to_s
# end
# end
#
# puts rss
#
# As you can see, this is a very Builder-like DSL. This code will spit out an
# RSS 0.9 feed with one item. If we needed a second item, we'd make another
# block with maker.items.new_item and build a second one.
module RSS09
NSPOOL = {}
ELEMENTS = []
def self.append_features(klass)
super
klass.install_must_call_validator('', "")
end
end
class Rss < Element
include RSS09
include RootElementMixin
%w(channel).each do |name|
install_have_child_element(name, "", nil)
end
attr_writer :feed_version
alias_method(:rss_version, :feed_version)
alias_method(:rss_version=, :feed_version=)
def initialize(feed_version, version=nil, encoding=nil, standalone=nil)
super
@feed_type = "rss"
end
def items
if @channel
@channel.items
else
[]
end
end
def image
if @channel
@channel.image
else
nil
end
end
def textinput
if @channel
@channel.textInput
else
nil
end
end
def setup_maker_elements(maker)
super
items.each do |item|
item.setup_maker(maker.items)
end
image.setup_maker(maker) if image
textinput.setup_maker(maker) if textinput
end
private
def _attrs
[
["version", true, "feed_version"],
]
end
class Channel < Element
include RSS09
[
["title", nil, :text],
["link", nil, :text],
["description", nil, :text],
["language", nil, :text],
["copyright", "?", :text],
["managingEditor", "?", :text],
["webMaster", "?", :text],
["rating", "?", :text],
["pubDate", "?", :date, :rfc822],
["lastBuildDate", "?", :date, :rfc822],
["docs", "?", :text],
["cloud", "?", :have_attribute],
["skipDays", "?", :have_child],
["skipHours", "?", :have_child],
["image", nil, :have_child],
["item", "*", :have_children],
["textInput", "?", :have_child],
].each do |name, occurs, type, *args|
__send__("install_#{type}_element", name, "", occurs, name, *args)
end
alias date pubDate
alias date= pubDate=
private
def maker_target(maker)
maker.channel
end
def setup_maker_elements(channel)
super
[
[skipDays, "day"],
[skipHours, "hour"],
].each do |skip, key|
if skip
skip.__send__("#{key}s").each do |val|
target_skips = channel.__send__("skip#{key.capitalize}s")
new_target = target_skips.__send__("new_#{key}")
new_target.content = val.content
end
end
end
end
def not_need_to_call_setup_maker_variables
%w(image textInput)
end
class SkipDays < Element
include RSS09
[
["day", "*"]
].each do |name, occurs|
install_have_children_element(name, "", occurs)
end
class Day < Element
include RSS09
content_setup
def initialize(*args)
if Utils.element_initialize_arguments?(args)
super
else
super()
self.content = args[0]
end
end
end
end
class SkipHours < Element
include RSS09
[
["hour", "*"]
].each do |name, occurs|
install_have_children_element(name, "", occurs)
end
class Hour < Element
include RSS09
content_setup(:integer)
def initialize(*args)
if Utils.element_initialize_arguments?(args)
super
else
super()
self.content = args[0]
end
end
end
end
class Image < Element
include RSS09
%w(url title link).each do |name|
install_text_element(name, "", nil)
end
[
["width", :integer],
["height", :integer],
["description"],
].each do |name, type|
install_text_element(name, "", "?", name, type)
end
def initialize(*args)
if Utils.element_initialize_arguments?(args)
super
else
super()
self.url = args[0]
self.title = args[1]
self.link = args[2]
self.width = args[3]
self.height = args[4]
self.description = args[5]
end
end
private
def maker_target(maker)
maker.image
end
end
class Cloud < Element
include RSS09
[
["domain", "", true],
["port", "", true, :integer],
["path", "", true],
["registerProcedure", "", true],
["protocol", "", true],
].each do |name, uri, required, type|
install_get_attribute(name, uri, required, type)
end
def initialize(*args)
if Utils.element_initialize_arguments?(args)
super
else
super()
self.domain = args[0]
self.port = args[1]
self.path = args[2]
self.registerProcedure = args[3]
self.protocol = args[4]
end
end
end
class Item < Element
include RSS09
[
["title", '?', :text],
["link", '?', :text],
["description", '?', :text],
["category", '*', :have_children, "categories"],
["source", '?', :have_child],
["enclosure", '?', :have_child],
].each do |tag, occurs, type, *args|
__send__("install_#{type}_element", tag, "", occurs, tag, *args)
end
private
def maker_target(items)
if items.respond_to?("items")
# For backward compatibility
items = items.items
end
items.new_item
end
def setup_maker_element(item)
super
@enclosure.setup_maker(item) if @enclosure
@source.setup_maker(item) if @source
end
class Source < Element
include RSS09
[
["url", "", true]
].each do |name, uri, required|
install_get_attribute(name, uri, required)
end
content_setup
def initialize(*args)
if Utils.element_initialize_arguments?(args)
super
else
super()
self.url = args[0]
self.content = args[1]
end
end
private
def maker_target(item)
item.source
end
def setup_maker_attributes(source)
source.url = url
source.content = content
end
end
class Enclosure < Element
include RSS09
[
["url", "", true],
["length", "", true, :integer],
["type", "", true],
].each do |name, uri, required, type|
install_get_attribute(name, uri, required, type)
end
def initialize(*args)
if Utils.element_initialize_arguments?(args)
super
else
super()
self.url = args[0]
self.length = args[1]
self.type = args[2]
end
end
private
def maker_target(item)
item.enclosure
end
def setup_maker_attributes(enclosure)
enclosure.url = url
enclosure.length = length
enclosure.type = type
end
end
class Category < Element
include RSS09
[
["domain", "", false]
].each do |name, uri, required|
install_get_attribute(name, uri, required)
end
content_setup
def initialize(*args)
if Utils.element_initialize_arguments?(args)
super
else
super()
self.domain = args[0]
self.content = args[1]
end
end
private
def maker_target(item)
item.new_category
end
def setup_maker_attributes(category)
category.domain = domain
category.content = content
end
end
end
class TextInput < Element
include RSS09
%w(title description name link).each do |name|
install_text_element(name, "", nil)
end
def initialize(*args)
if Utils.element_initialize_arguments?(args)
super
else
super()
self.title = args[0]
self.description = args[1]
self.name = args[2]
self.link = args[3]
end
end
private
def maker_target(maker)
maker.textinput
end
end
end
end
RSS09::ELEMENTS.each do |name|
BaseListener.install_get_text_element("", name, name)
end
module ListenerMixin
private
def initial_start_rss(tag_name, prefix, attrs, ns)
check_ns(tag_name, prefix, ns, "", false)
@rss = Rss.new(attrs['version'], @version, @encoding, @standalone)
@rss.do_validate = @do_validate
@rss.xml_stylesheets = @xml_stylesheets
@last_element = @rss
pr = Proc.new do |text, tags|
@rss.validate_for_stream(tags, @ignore_unknown_element) if @do_validate
end
@proc_stack.push(pr)
end
end
end

485
lib/rss/1.0.rb
Просмотреть файл

@ -1,485 +0,0 @@
# frozen_string_literal: false
require_relative "parser"
module RSS
##
# = RSS 1.0 support
#
# RSS has three different versions. This module contains support for version
# 1.0[http://web.resource.org/rss/1.0/]
#
# == Producing RSS 1.0
#
# Producing our own RSS feeds is easy as well. Let's make a very basic feed:
#
# require "rss"
#
# rss = RSS::Maker.make("1.0") do |maker|
# maker.channel.language = "en"
# maker.channel.author = "matz"
# maker.channel.about = "About my feed."
# maker.channel.updated = Time.now.to_s
# maker.channel.link = "http://www.ruby-lang.org/en/feeds/news.rss"
# maker.channel.title = "Example Feed"
# maker.channel.description = "A longer description of my feed."
# maker.items.new_item do |item|
# item.link = "http://www.ruby-lang.org/en/news/2010/12/25/ruby-1-9-2-p136-is-released/"
# item.title = "Ruby 1.9.2-p136 is released"
# item.updated = Time.now.to_s
# end
# end
#
# puts rss
#
# As you can see, this is a very Builder-like DSL. This code will spit out an
# RSS 1.0 feed with one item. If we needed a second item, we'd make another
# block with maker.items.new_item and build a second one.
module RSS10
NSPOOL = {}
ELEMENTS = []
def self.append_features(klass)
super
klass.install_must_call_validator('', ::RSS::URI)
end
end
class RDF < Element
include RSS10
include RootElementMixin
class << self
def required_uri
URI
end
end
@tag_name = 'RDF'
PREFIX = 'rdf'
URI = "http://www.w3.org/1999/02/22-rdf-syntax-ns#"
install_ns('', ::RSS::URI)
install_ns(PREFIX, URI)
[
["channel", nil],
["image", "?"],
["item", "+", :children],
["textinput", "?"],
].each do |tag, occurs, type|
type ||= :child
__send__("install_have_#{type}_element", tag, ::RSS::URI, occurs)
end
alias_method(:rss_version, :feed_version)
def initialize(version=nil, encoding=nil, standalone=nil)
super('1.0', version, encoding, standalone)
@feed_type = "rss"
end
def full_name
tag_name_with_prefix(PREFIX)
end
class Li < Element
include RSS10
class << self
def required_uri
URI
end
end
[
["resource", [URI, ""], true]
].each do |name, uri, required|
install_get_attribute(name, uri, required)
end
def initialize(*args)
if Utils.element_initialize_arguments?(args)
super
else
super()
self.resource = args[0]
end
end
def full_name
tag_name_with_prefix(PREFIX)
end
end
class Seq < Element
include RSS10
Li = ::RSS::RDF::Li
class << self
def required_uri
URI
end
end
@tag_name = 'Seq'
install_have_children_element("li", URI, "*")
install_must_call_validator('rdf', ::RSS::RDF::URI)
def initialize(*args)
if Utils.element_initialize_arguments?(args)
super
else
super()
@li = args[0] if args[0]
end
end
def full_name
tag_name_with_prefix(PREFIX)
end
def setup_maker(target)
lis.each do |li|
target << li.resource
end
end
end
class Bag < Element
include RSS10
Li = ::RSS::RDF::Li
class << self
def required_uri
URI
end
end
@tag_name = 'Bag'
install_have_children_element("li", URI, "*")
install_must_call_validator('rdf', URI)
def initialize(*args)
if Utils.element_initialize_arguments?(args)
super
else
super()
@li = args[0] if args[0]
end
end
def full_name
tag_name_with_prefix(PREFIX)
end
def setup_maker(target)
lis.each do |li|
target << li.resource
end
end
end
class Channel < Element
include RSS10
class << self
def required_uri
::RSS::URI
end
end
[
["about", URI, true]
].each do |name, uri, required|
install_get_attribute(name, uri, required, nil, nil,
"#{PREFIX}:#{name}")
end
[
['title', nil, :text],
['link', nil, :text],
['description', nil, :text],
['image', '?', :have_child],
['items', nil, :have_child],
['textinput', '?', :have_child],
].each do |tag, occurs, type|
__send__("install_#{type}_element", tag, ::RSS::URI, occurs)
end
def initialize(*args)
if Utils.element_initialize_arguments?(args)
super
else
super()
self.about = args[0]
end
end
private
def maker_target(maker)
maker.channel
end
def setup_maker_attributes(channel)
channel.about = about
end
class Image < Element
include RSS10
class << self
def required_uri
::RSS::URI
end
end
[
["resource", URI, true]
].each do |name, uri, required|
install_get_attribute(name, uri, required, nil, nil,
"#{PREFIX}:#{name}")
end
def initialize(*args)
if Utils.element_initialize_arguments?(args)
super
else
super()
self.resource = args[0]
end
end
end
class Textinput < Element
include RSS10
class << self
def required_uri
::RSS::URI
end
end
[
["resource", URI, true]
].each do |name, uri, required|
install_get_attribute(name, uri, required, nil, nil,
"#{PREFIX}:#{name}")
end
def initialize(*args)
if Utils.element_initialize_arguments?(args)
super
else
super()
self.resource = args[0]
end
end
end
class Items < Element
include RSS10
Seq = ::RSS::RDF::Seq
class << self
def required_uri
::RSS::URI
end
end
install_have_child_element("Seq", URI, nil)
install_must_call_validator('rdf', URI)
def initialize(*args)
if Utils.element_initialize_arguments?(args)
super
else
super()
self.Seq = args[0]
end
self.Seq ||= Seq.new
end
def resources
if @Seq
@Seq.lis.collect do |li|
li.resource
end
else
[]
end
end
end
end
class Image < Element
include RSS10
class << self
def required_uri
::RSS::URI
end
end
[
["about", URI, true]
].each do |name, uri, required|
install_get_attribute(name, uri, required, nil, nil,
"#{PREFIX}:#{name}")
end
%w(title url link).each do |name|
install_text_element(name, ::RSS::URI, nil)
end
def initialize(*args)
if Utils.element_initialize_arguments?(args)
super
else
super()
self.about = args[0]
end
end
private
def maker_target(maker)
maker.image
end
end
class Item < Element
include RSS10
class << self
def required_uri
::RSS::URI
end
end
[
["about", URI, true]
].each do |name, uri, required|
install_get_attribute(name, uri, required, nil, nil,
"#{PREFIX}:#{name}")
end
[
["title", nil],
["link", nil],
["description", "?"],
].each do |tag, occurs|
install_text_element(tag, ::RSS::URI, occurs)
end
def initialize(*args)
if Utils.element_initialize_arguments?(args)
super
else
super()
self.about = args[0]
end
end
private
def maker_target(items)
if items.respond_to?("items")
# For backward compatibility
items = items.items
end
items.new_item
end
end
class Textinput < Element
include RSS10
class << self
def required_uri
::RSS::URI
end
end
[
["about", URI, true]
].each do |name, uri, required|
install_get_attribute(name, uri, required, nil, nil,
"#{PREFIX}:#{name}")
end
%w(title description name link).each do |name|
install_text_element(name, ::RSS::URI, nil)
end
def initialize(*args)
if Utils.element_initialize_arguments?(args)
super
else
super()
self.about = args[0]
end
end
private
def maker_target(maker)
maker.textinput
end
end
end
RSS10::ELEMENTS.each do |name|
BaseListener.install_get_text_element(URI, name, name)
end
module ListenerMixin
private
def initial_start_RDF(tag_name, prefix, attrs, ns)
check_ns(tag_name, prefix, ns, RDF::URI, false)
@rss = RDF.new(@version, @encoding, @standalone)
@rss.do_validate = @do_validate
@rss.xml_stylesheets = @xml_stylesheets
@last_element = @rss
pr = Proc.new do |text, tags|
@rss.validate_for_stream(tags, @ignore_unknown_element) if @do_validate
end
@proc_stack.push(pr)
end
end
end

143
lib/rss/2.0.rb
Просмотреть файл

@ -1,143 +0,0 @@
# frozen_string_literal: false
require "rss/0.9"
module RSS
##
# = RSS 2.0 support
#
# RSS has three different versions. This module contains support for version
# 2.0[http://www.rssboard.org/rss-specification]
#
# == Producing RSS 2.0
#
# Producing our own RSS feeds is easy as well. Let's make a very basic feed:
#
# require "rss"
#
# rss = RSS::Maker.make("2.0") do |maker|
# maker.channel.language = "en"
# maker.channel.author = "matz"
# maker.channel.updated = Time.now.to_s
# maker.channel.link = "http://www.ruby-lang.org/en/feeds/news.rss"
# maker.channel.title = "Example Feed"
# maker.channel.description = "A longer description of my feed."
# maker.items.new_item do |item|
# item.link = "http://www.ruby-lang.org/en/news/2010/12/25/ruby-1-9-2-p136-is-released/"
# item.title = "Ruby 1.9.2-p136 is released"
# item.updated = Time.now.to_s
# end
# end
#
# puts rss
#
# As you can see, this is a very Builder-like DSL. This code will spit out an
# RSS 2.0 feed with one item. If we needed a second item, we'd make another
# block with maker.items.new_item and build a second one.
class Rss
class Channel
[
["generator"],
["ttl", :integer],
].each do |name, type|
install_text_element(name, "", "?", name, type)
end
[
%w(category categories),
].each do |name, plural_name|
install_have_children_element(name, "", "*", name, plural_name)
end
[
["image", "?"],
["language", "?"],
].each do |name, occurs|
install_model(name, "", occurs)
end
Category = Item::Category
class Item
[
["comments", "?"],
["author", "?"],
].each do |name, occurs|
install_text_element(name, "", occurs)
end
[
["pubDate", '?'],
].each do |name, occurs|
install_date_element(name, "", occurs, name, 'rfc822')
end
alias date pubDate
alias date= pubDate=
[
["guid", '?'],
].each do |name, occurs|
install_have_child_element(name, "", occurs)
end
private
alias _setup_maker_element setup_maker_element
def setup_maker_element(item)
_setup_maker_element(item)
@guid.setup_maker(item) if @guid
end
class Guid < Element
include RSS09
[
["isPermaLink", "", false, :boolean]
].each do |name, uri, required, type|
install_get_attribute(name, uri, required, type)
end
content_setup
def initialize(*args)
if Utils.element_initialize_arguments?(args)
super
else
super()
self.isPermaLink = args[0]
self.content = args[1]
end
end
alias_method :_PermaLink?, :PermaLink?
private :_PermaLink?
def PermaLink?
perma = _PermaLink?
perma or perma.nil?
end
private
def maker_target(item)
item.guid
end
def setup_maker_attributes(guid)
guid.isPermaLink = isPermaLink
guid.content = content
end
end
end
end
end
RSS09::ELEMENTS.each do |name|
BaseListener.install_get_text_element("", name, name)
end
end

1025
lib/rss/atom.rb
Просмотреть файл

Разница между файлами не показана из-за своего большого размера Загрузить разницу

34
lib/rss/content.rb
Просмотреть файл

@ -1,34 +0,0 @@
# frozen_string_literal: false
require_relative "rss"
module RSS
# The prefix for the Content XML namespace.
CONTENT_PREFIX = 'content'
# The URI of the Content specification.
CONTENT_URI = "http://purl.org/rss/1.0/modules/content/"
module ContentModel
extend BaseModel
ELEMENTS = ["#{CONTENT_PREFIX}_encoded"]
def self.append_features(klass)
super
klass.install_must_call_validator(CONTENT_PREFIX, CONTENT_URI)
ELEMENTS.each do |full_name|
name = full_name[(CONTENT_PREFIX.size + 1)..-1]
klass.install_text_element(name, CONTENT_URI, "?", full_name)
end
end
end
prefix_size = CONTENT_PREFIX.size + 1
ContentModel::ELEMENTS.each do |full_name|
name = full_name[prefix_size..-1]
BaseListener.install_get_text_element(CONTENT_URI, name, full_name)
end
end
require 'rss/content/1.0'
require 'rss/content/2.0'

10
lib/rss/content/1.0.rb
Просмотреть файл

@ -1,10 +0,0 @@
# frozen_string_literal: false
require 'rss/1.0'
module RSS
RDF.install_ns(CONTENT_PREFIX, CONTENT_URI)
class RDF
class Item; include ContentModel; end
end
end

12
lib/rss/content/2.0.rb
Просмотреть файл

@ -1,12 +0,0 @@
# frozen_string_literal: false
require "rss/2.0"
module RSS
Rss.install_ns(CONTENT_PREFIX, CONTENT_URI)
class Rss
class Channel
class Item; include ContentModel; end
end
end
end

171
lib/rss/converter.rb
Просмотреть файл

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

164
lib/rss/dublincore.rb
Просмотреть файл

@ -1,164 +0,0 @@
# frozen_string_literal: false
require_relative "rss"
module RSS
# The prefix for the Dublin Core XML namespace.
DC_PREFIX = 'dc'
# The URI of the Dublin Core specification.
DC_URI = "http://purl.org/dc/elements/1.1/"
module BaseDublinCoreModel
def append_features(klass)
super
return if klass.instance_of?(Module)
DublinCoreModel::ELEMENT_NAME_INFOS.each do |name, plural_name|
plural = plural_name || "#{name}s"
full_name = "#{DC_PREFIX}_#{name}"
full_plural_name = "#{DC_PREFIX}_#{plural}"
klass_name = "DublinCore#{Utils.to_class_name(name)}"
klass.install_must_call_validator(DC_PREFIX, DC_URI)
klass.install_have_children_element(name, DC_URI, "*",
full_name, full_plural_name)
klass.module_eval(<<-EOC, *get_file_and_line_from_caller(0))
remove_method :#{full_name}
remove_method :#{full_name}=
remove_method :set_#{full_name}
def #{full_name}
@#{full_name}.first and @#{full_name}.first.value
end
def #{full_name}=(new_value)
@#{full_name}[0] = Utils.new_with_value_if_need(#{klass_name}, new_value)
end
alias set_#{full_name} #{full_name}=
EOC
end
klass.module_eval(<<-EOC, *get_file_and_line_from_caller(0))
if method_defined?(:date)
alias date_without_#{DC_PREFIX}_date= date=
def date=(value)
self.date_without_#{DC_PREFIX}_date = value
self.#{DC_PREFIX}_date = value
end
else
alias date #{DC_PREFIX}_date
alias date= #{DC_PREFIX}_date=
end
# For backward compatibility
alias #{DC_PREFIX}_rightses #{DC_PREFIX}_rights_list
EOC
end
end
module DublinCoreModel
extend BaseModel
extend BaseDublinCoreModel
TEXT_ELEMENTS = {
"title" => nil,
"description" => nil,
"creator" => nil,
"subject" => nil,
"publisher" => nil,
"contributor" => nil,
"type" => nil,
"format" => nil,
"identifier" => nil,
"source" => nil,
"language" => nil,
"relation" => nil,
"coverage" => nil,
"rights" => "rights_list"
}
DATE_ELEMENTS = {
"date" => "w3cdtf",
}
ELEMENT_NAME_INFOS = DublinCoreModel::TEXT_ELEMENTS.to_a
DublinCoreModel::DATE_ELEMENTS.each do |name, |
ELEMENT_NAME_INFOS << [name, nil]
end
ELEMENTS = TEXT_ELEMENTS.keys + DATE_ELEMENTS.keys
ELEMENTS.each do |name, plural_name|
module_eval(<<-EOC, *get_file_and_line_from_caller(0))
class DublinCore#{Utils.to_class_name(name)} < Element
include RSS10
content_setup
class << self
def required_prefix
DC_PREFIX
end
def required_uri
DC_URI
end
end
@tag_name = #{name.dump}
alias_method(:value, :content)
alias_method(:value=, :content=)
def initialize(*args)
if Utils.element_initialize_arguments?(args)
super
else
super()
self.content = args[0]
end
end
def full_name
tag_name_with_prefix(DC_PREFIX)
end
def maker_target(target)
target.new_#{name}
end
def setup_maker_attributes(#{name})
#{name}.content = content
end
end
EOC
end
DATE_ELEMENTS.each do |name, type|
tag_name = "#{DC_PREFIX}:#{name}"
module_eval(<<-EOC, *get_file_and_line_from_caller(0))
class DublinCore#{Utils.to_class_name(name)} < Element
remove_method(:content=)
remove_method(:value=)
date_writer("content", #{type.dump}, #{tag_name.dump})
alias_method(:value=, :content=)
end
EOC
end
end
# For backward compatibility
DublincoreModel = DublinCoreModel
DublinCoreModel::ELEMENTS.each do |name|
class_name = Utils.to_class_name(name)
BaseListener.install_class_name(DC_URI, name, "DublinCore#{class_name}")
end
DublinCoreModel::ELEMENTS.collect! {|name| "#{DC_PREFIX}_#{name}"}
end
require 'rss/dublincore/1.0'
require 'rss/dublincore/2.0'
require_relative 'dublincore/atom'

13
lib/rss/dublincore/1.0.rb
Просмотреть файл

@ -1,13 +0,0 @@
# frozen_string_literal: false
require "rss/1.0"
module RSS
RDF.install_ns(DC_PREFIX, DC_URI)
class RDF
class Channel; include DublinCoreModel; end
class Image; include DublinCoreModel; end
class Item; include DublinCoreModel; end
class Textinput; include DublinCoreModel; end
end
end

13
lib/rss/dublincore/2.0.rb
Просмотреть файл

@ -1,13 +0,0 @@
# frozen_string_literal: false
require "rss/2.0"
module RSS
Rss.install_ns(DC_PREFIX, DC_URI)
class Rss
class Channel
include DublinCoreModel
class Item; include DublinCoreModel; end
end
end
end

17
lib/rss/dublincore/atom.rb
Просмотреть файл

@ -1,17 +0,0 @@
# frozen_string_literal: false
require_relative "../atom"
module RSS
module Atom
Feed.install_ns(DC_PREFIX, DC_URI)
class Feed
include DublinCoreModel
class Entry; include DublinCoreModel; end
end
class Entry
include DublinCoreModel
end
end
end

198
lib/rss/image.rb
Просмотреть файл

@ -1,198 +0,0 @@
# frozen_string_literal: false
require 'rss/1.0'
require_relative 'dublincore'
module RSS
# The prefix for the Image XML namespace.
IMAGE_PREFIX = 'image'
# The URI for the Image specification.
IMAGE_URI = 'http://purl.org/rss/1.0/modules/image/'
RDF.install_ns(IMAGE_PREFIX, IMAGE_URI)
# This constant holds strings which contain the names of
# image elements, with the appropriate prefix.
IMAGE_ELEMENTS = []
%w(item favicon).each do |name|
class_name = Utils.to_class_name(name)
BaseListener.install_class_name(IMAGE_URI, name, "Image#{class_name}")
IMAGE_ELEMENTS << "#{IMAGE_PREFIX}_#{name}"
end
module ImageModelUtils
def validate_one_tag_name(ignore_unknown_element, name, tags)
if !ignore_unknown_element
invalid = tags.find {|tag| tag != name}
raise UnknownTagError.new(invalid, IMAGE_URI) if invalid
end
raise TooMuchTagError.new(name, tag_name) if tags.size > 1
end
end
module ImageItemModel
include ImageModelUtils
extend BaseModel
def self.append_features(klass)
super
klass.install_have_child_element("item", IMAGE_URI, "?",
"#{IMAGE_PREFIX}_item")
klass.install_must_call_validator(IMAGE_PREFIX, IMAGE_URI)
end
class ImageItem < Element
include RSS10
include DublinCoreModel
@tag_name = "item"
class << self
def required_prefix
IMAGE_PREFIX
end
def required_uri
IMAGE_URI
end
end
install_must_call_validator(IMAGE_PREFIX, IMAGE_URI)
[
["about", ::RSS::RDF::URI, true],
["resource", ::RSS::RDF::URI, false],
].each do |name, uri, required|
install_get_attribute(name, uri, required, nil, nil,
"#{::RSS::RDF::PREFIX}:#{name}")
end
%w(width height).each do |tag|
full_name = "#{IMAGE_PREFIX}_#{tag}"
disp_name = "#{IMAGE_PREFIX}:#{tag}"
install_text_element(tag, IMAGE_URI, "?",
full_name, :integer, disp_name)
BaseListener.install_get_text_element(IMAGE_URI, tag, full_name)
end
alias width= image_width=
alias width image_width
alias height= image_height=
alias height image_height
def initialize(*args)
if Utils.element_initialize_arguments?(args)
super
else
super()
self.about = args[0]
self.resource = args[1]
end
end
def full_name
tag_name_with_prefix(IMAGE_PREFIX)
end
private
def maker_target(target)
target.image_item
end
def setup_maker_attributes(item)
item.about = self.about
item.resource = self.resource
end
end
end
module ImageFaviconModel
include ImageModelUtils
extend BaseModel
def self.append_features(klass)
super
unless klass.class == Module
klass.install_have_child_element("favicon", IMAGE_URI, "?",
"#{IMAGE_PREFIX}_favicon")
klass.install_must_call_validator(IMAGE_PREFIX, IMAGE_URI)
end
end
class ImageFavicon < Element
include RSS10
include DublinCoreModel
@tag_name = "favicon"
class << self
def required_prefix
IMAGE_PREFIX
end
def required_uri
IMAGE_URI
end
end
[
["about", ::RSS::RDF::URI, true, ::RSS::RDF::PREFIX],
["size", IMAGE_URI, true, IMAGE_PREFIX],
].each do |name, uri, required, prefix|
install_get_attribute(name, uri, required, nil, nil,
"#{prefix}:#{name}")
end
AVAILABLE_SIZES = %w(small medium large)
alias_method :set_size, :size=
private :set_size
def size=(new_value)
if @do_validate and !new_value.nil?
new_value = new_value.strip
unless AVAILABLE_SIZES.include?(new_value)
attr_name = "#{IMAGE_PREFIX}:size"
raise NotAvailableValueError.new(full_name, new_value, attr_name)
end
end
set_size(new_value)
end
alias image_size= size=
alias image_size size
def initialize(*args)
if Utils.element_initialize_arguments?(args)
super
else
super()
self.about = args[0]
self.size = args[1]
end
end
def full_name
tag_name_with_prefix(IMAGE_PREFIX)
end
private
def maker_target(target)
target.image_favicon
end
def setup_maker_attributes(favicon)
favicon.about = self.about
favicon.size = self.size
end
end
end
class RDF
class Channel; include ImageFaviconModel; end
class Item; include ImageItemModel; end
end
end

425
lib/rss/itunes.rb
Просмотреть файл

@ -1,425 +0,0 @@
# frozen_string_literal: false
require 'rss/2.0'
module RSS
# The prefix for the iTunes XML namespace.
ITUNES_PREFIX = 'itunes'
# The URI of the iTunes specification.
ITUNES_URI = 'http://www.itunes.com/dtds/podcast-1.0.dtd'
Rss.install_ns(ITUNES_PREFIX, ITUNES_URI)
module ITunesModelUtils
include Utils
def def_class_accessor(klass, name, type, *args)
normalized_name = name.gsub(/-/, "_")
full_name = "#{ITUNES_PREFIX}_#{normalized_name}"
klass_name = "ITunes#{Utils.to_class_name(normalized_name)}"
case type
when :element, :attribute
klass::ELEMENTS << full_name
def_element_class_accessor(klass, name, full_name, klass_name, *args)
when :elements
klass::ELEMENTS << full_name
def_elements_class_accessor(klass, name, full_name, klass_name, *args)
else
klass.install_must_call_validator(ITUNES_PREFIX, ITUNES_URI)
klass.install_text_element(normalized_name, ITUNES_URI, "?",
full_name, type, name)
end
end
def def_element_class_accessor(klass, name, full_name, klass_name,
recommended_attribute_name=nil)
klass.install_have_child_element(name, ITUNES_PREFIX, "?", full_name)
end
def def_elements_class_accessor(klass, name, full_name, klass_name,
plural_name, recommended_attribute_name=nil)
full_plural_name = "#{ITUNES_PREFIX}_#{plural_name}"
klass.install_have_children_element(name, ITUNES_PREFIX, "*",
full_name, full_plural_name)
end
end
module ITunesBaseModel
extend ITunesModelUtils
ELEMENTS = []
ELEMENT_INFOS = [["author"],
["block", :yes_other],
["explicit", :explicit_clean_other],
["keywords", :csv],
["subtitle"],
["summary"]]
end
module ITunesChannelModel
extend BaseModel
extend ITunesModelUtils
include ITunesBaseModel
ELEMENTS = []
class << self
def append_features(klass)
super
return if klass.instance_of?(Module)
ELEMENT_INFOS.each do |name, type, *additional_infos|
def_class_accessor(klass, name, type, *additional_infos)
end
end
end
ELEMENT_INFOS = [
["category", :elements, "categories", "text"],
["image", :attribute, "href"],
["owner", :element],
["new-feed-url"],
] + ITunesBaseModel::ELEMENT_INFOS
class ITunesCategory < Element
include RSS09
@tag_name = "category"
class << self
def required_prefix
ITUNES_PREFIX
end
def required_uri
ITUNES_URI
end
end
[
["text", "", true]
].each do |name, uri, required|
install_get_attribute(name, uri, required)
end
ITunesCategory = self
install_have_children_element("category", ITUNES_URI, "*",
"#{ITUNES_PREFIX}_category",
"#{ITUNES_PREFIX}_categories")
def initialize(*args)
if Utils.element_initialize_arguments?(args)
super
else
super()
self.text = args[0]
end
end
def full_name
tag_name_with_prefix(ITUNES_PREFIX)
end
private
def maker_target(categories)
if text or !itunes_categories.empty?
categories.new_category
else
nil
end
end
def setup_maker_attributes(category)
category.text = text if text
end
def setup_maker_elements(category)
super(category)
itunes_categories.each do |sub_category|
sub_category.setup_maker(category)
end
end
end
class ITunesImage < Element
include RSS09
@tag_name = "image"
class << self
def required_prefix
ITUNES_PREFIX
end
def required_uri
ITUNES_URI
end
end
[
["href", "", true]
].each do |name, uri, required|
install_get_attribute(name, uri, required)
end
def initialize(*args)
if Utils.element_initialize_arguments?(args)
super
else
super()
self.href = args[0]
end
end
def full_name
tag_name_with_prefix(ITUNES_PREFIX)
end
private
def maker_target(target)
if href
target.itunes_image {|image| image}
else
nil
end
end
def setup_maker_attributes(image)
image.href = href
end
end
class ITunesOwner < Element
include RSS09
@tag_name = "owner"
class << self
def required_prefix
ITUNES_PREFIX
end
def required_uri
ITUNES_URI
end
end
install_must_call_validator(ITUNES_PREFIX, ITUNES_URI)
[
["name"],
["email"],
].each do |name,|
ITunesBaseModel::ELEMENT_INFOS << name
install_text_element(name, ITUNES_URI, nil, "#{ITUNES_PREFIX}_#{name}")
end
def initialize(*args)
if Utils.element_initialize_arguments?(args)
super
else
super()
self.itunes_name = args[0]
self.itunes_email = args[1]
end
end
def full_name
tag_name_with_prefix(ITUNES_PREFIX)
end
private
def maker_target(target)
target.itunes_owner
end
def setup_maker_element(owner)
super(owner)
owner.itunes_name = itunes_name
owner.itunes_email = itunes_email
end
end
end
module ITunesItemModel
extend BaseModel
extend ITunesModelUtils
include ITunesBaseModel
class << self
def append_features(klass)
super
return if klass.instance_of?(Module)
ELEMENT_INFOS.each do |name, type|
def_class_accessor(klass, name, type)
end
end
end
ELEMENT_INFOS = ITunesBaseModel::ELEMENT_INFOS +
[["duration", :element, "content"]]
class ITunesDuration < Element
include RSS09
@tag_name = "duration"
class << self
def required_prefix
ITUNES_PREFIX
end
def required_uri
ITUNES_URI
end
def parse(duration, do_validate=true)
if do_validate and /\A(?:
\d?\d:[0-5]\d:[0-5]\d|
[0-5]?\d:[0-5]\d|
\d+
)\z/x !~ duration
raise ArgumentError,
"must be one of HH:MM:SS, H:MM:SS, MM:SS, M:SS, S+: " +
duration.inspect
end
if duration.include?(':')
components = duration.split(':')
components[3..-1] = nil if components.size > 3
components.unshift("00") until components.size == 3
components.collect do |component|
component.to_i
end
else
seconds_to_components(duration.to_i)
end
end
def construct(hours, minutes, seconds)
components = [minutes, seconds]
if components.include?(nil)
nil
else
components.unshift(hours) if hours and hours > 0
components.collect do |component|
"%02d" % component
end.join(':')
end
end
private
def seconds_to_components(total_seconds)
hours = total_seconds / (60 * 60)
minutes = (total_seconds / 60) % 60
seconds = total_seconds % 60
[hours, minutes, seconds]
end
end
content_setup
alias_method(:value, :content)
remove_method(:content=)
attr_reader :hour, :minute, :second
def initialize(*args)
if Utils.element_initialize_arguments?(args)
super
else
super()
args = args[0] if args.size == 1 and args[0].is_a?(Array)
if args.size == 1
self.content = args[0]
elsif args.size > 3
raise ArgumentError,
"must be (do_validate, params), (content), " +
"(minute, second), ([minute, second]), " +
"(hour, minute, second) or ([hour, minute, second]): " +
args.inspect
else
@second, @minute, @hour = args.reverse
update_content
end
end
end
def content=(value)
if value.nil?
@content = nil
elsif value.is_a?(self.class)
self.content = value.content
else
begin
@hour, @minute, @second = self.class.parse(value, @do_validate)
rescue ArgumentError
raise NotAvailableValueError.new(tag_name, value)
end
@content = value
end
end
alias_method(:value=, :content=)
def hour=(hour)
@hour = @do_validate ? Integer(hour) : hour.to_i
update_content
hour
end
def minute=(minute)
@minute = @do_validate ? Integer(minute) : minute.to_i
update_content
minute
end
def second=(second)
@second = @do_validate ? Integer(second) : second.to_i
update_content
second
end
def full_name
tag_name_with_prefix(ITUNES_PREFIX)
end
private
def update_content
@content = self.class.construct(hour, minute, second)
end
def maker_target(target)
if @content
target.itunes_duration {|duration| duration}
else
nil
end
end
def setup_maker_element(duration)
super(duration)
duration.content = @content
end
end
end
class Rss
class Channel
include ITunesChannelModel
class Item; include ITunesItemModel; end
end
end
element_infos =
ITunesChannelModel::ELEMENT_INFOS + ITunesItemModel::ELEMENT_INFOS
element_infos.each do |name, type|
case type
when :element, :elements, :attribute
class_name = Utils.to_class_name(name)
BaseListener.install_class_name(ITUNES_URI, name, "ITunes#{class_name}")
else
accessor_base = "#{ITUNES_PREFIX}_#{name.gsub(/-/, '_')}"
BaseListener.install_get_text_element(ITUNES_URI, name, accessor_base)
end
end
end

79
lib/rss/maker.rb
Просмотреть файл

@ -1,79 +0,0 @@
# frozen_string_literal: false
require_relative "rss"
module RSS
##
#
# Provides a set of builders for various RSS objects
#
# * Feeds
# * RSS 0.91
# * RSS 1.0
# * RSS 2.0
# * Atom 1.0
#
# * Elements
# * Atom::Entry
module Maker
# Collection of supported makers
MAKERS = {}
class << self
# Builder for an RSS object
# Creates an object of the type passed in +args+
#
# Executes the +block+ to populate elements of the created RSS object
def make(version, &block)
self[version].make(&block)
end
# Returns the maker for the +version+
def [](version)
maker_info = maker(version)
raise UnsupportedMakerVersionError.new(version) if maker_info.nil?
maker_info[:maker]
end
# Adds a maker to the set of supported makers
def add_maker(version, normalized_version, maker)
MAKERS[version] = {:maker => maker, :version => normalized_version}
end
# Returns collection of supported maker versions
def versions
MAKERS.keys.uniq.sort
end
# Returns collection of supported makers
def makers
MAKERS.values.collect { |info| info[:maker] }.uniq
end
# Returns true if the version is supported
def supported?(version)
versions.include?(version)
end
private
# Can I remove this method?
def maker(version)
MAKERS[version]
end
end
end
end
require_relative "maker/1.0"
require_relative "maker/2.0"
require_relative "maker/feed"
require_relative "maker/entry"
require_relative "maker/content"
require_relative "maker/dublincore"
require_relative "maker/slash"
require_relative "maker/syndication"
require_relative "maker/taxonomy"
require_relative "maker/trackback"
require_relative "maker/image"
require_relative "maker/itunes"

509
lib/rss/maker/0.9.rb
Просмотреть файл

@ -1,509 +0,0 @@
# frozen_string_literal: false
require_relative "../0.9"
require_relative "base"
module RSS
module Maker
class RSS09 < RSSBase
def initialize(feed_version)
super
@feed_type = "rss"
end
private
def make_feed
Rss.new(@feed_version, @version, @encoding, @standalone)
end
def setup_elements(rss)
setup_channel(rss)
end
class Channel < ChannelBase
def to_feed(rss)
channel = Rss::Channel.new
setup_values(channel)
_not_set_required_variables = not_set_required_variables
if _not_set_required_variables.empty?
rss.channel = channel
set_parent(channel, rss)
setup_items(rss)
setup_image(rss)
setup_textinput(rss)
setup_other_elements(rss, channel)
rss
else
raise NotSetError.new("maker.channel", _not_set_required_variables)
end
end
private
def setup_items(rss)
@maker.items.to_feed(rss)
end
def setup_image(rss)
@maker.image.to_feed(rss)
end
def setup_textinput(rss)
@maker.textinput.to_feed(rss)
end
def variables
super + ["pubDate"]
end
def required_variable_names
%w(link language)
end
def not_set_required_variables
vars = super
vars << "description" unless description {|d| d.have_required_values?}
vars << "title" unless title {|t| t.have_required_values?}
vars
end
class SkipDays < SkipDaysBase
def to_feed(rss, channel)
unless @days.empty?
skipDays = Rss::Channel::SkipDays.new
channel.skipDays = skipDays
set_parent(skipDays, channel)
@days.each do |day|
day.to_feed(rss, skipDays.days)
end
end
end
class Day < DayBase
def to_feed(rss, days)
day = Rss::Channel::SkipDays::Day.new
set = setup_values(day)
if set
days << day
set_parent(day, days)
setup_other_elements(rss, day)
end
end
private
def required_variable_names
%w(content)
end
end
end
class SkipHours < SkipHoursBase
def to_feed(rss, channel)
unless @hours.empty?
skipHours = Rss::Channel::SkipHours.new
channel.skipHours = skipHours
set_parent(skipHours, channel)
@hours.each do |hour|
hour.to_feed(rss, skipHours.hours)
end
end
end
class Hour < HourBase
def to_feed(rss, hours)
hour = Rss::Channel::SkipHours::Hour.new
set = setup_values(hour)
if set
hours << hour
set_parent(hour, hours)
setup_other_elements(rss, hour)
end
end
private
def required_variable_names
%w(content)
end
end
end
class Cloud < CloudBase
def to_feed(*args)
end
end
class Categories < CategoriesBase
def to_feed(*args)
end
class Category < CategoryBase
end
end
class Links < LinksBase
def to_feed(rss, channel)
return if @links.empty?
@links.first.to_feed(rss, channel)
end
class Link < LinkBase
def to_feed(rss, channel)
if have_required_values?
channel.link = href
else
raise NotSetError.new("maker.channel.link",
not_set_required_variables)
end
end
private
def required_variable_names
%w(href)
end
end
end
class Authors < AuthorsBase
def to_feed(rss, channel)
end
class Author < AuthorBase
def to_feed(rss, channel)
end
end
end
class Contributors < ContributorsBase
def to_feed(rss, channel)
end
class Contributor < ContributorBase
end
end
class Generator < GeneratorBase
def to_feed(rss, channel)
end
end
class Copyright < CopyrightBase
def to_feed(rss, channel)
channel.copyright = content if have_required_values?
end
private
def required_variable_names
%w(content)
end
end
class Description < DescriptionBase
def to_feed(rss, channel)
channel.description = content if have_required_values?
end
private
def required_variable_names
%w(content)
end
end
class Title < TitleBase
def to_feed(rss, channel)
channel.title = content if have_required_values?
end
private
def required_variable_names
%w(content)
end
end
end
class Image < ImageBase
def to_feed(rss)
image = Rss::Channel::Image.new
set = setup_values(image)
if set
image.link = link
rss.channel.image = image
set_parent(image, rss.channel)
setup_other_elements(rss, image)
elsif required_element?
raise NotSetError.new("maker.image", not_set_required_variables)
end
end
private
def required_variable_names
%w(url title link)
end
def required_element?
true
end
end
class Items < ItemsBase
def to_feed(rss)
if rss.channel
normalize.each do |item|
item.to_feed(rss)
end
setup_other_elements(rss, rss.items)
end
end
class Item < ItemBase
def to_feed(rss)
item = Rss::Channel::Item.new
setup_values(item)
_not_set_required_variables = not_set_required_variables
if _not_set_required_variables.empty?
rss.items << item
set_parent(item, rss.channel)
setup_other_elements(rss, item)
elsif variable_is_set?
raise NotSetError.new("maker.items", _not_set_required_variables)
end
end
private
def required_variable_names
[]
end
def not_set_required_variables
vars = super
if @maker.feed_version == "0.91"
vars << "title" unless title {|t| t.have_required_values?}
vars << "link" unless link
end
vars
end
class Guid < GuidBase
def to_feed(*args)
end
end
class Enclosure < EnclosureBase
def to_feed(*args)
end
end
class Source < SourceBase
def to_feed(*args)
end
class Authors < AuthorsBase
def to_feed(*args)
end
class Author < AuthorBase
end
end
class Categories < CategoriesBase
def to_feed(*args)
end
class Category < CategoryBase
end
end
class Contributors < ContributorsBase
def to_feed(*args)
end
class Contributor < ContributorBase
end
end
class Generator < GeneratorBase
def to_feed(*args)
end
end
class Icon < IconBase
def to_feed(*args)
end
end
class Links < LinksBase
def to_feed(*args)
end
class Link < LinkBase
end
end
class Logo < LogoBase
def to_feed(*args)
end
end
class Rights < RightsBase
def to_feed(*args)
end
end
class Subtitle < SubtitleBase
def to_feed(*args)
end
end
class Title < TitleBase
def to_feed(*args)
end
end
end
class Categories < CategoriesBase
def to_feed(*args)
end
class Category < CategoryBase
end
end
class Authors < AuthorsBase
def to_feed(*args)
end
class Author < AuthorBase
end
end
class Links < LinksBase
def to_feed(rss, item)
return if @links.empty?
@links.first.to_feed(rss, item)
end
class Link < LinkBase
def to_feed(rss, item)
if have_required_values?
item.link = href
else
raise NotSetError.new("maker.link",
not_set_required_variables)
end
end
private
def required_variable_names
%w(href)
end
end
end
class Contributors < ContributorsBase
def to_feed(rss, item)
end
class Contributor < ContributorBase
end
end
class Rights < RightsBase
def to_feed(rss, item)
end
end
class Description < DescriptionBase
def to_feed(rss, item)
item.description = content if have_required_values?
end
private
def required_variable_names
%w(content)
end
end
class Content < ContentBase
def to_feed(rss, item)
end
end
class Title < TitleBase
def to_feed(rss, item)
item.title = content if have_required_values?
end
private
def required_variable_names
%w(content)
end
end
end
end
class Textinput < TextinputBase
def to_feed(rss)
textInput = Rss::Channel::TextInput.new
set = setup_values(textInput)
if set
rss.channel.textInput = textInput
set_parent(textInput, rss.channel)
setup_other_elements(rss, textInput)
end
end
private
def required_variable_names
%w(title description name link)
end
end
end
class RSS091 < RSS09
def initialize(feed_version="0.91")
super
end
class Channel < RSS09::Channel
end
class Items < RSS09::Items
class Item < RSS09::Items::Item
end
end
class Image < RSS09::Image
end
class Textinput < RSS09::Textinput
end
end
class RSS092 < RSS09
def initialize(feed_version="0.92")
super
end
class Channel < RSS09::Channel
end
class Items < RSS09::Items
class Item < RSS09::Items::Item
end
end
class Image < RSS09::Image
end
class Textinput < RSS09::Textinput
end
end
add_maker("0.9", "0.92", RSS092)
add_maker("0.91", "0.91", RSS091)
add_maker("0.92", "0.92", RSS092)
add_maker("rss0.9", "0.92", RSS092)
add_maker("rss0.91", "0.91", RSS091)
add_maker("rss0.92", "0.92", RSS092)
end
end

436
lib/rss/maker/1.0.rb
Просмотреть файл

@ -1,436 +0,0 @@
# frozen_string_literal: false
require_relative "../1.0"
require_relative "base"
module RSS
module Maker
class RSS10 < RSSBase
def initialize(feed_version="1.0")
super
@feed_type = "rss"
end
private
def make_feed
RDF.new(@version, @encoding, @standalone)
end
def setup_elements(rss)
setup_channel(rss)
setup_image(rss)
setup_items(rss)
setup_textinput(rss)
end
class Channel < ChannelBase
include SetupDefaultLanguage
def to_feed(rss)
set_default_values do
_not_set_required_variables = not_set_required_variables
if _not_set_required_variables.empty?
channel = RDF::Channel.new(@about)
setup_values(channel)
channel.dc_dates.clear
rss.channel = channel
set_parent(channel, rss)
setup_items(rss)
setup_image(rss)
setup_textinput(rss)
setup_other_elements(rss, channel)
else
raise NotSetError.new("maker.channel", _not_set_required_variables)
end
end
end
private
def setup_items(rss)
items = RDF::Channel::Items.new
seq = items.Seq
set_parent(items, seq)
target_items = @maker.items.normalize
raise NotSetError.new("maker", ["items"]) if target_items.empty?
target_items.each do |item|
li = RDF::Channel::Items::Seq::Li.new(item.link)
seq.lis << li
set_parent(li, seq)
end
rss.channel.items = items
set_parent(rss.channel, items)
end
def setup_image(rss)
if @maker.image.have_required_values?
image = RDF::Channel::Image.new(@maker.image.url)
rss.channel.image = image
set_parent(image, rss.channel)
end
end
def setup_textinput(rss)
if @maker.textinput.have_required_values?
textinput = RDF::Channel::Textinput.new(@maker.textinput.link)
rss.channel.textinput = textinput
set_parent(textinput, rss.channel)
end
end
def required_variable_names
%w(about link)
end
def not_set_required_variables
vars = super
vars << "description" unless description {|d| d.have_required_values?}
vars << "title" unless title {|t| t.have_required_values?}
vars
end
class SkipDays < SkipDaysBase
def to_feed(*args)
end
class Day < DayBase
end
end
class SkipHours < SkipHoursBase
def to_feed(*args)
end
class Hour < HourBase
end
end
class Cloud < CloudBase
def to_feed(*args)
end
end
class Categories < CategoriesBase
def to_feed(*args)
end
class Category < CategoryBase
end
end
class Links < LinksBase
def to_feed(rss, channel)
return if @links.empty?
@links.first.to_feed(rss, channel)
end
class Link < LinkBase
def to_feed(rss, channel)
if have_required_values?
channel.link = href
else
raise NotSetError.new("maker.channel.link",
not_set_required_variables)
end
end
private
def required_variable_names
%w(href)
end
end
end
class Authors < AuthorsBase
def to_feed(rss, channel)
end
class Author < AuthorBase
def to_feed(rss, channel)
end
end
end
class Contributors < ContributorsBase
def to_feed(rss, channel)
end
class Contributor < ContributorBase
end
end
class Generator < GeneratorBase
def to_feed(rss, channel)
end
end
class Copyright < CopyrightBase
def to_feed(rss, channel)
end
end
class Description < DescriptionBase
def to_feed(rss, channel)
channel.description = content if have_required_values?
end
private
def required_variable_names
%w(content)
end
end
class Title < TitleBase
def to_feed(rss, channel)
channel.title = content if have_required_values?
end
private
def required_variable_names
%w(content)
end
end
end
class Image < ImageBase
def to_feed(rss)
if @url
image = RDF::Image.new(@url)
set = setup_values(image)
if set
rss.image = image
set_parent(image, rss)
setup_other_elements(rss, image)
end
end
end
def have_required_values?
super and @maker.channel.have_required_values?
end
private
def variables
super + ["link"]
end
def required_variable_names
%w(url title link)
end
end
class Items < ItemsBase
def to_feed(rss)
if rss.channel
normalize.each do |item|
item.to_feed(rss)
end
setup_other_elements(rss, rss.items)
end
end
class Item < ItemBase
def to_feed(rss)
set_default_values do
item = RDF::Item.new(link)
set = setup_values(item)
if set
item.dc_dates.clear
rss.items << item
set_parent(item, rss)
setup_other_elements(rss, item)
elsif !have_required_values?
raise NotSetError.new("maker.item", not_set_required_variables)
end
end
end
private
def required_variable_names
%w(link)
end
def variables
super + %w(link)
end
def not_set_required_variables
set_default_values do
vars = super
vars << "title" unless title {|t| t.have_required_values?}
vars
end
end
class Guid < GuidBase
def to_feed(*args)
end
end
class Enclosure < EnclosureBase
def to_feed(*args)
end
end
class Source < SourceBase
def to_feed(*args)
end
class Authors < AuthorsBase
def to_feed(*args)
end
class Author < AuthorBase
end
end
class Categories < CategoriesBase
def to_feed(*args)
end
class Category < CategoryBase
end
end
class Contributors < ContributorsBase
def to_feed(*args)
end
class Contributor < ContributorBase
end
end
class Generator < GeneratorBase
def to_feed(*args)
end
end
class Icon < IconBase
def to_feed(*args)
end
end
class Links < LinksBase
def to_feed(*args)
end
class Link < LinkBase
end
end
class Logo < LogoBase
def to_feed(*args)
end
end
class Rights < RightsBase
def to_feed(*args)
end
end
class Subtitle < SubtitleBase
def to_feed(*args)
end
end
class Title < TitleBase
def to_feed(*args)
end
end
end
class Categories < CategoriesBase
def to_feed(*args)
end
class Category < CategoryBase
end
end
class Authors < AuthorsBase
def to_feed(*args)
end
class Author < AuthorBase
end
end
class Links < LinksBase
def to_feed(*args)
end
class Link < LinkBase
end
end
class Contributors < ContributorsBase
def to_feed(rss, item)
end
class Contributor < ContributorBase
end
end
class Rights < RightsBase
def to_feed(rss, item)
end
end
class Description < DescriptionBase
def to_feed(rss, item)
item.description = content if have_required_values?
end
private
def required_variable_names
%w(content)
end
end
class Content < ContentBase
def to_feed(rss, item)
end
end
class Title < TitleBase
def to_feed(rss, item)
item.title = content if have_required_values?
end
private
def required_variable_names
%w(content)
end
end
end
end
class Textinput < TextinputBase
def to_feed(rss)
if @link
textinput = RDF::Textinput.new(@link)
set = setup_values(textinput)
if set
rss.textinput = textinput
set_parent(textinput, rss)
setup_other_elements(rss, textinput)
end
end
end
def have_required_values?
super and @maker.channel.have_required_values?
end
private
def required_variable_names
%w(title description name link)
end
end
end
add_maker("1.0", "1.0", RSS10)
add_maker("rss1.0", "1.0", RSS10)
end
end

224
lib/rss/maker/2.0.rb
Просмотреть файл

@ -1,224 +0,0 @@
# frozen_string_literal: false
require_relative "../2.0"
require_relative "0.9"
module RSS
module Maker
class RSS20 < RSS09
def initialize(feed_version="2.0")
super
end
class Channel < RSS09::Channel
private
def required_variable_names
%w(link)
end
class SkipDays < RSS09::Channel::SkipDays
class Day < RSS09::Channel::SkipDays::Day
end
end
class SkipHours < RSS09::Channel::SkipHours
class Hour < RSS09::Channel::SkipHours::Hour
end
end
class Cloud < RSS09::Channel::Cloud
def to_feed(rss, channel)
cloud = Rss::Channel::Cloud.new
set = setup_values(cloud)
if set
channel.cloud = cloud
set_parent(cloud, channel)
setup_other_elements(rss, cloud)
end
end
private
def required_variable_names
%w(domain port path registerProcedure protocol)
end
end
class Categories < RSS09::Channel::Categories
def to_feed(rss, channel)
@categories.each do |category|
category.to_feed(rss, channel)
end
end
class Category < RSS09::Channel::Categories::Category
def to_feed(rss, channel)
category = Rss::Channel::Category.new
set = setup_values(category)
if set
channel.categories << category
set_parent(category, channel)
setup_other_elements(rss, category)
end
end
private
def required_variable_names
%w(content)
end
end
end
class Generator < GeneratorBase
def to_feed(rss, channel)
channel.generator = content
end
private
def required_variable_names
%w(content)
end
end
end
class Image < RSS09::Image
private
def required_element?
false
end
end
class Items < RSS09::Items
class Item < RSS09::Items::Item
private
def required_variable_names
[]
end
def not_set_required_variables
vars = super
if !title {|t| t.have_required_values?} and
!description {|d| d.have_required_values?}
vars << "title or description"
end
vars
end
def variables
super + ["pubDate"]
end
class Guid < RSS09::Items::Item::Guid
def to_feed(rss, item)
guid = Rss::Channel::Item::Guid.new
set = setup_values(guid)
if set
item.guid = guid
set_parent(guid, item)
setup_other_elements(rss, guid)
end
end
private
def required_variable_names
%w(content)
end
end
class Enclosure < RSS09::Items::Item::Enclosure
def to_feed(rss, item)
enclosure = Rss::Channel::Item::Enclosure.new
set = setup_values(enclosure)
if set
item.enclosure = enclosure
set_parent(enclosure, item)
setup_other_elements(rss, enclosure)
end
end
private
def required_variable_names
%w(url length type)
end
end
class Source < RSS09::Items::Item::Source
def to_feed(rss, item)
source = Rss::Channel::Item::Source.new
set = setup_values(source)
if set
item.source = source
set_parent(source, item)
setup_other_elements(rss, source)
end
end
private
def required_variable_names
%w(url content)
end
class Links < RSS09::Items::Item::Source::Links
def to_feed(rss, source)
return if @links.empty?
@links.first.to_feed(rss, source)
end
class Link < RSS09::Items::Item::Source::Links::Link
def to_feed(rss, source)
source.url = href
end
end
end
end
class Categories < RSS09::Items::Item::Categories
def to_feed(rss, item)
@categories.each do |category|
category.to_feed(rss, item)
end
end
class Category < RSS09::Items::Item::Categories::Category
def to_feed(rss, item)
category = Rss::Channel::Item::Category.new
set = setup_values(category)
if set
item.categories << category
set_parent(category, item)
setup_other_elements(rss)
end
end
private
def required_variable_names
%w(content)
end
end
end
class Authors < RSS09::Items::Item::Authors
def to_feed(rss, item)
return if @authors.empty?
@authors.first.to_feed(rss, item)
end
class Author < RSS09::Items::Item::Authors::Author
def to_feed(rss, item)
item.author = name
end
end
end
end
end
class Textinput < RSS09::Textinput
end
end
add_maker("2.0", "2.0", RSS20)
add_maker("rss2.0", "2.0", RSS20)
end
end

173
lib/rss/maker/atom.rb
Просмотреть файл

@ -1,173 +0,0 @@
# frozen_string_literal: false
require_relative "../atom"
require_relative "base"
module RSS
module Maker
module AtomPersons
module_function
def def_atom_persons(klass, name, maker_name, plural=nil)
plural ||= "#{name}s"
klass_name = Utils.to_class_name(name)
plural_klass_name = Utils.to_class_name(plural)
klass.class_eval(<<-EOC, __FILE__, __LINE__ + 1)
class #{plural_klass_name} < #{plural_klass_name}Base
class #{klass_name} < #{klass_name}Base
def to_feed(feed, current)
#{name} = feed.class::#{klass_name}.new
set = setup_values(#{name})
unless set
raise NotSetError.new(#{maker_name.dump},
not_set_required_variables)
end
current.#{plural} << #{name}
set_parent(#{name}, current)
setup_other_elements(#{name})
end
private
def required_variable_names
%w(name)
end
end
end
EOC
end
end
module AtomTextConstruct
class << self
def def_atom_text_construct(klass, name, maker_name, klass_name=nil,
atom_klass_name=nil)
klass_name ||= Utils.to_class_name(name)
atom_klass_name ||= Utils.to_class_name(name)
klass.class_eval(<<-EOC, __FILE__, __LINE__ + 1)
class #{klass_name} < #{klass_name}Base
include #{self.name}
def to_feed(feed, current)
#{name} = current.class::#{atom_klass_name}.new
if setup_values(#{name})
current.#{name} = #{name}
set_parent(#{name}, current)
setup_other_elements(feed)
elsif variable_is_set?
raise NotSetError.new(#{maker_name.dump},
not_set_required_variables)
end
end
end
EOC
end
end
private
def required_variable_names
if type == "xhtml"
%w(xml_content)
else
%w(content)
end
end
def variables
if type == "xhtml"
super + %w(xhtml)
else
super
end
end
end
module AtomCategory
def to_feed(feed, current)
category = feed.class::Category.new
set = setup_values(category)
if set
current.categories << category
set_parent(category, current)
setup_other_elements(feed)
else
raise NotSetError.new(self.class.not_set_name,
not_set_required_variables)
end
end
private
def required_variable_names
%w(term)
end
def variables
super + ["term", "scheme"]
end
end
module AtomLink
def to_feed(feed, current)
link = feed.class::Link.new
set = setup_values(link)
if set
current.links << link
set_parent(link, current)
setup_other_elements(feed)
else
raise NotSetError.new(self.class.not_set_name,
not_set_required_variables)
end
end
private
def required_variable_names
%w(href)
end
end
module AtomGenerator
def to_feed(feed, current)
generator = current.class::Generator.new
if setup_values(generator)
current.generator = generator
set_parent(generator, current)
setup_other_elements(feed)
elsif variable_is_set?
raise NotSetError.new(self.class.not_set_name,
not_set_required_variables)
end
end
private
def required_variable_names
%w(content)
end
end
module AtomLogo
def to_feed(feed, current)
logo = current.class::Logo.new
class << logo
alias_method(:uri=, :content=)
end
set = setup_values(logo)
class << logo
remove_method(:uri=)
end
if set
current.logo = logo
set_parent(logo, current)
setup_other_elements(feed)
elsif variable_is_set?
raise NotSetError.new(self.class.not_set_name,
not_set_required_variables)
end
end
private
def required_variable_names
%w(uri)
end
end
end
end

945
lib/rss/maker/base.rb
Просмотреть файл

@ -1,945 +0,0 @@
# frozen_string_literal: false
require 'forwardable'
require_relative '../rss'
module RSS
module Maker
class Base
extend Utils::InheritedReader
OTHER_ELEMENTS = []
NEED_INITIALIZE_VARIABLES = []
class << self
def other_elements
inherited_array_reader("OTHER_ELEMENTS")
end
def need_initialize_variables
inherited_array_reader("NEED_INITIALIZE_VARIABLES")
end
def inherited_base
::RSS::Maker::Base
end
def inherited(subclass)
subclass.const_set(:OTHER_ELEMENTS, [])
subclass.const_set(:NEED_INITIALIZE_VARIABLES, [])
end
def add_other_element(variable_name)
self::OTHER_ELEMENTS << variable_name
end
def add_need_initialize_variable(variable_name, init_value=nil,
&init_block)
init_value ||= init_block
self::NEED_INITIALIZE_VARIABLES << [variable_name, init_value]
end
def def_array_element(name, plural=nil, klass_name=nil)
include Enumerable
extend Forwardable
plural ||= "#{name}s"
klass_name ||= Utils.to_class_name(name)
def_delegators("@#{plural}", :<<, :[], :[]=, :first, :last)
def_delegators("@#{plural}", :push, :pop, :shift, :unshift)
def_delegators("@#{plural}", :each, :size, :empty?, :clear)
add_need_initialize_variable(plural) {[]}
module_eval(<<-EOC, __FILE__, __LINE__ + 1)
def new_#{name}
#{name} = self.class::#{klass_name}.new(@maker)
@#{plural} << #{name}
if block_given?
yield #{name}
else
#{name}
end
end
alias new_child new_#{name}
def to_feed(*args)
@#{plural}.each do |#{name}|
#{name}.to_feed(*args)
end
end
def replace(elements)
@#{plural}.replace(elements.to_a)
end
EOC
end
def def_classed_element_without_accessor(name, class_name=nil)
class_name ||= Utils.to_class_name(name)
add_other_element(name)
add_need_initialize_variable(name) do |object|
object.send("make_#{name}")
end
module_eval(<<-EOC, __FILE__, __LINE__ + 1)
private
def setup_#{name}(feed, current)
@#{name}.to_feed(feed, current)
end
def make_#{name}
self.class::#{class_name}.new(@maker)
end
EOC
end
def def_classed_element(name, class_name=nil, attribute_name=nil)
def_classed_element_without_accessor(name, class_name)
if attribute_name
module_eval(<<-EOC, __FILE__, __LINE__ + 1)
def #{name}
if block_given?
yield(@#{name})
else
@#{name}.#{attribute_name}
end
end
def #{name}=(new_value)
@#{name}.#{attribute_name} = new_value
end
EOC
else
attr_reader name
end
end
def def_classed_elements(name, attribute, plural_class_name=nil,
plural_name=nil, new_name=nil)
plural_name ||= "#{name}s"
new_name ||= name
def_classed_element(plural_name, plural_class_name)
local_variable_name = "_#{name}"
new_value_variable_name = "new_value"
additional_setup_code = nil
if block_given?
additional_setup_code = yield(local_variable_name,
new_value_variable_name)
end
module_eval(<<-EOC, __FILE__, __LINE__ + 1)
def #{name}
#{local_variable_name} = #{plural_name}.first
#{local_variable_name} ? #{local_variable_name}.#{attribute} : nil
end
def #{name}=(#{new_value_variable_name})
#{local_variable_name} =
#{plural_name}.first || #{plural_name}.new_#{new_name}
#{additional_setup_code}
#{local_variable_name}.#{attribute} = #{new_value_variable_name}
end
EOC
end
def def_other_element(name)
attr_accessor name
def_other_element_without_accessor(name)
end
def def_other_element_without_accessor(name)
add_need_initialize_variable(name)
add_other_element(name)
module_eval(<<-EOC, __FILE__, __LINE__ + 1)
def setup_#{name}(feed, current)
if !@#{name}.nil? and current.respond_to?(:#{name}=)
current.#{name} = @#{name}
end
end
EOC
end
def def_csv_element(name, type=nil)
def_other_element_without_accessor(name)
attr_reader(name)
converter = ""
if type == :integer
converter = "{|v| Integer(v)}"
end
module_eval(<<-EOC, __FILE__, __LINE__ + 1)
def #{name}=(value)
@#{name} = Utils::CSV.parse(value)#{converter}
end
EOC
end
end
attr_reader :maker
def initialize(maker)
@maker = maker
@default_values_are_set = false
initialize_variables
end
def have_required_values?
not_set_required_variables.empty?
end
def variable_is_set?
variables.any? {|var| not __send__(var).nil?}
end
private
def initialize_variables
self.class.need_initialize_variables.each do |variable_name, init_value|
if init_value.nil?
value = nil
else
if init_value.respond_to?(:call)
value = init_value.call(self)
elsif init_value.is_a?(String)
# just for backward compatibility
value = instance_eval(init_value, __FILE__, __LINE__)
else
value = init_value
end
end
instance_variable_set("@#{variable_name}", value)
end
end
def setup_other_elements(feed, current=nil)
current ||= current_element(feed)
self.class.other_elements.each do |element|
__send__("setup_#{element}", feed, current)
end
end
def current_element(feed)
feed
end
def set_default_values(&block)
return yield if @default_values_are_set
begin
@default_values_are_set = true
_set_default_values(&block)
ensure
@default_values_are_set = false
end
end
def _set_default_values(&block)
yield
end
def setup_values(target)
set = false
if have_required_values?
variables.each do |var|
setter = "#{var}="
if target.respond_to?(setter)
value = __send__(var)
unless value.nil?
target.__send__(setter, value)
set = true
end
end
end
end
set
end
def set_parent(target, parent)
target.parent = parent if target.class.need_parent?
end
def variables
self.class.need_initialize_variables.find_all do |name, init|
# init == "nil" is just for backward compatibility
init.nil? or init == "nil"
end.collect do |name, init|
name
end
end
def not_set_required_variables
required_variable_names.find_all do |var|
__send__(var).nil?
end
end
def required_variables_are_set?
required_variable_names.each do |var|
return false if __send__(var).nil?
end
true
end
end
module AtomPersonConstructBase
def self.append_features(klass)
super
klass.class_eval(<<-EOC, __FILE__, __LINE__ + 1)
%w(name uri email).each do |element|
attr_accessor element
add_need_initialize_variable(element)
end
EOC
end
end
module AtomTextConstructBase
module EnsureXMLContent
class << self
def included(base)
super
base.class_eval do
%w(type content xml_content).each do |element|
attr_reader element
attr_writer element if element != "xml_content"
add_need_initialize_variable(element)
end
alias_method(:xhtml, :xml_content)
end
end
end
def ensure_xml_content(content)
xhtml_uri = ::RSS::Atom::XHTML_URI
unless content.is_a?(RSS::XML::Element) and
["div", xhtml_uri] == [content.name, content.uri]
children = content
children = [children] unless content.is_a?(Array)
children = set_xhtml_uri_as_default_uri(children)
content = RSS::XML::Element.new("div", nil, xhtml_uri,
{"xmlns" => xhtml_uri},
children)
end
content
end
def xml_content=(content)
@xml_content = ensure_xml_content(content)
end
def xhtml=(content)
self.xml_content = content
end
private
def set_xhtml_uri_as_default_uri(children)
children.collect do |child|
if child.is_a?(RSS::XML::Element) and
child.prefix.nil? and child.uri.nil?
RSS::XML::Element.new(child.name, nil, ::RSS::Atom::XHTML_URI,
child.attributes.dup,
set_xhtml_uri_as_default_uri(child.children))
else
child
end
end
end
end
def self.append_features(klass)
super
klass.class_eval do
include EnsureXMLContent
end
end
end
module SetupDefaultDate
private
def _set_default_values
keep = {
:date => date,
:dc_dates => dc_dates.to_a.dup,
}
_date = _parse_date_if_needed(date)
if _date and !dc_dates.any? {|dc_date| dc_date.value == _date}
dc_date = self.class::DublinCoreDates::DublinCoreDate.new(self)
dc_date.value = _date.dup
dc_dates.unshift(dc_date)
end
self.date ||= self.dc_date
super
ensure
self.date = keep[:date]
dc_dates.replace(keep[:dc_dates])
end
def _parse_date_if_needed(date_value)
date_value = Time.parse(date_value) if date_value.is_a?(String)
date_value
end
end
module SetupDefaultLanguage
private
def _set_default_values
keep = {
:dc_languages => dc_languages.to_a.dup,
}
_language = language
if _language and
!dc_languages.any? {|dc_language| dc_language.value == _language}
dc_language = self.class::DublinCoreLanguages::DublinCoreLanguage.new(self)
dc_language.value = _language.dup
dc_languages.unshift(dc_language)
end
super
ensure
dc_languages.replace(keep[:dc_languages])
end
end
class RSSBase < Base
class << self
def make(*args, &block)
new(*args).make(&block)
end
end
%w(xml_stylesheets channel image items textinput).each do |element|
attr_reader element
add_need_initialize_variable(element) do |object|
object.send("make_#{element}")
end
module_eval(<<-EOC, __FILE__, __LINE__ + 1)
private
def setup_#{element}(feed)
@#{element}.to_feed(feed)
end
def make_#{element}
self.class::#{Utils.to_class_name(element)}.new(self)
end
EOC
end
attr_reader :feed_version
alias_method(:rss_version, :feed_version)
attr_accessor :version, :encoding, :standalone
def initialize(feed_version)
super(self)
@feed_type = nil
@feed_subtype = nil
@feed_version = feed_version
@version = "1.0"
@encoding = "UTF-8"
@standalone = nil
end
def make
yield(self)
to_feed
end
def to_feed
feed = make_feed
setup_xml_stylesheets(feed)
setup_elements(feed)
setup_other_elements(feed)
feed.validate
feed
end
private
remove_method :make_xml_stylesheets
def make_xml_stylesheets
XMLStyleSheets.new(self)
end
end
class XMLStyleSheets < Base
def_array_element("xml_stylesheet", nil, "XMLStyleSheet")
class XMLStyleSheet < Base
::RSS::XMLStyleSheet::ATTRIBUTES.each do |attribute|
attr_accessor attribute
add_need_initialize_variable(attribute)
end
def to_feed(feed)
xss = ::RSS::XMLStyleSheet.new
guess_type_if_need(xss)
set = setup_values(xss)
if set
feed.xml_stylesheets << xss
end
end
private
def guess_type_if_need(xss)
if @type.nil?
xss.href = @href
@type = xss.type
end
end
def required_variable_names
%w(href type)
end
end
end
class ChannelBase < Base
include SetupDefaultDate
%w(cloud categories skipDays skipHours).each do |name|
def_classed_element(name)
end
%w(generator copyright description title).each do |name|
def_classed_element(name, nil, "content")
end
[
["link", "href", Proc.new {|target,| "#{target}.href = 'self'"}],
["author", "name"],
["contributor", "name"],
].each do |name, attribute, additional_setup_maker|
def_classed_elements(name, attribute, &additional_setup_maker)
end
%w(id about language
managingEditor webMaster rating docs ttl).each do |element|
attr_accessor element
add_need_initialize_variable(element)
end
%w(date lastBuildDate).each do |date_element|
attr_reader date_element
add_need_initialize_variable(date_element)
end
def date=(_date)
@date = _parse_date_if_needed(_date)
end
def lastBuildDate=(_date)
@lastBuildDate = _parse_date_if_needed(_date)
end
def pubDate
date
end
def pubDate=(date)
self.date = date
end
def updated
date
end
def updated=(date)
self.date = date
end
alias_method(:rights, :copyright)
alias_method(:rights=, :copyright=)
alias_method(:subtitle, :description)
alias_method(:subtitle=, :description=)
def icon
image_favicon.about
end
def icon=(url)
image_favicon.about = url
end
def logo
maker.image.url
end
def logo=(url)
maker.image.url = url
end
class SkipDaysBase < Base
def_array_element("day")
class DayBase < Base
%w(content).each do |element|
attr_accessor element
add_need_initialize_variable(element)
end
end
end
class SkipHoursBase < Base
def_array_element("hour")
class HourBase < Base
%w(content).each do |element|
attr_accessor element
add_need_initialize_variable(element)
end
end
end
class CloudBase < Base
%w(domain port path registerProcedure protocol).each do |element|
attr_accessor element
add_need_initialize_variable(element)
end
end
class CategoriesBase < Base
def_array_element("category", "categories")
class CategoryBase < Base
%w(domain content label).each do |element|
attr_accessor element
add_need_initialize_variable(element)
end
alias_method(:term, :domain)
alias_method(:term=, :domain=)
alias_method(:scheme, :content)
alias_method(:scheme=, :content=)
end
end
class LinksBase < Base
def_array_element("link")
class LinkBase < Base
%w(href rel type hreflang title length).each do |element|
attr_accessor element
add_need_initialize_variable(element)
end
end
end
class AuthorsBase < Base
def_array_element("author")
class AuthorBase < Base
include AtomPersonConstructBase
end
end
class ContributorsBase < Base
def_array_element("contributor")
class ContributorBase < Base
include AtomPersonConstructBase
end
end
class GeneratorBase < Base
%w(uri version content).each do |element|
attr_accessor element
add_need_initialize_variable(element)
end
end
class CopyrightBase < Base
include AtomTextConstructBase
end
class DescriptionBase < Base
include AtomTextConstructBase
end
class TitleBase < Base
include AtomTextConstructBase
end
end
class ImageBase < Base
%w(title url width height description).each do |element|
attr_accessor element
add_need_initialize_variable(element)
end
def link
@maker.channel.link
end
end
class ItemsBase < Base
def_array_element("item")
attr_accessor :do_sort, :max_size
def initialize(maker)
super
@do_sort = false
@max_size = -1
end
def normalize
if @max_size >= 0
sort_if_need[0...@max_size]
else
sort_if_need[0..@max_size]
end
end
private
def sort_if_need
if @do_sort.respond_to?(:call)
@items.sort do |x, y|
@do_sort.call(x, y)
end
elsif @do_sort
@items.sort do |x, y|
y <=> x
end
else
@items
end
end
class ItemBase < Base
include SetupDefaultDate
%w(guid enclosure source categories content).each do |name|
def_classed_element(name)
end
%w(rights description title).each do |name|
def_classed_element(name, nil, "content")
end
[
["author", "name"],
["link", "href", Proc.new {|target,| "#{target}.href = 'alternate'"}],
["contributor", "name"],
].each do |name, attribute|
def_classed_elements(name, attribute)
end
%w(comments id published).each do |element|
attr_accessor element
add_need_initialize_variable(element)
end
%w(date).each do |date_element|
attr_reader date_element
add_need_initialize_variable(date_element)
end
def date=(_date)
@date = _parse_date_if_needed(_date)
end
def pubDate
date
end
def pubDate=(date)
self.date = date
end
def updated
date
end
def updated=(date)
self.date = date
end
alias_method(:summary, :description)
alias_method(:summary=, :description=)
def <=>(other)
_date = date || dc_date
_other_date = other.date || other.dc_date
if _date and _other_date
_date <=> _other_date
elsif _date
1
elsif _other_date
-1
else
0
end
end
class GuidBase < Base
%w(isPermaLink content).each do |element|
attr_accessor element
add_need_initialize_variable(element)
end
def permanent_link?
isPermaLink
end
def permanent_link=(bool)
self.isPermaLink = bool
end
end
class EnclosureBase < Base
%w(url length type).each do |element|
attr_accessor element
add_need_initialize_variable(element)
end
end
class SourceBase < Base
include SetupDefaultDate
%w(authors categories contributors generator icon
logo rights subtitle title).each do |name|
def_classed_element(name)
end
[
["link", "href"],
].each do |name, attribute|
def_classed_elements(name, attribute)
end
%w(id content).each do |element|
attr_accessor element
add_need_initialize_variable(element)
end
alias_method(:url, :link)
alias_method(:url=, :link=)
%w(date).each do |date_element|
attr_reader date_element
add_need_initialize_variable(date_element)
end
def date=(_date)
@date = _parse_date_if_needed(_date)
end
def updated
date
end
def updated=(date)
self.date = date
end
private
AuthorsBase = ChannelBase::AuthorsBase
CategoriesBase = ChannelBase::CategoriesBase
ContributorsBase = ChannelBase::ContributorsBase
GeneratorBase = ChannelBase::GeneratorBase
class IconBase < Base
%w(url).each do |element|
attr_accessor element
add_need_initialize_variable(element)
end
end
LinksBase = ChannelBase::LinksBase
class LogoBase < Base
%w(uri).each do |element|
attr_accessor element
add_need_initialize_variable(element)
end
end
class RightsBase < Base
include AtomTextConstructBase
end
class SubtitleBase < Base
include AtomTextConstructBase
end
class TitleBase < Base
include AtomTextConstructBase
end
end
CategoriesBase = ChannelBase::CategoriesBase
AuthorsBase = ChannelBase::AuthorsBase
LinksBase = ChannelBase::LinksBase
ContributorsBase = ChannelBase::ContributorsBase
class RightsBase < Base
include AtomTextConstructBase
end
class DescriptionBase < Base
include AtomTextConstructBase
end
class ContentBase < Base
include AtomTextConstructBase::EnsureXMLContent
%w(src).each do |element|
attr_accessor(element)
add_need_initialize_variable(element)
end
def xml_content=(content)
content = ensure_xml_content(content) if inline_xhtml?
@xml_content = content
end
alias_method(:xml, :xml_content)
alias_method(:xml=, :xml_content=)
def inline_text?
[nil, "text", "html"].include?(@type)
end
def inline_html?
@type == "html"
end
def inline_xhtml?
@type == "xhtml"
end
def inline_other?
!out_of_line? and ![nil, "text", "html", "xhtml"].include?(@type)
end
def inline_other_text?
return false if @type.nil? or out_of_line?
/\Atext\//i.match(@type) ? true : false
end
def inline_other_xml?
return false if @type.nil? or out_of_line?
/[\+\/]xml\z/i.match(@type) ? true : false
end
def inline_other_base64?
return false if @type.nil? or out_of_line?
@type.include?("/") and !inline_other_text? and !inline_other_xml?
end
def out_of_line?
not @src.nil? and @content.nil?
end
end
class TitleBase < Base
include AtomTextConstructBase
end
end
end
class TextinputBase < Base
%w(title description name link).each do |element|
attr_accessor element
add_need_initialize_variable(element)
end
end
end
end

22
lib/rss/maker/content.rb
Просмотреть файл

@ -1,22 +0,0 @@
# frozen_string_literal: false
require_relative '../content'
require_relative '1.0'
require_relative '2.0'
module RSS
module Maker
module ContentModel
def self.append_features(klass)
super
::RSS::ContentModel::ELEMENTS.each do |name|
klass.def_other_element(name)
end
end
end
class ItemsBase
class ItemBase; include ContentModel; end
end
end
end

122
lib/rss/maker/dublincore.rb
Просмотреть файл

@ -1,122 +0,0 @@
# frozen_string_literal: false
require_relative '../dublincore'
require_relative '1.0'
module RSS
module Maker
module DublinCoreModel
def self.append_features(klass)
super
::RSS::DublinCoreModel::ELEMENT_NAME_INFOS.each do |name, plural_name|
plural_name ||= "#{name}s"
full_name = "#{RSS::DC_PREFIX}_#{name}"
full_plural_name = "#{RSS::DC_PREFIX}_#{plural_name}"
plural_klass_name = "DublinCore#{Utils.to_class_name(plural_name)}"
klass.def_classed_elements(full_name, "value", plural_klass_name,
full_plural_name, name)
klass.module_eval(<<-EOC, __FILE__, __LINE__ + 1)
def new_#{full_name}(value=nil)
_#{full_name} = #{full_plural_name}.new_#{name}
_#{full_name}.value = value
if block_given?
yield _#{full_name}
else
_#{full_name}
end
end
EOC
end
klass.module_eval(<<-EOC, __FILE__, __LINE__ + 1)
# For backward compatibility
alias #{DC_PREFIX}_rightses #{DC_PREFIX}_rights_list
EOC
end
::RSS::DublinCoreModel::ELEMENT_NAME_INFOS.each do |name, plural_name|
plural_name ||= "#{name}s"
full_name ||= "#{DC_PREFIX}_#{name}"
full_plural_name ||= "#{DC_PREFIX}_#{plural_name}"
klass_name = Utils.to_class_name(name)
full_klass_name = "DublinCore#{klass_name}"
plural_klass_name = "DublinCore#{Utils.to_class_name(plural_name)}"
module_eval(<<-EOC, __FILE__, __LINE__ + 1)
class #{plural_klass_name}Base < Base
def_array_element(#{name.dump}, #{full_plural_name.dump},
#{full_klass_name.dump})
class #{full_klass_name}Base < Base
attr_accessor :value
add_need_initialize_variable("value")
alias_method(:content, :value)
alias_method(:content=, :value=)
def have_required_values?
@value
end
def to_feed(feed, current)
if value and current.respond_to?(:#{full_name})
new_item = current.class::#{full_klass_name}.new(value)
current.#{full_plural_name} << new_item
end
end
end
#{klass_name}Base = #{full_klass_name}Base
end
EOC
end
def self.install_dublin_core(klass)
::RSS::DublinCoreModel::ELEMENT_NAME_INFOS.each do |name, plural_name|
plural_name ||= "#{name}s"
klass_name = Utils.to_class_name(name)
full_klass_name = "DublinCore#{klass_name}"
plural_klass_name = "DublinCore#{Utils.to_class_name(plural_name)}"
klass.module_eval(<<-EOC, __FILE__, __LINE__ + 1)
class #{plural_klass_name} < #{plural_klass_name}Base
class #{full_klass_name} < #{full_klass_name}Base
end
#{klass_name} = #{full_klass_name}
end
EOC
end
end
end
class ChannelBase
include DublinCoreModel
end
class ImageBase; include DublinCoreModel; end
class ItemsBase
class ItemBase
include DublinCoreModel
end
end
class TextinputBase; include DublinCoreModel; end
makers.each do |maker|
maker.module_eval(<<-EOC, __FILE__, __LINE__ + 1)
class Channel
DublinCoreModel.install_dublin_core(self)
end
class Image
DublinCoreModel.install_dublin_core(self)
end
class Items
class Item
DublinCoreModel.install_dublin_core(self)
end
end
class Textinput
DublinCoreModel.install_dublin_core(self)
end
EOC
end
end
end

164
lib/rss/maker/entry.rb
Просмотреть файл

@ -1,164 +0,0 @@
# frozen_string_literal: false
require_relative "atom"
require_relative "feed"
module RSS
module Maker
module Atom
class Entry < RSSBase
def initialize(feed_version="1.0")
super
@feed_type = "atom"
@feed_subtype = "entry"
end
private
def make_feed
::RSS::Atom::Entry.new(@version, @encoding, @standalone)
end
def setup_elements(entry)
setup_items(entry)
end
class Channel < ChannelBase
class SkipDays < SkipDaysBase
class Day < DayBase
end
end
class SkipHours < SkipHoursBase
class Hour < HourBase
end
end
class Cloud < CloudBase
end
Categories = Feed::Channel::Categories
Links = Feed::Channel::Links
Authors = Feed::Channel::Authors
Contributors = Feed::Channel::Contributors
class Generator < GeneratorBase
include AtomGenerator
def self.not_set_name
"maker.channel.generator"
end
end
Copyright = Feed::Channel::Copyright
class Description < DescriptionBase
end
Title = Feed::Channel::Title
end
class Image < ImageBase
end
class Items < ItemsBase
def to_feed(entry)
(normalize.first || Item.new(@maker)).to_feed(entry)
end
class Item < ItemBase
def to_feed(entry)
set_default_values do
setup_values(entry)
entry.dc_dates.clear
setup_other_elements(entry)
unless have_required_values?
raise NotSetError.new("maker.item", not_set_required_variables)
end
end
end
private
def required_variable_names
%w(id updated)
end
def variables
super + ["updated"]
end
def variable_is_set?
super or !authors.empty?
end
def not_set_required_variables
set_default_values do
vars = super
if authors.all? {|author| !author.have_required_values?}
vars << "author"
end
vars << "title" unless title {|t| t.have_required_values?}
vars
end
end
def _set_default_values
keep = {
:authors => authors.to_a.dup,
:contributors => contributors.to_a.dup,
:categories => categories.to_a.dup,
:id => id,
:links => links.to_a.dup,
:rights => @rights,
:title => @title,
:updated => updated,
}
authors.replace(@maker.channel.authors) if keep[:authors].empty?
if keep[:contributors].empty?
contributors.replace(@maker.channel.contributors)
end
if keep[:categories].empty?
categories.replace(@maker.channel.categories)
end
self.id ||= link || @maker.channel.id
links.replace(@maker.channel.links) if keep[:links].empty?
unless keep[:rights].variable_is_set?
@maker.channel.rights {|r| @rights = r}
end
unless keep[:title].variable_is_set?
@maker.channel.title {|t| @title = t}
end
self.updated ||= @maker.channel.updated
super
ensure
authors.replace(keep[:authors])
contributors.replace(keep[:contributors])
categories.replace(keep[:categories])
links.replace(keep[:links])
self.id = keep[:id]
@rights = keep[:rights]
@title = keep[:title]
self.updated = keep[:updated]
end
Guid = Feed::Items::Item::Guid
Enclosure = Feed::Items::Item::Enclosure
Source = Feed::Items::Item::Source
Categories = Feed::Items::Item::Categories
Authors = Feed::Items::Item::Authors
Contributors = Feed::Items::Item::Contributors
Links = Feed::Items::Item::Links
Rights = Feed::Items::Item::Rights
Description = Feed::Items::Item::Description
Title = Feed::Items::Item::Title
Content = Feed::Items::Item::Content
end
end
class Textinput < TextinputBase
end
end
end
add_maker("atom:entry", "1.0", Atom::Entry)
add_maker("atom1.0:entry", "1.0", Atom::Entry)
end
end

427
lib/rss/maker/feed.rb
Просмотреть файл

@ -1,427 +0,0 @@
# frozen_string_literal: false
require_relative "atom"
module RSS
module Maker
module Atom
class Feed < RSSBase
def initialize(feed_version="1.0")
super
@feed_type = "atom"
@feed_subtype = "feed"
end
private
def make_feed
::RSS::Atom::Feed.new(@version, @encoding, @standalone)
end
def setup_elements(feed)
setup_channel(feed)
setup_image(feed)
setup_items(feed)
end
class Channel < ChannelBase
include SetupDefaultLanguage
def to_feed(feed)
set_default_values do
setup_values(feed)
feed.dc_dates.clear
setup_other_elements(feed)
if image_favicon.about
icon = feed.class::Icon.new
icon.content = image_favicon.about
feed.icon = icon
end
unless have_required_values?
raise NotSetError.new("maker.channel",
not_set_required_variables)
end
end
end
def have_required_values?
super and
(!authors.empty? or
@maker.items.any? {|item| !item.authors.empty?})
end
private
def required_variable_names
%w(id updated)
end
def variables
super + %w(id updated)
end
def variable_is_set?
super or !authors.empty?
end
def not_set_required_variables
vars = super
if authors.empty? and
@maker.items.all? {|item| item.author.to_s.empty?}
vars << "author"
end
vars << "title" unless title {|t| t.have_required_values?}
vars
end
def _set_default_values(&block)
keep = {
:id => id,
}
self.id ||= about
super(&block)
ensure
self.id = keep[:id]
end
class SkipDays < SkipDaysBase
def to_feed(*args)
end
class Day < DayBase
end
end
class SkipHours < SkipHoursBase
def to_feed(*args)
end
class Hour < HourBase
end
end
class Cloud < CloudBase
def to_feed(*args)
end
end
class Categories < CategoriesBase
class Category < CategoryBase
include AtomCategory
def self.not_set_name
"maker.channel.category"
end
end
end
class Links < LinksBase
class Link < LinkBase
include AtomLink
def self.not_set_name
"maker.channel.link"
end
end
end
AtomPersons.def_atom_persons(self, "author", "maker.channel.author")
AtomPersons.def_atom_persons(self, "contributor",
"maker.channel.contributor")
class Generator < GeneratorBase
include AtomGenerator
def self.not_set_name
"maker.channel.generator"
end
end
AtomTextConstruct.def_atom_text_construct(self, "rights",
"maker.channel.copyright",
"Copyright")
AtomTextConstruct.def_atom_text_construct(self, "subtitle",
"maker.channel.description",
"Description")
AtomTextConstruct.def_atom_text_construct(self, "title",
"maker.channel.title")
end
class Image < ImageBase
def to_feed(feed)
logo = feed.class::Logo.new
class << logo
alias_method(:url=, :content=)
end
set = setup_values(logo)
class << logo
remove_method(:url=)
end
if set
feed.logo = logo
set_parent(logo, feed)
setup_other_elements(feed, logo)
elsif variable_is_set?
raise NotSetError.new("maker.image", not_set_required_variables)
end
end
private
def required_variable_names
%w(url)
end
end
class Items < ItemsBase
def to_feed(feed)
normalize.each do |item|
item.to_feed(feed)
end
setup_other_elements(feed, feed.entries)
end
class Item < ItemBase
def to_feed(feed)
set_default_values do
entry = feed.class::Entry.new
set = setup_values(entry)
entry.dc_dates.clear
setup_other_elements(feed, entry)
if set
feed.entries << entry
set_parent(entry, feed)
elsif variable_is_set?
raise NotSetError.new("maker.item", not_set_required_variables)
end
end
end
def have_required_values?
set_default_values do
super and title {|t| t.have_required_values?}
end
end
private
def required_variable_names
%w(id updated)
end
def variables
super + ["updated"]
end
def not_set_required_variables
vars = super
vars << "title" unless title {|t| t.have_required_values?}
vars
end
def _set_default_values(&block)
keep = {
:id => id,
}
self.id ||= link
super(&block)
ensure
self.id = keep[:id]
end
class Guid < GuidBase
def to_feed(feed, current)
end
end
class Enclosure < EnclosureBase
def to_feed(feed, current)
end
end
class Source < SourceBase
def to_feed(feed, current)
source = current.class::Source.new
setup_values(source)
current.source = source
set_parent(source, current)
setup_other_elements(feed, source)
current.source = nil if source.to_s == "<source/>"
end
private
def required_variable_names
[]
end
def variables
super + ["updated"]
end
AtomPersons.def_atom_persons(self, "author",
"maker.item.source.author")
AtomPersons.def_atom_persons(self, "contributor",
"maker.item.source.contributor")
class Categories < CategoriesBase
class Category < CategoryBase
include AtomCategory
def self.not_set_name
"maker.item.source.category"
end
end
end
class Generator < GeneratorBase
include AtomGenerator
def self.not_set_name
"maker.item.source.generator"
end
end
class Icon < IconBase
def to_feed(feed, current)
icon = current.class::Icon.new
class << icon
alias_method(:url=, :content=)
end
set = setup_values(icon)
class << icon
remove_method(:url=)
end
if set
current.icon = icon
set_parent(icon, current)
setup_other_elements(feed, icon)
elsif variable_is_set?
raise NotSetError.new("maker.item.source.icon",
not_set_required_variables)
end
end
private
def required_variable_names
%w(url)
end
end
class Links < LinksBase
class Link < LinkBase
include AtomLink
def self.not_set_name
"maker.item.source.link"
end
end
end
class Logo < LogoBase
include AtomLogo
def self.not_set_name
"maker.item.source.logo"
end
end
maker_name_base = "maker.item.source."
maker_name = "#{maker_name_base}rights"
AtomTextConstruct.def_atom_text_construct(self, "rights",
maker_name)
maker_name = "#{maker_name_base}subtitle"
AtomTextConstruct.def_atom_text_construct(self, "subtitle",
maker_name)
maker_name = "#{maker_name_base}title"
AtomTextConstruct.def_atom_text_construct(self, "title",
maker_name)
end
class Categories < CategoriesBase
class Category < CategoryBase
include AtomCategory
def self.not_set_name
"maker.item.category"
end
end
end
AtomPersons.def_atom_persons(self, "author", "maker.item.author")
AtomPersons.def_atom_persons(self, "contributor",
"maker.item.contributor")
class Links < LinksBase
class Link < LinkBase
include AtomLink
def self.not_set_name
"maker.item.link"
end
end
end
AtomTextConstruct.def_atom_text_construct(self, "rights",
"maker.item.rights")
AtomTextConstruct.def_atom_text_construct(self, "summary",
"maker.item.description",
"Description")
AtomTextConstruct.def_atom_text_construct(self, "title",
"maker.item.title")
class Content < ContentBase
def to_feed(feed, current)
content = current.class::Content.new
if setup_values(content)
content.src = nil if content.src and content.content
current.content = content
set_parent(content, current)
setup_other_elements(feed, content)
elsif variable_is_set?
raise NotSetError.new("maker.item.content",
not_set_required_variables)
end
end
alias_method(:xml, :xml_content)
private
def required_variable_names
if out_of_line?
%w(type)
elsif xml_type?
%w(xml_content)
else
%w(content)
end
end
def variables
if out_of_line?
super
elsif xml_type?
super + %w(xml)
else
super
end
end
def xml_type?
_type = type
return false if _type.nil?
_type == "xhtml" or
/(?:\+xml|\/xml)$/i =~ _type or
%w(text/xml-external-parsed-entity
application/xml-external-parsed-entity
application/xml-dtd).include?(_type.downcase)
end
end
end
end
class Textinput < TextinputBase
end
end
end
add_maker("atom", "1.0", Atom::Feed)
add_maker("atom:feed", "1.0", Atom::Feed)
add_maker("atom1.0", "1.0", Atom::Feed)
add_maker("atom1.0:feed", "1.0", Atom::Feed)
end
end

112
lib/rss/maker/image.rb
Просмотреть файл

@ -1,112 +0,0 @@
# frozen_string_literal: false
require_relative '../image'
require_relative '1.0'
require_relative 'dublincore'
module RSS
module Maker
module ImageItemModel
def self.append_features(klass)
super
name = "#{RSS::IMAGE_PREFIX}_item"
klass.def_classed_element(name)
end
def self.install_image_item(klass)
klass.module_eval(<<-EOC, __FILE__, __LINE__ + 1)
class ImageItem < ImageItemBase
DublinCoreModel.install_dublin_core(self)
end
EOC
end
class ImageItemBase < Base
include Maker::DublinCoreModel
attr_accessor :about, :resource, :image_width, :image_height
add_need_initialize_variable("about")
add_need_initialize_variable("resource")
add_need_initialize_variable("image_width")
add_need_initialize_variable("image_height")
alias width= image_width=
alias width image_width
alias height= image_height=
alias height image_height
def have_required_values?
@about
end
def to_feed(feed, current)
if current.respond_to?(:image_item=) and have_required_values?
item = current.class::ImageItem.new
setup_values(item)
setup_other_elements(item)
current.image_item = item
end
end
end
end
module ImageFaviconModel
def self.append_features(klass)
super
name = "#{RSS::IMAGE_PREFIX}_favicon"
klass.def_classed_element(name)
end
def self.install_image_favicon(klass)
klass.module_eval(<<-EOC, __FILE__, __LINE__ + 1)
class ImageFavicon < ImageFaviconBase
DublinCoreModel.install_dublin_core(self)
end
EOC
end
class ImageFaviconBase < Base
include Maker::DublinCoreModel
attr_accessor :about, :image_size
add_need_initialize_variable("about")
add_need_initialize_variable("image_size")
alias size image_size
alias size= image_size=
def have_required_values?
@about and @image_size
end
def to_feed(feed, current)
if current.respond_to?(:image_favicon=) and have_required_values?
favicon = current.class::ImageFavicon.new
setup_values(favicon)
setup_other_elements(favicon)
current.image_favicon = favicon
end
end
end
end
class ChannelBase; include Maker::ImageFaviconModel; end
class ItemsBase
class ItemBase; include Maker::ImageItemModel; end
end
makers.each do |maker|
maker.module_eval(<<-EOC, __FILE__, __LINE__ + 1)
class Channel
ImageFaviconModel.install_image_favicon(self)
end
class Items
class Item
ImageItemModel.install_image_item(self)
end
end
EOC
end
end
end

243
lib/rss/maker/itunes.rb
Просмотреть файл

@ -1,243 +0,0 @@
# frozen_string_literal: false
require_relative '../itunes'
require_relative '2.0'
module RSS
module Maker
module ITunesBaseModel
def def_class_accessor(klass, name, type, *args)
name = name.gsub(/-/, "_").gsub(/^itunes_/, '')
full_name = "#{RSS::ITUNES_PREFIX}_#{name}"
case type
when nil
klass.def_other_element(full_name)
when :yes_other
def_yes_other_accessor(klass, full_name)
when :explicit_clean_other
def_explicit_clean_other_accessor(klass, full_name)
when :csv
def_csv_accessor(klass, full_name)
when :element, :attribute
recommended_attribute_name, = *args
klass_name = "ITunes#{Utils.to_class_name(name)}"
klass.def_classed_element(full_name, klass_name,
recommended_attribute_name)
when :elements
plural_name, recommended_attribute_name = args
plural_name ||= "#{name}s"
full_plural_name = "#{RSS::ITUNES_PREFIX}_#{plural_name}"
klass_name = "ITunes#{Utils.to_class_name(name)}"
plural_klass_name = "ITunes#{Utils.to_class_name(plural_name)}"
def_elements_class_accessor(klass, name, full_name, full_plural_name,
klass_name, plural_klass_name,
recommended_attribute_name)
end
end
def def_yes_other_accessor(klass, full_name)
klass.def_other_element(full_name)
klass.module_eval(<<-EOC, __FILE__, __LINE__ + 1)
def #{full_name}?
Utils::YesOther.parse(@#{full_name})
end
EOC
end
def def_explicit_clean_other_accessor(klass, full_name)
klass.def_other_element(full_name)
klass.module_eval(<<-EOC, __FILE__, __LINE__ + 1)
def #{full_name}?
Utils::ExplicitCleanOther.parse(#{full_name})
end
EOC
end
def def_csv_accessor(klass, full_name)
klass.def_csv_element(full_name)
end
def def_elements_class_accessor(klass, name, full_name, full_plural_name,
klass_name, plural_klass_name,
recommended_attribute_name=nil)
if recommended_attribute_name
klass.def_classed_elements(full_name, recommended_attribute_name,
plural_klass_name, full_plural_name)
else
klass.def_classed_element(full_plural_name, plural_klass_name)
end
klass.module_eval(<<-EOC, __FILE__, __LINE__ + 1)
def new_#{full_name}(text=nil)
#{full_name} = @#{full_plural_name}.new_#{name}
#{full_name}.text = text
if block_given?
yield #{full_name}
else
#{full_name}
end
end
EOC
end
end
module ITunesChannelModel
extend ITunesBaseModel
class << self
def append_features(klass)
super
::RSS::ITunesChannelModel::ELEMENT_INFOS.each do |name, type, *args|
def_class_accessor(klass, name, type, *args)
end
end
end
class ITunesCategoriesBase < Base
def_array_element("category", "itunes_categories",
"ITunesCategory")
class ITunesCategoryBase < Base
attr_accessor :text
add_need_initialize_variable("text")
def_array_element("category", "itunes_categories",
"ITunesCategory")
def have_required_values?
text
end
alias_method :to_feed_for_categories, :to_feed
def to_feed(feed, current)
if text and current.respond_to?(:itunes_category)
new_item = current.class::ITunesCategory.new(text)
to_feed_for_categories(feed, new_item)
current.itunes_categories << new_item
end
end
end
end
class ITunesImageBase < Base
add_need_initialize_variable("href")
attr_accessor("href")
def to_feed(feed, current)
if @href and current.respond_to?(:itunes_image)
current.itunes_image ||= current.class::ITunesImage.new
current.itunes_image.href = @href
end
end
end
class ITunesOwnerBase < Base
%w(itunes_name itunes_email).each do |name|
add_need_initialize_variable(name)
attr_accessor(name)
end
def to_feed(feed, current)
if current.respond_to?(:itunes_owner=)
_not_set_required_variables = not_set_required_variables
if (required_variable_names - _not_set_required_variables).empty?
return
end
unless have_required_values?
raise NotSetError.new("maker.channel.itunes_owner",
_not_set_required_variables)
end
current.itunes_owner ||= current.class::ITunesOwner.new
current.itunes_owner.itunes_name = @itunes_name
current.itunes_owner.itunes_email = @itunes_email
end
end
private
def required_variable_names
%w(itunes_name itunes_email)
end
end
end
module ITunesItemModel
extend ITunesBaseModel
class << self
def append_features(klass)
super
::RSS::ITunesItemModel::ELEMENT_INFOS.each do |name, type, *args|
def_class_accessor(klass, name, type, *args)
end
end
end
class ITunesDurationBase < Base
attr_reader :content
add_need_initialize_variable("content")
%w(hour minute second).each do |name|
attr_reader(name)
add_need_initialize_variable(name, 0)
end
def content=(content)
if content.nil?
@hour, @minute, @second, @content = nil
else
@hour, @minute, @second =
::RSS::ITunesItemModel::ITunesDuration.parse(content)
@content = content
end
end
def hour=(hour)
@hour = Integer(hour)
update_content
end
def minute=(minute)
@minute = Integer(minute)
update_content
end
def second=(second)
@second = Integer(second)
update_content
end
def to_feed(feed, current)
if @content and current.respond_to?(:itunes_duration=)
current.itunes_duration ||= current.class::ITunesDuration.new
current.itunes_duration.content = @content
end
end
private
def update_content
components = [@hour, @minute, @second]
@content =
::RSS::ITunesItemModel::ITunesDuration.construct(*components)
end
end
end
class ChannelBase
include Maker::ITunesChannelModel
class ITunesCategories < ITunesCategoriesBase
class ITunesCategory < ITunesCategoryBase
ITunesCategory = self
end
end
class ITunesImage < ITunesImageBase; end
class ITunesOwner < ITunesOwnerBase; end
end
class ItemsBase
class ItemBase
include Maker::ITunesItemModel
class ITunesDuration < ITunesDurationBase; end
end
end
end
end

34
lib/rss/maker/slash.rb
Просмотреть файл

@ -1,34 +0,0 @@
# frozen_string_literal: false
require_relative '../slash'
require_relative '1.0'
module RSS
module Maker
module SlashModel
def self.append_features(klass)
super
::RSS::SlashModel::ELEMENT_INFOS.each do |name, type|
full_name = "#{RSS::SLASH_PREFIX}_#{name}"
case type
when :csv_integer
klass.def_csv_element(full_name, :integer)
else
klass.def_other_element(full_name)
end
end
klass.module_eval do
alias_method(:slash_hit_parades, :slash_hit_parade)
alias_method(:slash_hit_parades=, :slash_hit_parade=)
end
end
end
class ItemsBase
class ItemBase
include SlashModel
end
end
end
end

19
lib/rss/maker/syndication.rb
Просмотреть файл

@ -1,19 +0,0 @@
# frozen_string_literal: false
require_relative '../syndication'
require_relative '1.0'
module RSS
module Maker
module SyndicationModel
def self.append_features(klass)
super
::RSS::SyndicationModel::ELEMENTS.each do |name|
klass.def_other_element(name)
end
end
end
class ChannelBase; include SyndicationModel; end
end
end

119
lib/rss/maker/taxonomy.rb
Просмотреть файл

@ -1,119 +0,0 @@
# frozen_string_literal: false
require_relative '../taxonomy'
require_relative '1.0'
require_relative 'dublincore'
module RSS
module Maker
module TaxonomyTopicsModel
def self.append_features(klass)
super
klass.def_classed_element("#{RSS::TAXO_PREFIX}_topics",
"TaxonomyTopics")
end
def self.install_taxo_topics(klass)
klass.module_eval(<<-EOC, __FILE__, __LINE__ + 1)
class TaxonomyTopics < TaxonomyTopicsBase
def to_feed(feed, current)
if current.respond_to?(:taxo_topics)
topics = current.class::TaxonomyTopics.new
bag = topics.Bag
@resources.each do |resource|
bag.lis << RDF::Bag::Li.new(resource)
end
current.taxo_topics = topics
end
end
end
EOC
end
class TaxonomyTopicsBase < Base
attr_reader :resources
def_array_element("resource")
remove_method :new_resource
end
end
module TaxonomyTopicModel
def self.append_features(klass)
super
class_name = "TaxonomyTopics"
klass.def_classed_elements("#{TAXO_PREFIX}_topic", "value", class_name)
end
def self.install_taxo_topic(klass)
klass.module_eval(<<-EOC, __FILE__, __LINE__ + 1)
class TaxonomyTopics < TaxonomyTopicsBase
class TaxonomyTopic < TaxonomyTopicBase
DublinCoreModel.install_dublin_core(self)
TaxonomyTopicsModel.install_taxo_topics(self)
def to_feed(feed, current)
if current.respond_to?(:taxo_topics)
topic = current.class::TaxonomyTopic.new(value)
topic.taxo_link = value
taxo_topics.to_feed(feed, topic) if taxo_topics
current.taxo_topics << topic
setup_other_elements(feed, topic)
end
end
end
end
EOC
end
class TaxonomyTopicsBase < Base
def_array_element("topic", nil, "TaxonomyTopic")
alias_method(:new_taxo_topic, :new_topic) # For backward compatibility
class TaxonomyTopicBase < Base
include DublinCoreModel
include TaxonomyTopicsModel
attr_accessor :value
add_need_initialize_variable("value")
alias_method(:taxo_link, :value)
alias_method(:taxo_link=, :value=)
def have_required_values?
@value
end
end
end
end
class RSSBase
include TaxonomyTopicModel
end
class ChannelBase
include TaxonomyTopicsModel
end
class ItemsBase
class ItemBase
include TaxonomyTopicsModel
end
end
makers.each do |maker|
maker.module_eval(<<-EOC, __FILE__, __LINE__ + 1)
TaxonomyTopicModel.install_taxo_topic(self)
class Channel
TaxonomyTopicsModel.install_taxo_topics(self)
end
class Items
class Item
TaxonomyTopicsModel.install_taxo_topics(self)
end
end
EOC
end
end
end

62
lib/rss/maker/trackback.rb
Просмотреть файл

@ -1,62 +0,0 @@
# frozen_string_literal: false
require_relative '../trackback'
require_relative '1.0'
require_relative '2.0'
module RSS
module Maker
module TrackBackModel
def self.append_features(klass)
super
klass.def_other_element("#{RSS::TRACKBACK_PREFIX}_ping")
klass.def_classed_elements("#{RSS::TRACKBACK_PREFIX}_about", "value",
"TrackBackAbouts")
end
class TrackBackAboutsBase < Base
def_array_element("about", nil, "TrackBackAbout")
class TrackBackAboutBase < Base
attr_accessor :value
add_need_initialize_variable("value")
alias_method(:resource, :value)
alias_method(:resource=, :value=)
alias_method(:content, :value)
alias_method(:content=, :value=)
def have_required_values?
@value
end
def to_feed(feed, current)
if current.respond_to?(:trackback_abouts) and have_required_values?
about = current.class::TrackBackAbout.new
setup_values(about)
setup_other_elements(about)
current.trackback_abouts << about
end
end
end
end
end
class ItemsBase
class ItemBase; include TrackBackModel; end
end
makers.each do |maker|
maker.module_eval(<<-EOC, __FILE__, __LINE__ + 1)
class Items
class Item
class TrackBackAbouts < TrackBackAboutsBase
class TrackBackAbout < TrackBackAboutBase
end
end
end
end
EOC
end
end
end

589
lib/rss/parser.rb
Просмотреть файл

@ -1,589 +0,0 @@
# frozen_string_literal: false
require "forwardable"
require "open-uri"
require_relative "rss"
require_relative "xml"
module RSS
class NotWellFormedError < Error
attr_reader :line, :element
# Create a new NotWellFormedError for an error at +line+
# in +element+. If a block is given the return value of
# the block ends up in the error message.
def initialize(line=nil, element=nil)
message = "This is not well formed XML"
if element or line
message << "\nerror occurred"
message << " in #{element}" if element
message << " at about #{line} line" if line
end
message << "\n#{yield}" if block_given?
super(message)
end
end
class XMLParserNotFound < Error
def initialize
super("available XML parser was not found in " <<
"#{AVAILABLE_PARSER_LIBRARIES.inspect}.")
end
end
class NotValidXMLParser < Error
def initialize(parser)
super("#{parser} is not an available XML parser. " <<
"Available XML parser" <<
(AVAILABLE_PARSERS.size > 1 ? "s are " : " is ") <<
"#{AVAILABLE_PARSERS.inspect}.")
end
end
class NSError < InvalidRSSError
attr_reader :tag, :prefix, :uri
def initialize(tag, prefix, require_uri)
@tag, @prefix, @uri = tag, prefix, require_uri
super("prefix <#{prefix}> doesn't associate uri " <<
"<#{require_uri}> in tag <#{tag}>")
end
end
class Parser
extend Forwardable
class << self
@@default_parser = nil
def default_parser
@@default_parser || AVAILABLE_PARSERS.first
end
# Set @@default_parser to new_value if it is one of the
# available parsers. Else raise NotValidXMLParser error.
def default_parser=(new_value)
if AVAILABLE_PARSERS.include?(new_value)
@@default_parser = new_value
else
raise NotValidXMLParser.new(new_value)
end
end
def parse(rss, *args)
if args.last.is_a?(Hash)
options = args.pop
else
options = {}
end
do_validate = boolean_argument(args[0], options[:validate], true)
ignore_unknown_element =
boolean_argument(args[1], options[:ignore_unknown_element], true)
parser_class = args[2] || options[:parser_class] || default_parser
parser = new(rss, parser_class)
parser.do_validate = do_validate
parser.ignore_unknown_element = ignore_unknown_element
parser.parse
end
private
def boolean_argument(positioned_value, option_value, default)
value = positioned_value
if value.nil? and not option_value.nil?
value = option_value
end
value = default if value.nil?
value
end
end
def_delegators(:@parser, :parse, :rss,
:ignore_unknown_element,
:ignore_unknown_element=, :do_validate,
:do_validate=)
def initialize(rss, parser_class=self.class.default_parser)
@parser = parser_class.new(normalize_rss(rss))
end
private
# Try to get the XML associated with +rss+.
# Return +rss+ if it already looks like XML, or treat it as a URI,
# or a file to get the XML,
def normalize_rss(rss)
return rss if maybe_xml?(rss)
uri = to_uri(rss)
if uri.respond_to?(:read)
uri.read
elsif (RUBY_VERSION >= '2.7' || !rss.tainted?) and File.readable?(rss)
File.open(rss) {|f| f.read}
else
rss
end
end
# maybe_xml? tests if source is a string that looks like XML.
def maybe_xml?(source)
source.is_a?(String) and /</ =~ source
end
# Attempt to convert rss to a URI, but just return it if
# there's a ::URI::Error
def to_uri(rss)
return rss if rss.is_a?(::URI::Generic)
begin
::URI.parse(rss)
rescue ::URI::Error
rss
end
end
end
class BaseParser
class << self
def raise_for_undefined_entity?
listener.raise_for_undefined_entity?
end
end
def initialize(rss)
@listener = self.class.listener.new
@rss = rss
end
def rss
@listener.rss
end
def ignore_unknown_element
@listener.ignore_unknown_element
end
def ignore_unknown_element=(new_value)
@listener.ignore_unknown_element = new_value
end
def do_validate
@listener.do_validate
end
def do_validate=(new_value)
@listener.do_validate = new_value
end
def parse
if @listener.rss.nil?
_parse
end
@listener.rss
end
end
class BaseListener
extend Utils
class << self
@@accessor_bases = {}
@@registered_uris = {}
@@class_names = {}
# return the setter for the uri, tag_name pair, or nil.
def setter(uri, tag_name)
_getter = getter(uri, tag_name)
if _getter
"#{_getter}="
else
nil
end
end
def getter(uri, tag_name)
(@@accessor_bases[uri] || {})[tag_name]
end
# return the tag_names for setters associated with uri
def available_tags(uri)
(@@accessor_bases[uri] || {}).keys
end
# register uri against this name.
def register_uri(uri, name)
@@registered_uris[name] ||= {}
@@registered_uris[name][uri] = nil
end
# test if this uri is registered against this name
def uri_registered?(uri, name)
@@registered_uris[name].has_key?(uri)
end
# record class_name for the supplied uri and tag_name
def install_class_name(uri, tag_name, class_name)
@@class_names[uri] ||= {}
@@class_names[uri][tag_name] = class_name
end
# retrieve class_name for the supplied uri and tag_name
# If it doesn't exist, capitalize the tag_name
def class_name(uri, tag_name)
name = (@@class_names[uri] || {})[tag_name]
return name if name
tag_name = tag_name.gsub(/[_\-]([a-z]?)/) {$1.upcase}
tag_name[0, 1].upcase + tag_name[1..-1]
end
def install_get_text_element(uri, name, accessor_base)
install_accessor_base(uri, name, accessor_base)
def_get_text_element(uri, name, *get_file_and_line_from_caller(1))
end
def raise_for_undefined_entity?
true
end
private
# set the accessor for the uri, tag_name pair
def install_accessor_base(uri, tag_name, accessor_base)
@@accessor_bases[uri] ||= {}
@@accessor_bases[uri][tag_name] = accessor_base.chomp("=")
end
def def_get_text_element(uri, element_name, file, line)
register_uri(uri, element_name)
method_name = "start_#{element_name}"
unless private_method_defined?(method_name)
define_method(method_name) do |name, prefix, attrs, ns|
uri = _ns(ns, prefix)
if self.class.uri_registered?(uri, element_name)
start_get_text_element(name, prefix, ns, uri)
else
start_else_element(name, prefix, attrs, ns)
end
end
private(method_name)
end
end
end
end
module ListenerMixin
attr_reader :rss
attr_accessor :ignore_unknown_element
attr_accessor :do_validate
def initialize
@rss = nil
@ignore_unknown_element = true
@do_validate = true
@ns_stack = [{"xml" => :xml}]
@tag_stack = [[]]
@text_stack = ['']
@proc_stack = []
@last_element = nil
@version = @encoding = @standalone = nil
@xml_stylesheets = []
@xml_child_mode = false
@xml_element = nil
@last_xml_element = nil
end
# set instance vars for version, encoding, standalone
def xmldecl(version, encoding, standalone)
@version, @encoding, @standalone = version, encoding, standalone
end
def instruction(name, content)
if name == "xml-stylesheet"
params = parse_pi_content(content)
if params.has_key?("href")
@xml_stylesheets << XMLStyleSheet.new(params)
end
end
end
def tag_start(name, attributes)
@text_stack.push('')
ns = @ns_stack.last.dup
attrs = {}
attributes.each do |n, v|
if /\Axmlns(?:\z|:)/ =~ n
ns[$POSTMATCH] = v
else
attrs[n] = v
end
end
@ns_stack.push(ns)
prefix, local = split_name(name)
@tag_stack.last.push([_ns(ns, prefix), local])
@tag_stack.push([])
if @xml_child_mode
previous = @last_xml_element
element_attrs = attributes.dup
unless previous
ns.each do |ns_prefix, value|
next if ns_prefix == "xml"
key = ns_prefix.empty? ? "xmlns" : "xmlns:#{ns_prefix}"
element_attrs[key] ||= value
end
end
next_element = XML::Element.new(local,
prefix.empty? ? nil : prefix,
_ns(ns, prefix),
element_attrs)
previous << next_element if previous
@last_xml_element = next_element
pr = Proc.new do |text, tags|
if previous
@last_xml_element = previous
else
@xml_element = @last_xml_element
@last_xml_element = nil
end
end
@proc_stack.push(pr)
else
if @rss.nil? and respond_to?("initial_start_#{local}", true)
__send__("initial_start_#{local}", local, prefix, attrs, ns.dup)
elsif respond_to?("start_#{local}", true)
__send__("start_#{local}", local, prefix, attrs, ns.dup)
else
start_else_element(local, prefix, attrs, ns.dup)
end
end
end
def tag_end(name)
if DEBUG
p "end tag #{name}"
p @tag_stack
end
text = @text_stack.pop
tags = @tag_stack.pop
pr = @proc_stack.pop
pr.call(text, tags) unless pr.nil?
@ns_stack.pop
end
def text(data)
if @xml_child_mode
@last_xml_element << data if @last_xml_element
else
@text_stack.last << data
end
end
private
def _ns(ns, prefix)
ns.fetch(prefix, "")
end
CONTENT_PATTERN = /\s*([^=]+)=(["'])([^\2]+?)\2/
# Extract the first name="value" pair from content.
# Works with single quotes according to the constant
# CONTENT_PATTERN. Return a Hash.
def parse_pi_content(content)
params = {}
content.scan(CONTENT_PATTERN) do |name, quote, value|
params[name] = value
end
params
end
def start_else_element(local, prefix, attrs, ns)
class_name = self.class.class_name(_ns(ns, prefix), local)
current_class = @last_element.class
if known_class?(current_class, class_name)
next_class = current_class.const_get(class_name)
start_have_something_element(local, prefix, attrs, ns, next_class)
else
if !@do_validate or @ignore_unknown_element
@proc_stack.push(setup_next_element_in_unknown_element)
else
parent = "ROOT ELEMENT???"
if current_class.tag_name
parent = current_class.tag_name
end
raise NotExpectedTagError.new(local, _ns(ns, prefix), parent)
end
end
end
if Module.method(:const_defined?).arity == -1
def known_class?(target_class, class_name)
class_name and
(target_class.const_defined?(class_name, false) or
target_class.constants.include?(class_name.to_sym))
end
else
def known_class?(target_class, class_name)
class_name and
(target_class.const_defined?(class_name) or
target_class.constants.include?(class_name))
end
end
NAMESPLIT = /^(?:([\w:][-\w.]*):)?([\w:][-\w.]*)/
def split_name(name)
name =~ NAMESPLIT
[$1 || '', $2]
end
def check_ns(tag_name, prefix, ns, require_uri, ignore_unknown_element=nil)
if _ns(ns, prefix) == require_uri
true
else
if ignore_unknown_element.nil?
ignore_unknown_element = @ignore_unknown_element
end
if ignore_unknown_element
false
elsif @do_validate
raise NSError.new(tag_name, prefix, require_uri)
else
# Force bind required URI with prefix
@ns_stack.last[prefix] = require_uri
true
end
end
end
def start_get_text_element(tag_name, prefix, ns, required_uri)
pr = Proc.new do |text, tags|
setter = self.class.setter(required_uri, tag_name)
if setter and @last_element.respond_to?(setter)
if @do_validate
getter = self.class.getter(required_uri, tag_name)
if @last_element.__send__(getter)
raise TooMuchTagError.new(tag_name, @last_element.tag_name)
end
end
@last_element.__send__(setter, text.to_s)
else
if @do_validate and !@ignore_unknown_element
raise NotExpectedTagError.new(tag_name, _ns(ns, prefix),
@last_element.tag_name)
end
end
end
@proc_stack.push(pr)
end
def start_have_something_element(tag_name, prefix, attrs, ns, klass)
if check_ns(tag_name, prefix, ns, klass.required_uri)
attributes = collect_attributes(tag_name, prefix, attrs, ns, klass)
@proc_stack.push(setup_next_element(tag_name, klass, attributes))
else
@proc_stack.push(setup_next_element_in_unknown_element)
end
end
def collect_attributes(tag_name, prefix, attrs, ns, klass)
attributes = {}
klass.get_attributes.each do |a_name, a_uri, required, element_name|
if a_uri.is_a?(String) or !a_uri.respond_to?(:include?)
a_uri = [a_uri]
end
unless a_uri == [""]
for prefix, uri in ns
if a_uri.include?(uri)
val = attrs["#{prefix}:#{a_name}"]
break if val
end
end
end
if val.nil? and a_uri.include?("")
val = attrs[a_name]
end
if @do_validate and required and val.nil?
unless a_uri.include?("")
for prefix, uri in ns
if a_uri.include?(uri)
a_name = "#{prefix}:#{a_name}"
end
end
end
raise MissingAttributeError.new(tag_name, a_name)
end
attributes[a_name] = val
end
attributes
end
def setup_next_element(tag_name, klass, attributes)
previous = @last_element
next_element = klass.new(@do_validate, attributes)
previous.set_next_element(tag_name, next_element)
@last_element = next_element
@last_element.parent = previous if klass.need_parent?
@xml_child_mode = @last_element.have_xml_content?
Proc.new do |text, tags|
p(@last_element.class) if DEBUG
if @xml_child_mode
@last_element.content = @xml_element.to_s
xml_setter = @last_element.class.xml_setter
@last_element.__send__(xml_setter, @xml_element)
@xml_element = nil
@xml_child_mode = false
else
if klass.have_content?
if @last_element.need_base64_encode?
text = text.lstrip.unpack("m").first
end
@last_element.content = text
end
end
if @do_validate
@last_element.validate_for_stream(tags, @ignore_unknown_element)
end
@last_element = previous
end
end
def setup_next_element_in_unknown_element
current_element, @last_element = @last_element, nil
Proc.new {@last_element = current_element}
end
end
unless const_defined? :AVAILABLE_PARSER_LIBRARIES
# The list of all available libraries for parsing.
AVAILABLE_PARSER_LIBRARIES = [
["rss/xmlparser", :XMLParserParser],
["rss/xmlscanner", :XMLScanParser],
["rss/rexmlparser", :REXMLParser],
]
end
# The list of all available parsers, in constant form.
AVAILABLE_PARSERS = []
AVAILABLE_PARSER_LIBRARIES.each do |lib, parser|
begin
require lib
AVAILABLE_PARSERS.push(const_get(parser))
rescue LoadError
end
end
if AVAILABLE_PARSERS.empty?
raise XMLParserNotFound
end
end

50
lib/rss/rexmlparser.rb
Просмотреть файл

@ -1,50 +0,0 @@
# frozen_string_literal: false
require "rexml/document"
require "rexml/streamlistener"
module RSS
class REXMLParser < BaseParser
class << self
def listener
REXMLListener
end
end
private
def _parse
begin
REXML::Document.parse_stream(@rss, @listener)
rescue RuntimeError => e
raise NotWellFormedError.new{e.message}
rescue REXML::ParseException => e
context = e.context
line = context[0] if context
raise NotWellFormedError.new(line){e.message}
end
end
end
class REXMLListener < BaseListener
include REXML::StreamListener
include ListenerMixin
class << self
def raise_for_undefined_entity?
false
end
end
def xmldecl(version, encoding, standalone)
super(version, encoding, standalone == "yes")
# Encoding is converted to UTF-8 when REXML parse XML.
@encoding = 'UTF-8'
end
alias_method(:cdata, :text)
end
end

80
lib/rss/rss.gemspec
Просмотреть файл

@ -1,80 +0,0 @@
begin
require_relative "lib/rss/version"
rescue LoadError
# for Ruby core repository
require_relative "version"
end
Gem::Specification.new do |spec|
spec.name = "rss"
spec.version = RSS::VERSION
spec.authors = ["Kouhei Sutou"]
spec.email = ["kou@cozmixng.org"]
spec.summary = %q{Family of libraries that support various formats of XML "feeds".}
spec.description = %q{Family of libraries that support various formats of XML "feeds".}
spec.homepage = "https://github.com/ruby/rss"
spec.license = "BSD-2-Clause"
spec.files = [
".gitignore",
".travis.yml",
"Gemfile",
"LICENSE.txt",
"NEWS.md",
"README.md",
"Rakefile",
"lib/rss.rb",
"lib/rss/0.9.rb",
"lib/rss/1.0.rb",
"lib/rss/2.0.rb",
"lib/rss/atom.rb",
"lib/rss/content.rb",
"lib/rss/content/1.0.rb",
"lib/rss/content/2.0.rb",
"lib/rss/converter.rb",
"lib/rss/dublincore.rb",
"lib/rss/dublincore/1.0.rb",
"lib/rss/dublincore/2.0.rb",
"lib/rss/dublincore/atom.rb",
"lib/rss/image.rb",
"lib/rss/itunes.rb",
"lib/rss/maker.rb",
"lib/rss/maker/0.9.rb",
"lib/rss/maker/1.0.rb",
"lib/rss/maker/2.0.rb",
"lib/rss/maker/atom.rb",
"lib/rss/maker/base.rb",
"lib/rss/maker/content.rb",
"lib/rss/maker/dublincore.rb",
"lib/rss/maker/entry.rb",
"lib/rss/maker/feed.rb",
"lib/rss/maker/image.rb",
"lib/rss/maker/itunes.rb",
"lib/rss/maker/slash.rb",
"lib/rss/maker/syndication.rb",
"lib/rss/maker/taxonomy.rb",
"lib/rss/maker/trackback.rb",
"lib/rss/parser.rb",
"lib/rss/rexmlparser.rb",
"lib/rss/rss.rb",
"lib/rss/slash.rb",
"lib/rss/syndication.rb",
"lib/rss/taxonomy.rb",
"lib/rss/trackback.rb",
"lib/rss/utils.rb",
"lib/rss/version.rb",
"lib/rss/xml-stylesheet.rb",
"lib/rss/xml.rb",
"lib/rss/xmlparser.rb",
"lib/rss/xmlscanner.rb",
"rss.gemspec",
]
spec.bindir = "exe"
spec.executables = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
spec.require_paths = ["lib"]
spec.add_development_dependency "bundler"
spec.add_development_dependency "rake"
spec.add_development_dependency "test-unit"
end

1342
lib/rss/rss.rb
Просмотреть файл

Разница между файлами не показана из-за своего большого размера Загрузить разницу

52
lib/rss/slash.rb
Просмотреть файл

@ -1,52 +0,0 @@
# frozen_string_literal: false
require 'rss/1.0'
module RSS
# The prefix for the Slash XML namespace.
SLASH_PREFIX = 'slash'
# The URI of the Slash specification.
SLASH_URI = "http://purl.org/rss/1.0/modules/slash/"
RDF.install_ns(SLASH_PREFIX, SLASH_URI)
module SlashModel
extend BaseModel
ELEMENT_INFOS = \
[
["section"],
["department"],
["comments", :positive_integer],
["hit_parade", :csv_integer],
]
class << self
def append_features(klass)
super
return if klass.instance_of?(Module)
klass.install_must_call_validator(SLASH_PREFIX, SLASH_URI)
ELEMENT_INFOS.each do |name, type, *additional_infos|
full_name = "#{SLASH_PREFIX}_#{name}"
klass.install_text_element(full_name, SLASH_URI, "?",
full_name, type, name)
end
klass.module_eval do
alias_method(:slash_hit_parades, :slash_hit_parade)
undef_method(:slash_hit_parade)
alias_method(:slash_hit_parade, :slash_hit_parade_content)
end
end
end
end
class RDF
class Item; include SlashModel; end
end
SlashModel::ELEMENT_INFOS.each do |name, type|
accessor_base = "#{SLASH_PREFIX}_#{name}"
BaseListener.install_get_text_element(SLASH_URI, name, accessor_base)
end
end

69
lib/rss/syndication.rb
Просмотреть файл

@ -1,69 +0,0 @@
# frozen_string_literal: false
require "rss/1.0"
module RSS
# The prefix for the Syndication XML namespace.
SY_PREFIX = 'sy'
# The URI of the Syndication specification.
SY_URI = "http://purl.org/rss/1.0/modules/syndication/"
RDF.install_ns(SY_PREFIX, SY_URI)
module SyndicationModel
extend BaseModel
ELEMENTS = []
def self.append_features(klass)
super
klass.install_must_call_validator(SY_PREFIX, SY_URI)
klass.module_eval do
[
["updatePeriod"],
["updateFrequency", :positive_integer]
].each do |name, type|
install_text_element(name, SY_URI, "?",
"#{SY_PREFIX}_#{name}", type,
"#{SY_PREFIX}:#{name}")
end
%w(updateBase).each do |name|
install_date_element(name, SY_URI, "?",
"#{SY_PREFIX}_#{name}", 'w3cdtf',
"#{SY_PREFIX}:#{name}")
end
end
klass.module_eval(<<-EOC, __FILE__, __LINE__ + 1)
alias_method(:_sy_updatePeriod=, :sy_updatePeriod=)
def sy_updatePeriod=(new_value)
new_value = new_value.strip
validate_sy_updatePeriod(new_value) if @do_validate
self._sy_updatePeriod = new_value
end
EOC
end
private
SY_UPDATEPERIOD_AVAILABLE_VALUES = %w(hourly daily weekly monthly yearly)
def validate_sy_updatePeriod(value) # :nodoc:
unless SY_UPDATEPERIOD_AVAILABLE_VALUES.include?(value)
raise NotAvailableValueError.new("updatePeriod", value)
end
end
end
class RDF
class Channel; include SyndicationModel; end
end
prefix_size = SY_PREFIX.size + 1
SyndicationModel::ELEMENTS.uniq!
SyndicationModel::ELEMENTS.each do |full_name|
name = full_name[prefix_size..-1]
BaseListener.install_get_text_element(SY_URI, name, full_name)
end
end

148
lib/rss/taxonomy.rb
Просмотреть файл

@ -1,148 +0,0 @@
# frozen_string_literal: false
require "rss/1.0"
require_relative "dublincore"
module RSS
# The prefix for the Taxonomy XML namespace.
TAXO_PREFIX = "taxo"
# The URI for the specification of the Taxonomy XML namespace.
TAXO_URI = "http://purl.org/rss/1.0/modules/taxonomy/"
RDF.install_ns(TAXO_PREFIX, TAXO_URI)
# The listing of all the taxonomy elements, with the appropriate namespace.
TAXO_ELEMENTS = []
%w(link).each do |name|
full_name = "#{TAXO_PREFIX}_#{name}"
BaseListener.install_get_text_element(TAXO_URI, name, full_name)
TAXO_ELEMENTS << "#{TAXO_PREFIX}_#{name}"
end
%w(topic topics).each do |name|
class_name = Utils.to_class_name(name)
BaseListener.install_class_name(TAXO_URI, name, "Taxonomy#{class_name}")
TAXO_ELEMENTS << "#{TAXO_PREFIX}_#{name}"
end
module TaxonomyTopicsModel
extend BaseModel
def self.append_features(klass)
super
klass.install_must_call_validator(TAXO_PREFIX, TAXO_URI)
%w(topics).each do |name|
klass.install_have_child_element(name, TAXO_URI, "?",
"#{TAXO_PREFIX}_#{name}")
end
end
class TaxonomyTopics < Element
include RSS10
Bag = ::RSS::RDF::Bag
class << self
def required_prefix
TAXO_PREFIX
end
def required_uri
TAXO_URI
end
end
@tag_name = "topics"
install_have_child_element("Bag", RDF::URI, nil)
install_must_call_validator('rdf', RDF::URI)
def initialize(*args)
if Utils.element_initialize_arguments?(args)
super
else
super()
self.Bag = args[0]
end
self.Bag ||= Bag.new
end
def full_name
tag_name_with_prefix(TAXO_PREFIX)
end
def maker_target(target)
target.taxo_topics
end
def resources
if @Bag
@Bag.lis.collect do |li|
li.resource
end
else
[]
end
end
end
end
module TaxonomyTopicModel
extend BaseModel
def self.append_features(klass)
super
var_name = "#{TAXO_PREFIX}_topic"
klass.install_have_children_element("topic", TAXO_URI, "*", var_name)
end
class TaxonomyTopic < Element
include RSS10
include DublinCoreModel
include TaxonomyTopicsModel
class << self
def required_prefix
TAXO_PREFIX
end
def required_uri
TAXO_URI
end
end
@tag_name = "topic"
install_get_attribute("about", ::RSS::RDF::URI, true, nil, nil,
"#{RDF::PREFIX}:about")
install_text_element("link", TAXO_URI, "?", "#{TAXO_PREFIX}_link")
def initialize(*args)
if Utils.element_initialize_arguments?(args)
super
else
super()
self.about = args[0]
end
end
def full_name
tag_name_with_prefix(TAXO_PREFIX)
end
def maker_target(target)
target.new_taxo_topic
end
end
end
class RDF
include TaxonomyTopicModel
class Channel
include TaxonomyTopicsModel
end
class Item; include TaxonomyTopicsModel; end
end
end

291
lib/rss/trackback.rb
Просмотреть файл

@ -1,291 +0,0 @@
# frozen_string_literal: false
# This file contains the implementation of trackbacks. It is entirely internal
# and not useful to outside developers.
require 'rss/1.0'
require 'rss/2.0'
module RSS # :nodoc: all
TRACKBACK_PREFIX = 'trackback'
TRACKBACK_URI = 'http://madskills.com/public/xml/rss/module/trackback/'
RDF.install_ns(TRACKBACK_PREFIX, TRACKBACK_URI)
Rss.install_ns(TRACKBACK_PREFIX, TRACKBACK_URI)
module TrackBackUtils
private
def trackback_validate(ignore_unknown_element, tags, uri)
return if tags.nil?
if tags.find {|tag| tag == "about"} and
!tags.find {|tag| tag == "ping"}
raise MissingTagError.new("#{TRACKBACK_PREFIX}:ping", tag_name)
end
end
end
module BaseTrackBackModel
ELEMENTS = %w(ping about)
def append_features(klass)
super
unless klass.class == Module
klass.module_eval {include TrackBackUtils}
klass.install_must_call_validator(TRACKBACK_PREFIX, TRACKBACK_URI)
%w(ping).each do |name|
var_name = "#{TRACKBACK_PREFIX}_#{name}"
klass_name = "TrackBack#{Utils.to_class_name(name)}"
klass.install_have_child_element(name, TRACKBACK_URI, "?", var_name)
klass.module_eval(<<-EOC, __FILE__, __LINE__)
remove_method :#{var_name}
def #{var_name}
@#{var_name} and @#{var_name}.value
end
remove_method :#{var_name}=
def #{var_name}=(value)
@#{var_name} = Utils.new_with_value_if_need(#{klass_name}, value)
end
EOC
end
[%w(about s)].each do |name, postfix|
var_name = "#{TRACKBACK_PREFIX}_#{name}"
klass_name = "TrackBack#{Utils.to_class_name(name)}"
klass.install_have_children_element(name, TRACKBACK_URI, "*",
var_name)
klass.module_eval(<<-EOC, __FILE__, __LINE__)
remove_method :#{var_name}
def #{var_name}(*args)
if args.empty?
@#{var_name}.first and @#{var_name}.first.value
else
ret = @#{var_name}.__send__("[]", *args)
if ret.is_a?(Array)
ret.collect {|x| x.value}
else
ret.value
end
end
end
remove_method :#{var_name}=
remove_method :set_#{var_name}
def #{var_name}=(*args)
if args.size == 1
item = Utils.new_with_value_if_need(#{klass_name}, args[0])
@#{var_name}.push(item)
else
new_val = args.last
if new_val.is_a?(Array)
new_val = new_value.collect do |val|
Utils.new_with_value_if_need(#{klass_name}, val)
end
else
new_val = Utils.new_with_value_if_need(#{klass_name}, new_val)
end
@#{var_name}.__send__("[]=", *(args[0..-2] + [new_val]))
end
end
alias set_#{var_name} #{var_name}=
EOC
end
end
end
end
module TrackBackModel10
extend BaseModel
extend BaseTrackBackModel
class TrackBackPing < Element
include RSS10
class << self
def required_prefix
TRACKBACK_PREFIX
end
def required_uri
TRACKBACK_URI
end
end
@tag_name = "ping"
[
["resource", ::RSS::RDF::URI, true]
].each do |name, uri, required|
install_get_attribute(name, uri, required, nil, nil,
"#{::RSS::RDF::PREFIX}:#{name}")
end
alias_method(:value, :resource)
alias_method(:value=, :resource=)
def initialize(*args)
if Utils.element_initialize_arguments?(args)
super
else
super()
self.resource = args[0]
end
end
def full_name
tag_name_with_prefix(TRACKBACK_PREFIX)
end
end
class TrackBackAbout < Element
include RSS10
class << self
def required_prefix
TRACKBACK_PREFIX
end
def required_uri
TRACKBACK_URI
end
end
@tag_name = "about"
[
["resource", ::RSS::RDF::URI, true]
].each do |name, uri, required|
install_get_attribute(name, uri, required, nil, nil,
"#{::RSS::RDF::PREFIX}:#{name}")
end
alias_method(:value, :resource)
alias_method(:value=, :resource=)
def initialize(*args)
if Utils.element_initialize_arguments?(args)
super
else
super()
self.resource = args[0]
end
end
def full_name
tag_name_with_prefix(TRACKBACK_PREFIX)
end
private
def maker_target(abouts)
abouts.new_about
end
def setup_maker_attributes(about)
about.resource = self.resource
end
end
end
module TrackBackModel20
extend BaseModel
extend BaseTrackBackModel
class TrackBackPing < Element
include RSS09
@tag_name = "ping"
content_setup
class << self
def required_prefix
TRACKBACK_PREFIX
end
def required_uri
TRACKBACK_URI
end
end
alias_method(:value, :content)
alias_method(:value=, :content=)
def initialize(*args)
if Utils.element_initialize_arguments?(args)
super
else
super()
self.content = args[0]
end
end
def full_name
tag_name_with_prefix(TRACKBACK_PREFIX)
end
end
class TrackBackAbout < Element
include RSS09
@tag_name = "about"
content_setup
class << self
def required_prefix
TRACKBACK_PREFIX
end
def required_uri
TRACKBACK_URI
end
end
alias_method(:value, :content)
alias_method(:value=, :content=)
def initialize(*args)
if Utils.element_initialize_arguments?(args)
super
else
super()
self.content = args[0]
end
end
def full_name
tag_name_with_prefix(TRACKBACK_PREFIX)
end
end
end
class RDF
class Item; include TrackBackModel10; end
end
class Rss
class Channel
class Item; include TrackBackModel20; end
end
end
BaseTrackBackModel::ELEMENTS.each do |name|
class_name = Utils.to_class_name(name)
BaseListener.install_class_name(TRACKBACK_URI, name,
"TrackBack#{class_name}")
end
BaseTrackBackModel::ELEMENTS.collect! {|name| "#{TRACKBACK_PREFIX}_#{name}"}
end

200
lib/rss/utils.rb
Просмотреть файл

@ -1,200 +0,0 @@
# frozen_string_literal: false
module RSS
##
# RSS::Utils is a module that holds various utility functions that are used
# across many parts of the rest of the RSS library. Like most modules named
# some variant of 'util', its methods are probably not particularly useful
# to those who aren't developing the library itself.
module Utils
module_function
# Given a +name+ in a name_with_underscores or a name-with-dashes format,
# returns the CamelCase version of +name+.
#
# If the +name+ is already CamelCased, nothing happens.
#
# Examples:
#
# require 'rss/utils'
#
# RSS::Utils.to_class_name("sample_name")
# # => "SampleName"
# RSS::Utils.to_class_name("with-dashes")
# # => "WithDashes"
# RSS::Utils.to_class_name("CamelCase")
# # => "CamelCase"
def to_class_name(name)
name.split(/[_\-]/).collect do |part|
"#{part[0, 1].upcase}#{part[1..-1]}"
end.join("")
end
# Returns an array of two elements: the filename where the calling method
# is located, and the line number where it is defined.
#
# Takes an optional argument +i+, which specifies how many callers up the
# stack to look.
#
# Examples:
#
# require 'rss/utils'
#
# def foo
# p RSS::Utils.get_file_and_line_from_caller
# p RSS::Utils.get_file_and_line_from_caller(1)
# end
#
# def bar
# foo
# end
#
# def baz
# bar
# end
#
# baz
# # => ["test.rb", 5]
# # => ["test.rb", 9]
#
# If +i+ is not given, or is the default value of 0, it attempts to figure
# out the correct value. This is useful when in combination with
# instance_eval. For example:
#
# require 'rss/utils'
#
# def foo
# p RSS::Utils.get_file_and_line_from_caller(1)
# end
#
# def bar
# foo
# end
#
# instance_eval <<-RUBY, *RSS::Utils.get_file_and_line_from_caller
# def baz
# bar
# end
# RUBY
#
# baz
#
# # => ["test.rb", 8]
def get_file_and_line_from_caller(i=0)
file, line, = caller[i].split(':')
line = line.to_i
line += 1 if i.zero?
[file, line]
end
# Takes a string +s+ with some HTML in it, and escapes '&', '"', '<' and '>', by
# replacing them with the appropriate entities.
#
# This method is also aliased to h, for convenience.
#
# Examples:
#
# require 'rss/utils'
#
# RSS::Utils.html_escape("Dungeons & Dragons")
# # => "Dungeons &amp; Dragons"
# RSS::Utils.h(">_>")
# # => "&gt;_&gt;"
def html_escape(s)
s.to_s.gsub(/&/, "&amp;").gsub(/\"/, "&quot;").gsub(/>/, "&gt;").gsub(/</, "&lt;")
end
alias h html_escape
# If +value+ is an instance of class +klass+, return it, else
# create a new instance of +klass+ with value +value+.
def new_with_value_if_need(klass, value)
if value.is_a?(klass)
value
else
klass.new(value)
end
end
# This method is used inside of several different objects to determine
# if special behavior is needed in the constructor.
#
# Special behavior is needed if the array passed in as +args+ has
# +true+ or +false+ as its value, and if the second element of +args+
# is a hash.
def element_initialize_arguments?(args)
[true, false].include?(args[0]) and args[1].is_a?(Hash)
end
module ExplicitCleanOther
module_function
def parse(value)
if [true, false, nil].include?(value)
value
else
case value.to_s
when /\Aexplicit|yes|true\z/i
true
when /\Aclean|no|false\z/i
false
else
nil
end
end
end
end
module YesOther
module_function
def parse(value)
if [true, false].include?(value)
value
else
/\Ayes\z/i.match(value.to_s) ? true : false
end
end
end
module CSV
module_function
def parse(value, &block)
if value.is_a?(String)
value = value.strip.split(/\s*,\s*/)
value = value.collect(&block) if block_given?
value
else
value
end
end
end
module InheritedReader
def inherited_reader(constant_name)
base_class = inherited_base
result = base_class.const_get(constant_name)
found_base_class = false
ancestors.reverse_each do |klass|
if found_base_class
if klass.const_defined?(constant_name)
result = yield(result, klass.const_get(constant_name))
end
else
found_base_class = klass == base_class
end
end
result
end
def inherited_array_reader(constant_name)
inherited_reader(constant_name) do |result, current|
current + result
end
end
def inherited_hash_reader(constant_name)
inherited_reader(constant_name) do |result, current|
result.merge(current)
end
end
end
end
end

4
lib/rss/version.rb
Просмотреть файл

@ -1,4 +0,0 @@
module RSS
# The current version of RSS
VERSION = "0.2.8"
end

106
lib/rss/xml-stylesheet.rb
Просмотреть файл

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

72
lib/rss/xml.rb
Просмотреть файл

@ -1,72 +0,0 @@
# frozen_string_literal: false
require_relative "utils"
module RSS
module XML
class Element
include Enumerable
attr_reader :name, :prefix, :uri, :attributes, :children
def initialize(name, prefix=nil, uri=nil, attributes={}, children=[])
@name = name
@prefix = prefix
@uri = uri
@attributes = attributes
if children.is_a?(String) or !children.respond_to?(:each)
@children = [children]
else
@children = children
end
end
def [](name)
@attributes[name]
end
def []=(name, value)
@attributes[name] = value
end
def <<(child)
@children << child
end
def each(&block)
@children.each(&block)
end
def ==(other)
other.kind_of?(self.class) and
@name == other.name and
@uri == other.uri and
@attributes == other.attributes and
@children == other.children
end
def to_s
rv = "<#{full_name}"
attributes.each do |key, value|
rv << " #{Utils.html_escape(key)}=\"#{Utils.html_escape(value)}\""
end
if children.empty?
rv << "/>"
else
rv << ">"
children.each do |child|
rv << child.to_s
end
rv << "</#{full_name}>"
end
rv
end
def full_name
if @prefix
"#{@prefix}:#{@name}"
else
@name
end
end
end
end
end

95
lib/rss/xmlparser.rb
Просмотреть файл

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

122
lib/rss/xmlscanner.rb
Просмотреть файл

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

Двоичные данные
test/rss/dot.png
Просмотреть файл

Двоичный файл не отображается.
Режим "рядом"

До

Ширина:  |  Высота:  |  Размер: 111 B

2120
test/rss/rss-assertions.rb
Просмотреть файл

Разница между файлами не показана из-за своего большого размера Загрузить разницу

479
test/rss/rss-testcase.rb
Просмотреть файл

@ -1,479 +0,0 @@
# frozen_string_literal: false
require "erb"
require "test/unit"
require_relative 'rss-assertions'
require "rss"
module RSS
class TestCase < Test::Unit::TestCase
include ERB::Util
include RSS
include Assertions
XMLDECL_VERSION = "1.0"
XMLDECL_ENCODING = "UTF-8"
XMLDECL_STANDALONE = "no"
RDF_ABOUT = "http://www.xml.com/xml/news.rss"
RDF_RESOURCE = "http://xml.com/universal/images/xml_tiny.gif"
TITLE_VALUE = "XML.com"
LINK_VALUE = "http://xml.com/pub"
URL_VALUE = "http://xml.com/universal/images/xml_tiny.gif"
NAME_VALUE = "hogehoge"
LANGUAGE_VALUE = "ja"
DESCRIPTION_VALUE = "
XML.com features a rich mix of information and services
for the XML community.
"
RESOURCES = [
"http://xml.com/pub/2000/08/09/xslt/xslt.html",
"http://xml.com/pub/2000/08/09/rdfdb/index.html",
]
CLOUD_DOMAIN = "data.ourfavoritesongs.com"
CLOUD_PORT = "80"
CLOUD_PATH = "/RPC2"
CLOUD_REGISTER_PROCEDURE = "ourFavoriteSongs.rssPleaseNotify"
CLOUD_PROTOCOL = "xml-rpc"
ENCLOSURE_URL = "http://www.scripting.com/mp3s/weatherReportSuite.mp3"
ENCLOSURE_LENGTH = "12216320"
ENCLOSURE_TYPE = "audio/mpeg"
CATEGORY_DOMAIN = "http://www.superopendirectory.com/"
FEED_TITLE = "dive into mark"
FEED_UPDATED = "2003-12-13T18:30:02Z"
FEED_AUTHOR_NAME = "John Doe"
FEED_ID = "urn:uuid:60a76c80-d399-11d9-b93C-0003939e0af6"
ENTRY_TITLE = "Atom-Powered Robots Run Amok"
ENTRY_LINK = "http://example.org/2003/12/13/atom03"
ENTRY_ID = "urn:uuid:1225c695-cfb8-4ebb-aaaa-80da344efa6a"
ENTRY_UPDATED = "2003-12-13T18:30:02Z"
ENTRY_SUMMARY = "Some text."
t = Time.iso8601("2000-01-01T12:00:05+00:00")
class << t
alias_method(:to_s, :iso8601)
end
DC_ELEMENTS = {
:title => "hoge",
:description =>
" XML is placing increasingly heavy loads on
the existing technical infrastructure of the Internet.",
:creator => "Rael Dornfest (mailto:rael@oreilly.com)",
:subject => "XML",
:publisher => "The O'Reilly Network",
:contributor => "hogehoge",
:type => "fugafuga",
:format => "hohoho",
:identifier => "fufufu",
:source => "barbar",
:language => "ja",
:relation => "cococo",
:rights => "Copyright (c) 2000 O'Reilly &amp; Associates, Inc.",
:date => t,
}
DC_NODES = DC_ELEMENTS.collect do |name, value|
"<#{DC_PREFIX}:#{name}>#{value}</#{DC_PREFIX}:#{name}>"
end.join("\n")
def default_test
# This class isn't tested
end
private
def make_xmldecl(v=XMLDECL_VERSION, e=XMLDECL_ENCODING, s=XMLDECL_STANDALONE)
rv = "<?xml version='#{v}'"
rv << " encoding='#{e}'" if e
rv << " standalone='#{s}'" if s
rv << "?>"
rv
end
def make_RDF(content=nil, xmlns=[])
<<-EORSS
#{make_xmldecl}
<rdf:RDF xmlns="#{URI}" xmlns:rdf="#{RDF::URI}"
#{xmlns.collect {|pre, uri| "xmlns:#{pre}='#{uri}'"}.join(' ')}>
#{block_given? ? yield : content}
</rdf:RDF>
EORSS
end
def make_channel(content=nil)
<<-EOC
<channel rdf:about="#{RDF_ABOUT}">
<title>#{TITLE_VALUE}</title>
<link>#{LINK_VALUE}</link>
<description>#{DESCRIPTION_VALUE}</description>
<image rdf:resource="#{RDF_RESOURCE}" />
<items>
<rdf:Seq>
#{RESOURCES.collect do |res| '<rdf:li resource="' + res + '" />' end.join("\n")}
</rdf:Seq>
</items>
<textinput rdf:resource="#{RDF_RESOURCE}" />
#{block_given? ? yield : content}
</channel>
EOC
end
def make_image(content=nil)
<<-EOI
<image rdf:about="#{RDF_ABOUT}">
<title>#{TITLE_VALUE}</title>
<url>#{URL_VALUE}</url>
<link>#{LINK_VALUE}</link>
#{block_given? ? yield : content}
</image>
EOI
end
def make_item(content=nil)
<<-EOI
<item rdf:about="#{RDF_ABOUT}">
<title>#{TITLE_VALUE}</title>
<link>#{LINK_VALUE}</link>
<description>#{DESCRIPTION_VALUE}</description>
#{block_given? ? yield : content}
</item>
EOI
end
def make_textinput(content=nil)
<<-EOT
<textinput rdf:about="#{RDF_ABOUT}">
<title>#{TITLE_VALUE}</title>
<description>#{DESCRIPTION_VALUE}</description>
<name>#{NAME_VALUE}</name>
<link>#{LINK_VALUE}</link>
#{block_given? ? yield : content}
</textinput>
EOT
end
def make_sample_RDF
make_RDF(<<-EOR)
#{make_channel}
#{make_image}
#{make_item}
#{make_textinput}
EOR
end
def make_rss20(content=nil, xmlns=[])
<<-EORSS
#{make_xmldecl}
<rss version="2.0"
#{xmlns.collect {|pre, uri| "xmlns:#{pre}='#{uri}'"}.join(' ')}>
#{block_given? ? yield : content}
</rss>
EORSS
end
def make_sample_items20
RESOURCES.collect do |res|
elems = ["<link>#{res}</link>"]
elems << "<title>title of #{res}</title>"
elems = elems.join("\n")
"<item>\n#{elems}\n</item>"
end.join("\n")
end
def make_channel20(content=nil)
<<-EOC
<channel>
<title>#{TITLE_VALUE}</title>
<link>#{LINK_VALUE}</link>
<description>#{DESCRIPTION_VALUE}</description>
<language>#{LANGUAGE_VALUE}</language>
<image>
<url>#{RDF_RESOURCE}</url>
<title>#{TITLE_VALUE}</title>
<link>#{LINK_VALUE}</link>
</image>
#{make_sample_items20}
<textInput>
<title>#{TITLE_VALUE}</title>
<description>#{DESCRIPTION_VALUE}</description>
<name>#{NAME_VALUE}</name>
<link>#{RDF_RESOURCE}</link>
</textInput>
#{block_given? ? yield : content}
</channel>
EOC
end
def make_item20(content=nil)
<<-EOI
<item>
<title>#{TITLE_VALUE}</title>
<link>#{LINK_VALUE}</link>
<description>#{DESCRIPTION_VALUE}</description>
#{block_given? ? yield : content}
</item>
EOI
end
def make_cloud20
<<-EOC
<cloud
domain="#{CLOUD_DOMAIN}"
port="#{CLOUD_PORT}"
path="#{CLOUD_PATH}"
registerProcedure="#{CLOUD_REGISTER_PROCEDURE}"
protocol="#{CLOUD_PROTOCOL}" />
EOC
end
def make_sample_rss20
make_rss20(<<-EOR)
#{make_channel20}
EOR
end
def make_feed_without_entry(content=nil, xmlns=[])
<<-EOA
<feed xmlns="#{Atom::URI}"
#{xmlns.collect {|pre, uri| "xmlns:#{pre}='#{uri}'"}.join(' ')}>
<id>#{FEED_ID}</id>
<title>#{FEED_TITLE}</title>
<updated>#{FEED_UPDATED}</updated>
<author>
<name>#{FEED_AUTHOR_NAME}</name>
</author>
#{block_given? ? yield : content}
</feed>
EOA
end
def make_entry(content=nil)
<<-EOA
<entry>
<title>#{ENTRY_TITLE}</title>
<id>#{ENTRY_ID}</id>
<updated>#{ENTRY_UPDATED}</updated>
#{block_given? ? yield : content}
</entry>
EOA
end
def make_feed_with_open_entry(content=nil, xmlns=[], &block)
make_feed_without_entry(<<-EOA, xmlns)
#{make_entry(content, &block)}
EOA
end
def make_feed_with_open_entry_source(content=nil, xmlns=[])
make_feed_with_open_entry(<<-EOA, xmlns)
<source>
#{block_given? ? yield : content}
</source>
EOA
end
def make_feed(content=nil, xmlns=[])
make_feed_without_entry(<<-EOA, xmlns)
<entry>
<title>#{ENTRY_TITLE}</title>
<link href="#{ENTRY_LINK}"/>
<id>#{ENTRY_ID}</id>
<updated>#{ENTRY_UPDATED}</updated>
<summary>#{ENTRY_SUMMARY}</summary>
</entry>
#{block_given? ? yield : content}
EOA
end
def make_entry_document(content=nil, xmlns=[])
<<-EOA
<entry xmlns="#{Atom::URI}"
#{xmlns.collect {|pre, uri| "xmlns:#{pre}='#{uri}'"}.join(' ')}>
<id>#{ENTRY_ID}</id>
<title>#{ENTRY_TITLE}</title>
<updated>#{ENTRY_UPDATED}</updated>
<author>
<name>#{FEED_AUTHOR_NAME}</name>
</author>
#{block_given? ? yield : content}
</entry>
EOA
end
def make_entry_document_with_open_source(content=nil, xmlns=[])
make_entry_document(<<-EOA, xmlns)
<source>
#{block_given? ? yield : content}
</source>
EOA
end
def make_element(elem_name, attrs, contents)
attrs_str = attrs.collect do |name, value|
"#{h name}='#{h value}'"
end.join(" ")
attrs_str = " #{attrs_str}" unless attrs_str.empty?
if contents.is_a?(String)
contents_str = h(contents)
else
contents_str = contents.collect do |name, value|
"#{Element::INDENT}<#{h name}>#{h value}</#{h name}>"
end.join("\n")
contents_str = "\n#{contents_str}\n"
end
"<#{h elem_name}#{attrs_str}>#{contents_str}</#{h elem_name}>"
end
def xmlns_container(xmlns_decls, content)
attributes = xmlns_decls.collect do |prefix, uri|
"xmlns:#{h prefix}=\"#{h uri}\""
end.join(" ")
"<dummy #{attributes}>#{content}</dummy>"
end
private
def setup_rss10(rdf)
assert_equal("", rdf.to_s)
channel = RDF::Channel.new
assert_equal("", channel.to_s)
channel.about = "http://example.com/index.rdf"
channel.title = "title"
channel.link = "http://example.com/"
channel.description = "description"
assert_equal("", channel.to_s)
item_title = "item title"
item_link = "http://example.com/item"
channel.items = RDF::Channel::Items.new
channel.items.Seq.lis << RDF::Channel::Items::Seq::Li.new(item_link)
assert_not_equal("", channel.to_s)
rdf.channel = channel
assert_equal("", rdf.to_s)
item = RDF::Item.new
item.title = item_title
item.link = item_link
item.about = item_link
rdf.items << item
assert_not_equal("", rdf.to_s)
end
def setup_rss20(rss)
assert_equal("", rss.to_s)
channel = Rss::Channel.new
assert_equal("", channel.to_s)
channel.title = "title"
channel.link = "http://example.com/"
channel.description = "description"
assert_not_equal("", channel.to_s)
rss.channel = channel
assert_not_equal("", rss.to_s)
end
def setup_dummy_channel(maker)
about = "http://hoge.com"
title = "fugafuga"
link = "http://hoge.com/feed.xml"
description = "fugafugafugafuga"
language = "ja"
maker.channel.about = about
maker.channel.title = title
maker.channel.link = link
maker.channel.description = description
maker.channel.language = language
end
def setup_dummy_channel_atom(maker)
updated = Time.now
author = "Foo"
setup_dummy_channel(maker)
maker.channel.links.first.rel = "self"
maker.channel.links.first.type = "application/atom+xml"
maker.channel.updated = updated
maker.channel.author = author
end
def setup_dummy_image(maker)
title = "fugafuga"
link = "http://hoge.com"
url = "http://hoge.com/hoge.png"
maker.channel.link = link if maker.channel.link.nil?
maker.image.title = title
maker.image.url = url
end
def setup_dummy_textinput(maker)
title = "fugafuga"
description = "text hoge fuga"
name = "hoge"
link = "http://hoge.com/search.cgi"
maker.textinput.title = title
maker.textinput.description = description
maker.textinput.name = name
maker.textinput.link = link
end
def setup_dummy_item(maker)
title = "TITLE"
link = "http://hoge.com/"
item = maker.items.new_item
item.title = title
item.link = link
end
def setup_dummy_item_atom(maker)
setup_dummy_item(maker)
item = maker.items.first
item.id = "http://example.net/xxx"
item.updated = Time.now
end
def setup_taxo_topic(target, topics)
topics.each do |topic|
taxo_topic = target.taxo_topics.new_taxo_topic
topic.each do |name, value|
case name
when :link
taxo_topic.taxo_link = value
when :topics
value.each do |t|
taxo_topic.taxo_topics << t
end
else
dc_elems = taxo_topic.__send__("dc_#{name}s")
dc_elem = dc_elems.__send__("new_#{name}")
dc_elem.value = value
end
end
end
end
end
end

308
test/rss/test_1.0.rb
Просмотреть файл

@ -1,308 +0,0 @@
# frozen_string_literal: false
require "rexml/document"
require_relative "rss-testcase"
require "rss/1.0"
module RSS
class TestRSS10Core < 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 = false
rdf = RDF.new(version, encoding, standalone)
setup_rss10(rdf)
doc = REXML::Document.new(rdf.to_s)
xmldecl = doc.xml_decl
assert_equal(version, xmldecl.version)
assert_equal(encoding, xmldecl.encoding.to_s)
assert_equal(standalone, !xmldecl.standalone.nil?)
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"
resource = "http://hoge.com/hoge.png"
item_title = "item title"
item_link = "http://hoge.com/item"
image = RDF::Channel::Image.new(resource)
items = RDF::Channel::Items.new
items.Seq.lis << items.class::Seq::Li.new(item_link)
textinput = RDF::Channel::Textinput.new(resource)
rss_item = RDF::Item.new
rss_item.title = item_title
rss_item.link = item_link
rss_item.about = item_link
h = {
'title' => "fugafuga",
'link' => "http://hoge.com",
'description' => "fugafugafugafuga",
'image' => image,
'items' => items,
'textinput' => textinput,
}
channel = RDF::Channel.new(about)
%w(title link description image items textinput).each do |x|
channel.__send__("#{x}=", h[x])
end
doc = REXML::Document.new(make_RDF(<<-EOR))
#{channel}
<items>
#{rss_item}
</items>
EOR
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 = h[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_channel_items
item_link = "http://example.com/item"
items = RDF::Channel::Items.new
li = items.Seq.class::Li.new(item_link)
items.Seq.lis << li
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)
seq = i.elements[1]
assert_equal("Seq", seq.name)
assert_equal(@rdf_uri, seq.namespace)
assert_equal(1, seq.elements.size)
l = seq.elements[1]
assert_equal("li", l.name)
assert_equal(@rdf_uri, l.namespace)
assert_equal(item_link, l.attributes["resource"])
end
def test_seq
item_link = "http://example.com/item"
seq = RDF::Seq.new
li = seq.class::Li.new(item_link)
seq.lis << li
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)
assert_equal(1, s.elements.size)
l = s.elements[1]
assert_equal("li", l.name)
assert_equal(@rdf_uri, l.namespace)
assert_equal(item_link, l.attributes["resource"])
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"
h = {
'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}=", h[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(h[x], elem.text)
end
end
def test_item
about = "http://hoge.com"
h = {
'title' => "fugafuga",
'link' => "http://hoge.com/fuga",
'description' => "hogehogehoge",
}
item = RDF::Item.new(about)
%w(title link description).each do |x|
item.__send__("#{x}=", h[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(h[x], elem.text)
end
end
def test_textinput
about = "http://hoge.com"
h = {
'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}=", h[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(h[x], elem.text)
end
end
def test_to_xml
rss = RSS::Parser.parse(make_sample_RDF)
assert_equal(rss.to_s, rss.to_xml)
assert_equal(rss.to_s, rss.to_xml("1.0"))
rss09 = rss.to_xml("0.91") do |maker|
maker.channel.language = "en-us"
end
rss09 = RSS::Parser.parse(rss09)
assert_equal("0.91", rss09.rss_version)
assert_equal(["rss", "0.91", nil], rss09.feed_info)
rss20 = RSS::Parser.parse(rss.to_xml("2.0"))
assert_equal("2.0", rss20.rss_version)
assert_equal(["rss", "2.0", nil], rss20.feed_info)
atom_xml = rss.to_xml("atom") do |maker|
maker.channel.author = "Alice"
maker.channel.updated ||= Time.now
maker.items.each do |item|
item.updated ||= Time.now
end
end
atom = RSS::Parser.parse(atom_xml)
assert_equal(["atom", "1.0", "feed"], atom.feed_info)
end
end
end

412
test/rss/test_2.0.rb
Просмотреть файл

@ -1,412 +0,0 @@
# frozen_string_literal: false
require "rexml/document"
require_relative "rss-testcase"
module RSS
class TestRSS20Core < TestCase
def setup
@rss_version = "2.0"
end
def test_Rss
version = "1.0"
encoding = "UTF-8"
standalone = false
rss = Rss.new(@rss_version, version, encoding, standalone)
setup_rss20(rss)
doc = REXML::Document.new(rss.to_s(false))
xmldecl = doc.xml_decl
assert_equal(version, xmldecl.version)
assert_equal(encoding, xmldecl.encoding.to_s)
assert_equal(standalone, !xmldecl.standalone.nil?)
assert_equal("", doc.root.namespace)
assert_equal(@rss_version, doc.root.attributes["version"])
end
def test_not_displayed_xml_stylesheets
rss = Rss.new(@rss_version)
plain_rss = rss.to_s
3.times do
rss.xml_stylesheets.push(XMLStyleSheet.new)
assert_equal(plain_rss, rss.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|
rss = Rss.new(@rss_version)
setup_rss20(rss)
assert_xml_stylesheet_pis(attrs_ary, rss)
end
end
def test_channel
h = {
'title' => "fugafuga",
'link' => "http://hoge.com",
'description' => "fugafugafugafuga",
'language' => "en-us",
'copyright' => "Copyright 2002, Spartanburg Herald-Journal",
'managingEditor' => "geo@herald.com (George Matesky)",
'webMaster' => "betty@herald.com (Betty Guernsey)",
'pubDate' => Time.parse("Sat, 07 Sep 2002 00:00:01 GMT"),
'lastBuildDate' => Time.parse("Sat, 07 Sep 2002 09:42:31 GMT"),
'generator' => "MightyInHouse Content System v2.3",
'docs' => "http://blogs.law.harvard.edu/tech/rss",
'ttl' => "60",
'rating' => '(PICS-1.1 "http://www.rsac.org/ratingsv01.html" l gen true comment "RSACi North America Server" for "http://www.rsac.org" on "1996.04.16T08:15-0500" r (n 0 s 0 v 0 l 0))',
}
categories = [
{
:content => "Newspapers",
},
{
:domain => "Syndic8",
:content => "1765",
}
]
channel = Rss::Channel.new
elems = %w(title link description language copyright
managingEditor webMaster pubDate lastBuildDate
generator docs ttl rating)
elems.each do |x|
value = h[x]
value = value.rfc822 if %w(pubDate lastBuildDate).include?(x)
channel.__send__("#{x}=", value)
end
categories.each do |cat|
channel.categories << Rss::Channel::Category.new(cat[:domain],
cat[:content])
end
doc = REXML::Document.new(make_rss20(channel.to_s))
c = doc.root.elements[1]
elems.each do |x|
elem = c.elements[x]
assert_equal(x, elem.name)
assert_equal("", elem.namespace)
expected = h[x]
case x
when "pubDate", "lastBuildDate"
assert_equal(expected, Time.parse(elem.text))
when "ttl"
expected = channel.__send__(x)
assert_equal(expected, elem.text.to_i)
else
assert_equal(expected, elem.text)
end
end
categories.each_with_index do |cat, i|
cat = cat.dup
cat[:domain] ||= nil
category = c.elements["category[#{i+1}]"]
actual = {
:domain => category.attributes["domain"],
:content => category.text,
}
assert_equal(cat, actual)
end
end
def test_channel_cloud
cloud_params = {
:domain => "rpc.sys.com",
:port => "80",
:path => "/RPC2",
:registerProcedure => "myCloud.rssPleaseNotify",
:protocol => "xml-rpc",
}
cloud = Rss::Channel::Cloud.new(cloud_params[:domain],
cloud_params[:port],
cloud_params[:path],
cloud_params[:registerProcedure],
cloud_params[:protocol])
cloud_params[:port] = cloud.port
doc = REXML::Document.new(cloud.to_s)
cloud_elem = doc.root
actual = {}
cloud_elem.attributes.each do |name, value|
value = value.to_i if name == "port"
actual[name.intern] = value
end
assert_equal(cloud_params, actual)
end
def test_channel_image
image_params = {
:url => "http://hoge.com/hoge.png",
:title => "fugafuga",
:link => "http://hoge.com",
:width => "144",
:height => "400",
:description => "an image",
}
image = Rss::Channel::Image.new(image_params[:url],
image_params[:title],
image_params[:link],
image_params[:width],
image_params[:height],
image_params[:description])
doc = REXML::Document.new(image.to_s)
image_elem = doc.root
image_params.each do |name, value|
value = image.__send__(name)
actual = image_elem.elements[name.to_s].text
actual = actual.to_i if [:width, :height].include?(name)
assert_equal(value, actual)
end
end
def test_channel_textInput
textInput_params = {
:title => "fugafuga",
:description => "text hoge fuga",
:name => "hoge",
:link => "http://hoge.com",
}
textInput = Rss::Channel::TextInput.new(textInput_params[:title],
textInput_params[:description],
textInput_params[:name],
textInput_params[:link])
doc = REXML::Document.new(textInput.to_s)
input_elem = doc.root
textInput_params.each do |name, value|
actual = input_elem.elements[name.to_s].text
assert_equal(value, actual)
end
end
def test_channel_skip_days
skipDays_values = [
"Sunday",
"Monday",
]
skipDays = Rss::Channel::SkipDays.new
skipDays_values.each do |value|
skipDays.days << Rss::Channel::SkipDays::Day.new(value)
end
doc = REXML::Document.new(skipDays.to_s)
days_elem = doc.root
skipDays_values.each_with_index do |value, i|
assert_equal(value, days_elem.elements[i + 1].text)
end
end
def test_channel_skip_hours
skipHours_values = [
"0",
"13",
]
skipHours = Rss::Channel::SkipHours.new
skipHours_values.each do |value|
skipHours.hours << Rss::Channel::SkipHours::Hour.new(value)
end
doc = REXML::Document.new(skipHours.to_s)
hours_elem = doc.root
skipHours_values.each_with_index do |value, i|
expected = skipHours.hours[i].content
assert_equal(expected, hours_elem.elements[i + 1].text.to_i)
end
end
def test_item
h = {
'title' => "fugafuga",
'link' => "http://hoge.com/",
'description' => "text hoge fuga",
'author' => "oprah@oxygen.net",
'comments' => "http://www.myblog.org/cgi-local/mt/mt-comments.cgi?entry_id=290",
'pubDate' => Time.parse("Sat, 07 Sep 2002 00:00:01 GMT"),
}
categories = [
{
:content => "Newspapers",
},
{
:domain => "Syndic8",
:content => "1765",
}
]
channel = Rss::Channel.new
channel.title = "title"
channel.link = "http://example.com/"
channel.description = "description"
item = Rss::Channel::Item.new
channel.items << item
elems = %w(title link description author comments pubDate)
elems.each do |x|
value = h[x]
value = value.rfc822 if x == "pubDate"
item.__send__("#{x}=", value)
end
categories.each do |cat|
item.categories << Rss::Channel::Category.new(cat[:domain],
cat[:content])
end
doc = REXML::Document.new(channel.to_s)
channel_elem = doc.root
item_elem = channel_elem.elements["item[1]"]
elems.each do |x|
elem = item_elem.elements[x]
assert_equal(x, elem.name)
assert_equal("", elem.namespace)
expected = h[x]
case x
when "pubDate"
assert_equal(expected, Time.parse(elem.text))
else
assert_equal(expected, elem.text)
end
end
categories.each_with_index do |cat, i|
cat = cat.dup
cat[:domain] ||= nil
category = item_elem.elements["category[#{i+1}]"]
actual = {
:domain => category.attributes["domain"],
:content => category.text,
}
assert_equal(cat, actual)
end
end
def test_item_enclosure
enclosure_params = {
:url => "http://www.scripting.com/mp3s/weatherReportSuite.mp3",
:length => "12216320",
:type => "audio/mpeg",
}
enclosure = Rss::Channel::Item::Enclosure.new(enclosure_params[:url],
enclosure_params[:length],
enclosure_params[:type])
enclosure_params[:length] = enclosure.length
doc = REXML::Document.new(enclosure.to_s)
enclosure_elem = doc.root
actual = {}
enclosure_elem.attributes.each do |name, value|
value = value.to_i if name == "length"
actual[name.intern] = value
end
assert_equal(enclosure_params, actual)
end
def test_item_guid
test_params = [
{
:content => "http://some.server.com/weblogItem3207",
},
{
:isPermaLink => "true",
:content => "http://inessential.com/2002/09/01.php#a2",
},
]
test_params.each do |guid_params|
guid = Rss::Channel::Item::Guid.new(guid_params[:isPermaLink],
guid_params[:content])
if guid_params.has_key?(:isPermaLink)
guid_params[:isPermaLink] = guid.isPermaLink
end
if guid.isPermaLink.nil?
assert_equal(true, guid.PermaLink?)
else
assert_equal(guid.isPermaLink, guid.PermaLink?)
end
doc = REXML::Document.new(guid.to_s)
guid_elem = doc.root
actual = {}
actual[:content] = guid_elem.text if guid_elem.text
guid_elem.attributes.each do |name, value|
value = value == "true" if name == "isPermaLink"
actual[name.intern] = value
end
assert_equal(guid_params, actual)
end
end
def test_item_source
source_params = {
:url => "http://www.tomalak.org/links2.xml",
:content => "Tomalak's Realm",
}
source = Rss::Channel::Item::Source.new(source_params[:url],
source_params[:content])
doc = REXML::Document.new(source.to_s)
source_elem = doc.root
actual = {}
actual[:content] = source_elem.text
source_elem.attributes.each do |name, value|
actual[name.intern] = value
end
assert_equal(source_params, actual)
end
def test_to_xml
rss = RSS::Parser.parse(make_sample_rss20)
assert_equal(rss.to_s, rss.to_xml)
assert_equal(rss.to_s, rss.to_xml("2.0"))
rss09_xml = rss.to_xml("0.91") do |maker|
setup_dummy_image(maker)
end
rss09 = RSS::Parser.parse(rss09_xml)
assert_equal("0.91", rss09.rss_version)
rss10 = rss.to_xml("1.0") do |maker|
maker.channel.about = "http://www.example.com/index.rdf"
end
rss10 = RSS::Parser.parse(rss10)
assert_equal("1.0", rss10.rss_version)
atom_xml = rss.to_xml("atom1.0") do |maker|
maker.channel.id = "http://www.example.com/atom.xml"
maker.channel.author = "Alice"
maker.channel.updated = Time.now
maker.items.each do |item|
item.author = "Bob"
item.updated = Time.now
end
end
atom = RSS::Parser.parse(atom_xml)
assert_equal(["atom", "1.0", "feed"], atom.feed_info)
end
end
end

104
test/rss/test_accessor.rb
Просмотреть файл

@ -1,104 +0,0 @@
# frozen_string_literal: false
require_relative "rss-testcase"
require "rss/1.0"
require "rss/2.0"
require "rss/syndication"
require "rss/image"
module RSS
class TestAccessor < TestCase
def test_date
channel = Rss::Channel.new
channel.pubDate = nil
assert_nil(channel.pubDate)
time = Time.now
channel.pubDate = time
assert_equal(time, channel.pubDate)
time = Time.parse(Time.now.rfc822)
channel.pubDate = time.rfc822
assert_equal(time, channel.pubDate)
time = Time.parse(Time.now.iso8601)
value = time.iso8601
assert_not_available_value("pubDate", value) do
channel.pubDate = value
end
channel.do_validate = false
time = Time.parse(Time.now.iso8601)
value = time.iso8601
channel.pubDate = value
assert_equal(time, channel.pubDate)
channel.pubDate = nil
assert_nil(channel.pubDate)
end
def test_integer
image_item = RDF::Item::ImageItem.new
image_item.width = nil
assert_nil(image_item.width)
width = 10
image_item.width = width
assert_equal(width, image_item.width)
width = 10.0
image_item.width = width
assert_equal(width, image_item.width)
width = "10"
image_item.width = width
assert_equal(width.to_i, image_item.width)
width = "10.0"
assert_not_available_value("image:width", width) do
image_item.width = width
end
image_item.do_validate = false
width = "10.0"
image_item.width = width
assert_equal(width.to_i, image_item.width)
image_item.width = nil
assert_nil(image_item.width)
end
def test_positive_integer
channel = RDF::Channel.new
channel.sy_updateFrequency = nil
assert_nil(channel.sy_updateFrequency)
freq = 10
channel.sy_updateFrequency = freq
assert_equal(freq, channel.sy_updateFrequency)
freq = 10.0
channel.sy_updateFrequency = freq
assert_equal(freq, channel.sy_updateFrequency)
freq = "10"
channel.sy_updateFrequency = freq
assert_equal(freq.to_i, channel.sy_updateFrequency)
freq = "10.0"
assert_not_available_value("sy:updateFrequency", freq) do
channel.sy_updateFrequency = freq
end
channel.do_validate = false
freq = "10.0"
channel.sy_updateFrequency = freq
assert_equal(freq.to_i, channel.sy_updateFrequency)
channel.sy_updateFrequency = nil
assert_nil(channel.sy_updateFrequency)
end
end
end

684
test/rss/test_atom.rb
Просмотреть файл

@ -1,684 +0,0 @@
# frozen_string_literal: false
require "rexml/document"
require_relative "rss-testcase"
require "rss/atom"
module RSS
class TestAtomCore < TestCase
def setup
@uri = "http://www.w3.org/2005/Atom"
@xhtml_uri = "http://www.w3.org/1999/xhtml"
end
def test_feed
version = "1.0"
encoding = "UTF-8"
standalone = false
feed = Atom::Feed.new(version, encoding, standalone)
assert_equal("", feed.to_s)
author = feed.class::Author.new
name = feed.class::Author::Name.new
name.content = "an author"
author.name = name
assert_not_equal("", author.to_s)
feed.authors << author
assert_equal("", feed.to_s)
id = feed.class::Id.new
id.content = "http://example.com/atom.xml"
assert_not_equal("", id.to_s)
feed.id = id
assert_equal("", feed.to_s)
title = feed.class::Title.new
title.content = "a title"
assert_not_equal("", title.to_s)
feed.title = title
assert_equal("", feed.to_s)
updated = feed.class::Updated.new
updated.content = Time.now
assert_not_equal("", updated.to_s)
feed.updated = updated
assert_not_equal("", feed.to_s)
feed.authors.clear
assert_equal("", feed.to_s)
entry = Atom::Feed::Entry.new
setup_entry(entry)
assert_not_equal("", entry.to_s)
author = entry.authors.first
entry.authors.clear
assert_equal("", entry.to_s)
entry.parent = feed
assert_equal("", entry.to_s)
feed.authors << author
assert_not_equal("", entry.to_s)
feed.authors.clear
feed.entries << entry
assert_equal("", feed.to_s)
entry.authors << author
assert_not_equal("", entry.to_s)
assert_not_equal("", feed.to_s)
doc = REXML::Document.new(feed.to_s)
xmldecl = doc.xml_decl
assert_equal(version, xmldecl.version)
assert_equal(encoding, xmldecl.encoding.to_s)
assert_equal(standalone, !xmldecl.standalone.nil?)
assert_equal(@uri, doc.root.namespace)
end
def test_entry
version = "1.0"
encoding = "UTF-8"
standalone = false
entry = Atom::Entry.new(version, encoding, standalone)
setup_entry(entry)
author = entry.authors.first
entry.authors.clear
assert_equal("", entry.to_s)
source = Atom::Entry::Source.new
source.authors << author
entry.source = source
assert_not_equal("", entry.to_s)
doc = REXML::Document.new(entry.to_s)
xmldecl = doc.xml_decl
assert_equal(version, xmldecl.version)
assert_equal(encoding, xmldecl.encoding.to_s)
assert_equal(standalone, !xmldecl.standalone.nil?)
assert_equal(@uri, doc.root.namespace)
end
def test_not_displayed_xml_stylesheets
feed = Atom::Feed.new
plain_feed = feed.to_s
3.times do
feed.xml_stylesheets.push(XMLStyleSheet.new)
assert_equal(plain_feed, feed.to_s)
end
end
def test_atom_author
assert_atom_person_to_s(Atom::Feed::Author)
assert_atom_person_to_s(Atom::Feed::Entry::Author)
assert_atom_person_to_s(Atom::Entry::Author)
assert_atom_person_to_s(Atom::Feed::Entry::Source::Author)
assert_atom_person_to_s(Atom::Entry::Source::Author)
end
def test_atom_category
assert_atom_category_to_s(Atom::Feed::Category)
assert_atom_category_to_s(Atom::Feed::Entry::Category)
assert_atom_category_to_s(Atom::Entry::Category)
assert_atom_category_to_s(Atom::Feed::Entry::Source::Category)
assert_atom_category_to_s(Atom::Entry::Source::Category)
end
def test_atom_contributor
assert_atom_person_to_s(Atom::Feed::Contributor)
assert_atom_person_to_s(Atom::Feed::Entry::Contributor)
assert_atom_person_to_s(Atom::Entry::Contributor)
assert_atom_person_to_s(Atom::Feed::Entry::Source::Contributor)
assert_atom_person_to_s(Atom::Entry::Source::Contributor)
end
def test_atom_generator
assert_atom_generator_to_s(Atom::Feed::Generator)
assert_atom_generator_to_s(Atom::Feed::Entry::Source::Generator)
assert_atom_generator_to_s(Atom::Entry::Source::Generator)
end
def test_atom_icon
assert_atom_icon_to_s(Atom::Feed::Icon)
assert_atom_icon_to_s(Atom::Feed::Entry::Source::Icon)
assert_atom_icon_to_s(Atom::Entry::Source::Icon)
end
def test_atom_id
assert_atom_id_to_s(Atom::Feed::Id)
assert_atom_id_to_s(Atom::Feed::Entry::Id)
assert_atom_id_to_s(Atom::Entry::Id)
assert_atom_id_to_s(Atom::Feed::Entry::Source::Id)
assert_atom_id_to_s(Atom::Entry::Source::Id)
end
def test_atom_link
assert_atom_link_to_s(Atom::Feed::Link)
assert_atom_link_to_s(Atom::Feed::Entry::Link)
assert_atom_link_to_s(Atom::Entry::Link)
assert_atom_link_to_s(Atom::Feed::Entry::Source::Link)
assert_atom_link_to_s(Atom::Entry::Source::Link)
end
def test_atom_logo
assert_atom_logo_to_s(Atom::Feed::Logo)
assert_atom_logo_to_s(Atom::Feed::Entry::Source::Logo)
assert_atom_logo_to_s(Atom::Entry::Source::Logo)
end
def test_atom_rights
assert_atom_text_construct_to_s(Atom::Feed::Rights)
assert_atom_text_construct_to_s(Atom::Feed::Entry::Rights)
assert_atom_text_construct_to_s(Atom::Entry::Rights)
assert_atom_text_construct_to_s(Atom::Feed::Entry::Source::Rights)
assert_atom_text_construct_to_s(Atom::Entry::Source::Rights)
end
def test_atom_subtitle
assert_atom_text_construct_to_s(Atom::Feed::Subtitle)
assert_atom_text_construct_to_s(Atom::Feed::Entry::Source::Subtitle)
assert_atom_text_construct_to_s(Atom::Entry::Source::Subtitle)
end
def test_atom_title
assert_atom_text_construct_to_s(Atom::Feed::Title)
assert_atom_text_construct_to_s(Atom::Feed::Entry::Title)
assert_atom_text_construct_to_s(Atom::Entry::Title)
assert_atom_text_construct_to_s(Atom::Feed::Entry::Source::Title)
assert_atom_text_construct_to_s(Atom::Entry::Source::Title)
end
def test_atom_updated
assert_atom_date_construct_to_s(Atom::Feed::Updated)
assert_atom_date_construct_to_s(Atom::Feed::Entry::Updated)
assert_atom_date_construct_to_s(Atom::Entry::Updated)
assert_atom_date_construct_to_s(Atom::Feed::Entry::Source::Updated)
assert_atom_date_construct_to_s(Atom::Entry::Source::Updated)
end
def test_atom_content
assert_atom_content_to_s(Atom::Feed::Entry::Content)
assert_atom_content_to_s(Atom::Entry::Content)
end
def test_atom_published
assert_atom_date_construct_to_s(Atom::Feed::Entry::Published)
assert_atom_date_construct_to_s(Atom::Entry::Published)
end
def test_atom_summary
assert_atom_text_construct_to_s(Atom::Feed::Entry::Summary)
assert_atom_text_construct_to_s(Atom::Entry::Summary)
end
def test_to_xml(with_convenience_way=true)
atom = RSS::Parser.parse(make_feed)
assert_equal(atom.to_s, atom.to_xml)
assert_equal(atom.to_s, atom.to_xml("atom"))
assert_equal(atom.to_s, atom.to_xml("atom1.0"))
assert_equal(atom.to_s, atom.to_xml("atom1.0:feed"))
assert_equal(atom.to_s, atom.to_xml("atom:feed"))
rss09_xml = atom.to_xml("0.91") do |maker|
maker.channel.language = "en-us"
maker.channel.link = "http://example.com/"
if with_convenience_way
maker.channel.description = atom.title.content
else
maker.channel.description {|d| d.content = atom.title.content}
end
maker.image.url = "http://example.com/logo.png"
maker.image.title = "Logo"
end
rss09 = RSS::Parser.parse(rss09_xml)
assert_equal(["rss", "0.91", nil], rss09.feed_info)
rss20_xml = atom.to_xml("2.0") do |maker|
maker.channel.link = "http://example.com/"
if with_convenience_way
maker.channel.description = atom.title.content
else
maker.channel.description {|d| d.content = atom.title.content}
end
end
rss20 = RSS::Parser.parse(rss20_xml)
assert_equal("2.0", rss20.rss_version)
assert_equal(["rss", "2.0", nil], rss20.feed_info)
end
def test_to_xml_with_new_api_since_018
test_to_xml(false)
end
private
def setup_entry(entry)
_wrap_assertion do
assert_equal("", entry.to_s)
author = entry.class::Author.new
name = entry.class::Author::Name.new
name.content = "an author"
author.name = name
assert_not_equal("", author.to_s)
entry.authors << author
assert_equal("", entry.to_s)
id = entry.class::Id.new
id.content = "http://example.com/atom.xml"
assert_not_equal("", id.to_s)
entry.id = id
assert_equal("", entry.to_s)
title = entry.class::Title.new
title.content = "a title"
assert_not_equal("", title.to_s)
entry.title = title
assert_equal("", entry.to_s)
updated = entry.class::Updated.new
updated.content = Time.now
assert_not_equal("", updated.to_s)
entry.updated = updated
assert_not_equal("", entry.to_s)
end
end
def assert_atom_person_to_s(target_class)
_wrap_assertion do
name = "A person"
uri = "http://example.com/person/"
email = "person@example.com"
target = target_class.new
assert_equal("", target.to_s)
target = target_class.new
person_name = target_class::Name.new
person_name.content = name
target.name = person_name
xml_target = REXML::Document.new(target.to_s).root
assert_equal(["name"], xml_target.elements.collect {|e| e.name})
assert_equal([name], xml_target.elements.collect {|e| e.text})
person_uri = target_class::Uri.new
person_uri.content = uri
target.uri = person_uri
xml_target = REXML::Document.new(target.to_s).root
assert_equal(["name", "uri"], xml_target.elements.collect {|e| e.name})
assert_equal([name, uri], xml_target.elements.collect {|e| e.text})
person_email = target_class::Email.new
person_email.content = email
target.email = person_email
xml_target = REXML::Document.new(target.to_s).root
assert_equal(["name", "uri", "email"],
xml_target.elements.collect {|e| e.name})
assert_equal([name, uri, email],
xml_target.elements.collect {|e| e.text})
end
end
def assert_atom_category_to_s(target_class)
_wrap_assertion do
term = "music"
scheme = "http://example.com/music"
label = "Music"
category = target_class.new
assert_equal("", category.to_s)
category = target_class.new
category.scheme = scheme
assert_equal("", category.to_s)
category = target_class.new
category.label = label
assert_equal("", category.to_s)
category = target_class.new
category.scheme = scheme
category.label = label
assert_equal("", category.to_s)
category = target_class.new
category.term = term
xml = REXML::Document.new(category.to_s).root
assert_rexml_element([], {"term" => term}, nil, xml)
category = target_class.new
category.term = term
category.scheme = scheme
xml = REXML::Document.new(category.to_s).root
assert_rexml_element([], {"term" => term, "scheme" => scheme}, nil, xml)
category = target_class.new
category.term = term
category.label = label
xml = REXML::Document.new(category.to_s).root
assert_rexml_element([], {"term" => term, "label" => label}, nil, xml)
category = target_class.new
category.term = term
category.scheme = scheme
category.label = label
xml = REXML::Document.new(category.to_s).root
attrs = {"term" => term, "scheme" => scheme, "label" => label}
assert_rexml_element([], attrs, nil, xml)
end
end
def assert_atom_generator_to_s(target_class)
_wrap_assertion do
content = "Feed generator"
uri = "http://example.com/generator"
version = "0.0.1"
generator = target_class.new
assert_equal("", generator.to_s)
generator = target_class.new
generator.uri = uri
assert_equal("", generator.to_s)
generator = target_class.new
generator.version = version
assert_equal("", generator.to_s)
generator = target_class.new
generator.uri = uri
generator.version = version
assert_equal("", generator.to_s)
generator = target_class.new
generator.content = content
xml = REXML::Document.new(generator.to_s).root
assert_rexml_element([], {}, content, xml)
generator = target_class.new
generator.content = content
generator.uri = uri
xml = REXML::Document.new(generator.to_s).root
assert_rexml_element([], {"uri" => uri}, content, xml)
generator = target_class.new
generator.content = content
generator.version = version
xml = REXML::Document.new(generator.to_s).root
assert_rexml_element([], {"version" => version}, content, xml)
generator = target_class.new
generator.content = content
generator.uri = uri
generator.version = version
xml = REXML::Document.new(generator.to_s).root
assert_rexml_element([], {"uri" => uri, "version" => version},
content, xml)
end
end
def assert_atom_icon_to_s(target_class)
_wrap_assertion do
content = "http://example.com/icon.png"
icon = target_class.new
assert_equal("", icon.to_s)
icon = target_class.new
icon.content = content
xml = REXML::Document.new(icon.to_s).root
assert_rexml_element([], {}, content, xml)
end
end
def assert_atom_id_to_s(target_class)
_wrap_assertion do
content = "http://example.com/1"
id = target_class.new
assert_equal("", id.to_s)
id = target_class.new
id.content = content
xml = REXML::Document.new(id.to_s).root
assert_rexml_element([], {}, content, xml)
end
end
def assert_atom_link_to_s(target_class)
_wrap_assertion do
href = "http://example.com/atom.xml"
optvs = {
'rel' => "self",
'type' => "application/atom+xml",
'hreflang' => "ja",
'title' => "Atom Feed",
'length' => "801",
}
link = target_class.new
assert_equal("", link.to_s)
link = target_class.new
link.href = href
xml = REXML::Document.new(link.to_s).root
assert_rexml_element([], {"href" => href}, nil, xml)
optional_arguments = %w(rel type hreflang title length)
optional_arguments.each do |name|
rest = optional_arguments.reject {|x| x == name}
link = target_class.new
link.__send__("#{name}=", optvs[name])
assert_equal("", link.to_s)
rest.each do |n|
link.__send__("#{n}=", optvs[n])
assert_equal("", link.to_s)
end
link = target_class.new
link.href = href
link.__send__("#{name}=", optvs[name])
attrs = [["href", href], [name, optvs[name]]]
xml = REXML::Document.new(link.to_s).root
assert_rexml_element([], attrs, nil, xml)
rest.each do |n|
link.__send__("#{n}=", optvs[n])
attrs << [n, optvs[n]]
xml = REXML::Document.new(link.to_s).root
assert_rexml_element([], attrs, nil, xml)
end
end
end
end
def assert_atom_logo_to_s(target_class)
_wrap_assertion do
content = "http://example.com/logo.png"
logo = target_class.new
assert_equal("", logo.to_s)
logo = target_class.new
logo.content = content
xml = REXML::Document.new(logo.to_s).root
assert_rexml_element([], {}, content, xml)
end
end
def assert_atom_text_construct_to_s(target_class)
_wrap_assertion do
text_content = "plain text"
html_content = "<em>#{text_content}</em>"
xhtml_uri = "http://www.w3.org/1999/xhtml"
xhtml_em = RSS::XML::Element.new("em", nil, xhtml_uri, {}, text_content)
xhtml_content = RSS::XML::Element.new("div", nil, xhtml_uri,
{"xmlns" => xhtml_uri},
[xhtml_em])
text = target_class.new
assert_equal("", text.to_s)
text = target_class.new
text.type = "text"
assert_equal("", text.to_s)
text = target_class.new
text.content = text_content
xml = REXML::Document.new(text.to_s).root
assert_rexml_element([], {}, text_content, xml)
text = target_class.new
text.type = "text"
text.content = text_content
xml = REXML::Document.new(text.to_s).root
assert_rexml_element([], {"type" => "text"}, text_content, xml)
text = target_class.new
text.type = "html"
text.content = html_content
xml = REXML::Document.new(text.to_s).root
assert_rexml_element([], {"type" => "html"}, html_content, xml)
text = target_class.new
text.type = "xhtml"
text.content = xhtml_content
assert_equal("", text.to_s)
text = target_class.new
text.type = "xhtml"
text.__send__(target_class.xml_setter, xhtml_content)
xml = REXML::Document.new(text.to_s).root
assert_rexml_element([[xhtml_uri, "div"]], {"type" => "xhtml"},
nil, xml)
assert_rexml_element([[xhtml_uri, "em"]], nil, nil, xml.elements[1])
assert_rexml_element([], {}, text_content, xml.elements[1].elements[1])
text = target_class.new
text.type = "xhtml"
text.__send__(target_class.xml_setter, xhtml_em)
xml = REXML::Document.new(text.to_s).root
assert_rexml_element([[xhtml_uri, "div"]], {"type" => "xhtml"},
nil, xml)
assert_rexml_element([[xhtml_uri, "em"]], nil, nil, xml.elements[1])
assert_rexml_element([], {}, text_content, xml.elements[1].elements[1])
end
end
def assert_atom_date_construct_to_s(target_class)
_wrap_assertion do
date = target_class.new
assert_equal("", date.to_s)
[
"2003-12-13T18:30:02Z",
"2003-12-13T18:30:02.25Z",
"2003-12-13T18:30:02+01:00",
"2003-12-13T18:30:02.25+01:00",
].each do |content|
date = target_class.new
date.content = content
xml = REXML::Document.new(date.to_s).root
assert_rexml_element([], {}, content, xml, :time)
date = target_class.new
date.content = Time.parse(content)
xml = REXML::Document.new(date.to_s).root
assert_rexml_element([], {}, content, xml, :time)
end
end
end
def assert_atom_content_to_s(target_class)
_wrap_assertion do
assert_atom_text_construct_to_s(target_class)
assert_atom_content_inline_other_xml_to_s(target_class)
assert_atom_content_inline_other_text_to_s(target_class)
assert_atom_content_inline_other_base64_to_s(target_class)
assert_atom_content_out_of_line_to_s(target_class)
end
end
def assert_atom_content_inline_other_xml_to_s(target_class)
_wrap_assertion do
content = target_class.new
content.type = "text/xml"
assert_equal("", content.to_s)
content = target_class.new
content.type = "text/xml"
content.xml = RSS::XML::Element.new("em")
xml = REXML::Document.new(content.to_s).root
assert_rexml_element([["", "em"]], {"type" => "text/xml"}, nil, xml)
end
end
def assert_atom_content_inline_other_text_to_s(target_class)
_wrap_assertion do
content = target_class.new
content.type = "text/plain"
assert_equal("", content.to_s)
content = target_class.new
content.type = "text/plain"
content.xml = RSS::XML::Element.new("em")
assert_equal("", content.to_s)
content = target_class.new
content.type = "text/plain"
content.content = "content"
xml = REXML::Document.new(content.to_s).root
assert_rexml_element([], {"type" => "text/plain"}, "content", xml)
end
end
def assert_atom_content_inline_other_base64_to_s(target_class)
_wrap_assertion do
type = "image/png"
png_file = File.join(File.dirname(__FILE__), "dot.png")
original_content = File.open(png_file, "rb") do |file|
file.read.force_encoding("binary")
end
content = target_class.new
content.type = type
content.content = original_content
xml = REXML::Document.new(content.to_s).root
assert_rexml_element([], {"type" => type},
[original_content].pack("m").delete("\n"),
xml)
end
end
def assert_atom_content_out_of_line_to_s(target_class)
_wrap_assertion do
type = "application/zip"
src = "http://example.com/xxx.zip"
content = target_class.new
assert(!content.out_of_line?)
content.src = src
assert(content.out_of_line?)
xml = REXML::Document.new(content.to_s).root
assert_rexml_element([], {"src" => src}, nil, xml)
content = target_class.new
assert(!content.out_of_line?)
content.type = type
assert(!content.out_of_line?)
content.src = src
assert(content.out_of_line?)
xml = REXML::Document.new(content.to_s).root
assert_rexml_element([], {"type" => type, "src" => src}, nil, xml)
end
end
end
end

105
test/rss/test_content.rb
Просмотреть файл

@ -1,105 +0,0 @@
# frozen_string_literal: false
require "cgi"
require "rexml/document"
require_relative "rss-testcase"
require "rss/content"
module RSS
class TestContent < TestCase
def setup
@prefix = "content"
@uri = "http://purl.org/rss/1.0/modules/content/"
@elems = {
:encoded => "<em>ATTENTION</em>",
}
@content_nodes = @elems.collect do |name, value|
"<#{@prefix}:#{name}>#{CGI.escapeHTML(value.to_s)}</#{@prefix}:#{name}>"
end.join("\n")
@rss10_source = make_RDF(<<-EOR, {@prefix => @uri})
#{make_channel()}
#{make_image()}
#{make_item(@content_nodes)}
#{make_textinput()}
EOR
@rss10 = Parser.parse(@rss10_source)
@rss20_source = make_rss20(<<-EOR, {@prefix => @uri})
#{make_channel20(make_item20(@content_nodes))}
EOR
@rss20 = Parser.parse(@rss20_source)
end
def test_parser
assert_nothing_raised do
Parser.parse(@rss10_source)
end
assert_nothing_raised do
Parser.parse(@rss20_source)
end
@elems.each do |tag, value|
tag_name = "#{@prefix}:#{tag}"
content_encodes = make_element(tag_name, {}, value) * 2
assert_too_much_tag(tag.to_s, "item") do
Parser.parse(make_RDF(<<-EOR, {@prefix => @uri}))
#{make_channel}
#{make_item(content_encodes)}
EOR
end
assert_too_much_tag(tag.to_s, "item") do
Parser.parse(make_rss20(<<-EOR, {@prefix => @uri}))
#{make_channel20(make_item20(content_encodes))}
EOR
end
end
end
def test_accessor
new_value = {
:encoded => "<![CDATA[<it>hoge</it>]]>",
}
@elems.each do |name, value|
[@rss10, @rss20].each do |rss|
meth = "#{RSS::CONTENT_PREFIX}_#{name}"
parent = rss.items.last
assert_equal(value, parent.__send__(meth))
parent.__send__("#{meth}=", new_value[name].to_s)
assert_equal(new_value[name], parent.__send__(meth))
end
end
end
def test_to_s
@elems.each do |name, value|
excepted = make_element("#{@prefix}:#{name}", {}, value)
meth = "#{RSS::CONTENT_PREFIX}_#{name}_element"
[@rss10, @rss20].each do |rss|
assert_equal(excepted, rss.items.last.__send__(meth))
end
end
[@rss10_source, @rss20_source].each do |source|
REXML::Document.new(source).root.each_element do |parent|
next unless parent.name != "item"
parent.each_element do |elem|
if elem.namespace == @uri
assert_equal(elem.text, @elems[elem.name.intern].to_s)
end
end
end
end
end
end
end

270
test/rss/test_dublincore.rb
Просмотреть файл

@ -1,270 +0,0 @@
# frozen_string_literal: false
require "cgi"
require "rexml/document"
require_relative "rss-testcase"
require "rss/1.0"
require "rss/dublincore"
module RSS
class TestDublinCore < TestCase
def setup
@rss10_parents = [%w(channel), %w(image), %w(item), %w(textinput)]
@rss10_source = make_RDF(<<-EOR, {DC_PREFIX => DC_URI})
#{make_channel(DC_NODES)}
#{make_image(DC_NODES)}
#{make_item(DC_NODES)}
#{make_textinput(DC_NODES)}
EOR
@rss20_parents = [%w(channel), %w(items last)]
@rss20_source = make_rss20(<<-EOR, {DC_PREFIX => DC_URI})
#{make_channel20(DC_NODES + make_item20(DC_NODES))}
EOR
@atom_feed_parents = [[], %w(entries last)]
@atom_feed_source = make_feed(<<-EOR, {DC_PREFIX => DC_URI})
#{DC_NODES}
#{make_entry(DC_NODES)}
EOR
@atom_entry_parents = [[]]
@atom_entry_source = make_entry_document(<<-EOR, {DC_PREFIX => DC_URI})
#{DC_NODES}
EOR
end
def test_parser
rss10_maker = Proc.new do |content, xmlns|
make_RDF(<<-EOR, xmlns)
#{make_channel(content)}
#{make_image(content)}
#{make_item(content)}
#{make_textinput(content)}
EOR
end
assert_dc_parse(@rss10_source, @rss10_parents, false, &rss10_maker)
assert_dc_parse(@rss10_source, @rss10_parents, true, &rss10_maker)
rss20_maker = Proc.new do |content, xmlns|
make_rss20(<<-EOR, xmlns)
#{make_channel20(content + make_item20(content))}
EOR
end
assert_dc_parse(@rss20_source, @rss20_parents, false, &rss20_maker)
assert_dc_parse(@rss20_source, @rss20_parents, true, &rss20_maker)
atom_feed_maker = Proc.new do |content, xmlns|
make_feed(<<-EOR, xmlns)
#{content}
#{make_entry(content)}
EOR
end
assert_dc_parse(@atom_feed_source, @atom_feed_parents, false,
&atom_feed_maker)
assert_dc_parse(@atom_feed_source, @atom_feed_parents, true,
&atom_feed_maker)
atom_entry_maker = Proc.new do |content, xmlns|
make_entry_document(<<-EOR, xmlns)
#{content}
EOR
end
assert_dc_parse(@atom_entry_source, @atom_entry_parents, false,
&atom_entry_maker)
assert_dc_parse(@atom_entry_source, @atom_entry_parents, true,
&atom_entry_maker)
end
def test_singular_accessor
assert_dc_singular_accessor(@rss10_source, @rss10_parents)
assert_dc_singular_accessor(@rss20_source, @rss20_parents)
assert_dc_singular_accessor(@atom_feed_source, @atom_feed_parents)
assert_dc_singular_accessor(@atom_entry_source, @atom_entry_parents)
end
def test_plural_accessor
assert_dc_plural_accessor(@rss10_source, @rss10_parents, false)
assert_dc_plural_accessor(@rss10_source, @rss10_parents, true)
assert_dc_plural_accessor(@rss20_source, @rss20_parents, false)
assert_dc_plural_accessor(@rss20_source, @rss20_parents, true)
assert_dc_plural_accessor(@atom_feed_source, @atom_feed_parents, false)
assert_dc_plural_accessor(@atom_feed_source, @atom_feed_parents, true)
assert_dc_plural_accessor(@atom_entry_source, @atom_entry_parents, false)
assert_dc_plural_accessor(@atom_entry_source, @atom_entry_parents, true)
end
def test_to_s
assert_dc_to_s(@rss10_source, @rss10_parents, false)
assert_dc_to_s(@rss10_source, @rss10_parents, true)
targets = ["channel", "channel/item[3]"]
assert_dc_to_s(@rss20_source, @rss20_parents, false, targets)
assert_dc_to_s(@rss20_source, @rss20_parents, true, targets)
targets = [".", "entry"]
assert_dc_to_s(@atom_feed_source, @atom_feed_parents, false, targets)
assert_dc_to_s(@atom_feed_source, @atom_feed_parents, true, targets)
targets = ["."]
assert_dc_to_s(@atom_entry_source, @atom_entry_parents, false, targets)
assert_dc_to_s(@atom_entry_source, @atom_entry_parents, true, targets)
end
private
def dc_plural_suffix(name, check_backward_compatibility)
if name == :rights
if check_backward_compatibility
"es"
else
"_list"
end
else
"s"
end
end
def assert_dc_parse(source, parents, check_backward_compatibility, &maker)
assert_nothing_raised do
Parser.parse(source)
end
DC_ELEMENTS.each do |name, value|
parents.each do |parent_readers|
feed = nil
assert_nothing_raised do
tag = "#{DC_PREFIX}:#{name}"
dc_content = "<#{tag}>#{value}</#{tag}>\n"
dc_content *= 2
feed = Parser.parse(maker.call(dc_content, {DC_PREFIX => DC_URI}))
end
parent = chain_reader(feed, parent_readers)
plural_suffix = dc_plural_suffix(name, check_backward_compatibility)
plural_reader = "dc_#{name}#{plural_suffix}"
values = parent.__send__(plural_reader).collect(&:value)
value = CGI.unescapeHTML(value) if value.kind_of?(String)
assert_equal([value, value], values)
end
end
end
def assert_dc_singular_accessor(source, parents)
feed = Parser.parse(source)
new_value = "hoge"
parents.each do |parent_readers|
parent = chain_reader(feed, parent_readers)
DC_ELEMENTS.each do |name, value|
parsed_value = parent.__send__("dc_#{name}")
value = CGI.unescapeHTML(value) if value.kind_of?(String)
assert_equal(value, parsed_value)
if name == :date
t = Time.iso8601("2003-01-01T02:30:23+09:00")
class << t
alias_method(:to_s, :iso8601)
end
parent.__send__("dc_#{name}=", t.iso8601)
assert_equal(t, parent.__send__("dc_#{name}"))
if parent.class.method_defined?(:date_without_dc_date=)
assert_nil(parent.date)
else
assert_equal(t, parent.date)
end
parent.date = value
assert_equal(value, parent.date)
assert_equal(value, parent.__send__("dc_#{name}"))
else
parent.__send__("dc_#{name}=", new_value)
assert_equal(new_value, parent.__send__("dc_#{name}"))
end
end
end
end
def assert_dc_plural_accessor(source, parents, check_backward_compatibility)
feed = Parser.parse(source)
new_value = "hoge"
DC_ELEMENTS.each do |name, value|
parents.each do |parent_readers|
parent = chain_reader(feed, parent_readers)
parsed_value = parent.__send__("dc_#{name}")
value = CGI.unescapeHTML(value) if value.kind_of?(String)
assert_equal(value, parsed_value)
plural_suffix = dc_plural_suffix(name, check_backward_compatibility)
plural_reader = "dc_#{name}#{plural_suffix}"
klass_name = "DublinCore#{Utils.to_class_name(name.to_s)}"
klass = DublinCoreModel.const_get(klass_name)
if name == :date
t = Time.iso8601("2003-01-01T02:30:23+09:00")
class << t
alias_method(:to_s, :iso8601)
end
elems = parent.__send__(plural_reader)
elems << klass.new(t.iso8601)
new_elems = parent.__send__(plural_reader)
values = new_elems.collect{|x| x.value}
assert_equal([parent.__send__("dc_#{name}"), t], values)
else
elems = parent.__send__(plural_reader)
elems << klass.new(new_value)
new_elems = parent.__send__(plural_reader)
values = new_elems.collect{|x| x.value}
assert_equal([parent.__send__("dc_#{name}"), new_value],
values)
end
end
end
end
def assert_dc_to_s(source, parents, check_backward_compatibility,
targets=nil)
feed = Parser.parse(source)
DC_ELEMENTS.each do |name, value|
excepted = "<#{DC_PREFIX}:#{name}>#{value}</#{DC_PREFIX}:#{name}>"
parents.each do |parent_readers|
parent = chain_reader(feed, parent_readers)
assert_equal(excepted, parent.__send__("dc_#{name}_elements"))
end
plural_suffix = dc_plural_suffix(name, check_backward_compatibility)
reader = "dc_#{name}#{plural_suffix}"
excepted = Array.new(2, excepted).join("\n")
parents.each do |parent_readers|
parent = chain_reader(feed, parent_readers)
elems = parent.__send__(reader)
klass_name = "DublinCore#{Utils.to_class_name(name.to_s)}"
klass = DublinCoreModel.const_get(klass_name)
elems << klass.new(parent.__send__("dc_#{name}"))
assert_equal(excepted, parent.__send__("dc_#{name}_elements"))
end
end
targets ||= parents.collect do |parent_readers|
parent_readers.first
end
feed_root = REXML::Document.new(source).root
targets.each do |target_xpath|
parent = feed_root.elements[target_xpath]
parent.each_element do |elem|
if elem.namespace == DC_URI
assert_equal(elem.text,
CGI.unescapeHTML(DC_ELEMENTS[elem.name.intern].to_s))
end
end
end
end
end
end

215
test/rss/test_image.rb
Просмотреть файл

@ -1,215 +0,0 @@
# frozen_string_literal: false
require "cgi"
require "rexml/document"
require_relative "rss-testcase"
require "rss/1.0"
require "rss/image"
module RSS
class TestImage < TestCase
def setup
@prefix = "image"
@uri = "http://purl.org/rss/1.0/modules/image/"
@favicon_attrs = {
"rdf:about" => "http://www.kuro5hin.org/favicon.ico",
"#{@prefix}:size" => "small",
}
@favicon_contents = {"dc:title" => "Kuro5hin",}
@items = [
[
{
"rdf:about" => "http://www.example.org/item.png",
"rdf:resource" => "http://www.example.org/item",
},
{
"dc:title" => "Example Image",
"#{@prefix}:width" => "100",
"#{@prefix}:height" => "65",
},
],
[
{
"rdf:about" => "http://www.kuro5hin.org/images/topics/culture.jpg",
},
{
"dc:title" => "Culture",
"#{@prefix}:width" => "80",
"#{@prefix}:height" => "50",
},
]
]
@channel_nodes = make_element("#{@prefix}:favicon",
@favicon_attrs,
@favicon_contents)
items = ""
@items.each do |attrs, contents|
image_item = make_element("#{@prefix}:item", attrs, contents)
items << make_item(image_item)
end
@ns = {
@prefix => @uri,
DC_PREFIX => DC_URI,
}
@rss_source = make_RDF(<<-EOR, @ns)
#{make_channel(@channel_nodes)}
#{make_image}
#{items}
#{make_textinput}
EOR
@rss = Parser.parse(@rss_source)
end
def test_parser
assert_nothing_raised do
Parser.parse(@rss_source)
end
assert_too_much_tag("favicon", "channel") do
Parser.parse(make_RDF(<<-EOR, @ns))
#{make_channel(@channel_nodes * 2)}
#{make_item}
EOR
end
attrs = {"rdf:about" => "http://www.example.org/item.png"}
contents = [["#{@prefix}:width", "80"]] * 5
image_item = make_element("#{@prefix}:item", attrs, contents)
assert_too_much_tag("width", "item") do
Parser.parse(make_RDF(<<-EOR, @ns))
#{make_channel}
#{make_item(image_item)}
EOR
end
end
def test_favicon_accessor
favicon = @rss.channel.image_favicon
[
%w(about rdf:about http://example.com/favicon.ico),
%w(size image:size large),
%w(image_size image:size medium),
].each do |name, full_name, new_value|
assert_equal(@favicon_attrs[full_name], favicon.__send__(name))
favicon.__send__("#{name}=", new_value)
assert_equal(new_value, favicon.__send__(name))
favicon.__send__("#{name}=", @favicon_attrs[full_name])
assert_equal(@favicon_attrs[full_name], favicon.__send__(name))
end
%w(small medium large).each do |value|
assert_nothing_raised do
favicon.size = value
favicon.image_size = value
end
end
%w(aaa AAA SMALL MEDIUM LARGE).each do |value|
args = ["#{@prefix}:favicon", value, "#{@prefix}:size"]
assert_not_available_value(*args) do
favicon.size = value
end
assert_not_available_value(*args) do
favicon.image_size = value
end
end
[
%w(dc_title dc:title sample-favicon),
].each do |name, full_name, new_value|
assert_equal(@favicon_contents[full_name], favicon.__send__(name))
favicon.__send__("#{name}=", new_value)
assert_equal(new_value, favicon.__send__(name))
favicon.__send__("#{name}=", @favicon_contents[full_name])
assert_equal(@favicon_contents[full_name], favicon.__send__(name))
end
end
def test_item_accessor
@rss.items.each_with_index do |item, i|
image_item = item.image_item
attrs, contents = @items[i]
[
%w(about rdf:about http://example.com/image.png),
%w(resource rdf:resource http://example.com/),
].each do |name, full_name, new_value|
assert_equal(attrs[full_name], image_item.__send__(name))
image_item.__send__("#{name}=", new_value)
assert_equal(new_value, image_item.__send__(name))
image_item.__send__("#{name}=", attrs[full_name])
assert_equal(attrs[full_name], image_item.__send__(name))
end
[
["width", "image:width", "111"],
["image_width", "image:width", "44"],
["height", "image:height", "222"],
["image_height", "image:height", "88"],
].each do |name, full_name, new_value|
assert_equal(contents[full_name].to_i, image_item.__send__(name))
image_item.__send__("#{name}=", new_value)
assert_equal(new_value.to_i, image_item.__send__(name))
image_item.__send__("#{name}=", contents[full_name])
assert_equal(contents[full_name].to_i, image_item.__send__(name))
end
[
["dc_title", "dc:title", "sample-image"],
].each do |name, full_name, new_value|
assert_equal(contents[full_name], image_item.__send__(name))
image_item.__send__("#{name}=", new_value)
assert_equal(new_value, image_item.__send__(name))
image_item.__send__("#{name}=", contents[full_name])
assert_equal(contents[full_name], image_item.__send__(name))
end
end
end
def test_favicon_to_s
favicon = @rss.channel.image_favicon
expected_xml = image_xmlns_container(make_element("#{@prefix}:favicon",
@favicon_attrs,
@favicon_contents))
expected = REXML::Document.new(expected_xml)
actual_xml = image_xmlns_container(favicon.to_s(false, ""))
actual = REXML::Document.new(actual_xml)
assert_equal(expected.to_s, actual.to_s)
end
def test_item_to_s
@rss.items.each_with_index do |item, i|
attrs, contents = @items[i]
expected_xml = make_element("#{@prefix}:item", attrs, contents)
expected_xml = image_xmlns_container(expected_xml)
expected = REXML::Document.new(expected_xml)
actual_xml = image_xmlns_container(item.image_item.to_s(false, ""))
actual = REXML::Document.new(actual_xml)
assert_equal(expected[0].attributes, actual[0].attributes)
%w(image:height image:width dc:title).each do |name|
actual_target = actual.elements["//#{name}"]
expected_target = expected.elements["//#{name}"]
assert_equal(expected_target.to_s, actual_target.to_s)
end
end
end
private
def image_xmlns_container(content)
xmlns_container({
@prefix => @uri,
"dc" => "http://purl.org/dc/elements/1.1/",
"rdf" => "http://www.w3.org/1999/02/22-rdf-syntax-ns#",
},
content)
end
end
end

41
test/rss/test_inherit.rb
Просмотреть файл

@ -1,41 +0,0 @@
# frozen_string_literal: false
require_relative "rss-testcase"
require "rss/1.0"
module RSS
class TestInherit < TestCase
class InheritedImage < RSS::RDF::Image
def self.indent_size; 1; end
def self.tag_name; 'image'; end
end
def setup
@rss = make_RDF(<<-EOR)
#{make_channel}
#{make_image}
#{make_item}
#{make_textinput}
EOR
end
def test_inherit
rss = RSS::Parser.parse(@rss)
orig_image = rss.image
prefix = "[INHERIT]"
image = InheritedImage.new("#{prefix} #{orig_image.about}")
image.title = "#{prefix} #{orig_image.title}"
image.url = "#{prefix} #{orig_image.url}"
image.link = "#{prefix} #{orig_image.link}"
rss.image = image
new_rss = RSS::Parser.parse(rss.to_s)
new_image = new_rss.image
assert_equal("#{prefix} #{orig_image.about}", new_image.about)
assert_equal("#{prefix} #{orig_image.title}", new_image.title)
assert_equal("#{prefix} #{orig_image.url}", new_image.url)
assert_equal("#{prefix} #{orig_image.link}", new_image.link)
end
end
end

356
test/rss/test_itunes.rb
Просмотреть файл

@ -1,356 +0,0 @@
# frozen_string_literal: false
require "cgi"
require "rexml/document"
require_relative "rss-testcase"
require "rss/2.0"
require "rss/itunes"
module RSS
class TestITunes < TestCase
def test_author
assert_itunes_author(%w(channel)) do |content, xmlns|
make_rss20(make_channel20(content), xmlns)
end
assert_itunes_author(%w(items last)) do |content, xmlns|
make_rss20(make_channel20(make_item20(content)), xmlns)
end
end
def test_block
assert_itunes_block(%w(items last)) do |content, xmlns|
make_rss20(make_channel20(make_item20(content)), xmlns)
end
end
def test_category
assert_itunes_category(%w(channel)) do |content, xmlns|
make_rss20(make_channel20(content), xmlns)
end
end
def test_image
assert_itunes_image(%w(channel)) do |content, xmlns|
make_rss20(make_channel20(content), xmlns)
end
end
def test_duration
assert_itunes_duration(%w(items last)) do |content, xmlns|
make_rss20(make_channel20(make_item20(content)), xmlns)
end
end
def test_explicit
assert_itunes_explicit(%w(channel)) do |content, xmlns|
make_rss20(make_channel20(content), xmlns)
end
assert_itunes_explicit(%w(items last)) do |content, xmlns|
make_rss20(make_channel20(make_item20(content)), xmlns)
end
end
def test_keywords
assert_itunes_keywords(%w(channel)) do |content, xmlns|
make_rss20(make_channel20(content), xmlns)
end
assert_itunes_keywords(%w(items last)) do |content, xmlns|
make_rss20(make_channel20(make_item20(content)), xmlns)
end
end
def test_new_feed_url
assert_itunes_new_feed_url(%w(channel)) do |content, xmlns|
make_rss20(make_channel20(content), xmlns)
end
end
def test_owner
assert_itunes_owner(%w(channel)) do |content, xmlns|
make_rss20(make_channel20(content), xmlns)
end
end
def test_subtitle
assert_itunes_subtitle(%w(channel)) do |content, xmlns|
make_rss20(make_channel20(content), xmlns)
end
assert_itunes_subtitle(%w(items last)) do |content, xmlns|
make_rss20(make_channel20(make_item20(content)), xmlns)
end
end
def test_summary
assert_itunes_summary(%w(channel)) do |content, xmlns|
make_rss20(make_channel20(content), xmlns)
end
assert_itunes_summary(%w(items last)) do |content, xmlns|
make_rss20(make_channel20(make_item20(content)), xmlns)
end
end
private
def itunes_rss20_parse(content, &maker)
xmlns = {"itunes" => "http://www.itunes.com/dtds/podcast-1.0.dtd"}
rss20_xml = maker.call(content, xmlns)
::RSS::Parser.parse(rss20_xml)
end
def assert_itunes_author(readers, &rss20_maker)
_wrap_assertion do
author = "John Lennon"
rss20 = itunes_rss20_parse(tag("itunes:author", author), &rss20_maker)
target = chain_reader(rss20, readers)
assert_equal(author, target.itunes_author)
end
end
def _assert_itunes_block(value, boolean_value, readers, &rss20_maker)
rss20 = itunes_rss20_parse(tag("itunes:block", value), &rss20_maker)
target = chain_reader(rss20, readers)
assert_equal(value, target.itunes_block)
assert_equal(boolean_value, target.itunes_block?)
end
def assert_itunes_block(readers, &rss20_maker)
_wrap_assertion do
_assert_itunes_block("yes", true, readers, &rss20_maker)
_assert_itunes_block("Yes", true, readers, &rss20_maker)
_assert_itunes_block("no", false, readers, &rss20_maker)
_assert_itunes_block("", false, readers, &rss20_maker)
end
end
def _assert_itunes_category(categories, readers, &rss20_maker)
cats = categories.collect do |category|
if category.is_a?(Array)
category, sub_category = category
tag("itunes:category",
tag("itunes:category", nil, {"text" => sub_category}),
{"text" => category})
else
tag("itunes:category", nil, {"text" => category})
end
end.join
rss20 = itunes_rss20_parse(cats, &rss20_maker)
target = chain_reader(rss20, readers)
actual_categories = target.itunes_categories.collect do |category|
cat = category.text
if category.itunes_categories.empty?
cat
else
[cat, *category.itunes_categories.collect {|c| c.text}]
end
end
assert_equal(categories, actual_categories)
end
def assert_itunes_category(readers, &rss20_maker)
_wrap_assertion do
_assert_itunes_category(["Audio Blogs"], readers, &rss20_maker)
_assert_itunes_category([["Arts & Entertainment", "Games"]],
readers, &rss20_maker)
_assert_itunes_category([["Arts & Entertainment", "Games"],
["Technology", "Computers"],
"Audio Blogs"],
readers, &rss20_maker)
end
end
def assert_itunes_image(readers, &rss20_maker)
_wrap_assertion do
url = "http://example.com/podcasts/everything/AllAboutEverything.jpg"
content = tag("itunes:image", nil, {"href" => url})
rss20 = itunes_rss20_parse(content, &rss20_maker)
target = chain_reader(rss20, readers)
assert_not_nil(target.itunes_image)
assert_equal(url, target.itunes_image.href)
assert_missing_attribute("image", "href") do
content = tag("itunes:image")
itunes_rss20_parse(content, &rss20_maker)
end
end
end
def _assert_itunes_duration(hour, minute, second, value,
readers, &rss20_maker)
content = tag("itunes:duration", value)
rss20 = itunes_rss20_parse(content, &rss20_maker)
duration = chain_reader(rss20, readers).itunes_duration
assert_equal(value, duration.content)
assert_equal(hour, duration.hour)
assert_equal(minute, duration.minute)
assert_equal(second, duration.second)
end
def _assert_itunes_duration_not_available_value(value, &rss20_maker)
assert_not_available_value("duration", value) do
content = tag("itunes:duration", value)
itunes_rss20_parse(content, &rss20_maker)
end
end
def assert_itunes_duration(readers, &rss20_maker)
_wrap_assertion do
_assert_itunes_duration(7, 14, 5, "07:14:05", readers, &rss20_maker)
_assert_itunes_duration(7, 14, 5, "7:14:05", readers, &rss20_maker)
_assert_itunes_duration(0, 4, 55, "04:55", readers, &rss20_maker)
_assert_itunes_duration(0, 4, 5, "4:05", readers, &rss20_maker)
_assert_itunes_duration(0, 0, 5, "5", readers, &rss20_maker)
_assert_itunes_duration(0, 3, 15, "195", readers, &rss20_maker)
_assert_itunes_duration(1, 0, 1, "3601", readers, &rss20_maker)
_assert_itunes_duration_not_available_value("09:07:14:05", &rss20_maker)
_assert_itunes_duration_not_available_value("10:5", &rss20_maker)
_assert_itunes_duration_not_available_value("10:03:5", &rss20_maker)
_assert_itunes_duration_not_available_value("10:3:05", &rss20_maker)
_assert_itunes_duration_not_available_value("xx:xx:xx", &rss20_maker)
_assert_itunes_duration_not_available_value("", &rss20_maker)
end
end
def _assert_itunes_explicit(explicit, value, readers, &rss20_maker)
content = tag("itunes:explicit", value)
rss20 = itunes_rss20_parse(content, &rss20_maker)
target = chain_reader(rss20, readers)
assert_equal(value, target.itunes_explicit)
assert_equal(explicit, target.itunes_explicit?)
end
def assert_itunes_explicit(readers, &rss20_maker)
_wrap_assertion do
_assert_itunes_explicit(true, "explicit", readers, &rss20_maker)
_assert_itunes_explicit(true, "yes", readers, &rss20_maker)
_assert_itunes_explicit(true, "true", readers, &rss20_maker)
_assert_itunes_explicit(false, "clean", readers, &rss20_maker)
_assert_itunes_explicit(false, "no", readers, &rss20_maker)
_assert_itunes_explicit(false, "false", readers, &rss20_maker)
_assert_itunes_explicit(nil, "invalid", readers, &rss20_maker)
end
end
def _assert_itunes_keywords(keywords, value, readers, &rss20_maker)
content = tag("itunes:keywords", value)
rss20 = itunes_rss20_parse(content, &rss20_maker)
target = chain_reader(rss20, readers)
assert_equal(keywords, target.itunes_keywords)
end
def assert_itunes_keywords(readers, &rss20_maker)
_wrap_assertion do
_assert_itunes_keywords(["salt"], "salt", readers, &rss20_maker)
_assert_itunes_keywords(["salt"], " salt ", readers, &rss20_maker)
_assert_itunes_keywords(["salt", "pepper", "shaker", "exciting"],
"salt, pepper, shaker, exciting",
readers, &rss20_maker)
_assert_itunes_keywords(["metric", "socket", "wrenches", "toolsalt"],
"metric, socket, wrenches, toolsalt",
readers, &rss20_maker)
_assert_itunes_keywords(["olitics", "red", "blue", "state"],
"olitics, red, blue, state",
readers, &rss20_maker)
end
end
def assert_itunes_new_feed_url(readers, &rss20_maker)
_wrap_assertion do
url = "http://newlocation.com/example.rss"
content = tag("itunes:new-feed-url", url)
rss20 = itunes_rss20_parse(content, &rss20_maker)
target = chain_reader(rss20, readers)
assert_equal(url, target.itunes_new_feed_url)
end
end
def _assert_itunes_owner(name, email, readers, &rss20_maker)
content = tag("itunes:owner",
tag("itunes:name", name) + tag("itunes:email", email))
rss20 = itunes_rss20_parse(content, &rss20_maker)
owner = chain_reader(rss20, readers).itunes_owner
assert_equal(name, owner.itunes_name)
assert_equal(email, owner.itunes_email)
end
def assert_itunes_owner(readers, &rss20_maker)
_wrap_assertion do
_assert_itunes_owner("John Doe", "john.doe@example.com",
readers, &rss20_maker)
assert_missing_tag("name", "owner") do
content = tag("itunes:owner")
itunes_rss20_parse(content, &rss20_maker)
end
assert_missing_tag("name", "owner") do
content = tag("itunes:owner",
tag("itunes:email", "john.doe@example.com"))
itunes_rss20_parse(content, &rss20_maker)
end
assert_missing_tag("email", "owner") do
content = tag("itunes:owner", tag("itunes:name", "John Doe"))
itunes_rss20_parse(content, &rss20_maker)
end
end
end
def _assert_itunes_subtitle(value, readers, &rss20_maker)
content = tag("itunes:subtitle", value)
rss20 = itunes_rss20_parse(content, &rss20_maker)
target = chain_reader(rss20, readers)
assert_equal(value, target.itunes_subtitle)
end
def assert_itunes_subtitle(readers, &rss20_maker)
_wrap_assertion do
_assert_itunes_subtitle("A show about everything", readers, &rss20_maker)
_assert_itunes_subtitle("A short primer on table spices",
readers, &rss20_maker)
_assert_itunes_subtitle("Comparing socket wrenches is fun!",
readers, &rss20_maker)
_assert_itunes_subtitle("Red + Blue != Purple", readers, &rss20_maker)
end
end
def _assert_itunes_summary(value, readers, &rss20_maker)
content = tag("itunes:summary", value)
rss20 = itunes_rss20_parse(content, &rss20_maker)
target = chain_reader(rss20, readers)
assert_equal(value, target.itunes_summary)
end
def assert_itunes_summary(readers, &rss20_maker)
_wrap_assertion do
_assert_itunes_summary("All About Everything is a show about " +
"everything. Each week we dive into any " +
"subject known to man and talk about it as " +
"much as we can. Look for our Podcast in " +
"the iTunes Music Store",
readers, &rss20_maker)
_assert_itunes_summary("This week we talk about salt and pepper " +
"shakers, comparing and contrasting pour " +
"rates, construction materials, and overall " +
"aesthetics. Come and join the party!",
readers, &rss20_maker)
_assert_itunes_summary("This week we talk about metric vs. old " +
"english socket wrenches. Which one is " +
"better? Do you really need both? Get all " +
"of your answers here.",
readers, &rss20_maker)
_assert_itunes_summary("This week we talk about surviving in a " +
"Red state if you're a Blue person. Or " +
"vice versa.",
readers, &rss20_maker)
end
end
end
end

477
test/rss/test_maker_0.9.rb
Просмотреть файл

@ -1,477 +0,0 @@
# frozen_string_literal: false
require_relative "rss-testcase"
require "rss/maker"
module RSS
class TestMaker09 < TestCase
def test_supported?
assert(RSS::Maker.supported?("0.9"))
assert(RSS::Maker.supported?("rss0.9"))
assert(RSS::Maker.supported?("0.91"))
assert(RSS::Maker.supported?("rss0.91"))
assert(RSS::Maker.supported?("0.92"))
assert(RSS::Maker.supported?("rss0.92"))
assert(!RSS::Maker.supported?("0.93"))
assert(!RSS::Maker.supported?("rss0.93"))
end
def test_find_class
assert_equal(RSS::Maker::RSS091, RSS::Maker["0.91"])
assert_equal(RSS::Maker::RSS091, RSS::Maker["rss0.91"])
assert_equal(RSS::Maker::RSS092, RSS::Maker["0.9"])
assert_equal(RSS::Maker::RSS092, RSS::Maker["0.92"])
assert_equal(RSS::Maker::RSS092, RSS::Maker["rss0.92"])
end
def test_rss
assert_raise(LocalJumpError) do
RSS::Maker.make("0.91")
end
rss = RSS::Maker.make("0.9") do |maker|
setup_dummy_channel(maker)
setup_dummy_image(maker)
end
assert_equal("0.92", rss.rss_version)
rss = RSS::Maker.make("0.91") do |maker|
setup_dummy_channel(maker)
setup_dummy_image(maker)
end
assert_equal("0.91", rss.rss_version)
rss = RSS::Maker.make("0.91") do |maker|
setup_dummy_channel(maker)
setup_dummy_image(maker)
maker.encoding = "EUC-JP"
end
assert_equal("0.91", rss.rss_version)
assert_equal("EUC-JP", rss.encoding)
rss = RSS::Maker.make("0.91") do |maker|
setup_dummy_channel(maker)
setup_dummy_image(maker)
maker.standalone = "yes"
end
assert_equal("0.91", rss.rss_version)
assert_equal("yes", rss.standalone)
rss = RSS::Maker.make("0.91") do |maker|
setup_dummy_channel(maker)
setup_dummy_image(maker)
maker.encoding = "EUC-JP"
maker.standalone = "yes"
end
assert_equal("0.91", rss.rss_version)
assert_equal("EUC-JP", rss.encoding)
assert_equal("yes", rss.standalone)
end
def test_channel
title = "fugafuga"
link = "http://hoge.com"
description = "fugafugafugafuga"
language = "ja"
copyright = "foo"
managingEditor = "bar"
webMaster = "web master"
rating = '(PICS-1.1 "http://www.rsac.org/ratingsv01.html" l gen true comment "RSACi North America Server" for "http://www.rsac.org" on "1996.04.16T08:15-0500" r (n 0 s 0 v 0 l 0))'
docs = "http://foo.com/doc"
skipDays = [
"Sunday",
"Monday",
]
skipHours = [
"0",
"13",
]
pubDate = Time.now
lastBuildDate = Time.now
image_url = "http://example.com/logo.png"
image_title = "Logo"
rss = RSS::Maker.make("0.91") do |maker|
maker.channel.title = title
maker.channel.link = link
maker.channel.description = description
maker.channel.language = language
maker.channel.copyright = copyright
maker.channel.managingEditor = managingEditor
maker.channel.webMaster = webMaster
maker.channel.rating = rating
maker.channel.docs = docs
maker.channel.pubDate = pubDate
maker.channel.lastBuildDate = lastBuildDate
skipDays.each do |day|
maker.channel.skipDays.new_day do |new_day|
new_day.content = day
end
end
skipHours.each do |hour|
maker.channel.skipHours.new_hour do |new_hour|
new_hour.content = hour
end
end
maker.image.url = image_url
maker.image.title = image_title
end
channel = rss.channel
assert_equal(title, channel.title)
assert_equal(link, channel.link)
assert_equal(description, channel.description)
assert_equal(language, channel.language)
assert_equal(copyright, channel.copyright)
assert_equal(managingEditor, channel.managingEditor)
assert_equal(webMaster, channel.webMaster)
assert_equal(rating, channel.rating)
assert_equal(docs, channel.docs)
assert_equal(pubDate, channel.pubDate)
assert_equal(pubDate, channel.date)
assert_equal(lastBuildDate, channel.lastBuildDate)
skipDays.each_with_index do |day, i|
assert_equal(day, channel.skipDays.days[i].content)
end
skipHours.each_with_index do |hour, i|
assert_equal(hour.to_i, channel.skipHours.hours[i].content)
end
assert(channel.items.empty?)
assert_equal(image_url, channel.image.url)
assert_equal(image_title, channel.image.title)
assert_equal(link, channel.image.link)
assert_nil(channel.textInput)
end
def test_not_valid_channel
title = "fugafuga"
link = "http://hoge.com"
description = "fugafugafugafuga"
language = "ja"
assert_not_set_error("maker.channel", %w(title)) do
RSS::Maker.make("0.91") do |maker|
# maker.channel.title = title
maker.channel.link = link
maker.channel.description = description
maker.channel.language = language
end
end
assert_not_set_error("maker.channel", %w(link)) do
RSS::Maker.make("0.91") do |maker|
maker.channel.title = title
# maker.channel.link = link
maker.channel.link = nil
maker.channel.description = description
maker.channel.language = language
end
end
assert_not_set_error("maker.channel", %w(description)) do
RSS::Maker.make("0.91") do |maker|
maker.channel.title = title
maker.channel.link = link
# maker.channel.description = description
maker.channel.language = language
end
end
assert_not_set_error("maker.channel", %w(language)) do
RSS::Maker.make("0.91") do |maker|
maker.channel.title = title
maker.channel.link = link
maker.channel.description = description
# maker.channel.language = language
end
end
end
def test_image
title = "fugafuga"
link = "http://hoge.com"
url = "http://hoge.com/hoge.png"
width = "144"
height = "400"
description = "an image"
rss = RSS::Maker.make("0.91") do |maker|
setup_dummy_channel(maker)
maker.channel.link = link
maker.image.title = title
maker.image.url = url
maker.image.width = width
maker.image.height = height
maker.image.description = description
end
image = rss.image
assert_equal(title, image.title)
assert_equal(link, image.link)
assert_equal(url, image.url)
assert_equal(width.to_i, image.width)
assert_equal(height.to_i, image.height)
assert_equal(description, image.description)
assert_not_set_error("maker.channel", %w(description title language)) do
RSS::Maker.make("0.91") do |maker|
# setup_dummy_channel(maker)
maker.channel.link = link
maker.image.title = title
maker.image.url = url
maker.image.width = width
maker.image.height = height
maker.image.description = description
end
end
end
def test_not_valid_image
title = "fugafuga"
link = "http://hoge.com"
url = "http://hoge.com/hoge.png"
width = "144"
height = "400"
description = "an image"
assert_not_set_error("maker.image", %w(title)) do
RSS::Maker.make("0.91") do |maker|
setup_dummy_channel(maker)
maker.channel.link = link
# maker.image.title = title
maker.image.url = url
maker.image.width = width
maker.image.height = height
maker.image.description = description
end
end
assert_not_set_error("maker.channel", %w(link)) do
RSS::Maker.make("0.91") do |maker|
setup_dummy_channel(maker)
# maker.channel.link = link
maker.channel.link = nil
maker.image.title = title
maker.image.url = url
maker.image.width = width
maker.image.height = height
maker.image.description = description
end
end
assert_not_set_error("maker.image", %w(url)) do
RSS::Maker.make("0.91") do |maker|
setup_dummy_channel(maker)
maker.channel.link = link
maker.image.title = title
# maker.image.url = url
maker.image.width = width
maker.image.height = height
maker.image.description = description
end
end
end
def test_items(with_convenience_way=true)
title = "TITLE"
link = "http://hoge.com/"
description = "text hoge fuga"
rss = RSS::Maker.make("0.91") do |maker|
setup_dummy_channel(maker)
setup_dummy_image(maker)
end
assert(rss.channel.items.empty?)
rss = RSS::Maker.make("0.91") do |maker|
setup_dummy_channel(maker)
maker.items.new_item do |item|
item.title = title
item.link = link
# item.description = description
end
setup_dummy_image(maker)
end
assert_equal(1, rss.channel.items.size)
item = rss.channel.items.first
assert_equal(title, item.title)
assert_equal(link, item.link)
assert_nil(item.description)
pubDate = Time.now
item_size = 5
rss = RSS::Maker.make("0.91") do |maker|
setup_dummy_channel(maker)
item_size.times do |i|
maker.items.new_item do |_item|
_item.title = "#{title}#{i}"
_item.link = "#{link}#{i}"
_item.description = "#{description}#{i}"
_item.date = pubDate - i
end
end
maker.items.do_sort = true
setup_dummy_image(maker)
end
assert_equal(item_size, rss.items.size)
rss.channel.items.each_with_index do |_item, i|
assert_equal("#{title}#{i}", _item.title)
assert_equal("#{link}#{i}", _item.link)
assert_equal("#{description}#{i}", _item.description)
end
rss = RSS::Maker.make("0.91") do |maker|
setup_dummy_channel(maker)
item_size.times do |i|
maker.items.new_item do |_item|
_item.title = "#{title}#{i}"
_item.link = "#{link}#{i}"
_item.description = "#{description}#{i}"
end
end
maker.items.do_sort = Proc.new do |x, y|
if with_convenience_way
y.title[-1] <=> x.title[-1]
else
y.title {|t| t.content[-1]} <=> x.title {|t| t.content[-1]}
end
end
setup_dummy_image(maker)
end
assert_equal(item_size, rss.items.size)
rss.channel.items.reverse.each_with_index do |_item, i|
assert_equal("#{title}#{i}", _item.title)
assert_equal("#{link}#{i}", _item.link)
assert_equal("#{description}#{i}", _item.description)
end
end
def test_items_with_new_api_since_018
test_items(false)
end
def test_textInput
title = "fugafuga"
description = "text hoge fuga"
name = "hoge"
link = "http://hoge.com"
rss = RSS::Maker.make("0.91") do |maker|
setup_dummy_channel(maker)
setup_dummy_image(maker)
maker.textinput.title = title
maker.textinput.description = description
maker.textinput.name = name
maker.textinput.link = link
end
textInput = rss.channel.textInput
assert_equal(title, textInput.title)
assert_equal(description, textInput.description)
assert_equal(name, textInput.name)
assert_equal(link, textInput.link)
assert_not_set_error("maker.channel",
%w(link language description title)) do
RSS::Maker.make("0.91") do |maker|
# setup_dummy_channel(maker)
maker.textinput.title = title
maker.textinput.description = description
maker.textinput.name = name
maker.textinput.link = link
end
end
end
def test_not_valid_textInput
title = "fugafuga"
description = "text hoge fuga"
name = "hoge"
link = "http://hoge.com"
rss = RSS::Maker.make("0.91") do |maker|
setup_dummy_channel(maker)
setup_dummy_image(maker)
# maker.textinput.title = title
maker.textinput.description = description
maker.textinput.name = name
maker.textinput.link = link
end
assert_nil(rss.channel.textInput)
rss = RSS::Maker.make("0.91") do |maker|
setup_dummy_channel(maker)
setup_dummy_image(maker)
maker.textinput.title = title
# maker.textinput.description = description
maker.textinput.name = name
maker.textinput.link = link
end
assert_nil(rss.channel.textInput)
rss = RSS::Maker.make("0.91") do |maker|
setup_dummy_channel(maker)
setup_dummy_image(maker)
maker.textinput.title = title
maker.textinput.description = description
# maker.textinput.name = name
maker.textinput.link = link
end
assert_nil(rss.channel.textInput)
rss = RSS::Maker.make("0.91") do |maker|
setup_dummy_channel(maker)
setup_dummy_image(maker)
maker.textinput.title = title
maker.textinput.description = description
maker.textinput.name = name
# maker.textinput.link = link
end
assert_nil(rss.channel.textInput)
end
def test_date_in_string
date = Time.now
rss = RSS::Maker.make("0.91") do |maker|
setup_dummy_channel(maker)
setup_dummy_image(maker)
maker.items.new_item do |item|
item.title = "The first item"
item.link = "http://example.com/blog/1.html"
item.date = date.rfc822
end
end
assert_equal(date.iso8601, rss.items[0].date.iso8601)
end
end
end

519
test/rss/test_maker_1.0.rb
Просмотреть файл

@ -1,519 +0,0 @@
# frozen_string_literal: false
require_relative "rss-testcase"
require "rss/maker"
module RSS
class TestMaker10 < TestCase
def test_supported?
assert(RSS::Maker.supported?("1.0"))
assert(RSS::Maker.supported?("rss1.0"))
assert(!RSS::Maker.supported?("1.1"))
assert(!RSS::Maker.supported?("rss1.1"))
end
def test_find_class
assert_equal(RSS::Maker::RSS10, RSS::Maker["1.0"])
assert_equal(RSS::Maker::RSS10, RSS::Maker["rss1.0"])
end
def test_rdf
assert_raise(LocalJumpError) do
RSS::Maker.make("1.0")
end
rss = RSS::Maker.make("1.0") do |maker|
setup_dummy_channel(maker)
setup_dummy_item(maker)
end
assert_equal("1.0", rss.rss_version)
rss = RSS::Maker.make("1.0") do |maker|
setup_dummy_channel(maker)
maker.encoding = "EUC-JP"
setup_dummy_item(maker)
end
assert_equal("1.0", rss.rss_version)
assert_equal("EUC-JP", rss.encoding)
rss = RSS::Maker.make("1.0") do |maker|
setup_dummy_channel(maker)
maker.standalone = "yes"
setup_dummy_item(maker)
end
assert_equal("1.0", rss.rss_version)
assert_equal("yes", rss.standalone)
rss = RSS::Maker.make("1.0") do |maker|
setup_dummy_channel(maker)
maker.encoding = "EUC-JP"
maker.standalone = "yes"
setup_dummy_item(maker)
end
assert_equal("1.0", rss.rss_version)
assert_equal("EUC-JP", rss.encoding)
assert_equal("yes", rss.standalone)
end
def test_channel
about = "http://hoge.com"
title = "fugafuga"
link = "http://hoge.com"
description = "fugafugafugafuga"
rss = RSS::Maker.make("1.0") do |maker|
maker.channel.about = about
maker.channel.title = title
maker.channel.link = link
maker.channel.description = description
setup_dummy_item(maker)
end
channel = rss.channel
assert_equal(about, channel.about)
assert_equal(title, channel.title)
assert_equal(link, channel.link)
assert_equal(description, channel.description)
assert_equal(1, channel.items.Seq.lis.size)
assert_nil(channel.image)
assert_nil(channel.textinput)
rss = RSS::Maker.make("1.0") do |maker|
maker.channel.about = about
maker.channel.title = title
maker.channel.link = link
maker.channel.description = description
setup_dummy_image(maker)
setup_dummy_textinput(maker)
setup_dummy_item(maker)
end
channel = rss.channel
assert_equal(about, channel.about)
assert_equal(title, channel.title)
assert_equal(link, channel.link)
assert_equal(description, channel.description)
assert_equal(1, channel.items.Seq.lis.size)
assert_equal(rss.image.about, channel.image.resource)
assert_equal(rss.textinput.about, channel.textinput.resource)
end
def test_channel_language
about = "http://hoge.com"
title = "fugafuga"
link = "http://hoge.com"
description = "fugafugafugafuga"
language = "ja"
rss = RSS::Maker.make("1.0") do |maker|
maker.channel.about = about
maker.channel.title = title
maker.channel.link = link
maker.channel.description = description
maker.channel.language = language
setup_dummy_item(maker)
end
channel = rss.channel
assert_equal(language, channel.dc_language)
end
def test_not_valid_channel
about = "http://hoge.com"
title = "fugafuga"
link = "http://hoge.com"
description = "fugafugafugafuga"
assert_not_set_error("maker.channel", %w(about)) do
RSS::Maker.make("1.0") do |maker|
# maker.channel.about = about
maker.channel.title = title
maker.channel.link = link
maker.channel.description = description
end
end
assert_not_set_error("maker.channel", %w(title)) do
RSS::Maker.make("1.0") do |maker|
maker.channel.about = about
# maker.channel.title = title
maker.channel.link = link
maker.channel.description = description
end
end
assert_not_set_error("maker.channel", %w(link)) do
RSS::Maker.make("1.0") do |maker|
maker.channel.about = about
maker.channel.title = title
# maker.channel.link = link
maker.channel.description = description
end
end
assert_not_set_error("maker.channel", %w(description)) do
RSS::Maker.make("1.0") do |maker|
maker.channel.about = about
maker.channel.title = title
maker.channel.link = link
# maker.channel.description = description
end
end
end
def test_image
title = "fugafuga"
link = "http://hoge.com"
url = "http://hoge.com/hoge.png"
rss = RSS::Maker.make("1.0") do |maker|
setup_dummy_channel(maker)
maker.channel.link = link
maker.image.title = title
maker.image.url = url
setup_dummy_item(maker)
end
image = rss.image
assert_equal(url, image.about)
assert_equal(url, rss.channel.image.resource)
assert_equal(title, image.title)
assert_equal(link, image.link)
assert_equal(url, image.url)
assert_not_set_error("maker.channel", %w(about title description)) do
RSS::Maker.make("1.0") do |maker|
# setup_dummy_channel(maker)
maker.channel.link = link
maker.image.title = title
maker.image.url = url
end
end
end
def test_not_valid_image
title = "fugafuga"
link = "http://hoge.com"
url = "http://hoge.com/hoge.png"
rss = RSS::Maker.make("1.0") do |maker|
setup_dummy_channel(maker)
maker.channel.link = link
# maker.image.url = url
maker.image.title = title
setup_dummy_item(maker)
end
assert_nil(rss.channel.image)
assert_nil(rss.image)
rss = RSS::Maker.make("1.0") do |maker|
setup_dummy_channel(maker)
maker.channel.link = link
maker.image.url = url
# maker.image.title = title
setup_dummy_item(maker)
end
assert_nil(rss.channel.image)
assert_nil(rss.image)
assert_not_set_error("maker.channel", %w(link)) do
RSS::Maker.make("1.0") do |maker|
setup_dummy_channel(maker)
# maker.channel.link = link
maker.channel.link = nil
maker.image.url = url
maker.image.title = title
setup_dummy_item(maker)
end
end
end
def test_items(with_convenience_way=true)
title = "TITLE"
link = "http://hoge.com/"
description = "text hoge fuga"
assert_not_set_error("maker", %w(items)) do
RSS::Maker.make("1.0") do |maker|
setup_dummy_channel(maker)
end
end
rss = RSS::Maker.make("1.0") do |maker|
setup_dummy_channel(maker)
maker.items.new_item do |item|
item.title = title
item.link = link
# item.description = description
end
end
assert_equal(1, rss.items.size)
item = rss.items.first
assert_equal(link, item.about)
assert_equal(title, item.title)
assert_equal(link, item.link)
assert_nil(item.description)
pubDate = Time.now
item_size = 5
rss = RSS::Maker.make("1.0") do |maker|
setup_dummy_channel(maker)
item_size.times do |i|
maker.items.new_item do |_item|
_item.title = "#{title}#{i}"
_item.link = "#{link}#{i}"
_item.description = "#{description}#{i}"
_item.date = pubDate - i
end
end
maker.items.do_sort = true
end
assert_equal(item_size, rss.items.size)
rss.items.each_with_index do |_item, i|
assert_equal("#{link}#{i}", _item.about)
assert_equal("#{title}#{i}", _item.title)
assert_equal("#{link}#{i}", _item.link)
assert_equal("#{description}#{i}", _item.description)
end
rss = RSS::Maker.make("1.0") do |maker|
setup_dummy_channel(maker)
item_size.times do |i|
maker.items.new_item do |_item|
_item.title = "#{title}#{i}"
_item.link = "#{link}#{i}"
_item.description = "#{description}#{i}"
end
end
maker.items.do_sort = Proc.new do |x, y|
if with_convenience_way
y.title[-1] <=> x.title[-1]
else
y.title {|t| t.content[-1]} <=> x.title {|t| t.content[-1]}
end
end
end
assert_equal(item_size, rss.items.size)
rss.items.reverse.each_with_index do |_item, i|
assert_equal("#{link}#{i}", _item.about)
assert_equal("#{title}#{i}", _item.title)
assert_equal("#{link}#{i}", _item.link)
assert_equal("#{description}#{i}", _item.description)
end
max_size = item_size / 2
rss = RSS::Maker.make("1.0") do |maker|
setup_dummy_channel(maker)
item_size.times do |i|
maker.items.new_item do |_item|
_item.title = "#{title}#{i}"
_item.link = "#{link}#{i}"
_item.description = "#{description}#{i}"
end
end
maker.items.max_size = max_size
end
assert_equal(max_size, rss.items.size)
rss.items.each_with_index do |_item, i|
assert_equal("#{link}#{i}", _item.about)
assert_equal("#{title}#{i}", _item.title)
assert_equal("#{link}#{i}", _item.link)
assert_equal("#{description}#{i}", _item.description)
end
max_size = 0
assert_not_set_error("maker", %w(items)) do
RSS::Maker.make("1.0") do |maker|
setup_dummy_channel(maker)
item_size.times do |i|
maker.items.new_item do |_item|
_item.title = "#{title}#{i}"
_item.link = "#{link}#{i}"
_item.description = "#{description}#{i}"
end
end
maker.items.max_size = max_size
end
end
max_size = -2
rss = RSS::Maker.make("1.0") do |maker|
setup_dummy_channel(maker)
item_size.times do |i|
maker.items.new_item do |_item|
_item.title = "#{title}#{i}"
_item.link = "#{link}#{i}"
_item.description = "#{description}#{i}"
end
end
maker.items.max_size = max_size
end
assert_equal(item_size + max_size + 1, rss.items.size)
rss.items.each_with_index do |_item, i|
assert_equal("#{link}#{i}", _item.about)
assert_equal("#{title}#{i}", _item.title)
assert_equal("#{link}#{i}", _item.link)
assert_equal("#{description}#{i}", _item.description)
end
end
def test_items_with_new_api_since_018
test_items(false)
end
def test_not_valid_items
title = "TITLE"
link = "http://hoge.com/"
assert_not_set_error("maker.item", %w(title)) do
RSS::Maker.make("1.0") do |maker|
setup_dummy_channel(maker)
maker.items.new_item do |item|
# item.title = title
item.link = link
end
end
end
assert_not_set_error("maker.item", %w(link)) do
RSS::Maker.make("1.0") do |maker|
setup_dummy_channel(maker)
maker.items.new_item do |item|
item.title = title
# item.link = link
end
end
end
assert_not_set_error("maker.item", %w(title link)) do
RSS::Maker.make("1.0") do |maker|
setup_dummy_channel(maker)
maker.items.new_item do |item|
# item.title = title
# item.link = link
end
end
end
end
def test_textinput
title = "fugafuga"
description = "text hoge fuga"
name = "hoge"
link = "http://hoge.com"
rss = RSS::Maker.make("1.0") do |maker|
setup_dummy_channel(maker)
maker.textinput.link = link
maker.textinput.title = title
maker.textinput.description = description
maker.textinput.name = name
setup_dummy_item(maker)
end
textinput = rss.textinput
assert_equal(link, textinput.about)
assert_equal(link, rss.channel.textinput.resource)
assert_equal(title, textinput.title)
assert_equal(name, textinput.name)
assert_equal(description, textinput.description)
assert_equal(link, textinput.link)
assert_not_set_error("maker.channel", %w(about link description title)) do
RSS::Maker.make("1.0") do |maker|
# setup_dummy_channel(maker)
maker.textinput.link = link
maker.textinput.title = title
maker.textinput.description = description
maker.textinput.name = name
end
end
end
def test_not_valid_textinput
title = "fugafuga"
description = "text hoge fuga"
name = "hoge"
link = "http://hoge.com"
rss = RSS::Maker.make("1.0") do |maker|
setup_dummy_channel(maker)
# maker.textinput.link = link
maker.textinput.title = title
maker.textinput.description = description
maker.textinput.name = name
setup_dummy_item(maker)
end
assert_nil(rss.channel.textinput)
assert_nil(rss.textinput)
rss = RSS::Maker.make("1.0") do |maker|
setup_dummy_channel(maker)
maker.textinput.link = link
# maker.textinput.title = title
maker.textinput.description = description
maker.textinput.name = name
setup_dummy_item(maker)
end
assert_nil(rss.channel.textinput)
assert_nil(rss.textinput)
rss = RSS::Maker.make("1.0") do |maker|
setup_dummy_channel(maker)
maker.textinput.link = link
maker.textinput.title = title
# maker.textinput.description = description
maker.textinput.name = name
setup_dummy_item(maker)
end
assert_nil(rss.channel.textinput)
assert_nil(rss.textinput)
rss = RSS::Maker.make("1.0") do |maker|
setup_dummy_channel(maker)
maker.textinput.link = link
maker.textinput.title = title
maker.textinput.description = description
# maker.textinput.name = name
setup_dummy_item(maker)
end
assert_nil(rss.channel.textinput)
assert_nil(rss.textinput)
end
end
end

758
test/rss/test_maker_2.0.rb
Просмотреть файл

@ -1,758 +0,0 @@
# frozen_string_literal: false
require_relative "rss-testcase"
require "rss/maker"
module RSS
class TestMaker20 < TestCase
def test_supported?
assert(RSS::Maker.supported?("2.0"))
assert(RSS::Maker.supported?("rss2.0"))
assert(!RSS::Maker.supported?("2.2"))
assert(!RSS::Maker.supported?("rss2.2"))
end
def test_find_class
assert_equal(RSS::Maker::RSS20, RSS::Maker["2.0"])
assert_equal(RSS::Maker::RSS20, RSS::Maker["rss2.0"])
end
def test_rss
assert_raise(LocalJumpError) do
RSS::Maker.make("2.0")
end
rss = RSS::Maker.make("2.0") do |maker|
setup_dummy_channel(maker)
end
assert_equal("2.0", rss.rss_version)
rss = RSS::Maker.make("2.0") do |maker|
setup_dummy_channel(maker)
maker.encoding = "EUC-JP"
end
assert_equal("2.0", rss.rss_version)
assert_equal("EUC-JP", rss.encoding)
rss = RSS::Maker.make("2.0") do |maker|
setup_dummy_channel(maker)
maker.standalone = "yes"
end
assert_equal("2.0", rss.rss_version)
assert_equal("yes", rss.standalone)
rss = RSS::Maker.make("2.0") do |maker|
setup_dummy_channel(maker)
maker.encoding = "EUC-JP"
maker.standalone = "yes"
end
assert_equal("2.0", rss.rss_version)
assert_equal("EUC-JP", rss.encoding)
assert_equal("yes", rss.standalone)
end
def test_channel
title = "fugafuga"
link = "http://hoge.com"
description = "fugafugafugafuga"
language = "ja"
copyright = "foo"
managingEditor = "bar"
webMaster = "web master"
rating = '(PICS-1.1 "http://www.rsac.org/ratingsv01.html" l gen true comment "RSACi North America Server" for "http://www.rsac.org" on "1996.04.16T08:15-0500" r (n 0 s 0 v 0 l 0))'
docs = "http://foo.com/doc"
skipDays = [
"Sunday",
"Monday",
]
skipHours = [
"0",
"13",
]
pubDate = Time.now
lastBuildDate = Time.now
categories = [
"Nespapers",
"misc",
]
generator = "RSS Maker"
ttl = "60"
rss = RSS::Maker.make("2.0") do |maker|
maker.channel.title = title
maker.channel.link = link
maker.channel.description = description
maker.channel.language = language
maker.channel.copyright = copyright
maker.channel.managingEditor = managingEditor
maker.channel.webMaster = webMaster
maker.channel.rating = rating
maker.channel.docs = docs
maker.channel.pubDate = pubDate
maker.channel.lastBuildDate = lastBuildDate
skipDays.each do |day|
maker.channel.skipDays.new_day do |new_day|
new_day.content = day
end
end
skipHours.each do |hour|
maker.channel.skipHours.new_hour do |new_hour|
new_hour.content = hour
end
end
categories.each do |category|
maker.channel.categories.new_category do |new_category|
new_category.content = category
end
end
maker.channel.generator = generator
maker.channel.ttl = ttl
end
channel = rss.channel
assert_equal(title, channel.title)
assert_equal(link, channel.link)
assert_equal(description, channel.description)
assert_equal(language, channel.language)
assert_equal(copyright, channel.copyright)
assert_equal(managingEditor, channel.managingEditor)
assert_equal(webMaster, channel.webMaster)
assert_equal(rating, channel.rating)
assert_equal(docs, channel.docs)
assert_equal(pubDate, channel.pubDate)
assert_equal(pubDate, channel.date)
assert_equal(lastBuildDate, channel.lastBuildDate)
skipDays.each_with_index do |day, i|
assert_equal(day, channel.skipDays.days[i].content)
end
skipHours.each_with_index do |hour, i|
assert_equal(hour.to_i, channel.skipHours.hours[i].content)
end
channel.categories.each_with_index do |category, i|
assert_equal(categories[i], category.content)
end
assert_equal(generator, channel.generator)
assert_equal(ttl.to_i, channel.ttl)
assert(channel.items.empty?)
assert_nil(channel.image)
assert_nil(channel.textInput)
end
def test_not_valid_channel
title = "fugafuga"
link = "http://hoge.com"
description = "fugafugafugafuga"
language = "ja"
assert_not_set_error("maker.channel", %w(title)) do
RSS::Maker.make("2.0") do |maker|
# maker.channel.title = title
maker.channel.link = link
maker.channel.description = description
maker.channel.language = language
end
end
assert_not_set_error("maker.channel", %w(link)) do
RSS::Maker.make("2.0") do |maker|
maker.channel.title = title
# maker.channel.link = link
maker.channel.description = description
maker.channel.language = language
end
end
assert_not_set_error("maker.channel", %w(description)) do
RSS::Maker.make("2.0") do |maker|
maker.channel.title = title
maker.channel.link = link
# maker.channel.description = description
maker.channel.language = language
end
end
rss = RSS::Maker.make("2.0") do |maker|
maker.channel.title = title
maker.channel.link = link
maker.channel.description = description
# maker.channel.language = language
end
assert_not_nil(rss)
end
def test_cloud
domain = "rpc.sys.com"
port = "80"
path = "/RPC2"
registerProcedure = "myCloud.rssPleaseNotify"
protocol = "xml-rpc"
rss = RSS::Maker.make("2.0") do |maker|
setup_dummy_channel(maker)
maker.channel.cloud.domain = domain
maker.channel.cloud.port = port
maker.channel.cloud.path = path
maker.channel.cloud.registerProcedure = registerProcedure
maker.channel.cloud.protocol = protocol
end
cloud = rss.channel.cloud
assert_equal(domain, cloud.domain)
assert_equal(port.to_i, cloud.port)
assert_equal(path, cloud.path)
assert_equal(registerProcedure, cloud.registerProcedure)
assert_equal(protocol, cloud.protocol)
end
def test_not_valid_cloud
domain = "rpc.sys.com"
port = "80"
path = "/RPC2"
registerProcedure = "myCloud.rssPleaseNotify"
protocol = "xml-rpc"
rss = RSS::Maker.make("2.0") do |maker|
setup_dummy_channel(maker)
# maker.channel.cloud.domain = domain
maker.channel.cloud.port = port
maker.channel.cloud.path = path
maker.channel.cloud.registerProcedure = registerProcedure
maker.channel.cloud.protocol = protocol
end
assert_nil(rss.channel.cloud)
rss = RSS::Maker.make("2.0") do |maker|
setup_dummy_channel(maker)
maker.channel.cloud.domain = domain
# maker.channel.cloud.port = port
maker.channel.cloud.path = path
maker.channel.cloud.registerProcedure = registerProcedure
maker.channel.cloud.protocol = protocol
end
assert_nil(rss.channel.cloud)
rss = RSS::Maker.make("2.0") do |maker|
setup_dummy_channel(maker)
maker.channel.cloud.domain = domain
maker.channel.cloud.port = port
# maker.channel.cloud.path = path
maker.channel.cloud.registerProcedure = registerProcedure
maker.channel.cloud.protocol = protocol
end
assert_nil(rss.channel.cloud)
rss = RSS::Maker.make("2.0") do |maker|
setup_dummy_channel(maker)
maker.channel.cloud.domain = domain
maker.channel.cloud.port = port
maker.channel.cloud.path = path
# maker.channel.cloud.registerProcedure = registerProcedure
maker.channel.cloud.protocol = protocol
end
assert_nil(rss.channel.cloud)
rss = RSS::Maker.make("2.0") do |maker|
setup_dummy_channel(maker)
maker.channel.cloud.domain = domain
maker.channel.cloud.port = port
maker.channel.cloud.path = path
maker.channel.cloud.registerProcedure = registerProcedure
# maker.channel.cloud.protocol = protocol
end
assert_nil(rss.channel.cloud)
end
def test_image
title = "fugafuga"
link = "http://hoge.com"
url = "http://hoge.com/hoge.png"
width = "144"
height = "400"
description = "an image"
rss = RSS::Maker.make("2.0") do |maker|
setup_dummy_channel(maker)
maker.channel.link = link
maker.image.title = title
maker.image.url = url
maker.image.width = width
maker.image.height = height
maker.image.description = description
end
image = rss.image
assert_equal(title, image.title)
assert_equal(link, image.link)
assert_equal(url, image.url)
assert_equal(width.to_i, image.width)
assert_equal(height.to_i, image.height)
assert_equal(description, image.description)
assert_not_set_error("maker.channel", %w(title description)) do
RSS::Maker.make("2.0") do |maker|
# setup_dummy_channel(maker)
maker.channel.link = link
maker.image.title = title
maker.image.url = url
maker.image.width = width
maker.image.height = height
maker.image.description = description
end
end
end
def test_not_valid_image
title = "fugafuga"
link = "http://hoge.com"
url = "http://hoge.com/hoge.png"
width = "144"
height = "400"
description = "an image"
rss = RSS::Maker.make("2.0") do |maker|
setup_dummy_channel(maker)
maker.channel.link = link
# maker.image.title = title
maker.image.url = url
maker.image.width = width
maker.image.height = height
maker.image.description = description
end
assert_nil(rss.image)
assert_not_set_error("maker.channel", %w(link)) do
RSS::Maker.make("2.0") do |maker|
setup_dummy_channel(maker)
# maker.channel.link = link
maker.channel.link = nil
maker.image.title = title
maker.image.url = url
maker.image.width = width
maker.image.height = height
maker.image.description = description
end
end
rss = RSS::Maker.make("2.0") do |maker|
setup_dummy_channel(maker)
maker.channel.link = link
maker.image.title = title
# maker.image.url = url
maker.image.width = width
maker.image.height = height
maker.image.description = description
end
assert_nil(rss.image)
end
def test_items(with_convenience_way=true)
title = "TITLE"
link = "http://hoge.com/"
description = "text hoge fuga"
author = "oprah@oxygen.net"
comments = "http://www.myblog.org/cgi-local/mt/mt-comments.cgi?entry_id=290"
pubDate = Time.now
rss = RSS::Maker.make("2.0") do |maker|
setup_dummy_channel(maker)
end
assert(rss.channel.items.empty?)
item_size = 5
rss = RSS::Maker.make("2.0") do |maker|
setup_dummy_channel(maker)
item_size.times do |i|
maker.items.new_item do |item|
item.title = "#{title}#{i}"
item.link = "#{link}#{i}"
item.description = "#{description}#{i}"
item.author = "#{author}#{i}"
item.comments = "#{comments}#{i}"
item.date = pubDate - i
end
end
maker.items.do_sort = true
end
assert_equal(item_size, rss.items.size)
rss.channel.items.each_with_index do |item, i|
assert_equal("#{title}#{i}", item.title)
assert_equal("#{link}#{i}", item.link)
assert_equal("#{description}#{i}", item.description)
assert_equal("#{author}#{i}", item.author)
assert_equal("#{comments}#{i}", item.comments)
assert_equal(pubDate - i, item.pubDate)
assert_equal(pubDate - i, item.date)
end
rss = RSS::Maker.make("2.0") do |maker|
setup_dummy_channel(maker)
item_size.times do |i|
maker.items.new_item do |item|
item.title = "#{title}#{i}"
item.link = "#{link}#{i}"
item.description = "#{description}#{i}"
item.author = "#{author}#{i}"
item.comments = "#{comments}#{i}"
item.date = pubDate
end
end
maker.items.do_sort = Proc.new do |x, y|
if with_convenience_way
y.title[-1] <=> x.title[-1]
else
y.title {|t| t.content[-1]} <=> x.title {|t| t.content[-1]}
end
end
end
assert_equal(item_size, rss.items.size)
rss.channel.items.reverse.each_with_index do |item, i|
assert_equal("#{title}#{i}", item.title)
assert_equal("#{link}#{i}", item.link)
assert_equal("#{description}#{i}", item.description)
assert_equal("#{author}#{i}", item.author)
assert_equal("#{comments}#{i}", item.comments)
assert_equal(pubDate, item.pubDate)
assert_equal(pubDate, item.date)
end
end
def test_items_with_new_api_since_018
test_items(false)
end
def test_pubDate_without_description
title = "TITLE"
link = "http://hoge.com/"
# description = "text hoge fuga"
author = "oprah@oxygen.net"
pubDate = Time.now
rss = RSS::Maker.make("2.0") do |maker|
setup_dummy_channel(maker)
maker.items.new_item do |item|
item.title = title
item.link = link
# item.description = description
item.author = author
item.pubDate = pubDate
end
end
assert_equal(1, rss.items.size)
rss.channel.items.each_with_index do |item, i|
assert_equal(title, item.title)
assert_equal(link, item.link)
# assert_equal(description, item.description)
assert_equal(author, item.author)
assert_equal(pubDate, item.pubDate)
assert_equal(pubDate, item.date)
end
end
def test_guid
isPermaLink = "true"
content = "http://inessential.com/2002/09/01.php#a2"
rss = RSS::Maker.make("2.0") do |maker|
setup_dummy_channel(maker)
setup_dummy_item(maker)
guid = maker.items.last.guid
guid.isPermaLink = isPermaLink
guid.content = content
end
guid = rss.channel.items.last.guid
assert_equal(isPermaLink == "true", guid.isPermaLink)
assert_equal(content, guid.content)
end
def test_guid_permanent_link
content = "http://inessential.com/2002/09/01.php#a2"
rss = RSS::Maker.make("2.0") do |maker|
setup_dummy_channel(maker)
setup_dummy_item(maker)
guid = maker.items.last.guid
assert_equal(nil, guid.permanent_link?)
assert_equal(guid.isPermaLink, guid.permanent_link?)
guid.permanent_link = true
assert_equal(true, guid.permanent_link?)
assert_equal(guid.isPermaLink, guid.permanent_link?)
guid.content = content
end
guid = rss.channel.items.last.guid
assert_equal(true, guid.isPermaLink)
assert_equal(content, guid.content)
end
def test_guid_permanent_link_false
content = "http://inessential.com/2002/09/01.php#a2"
rss = RSS::Maker.make("2.0") do |maker|
setup_dummy_channel(maker)
setup_dummy_item(maker)
guid = maker.items.last.guid
assert_equal(nil, guid.permanent_link?)
assert_equal(guid.isPermaLink, guid.permanent_link?)
guid.permanent_link = false
assert_equal(false, guid.permanent_link?)
assert_equal(guid.isPermaLink, guid.permanent_link?)
guid.content = content
end
guid = rss.channel.items.last.guid
assert_equal(false, guid.isPermaLink)
assert_equal(content, guid.content)
end
def test_not_valid_guid
# content = "http://inessential.com/2002/09/01.php#a2"
rss = RSS::Maker.make("2.0") do |maker|
setup_dummy_channel(maker)
setup_dummy_item(maker)
# guid = maker.items.last.guid
# guid.content = content
end
assert_nil(rss.channel.items.last.guid)
end
def test_enclosure
url = "http://www.scripting.com/mp3s/weatherReportSuite.mp3"
length = "12216320"
type = "audio/mpeg"
rss = RSS::Maker.make("2.0") do |maker|
setup_dummy_channel(maker)
setup_dummy_item(maker)
enclosure = maker.items.last.enclosure
enclosure.url = url
enclosure.length = length
enclosure.type = type
end
enclosure = rss.channel.items.last.enclosure
assert_equal(url, enclosure.url)
assert_equal(length.to_i, enclosure.length)
assert_equal(type, enclosure.type)
end
def test_not_valid_enclosure
url = "http://www.scripting.com/mp3s/weatherReportSuite.mp3"
length = "12216320"
type = "audio/mpeg"
rss = RSS::Maker.make("2.0") do |maker|
setup_dummy_channel(maker)
setup_dummy_item(maker)
enclosure = maker.items.last.enclosure
# enclosure.url = url
enclosure.length = length
enclosure.type = type
end
assert_nil(rss.channel.items.last.enclosure)
rss = RSS::Maker.make("2.0") do |maker|
setup_dummy_channel(maker)
setup_dummy_item(maker)
enclosure = maker.items.last.enclosure
enclosure.url = url
# enclosure.length = length
enclosure.type = type
end
assert_nil(rss.channel.items.last.enclosure)
rss = RSS::Maker.make("2.0") do |maker|
setup_dummy_channel(maker)
setup_dummy_item(maker)
enclosure = maker.items.last.enclosure
enclosure.url = url
enclosure.length = length
# enclosure.type = type
end
assert_nil(rss.channel.items.last.enclosure)
end
def test_source
url = "http://static.userland.com/tomalak/links2.xml"
content = "Tomalak's Realm"
rss = RSS::Maker.make("2.0") do |maker|
setup_dummy_channel(maker)
setup_dummy_item(maker)
source = maker.items.last.source
source.url = url
source.content = content
end
source = rss.channel.items.last.source
assert_equal(url, source.url)
assert_equal(content, source.content)
end
def test_not_valid_source
url = "http://static.userland.com/tomalak/links2.xml"
content = "Tomalak's Realm"
rss = RSS::Maker.make("2.0") do |maker|
setup_dummy_channel(maker)
setup_dummy_item(maker)
source = maker.items.last.source
# source.url = url
source.content = content
end
assert_nil(rss.channel.items.last.source)
rss = RSS::Maker.make("2.0") do |maker|
setup_dummy_channel(maker)
setup_dummy_item(maker)
source = maker.items.last.source
source.url = url
# source.content = content
end
assert_nil(rss.channel.items.last.source)
end
def test_category
domain = "http://www.fool.com/cusips"
content = "MSFT"
rss = RSS::Maker.make("2.0") do |maker|
setup_dummy_channel(maker)
setup_dummy_item(maker)
maker.items.last.categories.new_category do |category|
category.domain = domain
category.content = content
end
end
category = rss.channel.items.last.categories.last
assert_equal(domain, category.domain)
assert_equal(content, category.content)
end
def test_not_valid_category
# content = "Grateful Dead"
rss = RSS::Maker.make("2.0") do |maker|
setup_dummy_channel(maker)
setup_dummy_item(maker)
maker.items.last.categories.new_category do |category|
# category.content = content
end
end
assert(rss.channel.items.last.categories.empty?)
end
def test_textInput
title = "fugafuga"
description = "text hoge fuga"
name = "hoge"
link = "http://hoge.com"
rss = RSS::Maker.make("2.0") do |maker|
setup_dummy_channel(maker)
maker.textinput.title = title
maker.textinput.description = description
maker.textinput.name = name
maker.textinput.link = link
end
textInput = rss.channel.textInput
assert_equal(title, textInput.title)
assert_equal(description, textInput.description)
assert_equal(name, textInput.name)
assert_equal(link, textInput.link)
assert_not_set_error("maker.channel", %w(link description title)) do
RSS::Maker.make("2.0") do |maker|
# setup_dummy_channel(maker)
maker.textinput.title = title
maker.textinput.description = description
maker.textinput.name = name
maker.textinput.link = link
end
end
end
def test_not_valid_textInput
title = "fugafuga"
description = "text hoge fuga"
name = "hoge"
link = "http://hoge.com"
rss = RSS::Maker.make("2.0") do |maker|
setup_dummy_channel(maker)
# maker.textinput.title = title
maker.textinput.description = description
maker.textinput.name = name
maker.textinput.link = link
end
assert_nil(rss.channel.textInput)
rss = RSS::Maker.make("2.0") do |maker|
setup_dummy_channel(maker)
maker.textinput.title = title
# maker.textinput.description = description
maker.textinput.name = name
maker.textinput.link = link
end
assert_nil(rss.channel.textInput)
rss = RSS::Maker.make("2.0") do |maker|
setup_dummy_channel(maker)
maker.textinput.title = title
maker.textinput.description = description
# maker.textinput.name = name
maker.textinput.link = link
end
assert_nil(rss.channel.textInput)
rss = RSS::Maker.make("2.0") do |maker|
setup_dummy_channel(maker)
maker.textinput.title = title
maker.textinput.description = description
maker.textinput.name = name
# maker.textinput.link = link
end
assert_nil(rss.channel.textInput)
end
end
end

394
test/rss/test_maker_atom_entry.rb
Просмотреть файл

@ -1,394 +0,0 @@
# frozen_string_literal: false
require_relative "rss-testcase"
require "rss/maker"
module RSS
class TestMakerAtomEntry < TestCase
def test_supported?
assert(RSS::Maker.supported?("atom:entry"))
assert(RSS::Maker.supported?("atom1.0:entry"))
assert(!RSS::Maker.supported?("atom2.0:entry"))
end
def test_find_class
assert_equal(RSS::Maker::Atom::Entry, RSS::Maker["atom:entry"])
assert_equal(RSS::Maker::Atom::Entry, RSS::Maker["atom1.0:entry"])
end
def test_root_element
entry = Maker.make("atom:entry") do |maker|
setup_dummy_channel_atom(maker)
setup_dummy_item_atom(maker)
end
assert_equal(["atom", "1.0", "entry"], entry.feed_info)
entry = Maker.make("atom:entry") do |maker|
setup_dummy_channel_atom(maker)
setup_dummy_item_atom(maker)
maker.encoding = "EUC-JP"
end
assert_equal(["atom", "1.0", "entry"], entry.feed_info)
assert_equal("EUC-JP", entry.encoding)
entry = Maker.make("atom:entry") do |maker|
setup_dummy_channel_atom(maker)
setup_dummy_item_atom(maker)
maker.standalone = "yes"
end
assert_equal(["atom", "1.0", "entry"], entry.feed_info)
assert_equal("yes", entry.standalone)
entry = Maker.make("atom:entry") do |maker|
setup_dummy_channel_atom(maker)
setup_dummy_item_atom(maker)
maker.encoding = "EUC-JP"
maker.standalone = "yes"
end
assert_equal(["atom", "1.0", "entry"], entry.feed_info)
assert_equal("EUC-JP", entry.encoding)
assert_equal("yes", entry.standalone)
end
def test_invalid_feed
assert_not_set_error("maker.item", %w(id title author updated)) do
Maker.make("atom:entry") do |maker|
end
end
assert_not_set_error("maker.item", %w(id title updated)) do
Maker.make("atom:entry") do |maker|
maker.channel.author = "foo"
end
end
assert_not_set_error("maker.item", %w(title updated)) do
Maker.make("atom:entry") do |maker|
maker.channel.author = "foo"
maker.channel.id = "http://example.com"
end
end
assert_not_set_error("maker.item", %w(updated)) do
Maker.make("atom:entry") do |maker|
maker.channel.author = "foo"
maker.channel.id = "http://example.com"
maker.channel.title = "Atom Feed"
end
end
assert_not_set_error("maker.item", %w(author)) do
Maker.make("atom:entry") do |maker|
maker.channel.id = "http://example.com"
maker.channel.title = "Atom Feed"
maker.channel.updated = Time.now
end
end
entry = Maker.make("atom:entry") do |maker|
maker.channel.author = "Foo"
maker.channel.id = "http://example.com"
maker.channel.title = "Atom Feed"
maker.channel.updated = Time.now
end
assert_not_nil(entry)
end
def test_author
assert_maker_atom_persons("entry",
["channel", "authors"],
["authors"],
"maker.channel.author") do |maker|
setup_dummy_channel_atom(maker)
setup_dummy_item_atom(maker)
end
assert_maker_atom_persons("entry",
["items", "first", "authors"],
["authors"],
"maker.item.author",
"maker.item", ["author"]) do |maker|
setup_dummy_channel_atom(maker)
setup_dummy_item_atom(maker)
maker.channel.authors.clear
maker.items.first.authors.clear
end
assert_maker_atom_persons("entry",
["items", "first", "source", "authors"],
["source", "authors"],
"maker.item.source.author") do |maker|
setup_dummy_channel_atom(maker)
setup_dummy_item_atom(maker)
end
end
def test_category
assert_maker_atom_categories("entry",
["channel", "categories"],
["categories"],
"maker.channel.category") do |maker|
setup_dummy_channel_atom(maker)
setup_dummy_item_atom(maker)
end
assert_maker_atom_categories("entry",
["items", "first", "categories"],
["categories"],
"maker.item.category") do |maker|
setup_dummy_channel_atom(maker)
setup_dummy_item_atom(maker)
end
assert_maker_atom_categories("entry",
["items", "first", "source", "categories"],
["source", "categories"],
"maker.item.source.category") do |maker|
setup_dummy_channel_atom(maker)
setup_dummy_item_atom(maker)
end
end
def test_content
assert_maker_atom_content("entry",
["items", "first", "content"],
["content"],
"maker.item.content") do |maker|
setup_dummy_channel_atom(maker)
setup_dummy_item_atom(maker)
end
end
def test_contributor
assert_maker_atom_persons("entry",
["channel", "contributors"],
["contributors"],
"maker.channel.contributor") do |maker|
setup_dummy_channel_atom(maker)
setup_dummy_item_atom(maker)
end
assert_maker_atom_persons("entry",
["items", "first", "contributors"],
["contributors"],
"maker.item.contributor") do |maker|
setup_dummy_channel_atom(maker)
setup_dummy_item_atom(maker)
end
assert_maker_atom_persons("entry",
["items", "first", "source", "contributors"],
["source", "contributors"],
"maker.item.source.contributor") do |maker|
setup_dummy_channel_atom(maker)
setup_dummy_item_atom(maker)
end
end
def test_link
assert_maker_atom_links("entry",
["channel", "links"],
["links"],
"maker.channel.link") do |maker|
setup_dummy_channel_atom(maker)
setup_dummy_item_atom(maker)
maker.channel.links.clear
maker.items.first.links.clear
end
assert_maker_atom_links("entry",
["items", "first", "links"],
["links"],
"maker.item.link") do |maker|
setup_dummy_channel_atom(maker)
setup_dummy_item_atom(maker)
maker.channel.links.clear
maker.items.first.links.clear
end
assert_maker_atom_links("entry",
["items", "first", "source", "links"],
["source", "links"],
"maker.item.source.link", true) do |maker|
setup_dummy_channel_atom(maker)
setup_dummy_item_atom(maker)
end
end
def test_published
assert_maker_atom_date_construct("entry",
["items", "first", "published"],
["published"]
) do |maker|
setup_dummy_channel_atom(maker)
setup_dummy_item_atom(maker)
end
end
def test_rights
assert_maker_atom_text_construct("entry",
["channel", "copyright"],
["rights"]) do |maker|
setup_dummy_channel_atom(maker)
setup_dummy_item_atom(maker)
end
assert_maker_atom_text_construct("entry",
["items", "first", "rights"],
["rights"],
nil, nil, "maker.item.rights"
) do |maker|
setup_dummy_channel_atom(maker)
setup_dummy_item_atom(maker)
end
assert_maker_atom_text_construct("entry",
["items", "first", "source", "rights"],
["source", "rights"],
nil, nil, "maker.item.source.rights"
) do |maker|
setup_dummy_channel_atom(maker)
setup_dummy_item_atom(maker)
end
end
def test_source_generator
assert_maker_atom_generator("entry",
["items", "first", "source", "generator"],
["source", "generator"],
"maker.item.source.generator") do |maker|
setup_dummy_channel_atom(maker)
setup_dummy_item_atom(maker)
end
end
def test_source_icon
assert_maker_atom_icon("entry",
["items", "first", "source", "icon"],
["source", "icon"],
nil, "maker.item.source.icon") do |maker|
setup_dummy_channel_atom(maker)
setup_dummy_item_atom(maker)
end
end
def test_source_id
assert_maker_atom_id("entry",
["items", "first", "source"],
["source"],
"maker.item.source") do |maker|
setup_dummy_channel_atom(maker)
setup_dummy_item_atom(maker)
end
end
def test_source_logo
assert_maker_atom_logo("entry",
["items", "first", "source", "logo"],
["source", "logo"],
nil,
"maker.item.source.logo") do |maker|
setup_dummy_channel_atom(maker)
setup_dummy_item_atom(maker)
end
end
def test_source_subtitle
assert_maker_atom_text_construct("entry",
["items", "first", "source", "subtitle"],
["source", "subtitle"],
nil, nil,
"maker.item.source.subtitle") do |maker|
setup_dummy_channel_atom(maker)
setup_dummy_item_atom(maker)
end
end
def test_summary
assert_maker_atom_text_construct("entry",
["items", "first", "description"],
["summary"],
nil, nil, "maker.item.description"
) do |maker|
setup_dummy_channel_atom(maker)
setup_dummy_item_atom(maker)
end
end
def test_title
assert_maker_atom_text_construct("entry",
["channel", "title"], ["title"],
"maker.item", ["title"],
"maker.channel.title") do |maker|
setup_dummy_channel_atom(maker)
setup_dummy_item_atom(maker)
maker.channel.title = nil
maker.items.first.title = nil
end
assert_maker_atom_text_construct("entry",
["items", "first", "title"],
["title"],
"maker.item", ["title"],
"maker.item.title") do |maker|
setup_dummy_channel_atom(maker)
setup_dummy_item_atom(maker)
maker.channel.title = nil
maker.items.first.title = nil
end
assert_maker_atom_text_construct("entry",
["items", "first", "source", "title"],
["source", "title"],
nil, nil, "maker.item.source.title"
) do |maker|
setup_dummy_channel_atom(maker)
setup_dummy_item_atom(maker)
end
end
def test_updated
assert_maker_atom_date_construct("entry",
["channel", "updated"], ["updated"],
"maker.item", ["updated"]) do |maker|
setup_dummy_channel_atom(maker)
setup_dummy_item_atom(maker)
maker.channel.updated = nil
maker.items.first.updated = nil
end
assert_maker_atom_date_construct("entry",
["items", "first", "updated"],
["updated"],
"maker.item", ["updated"]) do |maker|
setup_dummy_channel_atom(maker)
setup_dummy_item_atom(maker)
maker.channel.updated = nil
maker.items.first.updated = nil
end
assert_maker_atom_date_construct("entry",
["items", "first", "source", "updated"],
["source", "updated"]) do |maker|
setup_dummy_channel_atom(maker)
setup_dummy_item_atom(maker)
end
end
def test_date
date = Time.parse("2004/11/1 10:10")
feed = Maker.make("atom:entry") do |maker|
setup_dummy_channel_atom(maker)
maker.channel.date = nil
maker.items.new_item do |item|
item.link = "http://example.com/article.html"
item.title = "Sample Article"
item.date = date
end
end
assert_equal(date, feed.items[0].updated.content)
assert_equal([date], feed.items[0].dc_dates.collect {|_date| _date.value})
end
end
end

455
test/rss/test_maker_atom_feed.rb
Просмотреть файл

@ -1,455 +0,0 @@
# frozen_string_literal: false
require_relative "rss-testcase"
require "rss/maker"
module RSS
class TestMakerAtomFeed < TestCase
def test_supported?
assert(RSS::Maker.supported?("atom"))
assert(RSS::Maker.supported?("atom:feed"))
assert(RSS::Maker.supported?("atom1.0"))
assert(RSS::Maker.supported?("atom1.0:feed"))
assert(!RSS::Maker.supported?("atom2.0"))
assert(!RSS::Maker.supported?("atom2.0:feed"))
end
def test_find_class
assert_equal(RSS::Maker::Atom::Feed, RSS::Maker["atom"])
assert_equal(RSS::Maker::Atom::Feed, RSS::Maker["atom:feed"])
assert_equal(RSS::Maker::Atom::Feed, RSS::Maker["atom1.0"])
assert_equal(RSS::Maker::Atom::Feed, RSS::Maker["atom1.0:feed"])
end
def test_root_element
feed = Maker.make("atom") do |maker|
setup_dummy_channel_atom(maker)
end
assert_equal(["atom", "1.0", "feed"], feed.feed_info)
feed = Maker.make("atom") do |maker|
setup_dummy_channel_atom(maker)
maker.encoding = "EUC-JP"
end
assert_equal(["atom", "1.0", "feed"], feed.feed_info)
assert_equal("EUC-JP", feed.encoding)
feed = Maker.make("atom") do |maker|
setup_dummy_channel_atom(maker)
maker.standalone = "yes"
end
assert_equal(["atom", "1.0", "feed"], feed.feed_info)
assert_equal("yes", feed.standalone)
feed = Maker.make("atom") do |maker|
setup_dummy_channel_atom(maker)
maker.encoding = "EUC-JP"
maker.standalone = "yes"
end
assert_equal(["atom", "1.0", "feed"], feed.feed_info)
assert_equal("EUC-JP", feed.encoding)
assert_equal("yes", feed.standalone)
end
def test_invalid_feed
assert_not_set_error("maker.channel", %w(id title author updated)) do
Maker.make("atom") do |maker|
end
end
assert_not_set_error("maker.channel", %w(id title updated)) do
Maker.make("atom") do |maker|
maker.channel.author = "foo"
end
end
assert_not_set_error("maker.channel", %w(title updated)) do
Maker.make("atom") do |maker|
maker.channel.author = "foo"
maker.channel.id = "http://example.com"
end
end
assert_not_set_error("maker.channel", %w(updated)) do
Maker.make("atom") do |maker|
maker.channel.author = "foo"
maker.channel.id = "http://example.com"
maker.channel.title = "Atom Feed"
end
end
assert_not_set_error("maker.channel", %w(author)) do
Maker.make("atom") do |maker|
maker.channel.id = "http://example.com"
maker.channel.title = "Atom Feed"
maker.channel.updated = Time.now
end
end
feed = Maker.make("atom") do |maker|
maker.channel.author = "Foo"
maker.channel.id = "http://example.com"
maker.channel.title = "Atom Feed"
maker.channel.updated = Time.now
end
assert_not_nil(feed)
end
def test_author
assert_maker_atom_persons("feed",
["channel", "authors"],
["authors"],
"maker.channel.author") do |maker|
setup_dummy_channel_atom(maker)
end
assert_not_set_error("maker.channel", %w(author)) do
RSS::Maker.make("atom") do |maker|
setup_dummy_channel_atom(maker)
setup_dummy_item_atom(maker)
maker.channel.authors.clear
end
end
assert_maker_atom_persons("feed",
["items", "first", "authors"],
["entries", "first", "authors"],
"maker.item.author") do |maker|
setup_dummy_channel_atom(maker)
setup_dummy_item_atom(maker)
end
assert_maker_atom_persons("feed",
["items", "first", "source", "authors"],
["entries", "first", "source", "authors"],
"maker.item.source.author") do |maker|
setup_dummy_channel_atom(maker)
setup_dummy_item_atom(maker)
end
end
def test_category
assert_maker_atom_categories("feed",
["channel", "categories"],
["categories"],
"maker.channel.category") do |maker|
setup_dummy_channel_atom(maker)
end
assert_maker_atom_categories("feed",
["items", "first", "categories"],
["entries", "first", "categories"],
"maker.item.category") do |maker|
setup_dummy_channel_atom(maker)
setup_dummy_item_atom(maker)
end
assert_maker_atom_categories("feed",
["items", "first", "source", "categories"],
["entries", "first", "source", "categories"],
"maker.item.source.category") do |maker|
setup_dummy_channel_atom(maker)
setup_dummy_item_atom(maker)
end
end
def test_contributor
assert_maker_atom_persons("feed",
["channel", "contributors"],
["contributors"],
"maker.channel.contributor") do |maker|
setup_dummy_channel_atom(maker)
end
assert_maker_atom_persons("feed",
["items", "first", "contributors"],
["entries", "first", "contributors"],
"maker.item.contributor") do |maker|
setup_dummy_channel_atom(maker)
setup_dummy_item_atom(maker)
end
assert_maker_atom_persons("feed",
["items", "first", "source", "contributors"],
["entries", "first", "source", "contributors"],
"maker.item.source.contributor") do |maker|
setup_dummy_channel_atom(maker)
setup_dummy_item_atom(maker)
end
end
def test_generator
assert_maker_atom_generator("feed",
["channel", "generator"],
["generator"]) do |maker|
setup_dummy_channel_atom(maker)
setup_dummy_item_atom(maker)
end
assert_maker_atom_generator("feed",
["items", "first", "source", "generator"],
["entries", "first", "source", "generator"],
"maker.item.source.generator") do |maker|
setup_dummy_channel_atom(maker)
setup_dummy_item_atom(maker)
end
end
def test_icon
assert_maker_atom_icon("feed", ["channel"], ["icon"], "icon") do |maker|
setup_dummy_channel_atom(maker)
end
assert_maker_atom_icon("feed",
["items", "first", "source", "icon"],
["entries", "first", "source", "icon"],
nil, "maker.item.source.icon") do |maker|
setup_dummy_channel_atom(maker)
setup_dummy_item_atom(maker)
end
end
def test_link
assert_maker_atom_links("feed",
["channel", "links"],
["links"],
"maker.channel.link") do |maker|
setup_dummy_channel_atom(maker)
end
assert_maker_atom_links("feed",
["items", "first", "links"],
["entries", "first", "links"],
"maker.item.link") do |maker|
setup_dummy_channel_atom(maker)
setup_dummy_item_atom(maker)
end
assert_maker_atom_links("feed",
["items", "first", "source", "links"],
["entries", "first", "source", "links"],
"maker.item.source.link", true) do |maker|
setup_dummy_channel_atom(maker)
setup_dummy_item_atom(maker)
end
end
def test_logo
assert_maker_atom_logo("feed", ["channel"], ["logo"], "logo") do |maker|
setup_dummy_channel_atom(maker)
end
assert_maker_atom_logo("feed", ["image"], ["logo"], "url") do |maker|
setup_dummy_channel_atom(maker)
end
assert_maker_atom_logo("feed",
["items", "first", "source", "logo"],
["entries", "first", "source", "logo"],
nil, "maker.item.source.logo") do |maker|
setup_dummy_channel_atom(maker)
setup_dummy_item_atom(maker)
end
end
def test_rights
assert_maker_atom_text_construct("feed",
["channel", "copyright"],
["rights"]) do |maker|
setup_dummy_channel_atom(maker)
end
assert_maker_atom_text_construct("feed",
["items", "first", "rights"],
["entries", "first", "rights"],
nil, nil, "maker.item.rights"
) do |maker|
setup_dummy_channel_atom(maker)
setup_dummy_item_atom(maker)
end
assert_maker_atom_text_construct("feed",
["items", "first", "source", "rights"],
["entries", "first", "source", "rights"],
nil, nil, "maker.item.source.rights"
) do |maker|
setup_dummy_channel_atom(maker)
setup_dummy_item_atom(maker)
end
end
def test_subtitle
assert_maker_atom_text_construct("feed",
["channel", "subtitle"],
["subtitle"],
nil, nil,
"maker.channel.description") do |maker|
setup_dummy_channel_atom(maker)
maker.channel.description = nil
end
assert_maker_atom_text_construct("feed",
["channel", "subtitle"],
["subtitle"],
nil, nil,
"maker.channel.description") do |maker|
setup_dummy_channel_atom(maker)
maker.channel.description {|d| d.content = nil}
end
assert_maker_atom_text_construct("feed",
["items", "first", "source", "subtitle"],
["entries", "first",
"source", "subtitle"],
nil, nil,
"maker.item.source.subtitle") do |maker|
setup_dummy_channel_atom(maker)
setup_dummy_item_atom(maker)
end
end
def test_title
assert_maker_atom_text_construct("feed",
["channel", "title"], ["title"],
"maker.channel", ["title"]) do |maker|
setup_dummy_channel_atom(maker)
maker.channel.title = nil
end
assert_maker_atom_text_construct("feed",
["items", "first", "title"],
["entries", "first", "title"],
"maker.item", ["title"],
"maker.item.title") do |maker|
setup_dummy_channel_atom(maker)
setup_dummy_item_atom(maker)
maker.items.first.title = nil
end
assert_maker_atom_text_construct("feed",
["items", "first", "source", "title"],
["entries", "first", "source", "title"],
nil, nil, "maker.item.source.title"
) do |maker|
setup_dummy_channel_atom(maker)
setup_dummy_item_atom(maker)
end
end
def test_updated
assert_maker_atom_date_construct("feed",
["channel", "updated"], ["updated"],
"maker.channel", ["updated"]) do |maker|
setup_dummy_channel_atom(maker)
maker.channel.updated = nil
end
assert_maker_atom_date_construct("feed",
["items", "first", "updated"],
["entries", "first", "updated"],
"maker.item", ["updated"]) do |maker|
setup_dummy_channel_atom(maker)
setup_dummy_item_atom(maker)
maker.items.first.updated = nil
end
assert_maker_atom_date_construct("feed",
["items", "first", "source", "updated"],
["entries", "first", "source", "updated"]
) do |maker|
setup_dummy_channel_atom(maker)
setup_dummy_item_atom(maker)
end
end
def test_published
assert_maker_atom_date_construct("feed",
["items", "first", "published"],
["entries", "first", "published"]
) do |maker|
setup_dummy_channel_atom(maker)
setup_dummy_item_atom(maker)
end
end
def test_summary
assert_maker_atom_text_construct("feed",
["items", "first", "description"],
["entries", "first", "summary"],
nil, nil, "maker.item.description"
) do |maker|
setup_dummy_channel_atom(maker)
setup_dummy_item_atom(maker)
end
end
def test_content
assert_maker_atom_content("feed",
["items", "first", "content"],
["entries", "first", "content"],
"maker.item.content") do |maker|
setup_dummy_channel_atom(maker)
setup_dummy_item_atom(maker)
end
end
def test_id
assert_maker_atom_id("feed",
["items", "first", "source"],
["entries", "first", "source"],
"maker.item.source") do |maker|
setup_dummy_channel_atom(maker)
setup_dummy_item_atom(maker)
end
end
def test_language
language = "ja"
feed = Maker.make("atom") do |maker|
setup_dummy_channel_atom(maker)
maker.channel.language = "ja"
end
assert_equal(language, feed.dc_language)
end
def test_date
date = Time.parse("2004/11/1 10:10")
feed = Maker.make("atom") do |maker|
setup_dummy_channel_atom(maker)
maker.items.new_item do |item|
item.link = "http://example.com/article.html"
item.title = "sample article"
item.date = date
end
end
assert_equal(date, feed.items[0].updated.content)
assert_equal([date], feed.items[0].dc_dates.collect {|_date| _date.value})
end
def test_channel_dc_date
date = Time.parse("2004/11/1 10:10")
feed = Maker.make("atom") do |maker|
setup_dummy_channel_atom(maker)
maker.channel.updated = nil
maker.channel.dc_date = date
setup_dummy_item_atom(maker)
end
assert_equal(date, feed.updated.content)
assert_equal([date], feed.dc_dates.collect {|_date| _date.value})
end
def test_item_dc_date
date = Time.parse("2004/11/1 10:10")
feed = Maker.make("atom") do |maker|
setup_dummy_channel_atom(maker)
maker.items.new_item do |item|
item.link = "http://example.com/article.html"
item.title = "sample article"
item.dc_date = date
end
end
assert_equal(date, feed.items[0].updated.content)
assert_equal([date], feed.items[0].dc_dates.collect {|_date| _date.value})
end
end
end

48
test/rss/test_maker_content.rb
Просмотреть файл

@ -1,48 +0,0 @@
# frozen_string_literal: false
require_relative "rss-testcase"
require "rss/maker"
module RSS
class TestMakerContent < TestCase
def setup
@uri = "http://purl.org/rss/1.0/modules/content/"
@elements = {
:encoded => "<em>ATTENTION</em>",
}
end
def test_rss10
rss = RSS::Maker.make("1.0") do |maker|
setup_dummy_channel(maker)
setup_dummy_item(maker)
item = maker.items.last
@elements.each do |name, value|
item.__send__("#{accessor_name(name)}=", value)
end
end
assert_content(@elements, rss.items.last)
end
def test_rss20
rss = RSS::Maker.make("2.0") do |maker|
setup_dummy_channel(maker)
setup_dummy_item(maker)
item = maker.items.last
@elements.each do |name, value|
item.__send__("#{accessor_name(name)}=", value)
end
end
assert_content(@elements, rss.items.last)
end
private
def accessor_name(name)
"content_#{name}"
end
end
end

150
test/rss/test_maker_dc.rb
Просмотреть файл

@ -1,150 +0,0 @@
# frozen_string_literal: false
require_relative "rss-testcase"
require "rss/maker"
module RSS
class TestMakerDublinCore < TestCase
def setup
@uri = "http://purl.org/dc/elements/1.1/"
t = Time.iso8601("2000-01-01T12:00:05+00:00")
class << t
alias_method(:to_s, :iso8601)
end
@elements = {
:title => "hoge",
:description =>
" XML is placing increasingly heavy loads on
the existing technical infrastructure of the Internet.",
:creator => "Rael Dornfest (mailto:rael@oreilly.com)",
:subject => "XML",
:publisher => "The O'Reilly Network",
:contributor => "hogehoge",
:type => "fugafuga",
:format => "hohoho",
:identifier => "fufufu",
:source => "barbar",
:language => "ja",
:relation => "cococo",
:rights => "Copyright (c) 2000 O'Reilly &amp; Associates, Inc.",
:date => t,
}
end
def test_rss10
rss = RSS::Maker.make("1.0") do |maker|
setup_dummy_channel(maker)
set_elements(maker.channel)
setup_dummy_image(maker)
set_elements(maker.image)
setup_dummy_item(maker)
item = maker.items.last
@elements.each do |name, value|
item.__send__("#{accessor_name(name)}=", value)
end
setup_dummy_textinput(maker)
set_elements(maker.textinput)
end
assert_dublin_core(@elements, rss.channel)
assert_dublin_core(@elements, rss.image)
assert_dublin_core(@elements, rss.items.last)
assert_dublin_core(@elements, rss.textinput)
end
def test_rss10_multiple
assert_multiple_dublin_core_rss10("_list")
assert_multiple_dublin_core_rss10("es")
end
def assert_multiple_dublin_core_rss10(multiple_rights_suffix)
elems = []
@elements.each do |name, value|
plural = name.to_s + (name == :rights ? multiple_rights_suffix : "s")
values = [value]
if name == :date
values << value + 60
else
values << value * 2
end
elems << [name, values, plural]
end
rss = RSS::Maker.make("1.0") do |maker|
setup_dummy_channel(maker)
set_multiple_elements(maker.channel, elems)
setup_dummy_image(maker)
set_multiple_elements(maker.image, elems)
setup_dummy_item(maker)
item = maker.items.last
elems.each do |name, values, plural|
dc_elems = item.__send__("dc_#{plural}")
values.each do |value|
elem = dc_elems.__send__("new_#{name}")
elem.value = value
end
end
setup_dummy_textinput(maker)
set_multiple_elements(maker.textinput, elems)
end
assert_multiple_dublin_core(elems, rss.channel)
assert_multiple_dublin_core(elems, rss.image)
assert_multiple_dublin_core(elems, rss.items.last)
assert_multiple_dublin_core(elems, rss.textinput)
end
def test_date
t1 = Time.iso8601("2000-01-01T12:00:05+00:00")
t2 = Time.iso8601("2005-01-01T12:00:05+00:00")
rss = RSS::Maker.make("1.0") do |maker|
setup_dummy_channel(maker)
maker.channel.date = t1
maker.channel.dc_dates.new_date do |date|
date.value = t2
end
setup_dummy_item(maker)
item = maker.items.last
item.date = t2
item.dc_dates.new_date do |date|
date.value = t1
end
end
assert_equal([t1, t2], rss.channel.dc_dates.collect{|x| x.value})
assert_equal([t2, t1], rss.items.last.dc_dates.collect{|x| x.value})
end
private
def accessor_name(name)
"dc_#{name}"
end
def set_elements(target, elems=@elements)
elems.each do |name, value|
target.__send__("#{accessor_name(name)}=", value)
end
end
def set_multiple_elements(target, elems)
elems.each do |name, values, plural|
plural ||= "#{name}s"
dc_elems = target.__send__("dc_#{plural}")
values.each do |value|
dc_elems.__send__("new_#{name}") do |new_dc_elem|
new_dc_elem.value = value
end
end
end
end
end
end

63
test/rss/test_maker_image.rb
Просмотреть файл

@ -1,63 +0,0 @@
# frozen_string_literal: false
require_relative "rss-testcase"
require "rss/maker"
module RSS
class TestMakerImage < TestCase
def setup
@uri = "http://web.resource.org/rss/1.0/modules/image/"
@favicon_infos = {
"about" => "http://www.kuro5hin.org/favicon.ico",
"image_size" => "small",
"dc_title" => "example",
}
@item_infos = {
"about" => "http://www.example.org/item.png",
"resource" => "http://www.example.org/item",
"dc_title" => "Example Image",
"image_width" => "100",
"image_height" => "65",
}
end
def test_rss10
rss = RSS::Maker.make("1.0") do |maker|
setup_dummy_channel(maker)
@favicon_infos.each do |name, value|
maker.channel.image_favicon.__send__("#{name}=", value)
end
setup_dummy_image(maker)
setup_dummy_item(maker)
item = maker.items.last
@item_infos.each do |name, value|
item.image_item.__send__("#{name}=", value)
end
setup_dummy_textinput(maker)
end
setup_rss = RSS::Maker.make("1.0") do |maker|
rss.setup_maker(maker)
end
[rss, setup_rss].each_with_index do |target, i|
favicon = target.channel.image_favicon
assert_equal(@favicon_infos["about"], favicon.about)
assert_equal(@favicon_infos["image_size"], favicon.image_size)
assert_equal(@favicon_infos["dc_title"], favicon.dc_title)
item = target.items.last.image_item
assert_equal(@item_infos["about"], item.about)
assert_equal(@item_infos["resource"], item.resource)
assert_equal(@item_infos["image_width"].to_i, item.image_width)
assert_equal(@item_infos["image_height"].to_i, item.image_height)
assert_equal(@item_infos["dc_title"], item.dc_title)
end
end
end
end

487
test/rss/test_maker_itunes.rb
Просмотреть файл

@ -1,487 +0,0 @@
# frozen_string_literal: false
require_relative "rss-testcase"
require "rss/maker"
module RSS
class TestMakerITunes < TestCase
def test_author
assert_maker_itunes_author(%w(channel))
assert_maker_itunes_author(%w(items last))
end
def test_block
assert_maker_itunes_block(%w(channel))
assert_maker_itunes_block(%w(items last))
end
def test_category
assert_maker_itunes_category(%w(channel))
end
def test_image
assert_maker_itunes_image(%w(channel))
end
def test_duration
assert_maker_itunes_duration(%w(items last))
end
def test_explicit
assert_maker_itunes_explicit(%w(channel))
assert_maker_itunes_explicit(%w(items last))
end
def test_keywords
assert_maker_itunes_keywords(%w(channel))
assert_maker_itunes_keywords(%w(items last))
end
def test_new_feed_url
assert_maker_itunes_new_feed_url(%w(channel))
end
def test_owner
assert_maker_itunes_owner(%w(channel))
end
def test_subtitle
assert_maker_itunes_subtitle(%w(channel))
assert_maker_itunes_subtitle(%w(items last))
end
def test_summary
assert_maker_itunes_summary(%w(channel))
assert_maker_itunes_summary(%w(items last))
end
private
def assert_maker_itunes_author(maker_readers, feed_readers=nil)
_wrap_assertion do
feed_readers ||= maker_readers
author = "John Doe"
rss20 = ::RSS::Maker.make("rss2.0") do |maker|
setup_dummy_channel(maker)
setup_dummy_item(maker)
target = chain_reader(maker, maker_readers)
target.itunes_author = author
end
target = chain_reader(rss20, feed_readers)
assert_equal(author, target.itunes_author)
end
end
def _assert_maker_itunes_block(value, boolean_value, maker_readers,
feed_readers)
rss20 = ::RSS::Maker.make("rss2.0") do |maker|
setup_dummy_channel(maker)
setup_dummy_item(maker)
target = chain_reader(maker, maker_readers)
target.itunes_block = value
assert_equal(value, target.itunes_block)
assert_equal(boolean_value, target.itunes_block?)
end
target = chain_reader(rss20, feed_readers)
if [true, false].include?(value)
value = value ? "yes" : "no"
end
assert_equal(value, target.itunes_block)
assert_equal(boolean_value, target.itunes_block?)
end
def assert_maker_itunes_block(maker_readers, feed_readers=nil)
_wrap_assertion do
feed_readers ||= maker_readers
_assert_maker_itunes_block("yes", true, maker_readers, feed_readers)
_assert_maker_itunes_block("Yes", true, maker_readers, feed_readers)
_assert_maker_itunes_block("no", false, maker_readers, feed_readers)
_assert_maker_itunes_block("", false, maker_readers, feed_readers)
_assert_maker_itunes_block(true, true, maker_readers, feed_readers)
_assert_maker_itunes_block(false, false, maker_readers, feed_readers)
_assert_maker_itunes_block(nil, false, maker_readers, feed_readers)
end
end
def _assert_maker_itunes_category(categories, maker_readers, feed_readers)
rss20 = ::RSS::Maker.make("rss2.0") do |maker|
setup_dummy_channel(maker)
setup_dummy_item(maker)
target = chain_reader(maker, maker_readers)
categories.each do |category|
sub_target = target.itunes_categories
if category.is_a?(Array)
category.each do |sub_category|
sub_target = sub_target.new_category
sub_target.text = sub_category
end
else
sub_target.new_category.text = category
end
end
end
target = chain_reader(rss20, feed_readers)
actual_categories = target.itunes_categories.collect do |category|
cat = category.text
if category.itunes_categories.empty?
cat
else
[cat, *category.itunes_categories.collect {|c| c.text}]
end
end
assert_equal(categories, actual_categories)
end
def assert_maker_itunes_category(maker_readers, feed_readers=nil)
_wrap_assertion do
feed_readers ||= maker_readers
_assert_maker_itunes_category(["Audio Blogs"],
maker_readers, feed_readers)
_assert_maker_itunes_category([["Arts & Entertainment", "Games"]],
maker_readers, feed_readers)
_assert_maker_itunes_category([["Arts & Entertainment", "Games"],
["Technology", "Computers"],
"Audio Blogs"],
maker_readers, feed_readers)
end
end
def assert_maker_itunes_image(maker_readers, feed_readers=nil)
_wrap_assertion do
feed_readers ||= maker_readers
url = "http://example.com/podcasts/everything/AllAboutEverything.jpg"
rss20 = ::RSS::Maker.make("rss2.0") do |maker|
setup_dummy_channel(maker)
setup_dummy_item(maker)
target = chain_reader(maker, maker_readers)
target.itunes_image = url
end
target = chain_reader(rss20, feed_readers)
assert_not_nil(target.itunes_image)
assert_equal(url, target.itunes_image.href)
end
end
def _assert_maker_itunes_duration(hour, minute, second, value,
maker_readers, feed_readers)
_assert_maker_itunes_duration_by_value(hour, minute, second, value,
maker_readers, feed_readers)
_assert_maker_itunes_duration_by_hour_minute_second(hour, minute, second,
value,
maker_readers,
feed_readers)
end
def _assert_maker_itunes_duration_by(hour, minute, second, value,
maker_readers, feed_readers)
expected_value = nil
rss20 = ::RSS::Maker.make("rss2.0") do |maker|
setup_dummy_channel(maker)
setup_dummy_item(maker)
target = chain_reader(maker, maker_readers)
expected_value = yield(target)
assert_equal(expected_value, target.itunes_duration)
target.itunes_duration do |duration|
assert_equal([hour, minute, second, expected_value],
[duration.hour, duration.minute,
duration.second, duration.content])
end
end
target = chain_reader(rss20, feed_readers)
duration = target.itunes_duration
assert_not_nil(duration)
assert_equal([hour, minute, second, expected_value],
[duration.hour, duration.minute,
duration.second, duration.content])
end
def _assert_maker_itunes_duration_by_value(hour, minute, second, value,
maker_readers, feed_readers)
_assert_maker_itunes_duration_by(hour, minute, second, value,
maker_readers, feed_readers) do |target|
target.itunes_duration = value
value
end
end
def _assert_maker_itunes_duration_by_hour_minute_second(hour, minute, second,
value,
maker_readers,
feed_readers)
_assert_maker_itunes_duration_by(hour, minute, second, value,
maker_readers, feed_readers) do |target|
target.itunes_duration do |duration|
duration.hour = hour
duration.minute = minute
duration.second = second
end
value.split(":").collect {|v| "%02d" % v.to_i}.join(":")
end
end
def _assert_maker_itunes_duration_invalid_value(value, maker_readers)
assert_raise(ArgumentError) do
::RSS::Maker.make("rss2.0") do |maker|
setup_dummy_channel(maker)
setup_dummy_item(maker)
target = chain_reader(maker, maker_readers)
target.itunes_duration = value
end
end
end
def assert_maker_itunes_duration(maker_readers, feed_readers=nil)
_wrap_assertion do
feed_readers ||= maker_readers
_assert_maker_itunes_duration(7, 14, 5, "07:14:05", maker_readers,
feed_readers)
_assert_maker_itunes_duration(7, 14, 5, "7:14:05", maker_readers,
feed_readers)
_assert_maker_itunes_duration(0, 4, 55, "04:55", maker_readers,
feed_readers)
_assert_maker_itunes_duration(0, 4, 5, "4:05", maker_readers,
feed_readers)
_assert_maker_itunes_duration(0, 0, 5, "0:05", maker_readers,
feed_readers)
_assert_maker_itunes_duration_by_value(0, 5, 15, "315", maker_readers,
feed_readers)
_assert_maker_itunes_duration_by_value(1, 0, 1, "3601", maker_readers,
feed_readers)
_assert_maker_itunes_duration_invalid_value("09:07:14:05", maker_readers)
_assert_maker_itunes_duration_invalid_value("10:5", maker_readers)
_assert_maker_itunes_duration_invalid_value("10:03:5", maker_readers)
_assert_maker_itunes_duration_invalid_value("10:3:05", maker_readers)
_assert_maker_itunes_duration_invalid_value("xx:xx:xx", maker_readers)
_assert_maker_itunes_duration_invalid_value("", maker_readers)
end
end
def _assert_maker_itunes_explicit(explicit, value,
maker_readers, feed_readers)
rss20 = ::RSS::Maker.make("rss2.0") do |maker|
setup_dummy_channel(maker)
setup_dummy_item(maker)
target = chain_reader(maker, maker_readers)
target.itunes_explicit = value
assert_equal(explicit, target.itunes_explicit?)
end
target = chain_reader(rss20, feed_readers)
assert_equal(value, target.itunes_explicit)
assert_equal(explicit, target.itunes_explicit?)
end
def assert_maker_itunes_explicit(maker_readers, feed_readers=nil)
_wrap_assertion do
feed_readers ||= maker_readers
_assert_maker_itunes_explicit(true, "explicit",
maker_readers, feed_readers)
_assert_maker_itunes_explicit(true, "yes",
maker_readers, feed_readers)
_assert_maker_itunes_explicit(true, "true",
maker_readers, feed_readers)
_assert_maker_itunes_explicit(false, "clean",
maker_readers, feed_readers)
_assert_maker_itunes_explicit(false, "no",
maker_readers, feed_readers)
_assert_maker_itunes_explicit(false, "false",
maker_readers, feed_readers)
_assert_maker_itunes_explicit(nil, "invalid",
maker_readers, feed_readers)
end
end
def _assert_maker_itunes_keywords(keywords, value,
maker_readers, feed_readers)
_assert_maker_itunes_keywords_by_value(keywords, value,
maker_readers, feed_readers)
_assert_maker_itunes_keywords_by_keywords(keywords, maker_readers,
feed_readers)
end
def _assert_maker_itunes_keywords_by(keywords, maker_readers, feed_readers)
rss20 = ::RSS::Maker.make("rss2.0") do |maker|
setup_dummy_channel(maker)
setup_dummy_item(maker)
target = chain_reader(maker, maker_readers)
yield(target)
end
assert_nothing_raised do
rss20 = ::RSS::Parser.parse(rss20.to_s)
end
target = chain_reader(rss20, feed_readers)
assert_equal(keywords, target.itunes_keywords)
end
def _assert_maker_itunes_keywords_by_value(keywords, value,
maker_readers, feed_readers)
_assert_maker_itunes_keywords_by(keywords, maker_readers,
feed_readers) do |target|
target.itunes_keywords = value
end
end
def _assert_maker_itunes_keywords_by_keywords(keywords,
maker_readers, feed_readers)
_assert_maker_itunes_keywords_by(keywords, maker_readers,
feed_readers) do |target|
target.itunes_keywords = keywords
end
end
def assert_maker_itunes_keywords(maker_readers, feed_readers=nil)
_wrap_assertion do
feed_readers ||= maker_readers
_assert_maker_itunes_keywords(["salt"], "salt",
maker_readers, feed_readers)
_assert_maker_itunes_keywords(["salt"], " salt ",
maker_readers, feed_readers)
_assert_maker_itunes_keywords(["salt", "pepper", "shaker", "exciting"],
"salt, pepper, shaker, exciting",
maker_readers, feed_readers)
_assert_maker_itunes_keywords(["metric", "socket", "wrenches",
"toolsalt"],
"metric, socket, wrenches, toolsalt",
maker_readers, feed_readers)
_assert_maker_itunes_keywords(["olitics", "red", "blue", "state"],
"olitics, red, blue, state",
maker_readers, feed_readers)
end
end
def assert_maker_itunes_new_feed_url(maker_readers, feed_readers=nil)
feed_readers ||= maker_readers
url = "http://newlocation.com/example.rss"
rss20 = ::RSS::Maker.make("rss2.0") do |maker|
setup_dummy_channel(maker)
setup_dummy_item(maker)
target = chain_reader(maker, maker_readers)
target.itunes_new_feed_url = url
end
target = chain_reader(rss20, feed_readers)
assert_equal(url, target.itunes_new_feed_url)
end
def _assert_maker_itunes_owner(name, email, maker_readers, feed_readers)
rss20 = ::RSS::Maker.make("rss2.0") do |maker|
setup_dummy_channel(maker)
setup_dummy_item(maker)
target = chain_reader(maker, maker_readers)
owner = target.itunes_owner
owner.itunes_name = name
owner.itunes_email = email
end
owner = chain_reader(rss20, feed_readers).itunes_owner
if name.nil? and email.nil?
assert_nil(owner)
else
assert_not_nil(owner)
assert_equal(name, owner.itunes_name)
assert_equal(email, owner.itunes_email)
end
end
def assert_maker_itunes_owner(maker_readers, feed_readers=nil)
_wrap_assertion do
feed_readers ||= maker_readers
_assert_maker_itunes_owner("John Doe", "john.doe@example.com",
maker_readers, feed_readers)
not_set_name = (["maker"] + maker_readers + ["itunes_owner"]).join(".")
assert_not_set_error(not_set_name, ["itunes_name"]) do
_assert_maker_itunes_owner(nil, "john.doe@example.com",
maker_readers, feed_readers)
end
assert_not_set_error(not_set_name, ["itunes_email"]) do
_assert_maker_itunes_owner("John Doe", nil,
maker_readers, feed_readers)
end
_assert_maker_itunes_owner(nil, nil, maker_readers, feed_readers)
end
end
def _assert_maker_itunes_subtitle(subtitle, maker_readers, feed_readers)
rss20 = ::RSS::Maker.make("rss2.0") do |maker|
setup_dummy_channel(maker)
setup_dummy_item(maker)
target = chain_reader(maker, maker_readers)
target.itunes_subtitle = subtitle
end
target = chain_reader(rss20, feed_readers)
assert_equal(subtitle, target.itunes_subtitle)
end
def assert_maker_itunes_subtitle(maker_readers, feed_readers=nil)
_wrap_assertion do
feed_readers ||= maker_readers
_assert_maker_itunes_subtitle("A show about everything",
maker_readers, feed_readers)
_assert_maker_itunes_subtitle("A short primer on table spices",
maker_readers, feed_readers)
_assert_maker_itunes_subtitle("Comparing socket wrenches is fun!",
maker_readers, feed_readers)
_assert_maker_itunes_subtitle("Red + Blue != Purple",
maker_readers, feed_readers)
end
end
def _assert_maker_itunes_summary(summary, maker_readers, feed_readers)
rss20 = ::RSS::Maker.make("rss2.0") do |maker|
setup_dummy_channel(maker)
setup_dummy_item(maker)
target = chain_reader(maker, maker_readers)
target.itunes_summary = summary
end
target = chain_reader(rss20, feed_readers)
assert_equal(summary, target.itunes_summary)
end
def assert_maker_itunes_summary(maker_readers, feed_readers=nil)
_wrap_assertion do
feed_readers ||= maker_readers
_assert_maker_itunes_summary("All About Everything is a show about " +
"everything. Each week we dive into any " +
"subject known to man and talk about it " +
"as much as we can. Look for our Podcast " +
"in the iTunes Music Store",
maker_readers, feed_readers)
_assert_maker_itunes_summary("This week we talk about salt and pepper " +
"shakers, comparing and contrasting pour " +
"rates, construction materials, and " +
"overall aesthetics. Come and join the " +
"party!",
maker_readers, feed_readers)
_assert_maker_itunes_summary("This week we talk about metric vs. old " +
"english socket wrenches. Which one is " +
"better? Do you really need both? Get " +
"all of your answers here.",
maker_readers, feed_readers)
_assert_maker_itunes_summary("This week we talk about surviving in a " +
"Red state if you're a Blue person. Or " +
"vice versa.",
maker_readers, feed_readers)
end
end
end
end

38
test/rss/test_maker_slash.rb
Просмотреть файл

@ -1,38 +0,0 @@
# frozen_string_literal: false
require_relative "rss-testcase"
require "rss/maker"
module RSS
class TestMakerSlash < TestCase
def setup
@elements = {
"section" => "articles",
"department" => "not-an-ocean-unless-there-are-lobsters",
"comments" => 177,
"hit_parades" => [177, 155, 105, 33, 6, 3, 0],
}
end
def test_rss10
rss = RSS::Maker.make("1.0") do |maker|
setup_dummy_channel(maker)
setup_dummy_item(maker)
item = maker.items.last
@elements.each do |name, value|
item.send("slash_#{name}=", value)
end
end
item = rss.items.last
assert_not_nil(item)
assert_slash_elements(item)
end
private
def assert_slash_elements(target)
super(@elements, target)
end
end
end

45
test/rss/test_maker_sy.rb
Просмотреть файл

@ -1,45 +0,0 @@
# frozen_string_literal: false
require_relative "rss-testcase"
require "rss/maker"
module RSS
class TestMakerSyndication < TestCase
def setup
@uri = "http://purl.org/rss/1.0/modules/syndication/"
t = Time.iso8601("2000-01-01T12:00:05+00:00")
class << t
alias_method(:to_s, :iso8601)
end
@elements = {
:updatePeriod => "hourly",
:updateFrequency => "2",
:updateBase => t,
}
end
def test_rss10
rss = RSS::Maker.make("1.0") do |maker|
setup_dummy_channel(maker)
set_elements(maker.channel)
setup_dummy_item(maker)
end
assert_syndication(@elements, rss.channel)
end
private
def accessor_name(name)
"sy_#{name}"
end
def set_elements(target)
@elements.each do |name, value|
target.__send__("#{accessor_name(name)}=", value)
end
end
end
end

82
test/rss/test_maker_taxo.rb
Просмотреть файл

@ -1,82 +0,0 @@
# frozen_string_literal: false
require_relative "rss-testcase"
require "rss/maker"
module RSS
class TestMakerTaxonomy < TestCase
def setup
@uri = "http://purl.org/rss/1.0/modules/taxonomy/"
@resources = [
"http://meerkat.oreillynet.com/?c=cat23",
"http://meerkat.oreillynet.com/?c=47",
"http://dmoz.org/Computers/Data_Formats/Markup_Languages/XML/",
]
@topics = [
{
:link => "http://meerkat.oreillynet.com/?c=cat23",
:title => "Data: XML",
:description => "A Meerkat channel",
},
{
:link => "http://dmoz.org/Computers/Data_Formats/Markup_Languages/XML/",
:title => "XML",
:subject => "XML",
:description => "DMOZ category",
:topics => [
"http://meerkat.oreillynet.com/?c=cat23",
"http://dmoz.org/Computers/Data_Formats/Markup_Languages/SGML/",
"http://dmoz.org/Computers/Programming/Internet/",
]
},
]
end
def test_rss10
rss = RSS::Maker.make("1.0") do |maker|
setup_dummy_channel(maker)
set_topics(maker.channel)
setup_dummy_item(maker)
set_topics(maker.items.last)
setup_taxo_topic(maker, @topics)
end
assert_equal(@resources, rss.channel.taxo_topics.resources)
assert_equal(@resources, rss.items.last.taxo_topics.resources)
assert_taxo_topic(@topics, rss)
end
def _test_date
t1 = Time.iso8601("2000-01-01T12:00:05+00:00")
t2 = Time.iso8601("2005-01-01T12:00:05+00:00")
rss = RSS::Maker.make("1.0") do |maker|
setup_dummy_channel(maker)
maker.channel.date = t1
maker.channel.dc_dates.new_date do |date|
date.value = t2
end
setup_dummy_item(maker)
item = maker.items.last
item.date = t2
item.dc_dates.new_date do |date|
date.value = t1
end
end
assert_equal([t1, t2], rss.channel.dc_dates.collect{|x| x.value})
assert_equal([t2, t1], rss.items.last.dc_dates.collect{|x| x.value})
end
private
def set_topics(target, resources=@resources)
resources.each do |value|
target.taxo_topics << value
end
end
end
end

42
test/rss/test_maker_trackback.rb
Просмотреть файл

@ -1,42 +0,0 @@
# frozen_string_literal: false
require_relative "rss-testcase"
require "rss/maker"
module RSS
class TestMakerTrackBack < TestCase
def setup
@uri = "http://madskills.com/public/xml/rss/module/trackback/"
@elements = {
:ping => "http://bar.com/tb.cgi?tb_id=rssplustrackback",
:abouts => [
"http://foo.com/trackback/tb.cgi?tb_id=20020923",
"http://bar.com/trackback/tb.cgi?tb_id=20041114",
],
}
end
def test_rss10
rss = RSS::Maker.make("1.0") do |maker|
setup_dummy_channel(maker)
setup_dummy_item(maker)
item = maker.items.last
item.trackback_ping = @elements[:ping]
@elements[:abouts].each do |about|
item.trackback_abouts.new_about do |new_about|
new_about.value = about
end
end
end
assert_trackback(@elements, rss.items.last)
end
private
def accessor_name(name)
"trackback_#{name}"
end
end
end

84
test/rss/test_maker_xml-stylesheet.rb
Просмотреть файл

@ -1,84 +0,0 @@
# frozen_string_literal: false
require_relative "rss-testcase"
require "rss/maker"
module RSS
class TestMakerXMLStyleSheet < TestCase
def test_xml_stylesheet
href = 'a.xsl'
type = 'text/xsl'
title = 'sample'
media = 'printer'
charset = 'UTF-8'
alternate = 'yes'
rss = RSS::Maker.make("1.0") do |maker|
maker.xml_stylesheets.new_xml_stylesheet do |xss|
xss.href = href
xss.type = type
xss.title = title
xss.media = media
xss.charset = charset
xss.alternate = alternate
end
setup_dummy_channel(maker)
setup_dummy_item(maker)
end
xss = rss.xml_stylesheets.first
assert_equal(href, xss.href)
assert_equal(type, xss.type)
assert_equal(title, xss.title)
assert_equal(media, xss.media)
assert_equal(charset, xss.charset)
assert_equal(alternate, xss.alternate)
href = 'http://example.com/index.xsl'
type = 'text/xsl'
rss = RSS::Maker.make("1.0") do |maker|
maker.xml_stylesheets.new_xml_stylesheet do |_xss|
_xss.href = href
end
setup_dummy_channel(maker)
setup_dummy_item(maker)
end
xss = rss.xml_stylesheets.first
assert_equal(href, xss.href)
assert_equal(type, xss.type)
end
def test_not_valid_xml_stylesheet
href = 'xss.XXX'
type = "text/xsl"
rss = RSS::Maker.make("1.0") do |maker|
maker.xml_stylesheets.new_xml_stylesheet do |xss|
# xss.href = href
xss.type = type
end
setup_dummy_channel(maker)
setup_dummy_item(maker)
end
assert(rss.xml_stylesheets.empty?)
rss = RSS::Maker.make("1.0") do |maker|
maker.xml_stylesheets.new_xml_stylesheet do |xss|
xss.href = href
# xss.type = type
end
setup_dummy_channel(maker)
setup_dummy_item(maker)
end
assert(rss.xml_stylesheets.empty?)
end
end
end

121
test/rss/test_parser.rb
Просмотреть файл

@ -1,121 +0,0 @@
# frozen_string_literal: false
require "tempfile"
require_relative "rss-testcase"
require "rss/1.0"
require "rss/dublincore"
module RSS
class TestParser < TestCase
def setup
@_default_parser = Parser.default_parser
@rss10 = make_RDF(<<-EOR)
#{make_channel}
#{make_item}
#{make_textinput}
#{make_image}
EOR
@rss_tmp = Tempfile.new(%w"rss10- .rdf")
@rss_tmp.print(@rss10)
@rss_tmp.close
@rss_file = @rss_tmp.path
end
def teardown
Parser.default_parser = @_default_parser
@rss_tmp.close(true)
end
def test_default_parser
assert_nothing_raised do
Parser.default_parser = RSS::AVAILABLE_PARSERS.first
end
assert_raise(RSS::NotValidXMLParser) do
Parser.default_parser = RSS::Parser
end
end
def test_parse
assert_not_nil(RSS::Parser.parse(@rss_file))
garbage_rss_file = @rss_file + "-garbage"
if RSS::Parser.default_parser.name == "RSS::XMLParserParser"
assert_raise(RSS::NotWellFormedError) do
RSS::Parser.parse(garbage_rss_file)
end
else
assert_nil(RSS::Parser.parse(garbage_rss_file))
end
end
def test_parse_tag_includes_hyphen
assert_nothing_raised do
RSS::Parser.parse(make_RDF(<<-EOR))
<xCal:x-calconnect-venue xmlns:xCal="urn:ietf:params:xml:ns:xcal" />
#{make_channel}
#{make_item}
#{make_textinput}
#{make_image}
EOR
end
end
def test_parse_option_validate_nil
assert_raise(RSS::MissingTagError) do
RSS::Parser.parse(make_RDF(<<-RDF), :validate => nil)
RDF
end
end
def test_parse_option_validate_true
assert_raise(RSS::MissingTagError) do
RSS::Parser.parse(make_RDF(<<-RDF), :validate => true)
RDF
end
end
def test_parse_option_validate_false
rdf = RSS::Parser.parse(make_RDF(<<-RDF), :validate => false)
RDF
assert_nil(rdf.channel)
end
def test_parse_option_ignore_unknown_element_nil
assert_nothing_raised do
RSS::Parser.parse(make_RDF(<<-RDF), :ignore_unknown_element => nil)
<unknown/>
#{make_channel}
#{make_item}
#{make_textinput}
#{make_image}
RDF
end
end
def test_parse_option_ignore_unknown_element_true
assert_nothing_raised do
RSS::Parser.parse(make_RDF(<<-RDF), :ignore_unknown_element => true)
<unknown/>
#{make_channel}
#{make_item}
#{make_textinput}
#{make_image}
RDF
end
end
def test_parse_option_ignore_unknown_element_false
assert_raise(RSS::NotExpectedTagError) do
RSS::Parser.parse(make_RDF(<<-RDF), :ignore_unknown_element => false)
<unknown/>
#{make_channel}
#{make_item}
#{make_textinput}
#{make_image}
RDF
end
end
end
end

529
test/rss/test_parser_1.0.rb
Просмотреть файл

@ -1,529 +0,0 @@
# frozen_string_literal: false
require_relative "rss-testcase"
require "rss/1.0"
require "rss/dublincore"
module RSS
class TestParser10 < TestCase
def test_RDF
assert_ns("", RDF::URI) do
Parser.parse(<<-EOR)
#{make_xmldecl}
<RDF/>
EOR
end
assert_ns("", RDF::URI) do
Parser.parse(<<-EOR)
#{make_xmldecl}
<RDF xmlns="hoge"/>
EOR
end
assert_ns("rdf", RDF::URI) do
Parser.parse(<<-EOR)
#{make_xmldecl}
<rdf:RDF xmlns:rdf="hoge"/>
EOR
end
assert_parse(<<-EOR, :missing_tag, "channel", "RDF")
#{make_xmldecl}
<rdf:RDF xmlns:rdf="#{RSS::RDF::URI}"/>
EOR
assert_parse(<<-EOR, :missing_tag, "channel", "RDF")
#{make_xmldecl}
<RDF xmlns="#{RSS::RDF::URI}"/>
EOR
assert_parse(<<-EOR, :missing_tag, "channel", "RDF")
#{make_xmldecl}
<RDF xmlns="#{RSS::RDF::URI}"/>
EOR
assert_parse(make_RDF(<<-EOR), :missing_tag, "item", "RDF")
#{make_channel}
EOR
assert_parse(make_RDF(<<-EOR), :missing_tag, "item", "RDF")
#{make_channel}
#{make_image}
EOR
assert_parse(make_RDF(<<-EOR), :missing_tag, "item", "RDF")
#{make_channel}
#{make_textinput}
EOR
assert_too_much_tag("image", "RDF") do
Parser.parse(make_RDF(<<-EOR))
#{make_channel}
#{make_image}
#{make_image}
#{make_item}
#{make_textinput}
EOR
end
assert_parse(make_RDF(<<-EOR), :nothing_raised)
#{make_channel}
#{make_item}
#{make_image}
#{make_textinput}
EOR
assert_parse(make_RDF(<<-EOR), :nothing_raised)
#{make_channel}
#{make_item}
#{make_textinput}
#{make_image}
EOR
assert_parse(make_RDF(<<-EOR), :nothing_raised)
#{make_channel}
#{make_image}
#{make_item}
EOR
assert_parse(make_RDF(<<-EOR), :nothing_raised)
#{make_channel}
#{make_image}
#{make_item}
#{make_textinput}
EOR
1.step(15, 3) do |i|
rss = make_RDF() do
res = make_channel
i.times { res << make_item }
res
end
assert_parse(rss, :nothing_raised)
end
end
def test_undefined_entity
return unless RSS::Parser.default_parser.raise_for_undefined_entity?
assert_parse(make_RDF(<<-EOR), :raises, RSS::NotWellFormedError)
#{make_channel}
#{make_image}
<item rdf:about="#{RDF_ABOUT}">
<title>#{TITLE_VALUE} &UNKNOWN_ENTITY;</title>
<link>#{LINK_VALUE}</link>
<description>#{DESCRIPTION_VALUE}</description>
</item>
#{make_textinput}
EOR
end
def test_channel
assert_parse(make_RDF(<<-EOR), :missing_attribute, "channel", "rdf:about")
<channel />
EOR
assert_parse(make_RDF(<<-EOR), :missing_tag, "title", "channel")
<channel rdf:about="http://example.com/"/>
EOR
assert_parse(make_RDF(<<-EOR), :missing_tag, "link", "channel")
<channel rdf:about="http://example.com/">
<title>hoge</title>
</channel>
EOR
assert_parse(make_RDF(<<EOR), :missing_tag, "description", "channel")
<channel rdf:about="http://example.com/">
<title>hoge</title>
<link>http://example.com/</link>
</channel>
EOR
assert_parse(make_RDF(<<-EOR), :missing_tag, "items", "channel")
<channel rdf:about="http://example.com/">
<title>hoge</title>
<link>http://example.com/</link>
<description>hogehoge</description>
</channel>
EOR
assert_parse(make_RDF(<<-EOR), :missing_attribute, "image", "rdf:resource")
<channel rdf:about="http://example.com/">
<title>hoge</title>
<link>http://example.com/</link>
<description>hogehoge</description>
<image/>
</channel>
EOR
assert_parse(make_RDF(<<-EOR), :missing_tag, "items", "channel")
<channel rdf:about="http://example.com/">
<title>hoge</title>
<link>http://example.com/</link>
<description>hogehoge</description>
<image rdf:resource="http://example.com/hoge.png" />
</channel>
EOR
rss = make_RDF(<<-EOR)
<channel rdf:about="http://example.com/">
<title>hoge</title>
<link>http://example.com/</link>
<description>hogehoge</description>
<image rdf:resource="http://example.com/hoge.png" />
<items/>
</channel>
EOR
assert_missing_tag("Seq", "items") do
Parser.parse(rss)
end
assert_missing_tag("item", "RDF") do
Parser.parse(rss, false).validate
end
assert_parse(make_RDF(<<-EOR), :missing_tag, "item", "RDF")
<channel rdf:about="http://example.com/">
<title>hoge</title>
<link>http://example.com/</link>
<description>hogehoge</description>
<image rdf:resource="http://example.com/hoge.png" />
<items>
<rdf:Seq>
</rdf:Seq>
</items>
</channel>
EOR
assert_parse(make_RDF(<<-EOR), :missing_attribute, "textinput", "rdf:resource")
<channel rdf:about="http://example.com/">
<title>hoge</title>
<link>http://example.com/</link>
<description>hogehoge</description>
<image rdf:resource="http://example.com/hoge.png" />
<items>
<rdf:Seq>
</rdf:Seq>
</items>
<textinput/>
</channel>
EOR
assert_parse(make_RDF(<<-EOR), :missing_tag, "item", "RDF")
<channel rdf:about="http://example.com/">
<title>hoge</title>
<link>http://example.com/</link>
<description>hogehoge</description>
<image rdf:resource="http://example.com/hoge.png" />
<items>
<rdf:Seq>
</rdf:Seq>
</items>
<textinput rdf:resource="http://example.com/search" />
</channel>
EOR
end
def test_rdf_li
rss = make_RDF(<<-EOR)
<channel rdf:about="http://example.com/">
<title>hoge</title>
<link>http://example.com/</link>
<description>hogehoge</description>
<image rdf:resource="http://example.com/hoge.png" />
<items>
<rdf:Seq>
<rdf:li \#{rdf_li_attr}/>
</rdf:Seq>
</items>
<textinput rdf:resource="http://example.com/search" />
</channel>
#{make_item}
EOR
source = Proc.new do |rdf_li_attr|
eval(%Q[%Q[#{rss}]], binding)
end
attr = %q[resource="http://example.com/hoge"]
assert_parse(source.call(attr), :nothing_raised)
attr = %q[rdf:resource="http://example.com/hoge"]
assert_parse(source.call(attr), :nothing_raised)
assert_parse(source.call(""), :missing_attribute, "li", "resource")
end
def test_image
assert_parse(make_RDF(<<-EOR), :missing_attribute, "image", "rdf:about")
#{make_channel}
<image>
</image>
EOR
assert_parse(make_RDF(<<-EOR), :missing_tag, "title", "image")
#{make_channel}
<image rdf:about="http://example.com/hoge.png">
</image>
EOR
assert_parse(make_RDF(<<-EOR), :missing_tag, "url", "image")
#{make_channel}
<image rdf:about="http://example.com/hoge.png">
<title>hoge</title>
</image>
EOR
assert_parse(make_RDF(<<-EOR), :missing_tag, "link", "image")
#{make_channel}
<image rdf:about="http://example.com/hoge.png">
<title>hoge</title>
<url>http://example.com/hoge.png</url>
</image>
EOR
assert_parse(make_RDF(<<-EOR), :missing_tag, "item", "RDF")
#{make_channel}
<image rdf:about="http://example.com/hoge.png">
<title>hoge</title>
<url>http://example.com/hoge.png</url>
<link>http://example.com/</link>
</image>
EOR
rss = make_RDF(<<-EOR)
#{make_channel}
<image rdf:about="http://example.com/hoge.png">
<link>http://example.com/</link>
<url>http://example.com/hoge.png</url>
<title>hoge</title>
</image>
EOR
assert_missing_tag("item", "RDF") do
Parser.parse(rss)
end
assert_missing_tag("item", "RDF") do
Parser.parse(rss, false).validate
end
end
def test_item
assert_parse(make_RDF(<<-EOR), :missing_attribute, "item", "rdf:about")
#{make_channel}
#{make_image}
<item>
</item>
EOR
assert_parse(make_RDF(<<-EOR), :missing_tag, "title", "item")
#{make_channel}
#{make_image}
<item rdf:about="http://example.com/hoge.html">
</item>
EOR
assert_parse(make_RDF(<<-EOR), :missing_tag, "link", "item")
#{make_channel}
#{make_image}
<item rdf:about="http://example.com/hoge.html">
<title>hoge</title>
</item>
EOR
assert_too_much_tag("title", "item") do
Parser.parse(make_RDF(<<-EOR))
#{make_channel}
#{make_image}
<item rdf:about="http://example.com/hoge.html">
<title>hoge</title>
<title>hoge</title>
<link>http://example.com/hoge.html</link>
</item>
EOR
end
assert_parse(make_RDF(<<-EOR), :nothing_raised)
#{make_channel}
#{make_image}
<item rdf:about="http://example.com/hoge.html">
<title>hoge</title>
<link>http://example.com/hoge.html</link>
</item>
EOR
assert_parse(make_RDF(<<-EOR), :nothing_raised)
#{make_channel}
#{make_image}
<item rdf:about="http://example.com/hoge.html">
<title>hoge</title>
<link>http://example.com/hoge.html</link>
<description>hogehoge</description>
</item>
EOR
end
def test_textinput
assert_parse(make_RDF(<<-EOR), :missing_attribute, "textinput", "rdf:about")
#{make_channel}
#{make_image}
#{make_item}
<textinput>
</textinput>
EOR
assert_parse(make_RDF(<<-EOR), :missing_tag, "title", "textinput")
#{make_channel}
#{make_image}
#{make_item}
<textinput rdf:about="http://example.com/search.html">
</textinput>
EOR
assert_parse(make_RDF(<<-EOR), :missing_tag, "description", "textinput")
#{make_channel}
#{make_image}
#{make_item}
<textinput rdf:about="http://example.com/search.html">
<title>hoge</title>
</textinput>
EOR
assert_too_much_tag("title", "textinput") do
Parser.parse(make_RDF(<<-EOR))
#{make_channel}
#{make_image}
#{make_item}
<textinput rdf:about="http://example.com/search.html">
<title>hoge</title>
<title>hoge</title>
<description>hogehoge</description>
</textinput>
EOR
end
assert_parse(make_RDF(<<-EOR), :missing_tag, "name", "textinput")
#{make_channel}
#{make_image}
#{make_item}
<textinput rdf:about="http://example.com/search.html">
<title>hoge</title>
<description>hogehoge</description>
</textinput>
EOR
assert_parse(make_RDF(<<-EOR), :missing_tag, "link", "textinput")
#{make_channel}
#{make_image}
#{make_item}
<textinput rdf:about="http://example.com/search.html">
<title>hoge</title>
<description>hogehoge</description>
<name>key</name>
</textinput>
EOR
assert_parse(make_RDF(<<-EOR), :nothing_raised)
#{make_channel}
#{make_image}
#{make_item}
<textinput rdf:about="http://example.com/search.html">
<title>hoge</title>
<description>hogehoge</description>
<name>key</name>
<link>http://example.com/search.html</link>
</textinput>
EOR
end
def test_ignore
name = "a"
rss = make_RDF(<<-EOR)
#{make_channel}
#{make_item}
<#{name}/>
EOR
assert_not_expected_tag(name, ::RSS::URI, "RDF") do
Parser.parse(rss, true, false)
end
uri = ""
name = "a"
rss = make_RDF(<<-EOR)
#{make_channel}
#{make_item}
<#{name} xmlns=""/>
EOR
assert_parse(rss, :nothing_raised)
assert_not_expected_tag(name, uri, "RDF") do
Parser.parse(rss, true, false)
end
uri = "http://example.com/"
name = "a"
rss = make_RDF(<<-EOR)
#{make_channel}
#{make_item}
<x:#{name} xmlns:x="#{uri}"/>
EOR
assert_parse(rss, :nothing_raised)
assert_not_expected_tag(name, uri, "RDF") do
Parser.parse(rss, true, false)
end
uri = ::RSS::URI
name = "a"
rss = make_RDF(<<-EOR)
#{make_channel}
#{make_item}
#{make_image("<#{name}/>")}
EOR
assert_parse(rss, :nothing_raised)
assert_not_expected_tag(name, uri, "image") do
Parser.parse(rss, true, false)
end
uri = CONTENT_URI
name = "encoded"
elem = "<#{name} xmlns='#{uri}'/>"
rss = make_RDF(<<-EOR)
#{make_channel}
#{make_item}
#{make_image(elem)}
EOR
assert_parse(rss, :nothing_raised)
assert_not_expected_tag(name, uri, "image") do
Parser.parse(rss, true, false)
end
end
def test_unknown_duplicated_element
xmlns = {"test" => "http://localhost/test"}
assert_parse(make_RDF(<<-EOR, xmlns), :nothing_raised)
#{make_channel("<test:string/>")}
#{make_item}
#{make_image}
EOR
end
def test_unknown_case_insensitive_duplicated_element
xmlns = {
"foaf" => "http://xmlns.com/foaf/0.1/",
"dc" => "http://purl.org/dc/elements/1.1/",
}
assert_parse(make_RDF(<<-EOR, xmlns), :nothing_raised)
#{make_channel}
#{make_item}
#{make_image}
<foaf:Image rdf:about="http://example.com/myself.png">
<dc:title>Myself</dc:title>
<dc:link>http://example.com/</dc:link>
</foaf:Image>
EOR
end
end
end

123
test/rss/test_parser_2.0.rb
Просмотреть файл

@ -1,123 +0,0 @@
# frozen_string_literal: false
require_relative "rss-testcase"
require "rss/2.0"
module RSS
class TestParser20 < TestCase
def test_rss20
assert_parse(make_rss20(<<-EOR), :missing_tag, "channel", "rss")
EOR
assert_parse(make_rss20(<<-EOR), :nothing_raised)
#{make_channel20("")}
EOR
end
def test_cloud20
attrs = [
["domain", CLOUD_DOMAIN],
["port", CLOUD_PORT],
["path", CLOUD_PATH],
["registerProcedure", CLOUD_REGISTER_PROCEDURE],
["protocol", CLOUD_PROTOCOL],
]
(attrs.size + 1).times do |i|
missing_attr = attrs[i]
if missing_attr
meth = :missing_attribute
args = ["cloud", missing_attr[0]]
else
meth = :nothing_raised
args = []
end
cloud_attrs = []
attrs.each_with_index do |attr, j|
unless i == j
cloud_attrs << %Q[#{attr[0]}="#{attr[1]}"]
end
end
assert_parse(make_rss20(<<-EOR), meth, *args)
#{make_channel20(%Q[<cloud #{cloud_attrs.join("\n")}/>])}
EOR
end
end
def test_source20
assert_parse(make_rss20(<<-EOR), :missing_attribute, "source", "url")
#{make_channel20(make_item20(%Q[<source>Example</source>]))}
EOR
assert_parse(make_rss20(<<-EOR), :nothing_raised)
#{make_channel20(make_item20(%Q[<source url="http://example.com/" />]))}
EOR
assert_parse(make_rss20(<<-EOR), :nothing_raised)
#{make_channel20(make_item20(%Q[<source url="http://example.com/">Example</source>]))}
EOR
end
def test_enclosure20
attrs = [
["url", ENCLOSURE_URL],
["length", ENCLOSURE_LENGTH],
["type", ENCLOSURE_TYPE],
]
(attrs.size + 1).times do |i|
missing_attr = attrs[i]
if missing_attr
meth = :missing_attribute
args = ["enclosure", missing_attr[0]]
else
meth = :nothing_raised
args = []
end
enclosure_attrs = []
attrs.each_with_index do |attr, j|
unless i == j
enclosure_attrs << %Q[#{attr[0]}="#{attr[1]}"]
end
end
assert_parse(make_rss20(<<-EOR), meth, *args)
#{make_channel20(%Q[
#{make_item20(%Q[
<enclosure
#{enclosure_attrs.join("\n")} />
])}
])}
EOR
end
end
def test_category20
values = [nil, CATEGORY_DOMAIN]
values.each do |value|
domain = ""
domain << %Q[domain="#{value}"] if value
["", "Example Text"].each do |text|
rss_src = make_rss20(<<-EOR)
#{make_channel20(%Q[
#{make_item20(%Q[
<category #{domain}>#{text}</category>
])}
])}
EOR
assert_parse(rss_src, :nothing_raised)
rss = RSS::Parser.parse(rss_src)
category = rss.items.last.categories.first
assert_equal(value, category.domain)
assert_equal(text, category.content)
end
end
end
end
end

164
test/rss/test_parser_atom_entry.rb
Просмотреть файл

@ -1,164 +0,0 @@
# frozen_string_literal: false
require_relative "rss-testcase"
require "rss/atom"
module RSS
class TestParserAtom < TestCase
def test_entry_validation
assert_ns("", Atom::URI) do
Parser.parse(<<-EOA)
<entry/>
EOA
end
assert_ns("", Atom::URI) do
Parser.parse(<<-EOA)
<entry xmlns="hoge"/>
EOA
end
assert_parse(<<-EOA, :missing_tag, "id", "entry") do
<entry xmlns="#{Atom::URI}"/>
EOA
end
assert_parse(<<-EOA, :missing_tag, "title", "entry") do
<entry xmlns="#{Atom::URI}">
<id>urn:uuid:506e336c-a26e-4457-917b-b89dca7ae746</id>
</entry>
EOA
end
assert_parse(<<-EOA, :missing_tag, "updated", "entry") do
<entry xmlns="#{Atom::URI}">
<id>urn:uuid:506e336c-a26e-4457-917b-b89dca7ae746</id>
<title>Example Entry</title>
</entry>
EOA
end
assert_parse(<<-EOA, :missing_tag, "author", "entry") do
<entry xmlns="#{Atom::URI}">
<id>urn:uuid:506e336c-a26e-4457-917b-b89dca7ae746</id>
<title>Example Entry</title>
<updated>2003-10-10T18:30:02Z</updated>
</entry>
EOA
end
assert_parse(<<-EOA, :nothing_raised) do
<entry xmlns="#{Atom::URI}">
<id>urn:uuid:506e336c-a26e-4457-917b-b89dca7ae746</id>
<title>Example Entry</title>
<updated>2003-10-10T18:30:02Z</updated>
<author>
<name>A person</name>
</author>
</entry>
EOA
end
end
def test_entry
entry = RSS::Parser.parse(<<-EOA)
<?xml version="1.0" encoding="utf-8"?>
<entry xmlns="http://www.w3.org/2005/Atom">
<author>
<name>A person</name>
</author>
<title>Atom-Powered Robots Run Amok</title>
<link href="http://example.org/2003/12/13/atom03"/>
<id>urn:uuid:1225c695-cfb8-4ebb-aaaa-80da344efa6a</id>
<updated>2003-12-13T18:30:02Z</updated>
<summary>Some text.</summary>
</entry>
EOA
assert_not_nil(entry)
assert_equal("Atom-Powered Robots Run Amok", entry.title.content)
assert_equal("http://example.org/2003/12/13/atom03", entry.link.href)
assert_equal("urn:uuid:1225c695-cfb8-4ebb-aaaa-80da344efa6a",
entry.id.content)
assert_equal(Time.parse("2003-12-13T18:30:02Z"), entry.updated.content)
assert_equal("Some text.", entry.summary.content)
end
def test_entry_author
assert_atom_person("author", method(:make_entry_document)) do |entry|
assert_equal(2, entry.authors.size)
entry.authors.last
end
end
def test_entry_category
assert_atom_category(method(:make_entry_document)) do |entry|
assert_equal(1, entry.categories.size)
entry.category
end
end
def test_entry_content_text
assert_atom_content(method(:make_entry_document)) do |entry|
entry.content
end
end
def test_entry_contributor
assert_atom_person("contributor", method(:make_entry_document)) do |entry|
assert_equal(1, entry.contributors.size)
entry.contributor
end
end
def test_entry_id
entry = RSS::Parser.parse(make_entry_document)
assert_equal(ENTRY_ID, entry.id.content)
end
def test_entry_link
assert_atom_link(method(:make_entry_document)) do |entry|
assert_equal(1, entry.links.size)
entry.link
end
end
def test_published
generator = method(:make_entry_document)
assert_atom_date_construct("published", generator) do |entry|
entry.published
end
end
def test_entry_rights
generator = method(:make_entry_document)
assert_atom_text_construct("rights", generator) do |entry|
entry.rights
end
end
def test_entry_source
generator = method(:make_entry_document_with_open_source)
assert_atom_source(generator) do |entry|
assert_not_nil(entry.source)
entry.source
end
end
def test_entry_summary
generator = method(:make_entry_document)
assert_atom_text_construct("summary", generator) do |entry|
entry.summary
end
end
def test_entry_title
entry = RSS::Parser.parse(make_entry_document)
assert_equal(ENTRY_TITLE, entry.title.content)
end
def test_entry_updated
entry = RSS::Parser.parse(make_entry_document)
assert_equal(Time.parse(ENTRY_UPDATED), entry.updated.content)
end
end
end

277
test/rss/test_parser_atom_feed.rb
Просмотреть файл

@ -1,277 +0,0 @@
# frozen_string_literal: false
require_relative "rss-testcase"
require "rss/atom"
module RSS
class TestParserAtomFeed < TestCase
def test_feed_validation
assert_ns("", Atom::URI) do
Parser.parse(<<-EOA)
<feed/>
EOA
end
assert_ns("", Atom::URI) do
Parser.parse(<<-EOA)
<feed xmlns="hoge"/>
EOA
end
assert_parse(<<-EOA, :missing_tag, "id", "feed") do
<feed xmlns="#{Atom::URI}"/>
EOA
end
assert_parse(<<-EOA, :missing_tag, "title", "feed") do
<feed xmlns="#{Atom::URI}">
<id>urn:uuid:60a76c80-d399-11d9-b93C-0003939e0af6</id>
</feed>
EOA
end
assert_parse(<<-EOA, :missing_tag, "updated", "feed") do
<feed xmlns="#{Atom::URI}">
<id>urn:uuid:60a76c80-d399-11d9-b93C-0003939e0af6</id>
<title>Example Feed</title>
</feed>
EOA
end
assert_parse(<<-EOA, :missing_tag, "author", "feed") do
<feed xmlns="#{Atom::URI}">
<id>urn:uuid:60a76c80-d399-11d9-b93C-0003939e0af6</id>
<title>Example Feed</title>
<updated>2003-12-13T18:30:02Z</updated>
</feed>
EOA
end
assert_parse(<<-EOA, :nothing_raised) do
<feed xmlns="#{Atom::URI}">
<id>urn:uuid:60a76c80-d399-11d9-b93C-0003939e0af6</id>
<title>Example Feed</title>
<updated>2003-12-13T18:30:02Z</updated>
<author>
<name>A person</name>
</author>
</feed>
EOA
end
end
def test_lang
feed = RSS::Parser.parse(<<-EOA)
<feed xmlns="#{Atom::URI}" xml:lang="ja">
<id>urn:uuid:60a76c80-d399-11d9-b93C-0003939e0af6</id>
<title xml:lang="en">Example Feed</title>
<updated>2003-12-13T18:30:02Z</updated>
<author xml:lang="en">
<name>A person</name>
</author>
</feed>
EOA
assert_equal("ja", feed.lang)
assert_equal("ja", feed.id.lang)
assert_equal("en", feed.title.lang)
assert_equal("ja", feed.updated.lang)
assert_equal("en", feed.author.lang)
assert_equal("en", feed.author.name.lang)
end
def test_base
feed = RSS::Parser.parse(<<-EOA)
<feed xmlns="#{Atom::URI}" xml:base="http://example.com/">
<id>urn:uuid:60a76c80-d399-11d9-b93C-0003939e0af6</id>
<title xml:lang="en">Example Feed</title>
<updated>2003-12-13T18:30:02Z</updated>
<generator uri="generator">Generator</generator>
<link hreflang="ja" href="http://example.org/link1"/>
<link hreflang="en" href="link2"/>
<link hreflang="fr" xml:base="http://example.net/" href="link3"/>
<author>
<name>A person</name>
<uri>person</uri>
</author>
</feed>
EOA
assert_equal("http://example.com/", feed.base)
assert_equal("http://example.com/", feed.id.base)
assert_equal("http://example.com/", feed.title.base)
assert_equal("http://example.com/", feed.updated.base)
assert_equal("http://example.com/", feed.generator.base)
assert_equal("http://example.com/generator", feed.generator.uri)
assert_equal("http://example.com/", feed.links[0].base)
assert_equal("http://example.org/link1", feed.links[0].href)
assert_equal("http://example.com/", feed.links[1].base)
assert_equal("http://example.com/link2", feed.links[1].href)
assert_equal("http://example.net/", feed.links[2].base)
assert_equal("http://example.net/link3", feed.links[2].href)
assert_equal("http://example.com/person", feed.author.uri.content)
end
def test_feed_author
assert_atom_person("author", method(:make_feed)) do |feed|
assert_equal(2, feed.authors.size)
feed.authors[1]
end
end
def test_entry_author
generator = method(:make_feed_with_open_entry)
assert_atom_person("author", generator) do |feed|
assert_equal(1, feed.entries.size)
assert_equal(1, feed.entry.authors.size)
feed.entry.author
end
end
def test_feed_category
assert_atom_category(method(:make_feed)) do |feed|
assert_equal(1, feed.categories.size)
feed.category
end
end
def test_entry_category
assert_atom_category(method(:make_feed_with_open_entry)) do |feed|
assert_equal(1, feed.entries.size)
assert_equal(1, feed.entry.categories.size)
feed.entry.category
end
end
def test_entry_content
assert_atom_content(method(:make_feed_with_open_entry)) do |feed|
assert_equal(1, feed.entries.size)
feed.entry.content
end
end
def test_feed_contributor
assert_atom_person("contributor", method(:make_feed)) do |feed|
assert_equal(1, feed.contributors.size)
feed.contributor
end
end
def test_entry_contributor
generator = method(:make_feed_with_open_entry)
assert_atom_person("contributor", generator) do |feed|
assert_equal(1, feed.entries.size)
assert_equal(1, feed.entry.contributors.size)
feed.entry.contributor
end
end
def test_feed_generator
assert_atom_generator(method(:make_feed)) do |feed|
feed.generator
end
end
def test_feed_icon
assert_atom_icon(method(:make_feed)) do |feed|
feed.icon
end
end
def test_feed_id
feed = RSS::Parser.parse(make_feed(''))
assert_equal(FEED_ID, feed.id.content)
end
def test_entry_id
feed = RSS::Parser.parse(make_feed(''))
assert_equal(ENTRY_ID, feed.entry.id.content)
end
def test_feed_link
assert_atom_link(method(:make_feed)) do |feed|
assert_equal(1, feed.links.size)
feed.link
end
end
def test_entry_link
assert_atom_link(method(:make_feed_with_open_entry)) do |feed|
assert_equal(1, feed.entries.size)
assert_equal(1, feed.entry.links.size)
feed.entry.link
end
end
def test_feed_logo
assert_atom_logo(method(:make_feed)) do |feed|
feed.logo
end
end
def test_feed_rights
assert_atom_text_construct("rights", method(:make_feed)) do |feed|
feed.rights
end
end
def test_entry_rights
generator = method(:make_feed_with_open_entry)
assert_atom_text_construct("rights", generator) do |feed|
assert_equal(1, feed.entries.size)
feed.entry.rights
end
end
def test_entry_source
assert_atom_source(method(:make_feed_with_open_entry_source)) do |feed|
assert_equal(1, feed.entries.size)
assert_not_nil(feed.entry.source)
feed.entry.source
end
end
def test_feed_subtitle
assert_atom_text_construct("subtitle", method(:make_feed)) do |feed|
feed.subtitle
end
end
def test_feed_title
feed = RSS::Parser.parse(make_feed(''))
assert_equal(FEED_TITLE, feed.title.content)
end
def test_entry_title
feed = RSS::Parser.parse(make_feed(''))
assert_equal(ENTRY_TITLE, feed.entry.title.content)
end
def test_feed_updated
feed = RSS::Parser.parse(make_feed(''))
assert_equal(Time.parse(FEED_UPDATED), feed.updated.content)
end
def test_entry_updated
feed = RSS::Parser.parse(make_feed(''))
assert_equal(Time.parse(ENTRY_UPDATED), feed.entry.updated.content)
end
def test_entry_published
generator = method(:make_feed_with_open_entry)
assert_atom_date_construct("published", generator) do |feed|
assert_equal(1, feed.entries.size)
feed.entry.published
end
end
def test_entry_summary
generator = method(:make_feed_with_open_entry)
assert_atom_text_construct("summary", generator) do |feed|
assert_equal(1, feed.entries.size)
feed.entry.summary
end
end
end
end

247
test/rss/test_setup_maker_0.9.rb
Просмотреть файл

@ -1,247 +0,0 @@
# frozen_string_literal: false
require_relative "rss-testcase"
require "rss/maker"
module RSS
class TestSetupMaker09 < TestCase
def test_setup_maker_channel
title = "fugafuga"
link = "http://hoge.com"
description = "fugafugafugafuga"
language = "ja"
copyright = "foo"
managingEditor = "bar"
webMaster = "web master"
rating = '(PICS-1.1 "http://www.rsac.org/ratingsv01.html" l gen true comment "RSACi North America Server" for "http://www.rsac.org" on "1996.04.16T08:15-0500" r (n 0 s 0 v 0 l 0))'
docs = "http://foo.com/doc"
skipDays = [
"Sunday",
"Monday",
]
skipHours = [
"0",
"13",
]
pubDate = Time.now
lastBuildDate = Time.now
rss = RSS::Maker.make("0.91") do |maker|
maker.channel.title = title
maker.channel.link = link
maker.channel.description = description
maker.channel.language = language
maker.channel.copyright = copyright
maker.channel.managingEditor = managingEditor
maker.channel.webMaster = webMaster
maker.channel.rating = rating
maker.channel.docs = docs
maker.channel.pubDate = pubDate
maker.channel.lastBuildDate = lastBuildDate
skipDays.each do |day|
maker.channel.skipDays.new_day do |new_day|
new_day.content = day
end
end
skipHours.each do |hour|
maker.channel.skipHours.new_hour do |new_hour|
new_hour.content = hour
end
end
setup_dummy_image(maker)
end
assert_not_set_error("maker.image", %w(title url)) do
RSS::Maker.make("0.91") do |maker|
rss.channel.setup_maker(maker)
end
end
new_rss = RSS::Maker.make("0.91") do |maker|
rss.channel.setup_maker(maker)
setup_dummy_image(maker)
end
channel = new_rss.channel
assert_equal(title, channel.title)
assert_equal(link, channel.link)
assert_equal(description, channel.description)
assert_equal(language, channel.language)
assert_equal(copyright, channel.copyright)
assert_equal(managingEditor, channel.managingEditor)
assert_equal(webMaster, channel.webMaster)
assert_equal(rating, channel.rating)
assert_equal(docs, channel.docs)
assert_equal(pubDate, channel.pubDate)
assert_equal(lastBuildDate, channel.lastBuildDate)
skipDays.each_with_index do |day, i|
assert_equal(day, channel.skipDays.days[i].content)
end
skipHours.each_with_index do |hour, i|
assert_equal(hour.to_i, channel.skipHours.hours[i].content)
end
assert(channel.items.empty?)
assert_nil(channel.textInput)
end
def test_setup_maker_image
title = "fugafuga"
link = "http://hoge.com"
url = "http://hoge.com/hoge.png"
width = "144"
height = "400"
description = "an image"
rss = RSS::Maker.make("0.91") do |maker|
setup_dummy_channel(maker)
maker.channel.link = link
maker.image.title = title
maker.image.url = url
maker.image.width = width
maker.image.height = height
maker.image.description = description
end
new_rss = RSS::Maker.make("0.91") do |maker|
rss.channel.setup_maker(maker)
rss.image.setup_maker(maker)
end
image = new_rss.image
assert_equal(title, image.title)
assert_equal(link, image.link)
assert_equal(url, image.url)
assert_equal(width.to_i, image.width)
assert_equal(height.to_i, image.height)
assert_equal(description, image.description)
end
def test_setup_maker_textinput
title = "fugafuga"
description = "text hoge fuga"
name = "hoge"
link = "http://hoge.com"
rss = RSS::Maker.make("0.91") do |maker|
setup_dummy_channel(maker)
setup_dummy_image(maker)
maker.textinput.title = title
maker.textinput.description = description
maker.textinput.name = name
maker.textinput.link = link
end
new_rss = RSS::Maker.make("0.91") do |maker|
rss.channel.setup_maker(maker)
rss.image.setup_maker(maker)
rss.textinput.setup_maker(maker)
end
textInput = new_rss.channel.textInput
assert_equal(title, textInput.title)
assert_equal(description, textInput.description)
assert_equal(name, textInput.name)
assert_equal(link, textInput.link)
end
def test_setup_maker_items(for_backward_compatibility=false)
title = "TITLE"
link = "http://hoge.com/"
description = "text hoge fuga"
item_size = 5
rss = RSS::Maker.make("0.91") do |maker|
setup_dummy_channel(maker)
item_size.times do |i|
maker.items.new_item do |item|
item.title = "#{title}#{i}"
item.link = "#{link}#{i}"
item.description = "#{description}#{i}"
end
end
setup_dummy_image(maker)
end
new_rss = RSS::Maker.make("0.91") do |maker|
rss.channel.setup_maker(maker)
rss.items.each do |item|
if for_backward_compatibility
item.setup_maker(maker)
else
item.setup_maker(maker.items)
end
end
rss.image.setup_maker(maker)
end
assert_equal(item_size, new_rss.items.size)
new_rss.items.each_with_index do |item, i|
assert_equal("#{title}#{i}", item.title)
assert_equal("#{link}#{i}", item.link)
assert_equal("#{description}#{i}", item.description)
end
end
def test_setup_maker_items_backward_compatibility
test_setup_maker_items(true)
end
def test_setup_maker
encoding = "EUC-JP"
standalone = true
href = 'a.xsl'
type = 'text/xsl'
title = 'sample'
media = 'printer'
charset = 'UTF-8'
alternate = 'yes'
rss = RSS::Maker.make("0.91") do |maker|
maker.encoding = encoding
maker.standalone = standalone
maker.xml_stylesheets.new_xml_stylesheet do |xss|
xss.href = href
xss.type = type
xss.title = title
xss.media = media
xss.charset = charset
xss.alternate = alternate
end
setup_dummy_channel(maker)
setup_dummy_image(maker)
end
new_rss = RSS::Maker.make("0.91") do |maker|
rss.setup_maker(maker)
end
assert_equal("0.91", new_rss.rss_version)
assert_equal(encoding, new_rss.encoding)
assert_equal(standalone, new_rss.standalone)
xss = rss.xml_stylesheets.first
assert_equal(1, rss.xml_stylesheets.size)
assert_equal(href, xss.href)
assert_equal(type, xss.type)
assert_equal(title, xss.title)
assert_equal(media, xss.media)
assert_equal(charset, xss.charset)
assert_equal(alternate, xss.alternate)
end
end
end

551
test/rss/test_setup_maker_1.0.rb
Просмотреть файл

@ -1,551 +0,0 @@
# frozen_string_literal: false
require_relative "rss-testcase"
require "rss/maker"
module RSS
class TestSetupMaker10 < TestCase
def setup
t = Time.iso8601("2000-01-01T12:00:05+00:00")
class << t
alias_method(:to_s, :iso8601)
end
@dc_elems = {
:title => "hoge",
:description =>
" XML is placing increasingly heavy loads on
the existing technical infrastructure of the Internet.",
:creator => "Rael Dornfest (mailto:rael@oreilly.com)",
:subject => "XML",
:publisher => "The O'Reilly Network",
:contributor => "hogehoge",
:type => "fugafuga",
:format => "hohoho",
:identifier => "fufufu",
:source => "barbar",
:language => "ja",
:relation => "cococo",
:rights => "Copyright (c) 2000 O'Reilly &amp; Associates, Inc.",
:date => t,
}
@sy_elems = {
:updatePeriod => "hourly",
:updateFrequency => "2",
:updateBase => t,
}
@content_elems = {
:encoded => "<em>ATTENTION</em>",
}
@trackback_elems = {
:ping => "http://bar.com/tb.cgi?tb_id=rssplustrackback",
:about => [
"http://foo.com/trackback/tb.cgi?tb_id=20020923",
"http://foo.com/trackback/tb.cgi?tb_id=20021010",
],
}
@taxo_topic_elems = [
{
:link => "http://meerkat.oreillynet.com/?c=cat23",
:title => "Data: XML",
:description => "A Meerkat channel",
},
{
:link => "http://dmoz.org/Computers/Data_Formats/Markup_Languages/XML/",
:title => "XML",
:subject => "XML",
:description => "DMOZ category",
:topics => [
"http://meerkat.oreillynet.com/?c=cat23",
"http://dmoz.org/Computers/Data_Formats/Markup_Languages/SGML/",
"http://dmoz.org/Computers/Programming/Internet/",
]
},
]
end
def test_setup_maker_channel
about = "http://hoge.com"
title = "fugafuga"
link = "http://hoge.com"
description = "fugafugafugafuga"
rss = RSS::Maker.make("1.0") do |maker|
maker.channel.about = about
maker.channel.title = title
maker.channel.link = link
maker.channel.description = description
@dc_elems.each do |var, value|
maker.channel.__send__("dc_#{var}=", value)
end
@sy_elems.each do |var, value|
maker.channel.__send__("sy_#{var}=", value)
end
setup_dummy_item(maker)
end
new_rss = RSS::Maker.make("1.0") do |maker|
rss.channel.setup_maker(maker)
rss.items.each do |item|
item.setup_maker(maker)
end
end
channel = new_rss.channel
assert_equal(about, channel.about)
assert_equal(title, channel.title)
assert_equal(link, channel.link)
assert_equal(description, channel.description)
assert_equal(1, channel.items.Seq.lis.size)
assert_nil(channel.image)
assert_nil(channel.textinput)
@dc_elems.each do |var, value|
assert_equal(value, channel.__send__("dc_#{var}"))
end
@sy_elems.each do |var, value|
value = value.to_i if var == :updateFrequency
assert_equal(value, channel.__send__("sy_#{var}"))
end
end
def test_setup_maker_image
title = "fugafuga"
link = "http://hoge.com"
url = "http://hoge.com/hoge.png"
rss = RSS::Maker.make("1.0") do |maker|
setup_dummy_channel(maker)
maker.channel.link = link
maker.image.title = title
maker.image.url = url
@dc_elems.each do |var, value|
maker.image.__send__("dc_#{var}=", value)
end
setup_dummy_item(maker)
end
new_rss = RSS::Maker.make("1.0") do |maker|
rss.channel.setup_maker(maker)
rss.image.setup_maker(maker)
rss.items.each do |item|
item.setup_maker(maker)
end
end
image = new_rss.image
assert_equal(url, image.about)
assert_equal(url, new_rss.channel.image.resource)
assert_equal(title, image.title)
assert_equal(link, image.link)
assert_equal(url, image.url)
@dc_elems.each do |var, value|
assert_equal(image.__send__("dc_#{var}"), value)
end
end
def test_setup_maker_textinput
title = "fugafuga"
description = "text hoge fuga"
name = "hoge"
link = "http://hoge.com"
rss = RSS::Maker.make("1.0") do |maker|
setup_dummy_channel(maker)
maker.textinput.link = link
maker.textinput.title = title
maker.textinput.description = description
maker.textinput.name = name
@dc_elems.each do |var, value|
maker.textinput.__send__("dc_#{var}=", value)
end
setup_dummy_item(maker)
end
new_rss = RSS::Maker.make("1.0") do |maker|
rss.channel.setup_maker(maker)
rss.textinput.setup_maker(maker)
rss.items.each do |item|
item.setup_maker(maker)
end
end
textinput = new_rss.textinput
assert_equal(link, textinput.about)
assert_equal(link, new_rss.channel.textinput.resource)
assert_equal(title, textinput.title)
assert_equal(name, textinput.name)
assert_equal(description, textinput.description)
assert_equal(link, textinput.link)
@dc_elems.each do |var, value|
assert_equal(textinput.__send__("dc_#{var}"), value)
end
end
def test_setup_maker_items(for_backward_compatibility=false)
title = "TITLE"
link = "http://hoge.com/"
description = "text hoge fuga"
item_size = 5
rss = RSS::Maker.make("1.0") do |maker|
setup_dummy_channel(maker)
item_size.times do |i|
maker.items.new_item do |item|
item.title = "#{title}#{i}"
item.link = "#{link}#{i}"
item.description = "#{description}#{i}"
@dc_elems.each do |var, value|
item.__send__("dc_#{var}=", value)
end
@content_elems.each do |var, value|
item.__send__("content_#{var}=", value)
end
item.trackback_ping = @trackback_elems[:ping]
@trackback_elems[:about].each do |value|
item.trackback_abouts.new_about do |new_about|
new_about.value = value
end
end
end
end
end
new_rss = RSS::Maker.make("1.0") do |maker|
rss.channel.setup_maker(maker)
rss.items.each do |item|
if for_backward_compatibility
item.setup_maker(maker)
else
item.setup_maker(maker.items)
end
end
end
assert_equal(item_size, new_rss.items.size)
new_rss.items.each_with_index do |item, i|
assert_equal("#{link}#{i}", item.about)
assert_equal("#{title}#{i}", item.title)
assert_equal("#{link}#{i}", item.link)
assert_equal("#{description}#{i}", item.description)
@dc_elems.each do |var, value|
assert_equal(item.__send__("dc_#{var}"), value)
end
@content_elems.each do |var, value|
assert_equal(item.__send__("content_#{var}"), value)
end
assert_equal(@trackback_elems[:ping], item.trackback_ping)
assert_equal(@trackback_elems[:about].size, item.trackback_abouts.size)
item.trackback_abouts.each_with_index do |about, j|
assert_equal(@trackback_elems[:about][j], about.value)
end
end
end
def test_setup_maker_items_sort
title = "TITLE"
link = "http://hoge.com/"
description = "text hoge fuga"
item_size = 5
rss = RSS::Maker.make("1.0") do |maker|
setup_dummy_channel(maker)
item_size.times do |i|
item = RSS::RDF::Item.new("#{link}#{i}")
item.title = "#{title}#{i}"
item.link = "#{link}#{i}"
item.description = "#{description}#{i}"
item.dc_date = Time.now + i * 60
item.setup_maker(maker.items)
end
maker.items.do_sort = false
end
assert_equal(item_size, rss.items.size)
rss.items.each_with_index do |item, i|
assert_equal("#{link}#{i}", item.about)
assert_equal("#{title}#{i}", item.title)
assert_equal("#{link}#{i}", item.link)
assert_equal("#{description}#{i}", item.description)
end
rss = RSS::Maker.make("1.0") do |maker|
setup_dummy_channel(maker)
item_size.times do |i|
item = RSS::RDF::Item.new("#{link}#{i}")
item.title = "#{title}#{i}"
item.link = "#{link}#{i}"
item.description = "#{description}#{i}"
item.dc_date = Time.now + i * 60
item.setup_maker(maker.items)
end
maker.items.do_sort = true
end
assert_equal(item_size, rss.items.size)
rss.items.reverse.each_with_index do |item, i|
assert_equal("#{link}#{i}", item.about)
assert_equal("#{title}#{i}", item.title)
assert_equal("#{link}#{i}", item.link)
assert_equal("#{description}#{i}", item.description)
end
end
def test_setup_maker_items_backward_compatibility
test_setup_maker_items(true)
end
def test_setup_maker
encoding = "EUC-JP"
standalone = true
href = 'a.xsl'
type = 'text/xsl'
title = 'sample'
media = 'printer'
charset = 'UTF-8'
alternate = 'yes'
rss = RSS::Maker.make("1.0") do |maker|
maker.encoding = encoding
maker.standalone = standalone
maker.xml_stylesheets.new_xml_stylesheet do |xss|
xss.href = href
xss.type = type
xss.title = title
xss.media = media
xss.charset = charset
xss.alternate = alternate
end
setup_dummy_channel(maker)
setup_dummy_item(maker)
end
new_rss = RSS::Maker.make("1.0") do |maker|
rss.setup_maker(maker)
end
assert_equal("1.0", new_rss.rss_version)
assert_equal(encoding, new_rss.encoding)
assert_equal(standalone, new_rss.standalone)
xss = new_rss.xml_stylesheets.first
assert_equal(1, new_rss.xml_stylesheets.size)
assert_equal(href, xss.href)
assert_equal(type, xss.type)
assert_equal(title, xss.title)
assert_equal(media, xss.media)
assert_equal(charset, xss.charset)
assert_equal(alternate, xss.alternate)
end
def test_setup_maker_full
encoding = "EUC-JP"
standalone = true
href = 'a.xsl'
type = 'text/xsl'
title = 'sample'
media = 'printer'
charset = 'UTF-8'
alternate = 'yes'
channel_about = "http://hoge.com"
channel_title = "fugafuga"
channel_link = "http://hoge.com"
channel_description = "fugafugafugafuga"
image_title = "fugafuga"
image_url = "http://hoge.com/hoge.png"
textinput_title = "fugafuga"
textinput_description = "text hoge fuga"
textinput_name = "hoge"
textinput_link = "http://hoge.com"
item_title = "TITLE"
item_link = "http://hoge.com/"
item_description = "text hoge fuga"
item_size = 5
rss = RSS::Maker.make("1.0") do |maker|
maker.encoding = encoding
maker.standalone = standalone
maker.xml_stylesheets.new_xml_stylesheet do |xss|
xss.href = href
xss.type = type
xss.title = title
xss.media = media
xss.charset = charset
xss.alternate = alternate
end
maker.channel.about = channel_about
maker.channel.title = channel_title
maker.channel.link = channel_link
maker.channel.description = channel_description
@dc_elems.each do |var, value|
maker.channel.__send__("dc_#{var}=", value)
end
@sy_elems.each do |var, value|
maker.channel.__send__("sy_#{var}=", value)
end
maker.image.title = image_title
maker.image.url = image_url
@dc_elems.each do |var, value|
maker.image.__send__("dc_#{var}=", value)
end
maker.textinput.link = textinput_link
maker.textinput.title = textinput_title
maker.textinput.description = textinput_description
maker.textinput.name = textinput_name
@dc_elems.each do |var, value|
maker.textinput.__send__("dc_#{var}=", value)
end
item_size.times do |i|
maker.items.new_item do |item|
item.title = "#{item_title}#{i}"
item.link = "#{item_link}#{i}"
item.description = "#{item_description}#{i}"
@dc_elems.each do |var, value|
item.__send__("dc_#{var}=", value)
end
@content_elems.each do |var, value|
item.__send__("content_#{var}=", value)
end
item.trackback_ping = @trackback_elems[:ping]
@trackback_elems[:about].each do |value|
item.trackback_abouts.new_about do |new_about|
new_about.value = value
end
end
end
end
setup_taxo_topic(maker, @taxo_topic_elems)
end
new_rss = RSS::Maker.make("1.0") do |maker|
rss.setup_maker(maker)
end
assert_equal("1.0", new_rss.rss_version)
assert_equal(encoding, new_rss.encoding)
assert_equal(standalone, new_rss.standalone)
xss = new_rss.xml_stylesheets.first
assert_equal(1, new_rss.xml_stylesheets.size)
assert_equal(href, xss.href)
assert_equal(type, xss.type)
assert_equal(title, xss.title)
assert_equal(media, xss.media)
assert_equal(charset, xss.charset)
assert_equal(alternate, xss.alternate)
channel = new_rss.channel
assert_equal(channel_about, channel.about)
assert_equal(channel_title, channel.title)
assert_equal(channel_link, channel.link)
assert_equal(channel_description, channel.description)
item_resources = []
item_size.times do |i|
item_resources << "#{item_link}#{i}"
end
assert_equal(item_resources, channel.items.resources)
assert_equal(image_url, channel.image.resource)
assert_equal(textinput_link, channel.textinput.resource)
@dc_elems.each do |var, value|
assert_equal(value, channel.__send__("dc_#{var}"))
end
@sy_elems.each do |var, value|
value = value.to_i if var == :updateFrequency
assert_equal(value, channel.__send__("sy_#{var}"))
end
image = new_rss.image
assert_equal(image_url, image.about)
assert_equal(image_url, new_rss.channel.image.resource)
assert_equal(image_title, image.title)
assert_equal(channel_link, image.link)
assert_equal(image_url, image.url)
@dc_elems.each do |var, value|
assert_equal(image.__send__("dc_#{var}"), value)
end
textinput = new_rss.textinput
assert_equal(textinput_link, textinput.about)
assert_equal(textinput_link, new_rss.channel.textinput.resource)
assert_equal(textinput_title, textinput.title)
assert_equal(textinput_name, textinput.name)
assert_equal(textinput_description, textinput.description)
assert_equal(textinput_link, textinput.link)
@dc_elems.each do |var, value|
assert_equal(textinput.__send__("dc_#{var}"), value)
end
assert_equal(item_size, new_rss.items.size)
new_rss.items.each_with_index do |item, i|
assert_equal("#{item_link}#{i}", item.about)
assert_equal("#{item_title}#{i}", item.title)
assert_equal("#{item_link}#{i}", item.link)
assert_equal("#{item_description}#{i}", item.description)
@dc_elems.each do |var, value|
assert_equal(item.__send__("dc_#{var}"), value)
end
@content_elems.each do |var, value|
assert_equal(item.__send__("content_#{var}"), value)
end
assert_equal(@trackback_elems[:ping], item.trackback_ping)
assert_equal(@trackback_elems[:about].size, item.trackback_abouts.size)
item.trackback_abouts.each_with_index do |about, j|
assert_equal(@trackback_elems[:about][j], about.value)
end
end
assert_taxo_topic(@taxo_topic_elems, new_rss)
end
end
end

309
test/rss/test_setup_maker_2.0.rb
Просмотреть файл

@ -1,309 +0,0 @@
# frozen_string_literal: false
require_relative "rss-testcase"
require "rss/maker"
module RSS
class TestSetupMaker20 < TestCase
def test_setup_maker_channel
title = "fugafuga"
link = "http://hoge.com"
description = "fugafugafugafuga"
language = "ja"
copyright = "foo"
managingEditor = "bar"
webMaster = "web master"
rating = '(PICS-1.1 "http://www.rsac.org/ratingsv01.html" l gen true comment "RSACi North America Server" for "http://www.rsac.org" on "1996.04.16T08:15-0500" r (n 0 s 0 v 0 l 0))'
docs = "http://foo.com/doc"
skipDays = [
"Sunday",
"Monday",
]
skipHours = [
"0",
"13",
]
pubDate = Time.now
lastBuildDate = Time.now
categories = [
"Nespapers",
"misc",
]
generator = "RSS Maker"
ttl = "60"
rss = RSS::Maker.make("2.0") do |maker|
maker.channel.title = title
maker.channel.link = link
maker.channel.description = description
maker.channel.language = language
maker.channel.copyright = copyright
maker.channel.managingEditor = managingEditor
maker.channel.webMaster = webMaster
maker.channel.rating = rating
maker.channel.docs = docs
maker.channel.pubDate = pubDate
maker.channel.lastBuildDate = lastBuildDate
skipDays.each do |day|
maker.channel.skipDays.new_day do |new_day|
new_day.content = day
end
end
skipHours.each do |hour|
maker.channel.skipHours.new_hour do |new_hour|
new_hour.content = hour
end
end
categories.each do |category|
maker.channel.categories.new_category do |new_category|
new_category.content = category
end
end
maker.channel.generator = generator
maker.channel.ttl = ttl
end
new_rss = RSS::Maker.make("2.0") do |maker|
rss.channel.setup_maker(maker)
end
channel = new_rss.channel
assert_equal(title, channel.title)
assert_equal(link, channel.link)
assert_equal(description, channel.description)
assert_equal(language, channel.language)
assert_equal(copyright, channel.copyright)
assert_equal(managingEditor, channel.managingEditor)
assert_equal(webMaster, channel.webMaster)
assert_equal(rating, channel.rating)
assert_equal(docs, channel.docs)
assert_equal(pubDate, channel.pubDate)
assert_equal(lastBuildDate, channel.lastBuildDate)
skipDays.each_with_index do |day, i|
assert_equal(day, channel.skipDays.days[i].content)
end
skipHours.each_with_index do |hour, i|
assert_equal(hour.to_i, channel.skipHours.hours[i].content)
end
channel.categories.each_with_index do |category, i|
assert_equal(categories[i], category.content)
end
assert_equal(generator, channel.generator)
assert_equal(ttl.to_i, channel.ttl)
assert(channel.items.empty?)
assert_nil(channel.image)
assert_nil(channel.textInput)
end
def test_setup_maker_image
title = "fugafuga"
link = "http://hoge.com"
url = "http://hoge.com/hoge.png"
width = "144"
height = "400"
description = "an image"
rss = RSS::Maker.make("2.0") do |maker|
setup_dummy_channel(maker)
maker.channel.link = link
maker.image.title = title
maker.image.url = url
maker.image.width = width
maker.image.height = height
maker.image.description = description
end
new_rss = RSS::Maker.make("2.0") do |maker|
rss.channel.setup_maker(maker)
rss.image.setup_maker(maker)
end
image = new_rss.image
assert_equal(title, image.title)
assert_equal(link, image.link)
assert_equal(url, image.url)
assert_equal(width.to_i, image.width)
assert_equal(height.to_i, image.height)
assert_equal(description, image.description)
end
def test_setup_maker_textinput
title = "fugafuga"
description = "text hoge fuga"
name = "hoge"
link = "http://hoge.com"
rss = RSS::Maker.make("2.0") do |maker|
setup_dummy_channel(maker)
maker.textinput.title = title
maker.textinput.description = description
maker.textinput.name = name
maker.textinput.link = link
end
new_rss = RSS::Maker.make("2.0") do |maker|
rss.channel.setup_maker(maker)
rss.textinput.setup_maker(maker)
end
textInput = new_rss.channel.textInput
assert_equal(title, textInput.title)
assert_equal(description, textInput.description)
assert_equal(name, textInput.name)
assert_equal(link, textInput.link)
end
def test_setup_maker_items(for_backward_compatibility=false)
title = "TITLE"
link = "http://hoge.com/"
description = "text hoge fuga"
author = "oprah@oxygen.net"
comments = "http://www.myblog.org/cgi-local/mt/mt-comments.cgi?entry_id=290"
pubDate = Time.now
guid_isPermaLink = "true"
guid_content = "http://inessential.com/2002/09/01.php#a2"
enclosure_url = "http://www.scripting.com/mp3s/weatherReportSuite.mp3"
enclosure_length = "12216320"
enclosure_type = "audio/mpeg"
source_url = "http://static.userland.com/tomalak/links2.xml"
source_content = "Tomalak's Realm"
category_domain = "http://www.fool.com/cusips"
category_content = "MSFT"
item_size = 5
rss = RSS::Maker.make("2.0") do |maker|
setup_dummy_channel(maker)
item_size.times do |i|
maker.items.new_item do |item|
item.title = "#{title}#{i}"
item.link = "#{link}#{i}"
item.description = "#{description}#{i}"
item.author = "#{author}#{i}"
item.comments = "#{comments}#{i}"
item.date = pubDate
item.guid.isPermaLink = guid_isPermaLink
item.guid.content = guid_content
item.enclosure.url = enclosure_url
item.enclosure.length = enclosure_length
item.enclosure.type = enclosure_type
item.source.url = source_url
item.source.content = source_content
category = item.categories.new_category
category.domain = category_domain
category.content = category_content
end
end
end
new_rss = RSS::Maker.make("2.0") do |maker|
rss.channel.setup_maker(maker)
rss.items.each do |item|
if for_backward_compatibility
item.setup_maker(maker)
else
item.setup_maker(maker.items)
end
end
end
assert_equal(item_size, new_rss.items.size)
new_rss.items.each_with_index do |item, i|
assert_equal("#{title}#{i}", item.title)
assert_equal("#{link}#{i}", item.link)
assert_equal("#{description}#{i}", item.description)
assert_equal("#{author}#{i}", item.author)
assert_equal("#{comments}#{i}", item.comments)
assert_equal(pubDate, item.pubDate)
assert_equal(guid_isPermaLink == "true", item.guid.isPermaLink)
assert_equal(guid_content, item.guid.content)
assert_equal(enclosure_url, item.enclosure.url)
assert_equal(enclosure_length.to_i, item.enclosure.length)
assert_equal(enclosure_type, item.enclosure.type)
assert_equal(source_url, item.source.url)
assert_equal(source_content, item.source.content)
assert_equal(1, item.categories.size)
assert_equal(category_domain, item.category.domain)
assert_equal(category_content, item.category.content)
end
end
def test_setup_maker_items_backward_compatibility
test_setup_maker_items(true)
end
def test_setup_maker
encoding = "EUC-JP"
standalone = true
href = 'a.xsl'
type = 'text/xsl'
title = 'sample'
media = 'printer'
charset = 'UTF-8'
alternate = 'yes'
rss = RSS::Maker.make("2.0") do |maker|
maker.encoding = encoding
maker.standalone = standalone
maker.xml_stylesheets.new_xml_stylesheet do |xss|
xss.href = href
xss.type = type
xss.title = title
xss.media = media
xss.charset = charset
xss.alternate = alternate
end
setup_dummy_channel(maker)
end
new_rss = RSS::Maker.make("2.0") do |maker|
rss.setup_maker(maker)
end
assert_equal("2.0", new_rss.rss_version)
assert_equal(encoding, new_rss.encoding)
assert_equal(standalone, new_rss.standalone)
xss = rss.xml_stylesheets.first
assert_equal(1, rss.xml_stylesheets.size)
assert_equal(href, xss.href)
assert_equal(type, xss.type)
assert_equal(title, xss.title)
assert_equal(media, xss.media)
assert_equal(charset, xss.charset)
assert_equal(alternate, xss.alternate)
end
end
end

410
test/rss/test_setup_maker_atom_entry.rb
Просмотреть файл

@ -1,410 +0,0 @@
# frozen_string_literal: false
require_relative "rss-testcase"
require "rss/maker"
module RSS
class TestSetupMakerAtomEntry < TestCase
def setup
t = Time.iso8601("2000-01-01T12:00:05+00:00")
class << t
alias_method(:to_s, :iso8601)
end
@dc_elems = {
:title => "hoge",
:description =>
" XML is placing increasingly heavy loads on
the existing technical infrastructure of the Internet.",
:creator => "Rael Dornfest (mailto:rael@oreilly.com)",
:subject => "XML",
:publisher => "The O'Reilly Network",
:contributor => "hogehoge",
:type => "fugafuga",
:format => "hohoho",
:identifier => "fufufu",
:source => "barbar",
:language => "ja",
:relation => "cococo",
:rights => "Copyright (c) 2000 O'Reilly &amp; Associates, Inc.",
:date => t,
}
end
def test_setup_maker_entry(with_dc=true)
authors = [
{
:name => "Bob",
:uri => "http://example.com/~bob/",
:email => "bob@example.com",
},
{
:name => "Alice",
:uri => "http://example.com/~alice/",
:email => "alice@example.com",
},
]
categories = [
{
:term => "music",
:label => "Music",
},
{
:term => "book",
:scheme => "http://example.com/category/book/",
:label => "Book",
},
]
contributors = [
{
:name => "Chris",
:email => "chris@example.com",
},
{
:name => "Eva",
:uri => "http://example.com/~eva/",
},
]
id = "urn:uuid:8b105336-7e20-45fc-bb78-37fb3e1db25a"
link = "http://hoge.com"
published = Time.now - 60 * 3600
rights = "Copyrights (c) 2007 Alice and Bob"
description = "fugafugafugafuga"
title = "fugafuga"
updated = Time.now
feed = RSS::Maker.make("atom:entry") do |maker|
maker.items.new_item do |item|
authors.each do |author_info|
item.authors.new_author do |author|
author_info.each do |key, value|
author.__send__("#{key}=", value)
end
end
end
categories.each do |category_info|
item.categories.new_category do |category|
category_info.each do |key, value|
category.__send__("#{key}=", value)
end
end
end
contributors.each do |contributor_info|
item.contributors.new_contributor do |contributor|
contributor_info.each do |key, value|
contributor.__send__("#{key}=", value)
end
end
end
item.id = id
item.link = link
item.published = published
item.rights = rights
item.description = description
item.title = title
item.updated = updated
if with_dc
@dc_elems.each do |var, value|
if var == :date
item.new_dc_date(value)
else
item.__send__("dc_#{var}=", value)
end
end
end
end
end
assert_not_nil(feed)
new_feed = RSS::Maker.make("atom:entry") do |maker|
feed.setup_maker(maker)
end
assert_not_nil(new_feed)
new_authors = new_feed.authors.collect do |author|
{
:name => author.name.content,
:uri => author.uri.content,
:email => author.email.content,
}
end
assert_equal(authors, new_authors)
new_categories = new_feed.categories.collect do |category|
{
:term => category.term,
:scheme => category.scheme,
:label => category.label,
}.reject {|key, value| value.nil?}
end
assert_equal(categories, new_categories)
new_contributors = new_feed.contributors.collect do |contributor|
info = {}
info[:name] = contributor.name.content
info[:uri] = contributor.uri.content if contributor.uri
info[:email] = contributor.email.content if contributor.email
info
end
assert_equal(contributors, new_contributors)
assert_equal(id, new_feed.id.content)
assert_equal(link, new_feed.link.href)
assert_equal(published, new_feed.published.content)
assert_equal(rights, new_feed.rights.content)
assert_equal(description, new_feed.summary.content)
assert_equal(title, new_feed.title.content)
assert_equal(updated, new_feed.updated.content)
if with_dc
@dc_elems.each do |var, value|
if var == :date
assert_equal([updated, value],
new_feed.dc_dates.collect {|date| date.value})
else
assert_equal(value, new_feed.__send__("dc_#{var}"))
end
end
end
assert_equal(1, new_feed.items.size)
end
def test_setup_maker_entry_without_dc
test_setup_maker_entry(false)
end
def test_setup_maker_items(for_backward_compatibility=false)
title = "TITLE"
link = "http://hoge.com/"
description = "text hoge fuga"
updated = Time.now
item_size = 5
feed = RSS::Maker.make("atom:entry") do |maker|
setup_dummy_channel_atom(maker)
item_size.times do |i|
maker.items.new_item do |item|
item.title = "#{title}#{i}"
item.link = "#{link}#{i}"
item.description = "#{description}#{i}"
item.updated = updated + i * 60
end
end
end
new_feed = RSS::Maker.make("atom:entry") do |maker|
feed.items.each do |item|
if for_backward_compatibility
item.setup_maker(maker)
else
item.setup_maker(maker.items)
end
end
feed.items.clear
feed.setup_maker(maker)
end
assert_equal(1, new_feed.items.size)
new_feed.items[0..1].each_with_index do |item, i|
assert_equal("#{title}#{i}", item.title.content)
assert_equal("#{link}#{i}", item.link.href)
assert_equal("#{description}#{i}", item.summary.content)
assert_equal(updated + i * 60, item.updated.content)
end
end
def test_setup_maker_items_sort
title = "TITLE"
link = "http://hoge.com/"
summary = "text hoge fuga"
updated = Time.now
feed_size = 5
feed = RSS::Maker.make("atom:entry") do |maker|
setup_dummy_channel_atom(maker)
feed_size.times do |i|
entry_class = RSS::Atom::Entry
entry = entry_class.new
entry.title = entry_class::Title.new(:content => "#{title}#{i}")
entry.links << entry_class::Link.new(:href => "#{link}#{i}")
entry.summary = entry_class::Summary.new(:content => "#{summary}#{i}")
entry.updated = entry_class::Updated.new(:content => updated + i * 60)
entry.setup_maker(maker.items)
end
maker.items.do_sort = false
end
assert_equal(1, feed.items.size)
assert_equal("#{title}0", feed.title.content)
assert_equal("#{link}0", feed.link.href)
assert_equal("#{summary}0", feed.summary.content)
feed = RSS::Maker.make("atom:entry") do |maker|
setup_dummy_channel_atom(maker)
feed_size.times do |i|
entry_class = RSS::Atom::Entry
entry = entry_class.new
entry.title = entry_class::Title.new(:content => "#{title}#{i}")
entry.links << entry_class::Link.new(:href => "#{link}#{i}")
entry.summary = entry_class::Summary.new(:content => "#{summary}#{i}")
entry.updated = entry_class::Updated.new(:content => updated + i * 60)
entry.setup_maker(maker.items)
end
maker.items.do_sort = true
end
assert_equal(1, feed.items.size)
assert_equal("#{title}#{feed_size - 1}", feed.title.content)
assert_equal("#{link}#{feed_size - 1}", feed.link.href)
assert_equal("#{summary}#{feed_size - 1}", feed.summary.content)
end
def test_setup_maker_items_backward_compatibility
test_setup_maker_items(true)
end
def test_setup_maker
encoding = "EUC-JP"
standalone = true
href = 'a.xsl'
type = 'text/xsl'
title = 'sample'
media = 'printer'
charset = 'UTF-8'
alternate = 'yes'
feed = RSS::Maker.make("atom:entry") do |maker|
maker.encoding = encoding
maker.standalone = standalone
maker.xml_stylesheets.new_xml_stylesheet do |xss|
xss.href = href
xss.type = type
xss.title = title
xss.media = media
xss.charset = charset
xss.alternate = alternate
end
setup_dummy_channel_atom(maker)
setup_dummy_item_atom(maker)
end
assert_not_nil(feed)
new_feed = RSS::Maker.make("atom:entry") do |maker|
feed.setup_maker(maker)
end
assert_equal(["atom", "1.0", "entry"], new_feed.feed_info)
assert_equal(encoding, new_feed.encoding)
assert_equal(standalone, new_feed.standalone)
xss = new_feed.xml_stylesheets.first
assert_equal(1, new_feed.xml_stylesheets.size)
assert_equal(href, xss.href)
assert_equal(type, xss.type)
assert_equal(title, xss.title)
assert_equal(media, xss.media)
assert_equal(charset, xss.charset)
assert_equal(alternate, xss.alternate)
end
def test_setup_maker_full
encoding = "EUC-JP"
standalone = true
href = 'a.xsl'
type = 'text/xsl'
title = 'sample'
media = 'printer'
charset = 'UTF-8'
alternate = 'yes'
channel_about = "http://hoge.com"
channel_title = "fugafuga"
channel_link = "http://hoge.com"
channel_description = "fugafugafugafuga"
channel_author = "Bob"
image_url = "http://hoge.com/hoge.png"
item_title = "TITLE"
item_link = "http://hoge.com/"
item_description = "text hoge fuga"
entry_size = 5
feed = RSS::Maker.make("atom:entry") do |maker|
maker.encoding = encoding
maker.standalone = standalone
maker.xml_stylesheets.new_xml_stylesheet do |xss|
xss.href = href
xss.type = type
xss.title = title
xss.media = media
xss.charset = charset
xss.alternate = alternate
end
maker.channel.about = channel_about
maker.channel.title = channel_title
maker.channel.link = channel_link
maker.channel.description = channel_description
maker.channel.author = channel_author
@dc_elems.each do |var, value|
maker.channel.__send__("dc_#{var}=", value)
end
maker.image.url = image_url
entry_size.times do |i|
maker.items.new_item do |item|
item.title = "#{item_title}#{i}"
item.link = "#{item_link}#{i}"
item.description = "#{item_description}#{i}"
@dc_elems.each do |var, value|
item.__send__("dc_#{var}=", value)
end
end
end
end
new_feed = RSS::Maker.make("atom:entry") do |maker|
feed.setup_maker(maker)
end
assert_equal(["atom", "1.0", "entry"], new_feed.feed_info)
assert_equal(encoding, new_feed.encoding)
assert_equal(standalone, new_feed.standalone)
xss = new_feed.xml_stylesheets.first
assert_equal(1, new_feed.xml_stylesheets.size)
assert_equal(href, xss.href)
assert_equal(type, xss.type)
assert_equal(title, xss.title)
assert_equal(media, xss.media)
assert_equal(charset, xss.charset)
assert_equal(alternate, xss.alternate)
assert_equal("#{item_title}0", new_feed.title.content)
assert_equal("#{item_link}0", new_feed.link.href)
assert_equal("#{item_description}0", new_feed.summary.content)
@dc_elems.each do |var, value|
assert_equal(value, new_feed.__send__("dc_#{var}"))
end
assert_equal(1, new_feed.items.size)
end
end
end

446
test/rss/test_setup_maker_atom_feed.rb
Просмотреть файл

@ -1,446 +0,0 @@
# frozen_string_literal: false
require_relative "rss-testcase"
require "rss/maker"
module RSS
class TestSetupMakerAtomFeed < TestCase
def setup
t = Time.iso8601("2000-01-01T12:00:05+00:00")
class << t
alias_method(:to_s, :iso8601)
end
@dc_elems = {
:title => "hoge",
:description =>
" XML is placing increasingly heavy loads on
the existing technical infrastructure of the Internet.",
:creator => "Rael Dornfest (mailto:rael@oreilly.com)",
:subject => "XML",
:publisher => "The O'Reilly Network",
:contributor => "hogehoge",
:type => "fugafuga",
:format => "hohoho",
:identifier => "fufufu",
:source => "barbar",
:language => "ja",
:relation => "cococo",
:rights => "Copyright (c) 2000 O'Reilly &amp; Associates, Inc.",
:date => t,
}
end
def test_setup_maker_feed(with_dc=true)
authors = [
{
:name => "Bob",
:uri => "http://example.com/~bob/",
:email => "bob@example.com",
},
{
:name => "Alice",
:uri => "http://example.com/~alice/",
:email => "alice@example.com",
},
]
categories = [
{
:term => "music",
:label => "Music",
},
{
:term => "book",
:scheme => "http://example.com/category/book/",
:label => "Book",
},
]
contributors = [
{
:name => "Chris",
:email => "chris@example.com",
},
{
:name => "Eva",
:uri => "http://example.com/~eva/",
},
]
generator = {
:uri => "http://example.com/generator/",
:version => "0.0.1",
:content => "Feed Generator",
}
icon = "http://example.com/icon.png"
about = "http://hoge.com"
title = "fugafuga"
link = "http://hoge.com"
logo = "http://example.com/logo.png"
rights = "Copyrights (c) 2007 Alice and Bob"
description = "fugafugafugafuga"
updated = Time.now
feed = RSS::Maker.make("atom") do |maker|
authors.each do |author_info|
maker.channel.authors.new_author do |author|
author_info.each do |key, value|
author.__send__("#{key}=", value)
end
end
end
categories.each do |category_info|
maker.channel.categories.new_category do |category|
category_info.each do |key, value|
category.__send__("#{key}=", value)
end
end
end
contributors.each do |contributor_info|
maker.channel.contributors.new_contributor do |contributor|
contributor_info.each do |key, value|
contributor.__send__("#{key}=", value)
end
end
end
generator.each do |key, value|
maker.channel.generator do |g|
g.__send__("#{key}=", value)
end
end
maker.channel.icon = icon
maker.channel.about = about
maker.channel.link = link
maker.channel.logo = logo
maker.channel.rights = rights
maker.channel.title = title
maker.channel.description = description
maker.channel.updated = updated
if with_dc
@dc_elems.each do |var, value|
if var == :date
maker.channel.new_dc_date(value)
else
maker.channel.__send__("dc_#{var}=", value)
end
end
end
setup_dummy_item_atom(maker)
end
assert_not_nil(feed)
new_feed = RSS::Maker.make("atom") do |maker|
feed.setup_maker(maker)
end
assert_not_nil(new_feed)
new_authors = new_feed.authors.collect do |author|
{
:name => author.name.content,
:uri => author.uri.content,
:email => author.email.content,
}
end
assert_equal(authors, new_authors)
new_categories = new_feed.categories.collect do |category|
{
:term => category.term,
:scheme => category.scheme,
:label => category.label,
}.reject {|key, value| value.nil?}
end
assert_equal(categories, new_categories)
new_contributors = new_feed.contributors.collect do |contributor|
info = {}
info[:name] = contributor.name.content
info[:uri] = contributor.uri.content if contributor.uri
info[:email] = contributor.email.content if contributor.email
info
end
assert_equal(contributors, new_contributors)
new_generator = {
:uri => new_feed.generator.uri,
:version => new_feed.generator.version,
:content => new_feed.generator.content,
}
assert_equal(generator, new_generator)
assert_equal(icon, new_feed.icon.content)
assert_equal(about, new_feed.id.content)
assert_equal(link, new_feed.link.href)
assert_equal(logo, new_feed.logo.content)
assert_equal(rights, new_feed.rights.content)
assert_equal(description, new_feed.subtitle.content)
assert_equal(title, new_feed.title.content)
assert_equal(updated, new_feed.updated.content)
if with_dc
@dc_elems.each do |var, value|
if var == :date
assert_equal([updated, value],
new_feed.dc_dates.collect {|date| date.value})
else
assert_equal(value, new_feed.__send__("dc_#{var}"))
end
end
end
assert_equal(1, new_feed.items.size)
end
def test_setup_maker_feed_without_dc
test_setup_maker_feed(false)
end
def test_setup_maker_items(for_backward_compatibility=false)
title = "TITLE"
link = "http://hoge.com/"
description = "text hoge fuga"
updated = Time.now
item_size = 5
feed = RSS::Maker.make("atom") do |maker|
setup_dummy_channel_atom(maker)
item_size.times do |i|
maker.items.new_item do |item|
item.title = "#{title}#{i}"
item.link = "#{link}#{i}"
item.description = "#{description}#{i}"
item.updated = updated + i * 60
end
end
end
new_feed = RSS::Maker.make("atom") do |maker|
feed.items.each do |item|
if for_backward_compatibility
item.setup_maker(maker)
else
item.setup_maker(maker.items)
end
end
feed.items.clear
feed.setup_maker(maker)
end
assert_equal(item_size, new_feed.items.size)
new_feed.items.each_with_index do |item, i|
assert_equal("#{title}#{i}", item.title.content)
assert_equal("#{link}#{i}", item.link.href)
assert_equal("#{description}#{i}", item.summary.content)
assert_equal(updated + i * 60, item.updated.content)
end
end
def test_setup_maker_items_sort
title = "TITLE"
link = "http://hoge.com/"
summary = "text hoge fuga"
updated = Time.now
feed_size = 5
feed = RSS::Maker.make("atom") do |maker|
setup_dummy_channel_atom(maker)
feed_size.times do |i|
entry_class = RSS::Atom::Feed::Entry
entry = entry_class.new
entry.title = entry_class::Title.new(:content => "#{title}#{i}")
entry.links << entry_class::Link.new(:href => "#{link}#{i}")
entry.summary = entry_class::Summary.new(:content => "#{summary}#{i}")
entry.updated = entry_class::Updated.new(:content => updated + i * 60)
entry.setup_maker(maker.items)
end
maker.items.do_sort = false
end
assert_equal(feed_size, feed.entries.size)
feed.entries.each_with_index do |entry, i|
assert_equal("#{title}#{i}", entry.title.content)
assert_equal("#{link}#{i}", entry.link.href)
assert_equal("#{summary}#{i}", entry.summary.content)
end
feed = RSS::Maker.make("atom") do |maker|
setup_dummy_channel_atom(maker)
feed_size.times do |i|
entry_class = RSS::Atom::Feed::Entry
entry = entry_class.new
entry.title = entry_class::Title.new(:content => "#{title}#{i}")
entry.links << entry_class::Link.new(:href => "#{link}#{i}")
entry.summary = entry_class::Summary.new(:content => "#{summary}#{i}")
entry.updated = entry_class::Updated.new(:content => updated + i * 60)
entry.setup_maker(maker.items)
end
maker.items.do_sort = true
end
assert_equal(feed_size, feed.entries.size)
feed.entries.reverse.each_with_index do |entry, i|
assert_equal("#{title}#{i}", entry.title.content)
assert_equal("#{link}#{i}", entry.link.href)
assert_equal("#{summary}#{i}", entry.summary.content)
end
end
def test_setup_maker_items_backward_compatibility
test_setup_maker_items(true)
end
def test_setup_maker
encoding = "EUC-JP"
standalone = true
href = 'a.xsl'
type = 'text/xsl'
title = 'sample'
media = 'printer'
charset = 'UTF-8'
alternate = 'yes'
feed = RSS::Maker.make("atom") do |maker|
maker.encoding = encoding
maker.standalone = standalone
maker.xml_stylesheets.new_xml_stylesheet do |xss|
xss.href = href
xss.type = type
xss.title = title
xss.media = media
xss.charset = charset
xss.alternate = alternate
end
setup_dummy_channel_atom(maker)
setup_dummy_item_atom(maker)
end
assert_not_nil(feed)
new_feed = RSS::Maker.make("atom") do |maker|
feed.setup_maker(maker)
end
assert_equal(["atom", "1.0", "feed"], new_feed.feed_info)
assert_equal(encoding, new_feed.encoding)
assert_equal(standalone, new_feed.standalone)
xss = new_feed.xml_stylesheets.first
assert_equal(1, new_feed.xml_stylesheets.size)
assert_equal(href, xss.href)
assert_equal(type, xss.type)
assert_equal(title, xss.title)
assert_equal(media, xss.media)
assert_equal(charset, xss.charset)
assert_equal(alternate, xss.alternate)
end
def test_setup_maker_full
encoding = "EUC-JP"
standalone = true
href = 'a.xsl'
type = 'text/xsl'
title = 'sample'
media = 'printer'
charset = 'UTF-8'
alternate = 'yes'
channel_about = "http://hoge.com"
channel_title = "fugafuga"
channel_link = "http://hoge.com"
channel_description = "fugafugafugafuga"
channel_author = "Bob"
image_url = "http://hoge.com/hoge.png"
item_title = "TITLE"
item_link = "http://hoge.com/"
item_description = "text hoge fuga"
entry_size = 5
feed = RSS::Maker.make("atom") do |maker|
maker.encoding = encoding
maker.standalone = standalone
maker.xml_stylesheets.new_xml_stylesheet do |xss|
xss.href = href
xss.type = type
xss.title = title
xss.media = media
xss.charset = charset
xss.alternate = alternate
end
maker.channel.about = channel_about
maker.channel.title = channel_title
maker.channel.link = channel_link
maker.channel.description = channel_description
maker.channel.author = channel_author
@dc_elems.each do |var, value|
maker.channel.__send__("dc_#{var}=", value)
end
maker.image.url = image_url
entry_size.times do |i|
maker.items.new_item do |item|
item.title = "#{item_title}#{i}"
item.link = "#{item_link}#{i}"
item.description = "#{item_description}#{i}"
@dc_elems.each do |var, value|
item.__send__("dc_#{var}=", value)
end
end
end
end
new_feed = RSS::Maker.make("atom") do |maker|
feed.setup_maker(maker)
end
assert_equal(["atom", "1.0", "feed"], new_feed.feed_info)
assert_equal(encoding, new_feed.encoding)
assert_equal(standalone, new_feed.standalone)
xss = new_feed.xml_stylesheets.first
assert_equal(1, new_feed.xml_stylesheets.size)
assert_equal(href, xss.href)
assert_equal(type, xss.type)
assert_equal(title, xss.title)
assert_equal(media, xss.media)
assert_equal(charset, xss.charset)
assert_equal(alternate, xss.alternate)
assert_equal(channel_title, new_feed.title.content)
assert_equal(channel_link, new_feed.link.href)
assert_equal(channel_description, new_feed.subtitle.content)
assert_equal(channel_author, new_feed.author.name.content)
assert_equal(image_url, new_feed.logo.content)
@dc_elems.each do |var, value|
assert_equal(value, new_feed.__send__("dc_#{var}"))
end
assert_equal(entry_size, new_feed.entries.size)
new_feed.entries.each_with_index do |entry, i|
assert_equal("#{item_title}#{i}", entry.title.content)
assert_equal("#{item_link}#{i}", entry.link.href)
assert_equal("#{item_description}#{i}", entry.summary.content)
@dc_elems.each do |var, value|
assert_equal(value, entry.__send__("dc_#{var}"))
end
end
end
end
end

144
test/rss/test_setup_maker_itunes.rb
Просмотреть файл

@ -1,144 +0,0 @@
# frozen_string_literal: false
require_relative "rss-testcase"
require "rss/maker"
module RSS
class TestSetupMakerITunes < TestCase
def test_setup_maker_simple
author = "John Doe"
block = true
categories = ["Audio Blogs"]
image = "http://example.com/podcasts/everything/AllAboutEverything.jpg"
duration = "4:05"
duration_components = [0, 4, 5]
explicit = true
keywords = ["salt", "pepper", "shaker", "exciting"]
owner = {:name => "John Doe", :email => "john.doe@example.com"}
subtitle = "A show about everything"
summary = "All About Everything is a show about " +
"everything. Each week we dive into any " +
"subject known to man and talk about it " +
"as much as we can. Look for our Podcast " +
"in the iTunes Music Store"
feed = RSS::Maker.make("rss2.0") do |maker|
setup_dummy_channel(maker)
setup_dummy_item(maker)
channel = maker.channel
channel.itunes_author = author
channel.itunes_block = block
categories.each do |category|
channel.itunes_categories.new_category.text = category
end
channel.itunes_image = image
channel.itunes_explicit = explicit
channel.itunes_keywords = keywords
channel.itunes_owner.itunes_name = owner[:name]
channel.itunes_owner.itunes_email = owner[:email]
channel.itunes_subtitle = subtitle
channel.itunes_summary = summary
item = maker.items.last
item.itunes_author = author
item.itunes_block = block
item.itunes_duration = duration
item.itunes_explicit = explicit
item.itunes_keywords = keywords
item.itunes_subtitle = subtitle
item.itunes_summary = summary
end
assert_not_nil(feed)
new_feed = RSS::Maker.make("rss2.0") do |maker|
feed.setup_maker(maker)
end
assert_not_nil(new_feed)
channel = new_feed.channel
item = new_feed.items.last
assert_equal(author, channel.itunes_author)
assert_equal(author, item.itunes_author)
assert_equal(block, channel.itunes_block?)
assert_equal(block, item.itunes_block?)
assert_equal(categories,
collect_itunes_categories(channel.itunes_categories))
assert_equal(image, channel.itunes_image.href)
assert_equal(duration_components,
[item.itunes_duration.hour,
item.itunes_duration.minute,
item.itunes_duration.second])
assert_equal(explicit, channel.itunes_explicit?)
assert_equal(explicit, item.itunes_explicit?)
assert_equal(keywords, channel.itunes_keywords)
assert_equal(keywords, item.itunes_keywords)
assert_equal(owner,
{
:name => channel.itunes_owner.itunes_name,
:email => channel.itunes_owner.itunes_email
})
assert_equal(subtitle, channel.itunes_subtitle)
assert_equal(subtitle, item.itunes_subtitle)
assert_equal(summary, channel.itunes_summary)
assert_equal(summary, item.itunes_summary)
end
def test_setup_maker_with_nested_categories
categories = [["Arts & Entertainment", "Games"],
["Technology", "Computers"],
"Audio Blogs"]
feed = RSS::Maker.make("rss2.0") do |maker|
setup_dummy_channel(maker)
setup_dummy_item(maker)
channel = maker.channel
categories.each do |category|
target = channel.itunes_categories
if category.is_a?(Array)
category.each do |sub_category|
target = target.new_category
target.text = sub_category
end
else
target.new_category.text = category
end
end
end
assert_not_nil(feed)
new_feed = RSS::Maker.make("rss2.0") do |maker|
feed.setup_maker(maker)
end
assert_not_nil(new_feed)
channel = new_feed.channel
assert_equal(categories,
collect_itunes_categories(channel.itunes_categories))
end
private
def collect_itunes_categories(categories)
categories.collect do |c|
rest = collect_itunes_categories(c.itunes_categories)
if rest.empty?
c.text
else
[c.text, *rest]
end
end
end
end
end

39
test/rss/test_setup_maker_slash.rb
Просмотреть файл

@ -1,39 +0,0 @@
# frozen_string_literal: false
require_relative "rss-testcase"
require "rss/maker"
module RSS
class TestSetupMakerSlash < TestCase
def test_setup_maker
elements = {
"section" => "articles",
"department" => "not-an-ocean-unless-there-are-lobsters",
"comments" => 177,
"hit_parades" => [177, 155, 105, 33, 6, 3, 0],
}
rss = RSS::Maker.make("rss1.0") do |maker|
setup_dummy_channel(maker)
setup_dummy_item(maker)
item = maker.items.last
item.slash_section = elements["section"]
item.slash_department = elements["department"]
item.slash_comments = elements["comments"]
item.slash_hit_parade = elements["hit_parades"].join(",")
end
assert_not_nil(rss)
new_rss = RSS::Maker.make("rss1.0") do |maker|
rss.setup_maker(maker)
end
assert_not_nil(new_rss)
item = new_rss.items.last
assert_not_nil(item)
assert_slash_elements(elements, item)
end
end
end

65
test/rss/test_slash.rb
Просмотреть файл

@ -1,65 +0,0 @@
# frozen_string_literal: false
require "cgi"
require "rexml/document"
require_relative "rss-testcase"
require "rss/1.0"
require "rss/slash"
module RSS
class TestSlash < TestCase
def setup
@elements = {
"section" => "articles",
"department" => "not-an-ocean-unless-there-are-lobsters",
"comments" => 177,
"hit_parades" => [177, 155, 105, 33, 6, 3, 0],
}
slash_nodes = @elements.collect do |name, value|
if name == "hit_parades"
name = "hit_parade"
value = value.join(",")
end
"<slash:#{name}>#{value}</slash:#{name}>"
end.join("\n")
slash_ns = {"slash" => "http://purl.org/rss/1.0/modules/slash/"}
@source = make_RDF(<<-EOR, slash_ns)
#{make_channel}
#{make_image}
#{make_item(slash_nodes)}
#{make_textinput}
EOR
end
def test_parser
rss = RSS::Parser.parse(@source)
assert_not_nil(rss)
item = rss.items[0]
assert_not_nil(item)
assert_slash_elements(item)
end
def test_to_s
rss = RSS::Parser.parse(@source)
rss = RSS::Parser.parse(rss.to_s)
assert_not_nil(rss)
item = rss.items[0]
assert_not_nil(item)
assert_slash_elements(item)
end
private
def assert_slash_elements(target)
super(@elements, target)
end
end
end

126
test/rss/test_syndication.rb
Просмотреть файл

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

173
test/rss/test_taxonomy.rb
Просмотреть файл

@ -1,173 +0,0 @@
# frozen_string_literal: false
require "cgi"
require_relative "rss-testcase"
require "rss/1.0"
require "rss/2.0"
require "rss/taxonomy"
module RSS
class TestTaxonomy < TestCase
def setup
@prefix = "taxo"
@uri = "http://purl.org/rss/1.0/modules/taxonomy/"
@dc_prefix = "dc"
@dc_uri = "http://purl.org/dc/elements/1.1/"
@ns = {
@prefix => @uri,
@dc_prefix => @dc_uri,
}
@topics_parents = %w(channel item)
@topics_lis = [
"http://meerkat.oreillynet.com/?c=cat23",
"http://meerkat.oreillynet.com/?c=47",
"http://dmoz.org/Computers/Data_Formats/Markup_Languages/XML/",
]
@topics_node = "<#{@prefix}:topics>\n"
@topics_node << " <rdf:Bag>\n"
@topics_lis.each do |value|
resource = CGI.escapeHTML(value)
@topics_node << " <rdf:li resource=\"#{resource}\"/>\n"
end
@topics_node << " </rdf:Bag>\n"
@topics_node << "</#{@prefix}:topics>"
@topic_topics_lis = \
[
"http://meerkat.oreillynet.com/?c=cat23",
"http://dmoz.org/Computers/Data_Formats/Markup_Languages/SGML/",
"http://dmoz.org/Computers/Programming/Internet/",
]
@topic_contents = \
[
{
:link => "http://meerkat.oreillynet.com/?c=cat23",
:title => "Data: XML",
:description => "A Meerkat channel",
},
{
:link => "http://dmoz.org/Computers/Data_Formats/Markup_Languages/XML/",
:title => "XML",
:subject => "XML",
:description => "DMOZ category",
:topics => @topic_topics_lis,
}
]
@topic_nodes = @topic_contents.collect do |info|
link = info[:link]
rv = "<#{@prefix}:topic rdf:about=\"#{link}\">\n"
info.each do |name, value|
case name
when :topics
rv << " <#{@prefix}:topics>\n"
rv << " <rdf:Bag>\n"
value.each do |li|
resource = CGI.escapeHTML(li)
rv << " <rdf:li resource=\"#{resource}\"/>\n"
end
rv << " </rdf:Bag>\n"
rv << " </#{@prefix}:topics>\n"
else
prefix = (name == :link ? @prefix : @dc_prefix)
rv << " <#{prefix}:#{name}>#{value}</#{prefix}:#{name}>\n"
end
end
rv << "</#{@prefix}:topic>"
end
@rss_source = make_RDF(<<-EOR, @ns)
#{make_channel(@topics_node)}
#{make_image()}
#{make_item(@topics_node)}
#{make_textinput()}
#{@topic_nodes.join("\n")}
EOR
@rss = Parser.parse(@rss_source)
end
def test_parser
assert_nothing_raised do
Parser.parse(@rss_source)
end
assert_too_much_tag("topics", "channel") do
Parser.parse(make_RDF(<<-EOR, @ns))
#{make_channel(@topics_node * 2)}
#{make_item()}
EOR
end
assert_too_much_tag("topics", "item") do
Parser.parse(make_RDF(<<-EOR, @ns))
#{make_channel()}
#{make_item(@topics_node * 2)}
EOR
end
end
def test_accessor
topics = @rss.channel.taxo_topics
assert_equal(@topics_lis.sort,
topics.Bag.lis.collect {|li| li.resource}.sort)
assert_equal(@topics_lis.sort, topics.resources.sort)
assert_equal(@rss.taxo_topics.first, @rss.taxo_topic)
@topic_contents.each_with_index do |info, i|
topic = @rss.taxo_topics[i]
info.each do |name, value|
case name
when :link
assert_equal(value, topic.about)
assert_equal(value, topic.taxo_link)
when :topics
assert_equal(value.sort, topic.taxo_topics.resources.sort)
else
assert_equal(value, topic.__send__("dc_#{name}"))
end
end
end
end
def test_to_s
@topics_parents.each do |parent|
meth = "taxo_topics_element"
assert_equal(@topics_node, @rss.__send__(parent).__send__(meth))
end
@topic_nodes.each_with_index do |node, i|
expected_xml = taxo_xmlns_container(node)
expected = REXML::Document.new(expected_xml).root.elements[1]
actual_xml = taxo_xmlns_container(@rss.taxo_topics[i].to_s(true, ""))
actual = REXML::Document.new(actual_xml).root.elements[1]
expected_elems = expected.reject {|x| x.is_a?(REXML::Text)}
actual_elems = actual.reject {|x| x.is_a?(REXML::Text)}
expected_elems.sort! {|x, y| x.name <=> y.name}
actual_elems.sort! {|x, y| x.name <=> y.name}
assert_equal(expected_elems.collect {|x| x.to_s},
actual_elems.collect {|x| x.to_s})
assert_equal(expected.attributes.sort, actual.attributes.sort)
end
end
private
def taxo_xmlns_container(content)
xmlns_container({
@prefix => @uri,
"dc" => "http://purl.org/dc/elements/1.1/",
"rdf" => "http://www.w3.org/1999/02/22-rdf-syntax-ns#",
},
content)
end
end
end

701
test/rss/test_to_s.rb
Просмотреть файл

@ -1,701 +0,0 @@
# frozen_string_literal: false
require "rexml/document"
require_relative "rss-testcase"
require "rss/maker"
require "rss/1.0"
require "rss/2.0"
require "rss/content"
require "rss/dublincore"
require "rss/syndication"
require "rss/trackback"
module RSS
class TestToS < TestCase
def setup
@image_url = "http://example.com/foo.png"
@textinput_link = "http://example.com/search.cgi"
@item_links = [
"http://example.com/1",
"http://example.com/2",
]
setup_xml_declaration_info
setup_xml_stylesheet_infos
setup_channel_info
setup_item_infos
setup_image_info
setup_textinput_info
setup_dublin_core_info
setup_syndication_info
setup_content_info
setup_trackback_info
end
def test_to_s_10
rss = RSS::Maker.make("1.0") do |maker|
setup_full(maker)
end
assert_xml_declaration(@version, @encoding, @standalone, rss)
assert_xml_stylesheets(@xs_infos, rss.xml_stylesheets)
assert_channel10(@channel_info, rss.channel)
assert_items10(@item_infos, rss.items)
rss.items.each do |item|
assert_trackback(@trackback_info, item)
end
assert_image10(@image_info, rss.image)
assert_textinput10(@textinput_info, rss.textinput)
rss = RSS::Parser.parse(rss.to_s)
assert_xml_declaration(@version, @encoding, @standalone, rss)
assert_xml_stylesheets(@xs_infos, rss.xml_stylesheets)
assert_channel10(@channel_info, rss.channel)
assert_items10(@item_infos, rss.items)
assert_image10(@image_info, rss.image)
assert_textinput10(@textinput_info, rss.textinput)
end
def test_to_s_09
rss = RSS::Maker.make("0.91") do |maker|
setup_full(maker)
end
assert_xml_declaration(@version, @encoding, @standalone, rss)
assert_xml_stylesheets(@xs_infos, rss.xml_stylesheets)
assert_channel09(@channel_info, rss.channel)
assert_items09(@item_infos, rss.items)
assert_image09(@image_info, rss.image)
assert_textinput09(@textinput_info, rss.textinput)
rss = RSS::Parser.parse(rss.to_s)
assert_xml_declaration(@version, @encoding, @standalone, rss)
assert_xml_stylesheets(@xs_infos, rss.xml_stylesheets)
assert_channel09(@channel_info, rss.channel)
assert_items09(@item_infos, rss.items)
assert_image09(@image_info, rss.image)
assert_textinput09(@textinput_info, rss.textinput)
end
def test_to_s_20
rss = RSS::Maker.make("2.0") do |maker|
setup_full(maker)
end
assert_xml_declaration(@version, @encoding, @standalone, rss)
assert_xml_stylesheets(@xs_infos, rss.xml_stylesheets)
assert_channel20(@channel_info, rss.channel)
assert_items20(@item_infos, rss.items)
assert_image20(@image_info, rss.image)
assert_textinput20(@textinput_info, rss.textinput)
rss = RSS::Parser.parse(rss.to_s)
assert_xml_declaration(@version, @encoding, @standalone, rss)
assert_xml_stylesheets(@xs_infos, rss.xml_stylesheets)
assert_channel20(@channel_info, rss.channel)
assert_items20(@item_infos, rss.items)
assert_image20(@image_info, rss.image)
assert_textinput20(@textinput_info, rss.textinput)
end
def test_time_w3cdtf
assert_equal("2015-09-05T01:25:48.0001Z",
Time.utc(2015, 9, 5, 1, 25, 48, 100).w3cdtf,
'[ruby-core:70667] [Bug #11509]')
end
def test_20_empty_text
title = "Blog entries"
link = "http://blog.example.com/"
description = ""
rss = RSS::Maker.make("2.0") do |maker|
maker.channel.title = title
maker.channel.link = link
maker.channel.description = description
end
parsed_rss = RSS::Parser.parse(rss.to_s)
assert_equal({
title: title,
link: link,
description: description,
},
{
title: parsed_rss.channel.title,
link: parsed_rss.channel.link,
description: parsed_rss.channel.description,
},
"[ruby-core:80965] [Bug #13531]")
end
private
def setup_xml_declaration_info
@version = "1.0"
@encoding = "UTF-8"
@standalone = false
end
def setup_xml_stylesheet_infos
@xs_infos = [
{
"href" => "XXX.xsl",
"type" => "text/xsl",
"title" => "XXX",
"media" => "print",
"alternate" => "no",
},
{
"href" => "YYY.css",
"type" => "text/css",
"title" => "YYY",
"media" => "all",
"alternate" => "no",
},
]
end
def setup_channel_info
@channel_info = {
"about" => "http://example.com/index.rdf",
"title" => "Sample RSS",
"link" => "http://example.com/",
"description" => "Sample\n\n\n\n\nSite",
"language" => "en",
"copyright" => "FDL",
"managingEditor" => "foo@example.com",
"webMaster" => "webmaster@example.com",
"rating" => '(PICS-1.1 "http://www.rsac.org/ratingsv01.html" l gen true comment "RSACi North America Server" for "http://www.rsac.org" on "1996.04.16T08:15-0500" r (n 0 s 0 v 0 l 0))',
"docs" => "http://backend.userland.com/rss091",
"skipDays" => [
"Monday",
"Friday",
],
"skipHours" => [
"12",
"23",
],
"date" => Time.now,
"lastBuildDate" => Time.now - 3600,
"generator" => "RSS Maker",
"ttl" => "60",
"cloud" => {
"domain" => "rpc.sys.com",
"port" => "80",
"path" => "/RPC2",
"registerProcedure" => "myCloud.rssPleaseNotify",
"protocol" => "xml-rpc",
},
"category" => {
"domain" => "http://example.com/misc/",
"content" => "misc",
},
"image" => {
"resource" => @image_url,
},
"textinput" => {
"resource" => @textinput_link,
},
"items" => @item_links.collect{|link| {"resource" => link}},
}
end
def setup_item_infos
@item_infos = [
{
"title" => "Sample item1",
"link" => @item_links[0],
"description" => "Sample description1",
"date" => Time.now - 3600,
"author" => "foo@example.com",
"comments" => "http://example.com/1/comments",
"guid" => {
"isPermaLink" => "true",
"content" => "http://example.com/1",
},
"enclosure" => {
"url" => "http://example.com/1.mp3",
"length" => "100",
"type" => "audio/mpeg",
},
"source" => {
"url" => "http:/example.com/",
"content" => "Sample site",
},
"category" => {
"domain" => "http://example.com/misc/",
"content" => "misc",
},
},
{
"title" => "Sample item2",
"link" => @item_links[1],
"description" => "Sample description2",
"date" => Time.now - 7200,
"author" => "foo@example.com",
"comments" => "http://example.com/2/comments",
"guid" => {
"isPermaLink" => "false",
"content" => "http://example.com/2",
},
"enclosure" => {
"url" => "http://example.com/2.mp3",
"length" => "200",
"type" => "audio/mpeg",
},
"source" => {
"url" => "http:/example.com/",
"content" => "Sample site",
},
"category" => {
"domain" => "http://example.com/misc/",
"content" => "misc",
},
},
]
end
def setup_image_info
@image_info = {
"title" => "Sample image",
"url" => @image_url,
"width" => "88",
"height" => "31",
"description" => "Sample",
}
end
def setup_textinput_info
@textinput_info = {
"title" => "Sample textinput",
"description" => "Search",
"name" => "key",
"link" => @textinput_link,
}
end
def setup_dublin_core_info
@dc_info = {
"title" => "DC title",
"description" => "DC desc",
"creator" => "DC creator",
"subject" => "DC subject",
"publisher" => "DC publisher",
"contributor" => "DC contributor",
"type" => "DC type",
"format" => "DC format",
"identifier" => "DC identifier",
"source" => "DC source",
"language" => "ja",
"relation" => "DC relation",
"coverage" => "DC coverage",
"rights" => "DC rights",
"date" => Time.now - 60,
}
end
def setup_syndication_info
@sy_info = {
"updatePeriod" => "hourly",
"updateFrequency" => "2",
"updateBase" => Time.now - 3600,
}
end
def setup_content_info
@content_info = {
"encoded" => "<p>p</p>",
}
end
def setup_trackback_info
@trackback_info = {
"ping" => "http://example.com/tb.cgi?tb_id=XXX",
"abouts" => [
"http://example.net/tb.cgi?tb_id=YYY",
"http://example.org/tb.cgi?tb_id=ZZZ",
]
}
end
def setup_full(maker)
setup_xml_declaration(maker)
setup_xml_stylesheets(maker)
setup_channel(maker)
setup_image(maker)
setup_items(maker)
setup_textinput(maker)
end
def setup_xml_declaration(maker)
%w(version encoding standalone).each do |name|
maker.__send__("#{name}=", instance_eval("@#{name}"))
end
end
def setup_xml_stylesheets(maker)
@xs_infos.each do |info|
xs = maker.xml_stylesheets.new_xml_stylesheet
info.each do |name, value|
xs.__send__("#{name}=", value)
end
end
end
def setup_channel(maker)
channel = maker.channel
info = @channel_info
%w(about title link description language copyright
managingEditor webMaster rating docs date
lastBuildDate generator ttl).each do |name|
channel.__send__("#{name}=", info[name])
end
skipDays = channel.skipDays
info["skipDays"].each do |day|
new_day = skipDays.new_day
new_day.content = day
end
skipHours = channel.skipHours
info["skipHours"].each do |hour|
new_hour = skipHours.new_hour
new_hour.content = hour
end
cloud = channel.cloud
%w(domain port path registerProcedure protocol).each do |name|
cloud.__send__("#{name}=", info["cloud"][name])
end
category = channel.categories.new_category
%w(domain content).each do |name|
category.__send__("#{name}=", info["category"][name])
end
end
def setup_image(maker)
image = maker.image
info = @image_info
%w(title url width height description).each do |name|
image.__send__("#{name}=", info[name])
end
end
def setup_items(maker)
items = maker.items
@item_infos.each do |info|
item = items.new_item
%w(title link description date author comments).each do |name|
item.__send__("#{name}=", info[name])
end
guid = item.guid
%w(isPermaLink content).each do |name|
guid.__send__("#{name}=", info["guid"][name])
end
enclosure = item.enclosure
%w(url length type).each do |name|
enclosure.__send__("#{name}=", info["enclosure"][name])
end
source = item.source
%w(url content).each do |name|
source.__send__("#{name}=", info["source"][name])
end
category = item.categories.new_category
%w(domain content).each do |name|
category.__send__("#{name}=", info["category"][name])
end
setup_trackback(item)
end
end
def setup_textinput(maker)
textinput = maker.textinput
info = @textinput_info
%w(title description name link).each do |name|
textinput.__send__("#{name}=", info[name])
end
end
def setup_content(target)
prefix = "content"
%w(encoded).each do |name|
target.__send__("#{prefix}_#{name}=", @content_info[name])
end
end
def setup_dublin_core(target)
prefix = "dc"
%w(title description creator subject publisher
contributor type format identifier source language
relation coverage rights).each do |name|
target.__send__("#{prefix}_#{name}=", @dc_info[name])
end
end
def setup_syndicate(target)
prefix = "sy"
%w(updatePeriod updateFrequency updateBase).each do |name|
target.__send__("#{prefix}_#{name}=", @sy_info[name])
end
end
def setup_trackback(target)
target.trackback_ping = @trackback_info["ping"]
@trackback_info["abouts"].each do |about|
new_about = target.trackback_abouts.new_about
new_about.value = about
end
end
def assert_channel10(attrs, channel)
_wrap_assertion do
n_attrs = normalized_attrs(attrs)
names = %w(about title link description)
assert_attributes(attrs, names, channel)
%w(image items textinput).each do |name|
value = n_attrs[name]
if value
target = channel.__send__(name)
__send__("assert_channel10_#{name}", value, target)
end
end
end
end
def assert_channel10_image(attrs, image)
_wrap_assertion do
assert_attributes(attrs, %w(resource), image)
end
end
def assert_channel10_textinput(attrs, textinput)
_wrap_assertion do
assert_attributes(attrs, %w(resource), textinput)
end
end
def assert_channel10_items(attrs, items)
_wrap_assertion do
assert_equal(items.resources, items.Seq.lis.collect {|x| x.resource})
items.Seq.lis.each_with_index do |li, i|
assert_attributes(attrs[i], %w(resource), li)
end
end
end
def assert_image10(attrs, image)
_wrap_assertion do
names = %w(about title url link)
assert_attributes(attrs, names, image)
end
end
def assert_items10(attrs, items)
_wrap_assertion do
names = %w(about title link description)
items.each_with_index do |item, i|
assert_attributes(attrs[i], names, item)
end
end
end
def assert_textinput10(attrs, textinput)
_wrap_assertion do
names = %w(about title description name link)
assert_attributes(attrs, names, textinput)
end
end
def assert_channel09(attrs, channel)
_wrap_assertion do
n_attrs = normalized_attrs(attrs)
names = %w(title description link language rating
copyright pubDate lastBuildDate docs
managingEditor webMaster)
assert_attributes(attrs, names, channel)
%w(skipHours skipDays).each do |name|
value = n_attrs[name]
if value
target = channel.__send__(name)
__send__("assert_channel09_#{name}", value, target)
end
end
end
end
def assert_channel09_skipDays(contents, skipDays)
_wrap_assertion do
days = skipDays.days
contents.each_with_index do |content, i|
assert_equal(content, days[i].content)
end
end
end
def assert_channel09_skipHours(contents, skipHours)
_wrap_assertion do
hours = skipHours.hours
contents.each_with_index do |content, i|
assert_equal(content.to_i, hours[i].content)
end
end
end
def assert_image09(attrs, image)
_wrap_assertion do
names = %w(url link title description)
names << ["width", :integer]
names << ["height", :integer]
assert_attributes(attrs, names, image)
end
end
def assert_items09(attrs, items)
_wrap_assertion do
names = %w(title link description)
items.each_with_index do |item, i|
assert_attributes(attrs[i], names, item)
end
end
end
def assert_textinput09(attrs, textinput)
_wrap_assertion do
names = %w(title description name link)
assert_attributes(attrs, names, textinput)
end
end
def assert_channel20(attrs, channel)
_wrap_assertion do
n_attrs = normalized_attrs(attrs)
names = %w(title link description language copyright
managingEditor webMaster pubDate
lastBuildDate generator docs rating)
names << ["ttl", :integer]
assert_attributes(attrs, names, channel)
%w(cloud categories skipHours skipDays).each do |name|
value = n_attrs[name]
if value
target = channel.__send__(name)
__send__("assert_channel20_#{name}", value, target)
end
end
end
end
def assert_channel20_skipDays(contents, skipDays)
assert_channel09_skipDays(contents, skipDays)
end
def assert_channel20_skipHours(contents, skipHours)
assert_channel09_skipHours(contents, skipHours)
end
def assert_channel20_cloud(attrs, cloud)
_wrap_assertion do
names = %w(domain path registerProcedure protocol)
names << ["port", :integer]
assert_attributes(attrs, names, cloud)
end
end
def assert_channel20_categories(attrs, categories)
_wrap_assertion do
names = %w(domain content)
categories.each_with_index do |category, i|
assert_attributes(attrs[i], names, category)
end
end
end
def assert_image20(attrs, image)
_wrap_assertion do
names = %w(url link title description)
names << ["width", :integer]
names << ["height", :integer]
assert_attributes(attrs, names, image)
end
end
def assert_items20(attrs, items)
_wrap_assertion do
names = %w(about title link description)
items.each_with_index do |item, i|
assert_attributes(attrs[i], names, item)
n_attrs = normalized_attrs(attrs[i])
%w(source enclosure categories guid).each do |name|
value = n_attrs[name]
if value
target = item.__send__(name)
__send__("assert_items20_#{name}", value, target)
end
end
end
end
end
def assert_items20_source(attrs, source)
_wrap_assertion do
assert_attributes(attrs, %w(url content), source)
end
end
def assert_items20_enclosure(attrs, enclosure)
_wrap_assertion do
names = ["url", ["length", :integer], "type"]
assert_attributes(attrs, names, enclosure)
end
end
def assert_items20_categories(attrs, categories)
_wrap_assertion do
assert_channel20_categories(attrs, categories)
end
end
def assert_items20_guid(attrs, guid)
_wrap_assertion do
names = [["isPermaLink", :boolean], ["content"]]
assert_attributes(attrs, names, guid)
end
end
def assert_textinput20(attrs, textinput)
_wrap_assertion do
names = %w(title description name link)
assert_attributes(attrs, names, textinput)
end
end
end
end

136
test/rss/test_trackback.rb
Просмотреть файл

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

109
test/rss/test_xml-stylesheet.rb
Просмотреть файл

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

4
tool/sync_default_gems.rb
Просмотреть файл

@ -25,7 +25,6 @@
# * https://github.com/ruby/prime
# * https://github.com/ruby/matrix
# * https://github.com/ruby/ostruct
# * https://github.com/ruby/rss
# * https://github.com/ruby/irb
# * https://github.com/ruby/tracer
# * https://github.com/ruby/forwardable
@ -79,7 +78,6 @@ $repositories = {
prime: 'ruby/prime',
matrix: 'ruby/matrix',
ostruct: 'ruby/ostruct',
rss: 'ruby/rss',
irb: 'ruby/irb',
tracer: 'ruby/tracer',
forwardable: "ruby/forwardable",
@ -129,7 +127,7 @@ def sync_default_gems(gem)
cp_r("#{upstream}/rdoc.gemspec", "lib/rdoc")
cp_r("#{upstream}/exe/rdoc", "libexec")
cp_r("#{upstream}/exe/ri", "libexec")
rm_rf(%w[lib/rdoc/markdown.kpeg lib/rdoc/markdown/literals.kpeg lib/rdoc/rd/block_parser.ry lib/rdoc/rd/inline_parser.ry])
rm_rf(%w[lib/rdoc/markdown.kpeg lib/rdoc/markdown/literals.kpeg lib/rdoc/rd/block_pager.ry lib/rdoc/rd/inline_parser.ry])
`git checkout lib/rdoc/.document`
when "reline"
rm_rf(%w[lib/reline* test/reline])