flox 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 219bdba8d257f7a35c1b9174877fc74775ce0a89
+  data.tar.gz: cc1abbb765aa82c4b6c3d650e308869b9594361e
+SHA512:
+  metadata.gz: 77c3fe30874b4bd0531108be4965dfa5178813712f319346cd167fa9b41985737904e095375b7b64792a0135275d1231d1817ba16e023d20b9c4906a5c4d4c86
+  data.tar.gz: 01509872cb9f839e79bd2941894d01eee92f5b238404e75aff60f1dba2a4099a0e05e96936840e617a070172ea5e2f0adc993986c95bb03540af14426bc3c9cf

data/bin/flox

@@ -0,0 +1,102 @@
+#!/usr/bin/env ruby
+
+## Author:    Daniel Sperl
+## Copyright: Copyright 2014 Gamua
+## License:   Simplified BSD
+
+$LOAD_PATH << '../lib'
+
+require 'flox'
+require 'fileutils'
+require 'trollop'
+
+class Worker
+
+  attr_reader :flox
+
+  def initialize(game_id, game_key, base_url)
+    @flox = Flox.new(game_id, game_key, base_url)
+  end
+
+  def login_with_key(key)
+    flox.login_with_key(key)
+  end
+
+  def execute(command_name, args)
+    begin
+      method_name = command_name.downcase.gsub("-", "_")
+      self.send(method_name, **args)
+    rescue Exception => e
+      log "Error: " + e.to_s
+    end
+  end
+
+  private
+
+  def download_logs(args={})
+    query = args[:query]
+    limit = args[:limit]
+    destination = args[:destination] || Dir.pwd
+    FileUtils.mkdir_p(destination)
+
+    log "Fetching Logs ..."
+    log_ids = flox.load_log_ids(query, limit)
+    log_ids.each do |log_id|
+      remote_path = "logs/#{log_id}"
+      local_path = File.join(destination, log_id) + ".json"
+      load_and_save_resource(remote_path, local_path)
+    end
+  end
+
+  def status(args={})
+    log "Fetching Server Status ..."
+    status = flox.status
+    log "Version: #{status['version']}, status: #{status['status']}"
+  end
+
+  def log(message)
+    puts message
+  end
+
+  def fail(message)
+    log message
+    exit
+  end
+
+  def load_and_save_resource(remote_path, local_path)
+    if (File.exists? local_path)
+      log("Skipped #{local_path} (file exists)")
+    else
+      resource = flox.load_resource(remote_path)
+      File.write(local_path, JSON.pretty_generate(resource))
+      log("Saved #{local_path}")
+    end
+  end
+
+end
+
+options = Trollop::options do
+  banner "Administrative utility for the Flox.cc Game Backend"
+  opt :key, "The 'Hero' key used for authentication", :type => :string, :required => true
+  opt :game_id, "The ID of the game", :type => :string, :required => true
+  opt :game_key, "The key of the game", :type => :string, :required => true
+  opt :base_url, "The URL of the Flox service", :type => :string
+  opt :destination, "The directory in which to store the logs", :type => :string
+  opt :query, "Narrows down the list of results", :type => :string
+  opt :limit, "Maximum number of logs to download", :type => :int
+end
+
+commands = ARGV.clone
+# puts "Optons: #{options}"
+
+hero_key = options[:key]
+game_id  = options[:game_id]
+game_key = options[:game_key]
+base_url = options[:base_url] || Flox::DEFAULT_URL
+
+worker = Worker.new(game_id, game_key, base_url)
+worker.login_with_key(hero_key)
+
+commands.each do |command|
+  worker.execute(command, options)
+end

data/lib/flox.rb

