orchestrate 0.7.0 → 0.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: a997f89d7ead7ddaa902fa36b7c50d5dcaa36fe9
-  data.tar.gz: e767f9630b2a2c619c22d4606f8005a11e35e079
+  metadata.gz: a9ab618bc8f0fd8e7d46d7621b4378a894ec9150
+  data.tar.gz: 4869b43cead19ce0c710d135f6551b20e0ef991a
 SHA512:
-  metadata.gz: 6a0d8dabd889acb31b465972186862317f3a19d0709d9c96c188fadf06b0cf22748af04821e3331c47111b6f59e8af4390877004bf4a926eb5f2962d89539615
-  data.tar.gz: c76d14585febf3df794571aa6c2442820c89bdbcd6395ace403bcb7ad714ed8ef120461c7c73b686b5008c7f73643687cb4184446a776ea969554f521a7fc969
+  metadata.gz: b22bac7d118ed9f23c25f6f3f0dd8e624d99d3f0eb7da3c85b25fedb59fa280494087945eee367d08cb730ef78d8f39a5beac2c3bcddd179d808e3e07f77bc05
+  data.tar.gz: f72465848c71bbcbde91f021ce3f6097d006d5da3bd4177a3867534b1e201d01ea3d042ed3b158049852fa38107694af611397519c774572afd30f947be2d486

data/README.md

