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

data/ext/couchbase/version.hxx

@@ -17,8 +17,8 @@
 
 #pragma once
 
-#define BACKEND_VERSION_MAJOR 0
-#define BACKEND_VERSION_MINOR 5
+#define BACKEND_VERSION_MAJOR 1
+#define BACKEND_VERSION_MINOR 0
 #define BACKEND_VERSION_PATCH 0
 
 #include <build_version.hxx>

data/ext/extconf.rb

@@ -1,80 +1,83 @@
+#    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 "mkmf"
 require "tempfile"
 
 require_relative "../lib/couchbase/version"
 SDK_VERSION = Couchbase::VERSION[:sdk]
 
-unless find_executable("cmake")
-  abort "ERROR: CMake is required to build couchbase extension."
-end
+abort "ERROR: CMake is required to build couchbase extension." unless find_executable("cmake")
 
 def sys(*cmd)
   puts "-- #{Dir.pwd}"
-  puts "-- #{cmd.join(" ")}"
+  puts "-- #{cmd.join(' ')}"
   system(*cmd)
 end
 
-
 build_type = ENV["DEBUG"] ? "Debug" : "RelWithDebInfo"
 cmake_flags = %W[
   -DCMAKE_BUILD_TYPE=#{build_type}
-  -DRUBY_HDR_DIR=#{RbConfig::CONFIG["rubyhdrdir"]}
-  -DRUBY_ARCH_HDR_DIR=#{RbConfig::CONFIG["rubyarchhdrdir"]}
+  -DRUBY_HDR_DIR=#{RbConfig::CONFIG['rubyhdrdir']}
+  -DRUBY_ARCH_HDR_DIR=#{RbConfig::CONFIG['rubyarchhdrdir']}
   -DTAOCPP_JSON_BUILD_TESTS=OFF
   -DTAOCPP_JSON_BUILD_EXAMPLES=OFF
   -DSNAPPY_BUILD_TESTS=OFF
   -DSNAPPY_INSTALL=OFF
 ]
 
-if ENV["CB_CC"]
-  cmake_flags << "-DCMAKE_C_COMPILER=#{ENV["CB_CC"]}"
-end
-if ENV["CB_CXX"]
-  cmake_flags << "-DCMAKE_CXX_COMPILER=#{ENV["CB_CXX"]}"
-end
-if ENV["CB_STATIC"]
-  cmake_flags << "-DSTATIC_STDLIB=ON"
-end
+cmake_flags << "-DCMAKE_C_COMPILER=#{ENV['CB_CC']}" if ENV["CB_CC"]
+cmake_flags << "-DCMAKE_CXX_COMPILER=#{ENV['CB_CXX']}" if ENV["CB_CXX"]
+cmake_flags << "-DSTATIC_STDLIB=ON" if ENV["CB_STATIC"]
 
 openssl_root = `brew --prefix openssl 2> /dev/null`.strip
-unless openssl_root.empty?
-  cmake_flags << "-DOPENSSL_ROOT_DIR=#{openssl_root}"
-end
+cmake_flags << "-DOPENSSL_ROOT_DIR=#{openssl_root}" unless openssl_root.empty?
 
 project_path = File.expand_path(File.join(__dir__))
-build_dir = ENV['CB_EXT_BUILD_DIR'] || File.join(Dir.tmpdir, "cb-#{build_type}-#{RUBY_VERSION}-#{RUBY_PATCHLEVEL}-#{RUBY_PLATFORM}-#{SDK_VERSION}")
-FileUtils.mkdir_p(build_dir)
+build_dir = ENV['CB_EXT_BUILD_DIR'] ||
+            File.join(Dir.tmpdir, "cb-#{build_type}-#{RUBY_VERSION}-#{RUBY_PATCHLEVEL}-#{RUBY_PLATFORM}-#{SDK_VERSION}")
+FileUtils.rm_rf(build_dir, verbose: true) unless ENV['CB_PRESERVE_BUILD_DIR']
+FileUtils.mkdir_p(build_dir, verbose: true)
 Dir.chdir(build_dir) do
   puts "-- build #{build_type} extension #{SDK_VERSION} for ruby #{RUBY_VERSION}-#{RUBY_PATCHLEVEL}-#{RUBY_PLATFORM}"
   sys("cmake", *cmake_flags, project_path)
   sys("make -j4 VERBOSE=1")
 end
