* lib/rss/: untabified.

* test/rss/: untabified.
* lib/rss/0.9.rb (RSS::Rss#to_s): inent -> indent.


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

16 files changed, 3046 insertions, 3046 deletions

diff --git a/lib/rss/0.9.rb b/lib/rss/0.9.rb
index 8486c4fc1f..77b65cddec 100644
--- a/lib/rss/0.9.rb
+++ b/lib/rss/0.9.rb
@@ -2,144 +2,144 @@ require "rss/parser"
 
 module RSS
 
-	module RSS09
-		NSPOOL = {}
-		ELEMENTS = []
-
-		def self.append_features(klass)
-			super
-			
-			klass.install_must_call_validator('', nil)
-		end
-	end
-
-	class Rss < Element
-
-		include RSS09
-		include RootElementMixin
-		include XMLStyleSheetMixin
-
-		[
-			["channel", nil],
-		].each do |tag, occurs|
-			install_model(tag, occurs)
-		end
-
-		%w(channel).each do |x|
-			install_have_child_element(x)
-		end
-
-		attr_accessor :rss_version, :version, :encoding, :standalone
-		
-		def initialize(rss_version, version=nil, encoding=nil, standalone=nil)
-			super
-		end
-
-		def items
-			if @channel
-				@channel.items
-			else
-				[]
-			end
-		end
-
-		def image
-			if @channel
-				@channel.image
-			else
-				nil
-			end
-		end
-
-		def to_s(convert=true, indent=calc_indent)
-			next_indent = indent + INDENT
-			rv = <<-EOR
+  module RSS09
+    NSPOOL = {}
+    ELEMENTS = []
+
+    def self.append_features(klass)
+      super
+      
+      klass.install_must_call_validator('', nil)
+    end
+  end
+
+  class Rss < Element
+
+    include RSS09
+    include RootElementMixin
+    include XMLStyleSheetMixin
+
+    [
+      ["channel", nil],
+    ].each do |tag, occurs|
+      install_model(tag, occurs)
+    end
+
+    %w(channel).each do |x|
+      install_have_child_element(x)
+    end
+
+    attr_accessor :rss_version, :version, :encoding, :standalone
+    
+    def initialize(rss_version, version=nil, encoding=nil, standalone=nil)
+      super
+    end
+
+    def items
+      if @channel
+        @channel.items
+      else
+        []
+      end
+    end
+
+    def image
+      if @channel
+        @channel.image
+      else
+        nil
+      end
+    end
+
+    def to_s(convert=true, indent=calc_indent)
+      next_indent = indent + INDENT
+      rv = <<-EOR
 #{xmldecl}
 #{xml_stylesheet_pi}
 #{indent}<rss version="#{@rss_version}"#{ns_declaration(next_indent)}>
 #{channel_element(false, next_indent)}
 #{other_element(false, next_indent)}
-#{inent}}</rss>
+#{indent}}</rss>
 EOR
-			rv = @converter.convert(rv) if convert and @converter
-			remove_empty_newline(rv)
-		end
-
-		private
-		def children
-			[@channel]
-		end
-
-		def _tags
-			[
-				[nil, 'channel'],
-			].delete_if {|x| send(x[1]).nil?}
-		end
-
-		def _attrs
-			[
-				["version", true],
-			]
-		end
-
-		class Channel < Element
-
-			include RSS09
-
-			[
-				["title", nil],
-				["link", nil],
-				["description", nil],
-				["language", nil],
-				["copyright", "?"],
-				["managingEditor", "?"],
-				["webMaster", "?"],
-				["rating", "?"],
-				["docs", "?"],
-				["skipDays", "?"],
-				["skipHours", "?"],
-			].each do |x, occurs|
-				install_text_element(x)
-				install_model(x, occurs)
-			end
-
-			[
-				["pubDate", "?"],
-				["lastBuildDate", "?"],
-			].each do |x, occurs|
-				install_date_element(x, 'rfc822')
-				install_model(x, occurs)
-			end
-
-			[
-				["image", nil],
-				["textInput", "?"],
-			].each do |x, occurs|
-				install_have_child_element(x)
-				install_model(x, occurs)
-			end
-			
-			[
-				["cloud", "?"]
-			].each do |x, occurs|
-				install_have_attribute_element(x)
-				install_model(x, occurs)
-			end
-			
-			[
-				["item", "*"]
-			].each do |x, occurs|
-				install_have_children_element(x)
-				install_model(x, occurs)
-			end
-
-			def initialize()
-				super()
-			end
-
-			def to_s(convert=true, indent=calc_indent)
-				next_indent = indent + INDENT
-				rv = <<-EOT
+      rv = @converter.convert(rv) if convert and @converter
+      remove_empty_newline(rv)
+    end
+
+    private
+    def children
+      [@channel]
+    end
+
+    def _tags
+      [
+        [nil, 'channel'],
+      ].delete_if {|x| send(x[1]).nil?}
+    end
+
+    def _attrs
+      [
+        ["version", true],
+      ]
+    end
+
+    class Channel < Element
+
+      include RSS09
+
+      [
+        ["title", nil],
+        ["link", nil],
+        ["description", nil],
+        ["language", nil],
+        ["copyright", "?"],
+        ["managingEditor", "?"],
+        ["webMaster", "?"],
+        ["rating", "?"],
+        ["docs", "?"],
+        ["skipDays", "?"],
+        ["skipHours", "?"],
+      ].each do |x, occurs|
+        install_text_element(x)
+        install_model(x, occurs)
+      end
+
+      [
+        ["pubDate", "?"],
+        ["lastBuildDate", "?"],
+      ].each do |x, occurs|
+        install_date_element(x, 'rfc822')
+        install_model(x, occurs)
+      end
+
+      [
+        ["image", nil],
+        ["textInput", "?"],
+      ].each do |x, occurs|
+        install_have_child_element(x)
+        install_model(x, occurs)
+      end
+      
+      [
+        ["cloud", "?"]
+      ].each do |x, occurs|
+        install_have_attribute_element(x)
+        install_model(x, occurs)
+      end
+      
+      [
+        ["item", "*"]
+      ].each do |x, occurs|
+        install_have_children_element(x)
+        install_model(x, occurs)
+      end
+
+      def initialize()
+        super()
+      end
+
+      def to_s(convert=true, indent=calc_indent)
+        next_indent = indent + INDENT
+        rv = <<-EOT
 #{indent}<channel>
 #{title_element(false, next_indent)}
 #{link_element(false, next_indent)}
@@ -160,60 +160,60 @@ EOR
 #{other_element(false, next_indent)}
 #{indent}</channel>
 EOT
-	      rv = @converter.convert(rv) if convert and @converter
-				rv
-			end
-
-	    private
-			def children
-				[@image, @textInput, @cloud, *@item]
-			end
-
-			def _tags
-				rv = [
-					"title",
-					"link",
-					"description",
-					"language",
-					"copyright",
-					"managingEditor",
-					"webMaster",
-					"rating",
-					"docs",
-					"skipDays",
-					"skipHours",
-					"image",
-					"textInput",
-					"cloud",
-				].delete_if do |x|
-					send(x).nil?
-				end.collect do |elem|
-					[nil, elem]
-				end
-
-				@item.each do
-					rv << [nil, "item"]
-				end
-
-				rv
-			end
-
-			class Image < Element
-
-				include RSS09
-				
-				%w(url title link).each do |x|
-					install_text_element(x)
-					install_model(x, nil)
-				end
-				%w(width height description).each do |x|
-					install_text_element(x)
-					install_model(x, "?")
-				end
-
-				def to_s(convert=true, indent=calc_indent)
-					next_indent = indent + INDENT
-					rv = <<-EOT
+        rv = @converter.convert(rv) if convert and @converter
+        rv
+      end
+
+      private
+      def children
+        [@image, @textInput, @cloud, *@item]
+      end
+
+      def _tags
+        rv = [
+          "title",
+          "link",
+          "description",
+          "language",
+          "copyright",
+          "managingEditor",
+          "webMaster",
+          "rating",
+          "docs",
+          "skipDays",
+          "skipHours",
+          "image",
+          "textInput",
+          "cloud",
+        ].delete_if do |x|
+          send(x).nil?
+        end.collect do |elem|
+          [nil, elem]
+        end
+
+        @item.each do
+          rv << [nil, "item"]
+        end
+
+        rv
+      end
+
+      class Image < Element
+
+        include RSS09
+        
+        %w(url title link).each do |x|
+          install_text_element(x)
+          install_model(x, nil)
+        end
+        %w(width height description).each do |x|
+          install_text_element(x)
+          install_model(x, "?")
+        end
+
+        def to_s(convert=true, indent=calc_indent)
+          next_indent = indent + INDENT
+          rv = <<-EOT
 #{indent}<image>
 #{url_element(false, next_indent)}
 #{title_element(false, next_indent)}
@@ -224,46 +224,46 @@ EOT
 #{other_element(false, next_indent)}
 #{indent}</image>
 EOT
-	     		rv = @converter.convert(rv) if convert and @converter
-	  	    rv
-				end
-
-				private
-				def _tags
-					%w(url title link width height description).delete_if do |x|
-						send(x).nil?
-					end.collect do |elem|
-						[nil, elem]
-					end
-				end
-			end
-			
-			class Cloud < Element
-
-				include RSS09
-				
-				[
-					["domain", nil, true],
-					["port", nil, true],
-					["path", nil, true],
-					["registerProcedure", nil, true],
-					["protocol", nil ,true],
-				].each do |name, uri, required|
-					install_get_attribute(name, uri, required)
-				end
-
-				def initialize(domain, port, path, rp, protocol)
-					super()
-					@domain = domain
-					@port = port
-					@path = path
-					@registerProcedure = rp
-					@protocol = protocol
-				end
-
-				def to_s(convert=true, indent=calc_indent)
-					next_indent = indent + INDENT
-					rv = <<-EOT
+       		rv = @converter.convert(rv) if convert and @converter
+    	    rv
+        end
+
+        private
+        def _tags
+          %w(url title link width height description).delete_if do |x|
+            send(x).nil?
+          end.collect do |elem|
+            [nil, elem]
+          end
+        end
+      end
+      
+      class Cloud < Element
+
+        include RSS09
+        
+        [
+          ["domain", nil, true],
+          ["port", nil, true],
+          ["path", nil, true],
+          ["registerProcedure", nil, true],
+          ["protocol", nil ,true],
+        ].each do |name, uri, required|
+          install_get_attribute(name, uri, required)
+        end
+
+        def initialize(domain, port, path, rp, protocol)
+          super()
+          @domain = domain
+          @port = port
+          @path = path
+          @registerProcedure = rp
+          @protocol = protocol
+        end
+
+        def to_s(convert=true, indent=calc_indent)
+          next_indent = indent + INDENT
+          rv = <<-EOT
 #{indent}<cloud
 #{next_indent}domain="#{h @domain}"
 #{next_indent}port="#{h @port}"
@@ -271,45 +271,45 @@ EOT
 #{next_indent}registerProcedure="#{h @registerProcedure}"
 #{next_indent}protocol="#{h @protocol}"/>
 EOT
-	     		rv = @converter.convert(rv) if convert and @converter
-	  	    rv
-				end
-
-				private
-				def _attrs
-					%w(domain port path registerProcedure protocol).collect do |attr|
-						[attr, true]
-					end
-				end
-
-			end
-			
-			class Item < Element
-				
-				include RSS09
-
-				%w(title link description).each do |x|
-					install_text_element(x)
-				end
-
-				%w(category source enclosure).each do |x|
-					install_have_child_element(x)
-				end
-
-				[
-					["title", '?'],
-					["link", '?'],
-					["description", '?'],
-					["category", '?'],
-					["source", '?'],
-					["enclosure", '?'],
-				].each do |tag, occurs|
-					install_model(tag, occurs)
-				end
-
-				def to_s(convert=true, indent=calc_indent)
+       		rv = @converter.convert(rv) if convert and @converter
+    	    rv
+        end
+
+        private
+        def _attrs
+          %w(domain port path registerProcedure protocol).collect do |attr|
+            [attr, true]
+          end
+        end
+
+      end
+      
+      class Item < Element
+        
+        include RSS09
+
+        %w(title link description).each do |x|
+          install_text_element(x)
+        end
+
+        %w(category source enclosure).each do |x|
+          install_have_child_element(x)
+        end
+
+        [
+          ["title", '?'],
+          ["link", '?'],
+          ["description", '?'],
+          ["category", '?'],
+          ["source", '?'],
+          ["enclosure", '?'],
+        ].each do |tag, occurs|
+          install_model(tag, occurs)
+        end
+
+        def to_s(convert=true, indent=calc_indent)
           next_indent = indent + INDENT
-					rv = <<-EOT
+          rv = <<-EOT
 #{indent}<item>
 #{title_element(false, next_indent)}
 #{link_element(false, next_indent)}
@@ -320,159 +320,159 @@ EOT
 #{other_element(false, next_indent)}
 #{indent}</item>
 EOT
-	     		rv = @converter.convert(rv) if convert and @converter
-	  	    rv
-				end
-
-				private
-				def children
-					[@category, @source, @enclosure,].compact
-				end
-
-				def _tags
-					%w(title link description author comments category
-						source enclosure).delete_if do |x|
-						send(x).nil?
-					end.collect do |x|
-						[nil, x]
-					end
-				end
-
-				class Source < Element
-
-					include RSS09
-
-					[
-						["url", nil, true]
-					].each do |name, uri, required|
-						install_get_attribute(name, uri, required)
-					end
-					
-					content_setup
-
-					def initialize(url=nil, content=nil)
-						super()
-						@url = url
-						@content = content
-					end
-
-					def to_s(convert=true, indent=calc_indent)
-						if @url
-							rv = %Q!				<source url="#{@url}">!
-							rv << %Q!#{@content}</source>!
-							rv = @converter.convert(rv) if convert and @converter
-							rv
-						else
-							''
-						end
-					end
-
-					private
-					def _tags
-						[]
-					end
-
-					def _attrs
-						[
-							["url", true]
-						]
-					end
-
-				end
-
-				class Enclosure < Element
-
-					include RSS09
-
-					[
-						["url", nil, true],
-						["length", nil, true],
-						["type", nil, true],
-					].each do |name, uri, required|
-						install_get_attribute(name, uri, required)
-					end
-
-					def initialize(url=nil, length=nil, type=nil)
-						super()
-						@url = url
-						@length = length
-						@type = type
-					end
-
-					def to_s(convert=true, indent=calc_indent)
-						if @url and @length and @type
-							rv = %Q!<enclosure url="#{h @url}" !
-							rv << %Q!length="#{h @length}" type="#{h @type}"/>!
-							rv = @converter.convert(rv) if convert and @converter
-							rv
-						else
-							''
-						end
-					end
-
-					private
-					def _attrs
-						[
-							["url", true],
-							["length", true],
-							["type", true],
-						]
-					end
-
-				end
-
-				class Category < Element
-
-					include RSS09
-					
-					[
-						["domain", nil, true]
-					].each do |name, uri, required|
-						install_get_attribute(name, uri, required)
-					end
-
-					content_setup
-
-					def initialize(domain=nil, content=nil)
-						super()
-						@domain = domain
-						@content = content
-					end
-
-					def to_s(convert=true, indent=calc_indent)
-						if @domain
-							rv = %Q!<category domain="#{h @domain}">!
-							rv << %Q!#{h @content}</category>!
-							rv = @converter.convert(rv) if convert and @converter
-							rv
-						else
-							''
-						end
-					end
-
-					private
-					def _attrs
-						[
-							["domain", true]
-						]
-					end
-
-				end
-
-			end
-			
-			class TextInput < Element
-				
-				include RSS09
-
-				%w(title description name link).each do |x|
-					install_text_element(x)
-					install_model(x, nil)
-				end
-
-				def to_s(convert=true, indent=calc_indent)
+       		rv = @converter.convert(rv) if convert and @converter
+    	    rv
+        end
+
+        private
+        def children
+          [@category, @source, @enclosure,].compact
+        end
+
+        def _tags
+          %w(title link description author comments category
+            source enclosure).delete_if do |x|
+            send(x).nil?
+          end.collect do |x|
+            [nil, x]
+          end
+        end
+
+        class Source < Element
+
+          include RSS09
+
+          [
+            ["url", nil, true]
+          ].each do |name, uri, required|
+            install_get_attribute(name, uri, required)
+          end
+          
+          content_setup
+
+          def initialize(url=nil, content=nil)
+            super()
+            @url = url
+            @content = content
+          end
+
+          def to_s(convert=true, indent=calc_indent)
+            if @url
+              rv = %Q!				<source url="#{@url}">!
+              rv << %Q!#{@content}</source>!
+              rv = @converter.convert(rv) if convert and @converter
+              rv
+            else
+              ''
+            end
+          end
+
+          private
+          def _tags
+            []
+          end
+
+          def _attrs
+            [
+              ["url", true]
+            ]
+          end
+
+        end
+
+        class Enclosure < Element
+
+          include RSS09
+
+          [
+            ["url", nil, true],
+            ["length", nil, true],
+            ["type", nil, true],
+          ].each do |name, uri, required|
+            install_get_attribute(name, uri, required)
+          end
+
+          def initialize(url=nil, length=nil, type=nil)
+            super()
+            @url = url
+            @length = length
+            @type = type
+          end
+
+          def to_s(convert=true, indent=calc_indent)
+            if @url and @length and @type
+              rv = %Q!<enclosure url="#{h @url}" !
+              rv << %Q!length="#{h @length}" type="#{h @type}"/>!
+              rv = @converter.convert(rv) if convert and @converter
+              rv
+            else
+              ''
+            end
+          end
+
+          private
+          def _attrs
+            [
+              ["url", true],
+              ["length", true],
+              ["type", true],
+            ]
+          end
+
+        end
+
+        class Category < Element
+
+          include RSS09
+          
+          [
+            ["domain", nil, true]
+          ].each do |name, uri, required|
+            install_get_attribute(name, uri, required)
+          end
+
+          content_setup
+
+          def initialize(domain=nil, content=nil)
+            super()
+            @domain = domain
+            @content = content
+          end
+
+          def to_s(convert=true, indent=calc_indent)
+            if @domain
+              rv = %Q!<category domain="#{h @domain}">!
+              rv << %Q!#{h @content}</category>!
+              rv = @converter.convert(rv) if convert and @converter
+              rv
+            else
+              ''
+            end
+          end
+
+          private
+          def _attrs
+            [
+              ["domain", true]
+            ]
+          end
+
+        end
+
+      end
+      
+      class TextInput < Element
+        
+        include RSS09
+
+        %w(title description name link).each do |x|
+          install_text_element(x)
+          install_model(x, nil)
+        end
+
+        def to_s(convert=true, indent=calc_indent)
           next_indent = indent + INDENT
-					rv = <<-EOT
+          rv = <<-EOT
 #{indent}<textInput>
 #{title_element(false, next_indent)}
 #{description_element(false, next_indent)}
@@ -481,42 +481,42 @@ EOT
 #{other_element(false, next_indent)}
 #{indent}</textInput>
 EOT
-	     		rv = @converter.convert(rv) if convert and @converter
-	  	    rv
-				end
-
-				private
-				def _tags
-					%w(title description name link).each do |x|
-						send(x).nil?
-					end.collect do |elem|
-						[nil, elem]
-					end
-				end
-			end
-			
-		end
-		
-	end
-
-	RSS09::ELEMENTS.each do |x|
-		BaseListener.install_get_text_element(x, nil, "#{x}=")
-	end
-
-	module ListenerMixin
-		private
-		def start_rss(tag_name, prefix, attrs, ns)
-			check_ns(tag_name, prefix, ns, nil)
-			
-			@rss = Rss.new(attrs['version'], @version, @encoding, @standalone)
-			@rss.do_validate = @do_validate
-			@rss.xml_stylesheets = @xml_stylesheets
-			@last_element = @rss
-			@proc_stack.push Proc.new { |text, tags|
-				@rss.validate_for_stream(tags) if @do_validate
-			}
-		end
-		
-	end
+       		rv = @converter.convert(rv) if convert and @converter
+    	    rv
+        end
+
+        private
+        def _tags
+          %w(title description name link).each do |x|
+            send(x).nil?
+          end.collect do |elem|
+            [nil, elem]
+          end
+        end
+      end
+      
+    end
+    
+  end
+
+  RSS09::ELEMENTS.each do |x|
+    BaseListener.install_get_text_element(x, nil, "#{x}=")
+  end
+
+  module ListenerMixin
+    private
+    def start_rss(tag_name, prefix, attrs, ns)
+      check_ns(tag_name, prefix, ns, nil)
+      
+      @rss = Rss.new(attrs['version'], @version, @encoding, @standalone)
+      @rss.do_validate = @do_validate
+      @rss.xml_stylesheets = @xml_stylesheets
+      @last_element = @rss
+      @proc_stack.push Proc.new { |text, tags|
+        @rss.validate_for_stream(tags) if @do_validate
+      }
+    end
+    
+  end
 
 end
diff --git a/lib/rss/1.0.rb b/lib/rss/1.0.rb
index 999301c595..563ed66426 100644
--- a/lib/rss/1.0.rb
+++ b/lib/rss/1.0.rb
@@ -2,64 +2,64 @@ require "rss/parser"
 
 module RSS
 
-	module RSS10
-		NSPOOL = {}
-		ELEMENTS = []
+  module RSS10
+    NSPOOL = {}
+    ELEMENTS = []
 
-		def self.append_features(klass)
-			super
-			
-			klass.install_must_call_validator('', ::RSS::URI)
-		end
+    def self.append_features(klass)
+      super
+      
+      klass.install_must_call_validator('', ::RSS::URI)
+    end
 
-	end
+  end
 
-	class RDF < Element
+  class RDF < Element
 
-		include RSS10
-		include RootElementMixin
-		include XMLStyleSheetMixin
+    include RSS10
+    include RootElementMixin
+    include XMLStyleSheetMixin
 
-		class << self
+    class << self
 
-			def required_uri
-				URI
-			end
+      def required_uri
+        URI
+      end
 
-		end
+    end
 
-		@tag_name = 'RDF'
+    @tag_name = 'RDF'
 
-		PREFIX = 'rdf'
-		URI = "http://www.w3.org/1999/02/22-rdf-syntax-ns#"
+    PREFIX = 'rdf'
+    URI = "http://www.w3.org/1999/02/22-rdf-syntax-ns#"
 
-		install_ns('', ::RSS::URI)
-		install_ns(PREFIX, URI)
+    install_ns('', ::RSS::URI)
+    install_ns(PREFIX, URI)
 
-		[
-			["channel", nil],
-			["image", "?"],
-			["item", "+"],
-			["textinput", "?"],
-		].each do |tag, occurs|
-			install_model(tag, occurs)
-		end
+    [
+      ["channel", nil],
+      ["image", "?"],
+      ["item", "+"],
+      ["textinput", "?"],
+    ].each do |tag, occurs|
+      install_model(tag, occurs)
+    end
 
-		%w(channel image textinput).each do |x|
-			install_have_child_element(x)
-		end
+    %w(channel image textinput).each do |x|
+      install_have_child_element(x)
+    end
 
-		install_have_children_element("item")
+    install_have_children_element("item")
 
-		attr_accessor :rss_version, :version, :encoding, :standalone
-		
-		def initialize(version=nil, encoding=nil, standalone=nil)
-			super('1.0', version, encoding, standalone)
-		end
+    attr_accessor :rss_version, :version, :encoding, :standalone
+    
+    def initialize(version=nil, encoding=nil, standalone=nil)
+      super('1.0', version, encoding, standalone)
+    end
 
-		def to_s(convert=true, indent=calc_indent)
-			next_indent = indent + INDENT
-			rv = <<-EORDF
+    def to_s(convert=true, indent=calc_indent)
+      next_indent = indent + INDENT
+      rv = <<-EORDF
 #{xmldecl}
 #{xml_stylesheet_pi}
 #{indent}<#{PREFIX}:RDF#{ns_declaration(next_indent)}>
@@ -72,170 +72,170 @@ module RSS
 EORDF
       rv = @converter.convert(rv) if convert and @converter
       remove_empty_newline(rv)
-		end
-
-		private
-		def rdf_validate(tags)
-			_validate(tags, [])
-		end
-
-		def children
-			[@channel, @image, @textinput, *@item]
-		end
-
-		def _tags
-			rv = [
-				[::RSS::URI, "channel"],
-				[::RSS::URI, "image"],
-			].delete_if {|x| send(x[1]).nil?}
-			@item.each do |x|
-				rv << [::RSS::URI, "item"]
-			end
-			rv << [::RSS::URI, "textinput"] if @textinput
-			rv
-		end
-
-		class Seq < Element
-
-			include RSS10
-
-			class << self
-				
-				def required_uri
-					URI
-				end
-				
-			end
-
-			@tag_name = 'Seq'
-			
-			install_have_children_element("li")
-			
-			install_must_call_validator('rdf', ::RSS::RDF::URI)
-			
-			def initialize(li=[])
-				super()
-				@li = li
-			end
-			
-			def to_s(convert=true, indent=calc_indent)
-				next_indent = indent + INDENT
-				<<-EOT
+    end
+
+    private
+    def rdf_validate(tags)
+      _validate(tags, [])
+    end
+
+    def children
+      [@channel, @image, @textinput, *@item]
+    end
+
+    def _tags
+      rv = [
+        [::RSS::URI, "channel"],
+        [::RSS::URI, "image"],
+      ].delete_if {|x| send(x[1]).nil?}
+      @item.each do |x|
+        rv << [::RSS::URI, "item"]
+      end
+      rv << [::RSS::URI, "textinput"] if @textinput
+      rv
+    end
+
+    class Seq < Element
+
+      include RSS10
+
+      class << self
+        
+        def required_uri
+          URI
+        end
+        
+      end
+
+      @tag_name = 'Seq'
+      
+      install_have_children_element("li")
+      
+      install_must_call_validator('rdf', ::RSS::RDF::URI)
+      
+      def initialize(li=[])
+        super()
+        @li = li
+      end
+      
+      def to_s(convert=true, indent=calc_indent)
+        next_indent = indent + INDENT
+        <<-EOT
 #{indent}<#{PREFIX}:Seq>
 #{li_elements(convert, next_indent)}
 #{other_element(convert, next_indent)}
 #{indent}</#{PREFIX}:Seq>
 EOT
-			end
+      end
 
   		private
-			def children
-				@li
-			end
-					
-			def rdf_validate(tags)
-				_validate(tags, [["li", '*']])
-			end
-
-			def _tags
-				rv = []
-				@li.each do |x|
-					rv << [URI, "li"]
-				end
-				rv
-			end
-
-		end
-
-		class Li < Element
-
-			include RSS10
-
-			class << self
-					
-				def required_uri
-					URI
-				end
-				
-			end
-			
-			[
-				["resource", [URI, nil], true]
-			].each do |name, uri, required|
-				install_get_attribute(name, uri, required)
-			end
-			
-			def initialize(resource=nil)
-				super()
-				@resource = resource
-			end
-			
-			def to_s(convert=true, indent=calc_indent)
-				if @resource
-					rv = %Q!#{indent}<#{PREFIX}:li resource="#{h @resource}" />\n!
-					rv = @converter.convert(rv) if convert and @converter
-					rv
-				else
-					''
-				end
-			end
-
-			private
-			def _attrs
-				[
-					["resource", true]
-				]
-			end
-			
-		end
-
-		class Channel < Element
-
-			include RSS10
-			
-			class << self
-
-				def required_uri
-					::RSS::URI
-				end
-
-			end
+      def children
+        @li
+      end
+          
+      def rdf_validate(tags)
+        _validate(tags, [["li", '*']])
+      end
+
+      def _tags
+        rv = []
+        @li.each do |x|
+          rv << [URI, "li"]
+        end
+        rv
+      end
+
+    end
+
+    class Li < Element
+
+      include RSS10
+
+      class << self
+          
+        def required_uri
+          URI
+        end
+        
+      end
+      
+      [
+        ["resource", [URI, nil], true]
+      ].each do |name, uri, required|
+        install_get_attribute(name, uri, required)
+      end
+      
+      def initialize(resource=nil)
+        super()
+        @resource = resource
+      end
+      
+      def to_s(convert=true, indent=calc_indent)
+        if @resource
+          rv = %Q!#{indent}<#{PREFIX}:li resource="#{h @resource}" />\n!
+          rv = @converter.convert(rv) if convert and @converter
+          rv
+        else
+          ''
+        end
+      end
+
+      private
+      def _attrs
+        [
+          ["resource", true]
+        ]
+      end
+      
+    end
+
+    class Channel < Element
+
+      include RSS10
+      
+      class << self
+
+        def required_uri
+          ::RSS::URI
+        end
+
+      end
 
  			[
-				["about", URI, true]
-			].each do |name, uri, required|
-				install_get_attribute(name, uri, required)
-			end
-
-			%w(title link description).each do |x|
-				install_text_element(x)
-			end
-
-			%w(image items textinput).each do |x|
-				install_have_child_element(x)
-			end
-			
-			[
-				['title', nil],
-				['link', nil],
-				['description', nil],
-				['image', '?'],
-				['items', nil],
-				['textinput', '?'],
-			].each do |tag, occurs|
-				install_model(tag, occurs)
-			end
-			
-			def initialize(about=nil)
-				super()
-				@about = about
-			end
-
-			def to_s(convert=true, indent=calc_indent)
-				next_indent = indent + INDENT
-				about = ''
-				about << %Q!#{PREFIX}:about="#{h @about}"! if @about
-				rv = <<-EOT
+        ["about", URI, true]
+      ].each do |name, uri, required|
+        install_get_attribute(name, uri, required)
+      end
+
+      %w(title link description).each do |x|
+        install_text_element(x)
+      end
+
+      %w(image items textinput).each do |x|
+        install_have_child_element(x)
+      end
+      
+      [
+        ['title', nil],
+        ['link', nil],
+        ['description', nil],
+        ['image', '?'],
+        ['items', nil],
+        ['textinput', '?'],
+      ].each do |tag, occurs|
+        install_model(tag, occurs)
+      end
+      
+      def initialize(about=nil)
+        super()
+        @about = about
+      end
+
+      def to_s(convert=true, indent=calc_indent)
+        next_indent = indent + INDENT
+        about = ''
+        about << %Q!#{PREFIX}:about="#{h @about}"! if @about
+        rv = <<-EOT
 #{indent}<channel #{about}>
 #{title_element(false, next_indent)}
 #{link_element(false, next_indent)}
