nitro 0.29.0 → 0.30.0

data/lib/nitro/helper/feed.rb

@@ -0,0 +1,432 @@
+require 'rss/maker'
+require 'glue/markup'
+require 'rexml/document'
+require 'time'
+require 'uri'
+
+require 'facet/string/first_char'
+
+module Nitro
+  
+  # A helper that provides Feed related methods.
+  #
+  # To include this helper into your controller, 
+  # add the following at the beginning of your controller:
+  #
+  #  helper :feed
+  #
+  # Then define actions that set an appropriate content_type and use build_(rss|atom|opml)
+  # to generate your desired feed. See below for details.
+  #
+  # == RSS 0.91, 1.0 and 2.0
+  #
+  #  response.content_type = "application/rss+xml"
+  #  build_rss(og_objects, 
+  #    :version => "0.9", 
+  #    :base => context.host_url, # + object.to_href results in an item-link
+  #    :link => context.host_url+"/feed", # link to this feed
+  #    :title => "Feed Title", 
+  #    :description => "What this feed is about", 
+  #    :search_title => "Search Form Here",
+  #    :search_description => "Search description",
+  #    :search_input_name => "search_field",
+  #    :search_form_action => "http://url/to/search_action"
+  #  )
+  #
+  # For RSS 1.0 or RSS 2.0 just change :version (defaults to '0.91'), 
+  # possible :version options are "0.9", "0.91", "1.0" and "2.0"
+  #
+  # * for RSS 0.9 :language is required (or defaults to 'en')
+  # * for all RSS versions :title, :link and/or :base, :description are required
+  #
+  # <b>individual objects have to respond to at least:</b>
+  # 
+  # * 1.0/0.9/2.0 require @title
+  # * 1.0/0.9 require @to_href
+  # * 2.0 requires @body
+  #
+  # if it doesn't, no item is created
+  #
+  # * @update_time, @create_time or @date is used for item.date
+  # * so if Og's "is Timestamped" is being used, it'll be @update_time
+  # * @author[:name] can optionally be used for item.author
+  #
+  # == Atom 1.0
+  #
+  #   response.content_type = "application/atom+xml"
+  #   build_atom(og_objects,
+  #     :title => "Feed Title",
+  #     :base => context.host_url, # + object.to_href results in an item-link
+  #     :link => context.host_url+"/atomfeed",
+  #     :id => "your_unique_id",  # :base is being used unless :id specified (:base is recommended)
+  #     :author_name => "Takeo",
+  #     :author_email => "email@example.com",
+  #     :author_link => "http://uri.to/authors/home",
+  #   )
+  #
+  # <b>individual objects have to respond to at least:</b>
+  # 
+  # * @title
+  # * @to_href
+  # * @update_time/@create_time/@date (at least one of them)
+  #
+  # if it doesn't, no entry is created
+  #
+  # optional:
+  #
+  # * @body (taken as summary (256 chars))
+  # * @full_content
+  # * use Og's "is Timestamped", so both @update_time and @create_time can be used
+  # * @author[:name]
+  # * @author[:link]
+  # * @author[:email]   # be careful, you don't want to publish your users email address to spammers
+  # 
+  #
+  # == OPML 1.0 feed lists
+  #
+  # Fabian: Eew, who invented OPML? Who needs it? Implementing it in a very rough way anyway though.
+  # takes a Hash of Feeds and optional options
+  #
+  #   response.content_type = "application/opml+xml"
+  #   build_opml(
+  #     {
+  #     "http://oxyliquit.de/feed" => "rss",
+  #     "http://oxyliquit.de/feed/questions" => "rss",
+  #     "http://oxyliquit.de/feed/tips" => "rss",
+  #     "http://oxyliquit.de/feed/tutorials" => "rss"
+  #     },
+  #     :title => "My feeds"
+  #   )
+ 
+  module FeedHelper
+    include Glue::Markup
+    
+    # RSS 0.91, 1.0, 2.0 feeds.
+ 
+    def build_rss(objects, options = {})
+
+      # default options
+      options = {
+        :title => 'Syndication',
+        :description => 'Syndication',
+        :version => '0.9',
+        :language => 'en',  # required by 0.9
+      }.update(options)
+
+      raise "Option ':version' contains a wrong version!" unless %w(0.9 0.91 1.0 2.0).include?(options[:version])
+
+      options[:base] ||= options[:link]
+      raise "Option ':base' cannot be omitted!" unless options[:base]
+      
+      # build rss
+      rss = RSS::Maker.make(options[:version]) do |maker|
+        maker.channel.title = options[:title]
+        maker.channel.description = options[:description]
+        if options[:link]
+          maker.channel.link = options[:link]
+        else
+          maker.channel.link = options[:base] #FIXME: not sure
+        end 
+        case options[:version]
+          when '0.9', '0.91'
+            maker.channel.language = options[:language]
+          when '1.0'
+            if options[:link]
+              maker.channel.about = options[:link]
+            else
+              raise "Option ':link' is required for RSS 1.0"
+            end
+        end
+        maker.channel.generator = "Nitro " + Nitro::Version.to_s
+
+        maker.items.do_sort = true
+
+        # items for each object
+        # * 1.0/0.9/2.0 require @title
+        # * 1.0/0.9 require @link
+        # * 2.0 requires @description
+        objects.each do |o|
+          
+          # new Item
+          item = maker.items.new_item
+          
+          # Link
+          item.link = "#{options[:base]}/#{o.to_href}" if o.respond_to?(:to_href)
+          item.guid.content = "#{options[:base]}/#{o.to_href}" if options[:version] == '2.0' && o.respond_to?(:to_href)
+          
+          # Title
+          item.title = o.title if o.respond_to?(:title)
+          
+          # Description
+          if o.respond_to? :body and body = o.body
+            #TODO: think about whether markup should always be done 
+            # and whether 256 chars should be a fixed limit
+            #item.description = markup(body.first_char(256)) 
+            # markup disabled, feedvalidator.org says "description should not contain HTML"
+            # so removing everything that looks like a tag
+            item.description = body.first_char(256).gsub!(/<[^>]+>/, ' ')
+          end
+          
+          # Date  (item.date asks for a Time object, so don't .to_s !)
+          if o.respond_to?(:update_time)
+            item.date = o.update_time
+          elsif o.respond_to?(:create_time)
+            item.date = o.create_time
+          elsif o.respond_to?(:date)
+            item.date = o.date
+          end
+          
+          # Author
+          if o.respond_to?(:author)
+            if o.author[:name]
+              item.author = o.author[:name]
+            end
+          end
+          
+        end if objects.size > 0 # objects/items
+
+        # search form
+        maker.textinput.title = options[:search_title] if options[:search_title]
+        maker.textinput.description = options[:search_description] if options[:search_description]
+        maker.textinput.name = options[:search_input_name] if options[:search_input_name]
+        maker.textinput.link = options[:search_form_action] if options[:search_form_action]
+      end
+      
+      return rss.to_s
+    end # rss
+    alias_method :rss, :build_rss
+    
+    
+    # Atom 1.0 feeds.
+    
+    def build_atom(objects, options = {})
+      
+      # default options
+      options = {
+        :title => 'Syndication',
+      }.update(options)
+      
+      raise "first param must be a collection of objects!" unless objects.respond_to?(:to_ary)
+      raise "your object(s) have to respond to :update_time, :create_time or :date" unless objects[0].respond_to?(:update_time) or objects[0].respond_to?(:create_time) or objects[0].respond_to?(:date)
+      raise "Option ':base' cannot be omitted!" unless options[:base]
+      
+      # new XML Document for Atom
+      atom = REXML::Document.new
+      atom << REXML::XMLDecl.new("1.0", "utf-8")
+      
+        # Root element <feed />
+        feed = REXML::Element.new("feed").add_namespace("http://www.w3.org/2005/Atom")
+        
+          # Required feed elements
+          
+          # id: Identifies the feed using a universally unique and permanent URI.
+          iduri = URI.parse(options[:id] || options[:base]).normalize.to_s
+          id = REXML::Element.new("id").add_text(iduri)
+          feed << id
+          
+          # title: Contains a human readable title for the feed.
+          title = REXML::Element.new("title").add_text(options[:title])
+          feed << title
+          
+          # updated: Indicates the last time the feed was modified in a significant way. 
+          latest = Time.at(0) # a while back
+          objects.each do |o|
+            if o.respond_to?(:update_time)
+              latest = o.update_time if o.update_time > latest
+            elsif o.respond_to?(:create_time)
+              latest = o.create_time if o.create_time > latest
+            elsif o.respond_to?(:date)
+              latest = o.date if o.date > latest
+            end
+          end
+          updated = REXML::Element.new("updated").add_text(latest.iso8601)
+          feed << updated
+          
+          # Recommended feed elements
+          
+          # link: A feed should contain a link back to the feed itself.
+          if options[:link]
+            link = REXML::Element.new("link")
+            link.add_attributes({ "rel" => "self", "href" => options[:link] })
+            feed << link
+          end
+          
+          # author: Names one author of the feed.
+          if options[:author_name]  # name is required for author
+            author = REXML::Element.new("author")
+            author_name = REXML::Element.new("name").add_text(options[:author_name])
+            author << author_name
+            if options[:author_email]
+              author_email = REXML::Element.new("email").add_text(options[:author_email])
+              author << author_email
+            end
+            if options[:author_link]
+              author_link = REXML::Element.new("uri").add_text(options[:author_link])
+              author << author_link
+            end
+            feed << author
+          end
+          
+          # Optional feed elements
+          
+          # category:
+          # contributor:
+          # generator: Identifies the software used to generate the feed.
+          generator = REXML::Element.new("generator")
+          generator.add_attributes({ "uri" => "http://www.nitroproject.org", "version" => Nitro::Version })
+          generator.add_text("Nitro")
+          feed << generator
+          # icon
+          # logo
+          # rights
+          # subtitle
+                    
+          # Entries
+          objects.each do |o|
+            
+            # new Entry (called "item" in RSS)
+            unless o.respond_to?(:to_href) and o.respond_to?(:title) 
+              next
+            end
+            entry = REXML::Element.new("entry")
+          
+            # Required entry elements
+            
+              # id
+              if o.respond_to?(:to_href)
+                id = REXML::Element.new("id").add_text("#{options[:base]}/#{o.to_href}")
+                entry << id
+              end
+              
+              # title
+              if o.respond_to?(:title)
+                title = REXML::Element.new("title").add_text(o.title)
+                entry << title
+              end
+              
+              # updated
+              updated = Time.at(0) # a while back
+              if o.respond_to?(:update_time)
+                updated = o.update_time
+              elsif o.respond_to?(:create_time)
+                updated = o.create_time
+              elsif o.respond_to?(:date)
+                updated = o.date
+              end
+              entry << REXML::Element.new("updated").add_text(updated.iso8601)
+              
+            # Recommended entry elements
+            
+              # author
+              if o.respond_to?(:author)
+                if o.author[:name]  # name is required for author
+                  author = REXML::Element.new("author")
+                  author_name = REXML::Element.new("name").add_text(o.author[:name])
+                  author << author_name
+                  if o.author[:email]
+                    author_email = REXML::Element.new("email").add_text(o.author[:email])
+                    author << author_email
+                  end
+                  if o.author[:link]
+                    author_link = REXML::Element.new("uri").add_text(o.author[:link])
+                    author << author_link
+                  end
+                  entry << author
+                end
+              end
+              
+              # summary
+              if o.respond_to?(:body)
+                summary = REXML::Element.new("summary")
+                #TODO: think about whether 256 chars should be a fixed limit
+                summary.add_text(o.body.first_char(256).gsub(/<[^>]+>/, ' '))
+                entry << summary
+              end
+              
+              # content
+              # may have the type text, html or xhtml
+              if o.respond_to?(:full_content)
+                content = REXML::Element.new("content")
+                #TODO: think about whether markup should always be done
+                content.add_text(markup(o.full_content))
+                entry << content
+              end
+              
+              # link: An entry must contain an alternate link if there is no content element.
+              if o.respond_to?(:to_href)
+                link = REXML::Element.new("link")
+                link.add_attributes({ "rel" => "alternate", "href" => "#{options[:base]}/#{o.to_href}" })
+                entry << link
+              end
+              
+            # Optional entry elements
+            
+              # category
+                # could be used for Tags maybe?
+              # contributor
+              # published
+              if o.respond_to?(:create_time)
+                published = REXML::Element.new("published")
+                published.add_text(o.create_time.iso8601)
+                entry << published
+              end
+              # source
+              # rights
+            
+            # don't forget to add the entry to the feed
+            feed << entry
+            
+          end if objects.size > 0 # objects/entries
+          
+      atom << feed
+      
+      return atom.to_s
+    end # atom
+    alias_method :atom, :build_atom
+    
+    # OPML 1.0 feed lists
+    # Fabian: eww, who invented OPML? Who needs it? Implementing 
+    # it in a very rough way anyway though. Takes a Hash of 
+    # Feeds and optional options.
+    
+    def build_opml(feedhash, options = {})
+      
+      # new XML Document for OPML
+      opml = REXML::Document.new
+      opml << REXML::XMLDecl.new("1.0", "utf-8")
+      
+      # Root element <opml />
+      opml = REXML::Element.new("opml")
+      opml.add_attribute("version", "1.0")
+
+      # head
+      head = REXML::Element.new("head")
+        # title
+        if options[:title]
+          title = REXML::Element.new("title").add_text(options[:title])
+          head << title
+        end
+        # dateCreated
+        # dateModified
+        # ownerName
+        # ownerEmail 
+      opml << head
+      
+      # body
+      body = REXML::Element.new("body")
+        feedhash.each do |url, type|
+          outline = REXML::Element.new("outline")
+          outline.add_attributes({ "type" => type, "xmlUrl" => url })
+          body << outline
+        end
+      opml << body
+      
+      return opml.to_s
+    end # opml
+    alias_method :opml, :build_opml
+    
+  end
+end
+
+# * Fabian Buch <fabian@fabian-buch.de>
+# * George Moschovitis <gm@navel.gr>

data/lib/nitro/helper/form.rb

@@ -1,6 +1,7 @@
 require 'facet/inflect'
 
 require 'nitro/helper/form/controls'
+require 'nitro/helper/form/builder'
 
 module Nitro
 
@@ -86,9 +87,13 @@ module FormHelper
       end
     end
     
-    action = "#{@base}/#{action}" unless action =~ /\//
+    if action == :self
+      str << %{<form method="post"#{enctype_attribute}>}    
+    else
+      action = "#{@base}/#{action}" unless action =~ /\//
+      str << %{<form action="#{action}" method="post"#{enctype_attribute}>}    
+    end
     
-    str << %{<form action="#{action}" method="post"#{enctype_attribute}>}    
     str << %{<input type="hidden" name="oid" value="#{obj.oid}" />} if obj.oid
     str << controls_for(obj, options)
     str << %{<input type="submit" value="#{submit}" />}
@@ -104,7 +109,10 @@ module FormHelper
     str = FormBuilder.prologue
         
     controls_for_properties(str, obj, options)
-    controls_for_relations(str, obj, options)
+    
+    unless options[:no_relations]
+     controls_for_relations(str, obj, options)
+    end
     
     str << FormBuilder.epilogue