shoesgem 0.1424.0

data/shoes/ruby/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/shoes/ruby/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/shoes/ruby/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/shoes/ruby/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

data/shoes/ruby/lib/rss/utils.rb

@@ -0,0 +1,111 @@
+module RSS
+  module Utils
+    module_function
+
+    # Convert a name_with_underscores to CamelCase.
+    def to_class_name(name)
+      name.split(/[_\-]/).collect do |part|
+        "#{part[0, 1].upcase}#{part[1..-1]}"
+      end.join("")
+    end
+    
+    def get_file_and_line_from_caller(i=0)
+      file, line, = caller[i].split(':')
+      line = line.to_i
+      line += 1 if i.zero?
+      [file, line]
+    end
+
+    # escape '&', '"', '<' and '>' for use in HTML.
+    def html_escape(s)
+      s.to_s.gsub(/&/, "&amp;").gsub(/\"/, "&quot;").gsub(/>/, "&gt;").gsub(/</, "&lt;")
+    end
+    alias h html_escape
+    
+    # If +value+ is an instance of class +klass+, return it, else
+    # create a new instance of +klass+ with value +value+.
+    def new_with_value_if_need(klass, value)
+      if value.is_a?(klass)
+        value
+      else
+        klass.new(value)
+      end
+    end
+
+    def element_initialize_arguments?(args)
+      [true, false].include?(args[0]) and args[1].is_a?(Hash)
+    end
+
+    module YesCleanOther
+      module_function
+      def parse(value)
+        if [true, false, nil].include?(value)
+          value
+        else
+          case value.to_s
+          when /\Ayes\z/i
+            true
+          when /\Aclean\z/i
+            false
+          else
+            nil
+          end
+        end
+      end
+    end
+
+    module YesOther
+      module_function
+      def parse(value)
+        if [true, false].include?(value)
+          value
+        else
+          /\Ayes\z/i.match(value.to_s) ? true : false
+        end
+      end
+    end
+
+    module CSV
+      module_function
+      def parse(value, &block)
+        if value.is_a?(String)
+          value = value.strip.split(/\s*,\s*/)
+          value = value.collect(&block) if block_given?
+          value
+        else
+          value
+        end
+      end
+    end
+
+    module InheritedReader
+      def inherited_reader(constant_name)
+        base_class = inherited_base
+        result = base_class.const_get(constant_name)
+        found_base_class = false
+        ancestors.reverse_each do |klass|
+          if found_base_class
+            if klass.const_defined?(constant_name)
+              result = yield(result, klass.const_get(constant_name))
+            end
+          else
+            found_base_class = klass == base_class
+          end
+        end
+        result
+      end
+
+      def inherited_array_reader(constant_name)
+        inherited_reader(constant_name) do |result, current|
+          current + result
+        end
+      end
+
+      def inherited_hash_reader(constant_name)
+        inherited_reader(constant_name) do |result, current|
+          result.merge(current)
+        end
+      end
+    end
+  end
+end