couchbase 3.4.1-arm64-darwin-20 → 3.4.3-arm64-darwin-20

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0c66775f9944c58be71025321c4cd11d33068f47e723ebc3f1116172d4d1b0c2
-  data.tar.gz: e8cf7b5a11ac1ca879c34d89f1bc063e67e8cfd9ed8de5a435316aea9e488a74
+  metadata.gz: 7781858dae225372665d58fecb6eccadbd09828de8324398143a6233ac2b8a26
+  data.tar.gz: 5f9886de965d9fc967e7c241cff4cffd284002e491e8438b42a054dbcacf7571
 SHA512:
-  metadata.gz: 49a1c6a75d971fb8a79128dfea4212425b8f5c9cb1304c12e34c23dd8587b957826146829ecb031afaabce5b82f0a79e14f9127ffa02e5be5433dde469d662d4
-  data.tar.gz: 491c19def9f8fbc4e124064150766c3c7be643d8f628d68eea9f4b702586ef6fc61e87820e3418635b245554f28078e9c455b2b472270e7eb415f617ce0e4157
+  metadata.gz: da37e980f2852accdaa22c27e214b8a1e9cc6edb5fd690a9c57c5b8db3daddb180b40e34fb4acdd25df5b76292f6a5b3fb158edad4d6ce5f27ea2877c08e90fd
+  data.tar.gz: 4c2e1d4aa7ae3f60dacd18e2edcf299ceca355c6f4b2a84264bf928df09e418a0484868a93f7166c89ad53d0b048637ccde0e4e33d608351f69102c11198cb93

data/README.md

@@ -23,7 +23,7 @@ The library has been tested with MRI 3.0, 3.1 and 3.2. Supported platforms are L
 Add this line to your application's Gemfile:
 
 ```ruby
-gem "couchbase", "3.4.1"
+gem "couchbase", "3.4.3"
 ```
 
 And then execute:
