This commit was manufactured by cvs2svn to create branch 'ruby_1_8'.

git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/branches/ruby_1_8@9670 b2dd03c8-39d4-4d8f-98ff-823fe69b080e

5 files changed, 1048 insertions, 0 deletions

diff --git a/ext/tk/sample/scrollframe.rb b/ext/tk/sample/scrollframe.rb
new file mode 100644
index 0000000000..b0ac6d3874
--- /dev/null
+++ b/ext/tk/sample/scrollframe.rb
@@ -0,0 +1,237 @@
+#
+#  Tk::ScrollFrame class
+#
+#    This widget class is a frame widget with scrollbars.
+#    The ScrollFrame doesn't propagate the size of embedded widgets.
+#    When it is configured, scrollregion of the container is changed.
+#
+#    Scrollbars can be toggled by Tk::ScrollFrame#vscroll & hscroll.
+#    If horizontal or virtical scrollbar is turned off, the horizontal 
+#    or virtical size of embedded widgets is propagated.
+#
+#                         Hidetoshi NAGAI (nagai@ai.kyutech.ac.jp)
+#
+require 'tk'
+
+class Tk::ScrollFrame < TkFrame
+  include TkComposite
+
+  DEFAULT_WIDTH  = 200
+  DEFAULT_HEIGHT = 200
+
+  def initialize_composite(keys={})
+    @frame.configure(:width=>DEFAULT_WIDTH, :height=>DEFAULT_HEIGHT)
+
+    # create scrollbars
+    @h_scroll = TkScrollbar.new(@frame, 'orient'=>'horizontal')
+    @v_scroll = TkScrollbar.new(@frame, 'orient'=>'vertical')
+
+    # create a canvas widget
+    @canvas = TkCanvas.new(@frame, 
+                           :borderwidth=>0, :selectborderwidth=>0, 
+                           :highlightthickness=>0)
+
+    # allignment
+    TkGrid.rowconfigure(@frame, 0, 'weight'=>1, 'minsize'=>0)
+    TkGrid.columnconfigure(@frame, 0, 'weight'=>1, 'minsize'=>0)
+    @canvas.grid('row'=>0, 'column'=>0, 'sticky'=>'news')
+    @frame.grid_propagate(false)
+
+    # assign scrollbars
+    @canvas.xscrollbar(@h_scroll)
+    @canvas.yscrollbar(@v_scroll)
+
+    # convert hash keys
+    keys = _symbolkey2str(keys)
+
+    # check options for the frame
+    framekeys = {}
+    if keys.key?('classname')
+       keys['class'] = keys.delete('classname')
+    end
+    if @classname = keys.delete('class')
+      framekeys['class'] = @classname
+    end
+    if @colormap  = keys.delete('colormap')
+      framekeys['colormap'] = @colormap
+    end
+    if @container = keys.delete('container')
+      framekeys['container'] = @container
+    end
+    if @visual    = keys.delete('visual')
+      framekeys['visual'] = @visual
+    end
+    if @classname.kind_of? TkBindTag
+      @db_class = @classname
+      @classname = @classname.id
+    elsif @classname
+      @db_class = TkDatabaseClass.new(@classname)
+    else
+      @db_class = self.class
+      @classname = @db_class::WidgetClassName
+    end
+
+    # create base frame
+    @base = TkFrame.new(@canvas, framekeys)
+
+    # embed base frame
+    @cwin = TkcWindow.new(@canvas, [0, 0], :window=>@base, :anchor=>'nw')
+    @canvas.scrollregion(@cwin.bbox)
+
+    # binding to reset scrollregion
+    @base.bind('Configure'){ _reset_scrollregion(nil, nil) }
+
+    # set default receiver of method calls
+    @path = @base.path
+
+    # scrollbars ON
+    vscroll(keys.delete('vscroll'){true})
+    hscroll(keys.delete('hscroll'){true})
+
+    # please check the differences of the following definitions
+    option_methods(
+      :scrollbarwidth
+    )
+
+    # set receiver widgets for configure methods (with alias)
+    delegate_alias('scrollbarrelief', 'relief', @h_scroll, @v_scroll)
+
+    # set receiver widgets for configure methods
+    delegate('DEFAULT', @base)
+    delegate('background', @frame, @base, @canvas, @h_scroll, @v_scroll)
+    delegate('width', @frame)
+    delegate('height', @frame)
+    delegate('activebackground', @h_scroll, @v_scroll)
+    delegate('troughcolor', @h_scroll, @v_scroll)
+    delegate('repeatdelay', @h_scroll, @v_scroll)
+    delegate('repeatinterval', @h_scroll, @v_scroll)
+    delegate('borderwidth', @frame)
+    delegate('relief', @frame)
+
+    # do configure
+    configure keys unless keys.empty?
+  end
+
+  # callback for Configure event
+  def _reset_scrollregion(h_mod=nil, v_mod=nil)
+    cx1, cy1, cx2, cy2 = @canvas.scrollregion
+    x1, y1, x2, y2 = @cwin.bbox
+    @canvas.scrollregion([x1, y1, x2, y2])
+
+    if h_mod.nil? && v_mod.nil?
+      if x2 != cx2 && TkGrid.info(@h_scroll).size == 0
+        @frame.grid_propagate(true)
+        @canvas.width  = x2
+        Tk.update_idletasks
+        @frame.grid_propagate(false)
+      end
+      if y2 != cy2 && TkGrid.info(@v_scroll).size == 0
+        @frame.grid_propagate(true)
+        @canvas.height = y2
+        Tk.update_idletasks
+        @frame.grid_propagate(false)
+      end
+    else
+      @h_scroll.ungrid if h_mod == false
+      @v_scroll.ungrid if v_mod == false
+
+      h_flag = (TkGrid.info(@h_scroll).size == 0)
+      v_flag = (TkGrid.info(@v_scroll).size == 0)
+
+      @frame.grid_propagate(true)
+
+      @canvas.width  = (h_flag)? x2: @canvas.winfo_width
+      @canvas.height = (v_flag)? y2: @canvas.winfo_height
+
+      @h_scroll.grid('row'=>1, 'column'=>0, 'sticky'=>'ew') if h_mod
+      @v_scroll.grid('row'=>0, 'column'=>1, 'sticky'=>'ns') if v_mod
+
+      Tk.update_idletasks
+
+      @frame.grid_propagate(false)
+    end
+  end
+  private :_reset_scrollregion
+
+  # forbid to change binding of @base frame
+  def bind(*args)
+    @frame.bind(*args)
+  end
+  def bind_append(*args)
+    @frame.bind_append(*args)
+  end
+  def bind_remove(*args)
+    @frame.bind_remove(*args)
+  end
+  def bindinfo(*args)
+    @frame.bindinfo(*args)
+  end
+
+  # set width of scrollbar
+  def scrollbarwidth(width = nil)
+    if width
+      @h_scroll.width(width)
+      @v_scroll.width(width)
+    else
+      @h_scroll.width
+    end
+  end
+
+  # vertical scrollbar : ON/OFF
+  def vscroll(mode)
+    Tk.update_idletasks
+    st = TkGrid.info(@v_scroll)
+    if mode && st.size == 0 then
+      @v_scroll.grid('row'=>0, 'column'=>1, 'sticky'=>'ns')
+      _reset_scrollregion(nil, true)
+    elsif !mode && st.size != 0 then
+      _reset_scrollregion(nil, false)
+    else
+      _reset_scrollregion(nil, nil)
+    end
+    self
+  end
+
+  # horizontal scrollbar : ON/OFF
+  def hscroll(mode)
+    Tk.update_idletasks
+    st = TkGrid.info(@h_scroll)
+    if mode && st.size == 0 then
+      _reset_scrollregion(true, nil)
+    elsif !mode && st.size != 0 then
+      _reset_scrollregion(false, nil)
+    else
+      _reset_scrollregion(nil, nil)
+    end
+    self
+  end
+end
+
+# test
+if __FILE__ == $0
+  f = Tk::ScrollFrame.new(:scrollbarwidth=>10, :width=>300, :height=>200)
+  f.pack(:expand=>true, :fill=>:both)
+
+  TkButton.new(f, :text=>'foo button', :command=>proc{puts 'foo'}).pack
+  TkButton.new(f, :text=>'baaar button', :command=>proc{puts 'baaar'}).pack
+  TkButton.new(f, :text=>'baz button', :command=>proc{puts 'baz'}).pack
+  TkButton.new(f, :text=>'hoge hoge button', 
+               :command=>proc{puts 'hoge hoge'}).pack(:side=>:bottom)
+
+  # f.hscroll(false)
+
+  Tk.after(3000){
+    t = TkText.new(f).pack(:expand=>true, :fill=>:both)
+    t.insert(:end, 'Here is a text widget')
+  }
+
+  Tk.after(6000){ f.vscroll(false) }
+
+  Tk.after(9000){ f.vscroll(true) }
+
+  Tk.after(12000){ f.hscroll(false) }
+
+  Tk.after(15000){ f.hscroll(true) }
+
+  Tk.mainloop
+end
diff --git a/lib/rss/maker/taxonomy.rb b/lib/rss/maker/taxonomy.rb
new file mode 100644
index 0000000000..2e54ea66eb
--- /dev/null
+++ b/lib/rss/maker/taxonomy.rb
@@ -0,0 +1,178 @@
+require 'rss/taxonomy'
+require 'rss/maker/1.0'
+require 'rss/maker/dublincore'
+
+module RSS
+  module Maker
+    module TaxonomyTopicsModel
+      def self.append_features(klass)
+        super
+
+        klass.add_need_initialize_variable("taxo_topics", "make_taxo_topics")
+        klass.add_other_element("taxo_topics")
+        klass.module_eval(<<-EOC, __FILE__, __LINE__ + 1)
+          attr_reader :taxo_topics
+          def make_taxo_topics
+            self.class::TaxonomyTopics.new(@maker)
+          end
+            
+          def setup_taxo_topics(rss, current)
+            @taxo_topics.to_rss(rss, current)
+          end
+EOC
+      end
+
+      def self.install_taxo_topics(klass)
+        klass.module_eval(<<-EOC, *Utils.get_file_and_line_from_caller(1))
+          class TaxonomyTopics < TaxonomyTopicsBase
+            def to_rss(rss, current)
+              if current.respond_to?(:taxo_topics)
+                topics = current.class::TaxonomyTopics.new
+                bag = topics.Bag
+                @resources.each do |resource|
+                  bag.lis << RDF::Bag::Li.new(resource)
+                end
+                current.taxo_topics = topics
+              end
+            end
+          end
+EOC
+      end
+
+      class TaxonomyTopicsBase
+        include Base
+
+        attr_reader :resources
+        def_array_element("resources")
+      end
+    end
+
+    module TaxonomyTopicModel
+      def self.append_features(klass)
+        super
+
+        klass.add_need_initialize_variable("taxo_topics", "make_taxo_topics")
+        klass.add_other_element("taxo_topics")
+        klass.module_eval(<<-EOC, __FILE__, __LINE__ + 1)
+          attr_reader :taxo_topics
+          def make_taxo_topics
+            self.class::TaxonomyTopics.new(@maker)
+          end
+            
+          def setup_taxo_topics(rss, current)
+            @taxo_topics.to_rss(rss, current)
+          end
+
+          def taxo_topic
+            @taxo_topics[0] and @taxo_topics[0].value
+          end
+            
+          def taxo_topic=(new_value)
+            @taxo_topic[0] = self.class::TaxonomyTopic.new(self)
+            @taxo_topic[0].value = new_value
+          end
+EOC
+      end
+    
+      def self.install_taxo_topic(klass)
+        klass.module_eval(<<-EOC, *Utils.get_file_and_line_from_caller(1))
+          class TaxonomyTopics < TaxonomyTopicsBase
+            class TaxonomyTopic < TaxonomyTopicBase
+              DublinCoreModel.install_dublin_core(self)
+              TaxonomyTopicsModel.install_taxo_topics(self)
+
+              def to_rss(rss, current)
+                if current.respond_to?(:taxo_topics)
+                  topic = current.class::TaxonomyTopic.new(value)
+                  topic.taxo_link = value
+                  taxo_topics.to_rss(rss, topic) if taxo_topics
+                  current.taxo_topics << topic
+                  setup_other_elements(rss)
+                end
+              end
+
+              def current_element(rss)
+                super.taxo_topics.last
+              end
+            end
+          end
+EOC
+      end
+
+      class TaxonomyTopicsBase
+        include Base
+        
+        def_array_element("taxo_topics")
+                            
+        def new_taxo_topic
+          taxo_topic = self.class::TaxonomyTopic.new(self)
+          @taxo_topics << taxo_topic
+          taxo_topic
+        end
+
+        def to_rss(rss, current)
+          @taxo_topics.each do |taxo_topic|
+            taxo_topic.to_rss(rss, current)
+          end
+        end
+        
+        class TaxonomyTopicBase
+          include Base
+          include DublinCoreModel
+          include TaxonomyTopicsModel
+          
+          attr_accessor :value
+          add_need_initialize_variable("value")
+          alias_method(:taxo_link, :value)
+          alias_method(:taxo_link=, :value=)
+          
+          def have_required_values?
+            @value
+          end
+        end
+      end
+    end
+
+    class RSSBase
+      include TaxonomyTopicModel
+    end
+    
+    class ChannelBase
+      include TaxonomyTopicsModel
+    end
+    
+    class ItemsBase
+      class ItemBase
+        include TaxonomyTopicsModel
+      end
+    end
+
+    class RSS10
+      TaxonomyTopicModel.install_taxo_topic(self)
+      
+      class Channel
+        TaxonomyTopicsModel.install_taxo_topics(self)
+      end
+
+      class Items
+        class Item
+          TaxonomyTopicsModel.install_taxo_topics(self)
+        end
+      end
+    end
+    
+    class RSS09
+      TaxonomyTopicModel.install_taxo_topic(self)
+      
+      class Channel
+        TaxonomyTopicsModel.install_taxo_topics(self)
+      end
+
+      class Items
+        class Item
+          TaxonomyTopicsModel.install_taxo_topics(self)
+        end
+      end
+    end
+  end
+end
diff --git a/test/rss/test_2.0.rb b/test/rss/test_2.0.rb
new file mode 100644
index 0000000000..2027e5344a
--- /dev/null
+++ b/test/rss/test_2.0.rb
@@ -0,0 +1,394 @@
+require "rexml/document"
+
+require "rss-testcase"
+
+require "rss/2.0"
+
+module RSS
+  class TestRSS20Core < TestCase
+
+    def setup
+      @rss_version = "2.0"
+    end
+    
+    def test_Rss
+      version = "1.0"
+      encoding = "UTF-8"
+      standalone = false
+      
+      rss = Rss.new(@rss_version, version, encoding, standalone)
+      
+      doc = REXML::Document.new(rss.to_s(false))
+      
+      xmldecl = doc.xml_decl
+      
+      %w(version encoding).each do |x|
+        assert_equal(instance_eval(x), xmldecl.__send__(x))
+      end
+      assert_equal(standalone, !xmldecl.standalone.nil?)
+      
+      assert_equal("", doc.root.namespace)
+      assert_equal(@rss_version, doc.root.attributes["version"])
+    end
+    
+    def test_not_displayed_xml_stylesheets
+      rss = Rss.new(@rss_version)
+      plain_rss = rss.to_s
+      3.times do
+        rss.xml_stylesheets.push(XMLStyleSheet.new)
+        assert_equal(plain_rss, rss.to_s)
+      end
+    end
+    
+    def test_xml_stylesheets
+      [
+        [{:href => "a.xsl", :type => "text/xsl"}],
+        [
+          {:href => "a.xsl", :type => "text/xsl"},
+          {:href => "a.css", :type => "text/css"},
+        ],
+      ].each do |attrs_ary|
+        assert_xml_stylesheet_pis(attrs_ary, Rss.new(@rss_version))
+      end
+    end
+
+    def test_channel
+      title = "fugafuga"
+      link = "http://hoge.com"
+      description = "fugafugafugafuga"
+      
+      language = "en-us"
+      copyright = "Copyright 2002, Spartanburg Herald-Journal"
+      managingEditor = "geo@herald.com (George Matesky)"
+      webMaster = "betty@herald.com (Betty Guernsey)"
+      pubDate = Time.parse("Sat, 07 Sep 2002 00:00:01 GMT")
+      lastBuildDate = Time.parse("Sat, 07 Sep 2002 09:42:31 GMT")
+      categories = [
+        {
+          :content => "Newspapers",
+        },
+        {
+          :domain => "Syndic8",
+          :content => "1765",
+        }
+      ]
+      generator = "MightyInHouse Content System v2.3"
+      docs = "http://blogs.law.harvard.edu/tech/rss"
+
+      ttl = "60"
+
+      rating = '(PICS-1.1 "http://www.rsac.org/ratingsv01.html" l gen true comment "RSACi North America Server" for "http://www.rsac.org" on "1996.04.16T08:15-0500" r (n 0 s 0 v 0 l 0))'
+
+      channel = Rss::Channel.new
+      
+      elems = %w(title link description language copyright
+                 managingEditor webMaster pubDate lastBuildDate
+                 generator docs ttl rating)
+      elems.each do |x|
+        value = instance_eval(x)
+        value = value.rfc822 if %w(pubDate lastBuildDate).include?(x)
+        channel.__send__("#{x}=", value)
+      end
+      categories.each do |cat|
+        channel.categories << Rss::Channel::Category.new(cat[:domain],
+                                                         cat[:content])
+      end
+      
+      doc = REXML::Document.new(make_rss20(channel.to_s))
+      c = doc.root.elements[1]
+      
+      elems.each do |x|
+        elem = c.elements[x]
+        assert_equal(x, elem.name)
+        assert_equal("", elem.namespace)
+        expected = instance_eval(x)
+        case x
+        when "pubDate", "lastBuildDate"
+          assert_equal(expected, Time.parse(elem.text))
+        when "ttl"
+          expected = channel.__send__(x)
+          assert_equal(expected, elem.text.to_i)
+        else
+          assert_equal(expected, elem.text)
+        end
+      end
+      categories.each_with_index do |cat, i|
+        cat = cat.dup
+        cat[:domain] ||= nil
+        category = c.elements["category[#{i+1}]"]
+        actual = {
+          :domain => category.attributes["domain"],
+          :content => category.text,
+        }
+        assert_equal(cat, actual)
+      end
+    end
+
+    def test_channel_cloud
+      cloud_params = {
+        :domain => "rpc.sys.com",
+        :port => "80",
+        :path => "/RPC2",
+        :registerProcedure => "myCloud.rssPleaseNotify",
+        :protocol => "xml-rpc",
+      }
+      cloud = Rss::Channel::Cloud.new(cloud_params[:domain],
+                                      cloud_params[:port],
+                                      cloud_params[:path],
+                                      cloud_params[:registerProcedure],
+                                      cloud_params[:protocol])
+      cloud_params[:port] = cloud.port
+      
+      doc = REXML::Document.new(cloud.to_s)
+      cloud_elem = doc.root
+      
+      actual = {}
+      cloud_elem.attributes.each do |name, value|
+        value = value.to_i if name == "port"
+        actual[name.intern] = value
+      end
+      assert_equal(cloud_params, actual)
+    end
+
+    def test_channel_image
+      image_params = {
+        :url => "http://hoge.com/hoge.png",
+        :title => "fugafuga",
+        :link => "http://hoge.com",
+        :width => "144",
+        :height => "400",
+        :description => "an image",
+      }
+      image = Rss::Channel::Image.new(image_params[:url],
+                                      image_params[:title],
+                                      image_params[:link],
+                                      image_params[:width],
+                                      image_params[:height],
+                                      image_params[:description])
+
+      doc = REXML::Document.new(image.to_s)
+      image_elem = doc.root
+      
+      image_params.each do |name, value|
+        value = image.__send__(name)
+        actual = image_elem.elements[name.to_s].text
+        actual = actual.to_i if [:width, :height].include?(name)
+        assert_equal(value, actual)
+      end
+    end
+    
+    def test_channel_textInput
+      textInput_params = {
+        :title => "fugafuga",
+        :description => "text hoge fuga",
+        :name => "hoge",
+        :link => "http://hoge.com",
+      }
+      textInput = Rss::Channel::TextInput.new(textInput_params[:title],
+                                              textInput_params[:description],
+                                              textInput_params[:name],
+                                              textInput_params[:link])
+
+      doc = REXML::Document.new(textInput.to_s)
+      input_elem = doc.root
+      
+      textInput_params.each do |name, value|
+        actual = input_elem.elements[name.to_s].text
+        assert_equal(value, actual)
+      end
+    end
+    
+    def test_channel_skip_days
+      skipDays_values = [
+        "Sunday",
+        "Monday",
+      ]
+      skipDays = Rss::Channel::SkipDays.new
+      skipDays_values.each do |value|
+        skipDays.days << Rss::Channel::SkipDays::Day.new(value)
+      end
+      
+      doc = REXML::Document.new(skipDays.to_s)
+      days_elem = doc.root
+      
+      skipDays_values.each_with_index do |value, i|
+        assert_equal(value, days_elem.elements[i + 1].text)
+      end
+    end
+    
+    def test_channel_skip_hours
+      skipHours_values = [
+        "0",
+        "13",
+      ]
+      skipHours = Rss::Channel::SkipHours.new
+      skipHours_values.each do |value|
+        skipHours.hours << Rss::Channel::SkipHours::Hour.new(value)
+      end
+
+      doc = REXML::Document.new(skipHours.to_s)
+      hours_elem = doc.root
+      
+      skipHours_values.each_with_index do |value, i|
+        expected = skipHours.hours[i].content
+        assert_equal(expected, hours_elem.elements[i + 1].text.to_i)
+      end
+    end
+
+    def test_item
+      title = "fugafuga"
+      link = "http://hoge.com/"
+      description = "text hoge fuga"
+      author = "oprah@oxygen.net"
+      categories = [
+        {
+          :content => "Newspapers",
+        },
+        {
+          :domain => "Syndic8",
+          :content => "1765",
+        }
+      ]
+      comments = "http://www.myblog.org/cgi-local/mt/mt-comments.cgi?entry_id=290"
+      pubDate = Time.parse("Sat, 07 Sep 2002 00:00:01 GMT")
+
+      channel = Rss::Channel.new
+      item = Rss::Channel::Item.new
+      channel.items << item
+      
+      elems = %w(title link description author comments pubDate)
+      elems.each do |x|
+        value = instance_eval(x)
+        value = value.rfc822 if x == "pubDate"
+        item.__send__("#{x}=", value)
+      end
+      categories.each do |cat|
+        item.categories << Rss::Channel::Category.new(cat[:domain],
+                                                      cat[:content])
+      end
+      
+      doc = REXML::Document.new(channel.to_s)
+      channel_elem = doc.root
+
+      item_elem = channel_elem.elements["item[1]"]
+      elems.each do |x|
+        elem = item_elem.elements[x]
+        assert_equal(x, elem.name)
+        assert_equal("", elem.namespace)
+        expected = instance_eval(x)
+        case x
+        when "pubDate"
+          assert_equal(expected, Time.parse(elem.text))
+        else
+          assert_equal(expected, elem.text)
+        end
+      end
+      categories.each_with_index do |cat, i|
+        cat = cat.dup
+        cat[:domain] ||= nil
+        category = item_elem.elements["category[#{i+1}]"]
+        actual = {
+          :domain => category.attributes["domain"],
+          :content => category.text,
+        }
+        assert_equal(cat, actual)
+      end
+    end
+
+    def test_item_enclosure
+      enclosure_params = {
+        :url => "http://www.scripting.com/mp3s/weatherReportSuite.mp3",
+        :length => "12216320",
+        :type => "audio/mpeg",
+      }
+
+      enclosure = Rss::Channel::Item::Enclosure.new(enclosure_params[:url],
+                                                    enclosure_params[:length],
+                                                    enclosure_params[:type])
+      enclosure_params[:length] = enclosure.length
+      
+      doc = REXML::Document.new(enclosure.to_s)
+      enclosure_elem = doc.root
+
+      actual = {}
+      enclosure_elem.attributes.each do |name, value|
+        value = value.to_i if name == "length"
+        actual[name.intern] = value
+      end
+      assert_equal(enclosure_params, actual)
+    end
+    
+    def test_item_guid
+      test_params = [
+        {
+          :content => "http://some.server.com/weblogItem3207",
+        },
+        {
+          :isPermaLink => "true",
+          :content => "http://inessential.com/2002/09/01.php#a2",
+        },
+      ]
+
+      test_params.each do |guid_params|
+        guid = Rss::Channel::Item::Guid.new(guid_params[:isPermaLink],
+                                            guid_params[:content])
+        if guid_params.has_key?(:isPermaLink)
+          guid_params[:isPermaLink] = guid.isPermaLink
+        end
+        if guid.isPermaLink.nil?
+          assert_equal(true, guid.PermaLink?)
+        else
+          assert_equal(guid.isPermaLink, guid.PermaLink?)
+        end
+        
+        doc = REXML::Document.new(guid.to_s)
+        guid_elem = doc.root
+      
+        actual = {}
+        actual[:content] = guid_elem.text if guid_elem.text
+        guid_elem.attributes.each do |name, value|
+          value = value == "true" if name == "isPermaLink"
+          actual[name.intern] = value
+        end
+        assert_equal(guid_params, actual)
+      end
+    end
+    
+    def test_item_source
+      source_params = {
+        :url => "http://www.tomalak.org/links2.xml",
+        :content => "Tomalak's Realm",
+      }
+
+      source = Rss::Channel::Item::Source.new(source_params[:url],
+                                              source_params[:content])
+
+      doc = REXML::Document.new(source.to_s)
+      source_elem = doc.root
+      
+      actual = {}
+      actual[:content] = source_elem.text
+      source_elem.attributes.each do |name, value|
+        actual[name.intern] = value
+      end
+      assert_equal(source_params, actual)
+    end
+    
+    def test_indent_size
+      assert_equal(0, Rss.indent_size)
+      assert_equal(1, Rss::Channel.indent_size)
+      assert_equal(2, Rss::Channel::SkipDays.indent_size)
+      assert_equal(3, Rss::Channel::SkipDays::Day.indent_size)
+      assert_equal(2, Rss::Channel::SkipHours.indent_size)
+      assert_equal(3, Rss::Channel::SkipHours::Hour.indent_size)
+      assert_equal(2, Rss::Channel::Image.indent_size)
+      assert_equal(2, Rss::Channel::Cloud.indent_size)
+      assert_equal(2, Rss::Channel::Item.indent_size)
+      assert_equal(3, Rss::Channel::Item::Source.indent_size)
+      assert_equal(3, Rss::Channel::Item::Enclosure.indent_size)
+      assert_equal(3, Rss::Channel::Item::Category.indent_size)
+      assert_equal(3, Rss::Channel::Item::Guid.indent_size)
+      assert_equal(2, Rss::Channel::TextInput.indent_size)
+    end
+  end
+end
diff --git a/test/rss/test_maker_taxo.rb b/test/rss/test_maker_taxo.rb
new file mode 100644
index 0000000000..1c7d2844ce
--- /dev/null
+++ b/test/rss/test_maker_taxo.rb
@@ -0,0 +1,79 @@
+require "rss-testcase"
+
+require "rss/maker"
+
+module RSS
+  class TestMakerTaxonomy < TestCase
+
+    def setup
+      @uri = "http://purl.org/rss/1.0/modules/taxonomy/"
+      
+      @resources = [
+        "http://meerkat.oreillynet.com/?c=cat23",
+        "http://meerkat.oreillynet.com/?c=47",
+        "http://dmoz.org/Computers/Data_Formats/Markup_Languages/XML/",
+      ]
+
+      @topics = [
+        {
+          :link => "http://meerkat.oreillynet.com/?c=cat23",
+          :title => "Data: XML",
+          :description => "A Meerkat channel",
+         },
+        {
+          :link => "http://dmoz.org/Computers/Data_Formats/Markup_Languages/XML/",
+          :title => "XML",
+          :subject => "XML",
+          :description => "DMOZ category",
+          :topics => [
+            "http://meerkat.oreillynet.com/?c=cat23",
+            "http://dmoz.org/Computers/Data_Formats/Markup_Languages/SGML/",
+            "http://dmoz.org/Computers/Programming/Internet/",
+          ]
+         },
+       ]
+    end
+
+    def test_rss10
+      rss = RSS::Maker.make("1.0") do |maker|
+        setup_dummy_channel(maker)
+        set_topics(maker.channel)
+
+        setup_dummy_item(maker)
+        set_topics(maker.items.last)
+
+        setup_taxo_topic(maker, @topics)
+      end
+      assert_equal(@resources, rss.channel.taxo_topics.resources)
+      assert_equal(@resources, rss.items.last.taxo_topics.resources)
+      assert_taxo_topic(@topics, rss)
+    end
+
+    def _test_date
+      t1 = Time.iso8601("2000-01-01T12:00:05+00:00")
+      t2 = Time.iso8601("2005-01-01T12:00:05+00:00")
+      
+      rss = RSS::Maker.make("1.0") do |maker|
+        setup_dummy_channel(maker)
+        maker.channel.date = t1
+        date = maker.channel.dc_dates.new_date
+        date.value = t2
+
+        setup_dummy_item(maker)
+        item = maker.items.last
+        item.date = t2
+        date = item.dc_dates.new_date
+        date.value = t1
+      end
+      assert_equal([t1, t2], rss.channel.dc_dates.collect{|x| x.value})
+      assert_equal([t2, t1], rss.items.last.dc_dates.collect{|x| x.value})
+    end
+    
+    private
+    def set_topics(target, resources=@resources)
+      resources.each do |value|
+        target.taxo_topics << value
+      end
+    end
+  end
+end
diff --git a/test/rss/test_taxonomy.rb b/test/rss/test_taxonomy.rb
new file mode 100644
index 0000000000..b4950c0004
--- /dev/null
+++ b/test/rss/test_taxonomy.rb
@@ -0,0 +1,160 @@
+require "cgi"
+
+require "rss-testcase"
+
+require "rss/1.0"
+require "rss/2.0"
+require "rss/taxonomy"
+
+module RSS
+  class TestTaxonomy < TestCase
+    
+    def setup
+      @prefix = "taxo"
+      @uri = "http://purl.org/rss/1.0/modules/taxonomy/"
+      @dc_prefix = "dc"
+      @dc_uri = "http://purl.org/dc/elements/1.1/"
+
+      @ns = {
+        @prefix => @uri,
+        @dc_prefix => @dc_uri,
+      }
+      
+      @topics_parents = %w(channel item)
+      
+      @topics_lis = [
+        "http://meerkat.oreillynet.com/?c=cat23",
+        "http://meerkat.oreillynet.com/?c=47",
+        "http://dmoz.org/Computers/Data_Formats/Markup_Languages/XML/",
+      ]
+
+      @topics_node = "<#{@prefix}:topics>\n"
+      @topics_node << "  <rdf:Bag>\n"
+      @topics_lis.each do |value|
+        resource = CGI.escapeHTML(value)
+        @topics_node << "    <rdf:li resource=\"#{resource}\"/>\n"
+      end
+      @topics_node << "  </rdf:Bag>\n"
+      @topics_node << "</#{@prefix}:topics>"
+
+      @topic_topics_lis = \
+      [
+       "http://meerkat.oreillynet.com/?c=cat23",
+       "http://dmoz.org/Computers/Data_Formats/Markup_Languages/SGML/",
+       "http://dmoz.org/Computers/Programming/Internet/",
+      ]
+
+      @topic_contents = \
+      [
+       {
+         :link => "http://meerkat.oreillynet.com/?c=cat23",
+         :title => "Data: XML",
+         :description => "A Meerkat channel",
+       },
+       {
+         :link => "http://dmoz.org/Computers/Data_Formats/Markup_Languages/XML/",
+         :title => "XML",
+         :subject => "XML",
+         :description => "DMOZ category",
+         :topics => @topic_topics_lis,
+       }
+      ]
+
+      @topic_nodes = @topic_contents.collect do |info|
+        link = info[:link]
+        rv = "<#{@prefix}:topic rdf:about=\"#{link}\">\n"
+        info.each do |name, value|
+          case name
+          when :topics
+            rv << "  <#{@prefix}:topics>\n"
+            rv << "    <rdf:Bag>\n"
+            value.each do |li|
+              resource = CGI.escapeHTML(li)
+              rv << "      <rdf:li resource=\"#{resource}\"/>\n"
+            end
+            rv << "    </rdf:Bag>\n"
+            rv << "  </#{@prefix}:topics>\n"
+          else
+            prefix = (name == :link ? @prefix : @dc_prefix)
+            rv << "  <#{prefix}:#{name}>#{value}</#{prefix}:#{name}>\n"
+          end
+        end
+        rv << "</#{@prefix}:topic>"
+      end
+      
+      @rss_source = make_RDF(<<-EOR, @ns)
+#{make_channel(@topics_node)}
+#{make_image()}
+#{make_item(@topics_node)}
+#{make_textinput()}
+#{@topic_nodes.join("\n")}
+EOR
+
+      @rss = Parser.parse(@rss_source)
+    end
+
+    def test_parser
+      assert_nothing_raised do
+        Parser.parse(@rss_source)
+      end
+      
+      assert_too_much_tag("topics", "channel") do
+        Parser.parse(make_RDF(<<-EOR, @ns))
+#{make_channel(@topics_node * 2)}
+#{make_item()}
+EOR
+      end
+
+      assert_too_much_tag("topics", "item") do
+        Parser.parse(make_RDF(<<-EOR, @ns))
+#{make_channel()}
+#{make_item(@topics_node * 2)}
+EOR
+      end
+    end
+  
+    def test_accessor
+      topics = @rss.channel.taxo_topics
+      assert_equal(@topics_lis.sort,
+                   topics.Bag.lis.collect {|li| li.resource}.sort)
+      assert_equal(@topics_lis.sort, topics.resources.sort)
+
+      assert_equal(@rss.taxo_topics.first, @rss.taxo_topic)
+
+      @topic_contents.each_with_index do |info, i|
+        topic = @rss.taxo_topics[i]
+        info.each do |name, value|
+          case name
+          when :link
+            assert_equal(value, topic.about)
+            assert_equal(value, topic.taxo_link)
+          when :topics
+            assert_equal(value.sort, topic.taxo_topics.resources.sort)
+          else
+            assert_equal(value, topic.__send__("dc_#{name}"))
+          end
+        end
+      end
+    end
+    
+    def test_to_s
+      @topics_parents.each do |parent|
+        meth = "taxo_topics_element"
+        assert_equal(@topics_node, @rss.__send__(parent).funcall(meth))
+      end
+
+      @topic_nodes.each_with_index do |node, i|
+        expected = REXML::Document.new(node).root
+        actual = REXML::Document.new(@rss.taxo_topics[i].to_s(true, "")).root
+        expected_elems = expected.reject {|x| x.is_a?(REXML::Text)}
+        actual_elems = actual.reject {|x| x.is_a?(REXML::Text)}
+        expected_elems.sort! {|x, y| x.name <=> y.name}
+        actual_elems.sort! {|x, y| x.name <=> y.name}
+        assert_equal(expected_elems.collect {|x| x.to_s},
+                     actual_elems.collect {|x| x.to_s})
+        assert_equal(expected.attributes.sort, actual.attributes.sort)
+      end
+    end
+  end
+end
+