rss 0.2.8 → 0.2.9

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0661103c506f9158deefa370289f1f197422d06b500b92319e63d953d8243842
-  data.tar.gz: f855b9669a566ac469b85820a5bbe2ff6d60be14e72040096d997057c653e596
+  metadata.gz: 228e90a8417df4ef1a69fe4f26f41df3e8e8058aa8e2ff5e777d046d5ddb80ef
+  data.tar.gz: a2ebe156cafdb3f3f7b6db774d6dda4af3a06050831abd9b56eb6b347c97a4f8
 SHA512:
-  metadata.gz: cd38d5deb4396141f6e8a7e384cea8c3af86d7a54c42dc1e8f20d8447129c2e1f12a5fcb169d836353687ab16b6838999618f760b09f8d46246b17442977889e
-  data.tar.gz: 4cfaf4d6c6794344edee289fe73a0cc810e8a9ffe95c47f845f47a883c14dcb7ae64cdf6d4ce0a3e89bd1aa96ba8440958a4cb8294a78c648886d3e91e41a857
+  metadata.gz: dd0353495019535ddec0da221dca824b83edee471f93f28ec9046c3239c8fdaed9d5fa16a5942af86065957153ecd643287319b302030be680116f2b96b886d6
+  data.tar.gz: edfbad62f743b1b324b5ff8a2ed695e154684077a7045649e45200f1233768eafa6c9a2e6c9681b964a658279b5dc2f00a1f43b2a9f7487d5def5f2441bf6aa3

data/NEWS.md

@@ -1,5 +1,21 @@
 # News
 
