flox 0.1.2 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 7994c4b7087c3bbdd2202eb9078e9a3d718059a1
-  data.tar.gz: 84ca494ed9b601e7a4b5287b9075a6af6ef452cf
+  metadata.gz: 8c588236a3e6206950c5d693305514fe02335a0e
+  data.tar.gz: 9344c387fa0f1ff1a6060b8bff84cb1fdcdc485d
 SHA512:
-  metadata.gz: 866c2b3e215e19adf4751313b126e792efdb747b93fc76bbe6c809373682a000e3be344152587ffee7ba966a03253d70dac67eca4264b88491698232cf1444d2
-  data.tar.gz: 0f9e469c3487c31b559675d24a893c34260742d24f265733e926f9c4fd91c714560807740209221bd0f4d55174a05d23027c10faf244a5d99511105713cb8674
+  metadata.gz: ade435b67774267ec23f818078a756525a542ae1bc7ca7205d4a80e22909eda3e1d45121935a7ee430bdf91dbf4ecb5495e2f5d4f0238de7fd747febe2ae3af8
+  data.tar.gz: cd5754f39054ebf0b8d9cbce960b3c5c6850ee931ff92b3ddc35d58e94d83d2af3a9e38d0b8b98332ff5dbec9c66542691e4edd29e5421b19b03fa0ecafed720

data/README.md

@@ -53,7 +53,7 @@ We're done with the preparations! Now let's look at some of the things you can d
     entity = flox.load_entity('entity-type', 'entity-id') # => Flox::Entity
 
     # modify it via the []-operator
-    entity['myProperty'] = 'something'
+    entity[:myProperty] = 'something'
 
     # save or delete at will
     flox.save_entity(entity)

data/bin/flox

@@ -32,7 +32,7 @@ class Worker
     FileUtils.mkdir_p(destination)
 
     print "Loading log IDs (this could take a moment) ... "
-    log_ids = flox.load_log_ids(query, limit)
+    log_ids = flox.find_log_ids(query, limit)
     puts "found #{log_ids.length} logs."
     log_ids.each do |log_id|
       remote_path = "logs/#{log_id}"

data/lib/flox.rb

@@ -8,9 +8,6 @@
 # of all players.
 class Flox
 
-  # The main Error class, all Exception classes inherit from this class.
-  class Error < StandardError; end
-
   # The URL where the Flox servers are found.
   DEFAULT_URL = "https://www.flox.cc"
 
@@ -49,7 +46,7 @@ class Flox
   # @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'])
+      @current_player = Player.new(data[:id], data[:entity])
   end
 
   # Loads an entity with a certain type and id from the server.
@@ -58,11 +55,7 @@ class Flox
   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
+    create_entity(type, id, data)
   end
 
   # Loads an entity with type '.player'.
@@ -75,8 +68,8 @@ class Flox
   # @return [Flox::Entity]
   def save_entity(entity)
     result = service.put(entity.path, entity)
-    entity['updatedAt'] = result['updatedAt']
-    entity['createdAt'] = result['createdAt']
+    entity[:updatedAt] = result[:updatedAt]
+    entity[:createdAt] = result[:createdAt]
     entity
   end
 
@@ -112,9 +105,9 @@ class Flox
     args = {}
 
     if scope.is_a?(Array)
-      args['p'] = scope
+      args[:p] = scope
     else
-      args['t'] = scope.to_s.to_camelcase
+      args[:t] = scope.to_s.to_camelcase
     end
 
     raw_scores = service.get(path, args)
@@ -128,15 +121,26 @@ class Flox
     service.get(path, args)
   end
 
+  # Loads a bulk of resources from a certain path, optionally feeding them
+  # through a block.
+  # @yield [id, resource] called on every resource; the return-value is feeded
+  #                       into the result array.
+  # @return [Array]
+  def load_resources(path, ids)
+    ids.map do |id|
+      resource = load_resource "#{path}/#{id}"
+      resource = yield id, resource if block_given?
+      resource
+    end
+  end
+
   # Loads a log with a certain ID. A log is a Hash instance.
   # @return [Hash]
   def load_log(log_id)