@@ -0,0 +1,203 @@
+## Author:    Daniel Sperl
+## Copyright: Copyright 2014 Gamua
+## License:   Simplified BSD
+
+# The main class used to interact with the Flox cloud service. Create an
+# instance of Flox using the game ID and key acquired from the web interface,
+# then login with a "Hero" key. That way, you will be able to access the data
+# of all players.
+class Flox
+
+  # The URL where the Flox servers are found.
+  DEFAULT_URL = "https://www.flox.cc"
+
+  # @private
+  attr_reader :service
+
+  # The player that is currently logged in.
+  attr_reader :current_player
+
+  # Creates a new instance with a certain game ID and key. Per default, a guest
+  # player will be logged in. You probably need to call 'login_with_key' with a
+  # Hero-key to access your data.
+  def initialize(game_id, game_key, base_url=Flox::DEFAULT_URL)
+    @service = RestService.new(game_id, game_key, base_url)
+    self.login_guest
+  end
+
+  # Makes a key-login on the server. It is recommended to create a 'hero'
+  # player in the web interface and use that for the login.
+  def login_with_key(key)
+    login(:key, key)
+  end
+
+  # Creates a new guest player and logs it in.
+  def login_guest()
+    login(:guest)
+  end
+
+  # Logging out the current player automatically logs in a new guest.
+  alias_method :logout, :login_guest
+
+  # @private
+  def login(auth_type, auth_id=nil, auth_token=nil)
+      data = service.login(auth_type, auth_id, auth_token)
+      @current_player = Player.new(data['id'], data['entity'])
+  end
+
+  # Loads an entity with a certain type and id from the server.
+  # Normally, the type is the class name you used for the entity in your game.
+  # Returns a Flox::Entity instance.
+  def load_entity(type, id)
+    path = entity_path(type, id)
+    data = service.get(path)
+    if (type == '.player')
+      Player.new(id, data)
+    else
+      Entity.new(type, id, data)
+    end
+  end
+
+  # Stores an entity on the server.
+  def save_entity(entity)
+    result = service.put(entity.path, entity)
+    entity['updatedAt'] = result['updatedAt']
+    entity['createdAt'] = result['createdAt']
+    entity
+  end
+
+  # :call-seq:
+  #   delete_entity(entity)
+  #   delete_entity(type, id)
+  #
+  # Deletes the given entity from the database.
+  def delete_entity(*entity)
+    if entity.length > 1
+      type, id = entity[0], entity[1]
+    else
+      type, id = entity[0].type, entity[0].id
+    end
+    service.delete(entity_path(type, id))
+    nil
+  end
+
+  # Posts a score to a certain leaderboard. Beware that only the top score of
+  # a player will appear on the leaderboard.
+  def post_score(leaderboard_id, score, player_name)
+    path = leaderboard_path(leaderboard_id)
+    data = { playerName: player_name, value: score }
+    service.post(path, data)
+  end
+
+  # Loads all scores of a leaderboard, sorted by rank. 'scope' can either be
+  # one of the symbols +:today, :this_week, :all_time+ or an array of player IDs.
+  def load_scores(leaderboard_id, scope)
+    path = leaderboard_path(leaderboard_id)
+    args = {}
+
+    if scope.is_a?(Array)
+      args['p'] = scope
+    else
+      args['t'] = scope.to_s.to_camelcase
+    end
+
+    raw_scores = service.get(path, args)
+    raw_scores.collect { |raw_score| Score.new(raw_score) }
+  end
+
+  # Loads a JSON object from the given path. This works with any resource
+  # e.g. entities, logs, etc. Always returns a Hash.
+  def load_resource(path, args=nil)
+    service.get(path, args)
+  end
+
+  # Loads a log with a certain ID. A log is a Hash instance.
+  def load_log(log_id)
+    log = service.get log_path(log_id)
+    log['id'] = log_id unless log['id']
+    log
+  end
+
+  # Loads logs, optionally restricted by a certain query.
+  # Here are some sample queries:
+  #
+  # * 'day:2014-02-20' -> all logs of a certain day
+  # * 'severity:warning' -> all logs of type warning & error
+  # * 'severity:error' -> all logs of type error
+  # * 'day:2014-02-20 severity:error' all error logs from February 20th.
+  #
+  # Returns a Flox::ResourceEnumerator you can use to iterate
+  # over the logs.
+  def load_logs(query=nil, limit=nil)
+    log_ids = load_log_ids(query, limit)
+    paths = log_ids.map { |log_id| log_path(log_id) }
+    ResourceEnumerator.new(service, paths)
+  end
+
+  # Loads just the IDs of the logs, restricted by a certain query.
+  def load_log_ids(query=nil, limit=nil)
+    log_ids = []
+    cursor = nil
+    begin
+      args = {}
+      args['q'] = query  if query
+      args['l'] = limit  if limit
+      args['c'] = cursor if cursor
+
+      result = service.get "logs", args
+      cursor = result["cursor"]
+      log_ids += result["ids"]
+      limit -= log_ids.length if limit
+    end while !cursor.nil? and (limit.nil? or limit > 0)
+    log_ids
+  end
+
+  # Loads the status of the Flox service, which is a Hash with the
+  # keys 'status' and 'version'.
+  def status
+    service.get("")
+  end
+
+  # The ID of the game you are accessing.
+  def game_id
+    service.game_id
+  end
+
+  # The key of the game you are accessing.
+  def game_key
+    service.game_key
+  end
+
+  # The base URL of the Flox service.
+  def base_url
+    service.base_url
+  end
+
+  # @return [String] a string representation of the object.
+  def inspect
+    "[Flox game_id: '#{game_id}', base_url: '#{base_url}']"
+  end
+
+  private
+
+  def entity_path(type, id)
+    "entities/#{type}/#{id}"
+  end
+
+  def leaderboard_path(leaderboard_id)
+    "leaderboards/#{leaderboard_id}"
+  end
+
+  def log_path(log_id)
+    "logs/#{log_id}"
+  end
+
+end
+
+require 'flox/version'
+require 'flox/utils'
+require 'flox/rest_service'
+require 'flox/entity'
+require 'flox/player'
+require 'flox/score'
+require 'flox/resource_enumerator'

