doesopengraph 0.1.1 → 0.2.0

data/lib/doesopengraph/graph_api.rb

@@ -6,6 +6,14 @@
 #
 
 module DoesOpenGraph
+  
+  class OpenGraphException < Exception; end
+  class IncapableOfUpdateMethods < OpenGraphException; end
+  class InvalidRequestMethod < OpenGraphException; end
+  class InvalidResponseFromFacebook < OpenGraphException; end
+
+  
+  
   class GraphAPI
 
     require "typhoeus"
@@ -15,99 +23,70 @@ module DoesOpenGraph
     HTTP_GRAPH_ENDPOINT = "http://graph.facebook.com/"
     HTTPS_GRAPH_ENDPOINT = "https://graph.facebook.com/"
     
-    attr_reader :access_token
+    attr_reader :access_token, :history
   
     def initialize(acctok=nil)
       @access_token = acctok
+      @history = Array.new
     end
-  
-  
+    
+    def renew(acctok)
+      @access_token = acctok
+    end
+    
+    
     def node(id, connection=nil, params={})
-      # Inject an access_token if we plan to make an authorized request:
-      params[:access_token] = @access_token if @access_token
-      
-      # Stringify tokens:
-      id = id.to_s
-      connection = connection.to_s unless connection.nil?
-
-      # Smoosh the URL components together:
-      base = @access_token.nil? ? HTTP_GRAPH_ENDPOINT : HTTPS_GRAPH_ENDPOINT
-      path = connection.nil? ? id : File.join(id, connection)
-      href = File.join(base, path)
-      
-      # Make a request and parse JSON result:
-      begin
-        response = Typhoeus::Request.get(href, :params=>params)
-        data = JSON.parse(response.body)
-        return GraphNode.new(data, self)
-      rescue JSON::ParserError => jsone
-        raise "Invalid JSON or poorly formed JSON returned for #{path}" and return nil
-      end
+      path = connection.nil? ? id.to_s : File.join(id.to_s, connection.to_s)
+      return request(:get, path, params)
     end
     alias_method :get, :node
     
   
     def update(id, connection, params={})
-      # Inject the access token if we have it and err if we don't
       return nil unless @access_token
-      params[:access_token] = @access_token
-      
-      # Smoosh the URL components together:
-      base = HTTPS_GRAPH_ENDPOINT
-      path = File.join(id, connection)
-      href = File.join(base, path)
-      
-      # Make our POST request and check the results:
-      begin
-        response = Typhoeus::Request.post(href, :params=>params)
-        data = JSON.parse(response.body)
-        return GraphResponse.new(data)
-      rescue JSON::ParserError => jsone
-        # A JSON.parse on "true" triggers an error, so let's build it straight from body:
-        return GraphResponse.new(response.body)
-      end      
+      path = connection.nil? ? id.to_s : File.join(id.to_s, connection.to_s)
+      return request(:post, path, params)
     end
     alias_method :post, :update
     
     
     def delete(id, connection=nil)
-      # Inject the access token if we have it and err if we don't
       return nil unless @access_token
-      params = Hash.new and params[:access_token] = @access_token
-      
-      # Smoosh the URL components together:
-      base = HTTPS_GRAPH_ENDPOINT
-      path = connection.nil? ? id : File.join(id, connection)
-      href = File.join(base, path)
-      
-      # Make our DELETE request and return the results:
-      begin
-        response = Typhoeus::Request.delete(href, :params=>params)
-        data = JSON.parse(response.body)
-        return GraphResponse.new(data)
-      rescue JSON::ParserError => jsone
-        # A JSON.parse on "true" triggers an error, so let's build it straight from body:
-        return GraphResponse.new(response.body)
-      end
+      path = connection.nil? ? id.to_s : File.join(id.to_s, connection.to_s)
+      return request(:delete, path)
     end
     
-    
+
     def search(query, type, params={})
-      # Inject the access token if we have it and err if we don't
       return nil unless @access_token
-      params[:access_token] = @access_token
-      
-      # Build the search query and its target:
-      params[:q] = query
-      params[:type] = type
-      href = File.join(HTTPS_GRAPH_ENDPOINT, "search")
-      
-      # Make the request:
-      response = Typhoeus::Request.get(href, :params=>params)
-      data = JSON.parse(response.body)
-      return GraphResponse.new(data)
+      params[:q] = query.to_s
+      params[:type] = type.to_s      
+      request(:get, "search", params)
+    end
+    
+    
+    def num_requests
+      @history.length
     end
     