@@ -246,216 +246,216 @@ EOT
 #{other_element(false, next_indent)}
 #{indent}</channel>
 EOT
-	      rv = @converter.convert(rv) if convert and @converter
+        rv = @converter.convert(rv) if convert and @converter
   	    rv
-			end
-
-	    private
-			def children
-				[@image, @items, @textinput]
-			end
-
-			def _tags
-				[
-					[::RSS::URI, 'title'],
-					[::RSS::URI, 'link'],
-					[::RSS::URI, 'description'],
-					[::RSS::URI, 'image'],
-					[::RSS::URI, 'items'],
-					[::RSS::URI, 'textinput'],
-				].delete_if do |x|
-					send(x[1]).nil?
-				end
-			end
-
-			def _attrs
-				[
-					["about", true]
-				]
-			end
-			
-			class Image < Element
-				
-				include RSS10
-
-				class << self
-					
-					def required_uri
-						::RSS::URI
-					end
-
-				end
-
-				[
-					["resource", URI, true]
-				].each do |name, uri, required|
-					install_get_attribute(name, uri, required)
-				end
-			
-				def initialize(resource=nil)
-					super()
-					@resource = resource
-				end
-
-				def to_s(convert=true, indent=calc_indent)
-					if @resource
-						rv = %Q!#{indent}<image #{PREFIX}:resource="#{h @resource}" />!
-						rv = @converter.convert(rv) if convert and @converter
-						rv
-					else
-						''
-					end
-				end
-
-				private
-				def _attrs
-					[
-						["resource", true]
-					]
-				end
-
-			end
-
-			class Textinput < Element
-				
-				include RSS10
-
-				class << self
-					
-					def required_uri
-						::RSS::URI
-					end
-
-				end
-
-				[
-					["resource", URI, true]
-				].each do |name, uri, required|
-					install_get_attribute(name, uri, required)
-				end
-			
-				def initialize(resource=nil)
-					super()
-					@resource = resource
-				end
-
-				def to_s(convert=true, indent=calc_indent)
-					if @resource
-						rv = %Q|#{indent}<textinput #{PREFIX}:resource="#{h @resource}" />|
-						rv = @converter.convert(rv) if convert and @converter
-						rv
-					else
-						''
-					end
-				end
-				
-				private
-				def _attrs
-					[
-						["resource", true],
-					]
-				end
-
-			end
-			
-			class Items < Element
-
-				include RSS10
-
-				Seq = ::RSS::RDF::Seq
-				class Seq
-					unless const_defined?(:Li)
-						Li = ::RSS::RDF::Li
-					end
-				end
-
-				class << self
-					
-					def required_uri
-						::RSS::URI
-					end
-					
-				end
-
-				install_have_child_element("Seq")
-				
-				install_must_call_validator('rdf', ::RSS::RDF::URI)
-				
-				def initialize(seq=Seq.new)
-					super()
-					@Seq = seq
-				end
-				
-				def to_s(convert=true, indent=calc_indent)
-					next_indent = indent + INDENT
-					<<-EOT
+      end
+
+      private
+      def children
+        [@image, @items, @textinput]
+      end
+
+      def _tags
+        [
+          [::RSS::URI, 'title'],
+          [::RSS::URI, 'link'],
+          [::RSS::URI, 'description'],
+          [::RSS::URI, 'image'],
+          [::RSS::URI, 'items'],
+          [::RSS::URI, 'textinput'],
+        ].delete_if do |x|
+          send(x[1]).nil?
+        end
+      end
+
+      def _attrs
+        [
+          ["about", true]
+        ]
+      end
+      
+      class Image < Element
+        
+        include RSS10
+
+        class << self
+          
+          def required_uri
+            ::RSS::URI
+          end
+
+        end
+
+        [
+          ["resource", URI, true]
+        ].each do |name, uri, required|
+          install_get_attribute(name, uri, required)
+        end
+      
+        def initialize(resource=nil)
+          super()
+          @resource = resource
+        end
+
+        def to_s(convert=true, indent=calc_indent)
+          if @resource
+            rv = %Q!#{indent}<image #{PREFIX}:resource="#{h @resource}" />!
+            rv = @converter.convert(rv) if convert and @converter
+            rv
+          else
+            ''
+          end
+        end
+
+        private
+        def _attrs
+          [
+            ["resource", true]
+          ]
+        end
+
+      end
+
+      class Textinput < Element
+        
+        include RSS10
+
+        class << self
+          
+          def required_uri
+            ::RSS::URI
+          end
+
+        end
+
+        [
+          ["resource", URI, true]
+        ].each do |name, uri, required|
+          install_get_attribute(name, uri, required)
+        end
+      
+        def initialize(resource=nil)
+          super()
+          @resource = resource
+        end
+
+        def to_s(convert=true, indent=calc_indent)
+          if @resource
+            rv = %Q|#{indent}<textinput #{PREFIX}:resource="#{h @resource}" />|
+            rv = @converter.convert(rv) if convert and @converter
+            rv
+          else
+            ''
+          end
+        end
+        
+        private
+        def _attrs
+          [
+            ["resource", true],
+          ]
+        end
+
+      end
+      
+      class Items < Element
+
+        include RSS10
+
+        Seq = ::RSS::RDF::Seq
+        class Seq
+          unless const_defined?(:Li)
+            Li = ::RSS::RDF::Li
+          end
+        end
+
+        class << self
+          
+          def required_uri
+            ::RSS::URI
+          end
+          
+        end
+
+        install_have_child_element("Seq")
+        
+        install_must_call_validator('rdf', ::RSS::RDF::URI)
+        
+        def initialize(seq=Seq.new)
+          super()
+          @Seq = seq
+        end
+        
+        def to_s(convert=true, indent=calc_indent)
+          next_indent = indent + INDENT
+          <<-EOT
 #{indent}<items>
 #{Seq_element(convert, next_indent)}
 #{other_element(convert, next_indent)}
 #{indent}</items>
 EOT
-				end
-
-				private
-				def children
-					[@Seq]
-				end
-
-				private
-				def _tags
-					rv = []
-					rv << [URI, 'Seq'] unless @Seq.nil?
-					rv
-				end
-				
-				def rdf_validate(tags)
-					_validate(tags, [["Seq", nil]])
-				end
-
-			end
-
-		end
-
-		class Image < Element
-
-			include RSS10
-
-			class << self
-				
-				def required_uri
-					::RSS::URI
-				end
-
-			end
-			
-			[
-				["about", URI, true]
-			].each do |name, uri, required|
-				install_get_attribute(name, uri, required)
-			end
-
-			%w(title url link).each do |x|
-				install_text_element(x)
-			end
-		
-			[
-				['title', nil],
-				['url', nil],
-				['link', nil],
-			].each do |tag, occurs|
-				install_model(tag, occurs)
-			end
-
-			def initialize(about=nil)
-				super()
-				@about = about
-			end
-
-			def to_s(convert=true, indent=calc_indent)
-				next_indent = indent + INDENT
-				about = ''
-				about << %Q!#{PREFIX}:about="#{h @about}"! if @about
-				rv = <<-EOT
+        end
+
+        private
+        def children
+          [@Seq]
+        end
+
+        private
+        def _tags
+          rv = []
+          rv << [URI, 'Seq'] unless @Seq.nil?
+          rv
+        end
+        
+        def rdf_validate(tags)
+          _validate(tags, [["Seq", nil]])
+        end
+
+      end
+
+    end
+
+    class Image < Element
+
+      include RSS10
+
+      class << self
+        
+        def required_uri
+          ::RSS::URI
+        end
+
+      end
+      
+      [
+        ["about", URI, true]
+      ].each do |name, uri, required|
+        install_get_attribute(name, uri, required)
+      end
+
+      %w(title url link).each do |x|
+        install_text_element(x)
+      end
+    
+      [
+        ['title', nil],
+        ['url', nil],
+        ['link', nil],
+      ].each do |tag, occurs|
+        install_model(tag, occurs)
+      end
+
+      def initialize(about=nil)
+        super()
+        @about = about
+      end
+
+      def to_s(convert=true, indent=calc_indent)
+        next_indent = indent + INDENT
+        about = ''
+        about << %Q!#{PREFIX}:about="#{h @about}"! if @about
+        rv = <<-EOT
 #{indent}<image #{about}>
 #{title_element(false, next_indent)}
 #{url_element(false, next_indent)}
@@ -463,69 +463,69 @@ EOT
 #{other_element(false, next_indent)}
 #{indent}</image>
 EOT
-	      rv = @converter.convert(rv) if convert and @converter
-	      rv
-			end
-
-			private
-			def _tags
-				[
-					[::RSS::URI, 'title'],
-					[::RSS::URI, 'url'],
-					[::RSS::URI, 'link'],
-				].delete_if do |x|
-					send(x[1]).nil?
-				end
-			end
-
-			def _attrs
-				[
-					["about", true],
-				]
-			end
-
-		end
-
-		class Item < Element
-
-			include RSS10
-
-			class << self
-
-				def required_uri
-					::RSS::URI
-				end
-				
-			end
-
-			[
-				["about", URI, true]
-			].each do |name, uri, required|
-				install_get_attribute(name, uri, required)
-			end
-
-			%w(title link description).each do |x|
-				install_text_element(x)
-			end
-
-			[
-				["title", nil],
-				["link", nil],
-				["description", "?"],
-			].each do |tag, occurs|
-				install_model(tag, occurs)
-			end
-
-			def initialize(about=nil)
-				super()
-				@about = about
-			end
-
-			def to_s(convert=true, indent=calc_indent)
-				next_indent = indent + INDENT
-				about = ''
-				about << %Q!#{PREFIX}:about="#{h @about}"! if @about
-				rv = <<-EOT
+        rv = @converter.convert(rv) if convert and @converter
+        rv
+      end
+
+      private
+      def _tags
+        [
+          [::RSS::URI, 'title'],
+          [::RSS::URI, 'url'],
+          [::RSS::URI, 'link'],
+        ].delete_if do |x|
+          send(x[1]).nil?
+        end
+      end
+
+      def _attrs
+        [
+          ["about", true],
+        ]
+      end
+
+    end
+
+    class Item < Element
+
+      include RSS10
+
+      class << self
+
+        def required_uri
+          ::RSS::URI
+        end
+        
+      end
+
+      [
+        ["about", URI, true]
+      ].each do |name, uri, required|
+        install_get_attribute(name, uri, required)
+      end
+
+      %w(title link description).each do |x|
+        install_text_element(x)
+      end
+
+      [
+        ["title", nil],
+        ["link", nil],
+        ["description", "?"],
+      ].each do |tag, occurs|
+        install_model(tag, occurs)
+      end
+
+      def initialize(about=nil)
+        super()
+        @about = about
+      end
+
+      def to_s(convert=true, indent=calc_indent)
+        next_indent = indent + INDENT
+        about = ''
+        about << %Q!#{PREFIX}:about="#{h @about}"! if @about
+        rv = <<-EOT
 #{indent}<item #{about}>
 #{title_element(false, next_indent)}
 #{link_element(false, next_indent)}
