opensocial 0.0.4

data/lib/opensocial/appdata.rb

@@ -0,0 +1,117 @@
+# Copyright (c) 2008 Google Inc.
+# 
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+# 
+#     http://www.apache.org/licenses/LICENSE-2.0
+# 
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+
+module OpenSocial #:nodoc:
+  
+  # Acts as a wrapper for an OpenSocial appdata entry.
+  #
+  # The AppData class takes a person's ID and input JSON as initialization
+  # parameters, and iterates through each of the key/value pairs of that JSON.
+  # For each key that is found, an attr_accessor is constructed (except for
+  # :id which is preconstructed, and required), allowing direct access to the
+  # value. Each value is stored in the attr_accessor, either as a String,
+  # Fixnum, Hash, or Array.
+  #
+  
+  
+  class AppData < Base
+    attr_accessor :id
+    
+    # Initializes the AppData entry based on the provided id and json fragment.
+    # If no JSON is provided, an empty object (with only an ID) is created.
+    def initialize(id, json)
+      @id = id
+      
+      if json
+        json.each do |key, value|
+          begin
+            self.send("#{key}=", value)
+          rescue NoMethodError
+            add_attr(key)
+            self.send("#{key}=", value)
+          end
+        end
+      end
+    end
+  end
+  
+  # Provides the ability to request a Collection of AppData for a given
+  # user or set of users.
+  #
+  # The FetchAppData wraps a simple request to an OpenSocial
+  # endpoint for a Collection of AppData. As parameters, it accepts
+  # a user ID and selector. This request may be used, standalone, by calling
+  # send, or bundled into an RpcRequest.
+  #
+  
+  
+  class FetchAppDataRequest < Request
+    # Defines the service fragment for use in constructing the request URL or
+    # JSON
+    SERVICE = 'appdata'
+    
+    # Initializes a request to fetch appdata for the specified user and
+    # group, or the default (@me, @self). A valid Connection is not necessary
+    # if the request is to be used as part of an RpcRequest.
+    def initialize(connection = nil, guid = '@me', selector = '@self',
+                   aid = '@app')
+      super(connection, guid, selector, aid)
+    end
+    
+    # Sends the request, passing in the appropriate SERVICE and specified
+    # instance variables. Accepts an unescape parameter, defaulting to true,
+    # if the returned data should be unescaped.
+    def send(unescape = true)
+      json = send_request(SERVICE, @guid, @selector, @pid, unescape)
+
+      return parse_response(json['entry'])
+    end
+    
+    # Selects the appropriate fragment from the JSON response in order to
+    # create a native object.
+    def parse_rpc_response(response)
+      return parse_response(response['data'])
+    end
+    
+    # Converts the request into a JSON fragment that can be used as part of a
+    # larger RpcRequest.
+    def to_json(*a)
+      value = {
+        'method' => SERVICE + GET,
+        'params' => {
+          'userId' => ["#{@guid}"],
+          'groupId' => "#{@selector}",
+          'appId' => "#{@pid}",
+          'fields' => []
+        },
+        'id' => @key
+      }.to_json(*a)
+    end
+    
+    private
+    
+    # Converts the JSON response into a Collection of AppData entries, indexed
+    # by id.
+    def parse_response(response)
+      appdata = Collection.new
+      response.each do |key, value|
+        data = AppData.new(key, value)
+        appdata[key] = data
+      end
+      
+      return appdata
+    end
+  end
+end

data/lib/opensocial/auth/action_controller_request.rb

