fb_joy 0.1.2

data/lib/joey/hs_info.rb

@@ -0,0 +1,15 @@
+module Joey
+  class HsInfo < Model
+    define_properties :hs1_name, :hs2_name, :grad_year
+
+    def validate
+      valid = true
+    end
+
+    def valid?
+      self.validate
+      puts self.errors.inspect unless self.errors.empty?
+      self.errors.empty?
+    end
+  end
+end

data/lib/joey/image.rb

@@ -0,0 +1,5 @@
+module Joey
+  class Image < Model
+    define_properties :height, :width, :source
+  end
+end

data/lib/joey/like.rb

@@ -0,0 +1,13 @@
+module Joey
+  class Like < Model
+
+    define_properties :name, :id, :count
+
+    def validate
+    end
+
+    def valid?
+      true
+    end
+  end
+end

data/lib/joey/location.rb

@@ -0,0 +1,17 @@
+module Joey
+  class Location < Model
+    define_properties :name, :zip, :country, :id, :state, :city
+
+    def validate
+      valid = true
+      errors << { :message => "country should be string but is #{country.inspect}" } unless country.is_a?(String)
+      errors << { :message => "city should be string but is #{city.inspect}" } unless city.is_a?(String)
+    end
+
+    def valid?
+      self.validate
+      puts self.errors.inspect unless self.errors.empty?
+      self.errors.empty?
+    end
+  end
+end

data/lib/joey/model.rb

@@ -0,0 +1,84 @@
+module Joey
+  class Model < Hashie::Dash
+
+    class KoalaClientRequiredError < Exception; end
+
+    attr_accessor :client, :errors
+
+    def initialize(hash = {}, client = nil)
+      self.client = client
+      self.errors = []
+
+      super(hash || {})
+    end
+
+    def self.define_properties(*args)
+      args.each do |arg|
+        property arg
+      end
+    end
+
+    def self.recognize?(data)
+      true
+    end
+
+    def self.hash_populating_accessor(method_name, *klass)
+      define_method "#{method_name}=" do |hash|
+        instance_variable_set("@#{method_name}", client.map_data(hash, klass))
+      end
+
+      define_method "#{method_name}" do
+        instance_variable_get "@#{method_name}"
+      end
+      #add_creation_method(method_name,klass)
+    end
+
+    # TODO: Look out for creation of nodes in the Graph
+    # me = koala_client.me
+    # me.friends_create(args)
+    #def self.add_creation_method(name, klass)
+      #define_method "#{name}_create" do |arg|
+        #params = arg.nil? ? {} : arg.post_params
+        #klass_to_send = arg.nil? ? nil : klass
+        #client.post("#{id}/#{name}", klass_to_send, params)
+      #end
+    #end
+    
+    def self.hash_populating_association(method_name, *klass)
+      define_method "#{method_name}=" do |hash|
+        instance_variable_set("@#{method_name}", client.map_data(hash, klass))
+      end
+
+      define_method(method_name) do
+        if (ret = instance_variable_get("@#{method_name}")).nil?
+          ret = client.get_and_map("#{id}/#{method_name}", klass)
+          instance_variable_set("@#{method_name}", ret)
+        end
+        return ret
+      end
+    end
+
+    def self.has_association(name, klass)
+      define_method(name) do
+        if (ret = instance_variable_get("@#{name}")).nil?
+          ret = client.get_and_map("#{id}/#{name}", klass)
+          instance_variable_set("@#{name}", ret)
+        end
+        return ret
+      end
+      
+      #add_creation_method(name, klass)
+    end
+
+    ##
+    # Get some information of a node in the Graph.
+    # Joey::Post.find('19440638720_133872233324170', client, :fields => 'name,link,description,comments')
+    def self.find(id, client = nil, args = {})
+      client.get_and_map(id, self, args)
+    end
+
+    def self.get_all(ids, client = nil, args = {})
+      client.get_all_and_map(ids, self, args)
+    end
+  end
+end

data/lib/joey/page.rb