-extension_name = "libcouchbase.#{RbConfig::CONFIG["SOEXT"] || RbConfig::CONFIG["DLEXT"]}"
+extension_name = "libcouchbase.#{RbConfig::CONFIG['SOEXT'] || RbConfig::CONFIG['DLEXT']}"
 extension_path = File.expand_path(File.join(build_dir, extension_name))
-unless File.file?(extension_path)
-  abort "ERROR: failed to build extension in #{extension_path}"
-end
+abort "ERROR: failed to build extension in #{extension_path}" unless File.file?(extension_path)
 extension_name.gsub!(/\.dylib/, '.bundle')
 install_path = File.expand_path(File.join(__dir__, "..", "lib", "couchbase", extension_name))
 puts "-- copy extension to #{install_path}"
-FileUtils.cp(extension_path, install_path)
+FileUtils.cp(extension_path, install_path, verbose: true)
 ext_directory = File.expand_path(__dir__)
 create_makefile("libcouchbase")
 if ENV["CB_REMOVE_EXT_DIRECTORY"]
   puts "-- CB_REMOVE_EXT_DIRECTORY is set, remove #{ext_directory}"
   Dir
-      .glob("#{ext_directory}/*", File::FNM_DOTMATCH)
-      .reject { |path| %w[. .. extconf.rb].include?(File.basename(path)) || File.basename(path).start_with?(".gem") }
-      .each do |entry|
+    .glob("#{ext_directory}/*", File::FNM_DOTMATCH)
+    .reject { |path| %w[. .. extconf.rb].include?(File.basename(path)) || File.basename(path).start_with?(".gem") }
+    .each do |entry|
     puts "-- remove #{entry}"
-    FileUtils.rm_rf(entry)
+    FileUtils.rm_rf(entry, verbose: true)
   end
   File.truncate("#{ext_directory}/extconf.rb", 0)
   puts "-- truncate #{ext_directory}/extconf.rb"
-  File.write("#{ext_directory}/Makefile", <<EOF)
-.PHONY: all clean install
-all:
-clean:
-install:
-EOF
+  File.write("#{ext_directory}/Makefile", <<~MAKEFILE)
+    .PHONY: all clean install
+    all:
+    clean:
+    install:
+  MAKEFILE
 end

data/ext/test/main.cxx

@@ -64,33 +64,81 @@ p Couchbase::VERSION
 include Couchbase
 
 # begin
-#   load "/home/avsej/code/couchbase-ruby-client/test/query_test.rb"
+#   load "/home/avsej/code/couchbase-ruby-client/test/crud_test.rb"
 # rescue => ex
 #   p ex
 #   puts ex.backtrace
-#   raise
+#   rescue
 # end
 
 backend = Backend.new
-begin
-  options = {
-  }
-  connstr = "couchbases://192.168.42.101?trust_certificate=/tmp/couchbase-ssl-certificate.pem"
-  # curl http://localhost:8091/pools/default/certificate > /tmp/couchbase-ssl-certificate.pem
-  connstr = "couchbases://localhost.avsej.net?trust_certificate=/tmp/couchbase-ssl-certificate.pem"
-  connstr = "couchbases://mars.local?trust_certificate=/tmp/couchbase-ssl-certificate.pem"
-  p open: backend.open(connstr, "Administrator", "password", options)
+connstr = "couchbase://localhost"
+p open: backend.open(connstr, "Administrator", "password", {})
+p bucket: backend.open_bucket("default", true)
+p set: backend.document_upsert("default", "_default._default", "foo", 10_000, JSON.generate(foo: "bar"), 0, {})
+p mutate: begin
+backend.document_mutate_in(
+    "default", "_default._default", "foo", 10_000,
+    [
+      {:opcode => :dict_add, :path => "foo1",  :param => "bar1"},
+      {:opcode => :dict_add, :path => "foo2",  :param => "bar2"},
+      {:opcode => :dict_add, :path => "foo3",  :param => "bar3"},
+      {:opcode => :dict_add, :path => "foo4",  :param => "bar4"},
+      {:opcode => :dict_add, :path => "foo5",  :param => "bar5"},
+      {:opcode => :dict_add, :path => "foo6",  :param => "bar6"},
+      {:opcode => :dict_add, :path => "foo7",  :param => "bar7"},
+      {:opcode => :dict_add, :path => "foo8",  :param => "bar8"},
+      {:opcode => :dict_add, :path => "foo9",  :param => "bar9"},
+      {:opcode => :dict_add, :path => "foo10", :param => "bar10"},
+      {:opcode => :dict_add, :path => "foo11", :param => "bar11"},
+      {:opcode => :dict_add, :path => "foo12", :param => "bar12"},
+      {:opcode => :dict_add, :path => "foo13", :param => "bar13"},
+      {:opcode => :dict_add, :path => "foo14", :param => "bar14"},
+      {:opcode => :dict_add, :path => "foo15", :param => "bar15"},
+      {:opcode => :dict_add, :path => "foo16", :param => "bar16"},
+      {:opcode => :dict_add, :path => "foo17", :param => "bar17"},
+    ], {})
 rescue => ex