data/lib/flox/entity.rb

@@ -0,0 +1,103 @@
+## Author:    Daniel Sperl
+## Copyright: Copyright 2014 Gamua
+## License:   Simplified BSD
+
+require 'time'
+
+# The base class of all objects that can be stored persistently on the Flox
+# server.
+#
+# The class extends `Hash`. Thus, all properties of the Entity can be accessed
+# as keys of the Entity instance.
+#
+#     entity['name'] = 'Donald Duck'
+#
+# For convenience, the standard entity properties (e.g. `created_at` and
+# `updated_at`)can be accessed via Ruby attributes.
+#
+#     entity.public_access = 'rw'
+#
+# To load and save an entity, use the respective methods on the Flox class.
+#
+#     my_entity = flox.load_entity('SaveGame', '12345') # => Flox::Entity
+#     flox.save_entity(my_entity)
+#
+class Flox::Entity < Hash
+
+  # @return [String] the primary identifier of the entity.
+  attr_accessor :id
+
+  # @return [String] the type of the entity. Types group entities together on the server.
+  attr_reader :type
+
+  # @param type [String] Typically the class name of the entity (as used in the other SDKs).
+  # @param id [String] The unique identifier of the entity.
+  # @param data [Hash] The initial contents of the entity.
+  def initialize(type, id=nil, data=nil)
+    @type = type
+    @id = id ? id : String.random_uid
+    self['createdAt'] = self['updatedAt'] = Time.now.utc.to_xs_datetime
+    self.public_access = ''
+    self.merge!(data) if data
+  end
+
+  def created_at
+    Time.parse self['createdAt']
+  end
+
+  def updated_at
+    Time.parse self['updatedAt']
+  end
+
+  def public_access
+    self["publicAccess"]
+  end
+
+  def public_access=(access)
+    self["publicAccess"] = access.to_s
+  end
+
+  def owner_id
+    self["ownerId"]
+  end
+
+  def owner_id=(value)
+    self["ownerId"] = value.to_s
+  end
+
+  def path
+    "entities/#{@type}/#{@id}"
+  end
+
+  # @return [String] provides a simple string representation of the Entity.
+  def inspect
+    description = "[#{self.class} #{@id} (#{@type})\n"
+    each_pair do |key, value|
+      description += "    #{key}: #{value}\n"
+    end
+    description += "]"
+  end
+
+  #
+  # documentation hints
+  #
+
+  # @!attribute owner_id
+  #   @return [String] the player ID of the owner of the entity
+  #     (referencing a Player entitity).
+
+  # @!attribute created_at
+  #   @return [Time] the time the entity was created.
+
+  # @!attribute updated_at
+  #   @return [Time] the time the entity was last changed on the server.
+
+  # @!attribute public_access
+  #   @return [String] the access rights of all players except the owner
+  #     (the owner always has unlimited access). Possible values: '', 'r', 'rw'
+
+  # @!attribute [r] path
+  #   @return [String] the path to the REST-resource of the entity, relative
+  #     to the game's root.
+
+end

