orchestrate 0.9.2 → 0.10.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 7ea84118d96674889b76ea3cad03c131e6339aa5
-  data.tar.gz: d3c664b057f0af8e147060413ab9a43d96b2ae9f
+  metadata.gz: f7d5c6bc09a49e08d464387e25b98ae9777bbf93
+  data.tar.gz: 72a68c6e456c4920c9875e7e3f7108b29bd59d12
 SHA512:
-  metadata.gz: 7eb7729c1590a618715870997959990b8d4ac057ab240eb15109d704cb3277ad146c1b92de958c3a6259ce56656b0f1fd273ea86e0b32b4bbec734aa8381ad1e
-  data.tar.gz: 8a01ed2702ec401ec9d88628e2b2005a6c1511af13bf0596d051c934d7165e95ac19a00a4c27685b8a1a9bff8832e93bd91a94198f2daec14d802a680cef2afb
+  metadata.gz: a8a2a5f7124cd557dc4a3ed3a4fc9d71064494e8241ae87409c8fcfd2fe40236eaebd0171e54c5c2ab22bcba03a1e33bb8a81171681a205edb4c153f747ef2a9
+  data.tar.gz: 753527cab83aac5537fd178ac976cf704f6c173c63b0b64a2f9c9fdd859c30d18e6d8cd34cb92bcc4b6bb2aa3643e66f47918193d561c65e88b2f591b82f802e

data/README.md

@@ -45,6 +45,24 @@ jill.value                                  # { "name" => "Jill", "location" =>
 jill.save                                   # PUT-If-Match, updates ref
 ```
 
+#### Manipulate KeyValues with PATCH
+```ruby
+jill.merge({location: "Under the Hill"})        # Updates jill by merging given partial value into existing value
+
+# Patch Operations
+jill.add('favorite_sibling', 'Jack').update     # adds new field/value pair to jill
+jill.remove('favorite_sibling').update          # removes given field/value pair from jill
+jill.replace('on_the_hill', false).update       # replaces given field with given value
+jill.move('name', 'first_name').update          # moves given field's value to new field
+jill.copy('first_name', 'full_name').update     # copies given field's value to another field
+jill.increment('age', 1).update                 # increments given field (must have numeric value) by provided amount
+jill.decrement('years_to_live', 1).update       # decrements given field (must have numeric value) by provided amount
+jill.test('full_name', 'Jill').update           # tests equality of existing field/value pair with given field/value
+
+# Patch Operations can be chained together to perform multiple updates to a KeyValue item
+jill.add('favorite_food', 'Pizza').remove('years_to_live').update()
+```
+
 #### Searching, Sorting for KeyValues
 ```ruby
 users.search("name:Jill")                    # returns users with name "Jill"
@@ -63,6 +81,21 @@ users.search("location: Portland").order(:name) # returns users in ascending ord
 users.search("location: Portland").order(:name, :asc, :rank, :desc, :created_at) # :created_at argument defaults to :asc
 ```
 
+### Geo Queries
+```ruby
+# Create a Collection object
+cafes = app[:cafes]
+
+# Find cafes near a given geographic point
+cafes.near(:location, 12.56, 19.443, 4, 'mi')   # returns cafes in a 4 mile radius of given latitude, longitude
+
+# Sort nearby cafes by distance
+cafes.near(:location, 12.56, 19.443, 4, 'mi').order(:distance)  # returns nearby cafes in ascending order (closest to farthest)
+
+# Find cafes in a given area using a bounding box
+cafes.in(:location, {north:12.5, east:57, south:12, west:56})   # returns all cafes within specified bounding box
+```
+
 ### Method Client use
 
 #### Create a Client
@@ -84,6 +117,27 @@ client.delete(:users, :jack, jack.ref)      # DELETE-If-Match, returns API::Resp
 client.list(:users)                         # LIST users, returns API::CollectionResposne
 ```
 
+#### Manipulate KeyValues with PATCH
+```ruby
+# Give a set of operations to manipulate a given key
+# Operations are executed in sequential order
+ops = [
+  { "op" => "add", "path" => "nimble", "value" => true }, # adds new field/value pair
+  { "op" => "remove", "path" => "nimble" }, # removes given field/value pair
+  { "op" => "replace", "path" => "quick", "value" => true }, # replaces given field with given value
+  { "op" => "move", "from" => "name", "path" => "first_name" }, # moves given field's value to new field
+  { "op" => "copy", "from" => "city", "path" => "home_town" }, # copies given field's value to another field
+  { "op" => "inc", "path" => "age", "value" => 1 }, # increment a numeric value at a given path
+  { "op" => "inc", "path" => "age", "value" => -1 }, # pass a negative number to decrement a numeric value
+  { "op" => "test", "path" => "first_name", "value" => "Jack" }, # tests equality of existing field/value pair with given field/value
+]
+
+client.patch(:users, :jack, ops)
+
+# Merge partial values into existing key
+client.patch_merge(:users, :jack, { favorite_food: "Donuts" })
+```
+
 #### Search Collections
 ```ruby
 client.search(:users, "location:Portland") # search 'users' collection for items with a location of 'Portland'
@@ -96,6 +150,29 @@ client.search(:users, "location:Portland", { sort: "value.name:asc" }) # returns
 client.search(:users, "location:Portland", { sort: "value.name.last:asc,value.name.first:asc" }) # returns items sorted primarily by last name, but whenever two users have an identical last name, the results will be sorted by first name as well.
 ```
 