-  p err: ex
-  puts ex.backtrace
+ex
 end
+puts
+sleep(1)
+p close: backend.close
+
+# backend = Backend.new
+# begin
+#   options = {
+#   }
+#   connstr = "couchbases://192.168.42.101?trust_certificate=/tmp/couchbase-ssl-certificate.pem"
+#   # curl http://localhost:8091/pools/default/certificate > /tmp/couchbase-ssl-certificate.pem
+#   connstr = "couchbases://localhost.avsej.net?trust_certificate=/tmp/couchbase-ssl-certificate.pem"
+#   connstr = "couchbases://mars.local?trust_certificate=/tmp/couchbase-ssl-certificate.pem"
+#   connstr = "couchbase://127.0.0.1:12000"
+#   connstr = "couchbase://localhost"
+#   p open: backend.open(connstr, "Administrator", "password", options)
+# rescue => ex
+#   p err: ex
+#   puts ex.backtrace
+# end
 # p bucket: backend.open_bucket("default", true)
-# ('aaa'..'zzz').to_a.sample(10).each do |key|
+# keys = ('aaa'..'zzz').to_a.sample(10)
+# keys.each do |key|
+#     STDERR.puts("........ #{key} .........")
 #     p set: backend.document_upsert("default", "_default._default", key, 10_000, JSON.generate(foo: "bar"), 0, {})
-#     p get: backend.document_get("default", "_default._default", key, nil)
+#     p get: (backend.document_get("default", "_default._default", key, nil) rescue nil)
 # end
-p query: backend.document_query('select "ruby rules" as greeting', {})
-p close: backend.close
+# (1..10000).to_a.reverse.each do |i|
+#   sleep(1)
+#   STDERR.puts("........ #{i} .........")
+# end
+# keys.each do |key|
+#     STDERR.puts("........ #{key} .........")
+#   #  p set: backend.document_upsert("default", "_default._default", key, 10_000, JSON.generate(foo: "bar"), 0, {})
+#     p get: (backend.document_get("default", "_default._default", key, nil) rescue nil)
+# end
+# p query: backend.document_query('select "ruby rules" as greeting', {})
+# STDERR.puts("prepare to close backend")
+# p close: backend.close
 
 # backend = Backend.new
 # begin

data/lib/couchbase.rb

@@ -15,4 +15,3 @@
 require "couchbase/version"
 require "couchbase/libcouchbase"
 require "couchbase/cluster"
-

data/lib/couchbase/analytics_options.rb

@@ -60,10 +60,9 @@ module Couchbase
       # @api private
       # @return [Array<String>, nil]
       def export_positional_parameters
-        @positional_parameters.map { |p| JSON.dump(p) } if @positional_parameters
+        @positional_parameters&.map { |p| JSON.dump(p) }
       end
 
-
       # Sets named parameters for the query
       #
       # @param [Hash] named the key/value map of the parameters to substitute in the statement
@@ -83,7 +82,7 @@ module Couchbase
       # @api private
       # @return [Hash<String => String>, nil]
       def export_named_parameters
-        @named_parameters.each_with_object({}) { |(n, v), o| o[n.to_s] = JSON.dump(v) } if @named_parameters
+        @named_parameters&.each_with_object({}) { |(n, v), o| o[n.to_s] = JSON.dump(v) }
       end
     end
 
@@ -176,4 +175,3 @@ module Couchbase
     end
   end
 end
-

data/lib/couchbase/authenticator.rb