@@ -0,0 +1,87 @@
+# Copyright (c) 2007 Blaine Cook, Larry Halff, Pelle Braendgaard
+#  
+# Permission is hereby granted, free of charge, to any person obtaining
+# a copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sublicense, and/or sell copies of the Software, and to
+# permit persons to whom the Software is furnished to do so, subject to
+# the following conditions:
+#  
+# The above copyright notice and this permission notice shall be
+# included in all copies or substantial portions of the Software.
+#  
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+#
+# Includes modifications by Robin Luckey from:
+# http://github.com/robinluckey/oauth/tree/master/lib%2Foauth%2Frequest_proxy%2Faction_controller_request.rb
+
+require 'rubygems'
+require 'active_support'
+require 'oauth/request_proxy/action_controller_request'
+require 'uri'
+
+module OAuth::RequestProxy #:nodoc: all
+  class ActionControllerRequest < OAuth::RequestProxy::Base
+    proxies ActionController::AbstractRequest
+ 
+    def method
+      request.method.to_s.upcase
+    end
+ 
+    def uri
+      uri = URI.parse(request.protocol + request.host + request.port_string + request.path)
+      uri.query = nil
+      uri.to_s
+    end
+    
+    def parameters
+      if options[:clobber_request]
+        options[:parameters] || {}
+      else
+        params = request_params.merge(query_params).merge(header_params)
+        params.stringify_keys! if params.respond_to?(:stringify_keys!)
+        params.merge(options[:parameters] || {})
+      end
+    end
+    
+    # Override from OAuth::RequestProxy::Base to avoid roundtrip
+    # conversion to Hash or Array and thus preserve the original
+    # parameter names
+    def parameters_for_signature
+      params = []
+      params << options[:parameters].to_query if options[:parameters]
+ 
+      unless options[:clobber_request]
+        params << header_params.to_query
+        params << CGI.unescape(request.query_string) unless request.query_string.blank?
+        if request.content_type == Mime::Type.lookup("application/x-www-form-urlencoded")
+          params << CGI.unescape(request.raw_post)
+        end
+      end
+
+      params.
+        join('&').split('&').
+        reject { |kv| kv =~ /^oauth_signature=.*/}.
+        reject(&:blank?).
+        map { |p| p.split('=') }
+    end
+ 
+    protected
+ 
+    def query_params
+      request.query_parameters
+    end
+ 
+    def request_params
+      request.request_parameters
+    end
+ 
+  end
+end

data/lib/opensocial/auth/base.rb

@@ -0,0 +1,114 @@
+# Copyright (c) 2008 Google Inc.
+# 
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+# 
+#     http://www.apache.org/licenses/LICENSE-2.0
+# 
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+require 'rubygems'
+require 'oauth'
+require 'oauth/consumer'
+
+
+module OpenSocial #:nodoc:
+  
+  # Provides helper classes to be used in verifying and validating the user.
+  # In particular, support is provided for:
+  # 
+  # * Verification of signed makeRequest using OAuth/HMAC-SHA1
+  #   class ExampleController < ApplicationController
+  #     OpenSocial::Auth::CONSUMER_KEY = '623061448914'
+  #     OpenSocial::Auth::CONSUMER_SECRET = 'uynAeXiWTisflWX99KU1D2q5'
+  #     
+  #     include OpenSocial::Auth
+  #   
+  #     before_filter :validate
+  #   
+  #     def return_private_data
+  #     end
+  #   end
+  #
+  # * Request for an OAuth request token
+  #
+  # * Request for an OAuth access token, when supplied with a request token
+  #
+  
+  
+  module Auth
+    
+    # Validates an incoming request by using the OAuth library and the supplied
+    # key and secret.
+    def validate(key = CONSUMER_KEY, secret = CONSUMER_SECRET)
+      consumer = OAuth::Consumer.new(key, secret)
+      begin
+        signature = OAuth::Signature.build(request) do
+          [nil, consumer.secret]
+        end
+        pass = signature.verify
+      rescue OAuth::Signature::UnknownSignatureMethod => e
+        logger.error 'An unknown signature method was supplied: ' + e.to_s
+      end
+      return pass
+    end
+    
+    # Gets an OAuth request token, and redirects the user to authorize the app
+    # to access data on their behalf.
+    def get_oauth_token(key, secret, container, callback)
+      consumer = OAuth::Consumer.new(key, secret, {
+        :site => container[:base_uri],
+        :request_token_path => container[:request_token_path],
+        :authorize_path => container[:authorize_path],
+        :access_token_path => container[:access_token_path],
+        :http_method => container[:http_method]
+      })
+      request_token = consumer.get_request_token
+      
+      session[:token] = request_token.token
+      session[:secret] = request_token.secret
+      
+      redirect_to request_token.authorize_url + '&oauth_callback=' + CGI.escape(callback)
+    end
+    
+    # If neccesary, swaps an existing request token and secret for an access
+    # token, storing it in the Connection class, and returning the access token
+    # and secret for later use.
+    def get_access_token(connection, token, secret)
+      if (token && secret)
+        consumer = OAuth::Consumer.new(connection.consumer_key,
+                                       connection.consumer_secret,
+                                       connection.container)
+
+        if connection.consumer_token.token.empty? &&
+           connection.consumer_token.secret.empty?
+          connection.consumer_token = OAuth::Token.new(token, secret)
+
+          uri = URI.parse(connection.container[:base_uri] +
+                          connection.container[:access_token_path])
+          http = Net::HTTP.new(uri.host, uri.port)
+          req = Net::HTTP::Get.new(uri.request_uri)
+          connection.sign!(http, req)
+
+          resp = http.get(req.path)
+
+          matches = resp.body.match(/oauth_token=(.*?)&oauth_token_secret=(.*)/)
+          access_token = matches[1]
+          access_secret = matches[2]
+        end
+
+        reusable_token = OAuth::AccessToken.new(consumer, access_token, access_secret)
+        connection.consumer_token = reusable_token
+
+        return access_token, access_secret
+      end
+      
+      return nil, nil
+    end
+  end
+end

