r43 0.2.0

data/lib/city.rb

@@ -0,0 +1,52 @@
+# copyright 2005 Pat Eyler, Sean Carley, & Edward Cho
+# distributed under the same terms as Ruby
+
+
+#
+# Implements a city object from 43 things.  Currently only meant
+# to be contructed by an R43::Request object.
+#
+
+
+
+class City
+  attr_accessor :city_id, :name, :region, :country, :num_people,
+                :link, :goals   
+
+  def initialize()
+    # just to initialize the object, we'll always feed the attributes
+    # in some other way
+  end
+
+  def initialize_copy(city)
+    @goals= city.goals.collect{|goal| goal.clone}
+    self
+  end
+
+  def to_i()
+    @city_id
+  end
+
+  #
+  # Builds a City object from 43 things.  Currently only meant to 
+  # constructed by an R43::Request object.
+  #
+  def City.from_xml(xml)
+    city = City.new()
+    city.name= xml.elements["name"].text
+    city.region= xml.elements["region"].text
+    city.country= xml.elements["country"].text
+    city.num_people= xml.elements["num_people"].text.to_i
+    city.link=  xml.elements["link"].attributes["href"]
+    city.city_id= xml.attributes["city_id"].to_i
+    
+    city.goals = Array.new
+    xml.elements.each("goal") do |goal_element|
+      goal = Goal.from_xml(goal_element)
+      city.goals.push(goal)
+    end
+
+    city
+  end
+end
+

data/lib/entry.rb

@@ -0,0 +1,63 @@
+# copyright 2005 Pat Eyler, Sean Carley, & Edward Cho
+# distributed under the same terms as Ruby
+
+#
+# Implements an entry object from 43 things.  Currently only meant
+# to be constructed by an R43::Request object.
+#
+#
+
+class Entry
+  attr_accessor :title, :author, :dc_subject, :goal, :content,
+               :num_comments, :issued, :link, :id, :entry_id
+
+  def initialize()
+    # just to initialize the object, we'll always feed the attributes
+    # in some other way
+  end
+
+  def initialize_copy(entry)
+    @author = entry.author.clone if entry.author
+    @goal = entry.goal.clone if entry.goal
+    @id = entry.id.clone if entry.id
+    self
+  end
+
+  def to_i()
+    @entry_id
+  end
+
+  #
+  # Builds an Entry object from an xml object.  Normally, this is
+  # called by the get_entry method of an R43::Request object.
+  #
+  def Entry.from_xml(xml)
+    entry = Entry.new
+
+    if xml.elements["title"] then
+      entry.title= xml.elements["title"].text
+    end
+    entry.dc_subject= xml.elements["dc:subject"].text
+    entry.content= xml.elements["content"].text
+    entry.num_comments= 
+      xml.elements["num_comments"].text.to_i
+    entry.issued= xml.elements["issued"].text
+    entry.link= xml.elements["link"].attributes["href"]
+
+    entry.id= Id.from_xml(xml.elements["id"])
+    entry.entry_id = entry.id.to_i
+
+    xml.elements.each("author") do |entry_element|
+      entry.author= Person.from_xml(entry_element)
+    end
+
+    goal = Goal.new
+    xml.elements.each("goal") do |goal_entry|
+      goal = Goal.from_xml(goal_entry)
+    end
+    entry.goal= goal
+
+    entry
+  end
+
+end

data/lib/goal.rb