@@ -13,6 +13,7 @@
 #  limitations under the License.
 
 module Couchbase
+  # Authenticator for username/password credentials
   class PasswordAuthenticator
     attr_accessor :username
     attr_accessor :password
@@ -22,4 +23,17 @@ module Couchbase
       @password = password
     end
   end
+
+  # Authenticator for TLS client certificate
+  #
+  # @see https://docs.couchbase.com/server/current/manage/manage-security/configure-client-certificates.html
+  class CertificateAuthenticator
+    attr_accessor :certificate_path
+    attr_accessor :key_path
+
+    def initialize(certificate_path, key_path)
+      @certificate_path = certificate_path
+      @key_path = key_path
+    end
+  end
 end

data/lib/couchbase/binary_collection.rb

@@ -16,7 +16,7 @@ require "couchbase/binary_collection_options"
 
 module Couchbase
   class BinaryCollection
-    alias_method :inspect, :to_s
+    alias inspect to_s
 
     # @param [Couchbase::Collection] collection parent collection
     def initialize(collection)
@@ -52,10 +52,10 @@ module Couchbase
       resp = @backend.document_increment(@collection.bucket_name, "#{@collection.scope_name}.#{@collection.name}", id,
                                          options.timeout,
                                          {
-                                             delta: options.delta,
-                                             initial_value: options.initial,
-                                             expiry: options.expiry,
-                                             durability_level: options.durability_level,
+                                           delta: options.delta,
+                                           initial_value: options.initial,
+                                           expiry: options.expiry,
+                                           durability_level: options.durability_level,
                                          })
       CounterResult.new do |res|
         res.cas = resp[:cas]
@@ -74,10 +74,10 @@ module Couchbase
       resp = @backend.document_decrement(@collection.bucket_name, "#{@collection.scope_name}.#{@collection.name}", id,
                                          options.timeout,
                                          {
-                                             delta: options.delta,
-                                             initial_value: options.initial,
-                                             expiry: options.expiry,
-                                             durability_level: options.durability_level,
+                                           delta: options.delta,
+                                           initial_value: options.initial,
+                                           expiry: options.expiry,
+                                           durability_level: options.durability_level,
                                          })
       CounterResult.new do |res|
         res.cas = resp[:cas]

data/lib/couchbase/binary_collection_options.rb

@@ -22,6 +22,7 @@ module Couchbase
 
       # @yieldparam [AppendOptions] self
       def initialize
+        super
         yield self if block_given?
       end
     end
@@ -32,6 +33,7 @@ module Couchbase
 
       # @yieldparam [PrependOptions] self
       def initialize
+        super
         yield self if block_given?
       end
     end
@@ -51,14 +53,14 @@ module Couchbase
 
       # @yieldparam [IncrementOptions] self
       def initialize
+        super
         @delta = 1
         yield self if block_given?
       end
 
       def delta=(value)
-        if delta < 0
-          raise ArgumentError, "the delta cannot be less than 0"
-        end
+        raise ArgumentError, "the delta cannot be less than 0" if delta.negative?
+
         @delta = value
       end
     end
@@ -78,14 +80,14 @@ module Couchbase
 
       # @yieldparam [DecrementOptions] self
       def initialize
+        super
         @delta = 1
         yield self if block_given?
       end
 
       def delta=(value)
-        if delta < 0
-          raise ArgumentError, "the delta cannot be less than 0"
-        end
+        raise ArgumentError, "the delta cannot be less than 0" if delta.negative?
+
         @delta = value
       end
     end

data/lib/couchbase/bucket.rb

@@ -22,7 +22,7 @@ module Couchbase
     # @return [String] name of the bucket
     attr_reader :name
 
-    alias_method :inspect, :to_s
+    alias inspect to_s
 
     # @param [Couchbase::Backend] backend
     def initialize(backend, name)
