shoesgem 0.1424.0

data/shoes/ruby/lib/rss/maker/itunes.rb

@@ -0,0 +1,242 @@
+require 'rss/itunes'
+require 'rss/maker/2.0'
+
+module RSS
+  module Maker
+    module ITunesBaseModel
+      def def_class_accessor(klass, name, type, *args)
+        name = name.gsub(/-/, "_").gsub(/^itunes_/, '')
+        full_name = "#{RSS::ITUNES_PREFIX}_#{name}"
+        case type
+        when nil
+          klass.def_other_element(full_name)
+        when :yes_other
+          def_yes_other_accessor(klass, full_name)
+        when :yes_clean_other
+          def_yes_clean_other_accessor(klass, full_name)
+        when :csv
+          def_csv_accessor(klass, full_name)
+        when :element, :attribute
+          recommended_attribute_name, = *args
+          klass_name = "ITunes#{Utils.to_class_name(name)}"
+          klass.def_classed_element(full_name, klass_name,
+                                    recommended_attribute_name)
+        when :elements
+          plural_name, recommended_attribute_name = args
+          plural_name ||= "#{name}s"
+          full_plural_name = "#{RSS::ITUNES_PREFIX}_#{plural_name}"
+          klass_name = "ITunes#{Utils.to_class_name(name)}"
+          plural_klass_name = "ITunes#{Utils.to_class_name(plural_name)}"
+          def_elements_class_accessor(klass, name, full_name, full_plural_name,
+                                      klass_name, plural_klass_name,
+                                      recommended_attribute_name)
+        end
+      end
+
+      def def_yes_other_accessor(klass, full_name)
+        klass.def_other_element(full_name)
+        klass.module_eval(<<-EOC, __FILE__, __LINE__ + 1)
+          def #{full_name}?
+            Utils::YesOther.parse(@#{full_name})
+          end
+        EOC
+      end
+
+      def def_yes_clean_other_accessor(klass, full_name)
+        klass.def_other_element(full_name)
+        klass.module_eval(<<-EOC, __FILE__, __LINE__ + 1)
+          def #{full_name}?
+            Utils::YesCleanOther.parse(#{full_name})
+          end
+        EOC
+      end
+
+      def def_csv_accessor(klass, full_name)
+        klass.def_csv_element(full_name)
+      end
+
+      def def_elements_class_accessor(klass, name, full_name, full_plural_name,
+                                      klass_name, plural_klass_name,
+                                      recommended_attribute_name=nil)
+        if recommended_attribute_name
+          klass.def_classed_elements(full_name, recommended_attribute_name,
+                                     plural_klass_name, full_plural_name)
+        else
+          klass.def_classed_element(full_plural_name, plural_klass_name)
+        end
+        klass.module_eval(<<-EOC, __FILE__, __LINE__ + 1)
+          def new_#{full_name}(text=nil)
+            #{full_name} = @#{full_plural_name}.new_#{name}
+            #{full_name}.text = text
+            if block_given?
+              yield #{full_name}
+            else
+              #{full_name}
+            end
+          end
+        EOC
+      end
+    end
+
+    module ITunesChannelModel
+      extend ITunesBaseModel
+
+      class << self
+        def append_features(klass)
+          super
+
+          ::RSS::ITunesChannelModel::ELEMENT_INFOS.each do |name, type, *args|
+            def_class_accessor(klass, name, type, *args)
+          end
+        end
+      end
+
+      class ITunesCategoriesBase < Base
+        def_array_element("category", "itunes_categories",
+                          "ITunesCategory")
+        class ITunesCategoryBase < Base
+          attr_accessor :text
+          add_need_initialize_variable("text")
+          def_array_element("category", "itunes_categories",
+                            "ITunesCategory")
+
+          def have_required_values?
+            text
+          end
+
+          alias_method :to_feed_for_categories, :to_feed
+          def to_feed(feed, current)
+            if text and current.respond_to?(:itunes_category)
+              new_item = current.class::ITunesCategory.new(text)
+              to_feed_for_categories(feed, new_item)
+              current.itunes_categories << new_item
+            end
+          end
+        end
+      end
+
+      class ITunesImageBase < Base
+        add_need_initialize_variable("href")
+        attr_accessor("href")
+
+        def to_feed(feed, current)
+          if @href and current.respond_to?(:itunes_image)
+            current.itunes_image ||= current.class::ITunesImage.new
+            current.itunes_image.href = @href
+          end
+        end
+      end
+
+      class ITunesOwnerBase < Base
+        %w(itunes_name itunes_email).each do |name|
+          add_need_initialize_variable(name)
+          attr_accessor(name)
+        end
+
+        def to_feed(feed, current)
+          if current.respond_to?(:itunes_owner=)
+            _not_set_required_variables = not_set_required_variables
+            if (required_variable_names - _not_set_required_variables).empty?
+              return
+            end
+
+            unless have_required_values?
+              raise NotSetError.new("maker.channel.itunes_owner",
+                                    _not_set_required_variables)
+            end
+            current.itunes_owner ||= current.class::ITunesOwner.new
+            current.itunes_owner.itunes_name = @itunes_name
+            current.itunes_owner.itunes_email = @itunes_email
+          end
+        end
+
+        private
+        def required_variable_names
+          %w(itunes_name itunes_email)
+        end
+      end
+    end
+
+    module ITunesItemModel
+      extend ITunesBaseModel
+
+      class << self
+        def append_features(klass)
+          super
+
+          ::RSS::ITunesItemModel::ELEMENT_INFOS.each do |name, type, *args|
+            def_class_accessor(klass, name, type, *args)
+          end
+        end
+      end
+
+      class ITunesDurationBase < Base
+        attr_reader :content
+        add_need_initialize_variable("content")
+
+        %w(hour minute second).each do |name|
+          attr_reader(name)
+          add_need_initialize_variable(name, 0)
+        end
+
+        def content=(content)
+          if content.nil?
+            @hour, @minute, @second, @content = nil
+          else
+            @hour, @minute, @second =
+              ::RSS::ITunesItemModel::ITunesDuration.parse(content)
+            @content = content
+          end
+        end
+
+        def hour=(hour)
+          @hour = Integer(hour)
+          update_content
+        end
+
+        def minute=(minute)
+          @minute = Integer(minute)
+          update_content
+        end
+
+        def second=(second)
+          @second = Integer(second)
+          update_content
+        end
+
+        def to_feed(feed, current)
+          if @content and current.respond_to?(:itunes_duration=)
+            current.itunes_duration ||= current.class::ITunesDuration.new
+            current.itunes_duration.content = @content
+          end
+        end
+
+        private
+        def update_content
+          components = [@hour, @minute, @second]
+          @content =
+            ::RSS::ITunesItemModel::ITunesDuration.construct(*components)
+        end
+      end
+    end
+
+    class ChannelBase
+      include Maker::ITunesChannelModel
+      class ITunesCategories < ITunesCategoriesBase
+        class ITunesCategory < ITunesCategoryBase
+          ITunesCategory = self
+        end
+      end
+
+      class ITunesImage < ITunesImageBase; end
+      class ITunesOwner < ITunesOwnerBase; end
+    end
+
+    class ItemsBase
+      class ItemBase
+        include Maker::ITunesItemModel
+        class ITunesDuration < ITunesDurationBase; end
+      end
+    end
+  end
+end

data/shoes/ruby/lib/rss/maker/slash.rb

@@ -0,0 +1,33 @@
+require 'rss/slash'
+require 'rss/maker/1.0'
+
+module RSS
+  module Maker
+    module SlashModel
+      def self.append_features(klass)
+        super
+
+        ::RSS::SlashModel::ELEMENT_INFOS.each do |name, type|
+          full_name = "#{RSS::SLASH_PREFIX}_#{name}"
+          case type
+          when :csv_integer
+            klass.def_csv_element(full_name, :integer)
+          else
+            klass.def_other_element(full_name)
+          end
+        end
+
+        klass.module_eval do
+          alias_method(:slash_hit_parades, :slash_hit_parade)
+          alias_method(:slash_hit_parades=, :slash_hit_parade=)
+        end
+      end
+    end
+
+    class ItemsBase
+      class ItemBase
+        include SlashModel
+      end
+    end
+  end
+end

data/shoes/ruby/lib/rss/maker/syndication.rb

@@ -0,0 +1,18 @@
+require 'rss/syndication'
+require 'rss/maker/1.0'
+
+module RSS
+  module Maker
+    module SyndicationModel
+      def self.append_features(klass)
+        super
+
+        ::RSS::SyndicationModel::ELEMENTS.each do |name|
+          klass.def_other_element(name)
+        end
+      end
+    end
+
+    class ChannelBase; include SyndicationModel; end
+  end
+end

data/shoes/ruby/lib/rss/maker/taxonomy.rb

@@ -0,0 +1,118 @@
+require 'rss/taxonomy'
+require 'rss/maker/1.0'
+require 'rss/maker/dublincore'
+
+module RSS
+  module Maker
+    module TaxonomyTopicsModel
+      def self.append_features(klass)
+        super
+
+        klass.def_classed_element("#{RSS::TAXO_PREFIX}_topics",
+                                  "TaxonomyTopics")
+      end
+
+      def self.install_taxo_topics(klass)
+        klass.module_eval(<<-EOC, __FILE__, __LINE__ + 1)
+          class TaxonomyTopics < TaxonomyTopicsBase
+            def to_feed(feed, current)
+              if current.respond_to?(:taxo_topics)
+                topics = current.class::TaxonomyTopics.new
+                bag = topics.Bag
+                @resources.each do |resource|
+                  bag.lis << RDF::Bag::Li.new(resource)
+                end
+                current.taxo_topics = topics
+              end
+            end
+          end
+EOC
+      end
+
+      class TaxonomyTopicsBase < Base
+        attr_reader :resources
+        def_array_element("resource")
+        remove_method :new_resource
+      end
+    end
+
+    module TaxonomyTopicModel
+      def self.append_features(klass)
+        super
+
+        class_name = "TaxonomyTopics"
+        klass.def_classed_elements("#{TAXO_PREFIX}_topic", "value", class_name)
+      end
+
+      def self.install_taxo_topic(klass)
+        klass.module_eval(<<-EOC, __FILE__, __LINE__ + 1)
+          class TaxonomyTopics < TaxonomyTopicsBase
+            class TaxonomyTopic < TaxonomyTopicBase
+              DublinCoreModel.install_dublin_core(self)
+              TaxonomyTopicsModel.install_taxo_topics(self)
+
+              def to_feed(feed, current)
+                if current.respond_to?(:taxo_topics)
+                  topic = current.class::TaxonomyTopic.new(value)
+                  topic.taxo_link = value
+                  taxo_topics.to_feed(feed, topic) if taxo_topics
+                  current.taxo_topics << topic
+                  setup_other_elements(feed, topic)
+                end
+              end
+            end
+          end
+EOC
+      end
+
+      class TaxonomyTopicsBase < Base
+        def_array_element("topic", nil, "TaxonomyTopic")
+        alias_method(:new_taxo_topic, :new_topic) # For backward compatibility
+
+        class TaxonomyTopicBase < Base
+          include DublinCoreModel
+          include TaxonomyTopicsModel
+          
+          attr_accessor :value
+          add_need_initialize_variable("value")
+          alias_method(:taxo_link, :value)
+          alias_method(:taxo_link=, :value=)
+          
+          def have_required_values?
+            @value
+          end
+        end
+      end
+    end
+
+    class RSSBase
+      include TaxonomyTopicModel
+    end
+    
+    class ChannelBase
+      include TaxonomyTopicsModel
+    end
+    
+    class ItemsBase
+      class ItemBase
+        include TaxonomyTopicsModel
+      end
+    end
+
+    makers.each do |maker|
+      maker.module_eval(<<-EOC, __FILE__, __LINE__ + 1)
+        TaxonomyTopicModel.install_taxo_topic(self)
+
+        class Channel
+          TaxonomyTopicsModel.install_taxo_topics(self)
+        end
+
+        class Items
+          class Item
+            TaxonomyTopicsModel.install_taxo_topics(self)
+          end
+        end
+      EOC
+    end
+  end
+end

data/shoes/ruby/lib/rss/maker/trackback.rb

@@ -0,0 +1,61 @@
+require 'rss/trackback'
+require 'rss/maker/1.0'
+require 'rss/maker/2.0'
+
+module RSS
+  module Maker
+    module TrackBackModel
+      def self.append_features(klass)
+        super
+
+        klass.def_other_element("#{RSS::TRACKBACK_PREFIX}_ping")
+        klass.def_classed_elements("#{RSS::TRACKBACK_PREFIX}_about", "value",
+                                   "TrackBackAbouts")
+      end
+
+      class TrackBackAboutsBase < Base
+        def_array_element("about", nil, "TrackBackAbout")
+
+        class TrackBackAboutBase < Base
+          attr_accessor :value
+          add_need_initialize_variable("value")
+          
+          alias_method(:resource, :value)
+          alias_method(:resource=, :value=)
+          alias_method(:content, :value)
+          alias_method(:content=, :value=)
+
+          def have_required_values?
+            @value
+          end
+
+          def to_feed(feed, current)
+            if current.respond_to?(:trackback_abouts) and have_required_values?
+              about = current.class::TrackBackAbout.new
+              setup_values(about)
+              setup_other_elements(about)
+              current.trackback_abouts << about
+            end
+          end
+        end
+      end
+    end
+
+    class ItemsBase
+      class ItemBase; include TrackBackModel; end
+    end
+
+    makers.each do |maker|
+      maker.module_eval(<<-EOC, __FILE__, __LINE__ + 1)
+        class Items
+          class Item
+            class TrackBackAbouts < TrackBackAboutsBase
+              class TrackBackAbout < TrackBackAboutBase
+              end
+            end
+          end
+        end
+      EOC
+    end
+  end
+end

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

@@ -0,0 +1,44 @@
+require "rss/rss"
+
+module RSS
+  module Maker
+    MAKERS = {}
+
+    class << self
+      def make(version, &block)
+        m = maker(version)
+        raise UnsupportedMakerVersionError.new(version) if m.nil?
+        m[:maker].make(m[:version], &block)
+      end
+
+      def maker(version)
+        MAKERS[version]
+      end
+
+      def add_maker(version, normalized_version, maker)
+        MAKERS[version] = {:maker => maker, :version => normalized_version}
+      end
+
+      def versions
+        MAKERS.keys.uniq.sort
+      end
+
+      def makers
+        MAKERS.values.collect {|info| info[:maker]}.uniq
+      end
+    end
+  end
+end
+
+require "rss/maker/1.0"
+require "rss/maker/2.0"
+require "rss/maker/feed"
+require "rss/maker/entry"
+require "rss/maker/content"
+require "rss/maker/dublincore"
+require "rss/maker/slash"
+require "rss/maker/syndication"
+require "rss/maker/taxonomy"
+require "rss/maker/trackback"
+require "rss/maker/image"
+require "rss/maker/itunes"