@@ -0,0 +1,73 @@
+# copyright 2005 Pat Eyler, Sean Carley, & Edward Cho
+# distributed under the same terms as Ruby
+
+#
+# Implements a goal object from 43 things.  Currently only meant to be
+# constructed by an R43::Request object
+#
+#  require 'r43'
+#  connect = R43::Request.new(<api_key>)
+#  goal = get_goal_by_id(<goal_id>)
+#
+class Goal
+  attr_accessor :goal_id, :name, :link, :num_registered_people, 
+  :num_unregistered_people, :num_say_worth_it,
+  :num_say_not_worth_it, :percentage_worth_it,
+  :tags, :id, :progress_link, :team_link
+
+  def initialize()
+    # just to initialize the object, we'll always feed the attributes in
+    # some other way
+  end
+
+  def initialize_copy(goal)
+    @tags= goal.tags.collect{|tag| tag.clone}
+    @id = goal.id.clone if goal.id
+    self
+  end
+
+  def to_i()
+    @goal_id
+  end
+
+  #
+  # Builds a Goal object from an xml object.  Normally, this is
+  # called by the get_goal_by_id or get_goal_by_name methods of 
+  # an R43::Request object.
+  #
+  def Goal.from_xml(xml)
+    goal = Goal.new()
+
+    goal.goal_id= xml.attributes["goal_id"].to_i
+    goal.name=  xml.elements["name"].text
+    goal.link= xml.elements["link"].attributes["href"]
+
+    if xml.elements["num_registered_people"] then
+      goal.num_registered_people= 
+        xml.elements["num_registered_people"].text.to_i
+    end
+
+    if xml.elements["num_unregistered_people"] then
+      goal.num_unregistered_people= 
+        xml.elements["num_unregistered_people"].text.to_i
+    end
+
+    if xml.elements["worth_it_data"] then
+      goal.num_say_worth_it= 
+        xml.elements["worth_it_data"].elements["num_say_worth_it"].text.to_i
+      goal.num_say_not_worth_it= 
+        xml.elements["worth_it_data"].elements["num_say_not_worth_it"].text.to_i
+      goal.percentage_worth_it= 
+        xml.elements["worth_it_data"].elements["percentage_worth_it"].text.to_i
+    end
+    goal.id= Id.from_xml(xml.elements["id"])
+
+    tags = []
+    xml.elements.each("tags/tag") do |tag_element| 
+      tags.push(Tag.from_xml(tag_element))
+    end
+    goal.tags= tags
+
+    goal
+  end
+end

data/lib/id.rb

@@ -0,0 +1,39 @@
+# copyright 2005 Pat Eyler, Sean Carley, & Edward Cho
+# distributed under the same terms as Ruby
+
+
+#
+# Implements an id object.  This object encapsulates the 43 Things
+# id string format of "tag:43things.com:joshp:entry:33".  Currently,
+# intended to be constructed only by other domain objects.
+#
+class Id
+  attr_accessor :string_value, :int_value   
+
+  def initialize()
+    # just to initialize the object, we'll always feed the attributes
+    # in some other way
+  end
+
+  def to_i()
+    @int_value
+  end
+
+  def to_s()
+    @string_value
+  end
+
+  #
+  # Builds an Id object from the format 
+  # "<id>tag:43things.com:joshp:entry:33</id>"
+  #
+  def Id.from_xml(xml)
+    id = Id.new()
+    xml.text =~ /^(.*:(\d+))$/
+    id.string_value= $1
+    id.int_value= $2
+
+    id
+  end
+end
+

data/lib/person.rb