@@ -72,23 +72,23 @@ module Couchbase
     # @return [ViewResult]
     def view_query(design_document_name, view_name, options = ViewOptions.new)
       resp = @backend.document_view(@name, design_document_name, view_name, options.namespace, {
-          timeout: options.timeout,
-          scan_consistency: options.scan_consistency,
-          skip: options.skip,
-          limit: options.limit,
-          start_key: (JSON.generate(options.start_key) unless options.start_key.nil?),
-          end_key: (JSON.generate(options.end_key) unless options.end_key.nil?),
-          start_key_doc_id: options.start_key_doc_id,
-          end_key_doc_id: options.end_key_doc_id,
-          inclusive_end: options.inclusive_end,
-          group: options.group,
-          group_level: options.group_level,
-          key: (JSON.generate(options.key) unless options.key.nil?),
-          keys: (options.keys.map { |key| JSON.generate(key) } if options.keys),
-          order: options.order,
-          reduce: options.reduce,
-          on_error: options.on_error,
-          debug: options.debug,
+        timeout: options.timeout,
+        scan_consistency: options.scan_consistency,
+        skip: options.skip,
+        limit: options.limit,
+        start_key: (JSON.generate(options.start_key) unless options.start_key.nil?),
+        end_key: (JSON.generate(options.end_key) unless options.end_key.nil?),
+        start_key_doc_id: options.start_key_doc_id,
+        end_key_doc_id: options.end_key_doc_id,
+        inclusive_end: options.inclusive_end,
+        group: options.group,
+        group_level: options.group_level,
+        key: (JSON.generate(options.key) unless options.key.nil?),
+        keys: options.keys&.map { |key| JSON.generate(key) },
+        order: options.order,
+        reduce: options.reduce,
+        on_error: options.on_error,
+        debug: options.debug,
       })
       ViewResult.new do |res|
         res.meta_data = ViewMetaData.new do |meta|

data/lib/couchbase/cluster.rb

@@ -27,16 +27,24 @@ require "couchbase/analytics_options"
 
 module Couchbase
   class Cluster
-    alias_method :inspect, :to_s
+    alias inspect to_s
 
     # Connect to the Couchbase cluster
     #
-    # @param [String] connection_string connection string used to locate the Couchbase Cluster
-    # @param [ClusterOptions] options custom options when creating the cluster connection
+    # @overload connect(connection_string, options)
+    #   @param [String] connection_string connection string used to locate the Couchbase Cluster
+    #   @param [ClusterOptions] options custom options when creating the cluster connection
+    #
+    # @overload connect(connection_string, username, password, options)
+    #   Shortcut for {PasswordAuthenticator}
+    #   @param [String] connection_string connection string used to locate the Couchbase Cluster
+    #   @param [String] username name of the user
+    #   @param [String] password password of the user
+    #   @param [ClusterOptions, nil] options custom options when creating the cluster connection
     #
     # @return [Cluster]
-    def self.connect(connection_string, options)
-      Cluster.new(connection_string, options)
+    def self.connect(connection_string, *options)
+      Cluster.new(connection_string, *options)
     end
 
     # Returns an instance of the {Bucket}
@@ -56,29 +64,23 @@ module Couchbase
     # @return [QueryResult]
     def query(statement, options = QueryOptions.new)
       resp = @backend.document_query(statement, {
-          timeout: options.timeout,
-          adhoc: options.adhoc,
-          client_context_id: options.client_context_id,
-          max_parallelism: options.max_parallelism,
-          readonly: options.readonly,
-          scan_wait: options.scan_wait,
-          scan_cap: options.scan_cap,
-          pipeline_batch: options.pipeline_batch,
-          pipeline_cap: options.pipeline_cap,
-          metrics: options.metrics,
-          profile: options.profile,
-          positional_parameters: options.export_positional_parameters,
-          named_parameters: options.export_named_parameters,
-          raw_parameters: options.raw_parameters,
-          scan_consistency: options.scan_consistency,
-          mutation_state: (options.mutation_state.tokens.map { |t|
-            {
-                bucket_name: t.bucket_name,
-                partition_id: t.partition_id,
-                partition_uuid: t.partition_uuid,
-                sequence_number: t.sequence_number,
-            }
-          } if options.mutation_state),
+        timeout: options.timeout,
+        adhoc: options.adhoc,
+        client_context_id: options.client_context_id,
+        max_parallelism: options.max_parallelism,
+        readonly: options.readonly,
+        scan_wait: options.scan_wait,
+        scan_cap: options.scan_cap,
+        pipeline_batch: options.pipeline_batch,
+        pipeline_cap: options.pipeline_cap,
+        metrics: options.metrics,
+        profile: options.profile,
+        positional_parameters: options.export_positional_parameters,
+        named_parameters: options.export_named_parameters,
+        scope_qualifier: options.scope_qualifier,
+        raw_parameters: options.raw_parameters,
+        scan_consistency: options.scan_consistency,
+        mutation_state: options.mutation_state&.to_a,
       })
 
       QueryResult.new do |res|