data/lib/opensocial/base.rb

@@ -0,0 +1,54 @@
+# Copyright (c) 2008 Google Inc.
+# 
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+# 
+#     http://www.apache.org/licenses/LICENSE-2.0
+# 
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+require 'net/http'
+require 'uri'
+
+# Use json/pure if you opt-out of including the validation code in
+# opensocial/auth. This gem adds standard to_json behavior for the
+# request classes, instead of using ActiveSupport.
+require 'rubygems'
+require 'json/add/rails'
+
+
+module OpenSocial #:nodoc:
+  
+  # Provides base functionality for the OpenSocial child classes.
+  #
+  
+  
+  class Base
+    
+    # Creates an attr_accessor for the specified variable name.
+    def add_attr(name)
+      self.class.class_eval "attr_accessor :#{name}"
+    end
+  end
+  
+  # Wraps the functionality of an OpenSocial collection as defined by the
+  # specification. In practical uses, a Collection serves as a Hash (usually
+  # index by ID) with the added benefit of being convertable to an Array, when
+  # it's necessary to iterate over all of the values.
+  #
+  
+  
+  class Collection < Hash
+    
+    # Converts the Collection to an Array by returning each of the values from
+    # key/value pairs.
+    def to_array
+      values
+    end
+  end
+end

data/lib/opensocial/connection.rb

