rubysl-rss 1.0.0

data/lib/rss/slash.rb

@@ -0,0 +1,49 @@
+require 'rss/1.0'
+
+module RSS
+  SLASH_PREFIX = 'slash'
+  SLASH_URI = "http://purl.org/rss/1.0/modules/slash/"
+
+  RDF.install_ns(SLASH_PREFIX, SLASH_URI)
+
+  module SlashModel
+    extend BaseModel
+
+    ELEMENT_INFOS = \
+    [
+     ["section"],
+     ["department"],
+     ["comments", :positive_integer],
+     ["hit_parade", :csv_integer],
+    ]
+
+    class << self
+      def append_features(klass)
+        super
+
+        return if klass.instance_of?(Module)
+        klass.install_must_call_validator(SLASH_PREFIX, SLASH_URI)
+        ELEMENT_INFOS.each do |name, type, *additional_infos|
+          full_name = "#{SLASH_PREFIX}_#{name}"
+          klass.install_text_element(full_name, SLASH_URI, "?",
+                                     full_name, type, name)
+        end
+
+        klass.module_eval do
+          alias_method(:slash_hit_parades, :slash_hit_parade)
+          undef_method(:slash_hit_parade)
+          alias_method(:slash_hit_parade, :slash_hit_parade_content)
+        end
+      end
+    end
+  end
+
+  class RDF
+    class Item; include SlashModel; end
+  end
+
+  SlashModel::ELEMENT_INFOS.each do |name, type|
+    accessor_base = "#{SLASH_PREFIX}_#{name}"
+    BaseListener.install_get_text_element(SLASH_URI, name, accessor_base)
+  end
+end

data/lib/rss/syndication.rb

@@ -0,0 +1,67 @@
+require "rss/1.0"
+
+module RSS
+
+  SY_PREFIX = 'sy'
+  SY_URI = "http://purl.org/rss/1.0/modules/syndication/"
+
+  RDF.install_ns(SY_PREFIX, SY_URI)
+
+  module SyndicationModel
+    
+    extend BaseModel
+    
+    ELEMENTS = []
+    
+    def self.append_features(klass)
+      super
+
+      klass.install_must_call_validator(SY_PREFIX, SY_URI)
+      klass.module_eval do
+        [
+          ["updatePeriod"],
+          ["updateFrequency", :positive_integer]
+        ].each do |name, type|
+          install_text_element(name, SY_URI, "?",
+                               "#{SY_PREFIX}_#{name}", type,
+                               "#{SY_PREFIX}:#{name}")
+        end
+
+        %w(updateBase).each do |name|
+          install_date_element(name, SY_URI, "?",
+                               "#{SY_PREFIX}_#{name}", 'w3cdtf',
+                               "#{SY_PREFIX}:#{name}")
+        end
+      end
+
+      klass.module_eval(<<-EOC, __FILE__, __LINE__ + 1)
+        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
+      EOC
+    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
+  end
+
+  class RDF
+    class Channel; include SyndicationModel; end
+  end
+
+  prefix_size = SY_PREFIX.size + 1
+  SyndicationModel::ELEMENTS.uniq!
+  SyndicationModel::ELEMENTS.each do |full_name|
+    name = full_name[prefix_size..-1]
+    BaseListener.install_get_text_element(SY_URI, name, full_name)
+  end
+
+end

data/lib/rss/taxonomy.rb

