tagcrumbs-tagcrumbs 0.3.1

data/lib/tagcrumbs/resources/models/profile.rb

@@ -0,0 +1,16 @@
+module Tagcrumbs
+  # Each User has Profile. A Profile can only be updated, it is created automatically with a User and destroyed if the User
+  # decides to leave Tagcrumbs.
+  class Profile < Model
+    can_be :updated
+    
+    writeable_attributes :fullname, :about, :description
+    readable_attributes   :created_at, :updated_at
+    
+    has_one :user
+    has_one :city, :modifiable => true
+    has_one :picture
+    
+    has_many :profile_links
+  end
+end

data/lib/tagcrumbs/resources/models/profile_link.rb

@@ -0,0 +1,12 @@
+module Tagcrumbs
+  # Each User can set multiple ProfileLinks
+  # e.g. his Facebook account, blog, website etc.
+  class ProfileLink < Model
+    can_be :created, :updated, :destroyed
+    
+    writeable_attributes :url, :link_type
+    readable_attributes :created_at, :updated_at
+
+    has_one :profile
+  end
+end

data/lib/tagcrumbs/resources/models/root.rb

@@ -0,0 +1,19 @@
+module Tagcrumbs
+  # The Root Object that contains links to all other resources on tagcrumbs.com.
+  # It is used as the starting point for many other queries.
+  class Root < Model
+    has_one :you
+    has_one :location
+    
+    has_many :tagcrumbs
+    has_many :nearby_tagcrumbs
+    has_many :countries
+    
+    has_many :popular_countries
+    has_many :tags
+    has_many :users
+    
+    has_many :search
+    has_many :place_search
+  end
+end

data/lib/tagcrumbs/resources/models/settings.rb

@@ -0,0 +1,14 @@
+module Tagcrumbs
+  # Each user has a Settings object that can be updated
+  class Settings < Model
+    can_be :updated
+    
+    readable_attributes :created_at, :updated_at 
+    writeable_attributes :locale, :unit_system, :notification_fan, :notification_recommendation, :newsletter, :facebook_new_placemark_feed, 
+                         :facebook_new_favorite_feed, :facebook_new_comment_feed
+    
+    
+    has_one :user
+
+  end
+end

data/lib/tagcrumbs/resources/models/state.rb

@@ -0,0 +1,14 @@
+module Tagcrumbs
+  # A State is a Place and connects Countries and Cities.
+  class State < Place
+    
+    has_one :country
+    has_many :cities
+    
+    # Search a State by name
+    def self.search(q, args={})
+      super(q, args.merge(:for => :state))
+    end
+    
+  end
+end

data/lib/tagcrumbs/resources/models/subscription.rb

@@ -0,0 +1,13 @@
+module Tagcrumbs
+  # A Subscription is used to get updates of Placemarks
+  class Subscription < Model
+    can_be :created, :updated, :destroyed
+    
+    readable_attributes :created_at, :updated_at
+    
+    has_one :user
+    has_one :tagcrumb, :modifiable => true
+    
+    
+  end
+end

data/lib/tagcrumbs/resources/models/suggestions.rb

@@ -0,0 +1,11 @@
+module Tagcrumbs
+  # Suggestions is a Model that is used to load the name, tag and city suggestions from the web service.
+  class Suggestions < Model
+    has_many :recommended_tags
+    has_many :popular_tags
+    
+    has_many :names
+    
+    has_many :cities
+  end
+end

data/lib/tagcrumbs/resources/models/tag.rb

@@ -0,0 +1,6 @@
+module Tagcrumbs
+  # A single Tag.
+  class Tag < Model
+    readable_attributes :name
+  end
+end

data/lib/tagcrumbs/resources/models/tagcrumb.rb

