orchestrate 0.8.0 → 0.8.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: a9ab618bc8f0fd8e7d46d7621b4378a894ec9150
-  data.tar.gz: 4869b43cead19ce0c710d135f6551b20e0ef991a
+  metadata.gz: f337f0bb6cd0bea6f396f5f2cf1ac238325a5704
+  data.tar.gz: 5487fd1bf34564e6cc78eaad68a7d6a68d13184f
 SHA512:
-  metadata.gz: b22bac7d118ed9f23c25f6f3f0dd8e624d99d3f0eb7da3c85b25fedb59fa280494087945eee367d08cb730ef78d8f39a5beac2c3bcddd179d808e3e07f77bc05
-  data.tar.gz: f72465848c71bbcbde91f021ce3f6097d006d5da3bd4177a3867534b1e201d01ea3d042ed3b158049852fa38107694af611397519c774572afd30f947be2d486
+  metadata.gz: ba3609ecc24d1c0d1f5d919d6450769efe77e737eee5d785c888b6b31139c1d2d3b7baab54fe7ff188083c226bf8d243280a9786cf39a8b5b416a636aa258707
+  data.tar.gz: 32f3f69256d28a0733d9475adeb5adfb231c4f8e44a91e49cbbf1335b66397cfb8f106e6626df1e6d169d7ac8c02ee4db797250a36919de56b572af8cde45d47

data/README.md

@@ -159,6 +159,10 @@ end
 
 ## Release Notes
 
+### August 6, 2014: release 0.8.1
+  - Implement `KeyValue#refs`, `RefList` and `Ref` to access a KeyValue's Refs.
+  - Refactor `Client` api accessors on Object client to internal `#perform` methods.
+
 ### 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

data/lib/orchestrate/application.rb

@@ -51,10 +51,20 @@ module Orchestrate
       results
     end
 
+    # is the Application currently inside a block from `#in_parallel?`?
+    # @return [true, false]
     def inside_parallel?
       !! @inside_parallel
     end
 
+    # Perform a request against the client.
+    # @param api_method [Symbol] The method on the client to call
+    # @param args [#to_s, #to_json, Hash] The arguments for the method being called.
+    # @return Orchestrate::API::Response
+    def perform(api_method, *args)
+      client.send(api_method, *args)
+    end
+
     # @return a pretty-printed representation of the application.
     def to_s
       "#<Orchestrate::Application api_key=#{api_key[0..7]}...>"

data/lib/orchestrate/collection.rb

@@ -51,7 +51,7 @@ module Orchestrate
     # Deletes the collection.
     # @return Orchestrate::API::Response
     def destroy!
-      app.client.delete_collection(name)
+      perform :delete_collection
     end
 
     # @!endgroup
@@ -90,7 +90,7 @@ module Orchestrate
     # @raise Orchestrate::API::AlreadyPresent a false condition was provided, but a value already exists for this key
     # @see #[]=
     def set(key_name, value, condition=nil)
-      response = app.client.put(name, key_name, value, condition)
+      response = perform(:put, key_name, value, condition)
       KeyValue.from_bodyless_response(self, key_name, value, response)
     end
 
@@ -101,7 +101,7 @@ module Orchestrate
     # @note If the create is considered a success but the client is unable to parse the key
     #   from the location header, an API::ServiceError is raised.
     def <<(value)