data/lib/flox/player.rb

@@ -0,0 +1,43 @@
+## Author:    Daniel Sperl
+## Copyright: Copyright 2014 Gamua
+## License:   Simplified BSD
+
+# An Entity that contains information about a Flox Player.
+# Normally, you don't create instances of `Player` yourself. There's always
+# a player logged in you can access with
+#
+#     flox.current_player # => Flox::Player
+#
+# To log in as a different player, you'll probably want to use a `key`-login.
+# When you use the Flox Gem as a maintenance tool, create a "Hero" in the
+# online interface and use its key to login. That way, you have access to
+# all entities, regardless of their `public_access` values.
+#
+#     flox.login_with_key 'hero-key' # => Flox::Player
+#
+# The Player class itself is just an entity that adds an `auth_type`
+# property for your convenience.
+class Flox::Player < Flox::Entity
+
+  # Creates a player with a certain ID and data. The `type` of a player
+  # is always `.player` in Flox.
+  def initialize(id=nil, data=nil)
+    data ||= {}
+    data["authType"] ||= "guest"
+    data["publicAccess"] ||= "r"
+    super(".player", id, data)
+    self.owner_id ||= self.id
+  end
+
+  def auth_type
+    self["authType"].to_sym
+  end
+
+  #
+  # documentation hints
+  #
+
+  # @!attribute auth_type
+  #   @return [String] the type of authentication the player used to log in.
+
+end

data/lib/flox/resource_enumerator.rb

@@ -0,0 +1,43 @@
+## Author:    Daniel Sperl
+## Copyright: Copyright 2014 Gamua
+## License:   Simplified BSD
+
+require 'json'
+
+# A helper class that stores the paths to a number of REST resources and
+# supports iterating over those resources, downloading them lazily from the
+# server.
+class Flox::ResourceEnumerator
+
+  include Enumerable
+
+  # @param rest_service [RestService]
+  #        the service instance used to download the resources.
+  # @param paths [Array<String>]
+  #        the URLs to the resources that need to be accessed, relative to
+  #        the game's root.
+  def initialize(rest_service, paths)
+    @service = rest_service
+    @paths = paths
+  end
+
+  # Iterates over the resources provided on intialization, loading them
+  # from the server one by one.
+  def each
+    @paths.each do |path|
+      yield @service.get(path)
+    end
+  end
+
+  def length
+    @paths.length
+  end
+
+  #
+  # documentation hints
+  #
+
+  # @!attribute length
+  #   @return [Fixnum] the total number of objects being enumerated.
+
+end

data/lib/flox/rest_service.rb

