koala 1.3.0rc1 → 1.3.0rc2

data/lib/koala/graph_api.rb

@@ -1,289 +0,0 @@
-module Koala
-  module Facebook
-    GRAPH_SERVER = "graph.facebook.com"
-
-    module GraphAPIMethods
-      # A client for the Facebook Graph API.
-      #
-      # See http://github.com/arsduo/koala for Ruby/Koala documentation
-      # and http://developers.facebook.com/docs/api for Facebook API documentation
-      #
-      # The Graph API is made up of the objects in Facebook (e.g., people, pages,
-      # events, photos) and the connections between them (e.g., friends,
-      # photo tags, and event RSVPs). This client provides access to those
-      # primitive types in a generic way. For example, given an OAuth access
-      # token, this will fetch the profile of the active user and the list
-      # of the user's friends:
-      #
-      #    graph = Koala::Facebook::API.new(access_token)
-      #    user = graph.get_object("me")
-      #    friends = graph.get_connections(user["id"], "friends")
-      #
-      # You can see a list of all of the objects and connections supported
-      # by the API at http://developers.facebook.com/docs/reference/api/.
-      #
-      # You can obtain an access token via OAuth or by using the Facebook
-      # JavaScript SDK. See the Koala and Facebook documentation for more information.
-      #
-      # If you are using the JavaScript SDK, you can use the
-      # Koala::Facebook::OAuth.get_user_from_cookie() method below to get the OAuth access token
-      # for the active user from the cookie saved by the SDK.
-
-      # Objects
-
-      def get_object(id, args = {}, options = {})
-        # Fetchs the given object from the graph.
-        graph_call(id, args, "get", options)
-      end
-
-      def get_objects(ids, args = {}, options = {})
-        # Fetchs all of the given objects from the graph.
-        # If any of the IDs are invalid, they'll raise an exception.
-        return [] if ids.empty?
-        graph_call("", args.merge("ids" => ids.respond_to?(:join) ? ids.join(",") : ids), "get", options)
-      end
-
-      def put_object(parent_object, connection_name, args = {}, options = {})
-        # Writes the given object to the graph, connected to the given parent.
-        # See http://developers.facebook.com/docs/api#publishing for all of
-        # the supported writeable objects.
-        #
-        # For example,
-        #     graph.put_object("me", "feed", :message => "Hello, world")
-        # writes "Hello, world" to the active user's wall.
-        #
-        # Most write operations require extended permissions. For example,
-        # publishing wall posts requires the "publish_stream" permission. See
-        # http://developers.facebook.com/docs/authentication/ for details about
-        # extended permissions.
-
-        raise APIError.new({"type" => "KoalaMissingAccessToken", "message" => "Write operations require an access token"}) unless @access_token
-        graph_call("#{parent_object}/#{connection_name}", args, "post", options)
-      end
-
-      def delete_object(id, options = {})
-        # Deletes the object with the given ID from the graph.
-        raise APIError.new({"type" => "KoalaMissingAccessToken", "message" => "Delete requires an access token"}) unless @access_token
-        graph_call(id, {}, "delete", options)
-      end
-
-      # Connections
-
-      def get_connections(id, connection_name, args = {}, options = {})
-        # Fetchs the connections for given object.
-        graph_call("#{id}/#{connection_name}", args, "get", options)
-      end
-
-      def put_connections(id, connection_name, args = {}, options = {})
-        # Posts a certain connection
-        raise APIError.new({"type" => "KoalaMissingAccessToken", "message" => "Write operations require an access token"}) unless @access_token
-        graph_call("#{id}/#{connection_name}", args, "post", options)
-      end
-
-      def delete_connections(id, connection_name, args = {}, options = {})
-        # Deletes a given connection
-        raise APIError.new({"type" => "KoalaMissingAccessToken", "message" => "Delete requires an access token"}) unless @access_token
-        graph_call("#{id}/#{connection_name}", args, "delete", options)
-      end
-
-      # Media (photos and videos)
-      # to delete photos or videos, use delete_object(object_id)
-      # note: you'll need the user_photos or user_videos permissions to actually access media after upload
-
-      def get_picture(object, args = {}, options = {})
-        # Gets a picture object, returning the URL (which Facebook sends as a header)
-        graph_call("#{object}/picture", args, "get", options.merge(:http_component => :headers)) do |result|
-          result["Location"]
-        end
-      end
-
-      # Can be called in multiple ways:
-      #
-      #   put_picture(file, [content_type], ...)
-      #   put_picture(path_to_file, [content_type], ...)
-      #   put_picture(picture_url, ...)
-      #
-      # You can pass in uploaded files directly from Rails or Sinatra.
-      # (See lib/koala/uploadable_io.rb for supported frameworks)
-      #
-      # Optional parameters can be added to the end of the argument list:
-      # - args:       a hash of request parameters (default: {})
-      # - target_id:  ID of the target where to post the picture (default: "me")
-      # - options:    a hash of http options passed to the HTTPService module
-      #
-      #   put_picture(file, content_type, {:message => "Message"}, 01234560)
-      #   put_picture(params[:file], {:message => "Message"})
-      #
-      #   (Note that with URLs, there's no optional content type field)
-      #   put_picture(picture_url, {:message => "Message"}, my_page_id)
-
-      def put_picture(*picture_args)
-        put_object(*parse_media_args(picture_args, "photos"))
-      end
-
-      def put_video(*video_args)
-        args = parse_media_args(video_args, "videos")
-        args.last[:video] = true
-        put_object(*args)
-      end
-
-      # Wall posts
-      # To get wall posts, use get_connections(user, "feed")
-      # To delete a wall post, just use delete_object(post_id)
-
-      def put_wall_post(message, attachment = {}, profile_id = "me", options = {})
-        # attachment is a hash describing the wall post
-        # (see X for more details)
-        # For instance,
-        #
-        #     {"name" => "Link name"
-        #      "link" => "http://www.example.com/",
-        #      "caption" => "{*actor*} posted a new review",
-        #      "description" => "This is a longer description of the attachment",
-        #      "picture" => "http://www.example.com/thumbnail.jpg"}
-
-        self.put_object(profile_id, "feed", attachment.merge({:message => message}), options)
-      end
-
-      # Comments
-      # to delete comments, use delete_object(comment_id)
-      # to get comments, use get_connections(object, "likes")
-
-      def put_comment(object_id, message, options = {})
-        # Writes the given comment on the given post.
-        self.put_object(object_id, "comments", {:message => message}, options)
-      end
-
-      # Likes
-      # to get likes, use get_connections(user, "likes")
-
-      def put_like(object_id, options = {})
-        # Likes the given post.
-        self.put_object(object_id, "likes", {}, options)
-      end
-
-      def delete_like(object_id, options = {})
-        # Unlikes a given object for the logged-in user
-        raise APIError.new({"type" => "KoalaMissingAccessToken", "message" => "Unliking requires an access token"}) unless @access_token
-        graph_call("#{object_id}/likes", {}, "delete", options)
-      end
-
-      # Search
-
-      def search(search_terms, args = {}, options = {})
-        args.merge!({:q => search_terms}) unless search_terms.nil?
-        graph_call("search", args, "get", options)
-      end
-
-      # Convenience Methods
-      #
-      # in general, we're trying to avoid adding convenience methods to Koala
-      # except to support cases where the Facebook API requires non-standard input
-      # such as JSON-encoding arguments, posts directly to objects, etc.
-      
-      def fql_query(query, args = {}, options = {})
-        get_object("fql", args.merge(:q => query), options)
-      end
-
-      def fql_multiquery(queries = {}, args = {}, options = {})
-        if results = get_object("fql", args.merge(:q => MultiJson.encode(queries)), options)
-          # simplify the multiquery result format
-          results.inject({}) {|outcome, data| outcome[data["name"]] = data["fql_result_set"]; outcome}
-        end
-      end
-      
-      def get_page_access_token(object_id, args = {}, options = {})
-        result = get_object(object_id, args.merge(:fields => "access_token"), options) do
-          result ? result["access_token"] : nil
-        end
-      end
-
-      def get_comments_for_urls(urls = [], args = {}, options = {})
-        # Fetchs the comments for given URLs (array or comma-separated string)
-        # see https://developers.facebook.com/blog/post/490
-        return [] if urls.empty?
-        args.merge!(:ids => urls.respond_to?(:join) ? urls.join(",") : urls)
-        get_object("comments", args, options)
-      end
-      
-      def set_app_restrictions(app_id, restrictions_hash, args = {}, options = {})
-        graph_call(app_id, args.merge(:restrictions => MultiJson.encode(restrictions_hash)), "post", options)
-      end
-
-      # GraphCollection support
-      def get_page(params)
-        # Pages through a set of results stored in a GraphCollection
-        # Used for connections and search results
-        graph_call(*params)
-      end
-
-      # Batch API
-      def batch(http_options = {}, &block)
-        batch_client = GraphBatchAPI.new(access_token, self)
-        if block
-          yield batch_client
-          batch_client.execute(http_options)
-        else
-          batch_client
-        end
-      end
-      
-      # Direct access to the Facebook API
-      # see any of the above methods for example invocations
-      def graph_call(path, args = {}, verb = "get", options = {}, &post_processing)
-        result = api(path, args, verb, options) do |response|
-          error = check_response(response)
-          raise error if error
-        end
-
-        # turn this into a GraphCollection if it's pageable
-        result = GraphCollection.evaluate(result, self)
-        
-        # now process as appropriate for the given call (get picture header, etc.)
-        post_processing ? post_processing.call(result) : result
-      end
-
-      private
-      
-      def check_response(response)
-        # check for Graph API-specific errors
-        # this returns an error, which is immediately raised (non-batch)
-        # or added to the list of batch results (batch)
-        if response.is_a?(Hash) && error_details = response["error"]
-          APIError.new(error_details)
-        end
-      end
-
-      def parse_media_args(media_args, method)
-        # photo and video uploads can accept different types of arguments (see above)
-        # so here, we parse the arguments into a form directly usable in put_object
-        raise KoalaError.new("Wrong number of arguments for put_#{method == "photos" ? "picture" : "video"}") unless media_args.size.between?(1, 5)
-
-        args_offset = media_args[1].kind_of?(Hash) || media_args.size == 1 ? 0 : 1
-
-        args      = media_args[1 + args_offset] || {}
-        target_id = media_args[2 + args_offset] || "me"
-        options   = media_args[3 + args_offset] || {}
-
-        if url?(media_args.first)
-          # If media_args is a URL, we can upload without UploadableIO
-          args.merge!(:url => media_args.first)
-        else
-          args["source"] = Koala::UploadableIO.new(*media_args.slice(0, 1 + args_offset))
-        end
-
-        [target_id, method, args, options]
-      end
-
-      def url?(data)
-        return false unless data.is_a? String
-        begin
-          uri = URI.parse(data)
-          %w( http https ).include?(uri.scheme)
-        rescue URI::BadURIError
-          false
-        end
-      end
-    end
-  end
-end

