fauna 2.0.0 → 2.1.0

data/lib/fauna/query.rb

@@ -43,8 +43,12 @@ module Fauna
     # Construct a ref value
     #
     # Reference: {FaunaDB Values}[https://faunadb.com/documentation/queries#values]
-    def ref(*args)
-      Ref.new(*args)
+    def ref(str, id = nil)
+      if id.nil?
+        Ref.new(str)
+      else
+        Expr.new ref: Expr.wrap(str), id: Expr.wrap(id)
+      end
     end
 
     ##
@@ -134,6 +138,7 @@ module Fauna
     #   If this takes more than one argument, the lambda destructures an array argument.
     #   (To destructure single-element arrays use #lambda_expr.)
     def lambda(&block)
+      dsl = Query::QueryDSLContext.new
       vars =
         block.parameters.map do |kind, name|
           fail ArgumentError, 'Splat parameters are not supported in lambda expressions.' if kind == :rest
@@ -145,9 +150,9 @@ module Fauna
         fail ArgumentError, 'Block must take at least 1 argument.'
       when 1
         # When there's only 1 parameter, don't use an array pattern.
-        lambda_expr vars[0], block.call(var(vars[0]))
+        lambda_expr vars[0], DSLContext.eval_dsl(dsl, var(vars[0]), &block)
       else
-        lambda_expr vars, block.call(*(vars.map { |v| var(v) }))
+        lambda_expr vars, DSLContext.eval_dsl(dsl, *(vars.map { |v| var(v) }), &block)
       end
     end
 
@@ -441,6 +446,14 @@ module Fauna
 
     # :section: Miscellaneous Functions
 
+    ##
+    # A next_id function
+    #
+    # Reference: {FaunaDB Miscellaneous Functions}[https://faunadb.com/documentation#queries-misc_functions]
+    def next_id
+      Expr.new next_id: nil
+    end
+
     ##
     # An equals function
     #
@@ -575,6 +588,13 @@ module Fauna
 
       alias_method :inspect, :to_s
 
+      def ==(other)
+        return false unless other.is_a? Expr
+        raw == other.raw
+      end
+
+      alias_method :eql?, :==
+
       def self.wrap(obj)
         if obj.is_a? Expr
           obj

data/lib/fauna/util.rb

@@ -16,7 +16,7 @@ module Fauna
   end
 
   class DSLContext # :nodoc:
-    def self.eval_dsl(dsl, &blk)
+    def self.eval_dsl(dsl, *args, &blk)
       ctx = eval('self', blk.binding)
       dsl.instance_variable_set(:@__ctx__, ctx)
 
@@ -24,7 +24,7 @@ module Fauna
         dsl.instance_variable_set(iv, ctx.instance_variable_get(iv))
       end
 
-      dsl.instance_exec(&blk)
+      dsl.instance_exec(*args, &blk)
 
     ensure
       dsl.instance_variables.each do |iv|

data/lib/fauna/version.rb

@@ -1,4 +1,4 @@
 module Fauna
   # The version of the Fauna gem
-  VERSION = '2.0.0'
+  VERSION = '2.1.0'.freeze
 end

data/spec/client_spec.rb

@@ -36,7 +36,7 @@ RSpec.describe Fauna::Client do
 
   describe 'serialization' do
     it 'decodes ref' do
-      ref = Fauna::Ref.new('classes', random_string, random_number)
+      ref = Fauna::Ref.new("classes/#{random_string}/#{random_number}")
       test_client = stub_client(:get, 'tests/ref', to_json(resource: ref))
 
       response = test_client.get('tests/ref')
@@ -45,7 +45,7 @@ RSpec.describe Fauna::Client do
     end
 
     it 'decodes set' do
-      set = Fauna::SetRef.new(match: random_string, index: Fauna::Ref.new('indexes', random_string))
+      set = Fauna::SetRef.new(match: Fauna::Ref.new("indexes/#{random_string}"), terms: random_string)
       test_client = stub_client(:get, 'tests/set', to_json(resource: set))
 
       response = test_client.get('tests/set')

data/spec/context_spec.rb

@@ -68,6 +68,14 @@ RSpec.describe Fauna::Context do
     end
   end
 
+  describe '#paginate' do
+    it 'performs paginate' do
+      Fauna::Context.block(client) do
+        expect(Fauna::Context.paginate(Fauna::Query.expr { ref('classes') }).data).to eq([@test_class])
+      end
+    end
+  end
+
   describe '#push' do
     it 'pushes new client' do
       new = Fauna::Client.new