-    log = service.get log_path(log_id)
-    log['id'] = log_id unless log['id']
-    log
+    service.get log_path(log_id)
   end
 
-  # Loads logs defined by a certain query.
+  # Finds logs defined by a certain query.
   # Here are some sample queries:
   #
   # * `day:2014-02-20` → all logs of a certain day
@@ -144,32 +148,59 @@ class Flox
   # * `severity:error` → all logs of type error
   # * `day:2014-02-20 severity:error` → all error logs from February 20th.
   #
-  # @return [Flox::ResourceEnumerator<Hash>]
-  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)
+  # @return [Array<Hash>]
+  def find_logs(query=nil, limit=nil)
+    log_ids = find_log_ids(query, limit)
+    load_resources('logs', log_ids)
   end
 
-  # Loads just the IDs of the logs, defined by a certain query.
+  # Finds just the IDs of the logs, defined by a certain query.
+  # @see {#find_logs}
   # @return [Array<String>]
-  def load_log_ids(query=nil, limit=nil)
+  def find_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
+      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"]
+      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
 
+  # Executes a query over Entities, using a simple SQL-like syntax.
+  # @see Flox::Query
+  #
+  # @overload find_entities(query)
+  #   @param query [Flox::Query] the query to execute
+  # @overload find_entities(entity_type, constraints=nil, *args)
+  #   @param type [String, Symbol, Class] the type of the entity
+  #   @param query [String] the query string with optional '?' placeholders
+  def find_entities(*query)
+    query = create_query(*query)
+    ids = find_entity_ids(query)
+    load_resources "entities/#{query.type}", ids do |id, data|
+      create_entity(query.type, id, data)
+    end
+  end
+
+  # Executes a query over Entities, using a simple SQL-like syntax.
+  # @return [Array<String>]
+  # @see #find_entities
+  # @see Flox::Query
+  def find_entity_ids(*query)
+    query = create_query(*query)
+    path = "entities/#{query.type}"
+    data = { where: query.constraints, offset: query.offset, limit: query.limit }
+    service.post(path, data).map {|e| e[:id]}
+  end
+
   # Loads the status of the Flox service.
   # @return [Hash] with the keys 'status' and 'version'.
   def status
@@ -213,12 +244,27 @@ class Flox
     "logs/#{log_id}"
   end
 
+  def create_entity(type, id, data)
+    if (type == '.player' or type == Flox::Player)
+      Player.new(id, data)
+    else
+      Entity.new(type, id, data)
+    end
+  end
+
+  def create_query(*query)
+    if query[0].kind_of? Flox::Query then query[0]
+    else Flox::Query.new(query[0], query[1], *query[2..-1])
+    end
+  end
+
 end
 
-require 'flox/version'
-require 'flox/utils'
 require 'flox/rest_service'
+require 'flox/version'
+require 'flox/errors'
 require 'flox/entity'
 require 'flox/player'
 require 'flox/score'
-require 'flox/resource_enumerator'
+require 'flox/query'
+require 'flox/utils'

data/lib/flox/entity.rb

@@ -10,7 +10,7 @@ require 'time'
 # The class extends `Hash`. Thus, all properties of the Entity can be accessed
 # as keys of the Entity instance.
 #
-#     entity['name'] = 'Donald Duck'
+#     entity[:name] = 'Donald Duck'
 #
 # For convenience, the standard entity properties (e.g. `created_at` and
 # `updated_at`)can be accessed via Ruby attributes.
@@ -19,7 +19,7 @@ require 'time'
 #
 # To load and save an entity, use the respective methods on the Flox class.
 #
-#     my_entity = flox.load_entity('SaveGame', '12345') # => Flox::Entity
+#     my_entity = flox.load_entity(:SaveGame, '12345') # => Flox::Entity
 #     flox.save_entity(my_entity)
 #
 class Flox::Entity < Hash
@@ -36,33 +36,36 @@ class Flox::Entity < Hash
   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
+    self[:createdAt] = self[:updatedAt] = Time.now.utc.to_xs_datetime
+    self[:publicAccess] = ''
+    if (data)
+      data_sym = Hash[data.map{|k, v| [k.to_sym, v]}]
+      self.merge!(data_sym)
+    end
   end
 
   def created_at