@@ -0,0 +1,31 @@
+module Joey
+  class Page < Profile
+        
+    define_properties :id, :name, :category, :username, :category
+    
+    # General
+    define_properties :likes, :link, :picture, :has_added_app
+
+    # Retail
+    define_properties :founded, :products, :mission, :company_overview
+    
+    # Musicians
+    define_properties :record_label, :hometown, :band_members, :genre
+    
+    def self.recognize?(hash)
+      hash.has_key?("category")
+    end
+    
+    def validate
+      valid = true
+      errors << { :message => 'id should not be nil' } if id.nil?
+      errors << { :message => "name should be string but is #{name.inspect}" } unless name.is_a?(String)
+    end
+
+    def valid?
+      self.validate
+      puts self.errors.inspect unless self.errors.empty?
+      self.errors.empty?
+    end
+  end
+end

data/lib/joey/parser_helpers.rb

@@ -0,0 +1,7 @@
+module Joey
+  module ParserHelpers
+    def boolianize(value)
+      !value.zero?
+    end
+  end
+end

data/lib/joey/photo.rb

@@ -0,0 +1,41 @@
+module Joey
+  class Photo < Model
+    define_properties :id, :name, :picture, :source, :height, :width, :link, :icon,
+      :created_time, :updated_time, :position
+    #creation_properties :message
+    
+    hash_populating_accessor :from, "User","Page"
+    hash_populating_accessor :comments, "Comment"
+    hash_populating_accessor :tags, "Tag"
+    hash_populating_accessor :images, "Image"
+    #has_association :comments, "Comment"
+
+    def validate
+      created_time.to_time rescue errors << { :message => 'created_time is not compatible' }
+      updated_time.to_time rescue errors << { :message => 'updated_time is not compatible' }
+      errors << { :message => 'id should not be nil' } if id.nil?
+      errors << { :message => "name is neither string nor nil but is #{name.inspect}" } unless name.is_a?(String) || name.nil?
+      errors << { :message => "source is neither string nor nil but is #{source.inspect}" } unless source.is_a?(String) || source.nil?
+      errors << { :message => "height is neither integer nor nil but is #{height.inspect}" } unless height.is_a?(Integer) || height.nil?
+      errors << { :message => "icon is neither string nor nil but is #{icon.inspect}" } unless icon.is_a?(String) || icon.nil?
+      errors << { :message => "width is neither integer nor nil but is #{width.inspect}" } unless width.is_a?(Integer) || width.nil?
+      errors << { :message => "from is not a Joey::User or Joey::Page and is #{from.inspect}" } unless from.is_a?(Joey::User) || from.is_a?(Joey::Page)
+
+      errors << { :message => "comments is not an array nor nil and is #{comments.inspect}" } unless comments.is_a?(Array) || comments.nil?
+      if comments.is_a?(Array) && !(comments.collect(&:class).uniq - [Joey::Comment]).empty?
+        errors << { :message => 'comments is not an array of Joey::Comment' }
+      end
+
+      errors << { :message => "tags is not an array nor nil and is #{tags.inspect}" } unless tags.is_a?(Array) || tags.nil?
+      if tags.is_a?(Array) && !(tags.collect(&:class).uniq - [Joey::Tag]).empty?
+        errors << { :message => 'tags is not an array of Joey::Comment' }
+      end
+    end
+
+    def valid?
+      self.validate
+      puts self.errors.inspect unless self.errors.empty?
+      self.errors.empty?
+    end
+  end
+end

data/lib/joey/post.rb