@@ -4,7 +4,9 @@ Orchestrate API for Ruby
 
 Ruby client interface for the [Orchestrate.io](http://orchestrate.io) REST API.
 
-[rDoc Documentation](http://rdoc.info/github/orchestrate-io/orchestrate-ruby/master/frames)
+[rDoc Documentation][rdoc]
+
+[rdoc]: (http://rdoc.info/github/orchestrate-io/orchestrate-ruby/master/frames)
 
 ## Getting Started
 
@@ -53,6 +55,12 @@ client.delete(:users, :jack, jack.ref)      # DELETE-If-Match, returns API::Resp
 client.list(:users)                         # LIST users, returns API::CollectionResposne
 ```
 
+### Examples and Documentation
+
+There are more examples at [Orchestrate's API Documentation][apidoc] and documentation in the [rdoc][].
+
+[apidoc]: http://orchestrate.io/api/version
+
 ## Swapping out the HTTP back end
 
 This gem uses [Faraday][] for its HTTP needs -- and Faraday allows you to change the underlying HTTP client used.  The Orchestrate client defaults to [net-http-persistent][nhp] for speed on repeat requests without having to resort to a compiled library.  You can easily swap in [Typhoeus][] which uses libcurl to enable fast, parallel requests, or [EventMachine HTTP][em-http] to use a non-blocking, callback-based interface.  Examples are below.
@@ -68,6 +76,8 @@ You may use Faraday's `test` adapter to stub out calls to the Orchestrate API in
 
 If you're using a Faraday back end that enables parallelization, such as Typhoeus, EM-HTTP-Request, or EM-Synchrony you can use `Orchestrate::Client#in_parallel` to fire off multiple requests at once.  If your Faraday back end does not support this, the method will still work as expected, but Faraday will output a warning to STDERR and the requests will be performed in series.
 
+Note that these parallel modes are not thread-safe.  If you are using the client in a threaded environment, you should use `#dup` on your `Orchestrate::Client` or `Orchestrate::Application` to create per-thread instances.
+
 #### method client
 ``` ruby
 client = Orchestrate::Client.new(api_key) {|f| f.adapter :typhoeus }
@@ -87,14 +97,27 @@ responses[:user] = #<Orchestrate::API::ItemResponse:0x00...>
 app = Orchestrate::Application.new(api_key) {|f| f.adapter :typhoeus }
 
 app.in_parallel do
-  @items = app[:my_collection].lazy.take(100)
+  @items = app[:my_collection].each
   @user = app[:users][current_user_id]
 end
+@items.take(5)
 ```
 
-Note that values are not available inside of the `in_parallel` block.  The `r[:list]` or `@items` objects are placeholders for their future values and will be available after the `in_parallel` block returns.  Since `take` and other enumerable methods normally attempt to access the value when called, you **must** convert the `app[:my_collection]` enumerator to a lazy enumerator with #lazy.  Attempting to access the enumerator's values (for example, without using `#lazy` or by using `#any?` or `#find`) while inside the `in_parallel` block will raise an `Orchestrate::ResultsNotReady` exception.
+Note that values are not available inside of the `in_parallel` block.  The `r[:list]` or `@items` objects are placeholders for their future values and will be available after the `in_parallel` block returns.  Since `take` and other enumerable methods normally attempt to access the value when called, you **must** convert the `app[:my_collection]` to an `Enumerator` with `#each` and access them outside the parallel block.
 
-Lazy Enumerators are not available by default in Ruby 1.9.
+You can, inside the parallel block, construct further iteration over your collection with `Enumerable#lazy` like so:
+
+```ruby
+app.in_parallel do
+  @items = app[:my_collection].each.lazy.take(5)
+  ...
+end
+@items.force
+```
+
+Attempting to access the values inside the parallel block will raise an `Orchestrate::ResultsNotReady` exception.
+
+Lazy enumerators are not available by default in Ruby 1.9.  Lazy enumerator results are not pre-fetched from orchestrate unless they are taken inside an `#in_parallel` block, otherwise results are fetched when needed.
 
 ### Using with Typhoeus
 
@@ -136,6 +159,19 @@ end
 
 ## Release Notes
 
+### July 24, 2014: release 0.8.0
+  - **BACKWARDS-INCOMPATIBLE** Fix #69, `Client` will url-escape path segments.  If you have keys with slashes or spaces or other
+    characters escaped by `URI.escape` the client will now behave as expected, however if you've used these keys with this client
+    before you may not be able to get to those old keys.
+  - Fix #78, KeyValues are given an empty hash value by default, instead of nil.
+  - Change default value for `KeyValue#ref` to be false.  On save, this will send an `If-None-Match` header instead of omitting the condition.
+  - Revisited `#in_parallel` methods, improved documentation, tests for Enumerables on Object client, made sure behavior conforms.
+  - Implement `KeyValue#update` and `#update!` to update the value and save in one go.
+  - Implement `Collection#stub` to instantiate a KeyValue without loading it, for access to Relations, Refs, Events, etc.
+  - Implement `Collection#build` to provide a factory for unsaved KV items in a collection.
+  - Implement `KeyValue#relation` for Graph / Relation queries on object client.
+  - Implement `Collection#search` for Lucene queries on Collections via the object client.
+
 ### July 1, 2014: release 0.7.0
   - Fix #66 to make parallel mode work properly
   - Switch the default Faraday adapter to the `net-http-persistent` gem, which in casual testing yields much better performance for sustained use.

data/lib/orchestrate/application.rb

@@ -10,8 +10,7 @@ module Orchestrate
     attr_reader :client
 
     # Instantiate a new Application
-    # @param client_or_api_key [#to_s] The API key for your Orchestrate Application.
-    # @param client_or_api_key [Orchestrate::Client] A client instantiated with an Application and Faraday setup.
+    # @param client_or_api_key [Orchestrate::Client, #to_s] A client instantiated with the API key and faraday setup, or the API key for your Orchestrate Application.
     # @yieldparam [Faraday::Connection] connection Setup for the Faraday connection.
     # @return Orchestrate::Application
     def initialize(client_or_api_key, &client_setup)
@@ -41,8 +40,19 @@ module Orchestrate
     #     r[:user_feed]  = app.client.list_events(:users, current_user_key, :notices)
     #   end
     # @see README See the Readme for more examples.
+    # @note This method is not Thread-safe.  Requests generated from the same
+    #   application instance in different threads while #in_parallel is running
+    #   will behave unpredictably.  Use `#dup` to create per-thread application
+    #   instances.
     def in_parallel(&block)
-      client.in_parallel(&block)
+      @inside_parallel = true
+      results = client.in_parallel(&block)
+      @inside_parallel = nil
+      results
+    end
+
+    def inside_parallel?
+      !! @inside_parallel
     end
 
     # @return a pretty-printed representation of the application.

data/lib/orchestrate/client.rb

@@ -1,4 +1,5 @@
 require 'faraday'
+require 'uri'
 
 module Orchestrate
 
@@ -39,6 +40,11 @@ module Orchestrate
     end
     alias :inspect :to_s
 
+    # @!visibility private
+    def dup
+      self.class.new(api_key, &faraday_configuration)
+    end
+
     # Tests authentication with Orchestrate.
     # @return Orchestrate::API::Response
     # @raise Orchestrate::API::Unauthorized if the client could not authenticate.
@@ -358,6 +364,9 @@ module Orchestrate
     #     r[:user_feed] = client.list_events(:users, current_user_key, :notices)
     #   end
     # @see README See the Readme for more examples.
+    # @note This method is not Thread-safe.  Requests generated from the same
+    #   client in different threads while #in_parallel is running will behave
+    #   unpredictably.  Use `#dup` to create per-thread clients.
     def in_parallel(&block)
       accumulator = {}
       http.in_parallel do
@@ -377,7 +386,7 @@ module Orchestrate
     # @return API::Response
     # @raise [Orchestrate::API::RequestError, Orchestrate::API::ServiceError] see http://orchestrate.io/docs/api/#errors
     def send_request(method, path, options={})
-      path = ['/v0'].concat(path).join('/')
+      path = ['/v0'].concat(path.map{|s| URI.escape(s.to_s).gsub('/','%2F') }).join('/')
       query_string = options.fetch(:query, {})
       body = options.fetch(:body, '')
       headers = options.fetch(:headers, {})

data/lib/orchestrate/collection.rb

@@ -134,6 +134,26 @@ module Orchestrate
       end
     end
 
+    # Builds a new, unsaved KeyValue with the given key_name and value.
+    # @param key_name [#to_s] The key of the item
+    # @param value [#to_json] The value to store at the key.
+    # @return [KeyValue]
+    def build(key_name, value={})
+      kv = KeyValue.new(self, key_name)
+      kv.value = value
+      kv
+    end
+
+    # Returns an unloaded KeyValue object with the given key_name, if you need
+    # to access Refs, Relations or Events without loading the KeyValue's value.
+    # @param key_name [#to_s] The key of the item.
+    # @return [KeyValue]
+    def stub(key_name)
+      kv = KeyValue.new(self, key_name)
+      kv.value = nil
+      kv
+    end
+
     # [Deletes the value for a KeyValue
     # item](http://orchestrate.io/docs/api/#key/value/delete12).
     # @param key_name [#to_s] The name of the key
@@ -166,10 +186,15 @@ module Orchestrate
     #   keys = collection.take(20).map(&:key)
     #   # returns the first 20 keys in the collection.
     def each(&block)
-      return enum_for(:each) unless block
       KeyValueList.new(self).each(&block)
     end
 
+    # Creates a Lazy Enumerator for the Collection's KeyValue List.  If called inside the app's
+    # `#in_parallel` block, pre-fetches results.
+    def lazy
+      KeyValueList.new(self).lazy
+    end
+
     # Sets the inclusive start key for enumeration over the KeyValue items in the collection.
     # @see KeyValueList#start
     # @return [KeyValueList]
@@ -265,14 +290,13 @@ module Orchestrate
 
       include Enumerable
 
-      # Lazily iterates over each KeyValue item in the collection.  Used as the basis for Enumerable methods.
+      # Iterates over each KeyValue item in the collection.  Used as the basis for Enumerable methods.
       # Items are provided in lexicographically sorted order by key name.
       # @yieldparam [Orchestrate::KeyValue] key_value The KeyValue item
       # @example
       #   keys = collection.after(:foo).take(20).map(&:key)
       #   # returns the first 20 keys in the collection that occur after "foo"
       def each
-        return enum_for(:each) unless block_given?
         params = {}
         if range[:begin]
           begin_key = range[:begin_inclusive] ? :start : :after
@@ -283,15 +307,24 @@ module Orchestrate
           params[end_key] = range[:end]
         end
         params[:limit] = range[:limit]
-        response = collection.app.client.list(collection.name, params)
-        raise ResultsNotReady.new if collection.app.client.http.parallel_manager
+        @response ||= collection.app.client.list(collection.name, params)
+        return enum_for(:each) unless block_given?
+        raise ResultsNotReady.new if collection.app.inside_parallel?
         loop do
-          response.results.each do |doc|
-            yield KeyValue.new(collection, doc, response.request_time)
+          @response.results.each do |doc|
+            yield KeyValue.from_listing(collection, doc, @response)
           end
-          break unless response.next_link
-          response = response.next_results
+          break unless @response.next_link
+          @response = @response.next_results
         end
+        @response = nil
+      end
+
+      # Creates a Lazy Enumerator for the KeyValue list.  If called inside the
+      # app's `#in_parallel` block, will prefetch results.
+      def lazy
+        return each.lazy if collection.app.inside_parallel?
+        super
       end
 
       # Returns the first n items.  Equivalent to Enumerable#take.  Sets the
@@ -303,7 +336,97 @@ module Orchestrate
         range[:limit] = count > 100 ? 100 : count
         super(count)
       end
+    end
+
+    # @!group Searching
+    # [Search the items in a collection](http://orchestrate.io/docs/api/#search) using a Lucene
+    # Query Syntax.
+    # @param query [#to_s] The [Lucene Query
+    #   String](http://lucene.apache.org/core/4_3_0/queryparser/org/apache/lucene/queryparser/classic/package-summary.html#Overview)
+    #   to query the collection with.
+    # @return [SearchResults] A loaded SearchResults object ready to enumerate over.
+    def search(query)
+      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.
+      attr_reader :collection
+
+      # @return [#to_s] The Lucene Query String given as the search query.
+      attr_reader :query
+
+      # @return [Integer] The number of results to fetch per request.
+      attr_reader :limit
+
+      # Initialize a new SearchResults object
+      # @param collection [Orchestrate::Collection] The collection to search.
+      # @param query [#to_s] The Lucene Query to perform.
+      def initialize(collection, query)
+        @collection = collection
+        @query = query
+        @limit = 100
+        @offset= nil
+      end
+
+      include Enumerable
+
+      # Iterates over each result from the Search.  Used as the basis for Enumerable methods.  Items are
+      # provided on the basis of score, with most relevant first.
+      # @yieldparam [Array<(Float, Orchestrate::KeyValue)>] score,key_value  The item's score and the item.
+      # @example
+      #   collection.search("trendy").take(5).each do |score, item|
+      #     puts "#{item.key} has a trend score of #{score}"
+      #   end
+      def each
+        params = {limit:limit}
+        params[:offset] = offset if offset
+        @response ||= collection.app.client.search(collection.name, query, params)
+        return enum_for(:each) unless block_given?
+        raise ResultsNotReady.new if collection.app.inside_parallel?
+        loop do
+          @response.results.each do |listing|
+            yield [ listing['score'], KeyValue.from_listing(collection, listing, @response) ]
+          end
+          break unless @response.next_link
+          @response = @response.next_results
+        end
+        @response = nil
+      end
+
+      # Creates a Lazy Enumerator for the Search Results.  If called inside its
+      # app's `in_parallel` block, will pre-fetch results.
+      def lazy
+        return each.lazy if collection.app.inside_parallel?
+        super
+      end
+
+      # Returns the first n items.  Equivalent to Enumerable#take.  Sets the
+      # `limit` parameter on the query to Orchestrate, so we don't ask for more than is needed.
+      # @param count [Integer] The number of items to limit to.
+      # @return [Array]
+      def take(count)
+        @limit = count > 100 ? 100 : count
+        super(count)
+      end
 
+      # Sets the offset for the query to Orchestrate, so you can skip items.  Does not fire a request.
+      # Impelemented as separate method from drop, unlike #take, because take is a more common use case.
+      # @overload offset
+      #   @return [Integer, nil] The number of items to skip.  Nil is equivalent to zero.
+      # @overload offset(conunt)
+      #   @param count [Integer] The number of items to skip.
+      #   @return [SearchResults] self.
+      def offset(count=nil)
+        if count
+          @offset = count
+          self
+        else
+          @offset
+        end
+      end
     end
 
   end

data/lib/orchestrate/graph.rb

@@ -0,0 +1,146 @@
+module Orchestrate
+
+  # Manages graph relationships for a KeyValue item.
+  class Graph
+
+    # Instantiates a new Graph manager.
+    # @param kv_item [Orchestrate::KeyValue] The KeyValue item on the starting end of the graph.
+    def initialize(kv_item)
+      @kv_item = kv_item
+      @types = {}
+    end
+
+    # Accessor for graph relation types.
+    # @return [RelationStem]
+    def [](relation_type)
+      @types[relation_type.to_s] || RelationStem.new(@kv_item, relation_type.to_s)
+    end
+
+    # A directed relationship against a single KeyValue object.
+    class RelationStem
+
+      # the KeyValue object this RelationStem acts on behalf of.
+      # @return [Orchestrate::KeyValue]
+      attr_accessor :kv_item
+
+      # the type of relation this RelationStem interacts with.
+      # @return [String]
+      attr_accessor :type
+
+      # Instantiates a new RelationStem
+      # @param kv_item [Orchestrate::KeyValue] the KeyValue object this RelationStem acts on behalf of.
+      # @param type_name [#to_s] the type of relation this RelationStem interacts with.
+      def initialize(kv_item, type_name)
+        @kv_item = kv_item
+        @client = kv_item.collection.app.client
+        @type = type_name.to_s
+      end
+
+      # [Creates a relationship between two objects](http://orchestrate.io/docs/api/#graph/put).
+      # Relations can span collections.
+      # @overload <<(key_value_item)
+      #   @param key_value_item [Orchestrate::KeyValue] The KeyValue item to create the relationship with.
+      # @overload <<(collection_name, key_name)
+      #   @param collection_name [#to_s] The collection which the other item belongs to.
+      #   @param key_name [#to_s] The key of the other item.
+      # @return [Orchestrate::API::Response]
+      def <<(other_item_or_collection_name, other_key=nil)
+        coll, key = get_collection_and_key(kv_item, nil)
+        other_collection, other_key = get_collection_and_key(other_item_or_collection_name, other_key)
+        @client.put_relation(coll, key, type, other_collection, other_key)
+      end
+      alias :push :<<
+
+      # [Deletes a relationship between two objects](http://orchestrate.io/docs/api/#graph/delete29).
+      # @overload delete(key_value_item)
+      #   @param key_value_item [Orchestrate::KeyValue] The KeyValue item to create the relationship with.
+      # @overload delete(collection_name, key_name)
+      #   @param collection_name [#to_s] The collection which the other item belongs to.
+      #   @param key_name [#to_s] The key of the other item.
+      # @return [Orchestrate::API::Response]
+      def delete(other_item_or_collection_name, other_key=nil)
+        coll, key = get_collection_and_key(kv_item, nil)
+        other_collection, other_key = get_collection_and_key(other_item_or_collection_name, other_key)
+        @client.delete_relation(coll, key, type, other_collection, other_key)
+      end
+
+      # Adds depth to the retrieval of related items.
+      # @param type_n [#to_s] The kind of the relation for the second layer of depth to retreive results for.
+      # @return [Traversal]
+      def [](type_n)
+        Traversal.new(kv_item, [type, type_n.to_s])
+      end
+
+      include Enumerable
+
+      # [Retrieves the related items](http://orchestrate.io/api/graph), and
+      # iterates over each item in the result.  Used as the basis for
+      # Enumerable methods.
+      # @overload each
+      #   @return [Enumerator]
+      # @overload each(&block)
+      #   @yieldparam [Orchestrate::KeyValue] key_value The KeyValue item
+      def each(&block)
+        Traversal.new(kv_item, [type]).each(&block)
+      end
+
+     private
+      def get_collection_and_key(item_or_collection, key)
+        if item_or_collection.kind_of?(KeyValue)
+          collection = item_or_collection.collection_name
+          key = item_or_collection.key
+        else
+          collection = item_or_collection
+        end
+        [collection, key]
+      end
+
+      # Traverses from a single node in the graph across one or more edges.
+      # The workhorse for gathering results from a graph search.
+      class Traversal
+
+        # The KeyValue item from which the graph query originates.
+        # @return [KeyValue]
+        attr_accessor :kv_item
+
+        # The graph types and depth to traverse.
+        # @return [Array<#to_s>]
+        attr_accessor :edges
+
+        # Instantiates a new Traversal.
+        # @param kv_item [KeyValue] The KeyValue item from which to traverse.
+        # @param edge_names [Array<#to_s>] The graph types and depth to traverse.
+        def initialize(kv_item, edge_names)
+          @kv_item = kv_item
+          @edges = edge_names
+          @client = kv_item.collection.app.client
+        end
+
+        # Add a new type to the depth of the graph query.
+        # @param edge [#to_s] The type of relation to traverse.
+        # @return [Traversal]
+        def [](edge)
+          self.class.new(kv_item, [edges, edge].flatten)
+        end
+
+        include Enumerable
+
+        # [Retrieves the related items](http://orchestrate.io/api/graph), and
+        # iterates over each item in the result.  Used as the basis for
+        # Enumerable methods.
+        def each(&block)
+          @response = @client.get_relations(kv_item.collection_name, kv_item.key, *edges)
+          return enum_for(:each) unless block
+          raise ResultsNotReady if @client.http.parallel_manager
+          @response.results.each do |listing|
+            listing_collection = kv_item.collection.app[listing['path']['collection']]
+            yield KeyValue.from_listing(listing_collection, listing, @response)
+          end
+        end
+
+      end
+    end
+
+  end
+end
+

data/lib/orchestrate/key_value.rb

@@ -26,6 +26,25 @@ module Orchestrate
       kv
     end
 
+    # Instantiate a KeyValue from a listing in a LIST or SEARCH result
+    # @param collection [Orchestrate::Collection] The collection to which the KeyValue belongs.
+    # @param listing [Hash] The entry in the LIST or SEARCH result
+    # @option listing [Hash] path **required** The path of the entry, with collection, key and ref keys.
+    # @option listing [Hash] value **required** The value for the entry
+    # @option listing [Time] reftime The time which the ref was created (only returned by LIST)
+    # @param response [Orchestrate::API::Response] The response which the listing came from
+    # @return Orchestrate::KeyValue The KeyValue item.
+    def self.from_listing(collection, listing, response)
+      path = listing.fetch('path')
+      key = path.fetch('key')
+      ref = path.fetch('ref')
+      kv = new(collection, key, response)
+      kv.instance_variable_set(:@ref, ref)
+      kv.instance_variable_set(:@reftime, listing['reftime']) if listing['reftime']
+      kv.value = listing.fetch('value')
+      kv
+    end
+
     # The collection this KeyValue belongs to.
     # @return [Orchestrate::Collection]
     attr_reader :collection
@@ -66,28 +85,19 @@ module Orchestrate
     # Instantiates a new KeyValue item.  You generally don't want to call this yourself, but rather use
     # the methods on Orchestrate::Collection to load a KeyValue.
     # @param coll [Orchestrate::Collection] The collection to which this KeyValue belongs.
-    # @param key_name_or_listing [Hash] A listing result from Client#list
-    # @param key_name_or_listing [#to_s] The name of the key
-    # @param response_or_request_time [nil, Time, Orchestrate::API::Response]
-    #   If key_name_or_listing is a listing, and this value is a Time, used to set last_request_time.
-    #   Otherwise if an API::Request, used to load attributes and value.
+    # @param key_name [#to_s] The name of the key
+    # @param associated_response [nil, Orchestrate::API::Response]
+    #   If an API::Request, used to load attributes and value.
     # @return Orchestrate::KeyValue
-    def initialize(coll, key_name_or_listing, response_or_request_time=nil)
+    def initialize(coll, key_name, associated_response=nil)
       @collection = coll
       @collection_name = coll.name
       @app = coll.app
-      if key_name_or_listing.kind_of?(Hash)
-        path = key_name_or_listing.fetch('path')
-        @key = path.fetch('key')
-        @ref = path.fetch('ref')
-        @reftime = Time.at(key_name_or_listing.fetch('reftime') / 1000.0)
-        @value = key_name_or_listing.fetch('value')
-        @last_request_time = response_or_request_time if response_or_request_time.kind_of?(Time)
-      else
-        @key = key_name_or_listing.to_s
-      end
+      @key = key_name.to_s
       @id = "#{collection_name}/#{key}"
-      load_from_response(response_or_request_time) if response_or_request_time.kind_of?(API::Response)
+      @value = {}
+      @ref = false
+      load_from_response(associated_response) if associated_response
     end
 
     # Equivalent to `String#==`.  Compares by key and collection.
@@ -177,6 +187,27 @@ module Orchestrate
       end
     end
 
+    # 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)
+      begin
+        update!(merge)
+      rescue API::RequestError, API::ServiceError
+        false
+      end
+    end
+
+    # 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]
+    # @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)
+      merge.each_pair {|key, value| @value[key.to_s] = value }
+      save!
+    end
+
     # 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]
@@ -217,12 +248,22 @@ module Orchestrate
       true
     end
 
-    # @!engroup persistence
+    # @!endgroup persistence
+    #
+    # @!group relations
+
+    # Entry point for managing the graph relationships for this KeyValue item
+    # @return [Orchestrate::Graph] A graph instance bound to this item.
+    def relations
+      @relations ||= Graph.new(self)
+    end
+
+    # @!endgroup relations
 
     private
     def load_from_response(response)
       response.on_complete do
-        @ref = response.ref
+        @ref = response.ref if response.respond_to?(:ref)
         @value = response.body unless response.body.respond_to?(:strip) && response.body.strip.empty?
         @last_request_time = response.request_time
       end

data/lib/orchestrate/version.rb

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

data/lib/orchestrate.rb

@@ -3,6 +3,7 @@ require "orchestrate/client"
 require "orchestrate/application"
 require "orchestrate/collection"
 require "orchestrate/key_value"
+require "orchestrate/graph"
 require "orchestrate/version"
 #
 # A library for supporting connections to the \Orchestrate API.

data/test/orchestrate/application_test.rb

@@ -41,4 +41,14 @@ class ApplicationTest < MiniTest::Unit::TestCase
     assert_equal 'users', users.name
   end
 
+  def dup_generates_new_client
+    client, stubs = make_client_and_artifacts
+    app = Orchestrate::Application.new(client)
+    duped_app = app.dup
+    assert_equal app.api_key, duped_app.api_key
+    assert_equal client.faraday_configuration, duped_app.client.faraday_configuration
+    refute_equal client.object_id, duped_app.client.object_id
+    refute_equal client.http.object_id, duped_app.client.http.object_id
+  end
+
 end

data/test/orchestrate/client_test.rb

@@ -47,4 +47,21 @@ class ClientTest < MiniTest::Unit::TestCase
     end
   end
 
+  def test_escapes_url_segments
+    client, stubs = make_client_and_artifacts
+    stubs.get('/v0/foo%2Fbars/(bar%20baz)') { [200, response_headers, {}.to_json] }
+    client.get("foo/bars", "(bar baz)")
+    stubs.verify_stubbed_calls
+  end
+
+  def test_dup
+    client = Orchestrate::Client.new('8c3') do |f|
+      f.adapter :test
+    end
+    dup_client = client.dup
+    assert_equal client.api_key, dup_client.api_key
+    assert_equal client.faraday_configuration, dup_client.faraday_configuration
+    refute_equal client.http.object_id, dup_client.http.object_id
+  end
+
 end

data/test/orchestrate/collection_enumeration_test.rb

@@ -2,10 +2,13 @@ require "test_helper"
 
 class CollectionEnumerationTest < MiniTest::Unit::TestCase
 
-  def test_enumerates_over_all
-    app, stubs = make_application
-    stubs.get("/v0/items") do |env|
-      assert_equal "100", env.params['limit']
+  def setup
+    @app, @stubs = make_application({parallel: true})
+    @called = false
+    @limit = "100"
+    @stubs.get("/v0/items") do |env|
+      @called = true
+      assert_equal @limit, env.params['limit']
       body = case env.params['afterKey']
       when nil
         { "results" => 100.times.map {|x| make_kv_listing(:items, key: "key-#{x}") },
@@ -18,7 +21,10 @@ class CollectionEnumerationTest < MiniTest::Unit::TestCase
       end
       [ 200, response_headers, body.to_json ]
     end
-    items = app[:items].map {|item| item }
+  end
+
+  def test_enumerates_over_all
+    items = @app[:items].map {|item| item }
     assert_equal 104, items.length
     items.each_with_index do |item, index|
       assert_equal "key-#{index}", item.key
@@ -30,39 +36,76 @@ class CollectionEnumerationTest < MiniTest::Unit::TestCase
     end
   end
 
-  def test_enumerator_in_parallel
-    app, stubs = make_application({parallel:true})
-    stubs.get("/v0/items") do |env|
-      body = case env.params['afterKey']
-      when nil
-        { "results" => 10.times.map {|x| make_kv_listing(:items, key: "key-#{x}") },
-          "next" => "/v0/items?afterKey=key-9", "count" => 10 }
-      when 'key-9'
-        { "results" => 4.times.map {|x| make_kv_listing(:items, key: "key-#{10+x}")},
-          "count" => 4 }
-      else
-        raise ArgumentError.new("unexpected afterKey: #{env.params['afterKey']}")
-      end
-      [ 200, response_headers, body.to_json ]
-    end
-    items=nil
+  def test_enumerator_in_parallel_raises_not_ready_if_forced
+    @limit = "5"
     assert_raises Orchestrate::ResultsNotReady do
-      app.in_parallel { app[:items].take(5) }
+      @app.in_parallel { @app[:items].take(5) }
     end
-    if app[:items].respond_to?(:lazy)
-      app.in_parallel do
-        items = app[:items].lazy.map {|item| item }
-      end
-      items = items.force
-      assert_equal 14, items.length
-      items.each_with_index do |item, index|
-        assert_equal "key-#{index}", item.key
-        assert item.ref
-        assert item.reftime
-        assert item.value
-        assert_equal "key-#{index}", item[:key]
-        assert_in_delta Time.now.to_f, item.last_request_time.to_f, 1.1
-      end
+  end
+
+  def test_enumerator_in_parallel_prefetches_lazy_enums
+    return unless [].respond_to?(:lazy)
+    items = nil
+    @app.in_parallel do
+      items = @app[:items].lazy.map {|item| item }
+    end
+    assert @called, "lazy enumerator in parallel was not prefetched"
+    items = items.force
+    assert_equal 104, items.length
+    items.each_with_index do |item, index|
+      assert_equal "key-#{index}", item.key
+      assert item.ref
+      assert item.reftime
+      assert item.value
+      assert_equal "key-#{index}", item[:key]
+      assert_in_delta Time.now.to_f, item.last_request_time.to_f, 1.1
+    end
+  end
+
+  def test_enumerator_in_parallel_fetches_enums
+    items = nil
+    @app.in_parallel do
+      items = @app[:items].each
+    end
+    assert @called, "enumerator wasn't prefetched inside of parallel"
+    assert_equal 104, items.to_a.size
+    items.each_with_index do |item, index|
+      assert_equal "key-#{index}", item.key
+      assert item.ref
+      assert item.reftime
+      assert item.value
+      assert_equal "key-#{index}", item[:key]
+      assert_in_delta Time.now.to_f, item.last_request_time.to_f, 1.1
+    end
+  end
+
+  def test_enumerator_doesnt_prefetch_lazy_enums
+    return unless [].respond_to?(:lazy)
+    items = @app[:items].lazy.map {|item| item }
+    refute @called, "lazy enumerator was prefetched outside of parallel"
+    items = items.force
+    assert_equal 104, items.length
+    items.each_with_index do |item, index|
+      assert_equal "key-#{index}", item.key
+      assert item.ref
+      assert item.reftime
+      assert item.value
+      assert_equal "key-#{index}", item[:key]
+      assert_in_delta Time.now.to_f, item.last_request_time.to_f, 1.1
+    end
+  end
+
+  def test_enumerator_prefetches_enums
+    items = @app[:items].each
+    assert @called, "enumerator was not prefetched"
+    assert_equal 104, items.to_a.size
+    items.each_with_index do |item, index|
+      assert_equal "key-#{index}", item.key
+      assert item.ref
+      assert item.reftime
+      assert item.value
+      assert_equal "key-#{index}", item[:key]
+      assert_in_delta Time.now.to_f, item.last_request_time.to_f, 1.1
     end
   end
 

data/test/orchestrate/collection_kv_accessors_test.rb

@@ -22,6 +22,22 @@ class Collection_KV_Accessors_Test < MiniTest::Unit::TestCase
     assert_nil @items[:absent]
   end
 
+  def test_kv_builder
+    body = {"hello" => "nothing"}
+    kv = @items.build(:absent, body)
+    assert_equal 'absent', kv.key
+    assert_equal body, kv.value
+    assert_equal false, kv.ref
+  end
+
+  def test_kv_stubber
+    kv = @items.stub(:hello)
+    assert_equal 'hello', kv.key
+    assert_equal false, kv.ref
+    assert_nil kv.value
+    refute kv.loaded?
+  end
+
   def test_kv_setter
     body = { "hello" => "world" }
     ref = nil

data/test/orchestrate/collection_searching_test.rb

@@ -0,0 +1,101 @@
+require "test_helper"
+
+class CollectionSearchingTest < MiniTest::Unit::TestCase
+  def setup
+    @app, @stubs = make_application({parallel:true})
+    @items = @app[:items]
+
+    @query = "foo"
+    @limit = 100
+    @total = 110
+
+    @make_listing = lambda{|i| make_kv_listing(:items, key: "item-#{i}", reftime: nil, score: @total-i/@total*5.0) }
+    @handle_offset = lambda do |offset|
+      case offset
+      when nil
+        { "results" => 100.times.map{|i| @make_listing.call(i)}, "count" => 100, "total_count" => @total,
+          "next" => "/v0/items?query=foo&offset=100&limit=100"}
+      when "100"
+        { "results" => 10.times.map{|i| @make_listing.call(i+100)}, "count" => 10, "total_count" => @total }
+      else
+        raise ArgumentError.new("unexpected offset: #{env.params['offset']}")
+      end
+    end
+
+    @called = false
+    @stubs.get("/v0/items") do |env|
+      @called = true
+      assert_equal @query, env.params['query']
+      assert_equal @limit, env.params['limit'].to_i
+      body = @handle_offset.call(env.params['offset'])
+      [ 200, response_headers, body.to_json ]
+    end
+  end
+
+  def test_basic_search
+    results = @items.search("foo").map{|i| i }
+    assert_equal 110, 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_basic_as_needed
+    @limit = 50
+    offset = 10
+    @handle_offset = lambda do |o|
+      case o
+      when "10"
+        { "results" => 50.times.map{|i| @make_listing.call(i+offset) }, "count" => @limit, "total_count" => @total,
+          "next" => "/v0/items?query=foo&offset=#{offset+@limit}&limit=#{@limit}"}
+      else
+        raise ArgumentError.new("unexpected offset: #{o}")
+      end
+    end
+    results = @items.search("foo").offset(offset).take(@limit)
+    assert_equal 50, results.length
+    results.each_with_index do |item, idx|
+      assert_in_delta (@total-(idx+10)/@total * 5.0), item[0], 0.005
+      assert_equal "item-#{idx+10}", item[1].key
+      assert_nil item[1].reftime
+    end
+  end
+
+  def test_in_parallel_prefetches_enums
+    items = nil
+    @app.in_parallel { items = @app[:items].search("foo").each }
+    assert @called, "enum wasn't prefetched inside in_parallel"
+    assert_equal @total, items.to_a.size
+  end
+
+  def test_in_parallel_prefetches_lazy_enums
+    return unless [].respond_to?(:lazy)
+    items = nil
+    @app.in_parallel { items = @app[:items].search("foo").lazy.map{|d| d } }
+    assert @called, "lazy wasn't prefetched from in_parallel"
+    assert_equal @total, items.force.size
+  end
+
+  def test_in_parallel_raises_if_forced
+    assert_raises Orchestrate::ResultsNotReady do
+      @app.in_parallel { @app[:items].search("foo").to_a }
+    end
+  end
+
+  def test_enums_prefetch
+    items = nil
+    @app.in_parallel { items = @app[:items].search("foo").each }
+    assert @called, "enum wasn't prefetched"
+    assert_equal @total, items.to_a.size
+  end
+
+  def test_lazy_enums_dont_prefetch
+    return unless [].respond_to?(:lazy)
+    items = @app[:items].search("foo").lazy.map{|d| d }
+    refute @called, "lazy was prefetched outside in_parallel"
+    assert_equal @total, items.force.size
+  end
+
+end

data/test/orchestrate/key_value_persistence_test.rb

@@ -4,7 +4,7 @@ class KeyValuePersistenceTest < MiniTest::Unit::TestCase
   def setup
     @app, @stubs = make_application
     @items = @app[:items]
-    @kv = make_kv_item(@items, @stubs, :loaded => Time.now - 60)
+    @kv = make_kv_item(@items, @stubs, :loaded => Time.now - 60, body: {"hello" => "world", "another" => "key"})
   end
 
   def test_save_performs_put_if_match_and_returns_true_on_success
@@ -109,6 +109,68 @@ class KeyValuePersistenceTest < MiniTest::Unit::TestCase
     end
   end
 
+  def test_update_merges_values_and_saves
+    update = {hello: "there", 'two' => 2}
+    body = @kv.value
+    update.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)
+    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}
+    body = @kv.value
+    update.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)
+    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}
+    body = @kv.value
+    update.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)
+    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}
+    body = @kv.value
+    update.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
+    assert_raises Orchestrate::API::ServiceError do
+      @kv.update!(update)
+    end
+    assert_equal body, @kv.value
+    assert_equal old_ref, @kv.ref
+  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

