typo 3.99.0

data/app/models/aggregations/delicious.rb

@@ -0,0 +1,57 @@
+require 'open-uri'
+require 'time'
+require 'rexml/document'
+
+class Delicious
+  include REXML
+
+  attr_accessor :url, :items, :link, :title, :days
+
+  # This object holds given information of an item
+  class DeliciousItem < Struct.new(:link, :title, :description, :description_link, :date)
+    def to_s; title end
+  end
+
+  # Pass the url to the RSS feed you would like to keep tabs on
+  # by default this will request the rss from the server right away and
+  # fill the items array
+  def initialize(url, refresh = true)
+    self.items  = []
+    self.url    = url
+    self.days   = {}
+    self.refresh if refresh
+  end
+
+  # This method lets you refresh the items in the items array
+  # useful if you keep the object cached in memory and
+  def refresh
+    open(@url) do |http|
+      parse(http.read)
+    end
+  end
+
+private
+
+  def parse(body)
+
+    xml = Document.new(body)
+
+    self.items        = []
+    self.link         = XPath.match(xml, "//channel/link/text()").first.value rescue ""
+    self.title        = XPath.match(xml, "//channel/title/text()").first.value rescue ""
+
+    XPath.each(xml, "//item/") do |elem|
+      item = DeliciousItem.new
+      item.title       = XPath.match(elem, "title/text()").first.value rescue ""
+      item.link        = XPath.match(elem, "link/text()").first.value rescue ""
+      item.description = XPath.match(elem, "description/text()").first.value rescue ""
+      item.date        = Time.mktime(*ParseDate.parsedate(XPath.match(elem, "dc:date/text()").first.value)) rescue Time.now
+
+      item.description_link = item.description
+      item.description.gsub!(/<\/?a\b.*?>/, "") # remove all <a> tags
+      items << item
+    end
+
+    self.items = items.sort_by { |item| item.date }.reverse
+  end
+end

data/app/models/aggregations/flickr.rb

@@ -0,0 +1,89 @@
+require 'open-uri'
+require 'time'
+require 'rexml/document'
+
+# Example:
+#
+# flickr = Flickr.new('http://www.flickr.com/services/feeds/photos_public.gne?id=40235412@N00&format=rss_200')
+# flickr.pics.each do |pic|
+#   puts "#{pic.title} @ #{pic.link} updated at #{pic.date}"
+# end
+#
+class FlickrAggregation
+  include REXML
+
+  def choose(num)
+    return pics unless pics.size > num
+    bag = []
+    set = pics.dup
+    num.times {|x| bag << set.delete_at(rand(set.size))}
+    bag
+  end
+
+  attr_accessor :url, :pics, :link, :title, :description
+
+  # This object holds given information of a picture
+  class Picture
+    attr_accessor :link, :title, :date, :description
+
+    def to_s
+      title
+    end
+
+    def date=(value)
+      @date = Time.parse(value)
+    end
+
+    def image
+      description.scan( /(http:\/\/(static|photos).*?\.jpg)/ ).first.first
+    end
+    def thumb
+      image.gsub( /\_m\./, '_t.' )
+    end
+    def square
+      image.gsub( /\_m\./, '_s.' )
+    end
+  end
+
+  # Pass the url to the RSS feed you would like to keep tabs on
+  # by default this will request the rss from the server right away and
+  # fill the tasks array
+  def initialize(url, refresh = true)
+    self.pics  = []
+    self.url    = url
+    self.refresh if refresh
+  end
+
+  # This method lets you refresh the tasks int the tasks array
+  # useful if you keep the object cached in memory and
+  def refresh
+    open(@url) do |http|
+      parse(http.read)
+    end
+  end
+
+private
+
+  def parse(body)
+
+    xml = Document.new(body)
+
+    self.pics        = []
+    self.link         = XPath.match(xml, "//channel/link/text()").to_s
+    self.title        = XPath.match(xml, "//channel/title/text()").to_s
+    self.description  = XPath.match(xml, "//channel/description/text()").to_s
+
+    XPath.each(xml, "//item/") do |elem|
+
+      picture = Picture.new
+      picture.title       = XPath.match(elem, "title/text()").to_s
+      picture.date        = XPath.match(elem, "pubDate/text()").to_s
+      picture.link        = XPath.match(elem, "link/text()").to_s
+      picture.description = XPath.match(elem, "description/text()").to_s
+
+      pics << picture
+    end
+  end
+end
+
+

data/app/models/aggregations/fortythree.rb