@@ -0,0 +1,67 @@
+module Joey
+  class Post < Model
+
+    define_properties :id, :message, :picture, :link, :name, :caption, 
+      :description, :source, :icon, :attribution,
+      :created_time, :updated_time, :type, :object_id, :application
+
+    #creation_properties :message, :picture, :link, :name, :description
+
+    hash_populating_accessor :actions, "Action"
+    hash_populating_accessor :comments, "Comment"
+    hash_populating_accessor :from, "User", "Page"
+    hash_populating_accessor :to, "User", "Page"
+    hash_populating_accessor :privacy, "Privacy"
+    hash_populating_accessor :properties, "Property"
+    hash_populating_accessor :likes, "Like"
+
+    def validate
+      created_time.to_time rescue errors << { :message => 'created_time is not compatible' }
+      updated_time.to_time rescue errors << { :message => 'updated_time is not compatible' }
+      errors << { :message => 'id should not be nil' } if id.nil?
+      errors << { :message => "name is neither string nor nil but is #{name.inspect}" } unless name.is_a?(String) || name.nil?
+      errors << { :message => "message is neither string nor nil but is #{message.inspect}" } unless message.is_a?(String) || message.nil?
+      errors << { :message => "likes is neither string nor nil but is #{likes.inspect}" } unless likes.is_a?(Integer) || likes.nil? || likes.is_a?(Array)
+      errors << { :message => "icon is neither string nor nil but is #{icon.inspect}" } unless icon.is_a?(String) || icon.nil?
+      errors << { :message => "attribution is neither string nor nil but is #{attribution.inspect}" } unless attribution.is_a?(String) || attribution.nil?
+
+      unless ['music', 'photo', 'video', 'status', 'link'].include?(type)
+        errors << { :message => "type should be one of 'music', 'video', 'status', or 'link' but is #{type}" }
+      end
+
+      if type == 'picture' && !picture.is_a?(String)
+        errors << { :message => "picture is not present for picture post and is #{picture.inspect}" }
+      end
+
+      if type == 'link' && !link.is_a?(String)
+        errors << { :message => "picture is not present for picture post and is #{picture.inspect}" }
+      end
+
+      errors << { :message => "from is not a Joey::User or Joey::Page and is #{from.inspect}" } unless from.is_a?(Joey::User) || from.is_a?(Joey::Page)
+
+      errors << { :message => "to is neither an array nor nil and is #{to.inspect}" }  unless to.is_a?(Array) || to.nil?
+      if to.is_a?(Array) && !(to.collect(&:class).uniq - [Joey::User, Joey::Page]).empty?
+        errors << { :message => 'to is not an array of Joey::User or Joey::Page' }
+      end
+
+      # TODO: Explore following approach.
+      # errors << { :message => 'Comments is not valid' }, unless comment.nil? || (comments.collect(&:valid?).uniq - [true]).empty?
+
+      # Sometimes comments is a single Joey::Comment object
+      errors << { :message => "comments is not an array nor nil and is #{comments.inspect}" } unless comments.is_a?(Array) || comments.nil?
+      if comments.is_a?(Array) && !(comments.collect(&:class).uniq - [Joey::Comment]).empty?
+        errors << { :message => 'comments is not an array of Joey::Comment' }
+      end
+    end
+
+    def valid?
+      self.validate
+      puts self.errors.inspect unless self.errors.empty?
+      self.errors.empty?
+    end
+
+    #def likes_create
+    #client.post("#{id}/likes",nil,{})
+    #end
+  end
+end

data/lib/joey/privacy.rb

@@ -0,0 +1,15 @@
+module Joey
+  class Privacy < Model
+    define_properties :value, :description, :allow, :friends, :deny
+
+    def validate
+      valid = true
+    end
+
+    def valid?
+      self.validate
+      puts self.errors.inspect unless self.errors.empty?
+      self.errors.empty?
+    end
+  end
+end

data/lib/joey/profile.rb

@@ -0,0 +1,33 @@
+require 'joey/model'
+
+module Joey
+  class Profile < Model
+    define_properties :id, :name
+
+    has_association :feed, "Post"
+    #has_association :links, "Link"
+    has_association :photos, "Photo"
+    #has_association :groups, "Group"
+    has_association :albums,"Album"
+    has_association :videos, "Video"
+    #has_association :notes, "Note"
+    has_association :posts, "Post"
+    #has_association :events, "Event"
+    #has_association :links, "Link"
+    has_association :statuses, "Status"
+
+    def to_s
+      name
+    end
+
+    def validate
+      valid = true
+    end
+
+    def valid?
+      self.validate
+      puts self.errors.inspect unless self.errors.empty?
+      self.errors.empty?
+    end
+  end
+end

data/lib/joey/property.rb

@@ -0,0 +1,15 @@
+module Joey
+  class Property < Model
+    define_properties :name, :text, :href
+
+    def validate
+      errors = []
+    end
+
+    def valid?
+      self.validate
+      puts self.errors.inspect unless self.errors.empty?
+      self.errors.empty?
+    end
+  end
+end

data/lib/joey/relative.rb

