giggly 0.1.0

data/README.rdoc

@@ -0,0 +1,23 @@
+= Giggly
+
+Giggly is an attempt to create a gem for accessing Gigya Socialize 
+(http://www.gigya.com/site/partners/wfsocapi.aspx) via idiomatic ruby.  
+
+Consult the rdoc for detailed information.
+
+== Example
+
+For examples of usage, visit http://giggly.inheretic.com
+
+== Authors
+
+* Ben Vandgrift (http://neovore.com)
+* Adam Hunter (http://adamhunter.me)
+
+== Copyright
+
+Copyright (c) 2009 
+
+== Credits
+
+Sponsored by FlowMingle.com and Charlotte.com

data/Rakefile

@@ -0,0 +1,88 @@
+require 'rubygems'
+require 'rake'
+require 'fileutils'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name              = "giggly"
+    gem.summary           = "wrapper for the gigya rest and javascript apis"
+    gem.description       = "breaks the gigya web api down into idiomatic ruby for your coding pleasure."
+    gem.email             = "somethingfamiliar@gmail.com"
+    gem.homepage          = "http://github.com/sfamiliar/giggly"
+    gem.authors           = ["Ben Vandgrift", "Adam Hunter"]
+    gem.files             = FileList["[A-Z]*", "{examples,lib,test,javascripts}/**/*"]
+    #gem.rubyforge_project = "giggly"
+    
+    gem.add_dependency('httparty', '0.4.5')
+    
+    gem.add_development_dependency('thoughtbot-shoulda', '>= 2.10.1')
+    gem.add_development_dependency('jnunemaker-matchy', '0.4.0')
+    gem.add_development_dependency('mocha', '0.9.4')
+    gem.add_development_dependency('fakeweb', '>= 1.2.5')
+    gem.add_development_dependency('redgreen', '>= 1.0.0')
+  end
+  
+  Jeweler::RubyforgeTasks.new do |rubyforge|
+    rubyforge.doc_task = "rdoc"
+  end
+rescue LoadError
+  puts "Jeweler not available. Install it with: sudo gem install technicalpickles-jeweler -s http://gems.github.com"
+end
+
+require 'rake/testtask'
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'lib' << 'test'
+  test.pattern = 'test/**/*_test.rb'
+  test.verbose = false
+end
+
+begin
+  require 'rcov/rcovtask'
+  Rcov::RcovTask.new do |test|
+    test.libs << 'test'
+    test.pattern = 'test/**/*_test.rb'
+    test.verbose = true
+  end
+rescue LoadError
+  task :rcov do
+    abort "RCov is not available. In order to run rcov, you must: sudo gem install spicycode-rcov"
+  end
+end
+
+
+task :default => :test
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  if File.exist?('VERSION.yml')
+    config = YAML.load(File.read('VERSION.yml'))
+    version = "#{config[:major]}.#{config[:minor]}.#{config[:patch]}"
+  else
+    version = ""
+  end
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "giggly #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+def copy_js(source, destination)
+  destination ||= '.'
+  FileUtils.cp File.join(File.dirname(__FILE__), 'javascripts', source), destination
+  puts "wrote #{source} to #{destination}"
+end
+
+namespace :giggly do
+  desc "writes out the giggly-socialize.js api wrapper in the given directory. ex) rake giggly:js IN=path/to/write (IN defaults to the current directory)"
+  task :js do
+    copy_js 'giggly-socialize.js', ENV['IN']
+  end
+  
+  desc "writes out the minified version of giggly-socialize"
+  task :"js:min" do
+    copy_js 'giggly-socialize-min.js', ENV['IN']
+  end
+end
+

data/VERSION

@@ -0,0 +1 @@
+0.1.0

data/javascripts/giggly-socialize-min.js

@@ -0,0 +1,8 @@
+/*
+ * Wrapper for Gigya's Javascript Socialize API
+ * http://
+ * http://gigya.com
+ * 
+ * Dual licensed under the MIT and GPL licenses.
+ */
+eval(function(p,a,c,k,e,r){e=function(c){return(c<a?'':e(parseInt(c/a)))+((c=c%a)>35?String.fromCharCode(c+29):c.toString(36))};if(!''.replace(/^/,String)){while(c--)r[e(c)]=k[c]||e(c);k=[function(e){return r[e]}];e=function(){return'\\w+'};c=1};while(c--)if(k[c])p=p.replace(new RegExp('\\b'+e(c)+'\\b','g'),k[c]);return p}('B=1(h){0.4=h;0.q=1(a,b,c,d,e){2 f={\'m\':a,\'6\':i(b,c),\'7\':e,\'r\':d};5 8.9.j.q(0.4,f)};0.n=1(a,b,c,d,e,f){2 g={\'m\':a,\'7\':f,\'r\':e};3(o!=b&&o!=c){p.C(\'D E F G H I J K 3 L M N s.\')}3(o==b){g[\'6\']=i(c,d)}l{g[\'s\']=b}5 8.9.j.n(0.4,g)};0.t=1(a,b,c){2 d={\'7\':c,\'6\':i(a,b)};5 8.9.j.t(0.4,d)};0.u=1(a,b,c){2 d={\'7\':c,\'6\':i(a,b)};5 8.9.j.u(0.4,d)};0.v=1(a,b,c){2 d={\'7\':c,\'6\':i(a,b)};5 8.9.j.v(0.4,d)};0.w=1(a,b,c,d,e,f){2 g={\'7\':f,\'6\':i(d,e)};3(\'1\'==k a){g[\'O\']=a}3(\'1\'==k b){g[\'P\']=b}3(\'1\'==k c){g[\'Q\']=c}5 8.9.j.w(0.4,g)};0.x=1(a,b,c,d){2 e={\'m\':a,\'7\':d,\'6\':i(b,c)};5 8.9.j.x(0.4,e)};0.y=1(a,b,c,d){3(\'R\'!=k a){a=\'n,S,T,U,z\'}2 e={\'6\':i(b,c),\'7\':d,\'V\':a};5 8.9.j.y(0.4,e)};2 i=1(b,c){2 d=1(a){3(\'W\'==a.z){3(\'1\'==k b){b(a)}l{p.X(a)}}l{3(\'1\'==k c){c(a)}l{p.A("Y A Z 10! 11 12: ("+a.13+") 14 15: "+a.16)}}};5 d}}',62,69,'this|function|var|if|config|return|callback|context|gigya|services||||||||||socialize|typeof|else|provider|login|null|console|connect|useFacebookConnect|redirect|isLoggedIn|logout|getUserInfo|addEventHandlers|disconnect|getAvailableProviders|status|error|Giggly|warn|The|onSuccess|and|onFailure|params|will|be|ignored|passed|in|with|onLogin|onConnect|onDisconnect|string|notifications|actions|friends|requiredCapabilities|OK|log|An|has|occurred|Error|details|statusMessage|In|method|operation'.split('|'),0,{}))

data/javascripts/giggly-socialize.js

@@ -0,0 +1,109 @@
+
+Giggly = function(gigyaConfig) {
+	
+	this.config = gigyaConfig;
+	
+	this.connect = function(provider, onSuccess, onFailure, useFacebookConnect, context) {
+		var params = {
+			'provider': provider,
+			'callback': _onSuccessOrFailure(onSuccess, onFailure),
+			'context' : context,
+			'useFacebookConnect' : useFacebookConnect
+		};
+		return gigya.services.socialize.connect(this.config, params);  
+	};
+	
+	this.login = function(provider, redirect, onSuccess, onFailure, useFacebookConnect, context) {
+		var params = {
+			'provider': provider,
+			'context' : context,
+			'useFacebookConnect' : useFacebookConnect
+		};
+		if (null != redirect && null != onSuccess) {
+			console.warn('The onSuccess and onFailure params will be ignored if passed in with redirect.');
+		}
+		if (null == redirect) {
+			params['callback'] = _onSuccessOrFailure(onSuccess, onFailure);
+		} else {
+			params['redirect'] = redirect;
+		}
+		return gigya.services.socialize.login(this.config, params);
+	};
+	
+	this.isLoggedIn = function(onSuccess, onFailure, context) {
+		var params = {
+			'context' : context,
+			'callback': _onSuccessOrFailure(onSuccess, onFailure)
+		};
+		return gigya.services.socialize.isLoggedIn(this.config, params);
+	};
+	
+	this.logout = function(onSuccess, onFailure, context) {
+		var params = {
+			'context' : context,
+			'callback': _onSuccessOrFailure(onSuccess, onFailure)
+		};
+		return gigya.services.socialize.logout(this.config, params);
+	};
+	
+	this.getUserInfo = function(onSuccess, onFailure, context) {
+		var params = {
+			'context' : context,
+			'callback': _onSuccessOrFailure(onSuccess, onFailure)
+		};
+		return gigya.services.socialize.getUserInfo(this.config, params);
+	};
+	
+	this.addEventHandlers = function(onLogin, onConnect, onDisconnect, onSuccess, onFailure, context) {
+		var params = {
+			'context' : context,
+			'callback': _onSuccessOrFailure(onSuccess, onFailure)
+		};
+		if ('function' == typeof onLogin) { params['onLogin'] = onLogin; }
+		if ('function' == typeof onConnect) { params['onConnect'] = onConnect; }
+		if ('function' == typeof onDisconnect) { params['onDisconnect'] = onDisconnect; }
+		return gigya.services.socialize.addEventHandlers(this.config, params);
+	};
+	
+	this.disconnect = function(provider, onSuccess, onFailure, context) {
+		var params = {
+			'provider': provider,
+			'context' : context,
+			'callback': _onSuccessOrFailure(onSuccess, onFailure)
+		};
+		return gigya.services.socialize.disconnect(this.config, params);
+	};
+	
+	// currently supported capabilities are: login, notifications, actions, friends, status
+	this.getAvailableProviders = function(requiredCapabilities, onSuccess, onFailure, context) {
+		if ('string' != typeof requiredCapabilities) {
+			requiredCapabilities = 'login,notifications,actions,friends,status';
+		}
+		var params = {
+			'callback': _onSuccessOrFailure(onSuccess, onFailure),
+			'context' : context,
+			'requiredCapabilities' : requiredCapabilities
+		};
+		return gigya.services.socialize.getAvailableProviders(this.config, params);
+	};
+	
+	var _onSuccessOrFailure = function(success, failure) {
+		var onSuccessOrFailure = function(response) {
+			if ('OK' == response.status) {
+				if ('function' == typeof success) {
+					success(response);
+				} else {
+					console.log(response);
+				}
+			} else {
+				if ('function' == typeof failure) {
+					failure(response);
+				} else {
+					console.error("An error has occurred! Error details: (" + response.statusMessage + ") In method: " + response.operation);
+				}
+			}
+		};
+		return onSuccessOrFailure;
+	};
+	
+}

data/lib/giggly.rb

@@ -0,0 +1,18 @@
+require 'rubygems'
+
+gem 'httparty', '0.4.5'
+require 'httparty'
+
+# breaks the gigya web api down into idiomatic ruby for your coding pleasure.
+module Giggly
+  
+end
+
+directory = File.expand_path(File.dirname(__FILE__))
+
+require File.join(directory, 'giggly', 'rest')
+require File.join(directory, 'giggly', 'javascript')
+require File.join(directory, 'giggly', 'user')
+require File.join(directory, 'giggly', 'friend')
+require File.join(directory, 'giggly', 'session_info')
+

data/lib/giggly/friend.rb

@@ -0,0 +1,4 @@
+module Giggly
+  class Friend < Giggly::User
+  end
+end

data/lib/giggly/javascript.rb

@@ -0,0 +1,10 @@
+module Giggly
+  module Javascript
+    
+  end
+end
+
+directory = File.expand_path(File.dirname(__FILE__))
+
+require File.join(directory, 'javascript', 'helper')
+require File.join(directory, 'javascript', 'socialize')

data/lib/giggly/javascript/helper.rb

@@ -0,0 +1,45 @@
+module Giggly
+  module Javascript
+    module Helper
+      
+      # The Javascript helper should be totally generic to the api that is being used
+      # So that if there is a future api it can be wrapped in a class and include this
+      
+      def include_gigya_api(service)
+        '<script type="text/javascript" src="http://cdn.gigya.com/JS/gigya.js?services=' + service.to_s + '"></script>'
+      end
+      
+      def javascript(&block)
+        out = '<script type="text/javascript">' + "\n"
+        out += yield.to_s
+        out += "\n" + '</script>'
+        out
+      end
+      
+      def to_var(name, object, scope_to_window = false)
+        "#{scope_to_window ? '' : 'var '}#{name.to_s} = #{javascriptify_object object};"
+      end
+      
+      # borrowed mainly from the ym4r_gm plugin
+      def javascriptify_object(object)
+        if object.is_a? String
+          "'#{escape_javascript object}'"
+        elsif object.is_a? Array
+          '[' + object.collect{ |o| javascriptify_variable(o) }.join(', ') + ']'
+        elsif object.is_a? Hash
+          '{' + object.to_a.collect{ |o| "#{o[0].to_s} : #{javascriptify_object(o[1])}" }.join(', ') + '}'
+        elsif object.nil?
+          'undefined'
+        else
+          object.to_s
+        end
+      end
+      
+      # from rails
+      def escape_javascript(javascript)
+        javascript.gsub(/\r\n|\n|\r/, "\\n").gsub("\"") { |m| "\\#{m}" }
+      end
+      
+    end
+  end
+end

data/lib/giggly/javascript/socialize.rb

@@ -0,0 +1,46 @@
+module Giggly
+  module Javascript
+    class Socialize
+      include Giggly::Javascript::Helper
+      
+      attr_accessor :api_key, :enabled_providers, :disabled_providers, :config
+      
+      def initialize(config)
+        @api_key            = config[:api_key]
+        @enabled_providers  = array_to_string(config[:enabled_providers])
+        @disabled_providers = array_to_string(config[:disabled_providers])
+        
+        @config = to_config
+      end
+      
+      def to_config
+        {
+          'APIKey'            => @api_key,
+          'enabledProviders'  => @enabled_providers,
+          'disabledProviders' => @disabled_providers
+        }.reject { |k,v| v.nil? }
+      end
+      
+      # Socialize specific JS methods
+      
+      def config_to_js(config_var_name = :gigyaConfig)
+        to_var(config_var_name, to_config)
+      end
+      
+      def include_gigya_socialize(js_path = '/javascripts', min = true)
+        include_gigya_api(:socialize) + "\n<script type=\"text/javascript\" src=\"#{js_path}/giggly-socialize#{'-min' if min}.js\"></script>"
+      end
+      
+      protected 
+      
+        def array_to_string(array)
+          if array.is_a? String
+            array
+          elsif array.is_a? Array
+            array.join(',')
+          end
+        end
+      
+    end
+  end
+end

data/lib/giggly/rest.rb

@@ -0,0 +1,32 @@
+require 'digest'
+require 'hmac-sha1'
+require 'base64'
+require 'cgi'
+
+module Giggly
+  module Rest
+      
+    class SocializeError < StandardError
+      attr_reader :error_code
+
+      def initialize(error_data)
+        @error_code = error_data["errorCode"]
+        super(error_data["errorMessage"])
+      end
+    end
+
+    class BadRequest < SocializeError; end
+    class Unauthorized < SocializeError; end
+    class Forbidden < SocializeError; end
+    class NotFound < SocializeError; end
+    class RequestEntityTooLarge < SocializeError; end
+    class InternalServerError < SocializeError; end
+    class NotImplemented < SocializeError; end
+
+  end
+end
+
+directory = File.expand_path(File.dirname(__FILE__))
+
+require File.join(directory, 'rest', 'request')
+require File.join(directory, 'rest', 'socialize')

data/lib/giggly/rest/request.rb

@@ -0,0 +1,85 @@
+module Giggly
+  module Rest
+    class Request
+      include HTTParty
+      attr_accessor :api_key, :secret_key, :uid
+      format :xml
+      
+      # Accepts a hash of connection parameters that will be used to authenticate requests with gigya
+      # and specify the user that the request is specific to. The keys for the has are all symbols. 
+      # The connection parameter hash requires :api_key, :secret_key, and :uid
+      # These are the same parameters that can be passed to the constructor for +Giggly::Rest::Socialize+ 
+      # example:
+      #    @connection = Giggly::Rest::Request.new(
+      #      :api_key    => 'api key provided from Gigya',
+      #      :secret_key => 'secret key provided from Gigya',
+      #      :user_id    => 'the Gigya User ID',
+      #    )
+      def initialize(conn_params)
+        @api_key      = conn_params[:api_key]
+        @secret_key   = conn_params[:secret_key]
+        @uid          = conn_params[:user_id]
+        @gigya_secret = Base64.decode64(@secret_key)
+      end
+
+      # Wraps around HTTParty's post method to make API calls.
+      # Responsible for raising errors if they are returned from the API.
+      # Returns response data from the post request.
+      def post(url, params = {})
+        response = self.class.post(url, :query => sign('POST', url, params))
+        response_key, response_data = response.shift
+        raise_errors(response_data)
+        response_data
+      end
+      
+      def sign(http_method, api_url, params)
+        params.merge! "apiKey" => @api_key, "uid" => @uid
+        params.merge  "sig" => signature(api_url, http_method, params)
+      end
+      
+      def signature(http_method, api_url, params)
+        timestamp = Time.now.to_i.to_s
+        params.merge!("nonce" => "#{@uid}#{timestamp}", "timestamp" => timestamp) ####
+        base_string = build_base_string(http_method, api_url, params)
+        hmacsha1 = HMAC::SHA1.digest(@gigya_secret, base_string)
+        sig = Base64.encode64(hmacsha1).chomp.to_s.gsub(/\n/,'')
+      end
+      
+      private
+
+        # what is this supposed to do? or when is it supposed to be used?
+        def validate_signature(api_url, params, sig)
+          sig === signature(api_url, params) 
+        end
+        
+        def params_to_string(params)
+          params.sort {|a,b| a[0].to_s <=> b[0].to_s}.collect {|a| "#{a[0]}=#{CGI.escape a[1].to_s}"}.join('&').gsub('+', '%20')
+        end
+        
+        def build_base_string(http_method, api_url, params)
+          [http_method, api_url, params_to_string(params)].collect! {|a| CGI.escape a}.join('&')
+        end
+      
+        def raise_errors(data)
+          return if '200' == data["statusCode"]
+          case data["statusCode"].to_i
+            when 400
+              raise Giggly::Rest::BadRequest.new(data)
+            when 401
+              raise Giggly::Rest::Unauthorized.new(data)
+            when 403
+              raise Giggly::Rest::Forbidden.new(data)
+            when 404
+              raise Giggly::Rest::NotFound.new(data)
+            when 413
+              raise Giggly::Rest::RequestEntityTooLarge.new(data)
+            when 500
+              raise Giggly::Rest::InternalServerError.new(data)
+            when 503
+              raise Giggly::Rest::NotImplemented.new(data)
+          end
+        end
+            
+    end
+  end
+end