-    Time.parse self['createdAt']
+    Time.parse self[:createdAt]
   end
 
   def updated_at
-    Time.parse self['updatedAt']
+    Time.parse self[:updatedAt]
   end
 
   def public_access
-    self["publicAccess"]
+    self[:publicAccess]
   end
 
   def public_access=(access)
-    self["publicAccess"] = access.to_s
+    self[:publicAccess] = access.to_s
   end
 
   def owner_id
-    self["ownerId"]
+    self[:ownerId]
   end
 
   def owner_id=(value)
-    self["ownerId"] = value.to_s
+    self[:ownerId] = value.to_s
   end
 
   def path
@@ -78,6 +81,16 @@ class Flox::Entity < Hash
     description += "]"
   end
 
+  # Accesses a property of the entity; both symbols and strings work.
+  def [](key)
+    super(key.to_sym)
+  end
+
+  # (see #[])
+  def []=(key, value)
+    super(key.to_sym, value)
+  end
+
   #
   # documentation hints
   #

data/lib/flox/errors.rb

@@ -0,0 +1,20 @@
+## Author:    Daniel Sperl
+## Copyright: Copyright 2014 Gamua
+## License:   Simplified BSD
+
+# The main Error class for Flox errors
+class Flox::Error < StandardError; end
+
+# Raised when the REST service encounters an error
+# (e.g. the server returns a HTTP code >= 400).
+class Flox::ServiceError < Flox::Error
+
+  # @return [Net::HTTPResponse] the complete server response
+  attr_reader :response
+
+  # @param code [String] the http status code
+  def initialize(response)
+    @response = response
+  end
+
+end

data/lib/flox/player.rb

@@ -23,14 +23,14 @@ class Flox::Player < Flox::Entity
   # is always `.player` in Flox.
   def initialize(id=nil, data=nil)
     data ||= {}
-    data["authType"] ||= "guest"
-    data["publicAccess"] ||= "r"
+    data[:authType] ||= "guest"
+    data[:publicAccess] ||= "r"
     super(".player", id, data)
     self.owner_id ||= self.id
   end
 
   def auth_type
-    self["authType"].to_sym
+    self[:authType].to_sym
   end
 
   #

data/lib/flox/query.rb

@@ -0,0 +1,84 @@
+## Author:    Daniel Sperl
+## Copyright: Copyright 2014 Gamua
+## License:   Simplified BSD
+
+# The Query class allows you to retrieve entities from the server by narrowing
+# down the results with certain constraints. The system works similar to SQL
+# "select" statements.
+#
+# Before you can make a query, you have to create indices that match the query.
+# You can do that in the Flox online interface. An index has to contain all the
+# properties that are referenced in the constraints.
+#
+# Here is an example of how you can execute a Query with Flox. This query
+# requires an index containing both "level" and "score" properties.
+#
+#     query = Query.new(:Player)
+#     query.where("level == ? AND score > ?", "tutorial", 500)
+#     query.limit = 1
+#     results = flox.find_entities(query)
+#
+# Alternatively, you can execute the query in one single line:
+#
+#     results = flox.find_entities(:Player, "score > ?", 500)
+#     puts "Found #{results.length} players"
+#
+class Flox::Query
+
+  # @return [String] the constraints that will be used as WHERE-clause.
+  #   It is recommended to use the {#where} method to construct them.
+  attr_accessor :constraints
+
+  # @return [Fixnum] the offset of the results returned by the query.
+  attr_accessor :offset
+
+  # @return [Fixnum] the maximum number of returned entities.
+  attr_accessor :limit
+
+  # @return [String] the entity type that is searched.
+  attr_reader :type
+
+  # Create a new query that will search within the given Entity type.
+  # Optionally, pass the constraints in the same way as in the {#where} method.
+  # @param entity_type [String, Symbol, Class] the type of the entity
+  def initialize(entity_type, constraints=nil, *args)
+    if entity_type == Flox::Player || entity_type.to_s == "Player"
+      entity_type = '.player'
+    end
+
+    @type = entity_type
+    @offset = 0
+    @limit = 50
+    where(constraints, *args) if constraints
+  end
+
+  # You can narrow down the results of the query with an SQL like where-clause.
+  # The constraints string supports the following comparison operators:
+  # `==, >, >=, <, <=, !=`. You can combine constraints using `AND` and `OR`;
+  # construct logical groups with round brackets.
+  #
+  # To simplify creation of the constraints string, you can use questions
+  # marks as placeholders. They will be replaced one by one with the additional
+  # parameters you pass to the method, while making sure their format is correct
+  # (e.g. it surrounds Strings with quotations marks). Here is an example:
+  #
+  #     query.where("name == ? AND score > ?", "thomas", 500);
+  #     # -> name == "thomas" AND score > 500
+  #
+  # Use the 'IN'-operator to check for inclusion within a list of possible values:
+  #
+  #     query.where("name IN ?", ["alfa", "bravo", "charlie"]);
+  #     # -> name IN ["alfa", "bravo", "charlie"]
+  #
+  # Note that subsequent calls to this method will replace preceding constraints.
+  # @return String the final constraints string
+  def where(constraints, *args)
+    @constraints = constraints.gsub(/\?/) do
+      raise ArgumentError, "incorrect placeholder count" unless args.length > 0
+      arg = args.shift
+      arg = arg.to_xs_datetime if arg.kind_of?(Time)
+      arg.to_json
+    end
+  end
+
+end