@@ -139,7 +139,7 @@ Now the API reference is accessible using a web browser (where `VERSION` is the
 
 The gem is available as open source under the terms of the [Apache2 License](https://opensource.org/licenses/Apache-2.0).
 
-    Copyright 2011-2021 Couchbase, Inc.
+    Copyright 2011-Present Couchbase, Inc.
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.

data/lib/couchbase/authenticator.rb

@@ -28,7 +28,6 @@ module Couchbase
     def initialize(username, password)
       @username = username
       @password = password
-      @allowed_sasl_mechanisms = DEFAULT_SASL_MECHANISMS
     end
 
     # Creates a LDAP compatible password authenticator which is INSECURE if not used with TLS.

data/lib/couchbase/cluster.rb

@@ -32,13 +32,13 @@ module Couchbase
 
     # Connect to the Couchbase cluster
     #
-    # @overload connect(connection_string, options)
-    #   @param [String] connection_string connection string used to locate the Couchbase Cluster
+    # @overload connect(connection_string_or_config, options)
+    #   @param [String, Configuration] connection_string_or_config connection string used to locate the Couchbase Cluster
     #   @param [Options::Cluster] options custom options when creating the cluster connection
     #
-    # @overload connect(connection_string, username, password, options)
+    # @overload connect(connection_string_or_config, username, password, options)
     #   Shortcut for {PasswordAuthenticator}
-    #   @param [String] connection_string connection string used to locate the Couchbase Cluster
+    #   @param [String] connection_string_or_config connection string used to locate the Couchbase Cluster
     #   @param [String] username name of the user
     #   @param [String] password password of the user
     #   @param [Options::Cluster, nil] options custom options when creating the cluster connection
@@ -62,12 +62,16 @@ module Couchbase
     # @see https://docs.couchbase.com/server/current/manage/manage-security/configure-client-certificates.html
     #
     # @return [Cluster]
-    def self.connect(connection_string, *options)
-      regexp = /^((couchbases?|http):\/\/.*)$/i
-      if regexp.match?(connection_string) || !connection_string.include?("://")
-        Cluster.new(connection_string, *options)
+    def self.connect(connection_string_or_config, *options)
+      connection_string = if connection_string_or_config.is_a?(Configuration)
+                            connection_string_or_config.connection_string
+                          else
+                            connection_string_or_config
+                          end
+      if connection_string =~ /\Acouchbases?:\/\/.*\z/i || !connection_string.include?("://")
+        Cluster.new(connection_string_or_config, *options)
       else
-        ClusterRegistry.instance.connect(connection_string, *options)
+        ClusterRegistry.instance.connect(connection_string_or_config, *options)
       end
     end
 
@@ -382,8 +386,6 @@ module Couchbase
         raise ArgumentError, "missing connection_string" unless connection_string
         raise ArgumentError, "missing username" unless credentials[:username]
         raise ArgumentError, "missing password" unless credentials[:password]
-
-        open_options[:allowed_sasl_mechanisms] = PasswordAuthenticator::DEFAULT_SASL_MECHANISMS
       else
         options = args.shift
         case options
@@ -392,8 +394,6 @@ module Couchbase
           credentials[:password] = args.shift
           raise ArgumentError, "missing username" unless credentials[:username]
           raise ArgumentError, "missing password" unless credentials[:password]
-
-          open_options[:allowed_sasl_mechanisms] = PasswordAuthenticator::DEFAULT_SASL_MECHANISMS
         when Options::Cluster
           open_options = options&.to_backend || {}
           authenticator = options&.authenticator

data/lib/couchbase/cluster_registry.rb

@@ -26,9 +26,14 @@ module Couchbase
       @handlers = {}
     end
 
-    def connect(connection_string, *options)
+    def connect(connection_string_or_config, *options)
+      connection_string = if connection_string_or_config.is_a?(Configuration)
+                            connection_string_or_config.connection_string
+                          else
+                            connection_string_or_config
+                          end
       @handlers.each do |regexp, cluster_class|
-        return cluster_class.connect(connection_string, *options) if regexp.match?(connection_string)
+        return cluster_class.connect(connection_string_or_config, *options) if regexp.match?(connection_string)
       end
       raise(Error::FeatureNotAvailable, "Connection string '#{connection_string}' not supported.")
     end

data/lib/couchbase/config_profiles.rb

@@ -15,7 +15,7 @@
 module Couchbase
   module ConfigProfiles
     class Profiles
-      attr :profiles
+      attr_reader :profiles
 
       def initialize
         @profiles = {}

data/lib/couchbase/configuration.rb

@@ -33,10 +33,9 @@ module Couchbase
     private
 
     def load_configuration(settings)
-      configuration = settings.with_indifferent_access
-      @connection_string = configuration[:connection_string]
-      @username = configuration[:username]
-      @password = configuration[:password]
+      @connection_string = settings[:connection_string] || settings["connection_string"]
+      @username = settings[:username] || settings["username"]
+      @password = settings[:password] || settings["password"]
     end
 
     def load_yaml(path, environment)

data/lib/couchbase/json_transcoder.rb

@@ -14,18 +14,25 @@
 
 require "json"
 
+require "couchbase/transcoder_flags"
+
 module Couchbase
   class JsonTranscoder
     # @param [Object] document
     # @return [Array<String, Integer>] pair of encoded document and flags
     def encode(document)
-      [JSON.generate(document), (0x02 << 24) | 0x06]
+      raise Error::EncodingFailure, "The JsonTranscoder does not support binary data" if document.is_a?(String) && !document.valid_encoding?
+
+      [JSON.generate(document), TranscoderFlags.new(format: :json, lower_bits: 6).encode]
     end
 
-    # @param [String, nil] blob string of bytes, containing encoded representation of the document
-    # @param [Integer, :json] _flags bit field, describing how the data encoded
-    # @return Object decoded document
-    def decode(blob, _flags)
+    # @param [String] blob string of bytes, containing encoded representation of the document
+    # @param [Integer, :json] flags bit field, describing how the data encoded
+    # @return [Object] decoded document
+    def decode(blob, flags)
+      format = TranscoderFlags.decode(flags).format
+      raise Error::DecodingFailure, "Unable to decode #{format} with the JsonTranscoder" unless format == :json || format.nil?
+
       JSON.parse(blob) unless blob&.empty?
     end
   end

data/lib/couchbase/management/collection_query_index_manager.rb

@@ -14,6 +14,7 @@
 
 require "couchbase/management/query_index_manager"
 require "couchbase/utils/time"
+require "couchbase/errors"
 
 module Couchbase
   module Management
@@ -37,8 +38,18 @@ module Couchbase
       #
       # @return [Array<QueryIndex>]
       #
-      # @raise [ArgumentError]
+      # @raise [Error::InvalidArgument]
       def get_all_indexes(options = Options::Query::GetAllIndexes.new)
+        unless options.scope_name.nil?
+          raise Error::InvalidArgument,
+                "Scope name cannot be set in the options when using the Query Index manager at the collection level"
+        end
+
+        unless options.collection_name.nil?
+          raise Error::InvalidArgument,
+                "Collection name cannot be set in the options when using the Query Index manager at the collection level"
+        end
+
         res = @backend.collection_query_index_get_all(@bucket_name, @scope_name, @collection_name, options.to_backend)
         res[:indexes].map do |idx|
           QueryIndex.new do |index|
@@ -64,15 +75,17 @@ module Couchbase
       #
       # @return void
       #
-      # @raise [ArgumentError]
+      # @raise [Error::InvalidArgument]
       # @raise [Error::IndexExists]
       def create_index(index_name, fields, options = Options::Query::CreateIndex.new)
         unless options.scope_name.nil?
-          raise ArgumentError, "Scope name cannot be set in the options when using the Query Index manager at the collection level"
+          raise Error::InvalidArgument,
+                "Scope name cannot be set in the options when using the Query Index manager at the collection level"
         end
 
         unless options.collection_name.nil?
-          raise ArgumentError, "Collection name cannot be set in the options when using the Query Index manager at the collection level"
+          raise Error::InvalidArgument,
+                "Collection name cannot be set in the options when using the Query Index manager at the collection level"
         end
 
         @backend.collection_query_index_create(@bucket_name, @scope_name, @collection_name, index_name, fields, options.to_backend)
@@ -84,15 +97,17 @@ module Couchbase
       #
       # @return void
       #
-      # @raise [ArgumentError]
+      # @raise [Error::InvalidArgument]
       # @raise [Error::IndexExists]
       def create_primary_index(options = Options::Query::CreatePrimaryIndex.new)
         unless options.scope_name.nil?
-          raise ArgumentError, "Scope name cannot be set in the options when using the Query Index manager at the collection level"
+          raise Error::InvalidArgument,
+                "Scope name cannot be set in the options when using the Query Index manager at the collection level"
         end
 
         unless options.collection_name.nil?
-          raise ArgumentError, "Collection name cannot be set in the options when using the Query Index manager at the collection level"
+          raise Error::InvalidArgument,
+                "Collection name cannot be set in the options when using the Query Index manager at the collection level"
         end
 
         @backend.collection_query_index_create_primary(@bucket_name, @scope_name, @collection_name, options.to_backend)
@@ -105,15 +120,17 @@ module Couchbase
       #
       # @return void
       #
-      # @raise [ArgumentError]
+      # @raise [Error::InvalidArgument]
       # @raise [Error::IndexNotFound]
       def drop_index(index_name, options = Options::Query::DropIndex.new)
         unless options.scope_name.nil?
-          raise ArgumentError, "Scope name cannot be set in the options when using the Query Index manager at the collection level"
+          raise Error::InvalidArgument,
+                "Scope name cannot be set in the options when using the Query Index manager at the collection level"
         end
 
         unless options.collection_name.nil?
-          raise ArgumentError, "Collection name cannot be set in the options when using the Query Index manager at the collection level"
+          raise Error::InvalidArgument,
+                "Collection name cannot be set in the options when using the Query Index manager at the collection level"
         end
 
         @backend.collection_query_index_drop(@bucket_name, @scope_name, @collection_name, index_name, options.to_backend)
@@ -125,15 +142,17 @@ module Couchbase
       #
       # @return void
       #
-      # @raise [ArgumentError]
+      # @raise [Error::InvalidArgument]
       # @raise [Error::IndexNotFound]
       def drop_primary_index(options = Options::Query::DropPrimaryIndex.new)
         unless options.scope_name.nil?
-          raise ArgumentError, "Scope name cannot be set in the options when using the Query Index manager at the collection level"
+          raise Error::InvalidArgument,
+                "Scope name cannot be set in the options when using the Query Index manager at the collection level"
         end
 
         unless options.collection_name.nil?
-          raise ArgumentError, "Collection name cannot be set in the options when using the Query Index manager at the collection level"
+          raise Error::InvalidArgument,
+                "Collection name cannot be set in the options when using the Query Index manager at the collection level"
         end
 
         @backend.collection_query_index_drop_primary(@bucket_name, @scope_name, @collection_name, options.to_backend)
@@ -145,8 +164,18 @@ module Couchbase
       #
       # @return void
       #
-      # @raise [ArgumentError]
+      # @raise [Error::InvalidArgument]
       def build_deferred_indexes(options = Options::Query::BuildDeferredIndexes.new)
+        unless options.scope_name.nil?
+          raise Error::InvalidArgument,
+                "Scope name cannot be set in the options when using the Query Index manager at the collection level"
+        end
+
+        unless options.collection_name.nil?
+          raise Error::InvalidArgument,
+                "Collection name cannot be set in the options when using the Query Index manager at the collection level"
+        end
+
         @backend.collection_query_index_build_deferred(@bucket_name, @scope_name, @collection_name, options.to_backend)
       end
 
@@ -156,9 +185,19 @@ module Couchbase
       # @param [Integer, #in_milliseconds] timeout the time in milliseconds allowed for the operation to complete
       # @param [Options::Query::WatchIndexes] options
       #
-      # @raise [ArgumentError]
+      # @raise [Error::InvalidArgument]
       # @raise [Error::IndexNotFound]
       def watch_indexes(index_names, timeout, options = Options::Query::WatchIndexes.new)
+        unless options.scope_name.nil?
+          raise Error::InvalidArgument,
+                "Scope name cannot be set in the options when using the Query Index manager at the collection level"
+        end
+
+        unless options.collection_name.nil?
+          raise Error::InvalidArgument,
+                "Collection name cannot be set in the options when using the Query Index manager at the collection level"
+        end
+
         index_names.append("#primary") if options.watch_primary
 
         interval_millis = 50

data/lib/couchbase/management/query_index_manager.rb

@@ -22,21 +22,40 @@ module Couchbase
       module Query
         # Options for {QueryIndexManager#get_all_indexes}
         class GetAllIndexes < ::Couchbase::Options::Base
+          attr_accessor :scope_name # @return [String, nil]
+          attr_accessor :collection_name # @return [String, nil]
+
           # Creates an instance of options for {QueryIndexManager#get_all_indexes}
           #
+          # @param [String, nil] scope_name the name of the scope
+          # @param [String, nil] collection_name the name of the 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 [GetAllScopes] self
-          def initialize(timeout: nil,
+          def initialize(scope_name: nil,
+                         collection_name: nil,
+                         timeout: nil,
                          retry_strategy: nil,
                          client_context: nil,
                          parent_span: nil)
-            super
+            super(timeout: timeout, retry_strategy: retry_strategy, client_context: client_context, parent_span: parent_span)
+            @scope_name = scope_name
+            @collection_name = collection_name
             yield self if block_given?
           end
+
+          # @api private
+          def to_backend
+            {
+              timeout: Utils::Time.extract_duration(@timeout),
+              scope_name: @scope_name,
+              collection_name: @collection_name,
+            }
+          end
         end
 
         # Options for {QueryIndexManager#create_index}
@@ -102,6 +121,7 @@ module Couchbase
           attr_accessor :ignore_if_exists # @return [Boolean]
           attr_accessor :num_replicas # @return [Integer, nil]
           attr_accessor :deferred # @return [Boolean]
+          attr_accessor :index_name # @return [String. nil]
           attr_accessor :scope_name # @return [String, nil]
           attr_accessor :collection_name # @return [String, nil]
 
@@ -110,6 +130,7 @@ module Couchbase
           # @param [Boolean] ignore_if_exists do not raise error if the index already exist
           # @param [Integer] num_replicas the number of replicas that this index should have
           # @param [Boolean] deferred whether the index should be created as a deferred index.
+          # @param [String, nil] index_name the custom name of the primary index.
           # @param [String, nil] scope_name the name of the scope
           # @param [String, nil] collection_name the name of the collection
           #
@@ -122,6 +143,7 @@ module Couchbase
           def initialize(ignore_if_exists: false,
                          num_replicas: nil,
                          deferred: false,
+                         index_name: nil,
                          scope_name: nil,
                          collection_name: nil,
                          timeout: nil,
@@ -132,6 +154,7 @@ module Couchbase
             @ignore_if_exists = ignore_if_exists
             @num_replicas = num_replicas
             @deferred = deferred
+            @index_name = index_name
             @scope_name = scope_name
             @collection_name = collection_name
             yield self if block_given?
@@ -144,6 +167,7 @@ module Couchbase
               ignore_if_exists: @ignore_if_exists,
               deferred: @deferred,
               num_replicas: @num_replicas,
+              index_name: @index_name,
               scope_name: @scope_name,
               collection_name: @collection_name,
             }
@@ -238,7 +262,12 @@ module Couchbase
 
         # Options for {QueryIndexManager#build_deferred_indexes}
         class BuildDeferredIndexes < ::Couchbase::Options::Base
+          attr_accessor :scope_name # @return [String, nil]
+          attr_accessor :collection_name # @return [String, nil]
+
           # Creates an instance of options for {QueryIndexManager#build_deferred_indexes}
+          # @param [String, nil] scope_name the name of the scope
+          # @param [String, nil] collection_name the name of the 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
@@ -246,33 +275,55 @@ module Couchbase
           # @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,
+          def initialize(scope_name: nil,
+                         collection_name: nil,
+                         timeout: nil,
                          retry_strategy: nil,
                          client_context: nil,
                          parent_span: nil)
-            super
+            super(timeout: timeout, retry_strategy: retry_strategy, client_context: client_context, parent_span: parent_span)
+            @scope_name = scope_name
+            @collection_name = collection_name
             yield self if block_given?
           end
+
+          # @api private
+          def to_backend
+            {
+              timeout: Utils::Time.extract_duration(@timeout),
+              scope_name: @scope_name,
+              collection_name: @collection_name,
+            }
+          end
         end
 
         # Options for {QueryIndexManager#watch_indexes}
         class WatchIndexes < ::Couchbase::Options::Base
           attr_accessor :watch_primary # @return [Boolean]
+          attr_accessor :scope_name # @return [String, nil]
+          attr_accessor :collection_name # @return [String, nil]
 
           # Creates an instance of options for {QueryIndexManager#watch_indexes}
           #
           # @param [Boolean] watch_primary whether or not to watch the primary index
+          # @param [String, nil] scope_name the name of the scope
+          # @param [String, nil] collection_name the name of the collection
+          #
           # @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(watch_primary: false,
+                         scope_name: nil,
+                         collection_name: nil,
                          retry_strategy: nil,
                          client_context: nil,
                          parent_span: nil)
             super(timeout: nil, retry_strategy: retry_strategy, client_context: client_context, parent_span: parent_span)
             @watch_primary = watch_primary
+            @scope_name = scope_name
+            @collection_name = collection_name
             yield self if block_given?
           end
 
@@ -280,6 +331,8 @@ module Couchbase
           def to_backend
             {
               watch_primary: @watch_primary,
+              scope_name: @scope_name,
+              collection_name: @collection_name,
             }
           end
         end
@@ -343,6 +396,10 @@ module Couchbase
       #
       # @raise [ArgumentError]
       def get_all_indexes(bucket_name, options = GetAllIndexOptions.new)
+        unless options.scope_name.nil? && options.collection_name.nil?
+          warn "The attributes 'scope_name' and 'collection_name' have been deprecated. Use 'collection.query_indexes' instead"
+        end
+
         res = @backend.query_index_get_all(bucket_name, options.to_backend)
         res[:indexes].map do |idx|
           QueryIndex.new do |index|
@@ -436,10 +493,14 @@ module Couchbase
       # @param [String] bucket_name name of the bucket
       # @param [Options::Query::BuildDeferredIndexes] options
       #
-      # @return void
+      # @return
       #
       # @raise [ArgumentError]
       def build_deferred_indexes(bucket_name, options = Options::Query::BuildDeferredIndexes.new)
+        unless options.scope_name.nil? && options.collection_name.nil?
+          warn "The attributes 'scope_name' and 'collection_name' have been deprecated. Use 'collection.query_indexes' instead"
+        end
+
         @backend.query_index_build_deferred(bucket_name, options.to_backend)
       end
 
@@ -453,6 +514,10 @@ module Couchbase
       # @raise [ArgumentError]
       # @raise [Error::IndexNotFound]
       def watch_indexes(bucket_name, index_names, timeout, options = Options::Query::WatchIndexes.new)
+        unless options.scope_name.nil? && options.collection_name.nil?
+          warn "The attributes 'scope_name' and 'collection_name' have been deprecated. Use 'collection.query_indexes' instead"
+        end
+
         index_names.append("#primary") if options.watch_primary
 
         interval_millis = 50