-      response = app.client.post(name, value)
+      response = perform(:post, value)
       match_data = response.location.match(%r{#{name}/([^/]+)})
       raise API::ServiceError.new(response) unless match_data
       KeyValue.from_bodyless_response(self, match_data[1], value, response)
@@ -159,7 +159,7 @@ module Orchestrate
     # @param key_name [#to_s] The name of the key
     # @return [true] If the request suceeds.
     def delete(key_name)
-      app.client.delete(name, key_name)
+      perform(:delete, key_name)
       true
     end
 
@@ -168,7 +168,7 @@ module Orchestrate
     # @param key_name [#to_s] The name of the key
     # @return [true] If the request suceeds.
     def purge(key_name)
-      app.client.purge(name, key_name)
+      perform(:purge, key_name)
       true
     end
 
@@ -180,7 +180,10 @@ module Orchestrate
 
     # 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
+    # @overload each
+    #   @return [Enumerator]
+    # @overload each(&block)
+    #   @yieldparam [Orchestrate::KeyValue] key_value The KeyValue item
     # @see KeyValueList#each
     # @example
     #   keys = collection.take(20).map(&:key)
@@ -190,7 +193,8 @@ module Orchestrate
     end
 
     # Creates a Lazy Enumerator for the Collection's KeyValue List.  If called inside the app's
-    # `#in_parallel` block, pre-fetches results.
+    # `#in_parallel` block, pre-fetches the first page of results.
+    # @return [Enumerator::Lazy]
     def lazy
       KeyValueList.new(self).lazy
     end
@@ -226,7 +230,7 @@ module Orchestrate
     # 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]
+    # @return [Array<KeyValue>]
     def take(count)
       KeyValueList.new(self).take(count)
     end
@@ -292,7 +296,10 @@ module Orchestrate
 
       # 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
+      # @overload each
+      #   @return Enumerator
+      # @overload each(&block)
+      #   @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"
@@ -307,7 +314,7 @@ module Orchestrate
           params[end_key] = range[:end]
         end
         params[:limit] = range[:limit]
-        @response ||= collection.app.client.list(collection.name, params)
+        @response ||= collection.perform(:list, params)
         return enum_for(:each) unless block_given?
         raise ResultsNotReady.new if collection.app.inside_parallel?
         loop do
@@ -375,7 +382,10 @@ module Orchestrate
 
       # 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.
+      # @overload each
+      #   @return Enumerator
+      # @overload each(&block)
+      #   @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}"
@@ -383,7 +393,7 @@ module Orchestrate
       def each
         params = {limit:limit}
         params[:offset] = offset if offset
-        @response ||= collection.app.client.search(collection.name, query, params)
+        @response ||= collection.perform(:search, query, params)
         return enum_for(:each) unless block_given?
         raise ResultsNotReady.new if collection.app.inside_parallel?
         loop do
@@ -429,5 +439,14 @@ module Orchestrate
       end
     end
 
+    # Tells the Applicaiton to perform a request on its client, automatically
+    # providing the collection name.
+    # @param api_method [Symbol] The method on the client to call.
+    # @param args [#to_s, #to_json, Hash] The arguments for the method.
+    # @return API::Response
+    def perform(api_method, *args)
+      app.perform(api_method, name, *args)
+    end
+
   end
 end

data/lib/orchestrate/graph.rb

@@ -32,10 +32,13 @@ module Orchestrate
       # @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
 
+      def perform(api_method, *args)
+        kv_item.perform(api_method, type, *args)
+      end
+
       # [Creates a relationship between two objects](http://orchestrate.io/docs/api/#graph/put).
       # Relations can span collections.
       # @overload <<(key_value_item)
@@ -47,7 +50,7 @@ module Orchestrate
       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)
+        perform(:put_relation, other_collection, other_key)
       end
       alias :push :<<
 
@@ -61,7 +64,7 @@ module Orchestrate
       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)
+        perform(:delete_relation, other_collection, other_key)
       end
 
       # Adds depth to the retrieval of related items.
@@ -113,7 +116,6 @@ module Orchestrate
         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.
@@ -129,13 +131,14 @@ module Orchestrate
         # 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)
+          @response ||= kv_item.perform(:get_relations, *edges)
           return enum_for(:each) unless block
-          raise ResultsNotReady if @client.http.parallel_manager
+          raise ResultsNotReady if kv_item.collection.app.inside_parallel?
           @response.results.each do |listing|
             listing_collection = kv_item.collection.app[listing['path']['collection']]
             yield KeyValue.from_listing(listing_collection, listing, @response)
           end
+          @response = nil
         end
 
       end

data/lib/orchestrate/key_value.rb

@@ -41,7 +41,8 @@ module Orchestrate
       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.instance_variable_set(:@tombstone, path['tombstone'])
+      kv.value = listing.fetch('value', nil)
       kv
     end
 
@@ -134,7 +135,22 @@ module Orchestrate
     # Reload this KeyValue item from Orchestrate.
     # @raise Orchestrate::API::NotFound if the KeyValue no longer exists.
     def reload
