beintoo 0.0.1

data/.gitignore

@@ -0,0 +1,4 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*

data/.rspec

@@ -0,0 +1 @@
+--color

data/CHANGELOG

@@ -0,0 +1,3 @@
+## v0.0.1
+
+* Initial release

data/Gemfile

@@ -0,0 +1,3 @@
+source "http://rubygems.org"
+
+gemspec

data/README.md

@@ -0,0 +1,6 @@
+# Beintoo Api Gem
+
+This gem brings you the api for [Beintoo](http://documentation.beintoo.com/home/api-docs) in a handful way.
+
+Comes, out of the box, with a Rails Integration
+

data/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task default: :spec

data/beintoo.gemspec

@@ -0,0 +1,29 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "beintoo/version"
+
+Gem::Specification.new do |s|
+  s.name        = "beintoo"
+  s.version     = Beintoo::VERSION
+  s.authors     = ["Enrico Carlesso", "Mattia Gheda"]
+  s.email       = ["enricocarlesso@gmail.com", "ghedamat@gmail.com"]
+  s.homepage    = "http://www.beintoo.com"
+  s.summary     = "Ruby Wrapper for the Beintoo API"
+  s.description = "This gem tries to wrap the Beintoo API (http://documentation.beintoo.com) to a ruby friendly Module meant to be used within Ruby on Rails applications"
+
+  s.rubyforge_project = "beintoo"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  # specify any dependencies here; for example:
+  s.add_development_dependency "rspec"
+  s.add_development_dependency "supermodel"
+  s.add_development_dependency "pry"
+  s.add_runtime_dependency "rest-client"
+  s.add_dependency "rake"
+  s.add_dependency "json"
+  s.add_dependency "activesupport"
+end

data/lib/beintoo/api_exception.rb

@@ -0,0 +1,6 @@
+module Beintoo
+  class ApiException < RuntimeError
+  end
+  class UserAlreadyRegisteredException < RuntimeError
+  end
+end

data/lib/beintoo/app.rb

@@ -0,0 +1,20 @@
+module Beintoo
+  class App
+    RESOURCE = "app"
+
+    # returns a map the most delivered vgood with you application and the number those have been erogated. 
+    # This call can be very useful because you have visibility on the vgoods which are generating more
+    # revenues for you. You could decide for example to provide a functional advantage to users who converted
+    # one of these goods, for example giving him more energy in case of a game.
+    def topvgood
+    end
+
+    # returns a map with your players and the score of those.
+    def leaderboard
+    end
+
+    # returns a list of contest for your app, you can choose a single contest and to list all or just public contest
+    def contestShow
+    end
+  end
+end

data/lib/beintoo/model_additions.rb

@@ -0,0 +1,47 @@
+module Beintoo
+  module ModelAdditions
+    # field is the name of the field used for guid i.e. :id
+    def acts_as_beintoo_user(params = {})
+
+      par = {guid_field: :id, email_field: :email, name_field: :name, nickname_field: :nickname}.merge(params)
+
+      define_method 'beintoo_player' do
+        if @beintoo_player.nil?
+          @beintoo_player = Beintoo::Player.new({guid: self.send(par[:guid_field])})
+          @beintoo_player.login
+        end
+        @beintoo_player
+      end
+
+      define_method 'beintoo_user' do
+        begin
+          if @beintoo_user.nil?
+            @beintoo_user = beintoo_player.user({
+              email: self.send(par[:email_field]),
+              name: self.send(par[:name_field]),
+              nickname: self.send(par[:nickname_field]),
+              sendGreetingsEmail: false
+            })
+            @beintoo_user.create
+          end
+          @beintoo_user
+        rescue Beintoo::UserAlreadyRegisteredException => e
+          Beintoo.get_connect_url self.send(par[:guid_field])
+        end
+      end
+
+      define_method 'beintoo_get_potential_rewards' do
+        @beintoo_user.potential_rewards
+      end
+
+      define_method 'beintoo_accept_reward' do |reward|
+        @beintoo_user.accept_reward(reward)
+      end
+
+      define_method 'beintoo_list_rewards' do
+        @beintoo_user.list_rewards
+      end
+
+    end
+  end
+end

data/lib/beintoo/player.rb

@@ -0,0 +1,102 @@
+module Beintoo
+  class Player
+    RESOURCE = "player"
+    attr_accessor :guid, :logged_in, :b_user, :score
+
+    def initialize(params = {})
+      self.guid = params[:guid]
+      self
+    end
+
+    def user(params = {})
+      raise Beintoo::ApiException, "No guid set when creating new Beintoo::User" if guid.nil?
+      if b_user.nil?
+        self.b_user = Beintoo::User.new params.merge(guid: guid)
+      end
+      b_user
+    end
+
+    def login(_guid = nil, publicname = nil)
+      self.guid = _guid unless _guid.nil?
+      headers = {}
+      headers[:guid] = guid unless guid.nil?
+      headers = Beintoo::build_headers headers
+
+      params_get = {}
+      params_get[:language] = 1
+      params_get[:publicname] = publicname unless publicname.nil?
+      result = Beintoo::get "#{RESOURCE}/login", headers, params_get
+      self.guid = result["guid"]
+      self.logged_in = true
+      if result.has_key? "user"
+        self.b_user = Beintoo::User.new result["user"].merge(guid: guid)
+        self.b_user.created = true
+      end
+    end
+
+    def logged_in?
+      !!logged_in
+    end
+
+    def logout
+      return true if !logged_in?
+      headers = {}
+      headers[:guid] = guid
+      headers = Beintoo::build_headers headers
+
+      result = Beintoo::get "#{RESOURCE}/logout", headers
+      self.logged_in = false
+    end
+
+    def get_player(_guid = nil)
+      self.guid = _guid unless _guid.nil?
+      raise Beintoo::ApiException, "No guid setted when calling get_player" if guid.nil?
+      headers = Beintoo::build_headers
+      result = Beintoo::get "#{RESOURCE}/byguid/#{guid}", headers
+      if result.has_key? :playerScore
+        self.score = result[:playerScore]
+      end
+    end
+
+    def submit_score(score, code_id = nil, balance = nil)
+      raise Beintoo::ApiException, "User not logged in when trying to submit score" unless logged_in?
+      headers = {
+        guid:   guid,
+      }
+      headers[:codeID] = code_id unless code_id.nil?
+      headers = Beintoo::build_headers headers
+      body = {lastScore: score}
+      body[:balance] = balance unless balance.nil?
+      if Beintoo.debug
+        Beintoo.log "Submitting score of #{score} for player with guid #{guid}"
+        Beintoo.log body.inspect
+      end
+      result = Beintoo::get "#{RESOURCE}/submitscore/", headers, body
+      if result.has_key? :playerScore
+        self.score = result[:playerScore]
+      end
+      if result[:message] == "OK" && result[:messageID] == 0
+        true
+      else
+        false
+      end
+    end
+
+    def last_score(contest = :default)
+      score[contest][:lastscore] rescue nil
+    end
+
+    def best_score(contest = :default)
+      score[contest][:bestscore] rescue nil
+    end
+
+    def balance(contest = :default)
+      score[contest][:balance] rescue nil
+    end
+
+    def assign_reward
+      Beintoo::Vgood.byplayer(self)
+    end
+
+  end
+end

data/lib/beintoo/railtie.rb

@@ -0,0 +1,9 @@
+module Beintoo
+  class Railtie < Rails::Railtie
+    initializer 'beintoo.model_additions' do
+      ActiveSupport.on_load :active_record do
+        extend ModelAdditions
+      end
+    end
+  end
+end

data/lib/beintoo/user.rb

@@ -0,0 +1,84 @@
+module Beintoo
+  class User
+    RESOURCE = "user"
+    ATTRIBUTES = [:email, :address, :country, :gender, :nickname, :name, :password, :sendGreetingsEmail, :guid, :id, :userimg, :usersmallimg, :isverified, :lastupdate, :level, :bedollars, :bescore, :userExt]
+
+    ATTRIBUTES.each do |a|
+      self.send("attr_accessor", a)
+    end
+
+    attr_accessor :created
+
+    def initialize(params = {})
+      set_data params
+    end
+
+    def create(params = {})
+      set_data params
+      return self if created?
+      if valid?
+        headers = {
+          guid: guid
+        }
+        headers = Beintoo::build_headers headers
+        result = Beintoo::post "#{RESOURCE}/set", headers, get_user_params
+        set_data result
+        self.created = true
+        self
+      else
+        false
+      end
+    end
+
+    def created?
+      created
+    end
+
+    def valid?
+      !email.nil? && !guid.nil?
+    end
+
+    def to_hash
+      h = {}
+      ATTRIBUTES.each do |a|
+        h[a] = self.send(a)
+      end
+      h
+    end
+
+##### rewards methods
+
+    # Get a list of POTENTIAL rewards for the user
+    def potential_rewards
+      Beintoo::Vgood.byuser(self)
+    end
+
+    # User can accept a given reward previously fetched with self.byuser
+    def accept_reward(reward)
+      Beintoo::Vgood.accept(self, reward)
+    end
+
+    # return the vgoods owned by the current user not yet converted.
+    def list_rewards
+      Beintoo::Vgood.showbyuser(self)
+    end
+
+
+##### private
+    def set_data(params = {})
+      params = params.with_indifferent_access
+      ATTRIBUTES.each do |at|
+        self.send("#{at}=", params[at]) unless params[at].nil?
+      end
+      get_user_params
+    end
+
+    def get_user_params
+      params = {}
+      ATTRIBUTES.each do |at|
+        params[at] = self.send("#{at}") unless self.send(at).nil?
+      end
+      params
+    end
+  end
+end

data/lib/beintoo/version.rb

@@ -0,0 +1,3 @@
+module Beintoo
+  VERSION = "0.0.1"
+end

data/lib/beintoo/vgood.rb

@@ -0,0 +1,90 @@
+module Beintoo
+  class Vgood
+    RESOURCE = "vgood"
+
+    ATTRIBUTES = %w{getRealURL showURL description descriptionSmall id imageUrl imageSmallUrl startdate enddate name bedollars discount VgoodPoiWrapper  whoAlsoConverted  categories isBanner contentType content rewardText shareURL uvext}
+
+    ATTRIBUTES.each do |a|
+      self.send("attr_accessor", a)
+    end
+
+    def initialize(params = {})
+      params.each do |a,v|
+        self.send("#{a}=", v)
+      end
+    end
+
+    def to_s
+      ATTRIBUTES.inject(''){|s,a| s << "#{a}: #{self.send(a).to_s}\n"}
+    end
+
+    def == (other)
+      self.id == other.id
+    end
+
+##### VGood api wrapped methods see http://documentation.beintoo.com/home/api-docs/resources/vgood
+
+    # return the vgoods owned by the current user not yet converted.
+    def self.showbyuser(user = nil)
+      raise Beintoo::ApiException, "Called Vgood.byuser without passing a user!" if user.nil?
+      headers = Beintoo::build_headers
+      result = Beintoo::get "#{RESOURCE}/show/byuser/#{user.id}", headers
+      vgoods = []
+      result.each do |vgood|
+        vgoods << Beintoo::Vgood.new(vgood)
+      end
+      vgoods
+    end
+
+    # Get a list of POTENTIAL rewards for the user
+    # Should return an array of Beintoo::Vgood objects
+    def self.byuser(user = nil)
+      raise Beintoo::ApiException, "Called Vgood.byuser without passing a user!" if user.nil?
+      headers = Beintoo::build_headers
+      result = Beintoo::get "#{RESOURCE}/byuser/#{user.id}", headers
+      vgoods = []
+      result[:vgoods].each do |vgood|
+        vgoods << Beintoo::Vgood.new(vgood)
+      end
+      vgoods
+    end
+
+    # User can accept a given reward previously fetched with self.byuser
+    def self.accept(user = nil, reward = nil)
+      raise Beintoo::ApiException, "Called Vgood.accept_reward without passing a user!" if user.nil?
+      raise Beintoo::ApiException, "Called Vgood.accept_reward without passing a reward!" if reward.nil?
+      headers = Beintoo::build_headers
+      if reward.is_a? Beintoo::Vgood
+        result = Beintoo::get "#{RESOURCE}/accept/#{reward.id}/#{user.id}", headers
+      else
+        result = Beintoo::get "#{RESOURCE}/accept/#{reward}/#{user.id}", headers
+      end
+      # XXX WE SHOULD DETECT ERRORS HERE
+      true
+    end
+
+    def self.byplayer(player = nil)
+      raise Beintoo::ApiException, "Called Vgood.byplayer without passing a player!" if !player.logged_in?
+      headers = Beintoo::build_headers
+      result = Beintoo::get "#{RESOURCE}/byguid/#{player.guid}", headers
+      vgoods = []
+      result[:vgoods].each do |vgood|
+        vgoods << Beintoo::Vgood.new(vgood)
+      end
+      vgoods
+    end
+
+
+    # Returns a vgood, this method act as Vgood.getByUser but providing player guid instead of userExt.
+    def getVgoodByGuid
+    end
+
+    # return the friends of the given user
+    def convert
+    end
+
+    # return the friends of the given user
+    def sendAsGift
+    end
+  end
+end

data/lib/beintoo.rb

@@ -0,0 +1,179 @@
+require "beintoo/version"
+require "beintoo/player"
+require "beintoo/user"
+require "beintoo/vgood"
+require "beintoo/api_exception"
+require "beintoo/model_additions"
+require "beintoo/railtie" if defined? Rails
+require "rest_client"
+require "json"
+require "yaml"
+require "active_support"
+
+module Beintoo
+  SERVER_URL = "https://api.beintoo.com/api/rest/"
+  SANDBOX_SERVER_URL = "https://sandbox.beintoo.com/api/rest/"
+
+  DEFAULT_HEADER = {
+    'accept' => '*/*',
+    'Content-Type' => 'application/x-www-form-urlencoded;charset=UTF-8',
+    'X-BEINTOO-SDK-VERSION' => '0.0.1-ruby'
+  }
+
+
+  class << self
+    attr_accessor :apikey, :sandbox, :debug, :transformer, :redirect_uri, :logger
+    LOG_DEBUG   = 0
+    LOG_INFO    = 1
+    LOG_WARNING = 2
+    LOG_ERROR   = 3
+
+    def configure
+      yield self
+      self.sandbox = false if sandbox != true
+      if defined? Rails
+        self.logger = Rails.logger
+      end
+    end
+
+    def log(message, level = LOG_DEBUG)
+      begin
+        if defined? Rails
+          case level
+          when LOG_DEBUG
+            self.logger.debug message
+          when LOG_INFO, LOG_WARNING
+            self.logger.info message
+          when LOG_ERROR
+            self.logger.error message
+          end
+        elsif self.logger.is_a?(String) && self.logger == "file"
+          if @log_file.nil?
+            @log_file = File.open 'beintoo_log.log', 'a'
+          end
+          if debug || level >= LOG_INFO
+            @log_file.write message + "\n"
+          end
+        end
+      rescue Exception => e
+        puts e.message
+      end
+    end
+
+    def build_headers(headers = {})
+      raise Beintoo::ApiException, "Api Key not provided" if Beintoo::apikey.nil?
+      {apikey: apikey, sandbox: sandbox}.merge headers
+    end
+
+    def get(url, headers = {}, params = {})
+      url = "#{Beintoo::SERVER_URL}#{url}"
+      start = Time.now
+      headers.merge! Beintoo::DEFAULT_HEADER
+      url += "?#{hash_to_params(params)}" unless params.empty?
+
+      log "#"*80
+      log "       Calling Beintoo Api"
+      log url
+      log headers.inspect
+      log "#"*80
+
+      resource = RestClient::Resource.new url, headers: headers
+
+      log "Connecting GET to #{url} with headers #{headers}"
+
+      begin
+        response = resource.get
+        stop = Time.now
+        http_code = response.code
+
+        log "------  RAW RESULT  ------"
+        log response.body
+        log "------ /RAW RESULT  ------"
+
+        result = JSON.parse(response.body)
+        result = result.with_indifferent_access if result.is_a? Hash
+        result
+      rescue RestClient::Exception => e
+        log "Exception grabbed, response is", LOG_ERROR
+        log e.response.inspect, LOG_ERROR
+        log e.inspect, LOG_ERROR
+        mex = JSON.parse(e.response)["message"]
+        if mex == "An user with this email already registered"
+          raise Beintoo::UserAlreadyRegisteredException, mex
+        else
+          raise Beintoo::ApiException, mex
+        end
+      end
+    end
+
+    def post(url, headers = {}, params = {})
+      url = "#{Beintoo::SERVER_URL}#{url}"
+      start = Time.now
+      headers.merge! Beintoo::DEFAULT_HEADER
+      ll = {"Content-Type" => nil}
+      headers.merge! ll
+      if params.empty?
+        params = ""
+      end
+
+      log "#"*80
+      log "       Calling Beintoo Api"
+      log url
+      log headers.inspect
+      log "#"*80
+
+      resource = RestClient::Resource.new url, headers: headers
+      if debug
+        Beintoo.log "Connecting POST to #{url} with headers #{headers}"
+        Beintoo.log "and posting #{params.inspect}"
+      end
+      begin
+        response = resource.post params
+
+        stop = Time.now
+        http_code = response.code
+        result = JSON.parse(response.body).with_indifferent_access
+        log "RESULT IS #{result.inspect}"
+        result
+      rescue RestClient::Exception => e
+        log "Exception grabbed, response is", LOG_ERROR
+        log e.response.inspect, LOG_ERROR
+        log e.inspect, LOG_ERROR
+        mex = JSON.parse(e.response)["message"]
+        if mex == "An user with this email already registered"
+          raise Beintoo::UserAlreadyRegisteredException, mex
+        else
+          raise Beintoo::ApiException, mex
+        end
+      end
+    end
+
+    def hash_to_params(data = {})
+      out = []
+      data.each do |k, v|
+        if ![Hash, Array].include? v.class
+          out << "#{k.to_s}=#{v.to_s}"
+        end
+      end
+      out.join '&'
+    end
+
+    # generates beintoo-connect url when user creation fails 
+    # XXX logged_uri parameter is from php API but don't know yet how it works
+    # see http://documentation.beintoo.com/home/api-docs/user-player-connection
+    # redirect will have param userext=XXXXXXXXXXXXXyouruserGUID
+    def get_connect_url(guid, display=nil, signup="facebook", logged_uri=nil)
+      return false if guid.nil?
+      url = "http://www.beintoo.com/connect.html?guid=#{guid}&apikey=#{self.apikey}&redirect_uri=#{self.redirect_uri}"
+      unless display.nil?
+        url += "&display=#{display}"
+      end
+      url += "&signup=#{signup}"
+      unless logged_uri.nil?
+        url += "&logged_uri=#{logged_uri}"
+      end
+      url
+    end
+
+  end
+end

data/lib/generators/beintoo_generator.rb

@@ -0,0 +1,13 @@
+require 'rails/generators'
+require 'rails/generators/active_record'
+
+class BeintooGenerator < Rails::Generators::Base
+
+  source_root File.expand_path("../templates", __FILE__)
+
+  desc "This generator creates the initializer file at config/initializers"
+  def copy_initializer_file
+    copy_file "beintoo.rb", "config/initializers/beintoo.rb"
+  end
+
+end

data/lib/generators/templates/beintoo.rb

@@ -0,0 +1,12 @@
+Beintoo.configure do |config|
+  # Here you have to setup your apikey and the redirect uri used
+  # during the beintoo-connect procedure
+
+  # config.apikey  = "1234567890"
+  # config.redirect_uri = "http://localhost:3000"
+
+  # These are useful during debug
+
+  # config.sandbox = true
+  # config.debug   = true
+end

data/script/console

@@ -0,0 +1 @@
+RUBYLIB=./lib irb -r './lib/beintoo'

data/spec/beintoo/beintoo_player_spec.rb

@@ -0,0 +1,49 @@
+require 'spec_helper'
+
+describe 'BeintooPlayer' do
+  before :each do
+    set_testing_data
+  end
+
+  it "Should login/logout Player" do
+    player = Beintoo::Player.new
+    player.respond_to?(:logout).should be true
+    player.login
+    player.logged_in?.should be true
+    if Beintoo.debug
+      puts player.guid
+    end
+    player.logout
+    player.logged_in?.should be false
+  end
+
+  it "Should get player with guid" do
+    player = Beintoo::Player.new guid: "test"
+    player.login
+    player.get_player
+  end
+
+  it "Should have score" do
+    player = Beintoo::Player.new guid: "test"
+    player.login
+    player.respond_to?(:submit_score).should be true
+    player.submit_score(40)
+    if Beintoo.debug
+      puts player.get_player
+    end
+    player.submit_score(30)
+    if Beintoo.debug
+      puts player.get_player
+    end
+    player.submit_score(50)
+    if Beintoo.debug
+      puts player.get_player
+    end
+  end
+
+  it "Should assign a reward to the Beintoo::Player" do
+    player = Beintoo::Player.new guid: "BeintooGemTest_#{rand(300)}"
+    player.login
+    player.assign_reward
+  end
+end

data/spec/beintoo/beintoo_user_spec.rb

@@ -0,0 +1,27 @@
+require 'spec_helper'
+
+describe 'BeintooUser' do
+  before :each do
+    set_testing_data
+  end
+
+  it "Should generate a Beintoo::User for a Beintoo::Player" do
+    player = Beintoo::Player.new guid: "test#{rand(300)}"
+    player.login
+    user = player.user.create email: "foo_bar+#{rand(300)}@example.com", name: "Foo Bar", nickname: "foo_bar"
+    if Beintoo.debug
+      puts player.user.get_user_params
+      puts user.inspect
+    end
+    user.id.should_not be nil
+  end
+
+  it "Should generate a reward for a Beintoo::User" do
+    player = Beintoo::Player.new guid: "test#{rand(300)}"
+    player.login
+    user = player.user.create email: "foo_bar+#{rand(300)}@example.com", name: "Foo Bar", nickname: "foo_bar"
+    user.potential_rewards
+    user.list_rewards
+  end
+
+end

data/spec/beintoo/model_additions_spec.rb

@@ -0,0 +1,49 @@
+require 'spec_helper'
+
+class User < SuperModel::Base
+  include SuperModel::RandomID
+  extend Beintoo::ModelAdditions
+  acts_as_beintoo_user guid_field: :id, email_field: :email, name_field: :name, nickname_field: :nickname
+end
+
+describe Beintoo::ModelAdditions do
+  before :each do
+    set_testing_data
+  end
+
+  it "should create a player with a user" do
+    u = User.create email: "foo_bar+#{rand(1000)}@example.com", name: "Foo Bar", nickname: "foo_bar"
+    u.beintoo_player.class.should be Beintoo::Player
+    u.beintoo_user.class.should be Beintoo::User
+    u.beintoo_user.email.should match(/foo_bar/)
+  end
+
+  it "should retrieve a player with his user" do
+    # if player has already a user we should fetch him from beintoo and istantiate it locally
+    u = User.create id: 1234567, email: "foobar@example.com", name: "Foo Bar", nickname: "foo_bar"
+    u.beintoo_player.class.should be Beintoo::Player
+    u.beintoo_user.class.should be Beintoo::User
+    u.beintoo_user.name.should match(/Foo/)
+    u.beintoo_user.id.should_not be nil
+
+    u.respond_to?(:beintoo_get_potential_rewards).should be true
+    rews = u.beintoo_get_potential_rewards
+
+    u.beintoo_list_rewards.should_not include rews.first
+
+    u.respond_to?(:beintoo_accept_reward).should be true
+    u.beintoo_accept_reward(rews.first).should be true # XXX see XXX on vgood.rb
+
+    u.respond_to?(:beintoo_list_rewards).should be true
+    u.beintoo_list_rewards.should include rews.first
+  end
+
+  it "should return a beintoo connect url when creating a user with an existing email" do
+    u = User.create id: 22222, email: "foobar@example.com", name: "Mario", nickname: "Rossi"
+    u.beintoo_player.class.should be Beintoo::Player
+    bu = u.beintoo_user
+    bu.class.should be String
+    puts bu
+  end
+
+end

data/spec/beintoo/real_usage_spec.rb

@@ -0,0 +1,24 @@
+require 'spec_helper'
+
+describe 'BeintooUsage' do
+  before :each do
+    set_real_case_data
+  end
+
+  it "should create a player" do
+    player = Beintoo::Player.new guid: "1"
+    player.login
+    puts player.submit_score(0, nil, 0)
+    sleep 1
+    puts player.get_player
+    sleep 1
+    binding.pry
+    player.last_score.should eq 0.0
+    player.submit_score(30)
+    sleep 1
+    player.last_score.should eq 30.0
+    player.submit_score(40)
+    sleep 1
+    player.last_score.should eq 70.0
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,23 @@
+require 'rubygems'
+require 'supermodel'
+require 'beintoo'
+require 'rspec'
+require 'pry'
+
+def set_testing_data
+  Beintoo.configure do |config|
+    config.apikey  = "1234567890"
+    config.redirect_uri = "http://localhost:3000"
+    config.sandbox = true
+    config.debug   = true
+  end
+end
+
+def set_real_case_data
+  # Beintoo.configure do |config|
+  #   config.apikey  = ""
+  #   config.sandbox = false
+  #   config.debug   = true
+  # end
+  pending "Add your config block in spec/spec_helper.rb"
+end

metadata

@@ -0,0 +1,160 @@
+--- !ruby/object:Gem::Specification
+name: beintoo
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Enrico Carlesso
+- Mattia Gheda
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-02-15 00:00:00.000000000Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: &70094414489660 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70094414489660
+- !ruby/object:Gem::Dependency
+  name: supermodel
+  requirement: &70094414489240 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70094414489240
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: &70094414488820 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70094414488820
+- !ruby/object:Gem::Dependency
+  name: rest-client
+  requirement: &70094414488380 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *70094414488380
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: &70094414487960 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *70094414487960
+- !ruby/object:Gem::Dependency
+  name: json
+  requirement: &70094414487540 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *70094414487540
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: &70094414487100 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *70094414487100
+description: This gem tries to wrap the Beintoo API (http://documentation.beintoo.com)
+  to a ruby friendly Module meant to be used within Ruby on Rails applications
+email:
+- enricocarlesso@gmail.com
+- ghedamat@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .rspec
+- CHANGELOG
+- Gemfile
+- README.md
+- Rakefile
+- beintoo.gemspec
+- lib/beintoo.rb
+- lib/beintoo/api_exception.rb
+- lib/beintoo/app.rb
+- lib/beintoo/model_additions.rb
+- lib/beintoo/player.rb
+- lib/beintoo/railtie.rb
+- lib/beintoo/user.rb
+- lib/beintoo/version.rb
+- lib/beintoo/vgood.rb
+- lib/generators/beintoo_generator.rb
+- lib/generators/templates/beintoo.rb
+- script/console
+- spec/beintoo/beintoo_player_spec.rb
+- spec/beintoo/beintoo_user_spec.rb
+- spec/beintoo/model_additions_spec.rb
+- spec/beintoo/real_usage_spec.rb
+- spec/spec_helper.rb
+homepage: http://www.beintoo.com
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
+      - 0
+      hash: -40742333141001870
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
+      - 0
+      hash: -40742333141001870
+requirements: []
+rubyforge_project: beintoo
+rubygems_version: 1.8.10
+signing_key: 
+specification_version: 3
+summary: Ruby Wrapper for the Beintoo API
+test_files:
+- spec/beintoo/beintoo_player_spec.rb
+- spec/beintoo/beintoo_user_spec.rb
+- spec/beintoo/model_additions_spec.rb
+- spec/beintoo/real_usage_spec.rb
+- spec/spec_helper.rb