+    def previous_request
+      @history.last
+    end
+    
+    def repeat
+      previous_request.request()
+    end    
+  
+    
+    
+    private
+    
+    
+    def request(method, path, params={})
+      api_request = GraphRequest.new(self, method, path, params)
+      @history << api_request
+      return api_request.request()
+    end
   
 
   end # GraphAPI    

data/lib/doesopengraph/graph_request.rb

@@ -0,0 +1,59 @@
+# AWEXOME LABS
+# DoesOpenGraph
+#
+# GraphRequest - A request to the OpenGraph API.
+#
+
+module DoesOpenGraph
+  class GraphRequest
+
+    attr_reader :api, :method, :path, :params, :href
+    
+    # Build a Request object from its component parts
+    def initialize(api, method, path, params={})
+      @api = api
+      @method = method
+      @path = path
+      @params = params
+      @href = nil
+    end
+    
+    
+    # Perform the request
+    def request
+      base = @api.access_token ? GraphAPI::HTTPS_GRAPH_ENDPOINT : GraphAPI::HTTP_GRAPH_ENDPOINT
+      @href = File.join(base, @path)
+      
+      if !%w(get post delete).include?(@method.to_s)
+        raise InvalidRequestMethod.new("Invalid HTTP method #{@method} passed to request") and return nil
+      end
+      
+      params[:access_token] = @api.access_token if @api.access_token
+      
+      begin
+        response = Typhoeus::Request.send(@method, @href, :params=>@params)
+        puts "RESPONSE RECEIVED FROM FACEBOOK ON REQUEST TO PATH #{@path}:\n#{response.body}\n\n"
+        
+        return GraphResponse.new(response.body, self)
+        
+        # TODO: Parse known error responses from Facebook, such as:
+        # TODO: {"error":{"message":"Unknown path components: \/status","type":"OAuthException"}}
+        
+      rescue Exception => e
+        raise OpenGraphException.new("Error in OpenGraph response: #{e}") and return nil
+      end
+    end
+    
+    
+    # Repeat the same request with optionally different parameters
+    def repeat(params={})
+      @params.merge(params)
+      request()
+    end
+  
+
+  end # GraphRequest
+end # DoesOpenGraph
+      
+
+

data/lib/doesopengraph/graph_response.rb

@@ -7,17 +7,131 @@
 module DoesOpenGraph
   class GraphResponse
 
-    attr_reader :content, :api
+    attr_reader :content, :object, :request
 
-    # Build a Response object from request content and store the api
-    def initialize(content, api=nil)
-      @content = content.is_a?(Hash) ? content : Hash.new
-      @api = api
+    # Build a Response object from raw JSON HTTP response
+    def initialize(raw_content, request=nil)
+      @request = request
+      self.update(raw_content)
     end
-      
-    # Use secret patching to provide accessors to connections within node
+    
+    # Update the stored content of this node and parse
+    def update (raw_content)
+      @content = raw_content
+      self.parse
+    end
+    
+    # Parse the stored raw content and translate into a usable object
+    def parse
+      begin
+        parsed_content = JSON.parse(@content)
+        @object = parsed_content.is_a?(Hash) ? Hashie::Mash.new(parsed_content) : parsed_content
+    
+      rescue JSON::ParserError => parse_error
+        @object = nil
+        if parse_error.message.match("unexpected token")
+          @object = true if @content == "true"
+          @object = false if @content == "false"
+        end
+        if @object.nil?
+          raise InvalidResponseFromFacebook.new("Invalid JSON returned from Facebook: #{parse_error.message}")
+        end
+      end
+    end
+
+    
+    # Update this node from theFetch an updated view of this node
+    def reload
+      raise IncapableOfUpdateMethods.new("Cannot update content without stored request") if request.nil?
+      up = request.request()
+      @content = up.content
+      @object = up.object
+      return self
+    end
+    
+    # Is this response an error?
+    def error?
+      keys.include?(:error)
+    end
+    
+    # What is the error return from Facebook in this response?
+    def error_message
+      @object.error ? @object.error.message : nil
+    end
+    
+    # Introspect on the connections available to this node
+    def introspect
+      raise IncapableOfUpdateMethods.new("Cannot update content without stored request") if request.nil?
+      request.repeat(:metadata=>1)
+    end
+    
+    # Get a connection of this node
+    def get(connection, params={})
+      raise IncapableOfUpdateMethods.new("Cannot update content without stored request") if request.nil?
+      request.api.get(object.id, connection, params)
+    end
+    
+    # Post to a connection of this node
+    def post(connection, params={})
+      raise IncapableOfUpdateMethods.new("Cannot update content without stored request") if request.nil?
+      request.api.post(object.id, connection, params)
+    end
+    
+    
+    # Load the next page of the response if paging is available
+    def next_page; page("next"); end
+    def previous_page; page("previous"); end
+        
+    # Load a specific page of results if available:
+    def page(pg, pp=25)
+      if pg.is_a?(String)
+        if object.paging 
+          if page_url = object.paging[pg]
+            data = page_url.match(/\?(\S+)/)[1].split("&").collect{|pair| pair.split("=")}.select{|k,v| k!="access_token"}
+            params = Hash.new
+            data.each {|k,v| params[k.to_sym] = v}
+            return request.repeat(params)
+          end
+        end
+      else
+        return request.repeat(:limit=>pp, :offset=>(pg-1)*pp)
+      end
+      return nil
+    end
+    
+    
+    # Delete this node from the graph
+    def delete
+      raise IncapableOfUpdateMethods.new("Cannot update content without stored request") if request.nil?
+      request.api.delete(object.id)
+    end
+    
+    # Like this node, if supported
+    def like
+      raise IncapableOfUpdateMethods.new("Cannot update content without stored request") if request.nil?
+      request.api.post(object.id, "likes")
+    end
+    
+    # Unlike this node, if supported
+    def unlike
+      raise IncapableOfUpdateMethods.new("Cannot update content without stored request") if request.nil?
+      request.api.delete(object.id, "likes")
+    end
+
+    
+    # What keys are available on this OpenGraph node?
+    def keys
+      object.is_a?(Hash) ? object.keys.collect{|k|k.to_sym} : Array.new
+    end
+    
+    # Include our return top-level keys in the methods list:
+    def methods()
+      keys + super()
+    end
+    
+    # Use method-missing to provide top-level keys of response Hash as methods
     def method_missing(m, *args, &block)