data/lib/flox/rest_service.rb

@@ -30,33 +30,90 @@ class Flox::RestService
   # 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)
+    request(:get, path, data)
   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)
+    request(:delete, path)
   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)
+    request(:post, path, 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)
+    request(:put, path, data)
+  end
+
+  # Makes a request on the Flox server. When called without a block, the
+  # method will raise a {Flox::ServiceError} if the server returns an HTTP
+  # error code; when called with a block, it will always succeed.
+  #
+  # @yield [body, response] The decoded body and the raw http response
+  # @param method [Symbol] one of `:get, :delete, :put, :post`
+  # @param path [String] the path relative to the game, e.g. "entities/product"
+  # @param data [Hash] the body of the request.
+  # @return the body of the server response
+  def request(method, path, data=nil)
+    request_class =
+      case method
+      when :get
+        if data
+          path += "?" + URI.encode_www_form(data)
+          data = nil
+        end
+        Net::HTTP::Get
+      when :delete then Net::HTTP::Delete
+      when :post   then Net::HTTP::Post
+      when :put    then Net::HTTP::Put
+      end
+
+    flox_header = {
+      :sdk => { :type => "ruby", :version => Flox::VERSION },
+      :gameKey => @game_key,
+      :dispatchTime => Time.now.utc.to_xs_datetime,
+      :bodyCompression => "zlib",
+      :player => @authentication
+    }
+
+    request = request_class.new(full_path(path))
+    request["Content-Type"] = "application/json"
+    request["X-Flox"] = flox_header.to_json
+    request.body = encode(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)
+      body = body_from_response response
+
+      if block_given?
+        # if a block was passed to the method, no error is thrown
+        yield  body, response
+        return body
+      else
+        # without a block, we raise an error if the request was not a success
+        if (response.is_a? Net::HTTPSuccess)
+          return body
+        else
+          raise Flox::ServiceError.new(response), (body[:message] rescue body)
+        end
+      end
+    end
   end
 
   # Makes a login on the server with the given authentication data.
@@ -76,7 +133,7 @@ class Flox::RestService
         auth_data[:id] = @authentication[:id]
       end
       response = post("authenticate", auth_data)
-      auth_data[:id] = response["id"]
+      auth_data[:id] = response[:id]
     end
 
     @authentication = auth_data
@@ -90,45 +147,6 @@ class Flox::RestService
 
   private
 