@@ -0,0 +1,128 @@
+## Author:    Daniel Sperl
+## Copyright: Copyright 2014 Gamua
+## License:   Simplified BSD
+
+require 'json'
+require 'yaml'
+require 'net/http'
+
+# A class that makes it easy to communicate with the Flox server via a REST protocol.
+class Flox::RestService
+
+  # @return [String] the unique identifier of the game.
+  attr_reader :game_id
+
+  # @return [String] the key that identifies the game.
+  attr_reader :game_key
+
+  # @return [String] the URL pointing to the Flox REST API.
+  attr_reader :base_url
+
+  def initialize(game_id, game_key, base_url)
+    @game_id = game_id
+    @game_key = game_key
+    @base_url = base_url
+    @authentication = { "authType" => "guest" }
+  end
+
+  # Makes a `GET` request at the server. The given data-Hash is URI-encoded
+  # and added to the path.
+  # @return the server response.
+  def get(path, data=nil)
+    path = full_path(path)
+    path += "?" + URI.encode_www_form(data) if data
+    request = Net::HTTP::Get.new(path)
+    execute(request)
+  end
+
+  # Makes a `DELETE` request at the server.
+  # @return the server response.
+  def delete(path)
+    request = Net::HTTP::Delete.new(full_path(path))
+    execute(request)
+  end
+
+  # Makes a `POST` request at the server. The given data-Hash is transferred
+  # in the body of the request.
+  # @return the server response.
+  def post(path, data=nil)
+    request = Net::HTTP::Post.new(full_path(path))
+    execute(request, data)
+  end
+
+  # Makes a `PUT` request at the server. The given data-Hash is transferred
+  # in the body of the request.
+  # @return the server response.
+  def put(path, data=nil)
+    request = Net::HTTP::Put.new(full_path(path))
+    execute(request, data)
+  end
+
+  # Makes a login on the server with the given authentication data.
+  # @return the server response.
+  def login(auth_type, auth_id=nil, auth_token=nil)
+    auth_data = {
+      "authType"  => auth_type,
+      "authId"    => auth_id,
+      "authToken" => auth_token,
+      "id"        => auth_id
+    }
+
+    if (auth_type.to_sym == :guest)
+      response = auth_data
+    else
+      response = post("authenticate", auth_data)
+      auth_data["id"] = response["id"]
+    end
+
+    @authentication = auth_data
+    response
+  end
+
+  # @return [String] provides a simple string representation of the service.
+  def inspect
+    "[RestService game_id: #{game_id}, base_url: #{base_url}]"
+  end
+
+  private
+
+  def execute(request, data=nil)
+    flox_header = {
+      "sdk" => { "type" => "ruby", "version" => Flox::VERSION },
+      "gameKey" => @game_key,
+      "dispatchTime" => Time.now.utc.to_xs_datetime,
+      "player" => @authentication
+    }
+
+    request["Content-Type"] = "application/json"
+    request["X-Flox"] = flox_header.to_json
+    request.body = data.to_json if data
+
+    uri = URI.parse(@base_url)
+    http = Net::HTTP::new(uri.host, uri.port)
+
+    if uri.scheme == "https"  # enable SSL/TLS
+      http.verify_mode = OpenSSL::SSL::VERIFY_NONE
+      http.use_ssl = true
+    end
+
+    http.start do |session|
+      response = session.request(request)
+      if (response.is_a? Net::HTTPSuccess)
+        return JSON.parse(response.body || '{}')
+      else
+        message = begin
+          JSON.parse(response.body)['message']
+        rescue
+          response.body
+        end
+        raise message
+      end
+    end
+  end
+
+  def full_path(path)
+    "/api/games/#{@game_id}/#{path}"
+  end
+
+end

data/lib/flox/score.rb

@@ -0,0 +1,34 @@
+## Author:    Daniel Sperl
+## Copyright: Copyright 2014 Gamua
+## License:   Simplified BSD
+
+# Provides information about the value and origin of one posted score entry.
+class Flox::Score
+
+  # @return [String] the ID of the player who posted the score.
+  #   Note that this could be a guest player unknown to the server.
+  attr_reader :player_id
+
+  # @return [String] the name of the player who posted the score.
+  attr_reader :player_name
+
+  # @return [Fixnum] the actual score.
+  attr_reader :value
+
+  # @return [String] the country from which the score originated, in a
+  #   two-letter country code.
+  attr_reader :country
+
+  # @return [Time] the date at which the score was posted.
+  attr_reader :created_at
+
+  # @param data [Hash] the contents of the score as given by the Flox server.
+  def initialize(data)
+    @player_id = data['playerId'].to_s
+    @player_name = data['playerName'].to_s
+    @value = data['value'].to_i
+    @country = data['country'].to_s
+    @created_at = Time.parse(data['createdAt'].to_s)
+  end
+
+end