-      load_from_response(@app.client.get(collection_name, key))
+      load_from_response(perform(:get))
+    end
+
+    # Is this the "Current" value for this KeyValue?  False for non-Ref objects.
+    # Use this instead of `#is_a?` or `#kind_of?`.
+    # @return [true, false]
+    def archival?
+      false
+    end
+
+    # Is this a Ref that represents a null value (created through `#destroy` or
+    # similar)?  False for most cases -- The only way to retrieve a Ref for which
+    # this will return true is by enumerating trhough values from a RefList.
+    # @return [true, false]
+    def tombstone?
+      !! @tombstone
     end
 
     # @!group Attribute accessors
@@ -178,7 +194,7 @@ module Orchestrate
     # @raise [Orchestrate::API::RequestError, Orchestrate::API::ServiceError] If there are any other problems with saving.
     def save!
       begin
-        load_from_response(@app.client.put(collection_name, key, value, ref))
+        load_from_response(perform(:put, value, ref))
         true
       rescue API::IndexingConflict => e
         @ref = e.response.headers['Location'].split('/').last
@@ -222,7 +238,7 @@ module Orchestrate
     # Deletes a KeyValue item from Orchestrate using 'If-Match' with the current ref.
     # @raise [Orchestrate::API::VersionMismatch] If the KeyValue item has been updated with a new ref since this KeyValue was loaded.
     def destroy!
-      response = @app.client.delete(collection_name, key, ref)
+      response = perform(:delete, ref)
       @ref = nil
       @last_request_time = response.request_time
       true
@@ -242,7 +258,7 @@ module Orchestrate
     # Deletes a KeyValue item and its entire Ref history from Orchestrate using 'If-Match' with the current ref.
     # @raise [Orchestrate::API::VersionMismatch] If the KeyValue item has been updated with a new ref since this KeyValue was loaded.
     def purge!
-      response = @app.client.purge(collection_name, key, ref)
+      response = perform(:purge, ref)
       @ref = nil
       @last_request_time = response.request_time
       true
@@ -250,6 +266,16 @@ module Orchestrate
 
     # @!endgroup persistence
     #
+    # @!group refs
+
+    # Entry point for retrieving Refs associated with this KeyValue.
+    # @return [Orchestrate::RefList] A RefList instance bound to this KeyValue.
+    def refs
+      @refs ||= RefList.new(self)
+    end
+
+    # @!endgroup refs
+    #
     # @!group relations
 
     # Entry point for managing the graph relationships for this KeyValue item
@@ -260,6 +286,15 @@ module Orchestrate
 
     # @!endgroup relations
 
+    # Calls a method on the Collection's Application's client, providing the
+    # Collection's name and KeyValue's key.
+    # @param api_method [Symbol] The method on the client to call.
+    # @param args [#to_s, #to_json, Hash] The arguments for the method.
+    # @return API::Response
+    def perform(api_method, *args)
+      collection.perform(api_method, key, *args)
+    end
+
     private
     def load_from_response(response)
       response.on_complete do

data/lib/orchestrate/refs.rb

