couchbase 4.2.1 → 4.2.2

package/deps/couchbase-cxx-client/test/test_integration_query.cxx

@@ -127,8 +127,7 @@ TEST_CASE("integration: query on a collection", "[integration]")
     {
         couchbase::core::operations::query_request req{ fmt::format(
           R"(SELECT a, b FROM {} WHERE META().id = "{}")", collection_name, key) };
-        req.bucket_name = integration.ctx.bucket;
-        req.scope_name = scope_name;
+        req.query_context = fmt::format("default:`{}`.`{}`", integration.ctx.bucket, scope_name);
         req.mutation_state = { mutation_token };
         auto resp = test::utils::execute(integration.cluster, req);
         REQUIRE_SUCCESS(resp.ctx.ec);
@@ -140,8 +139,7 @@ TEST_CASE("integration: query on a collection", "[integration]")
     {
         couchbase::core::operations::query_request req{ fmt::format(
           R"(SELECT a, b FROM {} WHERE META().id = "{}")", collection_name, key) };
-        req.bucket_name = integration.ctx.bucket;
-        req.scope_name = "missing_scope";
+        req.query_context = fmt::format("default:`{}`.`{}`", integration.ctx.bucket, "missing_scope");
         req.mutation_state = { mutation_token };
         auto resp = test::utils::execute(integration.cluster, req);
         REQUIRE(resp.ctx.ec == couchbase::errc::query::index_failure);
@@ -150,8 +148,7 @@ TEST_CASE("integration: query on a collection", "[integration]")
     SECTION("missing collection")
     {
         couchbase::core::operations::query_request req{ fmt::format(R"(SELECT a, b FROM missing_collection WHERE META().id = "{}")", key) };
-        req.bucket_name = integration.ctx.bucket;
-        req.scope_name = scope_name;
+        req.query_context = fmt::format("default:`{}`.`{}`", integration.ctx.bucket, scope_name);
         req.mutation_state = { mutation_token };
         auto resp = test::utils::execute(integration.cluster, req);
         REQUIRE(resp.ctx.ec == couchbase::errc::query::index_failure);
@@ -161,8 +158,7 @@ TEST_CASE("integration: query on a collection", "[integration]")
     {
         couchbase::core::operations::query_request req{ fmt::format(
           R"(SELECT a, b FROM {} WHERE META().id = "{}")", collection_name, key) };
-        req.bucket_name = integration.ctx.bucket;
-        req.scope_name = scope_name;
+        req.query_context = fmt::format("default:`{}`.`{}`", integration.ctx.bucket, scope_name);
         req.mutation_state = { mutation_token };
         req.adhoc = false;
         auto resp = test::utils::execute(integration.cluster, req);

package/deps/couchbase-cxx-client/test/test_integration_transcoders.cxx

@@ -282,6 +282,7 @@ TEST_CASE("integration: get with projections and json transcoder", "[integration
         REQUIRE(resp.mutation_token().has_value());
     }
 
+    SECTION("all fields present")
     {
         auto [ctx, resp] = collection.get(id, couchbase::get_options{}.project({ "username", "full_name" })).get();
         REQUIRE_SUCCESS(ctx.ec());
@@ -293,6 +294,19 @@ TEST_CASE("integration: get with projections and json transcoder", "[integration
         REQUIRE(light_albert.birth_year != albert.birth_year);
         REQUIRE(light_albert.birth_year == 0);
     }
+
+    SECTION("with non-existent field in projections")
+    {
+        auto [ctx, resp] = collection.get(id, couchbase::get_options{}.project({ "username", "full_name", "non_existent_field" })).get();
+        REQUIRE_SUCCESS(ctx.ec());
+        REQUIRE_FALSE(resp.cas().empty());
+        auto light_albert = resp.content_as<profile>();
+        REQUIRE_FALSE(light_albert == albert);
+        REQUIRE(light_albert.username == albert.username);
+        REQUIRE(light_albert.full_name == albert.full_name);
+        REQUIRE(light_albert.birth_year != albert.birth_year);
+        REQUIRE(light_albert.birth_year == 0);
+    }
 }
 
 TEST_CASE("integration: get_and_touch and json transcoder", "[integration]")

package/deps/couchbase-cxx-client/test/test_transaction_transaction_public_blocking_api.cxx

@@ -33,13 +33,22 @@ txn_opts()
     opts.expiration_time(std::chrono::seconds(2));
     return opts;
 }
-
+void
+with_new_guard(std::function<void(test::utils::integration_test_guard&)> fn)
+{
+    test::utils::integration_test_guard integration;
+    try {
+        fn(integration);
+    } catch (...) {
+        // noop
+    }
+}
 void
 with_new_cluster(test::utils::integration_test_guard& integration, std::function<void(couchbase::cluster&)> fn)
 {
     // make new virginal public cluster
+
     asio::io_context io;
-    auto guard = asio::make_work_guard(io);
     std::thread io_thread([&io]() { io.run(); });
     auto options = couchbase::cluster_options(integration.ctx.username, integration.ctx.password);
     auto [cluster, ec] = couchbase::cluster::connect(io, integration.ctx.connection_string, options).get();
@@ -52,8 +61,10 @@ with_new_cluster(test::utils::integration_test_guard& integration, std::function
         // noop, just eat it.
     }
     cluster.close();
-    guard.reset();
-    io_thread.join();
+    io.stop();
+    if (io_thread.joinable()) {
+        io_thread.join();
+    }
 }
 
 void
@@ -512,19 +523,20 @@ TEST_CASE("can query from a scope", "[transactions]")
 
 TEST_CASE("can get doc from bucket not yet opened", "[transactions]")
 {
-    test::utils::integration_test_guard integration;
 
     auto id = test::utils::uniq_id("txn");
     {
+        test::utils::integration_test_guard integration;
         couchbase::cluster c(integration.cluster);
         auto coll = c.bucket(integration.ctx.bucket).default_collection();
         auto [err, upsert_res] = coll.upsert(id, content, {}).get();
         REQUIRE_SUCCESS(err.ec());
     }
 
-    with_new_cluster(integration, [&](couchbase::cluster& cluster) {
-        auto coll = cluster.bucket(integration.ctx.bucket).default_collection();
-        auto result = cluster.transactions()->run(
+    with_new_guard([&](test::utils::integration_test_guard& integration) {
+        couchbase::cluster c(integration.cluster);
+        auto coll = c.bucket(integration.ctx.bucket).default_collection();
+        auto result = c.transactions()->run(
           [&id, &coll](couchbase::transactions::attempt_context& ctx) {
               auto doc = ctx.get(coll, id);
               CHECK_FALSE(doc->ctx().ec());
@@ -543,10 +555,11 @@ TEST_CASE("can insert doc into bucket not yet opened", "[transactions]")
 
     auto id = test::utils::uniq_id("txn");
 
-    with_new_cluster(integration, [&](couchbase::cluster& cluster) {
-        auto coll = cluster.bucket(integration.ctx.bucket).default_collection();
+    with_new_guard([&](test::utils::integration_test_guard& guard) {
+        couchbase::cluster c(guard.cluster);
+        auto coll = c.bucket(integration.ctx.bucket).default_collection();
 
-        auto result = cluster.transactions()->run(
+        auto result = c.transactions()->run(
           [&id, &coll](couchbase::transactions::attempt_context& ctx) {
               auto doc = ctx.insert(coll, id, content);
               CHECK_FALSE(doc->ctx().ec());
@@ -564,21 +577,22 @@ TEST_CASE("can insert doc into bucket not yet opened", "[transactions]")
 
 TEST_CASE("can replace doc in bucket not yet opened", "[transactions]")
 {
-    test::utils::integration_test_guard integration;
 
     auto id = test::utils::uniq_id("txn");
     {
+        test::utils::integration_test_guard integration;
         couchbase::cluster c(integration.cluster);
         auto coll = c.bucket(integration.ctx.bucket).default_collection();
         auto [err, upsert_res] = coll.upsert(id, content, {}).get();
         REQUIRE_SUCCESS(err.ec());
     }
 
-    with_new_cluster(integration, [&](couchbase::cluster& cluster) {
-        auto coll = cluster.bucket(integration.ctx.bucket).default_collection();
+    with_new_guard([&](test::utils::integration_test_guard& guard) {
+        couchbase::cluster c(guard.cluster);
+        auto coll = c.bucket(guard.ctx.bucket).default_collection();
         tao::json::value new_content = { { "some", "new content" } };
 
-        auto result = cluster.transactions()->run(
+        auto result = c.transactions()->run(
           [&id, &coll, new_content](couchbase::transactions::attempt_context& ctx) {
               auto get_doc = ctx.get(coll, id);
               CHECK_FALSE(get_doc->ctx().ec());
@@ -598,20 +612,21 @@ TEST_CASE("can replace doc in bucket not yet opened", "[transactions]")
 
 TEST_CASE("can remove doc in bucket not yet opened", "[transactions]")
 {
-    test::utils::integration_test_guard integration;
 
     auto id = test::utils::uniq_id("txn");
     {
+        test::utils::integration_test_guard integration;
         couchbase::cluster c(integration.cluster);
         auto coll = c.bucket(integration.ctx.bucket).default_collection();
         auto [err, upsert_res] = coll.upsert(id, content, {}).get();
         REQUIRE_SUCCESS(err.ec());
     }
 
-    with_new_cluster(integration, [&](couchbase::cluster& cluster) {
-        auto coll = cluster.bucket(integration.ctx.bucket).default_collection();
+    with_new_guard([&](test::utils::integration_test_guard& guard) {
+        couchbase::cluster c(guard.cluster);
+        auto coll = c.bucket(guard.ctx.bucket).default_collection();
         tao::json::value new_content = { { "some", "new content" } };
-        auto result = cluster.transactions()->run(
+        auto result = c.transactions()->run(
           [&id, &coll, new_content](couchbase::transactions::attempt_context& ctx) {
               auto get_doc = ctx.get(coll, id);
               CHECK_FALSE(get_doc->ctx().ec());

package/deps/couchbase-cxx-client/test/test_unit_transaction_logging.cxx

@@ -14,9 +14,11 @@
  *   limitations under the License.
  */
 
-#include "core/transactions/internal/logging.hxx"
+#include "test/utils/wait_until.hxx"
 #include "test_helper.hxx"
-#include <core/transactions.hxx>
+#include <core/logger/configuration.hxx>
+#include <core/logger/logger.hxx>
+#include <core/transactions/internal/logging.hxx>
 
 #include <spdlog/sinks/base_sink.h>
 
@@ -28,8 +30,10 @@ using namespace couchbase::core::transactions;
 class TrivialFileSink : public spdlog::sinks::base_sink<std::mutex>
 {
   public:
-    std::string output() const
+    std::string output()
     {
+        // prevent data race if sink_it_ is called
+        std::lock_guard<std::mutex> lock(mut_);
         return out_.str();
     }
 
@@ -38,6 +42,8 @@ class TrivialFileSink : public spdlog::sinks::base_sink<std::mutex>
     {
         spdlog::memory_buf_t formatted;
         base_sink<std::mutex>::formatter_->format(msg, formatted);
+        // prevent data race when calling output()
+        std::lock_guard<std::mutex> lock(mut_);
         out_ << formatted.data();
     }
     void flush_() override
@@ -46,41 +52,79 @@ class TrivialFileSink : public spdlog::sinks::base_sink<std::mutex>
 
   private:
     std::stringstream out_;
+    // needed since we examine the internal state of this object
+    std::mutex mut_;
 };
 
+bool
+sink_has_output(std::shared_ptr<TrivialFileSink> sink)
+{
+    return test::utils::wait_until([&]() { return !sink->output().empty(); }, std::chrono::seconds(2), std::chrono::milliseconds(100));
+}
+
+bool
+sink_is_empty(std::shared_ptr<TrivialFileSink> sink)
+{
+    // now, we need to be sure it is empty, and stays that way for some period of time,
+    // since async loggers don't flush immediately.   The logger is set to flush every
+    // second, so waiting 2 or 3 seems reasonable
+    if (sink->output().empty()) {
+        std::this_thread::sleep_for(std::chrono::seconds(2));
+        return sink->output().empty();
+    }
+    return false;
+}
+
+bool
+sink_output_contains(std::shared_ptr<TrivialFileSink> sink, const std::string& msg)
+{
+    return std::string::npos != sink->output().find(msg);
+}
+
+void
+create_logger(std::shared_ptr<TrivialFileSink> sink, couchbase::core::logger::level level)
+{
+    couchbase::core::logger::configuration conf{};
+    conf.log_level = level;
+    conf.sink = sink;
+    conf.console = false;
+    couchbase::core::logger::create_file_logger(conf);
+}
+
 TEST_CASE("transactions: can use custom sink", "[unit]")
 {
-    couchbase::core::logger::create_blackhole_logger();
     std::string log_message = "I am a log";
     auto sink = std::make_shared<TrivialFileSink>();
-    create_loggers(couchbase::core::logger::level::debug, sink);
-    txn_log->debug(log_message);
-    txn_log->flush();
-    REQUIRE_FALSE(sink->output().empty());
-    REQUIRE(std::string::npos != sink->output().find(log_message));
+    create_logger(sink, couchbase::core::logger::level::trace);
+    CB_TXN_LOG_DEBUG(log_message);
+    couchbase::core::logger::flush();
+    // ASYNC logger, so flush returns immediately.   Gotta wait...
+    REQUIRE(sink_has_output(sink));
+    REQUIRE(sink_output_contains(sink, log_message));
 }
 
 TEST_CASE("transactions: custom sink respects log levels", "[unit]")
 {
-    couchbase::core::logger::create_blackhole_logger();
     std::string log_message = "I am a log";
+    std::string log_message2 = "I am also a log";
     auto sink = std::make_shared<TrivialFileSink>();
-    create_loggers(couchbase::core::logger::level::info, sink);
-    txn_log->debug(log_message);
-    txn_log->flush();
-    REQUIRE(sink->output().empty());
-    couchbase::core::logger::create_console_logger();
+    create_logger(sink, couchbase::core::logger::level::info);
+    CB_TXN_LOG_DEBUG(log_message);
+    couchbase::core::logger::flush();
+    REQUIRE(sink_is_empty(sink));
+    CB_TXN_LOG_INFO(log_message2);
+    couchbase::core::logger::flush();
+    REQUIRE(sink_has_output(sink));
+    REQUIRE(sink_output_contains(sink, log_message2));
 }
 
 TEST_CASE("transactions: custom sink respects log level changes", "[unit]")
 {
-    couchbase::core::logger::create_blackhole_logger();
     std::string log_message = "I am a log";
     auto sink = std::make_shared<TrivialFileSink>();
-    create_loggers(couchbase::core::logger::level::debug, sink);
-    set_transactions_log_level(couchbase::core::logger::level::info);
-    txn_log->debug(log_message);
-    txn_log->flush();
-    REQUIRE(sink->output().empty());
-    couchbase::core::logger::create_console_logger();
+    create_logger(sink, couchbase::core::logger::level::trace);
+    couchbase::core::logger::set_log_levels(couchbase::core::logger::level::info);
+    CB_TXN_LOG_DEBUG(log_message);
+    couchbase::core::logger::flush();
+    REQUIRE(sink_is_empty(sink));
 }

package/deps/couchbase-cxx-client/test/test_unit_utils.cxx

@@ -211,3 +211,54 @@ TEST_CASE("unit: base64", "[unit]")
     REQUIRE(couchbase::core::base64::encode(binary, false) == base64);
     REQUIRE(couchbase::core::base64::encode(binary, true) == base64_pretty);
 }
+
+namespace couchbase::core::meta
+{
+std::string
+parse_git_describe_output(const std::string& git_describe_output);
+}
+
+TEST_CASE("unit: semantic version string", "[unit]")
+{
+    REQUIRE(couchbase::core::meta::parse_git_describe_output("1.0.0-beta.4-16-gfbc9922") == "1.0.0-beta.4+16.fbc9922");
+    REQUIRE(couchbase::core::meta::parse_git_describe_output("1.0.0-16-gfbc9922") == "1.0.0+16.fbc9922");
+    REQUIRE(couchbase::core::meta::parse_git_describe_output("") == "");
+    REQUIRE(couchbase::core::meta::parse_git_describe_output("unknown") == "");
+    REQUIRE(couchbase::core::meta::parse_git_describe_output("invalid") == "");
+    REQUIRE(couchbase::core::meta::parse_git_describe_output("1.0.0.0.0") == "");
+    REQUIRE(couchbase::core::meta::parse_git_describe_output("1.0.0-beta.4-0-gfbc9922") == "1.0.0-beta.4");
+    REQUIRE(couchbase::core::meta::parse_git_describe_output("1.0.0-beta.4") == "1.0.0-beta.4");
+}
+
+#if 0
+// This test is commented out because, it is not necessary to run it with the suite, but it still useful for debugging.
+
+#include "core/platform/uuid.h"
+
+TEST_CASE("unit: uuid collision", "[unit]")
+{
+    std::array<std::set<std::string>, 10> uuids{};
+    std::vector<std::thread> threads{};
+    threads.reserve(10);
+
+    for (std::size_t t = 0; t < 10; ++t) {
+        threads.emplace_back([&uuids, t]() {
+            for (std::size_t i = 0; i < 1'000'000; ++i) {
+                auto uuid = couchbase::core::uuid::to_string(couchbase::core::uuid::random());
+                uuids[t].insert(uuid);
+            }
+        });
+    }
+    for (std::size_t t = 0; t < 10; ++t) {
+        threads[t].join();
+        REQUIRE(uuids[t].size() == 1'000'000);
+    }
+
+    std::set<std::string> all_uuids{};
+    for (std::size_t t = 0; t < 10; ++t) {
+        for (const auto& uuid : uuids[t]) {
+            REQUIRE(all_uuids.insert(uuid).second);
+        }
+    }
+}
+#endif

package/deps/couchbase-cxx-client/test/tools/tool_kv_loader.cxx

@@ -106,7 +106,7 @@ static std::string
 random_text(std::size_t length)
 {
     std::string alphabet = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
-    static thread_local std::minstd_rand gen{ std::random_device()() };
+    static thread_local std::mt19937_64 gen{ std::random_device()() };
     std::uniform_int_distribution<std::size_t> dis(0, alphabet.size() - 1);
     std::string text(length, '-');
     for (std::size_t i = 0; i < length; ++i) {
@@ -230,7 +230,7 @@ main()
         hit_chance_for_get = std::stod(val, nullptr);
     }
 
-    static thread_local std::minstd_rand gen{ std::random_device()() };
+    static thread_local std::mt19937_64 gen{ std::random_device()() };
     std::uniform_real_distribution<double> dist(0, 1);
 
     std::atomic_uint64_t total{};

package/deps/couchbase-cxx-client/test/utils/integration_test_guard.cxx

@@ -90,6 +90,7 @@ integration_test_guard::integration_test_guard(const couchbase::core::cluster_op
     // for now, lets _only_ add a tracer or meter from the incoming options
     connstr.options.meter = opts.meter;
     connstr.options.tracer = opts.tracer;
+    connstr.options.enable_mutation_tokens = opts.enable_mutation_tokens;
     couchbase::core::origin orig(auth, connstr);
     io_threads = spawn_io_threads(io, ctx.number_of_io_threads);
     open_cluster(cluster, orig);
@@ -98,6 +99,7 @@ integration_test_guard::integration_test_guard(const couchbase::core::cluster_op
 integration_test_guard::~integration_test_guard()
 {
     close_cluster(cluster);
+    io.stop();
     for (auto& thread : io_threads) {
         thread.join();
     }

package/deps/couchbase-cxx-client/test/utils/wait_until.cxx

@@ -80,11 +80,11 @@ wait_until_cluster_connected(const std::string& username, const std::string& pas
         asio::io_context io;
         auto guard = asio::make_work_guard(io);
         std::thread io_thread([&io]() { io.run(); });
-        auto resp = couchbase::cluster::connect(io, connection_string, cluster_options).get();
-        resp.first.close();
+        auto [cluster, ec] = couchbase::cluster::connect(io, connection_string, cluster_options).get();
+        cluster.close();
         guard.reset();
         io_thread.join();
-        return resp.second.value() == 0;
+        return ec.value() == 0;
     });
     if (connected) {
         std::this_thread::sleep_for(std::chrono::seconds(1));
@@ -92,4 +92,4 @@ wait_until_cluster_connected(const std::string& username, const std::string& pas
 
     return connected;
 }
-} // namespace test::utils
+} // namespace test::utils

package/deps/couchbase-cxx-client/third_party/docopt/.travis.yml

@@ -0,0 +1,103 @@
+language: cpp
+sudo: false   # Use the new container infrastructure
+
+matrix:
+  include:
+    - os: linux
+      env:
+        - COMPILER=g++-7
+      addons:
+        apt:
+          sources: ['ubuntu-toolchain-r-test']
+          packages: ["g++-7", "cmake-data", "cmake"]
+    - os: linux
+      env:
+        - COMPILER=g++-8
+      addons:
+        apt:
+          sources: ['ubuntu-toolchain-r-test']
+          packages: ["g++-8", "cmake-data", "cmake"]
+    - os: linux
+      env:
+        - COMPILER=g++-9
+      addons:
+        apt:
+          sources: ['ubuntu-toolchain-r-test']
+          packages: ["g++-9", "cmake-data", "cmake"]
+    - os: linux
+      env:
+        - COMPILER=g++-9 USE_BOOST_REGEX=ON
+      addons:
+        apt:
+          sources: ['ubuntu-toolchain-r-test']
+          packages: ["g++-9", "cmake-data", "cmake", "libboost-regex-dev"]
+
+    - os: linux
+      env:
+        - COMPILER=clang++-3.6 STDLIB=libc++
+      addons:
+        apt:
+          sources: ['ubuntu-toolchain-r-test', 'llvm-toolchain-precise-3.6', 'george-edison55-precise-backports']
+          packages: ["clang-3.6", "cmake-data", "cmake"]
+
+    - os: linux
+      env:
+        - COMPILER=clang++-8 STDLIB=libc++
+      addons:
+        apt:
+          sources: ['ubuntu-toolchain-r-test', 'llvm-toolchain-trusty-8']
+          packages: ["clang-8", "cmake-data", "cmake"]
+
+    - os: osx
+      osx_image: xcode9.4
+      env:
+        - COMPILER=clang++ V='Apple LLVM 9.1'
+        - COMPILER=clang++ V='Apple LLVM 9.1' WITH_CPP14=true
+
+    - os: osx
+      osx_image: xcode10.3
+      env:
+        - COMPILER=clang++ V='Apple LLVM 10.0'
+        - COMPILER=clang++ V='Apple LLVM 10.0' WITH_CPP14=true
+    - os: osx
+      osx_image: xcode11.2
+      env:
+        - COMPILER=clang++ V='Apple LLVM 11.0'
+        - COMPILER=clang++ V='Apple LLVM 11.0' WITH_CPP14=true
+    - os: osx
+      osx_image: xcode11.2
+      env:
+        - COMPILER=clang++ V='Apple LLVM 11.0'
+        - COMPILER=clang++ V='Apple LLVM 11.0' WITH_CPP17=true
+
+before_install:
+  - CMAKE_CXX_FLAGS+=" -Wall"
+  - |
+    if [[ "${WITH_CPP14}" == "true" ]]; then
+        CMAKE_OPTIONS+=" -DCMAKE_CXX_STANDARD=14"
+    fi
+  - |
+    if [[ "${WITH_CPP17}" == "true" ]]; then
+        CMAKE_OPTIONS+=" -DCMAKE_CXX_STANDARD=17"
+    fi
+  - |
+    if [[ "${USE_BOOST_REGEX}" == "ON" ]]; then
+        CMAKE_OPTIONS+=" -DUSE_BOOST_REGEX=ON"
+        CMAKE_OPTIONS+=" -DBoost_REGEX_LIBRARY_DEBUG=/usr/lib/x86_64-linux-gnu/libboost_regex.so"
+        CMAKE_OPTIONS+=" -DBoost_REGEX_LIBRARY_RELEASE=/usr/lib/x86_64-linux-gnu/libboost_regex.so"
+    fi
+  - |
+    if [[ "${STDLIB}" == "libc++" ]]; then
+        CMAKE_CXX_FLAGS+=" -stdlib=libc++"
+    fi
+  - ${COMPILER} --version
+
+before_script:
+  - rm -rf build/
+  - mkdir build
+  - cd build
+  - cmake -DCMAKE_CXX_COMPILER=${COMPILER} -DCMAKE_CXX_FLAGS=${CMAKE_CXX_FLAGS} -DWITH_TESTS=1 -DWITH_EXAMPLE=1 ${CMAKE_OPTIONS} ..
+
+script:
+  - cmake --build .
+  - python run_tests

package/deps/couchbase-cxx-client/third_party/docopt/CMakeLists.txt

@@ -0,0 +1,129 @@
+cmake_minimum_required(VERSION 3.1)
+project(docopt.cpp VERSION 0.6.2)
+
+include(GNUInstallDirs)
+
+#============================================================================
+# Settable options
+#============================================================================
+option(WITH_TESTS "Build tests." OFF)
+option(WITH_EXAMPLE "Build example." OFF)
+option(USE_BOOST_REGEX "Replace std::regex with Boost.Regex" OFF)
+
+#============================================================================
+# Internal compiler options
+#============================================================================
+# C++ standard
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
+set(CMAKE_CXX_EXTENSIONS OFF)
+if(NOT CMAKE_CXX_STANDARD OR CMAKE_CXX_STANDARD LESS 11)
+	set(CMAKE_CXX_STANDARD 11)
+endif()
+
+#============================================================================
+# Sources & headers
+#============================================================================
+set(docopt_SOURCES docopt.cpp)
+set(docopt_HEADERS
+		docopt.h
+		docopt_private.h
+		docopt_util.h
+		docopt_value.h
+		)
+
+#============================================================================
+# Compile targets
+#============================================================================
+add_library(docopt ${docopt_SOURCES} ${docopt_HEADERS})
+set_target_properties(docopt PROPERTIES
+  VERSION ${PROJECT_VERSION}
+  SOVERSION ${PROJECT_VERSION_MAJOR}
+)
+
+target_include_directories(docopt PUBLIC $<BUILD_INTERFACE:${PROJECT_SOURCE_DIR}> $<INSTALL_INTERFACE:include/docopt>)
+
+if(MSVC AND BUILD_SHARED_LIBS)
+    # DOCOPT_DLL: Must be specified when building *and* when using the DLL.
+    #             That's what the "PUBLIC" means.
+    # DOCOPT_EXPORTS: Must use __declspec(dllexport) when building the DLL.
+    #                 "PRIVATE" means it's only defined when building the DLL.
+    target_compile_definitions(docopt PUBLIC  DOCOPT_DLL
+                                      PRIVATE DOCOPT_EXPORTS)
+endif()
+
+if(USE_BOOST_REGEX)
+	add_definitions("-DDOCTOPT_USE_BOOST_REGEX")
+	# This is needed on Linux, where linking a static library into docopt.so
+	# fails because boost static libs are not compiled with -fPIC
+	set(Boost_USE_STATIC_LIBS OFF)
+    find_package(Boost 1.53 REQUIRED COMPONENTS regex)
+    include_directories(${Boost_INCLUDE_DIRS})
+    target_link_libraries(docopt ${Boost_LIBRARIES})
+endif()
+
+#============================================================================
+# Examples
+#============================================================================
+if(WITH_EXAMPLE)
+	add_executable(docopt_example examples/naval_fate.cpp)
+	target_link_libraries(docopt_example docopt)
+endif()
+
+#============================================================================
+# Tests
+#============================================================================
+if(WITH_TESTS)
+	set(TESTPROG "${CMAKE_CURRENT_BINARY_DIR}/run_testcase")
+	set(TESTCASES "${PROJECT_SOURCE_DIR}/testcases.docopt")
+	add_executable(run_testcase run_testcase.cpp)
+	target_link_libraries(run_testcase docopt)
+	configure_file(
+			"${PROJECT_SOURCE_DIR}/run_tests.py"
+			"${CMAKE_CURRENT_BINARY_DIR}/run_tests"
+			ESCAPE_QUOTES
+	)
+	add_test("Testcases docopt" ${TESTPROG})
+endif()
+
+#============================================================================
+# Install
+#============================================================================
+set(export_name "docopt-targets")
+
+# Runtime package
+install(TARGETS docopt EXPORT ${export_name}
+	RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
+	ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
+	LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR})
+
+# Development package
+install(FILES ${docopt_HEADERS} DESTINATION include/docopt)
+
+# CMake Package
+include(CMakePackageConfigHelpers)
+write_basic_package_version_file("${PROJECT_BINARY_DIR}/docopt-config-version.cmake" COMPATIBILITY SameMajorVersion)
+install(FILES docopt-config.cmake ${PROJECT_BINARY_DIR}/docopt-config-version.cmake DESTINATION "${CMAKE_INSTALL_LIBDIR}/cmake/docopt")
+install(EXPORT ${export_name} DESTINATION "${CMAKE_INSTALL_LIBDIR}/cmake/docopt")
+
+configure_file(${CMAKE_CURRENT_SOURCE_DIR}/docopt.pc.in ${CMAKE_CURRENT_BINARY_DIR}/docopt.pc @ONLY)
+install(FILES ${CMAKE_CURRENT_BINARY_DIR}/docopt.pc DESTINATION ${CMAKE_INSTALL_LIBDIR}/pkgconfig)
+
+#============================================================================
+# CPack
+#============================================================================
+set(CPACK_PACKAGE_NAME "docopt")
+set(CPACK_DEBIAN_PACKAGE_DEPENDS "")
+set(CPACK_RPM_PACKAGE_REQUIRES "")
+set(CPACK_PACKAGE_DESCRIPTION_SUMMARY "Beautiful command line interfaces")
+set(CPACK_PACKAGE_VENDOR "Jared Grubb")
+set(CPACK_PACKAGE_CONTACT ${CPACK_PACKAGE_VENDOR})
+set(CPACK_PACKAGE_DESCRIPTION_FILE "${PROJECT_SOURCE_DIR}/README.rst")
+set(CPACK_RESOURCE_FILE_LICENSE "${PROJECT_SOURCE_DIR}/LICENSE-MIT")
+set(CPACK_PACKAGE_VERSION_MAJOR ${PROJECT_VERSION_MAJOR})
+set(CPACK_PACKAGE_VERSION_MINOR ${PROJECT_VERSION_MINOR})
+set(CPACK_PACKAGE_VERSION_PATCH ${PROJECT_VERSION_PATCH})
+set(CPACK_DEBIAN_PACKAGE_SECTION "Development")
+set(CPACK_RPM_PACKAGE_GROUP "Development/Libraries")
+set(CPACK_RPM_PACKAGE_LICENSE "MIT")
+set(CPACK_STRIP_FILES TRUE)
+include(CPack)