+### Geo Queries
+```ruby
+# Find cafes near a given geographic point
+
+coords = {
+  lat: 12.56,
+  lon: 19.443,
+  dist: '4mi' # Define size of search radius for NEAR query
+}
+query = "value.location:NEAR:{lat:#{coords.lat} lon:#{coords.lon} dist:#{coords.dist}}"
+client.search(:cafes, query)    # returns cafes in a 4 mile radius of given latitude, longitude
+
+# Using the previous coords & query,
+# sort results by distance
+client.search(:cafes, query, {
+  sort: 'value.location:distance:asc'
+})
+
+# Find cafes in a given area using a bounding box
+query = "value:IN:{ north:12.5 east:57 south:12 west:56 }"
+client.search(:cafes, query)
+```
+
 ### Examples and Documentation
 
 There are more examples at [Orchestrate's API Documentation][apidoc] and documentation in the [rdoc][].
@@ -200,6 +277,13 @@ end
 
 ## Release Notes
 
+### December 11, 2014: release 0.10.0
+  - **BACKWARDS-INCOMPATIBLE** Prior `KeyValue#update` & `KeyValue#update!` renamed to `KeyValue#set` & `KeyValue#set!`. `KeyValue#update` now used after `PATCH` operations to fire the request.
+  - Implement `Collection#near` & `Collection#in`, allowing `Collection` to perform geo queries.
+  - Implement `Client#patch`, `Client#patch_merge`, allowing `Client` to perform subdocument updates through `PATCH` requests.
+  - Implement `KeyValue::OperationSet`, allowing a set of `PATCH` operations to be built by `KeyValue` through `KeyValue#add`, `KeyValue#remove`, `KeyValue#replace`, `KeyValue#move`, `KeyValue#copy`, `KeyValue#increment`, `KeyValue#decrement`, & `KeyValue#test`. The `KeyValue::OperationSet` is fired by ending the chain with `KeyValue#update`.
+  - Implement `KeyValue#merge`, allowing `KeyValue` to merge partial values into existing keys through `PATCH` requests.
+
 ### November 19, 2014: release 0.9.2
   - Implement `SearchResults#order`, allowing `Collection` object results to be sorted.
   - Implement Data Center choice on `Orchestrate::Client` and `Orchestrate::Application`.

data/lib/orchestrate/client.rb

@@ -166,6 +166,46 @@ module Orchestrate
       put collection, key, body, false
     end
 
+    # Manipulate values associated with a key, without retrieving the key object.
+    # Array of operations passed as body, will execute operations on the key sequentially.
+    # [Patch](http://orchestrate.io/docs/apiref#keyvalue-patch).
+    # @param collection [#to_s] The name of the collection.
+    # @param key [#to_s] The name of the key.
+    # @param body [#to_json] The value for the key.
+    # @param condition [String, false, nil] Conditions for setting the value.
+    #   If `String`, value used as `If-Match`, value will only be updated if key's current value's ref matches.
+    #   If `nil` (default), value is set regardless.
+    # @return Orchestrate::API::ItemResponse
+    # @raise Orchestrate::API::BadRequest the body is not valid JSON.
+    # @raise Orchestrate::API::AlreadyPresent the `false` condition was given, but a value already exists for this collection/key combo.
+    def patch(collection, key, body, condition=nil)
+      headers = {'Content-Type' => 'application/json-patch+json'}
+      if condition.is_a?(String)
+        headers['If-Match'] = API::Helpers.format_ref(condition)
+      end
+      send_request :patch, [collection, key], { body: body, headers: headers, response: API::ItemResponse }
+    end
+
+    # Merge field/value pairs into existing key, without retrieving the key object.
+    # [Patch](http://orchestrate.io/docs/apiref#keyvalue-patch-merge).
+    # If a given field's value is nil, will remove field from existing key on merge.
+    # @param collection [#to_s] The name of the collection.
+    # @param key [#to_s] The name of the key.
+    # @param body [#to_json] The value for the key.
+    # @param condition [String, false, nil] Conditions for setting the value.
+    #   If `String`, value used as `If-Match`, value will only be updated if key's current value's ref matches.
+    #   If `nil` (default), value is set regardless.
+    # @return Orchestrate::API::ItemResponse
+    # @raise Orchestrate::API::BadRequest the body is not valid JSON.
+    # @raise Orchestrate::API::AlreadyPresent the `false` condition was given, but a value already exists for this collection/key combo.
+    def patch_merge(collection, key, body, condition=nil)
+      headers = {'Content-Type' => 'application/merge-patch+json'}
+      if condition.is_a?(String)
+        headers['If-Match'] = API::Helpers.format_ref(condition)
+      end
+      send_request :patch, [collection, key], { body: body, headers: headers, response: API::ItemResponse }
+    end
+
     # [Sets the current value of a key to a null
     # object](http://orchestrate.io/docs/api/#key/value/delete11).
     # @param collection [#to_s] The name of the collection.
@@ -404,6 +444,8 @@ module Orchestrate
         if [:put, :post].include?(method)
           headers['Content-Type'] = 'application/json'
           request.body = body.to_json
+        elsif [:patch].include?(method)
+          request.body = body.to_json    
         end
         headers.each {|header, value| request[header] = value }
       end

data/lib/orchestrate/collection.rb

@@ -357,6 +357,37 @@ module Orchestrate
     end
     # @!endgroup
 
+    # @!group Geo Queries
+    # Performs a search for items near a specified geographic point in a collection.
+    # [Search for items near a geographic point](http://orchestrate.io/docs/apiref#geo-queries-near)
+    # @param field [#to_s] The field containing location data (latitude & longitude)
+    # @param latitude [Float] The number representing latitude of a geographic point
+    # @param longitude [Float] The number representing longitude of a geographic point
+    # @param distance [Integer] The number of distance units.
+    # @param units [#to_s] Unit of measurement for distance, default to kilometers (km),
+    # supported units: km, m, cm, mm, mi, yd, ft, in, nmi
+    # @return [SearchResults] A loaded SearchResults object ready to enumerate over.
+    def near(field, latitude, longitude, distance, units=nil)
+        units ||= 'km'
+        query = "#{field}:NEAR:{lat:#{latitude} lon:#{longitude} dist:#{distance}#{units}}"
+        SearchResults.new(self, query)
+    end
+
+    # Performs a search for items within a particular area, 
+    # using a specified bounding box
+    # [Search for items in a geographic bounding box](https://orchestrate.io/docs/apiref#geo-queries-bounding)
+    # @param field [#to_s] The field containing location data (latitude & longitude)
+    # @param box [#to_json] The values to create the bounding box,
+    # @example
+    #   collection.in(:field, {north: 12.5, south: 15, east: 14, west: 3})
+    # @return [SearchResults] A loaded SearchResults object ready to enumerate over.
+    def in(field, box={})
+      box = box.flatten.each_slice(2).map {|dir, val| "#{dir}:#{val}" }.join(" ")
+      query = "#{field}:IN:{#{box}}"
+      SearchResults.new(self, query)
+    end
+    # @!endgroup
+
     # An enumerator with a query for searching an Orchestrate::Collection
     class SearchResults
       # @return [Collection] The collection this object will search.

data/lib/orchestrate/key_value.rb

@@ -208,9 +208,9 @@ module Orchestrate
     # Merges a set of values into the item's existing value and saves.
     # @param merge [#each_pair] The Hash-like to merge into #value. Keys will be stringified.
     # @return [true, false]
-    def update(merge)
+    def set(merge)
       begin
-        update!(merge)
+        set!(merge)
       rescue API::RequestError, API::ServiceError
         false
       end
@@ -221,11 +221,168 @@ module Orchestrate
     # @return [true]
     # @raise [Orchestrate::API::VersionMismatch] If the KeyValue item has been updated with a new ref since this KeyValue was loaded.
     # @raise [Orchestrate::API::RequestError, Orchestrate::API::ServiceError] If there was any other problem with saving.
-    def update!(merge)
+    def set!(merge)
       merge.each_pair {|key, value| @value[key.to_s] = value }
       save!
     end
 
+    # @!group patch-merge
+
+    # Merges the given value into a KeyValue item using a patch request,
+    # enabling merges to be peformed without retrieving the KeyValue item.
+    # @param value [#to_json] Hash of partial values, to be converted to json,
+    # and merged into the KeyValue item.
+    # @param ref [String] optional condition, provide ref for 'If-Match' header
+    def merge(value, ref=nil)
+      self.perform(:patch_merge, value, ref)
+    end
+
+    # @!endgroup patch-merge
+    # @!group patch-operations
+
+    # Manipulate a KeyValue item with a set of operations.
+    # Chain a series of operation methods (#add, #remove, etc) to build the set,
+    # operations will be executed by Orchestrate in sequential order.
+    # @param ref [String] optional condition, provide ref for 'If-Match' header
+    # To perform singular operations or a set, add #update to the end of the method chain.
+    # @example
+    #   users['jon-snow'].add(:beard, true).remove(:some_field).update()
+    # @raise Orchestrate::API::NotFound if key does not exist
+    def update(ref=nil)
+      OperationSet.new(self).update(ref)
+    end
+
+    # Adds a new field/value pair to a KeyValue at the designated path (field name).
+    # @param path [#to_s] The location of the field to add.
+    # @param value [#to_json] The value to assign to the specified field.
+    # @return Orchestrate::KeyValue::OperationSet
+    def add(path, value)
+      OperationSet.new(self).add(path, value)
+    end
+
+    # Removes a field/value pair from a KeyValue item
+    # @param path [#to_s] The field to remove.
+    # @raise Orchestrate::API::RequestError if field does not exist
+    def remove(path)
+      OperationSet.new(self).remove(path)
+    end
+
+    # Replaces an existing field's value
+    # @param path [#to_s] The field whose value to replace.
+    # @param value [#to_json] The value to assign to the specified field.
+    # @raise Orchestrate::API::RequestError if field does not exist
+    # @return Orchestrate::KeyValue::OperationSet
+    def replace(path, value)
+      OperationSet.new(self).replace(path, value)
+    end
+
+    # Moves a KeyValue item's field/value pair to a new field (path)
+    # @param from_path [#to_s] The field to move.
+    # @param to_path [#to_s] The new location of the moved field.
+    # @raise Orchestrate::API::RequestError if field does not exist
+    # @return Orchestrate::KeyValue::OperationSet
+    def move(from_path, to_path)
+      OperationSet.new(self).move(from_path, to_path)
+    end
+
+    # Copies a KeyValue item's field value to another field (path)
+    # @param from_path [#to_s] The field to copy.
+    # @param to_path [#to_s] The target location to copy field/value to.
+    # @raise Orchestrate::API::RequestError if field does not exist
+    # @return Orchestrate::KeyValue::OperationSet
+    def copy(from_path, to_path)
+      OperationSet.new(self).copy(from_path, to_path)
+    end
+
+    # Increases a KeyValue item's field number value by given amount
+    # @param path [#to_s] The field (with a number value) to increment.
+    # @param amount [Integer] The amount to increment the field's value by.
+    # @raise Orchestrate::API::RequestError if field does not exist or 
+    # if existing value is not a number type
+    # @return Orchestrate::KeyValue::OperationSet
+    def increment(path, amount)
+      OperationSet.new(self).increment(path, amount)
+    end
+    alias :inc :increment
+
+    # Decreases a KeyValue item's field number value by given amount
+    # @param path [#to_s] The field (with a number value) to decrement.
+    # @param amount [Integer] The amount to decrement the field's value by.
+    # @raise Orchestrate::API::RequestError if field does not exist or 
+    # if existing value is not a number type
+    # @return Orchestrate::KeyValue::OperationSet
+    def decrement(path, amount)
+      OperationSet.new(self).decrement(path, amount)
+    end
+    alias :dec :decrement
+
+    # Tests equality of a KeyValue's existing field/value pair
+    # @param path [#to_s] The field to check equality of.
+    # @param value [#to_json] The expected value of the field.
+    # @raise Orchestrate::API::RequestError if field does not exist
+    # @raise Orchestrate::API::IndexingError if equality check fails
+    # @return Orchestrate::KeyValue::OperationSet
+    def test(path, value)
+      OperationSet.new(self).test(path, value)
+    end
+
+    # An object which builds a set of operations for manipulating an Orchestrate::KeyValue
+    class OperationSet
+
+      # @return [KeyValue] The keyvalue this object will manipulate.
+      attr_reader :key_value
+
+      # @return operations to be performed.
+      attr_reader :operations
+
+      # Initialize a new OperationSet object
+      # @param key_value [Orchestrate::KeyValue] The keyvalue to manipulate.
+      def initialize(key_value, operations=[])
+        @key_value = key_value
+        @operations = operations
+      end
+
+      def update(ref=nil)
+        key_value.perform(:patch, operations, ref)
+      end
+
+      def add(path, value)
+        self.class.new(key_value, operations.push({op: "add", path: "#{path}", value: value}))
+      end
+
+      def remove(path)
+        self.class.new(key_value, operations.push({op: "remove", path: "#{path}"}))
+      end
+
+      def replace(path, value)
+        self.class.new(key_value, operations.push({op: "replace", path: "#{path}", value: value}))
+      end
+
+      def move(from_path, to_path)
+        self.class.new(key_value, operations.push({op: "move", from: "#{from_path}", path: "#{to_path}"}))
+      end
+
+      def copy(from_path, to_path)
+        self.class.new(key_value, operations.push({op: "copy", from: "#{from_path}", path: "#{to_path}"}))
+      end
+
+      def increment(path, amount)
+        self.class.new(key_value, operations.push({op: "inc", path: "#{path}", value: amount}))
+      end
+      alias :inc :increment
+
+      def decrement(path, amount)
+        self.class.new(key_value, operations.push({op: "inc", path: "#{path}", value: -amount}))
+      end
+      alias :dec :decrement
+
+      def test(path, value)
+        self.class.new(key_value, operations.push({op: "test", path: "#{path}", value: value}))
+      end
+    end
+
+    # @!endgroup patch-operations
+
     # Deletes the KeyValue item from Orchestrate using 'If-Match' with the current ref.
     # Returns false if the item failed to delete because a new ref had been created since this KeyValue was loaded.
     # @return [true, false]

data/lib/orchestrate/version.rb

@@ -1,4 +1,4 @@
 module Orchestrate
   # @return [String] The version number of the Orchestrate Gem
-  VERSION = "0.9.2"
+  VERSION = "0.10.0"
 end

data/test/orchestrate/api/key_value_api_test.rb

@@ -64,7 +64,7 @@ class KeyValueAPITest < MiniTest::Unit::TestCase
   end
 
   def test_puts_key_value_without_ref
-    body={"foo" => "bar"}
+    body = {"foo" => "bar"}
     ref = "12345"
     base_location = "/v0/#{@collection}/#{@key}"
     @stubs.put(base_location) do |env|
@@ -143,6 +143,76 @@ class KeyValueAPITest < MiniTest::Unit::TestCase
     assert_equal 200, response.status
   end
 
+  def test_patches_key_value_without_ref
+    body =[ {"op" => "add", "path" => "foo", "value" => "bar"} ]
+    ref = "12345"
+    base_location = "/v0/#{@collection}/#{@key}"
+    @stubs.patch(base_location) do |env|
+      assert_authorization @basic_auth, env
+      assert_header 'Content-Type', 'application/json-patch+json', env
+      assert_equal body.to_json, env.body
+      headers = { "Location" => "#{base_location}/refs/#{ref}", 
+                  "Etag" => "\"#{ref}\"" }
+      [ 201, response_headers(headers), '' ]
+    end
+
+    response = @client.patch(@collection, @key, body)
+    assert_equal 201, response.status
+    assert_equal ref, response.ref
+    assert_equal "#{base_location}/refs/#{ref}", response.location
+  end
+
+  def test_patches_key_value_with_specific_ref
+    body = [ {"op" => "add", "path" => "foo", "value" => "bar"} ]
+    ref = '123456'
+
+    @stubs.patch("/v0/#{@collection}/#{@key}") do |env|
+      assert_authorization @basic_auth, env
+      assert_header 'If-Match', "\"#{ref}\"", env
+      assert_header 'Content-Type', 'application/json-patch+json', env
+      assert_equal body.to_json, env.body
+      [ 201, response_headers, '' ]
+    end
+
+    response = @client.patch(@collection, @key, body, ref)
+    assert_equal 201, response.status
+  end
+
+  def test_patch_merges_key_value_without_ref
+    body = {"foo" => "bar"}
+    ref = "12345"
+    base_location = "/v0/#{@collection}/#{@key}"
+    @stubs.patch(base_location) do |env|
+      assert_authorization @basic_auth, env
+      assert_header 'Content-Type', 'application/merge-patch+json', env
+      assert_equal body.to_json, env.body
+      headers = { "Location" => "#{base_location}/refs/#{ref}", 
+                  "Etag" => "\"#{ref}\"" }
+      [ 201, response_headers(headers), '' ]
+    end
+
+    response = @client.patch_merge(@collection, @key, body)
+    assert_equal 201, response.status
+    assert_equal ref, response.ref
+    assert_equal "#{base_location}/refs/#{ref}", response.location
+  end
+
+  def test_patch_merges_key_value_with_specific_ref
+    body = {"foo" => "bar"}
+    ref = '123456'
+
+    @stubs.patch("/v0/#{@collection}/#{@key}") do |env|
+      assert_authorization @basic_auth, env
+      assert_header 'If-Match', "\"#{ref}\"", env
+      assert_header 'Content-Type', 'application/merge-patch+json', env
+      assert_equal body.to_json, env.body
+      [ 201, response_headers, '' ]
+    end
+
+    response = @client.patch_merge(@collection, @key, body, ref)
+    assert_equal 201, response.status
+  end
+
   def test_delete_key_value
     @stubs.delete("/v0/#{@collection}/#{@key}") do |env|
       assert_authorization @basic_auth, env

data/test/orchestrate/collection_geo_queries_test.rb

@@ -0,0 +1,89 @@
+require "test_helper"
+
+class CollectionGeoQueriesTest < MiniTest::Unit::TestCase
+  def setup
+    @app, @stubs = make_application({parallel:true})
+    @items = @app[:items]
+
+    @near_query = "location:NEAR:{lat:12 lon:56 dist:1km}"
+    @in_query = "location:IN:{north:12 east:57 south:12 west:56}"
+    @total = 110
+
+    @make_listing = lambda{|i| make_kv_listing(:items, key: "item-#{i}", reftime: nil, score: @total-i/@total*5.0) }
+    @handle_geo = lambda do |query|
+      case query
+      when "location:NEAR:{lat:12 lon:56 dist:1km}"
+        { "results" => 10.times.map{|i| @make_listing.call(i)}, "count" => 10, "total_count" => 10 }
+      when "location:IN:{north:12 east:57 south:12 west:56}"
+        { "results" => 12.times.map{|i| @make_listing.call(i)}, "count" => 12, "total_count" => 12 }
+      when "location:NEAR:{lat:12 lon:56 dist:1km}&sort=location:distance:asc"
+        { "results" => 10.times.map{|i| @make_listing.call(i)}, "count" => 10, "total_count" => 10 }
+      else
+        raise ArgumentError.new("unexpected query: #{env.params['query']}")
+      end
+    end
+
+    @called = false
+    @stubs.get("/v0/items") do |env|
+      @called = true
+      assert_equal @query, env.params['query']
+      body = @handle_geo.call(env.params['query'])
+      [ 200, response_headers, body.to_json ]
+    end
+  end
+
+  def test_near_search_without_units
+    @query = @near_query
+    results = @items.near("location", 12, 56, 1).map{|i| i }
+    assert_equal 10, results.length
+    results.each_with_index do |item, idx|
+      assert_in_delta (@total-idx/@total * 5.0), item[0], 0.005
+      assert_equal "item-#{idx}", item[1].key
+      assert_nil item[1].reftime
+    end
+  end
+
+  def test_near_search_with_units
+    @query = @near_query
+    results = @items.near("location", 12, 56, 1, 'km').map{|i| i }
+    assert_equal 10, results.length
+    results.each_with_index do |item, idx|
+      assert_in_delta (@total-idx/@total * 5.0), item[0], 0.005
+      assert_equal "item-#{idx}", item[1].key
+      assert_nil item[1].reftime
+    end
+  end
+
+  def test_near_search_with_sort
+    @query = @near_query
+    results = @items.near("location", 12, 56, 1, 'km').order(:location).map{|i| i }
+    assert_equal 10, results.length
+    results.each_with_index do |item, idx|
+      assert_in_delta (@total-idx/@total * 5.0), item[0], 0.005
+      assert_equal "item-#{idx}", item[1].key
+      assert_nil item[1].reftime
+    end
+  end
+
+  def test_in_bounding_box
+    @query = @in_query
+    results = @items.in("location", {north:12, east:57, south:12, west:56}).map{|i| i }
+    assert_equal 12, results.length
+    results.each_with_index do |item, idx|
+      assert_in_delta (@total-idx/@total * 5.0), item[0], 0.005
+      assert_equal "item-#{idx}", item[1].key
+      assert_nil item[1].reftime
+    end
+  end
+
+  def test_in_bounding_box_with_sort
+    @query = @in_query
+    results = @items.in("location", {north:12, east:57, south:12, west:56}).order(:location).map{|i| i }
+    assert_equal 12, results.length
+    results.each_with_index do |item, idx|
+      assert_in_delta (@total-idx/@total * 5.0), item[0], 0.005
+      assert_equal "item-#{idx}", item[1].key
+      assert_nil item[1].reftime
+    end
+  end
+end

data/test/orchestrate/key_value_persistence_test.rb

@@ -109,55 +109,55 @@ class KeyValuePersistenceTest < MiniTest::Unit::TestCase
     end
   end
 
-  def test_update_merges_values_and_saves
-    update = {hello: "there", 'two' => 2}
+  def test_set_merges_values_and_saves
+    set = {hello: "there", 'two' => 2}
     body = @kv.value
-    update.each_pair {|key, value| body[key.to_s] = value }
+    set.each_pair {|key, value| body[key.to_s] = value }
     new_ref = make_ref
     @stubs.put("/v0/items/#{@kv.key}") do |env|
       assert_equal body, JSON.parse(env.body)
       assert_header 'If-Match', "\"#{@kv.ref}\"", env
       [201, response_headers({'Etag' => new_ref, "Location" => "/v0/items/#{@kv.key}/refs/#{new_ref}"}), '']
     end
-    @kv.update(update)
+    @kv.set(set)
     assert_equal body, @kv.value
     assert_equal new_ref, @kv.ref
   end
 
-  def test_update_merges_values_and_returns_false_on_error
-    update = {hello: "there", 'two' => 2}
+  def test_set_merges_values_and_returns_false_on_error
+    set = {hello: "there", 'two' => 2}
     body = @kv.value
-    update.each_pair {|key, value| body[key.to_s] = value }
+    set.each_pair {|key, value| body[key.to_s] = value }
     old_ref = @kv.ref
     @stubs.put("/v0/items/#{@kv.key}") do |env|
       assert_equal body, JSON.parse(env.body)
       assert_header 'If-Match', "\"#{@kv.ref}\"", env
       error_response(:service_error)
     end
-    refute @kv.update(update)
+    refute @kv.set(set)
     assert_equal body, @kv.value
     assert_equal old_ref, @kv.ref
   end
 
-  def test_update_bang_merges_values_and_save_bangs
-    update = {hello: "there", 'two' => 2}
+  def test_set_bang_merges_values_and_save_bangs
+    set = {hello: "there", 'two' => 2}
     body = @kv.value
-    update.each_pair {|key, value| body[key.to_s] = value }
+    set.each_pair {|key, value| body[key.to_s] = value }
     new_ref = make_ref
     @stubs.put("/v0/items/#{@kv.key}") do |env|
       assert_equal body, JSON.parse(env.body)
       assert_header 'If-Match', "\"#{@kv.ref}\"", env
       [201, response_headers({'Etag' => new_ref, "Location" => "/v0/items/#{@kv.key}/refs/#{new_ref}"}), '']
     end
-    @kv.update!(update)
+    @kv.set!(set)
     assert_equal body, @kv.value
     assert_equal new_ref, @kv.ref
   end
 
-  def test_update_bang_merges_values_and_save_bangs_raises_on_error
-    update = {hello: "there", 'two' => 2}
+  def test_set_bang_merges_values_and_save_bangs_raises_on_error
+    set = {hello: "there", 'two' => 2}
     body = @kv.value
-    update.each_pair {|key, value| body[key.to_s] = value }
+    set.each_pair {|key, value| body[key.to_s] = value }
     old_ref = @kv.ref
     @stubs.put("/v0/items/#{@kv.key}") do |env|
       assert_equal body, JSON.parse(env.body)
@@ -165,12 +165,397 @@ class KeyValuePersistenceTest < MiniTest::Unit::TestCase
       error_response(:service_error)
     end
     assert_raises Orchestrate::API::ServiceError do
-      @kv.update!(update)
+      @kv.set!(set)
     end
     assert_equal body, @kv.value
     assert_equal old_ref, @kv.ref
   end
 
+  def test_merge_patch_merges_partial_value_into_existing_kv_without_ref
+    merge = {"foo" => "bar"}
+    body = @kv.value
+    body["foo"] = "bar"
+    @stubs.patch("/v0/items/#{@kv.key}") do |env|
+      assert_equal merge, JSON.parse(env.body)
+      assert_header 'Content-Type', 'application/merge-patch+json', env
+      [201, response_headers({'Etag' => @kv.ref, "Location" => "/v0/items/#{@kv.key}/refs/#{@kv.ref}"}), '']
+    end
+    @kv.merge(merge)
+    assert_equal body, @kv.value
+  end
+
+  def test_merge_patch_merges_partial_value_into_existing_kv_with_ref
+    merge = {"foo" => "bar"}
+    body = @kv.value
+    body["foo"] = "bar"
+    ref = @kv.ref
+    @stubs.patch("/v0/items/#{@kv.key}") do |env|
+      assert_equal merge, JSON.parse(env.body)
+      assert_header 'If-Match', "\"#{@kv.ref}\"", env
+      assert_header 'Content-Type', 'application/merge-patch+json', env
+      [201, response_headers({'Etag' => ref, "Location" => "/v0/items/#{@kv.key}/refs/#{ref}"}), '']
+    end
+    @kv.merge(merge, ref)
+    assert_equal body, @kv.value
+    assert_equal ref, @kv.ref
+  end
+
+  def test_update_add_operation_creates_new_field_and_value_without_ref
+    add = [{ "op" => "add", "path" => "aloha", "value" => "universe"}]
+    body = @kv.value
+    body["aloha"] = "universe"
+    @stubs.patch("/v0/items/#{@kv.key}") do |env|
+      assert_equal add, JSON.parse(env.body)
+      assert_header 'Content-Type', 'application/json-patch+json', env
+      [201, response_headers({'Etag' => @kv.ref, "Location" => "/v0/items/#{@kv.key}/refs/#{@kv.ref}"}), '']
+    end
+    @kv.add(:aloha, "universe").update()
+    assert_equal body, @kv.value
+  end
+
+  def test_update_add_operation_creates_new_field_and_value_with_ref
+    add = [{ "op" => "add", "path" => "aloha", "value" => "universe"}]
+    body = @kv.value
+    body["aloha"] = "universe"
+    ref = @kv.ref
+    @stubs.patch("/v0/items/#{@kv.key}") do |env|
+      assert_equal add, JSON.parse(env.body)
+      assert_header 'If-Match', "\"#{@kv.ref}\"", env
+      assert_header 'Content-Type', 'application/json-patch+json', env
+      [201, response_headers({'Etag' => ref, "Location" => "/v0/items/#{@kv.key}/refs/#{ref}"}), '']
+    end
+    @kv.add(:aloha, "universe").update(ref)
+    assert_equal body, @kv.value
+    assert_equal ref, @kv.ref
+  end
+
+  def test_update_remove_operation_removes_new_field_and_value_without_ref
+    remove = [{ "op" => "remove", "path" => "hello"}]
+    body = @kv.value
+    body.delete("hello")
+    @stubs.patch("/v0/items/#{@kv.key}") do |env|
+      assert_equal remove, JSON.parse(env.body)
+      assert_header 'Content-Type', 'application/json-patch+json', env
+      [201, response_headers({'Etag' => @kv.ref, "Location" => "/v0/items/#{@kv.key}/refs/#{@kv.ref}"}), '']
+    end
+    @kv.remove(:hello).update()
+    assert_equal body, @kv.value
+  end
+
+  def test_update_remove_operation_removes_new_field_and_value_with_ref
+    remove = [{ "op" => "remove", "path" => "hello"}]
+    body = @kv.value
+    body.delete("hello")
+    ref = @kv.ref
+    @stubs.patch("/v0/items/#{@kv.key}") do |env|
+      assert_equal remove, JSON.parse(env.body)
+      assert_header 'If-Match', "\"#{@kv.ref}\"", env
+      assert_header 'Content-Type', 'application/json-patch+json', env
+      [201, response_headers({'Etag' => ref, "Location" => "/v0/items/#{@kv.key}/refs/#{ref}"}), '']
+    end
+    @kv.remove(:hello).update(ref)
+    assert_equal body, @kv.value
+    assert_equal ref, @kv.ref
+  end
+
+  def test_update_remove_operation_raises_error_with_non_existing_field
+    remove = [{ "op" => "remove", "path" => "foo"}]
+    body = @kv.value
+    @stubs.patch("/v0/items/#{@kv.key}") do |env|
+      assert_equal remove, JSON.parse(env.body)
+      assert_header 'Content-Type', 'application/json-patch+json', env
+      error_response(:malformed_ref)
+    end
+    assert_raises Orchestrate::API::MalformedRef do
+      @kv.remove(:foo).update()
+    end
+  end
+
+  def test_update_replace_operation_replaces_field_with_new_value_without_ref
+    replace = [{ "op" => "replace", "path" => "hello", "value" => "universe"}]
+    body = @kv.value
+    body["hello"] = "universe"
+    @stubs.patch("/v0/items/#{@kv.key}") do |env|
+      assert_equal replace, JSON.parse(env.body)
+      assert_header 'Content-Type', 'application/json-patch+json', env
+      [201, response_headers({'Etag' => @kv.ref, "Location" => "/v0/items/#{@kv.key}/refs/#{@kv.ref}"}), '']
+    end
+    @kv.replace(:hello, "universe").update()
+    assert_equal body, @kv.value
+  end
+
+  def test_update_replace_operation_replaces_field_with_new_value_with_ref
+    replace = [{ "op" => "replace", "path" => "hello", "value" => "universe"}]
+    body = @kv.value
+    body["hello"] = "universe"
+    ref = @kv.ref
+    @stubs.patch("/v0/items/#{@kv.key}") do |env|
+      assert_equal replace, JSON.parse(env.body)
+      assert_header 'If-Match', "\"#{@kv.ref}\"", env
+      assert_header 'Content-Type', 'application/json-patch+json', env
+      [201, response_headers({'Etag' => ref, "Location" => "/v0/items/#{@kv.key}/refs/#{ref}"}), '']
+    end
+    @kv.replace(:hello, "universe").update(ref)
+    assert_equal body, @kv.value
+    assert_equal ref, @kv.ref
+  end
+
+  def test_update_replace_operation_raises_error_with_non_existing_field
+    replace = [{ "op" => "replace", "path" => "foo", "value" => "bar"}]
+    body = @kv.value
+    @stubs.patch("/v0/items/#{@kv.key}") do |env|
+      assert_equal replace, JSON.parse(env.body)
+      assert_header 'Content-Type', 'application/json-patch+json', env
+      error_response(:malformed_ref)
+    end
+    assert_raises Orchestrate::API::MalformedRef do
+      @kv.replace(:foo, "bar").update()
+    end
+  end
+
+  def test_update_move_operation_moves_field_without_ref
+    move = [{ "op" => "move", "from" => "hello", "path" => "foo" }]
+    body = @kv.value
+    body.delete("hello")
+    body["foo"] = "world"
+    @stubs.patch("/v0/items/#{@kv.key}") do |env|
+      assert_equal move, JSON.parse(env.body)
+      assert_header 'Content-Type', 'application/json-patch+json', env
+      [201, response_headers({'Etag' => @kv.ref, "Location" => "/v0/items/#{@kv.key}/refs/#{@kv.ref}"}), '']
+    end
+    @kv.move(:hello, :foo).update()
+    assert_equal body, @kv.value
+  end
+
+  def test_update_move_operation_moves_field_with_ref
+    move = [{ "op" => "move", "from" => "hello", "path" => "foo" }]
+    body = @kv.value
+    body.delete("hello")
+    body["foo"] = "world"
+    ref = @kv.ref
+    @stubs.patch("/v0/items/#{@kv.key}") do |env|
+      assert_equal move, JSON.parse(env.body)
+      assert_header 'If-Match', "\"#{@kv.ref}\"", env
+      assert_header 'Content-Type', 'application/json-patch+json', env
+      [201, response_headers({'Etag' => ref, "Location" => "/v0/items/#{@kv.key}/refs/#{ref}"}), '']
+    end
+    @kv.move(:hello, :foo).update(ref)
+    assert_equal body, @kv.value
+    assert_equal ref, @kv.ref
+  end
+
+  def test_update_move_operation_raises_error_with_non_existing_field
+    move = [{ "op" => "move", "from" => "foo", "path" => "hello" }]
+    body = @kv.value
+    @stubs.patch("/v0/items/#{@kv.key}") do |env|
+      assert_equal move, JSON.parse(env.body)
+      assert_header 'Content-Type', 'application/json-patch+json', env
+      error_response(:malformed_ref)
+    end
+    assert_raises Orchestrate::API::MalformedRef do
+      @kv.move(:foo, :hello).update()
+    end
+  end
+
+  def test_update_copy_operation_copies_field_without_ref
+    copy = [{ "op" => "copy", "from" => "hello", "path" => "foo" }]
+    body = @kv.value
+    body["foo"] = "world"
+    @stubs.patch("/v0/items/#{@kv.key}") do |env|
+      assert_equal copy, JSON.parse(env.body)
+      assert_header 'Content-Type', 'application/json-patch+json', env
+      [201, response_headers({'Etag' => @kv.ref, "Location" => "/v0/items/#{@kv.key}/refs/#{@kv.ref}"}), '']
+    end
+    @kv.copy(:hello, :foo).update()
+    assert_equal body, @kv.value
+  end
+
+  def test_update_copy_operation_copies_field_with_ref
+    copy = [{ "op" => "copy", "from" => "hello", "path" => "foo" }]
+    body = @kv.value
+    body["foo"] = "world"
+    ref = @kv.ref
+    @stubs.patch("/v0/items/#{@kv.key}") do |env|
+      assert_equal copy, JSON.parse(env.body)
+      assert_header 'If-Match', "\"#{@kv.ref}\"", env
+      assert_header 'Content-Type', 'application/json-patch+json', env
+      [201, response_headers({'Etag' => ref, "Location" => "/v0/items/#{@kv.key}/refs/#{ref}"}), '']
+    end
+    @kv.copy(:hello, :foo).update(ref)
+    assert_equal body, @kv.value
+    assert_equal ref, @kv.ref
+  end
+
+  def test_update_copy_operation_raises_error_with_non_existing_field
+    copy = [{ "op" => "copy", "from" => "foo", "path" => "hello" }]
+    body = @kv.value
+    @stubs.patch("/v0/items/#{@kv.key}") do |env|
+      assert_equal copy, JSON.parse(env.body)
+      assert_header 'Content-Type', 'application/json-patch+json', env
+      error_response(:malformed_ref)
+    end
+    assert_raises Orchestrate::API::MalformedRef do
+      @kv.copy(:foo, :hello).update()
+    end
+  end
+
+  def test_update_increment_operation_increases_field_number_value_without_ref
+    increment = [{ "op" => "inc", "path" => "count", "value" => 1 }]
+    body = @kv.value
+    old_count = 2
+    body["count"] = 3
+    @stubs.patch("/v0/items/#{@kv.key}") do |env|
+      assert_equal increment, JSON.parse(env.body)
+      assert_header 'Content-Type', 'application/json-patch+json', env
+      [201, response_headers({'Etag' => @kv.ref, "Location" => "/v0/items/#{@kv.key}/refs/#{@kv.ref}"}), '']
+    end
+    @kv.increment(:count, 1).update()
+    assert_equal body, @kv.value
+    assert_equal old_count+1, @kv.value["count"]
+  end
+
+  def test_update_increment_operation_increases_field_number_value_with_ref
+    increment = [{ "op" => "inc", "path" => "count", "value" => 1 }]
+    body = @kv.value
+    old_count = 2
+    body["count"] = 3
+    ref = @kv.ref
+    @stubs.patch("/v0/items/#{@kv.key}") do |env|
+      assert_equal increment, JSON.parse(env.body)
+      assert_header 'If-Match', "\"#{@kv.ref}\"", env
+      assert_header 'Content-Type', 'application/json-patch+json', env
+      [201, response_headers({'Etag' => ref, "Location" => "/v0/items/#{@kv.key}/refs/#{ref}"}), '']
+    end
+    @kv.increment(:count, 1).update(ref)
+    assert_equal body, @kv.value
+    assert_equal ref, @kv.ref
+    assert_equal old_count+1, @kv.value["count"]
+  end
+
+  def test_update_increment_operation_raises_error_with_non_number_field
+    increment = [{ "op" => "inc", "path" => "hello", "value" => 1 }]
+    body = @kv.value
+    @stubs.patch("/v0/items/#{@kv.key}") do |env|
+      assert_equal increment, JSON.parse(env.body)
+      assert_header 'Content-Type', 'application/json-patch+json', env
+      error_response(:malformed_ref)
+    end
+    assert_raises Orchestrate::API::MalformedRef do
+      @kv.increment(:hello, 1).update()
+    end
+  end
+
+  def test_update_increment_operation_raises_error_with_non_existing_field
+    increment = [{ "op" => "inc", "path" => "foo", "value" => 1 }]
+    body = @kv.value
+    @stubs.patch("/v0/items/#{@kv.key}") do |env|
+      assert_equal increment, JSON.parse(env.body)
+      assert_header 'Content-Type', 'application/json-patch+json', env
+      error_response(:malformed_ref)
+    end
+    assert_raises Orchestrate::API::MalformedRef do
+      @kv.increment(:foo, 1).update()
+    end
+  end
+
+  def test_update_decrement_operation_decreases_field_number_value_without_ref
+    decrement = [{ "op" => "inc", "path" => "count", "value" => -1 }]
+    body = @kv.value
+    old_count = 3
+    body["count"] = 2
+    @stubs.patch("/v0/items/#{@kv.key}") do |env|
+      assert_equal decrement, JSON.parse(env.body)
+      assert_header 'Content-Type', 'application/json-patch+json', env
+      [201, response_headers({'Etag' => @kv.ref, "Location" => "/v0/items/#{@kv.key}/refs/#{@kv.ref}"}), '']
+    end
+    @kv.decrement(:count, 1).update()
+    assert_equal body, @kv.value
+    assert_equal old_count-1, @kv.value["count"]
+  end
+
+  def test_update_decrement_operation_decreases_field_number_value_with_ref
+    decrement = [{ "op" => "inc", "path" => "count", "value" => -1 }]
+    body = @kv.value
+    old_count = 3
+    body["count"] = 2
+    ref = @kv.ref
+    @stubs.patch("/v0/items/#{@kv.key}") do |env|
+      assert_equal decrement, JSON.parse(env.body)
+      assert_header 'If-Match', "\"#{@kv.ref}\"", env
+      assert_header 'Content-Type', 'application/json-patch+json', env
+      [201, response_headers({'Etag' => ref, "Location" => "/v0/items/#{@kv.key}/refs/#{ref}"}), '']
+    end
+    @kv.decrement(:count, 1).update(ref)
+    assert_equal body, @kv.value
+    assert_equal ref, @kv.ref
+    assert_equal old_count-1, @kv.value["count"]
+  end
+
+  def test_update_decrement_operation_raises_error_with_non_number_field
+    decrement = [{ "op" => "inc", "path" => "hello", "value" => -1 }]
+    body = @kv.value
+    @stubs.patch("/v0/items/#{@kv.key}") do |env|
+      assert_equal decrement, JSON.parse(env.body)
+      assert_header 'Content-Type', 'application/json-patch+json', env
+      error_response(:malformed_ref)
+    end
+    assert_raises Orchestrate::API::MalformedRef do
+      @kv.decrement(:hello, 1).update()
+    end
+  end
+
+  def test_update_decrement_operation_raises_error_with_non_existing_field
+    decrement = [{ "op" => "inc", "path" => "foo", "value" => -1 }]
+    body = @kv.value
+    @stubs.patch("/v0/items/#{@kv.key}") do |env|
+      assert_equal decrement, JSON.parse(env.body)
+      assert_header 'Content-Type', 'application/json-patch+json', env
+      error_response(:malformed_ref)
+    end
+    assert_raises Orchestrate::API::MalformedRef do
+      @kv.decrement(:foo, 1).update()
+    end
+  end
+
+  def test_update_test_operation_checks_equality_of_field_value_success
+    test = [{ "op" => "test", "path" => "count", "value" => 1 }]
+    body = @kv.value
+    body["count"] = 1
+    @stubs.patch("/v0/items/#{@kv.key}") do |env|
+      assert_equal test, JSON.parse(env.body)
+      assert_header 'Content-Type', 'application/json-patch+json', env
+      [201, response_headers({'Etag' => @kv.ref, "Location" => "/v0/items/#{@kv.key}/refs/#{@kv.ref}"}), '']
+    end
+    @kv.test(:count, 1).update()
+    assert_equal body, @kv.value
+  end
+
+  def test_update_test_operation_checks_equality_of_field_value_failure
+    test = [{ "op" => "test", "path" => "count", "value" => 2 }]
+    body = @kv.value
+    body["count"] = 1
+    @stubs.patch("/v0/items/#{@kv.key}") do |env|
+      assert_header 'Content-Type', 'application/json-patch+json', env
+      error_response(:indexing_conflict)
+    end
+    assert_raises Orchestrate::API::IndexingConflict do
+      @kv.test(:foo, 1).update()
+    end
+  end
+
+  def test_update_test_operation_raises_error_with_non_existing_field
+    test = [{ "op" => "test", "path" => "foo", "value" => 1 }]
+    body = @kv.value
+    @stubs.patch("/v0/items/#{@kv.key}") do |env|
+      assert_equal test, JSON.parse(env.body)
+      assert_header 'Content-Type', 'application/json-patch+json', env
+      error_response(:malformed_ref)
+    end
+    assert_raises Orchestrate::API::MalformedRef do
+      @kv.test(:foo, 1).update()
+    end
+  end
+
   def test_destroy_performs_delete_if_match_and_returns_true_on_success
     @stubs.delete("/v0/items/#{@kv.key}") do |env|
       assert_header 'If-Match', "\"#{@kv.ref}\"", env

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: orchestrate
 version: !ruby/object:Gem::Version
-  version: 0.9.2
+  version: 0.10.0
 platform: ruby
 authors:
 - Matthew Lyon
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-11-19 00:00:00.000000000 Z
+date: 2014-12-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: faraday
@@ -150,6 +150,7 @@ files:
 - test/orchestrate/application_test.rb
 - test/orchestrate/client_test.rb
 - test/orchestrate/collection_enumeration_test.rb
+- test/orchestrate/collection_geo_queries_test.rb
 - test/orchestrate/collection_kv_accessors_test.rb
 - test/orchestrate/collection_searching_test.rb
 - test/orchestrate/collection_sorting_test.rb
@@ -195,6 +196,7 @@ test_files:
 - test/orchestrate/application_test.rb
 - test/orchestrate/client_test.rb
 - test/orchestrate/collection_enumeration_test.rb
+- test/orchestrate/collection_geo_queries_test.rb
 - test/orchestrate/collection_kv_accessors_test.rb
 - test/orchestrate/collection_searching_test.rb
 - test/orchestrate/collection_sorting_test.rb