+## 0.2.9 - 2020-02-19
+
+### Improvements
+
+  * Removed needless taint check with Ruby 2.7.
+    [GitHub#7][Patch by Jeremy Evans]
+
+  * Added support for `itunes:image` in `item` element.
+    [GitHub#11][Patch by Ian McKenzie]
+
+### Thanks
+
+  * Jeremy Evans
+
+  * Ian McKenzie
+
 ## 0.2.8 - 2019-01-24
 
 ### Improvements

data/Rakefile

@@ -1,8 +1,15 @@
 require "bundler/gem_tasks"
 
+helper = Bundler::GemHelper.new(__dir__)
+def helper.version_tag
+  version
+end
+
+helper.install
+
 desc "Run test"
 task :test do
-  ruby("run-test.rb")
+  ruby("test/run-test.rb")
 end
 
 task :default => :test

data/lib/rss/itunes.rb

@@ -258,7 +258,55 @@ module RSS
     end
 
     ELEMENT_INFOS = ITunesBaseModel::ELEMENT_INFOS +
-      [["duration", :element, "content"]]
+      [["duration", :element, "content"], ["image", :attribute, "href"]]
+
+    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 ITunesDuration < Element
       include RSS09

data/lib/rss/maker/itunes.rb

@@ -171,6 +171,18 @@ module RSS
         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 ITunesDurationBase < Base
         attr_reader :content
         add_need_initialize_variable("content")
@@ -237,6 +249,7 @@ module RSS
       class ItemBase
         include Maker::ITunesItemModel
         class ITunesDuration < ITunesDurationBase; end
+        class ITunesImage < ITunesImageBase; end
       end
     end
   end

data/lib/rss/parser.rb

@@ -120,7 +120,7 @@ module RSS
 
       if uri.respond_to?(:read)
         uri.read
-      elsif !rss.tainted? and File.readable?(rss)
+      elsif (RUBY_VERSION >= '2.7' || !rss.tainted?) and File.readable?(rss)
         File.open(rss) {|f| f.read}
       else
         rss

data/lib/rss/version.rb

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

data/rss.gemspec

@@ -1,9 +1,4 @@
-begin
-  require_relative "lib/rss/version"
-rescue LoadError
-  # for Ruby core repository
-  require_relative "version"
-end
+require_relative "lib/rss/version"
 
 Gem::Specification.new do |spec|
   spec.name          = "rss"
@@ -16,64 +11,19 @@ Gem::Specification.new do |spec|
   spec.homepage      = "https://github.com/ruby/rss"
   spec.license       = "BSD-2-Clause"
 
-  spec.files         = [
-    ".gitignore",
-    ".travis.yml",
+  spec.files = [
+    "#{spec.name}.gemspec",
     "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.files += Dir.glob("lib/**/*.rb")
+  spec.test_files += Dir.glob("test/**/*")
   spec.require_paths = ["lib"]
 
+  spec.add_dependency "rexml"
   spec.add_development_dependency "bundler"
   spec.add_development_dependency "rake"
   spec.add_development_dependency "test-unit"

data/test/rss-assertions.rb

@@ -0,0 +1,2116 @@
+# frozen_string_literal: false
+require 'erb'
+
+module RSS
+  module Assertions
+    def assert_parse(rss, assert_method, *args)
+      __send__("assert_#{assert_method}", *args) do
+        ::RSS::Parser.parse(rss)
+      end
+      __send__("assert_#{assert_method}", *args) do
+        ::RSS::Parser.parse(rss, false).validate
+      end
+    end
+
+    def assert_ns(prefix, uri)
+      _wrap_assertion do
+        begin
+          yield
+          flunk("Not raise NSError")
+        rescue ::RSS::NSError => e
+          assert_equal(prefix, e.prefix)
+          assert_equal(uri, e.uri)
+        end
+      end
+    end
+
+    def assert_missing_tag(tag, parent)
+      _wrap_assertion do
+        begin
+          yield
+          flunk("Not raise MissingTagError")
+        rescue ::RSS::MissingTagError => e
+          assert_equal(tag, e.tag)
+          assert_equal(parent, e.parent)
+        end
+      end
+    end
+
+    def assert_too_much_tag(tag, parent)
+      _wrap_assertion do
+        begin
+          yield
+          flunk("Not raise TooMuchTagError")
+        rescue ::RSS::TooMuchTagError => e
+          assert_equal(tag, e.tag)
+          assert_equal(parent, e.parent)
+        end
+      end
+    end
+
+    def assert_missing_attribute(tag, attrname)
+      _wrap_assertion do
+        begin
+          yield
+          flunk("Not raise MissingAttributeError")
+        rescue ::RSS::MissingAttributeError => e
+          assert_equal(tag, e.tag)
+          assert_equal(attrname, e.attribute)
+        end
+      end
+    end
+
+    def assert_not_expected_tag(tag, uri, parent)
+      _wrap_assertion do
+        begin
+          yield
+          flunk("Not raise NotExpectedTagError")
+        rescue ::RSS::NotExpectedTagError => e
+          assert_equal(tag, e.tag)
+          assert_equal(uri, e.uri)
+          assert_equal(parent, e.parent)
+        end
+      end
+    end
+
+    def assert_not_available_value(tag, value, attribute=nil)
+      _wrap_assertion do
+        begin
+          yield
+          flunk("Not raise NotAvailableValueError")
+        rescue ::RSS::NotAvailableValueError => e
+          assert_equal(tag, e.tag)
+          assert_equal(value, e.value)
+          assert_equal(attribute, e.attribute)
+        end
+      end
+    end
+
+    def assert_not_set_error(name, variables)
+      _wrap_assertion do
+        begin
+          yield
+          flunk("Not raise NotSetError")
+        rescue ::RSS::NotSetError => e
+          assert_equal(name, e.name)
+          assert_kind_of(Array, variables)
+          assert_equal(variables.sort, e.variables.sort)
+        end
+      end
+    end
+
+    def assert_xml_declaration(version, encoding, standalone, rss)
+      _wrap_assertion do
+        assert_equal(version, rss.version)
+        assert_equal(encoding, rss.encoding)
+        assert_equal(standalone, rss.standalone)
+      end
+    end
+
+    def assert_xml_stylesheet_attrs(attrs, xsl)
+      _wrap_assertion do
+        n_attrs = normalized_attrs(attrs)
+        ::RSS::XMLStyleSheet::ATTRIBUTES.each do |name|
+          assert_equal(n_attrs[name], xsl.__send__(name))
+        end
+      end
+    end
+
+    def assert_xml_stylesheet(target, attrs, xsl)
+      _wrap_assertion do
+        if attrs.has_key?(:href)
+          if !attrs.has_key?(:type) and attrs.has_key?(:guess_type)
+            attrs[:type] = attrs[:guess_type]
+          end
+          assert_equal("xml-stylesheet", target)
+          assert_xml_stylesheet_attrs(attrs, xsl)
+        else
+          assert_nil(target)
+          assert_equal("", xsl.to_s)
+        end
+      end
+    end
+
+    def assert_xml_stylesheet_pis(attrs_ary, rss=nil)
+      _wrap_assertion do
+        if rss.nil?
+          rss = ::RSS::RDF.new
+          setup_rss10(rss)
+        end
+        xss_strs = []
+        attrs_ary.each do |attrs|
+          xss = ::RSS::XMLStyleSheet.new(attrs)
+          xss_strs.push(xss.to_s)
+          rss.xml_stylesheets.push(xss)
+        end
+        pi_str = rss.to_s.gsub(/<\?xml .*\n/, "").gsub(/\s*<[^\?].*\z/m, "")
+        assert_equal(xss_strs.join("\n"), pi_str)
+      end
+    end
+
+    def assert_xml_stylesheets(attrs, xss)
+      _wrap_assertion do
+        xss.each_with_index do |xs, i|
+          assert_xml_stylesheet_attrs(attrs[i], xs)
+        end
+      end
+    end
+
+
+    def assert_atom_person(tag_name, generator)
+      _wrap_assertion do
+        name = "Mark Pilgrim"
+        uri = "http://example.org/"
+        email = "f8dy@example.com"
+
+        assert_parse(generator.call(<<-EOA), :missing_tag, "name", tag_name)
+  <#{tag_name}/>
+EOA
+
+        assert_parse(generator.call(<<-EOA), :missing_tag, "name", tag_name)
+  <#{tag_name}>
+    <uri>#{uri}</uri>
+    <email>#{email}</email>
+  </#{tag_name}>
+EOA
+
+        assert_parse(generator.call(<<-EOA), :nothing_raised)
+  <#{tag_name}>
+    <name>#{name}</name>
+  </#{tag_name}>
+EOA
+
+        feed = RSS::Parser.parse(generator.call(<<-EOA))
+  <#{tag_name}>
+    <name>#{name}</name>
+    <uri>#{uri}</uri>
+    <email>#{email}</email>
+  </#{tag_name}>
+EOA
+
+        person = yield(feed)
+        assert_not_nil(person)
+        assert_equal(name, person.name.content)
+        assert_equal(uri, person.uri.content)
+        assert_equal(email, person.email.content)
+      end
+    end
+
+    def assert_atom_category(generator)
+      _wrap_assertion do
+        term = "Music"
+        scheme = "http://xmlns.com/wordnet/1.6/"
+        label = "music"
+
+        missing_args = [:missing_attribute, "category", "term"]
+        assert_parse(generator.call(<<-EOA), *missing_args)
+  <category/>
+EOA
+
+        assert_parse(generator.call(<<-EOA), *missing_args)
+  <category scheme="#{scheme}" label="#{label}"/>
+EOA
+
+        assert_parse(generator.call(<<-EOA), :nothing_raised)
+  <category term="#{term}"/>
+EOA
+
+      feed = RSS::Parser.parse(generator.call(<<-EOA))
+  <category term="#{term}" scheme="#{scheme}" label="#{label}"/>
+EOA
+
+        category = yield(feed)
+        assert_not_nil(category)
+        assert_equal(term, category.term)
+        assert_equal(scheme, category.scheme)
+        assert_equal(label, category.label)
+      end
+    end
+
+    def assert_atom_link(generator)
+      _wrap_assertion do
+        href = "http://example.org/feed.atom"
+        rel = "self"
+        type = "application/atom+xml"
+        hreflang = "en"
+        title = "Atom"
+        length = "1024"
+
+        assert_parse(generator.call(<<-EOA), :missing_attribute, "link", "href")
+  <link/>
+EOA
+
+        assert_parse(generator.call(<<-EOA), :missing_attribute, "link", "href")
+  <link rel="#{rel}" type="#{type}" hreflang="#{hreflang}"
+        title="#{title}" length="#{length}"/>
+EOA
+
+        assert_parse(generator.call(<<-EOA), :nothing_raised)
+  <link href="#{href}"/>
+EOA
+
+        feed = RSS::Parser.parse(generator.call(<<-EOA))
+  <link href="#{href}" rel="#{rel}" type="#{type}" hreflang="#{hreflang}"
+        title="#{title}" length="#{length}"/>
+EOA
+
+        link = yield(feed)
+        assert_not_nil(link)
+        assert_equal(href, link.href)
+        assert_equal(rel, link.rel)
+        assert_equal(type, link.type)
+        assert_equal(hreflang, link.hreflang)
+        assert_equal(title, link.title)
+        assert_equal(length, link.length)
+
+
+        href = "http://example.org/index.html.ja"
+        parent = link.parent.tag_name
+        return if parent == "source"
+
+        optional_attributes = %w(hreflang="ja" type="text/html")
+        0.upto(optional_attributes.size) do |i|
+          combination(optional_attributes, i).each do |attributes|
+            attrs = attributes.join(" ")
+            assert_parse(generator.call(<<-EOA), :too_much_tag, "link", parent)
+  <link rel="alternate" #{attrs} href="#{href}"/>
+  <link rel="alternate" #{attrs} href="#{href}"/>
+EOA
+          end
+        end
+      end
+    end
+
+    def assert_atom_generator(generator)
+      _wrap_assertion do
+        uri = "http://www.example.com/"
+        version = "1.0"
+        content = "Example Toolkit"
+
+        assert_parse(generator.call(<<-EOA), :nothing_raised)
+  <generator/>
+EOA
+
+        assert_parse(generator.call(<<-EOA), :nothing_raised)
+  <generator uri="#{uri}" version="#{version}"/>
+EOA
+
+        feed = RSS::Parser.parse(generator.call(<<-EOA))
+  <generator uri="#{uri}" version="#{version}">#{content}</generator>
+EOA
+
+        gen = yield(feed)
+        assert_not_nil(gen)
+        assert_equal(uri, gen.uri)
+        assert_equal(version, gen.version)
+        assert_equal(content, gen.content)
+      end
+    end
+
+    def assert_atom_icon(generator)
+      _wrap_assertion do
+        content = "http://www.example.com/example.png"
+
+        assert_parse(generator.call(<<-EOA), :nothing_raised)
+  <icon/>
+EOA
+
+        feed = RSS::Parser.parse(generator.call(<<-EOA))
+  <icon>#{content}</icon>
+EOA
+
+        icon = yield(feed)
+        assert_not_nil(icon)
+        assert_equal(content, icon.content)
+      end
+    end
+
+    def assert_atom_text_construct(tag_name, generator)
+      _wrap_assertion do
+        [nil, "text", "html"].each do |type|
+          attr = ""
+          attr = " type=\"#{type}\"" if type
+          assert_parse(generator.call(<<-EOA), :nothing_raised)
+  <#{tag_name}#{attr}/>
+EOA
+        end
+
+        assert_parse(generator.call(<<-EOA), :missing_tag, "div", tag_name)
+  <#{tag_name} type="xhtml"/>
+EOA
+
+        args = ["x", Atom::URI, tag_name]
+        assert_parse(generator.call(<<-EOA), :not_expected_tag, *args)
+  <#{tag_name} type="xhtml"><x/></#{tag_name}>
+EOA
+
+        invalid_value = "invalid"
+        args = ["type", invalid_value]
+        assert_parse(generator.call(<<-EOA), :not_available_value, *args)
+  <#{tag_name} type="#{invalid_value}"/>
+EOA
+
+        [
+         [nil, "A lot of effort went into making this effortless"],
+         ["text", "A lot of effort went into making this effortless"],
+         ["html", "A <em>lot</em> of effort went into making this effortless"],
+        ].each do |type, content|
+          attr = ""
+          attr = " type=\"#{type}\"" if type
+          feed = RSS::Parser.parse(generator.call(<<-EOA))
+  <#{tag_name}#{attr}>#{h content}</#{tag_name}>
+EOA
+
+          element = yield(feed)
+          assert_not_nil(element)
+          assert_equal(type, element.type)
+          assert_equal(content, element.content)
+        end
+
+        [false, true].each do |with_space|
+          xhtml_uri = "http://www.w3.org/1999/xhtml"
+          xhtml_content = "<div xmlns=\"#{xhtml_uri}\">abc</div>"
+          xhtml_element = RSS::XML::Element.new("div", nil, xhtml_uri,
+                                                {"xmlns" => xhtml_uri},
+                                                ["abc"])
+          content = xhtml_content
+          content = "  #{content}  " if with_space
+          feed = RSS::Parser.parse(generator.call(<<-EOA))
+  <#{tag_name} type="xhtml">#{content}</#{tag_name}>
+EOA
+
+          element = yield(feed)
+          assert_not_nil(element)
+          assert_equal("xhtml", element.type)
+          assert_equal(xhtml_content, element.content)
+          assert_equal(xhtml_element, element.xhtml)
+        end
+      end
+    end
+
+    def assert_atom_date_construct(tag_name, generator)
+      _wrap_assertion do
+        args = [tag_name, ""]
+        assert_parse(generator.call(<<-EOR), :not_available_value, *args)
+  <#{tag_name}/>
+EOR
+
+        [
+         ["xxx", false],
+         ["2007", false],
+         ["2007/02/09", true],
+        ].each do |invalid_value, can_parse|
+          assert_not_available_value(tag_name, invalid_value) do
+            RSS::Parser.parse(generator.call(<<-EOR))
+  <#{tag_name}>#{invalid_value}</#{tag_name}>
+EOR
+          end
+
+          feed = RSS::Parser.parse(generator.call(<<-EOR), false)
+  <#{tag_name}>#{invalid_value}</#{tag_name}>
+EOR
+          value = yield(feed).content
+          if can_parse
+            assert_equal(Time.parse(invalid_value), value)
+          else
+            assert_nil(value)
+          end
+        end
+
+        [
+         "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 |valid_value|
+          assert_parse(generator.call(<<-EOR), :nothing_raised)
+  <#{tag_name}>#{valid_value}</#{tag_name}>
+EOR
+
+          feed = RSS::Parser.parse(generator.call(<<-EOR))
+  <#{tag_name}>#{valid_value}</#{tag_name}>
+EOR
+          assert_equal(Time.parse(valid_value), yield(feed).content)
+        end
+      end
+    end
+
+    def assert_atom_logo(generator)
+      _wrap_assertion do
+        content = "http://www.example.com/example.png"
+
+        assert_parse(generator.call(<<-EOA), :nothing_raised)
+  <logo/>
+EOA
+
+        feed = RSS::Parser.parse(generator.call(<<-EOA))
+  <logo>#{content}</logo>
+EOA
+
+        logo = yield(feed)
+        assert_not_nil(logo)
+        assert_equal(content, logo.content)
+      end
+    end
+
+    def assert_atom_content(generator, &getter)
+      _wrap_assertion do
+        assert_atom_content_inline_text(generator, &getter)
+        assert_atom_content_inline_xhtml(generator, &getter)
+        assert_atom_content_inline_other(generator, &getter)
+        assert_atom_content_out_of_line(generator, &getter)
+      end
+    end
+
+    def assert_atom_content_inline_text(generator)
+      _wrap_assertion do
+        [nil, "text", "html"].each do |type|
+          content = "<content"
+          content << " type='#{type}'" if type
+
+          suffix = "/>"
+          assert_parse(generator.call(content + suffix), :nothing_raised)
+          suffix = ">xxx</content>"
+          assert_parse(generator.call(content + suffix), :nothing_raised)
+        end
+
+        [
+         ["text", "sample content"],
+         ["text/plain", "sample content"],
+         ["html", "<em>sample</em> content"]
+        ].each do |type, content_content|
+          feed = RSS::Parser.parse(generator.call(<<-EOA))
+  <content type="#{type}">#{h content_content}</content>
+EOA
+          content = yield(feed)
+          assert_equal(type, content.type)
+          if %w(text html).include?(type)
+            assert(content.inline_text?)
+          else
+            assert(!content.inline_text?)
+          end
+          if type == "html"
+            assert(content.inline_html?)
+          else
+            assert(!content.inline_html?)
+          end
+          assert(!content.inline_xhtml?)
+          if type == "text/plain"
+            assert(content.inline_other?)
+            assert(content.inline_other_text?)
+          else
+            assert(!content.inline_other?)
+            assert(!content.inline_other_text?)
+          end
+          assert(!content.inline_other_xml?)
+          assert(!content.inline_other_base64?)
+          assert(!content.out_of_line?)
+          assert(!content.have_xml_content?)
+          assert_equal(content_content, content.content)
+        end
+      end
+    end
+
+    def assert_atom_content_inline_xhtml(generator)
+      _wrap_assertion do
+        args = ["div", "content"]
+        assert_parse(generator.call(<<-EOA), :missing_tag, *args)
+  <content type="xhtml"/>
+EOA
+
+        args = ["x", Atom::URI, "content"]
+        assert_parse(generator.call(<<-EOA), :not_expected_tag, *args)
+  <content type="xhtml"><x/></content>
+EOA
+
+        xhtml_uri = "http://www.w3.org/1999/xhtml"
+        xhtml_content = "<div xmlns=\"#{xhtml_uri}\">abc</div>"
+        xhtml_element = RSS::XML::Element.new("div", nil, xhtml_uri,
+                                              {"xmlns" => xhtml_uri},
+                                              ["abc"])
+        feed = RSS::Parser.parse(generator.call(<<-EOA))
+  <content type="xhtml">#{xhtml_content}</content>
+EOA
+
+        content = yield(feed)
+        assert_not_nil(content)
+        assert_equal("xhtml", content.type)
+        assert(!content.inline_text?)
+        assert(!content.inline_html?)
+        assert(content.inline_xhtml?)
+        assert(!content.inline_other?)
+        assert(!content.inline_other_text?)
+        assert(!content.inline_other_xml?)
+        assert(!content.inline_other_base64?)
+        assert(!content.out_of_line?)
+        assert(content.have_xml_content?)
+        assert_equal(xhtml_content, content.content)
+        assert_equal(xhtml_element, content.xhtml)
+      end
+    end
+
+    def assert_atom_content_inline_other(generator, &getter)
+      _wrap_assertion do
+        assert_atom_content_inline_other_text(generator, &getter)
+        assert_atom_content_inline_other_xml(generator, &getter)
+      end
+    end
+
+    def assert_atom_content_inline_other_text(generator)
+      _wrap_assertion do
+        type = "image/png"
+        assert_parse(generator.call(<<-EOA), :nothing_raised)
+  <content type="#{type}"/>
+EOA
+
+        png_file = File.join(File.dirname(__FILE__), "dot.png")
+        png = File.open(png_file, "rb") do |file|
+          file.read.force_encoding("binary")
+        end
+        base64_content = [png].pack("m").delete("\n")
+
+        [false, true].each do |with_space|
+          xml_content = base64_content
+          xml_content = "  #{base64_content}" if with_space
+          feed = RSS::Parser.parse(generator.call(<<-EOA))
+  <content type="#{type}">#{xml_content}</content>
+EOA
+
+          content = yield(feed)
+          assert_not_nil(content)
+          assert_equal(type, content.type)
+          assert(!content.inline_text?)
+          assert(!content.inline_html?)
+          assert(!content.inline_xhtml?)
+          assert(content.inline_other?)
+          assert(!content.inline_other_text?)
+          assert(!content.inline_other_xml?)
+          assert(content.inline_other_base64?)
+          assert(!content.out_of_line?)
+          assert(!content.have_xml_content?)
+          assert_equal(png, content.content)
+
+          xml = REXML::Document.new(content.to_s).root
+          assert_rexml_element([], {"type" => type}, base64_content, xml)
+        end
+      end
+    end
+
+    def assert_atom_content_inline_other_xml(generator)
+      _wrap_assertion do
+        type = "image/svg+xml"
+
+        assert_parse(generator.call(<<-EOA), :nothing_raised)
+  <content type="#{type}"/>
+EOA
+
+        svg_uri = "http://www.w3.org/2000/svg"
+        svg_width = "50pt"
+        svg_height = "20pt"
+        svg_version = "1.0"
+        text_x = "15"
+        text_y = "15"
+        text = "text"
+        svg_content = <<-EOS
+<svg
+   xmlns="#{svg_uri}"
+   width="#{svg_width}"
+   height="#{svg_height}"
+   version="#{svg_version}"
+><text x="#{text_x}" y="#{text_y}">#{text}</text
+></svg>
+EOS
+
+        text_element = RSS::XML::Element.new("text", nil, svg_uri,
+                                             {
+                                               "x" => text_x,
+                                               "y" => text_y,
+                                             },
+                                             [text])
+        svg_element = RSS::XML::Element.new("svg", nil, svg_uri,
+                                            {
+                                              "xmlns" => svg_uri,
+                                              "width" => svg_width,
+                                              "height" => svg_height,
+                                              "version" => svg_version,
+                                            },
+                                            [text_element])
+        feed = RSS::Parser.parse(generator.call(<<-EOA))
+  <content type="#{type}">#{svg_content}</content>
+EOA
+
+        content = yield(feed)
+        assert_not_nil(content)
+        assert_equal(type, content.type)
+        assert(!content.inline_text?)
+        assert(!content.inline_html?)
+        assert(!content.inline_xhtml?)
+        assert(content.inline_other?)
+        assert(!content.inline_other_text?)
+        assert(content.inline_other_xml?)
+        assert(!content.inline_other_base64?)
+        assert(!content.out_of_line?)
+        assert(content.have_xml_content?)
+        assert_equal(REXML::Document.new(svg_content).to_s.chomp,
+                     REXML::Document.new(content.content).to_s.chomp)
+        assert_equal(svg_element, content.xml)
+        assert_nil(content.xhtml)
+      end
+    end
+
+    def assert_atom_content_out_of_line(generator)
+      _wrap_assertion do
+        text_type = "text/plain"
+        text_src = "http://example.com/README.txt"
+
+        missing_args = [:missing_attribute, "content", "type"]
+        # RSS Parser raises error even if this is "should" not "must".
+        assert_parse(generator.call(<<-EOA), *missing_args)
+  <content src="#{text_src}"/>
+EOA
+
+        content_content = "xxx"
+        not_available_value_args = [:not_available_value,
+                                    "content", content_content]
+        assert_parse(generator.call(<<-EOA), *not_available_value_args)
+  <content type="#{text_type}" src="#{text_src}">#{content_content}</content>
+EOA
+
+        feed = RSS::Parser.parse(generator.call(<<-EOA))
+  <content type="#{text_type}" src="#{text_src}"/>
+EOA
+        content = yield(feed)
+        assert_not_nil(content)
+        assert_equal(text_type, content.type)
+        assert_equal(text_src, content.src)
+        assert(!content.inline_text?)
+        assert(!content.inline_html?)
+        assert(!content.inline_xhtml?)
+        assert(!content.inline_other?)
+        assert(!content.inline_other_text?)
+        assert(!content.inline_other_xml?)
+        assert(!content.inline_other_base64?)
+        assert(content.out_of_line?)
+        assert(!content.have_xml_content?)
+        assert_nil(content.xml)
+        assert_nil(content.xhtml)
+        assert_equal("", content.content)
+      end
+    end
+
+    def assert_atom_source(generator, &getter)
+      _wrap_assertion do
+        assert_atom_source_author(generator, &getter)
+        assert_atom_source_category(generator, &getter)
+        assert_atom_source_contributor(generator, &getter)
+        assert_atom_source_generator(generator, &getter)
+        assert_atom_source_icon(generator, &getter)
+        assert_atom_source_id(generator, &getter)
+        assert_atom_source_link(generator, &getter)
+        assert_atom_source_logo(generator, &getter)
+        assert_atom_source_rights(generator, &getter)
+        assert_atom_source_subtitle(generator, &getter)
+        assert_atom_source_title(generator, &getter)
+        assert_atom_source_updated(generator, &getter)
+      end
+    end
+
+    def assert_atom_source_author(generator)
+      assert_atom_person("author", generator) do |feed|
+        source = yield(feed)
+        assert_equal(1, source.authors.size)
+        source.author
+      end
+    end
+
+    def assert_atom_source_category(generator)
+      assert_atom_category(generator) do |feed|
+        source = yield(feed)
+        assert_equal(1, source.categories.size)
+        source.category
+      end
+    end
+
+    def assert_atom_source_contributor(generator)
+      assert_atom_person("contributor", generator) do |feed|
+        source = yield(feed)
+        assert_equal(1, source.contributors.size)
+        source.contributor
+      end
+    end
+
+    def assert_atom_source_generator(generator)
+      assert_atom_generator(generator) do |feed|
+        yield(feed).generator
+      end
+    end
+
+    def assert_atom_source_icon(generator)
+      assert_atom_icon(generator) do |feed|
+        yield(feed).icon
+      end
+    end
+
+    def assert_atom_source_id(generator)
+      id_content = "urn:uuid:a2fb588b-5674-4898-b420-265a734fea69"
+      id = "<id>#{id_content}</id>"
+      feed = RSS::Parser.parse(generator.call(id))
+      assert_equal(id_content, yield(feed).id.content)
+    end
+
+    def assert_atom_source_link(generator)
+      assert_atom_link(generator) do |feed|
+        source = yield(feed)
+        assert_equal(1, source.links.size)
+        source.link
+      end
+    end
+
+    def assert_atom_source_logo(generator)
+      assert_atom_logo(generator) do |feed|
+        yield(feed).logo
+      end
+    end
+
+    def assert_atom_source_rights(generator)
+      assert_atom_text_construct("rights", generator) do |feed|
+        yield(feed).rights
+      end
+    end
+
+    def assert_atom_source_subtitle(generator)
+      assert_atom_text_construct("subtitle", generator) do |feed|
+        yield(feed).subtitle
+      end
+    end
+
+    def assert_atom_source_title(generator)
+      assert_atom_text_construct("title", generator) do |feed|
+        yield(feed).title
+      end
+    end
+
+    def assert_atom_source_updated(generator)
+      assert_atom_date_construct("updated", generator) do |feed|
+        yield(feed).updated
+      end
+    end
+
+    def assert_dublin_core(elems, target)
+      _wrap_assertion do
+        elems.each do |name, value|
+          assert_equal(value, target.__send__("dc_#{name}"))
+        end
+      end
+    end
+
+    def assert_multiple_dublin_core(elems, target)
+      _wrap_assertion do
+        elems.each do |name, values, plural|
+          plural ||= "#{name}s"
+          actual = target.__send__("dc_#{plural}").collect{|x| x.value}
+          assert_equal(values, actual)
+        end
+      end
+    end
+
+    def assert_syndication(elems, target)
+      _wrap_assertion do
+        elems.each do |name, value|
+          meth = "sy_#{name}"
+          value = value.to_i if meth == "sy_updateFrequency"
+          assert_equal(value, target.__send__(meth ))
+        end
+      end
+    end
+
+    def assert_content(elems, target)
+      _wrap_assertion do
+        elems.each do |name, value|
+          assert_equal(value, target.__send__("content_#{name}"))
+        end
+      end
+    end
+
+    def assert_trackback(attrs, target)
+      _wrap_assertion do
+        n_attrs = normalized_attrs(attrs)
+        if n_attrs["ping"]
+          assert_equal(n_attrs["ping"], target.trackback_ping)
+        end
+        if n_attrs["abouts"]
+          n_attrs["abouts"].each_with_index do |about, i|
+            assert_equal(about, target.trackback_abouts[i].value)
+          end
+        end
+      end
+    end
+
+    def assert_taxo_topic(topics, target)
+      _wrap_assertion do
+        topics.each_with_index do |topic, i|
+          taxo_topic = target.taxo_topics[i]
+          topic.each do |name, value|
+            case name
+            when :link
+              assert_equal(value, taxo_topic.about)
+              assert_equal(value, taxo_topic.taxo_link)
+            when :topics
+              assert_equal(value, taxo_topic.taxo_topics.resources)
+            else
+              assert_equal(value, taxo_topic.__send__("dc_#{name}"))
+            end
+          end
+        end
+      end
+    end
+
+
+    def assert_attributes(attrs, names, target)
+      _wrap_assertion do
+        n_attrs = normalized_attrs(attrs)
+        names.each do |info|
+          if info.is_a?(String)
+            name = info
+            type = nil
+          else
+            name, type = info
+          end
+          value = n_attrs[name]
+          if value.is_a?(Time)
+            actual = target.__send__(name)
+            assert_instance_of(Time, actual)
+            assert_equal(value.to_i, actual.to_i)
+          elsif value
+            case type
+            when :integer
+              value = value.to_i
+            when :boolean
+              value = value == "true" if value.is_a?(String)
+            end
+            assert_equal(value, target.__send__(name))
+          end
+        end
+      end
+    end
+
+    def assert_rexml_element(children, attrs, text, element, text_type=nil)
+      _wrap_assertion do
+        if children
+          children_info = element.elements.collect {|e| [e.namespace, e.name]}
+          assert_equal(children.collect {|uri, name| [uri, name]}.sort,
+                       children_info.sort)
+        end
+        if attrs
+          assert_equal(attrs.collect {|k, v| [k, v]}.sort,
+                       element.attributes.collect {|k, v| [k, v]}.sort)
+        end
+        case text_type
+        when :time
+          assert_not_nil(element.text)
+          assert_equal(Time.parse(text).to_s, Time.parse(element.text).to_s)
+        else
+          assert_equal(text, element.text)
+        end
+      end
+    end
+
+    def _assert_maker_atom_persons(feed_type, maker_readers, feed_readers)
+      _wrap_assertion do
+        persons = []
+        feed = RSS::Maker.make("atom:#{feed_type}") do |maker|
+          yield maker
+          targets = chain_reader(maker, maker_readers)
+          targets.each do |target|
+            person = {
+              :name => target.name,
+              :uri => target.uri,
+              :email => target.email,
+            }
+            persons << person if person[:name]
+          end
+        end
+
+        actual_persons = chain_reader(feed, feed_readers) || []
+        actual_persons = actual_persons.collect do |person|
+          {
+            :name => person.name ? person.name.content : nil,
+            :uri => person.uri ? person.uri.content : nil,
+            :email => person.email ? person.email.content : nil,
+          }
+        end
+        assert_equal(persons, actual_persons)
+      end
+    end
+
+    def assert_maker_atom_persons(feed_type, maker_readers, feed_readers,
+                                  not_set_error_name=nil,
+                                  parent_not_set_error_name=nil,
+                                  parent_not_set_variable=nil)
+      _wrap_assertion do
+        not_set_error_name ||= "maker.#{maker_readers.join('.')}"
+
+        args = [feed_type, maker_readers, feed_readers]
+        if parent_not_set_error_name or parent_not_set_variable
+          assert_not_set_error(parent_not_set_error_name,
+                               parent_not_set_variable) do
+            _assert_maker_atom_persons(*args) do |maker|
+              yield maker
+            end
+          end
+        else
+          _assert_maker_atom_persons(*args) do |maker|
+            yield maker
+          end
+        end
+
+        assert_not_set_error(not_set_error_name, %w(name)) do
+          _assert_maker_atom_persons(feed_type, maker_readers,
+                                     feed_readers) do |maker|
+            yield maker
+            targets = chain_reader(maker, maker_readers)
+            targets.new_child
+          end
+        end
+
+        assert_not_set_error(not_set_error_name, %w(name)) do
+          _assert_maker_atom_persons(feed_type, maker_readers,
+                                     feed_readers) do |maker|
+            yield maker
+            targets = chain_reader(maker, maker_readers)
+            target = targets.new_child
+            target.uri = "http://example.com/~me/"
+          end
+        end
+
+        assert_not_set_error(not_set_error_name, %w(name)) do
+          _assert_maker_atom_persons(feed_type, maker_readers,
+                                     feed_readers) do |maker|
+            yield maker
+            targets = chain_reader(maker, maker_readers)
+            target = targets.new_child
+            target.email = "me@example.com"
+          end
+        end
+
+        assert_not_set_error(not_set_error_name, %w(name)) do
+          _assert_maker_atom_persons(feed_type, maker_readers,
+                                     feed_readers) do |maker|
+            yield maker
+            targets = chain_reader(maker, maker_readers)
+            target = targets.new_child
+            target.uri = "http://example.com/~me/"
+            target.email = "me@example.com"
+          end
+        end
+
+        _assert_maker_atom_persons(feed_type, maker_readers,
+                                   feed_readers) do |maker|
+          yield maker
+          targets = chain_reader(maker, maker_readers)
+          target = targets.new_child
+          target.name = "me"
+        end
+
+        _assert_maker_atom_persons(feed_type, maker_readers,
+                                   feed_readers) do |maker|
+          yield maker
+          targets = chain_reader(maker, maker_readers)
+          target = targets.new_child
+          target.name = "me"
+          target.uri = "http://example.com/~me/"
+        end
+
+        _assert_maker_atom_persons(feed_type, maker_readers,
+                                   feed_readers) do |maker|
+          yield maker
+          targets = chain_reader(maker, maker_readers)
+          target = targets.new_child
+          target.name = "me"
+          target.email = "me@example.com"
+        end
+
+        _assert_maker_atom_persons(feed_type, maker_readers,
+                                   feed_readers) do |maker|
+          yield maker
+          targets = chain_reader(maker, maker_readers)
+          target = targets.new_child
+          target.name = "me"
+          target.uri = "http://example.com/~me/"
+          target.email = "me@example.com"
+        end
+
+        _assert_maker_atom_persons(feed_type, maker_readers,
+                                   feed_readers) do |maker|
+          yield maker
+          targets = chain_reader(maker, maker_readers)
+
+          target = targets.new_child
+          target.name = "me"
+          target.uri = "http://example.com/~me/"
+          target.email = "me@example.com"
+
+          target = targets.new_child
+          target.name = "you"
+          target.uri = "http://example.com/~you/"
+          target.email = "you@example.com"
+        end
+
+        assert_not_set_error(not_set_error_name, %w(name)) do
+          _assert_maker_atom_persons(feed_type, maker_readers,
+                                     feed_readers) do |maker|
+            yield maker
+            targets = chain_reader(maker, maker_readers)
+
+            target = targets.new_child
+            target.name = "me"
+            target.uri = "http://example.com/~me/"
+            target.email = "me@example.com"
+
+            targets.new_child
+          end
+        end
+      end
+    end
+
+    def _assert_maker_atom_text_construct(feed_type, maker_readers,
+                                          feed_readers, &block)
+      maker_extractor = Proc.new do |target|
+        text = {
+          :type => target.type,
+          :content => target.content,
+          :xml_content => target.xml_content,
+        }
+        if text[:type] == "xhtml"
+          if text[:xml_content]
+            xml_content = text[:xml_content]
+            xhtml_uri = "http://www.w3.org/1999/xhtml"
+            unless xml_content.is_a?(RSS::XML::Element) and
+                ["div", xhtml_uri] == [xml_content.name, xml_content.uri]
+              children = xml_content
+              children = [children] unless children.is_a?(Array)
+              xml_content = RSS::XML::Element.new("div", nil, xhtml_uri,
+                                                  {"xmlns" => xhtml_uri},
+                                                  children)
+              text[:xml_content] = xml_content
+            end
+            text
+          else
+            nil
+          end
+        else
+          text[:content] ? text : nil
+        end
+      end
+      feed_extractor = Proc.new do |target|
+        {
+          :type => target.type,
+          :content => target.content,
+          :xml_content => target.xhtml,
+        }
+      end
+      _assert_maker_atom_element(feed_type,
+                                 maker_readers, true,
+                                 feed_readers,
+                                 maker_extractor,
+                                 feed_extractor,
+                                 &block)
+    end
+
+    def assert_maker_atom_text_construct(feed_type, maker_readers, feed_readers,
+                                         parent_not_set_error_name=nil,
+                                         parent_not_set_variable=nil,
+                                         not_set_error_name=nil)
+      _wrap_assertion do
+        not_set_error_name ||= "maker.#{maker_readers.join('.')}"
+
+        args = [feed_type, maker_readers, feed_readers]
+        if parent_not_set_error_name or parent_not_set_variable
+          assert_not_set_error(parent_not_set_error_name,
+                               parent_not_set_variable) do
+            _assert_maker_atom_text_construct(*args) do |maker|
+              yield maker
+            end
+          end
+        else
+          _assert_maker_atom_text_construct(*args) do |maker|
+            yield maker
+          end
+        end
+
+        assert_not_set_error(not_set_error_name, %w(content)) do
+          _assert_maker_atom_text_construct(*args) do |maker|
+            yield maker
+            target = chain_reader(maker, maker_readers) {|x| x}
+            target.type = "text"
+          end
+        end
+
+        assert_not_set_error(not_set_error_name, %w(content)) do
+          _assert_maker_atom_text_construct(*args) do |maker|
+            yield maker
+            target = chain_reader(maker, maker_readers) {|x| x}
+            target.type = "html"
+          end
+        end
+
+        assert_not_set_error(not_set_error_name, %w(xml_content)) do
+          _assert_maker_atom_text_construct(*args) do |maker|
+            yield maker
+            target = chain_reader(maker, maker_readers) {|x| x}
+            target.type = "xhtml"
+          end
+        end
+
+        assert_not_set_error(not_set_error_name, %w(xml_content)) do
+          _assert_maker_atom_text_construct(*args) do |maker|
+            yield maker
+            target = chain_reader(maker, maker_readers) {|x| x}
+            target.type = "xhtml"
+            target.content = "Content"
+          end
+        end
+
+        _assert_maker_atom_text_construct(*args) do |maker|
+          yield maker
+          target = chain_reader(maker, maker_readers) {|x| x}
+          target.type = "text"
+          target.content = "Content"
+        end
+
+        _assert_maker_atom_text_construct(*args) do |maker|
+          yield maker
+          target = chain_reader(maker, maker_readers) {|x| x}
+          target.type = "html"
+          target.content = "<em>Content</em>"
+        end
+
+        _assert_maker_atom_text_construct(*args) do |maker|
+          yield maker
+          target = chain_reader(maker, maker_readers) {|x| x}
+          target.type = "xhtml"
+          target.xml_content = "text only"
+        end
+
+        _assert_maker_atom_text_construct(*args) do |maker|
+          yield maker
+          target = chain_reader(maker, maker_readers) {|x| x}
+          target.type = "xhtml"
+          target.xml_content = RSS::XML::Element.new("unknown")
+        end
+      end
+    end
+
+    def _assert_maker_atom_date_construct(feed_type, maker_readers,
+                                          feed_readers, &block)
+      maker_extractor = Proc.new do |target|
+        date = {
+          :content => target,
+        }
+        date[:content] ? date : nil
+      end
+      feed_extractor = Proc.new do |target|
+        {
+          :content => target.content,
+        }
+      end
+      _assert_maker_atom_element(feed_type,
+                                 maker_readers, false,
+                                 feed_readers,
+                                 maker_extractor,
+                                 feed_extractor,
+                                 &block)
+    end
+
+    def assert_maker_atom_date_construct(feed_type, maker_readers, feed_readers,
+                                         parent_not_set_error_name=nil,
+                                         parent_not_set_variable=nil)
+      _wrap_assertion do
+        args = [feed_type, maker_readers, feed_readers]
+        if parent_not_set_error_name or parent_not_set_variable
+          assert_not_set_error(parent_not_set_error_name,
+                               parent_not_set_variable) do
+            _assert_maker_atom_date_construct(*args) do |maker|
+              yield maker
+            end
+          end
+        else
+          _assert_maker_atom_date_construct(*args) do |maker|
+            yield maker
+          end
+        end
+
+        maker_readers = maker_readers.dup
+        writer = "#{maker_readers.pop}="
+        _assert_maker_atom_date_construct(*args) do |maker|
+          yield maker
+          target = chain_reader(maker, maker_readers)
+          target.__send__(writer, Time.now)
+        end
+      end
+    end
+
+    def _assert_maker_atom_element(feed_type,
+                                   maker_readers,
+                                   maker_readers_need_block,
+                                   feed_readers,
+                                   maker_extractor,
+                                   feed_extractor)
+      _wrap_assertion do
+        element = nil
+        feed = RSS::Maker.make("atom:#{feed_type}") do |maker|
+          yield maker
+          if maker_readers_need_block
+            target = chain_reader(maker, maker_readers) {|x| x}
+          else
+            target = chain_reader(maker, maker_readers)
+          end
+          element = maker_extractor.call(target)
+        end
+
+        target = chain_reader(feed, feed_readers)
+        if target
+          actual_element = feed_extractor.call(target)
+        else
+          actual_element = nil
+        end
+        assert_equal(element, actual_element)
+      end
+    end
+
+    def _assert_maker_atom_elements(feed_type, maker_readers, feed_readers,
+                                    maker_extractor, feed_extractor,
+                                    invalid_feed_checker=nil)
+      _wrap_assertion do
+        elements = []
+        invalid_feed_exception = nil
+        feed = nil
+        begin
+          feed = RSS::Maker.make("atom:#{feed_type}") do |maker|
+            yield maker
+            targets = chain_reader(maker, maker_readers)
+            targets.each do |target|
+              element = maker_extractor.call(target)
+              elements << element if element
+            end
+            if invalid_feed_checker
+              invalid_feed_exception = invalid_feed_checker.call(targets)
+            end
+          end
+        rescue RSS::Error
+          if invalid_feed_exception.is_a?(RSS::TooMuchTagError)
+            assert_too_much_tag(invalid_feed_exception.tag,
+                                invalid_feed_exception.parent) do
+              raise
+            end
+          else
+            raise
+          end
+        end
+
+        if invalid_feed_exception.nil?
+          actual_elements = chain_reader(feed, feed_readers) || []
+          actual_elements = actual_elements.collect do |target|
+            feed_extractor.call(target)
+          end
+          assert_equal(elements, actual_elements)
+        end
+      end
+    end
+
+    def assert_maker_atom_element(feed_type, maker_readers, feed_readers,
+                                  setup_target, optional_variables,
+                                  required_variable, assert_method_name,
+                                  not_set_error_name=nil,
+                                  *additional_args)
+      _wrap_assertion do
+        not_set_error_name ||= "maker.#{maker_readers.join('.')}"
+
+        0.upto(optional_variables.size) do |i|
+          combination(optional_variables, i).each do |names|
+            have = {}
+            names.each do |name|
+              have[name.intern] = true
+            end
+            have_required_variable_too =
+              have.merge({required_variable.intern => true})
+
+            assert_not_set_error(not_set_error_name, [required_variable]) do
+              __send__(assert_method_name, feed_type, maker_readers,
+                       feed_readers, *additional_args) do |maker|
+                yield maker
+                target = chain_reader(maker, maker_readers) {|x| x}
+                setup_target.call(target, have)
+              end
+            end
+
+            __send__(assert_method_name, feed_type, maker_readers, feed_readers,
+                     *additional_args) do |maker|
+              yield maker
+              target = chain_reader(maker, maker_readers) {|x| x}
+              setup_target.call(target, have_required_variable_too)
+            end
+          end
+        end
+      end
+    end
+
+    def assert_maker_atom_elements(feed_type, maker_readers, feed_readers,
+                                   setup_target, optional_variables,
+                                   required_variable, assert_method_name,
+                                   not_set_error_name=nil,
+                                   *additional_args)
+      _wrap_assertion do
+        not_set_error_name ||= "maker.#{maker_readers.join('.')}"
+
+        0.upto(optional_variables.size) do |i|
+          combination(optional_variables, i).each do |names|
+            have = {}
+            names.each do |name|
+              have[name.intern] = true
+            end
+            have_required_variable_too =
+              have.merge({required_variable.intern => true})
+
+            assert_not_set_error(not_set_error_name, [required_variable]) do
+              __send__(assert_method_name, feed_type, maker_readers,
+                       feed_readers, *additional_args) do |maker|
+                yield maker
+                targets = chain_reader(maker, maker_readers)
+                setup_target.call(targets, have)
+              end
+            end
+
+            __send__(assert_method_name, feed_type, maker_readers, feed_readers,
+                     *additional_args) do |maker|
+              yield maker
+              targets = chain_reader(maker, maker_readers)
+              setup_target.call(targets, have_required_variable_too)
+            end
+
+            __send__(assert_method_name, feed_type, maker_readers, feed_readers,
+                     *additional_args) do |maker|
+              yield maker
+              targets = chain_reader(maker, maker_readers)
+              setup_target.call(targets, have_required_variable_too)
+              setup_target.call(targets, have_required_variable_too)
+            end
+
+            assert_not_set_error(not_set_error_name, [required_variable]) do
+            __send__(assert_method_name, feed_type, maker_readers, feed_readers,
+                     *additional_args) do |maker|
+                yield maker
+                targets = chain_reader(maker, maker_readers)
+                setup_target.call(targets, have_required_variable_too)
+                setup_target.call(targets, have)
+              end
+            end
+          end
+        end
+      end
+    end
+
+    def _assert_maker_atom_categories(feed_type, maker_readers,
+                                      feed_readers, &block)
+      maker_extractor = Proc.new do |target|
+        category = {
+          :term => target.term,
+          :scheme => target.scheme,
+          :label => target.label,
+        }
+        category[:term] ? category : nil
+      end
+      feed_extractor = Proc.new do |target|
+        {
+          :term => target.term,
+          :scheme => target.scheme,
+          :label => target.label,
+        }
+      end
+      _assert_maker_atom_elements(feed_type, maker_readers, feed_readers,
+                                  maker_extractor, feed_extractor, &block)
+    end
+
+    def assert_maker_atom_categories(feed_type, maker_readers, feed_readers,
+                                     not_set_error_name=nil, &block)
+      _wrap_assertion do
+        _assert_maker_atom_categories(feed_type, maker_readers,
+                                      feed_readers) do |maker|
+          yield maker
+        end
+
+        setup_target = Proc.new do |targets, have|
+          target = targets.new_child
+          target.term = "music" if have[:term]
+          target.scheme = "http://example.com/category/music" if have[:scheme]
+          target.label = "Music" if have[:label]
+        end
+
+        optional_variables = %w(scheme label)
+
+        assert_maker_atom_elements(feed_type, maker_readers, feed_readers,
+                                   setup_target, optional_variables,
+                                   "term", :_assert_maker_atom_categories,
+                                   not_set_error_name, &block)
+      end
+    end
+
+    def _assert_maker_atom_generator(feed_type, maker_readers,
+                                     feed_readers, &block)
+      maker_extractor = Proc.new do |target|
+        generator = {
+          :uri => target.uri,
+          :version => target.version,
+          :content => target.content,
+        }
+        generator[:content] ? generator : nil
+      end
+      feed_extractor = Proc.new do |target|
+        {
+          :uri => target.uri,
+          :version => target.version,
+          :content => target.content,
+        }
+      end
+      _assert_maker_atom_element(feed_type,
+                                 maker_readers, true,
+                                 feed_readers,
+                                 maker_extractor,
+                                 feed_extractor,
+                                 &block)
+    end
+
+    def assert_maker_atom_generator(feed_type, maker_readers, feed_readers,
+                                    not_set_error_name=nil, &block)
+      _wrap_assertion do
+        not_set_error_name ||= "maker.#{maker_readers.join('.')}"
+
+        _assert_maker_atom_generator(feed_type, maker_readers,
+                                     feed_readers) do |maker|
+          yield maker
+        end
+
+        setup_target = Proc.new do |target, have|
+          target.content = "RSS Maker" if have[:content]
+          target.uri = "http://example.com/rss/maker" if have[:uri]
+          target.version = "0.0.1" if have[:version]
+        end
+
+        optional_variables = %w(uri version)
+
+        assert_maker_atom_element(feed_type, maker_readers, feed_readers,
+                                  setup_target, optional_variables,
+                                  "content", :_assert_maker_atom_generator,
+                                  not_set_error_name, &block)
+      end
+    end
+
+    def _assert_maker_atom_icon(feed_type, maker_readers, feed_readers,
+                                accessor_base, &block)
+      maker_extractor = Proc.new do |target|
+        icon = {
+          :content => target.__send__(accessor_base),
+        }
+        icon[:content] ? icon : nil
+      end
+      feed_extractor = Proc.new do |target|
+        {
+          :content => target.content,
+        }
+      end
+      _assert_maker_atom_element(feed_type,
+                                 maker_readers, true,
+                                 feed_readers,
+                                 maker_extractor,
+                                 feed_extractor,
+                                 &block)
+    end
+
+    def assert_maker_atom_icon(feed_type, maker_readers, feed_readers,
+                               accessor_base=nil, not_set_error_name=nil)
+      _wrap_assertion do
+        accessor_base ||= "url"
+        not_set_error_name ||= "maker.#{maker_readers.join('.')}"
+
+        _assert_maker_atom_icon(feed_type, maker_readers, feed_readers,
+                                accessor_base) do |maker|
+          yield maker
+        end
+
+        _assert_maker_atom_icon(feed_type, maker_readers, feed_readers,
+                                accessor_base) do |maker|
+          yield maker
+          target = chain_reader(maker, maker_readers)
+          target.__send__("#{accessor_base}=", "http://example.com/icon.png")
+        end
+      end
+    end
+
+    def _assert_maker_atom_links(feed_type, maker_readers, feed_readers,
+                                 allow_duplication=false, &block)
+      maker_extractor = Proc.new do |target|
+        link = {
+          :href => target.href,
+          :rel => target.rel,
+          :type => target.type,
+          :hreflang => target.hreflang,
+          :title => target.title,
+          :length => target.length,
+        }
+        link[:href] ? link : nil
+      end
+      feed_extractor = Proc.new do |target|
+        {
+          :href => target.href,
+          :rel => target.rel,
+          :type => target.type,
+          :hreflang => target.hreflang,
+          :title => target.title,
+          :length => target.length,
+        }
+      end
+
+      if feed_readers.first == "entries"
+        parent = "entry"
+      else
+        parent = feed_type
+      end
+      invalid_feed_checker = Proc.new do |targets|
+        infos = {}
+        invalid_exception = nil
+        targets.each do |target|
+          key = [target.hreflang, target.type]
+          if infos.has_key?(key)
+            invalid_exception = RSS::TooMuchTagError.new("link", parent)
+            break
+          end
+          infos[key] = true if target.rel.nil? or target.rel == "alternate"
+        end
+        invalid_exception
+      end
+      invalid_feed_checker = nil if allow_duplication
+      _assert_maker_atom_elements(feed_type, maker_readers, feed_readers,
+                                  maker_extractor, feed_extractor,
+                                  invalid_feed_checker,
+                                  &block)
+    end
+
+    def assert_maker_atom_links(feed_type, maker_readers, feed_readers,
+                                not_set_error_name=nil, allow_duplication=false,
+                                &block)
+      _wrap_assertion do
+        _assert_maker_atom_links(feed_type, maker_readers,
+                                 feed_readers) do |maker|
+          yield maker
+        end
+
+        langs = %(ja en fr zh po)
+        setup_target = Proc.new do |targets, have|
+          target = targets.new_child
+          lang = langs[targets.size % langs.size]
+          target.href = "http://example.com/index.html.#{lang}" if have[:href]
+          target.rel = "alternate" if have[:rel]
+          target.type = "text/xhtml" if have[:type]
+          target.hreflang = lang if have[:hreflang]
+          target.title = "FrontPage(#{lang})" if have[:title]
+          target.length = 1024 if have[:length]
+        end
+
+        optional_variables = %w(rel type hreflang title length)
+
+        assert_maker_atom_elements(feed_type, maker_readers, feed_readers,
+                                   setup_target, optional_variables,
+                                   "href", :_assert_maker_atom_links,
+                                   not_set_error_name, allow_duplication,
+                                   &block)
+      end
+    end
+
+    def _assert_maker_atom_logo(feed_type, maker_readers, feed_readers,
+                                accessor_base, &block)
+      maker_extractor = Proc.new do |target|
+        logo = {
+          :uri => target.__send__(accessor_base),
+        }
+        logo[:uri] ? logo : nil
+      end
+      feed_extractor = Proc.new do |target|
+        {
+          :uri => target.content,
+        }
+      end
+      _assert_maker_atom_element(feed_type,
+                                 maker_readers, true,
+                                 feed_readers,
+                                 maker_extractor,
+                                 feed_extractor,
+                                 &block)
+    end
+
+    def assert_maker_atom_logo(feed_type, maker_readers, feed_readers,
+                               accessor_base=nil, not_set_error_name=nil)
+      _wrap_assertion do
+        accessor_base ||= "uri"
+        not_set_error_name ||= "maker.#{maker_readers.join('.')}"
+
+        _assert_maker_atom_logo(feed_type, maker_readers, feed_readers,
+                                accessor_base) do |maker|
+          yield maker
+        end
+
+        _assert_maker_atom_logo(feed_type, maker_readers, feed_readers,
+                                accessor_base) do |maker|
+          yield maker
+          target = chain_reader(maker, maker_readers)
+          target.__send__("#{accessor_base}=", "http://example.com/logo.png")
+        end
+      end
+    end
+
+    def _assert_maker_atom_id(feed_type, maker_readers, feed_readers, &block)
+      maker_extractor = Proc.new do |target|
+        id = {
+          :uri => target.id,
+        }
+        id[:uri] ? id : nil
+      end
+      feed_extractor = Proc.new do |target|
+        if target.id
+          {
+            :uri => target.id.content,
+          }
+        else
+          nil
+        end
+      end
+      _assert_maker_atom_element(feed_type,
+                                 maker_readers, true,
+                                 feed_readers,
+                                 maker_extractor,
+                                 feed_extractor,
+                                 &block)
+    end
+
+    def assert_maker_atom_id(feed_type, maker_readers, feed_readers,
+                             not_set_error_name=nil)
+      _wrap_assertion do
+        not_set_error_name ||= "maker.#{maker_readers.join('.')}"
+
+        args = [feed_type, maker_readers, feed_readers]
+        _assert_maker_atom_id(*args) do |maker|
+          yield maker
+        end
+
+        _assert_maker_atom_id(*args) do |maker|
+          yield maker
+          target = chain_reader(maker, maker_readers)
+          target.id = "http://example.com/id/1"
+        end
+      end
+    end
+
+    def _assert_maker_atom_content(feed_type, maker_readers,
+                                   feed_readers, &block)
+      maker_extractor = Proc.new do |target|
+        content = {
+          :type => target.type,
+          :src => target.src,
+          :content => target.content,
+          :xml => target.xml,
+          :inline_text => target.inline_text?,
+          :inline_html => target.inline_html?,
+          :inline_xhtml => target.inline_xhtml?,
+          :inline_other => target.inline_other?,
+          :inline_other_text => target.inline_other_text?,
+          :inline_other_xml => target.inline_other_xml?,
+          :inline_other_base64 => target.inline_other_base64?,
+          :out_of_line => target.out_of_line?,
+        }
+        content[:src] = nil if content[:src] and content[:content]
+        if content[:type] or content[:content]
+          content
+        else
+          nil
+        end
+      end
+      feed_extractor = Proc.new do |target|
+        {
+          :type => target.type,
+          :src => target.src,
+          :content => target.content,
+          :xml => target.xml,
+          :inline_text => target.inline_text?,
+          :inline_html => target.inline_html?,
+          :inline_xhtml => target.inline_xhtml?,
+          :inline_other => target.inline_other?,
+          :inline_other_text => target.inline_other_text?,
+          :inline_other_xml => target.inline_other_xml?,
+          :inline_other_base64 => target.inline_other_base64?,
+          :out_of_line => target.out_of_line?,
+        }
+      end
+      _assert_maker_atom_element(feed_type,
+                                 maker_readers, true,
+                                 feed_readers,
+                                 maker_extractor,
+                                 feed_extractor,
+                                 &block)
+    end
+
+    def assert_maker_atom_content(feed_type, maker_readers, feed_readers,
+                                  not_set_error_name=nil, &block)
+      _wrap_assertion do
+        not_set_error_name ||= "maker.#{maker_readers.join('.')}"
+        args = [feed_type, maker_readers, feed_readers, not_set_error_name]
+        assert_maker_atom_content_inline_text(*args, &block)
+        assert_maker_atom_content_inline_xhtml(*args, &block)
+        assert_maker_atom_content_inline_other(*args, &block)
+        assert_maker_atom_content_out_of_line(*args, &block)
+      end
+    end
+
+    def assert_maker_atom_content_inline_text(feed_type, maker_readers,
+                                              feed_readers, not_set_error_name)
+      _wrap_assertion do
+        args = [feed_type, maker_readers, feed_readers]
+        _assert_maker_atom_content(*args) do |maker|
+          yield maker
+        end
+
+        assert_not_set_error(not_set_error_name, %w(content)) do
+          RSS::Maker.make("atom:#{feed_type}") do |maker|
+            yield maker
+            target = chain_reader(maker, maker_readers)
+            target.type = "text"
+          end
+        end
+
+        assert_not_set_error(not_set_error_name, %w(content)) do
+          RSS::Maker.make("atom:#{feed_type}") do |maker|
+            yield maker
+            target = chain_reader(maker, maker_readers)
+            target.type = "html"
+          end
+        end
+
+        _assert_maker_atom_content(*args) do |maker|
+          yield maker
+          target = chain_reader(maker, maker_readers)
+          target.content = ""
+        end
+
+        _assert_maker_atom_content(*args) do |maker|
+          yield maker
+          target = chain_reader(maker, maker_readers)
+          target.type = "text"
+          target.content = "example content"
+        end
+
+        _assert_maker_atom_content(*args) do |maker|
+          yield maker
+          target = chain_reader(maker, maker_readers)
+          target.type = "html"
+          target.content = "<em>text</em>"
+        end
+      end
+    end
+
+    def assert_maker_atom_content_inline_xhtml(feed_type, maker_readers,
+                                               feed_readers, not_set_error_name)
+      _wrap_assertion do
+        args = [feed_type, maker_readers, feed_readers]
+        assert_not_set_error(not_set_error_name, %w(xml_content)) do
+          RSS::Maker.make("atom:#{feed_type}") do |maker|
+            yield maker
+            target = chain_reader(maker, maker_readers)
+            target.type = "xhtml"
+          end
+        end
+
+        assert_not_set_error(not_set_error_name, %w(xml_content)) do
+          RSS::Maker.make("atom:#{feed_type}") do |maker|
+            yield maker
+            target = chain_reader(maker, maker_readers)
+            target.type = "xhtml"
+            target.content = "dummy"
+          end
+        end
+
+        _assert_maker_atom_content(*args) do |maker|
+          yield maker
+          target = chain_reader(maker, maker_readers)
+          target.type = "xhtml"
+          target.xml_content = "text"
+        end
+
+        _assert_maker_atom_content(*args) do |maker|
+          yield maker
+          target = chain_reader(maker, maker_readers)
+          target.type = "xhtml"
+          target.xml = "text"
+        end
+
+        _assert_maker_atom_content(*args) do |maker|
+          yield maker
+          target = chain_reader(maker, maker_readers)
+          target.type = "xhtml"
+          target.xml_content =
+            RSS::XML::Element.new("em", nil, nil, {}, ["text"])
+        end
+
+        _assert_maker_atom_content(*args) do |maker|
+          yield maker
+          target = chain_reader(maker, maker_readers)
+          target.type = "xhtml"
+          target.xml = RSS::XML::Element.new("em", nil, nil, {}, ["text"])
+        end
+
+
+        xhtml_uri = "http://www.w3.org/1999/xhtml"
+        em = RSS::XML::Element.new("em", nil, nil, {}, ["text"])
+        em_with_xhtml_uri =
+          RSS::XML::Element.new("em", nil, xhtml_uri, {}, ["text"])
+        feed = RSS::Maker.make("atom:#{feed_type}") do |maker|
+          yield maker
+          target = chain_reader(maker, maker_readers)
+          target.type = "xhtml"
+          target.xml = em
+        end
+        assert_equal(RSS::XML::Element.new("div", nil, xhtml_uri,
+                                           {"xmlns" => xhtml_uri},
+                                           [em_with_xhtml_uri]),
+                     chain_reader(feed, feed_readers).xml)
+
+        div = RSS::XML::Element.new("div", nil, xhtml_uri,
+                                    {"xmlns" => xhtml_uri,
+                                     "class" => "sample"},
+                                    ["text"])
+        feed = RSS::Maker.make("atom:#{feed_type}") do |maker|
+          yield maker
+          target = chain_reader(maker, maker_readers)
+          target.type = "xhtml"
+          target.xml = div
+        end
+        assert_equal(div, chain_reader(feed, feed_readers).xml)
+      end
+    end
+
+    def assert_maker_atom_content_inline_other(*args, &block)
+      _wrap_assertion do
+        assert_maker_atom_content_inline_other_xml(*args, &block)
+        assert_maker_atom_content_inline_other_text(*args, &block)
+        assert_maker_atom_content_inline_other_base64(*args, &block)
+      end
+    end
+
+    def assert_maker_atom_content_inline_other_xml(feed_type, maker_readers,
+                                                   feed_readers,
+                                                   not_set_error_name)
+      _wrap_assertion do
+        args = [feed_type, maker_readers, feed_readers]
+        assert_not_set_error(not_set_error_name, %w(xml_content)) do
+          RSS::Maker.make("atom:#{feed_type}") do |maker|
+            yield maker
+            target = chain_reader(maker, maker_readers)
+            target.type = "application/xml"
+          end
+        end
+
+        assert_not_set_error(not_set_error_name, %w(xml_content)) do
+          RSS::Maker.make("atom:#{feed_type}") do |maker|
+            yield maker
+            target = chain_reader(maker, maker_readers)
+            target.type = "svg/image+xml"
+          end
+        end
+
+        svg_uri = "http://www.w3.org/2000/svg"
+        rect = RSS::XML::Element.new("rect", nil, svg_uri,
+                                     {"x" => "0.5cm",
+                                      "y" => "0.5cm",
+                                      "width" => "2cm",
+                                      "height" => "1cm"})
+        svg = RSS::XML::Element.new("svg", nil, svg_uri,
+                                    {"xmlns" => svg_uri,
+                                     "version" => "1.1",
+                                     "width" => "5cm",
+                                     "height" => "4cm"},
+                                    [rect])
+        _assert_maker_atom_content(*args) do |maker|
+          yield maker
+          target = chain_reader(maker, maker_readers)
+          target.type = "image/svg+xml"
+          target.xml = svg
+        end
+
+        feed = RSS::Maker.make("atom:#{feed_type}") do |maker|
+          yield maker
+          target = chain_reader(maker, maker_readers)
+          target.type = "image/svg+xml"
+          target.xml = svg
+        end
+        assert_equal(svg, chain_reader(feed, feed_readers).xml)
+      end
+    end
+
+    def assert_maker_atom_content_inline_other_text(feed_type, maker_readers,
+                                                    feed_readers,
+                                                    not_set_error_name)
+      _wrap_assertion do
+        args = [feed_type, maker_readers, feed_readers]
+        assert_not_set_error(not_set_error_name, %w(content)) do
+          RSS::Maker.make("atom:#{feed_type}") do |maker|
+            yield maker
+            target = chain_reader(maker, maker_readers)
+            target.type = "text/plain"
+          end
+        end
+
+        _assert_maker_atom_content(*args) do |maker|
+          yield maker
+          target = chain_reader(maker, maker_readers)
+          target.type = "text/plain"
+          target.content = "text"
+        end
+      end
+    end
+
+    def assert_maker_atom_content_inline_other_base64(feed_type, maker_readers,
+                                                      feed_readers,
+                                                      not_set_error_name)
+      _wrap_assertion do
+        args = [feed_type, maker_readers, feed_readers]
+        content = "\211PNG\r\n\032\n"
+        _assert_maker_atom_content(*args) do |maker|
+          yield maker
+          target = chain_reader(maker, maker_readers)
+          target.type = "image/png"
+          target.content = content
+        end
+
+        _assert_maker_atom_content(*args) do |maker|
+          yield maker
+          target = chain_reader(maker, maker_readers)
+          target.type = "image/png"
+          target.src = "http://example.com/logo.png"
+          target.content = content
+        end
+
+        feed = RSS::Maker.make("atom:#{feed_type}") do |maker|
+          yield maker
+          target = chain_reader(maker, maker_readers)
+          target.type = "image/png"
+          target.src = "http://example.com/logo.png"
+          target.content = content
+        end
+        target = chain_reader(feed, feed_readers)
+        assert_nil(target.src)
+        assert_equal(content, target.content)
+      end
+    end
+
+    def assert_maker_atom_content_out_of_line(feed_type, maker_readers,
+                                              feed_readers, not_set_error_name)
+      _wrap_assertion do
+        args = [feed_type, maker_readers, feed_readers]
+        assert_not_set_error(not_set_error_name, %w(content)) do
+          RSS::Maker.make("atom:#{feed_type}") do |maker|
+            yield maker
+            target = chain_reader(maker, maker_readers)
+            target.type = "image/png"
+          end
+        end
+
+        assert_not_set_error(not_set_error_name, %w(type)) do
+          RSS::Maker.make("atom:#{feed_type}") do |maker|
+            yield maker
+            target = chain_reader(maker, maker_readers)
+            target.src = "http://example.com/logo.png"
+          end
+        end
+
+        _assert_maker_atom_content(*args) do |maker|
+          yield maker
+          target = chain_reader(maker, maker_readers)
+          target.type = "image/png"
+          target.src = "http://example.com/logo.png"
+        end
+
+        _assert_maker_atom_content(*args) do |maker|
+          yield maker
+          target = chain_reader(maker, maker_readers)
+          target.type = "image/png"
+          target.content = "\211PNG\r\n\032\n"
+        end
+
+        _assert_maker_atom_content(*args) do |maker|
+          yield maker
+          target = chain_reader(maker, maker_readers)
+          target.type = "application/xml"
+          target.src = "http://example.com/sample.xml"
+        end
+
+
+        _assert_maker_atom_content(*args) do |maker|
+          yield maker
+          target = chain_reader(maker, maker_readers)
+          target.type = "text/plain"
+          target.src = "http://example.com/README.txt"
+        end
+      end
+    end
+
+    def assert_slash_elements(expected, target)
+      assert_equal(expected,
+                   {
+                     "section" => target.slash_section,
+                     "department" => target.slash_department,
+                     "comments" => target.slash_comments,
+                     "hit_parades" => target.slash_hit_parades,
+                   })
+      assert_equal(expected["hit_parades"].join(","),
+                   target.slash_hit_parade)
+    end
+
+    def chain_reader(target, readers, &block)
+      readers.inject(target) do |result, reader|
+        return nil if result.nil?
+        result.__send__(reader, &block)
+      end
+    end
+
+    def normalized_attrs(attrs)
+      n_attrs = {}
+      attrs.each do |name, value|
+        n_attrs[name.to_s] = value
+      end
+      n_attrs
+    end
+
+    def combination(elements, n)
+      if n <= 0 or elements.size < n
+        []
+      elsif n == 1
+        elements.collect {|element| [element]}
+      else
+        first, *rest = elements
+        combination(rest, n - 1).collect do |sub_elements|
+          [first, *sub_elements]
+        end + combination(rest, n)
+      end
+    end
+
+    def tag(name, content=nil, attributes={})
+      attributes = attributes.collect do |key, value|
+        "#{ERB::Util.h(key)}=\"#{ERB::Util.h(value)}\""
+      end.join(" ")
+      begin_tag = "<#{name}"
+      begin_tag << " #{attributes}" unless attributes.empty?
+      if content
+        "#{begin_tag}>#{content}</#{name}>\n"
+      else
+        "#{begin_tag}/>\n"
+      end
+    end
+  end
+end