gs_graph 2.6.5

data/lib/gs_graph/searchable.rb

@@ -0,0 +1,33 @@
+module GSGraph
+  module Searchable
+    def self.search(query, options = {})
+      klass = options.delete(:class) || Searchable
+      query_param = klass.search_query_param
+      collection = Collection.new(
+        Node.new(:search).send(:get, options.merge(query_param.to_sym => query))
+      )
+      yield collection if block_given?
+      Searchable::Result.new(query, klass, options.merge(:collection => collection))
+    end
+
+    def search(query, options = {})
+      type = self.to_s.underscore.split('/').last.gsub("_", "")
+      Searchable.search(query, options.merge(:type => type, :class => self)) do |collection|
+        collection.map! do |obj|
+          self.new(obj[:id], obj.merge(
+            :access_token => options[:access_token]
+          ))
+        end
+      end
+    end
+
+    # The majority of Graph API searches use 'q' but some, like AdKeywordSuggestion
+    # use an alternate search query param
+    def self.search_query_param
+      :q
+    end
+    delegate :search_query_param, :to => Searchable
+  end
+end
+
+require 'gs_graph/searchable/result'

data/lib/gs_graph/searchable/result.rb

@@ -0,0 +1,31 @@
+module GSGraph
+  module Searchable
+    class Result < Collection
+      attr_accessor :query, :klass, :collection, :options
+
+      def initialize(query, klass, options = {})
+        @klass = klass
+        @query = query
+        @options = options
+        @collection = options.delete(:collection) || Collection.new
+        replace @collection
+      end
+
+      def next(_options_ = {})
+        if self.collection.next.present?
+          self.klass.search(self.query, self.options.merge(_options_).merge(self.collection.next))
+        else
+          self.class.new(self.query, self.klass)
+        end
+      end
+
+      def previous(_options_ = {})
+        if self.collection.previous.present?
+          self.klass.search(self.query, self.options.merge(_options_).merge(self.collection.previous))
+        else
+          self.class.new(self.query, self.klass)
+        end
+      end
+    end
+  end
+end

data/lib/gs_graph/serialization.rb

@@ -0,0 +1,19 @@
+module GSGraph
+  module Serialization
+    def to_hash(options = {})
+      raise "Define #{self.class}#to_hash!"
+    end
+
+    def as_json(options = {})
+      hash = self.to_hash options
+      hash.delete_if do |k, v|
+        v.blank?
+      end
+      hash
+    end
+
+    def to_json(options = {})
+      as_json.to_json options
+    end
+  end
+end

data/lib/gs_graph/status.rb

@@ -0,0 +1,27 @@
+module GSGraph
+  class Status < Node
+    include Connections::Comments
+    include Connections::Likes
+    include Connections::Likes::Likable
+
+    attr_accessor :from, :message, :updated_time
+
+    def initialize(identifier, attributes = {})
+      super
+      if (from = attributes[:from])
+        @from = if from[:category]
+          Page.new(from[:id], from)
+        else
+          User.new(from[:id], from)
+        end
+      end
+      @message = attributes[:message]
+      if (updated_time = attributes[:updated_time])
+        @updated_time = Time.parse(updated_time).utc
+      end
+
+      # cached connection
+      cache_collections attributes, :comments, :likes
+    end
+  end
+end

data/lib/gs_graph/subscription.rb

@@ -0,0 +1,14 @@
+module GSGraph
+  class Subscription
+    include Comparison
+
+    attr_accessor :object, :fields, :callback_url, :active
+
+    def initialize(attributes = {})
+      @object       = attributes[:object]
+      @fields       = attributes[:fields]
+      @callback_url = attributes[:callback_url]
+      @active       = attributes[:active]
+    end
+  end
+end

data/lib/gs_graph/tab.rb

@@ -0,0 +1,17 @@
+module GSGraph
+  class Tab < Node
+    attr_accessor :link, :application, :custom_name, :is_permanent, :position, :is_non_connection_landing_tab
+
+    def initialize(identifier, attributes = {})
+      super
+      @link = attributes[:link]
+      @application = if attributes[:application]
+        Application.new(attributes[:application][:id], attributes[:application])
+      end
+      @custom_name = attributes[:custom_name]
+      @is_permanent = attributes[:is_permanent]
+      @position = attributes[:position]
+      @is_non_connection_landing_tab = attributes[:is_non_connection_landing_tab]
+    end
+  end
+end

data/lib/gs_graph/tag.rb