@@ -533,70 +533,70 @@ EOT
 #{other_element(false, next_indent)}
 #{indent}</item>
 EOT
-	      rv = @converter.convert(rv) if convert and @converter
-	      rv
-			end
+        rv = @converter.convert(rv) if convert and @converter
+        rv
+      end
  
-			private
-			def _tags
-				[
-					[::RSS::URI, 'title'],
-					[::RSS::URI, 'link'],
-					[::RSS::URI, 'description'],
-				].delete_if do |x|
-					send(x[1]).nil?
-				end
-			end
-
-			def _attrs
-				[
-					["about", true],
-				]
-			end
-
-		end
-
-		class Textinput < Element
-
-			include RSS10
-
-			class << self
-
-				def required_uri
-					::RSS::URI
-				end
-
-			end
-
-			[
-				["about", URI, true]
-			].each do |name, uri, required|
-				install_get_attribute(name, uri, required)
-			end
-
-			%w(title description name link).each do |x|
-				install_text_element(x)
-			end
-		
-			[
-				["title", nil],
-				["description", nil],
-				["name", nil],
-				["link", nil],
-			].each do |tag, occurs|
-				install_model(tag, occurs)
-			end
-
-			def initialize(about=nil)
-				super()
-				@about = about
-			end
-
-			def to_s(convert=true, indent=calc_indent)
-				next_indent = indent + INDENT
-				about = ''
-				about << %Q!#{PREFIX}:about="#{h @about}"! if @about
-				rv = <<-EOT
+      private
+      def _tags
+        [
+          [::RSS::URI, 'title'],
+          [::RSS::URI, 'link'],
+          [::RSS::URI, 'description'],
+        ].delete_if do |x|
+          send(x[1]).nil?
+        end
+      end
+
+      def _attrs
+        [
+          ["about", true],
+        ]
+      end
+
+    end
+
+    class Textinput < Element
+
+      include RSS10
+
+      class << self
+
+        def required_uri
+          ::RSS::URI
+        end
+
+      end
+
+      [
+        ["about", URI, true]
+      ].each do |name, uri, required|
+        install_get_attribute(name, uri, required)
+      end
+
+      %w(title description name link).each do |x|
+        install_text_element(x)
+      end
+    
+      [
+        ["title", nil],
+        ["description", nil],
+        ["name", nil],
+        ["link", nil],
+      ].each do |tag, occurs|
+        install_model(tag, occurs)
+      end
+
+      def initialize(about=nil)
+        super()
+        @about = about
+      end
+
+      def to_s(convert=true, indent=calc_indent)
+        next_indent = indent + INDENT
+        about = ''
+        about << %Q!#{PREFIX}:about="#{h @about}"! if @about
+        rv = <<-EOT
 #{indent}<textinput #{about}>
 #{title_element(false, next_indent)}
 #{description_element(false, next_indent)}
@@ -605,49 +605,49 @@ EOT
 #{other_element(false, next_indent)}
 #{indent}</textinput>
 EOT
-	      rv = @converter.convert(rv) if convert and @converter
-	      rv
-			end
-
-			private
-			def _tags
-				[
-					[::RSS::URI, 'title'],
-					[::RSS::URI, 'description'],
-					[::RSS::URI, 'name'],
-					[::RSS::URI, 'link'],
-				].delete_if do |x|
-					send(x[1]).nil?
-				end
-			end
-			
-			def _attrs
-				[
-					["about", true],
-				]
-			end
-
-		end
-
-	end
-
-	RSS10::ELEMENTS.each do |x|
-		BaseListener.install_get_text_element(x, URI, "#{x}=")
-	end
-
-	module ListenerMixin
-		private
-		def start_RDF(tag_name, prefix, attrs, ns)
-			check_ns(tag_name, prefix, ns, RDF::URI)
-
-			@rss = RDF.new(@version, @encoding, @standalone)
-			@rss.do_validate = @do_validate
-			@rss.xml_stylesheets = @xml_stylesheets
-			@last_element = @rss
-			@proc_stack.push Proc.new { |text, tags|
-				@rss.validate_for_stream(tags) if @do_validate
-			}
-		end
-	end
+        rv = @converter.convert(rv) if convert and @converter
+        rv
+      end
+
+      private
+      def _tags
+        [
+          [::RSS::URI, 'title'],
+          [::RSS::URI, 'description'],
+          [::RSS::URI, 'name'],
+          [::RSS::URI, 'link'],
+        ].delete_if do |x|
+          send(x[1]).nil?
+        end
+      end
+      
+      def _attrs
+        [
+          ["about", true],
+        ]
+      end
+
+    end
+
+  end
+
+  RSS10::ELEMENTS.each do |x|
+    BaseListener.install_get_text_element(x, URI, "#{x}=")
+  end
+
+  module ListenerMixin
+    private
+    def start_RDF(tag_name, prefix, attrs, ns)
+      check_ns(tag_name, prefix, ns, RDF::URI)
+
+      @rss = RDF.new(@version, @encoding, @standalone)
+      @rss.do_validate = @do_validate
+      @rss.xml_stylesheets = @xml_stylesheets
+      @last_element = @rss
+      @proc_stack.push Proc.new { |text, tags|
+        @rss.validate_for_stream(tags) if @do_validate
+      }
+    end
+  end
 
 end
diff --git a/lib/rss/2.0.rb b/lib/rss/2.0.rb
index c4d055e984..7fafb23ba9 100644
--- a/lib/rss/2.0.rb
+++ b/lib/rss/2.0.rb
@@ -2,149 +2,149 @@ require "rss/0.9"
 
 module RSS
 
-	class Rss
+  class Rss
 
-		class Channel
+    class Channel
 
-			%w(generator ttl).each do |x|
-				install_text_element(x)
-				install_model(x, '?')
-			end
+      %w(generator ttl).each do |x|
+        install_text_element(x)
+        install_model(x, '?')
+      end
 
-			%w(category).each do |x|
-				install_have_child_element(x)
-				install_model(x, '?')
-			end
+      %w(category).each do |x|
+        install_have_child_element(x)
+        install_model(x, '?')
+      end
 
-			[
-				["image", "?"],
-				["language", "?"],
-			].each do |x, occurs|
-				install_model(x, occurs)
-			end
+      [
+        ["image", "?"],
+        ["language", "?"],
+      ].each do |x, occurs|
+        install_model(x, occurs)
+      end
 
-			def other_element(convert, indent)
-				rv = <<-EOT
+      def other_element(convert, indent)
+        rv = <<-EOT
 #{category_element(convert, indent)}
 #{generator_element(convert, indent)}
 #{ttl_element(convert, indent)}
 EOT
-				rv << super
-			end
-			
-			private
-			alias children09 children
-			def children
-				children09 + [@category].compact
-			end
-
-			alias _tags09 _tags
-			def _tags
-				%w(generator ttl category).delete_if do |x|
-					send(x).nil?
-				end.collect do |elem|
-					[nil, elem]
-				end + _tags09
-			end
-
-			Category = Item::Category
-
-			class Item
-			
-				[
-					["comments", "?"],
-					["author", "?"],
-				].each do |x, occurs|
-					install_text_element(x)
-					install_model(x, occurs)
-				end
-
-				[
-					["pubDate", '?'],
-				].each do |x, occurs|
-					install_date_element(x, 'rfc822')
-					install_model(x, occurs)
-				end
-
-				[
-					["guid", '?'],
-				].each do |x, occurs|
-					install_have_child_element(x)
-					install_model(x, occurs)
-				end
-			
-				def other_element(convert, indent)
-					rv = <<-EOT
+        rv << super
+      end
+      
+      private
+      alias children09 children
+      def children
+        children09 + [@category].compact
+      end
+
+      alias _tags09 _tags
+      def _tags
+        %w(generator ttl category).delete_if do |x|
+          send(x).nil?
+        end.collect do |elem|
+          [nil, elem]
+        end + _tags09
+      end
+
+      Category = Item::Category
+
+      class Item
+      
+        [
+          ["comments", "?"],
+          ["author", "?"],
+        ].each do |x, occurs|
+          install_text_element(x)
+          install_model(x, occurs)
+        end
+
+        [
+          ["pubDate", '?'],
+        ].each do |x, occurs|
+          install_date_element(x, 'rfc822')
+          install_model(x, occurs)
+        end
+
+        [
+          ["guid", '?'],
+        ].each do |x, occurs|
+          install_have_child_element(x)
+          install_model(x, occurs)
+        end
+      
+        def other_element(convert, indent)
+          rv = <<-EOT
 #{author_element(false, indent)}
 #{comments_element(false, indent)}
 #{pubDate_element(false, indent)}
 #{guid_element(false, indent)}
 EOT
-					rv << super
-				end
-
-				private
-				alias children09 children
-				def children
-					children09 + [@guid].compact
-				end
-
-				alias _tags09 _tags
-				def _tags
-					%w(comments author pubDate guid).delete_if do |x|
-						send(x).nil?
-					end.collect do |elem|
-						[nil, elem]
-					end + _tags09
-				end
-
-				class Guid < Element
-					
-					include RSS09
-
-					[
-						["isPermaLink", nil, false]
-					].each do |name, uri, required|
-						install_get_attribute(name, uri, required)
-					end
-
-					content_setup
-
-					def initialize(isPermaLink=nil, content=nil)
-						super()
-						@isPermaLink = isPermaLink
-						@content = content
-					end
-
-					def to_s(convert=true, indent=calc_indent)
-						if @content
-							rv = %Q!<guid!
-							rv << %Q! isPermaLink="#{h @isPermaLink}"! if @isPermaLink
-							rv << %Q!>#{h @content}</guid>!
-							rv = @converter.convert(rv) if convert and @converter
-							rv
-						else
-							''
-						end
-					end
-
-					private
-					def _attrs
-						[
-							["isPermaLink", false]
-						]
-					end
-
-				end
-
-			end
-
-		end
-
-	end
-
-	RSS09::ELEMENTS.each do |x|
-		BaseListener.install_get_text_element(x, nil, "#{x}=")
-	end
+          rv << super
+        end
+
+        private
+        alias children09 children
+        def children
+          children09 + [@guid].compact
+        end
+
+        alias _tags09 _tags
+        def _tags
+          %w(comments author pubDate guid).delete_if do |x|
+            send(x).nil?
+          end.collect do |elem|
+            [nil, elem]
+          end + _tags09
+        end
+
+        class Guid < Element
+          
+          include RSS09
+
+          [
+            ["isPermaLink", nil, false]
+          ].each do |name, uri, required|
+            install_get_attribute(name, uri, required)
+          end
+
+          content_setup
+
+          def initialize(isPermaLink=nil, content=nil)
+            super()
+            @isPermaLink = isPermaLink
+            @content = content
+          end
+
+          def to_s(convert=true, indent=calc_indent)
+            if @content
+              rv = %Q!<guid!
+              rv << %Q! isPermaLink="#{h @isPermaLink}"! if @isPermaLink
+              rv << %Q!>#{h @content}</guid>!
+              rv = @converter.convert(rv) if convert and @converter
+              rv
+            else
+              ''
+            end
+          end
+
+          private
+          def _attrs
+            [
+              ["isPermaLink", false]
+            ]
+          end
+
+        end
+
+      end
+
+    end
+
+  end
+
+  RSS09::ELEMENTS.each do |x|
+    BaseListener.install_get_text_element(x, nil, "#{x}=")
+  end
 
 end
diff --git a/lib/rss/content.rb b/lib/rss/content.rb
index a8ed962644..4367d16d92 100644
--- a/lib/rss/content.rb
+++ b/lib/rss/content.rb
@@ -2,51 +2,51 @@ require "rss/1.0"
 
 module RSS
 
-	CONTENT_PREFIX = 'content'
-	CONTENT_URI = "http://purl.org/rss/1.0/modules/content/"
-
-	RDF.install_ns(CONTENT_PREFIX, CONTENT_URI)
-
-	module ContentModel
-
-		extend BaseModel
-
-		ELEMENTS = []
-
-		def self.append_features(klass)
-			super
-			
-			klass.module_eval(<<-EOC)
-				%w(encoded).each do |x|
-					install_text_element("\#{CONTENT_PREFIX}_\#{x}")
-				end
-			EOC
-		end
-
-		def content_validate(tags)
-			counter = {}
-			ELEMENTS.each do |x|
-				counter[x] = 0
-			end
-
-			tags.each do |tag|
-				key = "#{CONTENT_PREFIX}_#{tag}"
-				raise UnknownTagError.new(tag, CONTENT_URI) unless counter.has_key?(key)
-				counter[key] += 1
-				raise TooMuchTagError.new(tag, tag_name) if counter[key] > 1
-			end
-		end
-
-	end
-
-	class RDF
-		class Item; include ContentModel; end
-	end
-
-	prefix_size = CONTENT_PREFIX.size + 1
-	ContentModel::ELEMENTS.uniq!
-	ContentModel::ELEMENTS.each do |x|
-		BaseListener.install_get_text_element(x[prefix_size..-1], CONTENT_URI, "#{x}=")
-	end
+  CONTENT_PREFIX = 'content'
+  CONTENT_URI = "http://purl.org/rss/1.0/modules/content/"
+
+  RDF.install_ns(CONTENT_PREFIX, CONTENT_URI)
+
+  module ContentModel
+
+    extend BaseModel
+
+    ELEMENTS = []
+
+    def self.append_features(klass)
+      super
+      
+      klass.module_eval(<<-EOC)
+        %w(encoded).each do |x|
+          install_text_element("\#{CONTENT_PREFIX}_\#{x}")
+        end
+      EOC
+    end
+
+    def content_validate(tags)
+      counter = {}
+      ELEMENTS.each do |x|
+        counter[x] = 0
+      end
+
+      tags.each do |tag|
+        key = "#{CONTENT_PREFIX}_#{tag}"
+        raise UnknownTagError.new(tag, CONTENT_URI) unless counter.has_key?(key)
+        counter[key] += 1
+        raise TooMuchTagError.new(tag, tag_name) if counter[key] > 1
+      end
+    end
+
+  end
+
+  class RDF
+    class Item; include ContentModel; end
+  end
+
+  prefix_size = CONTENT_PREFIX.size + 1
+  ContentModel::ELEMENTS.uniq!
+  ContentModel::ELEMENTS.each do |x|
+    BaseListener.install_get_text_element(x[prefix_size..-1], CONTENT_URI, "#{x}=")
+  end
 
 end
diff --git a/lib/rss/converter.rb b/lib/rss/converter.rb
index 472da2e0a9..7ad79db318 100644
--- a/lib/rss/converter.rb
+++ b/lib/rss/converter.rb
@@ -2,154 +2,154 @@ require "rss/utils"
 
 module RSS
 
-	class Converter
-		
-		include Utils
+  class Converter
+    
+    include Utils
 
-		def initialize(to_enc, from_enc=nil)
-			normalized_to_enc = to_enc.downcase.gsub(/-/, '_')
-			from_enc ||= 'utf-8'
-			normalized_from_enc = from_enc.downcase.gsub(/-/, '_')
-			if normalized_to_enc == normalized_from_enc
-				def_same_enc()
-			else
-				def_diff_enc = "def_to_#{normalized_to_enc}_from_#{normalized_from_enc}"
-				if respond_to?(def_diff_enc)
-					__send__(def_diff_enc)
-				else
-					def_else_enc(to_enc, from_enc)
-				end
-			end
-		end
+    def initialize(to_enc, from_enc=nil)
+      normalized_to_enc = to_enc.downcase.gsub(/-/, '_')
+      from_enc ||= 'utf-8'
+      normalized_from_enc = from_enc.downcase.gsub(/-/, '_')
+      if normalized_to_enc == normalized_from_enc
+        def_same_enc()
+      else
+        def_diff_enc = "def_to_#{normalized_to_enc}_from_#{normalized_from_enc}"
+        if respond_to?(def_diff_enc)
+          __send__(def_diff_enc)
+        else
+          def_else_enc(to_enc, from_enc)
+        end
+      end
+    end
 
-		def convert(value)
-			value
-		end
+    def convert(value)
+      value
+    end
 
-		def def_convert(depth=0)
-			instance_eval(<<-EOC, *get_file_and_line_from_caller(depth))
-			def convert(value)
-				if value.kind_of?(String)
-					#{yield('value')}
-				else
-					value
-				end
-			end
-			EOC
-		end
+    def def_convert(depth=0)
+      instance_eval(<<-EOC, *get_file_and_line_from_caller(depth))
+      def convert(value)
+        if value.kind_of?(String)
+          #{yield('value')}
+        else
+          value
+        end
+      end
+      EOC
+    end
 