@@ -0,0 +1,58 @@
+module Tagcrumbs
+  # Tagcrumb is the superclass for Placemark and Favorite, they are both a "Tagcrumb" as well
+  class Tagcrumb < Model
+    # Find Tagcrumbs by specifying filter criteria.
+    def self.find(args={})
+      args.assert_valid_keys(
+                             :from, # from: you, friends, fans, recommendations, everybody, user
+                             :username, # name of the user
+                             :tags, # comma separates tag list
+                             :tagcrumb_type, # Placemarks, Favorite or both?
+                             :city, :state, :country, :middle_of_nowhere, # filter by the place hierarchy
+                             :within, # within a certain radius
+                             :latitude, :longitude, # per default within is the current location, can be overwritten with latitude and longitude
+                             :bbox, # everything between a bounding box
+                             :since, :until, # filter by time
+                             :per_page, :page, :sort, :order # filter options
+                            )
+
+      Array.load(Tagcrumbs.root.tagcrumbs_url, typecast_and_validate_query_parameters(args))
+    end
+    
+    # Use a fulltext search to find Tagcrumbs.
+    # This is different from "finding" by filter criteria
+    def self.search(args={})
+      args.assert_valid_keys(:q, :from, :l, :w, :page, :per_page)
+      
+      Array.load(Tagcrumbs.root.search_url, typecast_and_validate_query_parameters(args))
+    end
+    
+    
+    def self.typecast_and_validate_query_parameters(args)
+      query_args = {}
+      
+      args.each do |key, value|
+        query_args[key] = case key
+          when :from, :w: value.to_sym
+          when :tagcrumb_type: value.to_s.capitalize
+          when :since, :until: value.iso8601
+          else
+            value
+        end
+
+        Tagcrumbs.validate(key, query_args[key])
+      end
+      
+      query_args
+    end
+    
+
+  end
+end
+
+
+
+
+
+
+

data/lib/tagcrumbs/resources/models/user.rb

@@ -0,0 +1,101 @@
+module Tagcrumbs
+  # The main actor in the webservice.
+  class User < Model
+    readable_attributes :username, :created_at, :updated_at
+    
+    has_one :profile
+    has_one :picture
+    has_one :settings
+    has_one :location
+    has_one :suggestions
+    
+    has_many :tagcrumbs
+    has_many :placemarks
+    has_many :favorites
+     
+    has_many :profile_links
+    
+    has_many :fanships
+    has_many :friendships
+
+    has_many :recommendations
+    has_many :received_recommendations
+    
+    has_many :filters
+    
+    has_many :comments
+    has_many :links
+    has_many :subscriptions
+    
+    has_many :tags
+    has_many :places
+    
+    has_many :activities
+    
+    has_many :tagcrumbs_friends
+    has_many :tagcrumbs_fans
+    
+    # An array of all friends of a User (people the user is following)
+    def friends
+      array = []
+      
+      friendships.each_page do |page|
+        array += page.map{|f| f.friend}
+      end
+      
+      array
+    end
+    
+    # An array of all fans of a User (people that follow this user)
+    def fans
+      array = []
+      
+      fanships.each_page do |page|
+        array += page.map{|f| f.fan}
+      end
+      
+      array      
+    end
+    
+    # The friendship with a specific user
+    def friendship_with(user)
+      f = Friendship.new
+      f.reload("/#{self.username}/friends/#{user}")      
+    rescue Net::HTTPServerException => error
+      f.requestor.response.code == '404' ? nil : (raise error) # not found
+    end
+    
+    # Is this user friend with user?
+    def friend_with?(user)
+      friendship_with(user) ? true : false
+    end
+    
+    # The fanship with a specific user
+    def fanship_with(user)
+      Fanship.load("/#{self.username}/fans/#{user}")
+    rescue Net::HTTPServerException => error
+      self.requestor.response.code == '404' ? nil : (raise error) # not found  
+    end
+    
+    # Is this user a fan of user?
+    def fan_of?(user)
+      fanship_with(user) ? true : false
+    end
+    
+    
+    # Search a User by name or email
+    def self.search(q, args={})
+      Array.load(Tagcrumbs.root.users_url, args.merge(:u => q))
+    end
+    
+    # Load a User by its username
+    def self.find_by_username(username)
+      User.load("/#{username}")
+    end
+    
+    def to_s
+      self.username
+    end
+    
+  end
+end

data/lib/tagcrumbs/resources/models/user_recommendation.rb

@@ -0,0 +1,18 @@
+module Tagcrumbs
+  # A Recommendation of a Placemark between two Users
+  class UserRecommendation < Model
+    can_be :created
+    
+    readable_attributes :created_at, :updated_at
+    writeable_attributes :message
+    
+    has_one :user
+    has_one :tagcrumb, :modifiable => true
+    has_one :recommended_user, :modifiable => true
+    
+    
+    def create_url
+      Tagcrumbs.current_user.recommendations_url # has to be overwritten
+    end
+  end
+end

data/lib/tagcrumbs/resources/resource.rb

