rss 0.2.9 → 0.3.0

data/test/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

data/test/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

data/test/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