data/lib/flox/utils.rb

@@ -0,0 +1,38 @@
+## Author:    Daniel Sperl
+## Copyright: Copyright 2014 Gamua
+## License:   Simplified BSD
+
+require 'securerandom'
+
+# Flox-extensions to the standard Time class.
+class Time
+
+  # @return [String] an XS-DateTime representation of the string, like this:
+  #   `2014-02-20T20:15:00.123Z`
+  def to_xs_datetime
+    strftime("%Y-%m-%dT%H:%M:%S.%LZ")
+  end
+
+end
+
+# Flox-extensions to the standard Time class.
+class String
+
+  # @return [String] creates a random alphanumeric string with a given length.
+  def self.random_uid(length=16)
+    SecureRandom.base64(length * 2).gsub(/[\+\/]/, '').slice(0, length)
+  end
+
+  # @return [String] converts a `camelCase` string to its `under_score` equivalent.
+  def to_underscore
+    gsub(/(.)([A-Z])/,'\1_\2').downcase
+  end
+
+  # @return [String] converts a string that separates its words with space,
+  #   underscore or dash into its `camelCase` equivalent.
+  def to_camelcase
+    words = downcase.split(/[_\-\s]/)
+    words.shift + words.map(&:capitalize).join
+  end
+
+end

data/lib/flox/version.rb

@@ -0,0 +1,10 @@
+## Author:    Daniel Sperl
+## Copyright: Copyright 2014 Gamua
+## License:   Simplified BSD
+
+class Flox
+
+  # The current version of the Flox SDK.
+  VERSION = "0.0.1"
+
+end

data/test/test_entity.rb

@@ -0,0 +1,52 @@
+## Author:    Daniel Sperl
+## Copyright: Copyright 2014 Gamua
+## License:   Simplified BSD
+
+require 'flox'
+require 'test/unit'
+
+class EntityTest < Test::Unit::TestCase
+
+  def test_init
+    type = "type"
+    id = "id"
+    data = { value: true }
+    entity = Flox::Entity.new(type, id, data)
+    assert_equal(type, entity.type)
+    assert_equal(id, entity.id)
+    assert_equal(data[:value], entity[:value])
+    assert_not_nil(entity.created_at)
+    assert_not_nil(entity.updated_at)
+    assert_not_nil(entity.public_access)
+  end
+
+  def test_init_without_id
+    entity = Flox::Entity.new("type")
+    assert_kind_of(String, entity.id)
+    assert_not_empty(entity.id)
+  end
+
+  def test_created_at
+    created_at = Time.parse("2014-02-20T11:00:00Z")
+    created_at_string = created_at.to_xs_datetime
+    entity = Flox::Entity.new('type', 'id')
+    entity['createdAt'] = created_at_string
+    assert_equal(created_at, entity.created_at)
+  end
+
+  def test_updated_at
+    updated_at = Time.parse("2014-02-20T11:00:00Z")
+    updated_at_string = updated_at.to_xs_datetime
+    entity = Flox::Entity.new('type', 'id')
+    entity['updatedAt'] = updated_at_string
+    assert_equal(updated_at, entity.updated_at)
+  end
+
+  def test_public_access
+    entity = Flox::Entity.new('type', 'id')
+    assert_equal('', entity.public_access)
+    entity.public_access = 'rw'
+    assert_equal('rw', entity.public_access)
+  end
+
+end

data/test/test_flox.rb