@@ -0,0 +1,76 @@
+module Tagcrumbs
+  # Superclass for all other Resources
+  class Resource
+    attr_accessor :resource_url, :loaded
+    attr_writer :requestor
+    attr_reader :properties
+    
+    def initialize
+      reset!
+    end
+    
+    # Clean up the state of the model and make it blank again
+    def reset!      
+      self.resource_url = nil
+      self.loaded = false
+      self.properties = {}
+      
+      true
+    end
+    
+    # Is the Resource loaded or is it just a stub and the attributes still need to be loaded from the web?
+    def loaded?
+      self.loaded ? true : false
+    end
+    
+    # A requestor that is auto-generated if needed to make requests to the webservice
+    def requestor
+      @requestor ||= Requestor.new
+    end
+       
+    # Reset the Resource, reload the data from the web and initialize it again from the document
+    def reload(url = nil)
+      self.requestor.get(url || resource_url)
+      initialize_from_document(requestor.response.body, requestor.response_format)
+      true
+    end
+    
+    # Set the properties and automatically set the resource_url
+    def properties=(properties)
+      self.resource_url = properties['xlink:href'] if properties['xlink:href']       
+      @properties = properties.with_indifferent_access
+    end
+    
+    # Load a Resource from a URL with optional query parameters
+    # The correct Resource class is automatically determined.
+    def self.load(path, query_string = {}, requestor_options={})
+      requestor = Requestor.new(requestor_options)
+      requestor.get(path, query_string)
+      
+      resource = new_from_document(requestor.response.body, requestor.response_format)
+    end
+    
+    # Create a new Resource from a document.
+    # The correct Resource class is automatically determined.
+    def self.new_from_document(document, format = Tagcrumbs.options[:format])
+      parser = Parser.new_for_format(document, format) 
+
+      resource = Tagcrumbs.class_by_type(parser.get_attribute('type')).new
+      resource.initialize_from_document(parser, format)
+      
+      resource
+    end
+    
+    # Initialize the object with data from the document
+    def initialize_from_document(document, format = Tagcrumbs.options[:format])      
+      parser = Parser.new_for_format(document, format)
+      reset!
+      
+      self.loaded = parser.node_loaded?
+      self.properties = parser.get_attributes || {}
+      
+      parser
+    end
+    
+  end
+end

data/lib/tagcrumbs/validations.rb