-      content.include?(m.to_s) ? content[m.to_s] : nil
+      object.include?(m.to_s) ? object.send(m.to_s) : super(m, args)
     end
 
   end # GraphResponse    

data/lib/doesopengraph.rb

@@ -3,10 +3,17 @@
 #
 # DoesOpenGraph - Module definition and loader
 
+require 'hashie'
+
 require "doesopengraph"
 require "doesopengraph/graph_api"
+require "doesopengraph/graph_request"
 require "doesopengraph/graph_response"
-require "doesopengraph/graph_node"
 
 module DoesOpenGraph
+  
+  def self.version
+    Gem.loaded_specs["doesopengraph"].version.to_s
+  end
+  
 end

metadata

@@ -2,7 +2,7 @@
 name: doesopengraph
 version: !ruby/object:Gem::Version 
   prerelease: 
-  version: 0.1.1
+  version: 0.2.0
 platform: ruby
 authors: 
 - mccolin
@@ -10,7 +10,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-03-25 00:00:00 -04:00
+date: 2011-09-23 00:00:00 -04:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -57,7 +57,7 @@ dependencies:
   type: :runtime
   prerelease: false
   version_requirements: *id004
-description: The Awexome Labs library for accessing and manipulating the Facebook OpenGraph
+description: Content-type-agnostic library for accessing and manipulating the Facebook OpenGraph with all major methods and search
 email: info@awexomelabs.com
 executables: []
 
@@ -69,7 +69,7 @@ extra_rdoc_files:
 files: 
 - lib/doesopengraph.rb
 - lib/doesopengraph/graph_api.rb
-- lib/doesopengraph/graph_node.rb
+- lib/doesopengraph/graph_request.rb
 - lib/doesopengraph/graph_response.rb
 - LICENSE
 - README.rdoc

data/lib/doesopengraph/graph_node.rb

@@ -1,42 +0,0 @@
-# AWEXOME LABS
-# DoesOpenGraph
-#
-# GraphNode - An instance of an item on the open graph
-#
-
-module DoesOpenGraph
-  class GraphNode < GraphResponse
-
-    # Fetch an updated view of this node
-    def reload
-      up = api.node(self.id)
-      @content = up.content
-      self
-    end
-    
-    # Introspect on the connections available to this node
-    def introspect
-      api.node(self.id, nil, :metadata=>1)
-    end
-    
-    # Delete this node from the graph
-    def delete
-      api.delete(self.id)
-    end
-    
-    # Like this node, if supported
-    def like
-      api.post(self.id, "likes")
-    end
-    
-    # Unlike this node, if supported
-    def unlike
-      api.delete(self.id, "likes")
-    end
-    
-
-  end # GraphNode    
-end # DoesOpenGraph
-      
-
-