savant-echo 1.0.4 → 1.0.5

data/bin/alexa-0.1.2-osx/lib/ruby/lib/ruby/2.2.0/rss/rexmlparser.rb

@@ -1,49 +0,0 @@
-require "rexml/document"
-require "rexml/streamlistener"
-
-module RSS
-
-  class REXMLParser < BaseParser
-
-    class << self
-      def listener
-        REXMLListener
-      end
-    end
-
-    private
-    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
-
-    class << self
-      def raise_for_undefined_entity?
-        false
-      end
-    end
-
-    def xmldecl(version, encoding, standalone)
-      super(version, encoding, standalone == "yes")
-      # Encoding is converted to UTF-8 when REXML parse XML.
-      @encoding = 'UTF-8'
-    end
-
-    alias_method(:cdata, :text)
-  end
-
-end

data/bin/alexa-0.1.2-osx/lib/ruby/lib/ruby/2.2.0/rss/rss.rb

@@ -1,1352 +0,0 @@
-require "time"
-
-class Time
-  class << self
-    unless respond_to?(:w3cdtf)
-      # This method converts a W3CDTF string date/time format to Time object.
-      #
-      # The W3CDTF format is defined here: http://www.w3.org/TR/NOTE-datetime
-      #
-      #   Time.w3cdtf('2003-02-15T13:50:05-05:00')
-      #   # => 2003-02-15 10:50:05 -0800
-      #   Time.w3cdtf('2003-02-15T13:50:05-05:00').class
-      #   # => Time
-      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]
-          usec = 0
-          usec = $7.to_f * 1000000 if $7
-          zone = $8
-          if zone
-            off = zone_offset(zone, datetime[0])
-            datetime = apply_offset(*(datetime + [off]))
-            datetime << usec
-            time = Time.utc(*datetime)
-            force_zone!(time, zone, off)
-            time
-          else
-            datetime << usec
-            Time.local(*datetime)
-          end
-        else
-          raise ArgumentError.new("invalid date: #{date.inspect}")
-        end
-      end
-    end
-  end
-
-  unless method_defined?(:w3cdtf)
-    # This method converts a Time object to a String. The String contains the
-    # time in W3CDTF date/time format.
-    #
-    # The W3CDTF format is defined here: http://www.w3.org/TR/NOTE-datetime
-    #
-    #  Time.now.w3cdtf
-    #  # => "2013-08-26T14:12:10.817124-07:00"
-    def w3cdtf
-      if usec.zero?
-        fraction_digits = 0
-      else
-        fraction_digits = Math.log10(usec.to_s.sub(/0*$/, '').to_i).floor + 1
-      end
-      xmlschema(fraction_digits)
-    end
-  end
-end
-
-
-require "English"
-require "rss/utils"
-require "rss/converter"
-require "rss/xml-stylesheet"
-
-module RSS
-
-  # The current version of RSS
-  VERSION = "0.2.7"
-
-  # The URI of the RSS 1.0 specification
-  URI = "http://purl.org/rss/1.0/"
-
-  DEBUG = false # :nodoc:
-
-  # The basic error all other RSS errors stem from. Rescue this error if you
-  # want to handle any given RSS error and you don't care about the details.
-  class Error < StandardError; end
-
-  # RSS, being an XML-based format, has namespace support. If two namespaces are
-  # declared with the same name, an OverlappedPrefixError will be raised.
-  class OverlappedPrefixError < Error
-    attr_reader :prefix
-    def initialize(prefix)
-      @prefix = prefix
-    end
-  end
-
-  # The InvalidRSSError error is the base class for a variety of errors
-  # related to a poorly-formed RSS feed. Rescue this error if you only
-  # care that a file could be invalid, but don't care how it is invalid.
-  class InvalidRSSError < Error; end
-
-  # Since RSS is based on XML, it must have opening and closing tags that
-  # match. If they don't, a MissingTagError will be raised.
-  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
-
-  # Some tags must only exist a specific number of times in a given RSS feed.
-  # If a feed has too many occurrences of one of these tags, a TooMuchTagError
-  # will be raised.
-  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
-
-  # Certain attributes are required on specific tags in an RSS feed. If a feed
-  # is missing one of these attributes, a MissingAttributeError is raised.
-  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
-
-  # RSS does not allow for free-form tag names, so if an RSS feed contains a
-  # tag that we don't know about, an UnknownTagError is raised.
-  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
-
-  # Raised when an unexpected tag is encountered.
-  class NotExpectedTagError < InvalidRSSError
-    attr_reader :tag, :uri, :parent
-    def initialize(tag, uri, parent)
-      @tag, @uri, @parent = tag, uri, parent
-      super("tag <{#{uri}}#{tag}> is not expected in tag <#{parent}>")
-    end
-  end
-  # For backward compatibility :X
-  NotExceptedTagError = NotExpectedTagError # :nodoc:
-
-  # Attributes are in key-value form, and if there's no value provided for an
-  # attribute, a NotAvailableValueError will be raised.
-  class NotAvailableValueError < InvalidRSSError
-    attr_reader :tag, :value, :attribute
-    def initialize(tag, value, attribute=nil)
-      @tag, @value, @attribute = tag, value, attribute
-      message = "value <#{value}> of "
-      message << "attribute <#{attribute}> of " if attribute
-      message << "tag <#{tag}> is not available."
-      super(message)
-    end
-  end
-
-  # Raised when an unknown conversion error occurs.
-  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 # :nodoc:
-
-  # Raised when a conversion failure occurs.
-  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
-
-  # Raised when a required variable is not set.
-  class NotSetError < Error
-    attr_reader :name, :variables
-    def initialize(name, variables)
-      @name = name
-      @variables = variables
-      super("required variables of #{@name} are not set: #{@variables.join(', ')}")
-    end
-  end
-
-  # Raised when a RSS::Maker attempts to use an unknown maker.
-  class UnsupportedMakerVersionError < Error
-    attr_reader :version
-    def initialize(version)
-      @version = version
-      super("Maker doesn't support version: #{@version}")
-    end
-  end
-
-  module BaseModel
-    include Utils
-
-    def install_have_child_element(tag_name, uri, occurs, name=nil, type=nil)
-      name ||= tag_name
-      add_need_initialize_variable(name)
-      install_model(tag_name, uri, occurs, name)
-
-      writer_type, reader_type = type
-      def_corresponded_attr_writer name, writer_type
-      def_corresponded_attr_reader name, reader_type
-      install_element(name) do |n, elem_name|
-        <<-EOC
-        if @#{n}
-          "\#{@#{n}.to_s(need_convert, indent)}"
-        else
-          ''
-        end
-EOC
-      end
-    end
-    alias_method(:install_have_attribute_element, :install_have_child_element)
-
-    def install_have_children_element(tag_name, uri, occurs, name=nil, plural_name=nil)
-      name ||= tag_name
-      plural_name ||= "#{name}s"
-      add_have_children_element(name, plural_name)
-      add_plural_form(name, plural_name)
-      install_model(tag_name, uri, occurs, plural_name, true)
-
-      def_children_accessor(name, plural_name)
-      install_element(name, "s") do |n, elem_name|
-        <<-EOC
-        rv = []
-        @#{n}.each do |x|
-          value = "\#{x.to_s(need_convert, indent)}"
-          rv << value if /\\A\\s*\\z/ !~ value
-        end
-        rv.join("\n")
-EOC
-      end
-    end
-
-    def install_text_element(tag_name, uri, occurs, name=nil, type=nil,
-                             disp_name=nil)
-      name ||= tag_name
-      disp_name ||= name
-      self::ELEMENTS << name unless self::ELEMENTS.include?(name)
-      add_need_initialize_variable(name)
-      install_model(tag_name, uri, occurs, name)
-
-      def_corresponded_attr_writer(name, type, disp_name)
-      def_corresponded_attr_reader(name, type || :convert)
-      install_element(name) do |n, elem_name|
-        <<-EOC
-        if respond_to?(:#{n}_content)
-          content = #{n}_content
-        else
-          content = @#{n}
-        end
-        if content
-          rv = "\#{indent}<#{elem_name}>"
-          value = html_escape(content)
-          if need_convert
-            rv << convert(value)
-          else
-            rv << value
-          end
-            rv << "</#{elem_name}>"
-          rv
-        else
-          ''
-        end
-EOC
-      end
-    end
-
-    def install_date_element(tag_name, uri, occurs, name=nil, type=nil, disp_name=nil)
-      name ||= tag_name
-      type ||= :w3cdtf
-      disp_name ||= name
-      self::ELEMENTS << name
-      add_need_initialize_variable(name)
-      install_model(tag_name, uri, occurs, name)
-
-      # accessor
-      convert_attr_reader name
-      date_writer(name, type, disp_name)
-
-      install_element(name) do |n, elem_name|
-        <<-EOC
-        if @#{n}
-          rv = "\#{indent}<#{elem_name}>"
-          value = html_escape(@#{n}.#{type})
-          if need_convert
-            rv << 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('_', ':')
-      method_name = "#{name}_element#{postfix}"
-      add_to_element_method(method_name)
-      module_eval(<<-EOC, *get_file_and_line_from_caller(2))
-      def #{method_name}(need_convert=true, indent='')
-        #{yield(name, elem_name)}
-      end
-      private :#{method_name}
-EOC
-    end
-
-    def inherit_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}_without_inherit
-          convert(@#{attr})
-        end
-
-        def #{attr}
-          if @#{attr}
-            #{attr}_without_inherit
-          elsif @parent
-            @parent.#{attr}
-          else
-            nil
-          end
-        end
-EOC
-      end
-    end
-
-    def uri_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}_without_base
-          convert(@#{attr})
-        end
-
-        def #{attr}
-          value = #{attr}_without_base
-          return nil if value.nil?
-          if /\\A[a-z][a-z0-9+.\\-]*:/i =~ value
-            value
-          else
-            "\#{base}\#{value}"
-          end
-        end
-EOC
-      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}
-          convert(@#{attr})
-        end
-EOC
-      end
-    end
-
-    def yes_clean_other_attr_reader(*attrs)
-      attrs.each do |attr|
-        attr = attr.id2name if attr.kind_of?(Integer)
-        module_eval(<<-EOC, __FILE__, __LINE__ + 1)
-          attr_reader(:#{attr})
-          def #{attr}?
-            YesCleanOther.parse(@#{attr})
-          end
-        EOC
-      end
-    end
-
-    def yes_other_attr_reader(*attrs)
-      attrs.each do |attr|
-        attr = attr.id2name if attr.kind_of?(Integer)
-        module_eval(<<-EOC, __FILE__, __LINE__ + 1)
-          attr_reader(:#{attr})
-          def #{attr}?
-            Utils::YesOther.parse(@#{attr})
-          end
-        EOC
-      end
-    end
-
-    def csv_attr_reader(*attrs)
-      separator = nil
-      if attrs.last.is_a?(Hash)
-        options = attrs.pop
-        separator = options[:separator]
-      end
-      separator ||= ", "
-      attrs.each do |attr|
-        attr = attr.id2name if attr.kind_of?(Integer)
-        module_eval(<<-EOC, __FILE__, __LINE__ + 1)
-          attr_reader(:#{attr})
-          def #{attr}_content
-            if @#{attr}.nil?
-              @#{attr}
-            else
-              @#{attr}.join(#{separator.dump})
-            end
-          end
-        EOC
-      end
-    end
-
-    def date_writer(name, type, disp_name=name)
-      module_eval(<<-EOC, *get_file_and_line_from_caller(2))
-      def #{name}=(new_value)
-        if new_value.nil?
-          @#{name} = new_value
-        elsif new_value.kind_of?(Time)
-          @#{name} = new_value.dup
-        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
-                unless Date._parse(new_value, false).empty?
-                  @#{name} = Time.parse(new_value)
-                end
-              rescue ArgumentError
-              end
-            end
-          end
-        end
-
-        # Is it need?
-        if @#{name}
-          class << @#{name}
-            undef_method(:to_s)
-            alias_method(:to_s, :#{type})
-          end
-        end
-
-      end
-EOC
-    end
-
-    def integer_writer(name, disp_name=name)
-      module_eval(<<-EOC, *get_file_and_line_from_caller(2))
-      def #{name}=(new_value)
-        if new_value.nil?
-          @#{name} = new_value
-        else
-          if @do_validate
-            begin
-              @#{name} = Integer(new_value)
-            rescue ArgumentError
-              raise NotAvailableValueError.new('#{disp_name}', new_value)
-            end
-          else
-            @#{name} = new_value.to_i
-          end
-        end
-      end
-EOC
-    end
-
-    def positive_integer_writer(name, disp_name=name)
-      module_eval(<<-EOC, *get_file_and_line_from_caller(2))
-      def #{name}=(new_value)
-        if new_value.nil?
-          @#{name} = new_value
-        else
-          if @do_validate
-            begin
-              tmp = Integer(new_value)
-              raise ArgumentError if tmp <= 0
-              @#{name} = tmp
-            rescue ArgumentError
-              raise NotAvailableValueError.new('#{disp_name}', new_value)
-            end
-          else
-            @#{name} = new_value.to_i
-          end
-        end
-      end
-EOC
-    end
-
-    def boolean_writer(name, disp_name=name)
-      module_eval(<<-EOC, *get_file_and_line_from_caller(2))
-      def #{name}=(new_value)
-        if new_value.nil?
-          @#{name} = new_value
-        else
-          if @do_validate and
-              ![true, false, "true", "false"].include?(new_value)
-            raise NotAvailableValueError.new('#{disp_name}', new_value)
-          end
-          if [true, false].include?(new_value)
-            @#{name} = new_value
-          else
-            @#{name} = new_value == "true"
-          end
-        end
-      end
-EOC
-    end
-
-    def text_type_writer(name, disp_name=name)
-      module_eval(<<-EOC, *get_file_and_line_from_caller(2))
-      def #{name}=(new_value)
-        if @do_validate and
-            !["text", "html", "xhtml", nil].include?(new_value)
-          raise NotAvailableValueError.new('#{disp_name}', new_value)
-        end
-        @#{name} = new_value
-      end
-EOC
-    end
-
-    def content_writer(name, disp_name=name)
-      klass_name = "self.class::#{Utils.to_class_name(name)}"
-      module_eval(<<-EOC, *get_file_and_line_from_caller(2))
-      def #{name}=(new_value)
-        if new_value.is_a?(#{klass_name})
-          @#{name} = new_value
-        else
-          @#{name} = #{klass_name}.new
-          @#{name}.content = new_value
-        end
-      end
-EOC
-    end
-
-    def yes_clean_other_writer(name, disp_name=name)
-      module_eval(<<-EOC, __FILE__, __LINE__ + 1)
-        def #{name}=(value)
-          value = (value ? "yes" : "no") if [true, false].include?(value)
-          @#{name} = value
-        end
-      EOC
-    end
-
-    def yes_other_writer(name, disp_name=name)
-      module_eval(<<-EOC, __FILE__, __LINE__ + 1)
-        def #{name}=(new_value)
-          if [true, false].include?(new_value)
-            new_value = new_value ? "yes" : "no"
-          end
-          @#{name} = new_value
-        end
-      EOC
-    end
-
-    def csv_writer(name, disp_name=name)
-      module_eval(<<-EOC, __FILE__, __LINE__ + 1)
-        def #{name}=(new_value)
-          @#{name} = Utils::CSV.parse(new_value)
-        end
-      EOC
-    end
-
-    def csv_integer_writer(name, disp_name=name)
-      module_eval(<<-EOC, __FILE__, __LINE__ + 1)
-        def #{name}=(new_value)
-          @#{name} = Utils::CSV.parse(new_value) {|v| Integer(v)}
-        end
-      EOC
-    end
-
-    def def_children_accessor(accessor_name, plural_name)
-      module_eval(<<-EOC, *get_file_and_line_from_caller(2))
-      def #{plural_name}
-        @#{accessor_name}
-      end
-
-      def #{accessor_name}(*args)
-        if args.empty?
-          @#{accessor_name}.first
-        else
-          @#{accessor_name}[*args]
-        end
-      end
-
-      def #{accessor_name}=(*args)
-        receiver = self.class.name
-        warn("Warning:\#{caller.first.sub(/:in `.*'\z/, '')}: " \
-             "Don't use `\#{receiver}\##{accessor_name} = XXX'/" \
-             "`\#{receiver}\#set_#{accessor_name}(XXX)'. " \
-             "Those APIs are not sense of Ruby. " \
-             "Use `\#{receiver}\##{plural_name} << XXX' instead of them.")
-        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
-
-  module SetupMaker
-    def setup_maker(maker)
-      target = maker_target(maker)
-      unless target.nil?
-        setup_maker_attributes(target)
-        setup_maker_element(target)
-        setup_maker_elements(target)
-      end
-    end
-
-    private
-    def maker_target(maker)
-      nil
-    end
-
-    def setup_maker_attributes(target)
-    end
-
-    def setup_maker_element(target)
-      self.class.need_initialize_variables.each do |var|
-        value = __send__(var)
-        next if value.nil?
-        if value.respond_to?("setup_maker") and
-            !not_need_to_call_setup_maker_variables.include?(var)
-          value.setup_maker(target)
-        else
-          setter = "#{var}="
-          if target.respond_to?(setter)
-            target.__send__(setter, value)
-          end
-        end
-      end
-    end
-
-    def not_need_to_call_setup_maker_variables
-      []
-    end
-
-    def setup_maker_elements(parent)
-      self.class.have_children_elements.each do |name, plural_name|
-        if parent.respond_to?(plural_name)
-          target = parent.__send__(plural_name)
-          __send__(plural_name).each do |elem|
-            elem.setup_maker(target)
-          end
-        end
-      end
-    end
-  end
-
-  class Element
-    extend BaseModel
-    include Utils
-    extend Utils::InheritedReader
-    include SetupMaker
-
-    INDENT = "  "
-
-    MUST_CALL_VALIDATORS = {}
-    MODELS = []
-    GET_ATTRIBUTES = []
-    HAVE_CHILDREN_ELEMENTS = []
-    TO_ELEMENT_METHODS = []
-    NEED_INITIALIZE_VARIABLES = []
-    PLURAL_FORMS = {}
-
-    class << self
-      def must_call_validators
-        inherited_hash_reader("MUST_CALL_VALIDATORS")
-      end
-      def models
-        inherited_array_reader("MODELS")
-      end
-      def get_attributes
-        inherited_array_reader("GET_ATTRIBUTES")
-      end
-      def have_children_elements
-        inherited_array_reader("HAVE_CHILDREN_ELEMENTS")
-      end
-      def to_element_methods
-        inherited_array_reader("TO_ELEMENT_METHODS")
-      end
-      def need_initialize_variables
-        inherited_array_reader("NEED_INITIALIZE_VARIABLES")
-      end
-      def plural_forms
-        inherited_hash_reader("PLURAL_FORMS")
-      end
-
-      def inherited_base
-        ::RSS::Element
-      end
-
-      def inherited(klass)
-        klass.const_set(:MUST_CALL_VALIDATORS, {})
-        klass.const_set(:MODELS, [])
-        klass.const_set(:GET_ATTRIBUTES, [])
-        klass.const_set(:HAVE_CHILDREN_ELEMENTS, [])
-        klass.const_set(:TO_ELEMENT_METHODS, [])
-        klass.const_set(:NEED_INITIALIZE_VARIABLES, [])
-        klass.const_set(:PLURAL_FORMS, {})
-
-        tag_name = klass.name.split(/::/).last
-        tag_name[0, 1] = tag_name[0, 1].downcase
-        klass.instance_variable_set(:@tag_name, tag_name)
-        klass.instance_variable_set(:@have_content, false)
-      end
-
-      def install_must_call_validator(prefix, uri)
-        self::MUST_CALL_VALIDATORS[uri] = prefix
-      end
-
-      def install_model(tag, uri, occurs=nil, getter=nil, plural=false)
-        getter ||= tag
-        if m = self::MODELS.find {|t, u, o, g, p| t == tag and u == uri}
-          m[2] = occurs
-        else
-          self::MODELS << [tag, uri, occurs, getter, plural]
-        end
-      end
-
-      def install_get_attribute(name, uri, required=true,
-                                type=nil, disp_name=nil,
-                                element_name=nil)
-        disp_name ||= name
-        element_name ||= name
-        writer_type, reader_type = type
-        def_corresponded_attr_writer name, writer_type, disp_name
-        def_corresponded_attr_reader name, reader_type
-        if type == :boolean and /^is/ =~ name
-          alias_method "#{$POSTMATCH}?", name
-        end
-        self::GET_ATTRIBUTES << [name, uri, required, element_name]
-        add_need_initialize_variable(disp_name)
-      end
-
-      def def_corresponded_attr_writer(name, type=nil, disp_name=nil)
-        disp_name ||= name
-        case type
-        when :integer
-          integer_writer name, disp_name
-        when :positive_integer
-          positive_integer_writer name, disp_name
-        when :boolean
-          boolean_writer name, disp_name
-        when :w3cdtf, :rfc822, :rfc2822
-          date_writer name, type, disp_name
-        when :text_type
-          text_type_writer name, disp_name
-        when :content
-          content_writer name, disp_name
-        when :yes_clean_other
-          yes_clean_other_writer name, disp_name
-        when :yes_other
-          yes_other_writer name, disp_name
-        when :csv
-          csv_writer name
-        when :csv_integer
-          csv_integer_writer name
-        else
-          attr_writer name
-        end
-      end
-
-      def def_corresponded_attr_reader(name, type=nil)
-        case type
-        when :inherit
-          inherit_convert_attr_reader name
-        when :uri
-          uri_convert_attr_reader name
-        when :yes_clean_other
-          yes_clean_other_attr_reader name
-        when :yes_other
-          yes_other_attr_reader name
-        when :csv
-          csv_attr_reader name
-        when :csv_integer
-          csv_attr_reader name, :separator => ","
-        else
-          convert_attr_reader name
-        end
-      end
-
-      def content_setup(type=nil, disp_name=nil)
-        writer_type, reader_type = type
-        def_corresponded_attr_writer :content, writer_type, disp_name
-        def_corresponded_attr_reader :content, reader_type
-        @have_content = true
-      end
-
-      def have_content?
-        @have_content
-      end
-
-      def add_have_children_element(variable_name, plural_name)
-        self::HAVE_CHILDREN_ELEMENTS << [variable_name, plural_name]
-      end
-
-      def add_to_element_method(method_name)
-        self::TO_ELEMENT_METHODS << method_name
-      end
-
-      def add_need_initialize_variable(variable_name)
-        self::NEED_INITIALIZE_VARIABLES << variable_name
-      end
-
-      def add_plural_form(singular, plural)
-        self::PLURAL_FORMS[singular] = plural
-      end
-
-      def required_prefix
-        nil
-      end
-
-      def required_uri
-        ""
-      end
-
-      def need_parent?
-        false
-      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
-    end
-
-    attr_accessor :parent, :do_validate
-
-    def initialize(do_validate=true, attrs=nil)
-      @parent = nil
-      @converter = nil
-      if attrs.nil? and (do_validate.is_a?(Hash) or do_validate.is_a?(Array))
-        do_validate, attrs = true, do_validate
-      end
-      @do_validate = do_validate
-      initialize_variables(attrs || {})
-    end
-
-    def tag_name
-      self.class.tag_name
-    end
-
-    def full_name
-      tag_name
-    end
-
-    def converter=(converter)
-      @converter = converter
-      targets = children.dup
-      self.class.have_children_elements.each do |variable_name, plural_name|
-        targets.concat(__send__(plural_name))
-      end
-      targets.each do |target|
-        target.converter = converter unless target.nil?
-      end
-    end
-
-    def convert(value)
-      if @converter
-        @converter.convert(value)
-      else
-        value
-      end
-    end
-
-    def valid?(ignore_unknown_element=true)
-      validate(ignore_unknown_element)
-      true
-    rescue RSS::Error
-      false
-    end
-
-    def validate(ignore_unknown_element=true)
-      do_validate = @do_validate
-      @do_validate = true
-      validate_attribute
-      __validate(ignore_unknown_element)
-    ensure
-      @do_validate = do_validate
-    end
-
-    def validate_for_stream(tags, ignore_unknown_element=true)
-      validate_attribute
-      __validate(ignore_unknown_element, tags, false)
-    end
-
-    def to_s(need_convert=true, indent='')
-      if self.class.have_content?
-        return "" if !empty_content? and !content_is_set?
-        rv = tag(indent) do |next_indent|
-          if empty_content?
-            ""
-          else
-            xmled_content
-          end
-        end
-      else
-        rv = tag(indent) do |next_indent|
-          self.class.to_element_methods.collect do |method_name|
-            __send__(method_name, false, next_indent)
-          end
-        end
-      end
-      rv = convert(rv) if need_convert
-      rv
-    end
-
-    def have_xml_content?
-      false
-    end
-
-    def need_base64_encode?
-      false
-    end
-
-    def set_next_element(tag_name, next_element)
-      klass = next_element.class
-      prefix = ""
-      prefix << "#{klass.required_prefix}_" if klass.required_prefix
-      key = "#{prefix}#{tag_name.gsub(/-/, '_')}"
-      if self.class.plural_forms.has_key?(key)
-        ary = __send__("#{self.class.plural_forms[key]}")
-        ary << next_element
-      else
-        __send__("#{key}=", next_element)
-      end
-    end
-
-    protected
-    def have_required_elements?
-      self.class::MODELS.all? do |tag, uri, occurs, getter|
-        if occurs.nil? or occurs == "+"
-          child = __send__(getter)
-          if child.is_a?(Array)
-            children = child
-            children.any? {|c| c.have_required_elements?}
-          else
-            !child.to_s.empty?
-          end
-        else
-          true
-        end
-      end
-    end
-
-    private
-    def initialize_variables(attrs)
-      normalized_attrs = {}
-      attrs.each do |key, value|
-        normalized_attrs[key.to_s] = value
-      end
-      self.class.need_initialize_variables.each do |variable_name|
-        value = normalized_attrs[variable_name.to_s]
-        if value
-          __send__("#{variable_name}=", value)
-        else
-          instance_variable_set("@#{variable_name}", nil)
-        end
-      end
-      initialize_have_children_elements
-      @content = normalized_attrs["content"] if self.class.have_content?
-    end
-
-    def initialize_have_children_elements
-      self.class.have_children_elements.each do |variable_name, plural_name|
-        instance_variable_set("@#{variable_name}", [])
-      end
-    end
-
-    def tag(indent, additional_attrs={}, &block)
-      next_indent = indent + INDENT
-
-      attrs = collect_attrs
-      return "" if attrs.nil?
-
-      return "" unless have_required_elements?
-
-      attrs.update(additional_attrs)
-      start_tag = make_start_tag(indent, next_indent, attrs.dup)
-
-      if block
-        content = block.call(next_indent)
-      else
-        content = []
-      end
-
-      if content.is_a?(String)
-        content = [content]
-        start_tag << ">"
-        end_tag = "</#{full_name}>"
-      else
-        content = content.reject{|x| x.empty?}
-        if content.empty?
-          return "" if attrs.empty?
-          end_tag = "/>"
-        else
-          start_tag << ">\n"
-          end_tag = "\n#{indent}</#{full_name}>"
-        end
-      end
-
-      start_tag + content.join("\n") + end_tag
-    end
-
-    def make_start_tag(indent, next_indent, attrs)
-      start_tag = ["#{indent}<#{full_name}"]
-      unless attrs.empty?
-        start_tag << attrs.collect do |key, value|
-          %Q[#{h key}="#{h value}"]
-        end.join("\n#{next_indent}")
-      end
-      start_tag.join(" ")
-    end
-
-    def collect_attrs
-      attrs = {}
-      _attrs.each do |name, required, alias_name|
-        value = __send__(alias_name || name)
-        return nil if required and value.nil?
-        next if value.nil?
-        return nil if attrs.has_key?(name)
-        attrs[name] = value
-      end
-      attrs
-    end
-
-    def tag_name_with_prefix(prefix)
-      "#{prefix}:#{tag_name}"
-    end
-
-    # For backward compatibility
-    def calc_indent
-      ''
-    end
-
-    def children
-      rv = []
-      self.class.models.each do |name, uri, occurs, getter|
-        value = __send__(getter)
-        next if value.nil?
-        value = [value] unless value.is_a?(Array)
-        value.each do |v|
-          rv << v if v.is_a?(Element)
-        end
-      end
-      rv
-    end
-
-    def _tags
-      rv = []
-      self.class.models.each do |name, uri, occurs, getter, plural|
-        value = __send__(getter)
-        next if value.nil?
-        if plural and value.is_a?(Array)
-          rv.concat([[uri, name]] * value.size)
-        else
-          rv << [uri, name]
-        end
-      end
-      rv
-    end
-
-    def _attrs
-      self.class.get_attributes.collect do |name, uri, required, element_name|
-        [element_name, required, name]
-      end
-    end
-
-    def __validate(ignore_unknown_element, 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
-      must_call_validators.each do |uri, prefix|
-        _validate(ignore_unknown_element, tags[uri], uri)
-        meth = "#{prefix}_validate"
-        if !prefix.empty? and respond_to?(meth, true)
-          __send__(meth, ignore_unknown_element, tags[uri], uri)
-        end
-      end
-    end
-
-    def validate_attribute
-      _attrs.each do |a_name, required, alias_name|
-        value = instance_variable_get("@#{alias_name || a_name}")
-        if required and value.nil?
-          raise MissingAttributeError.new(tag_name, a_name)
-        end
-        __send__("#{alias_name || a_name}=", value)
-      end
-    end
-
-    def _validate(ignore_unknown_element, tags, uri, models=self.class.models)
-      count = 1
-      do_redo = false
-      not_shift = false
-      tag = nil
-      models = models.find_all {|model| model[1] == uri}
-      element_names = models.collect {|model| model[0]}
-      if tags
-        tags_size = tags.size
-        tags = tags.sort_by {|x| element_names.index(x) || tags_size}
-      end
-
-      models.each_with_index do |model, i|
-        name, _, occurs, = model
-
-        if DEBUG
-          p "before"
-          p tags
-          p model
-        end
-
-        if not_shift
-          not_shift = false
-        elsif tags
-          tag = tags.shift
-        end
-
-        if DEBUG
-          p "mid"
-          p count
-        end
-
-        case occurs
-        when '?'
-          if count > 2
-            raise TooMuchTagError.new(name, tag_name)
-          else
-            if name == tag
-              do_redo = true
-            else
-              not_shift = true
-            end
-          end
-        when '*'
-          if name == tag
-            do_redo = true
-          else
-            not_shift = true
-          end
-        when '+'
-          if name == tag
-            do_redo = true
-          else
-            if count > 1
-              not_shift = true
-            else
-              raise MissingTagError.new(name, tag_name)
-            end
-          end
-        else
-          if name == tag
-            if models[i+1] and models[i+1][0] != name and
-                tags and tags.first == name
-              raise TooMuchTagError.new(name, tag_name)
-            end
-          else
-            raise MissingTagError.new(name, 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 !ignore_unknown_element and !tags.nil? and !tags.empty?
-        raise NotExpectedTagError.new(tags.first, uri, 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
-
-    def empty_content?
-      false
-    end
-
-    def content_is_set?
-      if have_xml_content?
-        __send__(self.class.xml_getter)
-      else
-        content
-      end
-    end
-
-    def xmled_content
-      if have_xml_content?
-        __send__(self.class.xml_getter).to_s
-      else
-        _content = content
-        _content = [_content].pack("m").delete("\n") if need_base64_encode?
-        h(_content)
-      end
-    end
-  end
-
-  module RootElementMixin
-
-    include XMLStyleSheetMixin
-
-    attr_reader :output_encoding
-    attr_reader :feed_type, :feed_subtype, :feed_version
-    attr_accessor :version, :encoding, :standalone
-    def initialize(feed_version, version=nil, encoding=nil, standalone=nil)
-      super()
-      @feed_type = nil
-      @feed_subtype = nil
-      @feed_version = feed_version
-      @version = version || '1.0'
-      @encoding = encoding
-      @standalone = standalone
-      @output_encoding = nil
-    end
-
-    def feed_info
-      [@feed_type, @feed_version, @feed_subtype]
-    end
-
-    def output_encoding=(enc)
-      @output_encoding = enc
-      self.converter = Converter.new(@output_encoding, @encoding)
-    end
-
-    def setup_maker(maker)
-      maker.version = version
-      maker.encoding = encoding
-      maker.standalone = standalone
-
-      xml_stylesheets.each do |xss|
-        xss.setup_maker(maker)
-      end
-
-      super
-    end
-
-    def to_feed(type, &block)
-      Maker.make(type) do |maker|
-        setup_maker(maker)
-        block.call(maker) if block
-      end
-    end
-
-    def to_rss(type, &block)
-      to_feed("rss#{type}", &block)
-    end
-
-    def to_atom(type, &block)
-      to_feed("atom:#{type}", &block)
-    end
-
-    def to_xml(type=nil, &block)
-      if type.nil? or same_feed_type?(type)
-        to_s
-      else
-        to_feed(type, &block).to_s
-      end
-    end
-
-    private
-    def same_feed_type?(type)
-      if /^(atom|rss)?(\d+\.\d+)?(?::(.+))?$/i =~ type
-        feed_type = ($1 || @feed_type).downcase
-        feed_version = $2 || @feed_version
-        feed_subtype = $3 || @feed_subtype
-        [feed_type, feed_version, feed_subtype] == feed_info
-      else
-        false
-      end
-    end
-
-    def tag(indent, attrs={}, &block)
-      rv = super(indent, ns_declarations.merge(attrs), &block)
-      return rv if rv.empty?
-      "#{xmldecl}#{xml_stylesheet_pi}#{rv}"
-    end
-
-    def xmldecl
-      rv = %Q[<?xml version="#{@version}"]
-      if @output_encoding or @encoding
-        rv << %Q[ encoding="#{@output_encoding or @encoding}"]
-      end
-      rv << %Q[ standalone="yes"] if @standalone
-      rv << "?>\n"
-      rv
-    end
-
-    def ns_declarations
-      decls = {}
-      self.class::NSPOOL.collect do |prefix, uri|
-        prefix = ":#{prefix}" unless prefix.empty?
-        decls["xmlns#{prefix}"] = uri
-      end
-      decls
-    end
-
-    def maker_target(target)
-      target
-    end
-  end
-end