@@ -0,0 +1,184 @@
+module Orchestrate
+  # A Ref is a specific immutable value that has been assigned to a Key.
+  #
+  # Ref is subclassed from KeyValue and as such contains its `#save` and `#update`
+  # methods.  Unless used on the most recent Ref, these will fail with a
+  # VersionMismatch error, as the #save and #update methods use Put-If-Match
+  # semantics.
+  class Ref < KeyValue
+
+    # Is this a historic ref value?  True for Ref objects.  Use this instead of
+    # `#is_a?` or `#kind_of?`.
+    # @return [true, false]
+    def archival?
+      true
+    end
+  end
+
+  # An enumerator over a query for listing Ref values in an Orchestrate::KeyValue.
+  class RefList
+
+    # @return [KeyValue]
+    attr_accessor :key_value
+
+    # Instantiates a new RefList
+    # @param key_value [KeyValue] The KeyValue item to retrieve Refs for.
+    def initialize(key_value)
+      @key_value = key_value
+    end
+
+    # Accessor for individual Refs.
+    # @param ref_id [#to_s] The ref of the specific immutable value to retrieve.
+    def [](ref_id)
+      response = @key_value.perform(:get, ref_id)
+      Ref.new(@key_value.collection, @key_value.key, response)
+    end
+
+    # @!group Ref Enumeration
+
+    include Enumerable
+
+    # Iterates over each Ref for the KeyValue.  Used as the basis for Enumerable.
+    # Refs are provided in time-series order, newest to oldest.
+    # @overload each
+    #   @return Enumerator
+    # @overload each(&block)
+    #   @yieldparam [Ref] ref the Ref item
+    # @see RefList::Fetcher#each
+    # @example
+    #   ref_ids = kv.refs.take(20).map(&:ref)
+    def each(&block)
+      Fetcher.new(self).each(&block)
+    end
+
+    # Creates a Lazy Enumerator for the RefList.  If called inside the Applciation's
+    # `#in_parallel` block, pre-fetches the first page of results.
+    # @return [Enumerator::Lazy]
+    def lazy
+      Fetcher.new(self).lazy
+    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 items
+    # than desired.
+    # @return [Array<Ref>]
+    def take(count)
+      Fetcher.new(self).take(count)
+    end
+
+    # Set the offset for the query to Orchestrate, so you can skip items.  Does
+    # not fetch results.  Implemented as a separate method from drop, unlike #take,
+    # because take is a more common use case.
+    # @return [RefList::Fetcher]
+    def offset(count)
+      Fetcher.new(self).offset(count)
+    end
+
+    # Specifies that the query to Orchestrate should use the `values` parameter,
+    # and that the query should return the values for each ref.
+    # @return [RefList::Fetcher]
+    def with_values
+      Fetcher.new(self).with_values
+    end
+
+    # @!endgroup
+
+    # Responsible for actually retrieving the list of Refs from Orchestrate.
+    class Fetcher
+
+      # The KeyValue to retrieve Refs for.
+      # @return [KeyValue]
+      attr_accessor :key_value
+
+      # The maximum number of Refs to return.
+      # @return [Integer]
+      attr_accessor :limit
+
+      # Whether to request values for each Ref or not.
+      # @return [nil, true] defaults to nil
+      attr_accessor :values
+
+      # Instantiates a new RefList::Fetcher.
+      # @param reflist [RefList] The RefList to base the queries on.
+      def initialize(reflist)
+        @key_value = reflist.key_value
+        @limit = 100
+      end
+
+      include Enumerable
+
+      # @!group Ref Enumeration
+
+      # Iterates over each Ref for the KeyValue.  Used as the basis for Enumerable.
+      # Refs are provided in time-series order, newest to oldest.
+      # @overload each
+      #   @return Enumerator
+      # @overload each(&block)
+      #   @yieldparam [Ref] ref the Ref item
+      # @example
+      #   ref_enum = kv.refs.each
+      def each
+        params = {limit: limit}
+        params[:offset] = offset if offset
+        params[:values] = true if values
+        @response ||= key_value.perform(:list_refs, params)
+        return enum_for(:each) unless block_given?
+        raise ResultsNotReady.new if key_value.collection.app.inside_parallel?
+        loop do
+          @response.results.each do |doc|
+            yield Ref.from_listing(key_value.collection, doc, @response)
+          end
+          break unless @response.next_link
+          @response = @response.next_results
+        end
+        @response = nil
+      end
+
+      # Creates a Lazy Enumerator for the Fetcher.  If called inside the Application's
+      # `#in_parallel` block, pre-fetches the first page of results.
+      # @return [Enumerator::Lazy]
+      def lazy
+        return each.lazy if key_value.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 items than
+      # desired.
+      # @param count [Integer] A positive integer constrained between 1 and 100.
+      # @return [Array<Ref>]
+      def take(count)
+        count = 1 if count < 1
+        count = 100 if count > 100
+        @limit = count
+        super(count)
+      end
+
+      # Sets the offset for the query to Orchestrate, so you can skip items.  Does
+      # not fetch results.  Implemented as a separate method from drop, unlike #take,
+      # because take is a more common use case.
+      # @overload offset
+      #   @return [Integer] the current offset value
+      # @overload offset(count)
+      #   @param count [Integer] The number of records to skip.  Constrained to positive integers.
+      #   @return [self]
+      def offset(count=nil)
+        if count
+          count = 1 if count < 1
+          @offset = count.to_i
+          return self
+        else
+          @offset
+        end
+      end
+
+      # Specifies the query to Orchestrate shoul duse the `values` parameter,
+      # and the query should return values for each ref.
+      # @return [self]
+      def with_values
+        @values = true
+        self
+      end
+    end
+  end
+end

data/lib/orchestrate/version.rb

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

data/lib/orchestrate.rb