@@ -0,0 +1,30 @@
+module GSGraph
+  class Tag
+    include Comparison
+    include Serialization
+
+    attr_accessor :user, :name, :x, :y, :created_time
+
+    def initialize(attributes = {})
+      @x = attributes[:x]
+      @y = attributes[:y]
+      if attributes[:created_time]
+        @created_time = Time.parse(attributes[:created_time]).utc
+      end
+      if attributes[:id].present?
+        @user = User.new(attributes[:id], attributes)
+      end
+      @name = attributes[:name]
+    end
+
+    def to_hash(options = {})
+      hash = {
+        :tag_text => self.name,
+        :x => self.x,
+        :y => self.y
+      }
+      hash[:tag_uid] = self.user.identifier if self.user
+      hash
+    end
+  end
+end

data/lib/gs_graph/tagged_object.rb

@@ -0,0 +1,23 @@
+module GSGraph
+  class TaggedObject < Node
+    attr_accessor :name, :offset, :length
+
+    def initialize(identifier, attributes = {})
+      super
+      [:name, :offset, :length].each do |key|
+        self.send("#{key}=", attributes[key])
+      end
+    end
+
+    def fetch_with_class_determination
+      attributes = fetch_without_class_determination.raw_attributes
+      klass = if attributes[:category]
+        Page
+      else
+        User
+      end
+      klass.new attributes[:id], attributes
+    end
+    alias_method_chain :fetch, :class_determination
+  end
+end

data/lib/gs_graph/targeting.rb

@@ -0,0 +1,23 @@
+module GSGraph
+  class Targeting
+    include Comparison
+
+    attr_accessor :country, :city, :region, :locale
+
+    def initialize(attributes = {})
+      @country = attributes[:country]
+      @city    = attributes[:city]
+      @region  = attributes[:region]
+      @locale  = attributes[:locale]
+    end
+
+    def to_hash(options = {})
+      {
+        :country => self.country,
+        :city    => self.city,
+        :region  => self.region,
+        :locale  => self.locale
+      }
+    end
+  end
+end

data/lib/gs_graph/test_user.rb

@@ -0,0 +1,24 @@
+module GSGraph
+  class TestUser < User
+    attr_accessor :login_url, :password
+
+    def initialize(identifier, attributes = {})
+      super
+      @login_url = attributes[:login_url]
+      @password = attributes[:password]
+    end
+
+    def friend!(test_user)
+      post(
+        :access_token => self.access_token,
+        :connection => :friends,
+        :connection_scope => test_user.identifier
+      )
+      test_user.send :post, {
+        :access_token => test_user.access_token,
+        :connection => :friends,
+        :connection_scope => self.identifier
+      }
+    end
+  end
+end

data/lib/gs_graph/thread.rb

@@ -0,0 +1,71 @@
+module GSGraph
+  class Thread < Node
+    include Connections::Messages
+    include Connections::Participants
+    include Connections::FormerParticipants
+    include Connections::Senders
+    include Connections::Tags
+
+    attr_accessor :snippet, :message_count, :unread_count, :updated_time
+
+    def initialize(identifier, attributes = {})
+      super
+      @snippet = attributes[:snippet]
+      @message_count = attributes[:message_count]
+      @unread_count = attributes[:unread_count].to_i
+      if attributes[:updated_time]
+        @updated_time = Time.parse(attributes[:updated_time]).utc
+      end
+
+      # cached connection
+      cache_collections attributes, :messages, :participants, :former_participants, :senders, :tags
+    end
+
+    # NOTE:
+    #  Facebook is under transision of their message platform.
+    #  This is current thread model in Graph API.
+    #  In near future, this will be replaced with GSGraph::Thread model.
+    class BeforeTransition < Node
+      attr_accessor :subject, :message, :from, :to, :unread, :unseen, :updated_time
+
+      def initialize(identifier, attributes = {})
+        super
+        @subject = attributes[:subject]
+        @message = attributes[:message]
+        if (from = attributes[:from])
+          @from = if from[:start_time]
+            Event.new(from[:id], from)
+          else
+            User.new(from[:id], from)
+          end
+        end
+        @to = []
+        Collection.new(attributes[:to]).each do |to|
+          @to << User.new(to[:id], to)
+        end
+        if attributes[:updated_time]
+          @created_time = Time.parse(attributes[:updated_time]).utc
+        end
+        @unread = attributes[:unread] == 1
+        @unseen = attributes[:unseen] == 1
+
+        # cached connection
+        cache_collection attributes, :comments
+      end
+
+      # NOTE:
+      #  This is a connection named "comments" but returns "messages" and different from normal "comments" connection.
+      #  Therefore I put this connection here not under GSGraph::Connections.
+      def messages(options = {})
+        messages = self.connection(:comments, options)
+        messages.map! do |message|
+          Message.new(message[:id], message.merge(
+            :access_token => options[:access_token] || self.access_token
+          ))
+        end
+      end
+      # for pagination, a method which name is same as the connection name is needed.
+      alias_method :comments, :messages
+    end
+  end
+end

data/lib/gs_graph/user.rb

