rss 0.2.9 → 0.3.0

data/test/test_content.rb

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

data/test/test_dublincore.rb

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

data/test/test_image.rb

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

data/test/test_inherit.rb

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