-  def execute(request, data=nil)
-    flox_header = {
-      "sdk" => { "type" => "ruby", "version" => Flox::VERSION },
-      "gameKey" => @game_key,
-      "dispatchTime" => Time.now.utc.to_xs_datetime,
-      "bodyCompression" => "zlib",
-      "player" => @authentication
-    }
-
-    request["Content-Type"] = "application/json"
-    request["X-Flox"] = flox_header.to_json
-    request.body = encode(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)
-      body = response.body
-      body = decode(body) if response['x-content-encoding'] == 'zlib'
-
-      if (response.is_a? Net::HTTPSuccess)
-        return JSON.parse(body || '{}')
-      else
-        message = begin
-          JSON.parse(body)['message']
-        rescue
-          body
-        end
-        raise Flox::Error, message
-      end
-    end
-  end
-
   def decode(string)
     return nil if string.nil? or string.empty?
     Zlib::Inflate.inflate(Base64.decode64(string))
@@ -139,6 +157,18 @@ class Flox::RestService
     Base64.encode64(Zlib::Deflate.deflate(string))
   end
 
+  def body_from_response(response)
+    body = response.body
+
+    begin
+      body = decode(response.body) if response['x-content-encoding'] == 'zlib'
+      JSON.parse(body || '{}', {symbolize_names: true})
+    rescue
+      html_matches = /\<h1\>(.*)\<\/h1\>/.match(body)
+      { message: html_matches ? html_matches[1] : body }
+    end
+  end
+
   def full_path(path)
     "/api/games/#{@game_id}/#{path}"
   end

data/lib/flox/score.rb

@@ -24,11 +24,11 @@ class Flox::Score
 
   # @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)
+    @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/version.rb

@@ -9,6 +9,6 @@
 class Flox
 
   # The current version of the Flox SDK.
-  VERSION = '0.1.2'
+  VERSION = '0.2.0'
 
 end

data/test/test_entity.rb

@@ -30,7 +30,7 @@ class EntityTest < Test::Unit::TestCase
     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
+    entity[:createdAt] = created_at_string
     assert_equal(created_at, entity.created_at)
   end
 
@@ -38,7 +38,7 @@ class EntityTest < Test::Unit::TestCase
     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
+    entity[:updatedAt] = updated_at_string
     assert_equal(updated_at, entity.updated_at)
   end
 
@@ -49,4 +49,15 @@ class EntityTest < Test::Unit::TestCase
     assert_equal('rw', entity.public_access)
   end
 
+  def test_accepts_string_or_symbol
+    first_name = 'donald'
+    last_name  = 'duck'
+    entity = Flox::Entity.new('type', 'id',
+      { first_name: first_name, "last_name" => last_name })
+    assert_equal(first_name, entity[:first_name])
+    assert_equal(first_name, entity['first_name'])
+    assert_equal(last_name, entity[:last_name])
+    assert_equal(last_name, entity['last_name'])
+  end
+
 end

data/test/test_flox.rb

@@ -36,37 +36,37 @@ class FloxTest < Test::Unit::TestCase
     leaderboard_id = "dummy"
     path = "leaderboards/#{leaderboard_id}"
     raw_score = {
-      'value' => 20,
-      'playerName' => 'hugo',
-      'playerId' => '123',
-      'country' => 'at',
-      'createdAt' => '2014-02-24T20:15:00.123Z'
+      :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([])
+    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])
+    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)
+    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' } }
+    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)
@@ -86,7 +86,7 @@ class FloxTest < Test::Unit::TestCase
     type = "type"
     id   = "id"
     path = "entities/#{type}/#{id}"
-    data = { "name" => "Jean-Luc" }
+    data = { :name => "Jean-Luc" }
 
     flox.service.expects(:get).with(path).once.returns(data)
     entity = flox.load_entity(type, id)
@@ -95,32 +95,32 @@ class FloxTest < Test::Unit::TestCase
     assert_equal(id, entity.id)
     assert_equal(type, entity.type)
     assert_equal(path, entity.path)
-    assert_equal(data["name"], entity["name"])
+    assert_equal(data[:name], entity[:name])
   end
 
   def test_load_player
     id = "id"
-    data = { "name" => "Jean-Luc" }
+    data = { :name => "Jean-Luc" }
     flox.service.expects(:get).once.returns(data)
     player = flox.load_player(id)
     assert_kind_of(Flox::Player, player)
-    assert_equal(data["name"], player["name"])
+    assert_equal(data[:name], player[:name])
     assert_equal(id, player.id)
     assert_equal('.player', player.type)
   end
 
   def test_save_entity
