rubysl-rss 1.0.0

data/lib/rss/content.rb

@@ -0,0 +1,31 @@
+require "rss/rss"
+
+module RSS
+  CONTENT_PREFIX = 'content'
+  CONTENT_URI = "http://purl.org/rss/1.0/modules/content/"
+
+  module ContentModel
+    extend BaseModel
+
+    ELEMENTS = ["#{CONTENT_PREFIX}_encoded"]
+
+    def self.append_features(klass)
+      super
+
+      klass.install_must_call_validator(CONTENT_PREFIX, CONTENT_URI)
+      ELEMENTS.each do |full_name|
+        name = full_name[(CONTENT_PREFIX.size + 1)..-1]
+        klass.install_text_element(name, CONTENT_URI, "?", full_name)
+      end
+    end
+  end
+
+  prefix_size = CONTENT_PREFIX.size + 1
+  ContentModel::ELEMENTS.each do |full_name|
+    name = full_name[prefix_size..-1]
+    BaseListener.install_get_text_element(CONTENT_URI, name, full_name)
+  end
+end
+
+require 'rss/content/1.0'
+require 'rss/content/2.0'

data/lib/rss/content/1.0.rb

@@ -0,0 +1,10 @@
+require 'rss/1.0'
+require 'rss/content'
+
+module RSS
+  RDF.install_ns(CONTENT_PREFIX, CONTENT_URI)
+
+  class RDF
+    class Item; include ContentModel; end
+  end
+end

data/lib/rss/content/2.0.rb

@@ -0,0 +1,12 @@
+require "rss/2.0"
+require "rss/content"
+
+module RSS
+  Rss.install_ns(CONTENT_PREFIX, CONTENT_URI)
+
+  class Rss
+    class Channel
+      class Item; include ContentModel; end
+    end
+  end
+end

data/lib/rss/converter.rb

@@ -0,0 +1,162 @@
+require "rss/utils"
+
+module RSS
+
+  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 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_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, nkf_arg)
+      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
+        require 'nkf'
+        if NKF.const_defined?(:UTF8)
+          def_convert(1) do |value|
+            "NKF.nkf(#{nkf_arg.dump}, #{value})"
+          end
+        else
+          def_iconv_convert(to_enc, from_enc, 1)
+        end
+      end
+    end
+
+    def def_to_euc_jp_from_utf_8
+      def_uconv_convert_if_can('u8toeuc', 'EUC-JP', 'UTF-8', '-We')
+    end
+    
+    def def_to_utf_8_from_euc_jp
+      def_uconv_convert_if_can('euctou8', 'UTF-8', 'EUC-JP', '-Ew')
+    end
+    
+    def def_to_shift_jis_from_utf_8
+      def_uconv_convert_if_can('u8tosjis', 'Shift_JIS', 'UTF-8', '-Ws')
+    end
+    
+    def def_to_utf_8_from_shift_jis
+      def_uconv_convert_if_can('sjistou8', 'UTF-8', 'Shift_JIS', '-Sw')
+    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
+  
+end

data/lib/rss/dublincore.rb

@@ -0,0 +1,161 @@
+require "rss/rss"
+
+module RSS
+  DC_PREFIX = 'dc'
+  DC_URI = "http://purl.org/dc/elements/1.1/"
+
+  module BaseDublinCoreModel
+    def append_features(klass)
+      super
+
+      return if klass.instance_of?(Module)
+      DublinCoreModel::ELEMENT_NAME_INFOS.each do |name, plural_name|
+        plural = plural_name || "#{name}s"
+        full_name = "#{DC_PREFIX}_#{name}"
+        full_plural_name = "#{DC_PREFIX}_#{plural}"
+        klass_name = "DublinCore#{Utils.to_class_name(name)}"
+        klass.install_must_call_validator(DC_PREFIX, DC_URI)
+        klass.install_have_children_element(name, DC_URI, "*",
+                                            full_name, full_plural_name)
+        klass.module_eval(<<-EOC, *get_file_and_line_from_caller(0))
+          remove_method :#{full_name}
+          remove_method :#{full_name}=
+          remove_method :set_#{full_name}
+
+          def #{full_name}
+            @#{full_name}.first and @#{full_name}.first.value
+          end
+          
+          def #{full_name}=(new_value)
+            @#{full_name}[0] = Utils.new_with_value_if_need(#{klass_name}, new_value)
+          end
+          alias set_#{full_name} #{full_name}=
+        EOC
+      end
+      klass.module_eval(<<-EOC, *get_file_and_line_from_caller(0))
+        if method_defined?(:date)
+          alias date_without_#{DC_PREFIX}_date= date=
+
+          def date=(value)
+            self.date_without_#{DC_PREFIX}_date = value
+            self.#{DC_PREFIX}_date = value
+          end
+        else
+          alias date #{DC_PREFIX}_date
+          alias date= #{DC_PREFIX}_date=
+        end
+
+        # For backward compatibility
+        alias #{DC_PREFIX}_rightses #{DC_PREFIX}_rights_list
+      EOC
+    end
+  end
+  
+  module DublinCoreModel
+
+    extend BaseModel
+    extend BaseDublinCoreModel
+
+    TEXT_ELEMENTS = {
+      "title" => nil,
+      "description" => nil,
+      "creator" => nil,
+      "subject" => nil,
+      "publisher" => nil,
+      "contributor" => nil,
+      "type" => nil,
+      "format" => nil,
+      "identifier" => nil,
+      "source" => nil,
+      "language" => nil,
+      "relation" => nil,
+      "coverage" => nil,
+      "rights" => "rights_list"
+    }
+
+    DATE_ELEMENTS = {
+      "date" => "w3cdtf",
+    }
+    
+    ELEMENT_NAME_INFOS = DublinCoreModel::TEXT_ELEMENTS.to_a
+    DublinCoreModel::DATE_ELEMENTS.each do |name, |
+      ELEMENT_NAME_INFOS << [name, nil]
+    end
+    
+    ELEMENTS = TEXT_ELEMENTS.keys + DATE_ELEMENTS.keys
+
+    ELEMENTS.each do |name, plural_name|
+      module_eval(<<-EOC, *get_file_and_line_from_caller(0))
+        class DublinCore#{Utils.to_class_name(name)} < Element
+          include RSS10
+          
+          content_setup
+
+          class << self
+            def required_prefix
+              DC_PREFIX
+            end
+        
+            def required_uri
+              DC_URI
+            end
+          end
+
+          @tag_name = #{name.dump}
+
+          alias_method(:value, :content)
+          alias_method(:value=, :content=)
+          
+          def initialize(*args)
+            if Utils.element_initialize_arguments?(args)
+              super
+            else
+              super()
+              self.content = args[0]
+            end
+          end
+      
+          def full_name
+            tag_name_with_prefix(DC_PREFIX)
+          end
+
+          def maker_target(target)
+            target.new_#{name}
+          end
+
+          def setup_maker_attributes(#{name})
+            #{name}.content = content
+          end
+        end
+      EOC
+    end
+
+    DATE_ELEMENTS.each do |name, type|
+      tag_name = "#{DC_PREFIX}:#{name}"
+      module_eval(<<-EOC, *get_file_and_line_from_caller(0))
+        class DublinCore#{Utils.to_class_name(name)} < Element
+          remove_method(:content=)
+          remove_method(:value=)
+
+          date_writer("content", #{type.dump}, #{tag_name.dump})
+
+          alias_method(:value=, :content=)
+        end
+      EOC
+    end
+  end
+
+  # For backward compatibility
+  DublincoreModel = DublinCoreModel
+
+  DublinCoreModel::ELEMENTS.each do |name|
+    class_name = Utils.to_class_name(name)
+    BaseListener.install_class_name(DC_URI, name, "DublinCore#{class_name}")
+  end
+
+  DublinCoreModel::ELEMENTS.collect! {|name| "#{DC_PREFIX}_#{name}"}
+end
+
+require 'rss/dublincore/1.0'
+require 'rss/dublincore/2.0'
+require 'rss/dublincore/atom'

data/lib/rss/dublincore/1.0.rb

@@ -0,0 +1,13 @@
+require "rss/1.0"
+require "rss/dublincore"
+
+module RSS
+  RDF.install_ns(DC_PREFIX, DC_URI)
+
+  class RDF
+    class Channel; include DublinCoreModel; end
+    class Image; include DublinCoreModel; end
+    class Item; include DublinCoreModel; end
+    class Textinput; include DublinCoreModel; end
+  end
+end

data/lib/rss/dublincore/2.0.rb

@@ -0,0 +1,13 @@
+require "rss/2.0"
+require "rss/dublincore"
+
+module RSS
+  Rss.install_ns(DC_PREFIX, DC_URI)
+
+  class Rss
+    class Channel
+      include DublinCoreModel
+      class Item; include DublinCoreModel; end
+    end
+  end
+end

data/lib/rss/dublincore/atom.rb

@@ -0,0 +1,17 @@
+require "rss/atom"
+require "rss/dublincore"
+
+module RSS
+  module Atom
+    Feed.install_ns(DC_PREFIX, DC_URI)
+
+    class Feed
+      include DublinCoreModel
+      class Entry; include DublinCoreModel; end
+    end
+
+    class Entry
+      include DublinCoreModel
+    end
+  end
+end

data/lib/rss/image.rb

@@ -0,0 +1,193 @@
+require 'rss/1.0'
+require 'rss/dublincore'
+
+module RSS
+
+  IMAGE_PREFIX = 'image'
+  IMAGE_URI = 'http://purl.org/rss/1.0/modules/image/'
+
+  RDF.install_ns(IMAGE_PREFIX, IMAGE_URI)
+
+  IMAGE_ELEMENTS = []
+
+  %w(item favicon).each do |name|
+    class_name = Utils.to_class_name(name)
+    BaseListener.install_class_name(IMAGE_URI, name, "Image#{class_name}")
+    IMAGE_ELEMENTS << "#{IMAGE_PREFIX}_#{name}"
+  end
+  
+  module ImageModelUtils
+    def validate_one_tag_name(ignore_unknown_element, name, tags)
+      if !ignore_unknown_element
+        invalid = tags.find {|tag| tag != name}
+        raise UnknownTagError.new(invalid, IMAGE_URI) if invalid
+      end
+      raise TooMuchTagError.new(name, tag_name) if tags.size > 1
+    end
+  end
+  
+  module ImageItemModel
+    include ImageModelUtils
+    extend BaseModel
+
+    def self.append_features(klass)
+      super
+
+      klass.install_have_child_element("item", IMAGE_URI, "?",
+                                       "#{IMAGE_PREFIX}_item")
+      klass.install_must_call_validator(IMAGE_PREFIX, IMAGE_URI)
+    end
+
+    class ImageItem < Element
+      include RSS10
+      include DublinCoreModel
+
+      @tag_name = "item"
+      
+      class << self
+        def required_prefix
+          IMAGE_PREFIX
+        end
+        
+        def required_uri
+          IMAGE_URI
+        end
+      end
+
+      install_must_call_validator(IMAGE_PREFIX, IMAGE_URI)
+
+      [
+        ["about", ::RSS::RDF::URI, true],
+        ["resource", ::RSS::RDF::URI, false],
+      ].each do |name, uri, required|
+        install_get_attribute(name, uri, required, nil, nil,
+                              "#{::RSS::RDF::PREFIX}:#{name}")
+      end
+
+      %w(width height).each do |tag|
+        full_name = "#{IMAGE_PREFIX}_#{tag}"
+        disp_name = "#{IMAGE_PREFIX}:#{tag}"
+        install_text_element(tag, IMAGE_URI, "?",
+                             full_name, :integer, disp_name)
+        BaseListener.install_get_text_element(IMAGE_URI, tag, full_name)
+      end
+
+      alias width= image_width=
+      alias width image_width
+      alias height= image_height=
+      alias height image_height
+
+      def initialize(*args)
+        if Utils.element_initialize_arguments?(args)
+          super
+        else
+          super()
+          self.about = args[0]
+          self.resource = args[1]
+        end
+      end
+
+      def full_name
+        tag_name_with_prefix(IMAGE_PREFIX)
+      end
+
+      private
+      def maker_target(target)
+        target.image_item
+      end
+
+      def setup_maker_attributes(item)
+        item.about = self.about
+        item.resource = self.resource
+      end
+    end
+  end
+  
+  module ImageFaviconModel
+    include ImageModelUtils
+    extend BaseModel
+    
+    def self.append_features(klass)
+      super
+
+      unless klass.class == Module
+        klass.install_have_child_element("favicon", IMAGE_URI, "?",
+                                         "#{IMAGE_PREFIX}_favicon")
+        klass.install_must_call_validator(IMAGE_PREFIX, IMAGE_URI)
+      end
+    end
+
+    class ImageFavicon < Element
+      include RSS10
+      include DublinCoreModel
+
+      @tag_name = "favicon"
+      
+      class << self
+        def required_prefix
+          IMAGE_PREFIX
+        end
+        
+        def required_uri
+          IMAGE_URI
+        end
+      end
+
+      [
+        ["about", ::RSS::RDF::URI, true, ::RSS::RDF::PREFIX],
+        ["size", IMAGE_URI, true, IMAGE_PREFIX],
+      ].each do |name, uri, required, prefix|
+        install_get_attribute(name, uri, required, nil, nil,
+                              "#{prefix}:#{name}")
+      end
+
+      AVAILABLE_SIZES = %w(small medium large)
+      alias_method :set_size, :size=
+      private :set_size
+      def size=(new_value)
+        if @do_validate and !new_value.nil?
+          new_value = new_value.strip
+          unless AVAILABLE_SIZES.include?(new_value)
+            attr_name = "#{IMAGE_PREFIX}:size"
+            raise NotAvailableValueError.new(full_name, new_value, attr_name)
+          end
+        end
+        set_size(new_value)
+      end
+      
+      alias image_size= size=
+      alias image_size size
+
+      def initialize(*args)
+        if Utils.element_initialize_arguments?(args)
+          super
+        else
+          super()
+          self.about = args[0]
+          self.size = args[1]
+        end
+      end
+
+      def full_name
+        tag_name_with_prefix(IMAGE_PREFIX)
+      end
+
+      private
+      def maker_target(target)
+        target.image_favicon
+      end
+
+      def setup_maker_attributes(favicon)
+        favicon.about = self.about
+        favicon.size = self.size
+      end
+    end
+
+  end
+
+  class RDF
+    class Channel; include ImageFaviconModel; end
+    class Item; include ImageItemModel; end
+  end
+
+end