gamerocket 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 37895025aecc1ccb572dc9432737f7a48afd3e44
+  data.tar.gz: 8cf474027374df10ffb4d511a74d3f9421b7d6f9
+SHA512:
+  metadata.gz: 443abd226ecff43f51a2b4cd9ceb02ebfc6fdb9e1187dd37439482c2dccc94efed7916d3af3a05cfefee120026a3f784dd6b20682fefb1bafa00e0fed90bb091
+  data.tar.gz: 83e86b52cc1f95c066c5d64cdb1b07e8801ef93f77159e32563a3419868bc0cd749b4b9082c5165543d76f7465cda5fb955017d5f3f1dff484b4fec6c95a7313

data/LICENSE

@@ -0,0 +1,24 @@
+(The MIT License)
+
+Copyright (c) 2012-2013 Work Bandits
+
+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.

data/README

@@ -0,0 +1,52 @@
+= GameRocket Ruby Client Library
+
+The GameRocket gem provides integration access to the GameRocket Gateway.
+
+== Dependencies
+
+* builder
+* json
+* base64
+* cgi
+
+== Quick Start Example
+
+  require "base64"
+  require "cgi"
+  require "date"
+  require "digest/sha2"
+  require "logger"
+  require "net/http"
+  require "net/https"
+  require "openssl"
+  require "stringio"
+  require "time"
+  require "zlib"
+
+ require "builder"
+ require "json"
+ require "gamerocket"
+
+  GameRocket::Configuration.environment = :development
+  GameRocket::Configuration.apiKey = "your_api_key"
+  GameRocket::Configuration.secretKey = "your_secret_key"
+
+  result = GameRocket::Player.create(
+    :name => "Bob", 
+    :locale => "fr_FR"
+  )
+
+  if result.success?
+    p "success!"
+  else
+    p result.error
+  end  
+
+== Documentation
+
+* Documentation[https://www.gamerocket.io:443/docs/ruby/guide/overview]
+
+
+== License
+
+See the LICENSE file.

data/Rakefile

@@ -0,0 +1,48 @@
+# 
+# To change this template, choose Tools | Templates
+# and open the template in the editor.
+ 
+
+require 'rubygems'
+require 'rake'
+require 'rake/clean'
+require 'rubygems/package_task'
+require 'rdoc/task'
+require 'rake/testtask'
+
+spec = Gem::Specification.new do |s|
+  s.name = 'gamerocket'
+  s.version = '1.0.0'
+  s.has_rdoc = true
+  s.extra_rdoc_files = ['README', 'LICENSE']
+  s.summary = 'Your summary here'
+  s.description = s.summary
+  s.author = 'Work Bandits'
+  s.email = 'contact@gamerocket.io'
+  # s.executables = ['your_executable_here']
+  s.files = %w(LICENSE README Rakefile) + Dir.glob("{bin,lib,spec}/**/*")
+  s.require_path = "lib"
+  s.bindir = "bin"
+  s.add_dependency "builder", ">= 2.0.0"
+  s.add_dependency "json"
+end
+
+Gem::PackageTask.new(spec) do |p|
+  p.gem_spec = spec
+  p.need_tar = true
+  p.need_zip = true
+end
+
+Rake::RDocTask.new do |rdoc|
+  files =['README', 'LICENSE', 'lib/**/*.rb']
+  rdoc.rdoc_files.add(files)
+  rdoc.main = "README" # page to start on
+  rdoc.title = "gamerocket-ruby Docs"
+  rdoc.rdoc_dir = 'doc/rdoc' # rdoc output folder
+  rdoc.options << '--line-numbers'
+end
+
+Rake::TestTask.new do |t|
+  t.test_files = FileList['test/**/*.rb']
+end
+

data/lib/gamerocket/achievement.rb

@@ -0,0 +1,26 @@
+module GameRocket
+  class Achievement    
+    include BaseModule
+    
+    attr_accessor :id, :progression, :unlocked, :unlockedDate, :dynProp, :template
+
+    def initialize(gateway, attributes)
+      @gateway = gateway      
+      if attributes.is_a?(Hash)
+        set_instance_variables_from_hash(attributes)
+        self.dynProp = attributes["dynProp"].is_a?(Hash) ? attributes["dynProp"] : {}
+        if attributes["template"].is_a?(Hash)
+        self.template = AchievementTemplate._new(attributes["template"])
+        end
+      end
+    end
+    
+    def self.find(player, id, params)
+      Configuration.gateway.achievement.find(player, id, params)
+    end
+     
+    def self._new(*args)
+      self.new *args
+    end
+  end
+end

data/lib/gamerocket/achievement_gateway.rb

@@ -0,0 +1,19 @@
+module GameRocket
+  class AchievementGateway
+    
+    def initialize(gateway)
+      @gateway = gateway
+      @config = gateway.config
+    end
+    
+    def find(player, id, params)
+      raise InvalidArgument, "Expected id to be set" if player.nil? || player == "" || id.nil? || id.to_s == ""
+      json = @config.http.get("/players/#{player}/achievements/#{id}", params)
+      if !json["achievement"].nil?
+        Achievement._new(@gateway, json["achievement"])
+      else
+        raise NotFoundError, "Achievement with id #{id} not found."
+      end
+    end
+  end
+end

data/lib/gamerocket/achievement_template.rb

@@ -0,0 +1,15 @@
+module GameRocket
+  class AchievementTemplate
+    include BaseModule
+    
+    attr_accessor :id, :ref, :name, :description, :image, :goal, :points, :dynProp
+    
+    def initialize(attributes)
+      set_instance_variables_from_hash(attributes)
+    end
+    
+    def self._new(*args)
+      self.new *args
+    end
+  end
+end

data/lib/gamerocket/action.rb

@@ -0,0 +1,26 @@
+module GameRocket
+  class Action
+    
+    attr_accessor :id, :ref, :name, :dynProp, :secured
+    
+    def initialize(gateway, attributes)
+      @gateway = gateway
+      if !attributes.nil?
+        set_instance_variables_from_hash(attributes) if !attributes.nil?
+        self.dynProp = attributes[:dynProp].nil ? attributes[:dynProp] : {}
+      end
+    end
+    
+    def self.find(id)
+      Configuration.gateway.action.find(id)
+    end
+    
+    def self.run(id, attributes)
+      Configuration.gateway.action.run(id, attributes)
+    end
+    
+    def self._new(*args)
+      self.new *args
+    end
+  end
+end

data/lib/gamerocket/action_gateway.rb

@@ -0,0 +1,30 @@
+module GameRocket
+  class ActionGateway
+    
+    def initialize(gateway)
+      @gateway = gateway
+      @config = gateway.config
+    end
+    
+    def find(id)
+      raise InvalidArgument, "Expected id to be set" if id.nil? || id.to_s == ""
+      response = @config.http.get("/games/#{@config.apiKey}/actions/#{id}")
+      if !response["action"].nil?
+        Action._new(@gateway, response["action"])
+      else
+        raise NotFoundError, "Action with id #{id} not found."
+      end
+    end
+    
+    def run(id, attributes)
+      response = @config.http.post("/games/#{@config.apiKey}/actions/#{id}/run", attributes)
+      if response["error"].nil?
+        SuccessfulResult.new(response)
+      else
+        ErrorResult.new(attributes, response)
+      end
+    rescue NotFoundError
+      raise NotFoundError, "Action with id #{id} not found."
+    end
+  end
+end

data/lib/gamerocket/base_module.rb

@@ -0,0 +1,36 @@
+module GameRocket
+  module BaseModule
+    module Methods
+      
+      def return_object_or_raise(object_to_return)
+        result = yield
+        if result.success?
+          result.send object_to_return
+        else
+          raise ValidationsFailed.new(result)
+        end
+      end
+      
+      def copy_instance_variables_from_object(object)
+        object.instance_variables.each do |ivar|
+          instance_variable_set ivar, object.instance_variable_get(ivar)
+        end
+      end
+      
+      def set_instance_variables_from_hash(hash)
+        hash.each do |key, value|
+          instance_variable_set "@#{key}", value
+        end
+      end
+      
+      def singleton_class
+        class <<self; self; end
+      end
+    end
+    
+    def self.included(klass)
+      klass.extend Methods
+    end
+    include Methods
+  end
+end

data/lib/gamerocket/configuration.rb

@@ -0,0 +1,121 @@
+module GameRocket
+  class Configuration
+    API_VERSION ="1"
+    
+    class << self
+      attr_writer :custom_user_agent, :logger, :apiKey, :secretKey
+    end
+    attr_reader :apiKey, :secretKey
+    
+    def self.expectant_reader(*attributes)
+      attributes.each do |attribute|
+        (class << self; self; end).send(:define_method, attribute) do
+          attribute_value = instance_variable_get("@#{attribute}")
+          raise ConfigurationError.new(attribute.to_s, "needs to be set") unless attribute_value
+          attribute_value
+        end
+      end
+    end
+    expectant_reader :environment, :apiKey, :secretKey
+    
+    def self.environment=(env)
+      unless [:development, :production].include?(env)
+        raise ArgumentError, "#{env.inspect} is not a valid environment"
+      end
+      @environment = env
+    end
+    
+    def self.gateway
+      GameRocket::Gateway.new(instantiate)
+    end
+    
+    def self.instantiate
+      config = new(
+        :custom_user_agent => @custom_user_agent,
+        :environment => environment,
+        :logger => logger,
+        :apiKey => apiKey,
+        :secretKey => secretKey
+      )
+    end
+    
+    def self.logger
+      @logger ||=_default_logger
+    end
+    
+    def initialize(options = {})
+      [:environment, :apiKey, :secretKey, :custom_user_agent, :logger].each do |attr|
+        instance_variable_set "@#{attr}", options[attr]
+      end
+    end
+    
+    def api_version
+      API_VERSION
+    end
+    
+    def baseUrl
+      "#{protocol}://#{server}:#{port}/api/#{API_VERSION}"
+    end
+    
+    def ca_file
+      case @environment
+      when :production
+        File.expand_path(File.join(File.dirname(_FILE_), "..", "ssl", "www_gamerocket_io.ca.crt" ))
+      end
+    end
+    
+    def http
+      Http.new(self)
+    end
+    
+    def logger
+      @logger ||=self.class._default_logger
+    end
+    
+    def port
+      case @environment
+      when :development
+        ENV['GATEWAY_PORT'] || 8180
+      when :production
+        443      
+      end
+    end
+    
+    def protocol
+      ssl? ? "https" : "http"
+    end.to_s
+    
+    def server
+      case @environment
+      when :development
+        "localhost"
+      when :production
+        "www.gamerocket.io"
+      end
+    end
+    
+    def ssl?
+      case @environment
+      when :development
+        false
+      when :production
+        true
+      end
+    end
+    
+    def user_agent
+      base_user_agent = "GameRocket Ruby Gem #{GameRocket::Version::String}"
+      @custom_user_agent ? "#{base_user_agent} (#{@custom_user_agent}" : base_user_agent
+    end
+    
+    def self._default_logger
+      logger = Logger.new(STDOUT)
+      logger.level = Logger::INFO
+      logger
+    end
+    
+    def inspect
+      super.gsub(/@secretKey=\".*\"/, '@secrectKey="[FILTERED]"')
+    end
+  end 
+end

data/lib/gamerocket/crypto.rb

@@ -0,0 +1,46 @@
+module GameRocket
+  module Crypto
+    
+    def self.sign(method, url, parameters, secretKey)
+      base_string = self.build_base_string(method, url, parameters)
+      self._sign(base_string, secretKey)
+    end
+    
+    private
+    def self.build_base_string(method, url, parameters)
+      base_string = "#{method}&" + "#{CGI.escape("#{url.downcase}").gsub("+", "%20")}&"
+      if !parameters.nil?
+        parameters.each{|key, value| 
+          if value.is_a?(Hash)
+            value.each{|key_bis, value_bis|
+              if value_bis.is_a?(Hash)
+                value_bis.each{ |key_ter, value_ter|
+                  CGI.escape(value_ter).gsub("+", "%20")
+                }
+                value_bis = GameRocket::Util.hash_to_query_string(value_bis)
+              else
+                CGI.escape(value_bis).gsub("+", "%20")
+              end
+              
+            }
+            value = GameRocket::Util.hash_to_query_string(value)
+            CGI.escape(value).gsub("+", "%20")
+          else
+            CGI.escape(value).gsub("+", "%20")
+          end
+          
+        }
+        parameters = parameters.sort
+        querystring = GameRocket::Util.hash_to_query_string(parameters)
+        base_string += CGI.escape(querystring).gsub("+", "%20")
+      end
+      
+      base_string
+    end
+    
+    def self._sign(base_string, secretKey)
+      digest = Digest::SHA256.hexdigest(base_string + secretKey)
+      Base64.strict_encode64(digest)
+    end
+  end
+end

data/lib/gamerocket/error_result.rb

@@ -0,0 +1,15 @@
+module GameRocket
+  class ErrorResult
+    
+    attr_reader :error, :error_description
+    
+    def initialize(gateway, json)
+      @error = json["error"]
+      @error_description = json["error_description"]
+    end
+    
+    def success?
+      false
+    end
+  end
+end

data/lib/gamerocket/exceptions.rb

@@ -0,0 +1,48 @@
+module GameRocket
+  class GameRocketError < ::StandardError; end
+
+  class AuthenticationError < GameRocketError; end
+
+  class AuthorizationError < GameRocketError; end
+
+  class ConfigurationError < GameRocketError
+    def initialize(setting, message)
+      super "GameRocket::Configuration.#{setting} #{message}"
+    end
+  end
+
+  class DownForMaintenanceError < GameRocketError; end
+
+  class ForgedQueryString < GameRocketError; end
+  
+  class InvalidArgument < GameRocketError; end
+
+  class InvalidSignature < GameRocketError; end
+
+  class NotFoundError < GameRocketError; end
+
+  class ServerError < GameRocketError; end
+
+  class SSLCertificateError < GameRocketError; end
+
+  class UnexpectedError < GameRocketError; end
+
+  class UpgradeRequiredError < GameRocketError; end
+
+  class ValidationsFailed < GameRocketError
+    attr_reader :error_result
+
+    def initialize(error_result)
+      @error_result = error_result
+    end
+
+    def inspect
+      "#<#{self.class} error_result: #{@error_result.inspect}>"
+    end
+
+    def to_s
+      inspect
+    end
+  end
+end
+

data/lib/gamerocket/game.rb

@@ -0,0 +1,22 @@
+module GameRocket
+  class Game
+    
+    attr_accessor :id, :name, :status, :dynProp
+    
+    def initialize(gateway, attributes)
+      @gateway = gateway
+      if !attributes.nil?
+        set_instance_variables_from_hash(attributes)
+        self.dynProp = attributes[:dynProp].is_a?(Hash) ? attributes[:dynProp] : {}
+      end
+    end
+    
+    def self.find(id)
+      Configuration.gateway.game.find(id)
+    end
+    
+    def self._new(*args)
+      self.new *args
+    end
+  end
+end

data/lib/gamerocket/game_gateway.rb

@@ -0,0 +1,19 @@
+module GameRocket
+  class GameGateway
+    
+    def initialize(gateway)
+      @gateway = gateway
+      @config = gateway.config
+    end
+    
+    def find(id)
+      raise InvalidArgument, "Expected id to be set" if id.nil? || id.to_s == ""
+      response = @config.http.get("/games/#{id}")
+      if !response["game"].nil?
+        Game._new(@gateway, response[:game])
+      else
+        raise NotFoundError, "Game with id #{id} not found."
+      end      
+    end
+  end
+end

data/lib/gamerocket/gateway.rb

@@ -0,0 +1,36 @@
+module GameRocket
+  class Gateway
+    
+    attr_reader :config
+    
+    def initialize(config)
+      if config.is_a?(Hash)
+        @config = Configuration.new config
+      elsif config.is_a?(GameRocket::Configuration)
+        @config = config  
+      else
+        raise ArgumentError, "config is an invalid type"
+      end
+    end
+    
+    def player
+      PlayerGateway.new(self)
+    end
+    
+    def achievement
+      AchievementGateway.new(self)
+    end
+    
+    def action
+      ActionGateway.new(self)
+    end
+    
+    def game
+      GameGateway.new(self)
+    end
+    
+    def purchase
+      PurchaseGateway.new(self)
+    end
+  end
+end

data/lib/gamerocket/http.rb

@@ -0,0 +1,113 @@
+module GameRocket
+  class Http
+    
+    def initialize(config)
+      @config = config
+    end
+    
+    def get(path, params = {})
+      params[:signature] = GameRocket::Crypto::sign('GET', @config.baseUrl + path, params, @config.secretKey)
+      qs = GameRocket::Util.hash_to_query_string(params)
+
+      response = _http_do Net::HTTP::Get, @config.baseUrl + path + "?" + qs
+      if response.code.to_i == 200 || response.code.to_i == 422
+        JSON.parse(_body(response))
+      else
+        Util.raise_exception_for_status_code(response.code)
+      end
+    end
+    
+    
+    def post(path, params = {})
+      params[:signature] = GameRocket::Crypto::sign('POST', @config.baseUrl + path, params, @config.secretKey)
+      qs = GameRocket::Util.hash_to_query_string(params)
+      
+      response = _http_do Net::HTTP::Post, @config.baseUrl + path, qs
+      if response.code.to_i == 200 || response.code.to_i == 201 || response.code.to_i == 422
+        JSON.parse(_body(response))
+      else
+        Util.raise_exception_for_status_code(response.code)
+      end
+    end
+    
+    def put(path, params = {})
+      params[:signature] = GameRocket::Crypto::sign('PUT', @config.baseUrl + path, params, @config.secretKey)
+      qs = GameRocket::Util.hash_to_query_string(params)
+      
+      response = _http_do Net::HTTP::Put, @config.baseUrl + path, qs
+      if response.code.to_i == 200 || response.code.to_i == 201 || response.code.to_i == 422
+        JSON.parse(_body(response))
+      else
+        Util.raise_exception_for_status_codes(response.code)
+      end
+    end
+    
+    def delete(path, params = {})
+      params[:signature] = GameRocket::Crypto::sign('DELETE', @config.baseUrl + path, params, @config.secretKey)
+      qs = GameRocket::Util.hash_to_query_string(params)
+
+      response = _http_do Net::HTTP::Delete, @config.baseUrl + path + "?" + qs
+      if response.code.to_i == 200
+        JSON.parse(_body(response))
+      else
+        Util.raise_exception_for_status_code(response.code)
+      end
+    end
+    
+    def _http_do(http_verb, path, body = nil)      
+      connection = Net::HTTP.new(@config.server, @config.port)
+      connection.read_timeout = 60
+      if @config.ssl?
+        connection.use_ssl= true
+        connection.verify_mode = OpenSSL::SSL::VERIFY_PEER
+        connection.ca_file = @config.ca_file
+        connection.verify_callback = proc { |preverify_ok, ssl_context| _verify_ssl_certificate(preverify_ok, ssl_context) }
+      end
+      connection.start do |http|
+        request = http_verb.new("#{path}")
+        request["Accept"] = "application/json"
+        request["User-Agent"] = @config.user_agent
+        request["Accept-Encoding"] = "gzip"
+        request["X-ApiVersion"] = @config.api_version
+        @config.logger.debug "[GameRocket] [#{_current_time}] #{request.method} #{path}"
+        if body
+          request.body = body
+          @config.logger.debug body
+        end
+        response = http.request(request)
+        @config.logger.info "[GameRocket] [#{_current_time}] #{request.method} #{path} #{response.code}"
+        @config.logger.debug "[GameRocket] [#{_current_time}] #{response.code} #{response.message}"
+        if @config.logger.level == Logger::DEBUG
+          @config.logger.debug _body(response)
+        end
+        response
+      end
+    rescue OpenSSL::SSL::SSLError
+      raise GameRocket::SSLCertificateError
+    end
+    
+    def _body(response)
+      if response.header["Content-Encoding"].nil?
+        response.body
+      elsif response.header["Content-Encoding"] == "gzip"
+        Zlib::GzipReader.new(StringIO.new(response.body)).read
+      else
+        raise UnexpectedError, "expected a gzipped response"
+      end
+    end
+    
+    def _current_time
+      Time.now.utc.strftime("%d/%b/%Y %H:%M:%S %Z")
+    end
+    
+    def _verify_ssl_certificate(preverify_ok, ssl_context)
+      if preverify_ok != true || ssl_context.error != 0
+        err_msg = "SSL Verification failed -- Preverify: #{preverify_ok}, Error: #{ssl_context.error_string} (#{ssl_context.error})"
+        @config.logger.error err_msg
+        false
+      else
+        true
+      end
+    end    
+  end
+end

data/lib/gamerocket/player.rb

@@ -0,0 +1,52 @@
+module GameRocket
+  class Player
+    include BaseModule
+    
+    attr_accessor :id, :name, :emailHash, :totalPointsAchievements, :locale, :dynProp
+    
+    def initialize(gateway, attributes)
+      @gateway = gateway
+      set_instance_variables_from_hash(attributes) unless attributes.nil?
+    end
+    
+    def self.create(attributes = {})
+      Configuration.gateway.player.create(attributes)
+    end
+    
+    def self.find(id)
+      Configuration.gateway.player.find(id)
+    end
+    
+    def self.update(id, attributes)
+      Configuration.gateway.player.update(id, attributes)
+    end
+    
+    def self.delete(id)
+      Configuration.gateway.player.delete(id)
+    end
+    
+    def delete
+      @gateway.player.delete(id)
+    end
+    
+    def ==(other)
+      return false unless other.is_a?(Player)
+      id == other.id
+    end
+    
+    class << self
+      protected :new
+    end
+    
+    def self._new(*args)
+      self.new *args
+    end
+    
+    def self._attributes
+      [
+        :id, :name, :emailHash, :totalPointsAchievements, :locale, :dynProp
+      ]
+    end
+    
+  end
+end

data/lib/gamerocket/player_gateway.rb

@@ -0,0 +1,61 @@
+module GameRocket
+  class PlayerGateway
+    
+    def initialize(gateway)
+      @gateway = gateway
+      @config = gateway.config
+    end
+
+    def self.createSignature
+        signature = ['name', 'locale']
+        signature
+      end
+
+    def create(attributes = {})
+      Util.verify_keys(PlayerGateway.createSignature, attributes)
+      result = _do_create "/games/" + GameRocket::Configuration::apiKey + "/players", attributes
+    end
+
+    def find(id)
+      raise ArgumentError, "id contains invalid characters" unless id.to_s =~ /\A[\w_]+\z/
+      raise ArgumentError, "id cannot be blank" if id.nil?|| id.to_s.strip ==""
+      json = @config.http.get("/players/#{id}")
+      if !json["player"].nil?
+        Player._new(@gateway, json["player"])
+      else
+        raise NotFoundError, "player with id#{id.inspect} not found"
+      end
+    end
+    
+    def update(id, attributes)
+      _do_update(:put, "/players/#{id}", attributes)
+    end
+    
+    def delete(id)
+      json = @config.http.delete("/players/#{id}")
+      SuccessfulResult.new
+    end
+        
+    def _do_create(url, params = nil)
+      json = @config.http.post url, params
+      if json["player"]
+        SuccessfulResult.new(:player => Player._new(@gateway, json["player"]))
+      elsif json["error"]
+        ErrorResult.new(@gateway, json)
+      else
+        raise "expected :player or :error"
+      end
+    end
+    
+    def _do_update(http_verb, url, params)
+      json = @config.http.send http_verb, url, params
+      if json["player"]
+        SuccessfulResult.new(:player => Player._new(@gateway, json["player"]))
+      elsif json["error"]
+        ErrorResult.new(@gateway, json)
+      else
+        raise UnexpectedError, "expected :player or :error"
+      end
+    end
+  end
+end

data/lib/gamerocket/purchase.rb

@@ -0,0 +1,26 @@
+module GameRocket
+  class Purchase
+    
+    attr_accessor :id, :ref, :name, :price, :dynProp
+    
+    def initialize(gateway, attributes)
+      @gateway = gateway
+      if !attributes.nil?
+        set_instance_variables_from_hash(attributes)
+        self.dynProp = attributes[:dynProp].is_a?(Hash) ? attributes[:dynProp] : {}
+      end
+    end
+    
+    def self.find(id)
+      Configuration.gateway.purchase.find(id)
+    end
+    
+    def self.buy(id, attributes)
+      Configuration.gateway.purchase.buy(id, attributes)
+    end
+    
+    def self._new(*args)
+      self.new *args
+    end    
+  end
+end

data/lib/gamerocket/purchase_gateway.rb

@@ -0,0 +1,30 @@
+module GameRocket
+  class PurchaseGateway
+    
+    def initialize(gateway)
+      @gateway = gateway
+      @config = gateway.config
+    end
+    
+    def find(id)
+      raise InvalidArgument, "Expected id to be set" if id.nil? || id.to_s == ""
+      response = @config.http.get("/games/#{@config.apiKey}/purchases/#{id}")
+      if !response["purchase"].nil?
+        Purchase._new(@gateway, response["purchase"])
+      else
+        raise NotFoundError, "Purchase with id #{id} not found."
+      end
+    end
+    
+    def buy(id, attributes)
+      response = @config.http.post("/games/#{@config.apiKey}/purchases/#{id}/buy", attributes)    
+      if response["error"].nil?
+        SuccessfulResult.new(response)
+      else
+        ErrorResult.new(@gateway, response)
+      end
+    rescue NotFoundError
+      raise NotFoundError, "Purchase with id #{id} not found."  
+    end
+  end
+end

data/lib/gamerocket/successful_result.rb

@@ -0,0 +1,20 @@
+module GameRocket
+  class SuccessfulResult
+    include BaseModule
+    
+    def initialize(attributes = {})
+      @attrs = attributes.keys
+      singleton_class.class_eval do
+        attributes.each do |key, value|
+          define_method key do
+            value
+          end
+        end
+      end
+    end
+    
+    def success?
+      true
+    end
+  end
+end

data/lib/gamerocket/util.rb

@@ -0,0 +1,138 @@
+module GameRocket
+  module Util
+    
+    def self.extract_attribute_as_array(hash, attribute)
+      raise UnexpectedError.new("Unprocessable entity due to an invalid request") if hash.nil?
+      value = hash.has_key?(attribute) ? hash.delete(attribute) : []
+      value.is_a?(Array) ? value : [value]
+    end
+    
+    def self.hash_to_query_string(hash, namespace = nil)
+      hash.collect do |key, value|
+        full_key = namespace ? "#{namespace}[#{key}]" : key
+        if value.is_a?(Hash)
+          hash_to_query_string(value, full_key)
+        else
+          if full_key.eql? :signature
+            full_key.to_s.to_str + "=" + value.to_s.to_str
+          else 
+            url_encode(full_key) + "=" + url_encode(value)
+          end
+        end
+      end.sort * '&'
+    end
+    
+    def self.parse_query_string(qs)
+      qs.split('&').inject({}) do |result, couplet|
+        pair = couplet.split('=')
+        result[CGI.unescape(pair[0]).to_sym] = CGI.unescapeHTML(pair[1] || '')
+        result
+      end
+    end
+    
+    def self.url_decode(text)
+      CGI.escape text.to_s.to_str
+    end
+    
+    def self.url_encode(text)
+      CGI.escape text.to_s.to_str
+    end
+    
+    def self.symbolize_keys(hash)
+      hash.inject({}) do |new_hash, (key, value)|
+        if value.is_a?(Hash)
+          value = symbolize_keys(value)
+        elsif value.is_a?(Array) && value.all? { |v| v.is_a?(Hash) }
+          value = value.map {|v| symbolize_keys(v)}          
+        end
+        new_hash.merge(key.to_sym => value)
+      end
+    end
+    
+    def self.raise_exception_for_status_code(status_code, message=nil)
+      case status_code.to_i
+      when 401
+        raise AuthenticationError
+      when 403
+        raise AuthorizationError, message
+      when 404
+        raise NotFoundError
+      when 426
+        raise UpgradeRequiredError, "Please upgrade your client library."
+      when 500
+        raise ServerError
+      when 503
+        raise DownForMaintenanceError
+      else
+        raise UnexpectedError, "unexpected HTTP_RESPONSE #{status_code.to_i}"
+      end
+    end
+    
+    def self.to_big_decimal(decimal)
+      case decimal
+      when BigDecimal, NilClass
+        decimal
+      when String
+        BigDecimal.new(decimal)
+      else
+        raise ArgumentError, "Argument must be a String or BigDecimal"
+      end
+    end
+    
+    def self.verify_keys(valid_keys, hash)
+      flattened_valid_keys = _flatten_valid_keys(valid_keys)
+      invalid_keys = _flatten_hash_keys(hash) - flattened_valid_keys
+      invalid_keys = _remove_wildcard_keys(flattened_valid_keys, invalid_keys)
+      if invalid_keys.any?
+        sorted = invalid_keys.sort_by { |k| k.to_s}.join(", ")
+        raise ArgumentError, "invalid keys: #{sorted}"
+      end
+    end
+    
+    def self._flatten_valid_keys(valid_keys, namespace = nil)
+      valid_keys.inject([]) do |result, key|
+        if key.is_a?(Hash)
+          full_key = key.keys[0]
+          full_key = (namespace ? "#{namespace}[#{full_key}]" : full_key)
+          nested_keys = key.values[0]
+          if nested_keys.is_a?(Array)
+            result += _flatten_valid_keys(nested_keys, full_key)
+          else
+            result << "#{full_key}[#{nested_keys}]"
+          end
+        else
+          result << (namespace ? "#{namespace}[#{key}]" : key.to_s)
+        end
+        result
+      end.sort
+    end
+    
+    def self._flatten_hash_keys(element, namespace = nil)
+      element = [element] if element.is_a?(String)
+      element.inject([]) do |result, (key, value)|
+        full_key = (namespace ? "#{namespace}[#{key}]" : key.to_s)
+        if value.is_a?(Hash)
+          result += _flatten_hash_keys(value, full_key)
+        elsif value.is_a?(Array)
+          value.each do |item|
+            result += _flatten_hash_keys(item, full_key)
+          end
+        else
+          result << full_key
+        end
+        result
+      end.sort
+    end
+    
+    def self._remove_wildcard_keys(valid_keys, invalid_keys)
+      wildcard_keys = valid_keys.select {|k| k.include? "[_any_key_]"}
+      return invalid_keys if wildcard_keys.empty?
+      wildcard_keys.map! { |wk| wk.sub "[_any]", ""}
+      invalid_keys.select do |invalid_key|
+        wildcard_keys.all? do |wildcard_key|
+          invalid_key.index(wildcard_key) != 0
+        end
+      end
+    end    
+  end
+end

data/lib/gamerocket/version.rb

@@ -0,0 +1,9 @@
+module GameRocket
+  module Version
+    Major = 1
+    Minor = 0
+    Tiny =0
+    
+    String = "#{Major}.#{Minor}.#{Tiny}"
+  end
+end

data/lib/gamerocket.rb

@@ -0,0 +1,45 @@
+require "base64"
+require "cgi"
+require "date"
+require "digest/sha2"
+require "logger"
+require "net/http"
+require "net/https"
+require "openssl"
+require "stringio"
+require "time"
+require "zlib"
+
+require "builder"
+require "json"
+
+require File.dirname(__FILE__) + "/gamerocket/exceptions"
+
+require File.dirname(__FILE__) + "/gamerocket/base_module"
+
+require File.dirname(__FILE__) + "/gamerocket/achievement"
+require File.dirname(__FILE__) + "/gamerocket/achievement_gateway"
+require File.dirname(__FILE__) + "/gamerocket/achievement_template"
+require File.dirname(__FILE__) + "/gamerocket/action"
+require File.dirname(__FILE__) + "/gamerocket/action_gateway"
+require File.dirname(__FILE__) + "/gamerocket/game"
+require File.dirname(__FILE__) + "/gamerocket/game_gateway"
+require File.dirname(__FILE__) + "/gamerocket/purchase"
+require File.dirname(__FILE__) + "/gamerocket/purchase_gateway"
+require File.dirname(__FILE__) + "/gamerocket/player"
+require File.dirname(__FILE__) + "/gamerocket/player_gateway"
+
+require File.dirname(__FILE__) + "/gamerocket/gateway"
+require File.dirname(__FILE__) + "/gamerocket/http"
+require File.dirname(__FILE__) + "/gamerocket/successful_result"
+require File.dirname(__FILE__) + "/gamerocket/error_result"
+
+require File.dirname(__FILE__) + "/gamerocket/crypto"
+require File.dirname(__FILE__) + "/gamerocket/util"
+require File.dirname(__FILE__) + "/gamerocket/configuration"
+require File.dirname(__FILE__) + "/gamerocket/version"
+
+
+GameRocket::Configuration.environment = "your_environment"#:development or :production
+GameRocket::Configuration.apiKey = "your_apiKey"#use your apiKey
+GameRocket::Configuration.secretKey = "your_secret_key"#use your secretKey

metadata

@@ -0,0 +1,97 @@
+--- !ruby/object:Gem::Specification
+name: gamerocket
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Work Bandits
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-07-18 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: builder
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: 2.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: 2.0.0
+- !ruby/object:Gem::Dependency
+  name: json
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Your summary here
+email: contact@gamerocket.io
+executables: []
+extensions: []
+extra_rdoc_files:
+- README
+- LICENSE
+files:
+- LICENSE
+- README
+- Rakefile
+- lib/gamerocket/game_gateway.rb
+- lib/gamerocket/player_gateway.rb
+- lib/gamerocket/base_module.rb
+- lib/gamerocket/achievement_gateway.rb
+- lib/gamerocket/achievement_template.rb
+- lib/gamerocket/http.rb
+- lib/gamerocket/purchase_gateway.rb
+- lib/gamerocket/game.rb
+- lib/gamerocket/purchase.rb
+- lib/gamerocket/gateway.rb
+- lib/gamerocket/version.rb
+- lib/gamerocket/util.rb
+- lib/gamerocket/action.rb
+- lib/gamerocket/configuration.rb
+- lib/gamerocket/crypto.rb
+- lib/gamerocket/error_result.rb
+- lib/gamerocket/successful_result.rb
+- lib/gamerocket/exceptions.rb
+- lib/gamerocket/player.rb
+- lib/gamerocket/achievement.rb
+- lib/gamerocket/action_gateway.rb
+- lib/gamerocket.rb
+homepage: 
+licenses: []
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.0.3
+signing_key: 
+specification_version: 4
+summary: Your summary here
+test_files: []