@@ -0,0 +1,301 @@
+module Tagcrumbs
+  class ResourceInvalid# < ClientError  #:nodoc:
+  end
+  
+  # == Borrowed from ActiveResource
+  
+  # Active Resource validation is reported to and from this object, which is used by Base#save
+  # to determine whether the object in a valid state to be saved. See usage example in Validations.  
+  class Errors
+    include Enumerable
+    attr_reader :errors
+
+    delegate :empty?, :to => :errors
+    
+    def initialize(base) # :nodoc:
+      @base, @errors = base, {}
+    end
+
+    # Add an error to the base Active Resource object rather than an attribute.
+    #
+    # ==== Examples
+    #   my_folder = Folder.find(1)
+    #   my_folder.errors.add_to_base("You can't edit an existing folder")
+    #   my_folder.errors.on_base
+    #   # => "You can't edit an existing folder"
+    #
+    #   my_folder.errors.add_to_base("This folder has been tagged as frozen")
+    #   my_folder.valid?
+    #   # => false
+    #   my_folder.errors.on_base
+    #   # => ["You can't edit an existing folder", "This folder has been tagged as frozen"]
+    #
+    def add_to_base(msg)
+      add(:base, msg)
+    end
+
+    # Adds an error to an Active Resource object's attribute (named for the +attribute+ parameter)
+    # with the error message in +msg+.
+    #
+    # ==== Examples
+    #   my_resource = Node.find(1)
+    #   my_resource.errors.add('name', 'can not be "base"') if my_resource.name == 'base'
+    #   my_resource.errors.on('name')
+    #   # => 'can not be "base"!'
+    #
+    #   my_resource.errors.add('desc', 'can not be blank') if my_resource.desc == ''
+    #   my_resource.valid?
+    #   # => false
+    #   my_resource.errors.on('desc')
+    #   # => 'can not be blank!'
+    #
+    def add(attribute, msg)
+      @errors[attribute.to_s] = [] if @errors[attribute.to_s].nil?
+      @errors[attribute.to_s] << msg
+    end
+
+    # Returns true if the specified +attribute+ has errors associated with it.
+    #
+    # ==== Examples
+    #   my_resource = Disk.find(1)
+    #   my_resource.errors.add('location', 'must be Main') unless my_resource.location == 'Main'
+    #   my_resource.errors.on('location')
+    #   # => 'must be Main!'
+    #
+    #   my_resource.errors.invalid?('location')
+    #   # => true
+    #   my_resource.errors.invalid?('name')
+    #   # => false
+    def invalid?(attribute)
+      !@errors[attribute.to_s].nil?
+    end
+
+    # A method to return the errors associated with +attribute+, which returns nil, if no errors are 
+    # associated with the specified +attribute+, the error message if one error is associated with the specified +attribute+,
+    # or an array of error messages if more than one error is associated with the specified +attribute+.
+    #
+    # ==== Examples
+    #   my_person = Person.new(params[:person])
+    #   my_person.errors.on('login')
+    #   # => nil
+    #
+    #   my_person.errors.add('login', 'can not be empty') if my_person.login == ''
+    #   my_person.errors.on('login')
+    #   # => 'can not be empty'
+    #
+    #   my_person.errors.add('login', 'can not be longer than 10 characters') if my_person.login.length > 10
+    #   my_person.errors.on('login')
+    #   # => ['can not be empty', 'can not be longer than 10 characters']
+    def on(attribute)
+      errors = @errors[attribute.to_s]
+      return nil if errors.nil?
+      errors.size == 1 ? errors.first : errors
+    end
+    
+    alias :[] :on
+
+    # A method to return errors assigned to +base+ object through add_to_base, which returns nil, if no errors are 
+    # associated with the specified +attribute+, the error message if one error is associated with the specified +attribute+,
+    # or an array of error messages if more than one error is associated with the specified +attribute+.
+    #
+    # ==== Examples
+    #   my_account = Account.find(1)
+    #   my_account.errors.on_base
+    #   # => nil
+    #
+    #   my_account.errors.add_to_base("This account is frozen")
+    #   my_account.errors.on_base
+    #   # => "This account is frozen"
+    #
+    #   my_account.errors.add_to_base("This account has been closed")
+    #   my_account.errors.on_base
+    #   # => ["This account is frozen", "This account has been closed"]
+    #
+    def on_base
+      on(:base)
+    end
+
+    # Yields each attribute and associated message per error added.
+    #
+    # ==== Examples
+    #   my_person = Person.new(params[:person])
+    #
+    #   my_person.errors.add('login', 'can not be empty') if my_person.login == ''
+    #   my_person.errors.add('password', 'can not be empty') if my_person.password == ''
+    #   messages = ''
+    #   my_person.errors.each {|attr, msg| messages += attr.to_s.humanize + " " + msg + "<br />"}
+    #   messages
+    #   # => "Login can not be empty<br />Password can not be empty<br />"
+    #
+    def each
+      @errors.each_key { |attr| @errors[attr].each { |msg| yield attr, msg } }
+    end
+
+    # Yields each full error message added. So Person.errors.add("first_name", "can't be empty") will be returned
+    # through iteration as "First name can't be empty".
+    #
+    # ==== Examples
+    #   my_person = Person.new(params[:person])
+    #
+    #   my_person.errors.add('login', 'can not be empty') if my_person.login == ''
+    #   my_person.errors.add('password', 'can not be empty') if my_person.password == ''
+    #   messages = ''
+    #   my_person.errors.each_full {|msg| messages += msg + "<br/>"}
+    #   messages
+    #   # => "Login can not be empty<br />Password can not be empty<br />"
+    #
+    def each_full
+      full_messages.each { |msg| yield msg }
+    end
+
+    # Returns all the full error messages in an array.
+    #
+    # ==== Examples
+    #   my_person = Person.new(params[:person])
+    #
+    #   my_person.errors.add('login', 'can not be empty') if my_person.login == ''
+    #   my_person.errors.add('password', 'can not be empty') if my_person.password == ''
+    #   messages = ''
+    #   my_person.errors.full_messages.each {|msg| messages += msg + "<br/>"}
+    #   messages
+    #   # => "Login can not be empty<br />Password can not be empty<br />"
+    #
+    def full_messages
+      full_messages = []
+
+      @errors.each_key do |attr|
+        @errors[attr].each do |msg|
+          next if msg.nil?
+
+          if attr == "base"
+            full_messages << msg
+          else
+            full_messages << [attr.to_s.humanize, msg].join(' ')
+          end
+        end
+      end
+      full_messages
+    end
+
+    def clear
+      @errors = {}
+    end
+
+    # Returns the total number of errors added. Two errors added to the same attribute will be counted as such
+    # with this as well.
+    #
+    # ==== Examples
+    #   my_person = Person.new(params[:person])
+    #   my_person.errors.size
+    #   # => 0
+    #
+    #   my_person.errors.add('login', 'can not be empty') if my_person.login == ''
+    #   my_person.errors.add('password', 'can not be empty') if my_person.password == ''
+    #   my_person.error.size
+    #   # => 2
+    #
+    def size
+      @errors.values.inject(0) { |error_count, attribute| error_count + attribute.size }
+    end
+
+    alias_method :count, :size
+    alias_method :length, :size
+    
+    def from_format(document, format)
+      case format
+        when :xml:  from_xml(document)
+        when :json: from_json(document)
+      end
+    end
+    
+    # Grabs errors from the XML response.
+    def from_xml(xml)
+      clear
+      humanized_attributes = @base.attributes.keys.inject({}) { |h, attr_name| h.update(attr_name.to_s.humanize => attr_name) }
+      messages = ::Array.wrap(Hash.from_xml(xml)['errors']['error']) rescue []
+      messages.each do |message|
+        attr_message = humanized_attributes.keys.detect do |attr_name|
+          if message[0, attr_name.size + 1] == "#{attr_name} "
+            add humanized_attributes[attr_name], message[(attr_name.size + 1)..-1]
+          end
+        end
+        
+        add_to_base message if attr_message.nil?
+      end
+    end
+    
+    # Grabs errors from the JSON response.
+    # Added for Tagcrumbs
+    def from_json(json)
+      clear
+      humanized_attributes = @base.attributes.keys.inject({}) { |h, attr_name| h.update(attr_name.to_s.humanize => attr_name) }
+
+      messages = JSON.parse(json)['errors']['error'] rescue []
+      messages.each do |message|
+        attr_message = humanized_attributes.keys.detect do |attr_name|
+          if message[0, attr_name.size + 1] == "#{attr_name} "
+            add humanized_attributes[attr_name], message[(attr_name.size + 1)..-1]
+          end
+        end
+        
+        add_to_base message if attr_message.nil?
+      end
+    end
+  end
+  
+  # Module to support validation and errors with Active Resource objects. The module overrides
+  # Base#save to rescue ActiveResource::ResourceInvalid exceptions and parse the errors returned 
+  # in the web service response. The module also adds an +errors+ collection that mimics the interface 
+  # of the errors provided by ActiveRecord::Errors.
+  #
+  # ==== Example
+  #
+  # Consider a Person resource on the server requiring both a +first_name+ and a +last_name+ with a 
+  # <tt>validates_presence_of :first_name, :last_name</tt> declaration in the model:
+  #
+  #   person = Person.new(:first_name => "Jim", :last_name => "")
+  #   person.save                   # => false (server returns an HTTP 422 status code and errors)
+  #   person.valid?                 # => false
+  #   person.errors.empty?          # => false
+  #   person.errors.count           # => 1
+  #   person.errors.full_messages   # => ["Last name can't be empty"]
+  #   person.errors.on(:last_name)  # => "can't be empty"
+  #   person.last_name = "Halpert"  
+  #   person.save                   # => true (and person is now saved to the remote service)
+  #
+  module Validations
+    # def self.included(base) # :nodoc:
+    #   base.class_eval do
+    #     alias_method_chain :save, :validation
+    #   end
+    # end
+    # 
+    # # Validate a resource and save (POST) it to the remote web service.
+    # def save_with_validation
+    #   save_without_validation
+    #   true
+    # rescue ResourceInvalid => error
+    #   errors.from_xml(error.response.body)
+    #   false
+    # end
+
+    # Checks for errors on an object (i.e., is resource.errors empty?).
+    # 
+    # ==== Examples
+    #   my_person = Person.create(params[:person])
+    #   my_person.valid?
+    #   # => true
+    #
+    #   my_person.errors.add('login', 'can not be empty') if my_person.login == ''
+    #   my_person.valid?
+    #   # => false
+    def valid?
+      errors.empty?
+    end
+
+    # Returns the Errors object that holds all information about attribute error messages.
+    def errors
+      @errors ||= Errors.new(self)
+    end
+  end
+end