couchbase 3.1.1 → 3.2.0

data/lib/couchbase/management/bucket_manager.rb

@@ -12,12 +12,178 @@
 #  See the License for the specific language governing permissions and
 #  limitations under the License.
 
-require "couchbase/errors"
-
 require "rubygems/deprecate"
 
+require "couchbase/errors"
+require "couchbase/options"
+
 module Couchbase
   module Management
+    module Options
+      module Bucket
+        # Options for {BucketManager#create_bucket}
+        class CreateBucket < ::Couchbase::Options::Base
+          # Creates an instance of options for {BucketManager#create_bucket}
+          #
+          # @param [Integer, #in_milliseconds, nil] timeout the time in milliseconds allowed for the operation to complete
+          # @param [Proc, nil] retry_strategy the custom retry strategy, if set
+          # @param [Hash, nil] client_context the client context data, if set
+          # @param [Span, nil] parent_span if set holds the parent span, that should be used for this request
+          #
+          # @yieldparam [CreateBucket] self
+          def initialize(timeout: nil,
+                         retry_strategy: nil,
+                         client_context: nil,
+                         parent_span: nil)
+            super
+            yield self if block_given?
+          end
+        end
+
+        # Options for {BucketManager#update_bucket}
+        class UpdateBucket < ::Couchbase::Options::Base
+          # Creates an instance of options for {BucketManager#update_bucket}
+          #
+          # @param [Integer, #in_milliseconds, nil] timeout the time in milliseconds allowed for the operation to complete
+          # @param [Proc, nil] retry_strategy the custom retry strategy, if set
+          # @param [Hash, nil] client_context the client context data, if set
+          # @param [Span, nil] parent_span if set holds the parent span, that should be used for this request
+          #
+          # @yieldparam [UpdateBucket] self
+          def initialize(timeout: nil,
+                         retry_strategy: nil,
+                         client_context: nil,
+                         parent_span: nil)
+            super
+            yield self if block_given?
+          end
+        end
+
+        # Options for {BucketManager#drop_bucket}
+        class DropBucket < ::Couchbase::Options::Base
+          # Creates an instance of options for {BucketManager#drop_bucket}
+          #
+          # @param [Integer, #in_milliseconds, nil] timeout the time in milliseconds allowed for the operation to complete
+          # @param [Proc, nil] retry_strategy the custom retry strategy, if set
+          # @param [Hash, nil] client_context the client context data, if set
+          # @param [Span, nil] parent_span if set holds the parent span, that should be used for this request
+          #
+          # @yieldparam [DropBucket] self
+          def initialize(timeout: nil,
+                         retry_strategy: nil,
+                         client_context: nil,
+                         parent_span: nil)
+            super
+            yield self if block_given?
+          end
+        end
+
+        # Options for {BucketManager#get_bucket}
+        class GetBucket < ::Couchbase::Options::Base
+          # Creates an instance of options for {BucketManager#get_bucket}
+          #
+          # @param [Integer, #in_milliseconds, nil] timeout the time in milliseconds allowed for the operation to complete
+          # @param [Proc, nil] retry_strategy the custom retry strategy, if set
+          # @param [Hash, nil] client_context the client context data, if set
+          # @param [Span, nil] parent_span if set holds the parent span, that should be used for this request
+          #
+          # @yieldparam [GetBucket] self
+          def initialize(timeout: nil,
+                         retry_strategy: nil,
+                         client_context: nil,
+                         parent_span: nil)
+            super
+            yield self if block_given?
+          end
+        end
+
+        # Options for {BucketManager#get_all_buckets}
+        class GetAllBuckets < ::Couchbase::Options::Base
+          # Creates an instance of options for {BucketManager#get_all_buckets}
+          #
+          # @param [Integer, #in_milliseconds, nil] timeout the time in milliseconds allowed for the operation to complete
+          # @param [Proc, nil] retry_strategy the custom retry strategy, if set
+          # @param [Hash, nil] client_context the client context data, if set
+          # @param [Span, nil] parent_span if set holds the parent span, that should be used for this request
+          #
+          # @yieldparam [GetAllBuckets] self
+          def initialize(timeout: nil,
+                         retry_strategy: nil,
+                         client_context: nil,
+                         parent_span: nil)
+            super
+            yield self if block_given?
+          end
+        end
+
+        # Options for {BucketManager#flush_bucket}
+        class FlushBucket < ::Couchbase::Options::Base
+          # Creates an instance of options for {BucketManager#flush_bucket}
+          #
+          # @param [Integer, #in_milliseconds, nil] timeout the time in milliseconds allowed for the operation to complete
+          # @param [Proc, nil] retry_strategy the custom retry strategy, if set
+          # @param [Hash, nil] client_context the client context data, if set
+          # @param [Span, nil] parent_span if set holds the parent span, that should be used for this request
+          #
+          # @yieldparam [FlushBucket] self
+          def initialize(timeout: nil,
+                         retry_strategy: nil,
+                         client_context: nil,
+                         parent_span: nil)
+            super
+            yield self if block_given?
+          end
+        end
+
+        # rubocop:disable Naming/MethodName constructor shortcuts
+        module_function
+
+        # Construct {CreateBucket} options for {BucketManager#create_bucket}
+        #
+        # @return [CreateBucket]
+        def CreateBucket(**args)
+          CreateBucket.new(**args)
+        end
+
+        # Construct {UpdateBucket} options for {BucketManager#update_bucket}
+        #
+        # @return [UpdateBucket]
+        def UpdateBucket(**args)
+          UpdateBucket.new(**args)
+        end
+
+        # Construct {DropBucket} options for {BucketManager#drop_bucket}
+        #
+        # @return [DropBucket]
+        def DropBucket(**args)
+          DropBucket.new(**args)
+        end
+
+        # Construct {GetBucket} options for {BucketManager#get_bucket}
+        #
+        # @return [GetBucket]
+        def GetBucket(**args)
+          GetBucket.new(**args)
+        end
+
+        # Construct {GetAllBuckets} options for {BucketManager#get_all_buckets}
+        #
+        # @return [GetAllBuckets]
+        def GetAllBuckets(**args)
+          GetAllBuckets.new(**args)
+        end
+
+        # Construct {FlushBucket} options for {BucketManager#flush_bucket}
+        #
+        # @return [FlushBucket]
+        def FlushBucket(**args)
+          FlushBucket.new(**args)
+        end
+
+        # rubocop:enable Naming/MethodName
+      end
+    end
+
     class BucketManager
       alias inspect to_s
 
@@ -29,13 +195,13 @@ module Couchbase
       # Creates new bucket
       #
       # @param [BucketSettings] settings bucket settings
-      # @param [CreateBucketOptions] options
+      # @param [Options::Bucket::CreateBucket] options
       #
       # @return void
       #
       # @raise [ArgumentError]
       # @raise [Error::BucketExists]
-      def create_bucket(settings, options = CreateBucketOptions.new)
+      def create_bucket(settings, options = Options::Bucket::CreateBucket.new)
         @backend.bucket_create(
           {
 
@@ -50,20 +216,20 @@ module Couchbase
             compression_mode: settings.compression_mode,
             minimum_durability_level: settings.minimum_durability_level,
             conflict_resolution_type: settings.conflict_resolution_type,
-          }, options.timeout
+          }, options.to_backend
         )
       end
 
       # Updates the bucket settings
       #
       # @param [BucketSettings] settings bucket settings
-      # @param [UpdateBucketOptions] options
+      # @param [Options::Bucket::UpdateBucket] options
       #
       # @return void
       #
       # @raise [ArgumentError]
       # @raise [Error::BucketNotFound]
-      def update_bucket(settings, options = UpdateBucketOptions.new)
+      def update_bucket(settings, options = Options::Bucket::UpdateBucket.new)
         @backend.bucket_update(
           {
             name: settings.name,
@@ -76,110 +242,80 @@ module Couchbase
             max_expiry: settings.max_expiry,
             compression_mode: settings.compression_mode,
             minimum_durability_level: settings.minimum_durability_level,
-          }, options.timeout
+          }, options.to_backend
         )
       end
 
       # Removes a bucket
       #
       # @param [String] bucket_name name of the bucket
-      # @param [DropBucketOptions] options
+      # @param [Options::Bucket::DropBucket] options
       #
       # @return void
       #
       # @raise [ArgumentError]
       # @raise [Error::BucketNotFound]
-      def drop_bucket(bucket_name, options = DropBucketOptions.new)
-        @backend.bucket_drop(bucket_name, options.timeout)
+      def drop_bucket(bucket_name, options = Options::Bucket::DropBucket.new)
+        @backend.bucket_drop(bucket_name, options.to_backend)
       end
 
       # Fetch settings of the bucket
       #
       # @param [String] bucket_name name of the bucket
-      # @param [GetBucketOptions] options
+      # @param [Options::Bucket::GetBucket] options
       #
       # @return [BucketSettings]
       #
       # @raise [ArgumentError]
       # @raise [Error::BucketNotFound]
-      def get_bucket(bucket_name, options = GetBucketOptions.new)
-        res = @backend.bucket_get(bucket_name, options.timeout)
-        extract_bucket_settings(res)
+      def get_bucket(bucket_name, options = Options::Bucket::GetBucket.new)
+        extract_bucket_settings(@backend.bucket_get(bucket_name, options.to_backend))
       end
 
       # Get settings for all buckets
       #
-      # @param [GetAllBucketsOptions] options
+      # @param [Options::Bucket::GetAllBuckets] options
       # @return [Array<BucketSettings>]
-      def get_all_buckets(options = GetAllBucketsOptions.new)
-        res = @backend.bucket_get_all(options.timeout)
-        res.map { |entry| extract_bucket_settings(entry) }
+      def get_all_buckets(options = Options::Bucket::GetAllBuckets.new)
+        @backend.bucket_get_all(options.to_backend)
+                .map { |entry| extract_bucket_settings(entry) }
       end
 
       # @param [String] bucket_name name of the bucket
+      # @param [Options::Bucket::FlushBucket] options
       #
       # @return void
       #
       # @raise [ArgumentError]
       # @raise [Error::BucketNotFound]
       # @raise [Error::BucketNotFlushable]
-      def flush_bucket(bucket_name, options = FlushBucketOptions.new)
-        @backend.bucket_flush(bucket_name, options.timeout)
-      end
-
-      class CreateBucketOptions
-        # @return [Integer] the time in milliseconds allowed for the operation to complete
-        attr_accessor :timeout
-
-        def initialize
-          yield self if block_given?
-        end
-      end
-
-      class UpdateBucketOptions
-        # @return [Integer] the time in milliseconds allowed for the operation to complete
-        attr_accessor :timeout
-
-        def initialize
-          yield self if block_given?
-        end
-      end
-
-      class DropBucketOptions
-        # @return [Integer] the time in milliseconds allowed for the operation to complete
-        attr_accessor :timeout
-
-        def initialize
-          yield self if block_given?
-        end
+      def flush_bucket(bucket_name, options = Options::Bucket::FlushBucket.new)
+        @backend.bucket_flush(bucket_name, options.to_backend)
       end
 
-      class GetBucketOptions
-        # @return [Integer] the time in milliseconds allowed for the operation to complete
-        attr_accessor :timeout
+      # @api private
+      # TODO: deprecate after 3.2
+      CreateBucketOptions = ::Couchbase::Management::Options::Bucket::CreateBucket
 
-        def initialize
-          yield self if block_given?
-        end
-      end
+      # @api private
+      # TODO: deprecate after 3.2
+      UpdateBucketOptions = ::Couchbase::Management::Options::Bucket::UpdateBucket
 
-      class GetAllBucketsOptions
-        # @return [Integer] the time in milliseconds allowed for the operation to complete
-        attr_accessor :timeout
+      # @api private
+      # TODO: deprecate after 3.2
+      DropBucketOptions = ::Couchbase::Management::Options::Bucket::DropBucket
 
-        def initialize
-          yield self if block_given?
-        end
-      end
+      # @api private
+      # TODO: deprecate after 3.2
+      GetBucketOptions = ::Couchbase::Management::Options::Bucket::GetBucket
 
-      class FlushBucketOptions
-        # @return [Integer] the time in milliseconds allowed for the operation to complete
-        attr_accessor :timeout
+      # @api private
+      # TODO: deprecate after 3.2
+      GetAllBucketsOptions = ::Couchbase::Management::Options::Bucket::GetAllBuckets
 
-        def initialize
-          yield self if block_given?
-        end
-      end
+      # @api private
+      # TODO: deprecate after 3.2
+      FlushBucketOptions = ::Couchbase::Management::Options::Bucket::FlushBucket
 
       private
 
@@ -263,12 +399,14 @@ module Couchbase
       def ejection_policy
         @eviction_policy
       end
+
       deprecate :ejection_policy, :eviction_policy, 2021, 1
 
       # @deprecated Use {#eviction_policy=} instead
       def ejection_policy=(val)
         @eviction_policy = val
       end
+
       deprecate :ejection_policy=, :eviction_policy=, 2021, 1
 
       # @yieldparam [BucketSettings] self

data/lib/couchbase/management/collection_manager.rb

@@ -15,9 +15,149 @@
 require "rubygems/deprecate"
 
 require "couchbase/errors"
+require "couchbase/options"
 
 module Couchbase
   module Management
+    module Options
+      module Collection
+        # Options for {CollectionManager#get_all_scopes}
+        class GetAllScopes < ::Couchbase::Options::Base
+          # Creates an instance of options for {CollectionManager#get_all_scopes}
+          #
+          # @param [Integer, #in_milliseconds, nil] timeout the time in milliseconds allowed for the operation to complete
+          # @param [Proc, nil] retry_strategy the custom retry strategy, if set
+          # @param [Hash, nil] client_context the client context data, if set
+          # @param [Span, nil] parent_span if set holds the parent span, that should be used for this request
+          #
+          # @yieldparam [GetAllScopes] self
+          def initialize(timeout: nil,
+                         retry_strategy: nil,
+                         client_context: nil,
+                         parent_span: nil)
+            super
+            yield self if block_given?
+          end
+        end
+
+        # Options for {CollectionManager#create_scope}
+        class CreateScope < ::Couchbase::Options::Base
+          # Creates an instance of options for {CollectionManager#create_scope}
+          #
+          # @param [Integer, #in_milliseconds, nil] timeout the time in milliseconds allowed for the operation to complete
+          # @param [Proc, nil] retry_strategy the custom retry strategy, if set
+          # @param [Hash, nil] client_context the client context data, if set
+          # @param [Span, nil] parent_span if set holds the parent span, that should be used for this request
+          #
+          # @yieldparam [CreateScope] self
+          def initialize(timeout: nil,
+                         retry_strategy: nil,
+                         client_context: nil,
+                         parent_span: nil)
+            super
+            yield self if block_given?
+          end
+        end
+
+        # Options for {CollectionManager#drop_scope}
+        class DropScope < ::Couchbase::Options::Base
+          # Creates an instance of options for {CollectionManager#drop_scope}
+          #
+          # @param [Integer, #in_milliseconds, nil] timeout the time in milliseconds allowed for the operation to complete
+          # @param [Proc, nil] retry_strategy the custom retry strategy, if set
+          # @param [Hash, nil] client_context the client context data, if set
+          # @param [Span, nil] parent_span if set holds the parent span, that should be used for this request
+          #
+          # @yieldparam [DropScope] self
+          def initialize(timeout: nil,
+                         retry_strategy: nil,
+                         client_context: nil,
+                         parent_span: nil)
+            super
+            yield self if block_given?
+          end
+        end
+
+        # Options for {CollectionManager#create_collection}
+        class CreateCollection < ::Couchbase::Options::Base
+          # Creates an instance of options for {CollectionManager#create_collection}
+          #
+          # @param [Integer, #in_milliseconds, nil] timeout the time in milliseconds allowed for the operation to complete
+          # @param [Proc, nil] retry_strategy the custom retry strategy, if set
+          # @param [Hash, nil] client_context the client context data, if set
+          # @param [Span, nil] parent_span if set holds the parent span, that should be used for this request
+          #
+          # @yieldparam [CreateCollection] self
+          def initialize(timeout: nil,
+                         retry_strategy: nil,
+                         client_context: nil,
+                         parent_span: nil)
+            super
+            yield self if block_given?
+          end
+        end
+
+        # Options for {CollectionManager#drop_collection}
+        class DropCollection < ::Couchbase::Options::Base
+          # Creates an instance of options for {CollectionManager#drop_collection}
+          #
+          # @param [Integer, #in_milliseconds, nil] timeout the time in milliseconds allowed for the operation to complete
+          # @param [Proc, nil] retry_strategy the custom retry strategy, if set
+          # @param [Hash, nil] client_context the client context data, if set
+          # @param [Span, nil] parent_span if set holds the parent span, that should be used for this request
+          #
+          # @yieldparam [DropCollection] self
+          def initialize(timeout: nil,
+                         retry_strategy: nil,
+                         client_context: nil,
+                         parent_span: nil)
+            super
+            yield self if block_given?
+          end
+        end
+
+        # rubocop:disable Naming/MethodName constructor shortcuts
+        module_function
+
+        # Construct {GetAllScopes} options for {CollectionManager#get_all_scopes}
+        #
+        # @return [GetAllScopes]
+        def GetAllScopes(**args)
+          GetAllScopes.new(**args)
+        end
+
+        # Construct {CreateScope} options for {CollectionManager#create_scope}
+        #
+        # @return [CreateScope]
+        def CreateScope(**args)
+          CreateScope.new(**args)
+        end
+
+        # Construct {DropScope} options for {CollectionManager#drop_scope}
+        #
+        # @return [DropScope]
+        def DropScope(**args)
+          DropScope.new(**args)
+        end
+
+        # Construct {CreateCollection} options for {CollectionManager#create_collection}
+        #
+        # @return [CreateCollection]
+        def CreateCollection(**args)
+          CreateCollection.new(**args)
+        end
+
+        # Construct {DropCollection} options for {CollectionManager#drop_collection}
+        #
+        # @return [DropCollection]
+        def DropCollection(**args)
+          DropCollection.new(**args)
+        end
+
+        # rubocop:enable Naming/MethodName
+      end
+    end
+
     class CollectionManager
       extend Gem::Deprecate
 
@@ -32,11 +172,11 @@ module Couchbase
 
       # Get all scopes
       #
-      # @param [GetAllScopesOptions] options
+      # @param [Options::Collection::GetAllScopes] options
       #
       # @return [Array<ScopeSpec>]
-      def get_all_scopes(options = GetAllScopesOptions.new)
-        res = @backend.scope_get_all(@bucket_name, options.timeout)
+      def get_all_scopes(options = Options::Collection::GetAllScopes.new)
+        res = @backend.scope_get_all(@bucket_name, options.to_backend)
         res[:scopes].map do |s|
           ScopeSpec.new do |scope|
             scope.name = s[:name]
@@ -61,61 +201,63 @@ module Couchbase
       #
       # @raise [Error::ScopeNotFound]
       def get_scope(scope_name, options = GetScopeOptions.new)
-        get_all_scopes(GetAllScopesOptions.new { |o| o.timeout = options.timeout })
+        get_all_scopes(Options::Collection::GetAllScopes(timeout: options.timeout))
           .find { |scope| scope.name == scope_name } or raise Error::ScopeNotFound, "unable to find scope #{scope_name}"
       end
+
       deprecate :get_scope, :get_all_scopes, 2021, 6
 
       # Creates a new scope
       #
       # @param [String] scope_name name of the scope
-      # @param [CreateScopeOptions] options
+      # @param [Options::Collection::CreateScope] options
       #
       # @return void
       #
       # @raise [ArgumentError]
-      def create_scope(scope_name, options = CreateScopeOptions.new)
-        @backend.scope_create(@bucket_name, scope_name, options.timeout)
+      def create_scope(scope_name, options = Options::Collection::CreateScope.new)
+        @backend.scope_create(@bucket_name, scope_name, options.to_backend)
       end
 
       # Removes a scope
       #
       # @param [String] scope_name name of the scope
-      # @param [DropScopeOptions] options
+      # @param [Options::Collection::DropScope] options
       #
       # @return void
       #
       # @raise [Error::ScopeNotFound]
-      def drop_scope(scope_name, options = DropScopeOptions.new)
-        @backend.scope_drop(@bucket_name, scope_name, options.timeout)
+      def drop_scope(scope_name, options = Options::Collection::DropScope.new)
+        @backend.scope_drop(@bucket_name, scope_name, options.to_backend)
       end
 
       # Creates a new collection
       #
       # @param [CollectionSpec] collection specification of the collection
-      # @param [CreateCollectionOptions] options
+      # @param [Options::Collection::CreateCollection] options
       #
       # @return void
       #
       # @raise [ArgumentError]
       # @raise [Error::CollectionExist]
       # @raise [Error::ScopeNotFound]
-      def create_collection(collection, options = CreateCollectionOptions.new)
-        @backend.collection_create(@bucket_name, collection.scope_name, collection.name, collection.max_expiry, options.timeout)
+      def create_collection(collection, options = Options::Collection::CreateCollection.new)
+        @backend.collection_create(@bucket_name, collection.scope_name, collection.name, collection.max_expiry, options.to_backend)
       end
 
       # Removes a collection
       #
       # @param [CollectionSpec] collection specification of the collection
-      # @param [DropCollectionOptions] options
+      # @param [Options::Collection::DropCollection] options
       #
       # @return void
       #
       # @raise [Error::CollectionNotFound]
-      def drop_collection(collection, options = DropCollectionOptions.new)
-        @backend.collection_drop(@bucket_name, collection.scope_name, collection.name, options.timeout)
+      def drop_collection(collection, options = Options::Collection::DropCollection.new)
+        @backend.collection_drop(@bucket_name, collection.scope_name, collection.name, options.to_backend)
       end
 
+      # @deprecated use {CollectionManager#get_all_scopes} instead
       class GetScopeOptions
         # @return [Integer] the time in milliseconds allowed for the operation to complete
         attr_accessor :timeout
@@ -126,55 +268,25 @@ module Couchbase
         end
       end
 
-      class GetAllScopesOptions
-        # @return [Integer] the time in milliseconds allowed for the operation to complete
-        attr_accessor :timeout
+      # @api private
+      # TODO: deprecate after 3.2
+      GetAllScopesOptions = ::Couchbase::Management::Options::Collection::GetAllScopes
 
-        # @yieldparam [GetAllScopesOptions] self
-        def initialize
-          yield self if block_given?
-        end
-      end
-
-      class CreateScopeOptions
-        # @return [Integer] the time in milliseconds allowed for the operation to complete
-        attr_accessor :timeout
-
-        # @yieldparam [CreateScopeOptions] self
-        def initialize
-          yield self if block_given?
-        end
-      end
-
-      class DropScopeOptions
-        # @return [Integer] the time in milliseconds allowed for the operation to complete
-        attr_accessor :timeout
-
-        # @yieldparam [DropScopeOptions] self
-        def initialize
-          yield self if block_given?
-        end
-      end
-
-      class CreateCollectionOptions
-        # @return [Integer] the time in milliseconds allowed for the operation to complete
-        attr_accessor :timeout
+      # @api private
+      # TODO: deprecate after 3.2
+      CreateScopeOptions = ::Couchbase::Management::Options::Collection::CreateScope
 
-        # @yieldparam [CreateCollectionOptions] self
-        def initialize
-          yield self if block_given?
-        end
-      end
+      # @api private
+      # TODO: deprecate after 3.2
+      DropScopeOptions = ::Couchbase::Management::Options::Collection::DropScope
 
-      class DropCollectionOptions
-        # @return [Integer] the time in milliseconds allowed for the operation to complete
-        attr_accessor :timeout
+      # @api private
+      # TODO: deprecate after 3.2
+      CreateCollectionOptions = ::Couchbase::Management::Options::Collection::CreateCollection
 
-        # @yieldparam [DropCollectionOptions] self
-        def initialize
-          yield self if block_given?
-        end
-      end
+      # @api private
+      # TODO: deprecate after 3.2
+      DropCollectionOptions = ::Couchbase::Management::Options::Collection::DropCollection
     end
 
     class ScopeSpec