data/test/orchestrate/key_value_test.rb

@@ -59,21 +59,11 @@ class KeyValueTest < MiniTest::Unit::TestCase
     kv = Orchestrate::KeyValue.new(items, 'keyname')
     assert_equal 'keyname', kv.key
     assert_equal items, kv.collection
+    assert_equal Hash.new, kv.value
+    assert_equal false, kv.ref
     assert ! kv.loaded?
   end
 
-  def test_instantiates_from_collection_and_listing
-    app, stubs = make_application
-    listing = make_kv_listing('items', {key: "foo"})
-    kv = Orchestrate::KeyValue.new(app[:items], listing, Time.now)
-    assert_equal 'items', kv.collection_name
-    assert_equal "foo", kv.key
-    assert_equal listing['path']['ref'], kv.ref
-    assert_equal listing['value'], kv.value
-    assert_in_delta Time.at(listing['reftime'] / 1000), kv.reftime, 1.1
-    assert_in_delta Time.now.to_f, kv.last_request_time.to_f, 1.1
-  end
-
   def test_equality
     app, stubs = make_application
     app2, stubs = make_application

data/test/orchestrate/relations_test.rb

@@ -0,0 +1,128 @@
+require "test_helper"
+
+class RelationsTest < MiniTest::Unit::TestCase
+
+  def setup
+    @app, @stubs = make_application
+    @items = @app[:items]
+    @kv = make_kv_item(@items, @stubs)
+    @other_kv = make_kv_item(@items, @stubs)
+    @relation_type = :siblings
+    @path = ['items', @kv.key, 'relation', @relation_type, :items, @other_kv.key]
+  end
+
+  def make_results(colls, count)
+    count.times.map do |i|
+      type = colls[i % colls.length]
+      make_kv_listing(type, {reftime:nil, key: "#{type.name}-#{i}", body: {index: i}})
+    end
+  end
+
+  def test_adds_relation_with_kv
+    @stubs.put("/v0/#{@path.join('/')}") { [ 204, response_headers, '' ] }
+    @kv.relations[@relation_type] << @other_kv
+    @stubs.verify_stubbed_calls
+  end
+
+  def test_adds_from_collname_and_keyname
+    @stubs.put("/v0/#{@path.join('/')}") { [ 204, response_headers, '' ] }
+    @kv.relations[@relation_type].push(:items, @other_kv.key)
+    @stubs.verify_stubbed_calls
+  end
+
+  def test_removes_relation_with_kv
+    @stubs.delete("/v0/#{@path.join('/')}") do |env|
+      assert_equal 'true', env.params['purge']
+      [ 204, response_headers, '' ]
+    end
+    @kv.relations[@relation_type].delete(@other_kv)
+    @stubs.verify_stubbed_calls
+  end
+
+  def test_removes_relation_with_collname_and_keyname
+    @stubs.delete("/v0/#{@path.join('/')}") do |env|
+      assert_equal 'true', env.params['purge']
+      [ 204, response_headers, '' ]
+    end
+    @kv.relations[@relation_type].delete(:items, @other_kv.key)
+    @stubs.verify_stubbed_calls
+  end
+
+  def test_enumerates_over_relation
+    colls = [@items, @app[:things], @app[:stuff]]
+    @stubs.get("/v0/#{@kv.collection_name}/#{@kv.key}/relations/#{@relation_type}") do |env|
+      [200, response_headers, {results: make_results(colls, 100), count: 100}.to_json]
+    end
+    related_stuff = @kv.relations[@relation_type].to_a
+    assert_equal 100, related_stuff.size
+    related_stuff.each do |item|
+      assert_kind_of Orchestrate::KeyValue, item
+      match = item.key.match(/(\w+)-(\d+)/)
+      assert_equal item[:index], match[2].to_i
+      assert_equal item.collection.name, match[1]
+      assert_equal item.collection, colls[match[2].to_i % colls.length]
+    end
+  end
+
+  def test_enumerates_over_subrelation
+    colls = [@items, @app[:things], @app[:stuff]]
+    @stubs.get("/v0/items/#{@kv.key}/relations/siblings/children/siblings") do |env|
+      [200, response_headers, {results: make_results(colls, 100), count:100}.to_json]
+    end
+    related_stuff = @kv.relations[:siblings][:children][:siblings].to_a
+    assert_equal 100, related_stuff.size
+    related_stuff.each do |item|
+      assert_kind_of Orchestrate::KeyValue, item
+      match = item.key.match(/(\w+)-(\d+)/)
+      assert_equal item[:index], match[2].to_i
+      assert_equal item.collection.name, match[1]
+      assert_equal item.collection, colls[match[2].to_i % colls.length]
+    end
+  end
+
+  def test_prevents_parallel_enumeration
+    app, stubs = make_application({parallel: true})
+    one = make_kv_item(app[:items], stubs, {key: 'one'})
+    stubs.get("/v0/items/one/relations/siblings") do |env|
+      [200, response_headers, {results: make_results([app[:items]], 10), count:10}.to_json]
+    end
+    assert_raises Orchestrate::ResultsNotReady do
+      app.in_parallel { one.relations[:siblings].to_a }
+    end
+  end
+
+  def test_parallel_get_performs_call
+    called = false
+    siblings = nil
+    app, stubs = make_application({parallel: true})
+    one = make_kv_item(app[:items], stubs, {key: 'one'})
+    stubs.get("/v0/items/one/relations/siblings") do |env|
+      called = true
+      [200, response_headers, {results: make_results([app[:items]], 10), count:10}.to_json]
+    end
+    app.in_parallel do
+      siblings = one.relations[:siblings].each
+    end
+    assert called, "parallel block finished, API call not made yet for enumerable"
+    siblings = siblings.to_a
+    assert_equal 10, siblings.size
+  end
+
+  def test_lazy_does_not_perform_call
+    return unless [].respond_to?(:lazy)
+    called = false
+    app, stubs = make_application
+    one = make_kv_item(app[:items], stubs, {key:'one'})
+    stubs.get("/v0/items/one/relations/siblings") do |env|
+      called = true
+      [200, response_headers, {results: make_results([app[:items]], 10), count:10}.to_json]
+    end
+    siblings = one.relations[:siblings].lazy
+    refute called, "lazy enumerator not evauluated, but request called"
+    siblings = siblings.to_a
+    assert called, "lazy enumerator forced, but request not called"
+    assert_equal 10, siblings.size
+  end
+
+end
+