@@ -0,0 +1,74 @@
+# copyright 2005 Pat Eyler, Sean Carley, & Edward Cho
+# distributed under the same terms as Ruby
+
+
+#
+# Implements a person object from 43 things.  Currently only meant to
+# be constructed by a R43::Request object:
+# 
+#   require 'r43'
+#   connect = R43::Request.new(<api_key>)
+#   person = connect.get_person('<username>')
+#
+class Person
+  attr_accessor :username, :name, :url, :profile_image_url, 
+              :num_open_goals, :link, :city, :goals,
+              :completed_goals, :flickr_username
+
+  def initialize()
+    # just to create the object, we'll always feed the attributes in
+    # some other way
+  end
+
+  def initialize_copy(person)
+    @city = person.city.clone if person.city
+    @goals = person.goals.collect{|goal| goal.clone}
+    @completed_goals = person.completed_goals.collect{|goal| goal.clone}
+    self
+  end
+
+  #
+  # Builds a Person object from an xml object.  Normally, this is
+  # called by the get_person method of an R43::Request object.
+  #
+  def Person.from_xml(xml)
+    person = Person.new
+
+    person.username= xml.elements["username"].text
+    person.name= xml.elements["name"].text
+    person.url= xml.elements["url"].text
+    person.num_open_goals= 
+      xml.elements["num_open_goals"].text.to_i
+    person.link= xml.elements["link"].attributes["href"]
+
+    person.flickr_username=xml.elements["flickr_username"].text if xml.elements["flickr_username"]
+    
+    if xml.elements["profile_image_url"] then 
+      person.profile_image_url= 
+        xml.elements["profile_image_url"].text
+    else
+      person.profile_image_url= "none"
+    end
+
+    if xml.elements["city"] then
+      xml.elements.each("city") do |element|
+        person.city = City.from_xml(element)
+      end
+    end
+
+    person.goals = Array.new
+    xml.elements.each("open_goals/goal") do |goal_element| 
+      goal = Goal.from_xml(goal_element)
+      person.goals.push(goal)
+    end   
+    
+    person.completed_goals = Array.new
+    xml.elements.each("completed_goals/goal") do |goal_element|
+      goal = Goal.from_xml(goal_element)
+      person.completed_goals.push(goal)
+    end
+
+    person
+  end
+
+end

data/lib/r43.rb