-		def def_iconv_convert(to_enc, from_enc, depth=0)
-			begin
-				require "iconv"
-				@iconv = Iconv.new(to_enc, from_enc)
-				def_convert(depth+1) do |value|
-					<<-EOC
-					begin
-						@iconv.iconv(#{value})
-					rescue Iconv::Failure
-						raise ConversionError.new(#{value}, "#{to_enc}", "#{from_enc}")
-					end
-					EOC
-				end
-			rescue LoadError, ArgumentError, SystemCallError
-				raise UnknownConversionMethodError.new(to_enc, from_enc)
-			end
-		end
-		
-		def def_else_enc(to_enc, from_enc)
-			def_iconv_convert(to_enc, from_enc, 0)
-		end
-		
-		def def_same_enc()
-			def_convert do |value|
-				value
-			end
-		end
+    def def_iconv_convert(to_enc, from_enc, depth=0)
+      begin
+        require "iconv"
+        @iconv = Iconv.new(to_enc, from_enc)
+        def_convert(depth+1) do |value|
+          <<-EOC
+          begin
+            @iconv.iconv(#{value})
+          rescue Iconv::Failure
+            raise ConversionError.new(#{value}, "#{to_enc}", "#{from_enc}")
+          end
+          EOC
+        end
+      rescue LoadError, ArgumentError, SystemCallError
+        raise UnknownConversionMethodError.new(to_enc, from_enc)
+      end
+    end
+    
+    def def_else_enc(to_enc, from_enc)
+      def_iconv_convert(to_enc, from_enc, 0)
+    end
+    
+    def def_same_enc()
+      def_convert do |value|
+        value
+      end
+    end
 
-		def def_uconv_convert_if_can(meth, to_enc, from_enc)
-			begin
-				require "uconv"
-				def_convert(1) do |value|
-					<<-EOC
-					begin
-						Uconv.#{meth}(#{value})
-					rescue Uconv::Error
-						raise ConversionError.new(#{value}, "#{to_enc}", "#{from_enc}")
-					end
-					EOC
-				end
-			rescue LoadError
-				def_iconv_convert(to_enc, from_enc, 1)
-			end
-		end
+    def def_uconv_convert_if_can(meth, to_enc, from_enc)
+      begin
+        require "uconv"
+        def_convert(1) do |value|
+          <<-EOC
+          begin
+            Uconv.#{meth}(#{value})
+          rescue Uconv::Error
+            raise ConversionError.new(#{value}, "#{to_enc}", "#{from_enc}")
+          end
+          EOC
+        end
+      rescue LoadError
+        def_iconv_convert(to_enc, from_enc, 1)
+      end
+    end
 
-		def def_to_euc_jp_from_utf_8
-			def_uconv_convert_if_can('u8toeuc', 'EUC-JP', 'UTF-8')
-		end
-		
-		def def_to_utf_8_from_euc_jp
-			def_uconv_convert_if_can('euctou8', 'UTF-8', 'EUC-JP')
-		end
-		
-		def def_to_shift_jis_from_utf_8
-			def_uconv_convert_if_can('u8tosjis', 'Shift_JIS', 'UTF-8')
-		end
-		
-		def def_to_utf_8_from_shift_jis
-			def_uconv_convert_if_can('sjistou8', 'UTF-8', 'Shift_JIS')
-		end
-		
-		def def_to_euc_jp_from_shift_jis
-			require "nkf"
-			def_convert do |value|
-				"NKF.nkf('-Se', #{value})"
-			end
-		end
-		
-		def def_to_shift_jis_from_euc_jp
-			require "nkf"
-			def_convert do |value|
-				"NKF.nkf('-Es', #{value})"
-			end
-		end
-		
-		def def_to_euc_jp_from_iso_2022_jp
-			require "nkf"
-			def_convert do |value|
-				"NKF.nkf('-Je', #{value})"
-			end
-		end
-		
-		def def_to_iso_2022_jp_from_euc_jp
-			require "nkf"
-			def_convert do |value|
-				"NKF.nkf('-Ej', #{value})"
-			end
-		end
+    def def_to_euc_jp_from_utf_8
+      def_uconv_convert_if_can('u8toeuc', 'EUC-JP', 'UTF-8')
+    end
+    
+    def def_to_utf_8_from_euc_jp
+      def_uconv_convert_if_can('euctou8', 'UTF-8', 'EUC-JP')
+    end
+    
+    def def_to_shift_jis_from_utf_8
+      def_uconv_convert_if_can('u8tosjis', 'Shift_JIS', 'UTF-8')
+    end
+    
+    def def_to_utf_8_from_shift_jis
+      def_uconv_convert_if_can('sjistou8', 'UTF-8', 'Shift_JIS')
+    end
+    
+    def def_to_euc_jp_from_shift_jis
+      require "nkf"
+      def_convert do |value|
+        "NKF.nkf('-Se', #{value})"
+      end
+    end
+    
+    def def_to_shift_jis_from_euc_jp
+      require "nkf"
+      def_convert do |value|
+        "NKF.nkf('-Es', #{value})"
+      end
+    end
+    
+    def def_to_euc_jp_from_iso_2022_jp
+      require "nkf"
+      def_convert do |value|
+        "NKF.nkf('-Je', #{value})"
+      end
+    end
+    
+    def def_to_iso_2022_jp_from_euc_jp
+      require "nkf"
+      def_convert do |value|
+        "NKF.nkf('-Ej', #{value})"
+      end
+    end
 
-		def def_to_utf_8_from_iso_8859_1
-			def_convert do |value|
-				"#{value}.unpack('C*').pack('U*')"
-			end
-		end
-		
-		def def_to_iso_8859_1_from_utf_8
-			def_convert do |value|
-				<<-EOC
-				array_utf8 = #{value}.unpack('U*')
-				array_enc = []
-				array_utf8.each do |num|
-					if num <= 0xFF
-						array_enc << num
-					else
-						array_enc.concat "&\#\#{num};".unpack('C*')
-					end
-				end
-				array_enc.pack('C*')
-				EOC
-			end
-		end
-		
-	end
-	
+    def def_to_utf_8_from_iso_8859_1
+      def_convert do |value|
+        "#{value}.unpack('C*').pack('U*')"
+      end
+    end
+    
+    def def_to_iso_8859_1_from_utf_8
+      def_convert do |value|
+        <<-EOC
+        array_utf8 = #{value}.unpack('U*')
+        array_enc = []
+        array_utf8.each do |num|
+          if num <= 0xFF
+            array_enc << num
+          else
+            array_enc.concat "&\#\#{num};".unpack('C*')
+          end
+        end
+        array_enc.pack('C*')
+        EOC
+      end
+    end
+    
+  end
+  
 end
diff --git a/lib/rss/dublincore.rb b/lib/rss/dublincore.rb
index c757b6279b..417ab5b179 100644
--- a/lib/rss/dublincore.rb
+++ b/lib/rss/dublincore.rb
@@ -2,63 +2,63 @@ require "rss/1.0"
 
 module RSS
 
-	DC_PREFIX = 'dc'
-	DC_URI = "http://purl.org/dc/elements/1.1/"
-	
-	RDF.install_ns(DC_PREFIX, DC_URI)
+  DC_PREFIX = 'dc'
+  DC_URI = "http://purl.org/dc/elements/1.1/"
+  
+  RDF.install_ns(DC_PREFIX, DC_URI)
 
-	module DublinCoreModel
+  module DublinCoreModel
 
-		extend BaseModel
+    extend BaseModel
 
-		ELEMENTS = []
+    ELEMENTS = []
 
-		def self.append_features(klass)
-			super
-			
-			klass.module_eval(<<-EOC)
-				%w(title description creator subject publisher
-						contributor type format identifier source
-						language relation coverage rights).each do |x|
-					install_text_element("\#{DC_PREFIX}_\#{x}")
-				end
+    def self.append_features(klass)
+      super
+      
+      klass.module_eval(<<-EOC)
+        %w(title description creator subject publisher
+            contributor type format identifier source
+            language relation coverage rights).each do |x|
+          install_text_element("\#{DC_PREFIX}_\#{x}")
+        end
 
-				%w(date).each do |x|
-					install_date_element("\#{DC_PREFIX}_\#{x}", 'w3cdtf', x)
-				end
-			EOC
-		end
+        %w(date).each do |x|
+          install_date_element("\#{DC_PREFIX}_\#{x}", 'w3cdtf', x)
+        end
+      EOC
+    end
 
-		def dc_validate(tags)
-			counter = {}
-			ELEMENTS.each do |x|
-				counter[x] = 0
-			end
+    def dc_validate(tags)
+      counter = {}
+      ELEMENTS.each do |x|
+        counter[x] = 0
+      end
 
-			tags.each do |tag|
-				key = "#{DC_PREFIX}_#{tag}"
-				raise UnknownTagError.new(tag, DC_URI)  unless counter.has_key?(key)
-				counter[key] += 1
-				raise TooMuchTagError.new(tag, tag_name) if counter[key] > 1
-			end
-		end
+      tags.each do |tag|
+        key = "#{DC_PREFIX}_#{tag}"
+        raise UnknownTagError.new(tag, DC_URI)  unless counter.has_key?(key)
+        counter[key] += 1
+        raise TooMuchTagError.new(tag, tag_name) if counter[key] > 1
+      end
+    end
 
-	end
+  end
 
-	# For backward compatibility
-	DublincoreModel = DublinCoreModel
+  # For backward compatibility
+  DublincoreModel = DublinCoreModel
 
-	class RDF
-		class Channel; include DublinCoreModel; end
-		class Image; include DublinCoreModel; end
-		class Item; include DublinCoreModel; end
-		class Textinput; include DublinCoreModel; end
-	end
+  class RDF
+    class Channel; include DublinCoreModel; end
+    class Image; include DublinCoreModel; end
+    class Item; include DublinCoreModel; end
+    class Textinput; include DublinCoreModel; end
+  end
 
-	prefix_size = DC_PREFIX.size + 1
-	DublinCoreModel::ELEMENTS.uniq!
-	DublinCoreModel::ELEMENTS.each do |x|
-		BaseListener.install_get_text_element(x[prefix_size..-1], DC_URI, "#{x}=")
-	end
+  prefix_size = DC_PREFIX.size + 1
+  DublinCoreModel::ELEMENTS.uniq!
+  DublinCoreModel::ELEMENTS.each do |x|
+    BaseListener.install_get_text_element(x[prefix_size..-1], DC_URI, "#{x}=")
+  end
 
 end
diff --git a/lib/rss/parser.rb b/lib/rss/parser.rb
index 9b9ff59173..09b3213372 100644
--- a/lib/rss/parser.rb
+++ b/lib/rss/parser.rb
@@ -4,393 +4,393 @@ require "rss/rss"
 
 module RSS
 
-	class NotWellFormedError < Error
-		attr_reader :line, :element
-		def initialize(line=nil, element=nil)
-			message = "This is not well formed XML"
-			if element or line
-				message << "\nerror occurred"
-				message << " in #{element}" if element
-				message << " at about #{line} line" if line
-			end
-			message << "\n#{yield}" if block_given?
-			super(message)
-		end
-	end
-
-	class XMLParserNotFound < Error
-		def initialize
-			super("available XML parser does not found in " <<
-						"#{AVAILABLE_PARSER_LIBRARIES.inspect}.")
-		end
-	end
-
-	class NotValidXMLParser < Error
-		def initialize(parser)
-			super("#{parser} is not available XML parser. " <<
-						"available XML parser is " <<
-						"#{AVAILABLE_PARSERS.inspect}.")
-		end
-	end
-
-	class NSError < InvalidRSSError
-		attr_reader :tag, :prefix, :uri
-		def initialize(tag, prefix, require_uri)
-			@tag, @prefix, @uri = tag, prefix, require_uri
-			super("prefix <#{prefix}> doesn't associate uri " <<
-						"<#{require_uri}> in tag <#{tag}>")
-		end
-	end
-
-	class Parser
-
-		extend Forwardable
-
-		class << self
-
-			@@default_parser = nil
-
-			def default_parser
-				@@default_parser || AVAILABLE_PARSERS.first
-			end
-
-			def default_parser=(new_value)
-				if AVAILABLE_PARSERS.include?(new_value)
-					@@default_parser = new_value
-				else
-					raise NotValidXMLParser.new(new_value)
-				end
-			end
-
-			def parse(rss, do_validate=true, ignore_unknown_element=true, parser_class=default_parser)
-				parser = new(rss, parser_class)
-				parser.do_validate = do_validate
-				parser.ignore_unknown_element = ignore_unknown_element
-				parser.parse
-			end
-
-		end
-
-		def_delegators(:@parser, :parse, :rss,
-									 :ignore_unknown_element,
-									 :ignore_unknown_element=, :do_validate,
-									 :do_validate=)
-
-		def initialize(rss, parser_class=self.class.default_parser)
-			@parser = parser_class.new(rss)
-		end
-	end
-
-	class BaseParser
-
-		def initialize(rss)
-			@listener = listener.new
-			@rss = rss
-		end
-
-		def rss
-			@listener.rss
-		end
-
-		def ignore_unknown_element
-			@listener.ignore_unknown_element
-		end
-
-		def ignore_unknown_element=(new_value)
-			@listener.ignore_unknown_element = new_value
-		end
-
-		def do_validate
-			@listener.do_validate
-		end
-
-		def do_validate=(new_value)
-			@listener.do_validate = new_value
-		end
-
-		def parse
-			if @listener.rss.nil?
-				_parse
-			end
-			@listener.rss
-		end
-
-	end
-
-	class BaseListener
-
-		extend Utils
-
-		class << self
-
-			@@setter = {}
-			@@registered_uris = {}
-
-			def install_setter(uri, tag_name, setter)
-				@@setter[uri] = {}  unless @@setter.has_key?(uri)
-				@@setter[uri][tag_name] = setter
-			end
-
-			def register_uri(name, uri)
-				@@registered_uris[name] = {}  unless @@registered_uris.has_key?(name)
-				@@registered_uris[name][uri] = nil
-			end
-
-			def uri_registered?(name, uri)
-				@@registered_uris[name].has_key?(uri)
-			end
-
-			def setter(uri, tag_name)
-				begin
-					@@setter[uri][tag_name]
-				rescue NameError
-					nil
-				end
-			end
-
-			def available_tags(uri)
-				begin
-					@@setter[uri].keys
-				rescue NameError
-					[]
-				end
-			end
-					
-			def install_get_text_element(name, uri, setter)
-				install_setter(uri, name, setter)
-				def_get_text_element(uri, name, *get_file_and_line_from_caller(1))
-			end
-			
-			private
-
-			def def_get_text_element(uri, name, file, line)
-				register_uri(name, uri)
-				unless private_instance_methods(false).include?("start_#{name}")
-					module_eval(<<-EOT, file, line)
-					def start_#{name}(name, prefix, attrs, ns)
-						uri = ns[prefix]
-						if self.class.uri_registered?(#{name.inspect}, uri)
-							if @do_validate
-								tags = self.class.available_tags(uri)
-								unless tags.include?(name)
-									raise UnknownTagError.new(name, uri)
-								end
-							end
-							start_get_text_element(name, prefix, ns, uri)
-						else
-							start_else_element(name, prefix, attrs, ns)
-						end
-					end
-					EOT
-					send("private", "start_#{name}")
-				end
-			end
-
-		end
-
-	end
-
-	module ListenerMixin
-
-		attr_reader :rss
-
-		attr_accessor :ignore_unknown_element
-		attr_accessor :do_validate
-
-		def initialize
-			@rss = nil
-			@ignore_unknown_element = true
-			@do_validate = true
-			@ns_stack = [{}]
-			@tag_stack = [[]]
-			@text_stack = ['']
-			@proc_stack = []
-			@last_element = nil
-			@version = @encoding = @standalone = nil
-			@xml_stylesheets = []
-		end
-		
-		def xmldecl(version, encoding, standalone)
-			@version, @encoding, @standalone = version, encoding, standalone
-		end
-
-		def instruction(name, content)
-			if name == "xml-stylesheet"
-				params = parse_pi_content(content)
-				if params.has_key?("href")
-					@xml_stylesheets << XMLStyleSheet.new(*params)
-				end
-			end
-		end
-
-		def tag_start(name, attributes)
-			@text_stack.push('')
-
-			ns = @ns_stack.last.dup
-			attrs = {}
-			attributes.each do |n, v|
-				if n =~ /\Axmlns:?/
-					ns[$POSTMATCH] = v
-				else
-					attrs[n] = v
-				end
-			end
-			@ns_stack.push(ns)
-
-			prefix, local = split_name(name)
-			@tag_stack.last.push([ns[prefix], local])
-			@tag_stack.push([])
-			if respond_to?("start_#{local}", true)
-				send("start_#{local}", local, prefix, attrs, ns.dup)
-			else
-				start_else_element(local, prefix, attrs, ns.dup)
-			end
-		end
-
-		def tag_end(name)
-			if DEBUG
-				p "end tag #{name}"
-				p @tag_stack
-			end
-			text = @text_stack.pop
-			tags = @tag_stack.pop
-			pr = @proc_stack.pop
-			pr.call(text, tags) unless pr.nil?
-		end
-
-		def text(data)
-			@text_stack.last << data
-		end
-
-		private
-
-		CONTENT_PATTERN = /\s*([^=]+)=(["'])([^\2]+?)\2/
-		def parse_pi_content(content)
-			params = {}
-			content.scan(CONTENT_PATTERN) do |name, quote, value|
-				params[name] = value
-			end
-			params
-		end
-
-		def start_else_element(local, prefix, attrs, ns)
-			class_name = local[0,1].upcase << local[1..-1]
-			current_class = @last_element.class
+  class NotWellFormedError < Error
+    attr_reader :line, :element
+    def initialize(line=nil, element=nil)
+      message = "This is not well formed XML"
+      if element or line
+        message << "\nerror occurred"
+        message << " in #{element}" if element
+        message << " at about #{line} line" if line
+      end
+      message << "\n#{yield}" if block_given?
+      super(message)
+    end
+  end
+
+  class XMLParserNotFound < Error
+    def initialize
+      super("available XML parser does not found in " <<
+            "#{AVAILABLE_PARSER_LIBRARIES.inspect}.")
+    end
+  end
+
+  class NotValidXMLParser < Error
+    def initialize(parser)
+      super("#{parser} is not available XML parser. " <<
+            "available XML parser is " <<
+            "#{AVAILABLE_PARSERS.inspect}.")
+    end
+  end
+
+  class NSError < InvalidRSSError
+    attr_reader :tag, :prefix, :uri
+    def initialize(tag, prefix, require_uri)
+      @tag, @prefix, @uri = tag, prefix, require_uri
+      super("prefix <#{prefix}> doesn't associate uri " <<
+            "<#{require_uri}> in tag <#{tag}>")
+    end
+  end
+
+  class Parser
+
+    extend Forwardable
+
+    class << self
+
+      @@default_parser = nil
+
+      def default_parser
+        @@default_parser || AVAILABLE_PARSERS.first
+      end
+
+      def default_parser=(new_value)
+        if AVAILABLE_PARSERS.include?(new_value)
+          @@default_parser = new_value
+        else
+          raise NotValidXMLParser.new(new_value)
+        end
+      end
+
+      def parse(rss, do_validate=true, ignore_unknown_element=true, parser_class=default_parser)
+        parser = new(rss, parser_class)
+        parser.do_validate = do_validate
+        parser.ignore_unknown_element = ignore_unknown_element
+        parser.parse
+      end
+
+    end
+
+    def_delegators(:@parser, :parse, :rss,
+                   :ignore_unknown_element,
+                   :ignore_unknown_element=, :do_validate,
+                   :do_validate=)
+
+    def initialize(rss, parser_class=self.class.default_parser)
+      @parser = parser_class.new(rss)
+    end
+  end
+
+  class BaseParser
+
+    def initialize(rss)
+      @listener = listener.new
+      @rss = rss
+    end
+
+    def rss
+      @listener.rss
+    end
+
+    def ignore_unknown_element
+      @listener.ignore_unknown_element
+    end
+
+    def ignore_unknown_element=(new_value)
+      @listener.ignore_unknown_element = new_value
+    end
+
+    def do_validate
+      @listener.do_validate
+    end
+
+    def do_validate=(new_value)
+      @listener.do_validate = new_value
+    end
+
+    def parse
+      if @listener.rss.nil?
+        _parse
+      end
+      @listener.rss
+    end
+
+  end
+
+  class BaseListener
+
+    extend Utils
+
+    class << self
+
+      @@setter = {}
+      @@registered_uris = {}
+
+      def install_setter(uri, tag_name, setter)
+        @@setter[uri] = {}  unless @@setter.has_key?(uri)
+        @@setter[uri][tag_name] = setter
+      end
+
+      def register_uri(name, uri)
+        @@registered_uris[name] = {}  unless @@registered_uris.has_key?(name)
+        @@registered_uris[name][uri] = nil
+      end
+
+      def uri_registered?(name, uri)
+        @@registered_uris[name].has_key?(uri)
+      end
+
+      def setter(uri, tag_name)
+        begin
+          @@setter[uri][tag_name]
+        rescue NameError
+          nil
+        end
+      end
+
+      def available_tags(uri)
+        begin
+          @@setter[uri].keys
+        rescue NameError
+          []
+        end
+      end
+          
+      def install_get_text_element(name, uri, setter)
+        install_setter(uri, name, setter)
+        def_get_text_element(uri, name, *get_file_and_line_from_caller(1))
+      end
+      
+      private
+
+      def def_get_text_element(uri, name, file, line)
+        register_uri(name, uri)
+        unless private_instance_methods(false).include?("start_#{name}")
+          module_eval(<<-EOT, file, line)
+          def start_#{name}(name, prefix, attrs, ns)
+            uri = ns[prefix]
+            if self.class.uri_registered?(#{name.inspect}, uri)
+              if @do_validate
+                tags = self.class.available_tags(uri)
+                unless tags.include?(name)
+                  raise UnknownTagError.new(name, uri)
+                end
+              end
+              start_get_text_element(name, prefix, ns, uri)
+            else
+              start_else_element(name, prefix, attrs, ns)
+            end
+          end
+          EOT
+          send("private", "start_#{name}")
+        end
+      end
+
+    end
+
+  end
+
+  module ListenerMixin
+
+    attr_reader :rss
+
+    attr_accessor :ignore_unknown_element
+    attr_accessor :do_validate
+
+    def initialize
+      @rss = nil
+      @ignore_unknown_element = true
+      @do_validate = true
+      @ns_stack = [{}]
+      @tag_stack = [[]]
+      @text_stack = ['']
+      @proc_stack = []
+      @last_element = nil
+      @version = @encoding = @standalone = nil
+      @xml_stylesheets = []
+    end
+    
+    def xmldecl(version, encoding, standalone)
+      @version, @encoding, @standalone = version, encoding, standalone
+    end
+
+    def instruction(name, content)
+      if name == "xml-stylesheet"
+        params = parse_pi_content(content)
+        if params.has_key?("href")
+          @xml_stylesheets << XMLStyleSheet.new(*params)
+        end
+      end
+    end
+
+    def tag_start(name, attributes)
+      @text_stack.push('')
+
+      ns = @ns_stack.last.dup
+      attrs = {}
+      attributes.each do |n, v|
+        if n =~ /\Axmlns:?/
+          ns[$POSTMATCH] = v
+        else
+          attrs[n] = v
+        end
+      end
+      @ns_stack.push(ns)
+
+      prefix, local = split_name(name)
+      @tag_stack.last.push([ns[prefix], local])
+      @tag_stack.push([])
+      if respond_to?("start_#{local}", true)
+        send("start_#{local}", local, prefix, attrs, ns.dup)
+      else
+        start_else_element(local, prefix, attrs, ns.dup)
+      end
+    end
+
+    def tag_end(name)
+      if DEBUG
+        p "end tag #{name}"
+        p @tag_stack
+      end
+      text = @text_stack.pop
+      tags = @tag_stack.pop
+      pr = @proc_stack.pop
+      pr.call(text, tags) unless pr.nil?
+    end
+
+    def text(data)
+      @text_stack.last << data
+    end
+
+    private
+
+    CONTENT_PATTERN = /\s*([^=]+)=(["'])([^\2]+?)\2/
+    def parse_pi_content(content)
+      params = {}
+      content.scan(CONTENT_PATTERN) do |name, quote, value|
+        params[name] = value
+      end
+      params
+    end
+
+    def start_else_element(local, prefix, attrs, ns)
+      class_name = local[0,1].upcase << local[1..-1]
+      current_class = @last_element.class
 #			begin
-			if current_class.constants.include?(class_name)
-				next_class = current_class.const_get(class_name)
-				start_have_something_element(local, prefix, attrs, ns, next_class)
+      if current_class.constants.include?(class_name)
+        next_class = current_class.const_get(class_name)
+        start_have_something_element(local, prefix, attrs, ns, next_class)
 #			rescue NameError
-			else
-				if @ignore_unknown_element
-					@proc_stack.push(nil)
-				else
-					parent = "ROOT ELEMENT???"
-					if current_class.tag_name
-						parent = current_class.tag_name
-					end
-					raise NotExceptedTagError.new(local, parent)
-				end
-			end
-		end
-
-		NAMESPLIT = /^(?:([\w:][-\w\d.]*):)?([\w:][-\w\d.]*)/
-		def split_name(name)
-			name =~ NAMESPLIT
-			[$1 || '', $2]
-		end
-
-		def check_ns(tag_name, prefix, ns, require_uri)
-			if @do_validate
-				if ns[prefix] == require_uri
-					#ns.delete(prefix)
-				else
-					raise NSError.new(tag_name, prefix, require_uri)
-				end
-			end
-		end
-
-		def start_get_text_element(tag_name, prefix, ns, required_uri)
-			@proc_stack.push Proc.new {|text, tags|
-				setter = self.class.setter(required_uri, tag_name)
-				setter ||= "#{tag_name}="
-				if @last_element.respond_to?(setter)
-					@last_element.send(setter, text.to_s)
-				else
-					if @do_validate and not @ignore_unknown_element
-						raise NotExceptedTagError.new(tag_name, @last_element.tag_name)
-					end
-				end
-			}
-		end
-
-		def start_have_something_element(tag_name, prefix, attrs, ns, klass)
-
-			check_ns(tag_name, prefix, ns, klass.required_uri)
-
-			args = []
-			
-			klass.get_attributes.each do |a_name, a_uri, required|
-
-				if a_uri.is_a?(String) or !a_uri.respond_to?(:include?)
-					a_uri = [a_uri]
-				end
-				unless a_uri == [nil]
-					for prefix, uri in ns
-						if a_uri.include?(uri)
-							val = attrs["#{prefix}:#{a_name}"]
-							break if val
-						end
-					end
-				end
-				if val.nil? and a_uri.include?(nil)
-					val = attrs[a_name]
-				end
-
-				if @do_validate and required and val.nil?
-					raise MissingAttributeError.new(tag_name, a_name)
-				end
-
-				args << val
-			end
-
-			previous = @last_element
-			next_element = klass.send(:new, *args)
-			next_element.do_validate = @do_validate
-			setter = ""
-			setter << "#{klass.required_prefix}_" if klass.required_prefix
-			setter << "#{tag_name}="
-			@last_element.send(setter, next_element)
-			@last_element = next_element
-			@proc_stack.push Proc.new { |text, tags|
-				p(@last_element.class) if DEBUG
-				@last_element.content = text if klass.have_content?
-				@last_element.validate_for_stream(tags) if @do_validate
-				@last_element = previous
-			}
-		end
-
-	end
-
-	unless const_defined? :AVAILABLE_PARSER_LIBRARIES
-		AVAILABLE_PARSER_LIBRARIES = [
-			["rss/xmlparser", :XMLParserParser],
-			["rss/xmlscanner", :XMLScanParser],
-			["rss/rexmlparser", :REXMLParser],
-		]
-	end
-
-	AVAILABLE_PARSERS = []
-
-	AVAILABLE_PARSER_LIBRARIES.each do |lib, parser|
-		begin
-			require lib
-			AVAILABLE_PARSERS.push(const_get(parser))
-		rescue LoadError
-		end
-	end
-
-	if AVAILABLE_PARSERS.empty?
-		raise XMLParserNotFound
-	end
+      else
+        if @ignore_unknown_element
+          @proc_stack.push(nil)
+        else
+          parent = "ROOT ELEMENT???"
+          if current_class.tag_name
+            parent = current_class.tag_name
+          end
+          raise NotExceptedTagError.new(local, parent)
+        end
+      end
+    end
+
+    NAMESPLIT = /^(?:([\w:][-\w\d.]*):)?([\w:][-\w\d.]*)/
+    def split_name(name)
+      name =~ NAMESPLIT
+      [$1 || '', $2]
+    end
+
+    def check_ns(tag_name, prefix, ns, require_uri)
+      if @do_validate
+        if ns[prefix] == require_uri
+          #ns.delete(prefix)
+        else
+          raise NSError.new(tag_name, prefix, require_uri)
+        end
+      end
+    end
+
+    def start_get_text_element(tag_name, prefix, ns, required_uri)
+      @proc_stack.push Proc.new {|text, tags|
+        setter = self.class.setter(required_uri, tag_name)
+        setter ||= "#{tag_name}="
+        if @last_element.respond_to?(setter)
+          @last_element.send(setter, text.to_s)
+        else
+          if @do_validate and not @ignore_unknown_element
+            raise NotExceptedTagError.new(tag_name, @last_element.tag_name)
+          end
+        end
+      }
+    end
+
+    def start_have_something_element(tag_name, prefix, attrs, ns, klass)
+
+      check_ns(tag_name, prefix, ns, klass.required_uri)
+
+      args = []
+      
+      klass.get_attributes.each do |a_name, a_uri, required|
+
+        if a_uri.is_a?(String) or !a_uri.respond_to?(:include?)
+          a_uri = [a_uri]
+        end
+        unless a_uri == [nil]
+          for prefix, uri in ns
+            if a_uri.include?(uri)
+              val = attrs["#{prefix}:#{a_name}"]
+              break if val
+            end
+          end
+        end
+        if val.nil? and a_uri.include?(nil)
+          val = attrs[a_name]
+        end
+
+        if @do_validate and required and val.nil?
+          raise MissingAttributeError.new(tag_name, a_name)
+        end
+
+        args << val
+      end
+
+      previous = @last_element
+      next_element = klass.send(:new, *args)
+      next_element.do_validate = @do_validate
+      setter = ""
+      setter << "#{klass.required_prefix}_" if klass.required_prefix
+      setter << "#{tag_name}="
+      @last_element.send(setter, next_element)
+      @last_element = next_element
+      @proc_stack.push Proc.new { |text, tags|
+        p(@last_element.class) if DEBUG
+        @last_element.content = text if klass.have_content?
+        @last_element.validate_for_stream(tags) if @do_validate
+        @last_element = previous
+      }
+    end
+
+  end
+
+  unless const_defined? :AVAILABLE_PARSER_LIBRARIES
+    AVAILABLE_PARSER_LIBRARIES = [
+      ["rss/xmlparser", :XMLParserParser],
+      ["rss/xmlscanner", :XMLScanParser],
+      ["rss/rexmlparser", :REXMLParser],
+    ]
+  end
+
+  AVAILABLE_PARSERS = []
+
+  AVAILABLE_PARSER_LIBRARIES.each do |lib, parser|
+    begin
+      require lib
+      AVAILABLE_PARSERS.push(const_get(parser))
+    rescue LoadError
+    end
+  end
+
+  if AVAILABLE_PARSERS.empty?
+    raise XMLParserNotFound
+  end
 end
diff --git a/lib/rss/rexmlparser.rb b/lib/rss/rexmlparser.rb
index 13ab0e277b..375b7794fb 100644
--- a/lib/rss/rexmlparser.rb
+++ b/lib/rss/rexmlparser.rb
@@ -3,45 +3,45 @@ require "rexml/streamlistener"
 
 /\A(\d+)\.(\d+)(?:\.\d+)+\z/ =~ REXML::Version
 if ([$1.to_i, $2.to_i] <=> [2, 5]) < 0
-	raise LoadError, "needs REXML 2.5 or later (#{REXML::Version})"
+  raise LoadError, "needs REXML 2.5 or later (#{REXML::Version})"
 end
 
 module RSS
-	
-	class REXMLParser < BaseParser
-
-		private
-
-		def listener
-			REXMLListener
-		end
-
-		def _parse
-			begin
-				REXML::Document.parse_stream(@rss, @listener)
-			rescue RuntimeError => e
-				raise NotWellFormedError.new{e.message}
-			rescue REXML::ParseException => e
-				context = e.context
-				line = context[0] if context
-				raise NotWellFormedError.new(line){e.message}
-			end
-		end
-		
-	end
-	
-	class REXMLListener < BaseListener
-
-		include REXML::StreamListener
-		include ListenerMixin
-
-		def xmldecl(version, encoding, standalone)
-			super
-			# Encoding is converted to UTF-8 when REXML parse XML.
-			@encoding = 'UTF-8'
-		end
-
-		alias_method(:cdata, :text)
-	end
+  
+  class REXMLParser < BaseParser
+
+    private
+
+    def listener
+      REXMLListener
+    end
+
+    def _parse
+      begin
+        REXML::Document.parse_stream(@rss, @listener)
+      rescue RuntimeError => e
+        raise NotWellFormedError.new{e.message}
+      rescue REXML::ParseException => e
+        context = e.context
+        line = context[0] if context
+        raise NotWellFormedError.new(line){e.message}
+      end
+    end
+    
+  end
+  
+  class REXMLListener < BaseListener
+
+    include REXML::StreamListener
+    include ListenerMixin
+
+    def xmldecl(version, encoding, standalone)
+      super
+      # Encoding is converted to UTF-8 when REXML parse XML.
+      @encoding = 'UTF-8'
+    end
+
+    alias_method(:cdata, :text)
+  end
 
 end
diff --git a/lib/rss/rss.rb b/lib/rss/rss.rb
index 24ba0eb170..231fb1fb62 100644
--- a/lib/rss/rss.rb
+++ b/lib/rss/rss.rb
@@ -7,47 +7,47 @@
 require "time"
 
 class Time
-	class << self
-		unless respond_to?(:w3cdtf)
-			def w3cdtf(date)
-				if /\A\s*
-				    (-?\d+)-(\d\d)-(\d\d)
-				    (?:T
-				    (\d\d):(\d\d)(?::(\d\d))?
-				    (\.\d+)?
-				    (Z|[+-]\d\d:\d\d)?)?
-				    \s*\z/ix =~ date and (($5 and $8) or (!$5 and !$8))
-					datetime = [$1.to_i, $2.to_i, $3.to_i, $4.to_i, $5.to_i, $6.to_i] 
-					datetime << $7.to_f * 1000000 if $7
-					if $8
-						Time.utc(*datetime) - zone_offset($8)
-					else
-						Time.local(*datetime)
-					end
-				else
-					raise ArgumentError.new("invalid date: #{date.inspect}")
-				end
-			end
-		end
-	end
-
-	unless instance_methods.include?("w3cdtf")
-		alias w3cdtf iso8601
-	end
+  class << self
+    unless respond_to?(:w3cdtf)
+      def w3cdtf(date)
+        if /\A\s*
+            (-?\d+)-(\d\d)-(\d\d)
+            (?:T
+            (\d\d):(\d\d)(?::(\d\d))?
+            (\.\d+)?
+            (Z|[+-]\d\d:\d\d)?)?
+            \s*\z/ix =~ date and (($5 and $8) or (!$5 and !$8))
+          datetime = [$1.to_i, $2.to_i, $3.to_i, $4.to_i, $5.to_i, $6.to_i] 
+          datetime << $7.to_f * 1000000 if $7
+          if $8
+            Time.utc(*datetime) - zone_offset($8)
+          else
+            Time.local(*datetime)
+          end
+        else
+          raise ArgumentError.new("invalid date: #{date.inspect}")
+        end
+      end
+    end
+  end
+
+  unless instance_methods.include?("w3cdtf")
+    alias w3cdtf iso8601
+  end
 end
 
 module Enumerable
-	unless instance_methods.include?("sort_by")
-		def sort_by
-			collect do |x|
-				[yield(x), x]
-			end.sort do |x, y|
-				x[0] <=> y[0]
-			end.collect! do |x|
-				x[1]
-			end
-		end
-	end
+  unless instance_methods.include?("sort_by")
+    def sort_by
+      collect do |x|
+        [yield(x), x]
+      end.sort do |x, y|
+        x[0] <=> y[0]
+      end.collect! do |x|
+        x[1]
+      end
+    end
+  end
 end
 
 require "English"
@@ -57,623 +57,623 @@ require "rss/xml-stylesheet"
 
 module RSS
 
-	VERSION = "0.1.0"
-
-	URI = "http://purl.org/rss/1.0/"
-
-	DEBUG = false
-
-	class Error < StandardError; end
-
-	class OverlappedPrefixError < Error
-		attr_reader :prefix
-		def initialize(prefix)
-			@prefix = prefix
-		end
-	end
-
-	class InvalidRSSError < Error; end
-
-	class MissingTagError < InvalidRSSError
-		attr_reader :tag, :parent
-		def initialize(tag, parent)
-			@tag, @parent = tag, parent
-			super("tag <#{tag}> is missing in tag <#{parent}>")
-		end
-	end
-
-	class TooMuchTagError < InvalidRSSError
-		attr_reader :tag, :parent
-		def initialize(tag, parent)
-			@tag, @parent = tag, parent
-			super("tag <#{tag}> is too much in tag <#{parent}>")
-		end
-	end
-
-	class MissingAttributeError < InvalidRSSError
-		attr_reader :tag, :attribute
-		def initialize(tag, attribute)
-			@tag, @attribute = tag, attribute
-			super("attribute <#{attribute}> is missing in tag <#{tag}>")
-		end
-	end
-
-	class UnknownTagError < InvalidRSSError
-		attr_reader :tag, :uri
-		def initialize(tag, uri)
-			@tag, @uri = tag, uri
-			super("tag <#{tag}> is unknown in namespace specified by uri <#{uri}>")
-		end
-	end
-
-	class NotExceptedTagError < InvalidRSSError
-		attr_reader :tag, :parent
-		def initialize(tag, parent)
-			@tag, @parent = tag, parent
-			super("tag <#{tag}> is not expected in tag <#{parent}>")
-		end
-	end
-
-	class NotAvailableValueError < InvalidRSSError
-		attr_reader :tag, :value
-		def initialize(tag, value)
-			@tag, @value = tag, value
-			super("value <#{value}> of tag <#{tag}> is not available.")
-		end
-	end
-
-	class UnknownConversionMethodError < Error
-		attr_reader :to, :from
-		def initialize(to, from)
-			@to = to
-			@from = from
-			super("can't convert to #{to} from #{from}.")
-		end
-	end
-	# for backward compatibility
-	UnknownConvertMethod = UnknownConversionMethodError
-
-	class ConversionError < Error
-		attr_reader :string, :to, :from
-		def initialize(string, to, from)
-			@string = string
-			@to = to
-			@from = from
-			super("can't convert #{@string} to #{to} from #{from}.")
-		end
-	end
-
-	module BaseModel
-
-		include Utils
-
-		def install_have_child_element(name)
-			add_need_initialize_variable(name)
-
-			attr_accessor name
-			install_element(name) do |n, elem_name|
-				<<-EOC
-				if @#{n}
-					"\#{@#{n}.to_s(convert, indent)}"
-				else
-					''
-				end
+  VERSION = "0.1.0"
+
+  URI = "http://purl.org/rss/1.0/"
+
+  DEBUG = false
+
+  class Error < StandardError; end
+
+  class OverlappedPrefixError < Error
+    attr_reader :prefix
+    def initialize(prefix)
+      @prefix = prefix
+    end
+  end
+
+  class InvalidRSSError < Error; end
+
+  class MissingTagError < InvalidRSSError
+    attr_reader :tag, :parent
+    def initialize(tag, parent)
+      @tag, @parent = tag, parent
+      super("tag <#{tag}> is missing in tag <#{parent}>")
+    end
+  end
+
+  class TooMuchTagError < InvalidRSSError
+    attr_reader :tag, :parent
+    def initialize(tag, parent)
+      @tag, @parent = tag, parent
+      super("tag <#{tag}> is too much in tag <#{parent}>")
+    end
+  end
+
+  class MissingAttributeError < InvalidRSSError
+    attr_reader :tag, :attribute
+    def initialize(tag, attribute)
+      @tag, @attribute = tag, attribute
+      super("attribute <#{attribute}> is missing in tag <#{tag}>")
+    end
+  end
+
+  class UnknownTagError < InvalidRSSError
+    attr_reader :tag, :uri
+    def initialize(tag, uri)
+      @tag, @uri = tag, uri
+      super("tag <#{tag}> is unknown in namespace specified by uri <#{uri}>")
+    end
+  end
+
+  class NotExceptedTagError < InvalidRSSError
+    attr_reader :tag, :parent
+    def initialize(tag, parent)
+      @tag, @parent = tag, parent
+      super("tag <#{tag}> is not expected in tag <#{parent}>")
+    end
+  end
+
+  class NotAvailableValueError < InvalidRSSError
+    attr_reader :tag, :value
+    def initialize(tag, value)
+      @tag, @value = tag, value
+      super("value <#{value}> of tag <#{tag}> is not available.")
+    end
+  end
+
+  class UnknownConversionMethodError < Error
+    attr_reader :to, :from
+    def initialize(to, from)
+      @to = to
+      @from = from
+      super("can't convert to #{to} from #{from}.")
+    end
+  end
+  # for backward compatibility
+  UnknownConvertMethod = UnknownConversionMethodError
+
+  class ConversionError < Error
+    attr_reader :string, :to, :from
+    def initialize(string, to, from)
+      @string = string
+      @to = to
+      @from = from
+      super("can't convert #{@string} to #{to} from #{from}.")
+    end
+  end
+
+  module BaseModel
+
+    include Utils
+
+    def install_have_child_element(name)
+      add_need_initialize_variable(name)
+
+      attr_accessor name
+      install_element(name) do |n, elem_name|
+        <<-EOC
+        if @#{n}
+          "\#{@#{n}.to_s(convert, indent)}"
+        else
+          ''
+        end
 EOC
-			end
-		end
-		alias_method(:install_have_attribute_element, :install_have_child_element)
-
-		def install_have_children_element(name, postfix="s")
-			add_have_children_element(name)
-
-			def_children_accessor(name, postfix)
-			install_element(name, postfix) do |n, elem_name|
-				<<-EOC
-				rv = ''
-				@#{n}.each do |x|
-					rv << "\#{x.to_s(convert, indent)}"
-				end
-				rv
+      end
+    end
+    alias_method(:install_have_attribute_element, :install_have_child_element)
+
+    def install_have_children_element(name, postfix="s")
+      add_have_children_element(name)
+
+      def_children_accessor(name, postfix)
+      install_element(name, postfix) do |n, elem_name|
+        <<-EOC
+        rv = ''
+        @#{n}.each do |x|
+          rv << "\#{x.to_s(convert, indent)}"
+        end
+        rv
 EOC
-			end
-		end
-
-		def install_text_element(name)
-			self::ELEMENTS << name
-			add_need_initialize_variable(name)
-
-			attr_writer name
-			convert_attr_reader name
-			install_element(name) do |n, elem_name|
-				<<-EOC
-				if @#{n}
-					rv = "\#{indent}<#{elem_name}>"
-					value = html_escape(@#{n})
-					if convert and @converter
-						rv << @converter.convert(value)
-					else
-						rv << value
-					end
-	  	    rv << "</#{elem_name}>"
-					rv
-				else
-					''
-				end
+      end
+    end
+
+    def install_text_element(name)
+      self::ELEMENTS << name
+      add_need_initialize_variable(name)
+
+      attr_writer name
+      convert_attr_reader name
+      install_element(name) do |n, elem_name|
+        <<-EOC
+        if @#{n}
+          rv = "\#{indent}<#{elem_name}>"
+          value = html_escape(@#{n})
+          if convert and @converter
+            rv << @converter.convert(value)
+          else
+            rv << value
+          end
+    	    rv << "</#{elem_name}>"
+          rv
+        else
+          ''
+        end
 EOC
-			end
-		end
-
-		def install_date_element(name, type, disp_name=name)
-			self::ELEMENTS << name
-			add_need_initialize_variable(name)
-
-			# accessor
-			convert_attr_reader name
-			module_eval(<<-EOC, *get_file_and_line_from_caller(2))
-			def #{name}=(new_value)
-				if new_value.kind_of?(Time)
-					@#{name} = new_value
-				else
-					if @do_validate
-						begin
-							@#{name} = Time.send('#{type}', new_value)
-						rescue ArgumentError
-							raise NotAvailableValueError.new('#{disp_name}', new_value)
-						end
-					else
-						@#{name} = nil
-						if /\\A\\s*\\z/ !~ new_value.to_s
-							begin
-								@#{name} = Time.parse(new_value)
-							rescue ArgumentError
-							end
-						end
-					end
-				end
-
-				# Is it need?
-				if @#{name}
-					class << @#{name}
-						alias_method(:_to_s, :to_s) unless respond_to?(:_to_s)
-						alias_method(:to_s, :#{type})
-					end
-				end
-
-			end
+      end
+    end
+
+    def install_date_element(name, type, disp_name=name)
+      self::ELEMENTS << name
+      add_need_initialize_variable(name)
+
+      # accessor
+      convert_attr_reader name
+      module_eval(<<-EOC, *get_file_and_line_from_caller(2))
+      def #{name}=(new_value)
+        if new_value.kind_of?(Time)
+          @#{name} = new_value
+        else
+          if @do_validate
+            begin
+              @#{name} = Time.send('#{type}', new_value)
+            rescue ArgumentError
+              raise NotAvailableValueError.new('#{disp_name}', new_value)
+            end
+          else
+            @#{name} = nil
+            if /\\A\\s*\\z/ !~ new_value.to_s
+              begin
+                @#{name} = Time.parse(new_value)
+              rescue ArgumentError
+              end
+            end
+          end
+        end
+
+        # Is it need?
+        if @#{name}
+          class << @#{name}
+            alias_method(:_to_s, :to_s) unless respond_to?(:_to_s)
+            alias_method(:to_s, :#{type})
+          end
+        end
+
+      end
 EOC
-			
-			install_element(name) do |n, elem_name|
-				<<-EOC
-				if @#{n}
-					rv = "\#{indent}<#{elem_name}>"
-					value = html_escape(@#{n}.#{type})
-					if convert and @converter
-						rv << @converter.convert(value)
-					else
-						rv << value
-					end
-	  	    rv << "</#{elem_name}>"
-					rv
-				else
-					''
-				end
+      
+      install_element(name) do |n, elem_name|
+        <<-EOC
+        if @#{n}
+          rv = "\#{indent}<#{elem_name}>"
+          value = html_escape(@#{n}.#{type})
+          if convert and @converter
+            rv << @converter.convert(value)
+          else
+            rv << value
+          end
+    	    rv << "</#{elem_name}>"
+          rv
+        else
+          ''
+        end
 EOC
-			end
-
-		end
-
-		private
-		def install_element(name, postfix="")
-			elem_name = name.sub('_', ':')
-			module_eval(<<-EOC, *get_file_and_line_from_caller(2))
-			def #{name}_element#{postfix}(convert=true, indent='')
-				#{yield(name, elem_name)}
-			end
-			private :#{name}_element#{postfix}
+      end
+
+    end
+
+    private
+    def install_element(name, postfix="")
+      elem_name = name.sub('_', ':')
+      module_eval(<<-EOC, *get_file_and_line_from_caller(2))
+      def #{name}_element#{postfix}(convert=true, indent='')
+        #{yield(name, elem_name)}
+      end
+      private :#{name}_element#{postfix}
 EOC
-		end
-
-		def convert_attr_reader(*attrs)
-			attrs.each do |attr|
-				attr = attr.id2name if attr.kind_of?(Integer)
-				module_eval(<<-EOC, *get_file_and_line_from_caller(2))
-				def #{attr}
-					if @converter
-						@converter.convert(@#{attr})
-					else
-						@#{attr}
-					end
-				end
+    end
+
+    def convert_attr_reader(*attrs)
+      attrs.each do |attr|
+        attr = attr.id2name if attr.kind_of?(Integer)
+        module_eval(<<-EOC, *get_file_and_line_from_caller(2))
+        def #{attr}
+          if @converter
+            @converter.convert(@#{attr})
+          else
+            @#{attr}
+          end
+        end
 EOC
-			end
-		end
-
-		def def_children_accessor(accessor_name, postfix="s")
-			module_eval(<<-EOC, *get_file_and_line_from_caller(2))
-			def #{accessor_name}#{postfix}
-				@#{accessor_name}
-			end
-
-			def #{accessor_name}(*args)
-				if args.empty?
-					@#{accessor_name}.first
-				else
-					@#{accessor_name}.send("[]", *args)
-				end
-			end
-				
-			def #{accessor_name}=(*args)
-				if args.size == 1
-					@#{accessor_name}.push(args[0])
-				else
-					@#{accessor_name}.send("[]=", *args)
-				end
-			end
-			alias_method(:set_#{accessor_name}, :#{accessor_name}=)
+      end
+    end
+
+    def def_children_accessor(accessor_name, postfix="s")
+      module_eval(<<-EOC, *get_file_and_line_from_caller(2))
+      def #{accessor_name}#{postfix}
+        @#{accessor_name}
+      end
+
+      def #{accessor_name}(*args)
+        if args.empty?
+          @#{accessor_name}.first
+        else
+          @#{accessor_name}.send("[]", *args)
+        end
+      end
+        
+      def #{accessor_name}=(*args)
+        if args.size == 1
+          @#{accessor_name}.push(args[0])
+        else
+          @#{accessor_name}.send("[]=", *args)
+        end
+      end
+      alias_method(:set_#{accessor_name}, :#{accessor_name}=)
 EOC
-		end
+    end
 
-	end
+  end
 
-	class Element
+  class Element
 
-		extend BaseModel
-		include Utils
+    extend BaseModel
+    include Utils
 
-		INDENT = "  "
+    INDENT = "  "
     
-		class << self
-
-			def inherited(klass)
-				klass.module_eval(<<-EOC)
-				public
-				
-				@tag_name = name.split(/::/).last.downcase
-				@indent_size = name.split(/::/).size - 2
-
-				@@must_call_validators = {}
-
-				def self.must_call_validators
-					@@must_call_validators
-				end
-
-				def self.install_must_call_validator(prefix, uri)
-					@@must_call_validators[uri] = prefix
-				end
-				
-				@@model = []
-
-				def self.model
-					@@model
-				end
-
-				def self.install_model(tag, occurs=nil)
-					if m = @@model.find {|t, o| t == tag}
-						m[1] = occurs
-					else
-						@@model << [tag, occurs]
-					end
-				end
-
-				@@get_attributes = []
-				
-				def self.get_attributes()
-					@@get_attributes
-				end
-
-				def self.install_get_attribute(name, uri, required=true)
-					attr_writer name
-					convert_attr_reader name
-					@@get_attributes << [name, uri, required]
-				end
-
-				@@have_content = false
-
-				def self.content_setup
-					attr_writer :content
-					convert_attr_reader :content
-					@@have_content = true
-				end
-
-				def self.have_content?
-					@@have_content
-				end
-
-				@@have_children_elements = []
-
-				def self.have_children_elements
-					@@have_children_elements
-				end
-
-				def self.add_have_children_element(variable_name)
-					@@have_children_elements << variable_name
-				end
-				
-				@@need_initialize_variables = []
-				
-				def self.add_need_initialize_variable(variable_name)
-					@@need_initialize_variables << variable_name
-				end
-				
-				def self.need_initialize_variables
-					@@need_initialize_variables
-				end
-
-				EOC
-			end
-
-			def required_prefix
-				nil
-			end
-
-			def required_uri
-				nil
-			end
-			
-			def install_ns(prefix, uri)
-				if self::NSPOOL.has_key?(prefix)
-					raise OverlappedPrefixError.new(prefix)
-				end
-				self::NSPOOL[prefix] = uri
-			end
-
-			def tag_name
-				@tag_name
-			end
+    class << self
+
+      def inherited(klass)
+        klass.module_eval(<<-EOC)
+        public
+        
+        @tag_name = name.split(/::/).last.downcase
+        @indent_size = name.split(/::/).size - 2
+
+        @@must_call_validators = {}
+
+        def self.must_call_validators
+          @@must_call_validators
+        end
+
+        def self.install_must_call_validator(prefix, uri)
+          @@must_call_validators[uri] = prefix
+        end
+        
+        @@model = []
+
+        def self.model
+          @@model
+        end
+
+        def self.install_model(tag, occurs=nil)
+          if m = @@model.find {|t, o| t == tag}
+            m[1] = occurs
+          else
+            @@model << [tag, occurs]
+          end
+        end
+
+        @@get_attributes = []
+        
+        def self.get_attributes()
+          @@get_attributes
+        end
+
+        def self.install_get_attribute(name, uri, required=true)
+          attr_writer name
+          convert_attr_reader name
+          @@get_attributes << [name, uri, required]
+        end
+
+        @@have_content = false
+
+        def self.content_setup
+          attr_writer :content
+          convert_attr_reader :content
+          @@have_content = true
+        end
+
+        def self.have_content?
+          @@have_content
+        end
+
+        @@have_children_elements = []
+
+        def self.have_children_elements
+          @@have_children_elements
+        end
+
+        def self.add_have_children_element(variable_name)
+          @@have_children_elements << variable_name
+        end
+        
+        @@need_initialize_variables = []
+        
+        def self.add_need_initialize_variable(variable_name)
+          @@need_initialize_variables << variable_name
+        end
+        
+        def self.need_initialize_variables
+          @@need_initialize_variables
+        end
+
+        EOC
+      end
+
+      def required_prefix
+        nil
+      end
+
+      def required_uri
+        nil
+      end
+      
+      def install_ns(prefix, uri)
+        if self::NSPOOL.has_key?(prefix)
+          raise OverlappedPrefixError.new(prefix)
+        end
+        self::NSPOOL[prefix] = uri
+      end
+
+      def tag_name
+        @tag_name
+      end
       
-			def indent_size
-				@indent_size
-			end
+      def indent_size
+        @indent_size
+      end
       
-		end
-
-		attr_accessor :do_validate
-
-		def initialize(do_validate=true)
-			@converter = nil
-			@do_validate = do_validate
-			initialize_variables
-		end
-
-		def tag_name
-			self.class.tag_name
-		end
-
-		def converter=(converter)
-			@converter = converter
-			children.each do |child|
-				child.converter = converter unless child.nil?
-			end
-		end
-		
-		def validate
-			validate_attribute
-			__validate
-		end
-		
-		def validate_for_stream(tags)
-			validate_attribute
-			__validate(tags, false)
-		end
+    end
+
+    attr_accessor :do_validate
+
+    def initialize(do_validate=true)
+      @converter = nil
+      @do_validate = do_validate
+      initialize_variables
+    end
+
+    def tag_name
+      self.class.tag_name
+    end
+
+    def converter=(converter)
+      @converter = converter
+      children.each do |child|
+        child.converter = converter unless child.nil?
+      end
+    end
+    
+    def validate
+      validate_attribute
+      __validate
+    end
+    
+    def validate_for_stream(tags)
+      validate_attribute
+      __validate(tags, false)
+    end
+
+    private
+    def initialize_variables
+      self.class.need_initialize_variables.each do |variable_name|
+        instance_eval("@#{variable_name} = nil")
+      end
+      initialize_have_children_elements
+      @content = "" if self.class.have_content?
+    end
+
+    def initialize_have_children_elements
+      self.class.have_children_elements.each do |variable_name|
+        instance_eval("@#{variable_name} = []")
+      end
+    end
+
+    # not String class children.
+    def children
+      []
+    end
+
+    # default #validate() argument.
+    def _tags
+      []
+    end
+
+    def _attrs
+      []
+    end
+
+    def __validate(tags=_tags, recursive=true)
+      if recursive
+        children.compact.each do |child|
+          child.validate
+        end
+      end
+      must_call_validators = self.class.must_call_validators
+      tags = tag_filter(tags.dup)
+      p tags if DEBUG
+      self.class::NSPOOL.each do |prefix, uri|
+        if tags.has_key?(uri) and !must_call_validators.has_key?(uri)
+          meth = "#{prefix}_validate"
+          send(meth, tags[uri]) if respond_to?(meth, true)
+        end
+      end
+      must_call_validators.each do |uri, prefix|
+        send("#{prefix}_validate", tags[uri])
+      end
+    end
+
+    def validate_attribute
+      _attrs.each do |a_name, required|
+        if required and send(a_name).nil?
+          raise MissingAttributeError.new(self.class.tag_name, a_name)
+        end
+      end
+    end
+
+    def other_element(convert, indent='')
+      rv = ''
+      private_methods.each do |meth|
+        if /\A([^_]+)_[^_]+_elements?\z/ =~ meth and
+            self.class::NSPOOL.has_key?($1)
+          res = send(meth, convert)
+          rv << "#{indent}#{res}\n" if /\A\s*\z/ !~ res
+        end
+      end
+      rv
+    end
+
+    def _validate(tags, model=self.class.model)
+      count = 1
+      do_redo = false
+      not_shift = false
+      tag = nil
+      element_names = model.collect {|elem| elem[0]}
+      if tags
+        tags_size = tags.size
+        tags = tags.sort_by {|x| element_names.index(x) || tags_size}
+      end
+
+      model.each_with_index do |elem, i|
+
+        if DEBUG
+          p "before" 
+          p tags
+          p elem
+        end
+
+        if not_shift
+          not_shift = false
+        elsif tags
+          tag = tags.shift
+        end
+
+        if DEBUG
+          p "mid"
+          p count
+        end
+
+        case elem[1]
+        when '?'
+          if count > 2
+            raise TooMuchTagError.new(elem[0], tag_name)
+          else
+            if elem[0] == tag
+              do_redo = true
+            else
+              not_shift = true
+            end
+          end
+        when '*'
+          if elem[0] == tag
+            do_redo = true
+          else
+            not_shift = true
+          end
+        when '+'
+          if elem[0] == tag
+            do_redo = true
+          else
+            if count > 1
+              not_shift = true
+            else
+              raise MissingTagError.new(elem[0], tag_name)
+            end
+          end
+        else
+          if elem[0] == tag
+            if model[i+1] and model[i+1][0] != elem[0] and
+                tags and tags.first == elem[0]
+              raise TooMuchTagError.new(elem[0], tag_name)
+            end
+          else
+            raise MissingTagError.new(elem[0], tag_name)
+          end
+        end
+
+        if DEBUG
+          p "after"
+          p not_shift
+          p do_redo
+          p tag
+        end
+
+        if do_redo
+          do_redo = false
+          count += 1
+          redo
+        else
+          count = 1
+        end
+
+      end
+
+      if !tags.nil? and !tags.empty?
+        raise NotExceptedTagError.new(tag, tag_name)
+      end
+
+    end
+
+    def tag_filter(tags)
+      rv = {}
+      tags.each do |tag|
+        rv[tag[0]] = [] unless rv.has_key?(tag[0])
+        rv[tag[0]].push(tag[1])
+      end
+      rv
+    end
+
+    private
+    def calc_indent
+      INDENT * (self.class.indent_size)
+    end
+    
+    def remove_empty_newline(string)
+      string.gsub(/^\s*$(?:\r?\n?)/, '')
+    end
+    
+  end
+
+  module RootElementMixin
+
+    attr_reader :output_encoding
+
+    def initialize(rss_version, version=nil, encoding=nil, standalone=nil)
+      super()
+      @rss_version = rss_version
+      @version = version || '1.0'
+      @encoding = encoding
+      @standalone = standalone
+      @output_encoding = nil
+    end
+
+    def output_encoding=(enc)
+      @output_encoding = enc
+      self.converter = Converter.new(@output_encoding, @encoding)
+    end
 
     private
-		def initialize_variables
-			self.class.need_initialize_variables.each do |variable_name|
-				instance_eval("@#{variable_name} = nil")
-			end
-			initialize_have_children_elements
-			@content = "" if self.class.have_content?
-		end
-
-		def initialize_have_children_elements
-			self.class.have_children_elements.each do |variable_name|
-				instance_eval("@#{variable_name} = []")
-			end
-		end
-
-		# not String class children.
-		def children
-			[]
-		end
-
-		# default #validate() argument.
-		def _tags
-			[]
-		end
-
-		def _attrs
-			[]
-		end
-
-		def __validate(tags=_tags, recursive=true)
-			if recursive
-				children.compact.each do |child|
-					child.validate
-				end
-			end
-			must_call_validators = self.class.must_call_validators
-			tags = tag_filter(tags.dup)
-			p tags if DEBUG
-			self.class::NSPOOL.each do |prefix, uri|
-				if tags.has_key?(uri) and !must_call_validators.has_key?(uri)
-					meth = "#{prefix}_validate"
-					send(meth, tags[uri]) if respond_to?(meth, true)
-				end
-			end
-			must_call_validators.each do |uri, prefix|
-				send("#{prefix}_validate", tags[uri])
-			end
-		end
-
-		def validate_attribute
-			_attrs.each do |a_name, required|
-				if required and send(a_name).nil?
-					raise MissingAttributeError.new(self.class.tag_name, a_name)
-				end
-			end
-		end
-
-		def other_element(convert, indent='')
-			rv = ''
-			private_methods.each do |meth|
-				if /\A([^_]+)_[^_]+_elements?\z/ =~ meth and
-						self.class::NSPOOL.has_key?($1)
-					res = send(meth, convert)
-					rv << "#{indent}#{res}\n" if /\A\s*\z/ !~ res
-				end
-			end
-			rv
-		end
-
-		def _validate(tags, model=self.class.model)
-			count = 1
-			do_redo = false
-			not_shift = false
-			tag = nil
-			element_names = model.collect {|elem| elem[0]}
-			if tags
-				tags_size = tags.size
-				tags = tags.sort_by {|x| element_names.index(x) || tags_size}
-			end
-
-			model.each_with_index do |elem, i|
-
-				if DEBUG
-					p "before" 
-					p tags
-					p elem
-				end
-
-				if not_shift
-					not_shift = false
-				elsif tags
-					tag = tags.shift
-				end
-
-				if DEBUG
-					p "mid"
-					p count
-				end
-
-				case elem[1]
-				when '?'
-					if count > 2
-						raise TooMuchTagError.new(elem[0], tag_name)
-					else
-						if elem[0] == tag
-							do_redo = true
-						else
-							not_shift = true
-						end
-					end
-				when '*'
-					if elem[0] == tag
-						do_redo = true
-					else
-						not_shift = true
-					end
-				when '+'
-					if elem[0] == tag
-						do_redo = true
-					else
-						if count > 1
-							not_shift = true
-						else
-							raise MissingTagError.new(elem[0], tag_name)
-						end
-					end
-				else
-					if elem[0] == tag
-						if model[i+1] and model[i+1][0] != elem[0] and
-								tags and tags.first == elem[0]
-							raise TooMuchTagError.new(elem[0], tag_name)
-						end
-					else
-						raise MissingTagError.new(elem[0], tag_name)
-					end
-				end
-
-				if DEBUG
-					p "after"
-					p not_shift
-					p do_redo
-					p tag
-				end
-
-				if do_redo
-					do_redo = false
-					count += 1
-					redo
-				else
-					count = 1
-				end
-
-			end
-
-			if !tags.nil? and !tags.empty?
-				raise NotExceptedTagError.new(tag, tag_name)
-			end
-
-		end
-
-		def tag_filter(tags)
-			rv = {}
-			tags.each do |tag|
-				rv[tag[0]] = [] unless rv.has_key?(tag[0])
-				rv[tag[0]].push(tag[1])
-			end
-			rv
-		end
-
-		private
-		def calc_indent
-			INDENT * (self.class.indent_size)
-		end
+    def xmldecl
+      rv = %Q[<?xml version="#{@version}"]
+      if @output_encoding or @encoding
+        rv << %Q[ encoding="#{@output_encoding or @encoding}"]
+      end
+      rv << %Q[ standalone="#{@standalone}"] if @standalone
+      rv << '?>'
+      rv
+    end
     
-		def remove_empty_newline(string)
-			string.gsub(/^\s*$(?:\r?\n?)/, '')
-		end
+    def ns_declaration(indent)
+      rv = ''
+      self.class::NSPOOL.each do |prefix, uri|
+        prefix = ":#{prefix}" unless prefix.empty?
+        rv << %Q|\n#{indent}xmlns#{prefix}="#{html_escape(uri)}"|
+      end
+      rv
+    end
     
-	end
-
-	module RootElementMixin
-
-		attr_reader :output_encoding
-
-		def initialize(rss_version, version=nil, encoding=nil, standalone=nil)
-			super()
-			@rss_version = rss_version
-			@version = version || '1.0'
-			@encoding = encoding
-			@standalone = standalone
-			@output_encoding = nil
-		end
-
-		def output_encoding=(enc)
-			@output_encoding = enc
-			self.converter = Converter.new(@output_encoding, @encoding)
-		end
-
-		private
-		def xmldecl
-			rv = %Q[<?xml version="#{@version}"]
-			if @output_encoding or @encoding
-				rv << %Q[ encoding="#{@output_encoding or @encoding}"]
-			end
-			rv << %Q[ standalone="#{@standalone}"] if @standalone
-			rv << '?>'
-			rv
-		end
-		
-		def ns_declaration(indent)
-			rv = ''
-			self.class::NSPOOL.each do |prefix, uri|
-				prefix = ":#{prefix}" unless prefix.empty?
-				rv << %Q|\n#{indent}xmlns#{prefix}="#{html_escape(uri)}"|
-			end
-			rv
-		end
-		
-	end
+  end
 
 end
diff --git a/lib/rss/syndication.rb b/lib/rss/syndication.rb
index aca39bb374..75f612864d 100644
--- a/lib/rss/syndication.rb
+++ b/lib/rss/syndication.rb
@@ -2,84 +2,84 @@ require "rss/1.0"
 
 module RSS
 
-	SY_PREFIX = 'sy'
-	SY_URI = "http://purl.org/rss/1.0/modules/syndication/"
+  SY_PREFIX = 'sy'
+  SY_URI = "http://purl.org/rss/1.0/modules/syndication/"
 
-	RDF.install_ns(SY_PREFIX, SY_URI)
+  RDF.install_ns(SY_PREFIX, SY_URI)
 
-	module SyndicationModel
-		
-		extend BaseModel
-		
-		ELEMENTS = []
-		
-		def self.append_features(klass)
-			super
-			
-			klass.module_eval(<<-EOC)
-				%w(updatePeriod updateFrequency).each do |x|
-					install_text_element("\#{SY_PREFIX}_\#{x}")
-				end
+  module SyndicationModel
+    
+    extend BaseModel
+    
+    ELEMENTS = []
+    
+    def self.append_features(klass)
+      super
+      
+      klass.module_eval(<<-EOC)
+        %w(updatePeriod updateFrequency).each do |x|
+          install_text_element("\#{SY_PREFIX}_\#{x}")
+        end
 
-				%w(updateBase).each do |x|
-					install_date_element("\#{SY_PREFIX}_\#{x}", 'w3cdtf', x)
-				end
+        %w(updateBase).each do |x|
+          install_date_element("\#{SY_PREFIX}_\#{x}", 'w3cdtf', x)
+        end
 
-				alias_method(:_sy_updatePeriod=, :sy_updatePeriod=)
-				def sy_updatePeriod=(new_value)
-					new_value = new_value.strip
-					validate_sy_updatePeriod(new_value) if @do_validate
-					self._sy_updatePeriod = new_value
-				end
+        alias_method(:_sy_updatePeriod=, :sy_updatePeriod=)
+        def sy_updatePeriod=(new_value)
+          new_value = new_value.strip
+          validate_sy_updatePeriod(new_value) if @do_validate
+          self._sy_updatePeriod = new_value
+        end
 
-				alias_method(:_sy_updateFrequency=, :sy_updateFrequency=)
-				def sy_updateFrequency=(new_value)
-					new_value = new_value.strip
-					validate_sy_updateFrequency(new_value) if @do_validate
-					self._sy_updateFrequency = new_value.to_i
-				end
-			EOC
-		end
+        alias_method(:_sy_updateFrequency=, :sy_updateFrequency=)
+        def sy_updateFrequency=(new_value)
+          new_value = new_value.strip
+          validate_sy_updateFrequency(new_value) if @do_validate
+          self._sy_updateFrequency = new_value.to_i
+        end
+      EOC
+    end
 
-		def sy_validate(tags)
-			counter = {}
-			ELEMENTS.each do |x|
-				counter[x] = 0
-			end
+    def sy_validate(tags)
+      counter = {}
+      ELEMENTS.each do |x|
+        counter[x] = 0
+      end
 
-			tags.each do |tag|
-				key = "#{SY_PREFIX}_#{tag}"
-				raise UnknownTagError.new(tag, SY_URI)  unless counter.has_key?(key)
-				counter[key] += 1
-				raise TooMuchTagError.new(tag, tag_name) if counter[key] > 1
-			end
-		end
+      tags.each do |tag|
+        key = "#{SY_PREFIX}_#{tag}"
+        raise UnknownTagError.new(tag, SY_URI)  unless counter.has_key?(key)
+        counter[key] += 1
+        raise TooMuchTagError.new(tag, tag_name) if counter[key] > 1
+      end
+    end
 
-		private
-		SY_UPDATEPERIOD_AVAILABLE_VALUES = %w(hourly daily weekly monthly yearly)
-		def validate_sy_updatePeriod(value)
-			unless SY_UPDATEPERIOD_AVAILABLE_VALUES.include?(value)
-				raise NotAvailableValueError.new("updatePeriod", value)
-			end
-		end
+    private
+    SY_UPDATEPERIOD_AVAILABLE_VALUES = %w(hourly daily weekly monthly yearly)
+    def validate_sy_updatePeriod(value)
+      unless SY_UPDATEPERIOD_AVAILABLE_VALUES.include?(value)
+        raise NotAvailableValueError.new("updatePeriod", value)
+      end
+    end
 
-		SY_UPDATEFREQUENCY_AVAILABLE_RE = /\A\s*\+?\d+\s*\z/
-		def validate_sy_updateFrequency(value)
-			if SY_UPDATEFREQUENCY_AVAILABLE_RE !~ value
-				raise NotAvailableValueError.new("updateFrequency", value)
-			end
-		end
+    SY_UPDATEFREQUENCY_AVAILABLE_RE = /\A\s*\+?\d+\s*\z/
+    def validate_sy_updateFrequency(value)
+      if SY_UPDATEFREQUENCY_AVAILABLE_RE !~ value
+        raise NotAvailableValueError.new("updateFrequency", value)
+      end
+    end
 
-	end
+  end
 
-	class RDF
-		class Channel; include SyndicationModel; end
-	end
+  class RDF
+    class Channel; include SyndicationModel; end
+  end
 
-	prefix_size = SY_PREFIX.size + 1
-	SyndicationModel::ELEMENTS.uniq!
-	SyndicationModel::ELEMENTS.each do |x|
-		BaseListener.install_get_text_element(x[prefix_size..-1], SY_URI, "#{x}=")
-	end
+  prefix_size = SY_PREFIX.size + 1
+  SyndicationModel::ELEMENTS.uniq!
+  SyndicationModel::ELEMENTS.each do |x|
+    BaseListener.install_get_text_element(x[prefix_size..-1], SY_URI, "#{x}=")
+  end
 
 end
diff --git a/lib/rss/taxonomy.rb b/lib/rss/taxonomy.rb
index 5b11d338e0..bec6ea3c17 100644
--- a/lib/rss/taxonomy.rb
+++ b/lib/rss/taxonomy.rb
@@ -4,29 +4,29 @@ require "rss/1.0"
 
 module RSS
 
-	TAXO_PREFIX = "taxo"
-	TAXO_NS = "http://purl.org/rss/1.0/modules/taxonomy/"
+  TAXO_PREFIX = "taxo"
+  TAXO_NS = "http://purl.org/rss/1.0/modules/taxonomy/"
 
-	Element.install_ns(TAXO_PREFIX, TAXO_NS)
+  Element.install_ns(TAXO_PREFIX, TAXO_NS)
 
-	TAXO_ELEMENTS = []
+  TAXO_ELEMENTS = []
 
-	%w(link).each do |x|
-		if const_defined? :Listener
-			Listener.install_get_text_element(x, TAXO_NS, "#{TAXO_PREFIX}_#{x}=")
-		end
-		TAXO_ELEMENTS << "#{TAXO_PREFIX}_#{x}"
-	end
-		
-	module TaxonomyModel
-		attr_writer(*%w(title description creator subject publisher
-		                contributor date format identifier source
-		                language relation coverage rights).collect{|x| "#{TAXO_PREFIX}_#{x}"})
-	end
-	
-	class Channel; extend TaxonomyModel;	end
-	class Item; extend TaxonomyModel;	end
-	class Image; extend TaxonomyModel;	end
-	class TextInput; extend TaxonomyModel;	end
-	
+  %w(link).each do |x|
+    if const_defined? :Listener
+      Listener.install_get_text_element(x, TAXO_NS, "#{TAXO_PREFIX}_#{x}=")
+    end
+    TAXO_ELEMENTS << "#{TAXO_PREFIX}_#{x}"
+  end
+    
+  module TaxonomyModel
+    attr_writer(*%w(title description creator subject publisher
+                    contributor date format identifier source
+                    language relation coverage rights).collect{|x| "#{TAXO_PREFIX}_#{x}"})
+  end
+  
+  class Channel; extend TaxonomyModel;	end
+  class Item; extend TaxonomyModel;	end
+  class Image; extend TaxonomyModel;	end
+  class TextInput; extend TaxonomyModel;	end
+  
 end
diff --git a/lib/rss/trackback.rb b/lib/rss/trackback.rb
index b427895aad..e276305ec1 100644
--- a/lib/rss/trackback.rb
+++ b/lib/rss/trackback.rb
@@ -3,304 +3,304 @@ require 'rss/2.0'
 
 module RSS
 
-	TRACKBACK_PREFIX = 'trackback'
-	TRACKBACK_URI = 'http://madskills.com/public/xml/rss/module/trackback/'
-
-	RDF.install_ns(TRACKBACK_PREFIX, TRACKBACK_URI)
-	Rss.install_ns(TRACKBACK_PREFIX, TRACKBACK_URI)
-
-	module BaseTrackBackModel
-		def trackback_validate(tags)
-			counter = {}
-			%w(ping about).each do |x|
-				counter["#{TRACKBACK_PREFIX}_#{x}"] = 0
-			end
-
-			tags.each do |tag|
-				key = "#{TRACKBACK_PREFIX}_#{tag}"
-				raise UnknownTagError.new(tag, TRACKBACK_URI) unless counter.has_key?(key)
-				counter[key] += 1
-				if tag != "about" and counter[key] > 1
-					raise TooMuchTagError.new(tag, tag_name)
-				end
-			end
-
-			if counter["#{TRACKBACK_PREFIX}_ping"].zero? and
-					counter["#{TRACKBACK_PREFIX}_about"].nonzero?
-				raise MissingTagError.new("#{TRACKBACK_PREFIX}:ping", tag_name)
-			end
-		end
-	end
-
-	module TrackBackModel10
-		extend BaseModel
-		include BaseTrackBackModel
-
-		def self.append_features(klass)
-			super
-
-			unless klass.class == Module
-				%w(ping).each do |x|
-					klass.install_have_child_element("#{TRACKBACK_PREFIX}_#{x}")
-				end
-				
-				%w(about).each do |x|
-					klass.install_have_children_element("#{TRACKBACK_PREFIX}_#{x}")
-				end
-			end
-		end
-
-		class Ping < Element
-			include RSS10
-
-			class << self
-
-				def required_prefix
-					TRACKBACK_PREFIX
-				end
-				
-				def required_uri
-					TRACKBACK_URI
-				end
-
-			end
-			
-			[
-				["resource", ::RSS::RDF::URI, true]
-			].each do |name, uri, required|
-				install_get_attribute(name, uri, required)
-			end
-
-			def initialize(resource=nil)
-				super()
-				@resource = resource
-			end
-
-			def to_s(convert=true, indent=calc_indent)
-				if @resource
-					rv = %Q[#{indent}<#{TRACKBACK_PREFIX}:ping ]
-					rv << %Q[#{::RSS::RDF::PREFIX}:resource="#{h @resource}"/>]
-					rv = @converter.convert(rv) if convert and @converter
-					rv
-				else
-					''
-				end
-			end
-
-			private
-			def _attrs
-				[
-					["resource", true],
-				]
-			end
-
-		end
-
-		class About < Element
-			include RSS10
-
-			class << self
-				
-				def required_prefix
-					TRACKBACK_PREFIX
-				end
-				
-				def required_uri
-					TRACKBACK_URI
-				end
-
-			end
-			
-			[
-				["resource", ::RSS::RDF::URI, true]
-			].each do |name, uri, required|
-				install_get_attribute(name, uri, required)
-			end
-
-			def initialize(resource=nil)
-				super()
-				@resource = resource
-			end
-
-			def to_s(convert=true, indent=calc_indent)
-				if @resource
-					rv = %Q[#{indent}<#{TRACKBACK_PREFIX}:about ]
-					rv << %Q[#{::RSS::RDF::PREFIX}:resource="#{h @resource}"/>]
-					rv = @converter.convert(rv) if convert and @converter
-					rv
-				else
-					''
-				end
-			end
-
-			private
-			def _attrs
-				[
-					["resource", true],
-				]
-			end
-
-		end
-	end
-
-	module TrackBackModel20
-		include BaseTrackBackModel
-		extend BaseModel
-
-		def self.append_features(klass)
-			super
-
-			unless klass.class == Module
-				%w(ping).each do |x|
-					var_name = "#{TRACKBACK_PREFIX}_#{x}"
-					klass.install_have_child_element(var_name)
-					klass.module_eval(<<-EOC)
-						alias _#{var_name} #{var_name}
-						def #{var_name}
-							@#{var_name} and @#{var_name}.content
-						end
-
-						alias _#{var_name}= #{var_name}=
-						def #{var_name}=(content)
-							@#{var_name} = new_with_content_if_need(#{x.capitalize}, content)
-						end
-					EOC
-				end
-				
-				[%w(about s)].each do |x, postfix|
-					var_name = "#{TRACKBACK_PREFIX}_#{x}"
-					klass.install_have_children_element(var_name)
-					klass.module_eval(<<-EOC)
-						alias _#{var_name}#{postfix} #{var_name}#{postfix}
-						def #{var_name}#{postfix}
-							@#{var_name}.collect {|x| x.content}
-						end
-
-						alias _#{var_name} #{var_name}
-						def #{var_name}(*args)
-							if args.empty?
-								@#{var_name}.first and @#{var_name}.first.content
-							else
-								ret = @#{var_name}.send("[]", *args)
-								if ret.is_a?(Array)
-									ret.collect {|x| x.content}
-								else
-									ret.content
-								end
-							end
-						end
-
-						alias _#{var_name}= #{var_name}=
-						alias _set_#{var_name} set_#{var_name}
-						def #{var_name}=(*args)
-							if args.size == 1
-								item = new_with_content_if_need(#{x.capitalize}, args[0])
-								@#{var_name}.push(item)
-							else
-								new_val = args.last
-								if new_val.is_a?(Array)
-									new_val = new_value.collect do |val|
-										new_with_content_if_need(#{x.capitalize}, val)
-									end
-								else
-									new_val = new_with_content_if_need(#{x.capitalize}, new_val)
-								end
-								@#{var_name}.send("[]=", *(args[0..-2] + [new_val]))
-							end
-						end
-						alias set_#{var_name} #{var_name}=
-					EOC
-				end
-			end
-		end
-
-		private
-		def new_with_content(klass, content)
-			obj = klass.new
-			obj.content = content
-			obj
-		end
-
-		def new_with_content_if_need(klass, content)
-			if content.is_a?(klass)
-				content
-			else
-				new_with_content(klass, content)
-			end
-		end
-
-
-		class Ping < Element
-			include RSS09
-
-			content_setup
-
-			class << self
-
-				def required_prefix
-					TRACKBACK_PREFIX
-				end
-				
-				def required_uri
-					TRACKBACK_URI
-				end
-
-			end
-			
-			def to_s(convert=true, indent=calc_indent)
-				if @content
-					rv = %Q[#{indent}<#{TRACKBACK_PREFIX}:ping>]
-					rv << h(@content)
-					rv << %Q[</#{TRACKBACK_PREFIX}:ping>]
-					rv = @converter.convert(rv) if convert and @converter
-					rv
-				else
-					''
-				end
-			end
-
-		end
-
-		class About < Element
-			include RSS09
-
-			content_setup
-
-			class << self
-				
-				def required_prefix
-					TRACKBACK_PREFIX
-				end
-				
-				def required_uri
-					TRACKBACK_URI
-				end
-
-			end
-			
-			def to_s(convert=true, indent=calc_indent)
-				if @content
-					rv = %Q[#{indent}<#{TRACKBACK_PREFIX}:about>]
-					rv << h(@content)
-					rv << %Q[</#{TRACKBACK_PREFIX}:about>]
-					rv = @converter.convert(rv) if convert and @converter
-					rv
-				else
-					''
-				end
-			end
-
-		end
-	end
-
-	class RDF
-		class Item; include TrackBackModel10; end
-	end
-
-	class Rss
-		class Channel
-			class Item; include TrackBackModel20; end
-		end
-	end
+  TRACKBACK_PREFIX = 'trackback'
+  TRACKBACK_URI = 'http://madskills.com/public/xml/rss/module/trackback/'
+
+  RDF.install_ns(TRACKBACK_PREFIX, TRACKBACK_URI)
+  Rss.install_ns(TRACKBACK_PREFIX, TRACKBACK_URI)
+
+  module BaseTrackBackModel
+    def trackback_validate(tags)
+      counter = {}
+      %w(ping about).each do |x|
+        counter["#{TRACKBACK_PREFIX}_#{x}"] = 0
+      end
+
+      tags.each do |tag|
+        key = "#{TRACKBACK_PREFIX}_#{tag}"
+        raise UnknownTagError.new(tag, TRACKBACK_URI) unless counter.has_key?(key)
+        counter[key] += 1
+        if tag != "about" and counter[key] > 1
+          raise TooMuchTagError.new(tag, tag_name)
+        end
+      end
+
+      if counter["#{TRACKBACK_PREFIX}_ping"].zero? and
+          counter["#{TRACKBACK_PREFIX}_about"].nonzero?
+        raise MissingTagError.new("#{TRACKBACK_PREFIX}:ping", tag_name)
+      end
+    end
+  end
+
+  module TrackBackModel10
+    extend BaseModel
+    include BaseTrackBackModel
+
+    def self.append_features(klass)
+      super
+
+      unless klass.class == Module
+        %w(ping).each do |x|
+          klass.install_have_child_element("#{TRACKBACK_PREFIX}_#{x}")
+        end
+        
+        %w(about).each do |x|
+          klass.install_have_children_element("#{TRACKBACK_PREFIX}_#{x}")
+        end
+      end
+    end
+
+    class Ping < Element
+      include RSS10
+
+      class << self
+
+        def required_prefix
+          TRACKBACK_PREFIX
+        end
+        
+        def required_uri
+          TRACKBACK_URI
+        end
+
+      end
+      
+      [
+        ["resource", ::RSS::RDF::URI, true]
+      ].each do |name, uri, required|
+        install_get_attribute(name, uri, required)
+      end
+
+      def initialize(resource=nil)
+        super()
+        @resource = resource
+      end
+
+      def to_s(convert=true, indent=calc_indent)
+        if @resource
+          rv = %Q[#{indent}<#{TRACKBACK_PREFIX}:ping ]
+          rv << %Q[#{::RSS::RDF::PREFIX}:resource="#{h @resource}"/>]
+          rv = @converter.convert(rv) if convert and @converter
+          rv
+        else
+          ''
+        end
+      end
+
+      private
+      def _attrs
+        [
+          ["resource", true],
+        ]
+      end
+
+    end
+
+    class About < Element
+      include RSS10
+
+      class << self
+        
+        def required_prefix
+          TRACKBACK_PREFIX
+        end
+        
+        def required_uri
+          TRACKBACK_URI
+        end
+
+      end
+      
+      [
+        ["resource", ::RSS::RDF::URI, true]
+      ].each do |name, uri, required|
+        install_get_attribute(name, uri, required)
+      end
+
+      def initialize(resource=nil)
+        super()
+        @resource = resource
+      end
+
+      def to_s(convert=true, indent=calc_indent)
+        if @resource
+          rv = %Q[#{indent}<#{TRACKBACK_PREFIX}:about ]
+          rv << %Q[#{::RSS::RDF::PREFIX}:resource="#{h @resource}"/>]
+          rv = @converter.convert(rv) if convert and @converter
+          rv
+        else
+          ''
+        end
+      end
+
+      private
+      def _attrs
+        [
+          ["resource", true],
+        ]
+      end
+
+    end
+  end
+
+  module TrackBackModel20
+    include BaseTrackBackModel
+    extend BaseModel
+
+    def self.append_features(klass)
+      super
+
+      unless klass.class == Module
+        %w(ping).each do |x|
+          var_name = "#{TRACKBACK_PREFIX}_#{x}"
+          klass.install_have_child_element(var_name)
+          klass.module_eval(<<-EOC)
+            alias _#{var_name} #{var_name}
+            def #{var_name}
+              @#{var_name} and @#{var_name}.content
+            end
+
+            alias _#{var_name}= #{var_name}=
+            def #{var_name}=(content)
+              @#{var_name} = new_with_content_if_need(#{x.capitalize}, content)
+            end
+          EOC
+        end
+        
+        [%w(about s)].each do |x, postfix|
+          var_name = "#{TRACKBACK_PREFIX}_#{x}"
+          klass.install_have_children_element(var_name)
+          klass.module_eval(<<-EOC)
+            alias _#{var_name}#{postfix} #{var_name}#{postfix}
+            def #{var_name}#{postfix}
+              @#{var_name}.collect {|x| x.content}
+            end
+
+            alias _#{var_name} #{var_name}
+            def #{var_name}(*args)
+              if args.empty?
+                @#{var_name}.first and @#{var_name}.first.content
+              else
+                ret = @#{var_name}.send("[]", *args)
+                if ret.is_a?(Array)
+                  ret.collect {|x| x.content}
+                else
+                  ret.content
+                end
+              end
+            end
+
+            alias _#{var_name}= #{var_name}=
+            alias _set_#{var_name} set_#{var_name}
+            def #{var_name}=(*args)
+              if args.size == 1
+                item = new_with_content_if_need(#{x.capitalize}, args[0])
+                @#{var_name}.push(item)
+              else
+                new_val = args.last
+                if new_val.is_a?(Array)
+                  new_val = new_value.collect do |val|
+                    new_with_content_if_need(#{x.capitalize}, val)
+                  end
+                else
+                  new_val = new_with_content_if_need(#{x.capitalize}, new_val)
+                end
+                @#{var_name}.send("[]=", *(args[0..-2] + [new_val]))
+              end
+            end
+            alias set_#{var_name} #{var_name}=
+          EOC
+        end
+      end
+    end
+
+    private
+    def new_with_content(klass, content)
+      obj = klass.new
+      obj.content = content
+      obj
+    end
+
+    def new_with_content_if_need(klass, content)
+      if content.is_a?(klass)
+        content
+      else
+        new_with_content(klass, content)
+      end
+    end
+
+
+    class Ping < Element
+      include RSS09
+
+      content_setup
+
+      class << self
+
+        def required_prefix
+          TRACKBACK_PREFIX
+        end
+        
+        def required_uri
+          TRACKBACK_URI
+        end
+
+      end
+      
+      def to_s(convert=true, indent=calc_indent)
+        if @content
+          rv = %Q[#{indent}<#{TRACKBACK_PREFIX}:ping>]
+          rv << h(@content)
+          rv << %Q[</#{TRACKBACK_PREFIX}:ping>]
+          rv = @converter.convert(rv) if convert and @converter
+          rv
+        else
+          ''
+        end
+      end
+
+    end
+
+    class About < Element
+      include RSS09
+
+      content_setup
+
+      class << self
+        
+        def required_prefix
+          TRACKBACK_PREFIX
+        end
+        
+        def required_uri
+          TRACKBACK_URI
+        end
+
+      end
+      
+      def to_s(convert=true, indent=calc_indent)
+        if @content
+          rv = %Q[#{indent}<#{TRACKBACK_PREFIX}:about>]
+          rv << h(@content)
+          rv << %Q[</#{TRACKBACK_PREFIX}:about>]
+          rv = @converter.convert(rv) if convert and @converter
+          rv
+        else
+          ''
+        end
+      end
+
+    end
+  end
+
+  class RDF
+    class Item; include TrackBackModel10; end
+  end
+
+  class Rss
+    class Channel
+      class Item; include TrackBackModel20; end
+    end
+  end
 
 end
diff --git a/lib/rss/utils.rb b/lib/rss/utils.rb
index ae6f69bcf1..1c30ae74bc 100644
--- a/lib/rss/utils.rb
+++ b/lib/rss/utils.rb
@@ -1,17 +1,17 @@
 module RSS
 
-	module Utils
+  module Utils
 
-		def get_file_and_line_from_caller(i=0)
-			file, line, = caller[i].split(':')
-			[file, line.to_i]
-		end
+    def get_file_and_line_from_caller(i=0)
+      file, line, = caller[i].split(':')
+      [file, line.to_i]
+    end
 
-		def html_escape(s)
-			s.to_s.gsub(/&/, "&amp;").gsub(/\"/, "&quot;").gsub(/>/, "&gt;").gsub(/</, "&lt;")
-		end
-		alias h html_escape
-		
-	end
+    def html_escape(s)
+      s.to_s.gsub(/&/, "&amp;").gsub(/\"/, "&quot;").gsub(/>/, "&gt;").gsub(/</, "&lt;")
+    end
+    alias h html_escape
+    
+  end
 
 end
diff --git a/lib/rss/xml-stylesheet.rb b/lib/rss/xml-stylesheet.rb
index 7862c4f278..726899ed88 100644
--- a/lib/rss/xml-stylesheet.rb
+++ b/lib/rss/xml-stylesheet.rb
@@ -2,93 +2,93 @@ require "rss/utils"
 
 module RSS
 
-	module XMLStyleSheetMixin
-		attr_accessor :xml_stylesheets
-		def initialize(*args)
-			super
-			@xml_stylesheets = []
-		end
-		
-		private
-		def xml_stylesheet_pi
-			xsss = @xml_stylesheets.collect do |xss|
-				pi = xss.to_s
-				pi = nil if /\A\s*\z/ =~ pi
-				pi
-			end.compact
-			xsss.push("") unless xsss.empty?
-			xsss.join("\n")
-		end
-	end
+  module XMLStyleSheetMixin
+    attr_accessor :xml_stylesheets
+    def initialize(*args)
+      super
+      @xml_stylesheets = []
+    end
+    
+    private
+    def xml_stylesheet_pi
+      xsss = @xml_stylesheets.collect do |xss|
+        pi = xss.to_s
+        pi = nil if /\A\s*\z/ =~ pi
+        pi
+      end.compact
+      xsss.push("") unless xsss.empty?
+      xsss.join("\n")
+    end
+  end
 
-	class XMLStyleSheet
+  class XMLStyleSheet
 
-		include Utils
+    include Utils
 
-		ATTRIBUTES = %w(href type title media charset alternate)
+    ATTRIBUTES = %w(href type title media charset alternate)
 
-		GUESS_TABLE = {
-			"xsl" => "text/xsl",
-			"css" => "text/css",
-		}
+    GUESS_TABLE = {
+      "xsl" => "text/xsl",
+      "css" => "text/css",
+    }
 
-		attr_accessor(*ATTRIBUTES)
-		attr_accessor(:do_validate)
-		def initialize(*attrs)
-			@do_validate = true
-			ATTRIBUTES.each do |attr|
-				self.send("#{attr}=", nil)
-			end
-			vars = ATTRIBUTES.dup
-			vars.unshift(:do_validate)
-			attrs.each do |name, value|
-				if vars.include?(name.to_s)
-					self.send("#{name}=", value)
-				end
-			end
-		end
+    attr_accessor(*ATTRIBUTES)
+    attr_accessor(:do_validate)
+    def initialize(*attrs)
+      @do_validate = true
+      ATTRIBUTES.each do |attr|
+        self.send("#{attr}=", nil)
+      end
+      vars = ATTRIBUTES.dup
+      vars.unshift(:do_validate)
+      attrs.each do |name, value|
+        if vars.include?(name.to_s)
+          self.send("#{name}=", value)
+        end
+      end
+    end
 
-		def to_s
-			rv = ""
-			if @href
-				rv << %Q[<?xml-stylesheet]
-				ATTRIBUTES.each do |name|
-					if self.send(name)
-						rv << %Q[ #{name}="#{h self.send(name)}"]
-					end
-				end
-				rv << %Q[?>]
-			end
-			rv
-		end
+    def to_s
+      rv = ""
+      if @href
+        rv << %Q[<?xml-stylesheet]
+        ATTRIBUTES.each do |name|
+          if self.send(name)
+            rv << %Q[ #{name}="#{h self.send(name)}"]
+          end
+        end
+        rv << %Q[?>]
+      end
+      rv
+    end
 
-		remove_method(:href=)
-		def href=(value)
-			@href = value
-			if @href and @type.nil?
-				@type = guess_type(@href)
-			end
-			@href
-		end
+    remove_method(:href=)
+    def href=(value)
+      @href = value
+      if @href and @type.nil?
+        @type = guess_type(@href)
+      end
+      @href
+    end
 
-		remove_method(:alternate=)
-		def alternate=(value)
-			if value.nil? or /\A(?:yes|no)\z/ =~ value
-				@alternate = value
-			else
-				if @do_validate
-					args = ["?xml-stylesheet?", %Q[alternate="#{value}"]]
-					raise NotAvailableValueError.new(*args)
-				end
-			end
-			@alternate
-		end
+    remove_method(:alternate=)
+    def alternate=(value)
+      if value.nil? or /\A(?:yes|no)\z/ =~ value
+        @alternate = value
+      else
+        if @do_validate
+          args = ["?xml-stylesheet?", %Q[alternate="#{value}"]]
+          raise NotAvailableValueError.new(*args)
+        end
+      end
+      @alternate
+    end
 
-		private
-		def guess_type(filename)
-			/\.([^.]+)/ =~ filename
-			GUESS_TABLE[$1]
-		end
+    private
+    def guess_type(filename)
+      /\.([^.]+)/ =~ filename
+      GUESS_TABLE[$1]
+    end
 
-	end
+  end
 end
diff --git a/lib/rss/xmlparser.rb b/lib/rss/xmlparser.rb
index 7be0dc9a11..64737b821b 100644
--- a/lib/rss/xmlparser.rb
+++ b/lib/rss/xmlparser.rb
@@ -1,91 +1,91 @@
 begin
-	require "xml/parser"
+  require "xml/parser"
 rescue LoadError
-	require "xmlparser"
+  require "xmlparser"
 end
 
 begin
-	require "xml/encoding-ja"
+  require "xml/encoding-ja"
 rescue LoadError
-	require "xmlencoding-ja"
-	if defined?(Kconv)
-		module XMLEncoding_ja
-			class SJISHandler
-				include Kconv
-			end
-		end
-	end
+  require "xmlencoding-ja"
+  if defined?(Kconv)
+    module XMLEncoding_ja
+      class SJISHandler
+        include Kconv
+      end
+    end
+  end
 end
 
 module XML
-	class Parser
-		unless defined?(Error)
-			Error = ::XMLParserError
-		end
-	end
+  class Parser
+    unless defined?(Error)
+      Error = ::XMLParserError
+    end
+  end
 end
 
 module RSS
-	
-	class REXMLLikeXMLParser < ::XML::Parser
-		
-		include ::XML::Encoding_ja
+  
+  class REXMLLikeXMLParser < ::XML::Parser
+    
+    include ::XML::Encoding_ja
 
-		def listener=(listener)
-			@listener = listener
-		end
+    def listener=(listener)
+      @listener = listener
+    end
 
-		def startElement(name, attrs)
-			@listener.tag_start(name, attrs)
-		end
-		
-		def endElement(name)
-			@listener.tag_end(name)
-		end
+    def startElement(name, attrs)
+      @listener.tag_start(name, attrs)
+    end
+    
+    def endElement(name)
+      @listener.tag_end(name)
+    end
 
-		def character(data)
-			@listener.text(data)
-		end
+    def character(data)
+      @listener.text(data)
+    end
 
-		def xmlDecl(version, encoding, standalone)
-			@listener.xmldecl(version, encoding, standalone == 1)
-		end
+    def xmlDecl(version, encoding, standalone)
+      @listener.xmldecl(version, encoding, standalone == 1)
+    end
 
-		def processingInstruction(target, content)
-			@listener.instruction(target, content)
-		end
+    def processingInstruction(target, content)
+      @listener.instruction(target, content)
+    end
 
-	end
+  end
 
-	class XMLParserParser < BaseParser
+  class XMLParserParser < BaseParser
 
-		private
-		def listener
-			XMLParserListener
-		end
+    private
+    def listener
+      XMLParserListener
+    end
 
-		def _parse
-			begin
-				parser = REXMLLikeXMLParser.new
-				parser.listener = @listener
-				parser.parse(@rss)
-			rescue ::XML::Parser::Error => e
-				raise NotWellFormedError.new(parser.line){e.message}
-			end
-		end
-		
-	end
-	
-	class XMLParserListener < BaseListener
+    def _parse
+      begin
+        parser = REXMLLikeXMLParser.new
+        parser.listener = @listener
+        parser.parse(@rss)
+      rescue ::XML::Parser::Error => e
+        raise NotWellFormedError.new(parser.line){e.message}
+      end
+    end
+    
+  end
+  
+  class XMLParserListener < BaseListener
 
-		include ListenerMixin
-		
-		def xmldecl(version, encoding, standalone)
-			super
-			# Encoding is converted to UTF-8 when XMLParser parses XML.
-			@encoding = 'UTF-8'
-		end
+    include ListenerMixin
+    
+    def xmldecl(version, encoding, standalone)
+      super
+      # Encoding is converted to UTF-8 when XMLParser parses XML.
+      @encoding = 'UTF-8'
+    end
 
-	end
+  end
 
 end
diff --git a/lib/rss/xmlscanner.rb b/lib/rss/xmlscanner.rb
index 4ab997062d..472ca93523 100644
--- a/lib/rss/xmlscanner.rb
+++ b/lib/rss/xmlscanner.rb
@@ -1,102 +1,102 @@
 require 'xmlscan/scanner'
 
 module RSS
-	
-	class XMLScanParser < BaseParser
-		
-		private
-		def listener
-			XMLScanListener
-		end
-
-		def _parse
-			begin
-				XMLScan::XMLScanner.new(@listener).parse(@rss)
-			rescue XMLScan::Error => e
-				raise NotWellFormedError.new(e.lineno){e.message}
-			end
-		end
-		
-	end
-
-	class XMLScanListener < BaseListener
-		
-		include XMLScan::Visitor
-		include ListenerMixin
-
-		ENTITIES = {
-			'lt' => '<',
-			'gt' => '>',
-			'amp' => '&',
-			'quot' => '"',
-			'apos' => '\''
-		}
+  
+  class XMLScanParser < BaseParser
+    
+    private
+    def listener
+      XMLScanListener
+    end
+
+    def _parse
+      begin
+        XMLScan::XMLScanner.new(@listener).parse(@rss)
+      rescue XMLScan::Error => e
+        raise NotWellFormedError.new(e.lineno){e.message}
+      end
+    end
+    
+  end
+
+  class XMLScanListener < BaseListener
+    
+    include XMLScan::Visitor
+    include ListenerMixin
+
+    ENTITIES = {
+      'lt' => '<',
+      'gt' => '>',
+      'amp' => '&',
+      'quot' => '"',
+      'apos' => '\''
+    }
 
     def on_xmldecl_version(str)
-			@version = str
+      @version = str
     end
 
     def on_xmldecl_encoding(str)
-			@encoding = str
+      @encoding = str
     end
 
     def on_xmldecl_standalone(str)
-			@standalone = str
+      @standalone = str
     end
 
     def on_xmldecl_end
-			xmldecl(@version, @encoding, @standalone)
+      xmldecl(@version, @encoding, @standalone)
     end
 
-		alias_method(:on_pi, :instruction)
-		alias_method(:on_chardata, :text)
-		alias_method(:on_cdata, :text)
+    alias_method(:on_pi, :instruction)
+    alias_method(:on_chardata, :text)
+    alias_method(:on_cdata, :text)
 
     def on_etag(name)
       tag_end(name)
     end
 
     def on_entityref(ref)
-			text(ENTITIES[ref])
+      text(ENTITIES[ref])
     end
 
     def on_charref(code)
-			text([code].pack('U'))
+      text([code].pack('U'))
     end
 
-		alias_method(:on_charref_hex, :on_charref)
+    alias_method(:on_charref_hex, :on_charref)
 
     def on_stag(name)
-			@attrs = {}
+      @attrs = {}
     end
 
     def on_attribute(name)
-			@attrs[name] = @current_attr = ''
+      @attrs[name] = @current_attr = ''
     end
 
     def on_attr_value(str)
-			@current_attr << str
+      @current_attr << str
     end
 
     def on_attr_entityref(ref)
-			@current_attr << ENTITIES[ref]
+      @current_attr << ENTITIES[ref]
     end
 
     def on_attr_charref(code)
-			@current_attr << [code].pack('U')
+      @current_attr << [code].pack('U')
     end
 
-		alias_method(:on_attr_charref_hex, :on_attr_charref)
+    alias_method(:on_attr_charref_hex, :on_attr_charref)
 
     def on_stag_end(name)
-			tag_start(name, @attrs)
+      tag_start(name, @attrs)
     end
 
     def on_stag_end_empty(name)
-			tag_start(name, @attrs)
-			tag_end(name)
+      tag_start(name, @attrs)
+      tag_end(name)
     end
 
-	end
+  end
 
 end