data/lib/koala/graph_collection.rb

@@ -1,63 +0,0 @@
-module Koala
-  module Facebook
-    class GraphCollection < Array
-      # This class is a light wrapper for collections returned
-      # from the Graph API.
-      #
-      # It extends Array to allow direct access to the data colleciton
-      # which should allow it to drop in seamlessly.
-      #
-      # It also allows access to paging information and the
-      # ability to get the next/previous page in the collection
-      # by calling next_page or previous_page.
-      attr_reader :paging, :api, :raw_response
-
-      def self.evaluate(response, api)
-        # turn the response into a GraphCollection if it's pageable; if not, return the original response
-        response.is_a?(Hash) && response["data"].is_a?(Array) ? self.new(response, api) : response
-      end
-    
-      def initialize(response, api)
-        super response["data"]
-        @paging = response["paging"]
-        @raw_response = response
-        @api = api
-      end
-
-      # defines methods for NEXT and PREVIOUS pages
-      %w{next previous}.each do |this|
-
-        # def next_page
-        # def previous_page
-        define_method "#{this.to_sym}_page" do
-          base, args = send("#{this}_page_params")
-          base ? @api.get_page([base, args]) : nil
-        end
-
-        # def next_page_params
-        # def previous_page_params
-        define_method "#{this.to_sym}_page_params" do
-          return nil unless @paging and @paging[this]
-          parse_page_url(@paging[this])
-        end
-      end
-      
-      def parse_page_url(url)
-        GraphCollection.parse_page_url(url)
-      end
-
-      def self.parse_page_url(url)
-        match = url.match(/.com\/(.*)\?(.*)/)
-        base = match[1]
-        args = match[2]
-        params = CGI.parse(args)
-        new_params = {}
-        params.each_pair do |key,value|
-          new_params[key] = value.join ","
-        end
-        [base,new_params]
-      end
-
-    end
-  end
-end