data/spec/errors_spec.rb

@@ -140,5 +140,9 @@ RSpec.describe 'Fauna Errors' do
     it 'raised for bad errors format' do
       expect { stub_get(500, '{"errors": true}').get('') }.to raise_error(Fauna::UnexpectedError, /unexpected format/)
     end
+
+    it 'raised for empty errors' do
+      expect { stub_get(500, '{"errors": []}').get('') }.to raise_error(Fauna::UnexpectedError, /blank/)
+    end
   end
 end

data/spec/fauna_helper.rb

@@ -24,7 +24,7 @@ module FaunaTestHelpers
   end
 
   def create_test_db
-    @db_ref = Fauna::Ref.new 'databases', "faunadb-ruby-test-#{random_string}"
+    @db_ref = Fauna::Ref.new "databases/faunadb-ruby-test-#{random_string}"
 
     root = root_client
     root.query { create ref('databases'), name: @db_ref.id }
@@ -65,14 +65,10 @@ module FaunaTestHelpers
     SecureRandom.random_number(1_000_000)
   end
 
-  def random_ref
+  def random_ref_string
     "classes/#{random_string}/#{random_number}"
   end
 
-  def random_class_ref
-    "classes/#{random_string}"
-  end
-
   def to_json(value)
     Fauna::FaunaJson.to_json(value)
   end
@@ -81,7 +77,7 @@ module FaunaTestHelpers
     Fauna::FaunaJson.json_load(value)
   end
 
-  def wait_for_active(ref)
-    sleep 1 until client.query { get(ref) }[:active]
+  def wait_for_index(*refs)
+    sleep 1 until client.query { map(refs) { |ref| select([:active], get(ref)) } }.all? { |active| active }
   end
 end

data/spec/json_spec.rb

@@ -1,7 +1,7 @@
 RSpec.describe Fauna::FaunaJson do
   describe '#deserialize' do
     it 'deserializes ref' do
-      ref = random_ref
+      ref = random_ref_string
 
       data = { :@ref => ref }
       obj = Fauna::Ref.new(ref)
@@ -10,7 +10,7 @@ RSpec.describe Fauna::FaunaJson do
     end
 
     it 'deserializes set' do
-      ref = random_ref
+      ref = random_ref_string
       terms = random_string
 
       data = { :@set => { match: { :@ref => ref }, terms: terms } }
@@ -41,7 +41,7 @@ RSpec.describe Fauna::FaunaJson do
     end
 
     it 'recursively deserializes hashes' do
-      ref = random_ref
+      ref = random_ref_string
 
       data = { test: { :@obj => { :@ref => ref } } }
       obj = { test: Fauna::Ref.new(ref) }
@@ -50,8 +50,8 @@ RSpec.describe Fauna::FaunaJson do
     end
 
     it 'recursively deserializes arrays' do
-      ref1 = random_ref
-      ref2 = random_ref
+      ref1 = random_ref_string
+      ref2 = random_ref_string
 
       data = [{ :@ref => ref1 }, { :@ref => ref2 }]
       obj = [Fauna::Ref.new(ref1), Fauna::Ref.new(ref2)]
@@ -62,7 +62,7 @@ RSpec.describe Fauna::FaunaJson do
 
   describe '#to_json' do
     it 'serializes ref' do
-      ref = random_ref
+      ref = random_ref_string
 
       data = { :@ref => ref }
       obj = Fauna::Ref.new(ref)
@@ -71,7 +71,7 @@ RSpec.describe Fauna::FaunaJson do
     end
 
     it 'serializes set' do
-      ref = random_ref
+      ref = random_ref_string
 
       data = { :@ref => ref }
       obj = Fauna::Ref.new(ref)
@@ -101,7 +101,7 @@ RSpec.describe Fauna::FaunaJson do
     end
 
     it 'recursively serializes hashes' do
-      ref = random_ref
+      ref = random_ref_string
       terms = random_string
 
       data = { a: { time: { :@ts => '1970-01-01T00:00:00.000000000Z' } }, b: { :@set => { match: { :@ref => ref }, terms: terms } } }
@@ -111,8 +111,8 @@ RSpec.describe Fauna::FaunaJson do
     end
 
     it 'recursively serializes arrays' do