@@ -0,0 +1,152 @@
+## Author:    Daniel Sperl
+## Copyright: Copyright 2014 Gamua
+## License:   Simplified BSD
+
+require 'flox'
+require 'test/unit'
+require 'mocha/test_unit'
+
+class FloxTest < Test::Unit::TestCase
+
+  GAME_ID  = "game_id"
+  GAME_KEY = "game_key"
+  BASE_URL = "http://url.com"
+
+  attr_reader :flox
+
+  def setup
+    @flox = Flox.new(GAME_ID, GAME_KEY, BASE_URL)
+  end
+
+  def test_init
+    assert_equal(GAME_ID, flox.game_id)
+    assert_equal(GAME_KEY, flox.game_key)
+    assert_equal(BASE_URL, flox.base_url)
+
+    assert_kind_of(Flox::Player, flox.current_player)
+    assert_equal(:guest, flox.current_player.auth_type)
+  end
+
+  def test_post_score
+    flox.service.expects(:post).once
+    flox.post_score('leaderboard_id', 123, 'player_name')
+  end
+
+  def test_load_scores
+    leaderboard_id = "dummy"
+    path = "leaderboards/#{leaderboard_id}"
+    raw_score = {
+      'value' => 20,
+      'playerName' => 'hugo',
+      'playerId' => '123',
+      'country' => 'at',
+      'createdAt' => '2014-02-24T20:15:00.123Z'
+    }
+
+    # using time scope (t)
+    flox.service.expects(:get).once.with(path, has_key('t')).returns([])
+    scores = flox.load_scores(leaderboard_id, :today)
+    assert_kind_of(Array, scores)
+    assert_equal(0, scores.length)
+
+    # using player scope (p)
+    flox.service.expects(:get).once.with(path, has_key('p')).returns([raw_score])
+    scores = flox.load_scores(leaderboard_id, %w(1, 2, 3))
+    assert_kind_of(Array, scores)
+    assert_equal(1, scores.length)
+
+    highscore = scores.first
+    assert_kind_of(Flox::Score, highscore)
+    assert_equal(raw_score['value'], highscore.value)
+    assert_equal(raw_score['playerName'], highscore.player_name)
+    assert_equal(raw_score['playerId'], highscore.player_id)
+    assert_equal(raw_score['country'], highscore.country)
+    assert_equal(raw_score['createdAt'], highscore.created_at.to_xs_datetime)
+  end
+
+  def test_login_with_key
+    key = "key"
+    result = { 'id' => '123', 'entity' => { 'authType' => 'key' } }
+    flox.service.expects(:login).with(:key, key, nil).once.returns(result)
+    player = flox.login_with_key(key)
+    assert_not_nil(player)
+    assert_equal(:key, player.auth_type)
+    assert_equal(player, flox.current_player)
+  end
+
+  def test_login_guest
+    player = flox.login_guest
+    assert_not_nil(player)
+    assert_equal(:guest, player.auth_type)
+    assert_equal(player, flox.current_player)
+  end
+
+  def test_load_entity
+    type = "type"
+    id   = "id"
+    path = "entities/#{type}/#{id}"
+    data = { "name" => "Jean-Luc" }
+
+    flox.service.expects(:get).with(path).once.returns(data)
+    entity = flox.load_entity(type, id)
+
+    assert_kind_of(Flox::Entity, entity)
+    assert_equal(id, entity.id)
+    assert_equal(type, entity.type)
+    assert_equal(path, entity.path)
+    assert_equal(data["name"], entity["name"])
+  end
+
+  def test_save_entity
+    data   = { "name" => "Jean-Luc" }
+    entity = Flox::Entity.new("type", "id", data)
+    path   = "entities/#{entity.type}/#{entity.id}"
+    result = { "createdAt" => "2014-01-01T12:00:00.000Z",
+               "updatedAt" => "2014-02-01T12:00:00.000Z" }
+
+    flox.service.expects(:put).with(path, entity).once.returns(result)
+    flox.save_entity(entity)
+
+    assert_equal(result["createdAt"], entity.created_at.to_xs_datetime)
+    assert_equal(result["updatedAt"], entity.updated_at.to_xs_datetime)
+  end
+
+  def test_delete_entity
+    entity = Flox::Entity.new("type", "id")
+    path   = "entities/#{entity.type}/#{entity.id}"
+    flox.service.expects(:delete).with(path)
+    flox.delete_entity(entity)
+  end
+
+  def test_find_logs
+    log_ids = %w{ 0 1 2 }
+    result = { 'ids' => log_ids, 'cursor' => nil }
+    flox.service.expects(:get).at_most_once.returns(result)
+    logs = flox.load_logs(':warning', 50)
+    assert_kind_of(Flox::ResourceEnumerator, logs)
+    assert_equal(log_ids.length, logs.length)
+    flox.service.expects(:get).times(log_ids.length).returns({})
+    logs.each { |log| assert_kind_of(Hash, log) }
+  end
+
+  def test_find_log_ids
+    log_ids   = %w{ 0 1 2 3 4 5 6 7 8 9 }
+    log_ids_a = log_ids.slice 0, 5
+    log_ids_b = log_ids.slice 5, 5
+    result_a = { 'ids' => log_ids_a, 'cursor' => 'a' }
+    result_b = { 'ids' => log_ids_b, 'cursor' => nil }
+
+    # without limit
+    flox.service.expects(:get).twice.returns(result_a, result_b)
+    out_log_ids = flox.load_log_ids
+    assert_equal(log_ids.length, out_log_ids.length)
+
+    # with limit
+    limit = 7
+    result_b['ids'] = %w{ 5 6 }
+    flox.service.expects(:get).twice.returns(result_a, result_b)
+    out_log_ids = flox.load_log_ids(nil, limit)
+    assert_equal(limit, out_log_ids.length)
+  end
+
+end