@@ -0,0 +1,145 @@
+require "rss/1.0"
+require "rss/dublincore"
+
+module RSS
+
+  TAXO_PREFIX = "taxo"
+  TAXO_URI = "http://purl.org/rss/1.0/modules/taxonomy/"
+
+  RDF.install_ns(TAXO_PREFIX, TAXO_URI)
+
+  TAXO_ELEMENTS = []
+
+  %w(link).each do |name|
+    full_name = "#{TAXO_PREFIX}_#{name}"
+    BaseListener.install_get_text_element(TAXO_URI, name, full_name)
+    TAXO_ELEMENTS << "#{TAXO_PREFIX}_#{name}"
+  end
+
+  %w(topic topics).each do |name|
+    class_name = Utils.to_class_name(name)
+    BaseListener.install_class_name(TAXO_URI, name, "Taxonomy#{class_name}")
+    TAXO_ELEMENTS << "#{TAXO_PREFIX}_#{name}"
+  end
+
+  module TaxonomyTopicsModel
+    extend BaseModel
+    
+    def self.append_features(klass)
+      super
+
+      klass.install_must_call_validator(TAXO_PREFIX, TAXO_URI)
+      %w(topics).each do |name|
+        klass.install_have_child_element(name, TAXO_URI, "?",
+                                         "#{TAXO_PREFIX}_#{name}")
+      end
+    end
+
+    class TaxonomyTopics < Element
+      include RSS10
+      
+      Bag = ::RSS::RDF::Bag
+
+      class << self
+        def required_prefix
+          TAXO_PREFIX
+        end
+        
+        def required_uri
+          TAXO_URI
+        end
+      end
+
+      @tag_name = "topics"
+      
+      install_have_child_element("Bag", RDF::URI, nil)
+      install_must_call_validator('rdf', RDF::URI)
+
+      def initialize(*args)
+        if Utils.element_initialize_arguments?(args)
+          super
+        else
+          super()
+          self.Bag = args[0]
+        end
+        self.Bag ||= Bag.new
+      end
+
+      def full_name
+        tag_name_with_prefix(TAXO_PREFIX)
+      end
+
+      def maker_target(target)
+        target.taxo_topics
+      end
+
+      def resources
+        if @Bag
+          @Bag.lis.collect do |li|
+            li.resource
+          end
+        else
+          []
+        end
+      end
+    end
+  end
+  
+  module TaxonomyTopicModel
+    extend BaseModel
+    
+    def self.append_features(klass)
+      super
+      var_name = "#{TAXO_PREFIX}_topic"
+      klass.install_have_children_element("topic", TAXO_URI, "*", var_name)
+    end
+
+    class TaxonomyTopic < Element
+      include RSS10
+
+      include DublinCoreModel
+      include TaxonomyTopicsModel
+      
+      class << self
+        def required_prefix
+          TAXO_PREFIX
+        end
+        
+        def required_uri
+          TAXO_URI
+        end
+      end
+
+      @tag_name = "topic"
+
+      install_get_attribute("about", ::RSS::RDF::URI, true, nil, nil,
+                            "#{RDF::PREFIX}:about")
+      install_text_element("link", TAXO_URI, "?", "#{TAXO_PREFIX}_link")
+        
+      def initialize(*args)
+        if Utils.element_initialize_arguments?(args)
+          super
+        else
+          super()
+          self.about = args[0]
+        end
+      end
+
+      def full_name
+        tag_name_with_prefix(TAXO_PREFIX)
+      end
+
+      def maker_target(target)
+        target.new_taxo_topic
+      end
+    end
+  end
+
+  class RDF
+    include TaxonomyTopicModel
+    class Channel
+      include TaxonomyTopicsModel
+    end
+    class Item; include TaxonomyTopicsModel; end
+  end
+end

data/lib/rss/trackback.rb

@@ -0,0 +1,288 @@
+require 'rss/1.0'
+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 TrackBackUtils
+    private
+    def trackback_validate(ignore_unknown_element, tags, uri)
+      return if tags.nil?
+      if tags.find {|tag| tag == "about"} and
+          !tags.find {|tag| tag == "ping"}
+        raise MissingTagError.new("#{TRACKBACK_PREFIX}:ping", tag_name)
+      end
+    end
+  end
+
+  module BaseTrackBackModel
+
+    ELEMENTS = %w(ping about)
+    
+    def append_features(klass)
+      super
+
+      unless klass.class == Module
+        klass.module_eval {include TrackBackUtils}
+
+        klass.install_must_call_validator(TRACKBACK_PREFIX, TRACKBACK_URI)
+        %w(ping).each do |name|
+          var_name = "#{TRACKBACK_PREFIX}_#{name}"
+          klass_name = "TrackBack#{Utils.to_class_name(name)}"
+          klass.install_have_child_element(name, TRACKBACK_URI, "?", var_name)
+          klass.module_eval(<<-EOC, __FILE__, __LINE__)
+            remove_method :#{var_name}
+            def #{var_name}
+              @#{var_name} and @#{var_name}.value
+            end
+
+            remove_method :#{var_name}=
+            def #{var_name}=(value)
+              @#{var_name} = Utils.new_with_value_if_need(#{klass_name}, value)
+            end
+          EOC
+        end
+        
+        [%w(about s)].each do |name, postfix|
+          var_name = "#{TRACKBACK_PREFIX}_#{name}"
+          klass_name = "TrackBack#{Utils.to_class_name(name)}"
+          klass.install_have_children_element(name, TRACKBACK_URI, "*",
+                                              var_name)
+          klass.module_eval(<<-EOC, __FILE__, __LINE__)
+            remove_method :#{var_name}
+            def #{var_name}(*args)
+              if args.empty?
+                @#{var_name}.first and @#{var_name}.first.value
+              else
+                ret = @#{var_name}.__send__("[]", *args)
+                if ret.is_a?(Array)
+                  ret.collect {|x| x.value}
+                else
+                  ret.value
+                end
+              end
+            end
+
+            remove_method :#{var_name}=
+            remove_method :set_#{var_name}
+            def #{var_name}=(*args)
+              if args.size == 1
+                item = Utils.new_with_value_if_need(#{klass_name}, args[0])
+                @#{var_name}.push(item)
+              else
+                new_val = args.last
+                if new_val.is_a?(Array)
+                  new_val = new_value.collect do |val|
+                    Utils.new_with_value_if_need(#{klass_name}, val)
+                  end
+                else
+                  new_val = Utils.new_with_value_if_need(#{klass_name}, new_val)
+                end
+                @#{var_name}.__send__("[]=", *(args[0..-2] + [new_val]))
+              end
+            end
+            alias set_#{var_name} #{var_name}=
+          EOC
+        end
+      end
+    end
+  end
+
+  module TrackBackModel10
+    extend BaseModel
+    extend BaseTrackBackModel
+
+    class TrackBackPing < Element
+      include RSS10
+
+      class << self
+
+        def required_prefix
+          TRACKBACK_PREFIX
+        end
+        
+        def required_uri
+          TRACKBACK_URI
+        end
+
+      end
+
+      @tag_name = "ping"
+
+      [
+        ["resource", ::RSS::RDF::URI, true]
+      ].each do |name, uri, required|
+        install_get_attribute(name, uri, required, nil, nil,
+                              "#{::RSS::RDF::PREFIX}:#{name}")
+      end
+
+      alias_method(:value, :resource)
+      alias_method(:value=, :resource=)
+      def initialize(*args)
+        if Utils.element_initialize_arguments?(args)
+          super
+        else
+          super()
+          self.resource = args[0]
+        end
+      end
+
+      def full_name
+        tag_name_with_prefix(TRACKBACK_PREFIX)
+      end
+    end
+
+    class TrackBackAbout < Element
+      include RSS10
+
+      class << self
+        
+        def required_prefix
+          TRACKBACK_PREFIX
+        end
+        
+        def required_uri
+          TRACKBACK_URI
+        end
+
+      end
+      
+      @tag_name = "about"
+
+      [
+        ["resource", ::RSS::RDF::URI, true]
+      ].each do |name, uri, required|
+        install_get_attribute(name, uri, required, nil, nil,
+                              "#{::RSS::RDF::PREFIX}:#{name}")
+      end
+
+      alias_method(:value, :resource)
+      alias_method(:value=, :resource=)
+      
+      def initialize(*args)
+        if Utils.element_initialize_arguments?(args)
+          super
+        else
+          super()
+          self.resource = args[0]
+        end
+      end
+
+      def full_name
+        tag_name_with_prefix(TRACKBACK_PREFIX)
+      end
+
+      private
+      def maker_target(abouts)
+        abouts.new_about
+      end
+
+      def setup_maker_attributes(about)
+        about.resource = self.resource
+      end
+      
+    end
+  end
+
+  module TrackBackModel20
+    extend BaseModel
+    extend BaseTrackBackModel
+
+    class TrackBackPing < Element
+      include RSS09
+
+      @tag_name = "ping"
+      
+      content_setup
+
+      class << self
+
+        def required_prefix
+          TRACKBACK_PREFIX
+        end
+        
+        def required_uri
+          TRACKBACK_URI
+        end
+
+      end
+      
+      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(TRACKBACK_PREFIX)
+      end
+      
+    end
+
+    class TrackBackAbout < Element
+      include RSS09
+
+      @tag_name = "about"
+      
+      content_setup
+
+      class << self
+        
+        def required_prefix
+          TRACKBACK_PREFIX
+        end
+        
+        def required_uri
+          TRACKBACK_URI
+        end
+
+      end
+
+      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(TRACKBACK_PREFIX)
+      end
+      
+    end
+  end
+
+  class RDF
+    class Item; include TrackBackModel10; end
+  end
+
+  class Rss
+    class Channel
+      class Item; include TrackBackModel20; end
+    end
+  end
+
+  BaseTrackBackModel::ELEMENTS.each do |name|
+    class_name = Utils.to_class_name(name)
+    BaseListener.install_class_name(TRACKBACK_URI, name,
+                                    "TrackBack#{class_name}")
+  end
+
+  BaseTrackBackModel::ELEMENTS.collect! {|name| "#{TRACKBACK_PREFIX}_#{name}"}
+end