@@ -3,6 +3,7 @@ require "orchestrate/client"
 require "orchestrate/application"
 require "orchestrate/collection"
 require "orchestrate/key_value"
+require "orchestrate/refs"
 require "orchestrate/graph"
 require "orchestrate/version"
 #

data/test/orchestrate/key_value_test.rb

@@ -13,6 +13,8 @@ class KeyValueTest < MiniTest::Unit::TestCase
     assert_equal "items/hello", kv.id
     assert_equal body, kv.value
     assert kv.loaded?
+    refute kv.archival?
+    refute kv.tombstone?
     assert_in_delta Time.now.to_f, kv.last_request_time.to_f, 1.1
   end
 

data/test/orchestrate/ref_test.rb

@@ -0,0 +1,129 @@
+require "test_helper"
+
+class RefTest < MiniTest::Unit::TestCase
+  def setup
+    @app, @stubs = make_application({parallel: true})
+    @kv = make_kv_item(@app[:items], @stubs)
+    @limit_to_assert = "100"
+    @called = false
+    @wants_values = false
+    @stubs.get("/v0/items/#{@kv.key}/refs") do |env|
+      @called = true
+      if @wants_values
+        assert_equal("true", env.params['values'])
+      else
+        assert_nil env.params['values']
+      end
+      assert_equal @limit_to_assert.to_s, env.params['limit']
+      assert_includes [nil, "100"], env.params['offset']
+      range = env.params['offset'] ? 101..150 : 1..100
+      list = range.map do |i|
+        make_kv_listing(@kv.collection,
+                        {value: @wants_values, key: @kv.key,
+                         ref: "#{i}", tombstone: i % 6 == 0,
+                         reftime: Time.now.to_f - i * 3600_00})
+      end
+      body = {results: list, count: range.respond_to?(:size) ? range.size : range.end - range.begin}
+      next_link = "/v0/items/#{@kv.key}/refs?offset=100&limit=100"
+      next_link += "&values=true" if @wants_values
+      body['next'] = next_link unless env.params['offset']
+      [200, response_headers, body.to_json]
+    end
+    @assert_ref_listing = lambda do |ref|
+      assert ref.archival?
+      assert_equal @kv.key, ref.key
+      if ref.ref.to_i % 6 == 0
+        assert ref.tombstone?, "Ref #{ref.ref} should be tombstone, isn't"
+        assert_nil ref.value
+      else
+        refute ref.tombstone?, "Ref #{ref.ref} should not be tombstone, is"
+        if @wants_values
+          assert_kind_of Hash, ref.value
+        else
+          assert_equal Hash.new, ref.value
+        end
+      end
+    end
+  end
+
+  def test_retrieves_single_ref
+    ref = make_ref
+    path = "/v0/items/#{@kv.key}/refs/#{ref}"
+    value = {"hello" => "history"}
+    @stubs.get(path) do |env|
+      [ 200, response_headers({'Etag' => "\"ref\"", "Content-Location" => path}), value.to_json]
+    end
+    ref_value = @kv.refs[ref]
+    assert ref_value.archival?
+    refute ref_value.tombstone?
+    assert_equal value, ref_value.value
+  end
+
+  def test_enumerates_over_refs
+    refs = @kv.refs.to_a
+    assert_equal 150, refs.size
+    refs.each(&@assert_ref_listing)
+  end
+
+  def test_enumerates_in_parallel_raises_not_ready_if_forced
+    @limit_to_assert = "5"
+    assert_raises Orchestrate::ResultsNotReady do
+      @app.in_parallel { @kv.refs.take(5) }
+    end
+  end
+
+  def test_enumerates_in_parallel_prefetches_lazy_enums
+    return unless [].respond_to?(:lazy)
+    refs = nil
+    @app.in_parallel { refs = @kv.refs.lazy.map {|r| r } }
+    assert @called, "lazy enumerator in parallel was not prefetched"
+    refs = refs.force
+    assert_equal 150, refs.length
+    refs.each(&@assert_ref_listing)
+  end
+
+  def test_enumerator_in_parallel_fetches_enums
+    refs = nil
+    @app.in_parallel { refs = @kv.refs.each }
+    assert @called, "enumerator wasn't prefetched inside of parallel"
+    assert_equal 150, refs.to_a.size
+    refs.each(&@assert_ref_listing)
+  end
+
+  def test_enumerator_doesnt_prefetch_lazy_enums
+    return unless [].respond_to?(:lazy)
+    refs = @kv.refs.lazy.map {|r| r }
+    refute @called, "lazy enumerator was prefetched outside of parallel"
+    refs = refs.force
+    assert_equal 150, refs.length
+    refs.each(&@assert_ref_listing)
+  end
+
+  def test_enumerator_prefetches_enums
+    refs = @kv.refs.each
+    assert @called, "enumerator was not prefetched"
+    assert_equal 150, refs.to_a.size
+    refs.each(&@assert_ref_listing)
+  end
+
+  def test_take_sets_limit
+    @limit_to_assert = 5
+    refs = @kv.refs.take(5).to_a
+    assert_equal 5, refs.length
+    refs.each(&@assert_ref_listing)
+  end
+
+  def test_offset_sets_offset
+    refs = @kv.refs.offset(100).to_a
+    assert_equal 50, refs.size
+    refs.each(&@assert_ref_listing)
+  end
+
+  def test_enumerates_with_values
+    @wants_values = true
+    refs = @kv.refs.with_values.to_a
+    assert_equal 150, refs.size
+    refs.each(&@assert_ref_listing)
+  end
+
+end

