fixing broken merge.

.gitignore

@@ -0,0 +1 @@
+coverage/*

Rakefile

@@ -1,3 +1,69 @@
 require 'rubygems'
 require 'rake'
 
+# begin
+#   require 'jeweler'
+#   Jeweler::Tasks.new do |gem|
+#     gem.name              = "twitter"
+#     gem.summary           = %Q{wrapper for the twitter api}
+#     gem.email             = "nunemaker@gmail.com"
+#     gem.homepage          = "http://github.com/jnunemaker/twitter"
+#     gem.authors           = ["John Nunemaker"]
+#     gem.rubyforge_project = "twitter"
+#     gem.files             = FileList["[A-Z]*", "{examples,lib,test}/**/*"]
+#     
+#     gem.add_dependency('oauth', '>= 0.3.5')
+#     gem.add_dependency('mash', '0.0.3')
+#     gem.add_dependency('httparty', '0.4.3')
+#     
+#     gem.add_development_dependency('thoughtbot-shoulda', '>= 2.10.1')
+#     gem.add_development_dependency('jeremymcanally-matchy', '0.4.0')
+#     gem.add_development_dependency('mocha', '0.9.4')
+#     gem.add_development_dependency('fakeweb', '>= 1.2.5')
+#   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
+

lib/giggly.rb

@@ -12,4 +12,8 @@ module Giggly
 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')
 

lib/giggly/friend.rb

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

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')

lib/giggly/javascript/helper.rb

@@ -0,0 +1,45 @@
+module Gigya
+  module Javscript
+    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">'
+        out += yield.to_s
+        out += '</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_variable(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

lib/giggly/javascript/socialize.rb

@@ -0,0 +1,36 @@
+module Gigya
+  module Javascript
+    class Socialize
+      include Gigya::Javascript::Helper
+
+      attr_accessor :api_key, :enabled_providers, :disabled_providers, :config
+
+      def initialize(config)
+        @api_key            = config[:api_key]
+        @enabled_providers  = config[:enabled_providers] || []
+        @disabled_providers = config[:disabled_providers] || []
+
+        @config = to_config
+      end
+
+      def to_config
+        {
+          'APIKey'            => @api_key,
+          'enabledProviders'  => @enabled_providers,
+          'disabledProviders' => @disabled_providers,
+        }
+      end
+
+      # Socialize specific JS methods
+
+      def config_to_js(config_var_name = :gigya_config)
+        to_var(config_var_name, to_config)
+      end
+
+      def include_gigya_socialize
+        include_gigya_api :socialize
+      end
+
+    end
+  end
+end

lib/giggly/rest.rb

@@ -22,16 +22,17 @@ class RequestEntityTooLarge < SocializeError; end
     class InternalServerError < SocializeError; end
     class NotImplemented < SocializeError; end
 
-    #token is the secret key, value is the nonce.
-    def self.signature(key, token, value)
-      base_string = "#{token}_#{value}"
-      binary_key = Base64.decode64(key) # this is the giggly api key
+    # signs the request as per Gigya's requirements
+    def self.signature(api_key, secret_key, nonce)
+      base_string = "#{secret_key}_#{nonce}"
+      binary_key = Base64.decode64(api_key)
       unencoded_signature = HMAC::SHA1.hexdigest(binary_key, base_string)
       Base64.encode64(unencoded_signature)
     end
 
-    def self.validate_signature(key, token, value, sig)
-      sig == signature(key, token, value) 
+
+    def self.validate_signature(api_key, secret_key, nonce, sig)
+      sig == signature(api_key, secret_key, nonce) 
     end
 
   end

lib/giggly/rest/request.rb

@@ -5,11 +5,23 @@ class Request
       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, @secret_key, @uid = conn_params[:api_key], conn_params[:secret_key], conn_params[:uid]
-        # should we allow the user to doom themeselves?  probably.
+        @api_key, @secret_key, @uid = conn_params[:api_key], conn_params[:secret_key], conn_params[:user_id]
       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(uri, params = {})
         response = self.class.post(uri, :query => sign(params))
         response_key, response_data = response.shift
@@ -19,36 +31,36 @@ def post(uri, params = {})
 
       private
 
-      def sign(params)
-        timestamp = Time.now().to_i
-        params.merge({
-          "apiKey" => @api_key,
-          "timestamp" => timestamp,
-          "nonce" => timestamp,
-          "uid" => @uid,
-          "sig" => Giggly::Rest::signature(@api_key, @secret_key, timestamp.to_s) 
-         })        
-      end
+        def sign(params)
+          timestamp = Time.now().to_i
+          params.merge({
+            "apiKey" => @api_key,
+            "timestamp" => timestamp,
+            "nonce" => timestamp,
+            "uid" => @uid,
+            "sig" => Giggly::Rest::signature(@api_key, @secret_key, timestamp.to_s) 
+           })        
+        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)
+        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