data/test/test_utils.rb

@@ -0,0 +1,34 @@
+## Author:    Daniel Sperl
+## Copyright: Copyright 2014 Gamua
+## License:   Simplified BSD
+
+require 'flox'
+require 'test/unit'
+
+class EntityTest < Test::Unit::TestCase
+
+  def test_random_uid
+    length = 16
+    uid = String.random_uid(length)
+    assert_equal(length, uid.length)
+    assert_match(/^[a-zA-Z0-9]+$/, uid)
+  end
+
+  def test_xs_datetime
+    time_xs = "2014-02-20T11:00:00.124Z"
+    time = Time.parse(time_xs)
+    assert_equal(time_xs, time.to_xs_datetime)
+  end
+
+  def test_to_camelcase
+    assert_equal("homeSweetHome", "home_sweet_home".to_camelcase)
+    assert_equal("homeSweetHome", "hOME-sWEET-hOME".to_camelcase)
+    assert_equal("homeSweetHome", "Home Sweet Home".to_camelcase)
+  end
+
+  def test_to_underscore
+    assert_equal("home_sweet_home", "HomeSweetHome".to_underscore)
+    assert_equal("home_sweet_home", "homeSweetHome".to_underscore)
+  end
+
+end

metadata

@@ -0,0 +1,102 @@
+--- !ruby/object:Gem::Specification
+name: flox
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Daniel Sperl
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-02-21 00:00:00.000000000 Z
+dependencies:
+- !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'
+- !ruby/object:Gem::Dependency
+  name: mocha
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: yard
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.8'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.8'
+description: |
+  Flox is the no-fuzz backend for game developers. The Ruby SDK allows direct
+  interaction with the Flox servers, e.g. to download log files or update
+  specific entities. It can be used from other Ruby scripts or directly with
+  its bundled command-line utility.
+email: daniel@gamua.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- bin/flox
+- test/test_entity.rb
+- test/test_flox.rb
+- test/test_utils.rb
+- lib/flox/entity.rb
+- lib/flox/player.rb
+- lib/flox/resource_enumerator.rb
+- lib/flox/rest_service.rb
+- lib/flox/score.rb
+- lib/flox/utils.rb
+- lib/flox/version.rb
+- lib/flox.rb
+homepage: https://www.flox.cc
+licenses:
+- Simplified BSD
+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: Ruby SDK for the flox.cc game backend
+test_files: []
+has_rdoc: