couchbase 3.0.0.alpha.2 → 3.0.0

data/lib/couchbase/common_options.rb

@@ -26,4 +26,4 @@ module Couchbase
     # @return [Span] If set holds the parent span, that should be used for this request
     attr_accessor :parent_span
   end
-end
+end

data/{bin/console → lib/couchbase/datastructures.rb}

@@ -1,5 +1,3 @@
-#!/usr/bin/env ruby
-
 #    Copyright 2020 Couchbase, Inc.
 #
 #  Licensed under the Apache License, Version 2.0 (the "License");
@@ -14,8 +12,7 @@
 #  See the License for the specific language governing permissions and
 #  limitations under the License.
 
-require "bundler/setup"
-require "irb"
-require "couchbase"
-
-IRB.start(__FILE__)
+require "couchbase/datastructures/couchbase_list"
+require "couchbase/datastructures/couchbase_set"
+require "couchbase/datastructures/couchbase_queue"
+require "couchbase/datastructures/couchbase_map"

data/lib/couchbase/datastructures/couchbase_list.rb

@@ -0,0 +1,171 @@
+#    Copyright 2020 Couchbase, Inc.
+#
+#  Licensed under the Apache License, Version 2.0 (the "License");
+#  you may not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#  See the License for the specific language governing permissions and
+#  limitations under the License.
+
+require "couchbase/collection"
+require "couchbase/errors"
+
+module Couchbase
+  module Datastructures
+    # A {CouchbaseList} is implements +Enumerable+ interface and backed by {Collection} document (more specifically
+    # a JSON array).
+    #
+    # Note that as such, a {CouchbaseList} is restricted to the types that JSON array can contain.
+    class CouchbaseList
+      include Enumerable
+
+      # Create a new List, backed by the document identified by +id+ in +collection+.
+      #
+      # @param [String] id the id of the document to back the list.
+      # @param [Collection] collection the Couchbase collection through which to interact with the document.
+      # @param [CouchbaseListOptions] options customization of the datastructure
+      def initialize(id, collection, options = CouchbaseListOptions.new)
+        @id = id
+        @collection = collection
+        @options = options
+        @cas = 0
+      end
+
+      # Calls the given block once for each element in the list, passing that element as a parameter.
+      #
+      # @yieldparam [Object] item
+      #
+      # @return [CouchbaseList, Enumerable]
+      def each
+        if block_given?
+          begin
+            result = @collection.get(@id, @options.get_options)
+            current = result.content
+            @cas = result.cas
+          rescue Error::DocumentNotFound
+            current = []
+            @cas = 0
+          end
+          current.each do |entry|
+            yield entry
+          end
+          self
+        else
+          enum_for(:each)
+        end
+      end
+
+      # @return [Integer] returns the number of elements in the list.
+      def length
+        result = @collection.lookup_in(@id, [
+                                         LookupInSpec.count(""),
+                                       ], @options.lookup_in_options)
+        result.content(0)
+      rescue Error::DocumentNotFound
+        0
+      end
+
+      alias size length
+
+      # @return [Boolean] returns true if list is empty
+      def empty?
+        size.zero?
+      end
+
+      # Appends the given object(s) on to the end of this error. This expression returns the array itself, so several
+      # appends may be chained together.
+      #
+      # @param [Object...] obj object(s) to append
+      # @return [CouchbaseList]
+      def push(*obj)
+        @collection.mutate_in(@id, [
+                                MutateInSpec.array_append("", obj),
+                              ], @options.mutate_in_options)
+        self
+      end
+
+      alias append push
+
+      # Prepends objects to the front of the list, moving other elements upwards
+      #
+      # @param [Object...] obj object(s) to prepend
+      # @return [CouchbaseList]
+      def unshift(*obj)
+        @collection.mutate_in(@id, [
+                                MutateInSpec.array_prepend("", obj),
+                              ], @options.mutate_in_options)
+        self
+      end
+
+      alias prepend unshift
+
+      # Inserts the given values before the element with the given +index+.
+      #
+      # @param [Integer] index
+      # @param [Object...] obj object(s) to insert
+      # @return [CouchbaseList]
+      def insert(index, *obj)
+        @collection.mutate_in(@id, [
+                                MutateInSpec.array_insert("[#{index.to_i}]", obj),
+                              ])
+        self
+      end
+
+      # Returns the element at +index+. A negative index counts from the end. Returns +nil+ if the index is out of range.
+      #
+      # @param [Integer] index
+      # @return [Object, nil]
+      def at(index)
+        result = @collection.lookup_in(@id, [
+                                         LookupInSpec.get("[#{index.to_i}]"),
+                                       ], @options.lookup_in_options)
+        result.exists?(0) ? result.content(0) : nil
+      rescue Error::DocumentNotFound
+        nil
+      end
+
+      alias [] at
+
+      # Deletes the element at the specified +index+, returning that element, or nil
+      #
+      # @param [Integer] index
+      # @return [CouchbaseList]
+      def delete_at(index)
+        @collection.mutate_in(@id, [
+                                MutateInSpec.remove("[#{index.to_i}]"),
+                              ])
+        self
+      rescue Error::DocumentNotFound
+        self
+      end
+
+      # Removes all elements from the list
+      def clear
+        @collection.remove(@id, @options.remove_options)
+        nil
+      rescue Error::DocumentNotFound
+        nil
+      end
+    end
+
+    class CouchbaseListOptions
+      attr_accessor :get_options
+      attr_accessor :lookup_in_options
+      attr_accessor :mutate_in_options
+      attr_accessor :remove_options
+
+      def initialize
+        @get_options = Collection::GetOptions.new
+        @remove_options = Collection::RemoveOptions.new
+        @lookup_in_options = Collection::LookupInOptions.new
+        @mutate_in_options = Collection::MutateInOptions.new
+        @mutate_in_options.store_semantics = :upsert
+      end
+    end
+  end
+end

data/lib/couchbase/datastructures/couchbase_map.rb

@@ -0,0 +1,205 @@
+#    Copyright 2020 Couchbase, Inc.
+#
+#  Licensed under the Apache License, Version 2.0 (the "License");
+#  you may not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#  See the License for the specific language governing permissions and
+#  limitations under the License.
+
+require "couchbase/collection"
+require "couchbase/errors"
+
+module Couchbase
+  module Datastructures
+    # A {CouchbaseMap} is implements +Enumerable+ interface and backed by {Collection} document (more specifically
+    # a JSON array).
+    #
+    # Note that as such, a {CouchbaseMap} is restricted to the types that JSON array can contain.
+    class CouchbaseMap
+      include Enumerable
+
+      # Create a new Map, backed by the document identified by +id+ in +collection+.
+      #
+      # @param [String] id the id of the document to back the map.
+      # @param [Collection] collection the Couchbase collection through which to interact with the document.
+      # @param [CouchbaseMapOptions] options customization of the datastructure
+      def initialize(id, collection, options = CouchbaseMapOptions.new)
+        @id = id
+        @collection = collection
+        @options = options
+        @cas = 0
+      end
+
+      # Calls the given block once for each element in the map, passing that element as a parameter.
+      #
+      # @yieldparam [Object] item
+      #
+      # @return [CouchbaseMap, Enumerable]
+      def each
+        if block_given?
+          begin
+            result = @collection.get(@id, @options.get_options)
+            current = result.content
+            @cas = result.cas
+          rescue Error::DocumentNotFound
+            current = []
+            @cas = 0
+          end
+          current.each do |key, value|
+            yield key, value
+          end
+          self
+        else
+          enum_for(:each)
+        end
+      end
+
+      # @return [Integer] returns the number of elements in the map.
+      def length
+        result = @collection.lookup_in(@id, [
+                                         LookupInSpec.count(""),
+                                       ], @options.lookup_in_options)
+        result.content(0)
+      rescue Error::DocumentNotFound
+        0
+      end
+
+      alias size length
+
+      # @return [Boolean] returns true if map is empty
+      def empty?
+        size.zero?
+      end
+
+      # Removes all elements from the map
+      def clear
+        @collection.remove(@id, @options.remove_options)
+        nil
+      rescue Error::DocumentNotFound
+        nil
+      end
+
+      # Returns a value from the map for the given key.
+      #
+      # If the key cannot be found, there are several options:
+      #
+      # * with no other arguments, it will raise a KeyError exception
+      # * if +default+ is given, then that will be returned
+      # * if the optional code +block+ is specified, then that will be run and its result returned
+      #
+      # @overload fetch(key)
+      #   Gets the value, associated with the key, or raise KeyError if key could not be found
+      #   @param key [String] key
+      #
+      # @overload fetch(key, default)
+      #   Gets the value, associated with the key, or return +default+ if key could not be found
+      #   @param key [String] key
+      #
+      # @overload fetch(key, &block)
+      #   Gets the value, associated with the key, or invoke specified +block+ and propagate its return value
+      #   if key could not be found
+      #   @param key [String] key
+      #   @yieldreturn [Object] the default value to return in case the key could not be found
+      #
+      # @return [Object]
+      def fetch(key, *rest)
+        result = @collection.lookup_in(@id, [
+                                         LookupInSpec.get(key),
+                                       ], @options.lookup_in_options)
+        result.content(0)
+      rescue Error::DocumentNotFound, Error::PathNotFound
+        return yield if block_given?
+        return rest.first unless rest.empty?
+
+        raise KeyError, "key not found: #{key}"
+      end
+
+      # Returns a value from the map for the given key.
+      #
+      # If the key cannot be found, +nil+ will be returned.
+      #
+      # @param [String] key
+      #
+      # @return [Object, nil] value, associated with the key or +nil+
+      def [](key)
+        fetch(key, nil)
+      end
+
+      # Associate the value given by +value+ with the key given by +key+.
+      #
+      # @param [String] key
+      # @param [Object] value
+      #
+      # @return [void]
+      def []=(key, value)
+        @collection.mutate_in(@id, [
+                                MutateInSpec.upsert(key, value),
+                              ], @options.mutate_in_options)
+      end
+
+      # Deletes the key-value pair from the map.
+      #
+      # @param [String] key
+      #
+      # @return void
+      def delete(key)
+        @collection.mutate_in(@id, [
+                                MutateInSpec.remove(key),
+                              ])
+      rescue Error::DocumentNotFound, Error::PathNotFound
+        nil
+      end
+
+      # Returns +true+ if the given key is present
+      #
+      # @param [String] key
+      # @return [Boolean]
+      def key?(key)
+        result = @collection.lookup_in(@id, [
+                                         LookupInSpec.exists(key),
+                                       ], @options.lookup_in_options)
+        result.exists?(0)
+      rescue Error::DocumentNotFound, Error::PathNotFound
+        false
+      end
+
+      alias member? key?
+      alias include? key?
+
+      # Returns a new array populated with the keys from the map.
+      #
+      # @return [Array]
+      def keys
+        map { |key, _value| key }
+      end
+
+      # Returns a new array populated with the values from the map.
+      #
+      # @return [Array]
+      def values
+        map { |_key, value| value }
+      end
+    end
+
+    class CouchbaseMapOptions
+      attr_accessor :get_options
+      attr_accessor :lookup_in_options
+      attr_accessor :mutate_in_options
+      attr_accessor :remove_options
+
+      def initialize
+        @get_options = Collection::GetOptions.new
+        @remove_options = Collection::RemoveOptions.new
+        @lookup_in_options = Collection::LookupInOptions.new
+        @mutate_in_options = Collection::MutateInOptions.new
+        @mutate_in_options.store_semantics = :upsert
+      end
+    end
+  end
+end

data/lib/couchbase/datastructures/couchbase_queue.rb

@@ -0,0 +1,145 @@
+#    Copyright 2020 Couchbase, Inc.
+#
+#  Licensed under the Apache License, Version 2.0 (the "License");
+#  you may not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#  See the License for the specific language governing permissions and
+#  limitations under the License.
+
+require "couchbase/collection"
+require "couchbase/errors"
+
+module Couchbase
+  module Datastructures
+    # A {CouchbaseQueue} is implements FIFO queue with +Enumerable+ interface and backed by {Collection} document
+    # (more specifically a JSON array).
+    #
+    # Note: sets are restricted to containing primitive types only due to server-side comparison restrictions.
+    class CouchbaseQueue
+      include Enumerable
+
+      # Create a new List, backed by the document identified by +id+ in +collection+.
+      #
+      # @param [String] id the id of the document to back the queue.
+      # @param [Collection] collection the collection through which to interact with the document.
+      # @param [CouchbaseListOptions] options customization of the datastructure
+      def initialize(id, collection, options = CouchbaseQueueOptions.new)
+        @id = id
+        @collection = collection
+        @options = options
+        @cas = 0
+      end
+
+      # Calls the given block once for each element in the queue, passing that element as a parameter.
+      #
+      # @yieldparam [Object] item
+      #
+      # @return [CouchbaseQueue, Enumerable]
+      def each
+        if block_given?
+          begin
+            result = @collection.get(@id, @options.get_options)
+            current = result.content
+            @cas = result.cas
+          rescue Error::DocumentNotFound
+            current = []
+            @cas = 0
+          end
+          current.each do |entry|
+            yield entry
+          end
+          self
+        else
+          enum_for(:each)
+        end
+      end
+
+      # @return [Integer] returns the number of elements in the queue.
+      def length
+        result = @collection.lookup_in(@id, [
+                                         LookupInSpec.count(""),
+                                       ], @options.lookup_in_options)
+        result.content(0)
+      rescue Error::DocumentNotFound
+        0
+      end
+
+      alias size length
+
+      # @return [Boolean] returns true if queue is empty
+      def empty?
+        size.zero?
+      end
+
+      # Removes all elements from the queue
+      def clear
+        @collection.remove(@id, @options.remove_options)
+        nil
+      rescue Error::DocumentNotFound
+        nil
+      end
+
+      # Adds the given value to the queue
+      #
+      # @param [Object] obj
+      # @return [CouchbaseQueue]
+      def push(obj)
+        begin
+          @collection.mutate_in(@id, [
+                                  MutateInSpec.array_prepend("", [obj]),
+                                ], @options.mutate_in_options)
+        rescue Error::PathExists
+          # ignore
+        end
+        self
+      end
+
+      alias enq push
+      alias << push
+
+      # Retrieves object from the queue
+      #
+      # @return [Object, nil] queue entry or nil
+      def pop
+        result = @collection.lookup_in(@id, [
+                                         LookupInSpec.get("[-1]"),
+                                       ], @options.lookup_in_options)
+        obj = result.exists?(0) ? result.content(0) : nil
+        options = Collection::MutateInOptions.new
+        options.cas = result.cas
+        @collection.mutate_in(@id, [
+                                MutateInSpec.remove("[-1]"),
+                              ], options)
+        obj
+      rescue Error::CasMismatch
+        retry
+      rescue Error::DocumentNotFound, Error::PathNotFound
+        nil
+      end
+
+      alias deq pop
+      alias shift pop
+    end
+
+    class CouchbaseQueueOptions
+      attr_accessor :get_options
+      attr_accessor :lookup_in_options
+      attr_accessor :mutate_in_options
+      attr_accessor :remove_options
+
+      def initialize
+        @get_options = Collection::GetOptions.new
+        @remove_options = Collection::RemoveOptions.new
+        @lookup_in_options = Collection::LookupInOptions.new
+        @mutate_in_options = Collection::MutateInOptions.new
+        @mutate_in_options.store_semantics = :upsert
+      end
+    end
+  end
+end