data/test/test_helper.rb

@@ -93,10 +93,14 @@ end
 def make_kv_listing(collection, opts={})
   key = opts[:key] || "item-#{rand(1_000_000)}"
   ref = opts[:ref] || make_ref
-  reftime = opts[:reftime] || Time.now.to_f - (rand(24) * 3600_000)
+  reftime = opts.fetch(:reftime, Time.now.to_f - (rand(24) * 3600_000))
+  score = opts[:score]
   body = opts[:body] || {"key" => key}
-  { "path" => { "collection" => collection, "key" => key, "ref" => ref },
-    "reftime" => reftime, "value" => body }
+  collection = collection.name if collection.kind_of?(Orchestrate::Collection)
+  result = { "path" => { "collection" => collection, "key" => key, "ref" => ref }, "value" => body  }
+  result["reftime"] = reftime if reftime
+  result["score"] = score if score
+  result
 end
 
 def capture_warnings

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: orchestrate
 version: !ruby/object:Gem::Version
-  version: 0.7.0
+  version: 0.8.0
 platform: ruby
 authors:
 - Matthew Lyon
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-07-01 00:00:00.000000000 Z
+date: 2014-07-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: faraday
@@ -134,6 +134,7 @@ files:
 - lib/orchestrate/application.rb
 - lib/orchestrate/client.rb
 - lib/orchestrate/collection.rb
+- lib/orchestrate/graph.rb
 - lib/orchestrate/key_value.rb
 - lib/orchestrate/version.rb
 - orchestrate.gemspec
@@ -147,9 +148,11 @@ files:
 - test/orchestrate/client_test.rb
 - test/orchestrate/collection_enumeration_test.rb
 - test/orchestrate/collection_kv_accessors_test.rb
+- test/orchestrate/collection_searching_test.rb
 - test/orchestrate/collection_test.rb
 - test/orchestrate/key_value_persistence_test.rb
 - test/orchestrate/key_value_test.rb
+- test/orchestrate/relations_test.rb
 - test/test_helper.rb
 homepage: https://github.com/orchestrate-io/orchestrate-ruby
 licenses:
@@ -186,8 +189,10 @@ test_files:
 - test/orchestrate/client_test.rb
 - test/orchestrate/collection_enumeration_test.rb
 - test/orchestrate/collection_kv_accessors_test.rb
+- test/orchestrate/collection_searching_test.rb
 - test/orchestrate/collection_test.rb
 - test/orchestrate/key_value_persistence_test.rb
 - test/orchestrate/key_value_test.rb
+- test/orchestrate/relations_test.rb
 - test/test_helper.rb
 has_rdoc: