couchbase 3.0.0.alpha.1-universal-darwin-19 → 3.0.0.beta.1-universal-darwin-19

data/lib/couchbase/datastructures/couchbase_set.rb

@@ -0,0 +1,138 @@
+#    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 {CouchbaseSet} is implements +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 CouchbaseSet
+      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 set.
+      # @param [Collection] collection the collection through which to interact with the document.
+      # @param [CouchbaseListOptions] options customization of the datastructure
+      def initialize(id, collection, options = CouchbaseSetOptions.new)
+        @id = id
+        @collection = collection
+        @options = options
+        @cas = 0
+      end
+
+      # Calls the given block once for each element in the set, passing that element as a parameter.
+      #
+      # @yieldparam [Object] item
+      #
+      # @return [CouchbaseSet, 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 set.
+      def length
+        result = @collection.lookup_in(@id, [
+            LookupInSpec.count("")
+        ], @options.lookup_in_options)
+        result.content(0)
+      rescue Error::DocumentNotFound
+        0
+      end
+
+      alias_method :size, :length
+
+      # @return [Boolean] returns true if set is empty
+      def empty?
+        size.zero?
+      end
+
+      # Adds the given value to the set
+      #
+      # @param [Object] obj
+      # @return [CouchbaseSet]
+      def add(obj)
+        begin
+          @collection.mutate_in(@id, [
+              MutateInSpec.array_add_unique("", obj)
+          ], @options.mutate_in_options)
+        rescue Error::PathExists
+          # ignore
+        end
+        self
+      end
+
+      # Removes all elements from the set
+      def clear
+        @collection.remove(@id, @options.remove_options)
+        nil
+      rescue Error::DocumentNotFound
+        nil
+      end
+
+      # Deletes the given object from the set.
+      #
+      # @return [Boolean] true if the value has been removed
+      def delete(obj)
+        result = @collection.get(@id)
+        idx = result.content.index(obj)
+        return false unless idx
+        options = Collection::MutateInOptions.new
+        options.cas = result.cas
+        @collection.mutate_in(@id, [
+            MutateInSpec.remove("[#{idx}]")
+        ], options)
+        true
+      rescue Error::CasMismatch
+        retry
+      rescue Error::DocumentNotFound
+        false
+      end
+    end
+
+    class CouchbaseSetOptions
+      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/errors.rb

@@ -13,210 +13,215 @@
 #  limitations under the License.
 
 module Couchbase
-  # Common exceptions
+  module Error
+    class CouchbaseError < StandardError
+    end
 
-  class RequestCanceled < StandardError
-  end
+    # Common exceptions
 
-  class InvalidArgument < StandardError
-  end
+    class RequestCanceled < CouchbaseError
+    end
 
-  class ServiceNotAvailable < StandardError
-  end
+    class InvalidArgument < ArgumentError
+    end
 
-  class InternalServerFailure < StandardError
-  end
+    class ServiceNotAvailable < CouchbaseError
+    end
 
-  class AuthenticationFailure < StandardError
-  end
+    class InternalServerFailure < CouchbaseError
+    end
 
-  class TemporaryFailure < StandardError
-  end
+    class AuthenticationFailure < CouchbaseError
+    end
 
-  class ParsingFailure < StandardError
-  end
+    class TemporaryFailure < CouchbaseError
+    end
 
-  class CasMismatch < StandardError
-  end
+    class ParsingFailure < CouchbaseError
+    end
 
-  class BucketNotFound < StandardError
-  end
+    class CasMismatch < CouchbaseError
+    end
 
-  class CollectionNotFound < StandardError
-  end
+    class BucketNotFound < CouchbaseError
+    end
 
-  class ScopeNotFound < StandardError
-  end
+    class CollectionNotFound < CouchbaseError
+    end
 
-  class IndexNotFound < StandardError
-  end
+    class ScopeNotFound < CouchbaseError
+    end
 
-  class IndexExists < StandardError
-  end
+    class IndexNotFound < CouchbaseError
+    end
 
-  class EncodingFailure < StandardError
-  end
+    class IndexExists < CouchbaseError
+    end
 
-  class DecodingFailure < StandardError
-  end
+    class EncodingFailure < CouchbaseError
+    end
 
-  class UnsupportedOperation < StandardError
-  end
+    class DecodingFailure < CouchbaseError
+    end
 
-  class AmbiguousTimeout < StandardError
-  end
+    class UnsupportedOperation < CouchbaseError
+    end
 
-  class UnambiguousTimeout < StandardError
-  end
+    class AmbiguousTimeout < CouchbaseError
+    end
 
-  class FeatureNotAvailable < StandardError
-  end
+    class UnambiguousTimeout < CouchbaseError
+    end
 
-  # KeyValue exceptions
+    class FeatureNotAvailable < CouchbaseError
+    end
 
-  class DocumentNotFound < StandardError
-  end
+    # KeyValue exceptions
 
-  class DocumentIrretrievable < StandardError
-  end
+    class DocumentNotFound < CouchbaseError
+    end
 
-  class DocumentLocked < StandardError
-  end
+    class DocumentIrretrievable < CouchbaseError
+    end
 
-  class ValueTooLarge < StandardError
-  end
+    class DocumentLocked < CouchbaseError
+    end
 
-  class DocumentExists < StandardError
-  end
+    class ValueTooLarge < CouchbaseError
+    end
 
-  class DurabilityLevelNotAvailable < StandardError
-  end
+    class DocumentExists < CouchbaseError
+    end
 
-  class DurabilityImpossible < StandardError
-  end
+    class DurabilityLevelNotAvailable < CouchbaseError
+    end
 
-  class DurabilityAmbiguous < StandardError
-  end
+    class DurabilityImpossible < CouchbaseError
+    end
 
-  class DurableWriteInProgress < StandardError
-  end
+    class DurabilityAmbiguous < CouchbaseError
+    end
 
-  class DurableWriteReCommitInProgress < StandardError
-  end
+    class DurableWriteInProgress < CouchbaseError
+    end
 
-  class PathNotFound < StandardError
-  end
+    class DurableWriteReCommitInProgress < CouchbaseError
+    end
 
-  class PathMismatch < StandardError
-  end
+    class PathNotFound < CouchbaseError
+    end
 
-  class PathInvalid < StandardError
-  end
+    class PathMismatch < CouchbaseError
+    end
 
-  class PathTooDeep < StandardError
-  end
+    class PathInvalid < CouchbaseError
+    end
 
-  class PathTooBig < StandardError
-  end
+    class PathTooDeep < CouchbaseError
+    end
 
-  class ValueTooDeep < StandardError
-  end
+    class PathTooBig < CouchbaseError
+    end
 
-  class ValueInvalid < StandardError
-  end
+    class ValueTooDeep < CouchbaseError
+    end
 
-  class DocumentNotJson < StandardError
-  end
+    class ValueInvalid < CouchbaseError
+    end
 
-  class NumberTooBig < StandardError
-  end
+    class DocumentNotJson < CouchbaseError
+    end
 
-  class DeltaInvalid < StandardError
-  end
+    class NumberTooBig < CouchbaseError
+    end
 
-  class PathExists < StandardError
-  end
+    class DeltaInvalid < CouchbaseError
+    end
 
-  class XattrUnknownMacro < StandardError
-  end
+    class PathExists < CouchbaseError
+    end
 
-  class XattrInvalidKeyCombo < StandardError
-  end
+    class XattrUnknownMacro < CouchbaseError
+    end
 
-  class XattrUnknownVirtualAttribute < StandardError
-  end
+    class XattrInvalidKeyCombo < CouchbaseError
+    end
 
-  class XattrCannotModifyVirtualAttribute < StandardError
-  end
+    class XattrUnknownVirtualAttribute < CouchbaseError
+    end
 
-  # Query exceptions
+    class XattrCannotModifyVirtualAttribute < CouchbaseError
+    end
 
-  class PlanningFailure < StandardError
-  end
+    # Query exceptions
 
-  class IndexFailure < StandardError
-  end
+    class PlanningFailure < CouchbaseError
+    end
 
-  class PreparedStatementFailure < StandardError
-  end
+    class IndexFailure < CouchbaseError
+    end
 
+    class PreparedStatementFailure < CouchbaseError
+    end
 
-  # Analytics exceptions
 
-  class CompilationFailure < StandardError
-  end
+    # Analytics exceptions
 
-  class JobQueueFull < StandardError
-  end
+    class CompilationFailure < CouchbaseError
+    end
 
-  class DatasetNotFound < StandardError
-  end
+    class JobQueueFull < CouchbaseError
+    end
 
-  class DatasetExists < StandardError
-  end
+    class DatasetNotFound < CouchbaseError
+    end
 
-  class DataverseExists < StandardError
-  end
+    class DatasetExists < CouchbaseError
+    end
 
-  class DataverseNotFound < StandardError
-  end
+    class DataverseExists < CouchbaseError
+    end
 
-  class LinkNotFound < StandardError
-  end
+    class DataverseNotFound < CouchbaseError
+    end
 
-  # View exceptions
+    class LinkNotFound < CouchbaseError
+    end
 
-  class DesignDocumentNotFound < StandardError
-  end
+    # View exceptions
 
-  class ViewNotFound < StandardError
-  end
+    class DesignDocumentNotFound < CouchbaseError
+    end
 
-  # Management exceptions
+    class ViewNotFound < CouchbaseError
+    end
 
-  class CollectionExists < StandardError
-  end
+    # Management exceptions
 
-  class ScopeExists < StandardError
-  end
+    class CollectionExists < CouchbaseError
+    end
 
-  class UserExists < StandardError
-  end
+    class ScopeExists < CouchbaseError
+    end
 
-  class BucketExists < StandardError
-  end
+    class UserExists < CouchbaseError
+    end
 
-  class BucketNotFlushable < StandardError
-  end
+    class BucketExists < CouchbaseError
+    end
 
-  class GroupNotFound < StandardError
-  end
+    class BucketNotFlushable < CouchbaseError
+    end
 
-  class UserNotFound < StandardError
-  end
+    class GroupNotFound < CouchbaseError
+    end
+
+    class UserNotFound < CouchbaseError
+    end
 
-  # Library-specific exceptions
+    # Library-specific exceptions
 
-  class BackendError < StandardError
+    class BackendError < CouchbaseError
+    end
   end
-end
+end