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

data/ext/couchbase/protocol/unsigned_leb128.h

@@ -49,14 +49,14 @@ template
 typename std::enable_if<std::is_unsigned<T>::value, std::pair<T, std::string_view>>::type
 decode_unsigned_leb128(std::string_view buf, struct Leb128NoThrow)
 {
-    T rv = static_cast<uint8_t>(buf[0]) & 0x7full;
+    T rv = static_cast<uint8_t>(buf[0]) & 0x7fULL;
     size_t end = 0;
-    if ((buf[0] & 0x80) == 0x80ull) {
+    if ((buf[0] & 0x80) == 0x80ULL) {
         T shift = 7;
         // shift in the remaining data
         for (end = 1; end < buf.size(); end++) {
-            rv |= (buf[end] & 0x7full) << shift;
-            if ((static_cast<uint8_t>(buf[end]) & 0x80ull) == 0) {
+            rv |= (buf[end] & 0x7fULL) << shift;
+            if ((static_cast<uint8_t>(buf[end]) & 0x80ULL) == 0) {
                 break; // no more
             }
             shift += 7;
@@ -112,7 +112,7 @@ unsigned_leb128_get_stop_byte_index(std::string_view buf)
     // If buf does not contain a stop-byte, invalid
     size_t stopByte = 0;
     for (auto c : buf) {
-        if ((static_cast<uint8_t>(c) & 0x80ull) == 0) {
+        if ((static_cast<uint8_t>(c) & 0x80ULL) == 0) {
             return stopByte;
         }
         stopByte++;
@@ -134,45 +134,45 @@ template
 class unsigned_leb128<T, typename std::enable_if<std::is_unsigned<T>::value>::type>
 {
   public:
-    unsigned_leb128(T in)
+    explicit unsigned_leb128(T in)
     {
         while (in > 0) {
-            auto byte = gsl::narrow_cast<uint8_t>(in & 0x7full);
+            auto byte = gsl::narrow_cast<uint8_t>(in & 0x7fULL);
             in >>= 7;
 
             // In has more data?
             if (in > 0) {
                 byte |= 0x80;
-                encodedData[encodedSize - 1] = byte;
+                encodedData[encodedSize - 1U] = byte;
                 // Increase the size
                 encodedSize++;
             } else {
-                encodedData[encodedSize - 1] = byte;
+                encodedData[encodedSize - 1U] = byte;
             }
         }
     }
 
-    std::string_view get() const
+    [[nodiscard]] std::string get() const
     {
-        return { encodedData.data(), encodedSize };
+        return { begin(), end() };
     }
 
-    const uint8_t* begin() const
+    [[nodiscard]] const uint8_t* begin() const
     {
         return encodedData.data();
     }
 
-    const uint8_t* end() const
+    [[nodiscard]] const uint8_t* end() const
     {
         return encodedData.data() + encodedSize;
     }
 
-    const uint8_t* data() const
+    [[nodiscard]] const uint8_t* data() const
     {
         return encodedData.data();
     }
 
-    size_t size() const
+    [[nodiscard]] size_t size() const
     {
         return encodedSize;
     }

data/ext/couchbase/utils/byteswap.hxx

@@ -22,7 +22,6 @@ namespace couchbase::utils
 static inline std::uint64_t
 byte_swap_64(std::uint64_t val)
 {
-    ;
     std::uint64_t ret = 0U;
     for (std::size_t i = 0; i < sizeof(std::uint64_t); ++i) {
         ret <<= 8U;
@@ -31,4 +30,4 @@ byte_swap_64(std::uint64_t val)
     }
     return ret;
 }
-} // namespace couchbase::utils
+} // namespace couchbase::utils

data/ext/couchbase/utils/url_codec.hxx

@@ -0,0 +1,225 @@
+#pragma once
+
+namespace couchbase::utils::string_codec
+{
+template<typename Ti, typename To>
+bool
+url_decode(Ti first, Ti last, To out, size_t& nout)
+{
+    for (; first != last && *first != '\0'; ++first) {
+        if (*first == '%') {
+            char nextbuf[3] = { 0 };
+            size_t jj = 0;
+            first++;
+            nextbuf[0] = *first;
+            for (; first != last && jj < 2; ++jj) {
+                nextbuf[jj] = *first;
+                if (jj != 1) {
+                    first++;
+                }
+            }
+            if (jj != 2) {
+                return false;
+            }
+
+            unsigned octet = 0;
+            if (sscanf(nextbuf, "%2X", &octet) != 1) {
+                return false;
+            }
+
+            *out = static_cast<char>(octet);
+        } else {
+            *out = *first;
+        }
+
+        out++;
+        nout++;
+    }
+    return true;
+}
+
+inline bool
+url_decode(const char* input, char* output)
+{
+    const char* endp = input + strlen(input);
+    size_t nout = 0;
+    if (url_decode(input, endp, output, nout)) {
+        output[nout] = '\0';
+        return true;
+    }
+    return false;
+}
+
+inline bool
+url_decode(char* in_out)
+{
+    return url_decode(in_out, in_out);
+}
+
+inline bool
+url_decode(std::string& s)
+{
+    size_t n = 0;
+    if (url_decode(s.begin(), s.end(), s.begin(), n)) {
+        s.resize(n);
+        return true;
+    }
+    return false;
+}
+
+namespace priv
+{
+inline bool
+is_legal_uri_char(char c)
+{
+    auto uc = static_cast<unsigned char>(c);
+    if ((isalpha(uc) != 0) || (isdigit(uc) != 0)) {
+        return true;
+    }
+    switch (uc) {
+        case '-':
+        case '_':
+        case '.':
+        case '~':
+        case '!':
+        case '*':
+        case '\'':
+        case '(':
+        case ')':
+        case ';':
+        case ':':
+        case '@':
+        case '&':
+        case '=':
+        case '+':
+        case '$':
+        case ',':
+        case '/':
+        case '?':
+        case '#':
+        case '[':
+        case ']':
+            return true;
+        default:
+            break;
+    }
+    return false;
+}
+
+template<typename T>
+inline bool
+is_already_escape(T first, T last)
+{
+    first++; // ignore '%'
+    size_t jj;
+    for (jj = 0; first != last && jj < 2; ++jj, ++first) {
+        if (!isxdigit(*first)) {
+            return false;
+        }
+    }
+    return jj == 2;
+}
+} // namespace priv
+
+template<typename Ti, typename To>
+bool
+url_encode(Ti first, Ti last, To& o, bool check_encoded = true)
+{
+    // If re-encoding detection is enabled, this flag indicates not to
+    // re-encode
+    bool skip_encoding = false;
+
+    for (; first != last; ++first) {
+        if (!skip_encoding && check_encoded) {
+            if (*first == '%') {
+                skip_encoding = priv::is_already_escape(first, last);
+            } else if (*first == '+') {
+                skip_encoding = true;
+            }
+        }
+        if (skip_encoding || priv::is_legal_uri_char(*first)) {
+            if (skip_encoding && *first != '%' && !priv::is_legal_uri_char(*first)) {
+                return false;
+            }
+
+            o.insert(o.end(), first, first + 1);
+        } else {
+            unsigned int c = static_cast<unsigned char>(*first);
+            size_t numbytes = 0;
+
+            if ((c & 0x80) == 0) { /* ASCII character */
+                numbytes = 1;
+            } else if ((c & 0xE0) == 0xC0) { /* 110x xxxx */
+                numbytes = 2;
+            } else if ((c & 0xF0) == 0xE0) { /* 1110 xxxx */
+                numbytes = 3;
+            } else if ((c & 0xF8) == 0xF0) { /* 1111 0xxx */
+                numbytes = 4;
+            } else {
+                return false;
+            }
+
+            do {
+                char buf[4];
+                sprintf(buf, "%%%02X", static_cast<unsigned char>(*first));
+                o.insert(o.end(), &buf[0], &buf[0] + 3);
+            } while (--numbytes && ++first != last);
+        }
+    }
+    return true;
+}
+
+template<typename Tin, typename Tout>
+bool
+url_encode(const Tin& in, Tout& out)
+{
+    return url_encode(in.begin(), in.end(), out);
+}
+
+/* See: https://url.spec.whatwg.org/#urlencoded-serializing: */
+/*
+ * 0x2A
+ * 0x2D
+ * 0x2E
+ * 0x30 to 0x39
+ * 0x41 to 0x5A
+ * 0x5F
+ * 0x61 to 0x7A
+ *  Append a code point whose value is byte to output.
+ * Otherwise
+ *  Append byte, percent encoded, to output.
+ */
+template<typename Ti, typename To>
+void
+form_encode(Ti first, Ti last, To& out)
+{
+    for (; first != last; ++first) {
+        auto c = static_cast<unsigned char>(*first);
+        if (isalnum(c)) {
+            out.insert(out.end(), first, first + 1);
+            continue;
+        }
+        if (c == ' ') {
+            char tmp = '+';
+            out.insert(out.end(), &tmp, &tmp + 1);
+        } else if ((c == 0x2A || c == 0x2D || c == 0x2E) || (c >= 0x30 && c <= 0x39) || (c >= 0x41 && c <= 0x5A) || (c == 0x5F) ||
+                   (c >= 0x60 && c <= 0x7A)) {
+            out.insert(out.end(), static_cast<char>(c));
+        } else {
+            char buf[3] = { 0 };
+            out.insert(out.end(), '%');
+            sprintf(buf, "%02X", c);
+            out.insert(out.end(), &buf[0], &buf[0] + 2);
+        }
+    }
+}
+
+std::string
+form_encode(const std::string& src)
+{
+    std::string dst;
+    form_encode(src.begin(), src.end(), dst);
+    return dst;
+}
+
+} // namespace couchbase::utils::string_codec

data/ext/couchbase/version.hxx

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

data/ext/extconf.rb

@@ -12,6 +12,7 @@ def sys(*cmd)
   system(*cmd)
 end
 
+
 build_type = ENV["DEBUG"] ? "Debug" : "RelWithDebInfo"
 cmake_flags = [
   "-DCMAKE_BUILD_TYPE=#{build_type}",
@@ -19,9 +20,11 @@ cmake_flags = [
   "-DRUBY_ARCH_HDR_DIR=#{RbConfig::CONFIG["rubyarchhdrdir"]}",
   "-DTAOCPP_JSON_BUILD_TESTS=OFF",
   "-DTAOCPP_JSON_BUILD_EXAMPLES=OFF",
+  "-DSNAPPY_BUILD_TESTS=OFF",
+  "-DSNAPPY_INSTALL=OFF",
 ]
 openssl_root = `brew --prefix openssl 2> /dev/null`.strip
-if openssl_root
+unless openssl_root.empty?
   cmake_flags << "-DOPENSSL_ROOT_DIR=#{openssl_root}"
 end
 

data/ext/test/main.cxx

@@ -15,129 +15,53 @@
  *   limitations under the License.
  */
 
-#include <asio.hpp>
+#include <generated_config.hxx>
 
-#include <cluster.hxx>
+#include <spdlog/spdlog.h>
 
-#include <errors.hxx>
-#include <operations/get.hxx>
-#include <operations/upsert.hxx>
-#include <operations/lookup_in.hxx>
-#include <operations/query.hxx>
+#include <ruby.h>
 
-static int num_ops = 4;
-
-bool
-done()
+void
+run_script(const char* script)
 {
-    --num_ops;
-    spdlog::info("------ num_ops={}", num_ops);
-    return num_ops == 0;
+    spdlog::info("run script:\n----------------------------------------{}---------------------------------------\n", script);
+    int status = 0;
+    rb_eval_string_protect(script, &status);
+    if (status != 0) {
+        VALUE rbError = rb_funcall(rb_gv_get("$!"), rb_intern("message"), 0);
+        spdlog::critical("ruby execution failure: {}", StringValuePtr(rbError));
+        exit(EXIT_FAILURE);
+    }
 }
 
 int
 main()
 {
-    spdlog::set_level(spdlog::level::trace);
-    spdlog::set_pattern("[%Y-%m-%d %T.%e] [%P,%t] [%^%l%$] %v");
-    asio::io_context ctx;
+    ruby_init();
+    ruby_init_loadpath();
+
+    rb_require(LIBCOUCHBASE_EXT_PATH);
+    run_script(R"(
+p Couchbase::VERSION
+)");
 
-    couchbase::cluster cluster{ ctx };
+    run_script(R"(
+B = Couchbase::Backend.new
+#B.open("192.168.42.101", "Administrator", "password")
+B.open("localhost", "Administrator", "password")
+)");
 
-    couchbase::origin options;
-    options.hostname = "192.168.42.103";
-    options.hostname = "127.0.0.1";
-    options.username = "Administrator";
-    options.password = "password";
+    run_script(R"(
+p B.open_bucket("default")
+p B.document_increment("default", "_default._default", "foo", {:initial_value => 32, :expiration => 42})
+p B.document_get("default", "_default._default", "foo")
+p B.document_decrement("default", "_default._default", "foo", {:initial_value => 32, :expiration => 42})
+)");
 
-    //  std::string bucket_name = "default";
-    //  std::string collection_name = "_default._default";
+    run_script(R"(
+B.close
+)");
 
-    cluster.open(options, [&](std::error_code ec1) {
-        spdlog::info("cluster has been opened: {}", ec1.message());
-        couchbase::operations::query_request req{ "select random()" };
-        cluster.execute(req, [&](couchbase::operations::query_response resp) {
-            spdlog::info("QUERY {}: ec={}, body={}",
-                         couchbase::uuid::to_string(resp.client_context_id),
-                         resp.ec.message(),
-                         resp.payload.meta_data.metrics.result_size);
-            for (auto &r : resp.payload.rows) {
-                spdlog::info("ROW: {}", r);
-            }
-            if (resp.payload.meta_data.profile) {
-                spdlog::info("PROFILE: {}", *resp.payload.meta_data.profile);
-            }
-            cluster.close();
-        });
-#if 0
-      cluster.open_bucket(bucket_name, [&](std::error_code ec2) {
-            if (!ec2) {
-                couchbase::operations::mutate_in_request req{
-                    couchbase::operations::document_id{ bucket_name, collection_name, "foo" },
-                };
-                req.specs.add_spec(couchbase::protocol::subdoc_opcode::dict_upsert, false, false, false, "test", R"({"name":"sergey"})");
-                req.specs.add_spec(couchbase::protocol::subdoc_opcode::counter, false,  false, false,"num", 24);
-                cluster.execute(req, [&](couchbase::operations::mutate_in_response resp) {
-                    spdlog::info("MUTATE_IN {}: ec={}, cas={}, fields={}", resp.id, resp.ec.message(), resp.cas, resp.fields.size());
-                    size_t idx = 0;
-                    for (const auto& field : resp.fields) {
-                        spdlog::info("  {}. {}: {} {}", idx++, field.path, field.status, field.value);
-                    }
-                    // if (done()) {
-                    cluster.close();
-                    //}
-                });
-                couchbase::operations::lookup_in_request req{
-                    couchbase::operations::document_id{ bucket_name, collection_name, "foo" },
-                };
-                req.access_deleted = true;
-                req.specs.add_spec(couchbase::protocol::subdoc_opcode::get, true, "$document");
-                req.specs.add_spec(couchbase::protocol::subdoc_opcode::exists, false, "bar");
-                req.specs.add_spec(couchbase::protocol::subdoc_opcode::get, false, "foo");
-                cluster.execute(req, [&](couchbase::operations::lookup_in_response resp) {
-                    spdlog::info("LOOKUP_IN {}: ec={}, cas={}, fields={}", resp.id, resp.ec.message(), resp.cas, resp.fields.size());
-                    size_t idx = 0;
-                    for (const auto &field : resp.fields) {
-                        spdlog::info("  {}. {}{}: {}", idx++, field.path, field.exists ? "(hit) " : "(miss)", field.value);
-                    }
-                    //if (done()) {
-                        cluster.close();
-                    //}
-                });
-                cluster.execute(
-                  couchbase::operations::get_request{
-                    couchbase::operations::document_id{ bucket_name, collection_name, "foo" },
-                  },
-                  [&](couchbase::operations::get_response resp) {
-                      spdlog::info("GET {}: ec={}, cas={}\n{}", resp.id, resp.ec.message(), resp.cas, resp.value);
-                      if (done()) {
-                          cluster.close();
-                      }
-                  });
-                cluster.execute(
-                  couchbase::operations::get_request{
-                    couchbase::operations::document_id{ bucket_name, collection_name, "bar" },
-                  },
-                  [&](couchbase::operations::get_response resp) {
-                      spdlog::info("GET {}: ec={}, cas={}\n{}", resp.id, resp.ec.message(), resp.cas, resp.value);
-                      if (done()) {
-                          cluster.close();
-                      }
-                  });
-                cluster.execute(
-                  couchbase::operations::upsert_request{ couchbase::operations::document_id{ bucket_name, collection_name, "foo" },
-                                                         "{\"prop\":42}" },
-                  [&](couchbase::operations::upsert_response resp) {
-                      spdlog::info("UPSERT {}: ec={}, cas={}", resp.id, resp.ec.message(), resp.cas);
-                      if (done()) {
-                          cluster.close();
-                      }
-                  });
-            } else {
-                spdlog::info("unable to open the bucket: {}", ec2.message());
-            }
-        });
-#endif
-    });
-    ctx.run();
-}
+    ruby_finalize();
+    return 0;
+}