mjfreshyfresh-mini_fb 0.1.11

data/README.markdown

@@ -0,0 +1,49 @@
+MiniFB - the simple miniature facebook library
+==============================================
+
+MiniFB is a small, lightweight Ruby library for interacting with the [Facebook API](http://wiki.developers.facebook.com/index.php/API).
+
+Installation
+-------------
+
+We're using gemcutter so be sure to have gemcutter as a source, then: 
+
+    gem install mini_fb
+
+General Usage
+-------------
+
+The most general case is to use MiniFB.call method:
+
+    user_hash = MiniFB.call(FB_API_KEY, FB_SECRET, "Users.getInfo", "session_key"=>@session_key, "uids"=>@uid, "fields"=>User.all_fields)
+
+Which simply returns the parsed json response from Facebook.
+
+Some Higher Level Objects for Common Uses
+----------------------
+
+Get a MiniFB::Session:
+
+    @fb = MiniFB::Session.new(FB_API_KEY, FB_SECRET, @fb_session, @fb_uid)
+
+With the session, you can then get the user information for the session/uid.
+
+    user = @fb.user
+
+Then get info from the user:
+
+    first_name = user["first_name"]
+
+Or profile photos:
+
+    photos = user.profile_photos
+
+Or if you want other photos, try:
+
+    photos = @fb.photos("pids"=>[12343243,920382343,9208348])
+
+Support
+--------
+
+Join our Discussion Group at: http://groups.google.com/group/mini_fb
+

data/lib/mini_fb.rb

@@ -0,0 +1,279 @@
+require 'digest/md5'
+require 'erb'
+require 'json' unless defined? JSON
+
+module MiniFB
+
+    # Global constants
+    FB_URL = "http://api.facebook.com/restserver.php"
+    FB_API_VERSION = "1.0"
+
+    @@logging = false
+
+    def enable_logging
+        @@logging = true
+    end
+
+    def disable_logging
+        @@logging = false
+    end
+
+    class FaceBookError < StandardError
+        # Error that happens during a facebook call.
+        def initialize( error_code, error_msg )
+            super("Facebook error #{error_code}: #{error_msg}" )
+        end
+    end
+
+    class Session
+        attr_accessor :api_key, :secret_key, :session_key, :uid
+
+
+        def initialize(api_key, secret_key, session_key, uid)
+            @api_key = api_key
+            @secret_key = FaceBookSecret.new secret_key
+            @session_key = session_key
+            @uid = uid
+        end
+
+        # returns current user
+        def user
+            return @user unless @user.nil?
+            @user = User.new(MiniFB.call(@api_key, @secret_key, "Users.getInfo", "session_key"=>@session_key, "uids"=>@uid, "fields"=>User.all_fields)[0], self)
+            @user
+        end
+
+        def photos
+            Photos.new(self)
+        end
+
+
+        def call(method, params={})
+            return MiniFB.call(api_key, secret_key, method, params.update("session_key"=>session_key))
+        end
+
+
+    end
+    class User
+        FIELDS = [:uid, :status, :political, :pic_small, :name, :quotes, :is_app_user, :tv, :profile_update_time, :meeting_sex, :hs_info, :timezone, :relationship_status, :hometown_location, :about_me, :wall_count, :significant_other_id, :pic_big, :music, :work_history, :sex, :religion, :notes_count, :activities, :pic_square, :movies, :has_added_app, :education_history, :birthday, :birthday_date, :first_name, :meeting_for, :last_name, :interests, :current_location, :pic, :books, :affiliations, :locale, :profile_url, :proxied_email, :email_hashes, :allowed_restrictions, :pic_with_logo, :pic_big_with_logo, :pic_small_with_logo, :pic_square_with_logo]
+        STANDARD_FIELDS = [:uid, :first_name, :last_name, :name, :timezone, :birthday, :sex, :affiliations, :locale, :profile_url, :proxied_email]
+
+        def self.all_fields
+            FIELDS.join(",")
+        end
+
+        def self.standard_fields
+            STANDARD_FIELDS.join(",")
+        end
+
+        def initialize(fb_hash, session)
+            @fb_hash = fb_hash
+            @session = session
+        end
+
+        def [](key)
+            @fb_hash[key]
+        end
+
+        def uid
+            return self["uid"]
+        end
+
+        def profile_photos
+            @session.photos.get("uid"=>uid, "aid"=>profile_pic_album_id)
+        end
+
+        def profile_pic_album_id
+            merge_aid(-3, uid)
+        end
+
+        def merge_aid(aid, uid)
+            uid = uid.to_i
+            ret = (uid << 32) + (aid & 0xFFFFFFFF)
+#            puts 'merge_aid=' + ret.inspect
+            return ret
+        end
+    end
+
+    class Photos
+
+        def initialize(session)
+            @session = session
+        end
+
+        def get(params)
+            pids = params["pids"]
+            if !pids.nil? && pids.is_a?(Array)
+                pids = pids.join(",")
+                params["pids"] = pids
+            end
+            @session.call("photos.get", params)
+        end
+    end
+
+    BAD_JSON_METHODS = ["users.getLoggedInUser","auth.promoteSession"]
+
+    # Call facebook server with a method request. Most keyword arguments
+    # are passed directly to the server with a few exceptions.
+    # The 'sig' value will always be computed automatically.
+    # The 'v' version will be supplied automatically if needed.
+    # The 'call_id' defaults to True, which will generate a valid
+    # number. Otherwise it should be a valid number or False to disable.
+
+    # The default return is a parsed json object.
+    # Unless the 'format' and/or 'callback' arguments are given,
+    # in which case the raw text of the reply is returned. The string
+    # will always be returned, even during errors.
+
+    # If an error occurs, a FacebookError exception will be raised
+    # with the proper code and message.
+
+    # The secret argument should be an instance of FacebookSecret
+    # to hide value from simple introspection.
+    def MiniFB.call( api_key, secret, method, kwargs )
+
+        puts 'kwargs=' + kwargs.inspect
+
+        if secret.is_a? String
+            secret = FaceBookSecret.new(secret)
+        end
+
+        # Prepare arguments for call
+        call_id = kwargs.fetch("call_id", true)
+        if call_id == true then
+            kwargs["call_id"] = Time.now.tv_sec.to_s
+        else
+            kwargs.delete("call_id")
+        end
+
+        custom_format = kwargs.include?("format") or kwargs.include?("callback")
+        kwargs["format"] ||= "JSON"
+        kwargs["v"] ||= FB_API_VERSION
+        kwargs["api_key"]||= api_key
+        kwargs["method"] ||= method
+
+        # Hash with secret
+        arg_string = String.new
+        # todo: convert symbols to strings, symbols break the next line
+        kwargs.sort.each { |kv| arg_string << kv[0] << "=" << kv[1].to_s }
+        kwargs["sig"] = Digest::MD5.hexdigest( arg_string + secret.value.call )
+
+        # Call website with POST request
+        begin
+            response = Net::HTTP.post_form( URI.parse(FB_URL), kwargs )
+        rescue SocketError => err
+            raise IOError.new( "Cannot connect to the facebook server: " + err )
+        end
+
+        # Handle response
+        return response.body if custom_format
+
+        fb_method = kwargs["method"]
+        body = response.body
+
+        begin
+            data = JSON.parse( body )
+            puts 'response=' + data.inspect if @@logging
+            if data.include?( "error_msg" ) then
+                raise FaceBookError.new( data["error_code"] || 1, data["error_msg"] )
+            end
+
+        rescue JSON::ParserError => ex
+            if BAD_JSON_METHODS.include?(fb_method) # Little hack because this response isn't valid JSON
+                return body
+            else
+                raise ex
+            end
+        end
+        return data
+    end
+
+    # Returns true is signature is valid, false otherwise.
+    def MiniFB.verify_signature( secret, arguments )
+        signature = arguments.delete( "fb_sig" )
+        return false if signature.nil?
+
+        unsigned = Hash.new
+        signed = Hash.new
+
+        arguments.each do |k, v|
+            if k =~ /^fb_sig_(.*)/ then
+                signed[$1] = v
+            else
+                unsigned[k] = v
+            end
+        end
+
+        arg_string = String.new
+        signed.sort.each { |kv| arg_string << kv[0] << "=" << kv[1] }
+        if Digest::MD5.hexdigest( arg_string + secret ) == signature
+            return true
+        end
+        return false
+    end
+
+    # Returns the login/add app url for your application.
+    #
+    # options:
+    #    - :next => a relative next page to go to. relative to your facebook connect url or if :canvas is true, then relative to facebook app url
+    #    - :canvas => true/false - to say whether this is a canvas app or not
+    def self.login_url(api_key, options={})
+        login_url = "http://api.facebook.com/login.php?api_key=#{api_key}"
+        login_url << "&next=#{options[:next]}" if options[:next]
+        login_url << "&canvas" if options[:canvas]
+        login_url
+    end
+
+    # This function expects arguments as a hash, so
+    # it is agnostic to different POST handling variants in ruby.
+    #
+    # Validate the arguments received from facebook. This is usually
+    # sent for the iframe in Facebook's canvas. It is not necessary
+    # to use this on the auth_token and uid passed to callbacks like
+    # post-add and post-remove.
+#
+    # The arguments must be a mapping of to string keys and values
+    # or a string of http request data.
+#
+    # If the data is invalid or not signed properly, an empty
+    # dictionary is returned.
+#
+    # The secret argument should be an instance of FacebookSecret
+    # to hide value from simple introspection.
+#
+    # DEPRECATED, use verify_signature instead
+    def MiniFB.validate( secret, arguments )
+
+        signature = arguments.delete( "fb_sig" )
+        return arguments if signature.nil?
+
+        unsigned = Hash.new
+        signed = Hash.new
+
+        arguments.each do |k, v|
+            if k =~ /^fb_sig_(.*)/ then
+                signed[$1] = v
+            else
+                unsigned[k] = v
+            end
+        end
+
+        arg_string = String.new
+        signed.sort.each { |kv| arg_string << kv[0] << "=" << kv[1] }
+        if Digest::MD5.hexdigest( arg_string + secret ) != signature
+            unsigned # Hash is incorrect, return only unsigned fields.
+        else
+            unsigned.merge signed
+        end
+    end
+
+    class FaceBookSecret
+        # Simple container that stores a secret value.
+        # Proc cannot be dumped or introspected by normal tools.
+        attr_reader :value
+
+        def initialize( value )
+            @value = Proc.new { value }
+        end
+    end
+end

data/test/test_mini_fb.rb

@@ -0,0 +1,29 @@
+require 'test/unit'
+class MiniFBTests < Test::Unit::TestCase
+
+
+    def setup
+    end
+
+    def teardown
+
+    end
+
+    # Test signature verification.
+    def test_signature
+        
+    end
+
+    def test_basic_calls
+
+    end
+
+    def test_session
+
+    end
+
+    def test_photos
+        
+    end
+
+end

metadata

@@ -0,0 +1,57 @@
+--- !ruby/object:Gem::Specification 
+name: mjfreshyfresh-mini_fb
+version: !ruby/object:Gem::Version 
+  version: 0.1.11
+platform: ruby
+authors: 
+- Travis Reeder
+- Aaron Hurley
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-01-20 00:00:00 -08:00
+default_executable: 
+dependencies: []
+
+description: Tiny facebook library
+email: michael@stepchangegroup.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README.markdown
+files: 
+- lib/mini_fb.rb
+- README.markdown
+has_rdoc: true
+homepage: http://github.com/mjfreshyfresh/mini_fb
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: Tiny facebook library
+test_files: 
+- test/test_mini_fb.rb