rss-nokogiri 0.0.1

data/test/regression/test_content.rb

@@ -0,0 +1,104 @@
+require "cgi"
+require "rexml/document"
+
+require "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/regression/test_dublincore.rb

@@ -0,0 +1,279 @@
+require "cgi"
+require "rexml/document"
+
+require "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 do |x|
+            val = x.value
+            if val.kind_of?(String)
+              CGI.escapeHTML(val)
+            else
+              val
+            end
+          end
+          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}")
+          if parsed_value.kind_of?(String)
+            parsed_value = CGI.escapeHTML(parsed_value)
+          end
+          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}")
+          if parsed_value.kind_of?(String)
+            parsed_value = CGI.escapeHTML(parsed_value)
+          end
+          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(CGI.escapeHTML(elem.text),
+                         DC_ELEMENTS[elem.name.intern].to_s)
+          end
+        end
+      end
+    end
+  end
+end

data/test/regression/test_image.rb

@@ -0,0 +1,214 @@
+require "cgi"
+require "rexml/document"
+
+require "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