@@ -114,14 +116,14 @@ module Couchbase
     # @return [AnalyticsResult]
     def analytics_query(statement, options = AnalyticsOptions.new)
       resp = @backend.document_analytics(statement, {
-          timeout: options.timeout,
-          client_context_id: options.client_context_id,
-          scan_consistency: options.scan_consistency,
-          readonly: options.readonly,
-          priority: options.priority,
-          positional_parameters: options.export_positional_parameters,
-          named_parameters: options.export_named_parameters,
-          raw_parameters: options.raw_parameters,
+        timeout: options.timeout,
+        client_context_id: options.client_context_id,
+        scan_consistency: options.scan_consistency,
+        readonly: options.readonly,
+        priority: options.priority,
+        positional_parameters: options.export_positional_parameters,
+        named_parameters: options.export_named_parameters,
+        raw_parameters: options.raw_parameters,
       })
 
       AnalyticsResult.new do |res|
@@ -158,24 +160,17 @@ module Couchbase
     # @return [SearchResult]
     def search_query(index_name, query, options = SearchOptions.new)
       resp = @backend.document_search(index_name, JSON.generate(query), {
-          timeout: options.timeout,
-          limit: options.limit,
-          skip: options.skip,
-          explain: options.explain,
-          highlight_style: options.highlight_style,
-          highlight_fields: options.highlight_fields,
-          fields: options.fields,
-          sort: (options.sort.map { |v| JSON.generate(v) } if options.sort),
-          facets: (options.facets.map { |(k, v)| [k, JSON.generate(v)] } if options.facets),
-          scan_consistency: options.scan_consistency,
-          mutation_state: (options.mutation_state.tokens.map { |t|
-            {
-                bucket_name: t.bucket_name,
-                partition_id: t.partition_id,
-                partition_uuid: t.partition_uuid,
-                sequence_number: t.sequence_number,
-            }
-          } if options.mutation_state),
+        timeout: options.timeout,
+        limit: options.limit,
+        skip: options.skip,
+        explain: options.explain,
+        highlight_style: options.highlight_style,
+        highlight_fields: options.highlight_fields,
+        fields: options.fields,
+        sort: options.sort&.map { |v| JSON.generate(v) },
+        facets: options.facets&.map { |(k, v)| [k, JSON.generate(v)] },
+        scan_consistency: options.scan_consistency,
+        mutation_state: options.mutation_state&.to_a,
       })
 
       SearchResult.new do |res|
@@ -185,6 +180,7 @@ module Couchbase
           meta.metrics.success_partition_count = resp[:meta_data][:metrics][:success_partition_count]
           meta.metrics.took = resp[:meta_data][:metrics][:took]
           meta.metrics.total_rows = resp[:meta_data][:metrics][:total_rows]
+          meta.errors = resp[:meta_data][:errors]
         end
         res.rows = resp[:rows].map do |r|
           SearchRow.new do |row|
@@ -194,16 +190,16 @@ module Couchbase
             row.score = r[:score]
             row.fragments = r[:fragments]
             row.locations = SearchRowLocations.new(
-                r[:locations].map do |loc|
-                  SearchRowLocation.new do |location|
-                    location.field = loc[:field]
-                    location.term = loc[:term]
-                    location.position = loc[:position]
-                    location.start_offset = loc[:start_offset]
-                    location.end_offset = loc[:end_offset]
-                    location.array_positions = loc[:array_positions]
-                  end
+              r[:locations].map do |loc|
+                SearchRowLocation.new do |location|
+                  location.field = loc[:field]
+                  location.term = loc[:term]
+                  location.position = loc[:position]
+                  location.start_offset = loc[:start_offset]
+                  location.end_offset = loc[:end_offset]
+                  location.array_positions = loc[:array_positions]
                 end
+              end
             )
             row.instance_variable_set("@fields", r[:fields])
             row.explanation = JSON.parse(r[:explanation]) if r[:explanation]
@@ -215,35 +211,35 @@ module Couchbase
                     when SearchFacet::SearchFacetTerm
                       SearchFacetResult::TermFacetResult.new do |f|
                         f.terms =
-                            if v[:terms]
-                              v[:terms].map do |t|
-                                SearchFacetResult::TermFacetResult::TermFacet.new(t[:term], t[:count])
-                              end
-                            else
-                              []
+                          if v[:terms]
+                            v[:terms].map do |t|
+                              SearchFacetResult::TermFacetResult::TermFacet.new(t[:term], t[:count])
                             end
+                          else
+                            []
+                          end
                       end
                     when SearchFacet::SearchFacetDateRange
                       SearchFacetResult::DateRangeFacetResult.new do |f|
                         f.date_ranges =
-                            if v[:date_ranges]
-                              v[:date_ranges].map do |r|
-                                SearchFacetResult::DateRangeFacetResult::DateRangeFacet.new(r[:name], r[:count], r[:start_time], r[:end_time])
-                              end
-                            else
-                              []
+                          if v[:date_ranges]
+                            v[:date_ranges].map do |r|
+                              SearchFacetResult::DateRangeFacetResult::DateRangeFacet.new(r[:name], r[:count], r[:start_time], r[:end_time])
                             end
+                          else
+                            []
+                          end
                       end
                     when SearchFacet::SearchFacetNumericRange
                       SearchFacetResult::NumericRangeFacetResult.new do |f|
                         f.numeric_ranges =
-                            if v[:numeric_ranges]
-                              v[:numeric_ranges].map do |r|
-                                SearchFacetResult::NumericRangeFacetResult::NumericRangeFacet.new(r[:name], r[:count], r[:min], r[:max])
-                              end
-                            else
-                              []
+                          if v[:numeric_ranges]
+                            v[:numeric_ranges].map do |r|
+                              SearchFacetResult::NumericRangeFacetResult::NumericRangeFacet.new(r[:name], r[:count], r[:min], r[:max])
                             end
+                          else
+                            []
+                          end
                       end
                     else
                       next # ignore unknown facet result
@@ -316,17 +312,52 @@ module Couchbase
 
     # Initialize {Cluster} object
     #
-    # @param [String] connection_string connection string used to locate the Couchbase Cluster
-    # @param [ClusterOptions] options custom options when creating the cluster connection
-    def initialize(connection_string, options)
-      raise ArgumentError, "options must have authenticator configured" unless options.authenticator
-      username = options.authenticator.username
-      raise ArgumentError, "missing username" unless username
-      password = options.authenticator.password
-      raise ArgumentError, "missing password" unless password
+    # @overload new(connection_string, options)
+    #   @param [String] connection_string connection string used to locate the Couchbase Cluster
+    #   @param [ClusterOptions] options custom options when creating the cluster connection
+    #
+    # @overload new(connection_string, username, password, options)
+    #   Shortcut for {PasswordAuthenticator}
+    #   @param [String] connection_string connection string used to locate the Couchbase Cluster
+    #   @param [String] username name of the user
+    #   @param [String] password password of the user
+    #   @param [ClusterOptions, nil] options custom options when creating the cluster connection
+    def initialize(connection_string, *args)
+      credentials = {}
+
+      options = args.shift
+      case options
+      when String
+        credentials[:username] = options
+        credentials[:password] = args.shift
+        raise ArgumentError, "missing username" unless credentials[:username]
+        raise ArgumentError, "missing password" unless credentials[:password]
+      when ClusterOptions
+        authenticator = options&.authenticator
+        case authenticator
+        when PasswordAuthenticator
+          credentials[:username] = authenticator&.username
+          raise ArgumentError, "missing username" unless credentials[:username]
+
+          credentials[:password] = authenticator&.password
+          raise ArgumentError, "missing password" unless credentials[:password]
+
+        when CertificateAuthenticator
+          credentials[:certificate_path] = authenticator&.certificate_path
+          raise ArgumentError, "missing certificate path" unless credentials[:certificate_path]
+
+          credentials[:key_path] = authenticator&.key_path
+          raise ArgumentError, "missing key path" unless credentials[:key_path]
+
+        else
+          raise ArgumentError, "options must have authenticator configured"
+        end
+      else
+        raise ArgumentError, "unexpected second argument, have to be String or ClusterOptions"
+      end
 
       @backend = Backend.new
-      @backend.open(connection_string, username, password, {})
+      @backend.open(connection_string, credentials, {})
     end
   end
 end