@@ -0,0 +1,15 @@
+module Joey
+  class Relative < Model
+    define_properties :uid, :relationship, :name
+
+    def validate
+      valid = true
+    end
+
+    def valid?
+      self.validate
+      puts self.errors.inspect unless self.errors.empty?
+      self.errors.empty?
+    end
+  end
+end

data/lib/joey/rest_api.rb

@@ -0,0 +1,116 @@
+require 'joey/parser_helpers'
+
+module Joey
+  module RestAPI
+
+    include Joey::ParserHelpers
+
+    class UnrecognizeableClassError < Exception; end
+
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+
+    module ClassMethods
+    end
+
+    def me
+      get_and_map('me', Joey::User)
+    end
+
+    def revoke_app_permission(ext_perm)
+      # no need to boolianize. It returns true/false.
+      self.rest_call("auth.revokeExtendedPermission", :perm => ext_perm.to_s)
+    end
+
+    # path can be some node id in the Facebook Graph e.g. 'me', 'me/feed', '1234567890/feed'.
+    # klass is wrapper class for that node.
+    def get_and_map(path, klass = nil, args = {})
+      data = self.get_object(path, args)
+      map_data(data, klass)
+    end
+
+    def get_all_and_map(ids, klass = nil, args = {})
+      data = self.get_objects(ids, args)
+      map_data({ 'data' => data.values }, klass)
+    end
+
+    def get_and_map_url(url, klass = nil)
+      # FIXME: following only returns a hash like {"id"=>"http://graph.facebook.com/100000637452380/feed"}
+      # try to write a method in koala which can request absolute Facebook urls. See fetching_array.rb:7.
+      data = self.class.get_object(url)
+      map_data(data,klass)
+    end
+
+    def map_data(data, klass = nil)
+      raise_error_if_necessary(data)
+      hash_or_array = extract_hash_or_array(data, klass)
+      hash_or_array = map_to_class(hash_or_array, klass) if klass
+      # TODO: Validate an object here.
+      #hash_or_array.validate and puts hash_or_array.class.inspect if hash_or_array.is_a?(Model)
+      hash_or_array
+    end
+
+    def extract_hash_or_array(hash_or_array, klass)
+      return nil unless hash_or_array
+      return hash_or_array if hash_or_array.kind_of?(Array)
+      return extract_fetching_array(hash_or_array, klass) if hash_or_array.has_key?("data")
+      return hash_or_array
+    end
+
+    def extract_fetching_array(hash, klass)
+      f = Joey::FetchingArray.new
+      f.concat(hash["data"])
+      f.client = self
+      f.classes = Array(klass)
+      if hash["paging"]
+        f.next_url = hash["paging"]["next"]
+        f.previous_url = hash["paging"]["previous"]
+      end
+      if hash["count"]
+        f.count = hash['count']
+      end
+      f
+    end
+
+    def map_to_class(hash_or_array, klass)
+      return nil if hash_or_array.nil?
+      if hash_or_array.kind_of?(Array)
+        hash_or_array.map! {|elmnt| create_instance(klass, elmnt)}
+      else
+        hash_or_array = create_instance(klass, hash_or_array)
+      end
+      hash_or_array
+    end
+
+    def create_instance(klass, data)
+      klass = determine_class(klass, data)
+      if klass.nil?
+        raise UnrecognizeableClassError.new("unable to recognize klass for #{klass.inspect} => #{data.inspect}")
+      end
+      klass.new(data, self)
+    end
+    
+    def constantize_string(klass)
+      # FIXME: cost_get is buggy on some versions of Ruby
+      # klass.is_a?(String) ? Joey.const_get(klass) : klass
+      klass.is_a?(String) ? (klass =~ /Joey/ ? klass.constantize : ("Joey::"+ klass).constantize) : klass
+    end
+    
+    def determine_class(klass_or_klasses, data)
+      klasses = Array(klass_or_klasses).map { |k| constantize_string(k)}
+      klasses.detect {|klass| klass.recognize?(data)} || klasses.first
+    end
+
+    def raise_error_if_necessary(data)
+      if data.kind_of?(Hash)
+        if data.keys.size == 1 and data["error"]
+          type = data["error"]["type"]
+          message = data["error"]["message"]
+          raise Exception.new("#{type}: #{message}")
+        end
+      end
+    end
+
+  end
+end