@@ -0,0 +1,153 @@
+module GSGraph
+  class User < Node
+    include Connections::Accounts
+    include Connections::AdAccounts
+    include Connections::Activities
+    include Connections::Albums
+    include Connections::AppRequests
+    include Connections::Books
+    include Connections::Checkins
+    include Connections::Events
+    include Connections::Feed
+    include Connections::FriendLists
+    include Connections::FriendRequests
+    include Connections::Friends
+    include Connections::Family
+    include Connections::Games
+    include Connections::Groups
+    include Connections::Home
+    include Connections::Inbox
+    include Connections::Interests
+    include Connections::Likes
+    include Connections::Links
+    include Connections::Movies
+    include Connections::Music
+    include Connections::MutualFriends
+    include Connections::Notes
+    include Connections::Notifications
+    include Connections::Outbox
+    include Connections::Payments
+    include Connections::Permissions
+    include Connections::Photos
+    include Connections::Picture
+    include Connections::Pokes
+    include Connections::Posts
+    include Connections::Questions
+    include Connections::Scores
+    include Connections::Statuses
+    include Connections::SubscribedTo
+    include Connections::Subscribers
+    include Connections::Tagged
+    include Connections::Television
+    include Connections::Threads
+    include Connections::UserAchievements
+    include Connections::UserLikes
+    include Connections::Videos
+    include OpenGraph::UserContext
+    extend Searchable
+
+    @@attributes = {
+      :raw => [
+        :name, :first_name, :middle_name, :last_name, :gender,
+        :locale, :link, :username, :third_party_id, :timezone,
+        :verified, :about, :bio, :email, :political, :quotes,
+        :relationship_status, :relationship, :video_upload_limits,
+        :website, :mobile_phone, :installed, :rsvp_status,
+        :security_settings, :currency, :religion
+      ],
+      :custom => [
+        :languages, :like_count, :updated_time,
+        :birthday, :education, :hometown, :interested_in, :location,
+        :favorite_teams, :age_range, :significant_other,
+        :work, :devices, :sports, :favorite_athletes, :inspirational_people,
+        :address, :mobile_phone
+      ]
+    }
+
+    attr_accessor *@@attributes.values.flatten
+
+    def initialize(identifier, attributes = {})
+      super
+      @@attributes[:raw].each do |key|
+        self.send :"#{key}=", attributes[key]
+      end
+      @languages = []
+      if attributes[:languages]
+        attributes[:languages].each do |language|
+          @languages << Page.new(language[:id], language)
+        end
+      end
+      if attributes[:updated_time]
+        @updated_time = Time.parse(attributes[:updated_time]).utc
+      end
+      if attributes[:birthday]
+        month, day, year = attributes[:birthday].split('/').collect(&:to_i)
+        year ||= 0
+        @birthday = Date.new(year, month, day)
+      end
+      @education = []
+      if attributes[:education]
+        attributes[:education].each do |education|
+          @education << Education.new(education)
+        end
+      end
+      if (hometown = attributes[:hometown])
+        @hometown = Page.new(hometown[:id], hometown)
+      end
+      @interested_in = Array(attributes[:interested_in])
+      if (location = attributes[:location])
+        @location = Page.new(location[:id], location)
+      end
+      @favorite_teams = []
+      if attributes[:favorite_teams]
+        attributes[:favorite_teams].each do |favorite_team|
+          @favorite_teams << Page.new(favorite_team[:id], favorite_team)
+        end
+      end
+      if (significant_other = attributes[:significant_other])
+        @significant_other = User.new(significant_other[:id], significant_other)
+      end
+      @work = []
+      if attributes[:work]
+        attributes[:work].each do |work|
+          @work << Work.new(work)
+        end
+      end
+      @devices = []
+      if attributes[:devices]
+        attributes[:devices].each do |device|
+          @devices << Device.new(device)
+        end
+      end
+      @security_settings = attributes[:security_settings]
+      if attributes[:age_range]
+        @age_range = AgeRange.new(attributes[:age_range])
+      end
+      @sports = []
+      if (sports = attributes[:sports])
+        sports.each do |sport|
+          @sports << Page.new(sport[:id], sport)
+        end
+      end
+      @favorite_athletes = []
+      if attributes[:favorite_athletes]
+        attributes[:favorite_athletes].each do |favorite_athlete|
+          @favorite_athletes << Page.new(favorite_athlete[:id], favorite_athlete)
+        end
+      end
+      @inspirational_people = []
+      if attributes[:inspirational_people]
+        attributes[:inspirational_people].each do |inspirational_person|
+          @inspirational_people << Page.new(inspirational_person[:id], inspirational_person)
+        end
+      end
+      if attributes[:address]
+        @address = Venue.new(attributes[:address])
+      end
+    end
+
+    def self.me(access_token)
+      new('me', :access_token => access_token)
+    end
+  end
+end