@@ -0,0 +1,146 @@
+# Copyright (c) 2008 Google Inc.
+# 
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+# 
+#     http://www.apache.org/licenses/LICENSE-2.0
+# 
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+require 'oauth/consumer'
+
+
+module OpenSocial #:nodoc:
+  
+  # Describes a connection to an OpenSocial container, including the ability to
+  # declare an authorization mechanism and appropriate credentials.
+  #
+  
+  
+  class Connection
+    ORKUT = { :endpoint => 'http://sandbox.orkut.com/social',
+              :rest => 'rest/',
+              :rpc => 'rpc/',
+              :content_type => 'application/json',
+              :post_body_signing => false,
+              :use_request_body_hash => true }
+    IGOOGLE = { :endpoint => 'http://www-opensocial-sandbox.googleusercontent.com/api',
+                :rest => '',
+                :rpc => 'rpc',
+                :content_type => 'application/json',
+                :post_body_signing => false,
+                :use_request_body_hash => true }
+    MYSPACE = { :endpoint => 'http://api.myspace.com/v2',
+                :rest => '',
+                :rpc => '',
+                :base_uri => 'http://api.myspace.com',
+                :request_token_path => '/request_token',
+                :authorize_path => '/authorize',
+                :access_token_path => '/access_token',
+                :http_method => :get,
+                :content_type => 'application/x-www-form-urlencoded',
+                :post_body_signing => true,
+                :use_request_body_hash => false }
+    
+    AUTH_HMAC = 0
+    AUTH_ST = 1
+    
+    DEFAULT_OPTIONS = { :container => ORKUT,
+                        :st => '',
+                        :consumer_key => '',
+                        :consumer_secret => '',
+                        :consumer_token => OAuth::Token.new('', ''),
+                        :xoauth_requestor_id => '',
+                        :auth => AUTH_HMAC }
+    
+    # Defines the container that will be used in requests.
+    attr_accessor :container
+    
+    # Defines the security token, for when OAuth is not in use.
+    attr_accessor :st
+    
+    # Defines the consumer key for OAuth.
+    attr_accessor :consumer_key
+    
+    # Defines the consumer secret for OAuth.
+    attr_accessor :consumer_secret
+    
+    # Defines the consumer token for OAuth.
+    attr_accessor :consumer_token
+    
+    # Defines the ID of the requestor (required by some implementations when
+    # using OAuth).
+    attr_accessor :xoauth_requestor_id
+    
+    # Defines the authentication scheme: HMAC or security token.
+    attr_accessor :auth
+    
+    # Defines the content-type when sending a request body
+    attr_accessor :content_type
+    
+    # Defines whether or not to sign the request body (treating the body as a
+    # large query parameter for the purposes of the signature base string)
+    attr_accessor :post_body_signing
+    
+    # Defines whether or not to sign the body using a request body hash
+    attr_accessor :use_request_body_hash
+    
+    # Initializes the Connection using the supplied options hash, or the
+    # defaults. Verifies that the supplied authentication type has proper
+    # (ie. non-blank) credentials, and that the authentication type is known.
+    def initialize(options = {})
+      options = DEFAULT_OPTIONS.merge(options)
+      options.each do |key, value|
+        self.send("#{key}=", value)
+      end
+      
+      if @auth == AUTH_HMAC && !has_valid_hmac_double?
+        raise ArgumentError.new('Connection authentication is set to ' +
+                                'HMAC-SHA1, but a valid consumer_key and' +
+                                'secret pair was not supplied.')
+      elsif @auth == AUTH_ST && @st.empty?
+        raise ArgumentError.new('Connection authentication is set to ' +
+                                'security token, but a security token was ' +
+                                'not supplied.')
+      elsif ![AUTH_HMAC, AUTH_ST].include?(@auth)
+        raise ArgumentError.new('Connection authentication is set to an ' +
+                                'unknown value.')
+      end
+    end
+    
+    # Constructs a URI to the OpenSocial endpoint given a service, guid,
+    # selector, and pid.
+    def service_uri(service, guid, selector, pid)
+      uri = [@container[:endpoint], service, guid, selector, pid].compact.
+              join('/')
+      
+      if @auth == AUTH_HMAC && !xoauth_requestor_id.empty?
+        uri << '?xoauth_requestor_id=' + @xoauth_requestor_id
+      elsif @auth == AUTH_ST
+        uri << '?st=' + self.st
+      end
+      URI.parse(uri)
+    end
+    
+    # Signs a request using OAuth.
+    def sign!(http, req)
+      if @auth == AUTH_HMAC
+        consumer = OAuth::Consumer.new(@consumer_key, @consumer_secret)
+        req.oauth!(http, consumer, nil, :scheme => 'query_string')
+      end
+    end
+    
+    private
+    
+    # Verifies that the consumer key, consumer secret and requestor id are all
+    # non-blank.
+    def has_valid_hmac_double?
+      return (!@consumer_key.empty? && !@consumer_secret.empty?)
+    end
+  end
+end