-    data   = { "name" => "Jean-Luc" }
+    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" }
+    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)
+    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
@@ -132,12 +132,12 @@ class FloxTest < Test::Unit::TestCase
 
   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)
+    result = { :ids => log_ids, :cursor => nil }
+
+    flox.service.expects(:get).times(4).returns(result).then.returns({})
+    logs = flox.find_logs('severity:warning', 50)
+    assert_kind_of(Array, 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
 
@@ -145,19 +145,19 @@ class FloxTest < Test::Unit::TestCase
     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 }
+    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
+    out_log_ids = flox.find_log_ids
     assert_equal(log_ids.length, out_log_ids.length)
 
     # with limit
     limit = 7
-    result_b['ids'] = %w{ 5 6 }
+    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)
+    out_log_ids = flox.find_log_ids(nil, limit)
     assert_equal(limit, out_log_ids.length)
   end
 

data/test/test_query.rb

@@ -0,0 +1,70 @@
+## Author:    Daniel Sperl
+## Copyright: Copyright 2014 Gamua
+## License:   Simplified BSD
+
+require 'flox'
+require 'test/unit'
+require 'mocha/setup'
+
+class FloxTest < Test::Unit::TestCase
+
+  def test_constraints
+    time_xs = "2014-03-10T14:00:00.124Z"
+    time = Time.parse(time_xs)
+    query = Flox::Query.new("Type")
+    query.where "count >= ? AND (name == ? OR date <= ?)", 10, "hugo", time
+    assert_equal("count >= 10 AND (name == \"hugo\" OR date <= \"#{time_xs}\")",
+      query.constraints, "wrong placeholder replacement")
+  end
+
+  def test_constraints_with_array
+    query = Flox::Query.new("Type")
+    query.where "name IN ?", %w{ alpha bravo charlie }
+    assert_equal('name IN ["alpha","bravo","charlie"]', query.constraints)
+  end
+
+  def test_offset
+    query = Flox::Query.new("Type")
+    query.offset = 15
+    assert_equal(15, query.offset)
+  end
+
+  def test_limit
+    query = Flox::Query.new("Type")
+    query.limit = 5
+    assert_equal(5, query.limit)
+  end
+
+  def test_constraints_checks_argument_count
+    query = Flox::Query.new("Type")
+    assert_raise ArgumentError do
+      query.where "a == ? AND b == ?", 10
+    end
+  end
+
+  def test_run_query
+    flox = Flox.new("game_id", "game_key")
+    query = Flox::Query.new("Type", "score > ?", 100)
+    flox.service.expects(:request).times(3).returns([{id: 1}, {id: 2}])
+      .then.returns({score: 101}, {score: 102})
+    results = flox.find_entities query
+    assert_equal 2, results.length
+
+    result_0 = results[0]
+    assert_kind_of(Flox::Entity, result_0)
+    assert_equal(101, result_0[:score])
+
+    result_1 = results[1]
+    assert_kind_of(Flox::Entity, result_1)
+    assert_equal(102, result_1[:score])
+  end
+
+  def test_run_query_direct
+    flox = Flox.new("game_id", "game_key")
+    flox.service.expects(:request).times(3).returns([{id: 1}, {id: 2}])
+      .then.returns({}, {})
+    results = flox.find_entities "Type", "score > ?", 100
+    assert_equal 2, results.length
+  end
+
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: flox
 version: !ruby/object:Gem::Version
-  version: 0.1.2
+  version: 0.2.0
 platform: ruby
 authors:
 - Daniel Sperl
@@ -97,10 +97,12 @@ files:
 - bin/flox
 - test/test_entity.rb
 - test/test_flox.rb
+- test/test_query.rb
 - test/test_utils.rb
 - lib/flox/entity.rb
+- lib/flox/errors.rb
 - lib/flox/player.rb
-- lib/flox/resource_enumerator.rb
+- lib/flox/query.rb
 - lib/flox/rest_service.rb
 - lib/flox/score.rb
 - lib/flox/utils.rb

data/lib/flox/resource_enumerator.rb

@@ -1,43 +0,0 @@
-## 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