@@ -0,0 +1,637 @@
+# copyright 2005 Pat Eyler, Sean Carley, & Edward Cho
+# distributed under the same terms as Ruby
+
+
+require 'net/http'
+require 'rexml/document'
+require 'city'
+require 'entry'
+require 'goal'
+require 'id'
+require 'person'
+require 'tag'
+
+module R43
+
+
+  private
+
+  class R43::Service
+    attr_reader :key, :proxy_addr
+    
+    def initialize(key, proxy_addr, proxy_port, proxy_user, proxy_pass)
+      @key = key.to_s
+      @proxy_addr = proxy_addr
+      @proxy_port = proxy_port
+      @proxy_user = proxy_user
+      @proxy_pass = proxy_pass
+    end
+
+    protected
+
+    #
+    # a private method to add the api_key to the url
+    #
+    def _inject_key(url)
+      key_str = "api_key=#{@key}"
+      if url =~ /\?$/
+        url + key_str
+      elsif url =~ /\?/
+        url.sub /\?/, "?#{key_str}&"
+      else
+        url + "?" + key_str
+      end
+    end
+
+    def _get_http()
+      if @proxy_addr
+        Net::HTTP::Proxy(@proxy_addr, @proxy_port, @proxy_user, @proxy_pass)
+      else
+        Net::HTTP
+      end
+    end
+
+    #
+    # a private method for getting responses from 43 things.
+    #
+    def _get_response(url)
+      _get_http.start('www.43things.com')  do |http|
+        response = _build_response(http, url)
+      end
+    end
+    
+    def _build_response(http, url)
+      full_url = _inject_key url
+      response = http.get("/service/#{url}")
+      if response.code == "200"
+        xml = REXML::Document.new(response.body)
+        return xml 
+      else
+        return response.code
+      end
+    end
+
+
+
+    public
+    
+    def get_response(url)
+      _get_response(_inject_key(url))
+    end
+    
+  end
+
+  public
+  
+  #
+  # Implements the 43 Things API.  This is where you actually
+  # instantiate objects.
+  #
+  #   require 'r43'
+  #   connection = R43::Connection.new(<api_key>) 
+  #
+  class R43::Connection
+    attr_reader :service, :response
+
+    def initialize(key, proxy_addr=nil, proxy_port=nil, 
+                   proxy_user=nil, proxy_pass=nil)
+      @service = R43::Service.new(key, proxy_addr, proxy_port,
+                                  proxy_user, proxy_pass)
+    end
+
+
+    protected
+    attr_reader :return_reference
+
+    #
+    # a private method for getting responses from 43 things.
+    #
+    def _get_response(url)
+      @response = Response.new(@service, url)
+    end
+
+    def return_by_value(object)
+      if object.kind_of? Enumerable then
+        object.collect{|element| element.clone}
+      else
+        return object.clone
+      end
+    end
+
+    def store_and_return(object)
+      @return_reference = object
+      return_by_value(object)
+    end
+
+    public
+
+    #
+    # Exposes paging from the last connection.
+    #
+    def more()
+      @response.more()
+      return_by_value(@return_reference)
+    end
+
+    #
+    # Implements the echo method from the General API.  Returns a hash
+    # with the keys; <em>api_key</em>, <em>action</em>,
+    # <em>controller</em> 
+    #
+    #   require 'r43'
+    #   connection = R43::Connection.new(<api_key>)
+    #   response = connection.echo
+    #
+    def echo()
+      xml = _get_response("echo").xml
+      response = {
+        "api_key" =>  
+          xml.elements["parameters"].elements["api_key"].text,
+        "action" =>
+          xml.elements["parameters"].elements["action"].text,
+        "controller" =>
+          xml.elements["parameters"].elements["controller"].text
+      }
+    end
+
+
+    #
+    # Implements the authentication_test method from the General API.
+    # returns "true" if the connection works.  Only uses the cleartext
+    # username and password at this point
+    #
+    #  require 'r43'
+    #  connection = R43::Connection.new(<api_key>)
+    #  response = connection.authentication_test(<username>,<password>)
+    #--
+    # This really needs ATOM style authentication to work properly
+    #++
+    #
+    def authentication_test(username, password)
+      xml = _get_response("authentication_test?username=#{username}&password=#{password}").xml
+      xml.elements["authentication_test"].text
+    end
+
+    #
+    # Implements the get_goal_by_id method from the Goals API.  Returns a
+    # Goal object.
+    #
+    #   require 'r43'
+    #   connection = R43::Connection.new(<api_key>)
+    #   goal = connection.get_goal_by_id(255)
+    #
+    def get_goal_by_id(id)
+      store_and_return(_get_response("get_goal_by_id?id=#{id}").goal)
+    end
+
+
+    #
+    # Implements the get_goal_by_name method from the Goals API.  Returns
+    # a Goal object
+    #
+    #  require 'r43'
+    #  connection = R43::Connection.new(<api_key>)
+    #  goal = connection.get_goal_by_name(<name>)
+    #
+    def get_goal_by_name(name)
+      name = name.gsub!(/\s/, '+')
+      store_and_return(_get_response("get_goal_by_name?name=#{name}").goal)
+    end
+
+
+    #
+    # Implements the get_goals_similarities method from the Goals API and
+    # returns an array of Goal objects
+    #
+    #
+    #  require 'r43'
+    #  connection = R43::Connection.new(<api_key>)
+    #  goals = connection.get_goals_similarities(<id>)
+    #
+    def get_goals_similarities(id)
+      store_and_return(_get_response("get_goals_similarities?id=#{id}").goals)
+    end
+
+    #
+    # Implements the search_goals method from the Goals API and
+    # returns an array of Goal objects
+    #
+    #
+    #  require 'r43'
+    #  connection = R43::Connection.new(<api_key>)
+    #  goals = connection.search_goals(<query string>[,
+    #                               {["offset" => <offset>], 
+    #                                ["max" => <max>]}])
+    #
+    def search_goals(string, optional={})
+      string.gsub!(/\s/, "+") 
+      if optional["offset"] then
+        string += "&offset=#{optional["offset"]}"
+      end
+      if optional["max"] then
+        string += "&max=#{optional["max"]}"
+      end
+  
+      store_and_return(_get_response("search_goals?q=#{string}").goals)
+    end
+
+    #
+    # Implements the get_goals_people method from the Goals API and
+    # returns an array of Person objects
+    #
+    #  require 'r43'
+    #  connection = R43::Connection.new(<api_key>)
+    #  people = connection.get_goals_people(<id>[,
+    #                                    {["offset" => <offset>], 
+    #                                     ["max" => <max>]}])
+    #
+    def get_goals_people(id, optional={})
+      string = "id=#{id}"
+      if optional["offset"] then
+        string += "&offset=#{optional["offset"]}"
+      end
+      if optional["max"] then
+        string += "&max=#{optional["max"]}"
+      end
+  
+      store_and_return(_get_response("get_goals_people?#{string}").people)
+    end
+
+    #
+    # Implements the get_goals_entries method from the Goals API and
+    # returns an array of Entry objects
+    #
+    #  require 'r43'
+    #  connection = R43::Connection.new(<api_key>)
+    #  entries = connection.get_goals_entries(<id>,[{["offset" => <offset>], 
+    #                                             ["max" => <max>], 
+    #                                             ["view" => <view>]}])
+    #
+    def get_goals_entries(id, optional={})
+      string = "id=#{id}"
+      if optional["offset"] then
+        string += "&offset=#{optional["offset"]}"
+      end
+      if optional["max"] then
+        string += "&max=#{optional["max"]}"
+      end
+      if optional["view"] then
+        string += "&view=#{optional["view"]}"
+      end
+      
+      store_and_return(_get_response("get_goals_entries?#{string}").entries)
+    end
+
+
+    #
+    # Implements the search_people method from the People API and returns
+    # an array of Person objects.  Response will be set on Connection and
+    # this is a paged collection.
+    #
+    #  require 'r43'
+    #  connection = R43::Connection.new(<api_key>)
+    #  people = connection.search_people(<query>)
+    #  people += connection.more
+    #
+    def search_people(query, options={})
+      # TODO: add paging options
+      store_and_return(_get_response("search_people?q=#{query}").people)
+    end
+     
+    #
+    # Implements the search_people_by_email method from the People API
+    # and returns an array of Person objects.  Response will be set on
+    # Connection and this is a paged collection.
+    #
+    #  require 'r43'
+    #  connection = R43::Connection.new(<api_key>)
+    #  people = connection.search_people_by_email(<query>)
+    #  people += connection.more
+    #
+    def search_people_by_email(query, options={})
+      # TODO: add paging options
+      store_and_return(_get_response("search_people_by_email?q=#{query}").people)
+    end
+     
+    #
+    # Implements the get_person method from the People API and returns a
+    # Person object.  If the optional true or false value is set to true,
+    # the username is treated as a flickr username instead of a 43 Things
+    # username.  If the value is false or not set, the username is treated 
+    # as a 43 Things username.
+    #
+    #  require 'r43'
+    #  connection = R43::Connection.new(<api_key>)
+    #  person = connection.get_person(<username>[, <true|false>])
+    #
+    def get_person(id,use_flickr=false)
+      if (use_flickr)
+        id_cmd = "flickr_username"
+      else
+        id_cmd = "id"
+      end
+      store_and_return(_get_response("get_person?#{id_cmd}=#{id}").person)
+    end
+
+    #
+    # Implements get_persons_completed_things from the People API and
+    # returns a Person object with completed_goals populated.
+    # 
+    #  require 'r43'
+    #  connection = R43::Connection.new(<api_key>)
+    #  person = connection.get_persons_completed_things("erik")
+    #  completed_goals = person.completed_goals
+    #
+    def get_persons_completed_things(username, options={})
+      # TODO: add flickr_username handling
+      store_and_return(_get_response("get_persons_completed_things?id=#{username}").person)
+    end
+
+    #
+    # Implements get_persons_entries from the People API and
+    # returns an array of the person's entries.  This method
+    # sets connection.response and configures paging via connection.
+    # 
+    # Currently broken.  The web service never returns entries.
+    #
+    #  require 'r43'
+    #  connection = R43::Connection.new(<api_key>)
+    #  entries = connection.get_persons_completed_things(<username>)
+    #  entries += connection.more
+    #
+    def get_persons_entries(username, options={})
+      # TODO: add flickr_username handling
+      store_and_return(_get_response("get_persons_entries?id=#{username}").entries)
+    end
+
+    #
+    # Implements get_persons_progress_on_goal from the People
+    # API and returns an array of entries for the goal.  The
+    # entries may be paginated.
+    # 
+    #  require 'r43'
+    #  connection = R43::Connection.new(<api_key>)
+    #  entries = connection.get_persons_progress_on_goal(<username>, goal_id
+    #                                                 [, options])
+    #  entries += connection.more
+    #
+    def get_persons_progress_on_goal(username, goal_id, options={})
+      # TODO: add flickr_username handling
+      store_and_return(_get_response("get_persons_progress_on_goal?id=#{username}&goal_id=#{goal_id}").entries)
+    end
+
+
+    #
+    # Implements get_persons_teammates from the People
+    # API and returns an array of people.  The people
+    # may be paginated.
+    # 
+    #  require 'r43'
+    #  connection = R43::Connection.new(<api_key>)
+    #  people = connection.get_persons_teammates(<username>
+    #                                         [, options])
+    #  people += connection.more
+    #
+    def get_persons_teammates(username, options={})
+      # TODO: add flickr_username handling
+      # TODO: add paging options
+      store_and_return(_get_response("get_persons_teammates?id=#{username}").people)
+    end
+
+
+    #
+    # Implements get_persons_neighbors from the People
+    # API and returns an array of people.  The array
+    # may be paginated.
+    # 
+    #  require 'r43'
+    #  connection = R43::Connection.new(<api_key>)
+    #  people = connection.get_persons_neighborss(<username>
+    #                                          [, options])
+    #  people += connection.more
+    #
+    def get_persons_neighbors(username, options={})
+      # TODO: add flickr_username handling
+      # TODO: add paging options
+      store_and_return(_get_response("get_persons_neighbors?id=#{username}").people)
+    end
+
+    
+    #
+    # Implements get_persons_tags from the People
+    # API and returns an array of tags.
+    # 
+    #  require 'r43'
+    #  connection = R43::Connection.new(<api_key>)
+    #  tags = connection.get_persons_tags(<username>
+    #                                  [, options])
+    #
+    def get_persons_tags(username, options={})
+      # TODO: add flickr_username handling
+      store_and_return(_get_response("get_persons_tags?id=#{username}").tags)
+    end
+
+    
+    #
+    # Implements get_persons_tag_cloud from the People
+    # API and returns an array of tags.
+    # 
+    #  require 'r43'
+    #  connection = R43::Connection.new(<api_key>)
+    #  tags = connection.get_persons_tag_cloud(<username>
+    #                                       [, options])
+    #
+    def get_persons_tag_cloud(username, options={})
+      # TODO: add flickr_username handling
+      store_and_return(_get_response("get_persons_tag_cloud?id=#{username}").tags)
+    end
+
+    
+    #
+    # Implements the get_entry method of the Entries API and
+    # returns an Entry object.
+    #
+    #   require 'r43'
+    #   connection = R43::Connection.new(<api_key>)
+    #   entry = connection.get_entry(<id>)
+    #
+    def get_entry(id)
+      store_and_return(_get_response("get_entry?id=#{id}").entry)
+    end
+
+    #
+    # Implements the search_cities method of the Cities API
+    #
+    #   require 'r43'
+    #   connection = R43::Connection.new(<api_key>)
+    #   cities = connection.search_cities(<query>)
+    #
+    def search_cities(query)
+      store_and_return(_get_response("search_cities?q=#{query}").cities)
+    end
+    
+    #
+    # Implements the get_city method of the Cities API
+    #
+    #   require 'r43'
+    #   connection = R43::Connection.new(<api_key>)
+    #   city = connection.get_city(<id>)
+    #
+
+    def get_city(id)
+      store_and_return(_get_response("get_city?id=#{id}").city)
+    end
+
+    #
+    # Implements the get_citys_people method of the Cities API
+    #
+    #   require 'r43'
+    #   connection = R43::Connection.new(<api_key>)
+    #   people = connection.get_citys_people(<id>)
+    #
+
+    def get_citys_people(id, optional={})
+      params = "id=#{id}"
+      params += "&offset=#{optional["offset"]}" if optional["offset"]
+      params += "&max=#{optional["max"]}" if optional["max"]
+
+      store_and_return(_get_response("get_citys_people?#{params}").people)
+    end
+    
+  end
+
+  class R43::Response
+    attr_reader :service, :query, :xml,
+                :object,  :entry,   :person, :goal, :city,
+                :objects, :entries, :people, :goals, :cities, :tags,
+                :has_object, :max_in_page, :total_available, :next_offset
+
+    def initialize(service, query)
+      @service = service
+      @query = query
+      @has_object = false
+      @objects = []
+      @entries = []
+      @people = []
+      @goals = []
+      @cities = []
+      @tags = []
+      @max_in_page = 0
+      @total_available = 0
+      @next_offset = 0
+      _from_xml(service.get_response(query))
+    end
+
+    def more()
+      clear_arrays()
+      _populate_collections_from_xml(service.get_response(query + "&offset=#{@next_offset}"))
+    end
+
+    private
+    
+    def clear_arrays()
+      @objects.clear()
+      @entries.clear()
+      @people.clear()
+      @goals.clear()
+      @cities.clear()
+      @tags.clear()
+    end
+
+    def object=(object)
+      if @has_object
+        @object = nil
+      else
+        @has_object = true
+        @object = object
+      end
+    end
+
+    def entry=(entry)
+      @entry = entry
+      self.object = @entry
+      add_entry(@entry)
+    end
+
+    def person=(person)
+      @person = person
+      self.object = @person
+      add_person @person
+    end
+
+    def goal=(goal)
+      @goal = goal
+      self.object = @goal
+      add_goal @goal
+    end
+
+    def city=(city)
+      @city = city
+      self.object = @city
+      add_city @city
+    end
+
+    def add_entry(entry)
+      @entries.push entry
+      @objects.push entry
+    end
+
+    def add_person(person)
+      @people.push person
+      @objects.push person
+    end
+
+    def add_goal(goal)
+      @goals.push goal
+      @objects.push goal
+    end
+
+    def add_city(city)
+      @cities.push city
+      @objects.push city
+    end
+
+    def add_tag(tag)
+      @tags.push tag
+      @objects.push tag
+    end
+
+    def _from_xml(xml)
+      @xml = xml
+      self.entry = Entry.from_xml(xml.elements["entry"]) if xml.elements["entry"]
+      self.person = Person.from_xml(xml.elements["person"]) if xml.elements["person"]
+      self.goal = Goal.from_xml(xml.elements["goal"]) if xml.elements["goal"]
+      self.city = City.from_xml(xml.elements["city"]) if xml.elements["city"]
+      _populate_collections_from_xml xml
+    end
+
+    def _populate_collections_from_xml(xml)
+      if xml.elements["feed/pagination"] then
+        @max_per_page = xml.elements["feed/pagination/max"].text.to_i
+        @total_available = xml.elements["feed/pagination/total"].text.to_i
+        @next_offset = xml.elements["feed/pagination/next_offset"].text.to_i
+      end
+      
+      xml.elements.each("feed/entry") do |entry_element|
+        add_entry(Entry.from_xml(entry_element))
+      end
+
+      xml.elements.each("feed/person") do |person_element|
+        add_person(Person.from_xml(person_element))
+      end
+
+      xml.elements.each("feed/goal") do |goal_element|
+        add_goal(Goal.from_xml(goal_element))
+      end
+
+      xml.elements.each("feed/city") do |city_element|
+        add_city(City.from_xml(city_element))
+      end
+
+      xml.elements.each("feed/tags/tag") do |tag_element|
+        tag = Tag.from_xml(tag_element)
+        add_tag(tag)
+      end
+    end
+  end
+end