@@ -0,0 +1,62 @@
+require 'open-uri'
+require 'time'
+require 'rexml/document'
+
+# Example:
+#
+# fortythree = Fortythree.new('http://www.43things.com/rss/uber/author?username=<user>')
+# fortythree.things.each do |thing|
+#   puts "#{thing.title} @ #{thing.link} updated at #{thing.date}"
+# end
+#
+class Fortythree
+  include REXML
+
+  attr_accessor :url, :things, :link, :title, :description
+
+  # This object holds given information of a thing
+  class ThingItem < Struct.new(:link, :title, :date)
+    def to_s; title end
+    def date=(value); super(Time.parse(value)) end
+  end
+
+  # Pass the url to the RSS feed you would like to keep tabs on
+  # by default this will request the rss from the server right away and
+  # fill the tasks array  def initialize(url, refresh = true)
+  def initialize(url, refresh = true)
+    self.things  = []
+    self.url    = url
+    self.refresh if refresh
+  end
+
+  # This method lets you refresh the things into the things array
+  # useful if you keep the object cached in memory and
+  def refresh
+    open(@url) do |http|
+      parse(http.read)
+    end
+  end
+
+private
+
+  def parse(body)
+
+    xml = Document.new(body)
+
+    self.things        = []
+    self.link         = XPath.match(xml, "//channel/link/text()").to_s
+    self.title        = XPath.match(xml, "//channel/title/text()").to_s
+    self.description  = XPath.match(xml, "//channel/description/text()").to_s
+
+    XPath.each(xml, "//item/") do |elem|
+
+      thing = ThingItem.new
+      thing.title = XPath.match(elem, "title/text()").to_s
+
+      thing.date  = XPath.match(elem, "pubDate/text()").to_s
+      thing.link  = XPath.match(elem, "link/text()").to_s
+
+      things << thing
+    end
+  end
+end

data/app/models/aggregations/magnolia.rb