data/test/test_helper.rb

@@ -97,7 +97,12 @@ def make_kv_listing(collection, opts={})
   score = opts[:score]
   body = opts[:body] || {"key" => key}
   collection = collection.name if collection.kind_of?(Orchestrate::Collection)
-  result = { "path" => { "collection" => collection, "key" => key, "ref" => ref }, "value" => body  }
+  result = { "path" => { "collection" => collection, "key" => key, "ref" => ref }}
+  if opts[:tombstone]
+    result["path"]["tombstone"] = true
+  else
+    result["value"] = opts.fetch(:value, true) ? body : {}
+  end
   result["reftime"] = reftime if reftime
   result["score"] = score if score
   result

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: orchestrate
 version: !ruby/object:Gem::Version
-  version: 0.8.0
+  version: 0.8.1
 platform: ruby
 authors:
 - Matthew Lyon
@@ -10,104 +10,104 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-07-24 00:00:00.000000000 Z
+date: 2014-08-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: faraday
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ~>
       - !ruby/object:Gem::Version
         version: '0.9'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ~>
       - !ruby/object:Gem::Version
         version: '0.9'
 - !ruby/object:Gem::Dependency
   name: net-http-persistent
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ~>
       - !ruby/object:Gem::Version
         version: '2.9'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ~>
       - !ruby/object:Gem::Version
         version: '2.9'
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ~>
       - !ruby/object:Gem::Version
         version: '1.6'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ~>
       - !ruby/object:Gem::Version
         version: '1.6'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: typhoeus
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: em-http-request
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: em-synchrony
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
 description: Client for the Orchestrate REST API
@@ -119,9 +119,9 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- ".gitignore"
-- ".travis.yml"
-- ".yardopts"
+- .gitignore
+- .travis.yml
+- .yardopts
 - Gemfile
 - LICENSE
 - README.md
@@ -136,6 +136,7 @@ files:
 - lib/orchestrate/collection.rb
 - lib/orchestrate/graph.rb
 - lib/orchestrate/key_value.rb
+- lib/orchestrate/refs.rb
 - lib/orchestrate/version.rb
 - orchestrate.gemspec
 - test/orchestrate/api/collections_api_test.rb
@@ -152,6 +153,7 @@ files:
 - test/orchestrate/collection_test.rb
 - test/orchestrate/key_value_persistence_test.rb
 - test/orchestrate/key_value_test.rb
+- test/orchestrate/ref_test.rb
 - test/orchestrate/relations_test.rb
 - test/test_helper.rb
 homepage: https://github.com/orchestrate-io/orchestrate-ruby
@@ -164,17 +166,17 @@ require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - '>='
     - !ruby/object:Gem::Version
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - '>='
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.0.3
+rubygems_version: 2.0.14
 signing_key: 
 specification_version: 4
 summary: Ruby client for Orchestrate.io
@@ -193,6 +195,7 @@ test_files:
 - test/orchestrate/collection_test.rb
 - test/orchestrate/key_value_persistence_test.rb
 - test/orchestrate/key_value_test.rb
+- test/orchestrate/ref_test.rb
 - test/orchestrate/relations_test.rb
 - test/test_helper.rb
 has_rdoc: