RubyGems - couchbase - Versions diffs - 3.0.0.alpha.3-universal-darwin-19 → 3.0.1-universal-darwin-19 - Mend

couchbase 3.0.0.alpha.3-universal-darwin-19 → 3.0.1-universal-darwin-19

Files changed (1684) hide show

data/ext/third_party/gsl/tests/utils_tests.cpp DELETED

@@ -1,129 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////
-//
-// Copyright (c) 2015 Microsoft Corporation. All rights reserved.
-//
-// This code is licensed under the MIT License (MIT).
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-// THE SOFTWARE.
-//
-///////////////////////////////////////////////////////////////////////////////
-#include <gtest/gtest.h>
-#include <gsl/gsl_util> // for narrow, finally, narrow_cast, narrowing_e...
-#include <algorithm>   // for move
-#include <functional>  // for reference_wrapper, _Bind_helper<>::type
-#include <limits>      // for numeric_limits
-#include <stdint.h>    // for uint32_t, int32_t
-#include <type_traits> // for is_same
-#include <cstddef>     // for std::ptrdiff_t
-using namespace gsl;
-namespace
-{
-void f(int& i) { i += 1; }
-static int j = 0;
-void g() { j += 1; }
-}
-TEST(utils_tests, sanity_check_for_gsl_index_typedef)
-{
-    static_assert(std::is_same<gsl::index, std::ptrdiff_t>::value,
-                  "gsl::index represents wrong arithmetic type");
-}
-TEST(utils_tests, finally_lambda)
-{
-    int i = 0;
-    {
-        auto _ = finally([&]() { f(i); });
-        EXPECT_TRUE(i == 0);
-    }
-    EXPECT_TRUE(i == 1);
-}
-TEST(utils_tests, finally_lambda_move)
-{
-    int i = 0;
-    {
-        auto _1 = finally([&]() { f(i); });
-        {
-            auto _2 = std::move(_1);
-            EXPECT_TRUE(i == 0);
-        }
-        EXPECT_TRUE(i == 1);
-        {
-            auto _2 = std::move(_1);
-            EXPECT_TRUE(i == 1);
-        }
-        EXPECT_TRUE(i == 1);
-    }
-    EXPECT_TRUE(i == 1);
-}
-TEST(utils_tests, finally_function_with_bind)
-{
-    int i = 0;
-    {
-        auto _ = finally(std::bind(&f, std::ref(i)));
-        EXPECT_TRUE(i == 0);
-    }
-    EXPECT_TRUE(i == 1);
-}
-TEST(utils_tests, finally_function_ptr)
-{
-    j = 0;
-    {
-        auto _ = finally(&g);
-        EXPECT_TRUE(j == 0);
-    }
-    EXPECT_TRUE(j == 1);
-}
-TEST(utils_tests, narrow_cast)
-{
-    int n = 120;
-    char c = narrow_cast<char>(n);
-    EXPECT_TRUE(c == 120);
-    n = 300;
-    unsigned char uc = narrow_cast<unsigned char>(n);
-    EXPECT_TRUE(uc == 44);
-}
-TEST(utils_tests, narrow)
-{
-    int n = 120;
-    const char c = narrow<char>(n);
-    EXPECT_TRUE(c == 120);
-    n = 300;
-    EXPECT_THROW(narrow<char>(n), narrowing_error);
-    const auto int32_max = std::numeric_limits<int32_t>::max();
-    const auto int32_min = std::numeric_limits<int32_t>::min();
-    EXPECT_TRUE(narrow<uint32_t>(int32_t(0)) == 0);
-    EXPECT_TRUE(narrow<uint32_t>(int32_t(1)) == 1);
-    EXPECT_TRUE(narrow<uint32_t>(int32_max) == static_cast<uint32_t>(int32_max));
-    EXPECT_THROW(narrow<uint32_t>(int32_t(-1)), narrowing_error);
-    EXPECT_THROW(narrow<uint32_t>(int32_min), narrowing_error);
-    n = -42;
-    EXPECT_THROW(narrow<unsigned>(n), narrowing_error);
-#if GSL_CONSTEXPR_NARROW
-    static_assert(narrow<char>(120) == 120, "Fix GSL_CONSTEXPR_NARROW");
-#endif
-}

data/ext/third_party/http_parser/.gitignore DELETED

@@ -1,30 +0,0 @@
-/out/
-core
-tags
-*.o
-test
-test_g
-test_fast
-bench
-url_parser
-parsertrace
-parsertrace_g
-*.mk
-*.Makefile
-*.so.*
-*.exe.*
-*.exe
-*.a
-# Visual Studio uglies
-*.suo
-*.sln
-*.vcxproj
-*.vcxproj.filters
-*.vcxproj.user
-*.opensdf
-*.ncrunchsolution*
-*.sdf
-*.vsp
-*.psess

data/ext/third_party/http_parser/.mailmap DELETED

@@ -1,8 +0,0 @@
-# update AUTHORS with:
-#   git log --all --reverse --format='%aN <%aE>' | perl -ne 'BEGIN{print "# Authors ordered by first contribution.\n"} print unless $h{$_}; $h{$_} = 1' > AUTHORS
-Ryan Dahl <ry@tinyclouds.org>
-Salman Haq <salman.haq@asti-usa.com>
-Simon Zimmermann <simonz05@gmail.com>
-Thomas LE ROUX <thomas@november-eleven.fr> LE ROUX Thomas <thomas@procheo.fr>
-Thomas LE ROUX <thomas@november-eleven.fr> Thomas LE ROUX <thomas@procheo.fr>
-Fedor Indutny <fedor@indutny.com>

data/ext/third_party/http_parser/.travis.yml DELETED

@@ -1,13 +0,0 @@
-language: c
-compiler:
-  - clang
-  - gcc
-script:
-  - "make"
-notifications:
-  email: false
-  irc:
-    - "irc.freenode.net#node-ci"

data/ext/third_party/http_parser/AUTHORS DELETED

@@ -1,68 +0,0 @@
-# Authors ordered by first contribution.
-Ryan Dahl <ry@tinyclouds.org>
-Jeremy Hinegardner <jeremy@hinegardner.org>
-Sergey Shepelev <temotor@gmail.com>
-Joe Damato <ice799@gmail.com>
-tomika <tomika_nospam@freemail.hu>
-Phoenix Sol <phoenix@burninglabs.com>
-Cliff Frey <cliff@meraki.com>
-Ewen Cheslack-Postava <ewencp@cs.stanford.edu>
-Santiago Gala <sgala@apache.org>
-Tim Becker <tim.becker@syngenio.de>
-Jeff Terrace <jterrace@gmail.com>
-Ben Noordhuis <info@bnoordhuis.nl>
-Nathan Rajlich <nathan@tootallnate.net>
-Mark Nottingham <mnot@mnot.net>
-Aman Gupta <aman@tmm1.net>
-Tim Becker <tim.becker@kuriositaet.de>
-Sean Cunningham <sean.cunningham@mandiant.com>
-Peter Griess <pg@std.in>
-Salman Haq <salman.haq@asti-usa.com>
-Cliff Frey <clifffrey@gmail.com>
-Jon Kolb <jon@b0g.us>
-Fouad Mardini <f.mardini@gmail.com>
-Paul Querna <pquerna@apache.org>
-Felix Geisendörfer <felix@debuggable.com>
-koichik <koichik@improvement.jp>
-Andre Caron <andre.l.caron@gmail.com>
-Ivo Raisr <ivosh@ivosh.net>
-James McLaughlin <jamie@lacewing-project.org>
-David Gwynne <loki@animata.net>
-Thomas LE ROUX <thomas@november-eleven.fr>
-Randy Rizun <rrizun@ortivawireless.com>
-Andre Louis Caron <andre.louis.caron@usherbrooke.ca>
-Simon Zimmermann <simonz05@gmail.com>
-Erik Dubbelboer <erik@dubbelboer.com>
-Martell Malone <martellmalone@gmail.com>
-Bertrand Paquet <bpaquet@octo.com>
-BogDan Vatra <bogdan@kde.org>
-Peter Faiman <peter@thepicard.org>
-Corey Richardson <corey@octayn.net>
-Tóth Tamás <tomika_nospam@freemail.hu>
-Cam Swords <cam.swords@gmail.com>
-Chris Dickinson <christopher.s.dickinson@gmail.com>
-Uli Köhler <ukoehler@btronik.de>
-Charlie Somerville <charlie@charliesomerville.com>
-Patrik Stutz <patrik.stutz@gmail.com>
-Fedor Indutny <fedor.indutny@gmail.com>
-runner <runner.mei@gmail.com>
-Alexis Campailla <alexis@janeasystems.com>
-David Wragg <david@wragg.org>
-Vinnie Falco <vinnie.falco@gmail.com>
-Alex Butum <alexbutum@linux.com>
-Rex Feng <rexfeng@gmail.com>
-Alex Kocharin <alex@kocharin.ru>
-Mark Koopman <markmontymark@yahoo.com>
-Helge Heß <me@helgehess.eu>
-Alexis La Goutte <alexis.lagoutte@gmail.com>
-George Miroshnykov <george.miroshnykov@gmail.com>
-Maciej Małecki <me@mmalecki.com>
-Marc O'Morain <github.com@marcomorain.com>
-Jeff Pinner <jpinner@twitter.com>
-Timothy J Fontaine <tjfontaine@gmail.com>
-Akagi201 <akagi201@gmail.com>
-Romain Giraud <giraud.romain@gmail.com>
-Jay Satiro <raysatiro@yahoo.com>
-Arne Steen <Arne.Steen@gmx.de>
-Kjell Schubert <kjell.schubert@gmail.com>
-Olivier Mengué <dolmen@cpan.org>

data/ext/third_party/http_parser/README.md DELETED

@@ -1,246 +0,0 @@
-HTTP Parser
-===========
-[![Build Status](https://api.travis-ci.org/nodejs/http-parser.svg?branch=master)](https://travis-ci.org/nodejs/http-parser)
-This is a parser for HTTP messages written in C. It parses both requests and
-responses. The parser is designed to be used in performance HTTP
-applications. It does not make any syscalls nor allocations, it does not
-buffer data, it can be interrupted at anytime. Depending on your
-architecture, it only requires about 40 bytes of data per message
-stream (in a web server that is per connection).
-Features:
-  * No dependencies
-  * Handles persistent streams (keep-alive).
-  * Decodes chunked encoding.
-  * Upgrade support
-  * Defends against buffer overflow attacks.
-The parser extracts the following information from HTTP messages:
-  * Header fields and values
-  * Content-Length
-  * Request method
-  * Response status code
-  * Transfer-Encoding
-  * HTTP version
-  * Request URL
-  * Message body
-Usage
------
-One `http_parser` object is used per TCP connection. Initialize the struct
-using `http_parser_init()` and set the callbacks. That might look something
-like this for a request parser:
-```c
-http_parser_settings settings;
-settings.on_url = my_url_callback;
-settings.on_header_field = my_header_field_callback;
-/* ... */
-http_parser *parser = malloc(sizeof(http_parser));
-http_parser_init(parser, HTTP_REQUEST);
-parser->data = my_socket;
-```
-When data is received on the socket execute the parser and check for errors.
-```c
-size_t len = 80*1024, nparsed;
-char buf[len];
-ssize_t recved;
-recved = recv(fd, buf, len, 0);
-if (recved < 0) {
-  /* Handle error. */
-}
-/* Start up / continue the parser.
- * Note we pass recved==0 to signal that EOF has been received.
- */
-nparsed = http_parser_execute(parser, &settings, buf, recved);
-if (parser->upgrade) {
-  /* handle new protocol */
-} else if (nparsed != recved) {
-  /* Handle error. Usually just close the connection. */
-}
-```
-`http_parser` needs to know where the end of the stream is. For example, sometimes
-servers send responses without Content-Length and expect the client to
-consume input (for the body) until EOF. To tell `http_parser` about EOF, give
-`0` as the fourth parameter to `http_parser_execute()`. Callbacks and errors
-can still be encountered during an EOF, so one must still be prepared
-to receive them.
-Scalar valued message information such as `status_code`, `method`, and the
-HTTP version are stored in the parser structure. This data is only
-temporally stored in `http_parser` and gets reset on each new message. If
-this information is needed later, copy it out of the structure during the
-`headers_complete` callback.
-The parser decodes the transfer-encoding for both requests and responses
-transparently. That is, a chunked encoding is decoded before being sent to
-the on_body callback.
-The Special Problem of Upgrade
-------------------------------
-`http_parser` supports upgrading the connection to a different protocol. An
-increasingly common example of this is the WebSocket protocol which sends
-a request like
-        GET /demo HTTP/1.1
-        Upgrade: WebSocket
-        Connection: Upgrade
-        Host: example.com
-        Origin: http://example.com
-        WebSocket-Protocol: sample
-followed by non-HTTP data.
-(See [RFC6455](https://tools.ietf.org/html/rfc6455) for more information the
-WebSocket protocol.)
-To support this, the parser will treat this as a normal HTTP message without a
-body, issuing both on_headers_complete and on_message_complete callbacks. However
-http_parser_execute() will stop parsing at the end of the headers and return.
-The user is expected to check if `parser->upgrade` has been set to 1 after
-`http_parser_execute()` returns. Non-HTTP data begins at the buffer supplied
-offset by the return value of `http_parser_execute()`.
-Callbacks
----------
-During the `http_parser_execute()` call, the callbacks set in
-`http_parser_settings` will be executed. The parser maintains state and
-never looks behind, so buffering the data is not necessary. If you need to
-save certain data for later usage, you can do that from the callbacks.
-There are two types of callbacks:
-* notification `typedef int (*http_cb) (http_parser*);`
-    Callbacks: on_message_begin, on_headers_complete, on_message_complete.
-* data `typedef int (*http_data_cb) (http_parser*, const char *at, size_t length);`
-    Callbacks: (requests only) on_url,
-               (common) on_header_field, on_header_value, on_body;
-Callbacks must return 0 on success. Returning a non-zero value indicates
-error to the parser, making it exit immediately.
-For cases where it is necessary to pass local information to/from a callback,
-the `http_parser` object's `data` field can be used.
-An example of such a case is when using threads to handle a socket connection,
-parse a request, and then give a response over that socket. By instantiation
-of a thread-local struct containing relevant data (e.g. accepted socket,
-allocated memory for callbacks to write into, etc), a parser's callbacks are
-able to communicate data between the scope of the thread and the scope of the
-callback in a threadsafe manner. This allows `http_parser` to be used in
-multi-threaded contexts.
-Example:
-```c
- typedef struct {
-  socket_t sock;
-  void* buffer;
-  int buf_len;
- } custom_data_t;
-int my_url_callback(http_parser* parser, const char *at, size_t length) {
-  /* access to thread local custom_data_t struct.
-  Use this access save parsed data for later use into thread local
-  buffer, or communicate over socket
-  */
-  parser->data;
-  ...
-  return 0;
-}
-...
-void http_parser_thread(socket_t sock) {
- int nparsed = 0;
- /* allocate memory for user data */
- custom_data_t *my_data = malloc(sizeof(custom_data_t));
- /* some information for use by callbacks.
- * achieves thread -> callback information flow */
- my_data->sock = sock;
- /* instantiate a thread-local parser */
- http_parser *parser = malloc(sizeof(http_parser));
- http_parser_init(parser, HTTP_REQUEST); /* initialise parser */
- /* this custom data reference is accessible through the reference to the
- parser supplied to callback functions */
- parser->data = my_data;
- http_parser_settings settings; /* set up callbacks */
- settings.on_url = my_url_callback;
- /* execute parser */
- nparsed = http_parser_execute(parser, &settings, buf, recved);
- ...
- /* parsed information copied from callback.
- can now perform action on data copied into thread-local memory from callbacks.
- achieves callback -> thread information flow */
- my_data->buffer;
- ...
-}
-```
-In case you parse HTTP message in chunks (i.e. `read()` request line
-from socket, parse, read half headers, parse, etc) your data callbacks
-may be called more than once. `http_parser` guarantees that data pointer is only
-valid for the lifetime of callback. You can also `read()` into a heap allocated
-buffer to avoid copying memory around if this fits your application.
-Reading headers may be a tricky task if you read/parse headers partially.
-Basically, you need to remember whether last header callback was field or value
-and apply the following logic:
-    (on_header_field and on_header_value shortened to on_h_*)
-     ------------------------ ------------ --------------------------------------------
-    | State (prev. callback) | Callback   | Description/action                         |
-     ------------------------ ------------ --------------------------------------------
-    | nothing (first call)   | on_h_field | Allocate new buffer and copy callback data |
-    |                        |            | into it                                    |
-     ------------------------ ------------ --------------------------------------------
-    | value                  | on_h_field | New header started.                        |
-    |                        |            | Copy current name,value buffers to headers |
-    |                        |            | list and allocate new buffer for new name  |
-     ------------------------ ------------ --------------------------------------------
-    | field                  | on_h_field | Previous name continues. Reallocate name   |
-    |                        |            | buffer and append callback data to it      |
-     ------------------------ ------------ --------------------------------------------
-    | field                  | on_h_value | Value for current header started. Allocate |
-    |                        |            | new buffer and copy callback data to it    |
-     ------------------------ ------------ --------------------------------------------
-    | value                  | on_h_value | Value continues. Reallocate value buffer   |
-    |                        |            | and append callback data to it             |
-     ------------------------ ------------ --------------------------------------------
-Parsing URLs
-------------
-A simplistic zero-copy URL parser is provided as `http_parser_parse_url()`.
-Users of this library may wish to use it to parse URLs constructed from
-consecutive `on_url` callbacks.
-See examples of reading in headers:
-* [partial example](http://gist.github.com/155877) in C
-* [from http-parser tests](http://github.com/joyent/http-parser/blob/37a0ff8/test.c#L403) in C
-* [from Node library](http://github.com/joyent/node/blob/842eaf4/src/http.js#L284) in Javascript