-      ref1 = random_ref
-      ref2 = random_ref
+      ref1 = random_ref_string
+      ref2 = random_ref_string
 
       data = [{ :@ref => ref1 }, { :@ref => ref2 }]
       obj = [Fauna::Ref.new(ref1), Fauna::Ref.new(ref2)]

data/spec/page_spec.rb

@@ -0,0 +1,357 @@
+RSpec.describe Fauna::Page do
+  before(:all) do
+    create_test_db
+    @test_class = client.query { create ref('classes'), name: 'page_test' }[:ref]
+    @foreach_class = client.query { create ref('classes'), name: 'page_foreach' }[:ref]
+
+    index_refs = client.query { create ref('indexes'), name: 'page_refs', source: @test_class }
+    index_values = client.query { create ref('indexes'), name: 'page_values', source: @test_class, values: [{ path: 'data.value' }] }
+    index_foreach = client.query { create ref('indexes'), name: 'page_apply', source: @foreach_class }
+
+    wait_for_index(index_refs[:ref], index_values[:ref], index_foreach[:ref])
+
+    @refs_index = index_refs[:ref]
+    @values_index = index_values[:ref]
+    @foreach_index = index_foreach[:ref]
+
+    @instances = client.query { (1..6).collect { |x| create(@test_class, data: { value: x }) } }.sort_by { |inst| inst[:ref].id }
+    @instance_refs = @instances.collect { |instance| instance[:ref] }
+    @instance_values = @instances.collect { |instance| instance[:data][:value] }.sort
+
+    @refs_match = Fauna::Query.match(@refs_index)
+    @values_match = Fauna::Query.match(@values_index)
+    @foreach_match = Fauna::Query.match(@foreach_index)
+  end
+
+  after(:all) do
+    destroy_test_db
+  end
+
+  describe '#==' do
+    it 'equals identical page' do
+      page1 = Fauna::Page.new(client, @refs_match, size: 1)
+      page2 = Fauna::Page.new(client, @refs_match, size: 1)
+
+      expect(page1).to eq(page2)
+    end
+
+    it 'does not equal different page' do
+      page1 = Fauna::Page.new(client, @refs_match, size: 1234)
+      page2 = Fauna::Page.new(client, @refs_match, size: 4321)
+
+      expect(page1).not_to eq(page2)
+    end
+  end
+
+  it 'can\'t mutate params directly' do
+    page = client.paginate(@refs_match)
+
+    expect { page.params[:ts] = random_number }.to raise_error(RuntimeError, 'can\'t modify frozen Hash')
+
+    page = page.with_params(ts: random_number)
+
+    expect { page.params[:ts] = random_number }.to raise_error(RuntimeError, 'can\'t modify frozen Hash')
+  end
+
+  describe 'builders' do
+    def get_funcs(page)
+      page.instance_variable_get(:@fauna_funcs)
+    end
+
+    def get_postprocessing(page)
+      page.instance_variable_get(:@postprocessing_map)
+    end
+
+    describe '#with_params' do
+      let(:ref1) { random_ref_string }
+      let(:ref2) { random_ref_string }
+
+      it 'sets params on copy' do
+        ts1 = random_number
+        ts2 = random_number
+
+        page = client.paginate(@refs_match, ts: ts1)
+
+        expect(page.with_params(ts: ts2, sources: false).params).to eq(ts: ts2, sources: false)
+        expect(page.params).to eq(ts: ts1)
+      end
+
+      it 'reverses cursor' do
+        page = client.paginate(@refs_match, before: ref1)
+
+        expect(page.with_params(after: ref2).params).to eq(after: ref2)
+        expect(page.params).to eq(before: ref1)
+      end
+
+      it 'preserves nil' do
+        page = client.paginate(@refs_match, after: nil)
+
+        expect(page.with_params(before: nil).params).to eq(before: nil)
+        expect(page.params).to eq(after: nil)
+      end
+
+      it 'resets paging' do
+        page = client.paginate(@refs_match, size: 1)
+        page1 = page.page_after
+
+        page2 = page1.with_params(after: 0).page_after
+
+        expect(page2.data).to eq(page2.data)
+      end
+    end
+
+    describe '#map' do
+      it 'sets map on copy' do
+        page = client.paginate(@refs_match)
+
+        expect(get_funcs(page.map { |ref| get ref }).length).to be(1)
+        expect(get_funcs(page).length).to be(0)
+      end
+
+      it 'performs map when paging' do
+        page = client.paginate(@refs_match).map { |ref| get ref }
+
+        expect(page.all).to eq(@instances)
+      end
+    end
+
+    describe '#filter' do
+      it 'sets filter on copy' do
+        page = client.paginate(@values_match)
+
+        expect(get_funcs(page.filter { |value| equals(modulo(value, 2), 0) }).length).to be(1)
+        expect(get_funcs(page).length).to be(0)
+      end
+
+      it 'performs filter when paging' do
+        page = client.paginate(@values_match).filter { |value| equals(modulo(value, 2), 0) }
+
+        expect(page.all).to eq(@instance_values.find_all(&:even?))
+      end
+    end
+
+    describe '#postprocessing_map' do
+      it 'sets ruby map on copy' do
+        page = client.paginate(@refs_match)
+
+        expect(get_postprocessing(page.postprocessing_map(&:id))).to be_a(Proc)
+        expect(get_postprocessing(page)).to be_nil
+      end
+    end
+  end
+
+  describe '#load!' do
+    it 'explicitly loads page' do
+      page = client.paginate(@refs_match, size: 1, after: @instance_refs[1])
+      expected = [@instance_refs[1]]
+
+      expect(page.instance_variable_get(:@data)).to be_nil
+      page.load!
+      expect(page.instance_variable_get(:@data)).to eq(expected)
+    end
+
+    it 'returns true when page was loaded' do
+      page = client.paginate(@refs_match, size: 1, after: @instance_refs[1])
+
+      expect(page.instance_variable_get(:@populated)).to be(false)
+      expect(page.load!).to be(true)
+      expect(page.instance_variable_get(:@populated)).to be(true)
+    end
+
+    it 'returns false when page not loaded' do
+      page = client.paginate(@refs_match, size: 1, after: @instance_refs[1])
+
+      page.load!
+      expect(page.instance_variable_get(:@populated)).to be(true)
+      expect(page.load!).to be(false)
+    end
+  end
+
+  describe '#data' do
+    it 'lazily loads page' do
+      page = client.paginate(@refs_match, size: 1, after: @instance_refs[1])
+      expected = [@instance_refs[1]]
+
+      expect(page.instance_variable_get(:@data)).to be_nil
+      expect(page.data).to eq(expected)
+      expect(page.instance_variable_get(:@data)).to eq(expected)
+    end
+  end
+
+  describe '#before' do
+    it 'lazily loads page' do
+      page = client.paginate(@refs_match, size: 1, after: @instance_refs[1])
+      expected = [@instance_refs[1]]
+
+      expect(page.instance_variable_get(:@before)).to be_nil
+      expect(page.before).to eq(expected)
+      expect(page.instance_variable_get(:@before)).to eq(expected)
+    end
+  end
+
+  describe '#after' do
+    it 'lazily loads page' do
+      page = client.paginate(@refs_match, size: 1, after: @instance_refs[1])
+      expected = [@instance_refs[2]]
+
+      expect(page.instance_variable_get(:@after)).to be_nil
+      expect(page.after).to eq(expected)
+      expect(page.instance_variable_get(:@after)).to eq(expected)
+    end
+  end
+
+  describe '#page_after' do
+    it 'returns the page after' do
+      page = client.paginate(@refs_match, size: 1, after: 0)
+
+      @instance_refs.drop(1).each do |ref|
+        page = page.page_after
+        expect(page.data.first).to eq(ref)
+      end
+    end
+
+    it 'returns nil on last page' do
+      page = client.paginate(@refs_match, size: 1, after: @instance_refs.last)
+
+      expect(page.data.first).to eq(@instance_refs.last)
+      expect(page.page_after).to be_nil
+    end
+
+    it 'is not affected by lazy loading' do
+      page = client.paginate(@refs_match, size: 1, after: 0)
+
+      expect(page.data.first).to eq(@instance_refs[0])
+      expect(page.page_after.data.first).to eq(@instance_refs[1])
+
+      page = client.paginate(@refs_match, size: 1, after: 0)
+
+      expect(page.page_after.data.first).to eq(@instance_refs[1])
+    end
+  end
+
+  describe '#page_before' do
+    it 'returns the page before' do
+      page = client.paginate(@refs_match, size: 1, before: nil)
+
+      @instance_refs.reverse.drop(1).each do |ref|
+        page = page.page_before
+        expect(page.data.first).to eq(ref)
+      end
+    end
+
+    it 'returns nil on last page' do
+      page = client.paginate(@refs_match, size: 1, before: @instance_refs.first)
+
+      expect(page.page_before).to be_nil
+    end
+
+    it 'is not affected by lazy loading' do
+      page = client.paginate(@refs_match, size: 1, before: nil)
+
+      expect(page.data.first).to eq(@instance_refs[-1])
+      expect(page.page_before.data.first).to eq(@instance_refs[-2])
+
+      page = client.paginate(@refs_match, size: 1, before: nil)
+
+      expect(page.page_before.data.first).to eq(@instance_refs[-2])
+    end
+  end
+
+  it 'pages both directions' do
+    page = client.paginate(@refs_match, size: 1, after: 0)
+    expect(page.data.first).to eq(@instance_refs[0])
+
+    page = page.page_after
+    expect(page.data.first).to eq(@instance_refs[1])
+
+    page = page.page_before
+    expect(page.data.first).to eq(@instance_refs[0])
+  end
+
+  describe '#each' do
+    it 'iterates the set in the after direction' do
+      page = client.paginate(@refs_match, size: 1)
+      refs = @instance_refs.collect { |ref| [ref] }
+
+      expect(page.each.collect { |ref| ref }).to eq(refs)
+    end
+
+    it 'is not affected by lazy loading' do
+      page = client.paginate(@refs_match, size: 1)
+      refs = @instance_refs.collect { |ref| [ref] }
+
+      expect(page.each.collect { |ref| ref }).to eq(refs)
+
+      page = client.paginate(@refs_match, size: 1)
+      refs = @instance_refs.collect { |ref| [ref] }
+
+      expect(page.data).to eq([@instance_refs.first])
+      expect(page.each.collect { |ref| ref }).to eq(refs)
+    end
+
+    context 'with fauna map' do
+      it 'iterates the set using the fauna map' do
+        page = client.paginate(@refs_match, size: 1) { |ref| get(ref) }
+        instances = @instances.collect { |inst| [inst] }
+
+        expect(page.each.collect { |inst| inst }).to eq(instances)
+      end
+
+      it 'chains multiple collection functions' do
+        page = client.paginate(@refs_match, size: 1)
+        # Map ref to value
+        page = page.map { |ref| select(['data', 'value'], get(ref)) }
+        # Filter out odd numbers
+        page = page.filter { |value| equals(modulo(value, 2), 0) }
+        # Map to double the value
+        page = page.map { |value| multiply(value, 2) }
+
+        # We are using the index on refs, not value, so we need to expect the values to be sorted by instance ref
+        expected = @instances.collect { |inst| inst[:data][:value] }.find_all(&:even?).collect { |v| v * 2 }
+
+        expect(page.all).to eq(expected)
+      end
+    end
+
+    context 'with ruby map' do
+      it 'iterates the set using the ruby map' do
+        page = client.paginate(@refs_match, size: 1).postprocessing_map(&:id)
+        ids = @instance_refs.collect { |ref| [ref.id] }
+
+        expect(page.each.collect { |id| id }).to eq(ids)
+      end
+    end
+  end
+
+  describe '#reverse_each' do
+    it 'iterates the set in the before direction' do
+      page = client.paginate(@refs_match, size: 1, before: nil)
+      refs = @instance_refs.reverse.collect { |ref| [ref] }
+
+      expect(page.reverse_each.collect { |ref| ref }).to eq(refs)
+    end
+  end
+
+  describe '#all' do
+    it 'returns full contents of the set' do
+      page = client.paginate(@refs_match, size: 1)
+
+      expect(page.all).to eq(@instance_refs)
+    end
+  end
+
+  describe '#foreach!' do
+    before(:each) do
+      @apply_refs = client.query { (1..3).collect { |x| select([:ref], create(@foreach_class, data: { value: x })) } }
+    end
+
+    it 'applies foreach to set' do
+      # Sanity
+      expect(client.query { map(@apply_refs) { |ref| exists ref } }).to eq(@apply_refs.collect { true })
+
+      client.paginate(@foreach_match, size: 1).foreach! { |ref| delete ref }
+
+      expect(client.query { map(@apply_refs) { |ref| exists ref } }).to eq(@apply_refs.collect { false })
+    end
+  end
+end