data/lib/koala/multipart_request.rb

@@ -1,35 +0,0 @@
-require 'faraday'
-
-module Koala
-  class MultipartRequest < Faraday::Request::Multipart
-    # Facebook expects nested parameters to be passed in a certain way
-    # Based on our testing (https://github.com/arsduo/koala/issues/125),
-    # Faraday needs two changes to make that work:
-    # 1) [] need to be escaped (e.g. params[foo]=bar ==> params%5Bfoo%5D=bar)
-    # 2) such messages need to be multipart-encoded
-    
-    self.mime_type = 'multipart/form-data'.freeze
-    
-    def process_request?(env)
-      # if the request values contain any hashes or arrays, multipart it
-      super || !!(env[:body].respond_to?(:values) && env[:body].values.find {|v| v.is_a?(Hash) || v.is_a?(Array)})
-    end   
-    
-    
-    def process_params(params, prefix = nil, pieces = nil, &block)
-      params.inject(pieces || []) do |all, (key, value)|
-        key = "#{prefix}%5B#{key}%5D" if prefix
-
-        case value
-        when Array
-          values = value.inject([]) { |a,v| a << [nil, v] }
-          process_params(values, key, all, &block)
-        when Hash
-          process_params(value, key, all, &block)
-        else
-          all << block.call(key, value)
-        end
-      end
-    end
-  end
-end