@@ -0,0 +1,81 @@
+require 'open-uri'
+require 'time'
+require 'rexml/document'
+
+# Example:
+#                                                                            
+# magnolia = MagnoliaAggregation.new('http://ma.gnolia.com/rss/full/people/steve.longdo/')
+# magnolia.pics.each do |pic|
+#   puts "#{pic.title} @ #{pic.link} updated at #{pic.date}"
+# end
+#
+class MagnoliaAggregation
+  include REXML
+
+  def choose(num)
+    return pics unless pics.size > num
+    bag = []
+    set = pics.dup
+    num.times {|x| bag << set.delete_at(rand(set.size))}
+    bag
+  end
+
+  attr_accessor :url, :pics, :link, :title, :description
+
+  # This object holds given information of a picture
+  class Picture
+    attr_accessor :link, :title, :date, :description, :image
+
+    def to_s
+      title
+    end
+
+    def date=(value)
+      @date = Time.parse(value)
+    end
+
+    def image
+      begin
+        CGI.unescapeHTML(description.scan( /(http:\/\/(scst.srv.girafa.com).*\")/ ).first.first).chomp('"')
+      rescue Exception => e
+        p e
+        nil
+      end
+    end
+  end
+
+  def initialize(url, refresh = true)
+    self.pics  = []
+    self.url    = url
+    self.refresh if refresh
+  end
+
+  def refresh
+    open(@url) do |http|
+      parse(http.read)
+    end
+  end
+
+private
+
+  def parse(body)
+# Not checking filesize here yet. Just looking for the not found condition...
+    xml = Document.new(body)
+
+    self.pics        = []
+    self.link         = XPath.match(xml, "//channel/link/text()").to_s
+    self.title        = XPath.match(xml, "//channel/title/text()").to_s
+    self.description  = XPath.match(xml, "//channel/description/text()").to_s
+
+     XPath.each(xml, "//item/") do |elem|
+       picture = Picture.new
+       picture.title       = XPath.match(elem, "title/text()").to_s
+       picture.date        = XPath.match(elem, "pubDate/text()").to_s
+       picture.link        = XPath.match(elem, "link/text()").to_s
+       picture.description = XPath.match(elem, "description/text()").to_s       
+       pics << picture unless picture.image.nil? || picture.image.match(/not found/)
+     end
+  end
+end
+
+

data/app/models/aggregations/tada.rb

@@ -0,0 +1,75 @@
+require 'open-uri'
+require 'time'
+require 'rexml/document'
+
+# Example:
+#
+# tada = Tada.new('http://<nick>.tadalist.com/lists/feed/<id>?token=<token>')
+# tada.tasks.each do |task|
+#   puts "#{task.title} @ #{task.link} updated at #{task.date}"
+# end
+#
+class Tada
+  include REXML
+
+  attr_accessor :url, :tasks, :link, :title, :description
+
+  # This object holds given information of a task
+  class TaskItem < Struct.new(:link, :title, :date, :status)
+    def to_s; title end
+    def date=(value); super(Time.parse(value)) end
+  end
+
+  # Pass the url to the RSS feed you would like to keep tabs on
+  # by default this will request the rss from the server right away and
+  # fill the tasks array  def initialize(url, refresh = true)
+  def initialize(url, refresh = true)
+    self.tasks  = []
+    self.url    = url
+    self.refresh if refresh
+  end
+
+  # This method lets you refresh the tasks int the tasks array
+  # useful if you keep the object cached in memory and
+  def refresh
+    open(@url) do |http|
+      parse(http.read)
+    end
+  end
+
+private
+
+  def parse(body)
+
+    xml = Document.new(body)
+
+    self.tasks        = []
+    self.link         = XPath.match(xml, "//channel/link/text()")
+    self.title        = XPath.match(xml, "//channel/title/text()")
+    self.description  = XPath.match(xml, "//channel/description/text()")
+
+    XPath.each(xml, "//item/") do |elem|
+
+      title = XPath.match(elem, "title/text()").to_s
+
+       # extract the status from the title
+       status = if title =~ /^(.+): (.+)$/
+         title = $2
+         $1.downcase.intern
+       else
+         :unknown
+       end
+
+      task = TaskItem.new
+      task.title = title
+      task.status = status
+
+      task.date  = XPath.match(elem, "pubDate/text()").to_s
+      task.link  = XPath.match(elem, "link/text()").to_s
+
+      tasks << task
+    end
+
+    self.tasks = tasks.sort_by { |task| task.status.to_s }
+  end
+end

data/app/models/aggregations/technorati.rb

@@ -0,0 +1,51 @@
+require 'open-uri'
+require 'time'
+require 'rexml/document'
+
+class Technorati
+  include REXML
+
+  def choose(num)
+    return cosmos unless cosmos.size > num
+    bag = []
+    set = cosmos.dup
+    num.times {|x| bag << set.delete_at(rand(set.size))}
+    bag
+  end
+
+  attr_accessor :url, :link, :title, :cosmos
+
+  # This object holds given information of a picture
+  class Inbound < Struct.new(:link, :title)
+    def to_s; title end
+  end
+
+  def initialize(url, refresh = true)
+    self.cosmos  = []
+    self.url    = url
+    self.refresh if refresh
+  end
+
+  # This method lets you refresh the tasks int the tasks array
+  # useful if you keep the object cached in memory and
+  def refresh
+    open(@url) do |http|
+      parse(http.read)
+    end
+  end
+
+private
+
+  def parse(body)
+    xml = Document.new(body)
+    self.cosmos        = []
+    XPath.each(xml, "//item/") do |elem|
+      inbound = Inbound.new
+      inbound.title       = XPath.match(elem, "title/text()").to_s
+      inbound.link        = XPath.match(elem, "link/text()").to_s
+      cosmos << inbound
+    end
+  end
+end
+
+

data/app/models/aggregations/upcoming.rb

@@ -0,0 +1,74 @@
+require 'open-uri'
+require 'rexml/document'
+
+# Example:
+#
+# upcoming = Upcoming.new('http://upcoming.org/syndicate/my_events/<your_user_id>')
+# upcoming.events.each do |event|
+#   puts "#{event.title} @  #{event.timespan} #{event.link} : #{event.description}"
+# end
+#
+
+class Upcoming
+  include REXML
+
+  def choose(num)
+    events.last(num)
+  end
+
+  attr_accessor :events, :link, :title, :description, :url
+
+  # This object holds given information for an Event
+  class Event < Struct.new(:link, :title, :description)
+    def to_s; title end
+
+    def timespan
+      description.split(':')[0]
+    end
+
+    def info
+        description.split(':')[1]
+    end
+  end
+
+  # Pass the url to the RSS feed you would like to keep tabs on
+  # by default this will request the rss from the server right away and
+  # fill the tasks array
+  def initialize(url, refresh = true)
+    self.events  = []
+    self.url    = url
+    self.refresh if refresh
+  end
+
+  # This method lets you refresh the tasks int the tasks array
+  # useful if you keep the object cached in memory and
+  def refresh
+    open(@url) do |http|
+      parse(http.read)
+    end
+  end
+
+private
+
+  def parse(body)
+
+    xml = Document.new(body)
+
+    self.events       = []
+    self.link         = XPath.match(xml, "//channel/link/text()").to_s
+    self.title        = XPath.match(xml, "//channel/title/text()").to_s
+    self.description  = XPath.match(xml, "//channel/description/text()").to_s
+
+    XPath.each(xml, "//item/") do |elem|
+
+      event = Event.new
+      event.title       = XPath.match(elem, "title/text()").to_s
+      event.link        = XPath.match(elem, "link/text()").to_s
+      event.description = XPath.match(elem, "description/text()").to_s
+      event.inspect
+      events << event
+    end
+  end
+end
+
+