data/lib/koala/uploadable_io.rb

@@ -1,181 +0,0 @@
-require "net/http/post/multipart"
-
-module Koala
-  class UploadableIO
-    attr_reader :io_or_path, :content_type, :filename
-
-    def initialize(io_or_path_or_mixed, content_type = nil, filename = nil)
-      # see if we got the right inputs
-      parse_init_mixed_param io_or_path_or_mixed, content_type
-
-      # filename is used in the Ads API
-      # if it's provided, take precedence over the detected filename
-      # otherwise, fall back to a dummy name
-      @filename = filename || @filename || "koala-io-file.dum"
-
-      raise KoalaError.new("Invalid arguments to initialize an UploadableIO") unless @io_or_path
-      raise KoalaError.new("Unable to determine MIME type for UploadableIO") if !@content_type
-    end
-
-    def to_upload_io
-      UploadIO.new(@io_or_path, @content_type, @filename)
-    end
-
-    def to_file
-      @io_or_path.is_a?(String) ? File.open(@io_or_path) : @io_or_path
-    end
-
-    def self.binary_content?(content)
-      content.is_a?(UploadableIO) || DETECTION_STRATEGIES.detect {|method| send(method, content)}
-    end
-
-    private
-    DETECTION_STRATEGIES = [
-      :sinatra_param?,
-      :rails_3_param?,
-      :file_param?
-    ]
-
-    PARSE_STRATEGIES = [
-      :parse_rails_3_param,
-      :parse_sinatra_param,
-      :parse_file_object,
-      :parse_string_path,
-      :parse_io
-    ]
-
-    def parse_init_mixed_param(mixed, content_type = nil)
-      PARSE_STRATEGIES.each do |method|
-        send(method, mixed, content_type)
-        return if @io_or_path && @content_type
-      end
-    end
-
-    # Expects a parameter of type ActionDispatch::Http::UploadedFile
-    def self.rails_3_param?(uploaded_file)
-      uploaded_file.respond_to?(:content_type) and uploaded_file.respond_to?(:tempfile) and uploaded_file.tempfile.respond_to?(:path)
-    end
-
-    def parse_rails_3_param(uploaded_file, content_type = nil)
-      if UploadableIO.rails_3_param?(uploaded_file)
-        @io_or_path = uploaded_file.tempfile.path
-        @content_type = content_type || uploaded_file.content_type
-        @filename = uploaded_file.original_filename
-      end
-    end
-
-    # Expects a Sinatra hash of file info
-    def self.sinatra_param?(file_hash)
-      file_hash.kind_of?(Hash) and file_hash.has_key?(:type) and file_hash.has_key?(:tempfile)
-    end
-
-    def parse_sinatra_param(file_hash, content_type = nil)
-      if UploadableIO.sinatra_param?(file_hash)
-        @io_or_path = file_hash[:tempfile]
-        @content_type = content_type || file_hash[:type] || detect_mime_type(tempfile)
-        @filename = file_hash[:filename]
-      end
-    end
-
-    # takes a file object
-    def self.file_param?(file)
-      file.kind_of?(File)
-    end
-
-    def parse_file_object(file, content_type = nil)
-      if UploadableIO.file_param?(file)
-        @io_or_path = file
-        @content_type = content_type || detect_mime_type(file.path)
-        @filename = File.basename(file.path)
-      end
-    end
-
-    def parse_string_path(path, content_type = nil)
-      if path.kind_of?(String)
-        @io_or_path = path
-        @content_type = content_type || detect_mime_type(path)
-        @filename = File.basename(path)
-      end
-    end
-
-    def parse_io(io, content_type = nil)
-      if io.respond_to?(:read)
-        @io_or_path = io
-        @content_type = content_type
-      end
-    end
-
-    MIME_TYPE_STRATEGIES = [
-      :use_mime_module,
-      :use_simple_detection
-    ]
-
-    def detect_mime_type(filename)
-      if filename
-        MIME_TYPE_STRATEGIES.each do |method|
-          result = send(method, filename)
-          return result if result
-        end
-      end
-      nil # if we can't find anything
-    end
-
-    def use_mime_module(filename)
-      # if the user has installed mime/types, we can use that
-      # if not, rescue and return nil
-      begin
-        type = MIME::Types.type_for(filename).first
-        type ? type.to_s : nil
-      rescue
-        nil
-      end
-    end
-
-    def use_simple_detection(filename)
-      # very rudimentary extension analysis for images
-      # first, get the downcased extension, or an empty string if it doesn't exist
-      extension = ((filename.match(/\.([a-zA-Z0-9]+)$/) || [])[1] || "").downcase
-      case extension
-        when ""
-          nil
-        # images
-        when "jpg", "jpeg"
-          "image/jpeg"
-        when "png"
-          "image/png"
-        when "gif"
-          "image/gif"
-
-        # video
-        when "3g2"
-        	"video/3gpp2"
-        when "3gp", "3gpp"
-        	"video/3gpp"
-        when "asf"
-        	"video/x-ms-asf"
-        when "avi"
-        	"video/x-msvideo"
-        when "flv"
-        	"video/x-flv"
-        when "m4v"
-        	"video/x-m4v"
-        when "mkv"
-        	"video/x-matroska"
-        when "mod"
-        	"video/mod"
-        when "mov", "qt"
-        	"video/quicktime"
-        when "mp4", "mpeg4"
-        	"video/mp4"
-        when "mpe", "mpeg", "mpg", "tod", "vob"
-        	"video/mpeg"
-        when "nsv"
-        	"application/x-winamp"
-        when "ogm", "ogv"
-        	"video/ogg"
-        when "wmv"
-        	"video/x-ms-wmv"
-      end
-    end
-  end
-end