From bb18b29e07b22c1370ea2c8eeafd9ee9209b490c Mon Sep 17 00:00:00 2001
From: Davide Di Carlo <daddinuz@gmail.com>
Date: Wed, 1 Aug 2018 17:30:30 +0200
Subject: [PATCH] 0.3.0

---
 .gitignore                              |    3 +
 CMakeLists.txt                          |   52 +-
 LICENSE                                 |   35 +-
 README.md                               |   36 +-
 bench.log                               |   60 -
 bench.py                                |   14 -
 bench.sh                                |   16 -
 deps/alligator/alligator.c              |   58 +
 deps/alligator/alligator.h              |   69 +
 deps/alligator/alligator_config.h       |   70 +
 deps/alligator/build.cmake              |    7 +
 deps/alligator/package.json             |   23 +
 deps/atom/atom.c                        |  208 +++
 deps/atom/atom.h                        |  117 ++
 deps/atom/build.cmake                   |    2 +
 deps/atom/package.json                  |   25 +
 deps/error/build.cmake                  |    6 +
 deps/error/error.c                      |   38 +
 deps/error/error.h                      |   98 ++
 deps/error/package.json                 |   16 +
 deps/option/build.cmake                 |    7 +
 deps/option/option.c                    |   65 +
 deps/option/option.h                    |  144 ++
 deps/option/package.json                |   19 +
 deps/panic/build.cmake                  |    6 +
 deps/panic/package.json                 |   19 +
 deps/panic/panic.c                      |   65 +
 deps/panic/panic.h                      |   87 +
 deps/text/build.cmake                   |    7 +
 deps/text/package.json                  |   23 +
 deps/text/text.c                        |  544 ++++++
 deps/text/text.h                        |  590 +++++++
 deps/text/text_config.h                 |   40 +
 deps/traits-unit/build.cmake            |    6 +
 deps/traits-unit/package.json           |   24 +
 deps/traits-unit/traits-unit.c          |  597 +++++++
 deps/traits-unit/traits-unit.h          |  200 +++
 deps/traits/package.json                |   15 +
 deps/traits/traits.h                    |  264 +++
 examples/bench.c                        |   45 -
 examples/build.cmake                    |    2 +
 examples/example.c                      |  144 --
 examples/main.c                         |  105 ++
 ext/parson/README.md                    |  145 --
 ext/parson/parson.c                     | 2007 -----------------------
 ext/parson/parson.cmake                 |    6 -
 ext/parson/parson.h                     |  234 ---
 ext/picohttpparser/README.md            |  116 --
 ext/picohttpparser/picohttpparser.c     |  620 -------
 ext/picohttpparser/picohttpparser.cmake |    6 -
 ext/picohttpparser/picohttpparser.h     |   89 -
 ext/sds/LICENSE                         |   24 -
 ext/sds/README.md                       |  892 ----------
 ext/sds/sds.c                           | 1264 --------------
 ext/sds/sds.cmake                       |    6 -
 ext/sds/sds.h                           |  264 ---
 ext/sds/sdsalloc.h                      |   41 -
 http.cmake                              |    7 -
 include/http/http.h                     |   45 -
 include/http/http_method.h              |   56 -
 include/http/http_request.h             |   58 -
 include/http/http_response.h            |   44 -
 include/http/http_status.h              |   82 -
 package.json                            |   42 +-
 sources/build.cmake                     |   10 +
 sources/http.c                          |  220 +++
 sources/http.h                          |   77 +
 sources/http_error.c                    |   38 +
 sources/http_error.h                    |   52 +
 sources/http_fire_result.c              |   65 +
 sources/http_fire_result.h              |  114 ++
 sources/http_maybe_text.c               |   47 +
 sources/http_maybe_text.h               |   78 +
 sources/http_method.c                   |  116 ++
 sources/http_method.h                   |   80 +
 sources/http_request.c                  |  210 +++
 sources/http_request.h                  |  291 ++++
 sources/http_response.c                 |  164 ++
 sources/http_response.h                 |  211 +++
 sources/http_status.c                   |  215 +++
 sources/http_status.h                   |  113 ++
 src/http.c                              |  266 ---
 src/http_request.c                      |   38 -
 src/http_response.c                     |   19 -
 tests/unit/build.cmake                  |   14 +
 tests/unit/describe.c                   |   40 +
 tests/unit/features/http_fire_result.c  |   98 ++
 tests/unit/features/http_fire_result.h  |   42 +
 tests/unit/features/http_maybe_text.c   |   48 +
 tests/unit/features/http_maybe_text.h   |   41 +
 tests/unit/fixtures.c                   |   42 +
 tests/unit/fixtures.h                   |   41 +
 valgrind.sh                             |    4 +
 93 files changed, 6143 insertions(+), 6670 deletions(-)
 delete mode 100644 bench.log
 delete mode 100644 bench.py
 delete mode 100755 bench.sh
 create mode 100644 deps/alligator/alligator.c
 create mode 100644 deps/alligator/alligator.h
 create mode 100644 deps/alligator/alligator_config.h
 create mode 100644 deps/alligator/build.cmake
 create mode 100644 deps/alligator/package.json
 create mode 100644 deps/atom/atom.c
 create mode 100644 deps/atom/atom.h
 create mode 100644 deps/atom/build.cmake
 create mode 100644 deps/atom/package.json
 create mode 100644 deps/error/build.cmake
 create mode 100644 deps/error/error.c
 create mode 100644 deps/error/error.h
 create mode 100644 deps/error/package.json
 create mode 100644 deps/option/build.cmake
 create mode 100644 deps/option/option.c
 create mode 100644 deps/option/option.h
 create mode 100644 deps/option/package.json
 create mode 100644 deps/panic/build.cmake
 create mode 100644 deps/panic/package.json
 create mode 100644 deps/panic/panic.c
 create mode 100644 deps/panic/panic.h
 create mode 100644 deps/text/build.cmake
 create mode 100644 deps/text/package.json
 create mode 100644 deps/text/text.c
 create mode 100644 deps/text/text.h
 create mode 100644 deps/text/text_config.h
 create mode 100644 deps/traits-unit/build.cmake
 create mode 100644 deps/traits-unit/package.json
 create mode 100644 deps/traits-unit/traits-unit.c
 create mode 100644 deps/traits-unit/traits-unit.h
 create mode 100644 deps/traits/package.json
 create mode 100644 deps/traits/traits.h
 delete mode 100644 examples/bench.c
 create mode 100644 examples/build.cmake
 delete mode 100644 examples/example.c
 create mode 100644 examples/main.c
 delete mode 100644 ext/parson/README.md
 delete mode 100644 ext/parson/parson.c
 delete mode 100644 ext/parson/parson.cmake
 delete mode 100644 ext/parson/parson.h
 delete mode 100644 ext/picohttpparser/README.md
 delete mode 100644 ext/picohttpparser/picohttpparser.c
 delete mode 100644 ext/picohttpparser/picohttpparser.cmake
 delete mode 100644 ext/picohttpparser/picohttpparser.h
 delete mode 100644 ext/sds/LICENSE
 delete mode 100644 ext/sds/README.md
 delete mode 100644 ext/sds/sds.c
 delete mode 100644 ext/sds/sds.cmake
 delete mode 100644 ext/sds/sds.h
 delete mode 100644 ext/sds/sdsalloc.h
 delete mode 100644 http.cmake
 delete mode 100644 include/http/http.h
 delete mode 100644 include/http/http_method.h
 delete mode 100644 include/http/http_request.h
 delete mode 100644 include/http/http_response.h
 delete mode 100644 include/http/http_status.h
 create mode 100644 sources/build.cmake
 create mode 100644 sources/http.c
 create mode 100644 sources/http.h
 create mode 100644 sources/http_error.c
 create mode 100644 sources/http_error.h
 create mode 100644 sources/http_fire_result.c
 create mode 100644 sources/http_fire_result.h
 create mode 100644 sources/http_maybe_text.c
 create mode 100644 sources/http_maybe_text.h
 create mode 100644 sources/http_method.c
 create mode 100644 sources/http_method.h
 create mode 100644 sources/http_request.c
 create mode 100644 sources/http_request.h
 create mode 100644 sources/http_response.c
 create mode 100644 sources/http_response.h
 create mode 100644 sources/http_status.c
 create mode 100644 sources/http_status.h
 delete mode 100644 src/http.c
 delete mode 100644 src/http_request.c
 delete mode 100644 src/http_response.c
 create mode 100644 tests/unit/build.cmake
 create mode 100644 tests/unit/describe.c
 create mode 100644 tests/unit/features/http_fire_result.c
 create mode 100644 tests/unit/features/http_fire_result.h
 create mode 100644 tests/unit/features/http_maybe_text.c
 create mode 100644 tests/unit/features/http_maybe_text.h
 create mode 100644 tests/unit/fixtures.c
 create mode 100644 tests/unit/fixtures.h
 create mode 100755 valgrind.sh

diff --git a/.gitignore b/.gitignore
index 0adcbb5..9ccbfbc 100644
--- a/.gitignore
+++ b/.gitignore
@@ -51,3 +51,6 @@ cmake-build-*/
 # IDEs and editors
 *.idea
 *.swp
+
+# log files
+*.log
diff --git a/CMakeLists.txt b/CMakeLists.txt
index bd72ce4..2f93345 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -1,37 +1,27 @@
-cmake_minimum_required(VERSION 3.1)
-project(http)
+cmake_minimum_required(VERSION 3.8)
+project(http C)
 
 set(CMAKE_C_STANDARD 99)
-set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wall -Wextra -Werror -pedantic")
-if ("${CMAKE_C_COMPILER_ID}" STREQUAL "GNU")
-    # using GCC
-    set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wcast-align -Wbad-function-cast")
-endif ()
+set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wall -Wextra -Werror")
 
-#####
-# Archive
-###
-include_directories(${PROJECT_SOURCE_DIR}/include/http)
-file(GLOB HEADER_FILES ${PROJECT_SOURCE_DIR}/include/http/*.h)
-file(GLOB SOURCE_FILES ${PROJECT_SOURCE_DIR}/src/*.c)
-add_library(${PROJECT_NAME} ${HEADER_FILES} ${SOURCE_FILES})
-target_link_libraries(${PROJECT_NAME} PRIVATE curl)
+# dependencies
+include_directories(deps)
+find_package(CURL)
+include(deps/atom/build.cmake)
+include(deps/text/build.cmake)
+include(deps/error/build.cmake)
+include(deps/panic/build.cmake)
+include(deps/option/build.cmake)
+include(deps/alligator/build.cmake)
+include(deps/traits-unit/build.cmake)
 
-#####
-# External
-###
-include(ext/sds/sds.cmake)
-include(ext/parson/parson.cmake)
-include(ext/picohttpparser/picohttpparser.cmake)
+# archive
+include_directories(sources)
+include(sources/build.cmake)
 
-#####
-# Examples
-###
-set(EXAMPLE_PATH ${PROJECT_SOURCE_DIR}/examples)
+# examples
+include(examples/build.cmake)
 
-add_executable(example ${EXAMPLE_PATH}/example.c)
-target_include_directories(example PRIVATE ${PROJECT_SOURCE_DIR}/ext)
-target_link_libraries(example PRIVATE ${PROJECT_NAME} sds parson picohttpparser)
-
-add_executable(bench ${EXAMPLE_PATH}/bench.c)
-target_link_libraries(bench PRIVATE ${PROJECT_NAME})
+# tests
+include_directories(tests)
+include(tests/unit/build.cmake)
diff --git a/LICENSE b/LICENSE
index 7de9ab0..ca48049 100644
--- a/LICENSE
+++ b/LICENSE
@@ -1,21 +1,24 @@
 The MIT License (MIT)
 
-Copyright (c) 2017-Present Davide Di Carlo
+Copyright (c) 2018 Davide Di Carlo
 
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
+Permission is hereby granted, free of charge, to any person
+obtaining a copy of this software and associated documentation
+files (the "Software"), to deal in the Software without
+restriction, including without limitation the rights to use,
+copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the
+Software is furnished to do so, subject to the following
+conditions:
 
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
 
-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.
+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.
diff --git a/README.md b/README.md
index 2b3d8f4..881c715 100644
--- a/README.md
+++ b/README.md
@@ -1,4 +1,34 @@
-# http
+http
+====
 
-HTTP requests made easier.  
-Depends on libcurl.
+Http requests made easier, depends on libcurl.
+
+```C
+#include <http.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+int main() {
+    Http_initialize();
+
+    Atom url = Atom_fromLiteral("https://api.github.com/repos/daddinuz/http/issues");
+    struct HttpRequestBuilder *requestBuilder = HttpRequestBuilder_new(HTTP_METHOD_GET, url);
+    HttpRequestBuilder_setTimeout(requestBuilder, 25);
+    HttpRequestBuilder_emplaceHeaders(requestBuilder,
+                                      "Authorization: token %s\n"
+                                      "Accept: application/vnd.github.VERSION.raw+json\n"
+                                      "Content-Type: application/json\n"
+                                      "User-Agent: daddinuz/http\n",
+                                      getenv("GITHUB_AUTH_TOKEN"));
+
+    const struct HttpRequest *request = HttpRequestBuilder_build(&requestBuilder);
+    printRequest(request);
+
+    const struct HttpResponse *response = Http_FireResult_unwrap(HttpRequest_fire(&request));
+    printResponse(response);
+
+    HttpResponse_delete(response);
+    Http_terminate();
+    return 0;
+}
+```
diff --git a/bench.log b/bench.log
deleted file mode 100644
index e1fff88..0000000
--- a/bench.log
+++ /dev/null
@@ -1,60 +0,0 @@
-====================
-Python
-real 0.77
-user 0.30
-sys 0.00
-
-C
-real 0.82
-user 0.13
-sys 0.03
-====================
-
-====================
-Python
-real 0.81
-user 0.24
-sys 0.04
-
-C
-real 0.79
-user 0.15
-sys 0.02
-====================
-
-====================
-Python
-real 0.81
-user 0.28
-sys 0.01
-
-C
-real 0.81
-user 0.14
-sys 0.03
-====================
-
-====================
-Python
-real 0.82
-user 0.29
-sys 0.00
-
-C
-real 0.80
-user 0.09
-sys 0.04
-====================
-
-====================
-Python
-real 0.83
-user 0.25
-sys 0.03
-
-C
-real 0.84
-user 0.15
-sys 0.01
-====================
-
diff --git a/bench.py b/bench.py
deleted file mode 100644
index f9e52ef..0000000
--- a/bench.py
+++ /dev/null
@@ -1,14 +0,0 @@
-import requests
-
-status = 0
-url = 'https://api.github.com/repos/daddinuz/http/issues'
-headers = {
-    'Accept': 'application/vnd.github.v3+json',
-    'Content-Type': 'application/json',
-    'User-Agent': 'daddinuz/http'
-}
-
-response = requests.get(url, headers=headers)
-status = response.status_code
-
-exit(not (200 == status))
diff --git a/bench.sh b/bench.sh
deleted file mode 100755
index 2364e1f..0000000
--- a/bench.sh
+++ /dev/null
@@ -1,16 +0,0 @@
-#!/usr/bin/env bash
-
-set -e
-
-x=1
-while [ ${x} -le 5 ]; do
-    echo -e "====================\nPython"
-    \time -p python3 bench.py 2>&1
-    echo
-
-    echo "C"
-    \time -p ./cmake-build-release/bench 2>&1
-    echo -e "====================\n"
-
-    x=$(( ${x} + 1 ))
-done
diff --git a/deps/alligator/alligator.c b/deps/alligator/alligator.c
new file mode 100644
index 0000000..9ece0f2
--- /dev/null
+++ b/deps/alligator/alligator.c
@@ -0,0 +1,58 @@
+/*
+ * Author: daddinuz
+ * email:  daddinuz@gmail.com
+ *
+ * Copyright (c) 2018 Davide Di Carlo
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * 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 "alligator.h"
+#include "alligator_config.h"
+
+#if (defined(__STDC_VERSION__) && __STDC_VERSION__ >= 201112L) || (defined(__cplusplus) && __cplusplus >= 201103L)
+
+Option Alligator_aligned_alloc(size_t alignment, size_t size) {
+    void *memory = __Alligator_aligned_alloc(alignment, size);
+    return memory ? Option_some(memory) : None;
+}
+
+#endif
+
+Option Alligator_malloc(const size_t size) {
+    void *memory = __Alligator_malloc(size);
+    return memory ? Option_some(memory) : None;
+}
+
+Option Alligator_calloc(const size_t numberOfMembers, const size_t memberSize) {
+    void *memory = __Alligator_calloc(numberOfMembers, memberSize);
+    return memory ? Option_some(memory) : None;
+}
+
+Option Alligator_realloc(void *ptr, size_t newSize) {
+    void *memory = __Alligator_realloc(ptr, newSize);
+    return memory ? Option_some(memory) : None;
+}
+
+void Alligator_free(void *ptr) {
+    __Alligator_free(ptr);
+}
diff --git a/deps/alligator/alligator.h b/deps/alligator/alligator.h
new file mode 100644
index 0000000..5603bf7
--- /dev/null
+++ b/deps/alligator/alligator.h
@@ -0,0 +1,69 @@
+/*
+ * Author: daddinuz
+ * email:  daddinuz@gmail.com
+ *
+ * Copyright (c) 2018 Davide Di Carlo
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * 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.
+ */
+
+#pragma once
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <stddef.h>
+#include <option/option.h>
+
+#if !(defined(__GNUC__) || defined(__clang__))
+#define __attribute__(...)
+#endif
+
+#define ALLIGATOR_VERSION_MAJOR       0
+#define ALLIGATOR_VERSION_MINOR       24
+#define ALLIGATOR_VERSION_PATCH       0
+#define ALLIGATOR_VERSION_SUFFIX      ""
+#define ALLIGATOR_VERSION_IS_RELEASE  0
+#define ALLIGATOR_VERSION_HEX         0x002400
+
+#if (defined(__STDC_VERSION__) && __STDC_VERSION__ >= 201112L) || (defined(__cplusplus) && __cplusplus >= 201103L)
+
+extern Option Alligator_aligned_alloc(size_t alignment, size_t size)
+__attribute__((__warn_unused_result__));
+
+#endif
+
+extern Option Alligator_malloc(size_t size)
+__attribute__((__warn_unused_result__));
+
+extern Option Alligator_calloc(size_t numberOfMembers, size_t memberSize)
+__attribute__((__warn_unused_result__));
+
+extern Option Alligator_realloc(void *ptr, size_t newSize)
+__attribute__((__warn_unused_result__));
+
+extern void Alligator_free(void *ptr);
+
+#ifdef __cplusplus
+}
+#endif
diff --git a/deps/alligator/alligator_config.h b/deps/alligator/alligator_config.h
new file mode 100644
index 0000000..f39081e
--- /dev/null
+++ b/deps/alligator/alligator_config.h
@@ -0,0 +1,70 @@
+/*
+ * Author: daddinuz
+ * email:  daddinuz@gmail.com
+ *
+ * Copyright (c) 2018 Davide Di Carlo
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * 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.
+ */
+
+/**
+* Underlying allocator configuration.
+*
+* Update this file is in order to change at compile time the allocator that alligator is going to use.
+* Just define the macros below to what you want to use and include the proper files.
+*
+* WARNING:
+*  The macros below are intended for internal use only, DO NOT INCLUDE THIS FILE directly in your code.
+*/
+
+#pragma once
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <stdlib.h>
+
+#if (defined(__STDC_VERSION__) && __STDC_VERSION__ >= 201112L) || (defined(__cplusplus) && __cplusplus >= 201103L)
+
+#include <stdalign.h>
+
+#define __Alligator_aligned_alloc(alignment, size) \
+    aligned_alloc((alignment), (size))
+
+#endif
+
+#define __Alligator_malloc(size) \
+    malloc((size))
+
+#define __Alligator_calloc(numberOfMembers, memberSize) \
+    calloc((numberOfMembers), (memberSize))
+
+#define __Alligator_realloc(ptr, newSize) \
+    realloc((ptr), (newSize))
+
+#define __Alligator_free(ptr) \
+    free((ptr))
+
+#ifdef __cplusplus
+}
+#endif
diff --git a/deps/alligator/build.cmake b/deps/alligator/build.cmake
new file mode 100644
index 0000000..eba1225
--- /dev/null
+++ b/deps/alligator/build.cmake
@@ -0,0 +1,7 @@
+set(ARCHIVE_NAME alligator)
+message("${ARCHIVE_NAME}@${CMAKE_CURRENT_LIST_DIR} using: ${CMAKE_CURRENT_LIST_FILE}")
+
+file(GLOB ARCHIVE_HEADERS ${CMAKE_CURRENT_LIST_DIR}/*.h)
+file(GLOB ARCHIVE_SOURCES ${CMAKE_CURRENT_LIST_DIR}/*.c)
+add_library(${ARCHIVE_NAME} ${ARCHIVE_HEADERS} ${ARCHIVE_SOURCES})
+target_link_libraries(${ARCHIVE_NAME} PUBLIC option)
diff --git a/deps/alligator/package.json b/deps/alligator/package.json
new file mode 100644
index 0000000..524b4c0
--- /dev/null
+++ b/deps/alligator/package.json
@@ -0,0 +1,23 @@
+{
+  "name": "alligator",
+  "repo": "daddinuz/alligator",
+  "version": "0.24.0",
+  "license": "MIT",
+  "description": "Alligator is a wrapper over stdlib allocator that will enforce out of memory conditions checking making code safer.",
+  "keywords": [
+    "allocator",
+    "memory",
+    "malloc",
+    "free",
+    "oom"
+  ],
+  "src": [
+    "sources/alligator_config.h",
+    "sources/alligator.h",
+    "sources/alligator.c"
+  ],
+  "dependencies": {
+    "daddinuz/option": "0.22.0"
+  },
+  "makefile": "sources/build.cmake"
+}
diff --git a/deps/atom/atom.c b/deps/atom/atom.c
new file mode 100644
index 0000000..23e0c04
--- /dev/null
+++ b/deps/atom/atom.c
@@ -0,0 +1,208 @@
+/*
+ * Author: daddinuz
+ * email:  daddinuz@gmail.com
+ *
+ * Copyright (c) 2018 Davide Di Carlo
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * 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 <stdio.h>
+#include <stdlib.h>
+#include <stdint.h>
+#include <string.h>
+#include <assert.h>
+#include <alligator/alligator.h>
+#include "atom.h"
+
+#define ATOM_TABLE_SIZE 2039
+
+struct Atom_Node {
+    struct Atom_Node *next;
+    size_t length;
+    uint32_t hash;
+    void *bytes;
+};
+
+static uint32_t
+Atom_hash(const void *bytes, size_t length)
+__attribute__((__warn_unused_result__, __nonnull__));
+
+static struct Atom_Node *
+Atom_put(const void *bytes, size_t length, uint32_t hash)
+__attribute__((__warn_unused_result__, __nonnull__));
+
+static struct Atom_Node *
+Atom_fetch(const void *bytes, size_t length, uint32_t hash)
+__attribute__((__warn_unused_result__, __nonnull__));
+
+static void
+Atom_onExit(void);
+
+static void
+Atom_assertValidInstance(Atom atom)
+__attribute__((__nonnull__));
+
+static bool initialized = false;
+static struct Atom_Node *table[ATOM_TABLE_SIZE] = {0};
+
+/*
+ *
+ */
+Atom Atom_fromBytes(const void *const bytes, const size_t length) {
+    assert(bytes);
+    assert(length < SIZE_MAX);
+    return Atom_put(bytes, length, Atom_hash(bytes, length))->bytes;
+}
+
+Atom Atom_fromLiteral(const char *const literal) {
+    assert(literal);
+    assert(strlen(literal) < SIZE_MAX);
+    return Atom_fromBytes(literal, strlen(literal));
+}
+
+Atom Atom_fromInteger(const long long number) {
+    char buffer[64] = {0};
+    const size_t bufferSize = sizeof(buffer) / sizeof(buffer[0]);
+    const int length = snprintf(buffer, bufferSize, "%lld", number);
+    assert(0 < length && length < (int) bufferSize);
+    return Atom_fromBytes(buffer, (size_t) length);
+}
+
+Atom Atom_fromFloating(const long double number) {
+    char buffer[64] = {0};
+    const size_t bufferSize = sizeof(buffer) / sizeof(buffer[0]);
+    const int length = snprintf(buffer, bufferSize, "%.8Lf", number);
+    assert(0 < length && length < (int) bufferSize);
+    return Atom_fromBytes(buffer, (size_t) length);
+}
+
+size_t Atom_length(Atom atom) {
+    assert(atom);
+    Atom_assertValidInstance(atom);
+    struct Atom_Node *node = ((struct Atom_Node *) atom) - 1;
+    return node->length;
+}
+
+bool Atom_equals(Atom atom, Atom other) {
+    assert(atom);
+    assert(other);
+    Atom_assertValidInstance(atom);
+    Atom_assertValidInstance(other);
+    return atom == other;
+}
+
+/*
+ *
+ */
+struct Atom_Node *Atom_Node_new(const void *const bytes, const size_t length, const uint32_t hash) {
+    assert(bytes);
+    assert(length < SIZE_MAX);
+    struct Atom_Node *self = Option_unwrap(Alligator_malloc(length + 1));
+    memcpy(self->bytes, bytes, length);
+    self->hash = hash;
+    self->length = length;
+    self->next = NULL;
+    return self;
+}
+
+uint32_t Atom_hash(const void *const bytes, const size_t length) {  /* Jenkins one at time */
+    size_t i = 0;
+    uint32_t hash = 0;
+    const uint8_t *key = bytes;
+    while (i != length) {
+        hash += key[i++];
+        hash += hash << 10;
+        hash ^= hash >> 6;
+    }
+    hash += hash << 3;
+    hash ^= hash >> 11;
+    hash += hash << 15;
+    return hash;
+}
+
+struct Atom_Node *Atom_put(const void *const bytes, const size_t length, const uint32_t hash) {
+    assert(bytes);
+    assert(length < SIZE_MAX);
+    struct Atom_Node *node;
+
+    if (!initialized) {
+        atexit(Atom_onExit);
+        initialized = true;
+    }
+
+    node = Atom_fetch(bytes, length, hash);
+    if (NULL == node) {
+        const size_t index = hash % ATOM_TABLE_SIZE;
+
+        node = Option_unwrap(Alligator_malloc(sizeof(*node) + length + 1));
+        node->next = table[index];
+        node->length = length;
+        node->hash = hash;
+        node->bytes = node + 1;
+
+        memcpy(node->bytes, bytes, length);
+        ((char *) node->bytes)[length] = 0;
+        table[index] = node;
+    }
+
+    return node;
+}
+
+struct Atom_Node *Atom_fetch(const void *const bytes, const size_t length, const uint32_t hash) {
+    assert(bytes);
+    assert(length < SIZE_MAX);
+    const size_t index = hash % ATOM_TABLE_SIZE;
+
+    for (struct Atom_Node *current = table[index]; NULL != current; current = current->next) {
+        if (length == current->length) {
+            if (0 == memcmp(bytes, current->bytes, length)) {
+                return current;
+            }
+        }
+    }
+
+    return NULL;
+}
+
+void Atom_onExit(void) {
+    struct Atom_Node *node;
+    for (size_t i = 0; i < ATOM_TABLE_SIZE; i++) {
+        node = table[i];
+        if (NULL != node) {
+            for (struct Atom_Node *prev = node; NULL != node; prev = node) {
+                node = node->next;
+                Alligator_free(prev);
+            }
+        }
+        table[i] = NULL;
+    }
+}
+
+void Atom_assertValidInstance(Atom atom) {
+    assert(atom);
+    (void) atom;
+#ifndef NDEBUG
+    struct Atom_Node *node = ((struct Atom_Node *) atom) - 1;
+    assert(NULL != Atom_fetch(node->bytes, node->length, node->hash));
+#endif
+}
diff --git a/deps/atom/atom.h b/deps/atom/atom.h
new file mode 100644
index 0000000..9584b7e
--- /dev/null
+++ b/deps/atom/atom.h
@@ -0,0 +1,117 @@
+/*
+ * Author: daddinuz
+ * email:  daddinuz@gmail.com
+ *
+ * Copyright (c) 2018 Davide Di Carlo
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * 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.
+ */
+
+#pragma once
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <stddef.h>
+#include <stdbool.h>
+
+#if !(defined(__GNUC__) || defined(__clang__))
+#define __attribute__(...)
+#endif
+
+#define ATOM_VERSION_MAJOR          0
+#define ATOM_VERSION_MINOR          1
+#define ATOM_VERSION_PATCH          0
+#define ATOM_VERSION_SUFFIX         ""
+#define ATOM_VERSION_IS_RELEASE     0
+#define ATOM_VERSION_HEX            0x000100
+
+/**
+ * Atoms are pointers to a unique, immutable, sequence of zero or more arbitrary bytes.
+ * There is only a single occurrence of any atom, which is why it’s called an atom.
+ * Two atoms are identical if they point to the same location.
+ * One of the advantages of atoms is that comparing two byte sequences for equality is performed by simply comparing pointers.
+ * Another advantage is that using atoms saves space because there’s only one occurrence of each sequence.
+ * Atoms are often used as keys in data structures that are indexed by sequences of arbitrary bytes instead of by integers.
+ */
+typedef const char *Atom;
+
+/**
+ * Gets the Atom instance or creates a new one if not exists from a sequence of bytes.
+ *
+ * @attention bytes must not be NULL.
+ * @attention length must be < SIZE_MAX.
+ */
+extern Atom
+Atom_fromBytes(const void *bytes, size_t length)
+__attribute__((__warn_unused_result__, __nonnull__));
+
+/**
+ * Gets the Atom instance or creates a new one if not exists from the given literal.
+ *
+ * @attention literal must not be NULL.
+ * @attention strlen(literal) must be < SIZE_MAX.
+ */
+extern Atom
+Atom_fromLiteral(const char *literal)
+__attribute__((__warn_unused_result__, __nonnull__));
+
+/**
+ * Gets the Atom instance or creates a new one if not exists from the given integer number.
+ */
+extern Atom
+Atom_fromInteger(long long number)
+__attribute__((__warn_unused_result__));
+
+/**
+ * Gets the Atom instance or creates a new one if not exists from the given floating number.
+ */
+extern Atom
+Atom_fromFloating(long double number)
+__attribute__((__warn_unused_result__));
+
+/**
+ * Gets the length of the atom.
+ *
+ * @attention atom must not be NULL and must be a valid Atom instance.
+ *
+ * @param atom The Atom instance.
+ * @return The length of the atom.
+ */
+extern size_t
+Atom_length(Atom atom)
+__attribute__((__warn_unused_result__, __nonnull__));
+
+/**
+ * Checks for equality.
+ *
+ * @attention atom must not be NULL.
+ * @attention other must not be NULL.
+ */
+extern bool
+Atom_equals(Atom atom, Atom other)
+__attribute__((__warn_unused_result__, __nonnull__));
+
+#ifdef __cplusplus
+}
+#endif
diff --git a/deps/atom/build.cmake b/deps/atom/build.cmake
new file mode 100644
index 0000000..958dbd0
--- /dev/null
+++ b/deps/atom/build.cmake
@@ -0,0 +1,2 @@
+add_library(atom ${CMAKE_CURRENT_LIST_DIR}/atom.h ${CMAKE_CURRENT_LIST_DIR}/atom.c)
+target_link_libraries(atom PRIVATE alligator)
diff --git a/deps/atom/package.json b/deps/atom/package.json
new file mode 100644
index 0000000..abf3128
--- /dev/null
+++ b/deps/atom/package.json
@@ -0,0 +1,25 @@
+{
+  "name": "atom",
+  "version": "0.1.0",
+  "repo": "daddinuz/atom",
+  "description": "Atoms are pointers to a unique, immutable, sequence of zero or more arbitrary bytes. There is only a single occurrence of any atom, which is why it’s called an atom. Two atoms are identical if they point to the same location. One of the advantages of atoms is that comparing two byte sequences for equality is performed by simply comparing pointers. Another advantage is that using atoms saves space because there’s only one occurrence of each sequence. Atoms are often used as keys in data structures that are indexed by sequences of arbitrary bytes instead of by integers.",
+  "keywords": [
+    "key",
+    "atom",
+    "symbol",
+    "intern"
+  ],
+  "license": "MIT",
+  "dependencies": {
+    "daddinuz/alligator": "0.24.0"
+  },
+  "src": [
+    "sources/atom.h",
+    "sources/atom.c"
+  ],
+  "makefile": "sources/build.cmake",
+  "development": {
+    "daddinuz/traits": "3.2.0",
+    "daddinuz/traits-unit": "3.0.0"
+  }
+}
diff --git a/deps/error/build.cmake b/deps/error/build.cmake
new file mode 100644
index 0000000..6c6982a
--- /dev/null
+++ b/deps/error/build.cmake
@@ -0,0 +1,6 @@
+set(ARCHIVE_NAME error)
+message("${ARCHIVE_NAME}@${CMAKE_CURRENT_LIST_DIR} using: ${CMAKE_CURRENT_LIST_FILE}")
+
+file(GLOB ARCHIVE_HEADERS ${CMAKE_CURRENT_LIST_DIR}/*.h)
+file(GLOB ARCHIVE_SOURCES ${CMAKE_CURRENT_LIST_DIR}/*.c)
+add_library(${ARCHIVE_NAME} ${ARCHIVE_HEADERS} ${ARCHIVE_SOURCES})
diff --git a/deps/error/error.c b/deps/error/error.c
new file mode 100644
index 0000000..a951770
--- /dev/null
+++ b/deps/error/error.c
@@ -0,0 +1,38 @@
+/*
+ * Author: daddinuz
+ * email:  daddinuz@gmail.com
+ *
+ * Copyright (c) 2018 Davide Di Carlo
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * 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 <assert.h>
+#include "error.h"
+
+const char *Error_explain(Error self) {
+    assert(self);
+    return self->__message;
+}
+
+const Error Ok = Error_new("Ok");
+const Error OutOfMemory = Error_new("Out of memory");
diff --git a/deps/error/error.h b/deps/error/error.h
new file mode 100644
index 0000000..a943310
--- /dev/null
+++ b/deps/error/error.h
@@ -0,0 +1,98 @@
+/*
+ * Author: daddinuz
+ * email:  daddinuz@gmail.com
+ *
+ * Copyright (c) 2018 Davide Di Carlo
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * 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.
+ */
+
+#pragma once
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#if !(defined(__GNUC__) || defined(__clang__))
+#define __attribute__(...)
+#endif
+
+#define ERROR_VERSION_MAJOR       0
+#define ERROR_VERSION_MINOR       2
+#define ERROR_VERSION_PATCH       0
+#define ERROR_VERSION_SUFFIX      ""
+#define ERROR_VERSION_IS_RELEASE  0
+#define ERROR_VERSION_HEX         0x000200
+
+/**
+ * Represents errors that may occur at runtime.
+ * Every error instance must be a singleton, in order to check if two errors are equal a simple comparison
+ * between pointers can be done.
+ *
+ * @attention
+ *  This type must be treated as opaque therefore its members should never be accessed directly.
+ */
+typedef struct __Error {
+    const char *__message;
+} const *Error;
+
+/**
+ * An helper macro used for type hinting, useful when writing interfaces.
+ * By convention the annotations are the errors that may be returned.
+ */
+#define ErrorOf(...) \
+    Error
+
+/**
+ * Helper macro to create new singleton errors.
+ * This macro should be used only to define new global errors, and Errors defined with this macro must be declared const:
+ *
+ * @code
+ * const Error OutOfMemoryError = Error_new("Out of memory");
+ * @endcode
+ */
+#define Error_new(xMessage) \
+     ((Error) &((const struct __Error) {.__message=(xMessage)}))
+
+/**
+ * Gets the error message explanation.
+ *
+ * @param self The error instance <b>must not be NULL</b>.
+ * @return The error message.
+ */
+extern const char *
+Error_explain(Error self)
+__attribute__((__warn_unused_result__, __nonnull__));
+
+/**
+ * The Ok Error instance to notify a successful execution.
+ */
+extern const Error Ok;
+
+/**
+ * Some error instances
+ */
+extern const Error OutOfMemory;
+
+#ifdef __cplusplus
+}
+#endif
diff --git a/deps/error/package.json b/deps/error/package.json
new file mode 100644
index 0000000..3d9e543
--- /dev/null
+++ b/deps/error/package.json
@@ -0,0 +1,16 @@
+{
+  "name": "error",
+  "repo": "daddinuz/error",
+  "version": "0.2.0",
+  "license": "MIT",
+  "description": "Error representation.",
+  "keywords": [
+    "Error Handling",
+    "Error"
+  ],
+  "src": [
+    "sources/error.h",
+    "sources/error.c"
+  ],
+  "makefile": "sources/build.cmake"
+}
diff --git a/deps/option/build.cmake b/deps/option/build.cmake
new file mode 100644
index 0000000..38ff4fb
--- /dev/null
+++ b/deps/option/build.cmake
@@ -0,0 +1,7 @@
+set(ARCHIVE_NAME option)
+message("${ARCHIVE_NAME}@${CMAKE_CURRENT_LIST_DIR} using: ${CMAKE_CURRENT_LIST_FILE}")
+
+file(GLOB ARCHIVE_HEADERS ${CMAKE_CURRENT_LIST_DIR}/*.h)
+file(GLOB ARCHIVE_SOURCES ${CMAKE_CURRENT_LIST_DIR}/*.c)
+add_library(${ARCHIVE_NAME} ${ARCHIVE_HEADERS} ${ARCHIVE_SOURCES})
+target_link_libraries(${ARCHIVE_NAME} PRIVATE panic)
diff --git a/deps/option/option.c b/deps/option/option.c
new file mode 100644
index 0000000..b8c8f24
--- /dev/null
+++ b/deps/option/option.c
@@ -0,0 +1,65 @@
+/*
+ * Author: daddinuz
+ * email:  daddinuz@gmail.com
+ *
+ * Copyright (c) 2018 Davide Di Carlo
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * 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 <stdio.h>
+#include <stdlib.h>
+#include <stdarg.h>
+#include <assert.h>
+#include <panic/panic.h>
+#include "option.h"
+
+const Option None = {.__value=NULL};
+
+Option Option_some(void *const value) {
+    assert(value);
+    return (Option) {.__value=value};
+}
+
+bool Option_isSome(const Option self) {
+    return NULL != self.__value;
+}
+
+bool Option_isNone(const Option self) {
+    return NULL == self.__value;
+}
+
+void *__Option_expect(const char *const file, const int line, const Option self, const char *const format, ...) {
+    assert(file);
+    assert(format);
+    if (Option_isNone(self)) {
+        va_list args;
+        va_start(args, format);
+        __Panic_vterminate(file, line, format, args);
+    }
+    return self.__value;
+}
+
+void *__Option_unwrap(const char *const file, const int line, const Option self) {
+    assert(file);
+    return __Option_expect(file, line, self, "Error: %s.\n", "Unable to unwrap value.");
+}
diff --git a/deps/option/option.h b/deps/option/option.h
new file mode 100644
index 0000000..0ef823d
--- /dev/null
+++ b/deps/option/option.h
@@ -0,0 +1,144 @@
+/*
+ * Author: daddinuz
+ * email:  daddinuz@gmail.com
+ *
+ * Copyright (c) 2018 Davide Di Carlo
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * 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.
+ */
+
+#pragma once
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <stdbool.h>
+
+#if !(defined(__GNUC__) || defined(__clang__))
+#define __attribute__(...)
+#endif
+
+#define OPTION_VERSION_MAJOR       0
+#define OPTION_VERSION_MINOR       22
+#define OPTION_VERSION_PATCH       0
+#define OPTION_VERSION_SUFFIX      ""
+#define OPTION_VERSION_IS_RELEASE  0
+#define OPTION_VERSION_HEX         0x002200
+
+/**
+ * Option represents encapsulation of an optional value; it is used as the return type of functions which may or may
+ * not return a meaningful value when they are applied.
+ *
+ * @attention
+ *  This type must be treated as opaque therefore its members should never be accessed directly.
+ */
+typedef struct __Option {
+    void *__value;
+} Option;
+
+/**
+ * An helper macro used for type hinting, useful when writing interfaces.
+ * By convention the annotated type is the wrapped value type.
+ */
+#define OptionOf(xType) \
+    Option
+
+/**
+ * The None Option instance used instead of NULL to represent the absence of a value.
+ */
+extern const Option None;
+
+/**
+ * Creates an Option wrapping a value.
+ *
+ * @param value The wrapped value <b>must not be NULL</b>.
+ * @return A new Option instance wrapping value.
+ */
+extern Option Option_some(void *value)
+__attribute__((__warn_unused_result__, __nonnull__));
+
+/**
+ * Tests if Option is None
+ *
+ * @param self The Option instance.
+ * @return false if Option is None else true.
+ */
+extern bool Option_isSome(Option self)
+__attribute__((__warn_unused_result__));
+
+/**
+ * Tests if Option is None
+ *
+ * @param self The Option instance.
+ * @return true if Option is None else false.
+ */
+extern bool Option_isNone(Option self)
+__attribute__((__warn_unused_result__));
+
+/**
+ * Unwraps an Option, yielding its wrapped value if it's not None.
+ * Aborts execution if Option is None.
+ *
+ * @attention
+ *  This function should never be used directly, used the exported macro instead.
+ *
+ * @param file The file name.
+ * @param line The line number.
+ * @param self The Option instance.
+ * @param format The custom panic message.
+ * @param ... The format params.
+ * @return The unwrapped value or terminates the execution.
+ */
+extern void *__Option_expect(const char *file, int line, Option self, const char *format, ...)
+__attribute__((__warn_unused_result__, __nonnull__, __format__(__printf__, 4, 5)));
+
+/**
+ * @see __Option_expect(const char *file, int line, Option self, const char *format, ...)
+ */
+#define Option_expect(xSelf, ...) \
+    __Option_expect(__FILE__, __LINE__, (xSelf), __VA_ARGS__)
+
+/**
+ * Unwraps an Option, yielding its wrapped value if it's not None.
+ * Aborts execution if Option is None.
+ *
+ * @attention
+ *  This function should never be used directly, used the exported macro instead.
+ *
+ * @param file The file name.
+ * @param line The line number.
+ * @param self The Option instance.
+ * @return The unwrapped value or terminates the execution.
+ */
+extern void *__Option_unwrap(const char *file, int line, Option self)
+__attribute__((__warn_unused_result__, __nonnull__));
+
+/**
+ * @see __Option_unwrap(const char *file, int line, Option self)
+ */
+#define Option_unwrap(xSelf) \
+    __Option_unwrap(__FILE__, __LINE__, (xSelf))
+
+#ifdef __cplusplus
+}
+#endif
diff --git a/deps/option/package.json b/deps/option/package.json
new file mode 100644
index 0000000..c9d2db3
--- /dev/null
+++ b/deps/option/package.json
@@ -0,0 +1,19 @@
+{
+  "name": "option",
+  "repo": "daddinuz/option",
+  "version": "0.22.0",
+  "license": "MIT",
+  "description": "Option type resembling Rust's Option.",
+  "keywords": [
+    "Error Handling",
+    "Option"
+  ],
+  "src": [
+    "sources/option.h",
+    "sources/option.c"
+  ],
+  "dependencies": {
+    "daddinuz/panic": "0.3.0"
+  },
+  "makefile": "sources/build.cmake"
+}
diff --git a/deps/panic/build.cmake b/deps/panic/build.cmake
new file mode 100644
index 0000000..ed5fdc1
--- /dev/null
+++ b/deps/panic/build.cmake
@@ -0,0 +1,6 @@
+set(ARCHIVE_NAME panic)
+message("${ARCHIVE_NAME}@${CMAKE_CURRENT_LIST_DIR} using: ${CMAKE_CURRENT_LIST_FILE}")
+
+file(GLOB ARCHIVE_HEADERS ${CMAKE_CURRENT_LIST_DIR}/*.h)
+file(GLOB ARCHIVE_SOURCES ${CMAKE_CURRENT_LIST_DIR}/*.c)
+add_library(${ARCHIVE_NAME} ${ARCHIVE_HEADERS} ${ARCHIVE_SOURCES})
diff --git a/deps/panic/package.json b/deps/panic/package.json
new file mode 100644
index 0000000..5c95345
--- /dev/null
+++ b/deps/panic/package.json
@@ -0,0 +1,19 @@
+{
+  "name": "panic",
+  "repo": "daddinuz/panic",
+  "version": "0.3.0",
+  "license": "MIT",
+  "description": "A panic library to abort execution on non-recoverable errors with a detailed message",
+  "keywords": [
+    "Error Handling",
+    "Terminate",
+    "Panic",
+    "Abort",
+    "Error"
+  ],
+  "src": [
+    "sources/panic.h",
+    "sources/panic.c"
+  ],
+  "makefile": "sources/build.cmake"
+}
diff --git a/deps/panic/panic.c b/deps/panic/panic.c
new file mode 100644
index 0000000..0753b0f
--- /dev/null
+++ b/deps/panic/panic.c
@@ -0,0 +1,65 @@
+/*
+ * Author: daddinuz
+ * email:  daddinuz@gmail.com
+ *
+ * Copyright (c) 2018 Davide Di Carlo
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * 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 <errno.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <assert.h>
+#include "panic.h"
+
+static Panic_Callback globalCallback = NULL;
+
+Panic_Callback Panic_registerCallback(const Panic_Callback callback) {
+    const Panic_Callback backup = callback;
+    globalCallback = callback;
+    return backup;
+}
+
+void __Panic_terminate(const char *file, int line, const char *format, ...) {
+    assert(file);
+    assert(format);
+    va_list args;
+    va_start(args, format);
+    __Panic_vterminate(file, line, format, args);
+}
+
+void __Panic_vterminate(const char *file, int line, const char *format, va_list args) {
+    assert(file);
+    assert(format);
+    fprintf(stderr, "\nAt: %s:%d\n", file, line);
+    if (errno != 0) {
+        fprintf(stderr, "errno: (%d) %s\n", errno, strerror(errno));
+    }
+    vfprintf(stderr, format, args);
+    va_end(args);
+    if (globalCallback) {
+        globalCallback();
+    }
+    abort();
+}
diff --git a/deps/panic/panic.h b/deps/panic/panic.h
new file mode 100644
index 0000000..e3383c6
--- /dev/null
+++ b/deps/panic/panic.h
@@ -0,0 +1,87 @@
+/*
+ * Author: daddinuz
+ * email:  daddinuz@gmail.com
+ *
+ * Copyright (c) 2018 Davide Di Carlo
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * 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.
+ */
+
+#pragma once
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <stdarg.h>
+
+#if !(defined(__GNUC__) || defined(__clang__))
+#define __attribute__(...)
+#endif
+
+#define PANIC_VERSION_MAJOR       0
+#define PANIC_VERSION_MINOR       3
+#define PANIC_VERSION_PATCH       0
+#define PANIC_VERSION_SUFFIX      ""
+#define PANIC_VERSION_IS_RELEASE  0
+#define PANIC_VERSION_HEX         0x000300
+
+/**
+ * Type signature of the callback function to be executed on exit.
+ */
+typedef void (*Panic_Callback)(void);
+
+/**
+ * Registers a callback to execute before terminating.
+ *
+ * @param callback The callback to be executed, if NULL nothing will be executed.
+ * @return The previous registered callback if any else NULL.
+ */
+extern Panic_Callback Panic_registerCallback(Panic_Callback callback);
+
+/**
+ * Reports the error and terminates execution.
+ * @warning This function should not be called directly, use the exported macro instead.
+ */
+extern void __Panic_terminate(const char *file, int line, const char *format, ...)
+__attribute__((__nonnull__, __format__(__printf__, 3, 4), __noreturn__));
+
+/**
+ * Like __panic but takes a variadic list.
+ *
+ * @see __panic(const char *file, int line, const char *format, ...)
+ *
+ * @warning This function should not be called directly, use the exported macro instead.
+ */
+extern void __Panic_vterminate(const char *file, int line, const char *format, va_list args)
+__attribute__((__nonnull__, __format__(__printf__, 3, 0), __noreturn__));
+
+/**
+ * This macro acts like a wrapper over __panic function passing the right
+ * call coordinates (file and line number) for a better error report.
+ */
+#define Panic_terminate(...) \
+    __Panic_terminate(__FILE__, __LINE__, __VA_ARGS__)
+
+#ifdef __cplusplus
+}
+#endif
diff --git a/deps/text/build.cmake b/deps/text/build.cmake
new file mode 100644
index 0000000..ae8994e
--- /dev/null
+++ b/deps/text/build.cmake
@@ -0,0 +1,7 @@
+set(ARCHIVE_NAME text)
+message("${ARCHIVE_NAME}@${CMAKE_CURRENT_LIST_DIR} using: ${CMAKE_CURRENT_LIST_FILE}")
+
+file(GLOB ARCHIVE_HEADERS ${CMAKE_CURRENT_LIST_DIR}/*.h)
+file(GLOB ARCHIVE_SOURCES ${CMAKE_CURRENT_LIST_DIR}/*.c)
+add_library(${ARCHIVE_NAME} ${ARCHIVE_HEADERS} ${ARCHIVE_SOURCES})
+target_link_libraries(${ARCHIVE_NAME} PRIVATE panic alligator)
diff --git a/deps/text/package.json b/deps/text/package.json
new file mode 100644
index 0000000..20a9ea3
--- /dev/null
+++ b/deps/text/package.json
@@ -0,0 +1,23 @@
+{
+  "name": "text",
+  "repo": "daddinuz/text",
+  "version": "0.1.0",
+  "license": "MIT",
+  "description": "A string library with support for complex operations on textual data.",
+  "keywords": [
+  ],
+  "src": [
+    "sources/text.h",
+    "sources/text.c",
+    "sources/text_config.h"
+  ],
+  "dependencies": {
+    "daddinuz/panic": "0.3.0",
+    "daddinuz/alligator": "0.24.0"
+  },
+  "development": {
+    "daddinuz/traits": "3.2.0",
+    "daddinuz/traits-unit": "3.0.0"
+  },
+  "makefile": "sources/build.cmake"
+}
diff --git a/deps/text/text.c b/deps/text/text.c
new file mode 100644
index 0000000..ca513c0
--- /dev/null
+++ b/deps/text/text.c
@@ -0,0 +1,544 @@
+/*
+ * Author: daddinuz
+ * email:  daddinuz@gmail.com
+ *
+ * Copyright (c) 2018 Davide Di Carlo
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * 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 <stdio.h>
+#include <ctype.h>
+#include <assert.h>
+#include <stdint.h>
+#include <string.h>
+#include <panic/panic.h>
+#include <alligator/alligator.h>
+#include "text.h"
+#include "text_config.h"
+
+#if TEXT_DEFAULT_CAPACITY < 32UL || TEXT_DEFAULT_CAPACITY >= SIZE_MAX
+    #error
+#endif
+
+static size_t nextEven(const size_t size) {
+    assert(size < SIZE_MAX);
+    return size + (size % 2);
+}
+
+static size_t applyLoadFactor(const size_t size) {
+    assert(size < SIZE_MAX);
+    return nextEven((size_t) (size * TEXT_LOAD_FACTOR));
+}
+
+static size_t calculateNewCapacity(size_t currentCapacity, const size_t targetCapacity) {
+    assert(currentCapacity < SIZE_MAX);
+    assert(targetCapacity < SIZE_MAX);
+    assert(currentCapacity < targetCapacity);
+    while (currentCapacity < targetCapacity) {
+        currentCapacity = applyLoadFactor(currentCapacity);
+    }
+    return currentCapacity;
+}
+
+static bool isTrimmable(char c) {
+    return isspace(c) || isblank(c) || !isprint(c);
+}
+
+struct Text_Header {
+    size_t capacity;
+    size_t length;
+    char *content;
+};
+
+Text Text_new(void) {
+    return Text_withCapacity(TEXT_DEFAULT_CAPACITY);
+}
+
+Text Text_withCapacity(size_t capacity) {
+    assert(capacity < SIZE_MAX);
+    if (capacity < TEXT_DEFAULT_CAPACITY) {
+        capacity = TEXT_DEFAULT_CAPACITY;
+    }
+    struct Text_Header *header = Option_unwrap(Alligator_malloc(
+            sizeof(*header) + sizeof(header->content[0]) * (capacity + 1)
+    ));
+    header->content = (char *) (header + 1);
+    header->content[header->length = 0] = 0;
+    header->content[header->capacity = capacity] = 0;
+    return header->content;
+}
+
+Text Text_quoted(const void *bytes, const size_t size) {
+    assert(bytes);
+    assert(size < SIZE_MAX);
+
+    const char *data = bytes;
+    Text text = Text_withCapacity(size + size / 3);
+
+    text = Text_appendBytes(&text, "\"", 1);
+    for (size_t i = 0; i < size; i++) {
+        switch (*data) {
+            case '"': {
+                text = Text_appendBytes(&text, "\\\"", 2);
+                break;
+            }
+            case '\\': {
+                text = Text_appendBytes(&text, "\\\\", 2);
+                break;
+            }
+            case '/': {
+                text = Text_appendBytes(&text, "\\/", 2);
+                break;
+            }
+            case '\b': {
+                text = Text_appendBytes(&text, "\\b", 2);
+                break;
+            }
+            case '\f': {
+                text = Text_appendBytes(&text, "\\f", 2);
+                break;
+            }
+            case '\n': {
+                text = Text_appendBytes(&text, "\\n", 2);
+                break;
+            }
+            case '\r': {
+                text = Text_appendBytes(&text, "\\r", 2);
+                break;
+            }
+            case '\t': {
+                text = Text_appendBytes(&text, "\\t", 2);
+                break;
+            }
+            default: {
+                if (isprint(*data)) {
+                    text = Text_appendFormat(&text, "%c", *data);
+                } else {
+                    text = Text_appendFormat(&text, "\\u%04hhx", *data);
+                }
+                break;
+            }
+        }
+        data++;
+    }
+    text = Text_appendBytes(&text, "\"", 1);
+
+    return text;
+}
+
+Text Text_format(const char *format, ...) {
+    assert(format);
+    va_list args;
+    va_start(args, format);
+    Text text = Text_vFormat(format, args);
+    va_end(args);
+    return text;
+}
+
+Text Text_vFormat(const char *format, va_list args) {
+    assert(format);
+    va_list argsCopy;
+    va_copy(argsCopy, args);
+    const int formattedSize = vsnprintf(NULL, 0, format, argsCopy);
+    va_end(argsCopy);
+
+    if (formattedSize < 0) {
+        Panic_terminate("Unable to format string");
+    }
+
+    const size_t length = (size_t) formattedSize;
+    Text text = Text_withCapacity(length);
+    struct Text_Header *header = (struct Text_Header *) text - 1;
+
+    vsnprintf(header->content, length + 1, format, args);
+    header->length = length;
+    return text;
+}
+
+Text Text_fromBytes(const void *const bytes, const size_t size) {
+    assert(bytes);
+    assert(size < SIZE_MAX);
+    Text text = Text_withCapacity(size);
+    struct Text_Header *header = (struct Text_Header *) text - 1;
+    memcpy(text, bytes, size);
+    text[header->length = size] = 0;
+    return text;
+}
+
+Text Text_fromLiteral(const char *const literal) {
+    assert(literal);
+    return Text_fromBytes(literal, strlen(literal));
+}
+
+Text Text_duplicate(const TextView self) {
+    assert(self);
+    return Text_fromBytes(self, Text_length(self));
+}
+
+Text Text_overwrite(Text *ref, const TextView other) {
+    assert(ref);
+    assert(*ref);
+    assert(other);
+    return Text_overwriteWithBytes(ref, other, Text_length(other));
+}
+
+Text Text_overwriteWithFormat(Text *ref, const char *format, ...) {
+    assert(ref);
+    assert(*ref);
+    assert(format);
+    va_list args;
+    va_start(args, format);
+    Text text = Text_vOverwriteWithFormat(ref, format, args);
+    va_end(args);
+    return text;
+}
+
+Text Text_vOverwriteWithFormat(Text *ref, const char *format, va_list args) {
+    assert(ref);
+    assert(*ref);
+    assert(format);
+    va_list argsCopy;
+    va_copy(argsCopy, args);
+    const int formattedSize = vsnprintf(NULL, 0, format, argsCopy);
+    va_end(argsCopy);
+
+    if (formattedSize < 0) {
+        Panic_terminate("Unable to format string");
+    }
+
+    const size_t newLength = (size_t) formattedSize;
+    Text text = Text_expandToFit(ref, newLength);
+    struct Text_Header *header = (struct Text_Header *) text - 1;
+
+    vsnprintf(header->content, newLength + 1, format, args);
+    header->length = newLength;
+    return text;
+}
+
+Text Text_overwriteWithBytes(Text *ref, const void *const bytes, const size_t size) {
+    assert(ref);
+    assert(*ref);
+    assert(bytes);
+    assert(size < SIZE_MAX);
+    Text text = Text_expandToFit(ref, size);
+    struct Text_Header *header = (struct Text_Header *) text - 1;
+    memmove(text, bytes, size);
+    text[header->length = size] = 0;
+    *ref = NULL;
+    return text;
+}
+
+Text Text_overwriteWithLiteral(Text *ref, const char *const literal) {
+    assert(ref);
+    assert(*ref);
+    assert(literal);
+    return Text_overwriteWithBytes(ref, literal, strlen(literal));
+}
+
+Text Text_append(Text *ref, TextView other) {
+    assert(ref);
+    assert(*ref);
+    assert(other);
+    return Text_appendBytes(ref, other, Text_length(other));
+}
+
+Text Text_appendFormat(Text *const ref, const char *const format, ...) {
+    assert(ref);
+    assert(*ref);
+    assert(format);
+    va_list args;
+    va_start(args, format);
+    Text text = Text_vAppendFormat(ref, format, args);
+    va_end(args);
+    return text;
+}
+
+Text Text_vAppendFormat(Text *ref, const char *format, va_list args) {
+    assert(ref);
+    assert(*ref);
+    assert(format);
+    va_list argsCopy;
+    va_copy(argsCopy, args);
+    const int formattedSize = vsnprintf(NULL, 0, format, argsCopy);
+    va_end(argsCopy);
+
+    if (formattedSize < 0) {
+        Panic_terminate("Unable to format string");
+    }
+
+    const size_t oldLength = Text_length(*ref), newLength = (size_t) formattedSize;
+    Text text = Text_expandToFit(ref, oldLength + newLength);
+    struct Text_Header *header = (struct Text_Header *) text - 1;
+
+    vsnprintf(header->content + oldLength, newLength + 1, format, args);
+    header->length += newLength;
+    return text;
+}
+
+Text Text_appendBytes(Text *ref, const void *const bytes, const size_t size) {
+    assert(ref);
+    assert(*ref);
+    assert(bytes);
+    assert(size < SIZE_MAX);
+    return Text_insertBytes(ref, Text_length(*ref), bytes, size);
+}
+
+Text Text_appendLiteral(Text *ref, const char *const literal) {
+    assert(ref);
+    assert(*ref);
+    assert(literal);
+    return Text_appendBytes(ref, literal, strlen(literal));
+}
+
+Text Text_insert(Text *ref, size_t index, TextView text) {
+    assert(ref);
+    assert(*ref);
+    assert(index <= Text_length(*ref));
+    assert(text);
+    return Text_insertBytes(ref, index, text, Text_length(text));
+}
+
+Text Text_insertFormat(Text *ref, size_t index, const char *format, ...) {
+    assert(ref);
+    assert(*ref);
+    assert(index <= Text_length(*ref));
+    assert(format);
+    va_list args;
+    va_start(args, format);
+    Text text = Text_vInsertFormat(ref, index, format, args);
+    va_end(args);
+    return text;
+}
+
+Text Text_vInsertFormat(Text *ref, size_t index, const char *format, va_list args) {
+    assert(ref);
+    assert(*ref);
+    assert(index <= Text_length(*ref));
+    assert(format);
+    va_list argsCopy;
+    va_copy(argsCopy, args);
+    const int formattedSize = vsnprintf(NULL, 0, format, argsCopy);
+    va_end(argsCopy);
+
+    if (formattedSize < 0) {
+        Panic_terminate("Unable to format string");
+    }
+
+    const size_t additional = (size_t) formattedSize;
+    Text self = Text_expandToFit(ref, Text_length(*ref) + additional);
+    struct Text_Header *header = (struct Text_Header *) self - 1;
+    char *ptr = self + index;
+    const char previous = self[index];
+    memmove(ptr + additional, ptr, header->length - index);
+    vsnprintf(ptr, additional + 1, format, args);
+    self[index + additional] = previous;
+    self[header->length += additional] = 0;
+    return self;
+}
+
+Text Text_insertBytes(Text *ref, size_t index, const void *bytes, size_t size) {
+    assert(ref);
+    assert(*ref);
+    assert(index <= Text_length(*ref));
+    assert(bytes);
+    assert(size < SIZE_MAX);
+    Text self = Text_expandToFit(ref, Text_length(*ref) + size);
+    struct Text_Header *header = (struct Text_Header *) self - 1;
+    char *ptr = self + index;
+    memmove(ptr + size, ptr, header->length - index);
+    memmove(ptr, bytes, size);
+    self[header->length += size] = 0;
+    return self;
+}
+
+Text Text_insertLiteral(Text *ref, size_t index, const char *literal) {
+    assert(ref);
+    assert(*ref);
+    assert(index <= Text_length(*ref));
+    assert(literal);
+    return Text_insertBytes(ref, index, literal, strlen(literal));
+}
+
+Text Text_quote(Text *ref) {
+    assert(ref);
+    assert(*ref);
+    Text self = *ref;
+    self = Text_quoted(self, Text_length(self));
+    Text_delete(*ref);
+    *ref = NULL;
+    return self;
+}
+
+void Text_eraseRange(Text self, const size_t start, const size_t end) {
+    assert(self);
+    assert(start <= end);
+    assert(end <= Text_length(self));
+    if (start != end) {
+        const size_t length = Text_length(self);
+        if (length == end) {
+            if (0 == start) {
+                Text_clear(self);
+            } else {
+                struct Text_Header *header = (struct Text_Header *) self - 1;
+                self[header->length -= (end - start)] = 0;
+            }
+        } else {
+            struct Text_Header *header = (struct Text_Header *) self - 1;
+            memmove(self + start, self + end, length - end);
+            self[header->length -= (end - start)] = 0;
+        }
+    }
+}
+
+void Text_trimLeft(Text self) {     // TODO test
+    assert(self);
+    char *cursor = self;
+    for (const char *end = cursor + Text_length(self); cursor < end && isTrimmable(*cursor); cursor++) {}
+    Text_eraseRange(self, 0, cursor - self);
+}
+
+void Text_trimRight(Text self) {    // TODO test
+    assert(self);
+    char *cursor;
+    const size_t length = Text_length(self);
+    for (cursor = self + length; self < cursor && isTrimmable(*cursor); cursor--) {}
+    Text_eraseRange(self, (isTrimmable(*cursor) ? cursor : cursor + 1) - self, length);
+}
+
+void Text_trim(Text self) {         // TODO test
+    assert(self);
+    Text_trimLeft(self);
+    Text_trimRight(self);
+}
+
+void Text_lower(Text self) {
+    assert(self);
+    const size_t length = Text_length(self);
+    for (size_t i = 0; i < length; i++) {
+        self[i] = (char) tolower(self[i]);
+    }
+}
+
+void Text_upper(Text self) {
+    assert(self);
+    const size_t length = Text_length(self);
+    for (size_t i = 0; i < length; i++) {
+        self[i] = (char) toupper(self[i]);
+    }
+}
+
+void Text_clear(Text self) {
+    assert(self);
+    struct Text_Header *header = (struct Text_Header *) self - 1;
+    self[header->length = 0] = 0;
+}
+
+void Text_setLength(Text self, size_t length) { // TODO test
+    assert(self);
+    assert(length <= Text_capacity(self));
+    struct Text_Header *header = (struct Text_Header *) self - 1;
+    header->length = length;
+}
+
+Text Text_expandToFit(Text *ref, size_t capacity) {
+    assert(ref);
+    assert(*ref);
+    assert(capacity < SIZE_MAX);
+    struct Text_Header *header = (struct Text_Header *) (*ref) - 1;
+    if (capacity > header->capacity) {
+        capacity = calculateNewCapacity(header->capacity, capacity);
+        header = Option_unwrap(Alligator_realloc(
+                header, sizeof(*header) + sizeof(header->content[0]) * (capacity + 1)
+        ));
+        header->content = (char *) (header + 1);
+        header->content[header->capacity = capacity] = 0;
+    }
+    *ref = NULL;
+    return header->content;
+}
+
+Text Text_shrinkToFit(Text *ref) {
+    assert(ref);
+    assert(*ref);
+    struct Text_Header *header = (struct Text_Header *) (*ref) - 1;
+    const size_t size = header->length;
+    if (size < header->capacity) {
+        header = Option_unwrap(Alligator_realloc(
+                header, sizeof(*header) + sizeof(header->content[0]) * (size + 1)
+        ));
+        header->content = (char *) (header + 1);
+        header->content[header->capacity = size] = 0;
+    }
+    *ref = NULL;
+    return header->content;
+}
+
+char Text_get(const TextView self, const size_t index) {
+    assert(self);
+    if (index >= Text_length(self)) {
+        Panic_terminate("Out of range");
+    }
+    return self[index];
+}
+
+char Text_put(Text self, const size_t index, const char c) {
+    assert(self);
+    if (index >= Text_length(self)) {
+        Panic_terminate("Out of range");
+    }
+    char *p = self + index;
+    const char bk = *p;
+    *p = c;
+    return bk;
+}
+
+size_t Text_length(const TextView self) {
+    assert(self);
+    struct Text_Header *header = (struct Text_Header *) self - 1;
+    return header->length;
+}
+
+size_t Text_capacity(const TextView self) {
+    assert(self);
+    struct Text_Header *header = (struct Text_Header *) self - 1;
+    return header->capacity;
+}
+
+bool Text_isEmpty(TextView self) {
+    assert(self);
+    return 0 == Text_length(self);
+}
+
+bool Text_equals(const TextView self, const TextView other) {
+    assert(self);
+    assert(other);
+    const size_t length = Text_length(self);
+    return length == Text_length(other) && 0 == memcmp(self, other, length);
+}
+
+void Text_delete(Text self) {
+    if (self) {
+        struct Text_Header *header = (struct Text_Header *) self - 1;
+        Alligator_free(header);
+    }
+}
diff --git a/deps/text/text.h b/deps/text/text.h
new file mode 100644
index 0000000..11ba390
--- /dev/null
+++ b/deps/text/text.h
@@ -0,0 +1,590 @@
+/*
+ * Author: daddinuz
+ * email:  daddinuz@gmail.com
+ *
+ * Copyright (c) 2018 Davide Di Carlo
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * 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.
+ */
+
+#pragma once
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <stdarg.h>
+#include <stddef.h>
+#include <stdbool.h>
+
+#if !(defined(__GNUC__) || defined(__clang__))
+#define __attribute__(...)
+#endif
+
+#define TEXT_VERSION_MAJOR        0
+#define TEXT_VERSION_MINOR        1
+#define TEXT_VERSION_PATCH        0
+#define TEXT_VERSION_SUFFIX       ""
+#define TEXT_VERSION_IS_RELEASE   0
+#define TEXT_VERSION_HEX          0x000100
+
+/**
+ * A string library with support for complex operations on textual data
+ *
+ * @attention Every function in this library terminates the program in case of out of memory.
+ */
+typedef char *Text;
+typedef const char *TextView;
+
+/**
+ * Creates an empty text using default capacity.
+ *
+ * @return a new text instance.
+ */
+extern Text Text_new(void)
+__attribute__((__warn_unused_result__));
+
+/**
+ * Creates a new text with at least the given initial capacity.
+ *
+ * @attention capacity must be less than SIZE_MAX.
+ *
+ * @param capacity The initial capacity.
+ * @return a new text instance.
+ */
+extern Text Text_withCapacity(size_t capacity)
+__attribute__((__warn_unused_result__));
+
+/**
+ * Creates a new JSON compliant quoted instance of text starting from bytes.
+ *
+ * @attention bytes array must not be NULL.
+ * @attention the size of the bytes array must be less than SIZE_MAX.
+ *
+ * @param bytes The sequence of bytes.
+ * @param size The size of bytes.
+ * @return a new text instance.
+ */
+extern Text Text_quoted(const void *bytes, size_t size)
+__attribute__((__warn_unused_result__, __nonnull__));
+
+/**
+ * Creates a new text from a printf-like format.
+ *
+ * @attention format must not be NULL.
+ *
+ * @param format The printf-like format string.
+ * @param ... The args for format.
+ * @return a new text instance.
+ */
+extern Text Text_format(const char *format, ...)
+__attribute__((__warn_unused_result__, __nonnull__(1), __format__(printf, 1, 2)));
+
+/**
+ * Creates a new text from a printf-like format, behaves like Text_format but takes a va_list.
+ *
+ * @attention format must not be NULL.
+ *
+ * @param format The printf-like format string.
+ * @param args The args for format.
+ * @return a new text instance.
+ */
+extern Text Text_vFormat(const char *format, va_list args)
+__attribute__((__warn_unused_result__, __nonnull__, __format__(__printf__, 1, 0)));
+
+/**
+ * Creates a new text from the given bytes array.
+ *
+ * @attention bytes array must not be NULL.
+ * @attention the size of the bytes array must be less than SIZE_MAX.
+ *
+ * @param bytes The bytes array.
+ * @param size The size of the array.
+ * @return a new text instance.
+ */
+extern Text Text_fromBytes(const void *bytes, size_t size)
+__attribute__((__warn_unused_result__, __nonnull__));
+
+/**
+ * Creates a new text from the given literal.
+ *
+ * @attention literal must not be NULL.
+ * @attention the length of the literal must be less than SIZE_MAX.
+ *
+ * @param literal The string literal.
+ * @return a new text instance.
+ */
+extern Text Text_fromLiteral(const char *literal)
+__attribute__((__warn_unused_result__, __nonnull__));
+
+/**
+ * Duplicates a text instance.
+ * Note: capacity may be different between instances.
+ *
+ * @attention s must not be NULL.
+ *
+ * @param self The text instance to be duplicated.
+ * @return a new text instance.
+ */
+extern Text Text_duplicate(TextView self)
+__attribute__((__warn_unused_result__, __nonnull__));
+
+/**
+ * Overwrites the content of the text (expanding it's capacity if needed) with the other text.
+ *
+ * @attention ref and *ref must not be NULL.
+ * @attention other must not be NULL.
+ *
+ * @attention the reference to the text will be invalidated after this call, the new text is returned.
+ *
+ * @param ref The text instance reference.
+ * @param bytes The bytes array to write in the text.
+ * @param size The size of the bytes array.
+ * @return the modified text instance
+ */
+extern Text Text_overwrite(Text *ref, TextView other)
+__attribute__((__warn_unused_result__, __nonnull__));
+
+/**
+ * Overwrites the content of the text (expanding it's capacity if needed) with the formatted content.
+ *
+ * @attention ref and *ref must not be NULL.
+ * @attention format must not be NULL.
+ *
+ * @attention the reference to the text will be invalidated after this call, the new text is returned.
+ *
+ * @param ref The text instance reference.
+ * @param format The printf-like format string.
+ * @param ... The args for format
+ * @return the modified text instance
+ */
+extern Text Text_overwriteWithFormat(Text *ref, const char *format, ...)
+__attribute__((__warn_unused_result__, __nonnull__(1, 2), __format__(printf, 2, 3)));
+
+/**
+ * Overwrites the content of the text (expanding it's capacity if needed) with the formatted content.
+ * Behaves like Text_overwriteWithFormat but takes a va_list.
+ *
+ * @attention ref and *ref must not be NULL.
+ * @attention format must not be NULL
+ *
+ * @attention the reference to the text will be invalidated after this call, the new text is returned.
+ *
+ * @param ref The text instance reference.
+ * @param format The printf-like format string.
+ * @param args The args for format.
+ * @return the modified text instance
+ */
+extern Text Text_vOverwriteWithFormat(Text *ref, const char *format, va_list args)
+__attribute__((__warn_unused_result__, __nonnull__, __format__(printf, 2, 0)));
+
+/**
+ * Overwrites the content of the text (expanding it's capacity if needed) with the given bytes array.
+ *
+ * @attention ref and *ref must not be NULL.
+ * @attention bytes must not be NULL.
+ * @attention size must be less than SIZE_MAX.
+ *
+ * @attention the reference to the text will be invalidated after this call, the new text is returned.
+ *
+ * @param ref The text instance reference.
+ * @param bytes The bytes array to write in the text.
+ * @param size The size of the bytes array.
+ * @return the modified text instance
+ */
+extern Text Text_overwriteWithBytes(Text *ref, const void *bytes, size_t size)
+__attribute__((__warn_unused_result__, __nonnull__));
+
+/**
+ * Overwrites the content of the text (expanding it's capacity if needed) with the given literal.
+ *
+ * @attention ref and *ref must not be NULL.
+ * @attention literal must not be NULL.
+ * @attention the length of the literal must be less than SIZE_MAX.
+ *
+ * @attention the reference to the text will be invalidated after this call, the new text is returned.
+ *
+ * @param ref The text instance reference.
+ * @param literal The literal to write in the text.
+ * @return the modified text instance
+ */
+extern Text Text_overwriteWithLiteral(Text *ref, const char *literal)
+__attribute__((__warn_unused_result__, __nonnull__));
+
+/**
+ * Appends content to the text.
+ *
+ * @attention ref and *ref must not be NULL.
+ * @attention other must not be NULL.
+ *
+ * @attention the reference to the text will be invalidated after this call, the new text is returned.
+ *
+ * @param ref The text instance reference.
+ * @param other The text to be appended.
+ * @return the modified text instance
+ */
+extern Text Text_append(Text *ref, TextView other)
+__attribute__((__warn_unused_result__, __nonnull__));
+
+/**
+ * Appends the formatted content to the text.
+ *
+ * @attention ref and *ref must not be NULL.
+ * @attention format must not be NULL.
+ *
+ * @attention the reference to the text will be invalidated after this call, the new text is returned.
+ *
+ * @param ref The text instance reference.
+ * @param format The printf-like format string.
+ * @param ... The args for format
+ * @return the modified text instance
+ */
+extern Text Text_appendFormat(Text *ref, const char *format, ...)
+__attribute__((__warn_unused_result__, __nonnull__(1, 2), __format__(printf, 2, 3)));
+
+/**
+ * Appends the formatted content to the text.
+ * Behaves like Text_appendFormat but takes a va_list.
+ *
+ * @attention ref and *ref must not be NULL.
+ * @attention format must not be NULL
+ *
+ * @attention the reference to the text will be invalidated after this call, the new text is returned.
+ *
+ * @param ref The text instance reference.
+ * @param format The printf-like format string.
+ * @param args The args for format.
+ * @return the modified text instance
+ */
+extern Text Text_vAppendFormat(Text *ref, const char *format, va_list args)
+__attribute__((__warn_unused_result__, __nonnull__, __format__(printf, 2, 0)));
+
+/**
+ * Appends the bytes array to the text.
+ *
+ * @attention ref and *ref must not be NULL.
+ * @attention bytes must not be NULL.
+ * @attention size must be less than SIZE_MAX.
+ *
+ * @attention the reference to the text will be invalidated after this call, the new text is returned.
+ *
+ * @param ref The text instance reference.
+ * @param bytes The bytes array to append.
+ * @param size The size of the bytes array.
+ * @return the modified text instance
+ */
+extern Text Text_appendBytes(Text *ref, const void *bytes, size_t size)
+__attribute__((__warn_unused_result__, __nonnull__));
+
+/**
+ * Appends the literal to the text.
+ *
+ * @attention ref and *ref must not be NULL.
+ * @attention literal must not be NULL.
+ * @attention the length of the literal must be less than SIZE_MAX.
+ *
+ * @attention the reference to the text will be invalidated after this call, the new text is returned.
+ *
+ * @param ref The text instance reference.
+ * @param literal The literal to append.
+ * @return the modified text instance
+ */
+extern Text Text_appendLiteral(Text *ref, const char *literal)
+__attribute__((__warn_unused_result__, __nonnull__));
+
+/**
+ * Insert text at the index position.
+ *
+ * @attention ref and *ref must not be NULL.
+ * @attention index must be less or equal than the length of the text.
+ * @attention text must not be NULL.
+ *
+ * @attention terminates execution if index is greater than the length of the text.
+ * @attention the reference to the text will be invalidated after this call, the new text is returned.
+ *
+ * @param ref The text instance reference.
+ * @param index The index position.
+ * @param text The text to insert.
+ * @return the modified text instance
+ */
+extern Text Text_insert(Text *ref, size_t index, TextView text)
+__attribute__((__warn_unused_result__, __nonnull__));
+
+/**
+ * Inserts a formatted string into this text.
+ *
+ * @attention ref and *ref must not be NULL.
+ * @attention index must be less or equal than the length of the text.
+ * @attention format must not be NULL.
+ *
+ * @attention terminates execution if index is greater than the length of the text.
+ * @attention the reference to the text will be invalidated after this call, the new text is returned.
+ *
+ * @param ref The text instance reference.
+ * @param index The index position.
+ * @param format The printf-like format string.
+ * @param ... The args for format.
+ * @return the modified text instance
+ */
+extern Text Text_insertFormat(Text *ref, size_t index, const char *format, ...)
+__attribute__((__warn_unused_result__, __nonnull__(1, 3), __format__(printf, 3, 4)));
+
+/**
+ * Inserts a formatted string into this text.
+ * Behaves like Text_insertFormat but takes a va_list.
+ *
+ * @attention ref and *ref must not be NULL.
+ * @attention index must be less or equal than the length of the text.
+ * @attention format must not be NULL
+ *
+ * @attention terminates execution if index is greater than the length of the text.
+ * @attention the reference to the text will be invalidated after this call, the new text is returned.
+ *
+ * @param ref The text instance reference.
+ * @param index The index position.
+ * @param format The printf-like format string.
+ * @param args The args for format.
+ * @return the modified text instance
+ */
+extern Text Text_vInsertFormat(Text *ref, size_t index, const char *format, va_list args)
+__attribute__((__warn_unused_result__, __nonnull__, __format__(printf, 3, 0)));
+
+/**
+ * Insert bytes into this text at the index position.
+ *
+ * @attention ref and *ref must not be NULL.
+ * @attention index must be less or equal than the length of the text.
+ * @attention bytes must not be NULL.
+ * @attention size must be less than SIZE_MAX.
+ *
+ * @attention terminates execution if index is greater than the length of the text.
+ * @attention the reference to the text will be invalidated after this call, the new text is returned.
+ *
+ * @param ref The text instance reference.
+ * @param index The index position.
+ * @param bytes The bytes array to insert.
+ * @param size The size of the bytes array.
+ * @return the modified text instance
+ */
+extern Text Text_insertBytes(Text *ref, size_t index, const void *bytes, size_t size)
+__attribute__((__warn_unused_result__, __nonnull__));
+
+/**
+ * Insert literal into this text at the index position.
+ *
+ * @attention ref and *ref must not be NULL.
+ * @attention index must be less or equal than the length of the text.
+ * @attention literal must not be NULL.
+ *
+ * @attention terminates execution if index is greater than the length of the text.
+ * @attention the reference to the text will be invalidated after this call, the new text is returned.
+ *
+ * @param ref The text instance reference.
+ * @param index The index position.
+ * @param literal The literal to insert.
+ * @return the modified text instance
+ */
+extern Text Text_insertLiteral(Text *ref, size_t index, const char *literal)
+__attribute__((__warn_unused_result__, __nonnull__));
+
+/**
+ * Modifies text quoting (JSON compliant) it's content.
+ *
+ * @attention the reference to the text will be invalidated after this call, the new text is returned.
+ *
+ * @param ref The text instance reference.
+ * @return the modified text instance
+ */
+extern Text Text_quote(Text *ref)
+__attribute__((__warn_unused_result__, __nonnull__));
+
+/**
+ * Erases content from this text.
+ * Note: A starting index equal to the ending one will result in a no-op.
+ *
+ * @attention self must not be NULL.
+ * @attention start must be less or equal than end.
+ * @attention end must be less or equal than the length of the text.
+ *
+ * @attention terminates execution if range is invalid.
+ *
+ * @param self The text instance.
+ * @param start Starting index included.
+ * @param end Ending index excluded.
+ */
+extern void Text_eraseRange(Text self, size_t start, size_t end)
+__attribute__((__nonnull__));
+
+/**
+ * Removes leading whitespace from left.
+ *
+ * @param self The text instance.
+ */
+extern void Text_trimLeft(Text self)
+__attribute__((__nonnull__));
+
+/**
+ * Removes leading whitespace from right.
+ *
+ * @param self The text instance.
+ */
+extern void Text_trimRight(Text self)
+__attribute__((__nonnull__));
+
+/**
+ * Removes leading whitespace from both endings.
+ *
+ * @param self The text instance.
+ */
+extern void Text_trim(Text self)
+__attribute__((__nonnull__));
+
+/**
+ * To lower case.
+ *
+ * @param self The text instance.
+ */
+extern void Text_lower(Text self)
+__attribute__((__nonnull__));
+
+/**
+ * To upper case.
+ *
+ * @param self The text instance.
+ */
+extern void Text_upper(Text self)
+__attribute__((__nonnull__));
+
+/**
+ * Clears the content of the text without changing its capacity.
+ *
+ * @attention self must not be NULL.
+ *
+ * @param self The text instance.
+ */
+extern void Text_clear(Text self)
+__attribute__((__nonnull__));
+
+/**
+ * Sets the length of the text.
+ *
+ * @attention self must not be NULL.
+ * @attention length must not be greater than capacity.
+ *
+ * @param self The text instance.
+ * @param length The new length.
+ */
+extern void Text_setLength(Text self, size_t length)
+__attribute__((__nonnull__));
+
+/**
+ * Expands (if needed) the text to fit the requested capacity.
+ *
+ * @attention ref and *ref must not be NULL.
+ * @attention capacity must be less than SIZE_MAX.
+ *
+ * @attention the reference to the text will be invalidated after this call, the new text is returned.
+ *
+ * @return the modified text instance
+ */
+extern Text Text_expandToFit(Text *ref, size_t capacity)
+__attribute__((__warn_unused_result__, __nonnull__));
+
+/**
+ * Shrinks the capacity of the text to fit the size of its content.
+ *
+ * @attention ref and *ref must not be NULL.
+ * @attention the reference to the text will be invalidated after this call, the new text is returned.
+ *
+ * @return the modified text instance
+ */
+extern Text Text_shrinkToFit(Text *ref)
+__attribute__((__warn_unused_result__, __nonnull__));
+
+/**
+ * Gets the character in the text at the given index.
+ *
+ * @attention self must not be NULL.
+ * @attention terminates execution if index is greater or equals the text's length.
+ */
+extern char Text_get(TextView self, size_t index)
+__attribute__((__warn_unused_result__, __nonnull__));
+
+/**
+ * Puts the character in the text at the given index replacing the existing one.
+ *
+ * @attention self must not be NULL.
+ * @attention terminates execution if index is greater or equals the text's length.
+ *
+ * @return the replaced character.
+ */
+extern char Text_put(Text self, size_t index, char c)
+__attribute__((__nonnull__));
+
+/**
+ * Gets the size of the text.
+ *
+ * @attention self must not be NULL.
+ *
+ * @param self The text instance.
+ * @return the size of the text.
+ */
+extern size_t Text_length(TextView self)
+__attribute__((__warn_unused_result__, __nonnull__));
+
+/**
+ * Gets the capacity of the text.
+ *
+ * @attention self must not be NULL.
+ *
+ * @param self The text instance.
+ * @return the capacity of the text.
+ */
+extern size_t Text_capacity(TextView self)
+__attribute__((__warn_unused_result__, __nonnull__));
+
+/**
+ * Checks if the string is empty.
+ */
+extern bool Text_isEmpty(TextView self)
+__attribute__((__warn_unused_result__, __nonnull__));
+
+/**
+ * Checks for equality.
+ *
+ * @attention self must not be NULL.
+ * @attention other must not be NULL.
+ */
+extern bool Text_equals(TextView self, TextView other)
+__attribute__((__warn_unused_result__, __nonnull__));
+
+/**
+ * Deletes an instance of a text.
+ * If NULL nothing will be done.
+ *
+ * @param self The instance to be deleted.
+ */
+extern void Text_delete(Text self);
+
+#ifdef __cplusplus
+}
+#endif
diff --git a/deps/text/text_config.h b/deps/text/text_config.h
new file mode 100644
index 0000000..179098d
--- /dev/null
+++ b/deps/text/text_config.h
@@ -0,0 +1,40 @@
+/*
+ * Author: daddinuz
+ * email:  daddinuz@gmail.com
+ *
+ * Copyright (c) 2018 Davide Di Carlo
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * 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.
+ */
+
+#pragma once
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define TEXT_DEFAULT_CAPACITY   128UL   // must be greater or equal than 32UL and less than SIZE_MAX
+#define TEXT_LOAD_FACTOR        1.6F    // must be greater than 1.1F
+
+#ifdef __cplusplus
+}
+#endif
diff --git a/deps/traits-unit/build.cmake b/deps/traits-unit/build.cmake
new file mode 100644
index 0000000..c291488
--- /dev/null
+++ b/deps/traits-unit/build.cmake
@@ -0,0 +1,6 @@
+set(ARCHIVE_NAME traits-unit)
+message("${ARCHIVE_NAME}@${CMAKE_CURRENT_LIST_DIR} using: ${CMAKE_CURRENT_LIST_FILE}")
+
+file(GLOB ARCHIVE_HEADERS ${CMAKE_CURRENT_LIST_DIR}/*.h)
+file(GLOB ARCHIVE_SOURCES ${CMAKE_CURRENT_LIST_DIR}/*.c)
+add_library(${ARCHIVE_NAME} ${ARCHIVE_HEADERS} ${ARCHIVE_SOURCES})
diff --git a/deps/traits-unit/package.json b/deps/traits-unit/package.json
new file mode 100644
index 0000000..4a3f3f3
--- /dev/null
+++ b/deps/traits-unit/package.json
@@ -0,0 +1,24 @@
+{
+  "name": "traits-unit",
+  "repo": "daddinuz/traits-unit",
+  "version": "3.0.0",
+  "license": "MIT",
+  "description": "Unittest framework written in C99.",
+  "keywords": [
+    "test",
+    "unittest",
+    "framework",
+    "unit-test",
+    "unittesting",
+    "unit-testing",
+    "test-framework"
+  ],
+  "development": {
+    "daddinuz/traits": "3.2.0"
+  },
+  "src": [
+    "sources/traits-unit.h",
+    "sources/traits-unit.c"
+  ],
+  "makefile": "sources/build.cmake"
+}
diff --git a/deps/traits-unit/traits-unit.c b/deps/traits-unit/traits-unit.c
new file mode 100644
index 0000000..1dd19ea
--- /dev/null
+++ b/deps/traits-unit/traits-unit.c
@@ -0,0 +1,597 @@
+/*
+ * Author: daddinuz
+ * email:  daddinuz@gmail.com
+ *
+ * Copyright (c) 2018 Davide Di Carlo
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * 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 <errno.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdarg.h>
+#include <string.h>
+#include <assert.h>
+#include <unistd.h>
+#include <sys/mman.h>
+#include <sys/wait.h>
+#include "traits-unit.h"
+
+/*
+ * Internal macro to disable compiler tricks on unsupported platforms
+ */
+#if !(defined(__GNUC__) || defined(__clang__))
+#define __attribute__(...)
+#endif
+
+/*
+ * Some constants
+ */
+#define TRAITS_UNIT_OUTPUT_STREAM                       stdout
+#define TRAITS_UNIT_BUFFER_CAPACITY                     1024
+#define TRAITS_UNIT_INDENTATION_STEP                    2
+#define TRAITS_UNIT_INDENTATION_START                   0
+
+/*
+ * Forward declare traits subject (this should come from the test file Describe macro)
+ */
+extern traits_unit_subject_t traits_unit_subject;
+
+/*
+ * Define private global variables
+ */
+jmp_buf __traits_unit_jump_buffer;
+
+/*
+ * Define internal global variables
+ */
+static int global_signal_id = 0;
+static int global_wrapping_attempts = 0;
+static void (*global_previous_signal_handler)(int) = NULL;
+static volatile sig_atomic_t global_wrapped_signals_counter = 0;
+
+static void *global_context = NULL;
+static bool global_context_initialized = false;
+static traits_unit_feature_t *global_feature = NULL;
+
+/*
+ * Define internal types
+ */
+typedef struct traits_unit_buffer_t {
+    size_t _index;
+    size_t _capacity;
+    char *_content;
+} traits_unit_buffer_t;
+
+typedef struct traits_unit_trait_result_t {
+    size_t succeed;
+    size_t skipped;
+    size_t failed;
+    size_t todo;
+    size_t all;
+} traits_unit_trait_result_t;
+
+typedef enum traits_unit_feature_result_t {
+    TRAITS_UNIT_FEATURE_RESULT_SUCCEED,
+    TRAITS_UNIT_FEATURE_RESULT_SKIPPED,
+    TRAITS_UNIT_FEATURE_RESULT_FAILED,
+    TRAITS_UNIT_FEATURE_RESULT_TODO,
+} traits_unit_feature_result_t;
+
+/*
+ * Declare internal functions
+ */
+static void *
+traits_unit_shared_malloc(size_t size);
+
+static void
+traits_unit_shared_free(void *address, size_t size);
+
+static traits_unit_buffer_t *
+traits_unit_buffer_new(size_t capacity);
+
+static void
+traits_unit_buffer_read(traits_unit_buffer_t *buffer, int fd);
+
+static char *
+traits_unit_buffer_get(traits_unit_buffer_t *buffer);
+
+static void
+traits_unit_buffer_clear(traits_unit_buffer_t *buffer);
+
+static void
+traits_unit_buffer_delete(traits_unit_buffer_t **buffer);
+
+static void
+_traits_unit_panic(size_t line, const char *file, const char *fmt, ...)
+__attribute__((__noreturn__, __format__(__printf__, 3, 4)));
+
+static void
+traits_unit_print(size_t indentation_level, const char *fmt, ...)
+__attribute__((__format__(__printf__, 2, 3)));
+
+static void
+traits_unit_teardown(void);
+
+static void
+traits_unit_register_teardown_on_exit(void);
+
+static traits_unit_trait_result_t
+traits_unit_run_trait(size_t indentation_level, traits_unit_trait_t *trait, traits_unit_buffer_t *buffer);
+
+static int
+traits_unit_fork_and_run_feature(traits_unit_feature_t *feature, traits_unit_buffer_t *buffer);
+
+static traits_unit_feature_result_t
+traits_unit_run_feature(size_t indentation_level, traits_unit_feature_t *feature, traits_unit_buffer_t *buffer);
+
+static void
+traits_unit_report(size_t indentation_level, size_t succeed, size_t skipped, size_t failed, size_t todo, size_t all);
+
+static void
+traits_unit_signal_handler(int signal_id);
+
+/*
+ * Define internal macros
+ */
+#define traits_unit_panic(fmt, ...)     _traits_unit_panic(__LINE__, __FILE__, fmt, __VA_ARGS__)
+#define traits_unit_newline()           traits_unit_print(0, "\n")
+
+/*
+ * Define public functions
+ */
+const char *
+traits_unit_version(void) {
+    return (TRAITS_UNIT_VERSION_IS_RELEASE || sizeof(TRAITS_UNIT_VERSION_SUFFIX) <= 1)
+           ?
+           __TRAITS_UNIT_TO_STRING(TRAITS_UNIT_VERSION_MAJOR) "."
+           __TRAITS_UNIT_TO_STRING(TRAITS_UNIT_VERSION_MINOR) "."
+           __TRAITS_UNIT_TO_STRING(TRAITS_UNIT_VERSION_PATCH)
+           :
+           __TRAITS_UNIT_TO_STRING(TRAITS_UNIT_VERSION_MAJOR) "."
+           __TRAITS_UNIT_TO_STRING(TRAITS_UNIT_VERSION_MINOR) "."
+           __TRAITS_UNIT_TO_STRING(TRAITS_UNIT_VERSION_PATCH) "-"
+           TRAITS_UNIT_VERSION_SUFFIX;
+}
+
+void *
+traits_unit_get_context(void) {
+    if (!global_context_initialized) {
+        traits_unit_panic("Unexpected call to %s outside feature-cycle scope\n", __func__);
+    }
+    return global_context;
+}
+
+size_t
+traits_unit_get_wrapped_signals_counter(void) {
+    if (global_wrapped_signals_counter < 0) {
+        // this should never happen
+        traits_unit_panic("Unexpected wrapped signals counter value: %ld\n", (long) global_wrapped_signals_counter);
+    }
+    return (size_t) global_wrapped_signals_counter;
+}
+
+/*
+ * Define main
+ */
+int
+main(int argc, char *argv[]) {
+    bool loaded = true;
+    traits_unit_buffer_t *buffer = NULL;
+    traits_unit_trait_t *traits_list[TRAITS_UNIT_MAX_TRAITS] = {0};
+    size_t counter_succeed = 0, counter_skipped = 0, counter_failed = 0, counter_todo = 0, counter_all = 0;
+    size_t indentation_level = TRAITS_UNIT_INDENTATION_START;
+
+    traits_unit_print(0, "Running traits-unit version %s\n\n", traits_unit_version());
+
+    /* Load traits_list */
+    if (argc > 1) {
+        /* Specific traits must be run */
+        if (argc > TRAITS_UNIT_MAX_TRAITS) {
+            /* Too many traits has been specified, not able to load traits_list */
+            loaded = false;
+            traits_unit_print(indentation_level, "Too many traits specified\n");
+        } else {
+            /* Search for the specified traits and load them into traits_list */
+            size_t index = 0;
+            traits_unit_trait_t *trait = NULL;
+            for (int x = 1; x < argc; x++) {
+                bool found = false;
+                for (size_t y = 0; (trait = &traits_unit_subject.traits[y]) && trait->trait_name; y++) {
+                    if (0 == strcmp(trait->trait_name, argv[x])) {
+                        found = true;
+                        traits_list[index++] = trait;
+                    }
+                }
+                if (!found) {
+                    /* No such trait found, not able to load traits_list */
+                    loaded = false;
+                    traits_unit_print(indentation_level, "Unknown trait: `%s`\n", argv[x]);
+                    break;
+                }
+            }
+        }
+    } else {
+        /* Load all traits present in traits_subject */
+        for (size_t i = 0; i < TRAITS_UNIT_MAX_TRAITS; i++) {
+            traits_list[i] = &traits_unit_subject.traits[i];
+        }
+    }
+
+    if (loaded) {
+        /* Run features of traits in traits_list */
+        traits_unit_trait_t *trait = NULL;
+        buffer = traits_unit_buffer_new(TRAITS_UNIT_BUFFER_CAPACITY);
+        traits_unit_print(indentation_level, "Describing: %s\n", traits_unit_subject.subject);
+        indentation_level += TRAITS_UNIT_INDENTATION_STEP;
+        for (size_t i = 0; (trait = traits_list[i]) && trait->trait_name; i++) {
+            traits_unit_trait_result_t trait_result = traits_unit_run_trait(indentation_level, trait, buffer);
+            counter_succeed += trait_result.succeed;
+            counter_skipped += trait_result.skipped;
+            counter_failed += trait_result.failed;
+            counter_todo += trait_result.todo;
+            counter_all += trait_result.all;
+        }
+        indentation_level -= TRAITS_UNIT_INDENTATION_STEP;
+        traits_unit_report(
+                indentation_level, counter_succeed, counter_skipped, counter_failed, counter_todo, counter_all
+        );
+        traits_unit_buffer_delete(&buffer);
+    }
+
+    return (loaded && (0 == counter_failed)) ? EXIT_SUCCESS : EXIT_FAILURE;
+}
+
+/*
+ * Define private functions
+ */
+void
+__traits_unit_wraps_enter(int signal_id) {
+    fflush(TRAITS_UNIT_OUTPUT_STREAM);
+    global_signal_id = signal_id;
+    global_wrapping_attempts = 1;
+    global_previous_signal_handler = signal(global_signal_id, traits_unit_signal_handler);
+}
+
+bool
+__traits_unit_wraps_is_done(void) {
+    return 0 != global_wrapping_attempts--;
+}
+
+void
+__traits_unit_wraps_exit(void) {
+    fflush(TRAITS_UNIT_OUTPUT_STREAM);
+    signal(global_signal_id, global_previous_signal_handler);
+    global_previous_signal_handler = NULL;
+    global_wrapping_attempts = 0;
+    global_signal_id = 0;
+}
+
+Setup(__TraitsUnitDefaultSetup) {
+    return NULL;
+}
+
+Teardown(__TraitsUnitDefaultTeardown) {
+
+}
+
+FixtureImplements(__TraitsUnitDefaultFixture, __TraitsUnitDefaultSetup, __TraitsUnitDefaultTeardown);
+
+/*
+ * Define internal functions
+ */
+void *
+traits_unit_shared_malloc(size_t size) {
+    /* Our memory will be readable and writable */
+    int protection = PROT_READ | PROT_WRITE;
+
+    /*
+     * The buffer will be shared (meaning other processes can access it), but
+     * anonymous (meaning third-party processes cannot obtain an address for it),
+     * so only this process and its children will be able to use it.
+     */
+    int visibility = MAP_ANONYMOUS | MAP_SHARED;
+
+    /* Perform memory mapping */
+    void *memory = mmap(NULL, size, protection, visibility, 0, 0);
+    if (!memory) {
+        traits_unit_panic("%s\n", "Unable to map memory");
+    }
+
+    return memory;
+}
+
+void
+traits_unit_shared_free(void *address, size_t size) {
+    if (0 != munmap(address, size)) {
+        traits_unit_panic("%s\n", "Unable to unmap memory");
+    }
+}
+
+traits_unit_buffer_t *
+traits_unit_buffer_new(size_t capacity) {
+    traits_unit_buffer_t *self = traits_unit_shared_malloc(sizeof(*self));
+    if (!self) {
+        traits_unit_panic("%s\n", "Out of memory.");
+        abort(); // not needed just to quiet analyzer
+    }
+    self->_content = traits_unit_shared_malloc(capacity + 1);
+    if (!self->_content) {
+        traits_unit_panic("%s\n", "Out of memory.");
+    }
+    self->_index = 0;
+    self->_capacity = capacity;
+    self->_content[capacity] = 0;
+    return self;
+}
+
+void
+traits_unit_buffer_read(traits_unit_buffer_t *buffer, int fd) {
+    assert(buffer);
+    FILE *stream = fdopen(fd, "r");
+
+    /* Open fd */
+    if (!stream) {
+        traits_unit_panic("%s\n", "Unable to open file.");
+    }
+
+    /* Read from fd and write to buffer */
+    buffer->_index += fread(
+            buffer->_content + buffer->_index,
+            sizeof(buffer->_content[0]),
+            (buffer->_index >= buffer->_capacity) ? 0 : buffer->_capacity - buffer->_index,
+            stream
+    );
+    buffer->_content[buffer->_index] = 0;
+
+    /* Close the stream */
+    fclose(stream);
+}
+
+char *
+traits_unit_buffer_get(traits_unit_buffer_t *buffer) {
+    assert(buffer);
+    return buffer->_content;
+}
+
+void
+traits_unit_buffer_clear(traits_unit_buffer_t *buffer) {
+    assert(buffer);
+    buffer->_index = 0;
+    buffer->_content[0] = 0;
+}
+
+void
+traits_unit_buffer_delete(traits_unit_buffer_t **buffer) {
+    assert(buffer && *buffer);
+    traits_unit_shared_free((*buffer)->_content, (*buffer)->_capacity + 1);
+    traits_unit_shared_free(*buffer, sizeof(*buffer));
+    *buffer = NULL;
+}
+
+void
+_traits_unit_panic(size_t line, const char *file, const char *fmt, ...) {
+    va_list args;
+    va_start(args, fmt);
+    fprintf(stderr, "\nAt %s:%zu\nError: %s\n", file, line, strerror(errno));
+    vfprintf(stderr, fmt, args);
+    fputs("", stderr);
+    va_end(args);
+    exit(-1);
+}
+
+void
+traits_unit_print(size_t indentation_level, const char *fmt, ...) {
+    va_list args;
+    va_start(args, fmt);
+    fprintf(TRAITS_UNIT_OUTPUT_STREAM, "%*s", (int) indentation_level, "");
+    vfprintf(TRAITS_UNIT_OUTPUT_STREAM, fmt, args);
+    va_end(args);
+}
+
+void
+traits_unit_teardown(void) {
+    if (!global_feature) {
+        traits_unit_panic("%s\n", "Unexpected error");
+    }
+    global_feature->fixture->teardown();
+    global_context_initialized = false;
+    global_context = NULL;
+    global_feature = NULL;
+}
+
+void
+traits_unit_register_teardown_on_exit(void) {
+    atexit(traits_unit_teardown);
+}
+
+traits_unit_trait_result_t
+traits_unit_run_trait(size_t indentation_level, traits_unit_trait_t *trait, traits_unit_buffer_t *buffer) {
+    traits_unit_trait_result_t trait_result;
+    memset(&trait_result, 0, sizeof(trait_result));
+    traits_unit_feature_t *feature = NULL;
+    traits_unit_print(indentation_level, "Trait: %s\n", trait->trait_name);
+    indentation_level += TRAITS_UNIT_INDENTATION_STEP;
+    for (size_t i = 0; (feature = &trait->features[i]) && feature->feature && feature->feature_name; i++) {
+        traits_unit_feature_result_t feature_result = traits_unit_run_feature(indentation_level, feature, buffer);
+        switch (feature_result) {
+            case TRAITS_UNIT_FEATURE_RESULT_SUCCEED: {
+                trait_result.succeed++;
+                break;
+            }
+            case TRAITS_UNIT_FEATURE_RESULT_SKIPPED: {
+                trait_result.skipped++;
+                break;
+            }
+            case TRAITS_UNIT_FEATURE_RESULT_FAILED: {
+                trait_result.failed++;
+                break;
+            }
+            case TRAITS_UNIT_FEATURE_RESULT_TODO: {
+                trait_result.todo++;
+                break;
+            }
+            default: {
+                traits_unit_panic("Unexpected traits_unit_feature_result_t value: %d\n", feature_result);
+            }
+        }
+        trait_result.all++;
+    }
+    return trait_result;
+}
+
+int
+traits_unit_fork_and_run_feature(traits_unit_feature_t *feature, traits_unit_buffer_t *buffer) {
+    pid_t pid;
+    int fd, pipe_fd[2], pid_status;
+
+    /* Flush TRAITS_UNIT_OUTPUT_STREAM */
+    fflush(TRAITS_UNIT_OUTPUT_STREAM);
+
+    /* Open a pipe */
+    if (pipe(pipe_fd) < 0) {
+        traits_unit_panic("%s\n", "Unable to open pipe.");
+    }
+
+    /* Fork the process */
+    if ((pid = fork()) < 0) {
+        traits_unit_panic("%s\n", "Unable to fork process.");
+    }
+
+    /* We are in the child process */
+    if (0 == pid) {
+        /* Close read end of pipe */
+        close(pipe_fd[0]);
+
+        /* Get write end of pipe */
+        fd = pipe_fd[1];
+
+        /* Redirect STDERR to pipe*/
+        dup2(fd, STDERR_FILENO);
+
+        /* Setup globals */
+        global_feature = feature;
+        global_context = feature->fixture->setup();
+        global_context_initialized = true;
+
+        /* Teardown globals on exit */
+        traits_unit_register_teardown_on_exit();
+
+        /* Run feature */
+        feature->feature();
+
+        /* Close fd */
+        close(fd);
+
+        /* Exit normally */
+        exit(EXIT_SUCCESS);
+    }
+
+    /* We are in the parent process */
+
+    /* Wait for children */
+    wait(&pid_status);
+
+    /* Close write end of pipe */
+    close(pipe_fd[1]);
+
+    /* Get read end of pipe */
+    fd = pipe_fd[0];
+
+    /* Redirect the children output to the global buffer */
+    traits_unit_buffer_read(buffer, fd);
+
+    /* Close fd */
+    close(fd);
+
+    /* Flush TRAITS_UNIT_OUTPUT_STREAM */
+    fflush(TRAITS_UNIT_OUTPUT_STREAM);
+    return pid_status;
+}
+
+traits_unit_feature_result_t
+traits_unit_run_feature(size_t indentation_level, traits_unit_feature_t *feature, traits_unit_buffer_t *buffer) {
+    traits_unit_feature_result_t result;
+    traits_unit_print(indentation_level, "Feature: %s... ", feature->feature_name);
+    switch (feature->action) {
+        case TRAITS_UNIT_ACTION_RUN: {
+            traits_unit_buffer_clear(buffer);
+            const int exit_status = traits_unit_fork_and_run_feature(feature, buffer);
+            if (EXIT_SUCCESS == exit_status) {
+                result = TRAITS_UNIT_FEATURE_RESULT_SUCCEED;
+                traits_unit_print(0, "succeed\n");
+            } else {
+                result = TRAITS_UNIT_FEATURE_RESULT_FAILED;
+                if (!WIFEXITED(exit_status)) {
+                    if (WIFSIGNALED(exit_status)) {
+                        traits_unit_print(
+                                0, "(terminated by signal %d - %s) ",
+                                WTERMSIG(exit_status), strsignal(WTERMSIG(exit_status))
+                        );
+                    } else {
+                        traits_unit_print(0, "(terminated abnormally) ");
+                    }
+                }
+                traits_unit_print(0, "failed\n\n%s\n", traits_unit_buffer_get(buffer));
+            }
+            break;
+        }
+        case TRAITS_UNIT_ACTION_SKIP: {
+            result = TRAITS_UNIT_FEATURE_RESULT_SKIPPED;
+            traits_unit_print(0, "skipped\n");
+            break;
+        }
+        case TRAITS_UNIT_ACTION_TODO: {
+            result = TRAITS_UNIT_FEATURE_RESULT_TODO;
+            traits_unit_print(0, "todo\n");
+            break;
+        }
+        default: {
+            traits_unit_panic("Unexpected traits_unit_action_t value: %d\n", feature->action);
+            abort();  // not needed, used to quiet analyzer
+        }
+    }
+    return result;
+}
+
+void
+traits_unit_report(size_t indentation_level, size_t succeed, size_t skipped, size_t failed, size_t todo, size_t all) {
+    traits_unit_newline();
+    const int width = snprintf(NULL, 0, "%zu", all);
+    traits_unit_print(indentation_level, "Succeed: %*zu\n", width, succeed);
+    traits_unit_print(indentation_level, "Skipped: %*zu\n", width, skipped);
+    traits_unit_print(indentation_level, " Failed: %*zu\n", width, failed);
+    traits_unit_print(indentation_level, "   Todo: %*zu\n", width, todo);
+    traits_unit_print(indentation_level, "    All: %*zu\n", width, all);
+}
+
+void
+traits_unit_signal_handler(int signal_id) {
+    fflush(TRAITS_UNIT_OUTPUT_STREAM);
+    if (signal_id != global_signal_id) {
+        exit(-1);   // ensure we are handling the same signal
+    }
+    global_wrapped_signals_counter++;
+    signal(signal_id, global_previous_signal_handler);
+    siglongjmp(__traits_unit_jump_buffer, 1);
+}
diff --git a/deps/traits-unit/traits-unit.h b/deps/traits-unit/traits-unit.h
new file mode 100644
index 0000000..1de7735
--- /dev/null
+++ b/deps/traits-unit/traits-unit.h
@@ -0,0 +1,200 @@
+/*
+ * Author: daddinuz
+ * email:  daddinuz@gmail.com
+ *
+ * Copyright (c) 2018 Davide Di Carlo
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * 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.
+ */
+
+#pragma once
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <stddef.h>
+#include <signal.h>
+#include <setjmp.h>
+#include <stdbool.h>
+
+#if !(defined(__GNUC__) || defined(__clang__))
+#define __attribute__(...)
+#endif
+
+/* [public section begin] */
+
+/*
+* Versioning
+*/
+#define TRAITS_UNIT_VERSION_MAJOR       3
+#define TRAITS_UNIT_VERSION_MINOR       0
+#define TRAITS_UNIT_VERSION_PATCH       0
+#define TRAITS_UNIT_VERSION_SUFFIX      ""
+#define TRAITS_UNIT_VERSION_IS_RELEASE  1
+#define TRAITS_UNIT_VERSION_HEX         0x030000
+
+/*
+ * Constants
+ */
+#define TRAITS_UNIT_MAX_TRAITS          96
+#define TRAITS_UNIT_MAX_FEATURES        64
+
+/*
+ * Types
+ */
+typedef void *traits_unit_setup_fn(void);
+typedef void traits_unit_teardown_fn(void);
+
+typedef struct traits_unit_fixture_t {
+    traits_unit_setup_fn *setup;
+    traits_unit_teardown_fn *teardown;
+} traits_unit_fixture_t;
+
+typedef void traits_unit_feature_fn(void);
+
+typedef enum traits_unit_action_t {
+    TRAITS_UNIT_ACTION_RUN,
+    TRAITS_UNIT_ACTION_SKIP,
+    TRAITS_UNIT_ACTION_TODO
+} traits_unit_action_t;
+
+typedef struct traits_unit_feature_t {
+    const char *feature_name;
+    traits_unit_fixture_t *fixture;
+    traits_unit_feature_fn *feature;
+    traits_unit_action_t action;
+} traits_unit_feature_t;
+
+typedef struct traits_unit_trait_t {
+    const char *trait_name;
+    traits_unit_feature_t features[TRAITS_UNIT_MAX_FEATURES];
+} traits_unit_trait_t;
+
+typedef struct traits_unit_subject_t {
+    const char *subject;
+    traits_unit_trait_t traits[TRAITS_UNIT_MAX_TRAITS];
+} traits_unit_subject_t;
+
+/*
+ * Functions
+ */
+extern const char *
+traits_unit_version(void);
+
+extern void *
+traits_unit_get_context(void);
+
+extern size_t
+traits_unit_get_wrapped_signals_counter(void);
+
+/*
+ * Declare main in order to force definition by traits-unit
+ */
+extern int
+main(int argc, char *argv[]);
+
+/*
+ * Macros
+ */
+#define Setup(Name)                       \
+    void *__TRAITS_UNIT_SETUP_ID(Name)(void)        // NOLINT
+
+#define Teardown(Name)                    \
+    void __TRAITS_UNIT_TEARDOWN_ID(Name)(void)
+
+#define Feature(Name)                     \
+    void __TRAITS_UNIT_FEATURE_ID(Name)(void)
+
+#define Fixture(Name)                    \
+    extern traits_unit_fixture_t __TRAITS_UNIT_FIXTURE_ID(Name)
+
+#define FixtureImplements(Name, Setup, Teardown)    \
+    traits_unit_fixture_t __TRAITS_UNIT_FIXTURE_ID(Name) = {.setup=__TRAITS_UNIT_SETUP_ID(Setup), .teardown=__TRAITS_UNIT_TEARDOWN_ID(Teardown)}
+
+#define Describe(Subject, ...)                  \
+    traits_unit_subject_t traits_unit_subject = {.subject=(Subject), .traits={__VA_ARGS__}};
+
+#define Trait(Name, ...)                        \
+    {.trait_name=(Name), .features={__VA_ARGS__}}
+
+#define Run(...)                                \
+    __TRAITS_UNIT_FEATURE_RUN(__VA_ARGS__, __TraitsUnitDefaultFixture, __TraitsUnitDefaultFixture)
+
+#define Skip(...)                               \
+    __TRAITS_UNIT_FEATURE_SKIP(__VA_ARGS__, __TraitsUnitDefaultFixture, __TraitsUnitDefaultFixture)
+
+#define Todo(...)                               \
+    __TRAITS_UNIT_FEATURE_TODO(__VA_ARGS__, __TraitsUnitDefaultFixture, __TraitsUnitDefaultFixture)
+
+/*
+ * Helper macro to handle signals
+ */
+#define traits_unit_wraps(xSignalId)                                                    \
+    for (                                                                               \
+        __traits_unit_wraps_enter((xSignalId));                                         \
+        !sigsetjmp(__traits_unit_jump_buffer, true) && __traits_unit_wraps_is_done();   \
+        __traits_unit_wraps_exit()                                                      \
+    )
+
+/* [public section end] */
+
+/* [private section begin] */
+
+#define __TRAITS_UNIT_CAT_IMPL_(x, ...)      x ## __VA_ARGS__
+#define __TRAITS_UNIT_CAT(x, ...)           __TRAITS_UNIT_CAT_IMPL_(x, __VA_ARGS__)
+
+#define __TRAITS_UNIT_TO_STRING_IMPL_(x)     #x
+#define __TRAITS_UNIT_TO_STRING(x)          __TRAITS_UNIT_TO_STRING_IMPL_(x)
+
+#define __TRAITS_UNIT_SETUP_ID(Name)        __TRAITS_UNIT_CAT(traits_unit_user_setup_, Name)
+#define __TRAITS_UNIT_TEARDOWN_ID(Name)     __TRAITS_UNIT_CAT(traits_unit_user_teardown_, Name)
+#define __TRAITS_UNIT_FIXTURE_ID(Name)      __TRAITS_UNIT_CAT(traits_unit_user_fixture_, Name)
+#define __TRAITS_UNIT_FEATURE_ID(Name)      __TRAITS_UNIT_CAT(traits_unit_user_feature_, Name)
+
+#define __TRAITS_UNIT_FEATURE_RUN(Name, Fixture, ...)               \
+    {.feature_name=__TRAITS_UNIT_TO_STRING(Name), .feature=__TRAITS_UNIT_FEATURE_ID(Name), .fixture=&__TRAITS_UNIT_FIXTURE_ID(Fixture), .action=TRAITS_UNIT_ACTION_RUN}
+
+#define __TRAITS_UNIT_FEATURE_SKIP(Name, Fixture, ...)              \
+    {.feature_name=__TRAITS_UNIT_TO_STRING(Name), .feature=__TRAITS_UNIT_FEATURE_ID(Name), .fixture=&__TRAITS_UNIT_FIXTURE_ID(Fixture), .action=TRAITS_UNIT_ACTION_SKIP}
+
+#define __TRAITS_UNIT_FEATURE_TODO(Name, Fixture, ...)              \
+    {.feature_name=__TRAITS_UNIT_TO_STRING(Name), .feature=__TRAITS_UNIT_FEATURE_ID(Name), .fixture=&__TRAITS_UNIT_FIXTURE_ID(Fixture), .action=TRAITS_UNIT_ACTION_TODO}
+
+extern jmp_buf __traits_unit_jump_buffer;
+
+extern void
+__traits_unit_wraps_enter(int signal_id);
+
+extern bool
+__traits_unit_wraps_is_done(void);
+
+extern void
+__traits_unit_wraps_exit(void);
+
+Fixture(__TraitsUnitDefaultFixture);
+
+/* [private section end] */
+
+#ifdef __cplusplus
+}
+#endif
diff --git a/deps/traits/package.json b/deps/traits/package.json
new file mode 100644
index 0000000..e7f2f63
--- /dev/null
+++ b/deps/traits/package.json
@@ -0,0 +1,15 @@
+{
+  "name": "traits",
+  "repo": "daddinuz/traits",
+  "version": "3.2.0",
+  "license": "MIT",
+  "description": "Assertions library written in C99.",
+  "keywords": [
+    "assert",
+    "assertions",
+    "assertions-library"
+  ],
+  "src": [
+    "sources/traits.h"
+  ]
+}
diff --git a/deps/traits/traits.h b/deps/traits/traits.h
new file mode 100644
index 0000000..7feb922
--- /dev/null
+++ b/deps/traits/traits.h
@@ -0,0 +1,264 @@
+/*
+ * Author: daddinuz
+ * email:  daddinuz@gmail.com
+ *
+ * Copyright (c) 2018 Davide Di Carlo
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * 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 <stdio.h>
+#include <stdlib.h>
+#include <stdarg.h>
+#include <string.h>
+#include <memory.h>
+#include <stdbool.h>
+
+
+#ifndef TRAITS_INCLUDED
+#define TRAITS_INCLUDED
+
+#define TRAITS_VERSION_MAJOR                        3
+#define TRAITS_VERSION_MINOR                        2
+#define TRAITS_VERSION_PATCH                        0
+#define TRAITS_VERSION_SUFFIX                       ""
+#define TRAITS_VERSION_IS_RELEASE                   1
+#define TRAITS_VERSION_HEX                          0x030200
+
+#if !(defined(__GNUC__) || defined(__clang__))
+#define __attribute__(...)
+#endif
+
+#define __TRAITS_CAT_IMPL_(x, ...)                  x ## __VA_ARGS__
+#define __TRAITS_CAT(x, ...)                        __TRAITS_CAT_IMPL_(x, __VA_ARGS__)
+
+#define __TRAITS_TO_STRING_IMPL_(x)                 #x
+#define __TRAITS_TO_STRING(x)                       __TRAITS_TO_STRING_IMPL_(x)
+
+#define __TRAITS_MORE_THAN_ONE_IMPL_(/**/   \
+        _1, _2, _3, _4, _5, _6, _7, _8, \
+        _9, _a, _b, _c, _d, _e, _f, _g, \
+        _h, _i, _j, _k, _l, _m, _n, _o, \
+        _p, _q, _r, _s, _t, _u, _v, _w, \
+        N, ...)                                     N
+
+#define __TRAITS_MORE_THAN_ONE(...)                 __TRAITS_MORE_THAN_ONE_IMPL_(           \
+                                                        __VA_ARGS__, 1, 1, 1, 1, 1, 1, 1,   \
+                                                        1, 1, 1, 1, 1, 1, 1, 1,             \
+                                                        1, 1, 1, 1, 1, 1, 1, 1,             \
+                                                        1, 1, 1, 1, 1, 1, 1, 1,             \
+                                                        0, 0                                \
+                                                    )
+
+#define __TRAITS_MORE_THAN_TWO_IMPL_(/**/   \
+        _1, _2, _3, _4, _5, _6, _7, _8, \
+        _9, _a, _b, _c, _d, _e, _f, _g, \
+        _h, _i, _j, _k, _l, _m, _n, _o, \
+        _p, _q, _r, _s, _t, _u, _v, _w, \
+        _x, N, ...)                                 N
+
+#define __TRAITS_MORE_THAN_TWO(...)                 __TRAITS_MORE_THAN_TWO_IMPL_(           \
+                                                        __VA_ARGS__, 1, 1, 1, 1, 1, 1, 1,   \
+                                                        1, 1, 1, 1, 1, 1, 1, 1,             \
+                                                        1, 1, 1, 1, 1, 1, 1, 1,             \
+                                                        1, 1, 1, 1, 1, 1, 1, 1,             \
+                                                        0, 0, 0                             \
+                                                    )
+
+#define __TRAITS_MORE_THAN_THREE_IMPL_(/**/ \
+        _1, _2, _3, _4, _5, _6, _7, _8, \
+        _9, _a, _b, _c, _d, _e, _f, _g, \
+        _h, _i, _j, _k, _l, _m, _n, _o, \
+        _p, _q, _r, _s, _t, _u, _v, _w, \
+        _x, _A, N, ...)                             N
+
+#define __TRAITS_MORE_THAN_THREE(...)               __TRAITS_MORE_THAN_THREE_IMPL_(         \
+                                                        __VA_ARGS__, 1, 1, 1, 1, 1, 1, 1,   \
+                                                        1, 1, 1, 1, 1, 1, 1, 1,             \
+                                                        1, 1, 1, 1, 1, 1, 1, 1,             \
+                                                        1, 1, 1, 1, 1, 1, 1, 1,             \
+                                                        0, 0, 0, 0                          \
+                                                    )
+
+#define __TRAITS_STATIC_IF_0(x, y)                  x
+#define __TRAITS_STATIC_IF_1(x, y)                  y
+#define __TRAITS_STATIC_IF(c)                       __TRAITS_CAT(__TRAITS_STATIC_IF_, c)
+
+#define __TRAITS_OVERLOAD_ONE(f0, f1, ...)          __TRAITS_STATIC_IF(__TRAITS_MORE_THAN_ONE(__VA_ARGS__))(f0, f1)(__VA_ARGS__)
+#define __TRAITS_OVERLOAD_TWO(f0, f1, ...)          __TRAITS_STATIC_IF(__TRAITS_MORE_THAN_TWO(__VA_ARGS__))(f0, f1)(__VA_ARGS__)
+#define __TRAITS_OVERLOAD_THREE(f0, f1, ...)        __TRAITS_STATIC_IF(__TRAITS_MORE_THAN_THREE(__VA_ARGS__))(f0, f1)(__VA_ARGS__)
+
+/*
+ * Helpers
+ */
+#define eq(e, a)                                    ((e) == (a))
+#define ne(e, a)                                    ((e) != (a))
+#define gt(e, a)                                    ((e)  > (a))
+#define ge(e, a)                                    ((e) >= (a))
+#define lt(e, a)                                    ((e)  < (a))
+#define le(e, a)                                    ((e) <= (a))
+
+#define as(T, x)                                    ((T)(x))
+#define eq_as(T, e, a)                              eq(as(T, e), as(T, a))
+#define ne_as(T, e, a)                              ne(as(T, e), as(T, a))
+#define gt_as(T, e, a)                              gt(as(T, e), as(T, a))
+#define ge_as(T, e, a)                              ge(as(T, e), as(T, a))
+#define lt_as(T, e, a)                              lt(as(T, e), as(T, a))
+#define le_as(T, e, a)                              le(as(T, e), as(T, a))
+
+/*
+ * Assertions framework
+ */
+static inline const char *
+traits_version(void) {
+    return (TRAITS_VERSION_IS_RELEASE || sizeof(TRAITS_VERSION_SUFFIX) <= 1)
+           ?
+           __TRAITS_TO_STRING(TRAITS_VERSION_MAJOR) "."
+                   __TRAITS_TO_STRING(TRAITS_VERSION_MINOR) "."
+                   __TRAITS_TO_STRING(TRAITS_VERSION_PATCH)
+           :
+           __TRAITS_TO_STRING(TRAITS_VERSION_MAJOR) "."
+                   __TRAITS_TO_STRING(TRAITS_VERSION_MINOR) "."
+                   __TRAITS_TO_STRING(TRAITS_VERSION_PATCH) "-"
+                   TRAITS_VERSION_SUFFIX;
+}
+
+static void
+__traits_assert(bool condition, size_t line, const char *file, const char *assertion, const char *message, ...)
+__attribute__((__format__(__printf__, 5, 6)));
+
+inline void
+__traits_assert(bool condition, size_t line, const char *file, const char *assertion, const char *message, ...) {
+    va_list args;
+    if (!condition) {
+        fprintf(stderr, "At %s:%zu\nAssertion `%s` failed.\n", file, line, assertion);
+        va_start(args, message);
+        vfprintf(stderr, message, args);
+        va_end(args);
+        exit(1);
+    }
+}
+
+#define __traits_helper_x(A, x, ...)                __traits_assert((x), __LINE__, __FILE__, A, __VA_ARGS__)
+#define __traits_helper_0(A, x)                     __traits_helper_x(A, x, NULL)
+#define __traits_helper_1(A, x, ...)                __traits_helper_x(A, x, __VA_ARGS__)
+#define __traits_helper(A, ...)                     __TRAITS_STATIC_IF(__TRAITS_MORE_THAN_ONE(__VA_ARGS__))(__traits_helper_0, __traits_helper_1)(A, __VA_ARGS__)
+
+/*
+ * Basic
+ */
+#define __traits_assert_x(x, ...)                   do { const bool __traits_x = (x); __traits_helper(__TRAITS_TO_STRING(x), eq(true, __traits_x), __VA_ARGS__); } while(false)
+#define __traits_assert_0(x)                        __traits_assert_x(x, NULL)
+#define __traits_assert_1(x, ...)                   __traits_assert_x(x, __VA_ARGS__)
+#define traits_assert(...)                          __TRAITS_OVERLOAD_ONE(__traits_assert_0, __traits_assert_1, __VA_ARGS__)
+
+#define __assert_that_x(x, ...)                     do { const bool __traits_x = (x); __traits_helper(__TRAITS_TO_STRING(x), eq(true, __traits_x), __VA_ARGS__); } while(false)
+#define __assert_that_0(x)                          __assert_that_x(x, NULL)
+#define __assert_that_1(x, ...)                     __assert_that_x(x, __VA_ARGS__)
+#define assert_that(...)                            __TRAITS_OVERLOAD_ONE(__assert_that_0, __assert_that_1, __VA_ARGS__)
+
+/*
+ * Boolean
+ */
+#define __assert_true_x(x, ...)                     do { const bool __traits_x = (x); __traits_helper(__TRAITS_TO_STRING(x), eq(true, __traits_x), __VA_ARGS__); } while(false)
+#define __assert_true_0(x)                          __assert_true_x(x, "Expected to be true.\n")
+#define __assert_true_1(x, ...)                     __assert_true_x(x, __VA_ARGS__)
+#define assert_true(...)                            __TRAITS_OVERLOAD_ONE(__assert_true_0, __assert_true_1, __VA_ARGS__)
+
+#define __assert_false_x(x, ...)                    do { const bool __traits_x = (x); __traits_helper(__TRAITS_TO_STRING(x), eq(false, __traits_x), __VA_ARGS__); } while(false)
+#define __assert_false_0(x)                         __assert_false_x(x, "Expected to be false.\n")
+#define __assert_false_1(x, ...)                    __assert_false_x(x, __VA_ARGS__)
+#define assert_false(...)                           __TRAITS_OVERLOAD_ONE(__assert_false_0, __assert_false_1, __VA_ARGS__)
+
+/*
+ * Numerical
+ */
+#define __assert_equal_x(e, a, ...)                 __traits_helper(__TRAITS_TO_STRING(eq(e, a)), eq(e, a), __VA_ARGS__)
+#define __assert_equal_0(e, a)                      __assert_equal_x(e, a, "Expected to be equal.\n")
+#define __assert_equal_1(e, a, ...)                 __assert_equal_x(e, a, __VA_ARGS__)
+#define assert_equal(...)                           __TRAITS_OVERLOAD_TWO(__assert_equal_0, __assert_equal_1, __VA_ARGS__)
+
+#define __assert_not_equal_x(e, a, ...)             __traits_helper(__TRAITS_TO_STRING(ne(e, a)), ne(e, a), __VA_ARGS__)
+#define __assert_not_equal_0(e, a)                  __assert_not_equal_x(e, a, "Expected to be not equal.\n")
+#define __assert_not_equal_1(e, a, ...)             __assert_not_equal_x(e, a, __VA_ARGS__)
+#define assert_not_equal(...)                       __TRAITS_OVERLOAD_TWO(__assert_not_equal_0, __assert_not_equal_1, __VA_ARGS__)
+
+#define __assert_greater_x(e, a, ...)               __traits_helper(__TRAITS_TO_STRING(gt(e, a)), gt(e, a), __VA_ARGS__)
+#define __assert_greater_0(e, a)                    __assert_greater_x(e, a, "Expected to be greater.\n")
+#define __assert_greater_1(e, a, ...)               __assert_greater_x(e, a, __VA_ARGS__)
+#define assert_greater(...)                         __TRAITS_OVERLOAD_TWO(__assert_greater_0, __assert_greater_1, __VA_ARGS__)
+
+#define __assert_greater_equal_x(e, a, ...)         __traits_helper(__TRAITS_TO_STRING(ge(e, a)), ge(e, a), __VA_ARGS__)
+#define __assert_greater_equal_0(e, a)              __assert_greater_equal_x(e, a, "Expected to be greater or equal.\n")
+#define __assert_greater_equal_1(e, a, ...)         __assert_greater_equal_x(e, a, __VA_ARGS__)
+#define assert_greater_equal(...)                   __TRAITS_OVERLOAD_TWO(__assert_greater_equal_0, __assert_greater_equal_1, __VA_ARGS__)
+
+#define __assert_less_x(e, a, ...)                  __traits_helper(__TRAITS_TO_STRING(lt(e, a)), lt(e, a), __VA_ARGS__)
+#define __assert_less_0(e, a)                       __assert_less_x(e, a, "Expected to be less.\n")
+#define __assert_less_1(e, a, ...)                  __assert_less_x(e, a, __VA_ARGS__)
+#define assert_less(...)                            __TRAITS_OVERLOAD_TWO(__assert_less_0, __assert_less_1, __VA_ARGS__)
+
+#define __assert_less_equal_x(e, a, ...)            __traits_helper(__TRAITS_TO_STRING(le(e, a)), le(e, a), __VA_ARGS__)
+#define __assert_less_equal_0(e, a)                 __assert_less_equal_x(e, a, "Expected to be less or equal.\n")
+#define __assert_less_equal_1(e, a, ...)            __assert_less_equal_x(e, a, __VA_ARGS__)
+#define assert_less_equal(...)                      __TRAITS_OVERLOAD_TWO(__assert_less_equal_0, __assert_less_equal_1, __VA_ARGS__)
+
+/*
+ * Pointer
+ */
+#define __assert_null_x(x, ...)                     do { const void *__traits_x = (x); __traits_helper(__TRAITS_TO_STRING(x), eq(NULL, __traits_x), __VA_ARGS__); } while(false)
+#define __assert_null_0(x)                          __assert_null_x(x, "Expected to be null.\n")
+#define __assert_null_1(x, ...)                     __assert_null_x(x, __VA_ARGS__)
+#define assert_null(...)                            __TRAITS_OVERLOAD_ONE(__assert_null_0, __assert_null_1, __VA_ARGS__)
+
+#define __assert_not_null_x(x, ...)                 do { const void *__traits_x = (x); __traits_helper(__TRAITS_TO_STRING(x), ne(NULL, __traits_x), __VA_ARGS__); } while(false)
+#define __assert_not_null_0(x)                      __assert_not_null_x(x, "Expected to be not null.\n")
+#define __assert_not_null_1(x, ...)                 __assert_not_null_x(x, __VA_ARGS__)
+#define assert_not_null(...)                        __TRAITS_OVERLOAD_ONE(__assert_not_null_0, __assert_not_null_1, __VA_ARGS__)
+
+/*
+ * Memory
+ */
+#define __assert_memory_equal_x(s, e, a, ...)       do { const size_t __trait_s = (s); const char *const __trait_e = (e), *const __trait_a = (a); __traits_helper(__TRAITS_TO_STRING(eq(0, memcmp(e, a, s))), eq(0, memcmp(__trait_e, __trait_a, __trait_s)), __VA_ARGS__); } while(false)
+#define __assert_memory_equal_0(s, e, a)            __assert_memory_equal_x(s, e, a, "Expected to be equal.\n")
+#define __assert_memory_equal_1(s, e, a, ...)       __assert_memory_equal_x(s, e, a, __VA_ARGS__)
+#define assert_memory_equal(...)                    __TRAITS_OVERLOAD_THREE(__assert_memory_equal_0, __assert_memory_equal_1, __VA_ARGS__)
+
+#define __assert_memory_not_equal_x(s, e, a, ...)   do { const size_t __trait_s = (s); const char *const __trait_e = (e), *const __trait_a = (a); __traits_helper(__TRAITS_TO_STRING(ne(0, memcmp(e, a, s))), ne(0, memcmp(__trait_e, __trait_a, __trait_s)), __VA_ARGS__); } while(false)
+#define __assert_memory_not_equal_0(s, e, a)        __assert_memory_not_equal_x(s, e, a, "Expected to be not equal.\n")
+#define __assert_memory_not_equal_1(s, e, a, ...)   __assert_memory_not_equal_x(s, e, a, __VA_ARGS__)
+#define assert_memory_not_equal(...)                __TRAITS_OVERLOAD_THREE(__assert_memory_not_equal_0, __assert_memory_not_equal_1, __VA_ARGS__)
+
+/*
+ * String
+ */
+#define __assert_string_equal_x(e, a, ...)          do { const char *const __trait_e = (e), *const __trait_a = (a); __traits_helper(__TRAITS_TO_STRING(eq(0, strcmp(e, a))), eq(0, strcmp(__trait_e, __trait_a)), __VA_ARGS__); } while(false)
+#define __assert_string_equal_0(e, a)               __assert_string_equal_x(e, a, "Expected to be equal.\n")
+#define __assert_string_equal_1(e, a, ...)          __assert_string_equal_x(e, a, __VA_ARGS__)
+#define assert_string_equal(...)                    __TRAITS_OVERLOAD_TWO(__assert_string_equal_0, __assert_string_equal_1, __VA_ARGS__)
+
+#define __assert_string_not_equal_x(e, a, ...)      do { const char *const __trait_e = (e), *const __trait_a = (a); __traits_helper(__TRAITS_TO_STRING(ne(0, strcmp(e, a))), ne(0, strcmp(__trait_e, __trait_a)), __VA_ARGS__); } while(false)
+#define __assert_string_not_equal_0(e, a)           __assert_string_not_equal_x(e, a, "Expected to be not equal.\n")
+#define __assert_string_not_equal_1(e, a, ...)      __assert_string_not_equal_x(e, a, __VA_ARGS__)
+#define assert_string_not_equal(...)                __TRAITS_OVERLOAD_TWO(__assert_string_not_equal_0, __assert_string_not_equal_1, __VA_ARGS__)
+
+#endif /* TRAITS_INCLUDED */
diff --git a/examples/bench.c b/examples/bench.c
deleted file mode 100644
index b09a447..0000000
--- a/examples/bench.c
+++ /dev/null
@@ -1,45 +0,0 @@
-/*
- * C Source File
- *
- * Author: Davide Di Carlo
- * Date:   February 11, 2017
- * email:  daddinuz@gmail.com
- */
-
-#ifndef NDEBUG
-#include <stdio.h>
-#endif
-
-#include <stdlib.h>
-#include "http.h"
-
-/*
- *
- */
-int main() {
-    int status = 0;
-    const char *url = "https://api.github.com/repos/daddinuz/http/issues";
-    const char *headers = "Accept: application/vnd.github.VERSION.raw+json\n"
-            "Content-Type: application/json\n"
-            "User-Agent: daddinuz/http";
-
-    http_request_t *request = http_request_new(HTTP_METHOD_GET, url, headers, NULL);
-#ifndef NDEBUG
-    printf("[ Request ]\n>>> method: %d\n>>> url: %s\n>>> headers:\n%s\n>>> body:\n%s\n\n\n",
-           request->method, request->url, request->headers, request->body
-    );
-#endif
-    http_response_t *response = http_perform(request, NULL);
-    status = response->status;
-#ifndef NDEBUG
-    printf("[ Response (Request) ]\n>>> method: %d\n>>> url: %s\n>>> headers:\n%s\n>>> body:\n%s\n\n",
-           response->request->method, response->request->url, response->request->headers, response->request->body
-    );
-    printf("[ Response ]\n>>> url: %s\n>>> status: %d\n>>> headers:\n%s\n>>> body:\n%s\n",
-           response->url, response->status, response->headers, response->body
-    );
-#endif
-    http_request_delete(request);
-    http_response_delete(response);
-    return !(HTTP_STATUS_OK == status);
-}
diff --git a/examples/build.cmake b/examples/build.cmake
new file mode 100644
index 0000000..35d7d5a
--- /dev/null
+++ b/examples/build.cmake
@@ -0,0 +1,2 @@
+add_executable(main ${CMAKE_CURRENT_LIST_DIR}/main.c)
+target_link_libraries(main PRIVATE http)
diff --git a/examples/example.c b/examples/example.c
deleted file mode 100644
index 47060df..0000000
--- a/examples/example.c
+++ /dev/null
@@ -1,144 +0,0 @@
-/*
- * C Source File
- *
- * Author: Davide Di Carlo
- * Date:   February 11, 2017
- * email:  daddinuz@gmail.com
- */
-
-#include <stdlib.h>
-#include <string.h>
-#include <stdio.h>
-#include "http.h"
-#include "sds/sds.h"
-#include "parson/parson.h"
-#include "picohttpparser/picohttpparser.h"
-
-#define MAX_HEADERS 64
-#define DATE_HEADER_LEN 5
-
-/*
- *
- */
-int main() {
-    sds created_at = NULL;
-    sds issue_details_url = NULL;
-    sds issues_list_url = sdsnew("https://api.github.com/repos/daddinuz/http/issues");
-    sds headers = sdscatfmt(
-            sdsempty(),
-            "Authorization: token %s\n"
-                    "Accept: application/vnd.github.VERSION.raw+json\n"
-                    "Content-Type: application/json\n"
-                    "User-Agent: daddinuz/http",
-            getenv("GITHUB_AUTH_TOKEN")
-    );
-
-    /**
-     * Open an issue
-     */
-    {
-        printf("Creating a new issue... ");
-
-        /* performing request */
-        const char *body = "{\"title\":\"Test issue opened with http.\",\"body\":\"That's cool.\"}";
-        http_request_t *request = http_request_new(HTTP_METHOD_POST, issues_list_url, headers, body);
-        http_response_t *response = http_perform(request, NULL);
-        if (response->status != HTTP_STATUS_CREATED) {
-            return 1;
-        }
-
-        /* parsing headers */
-        char header_name[DATE_HEADER_LEN] = {0};
-        size_t response_headers_len = MAX_HEADERS;
-        struct phr_header response_headers_dict[MAX_HEADERS];
-        const size_t response_headers_start = strcspn(response->headers, "\n") + 1;
-        const size_t response_headers_length = response->headers_length - response_headers_start;
-        const char *response_headers = (response->headers + response_headers_start);
-        phr_parse_headers(response_headers, response_headers_length, response_headers_dict, &response_headers_len, 0);
-        struct phr_header *current_header = NULL;
-        for (size_t i = 0; i < response_headers_len; i++) {
-            current_header = &response_headers_dict[i];
-            snprintf(header_name, DATE_HEADER_LEN, "%.*s", (int) current_header->name_len, current_header->name);
-            if (strcasecmp("date", header_name) == 0) {
-                created_at = sdscatprintf(sdsempty(), "%.*s", (int) current_header->value_len, current_header->value);
-                break;
-            }
-        }
-
-        /* parsing body */
-        JSON_Value *root = json_parse_string(response->body);
-        JSON_Object *object = json_value_get_object(root);
-        issue_details_url = sdsnew(json_object_get_string(object, "url"));
-
-        /* freeing memory */
-        json_value_free(root);
-        http_response_delete(response);
-        http_request_delete(request);
-
-        puts("done");
-    }
-
-    /**
-     * Update the issue
-     */
-    {
-        printf("Updating the issue... ");
-
-        sds body = sdscatfmt(
-                sdsempty(),
-                "{\"title\":\"Test issue opened %s.\",\"body\":\"Going to close this issue.\"}",
-                created_at
-        );
-        http_request_t *request = http_request_new(HTTP_METHOD_PATCH, issue_details_url, headers, body);
-        http_response_t *response = http_perform(request, NULL);
-        if (response->status != HTTP_STATUS_OK) {
-            return 2;
-        }
-        http_response_delete(response);
-        http_request_delete(request);
-        sdsfree(body);
-
-        puts("done");
-    }
-
-    /**
-     * Retrieve the issue
-     */
-    {
-        printf("Retrieving the issue... ");
-
-        http_request_t *request = http_request_new(HTTP_METHOD_GET, issue_details_url, headers, NULL);
-        http_response_t *response = http_perform(request, NULL);
-        if (response->status != HTTP_STATUS_OK) {
-            return 3;
-        }
-        http_response_delete(response);
-        http_request_delete(request);
-
-        puts("done");
-    }
-
-    /**
-     * Close the issue
-     */
-    {
-        printf("Closing the issue... ");
-
-        const char *body = "{\"state\":\"closed\"}";
-        http_request_t *request = http_request_new(HTTP_METHOD_PATCH, issue_details_url, headers, body);
-        http_response_t *response = http_perform(request, NULL);
-        if (response->status != HTTP_STATUS_OK) {
-            return 4;
-        }
-        http_response_delete(response);
-        http_request_delete(request);
-
-        puts("done");
-    }
-
-    sdsfree(headers);
-    sdsfree(issues_list_url);
-    sdsfree(issue_details_url);
-    sdsfree(created_at);
-    return 0;
-}
diff --git a/examples/main.c b/examples/main.c
new file mode 100644
index 0000000..aa1e6b9
--- /dev/null
+++ b/examples/main.c
@@ -0,0 +1,105 @@
+/*
+ * Author: daddinuz
+ * email:  daddinuz@gmail.com
+ *
+ * Copyright (c) 2018 Davide Di Carlo
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * 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 <http.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+#define truth(x) \
+    (((x)) ? "true" : "false")
+
+static void
+printRequest(const struct HttpRequest *request)
+__attribute__((__nonnull__));
+
+static void
+printResponse(const struct HttpResponse *response)
+__attribute__((__nonnull__));
+
+int main() {
+    Http_initialize();
+
+    Atom url = Atom_fromLiteral("https://api.github.com/repos/daddinuz/http/issues");
+    struct HttpRequestBuilder *requestBuilder = HttpRequestBuilder_new(HTTP_METHOD_GET, url);
+    HttpRequestBuilder_setTimeout(requestBuilder, 25);
+    HttpRequestBuilder_emplaceHeaders(requestBuilder,
+                                      "Authorization: token %s\n"
+                                      "Accept: application/vnd.github.VERSION.raw+json\n"
+                                      "Content-Type: application/json\n"
+                                      "User-Agent: daddinuz/http\n",
+                                      getenv("GITHUB_AUTH_TOKEN"));
+
+    const struct HttpRequest *request = HttpRequestBuilder_build(&requestBuilder);
+    printRequest(request);
+
+    const struct HttpResponse *response = Http_FireResult_unwrap(HttpRequest_fire(&request));
+    printResponse(response);
+
+    HttpResponse_delete(response);
+    Http_terminate();
+    return 0;
+}
+
+/*
+ *
+ */
+void printRequest(const struct HttpRequest *request) {
+    printf("\n"
+           "method: %s\n"
+           "url: %s\n"
+           "headers:\n---------------------------------------\n%s\n---------------------------------------\n"
+           "body:\n---------------------------------------\n%s\n---------------------------------------\n"
+           "timeout: %ld\n"
+           "followLocation: %s\n"
+           "peerVerification: %s\n"
+           "hostVerification: %s\n"
+           "\n",
+           HttpMethod_explain(HttpRequest_getMethod(request)),
+           HttpRequest_getUrl(request),
+           HttpRequest_getHeaders(request),
+           HttpRequest_getBody(request),
+           HttpRequest_getTimeout(request),
+           truth(HttpRequest_getFollowLocation(request)),
+           truth(HttpRequest_getPeerVerification(request)),
+           truth(HttpRequest_getHostVerification(request))
+    );
+}
+
+void printResponse(const struct HttpResponse *response) {
+    printf("\n"
+           "status: %d %s\n"
+           "effectiveUrl: %s\n"
+           "headers:\n---------------------------------------\n%s\n---------------------------------------\n"
+           "body:\n---------------------------------------\n%s\n---------------------------------------\n"
+           "\n",
+           HttpResponse_getStatus(response), HttpStatus_explain(HttpResponse_getStatus(response)),
+           HttpResponse_getUrl(response),
+           HttpResponse_getHeaders(response),
+           HttpResponse_getBody(response)
+    );
+}
diff --git a/ext/parson/README.md b/ext/parson/README.md
deleted file mode 100644
index 432f027..0000000
--- a/ext/parson/README.md
+++ /dev/null
@@ -1,145 +0,0 @@
-## About
-Parson is a lighweight [json](http://json.org) library written in C.
-
-## Features
-* Full JSON support
-* Lightweight (only 2 files)
-* Simple API
-* Addressing json values with dot notation (similiar to C structs or objects in most OO languages, e.g. "objectA.objectB.value")
-* C89 compatible
-* Test suites
-
-## Installation
-Run:
-```
-git clone https://github.com/kgabis/parson.git
-```
-and copy parson.h and parson.c to you source code tree.
-
-Run ```make test``` to compile and run tests.
-
-## Examples
-### Parsing JSON
-Here is a function, which prints basic commit info (date, sha and author) from a github repository.  
-```c
-void print_commits_info(const char *username, const char *repo) {
-    JSON_Value *root_value;
-    JSON_Array *commits;
-    JSON_Object *commit;
-    size_t i;
-    
-    char curl_command[512];
-    char cleanup_command[256];
-    char output_filename[] = "commits.json";
-    
-    /* it ain't pretty, but it's not a libcurl tutorial */
-    sprintf(curl_command, 
-        "curl -s \"https://api.github.com/repos/%s/%s/commits\" > %s",
-        username, repo, output_filename);
-    sprintf(cleanup_command, "rm -f %s", output_filename);
-    system(curl_command);
-    
-    /* parsing json and validating output */
-    root_value = json_parse_file(output_filename);
-    if (json_value_get_type(root_value) != JSONArray) {
-        system(cleanup_command);
-        return;
-    }
-    
-    /* getting array from root value and printing commit info */
-    commits = json_value_get_array(root_value);
-    printf("%-10.10s %-10.10s %s\n", "Date", "SHA", "Author");
-    for (i = 0; i < json_array_get_count(commits); i++) {
-        commit = json_array_get_object(commits, i);
-        printf("%.10s %.10s %s\n",
-               json_object_dotget_string(commit, "commit.author.date"),
-               json_object_get_string(commit, "sha"),
-               json_object_dotget_string(commit, "commit.author.name"));
-    }
-    
-    /* cleanup code */
-    json_value_free(root_value);
-    system(cleanup_command);
-}
-
-```
-Calling ```print_commits_info("torvalds", "linux");``` prints:  
-```
-Date       SHA        Author
-2012-10-15 dd8e8c4a2c David Rientjes
-2012-10-15 3ce9e53e78 Michal Marek
-2012-10-14 29bb4cc5e0 Randy Dunlap
-2012-10-15 325adeb55e Ralf Baechle
-2012-10-14 68687c842c Russell King
-2012-10-14 ddffeb8c4d Linus Torvalds
-...
-```
-
-### Persistence
-In this example I'm using parson to save user information to a file and then load it and validate later.
-```c
-void persistence_example(void) {
-    JSON_Value *schema = json_parse_string("{\"name\":\"\"}");
-    JSON_Value *user_data = json_parse_file("user_data.json");
-    char buf[256];
-    const char *name = NULL;
-    if (user_data == NULL || json_validate(schema, user_data) != JSONSuccess) {
-        puts("Enter your name:");
-        scanf("%s", buf);
-        user_data = json_value_init_object();
-        json_object_set_string(json_object(user_data), "name", buf);
-        json_serialize_to_file(user_data, "user_data.json");
-    }
-    name = json_object_get_string(json_object(user_data), "name");
-    printf("Hello, %s.", name);
-    json_value_free(schema);
-    json_value_free(user_data);
-    return;
-}
-```
-
-### Serialization
-Creating JSON values is very simple thanks to the dot notation. 
-Object hierarchy is automatically created when addressing specific fields. 
-In the following example I create a simple JSON value containing basic information about a person.
-```c
-void serialization_example(void) {
-    JSON_Value *root_value = json_value_init_object();
-    JSON_Object *root_object = json_value_get_object(root_value);
-    char *serialized_string = NULL;
-    json_object_set_string(root_object, "name", "John Smith");
-    json_object_set_number(root_object, "age", 25);
-    json_object_dotset_string(root_object, "address.city", "Cupertino");
-    json_object_dotset_value(root_object, "contact.emails", json_parse_string("[\"email@example.com\",\"email2@example.com\"]"));
-    serialized_string = json_serialize_to_string_pretty(root_value);
-    puts(serialized_string);
-    json_free_serialized_string(serialized_string);
-    json_value_free(root_value);
-}
-
-```
-
-Output:
-```
-{
-    "name": "John Smith",
-    "age": 25,
-    "address": {
-        "city": "Cupertino"
-    },
-    "contact": {
-        "emails": [
-            "email@example.com",
-            "email2@example.com"
-        ]
-    }
-}
-```
-
-## Contributing
-
-I will always merge *working* bug fixes. However, if you want to add something new to the API, please create an "issue" on github for this first so we can discuss if it should end up in the library before you start implementing it.
-Remember to follow parson's code style and write appropriate tests.
-
-## License
-[The MIT License (MIT)](http://opensource.org/licenses/mit-license.php)
diff --git a/ext/parson/parson.c b/ext/parson/parson.c
deleted file mode 100644
index 384280e..0000000
--- a/ext/parson/parson.c
+++ /dev/null
@@ -1,2007 +0,0 @@
-/*
- Parson ( http://kgabis.github.com/parson/ )
- Copyright (c) 2012 - 2017 Krzysztof Gabis
-
- Permission is hereby granted, free of charge, to any person obtaining a copy
- of this software and associated documentation files (the "Software"), to deal
- in the Software without restriction, including without limitation the rights
- to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- copies of the Software, and to permit persons to whom the Software is
- furnished to do so, subject to the following conditions:
-
- The above copyright notice and this permission notice shall be included in
- all copies or substantial portions of the Software.
-
- 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.
-*/
-#ifdef _MSC_VER
-#ifndef _CRT_SECURE_NO_WARNINGS
-#define _CRT_SECURE_NO_WARNINGS
-#endif /* _CRT_SECURE_NO_WARNINGS */
-#endif /* _MSC_VER */
-
-#include "parson.h"
-
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include <ctype.h>
-#include <math.h>
-#include <errno.h>
-
-/* Apparently sscanf is not implemented in some "standard" libraries, so don't use it, if you
- * don't have to. */
-#define sscanf THINK_TWICE_ABOUT_USING_SSCANF
-
-#define STARTING_CAPACITY         15
-#define ARRAY_MAX_CAPACITY    122880 /* 15*(2^13) */
-#define OBJECT_MAX_CAPACITY      960 /* 15*(2^6)  */
-#define MAX_NESTING             2048
-#define DOUBLE_SERIALIZATION_FORMAT "%f"
-
-#define SIZEOF_TOKEN(a)       (sizeof(a) - 1)
-#define SKIP_CHAR(str)        ((*str)++)
-#define SKIP_WHITESPACES(str) while (isspace(**str)) { SKIP_CHAR(str); }
-#define MAX(a, b)             ((a) > (b) ? (a) : (b))
-
-#undef malloc
-#undef free
-
-static JSON_Malloc_Function parson_malloc = malloc;
-static JSON_Free_Function parson_free = free;
-
-#define IS_CONT(b) (((unsigned char)(b) & 0xC0) == 0x80) /* is utf-8 continuation byte */
-
-/* Type definitions */
-typedef union json_value_value {
-    char        *string;
-    double       number;
-    JSON_Object *object;
-    JSON_Array  *array;
-    int          boolean;
-    int          null;
-} JSON_Value_Value;
-
-struct json_value_t {
-    JSON_Value      *parent;
-    JSON_Value_Type  type;
-    JSON_Value_Value value;
-};
-
-struct json_object_t {
-    JSON_Value  *wrapping_value;
-    char       **names;
-    JSON_Value **values;
-    size_t       count;
-    size_t       capacity;
-};
-
-struct json_array_t {
-    JSON_Value  *wrapping_value;
-    JSON_Value **items;
-    size_t       count;
-    size_t       capacity;
-};
-
-/* Various */
-static char * read_file(const char *filename);
-static void   remove_comments(char *string, const char *start_token, const char *end_token);
-static char * parson_strndup(const char *string, size_t n);
-static char * parson_strdup(const char *string);
-static int    hex_char_to_int(char c);
-static int    parse_utf16_hex(const char *string, unsigned int *result);
-static int    num_bytes_in_utf8_sequence(unsigned char c);
-static int    verify_utf8_sequence(const unsigned char *string, int *len);
-static int    is_valid_utf8(const char *string, size_t string_len);
-static int    is_decimal(const char *string, size_t length);
-
-/* JSON Object */
-static JSON_Object * json_object_init(JSON_Value *wrapping_value);
-static JSON_Status   json_object_add(JSON_Object *object, const char *name, JSON_Value *value);
-static JSON_Status   json_object_resize(JSON_Object *object, size_t new_capacity);
-static JSON_Value  * json_object_nget_value(const JSON_Object *object, const char *name, size_t n);
-static void          json_object_free(JSON_Object *object);
-
-/* JSON Array */
-static JSON_Array * json_array_init(JSON_Value *wrapping_value);
-static JSON_Status  json_array_add(JSON_Array *array, JSON_Value *value);
-static JSON_Status  json_array_resize(JSON_Array *array, size_t new_capacity);
-static void         json_array_free(JSON_Array *array);
-
-/* JSON Value */
-static JSON_Value * json_value_init_string_no_copy(char *string);
-
-/* Parser */
-static JSON_Status  skip_quotes(const char **string);
-static int          parse_utf16(const char **unprocessed, char **processed);
-static char *       process_string(const char *input, size_t len);
-static char *       get_quoted_string(const char **string);
-static JSON_Value * parse_object_value(const char **string, size_t nesting);
-static JSON_Value * parse_array_value(const char **string, size_t nesting);
-static JSON_Value * parse_string_value(const char **string);
-static JSON_Value * parse_boolean_value(const char **string);
-static JSON_Value * parse_number_value(const char **string);
-static JSON_Value * parse_null_value(const char **string);
-static JSON_Value * parse_value(const char **string, size_t nesting);
-
-/* Serialization */
-static int    json_serialize_to_buffer_r(const JSON_Value *value, char *buf, int level, int is_pretty, char *num_buf);
-static int    json_serialize_string(const char *string, char *buf);
-static int    append_indent(char *buf, int level);
-static int    append_string(char *buf, const char *string);
-
-/* Various */
-static char * parson_strndup(const char *string, size_t n) {
-    char *output_string = (char*)parson_malloc(n + 1);
-    if (!output_string) {
-        return NULL;
-    }
-    output_string[n] = '\0';
-    strncpy(output_string, string, n);
-    return output_string;
-}
-
-static char * parson_strdup(const char *string) {
-    return parson_strndup(string, strlen(string));
-}
-
-static int hex_char_to_int(char c) {
-    if (c >= '0' && c <= '9') {
-        return c - '0';
-    } else if (c >= 'a' && c <= 'f') {
-        return c - 'a' + 10;
-    } else if (c >= 'A' && c <= 'F') {
-        return c - 'A' + 10;
-    }
-    return -1;
-}
-
-static int parse_utf16_hex(const char *s, unsigned int *result) {
-    int x1, x2, x3, x4;
-    if (s[0] == '\0' || s[1] == '\0' || s[2] == '\0' || s[3] == '\0') {
-        return 0;
-    }
-    x1 = hex_char_to_int(s[0]);
-    x2 = hex_char_to_int(s[1]);
-    x3 = hex_char_to_int(s[2]);
-    x4 = hex_char_to_int(s[3]);
-    if (x1 == -1 || x2 == -1 || x3 == -1 || x4 == -1) {
-        return 0;
-    }
-    *result = (unsigned int)((x1 << 12) | (x2 << 8) | (x3 << 4) | x4);
-    return 1;
-}
-
-static int num_bytes_in_utf8_sequence(unsigned char c) {
-    if (c == 0xC0 || c == 0xC1 || c > 0xF4 || IS_CONT(c)) {
-        return 0;
-    } else if ((c & 0x80) == 0) {    /* 0xxxxxxx */
-        return 1;
-    } else if ((c & 0xE0) == 0xC0) { /* 110xxxxx */
-        return 2;
-    } else if ((c & 0xF0) == 0xE0) { /* 1110xxxx */
-        return 3;
-    } else if ((c & 0xF8) == 0xF0) { /* 11110xxx */
-        return 4;
-    }
-    return 0; /* won't happen */
-}
-
-static int verify_utf8_sequence(const unsigned char *string, int *len) {
-    unsigned int cp = 0;
-    *len = num_bytes_in_utf8_sequence(string[0]);
-
-    if (*len == 1) {
-        cp = string[0];
-    } else if (*len == 2 && IS_CONT(string[1])) {
-        cp = string[0] & 0x1F;
-        cp = (cp << 6) | (string[1] & 0x3F);
-    } else if (*len == 3 && IS_CONT(string[1]) && IS_CONT(string[2])) {
-        cp = ((unsigned char)string[0]) & 0xF;
-        cp = (cp << 6) | (string[1] & 0x3F);
-        cp = (cp << 6) | (string[2] & 0x3F);
-    } else if (*len == 4 && IS_CONT(string[1]) && IS_CONT(string[2]) && IS_CONT(string[3])) {
-        cp = string[0] & 0x7;
-        cp = (cp << 6) | (string[1] & 0x3F);
-        cp = (cp << 6) | (string[2] & 0x3F);
-        cp = (cp << 6) | (string[3] & 0x3F);
-    } else {
-        return 0;
-    }
-
-    /* overlong encodings */
-    if ((cp < 0x80    && *len > 1) ||
-        (cp < 0x800   && *len > 2) ||
-        (cp < 0x10000 && *len > 3)) {
-        return 0;
-    }
-
-    /* invalid unicode */
-    if (cp > 0x10FFFF) {
-        return 0;
-    }
-
-    /* surrogate halves */
-    if (cp >= 0xD800 && cp <= 0xDFFF) {
-        return 0;
-    }
-
-    return 1;
-}
-
-static int is_valid_utf8(const char *string, size_t string_len) {
-    int len = 0;
-    const char *string_end =  string + string_len;
-    while (string < string_end) {
-        if (!verify_utf8_sequence((const unsigned char*)string, &len)) {
-            return 0;
-        }
-        string += len;
-    }
-    return 1;
-}
-
-static int is_decimal(const char *string, size_t length) {
-    if (length > 1 && string[0] == '0' && string[1] != '.') {
-        return 0;
-    }
-    if (length > 2 && !strncmp(string, "-0", 2) && string[2] != '.') {
-        return 0;
-    }
-    while (length--) {
-        if (strchr("xX", string[length])) {
-            return 0;
-        }
-    }
-    return 1;
-}
-
-static char * read_file(const char * filename) {
-    FILE *fp = fopen(filename, "r");
-    size_t file_size;
-    long pos;
-    char *file_contents;
-    if (!fp) {
-        return NULL;
-    }
-    fseek(fp, 0L, SEEK_END);
-    pos = ftell(fp);
-    if (pos < 0) {
-        fclose(fp);
-        return NULL;
-    }
-    file_size = pos;
-    rewind(fp);
-    file_contents = (char*)parson_malloc(sizeof(char) * (file_size + 1));
-    if (!file_contents) {
-        fclose(fp);
-        return NULL;
-    }
-    if (fread(file_contents, file_size, 1, fp) < 1) {
-        if (ferror(fp)) {
-            fclose(fp);
-            parson_free(file_contents);
-            return NULL;
-        }
-    }
-    fclose(fp);
-    file_contents[file_size] = '\0';
-    return file_contents;
-}
-
-static void remove_comments(char *string, const char *start_token, const char *end_token) {
-    int in_string = 0, escaped = 0;
-    size_t i;
-    char *ptr = NULL, current_char;
-    size_t start_token_len = strlen(start_token);
-    size_t end_token_len = strlen(end_token);
-    if (start_token_len == 0 || end_token_len == 0) {
-        return;
-    }
-    while ((current_char = *string) != '\0') {
-        if (current_char == '\\' && !escaped) {
-            escaped = 1;
-            string++;
-            continue;
-        } else if (current_char == '\"' && !escaped) {
-            in_string = !in_string;
-        } else if (!in_string && strncmp(string, start_token, start_token_len) == 0) {
-            for(i = 0; i < start_token_len; i++) {
-                string[i] = ' ';
-            }
-            string = string + start_token_len;
-            ptr = strstr(string, end_token);
-            if (!ptr) {
-                return;
-            }
-            for (i = 0; i < (ptr - string) + end_token_len; i++) {
-                string[i] = ' ';
-            }
-            string = ptr + end_token_len - 1;
-        }
-        escaped = 0;
-        string++;
-    }
-}
-
-/* JSON Object */
-static JSON_Object * json_object_init(JSON_Value *wrapping_value) {
-    JSON_Object *new_obj = (JSON_Object*)parson_malloc(sizeof(JSON_Object));
-    if (new_obj == NULL) {
-        return NULL;
-    }
-    new_obj->wrapping_value = wrapping_value;
-    new_obj->names = (char**)NULL;
-    new_obj->values = (JSON_Value**)NULL;
-    new_obj->capacity = 0;
-    new_obj->count = 0;
-    return new_obj;
-}
-
-static JSON_Status json_object_add(JSON_Object *object, const char *name, JSON_Value *value) {
-    size_t index = 0;
-    if (object == NULL || name == NULL || value == NULL) {
-        return JSONFailure;
-    }
-    if (json_object_get_value(object, name) != NULL) {
-        return JSONFailure;
-    }
-    if (object->count >= object->capacity) {
-        size_t new_capacity = MAX(object->capacity * 2, STARTING_CAPACITY);
-        if (new_capacity > OBJECT_MAX_CAPACITY) {
-            return JSONFailure;
-        }
-        if (json_object_resize(object, new_capacity) == JSONFailure) {
-            return JSONFailure;
-        }
-    }
-    index = object->count;
-    object->names[index] = parson_strdup(name);
-    if (object->names[index] == NULL) {
-        return JSONFailure;
-    }
-    value->parent = json_object_get_wrapping_value(object);
-    object->values[index] = value;
-    object->count++;
-    return JSONSuccess;
-}
-
-static JSON_Status json_object_resize(JSON_Object *object, size_t new_capacity) {
-    char **temp_names = NULL;
-    JSON_Value **temp_values = NULL;
-
-    if ((object->names == NULL && object->values != NULL) ||
-        (object->names != NULL && object->values == NULL) ||
-        new_capacity == 0) {
-            return JSONFailure; /* Shouldn't happen */
-    }
-    temp_names = (char**)parson_malloc(new_capacity * sizeof(char*));
-    if (temp_names == NULL) {
-        return JSONFailure;
-    }
-    temp_values = (JSON_Value**)parson_malloc(new_capacity * sizeof(JSON_Value*));
-    if (temp_values == NULL) {
-        parson_free(temp_names);
-        return JSONFailure;
-    }
-    if (object->names != NULL && object->values != NULL && object->count > 0) {
-        memcpy(temp_names, object->names, object->count * sizeof(char*));
-        memcpy(temp_values, object->values, object->count * sizeof(JSON_Value*));
-    }
-    parson_free(object->names);
-    parson_free(object->values);
-    object->names = temp_names;
-    object->values = temp_values;
-    object->capacity = new_capacity;
-    return JSONSuccess;
-}
-
-static JSON_Value * json_object_nget_value(const JSON_Object *object, const char *name, size_t n) {
-    size_t i, name_length;
-    for (i = 0; i < json_object_get_count(object); i++) {
-        name_length = strlen(object->names[i]);
-        if (name_length != n) {
-            continue;
-        }
-        if (strncmp(object->names[i], name, n) == 0) {
-            return object->values[i];
-        }
-    }
-    return NULL;
-}
-
-static void json_object_free(JSON_Object *object) {
-    size_t i;
-    for (i = 0; i < object->count; i++) {
-        parson_free(object->names[i]);
-        json_value_free(object->values[i]);
-    }
-    parson_free(object->names);
-    parson_free(object->values);
-    parson_free(object);
-}
-
-/* JSON Array */
-static JSON_Array * json_array_init(JSON_Value *wrapping_value) {
-    JSON_Array *new_array = (JSON_Array*)parson_malloc(sizeof(JSON_Array));
-    if (new_array == NULL) {
-        return NULL;
-    }
-    new_array->wrapping_value = wrapping_value;
-    new_array->items = (JSON_Value**)NULL;
-    new_array->capacity = 0;
-    new_array->count = 0;
-    return new_array;
-}
-
-static JSON_Status json_array_add(JSON_Array *array, JSON_Value *value) {
-    if (array->count >= array->capacity) {
-        size_t new_capacity = MAX(array->capacity * 2, STARTING_CAPACITY);
-        if (new_capacity > ARRAY_MAX_CAPACITY) {
-            return JSONFailure;
-        }
-        if (json_array_resize(array, new_capacity) == JSONFailure) {
-            return JSONFailure;
-        }
-    }
-    value->parent = json_array_get_wrapping_value(array);
-    array->items[array->count] = value;
-    array->count++;
-    return JSONSuccess;
-}
-
-static JSON_Status json_array_resize(JSON_Array *array, size_t new_capacity) {
-    JSON_Value **new_items = NULL;
-    if (new_capacity == 0) {
-        return JSONFailure;
-    }
-    new_items = (JSON_Value**)parson_malloc(new_capacity * sizeof(JSON_Value*));
-    if (new_items == NULL) {
-        return JSONFailure;
-    }
-    if (array->items != NULL && array->count > 0) {
-        memcpy(new_items, array->items, array->count * sizeof(JSON_Value*));
-    }
-    parson_free(array->items);
-    array->items = new_items;
-    array->capacity = new_capacity;
-    return JSONSuccess;
-}
-
-static void json_array_free(JSON_Array *array) {
-    size_t i;
-    for (i = 0; i < array->count; i++) {
-        json_value_free(array->items[i]);
-    }
-    parson_free(array->items);
-    parson_free(array);
-}
-
-/* JSON Value */
-static JSON_Value * json_value_init_string_no_copy(char *string) {
-    JSON_Value *new_value = (JSON_Value*)parson_malloc(sizeof(JSON_Value));
-    if (!new_value) {
-        return NULL;
-    }
-    new_value->parent = NULL;
-    new_value->type = JSONString;
-    new_value->value.string = string;
-    return new_value;
-}
-
-/* Parser */
-static JSON_Status skip_quotes(const char **string) {
-    if (**string != '\"') {
-        return JSONFailure;
-    }
-    SKIP_CHAR(string);
-    while (**string != '\"') {
-        if (**string == '\0') {
-            return JSONFailure;
-        } else if (**string == '\\') {
-            SKIP_CHAR(string);
-            if (**string == '\0') {
-                return JSONFailure;
-            }
-        }
-        SKIP_CHAR(string);
-    }
-    SKIP_CHAR(string);
-    return JSONSuccess;
-}
-
-static int parse_utf16(const char **unprocessed, char **processed) {
-    unsigned int cp, lead, trail;
-    int parse_succeeded = 0;
-    char *processed_ptr = *processed;
-    const char *unprocessed_ptr = *unprocessed;
-    unprocessed_ptr++; /* skips u */
-    parse_succeeded = parse_utf16_hex(unprocessed_ptr, &cp);
-    if (!parse_succeeded) {
-        return JSONFailure;
-    }
-    if (cp < 0x80) {
-        *processed_ptr = (char)cp; /* 0xxxxxxx */
-    } else if (cp < 0x800) {
-        *processed_ptr++ = ((cp >> 6) & 0x1F) | 0xC0; /* 110xxxxx */
-        *processed_ptr   = ((cp     ) & 0x3F) | 0x80; /* 10xxxxxx */
-    } else if (cp < 0xD800 || cp > 0xDFFF) {
-        *processed_ptr++ = ((cp >> 12) & 0x0F) | 0xE0; /* 1110xxxx */
-        *processed_ptr++ = ((cp >> 6)  & 0x3F) | 0x80; /* 10xxxxxx */
-        *processed_ptr   = ((cp     )  & 0x3F) | 0x80; /* 10xxxxxx */
-    } else if (cp >= 0xD800 && cp <= 0xDBFF) { /* lead surrogate (0xD800..0xDBFF) */
-        lead = cp;
-        unprocessed_ptr += 4; /* should always be within the buffer, otherwise previous sscanf would fail */
-        if (*unprocessed_ptr++ != '\\' || *unprocessed_ptr++ != 'u') {
-            return JSONFailure;
-        }
-        parse_succeeded = parse_utf16_hex(unprocessed_ptr, &trail);
-        if (!parse_succeeded || trail < 0xDC00 || trail > 0xDFFF) { /* valid trail surrogate? (0xDC00..0xDFFF) */
-            return JSONFailure;
-        }
-        cp = ((((lead-0xD800)&0x3FF)<<10)|((trail-0xDC00)&0x3FF))+0x010000;
-        *processed_ptr++ = (((cp >> 18) & 0x07) | 0xF0); /* 11110xxx */
-        *processed_ptr++ = (((cp >> 12) & 0x3F) | 0x80); /* 10xxxxxx */
-        *processed_ptr++ = (((cp >> 6)  & 0x3F) | 0x80); /* 10xxxxxx */
-        *processed_ptr   = (((cp     )  & 0x3F) | 0x80); /* 10xxxxxx */
-    } else { /* trail surrogate before lead surrogate */
-        return JSONFailure;
-    }
-    unprocessed_ptr += 3;
-    *processed = processed_ptr;
-    *unprocessed = unprocessed_ptr;
-    return JSONSuccess;
-}
-
-
-/* Copies and processes passed string up to supplied length.
-Example: "\u006Corem ipsum" -> lorem ipsum */
-static char* process_string(const char *input, size_t len) {
-    const char *input_ptr = input;
-    size_t initial_size = (len + 1) * sizeof(char);
-    size_t final_size = 0;
-    char *output = NULL, *output_ptr = NULL, *resized_output = NULL;
-    output = (char*)parson_malloc(initial_size);
-    if (output == NULL) {
-        goto error;
-    }
-    output_ptr = output;
-    while ((*input_ptr != '\0') && (size_t)(input_ptr - input) < len) {
-        if (*input_ptr == '\\') {
-            input_ptr++;
-            switch (*input_ptr) {
-                case '\"': *output_ptr = '\"'; break;
-                case '\\': *output_ptr = '\\'; break;
-                case '/':  *output_ptr = '/';  break;
-                case 'b':  *output_ptr = '\b'; break;
-                case 'f':  *output_ptr = '\f'; break;
-                case 'n':  *output_ptr = '\n'; break;
-                case 'r':  *output_ptr = '\r'; break;
-                case 't':  *output_ptr = '\t'; break;
-                case 'u':
-                    if (parse_utf16(&input_ptr, &output_ptr) == JSONFailure) {
-                        goto error;
-                    }
-                    break;
-                default:
-                    goto error;
-            }
-        } else if ((unsigned char)*input_ptr < 0x20) {
-            goto error; /* 0x00-0x19 are invalid characters for json string (http://www.ietf.org/rfc/rfc4627.txt) */
-        } else {
-            *output_ptr = *input_ptr;
-        }
-        output_ptr++;
-        input_ptr++;
-    }
-    *output_ptr = '\0';
-    /* resize to new length */
-    final_size = (size_t)(output_ptr-output) + 1;
-    /* todo: don't resize if final_size == initial_size */
-    resized_output = (char*)parson_malloc(final_size);
-    if (resized_output == NULL) {
-        goto error;
-    }
-    memcpy(resized_output, output, final_size);
-    parson_free(output);
-    return resized_output;
-error:
-    parson_free(output);
-    return NULL;
-}
-
-/* Return processed contents of a string between quotes and
-   skips passed argument to a matching quote. */
-static char * get_quoted_string(const char **string) {
-    const char *string_start = *string;
-    size_t string_len = 0;
-    JSON_Status status = skip_quotes(string);
-    if (status != JSONSuccess) {
-        return NULL;
-    }
-    string_len = *string - string_start - 2; /* length without quotes */
-    return process_string(string_start + 1, string_len);
-}
-
-static JSON_Value * parse_value(const char **string, size_t nesting) {
-    if (nesting > MAX_NESTING) {
-        return NULL;
-    }
-    SKIP_WHITESPACES(string);
-    switch (**string) {
-        case '{':
-            return parse_object_value(string, nesting + 1);
-        case '[':
-            return parse_array_value(string, nesting + 1);
-        case '\"':
-            return parse_string_value(string);
-        case 'f': case 't':
-            return parse_boolean_value(string);
-        case '-':
-        case '0': case '1': case '2': case '3': case '4':
-        case '5': case '6': case '7': case '8': case '9':
-            return parse_number_value(string);
-        case 'n':
-            return parse_null_value(string);
-        default:
-            return NULL;
-    }
-}
-
-static JSON_Value * parse_object_value(const char **string, size_t nesting) {
-    JSON_Value *output_value = json_value_init_object(), *new_value = NULL;
-    JSON_Object *output_object = json_value_get_object(output_value);
-    char *new_key = NULL;
-    if (output_value == NULL || **string != '{') {
-        return NULL;
-    }
-    SKIP_CHAR(string);
-    SKIP_WHITESPACES(string);
-    if (**string == '}') { /* empty object */
-        SKIP_CHAR(string);
-        return output_value;
-    }
-    while (**string != '\0') {
-        new_key = get_quoted_string(string);
-        SKIP_WHITESPACES(string);
-        if (new_key == NULL || **string != ':') {
-            json_value_free(output_value);
-            return NULL;
-        }
-        SKIP_CHAR(string);
-        new_value = parse_value(string, nesting);
-        if (new_value == NULL) {
-            parson_free(new_key);
-            json_value_free(output_value);
-            return NULL;
-        }
-        if (json_object_add(output_object, new_key, new_value) == JSONFailure) {
-            parson_free(new_key);
-            json_value_free(new_value);
-            json_value_free(output_value);
-            return NULL;
-        }
-        parson_free(new_key);
-        SKIP_WHITESPACES(string);
-        if (**string != ',') {
-            break;
-        }
-        SKIP_CHAR(string);
-        SKIP_WHITESPACES(string);
-    }
-    SKIP_WHITESPACES(string);
-    if (**string != '}' || /* Trim object after parsing is over */
-        json_object_resize(output_object, json_object_get_count(output_object)) == JSONFailure) {
-            json_value_free(output_value);
-            return NULL;
-    }
-    SKIP_CHAR(string);
-    return output_value;
-}
-
-static JSON_Value * parse_array_value(const char **string, size_t nesting) {
-    JSON_Value *output_value = json_value_init_array(), *new_array_value = NULL;
-    JSON_Array *output_array = json_value_get_array(output_value);
-    if (!output_value || **string != '[') {
-        return NULL;
-    }
-    SKIP_CHAR(string);
-    SKIP_WHITESPACES(string);
-    if (**string == ']') { /* empty array */
-        SKIP_CHAR(string);
-        return output_value;
-    }
-    while (**string != '\0') {
-        new_array_value = parse_value(string, nesting);
-        if (new_array_value == NULL) {
-            json_value_free(output_value);
-            return NULL;
-        }
-        if (json_array_add(output_array, new_array_value) == JSONFailure) {
-            json_value_free(new_array_value);
-            json_value_free(output_value);
-            return NULL;
-        }
-        SKIP_WHITESPACES(string);
-        if (**string != ',') {
-            break;
-        }
-        SKIP_CHAR(string);
-        SKIP_WHITESPACES(string);
-    }
-    SKIP_WHITESPACES(string);
-    if (**string != ']' || /* Trim array after parsing is over */
-        json_array_resize(output_array, json_array_get_count(output_array)) == JSONFailure) {
-            json_value_free(output_value);
-            return NULL;
-    }
-    SKIP_CHAR(string);
-    return output_value;
-}
-
-static JSON_Value * parse_string_value(const char **string) {
-    JSON_Value *value = NULL;
-    char *new_string = get_quoted_string(string);
-    if (new_string == NULL) {
-        return NULL;
-    }
-    value = json_value_init_string_no_copy(new_string);
-    if (value == NULL) {
-        parson_free(new_string);
-        return NULL;
-    }
-    return value;
-}
-
-static JSON_Value * parse_boolean_value(const char **string) {
-    size_t true_token_size = SIZEOF_TOKEN("true");
-    size_t false_token_size = SIZEOF_TOKEN("false");
-    if (strncmp("true", *string, true_token_size) == 0) {
-        *string += true_token_size;
-        return json_value_init_boolean(1);
-    } else if (strncmp("false", *string, false_token_size) == 0) {
-        *string += false_token_size;
-        return json_value_init_boolean(0);
-    }
-    return NULL;
-}
-
-static JSON_Value * parse_number_value(const char **string) {
-    char *end;
-    double number = 0;
-    errno = 0;
-    number = strtod(*string, &end);
-    if (errno || !is_decimal(*string, end - *string)) {
-        return NULL;
-    }
-    *string = end;
-    return json_value_init_number(number);
-}
-
-static JSON_Value * parse_null_value(const char **string) {
-    size_t token_size = SIZEOF_TOKEN("null");
-    if (strncmp("null", *string, token_size) == 0) {
-        *string += token_size;
-        return json_value_init_null();
-    }
-    return NULL;
-}
-
-/* Serialization */
-#define APPEND_STRING(str) do { written = append_string(buf, (str));\
-                                if (written < 0) { return -1; }\
-                                if (buf != NULL) { buf += written; }\
-                                written_total += written; } while(0)
-
-#define APPEND_INDENT(level) do { written = append_indent(buf, (level));\
-                                  if (written < 0) { return -1; }\
-                                  if (buf != NULL) { buf += written; }\
-                                  written_total += written; } while(0)
-
-static int json_serialize_to_buffer_r(const JSON_Value *value, char *buf, int level, int is_pretty, char *num_buf)
-{
-    const char *key = NULL, *string = NULL;
-    JSON_Value *temp_value = NULL;
-    JSON_Array *array = NULL;
-    JSON_Object *object = NULL;
-    size_t i = 0, count = 0;
-    double num = 0.0;
-    int written = -1, written_total = 0;
-
-    switch (json_value_get_type(value)) {
-        case JSONArray:
-            array = json_value_get_array(value);
-            count = json_array_get_count(array);
-            APPEND_STRING("[");
-            if (count > 0 && is_pretty) {
-                APPEND_STRING("\n");
-            }
-            for (i = 0; i < count; i++) {
-                if (is_pretty) {
-                    APPEND_INDENT(level+1);
-                }
-                temp_value = json_array_get_value(array, i);
-                written = json_serialize_to_buffer_r(temp_value, buf, level+1, is_pretty, num_buf);
-                if (written < 0) {
-                    return -1;
-                }
-                if (buf != NULL) {
-                    buf += written;
-                }
-                written_total += written;
-                if (i < (count - 1)) {
-                    APPEND_STRING(",");
-                }
-                if (is_pretty) {
-                    APPEND_STRING("\n");
-                }
-            }
-            if (count > 0 && is_pretty) {
-                APPEND_INDENT(level);
-            }
-            APPEND_STRING("]");
-            return written_total;
-        case JSONObject:
-            object = json_value_get_object(value);
-            count  = json_object_get_count(object);
-            APPEND_STRING("{");
-            if (count > 0 && is_pretty) {
-                APPEND_STRING("\n");
-            }
-            for (i = 0; i < count; i++) {
-                key = json_object_get_name(object, i);
-                if (key == NULL) {
-                    return -1;
-                }
-                if (is_pretty) {
-                    APPEND_INDENT(level+1);
-                }
-                written = json_serialize_string(key, buf);
-                if (written < 0) {
-                    return -1;
-                }
-                if (buf != NULL) {
-                    buf += written;
-                }
-                written_total += written;
-                APPEND_STRING(":");
-                if (is_pretty) {
-                    APPEND_STRING(" ");
-                }
-                temp_value = json_object_get_value(object, key);
-                written = json_serialize_to_buffer_r(temp_value, buf, level+1, is_pretty, num_buf);
-                if (written < 0) {
-                    return -1;
-                }
-                if (buf != NULL) {
-                    buf += written;
-                }
-                written_total += written;
-                if (i < (count - 1)) {
-                    APPEND_STRING(",");
-                }
-                if (is_pretty) {
-                    APPEND_STRING("\n");
-                }
-            }
-            if (count > 0 && is_pretty) {
-                APPEND_INDENT(level);
-            }
-            APPEND_STRING("}");
-            return written_total;
-        case JSONString:
-            string = json_value_get_string(value);
-            if (string == NULL) {
-                return -1;
-            }
-            written = json_serialize_string(string, buf);
-            if (written < 0) {
-                return -1;
-            }
-            if (buf != NULL) {
-                buf += written;
-            }
-            written_total += written;
-            return written_total;
-        case JSONBoolean:
-            if (json_value_get_boolean(value)) {
-                APPEND_STRING("true");
-            } else {
-                APPEND_STRING("false");
-            }
-            return written_total;
-        case JSONNumber:
-            num = json_value_get_number(value);
-            if (buf != NULL) {
-                num_buf = buf;
-            }
-            if (num == ((double)(int)num)) { /*  check if num is integer */
-                written = sprintf(num_buf, "%d", (int)num);
-	    } else if (num == ((double)(unsigned int)num)) {
-                written = sprintf(num_buf, "%u", (unsigned int)num);
-            } else {
-                written = sprintf(num_buf, DOUBLE_SERIALIZATION_FORMAT, num);
-            }
-            if (written < 0) {
-                return -1;
-            }
-            if (buf != NULL) {
-                buf += written;
-            }
-            written_total += written;
-            return written_total;
-        case JSONNull:
-            APPEND_STRING("null");
-            return written_total;
-        case JSONError:
-            return -1;
-        default:
-            return -1;
-    }
-}
-
-static int json_serialize_string(const char *string, char *buf) {
-    size_t i = 0, len = strlen(string);
-    char c = '\0';
-    int written = -1, written_total = 0;
-    APPEND_STRING("\"");
-    for (i = 0; i < len; i++) {
-        c = string[i];
-        switch (c) {
-            case '\"': APPEND_STRING("\\\""); break;
-            case '\\': APPEND_STRING("\\\\"); break;
-            case '/':  APPEND_STRING("\\/"); break; /* to make json embeddable in xml\/html */
-            case '\b': APPEND_STRING("\\b"); break;
-            case '\f': APPEND_STRING("\\f"); break;
-            case '\n': APPEND_STRING("\\n"); break;
-            case '\r': APPEND_STRING("\\r"); break;
-            case '\t': APPEND_STRING("\\t"); break;
-            case '\x00': APPEND_STRING("\\u0000"); break;
-            case '\x01': APPEND_STRING("\\u0001"); break;
-            case '\x02': APPEND_STRING("\\u0002"); break;
-            case '\x03': APPEND_STRING("\\u0003"); break;
-            case '\x04': APPEND_STRING("\\u0004"); break;
-            case '\x05': APPEND_STRING("\\u0005"); break;
-            case '\x06': APPEND_STRING("\\u0006"); break;
-            case '\x07': APPEND_STRING("\\u0007"); break;
-            /* '\x08' duplicate: '\b' */
-            /* '\x09' duplicate: '\t' */
-            /* '\x0a' duplicate: '\n' */
-            case '\x0b': APPEND_STRING("\\u000b"); break;
-            /* '\x0c' duplicate: '\f' */
-            /* '\x0d' duplicate: '\r' */
-            case '\x0e': APPEND_STRING("\\u000e"); break;
-            case '\x0f': APPEND_STRING("\\u000f"); break;
-            case '\x10': APPEND_STRING("\\u0010"); break;
-            case '\x11': APPEND_STRING("\\u0011"); break;
-            case '\x12': APPEND_STRING("\\u0012"); break;
-            case '\x13': APPEND_STRING("\\u0013"); break;
-            case '\x14': APPEND_STRING("\\u0014"); break;
-            case '\x15': APPEND_STRING("\\u0015"); break;
-            case '\x16': APPEND_STRING("\\u0016"); break;
-            case '\x17': APPEND_STRING("\\u0017"); break;
-            case '\x18': APPEND_STRING("\\u0018"); break;
-            case '\x19': APPEND_STRING("\\u0019"); break;
-            case '\x1a': APPEND_STRING("\\u001a"); break;
-            case '\x1b': APPEND_STRING("\\u001b"); break;
-            case '\x1c': APPEND_STRING("\\u001c"); break;
-            case '\x1d': APPEND_STRING("\\u001d"); break;
-            case '\x1e': APPEND_STRING("\\u001e"); break;
-            case '\x1f': APPEND_STRING("\\u001f"); break;
-            default:
-                if (buf != NULL) {
-                    buf[0] = c;
-                    buf += 1;
-                }
-                written_total += 1;
-                break;
-        }
-    }
-    APPEND_STRING("\"");
-    return written_total;
-}
-
-static int append_indent(char *buf, int level) {
-    int i;
-    int written = -1, written_total = 0;
-    for (i = 0; i < level; i++) {
-        APPEND_STRING("    ");
-    }
-    return written_total;
-}
-
-static int append_string(char *buf, const char *string) {
-    if (buf == NULL) {
-        return (int)strlen(string);
-    }
-    return sprintf(buf, "%s", string);
-}
-
-#undef APPEND_STRING
-#undef APPEND_INDENT
-
-/* Parser API */
-JSON_Value * json_parse_file(const char *filename) {
-    char *file_contents = read_file(filename);
-    JSON_Value *output_value = NULL;
-    if (file_contents == NULL) {
-        return NULL;
-    }
-    output_value = json_parse_string(file_contents);
-    parson_free(file_contents);
-    return output_value;
-}
-
-JSON_Value * json_parse_file_with_comments(const char *filename) {
-    char *file_contents = read_file(filename);
-    JSON_Value *output_value = NULL;
-    if (file_contents == NULL) {
-        return NULL;
-    }
-    output_value = json_parse_string_with_comments(file_contents);
-    parson_free(file_contents);
-    return output_value;
-}
-
-JSON_Value * json_parse_string(const char *string) {
-    if (string == NULL) {
-        return NULL;
-    }
-    if (string[0] == '\xEF' && string[1] == '\xBB' && string[2] == '\xBF') {
-        string = string + 3; /* Support for UTF-8 BOM */
-    }
-    return parse_value((const char**)&string, 0);
-}
-
-JSON_Value * json_parse_string_with_comments(const char *string) {
-    JSON_Value *result = NULL;
-    char *string_mutable_copy = NULL, *string_mutable_copy_ptr = NULL;
-    string_mutable_copy = parson_strdup(string);
-    if (string_mutable_copy == NULL) {
-        return NULL;
-    }
-    remove_comments(string_mutable_copy, "/*", "*/");
-    remove_comments(string_mutable_copy, "//", "\n");
-    string_mutable_copy_ptr = string_mutable_copy;
-    result = parse_value((const char**)&string_mutable_copy_ptr, 0);
-    parson_free(string_mutable_copy);
-    return result;
-}
-
-/* JSON Object API */
-
-JSON_Value * json_object_get_value(const JSON_Object *object, const char *name) {
-    if (object == NULL || name == NULL) {
-        return NULL;
-    }
-    return json_object_nget_value(object, name, strlen(name));
-}
-
-const char * json_object_get_string(const JSON_Object *object, const char *name) {
-    return json_value_get_string(json_object_get_value(object, name));
-}
-
-double json_object_get_number(const JSON_Object *object, const char *name) {
-    return json_value_get_number(json_object_get_value(object, name));
-}
-
-JSON_Object * json_object_get_object(const JSON_Object *object, const char *name) {
-    return json_value_get_object(json_object_get_value(object, name));
-}
-
-JSON_Array * json_object_get_array(const JSON_Object *object, const char *name) {
-    return json_value_get_array(json_object_get_value(object, name));
-}
-
-int json_object_get_boolean(const JSON_Object *object, const char *name) {
-    return json_value_get_boolean(json_object_get_value(object, name));
-}
-
-JSON_Value * json_object_dotget_value(const JSON_Object *object, const char *name) {
-    const char *dot_position = strchr(name, '.');
-    if (!dot_position) {
-        return json_object_get_value(object, name);
-    }
-    object = json_value_get_object(json_object_nget_value(object, name, dot_position - name));
-    return json_object_dotget_value(object, dot_position + 1);
-}
-
-const char * json_object_dotget_string(const JSON_Object *object, const char *name) {
-    return json_value_get_string(json_object_dotget_value(object, name));
-}
-
-double json_object_dotget_number(const JSON_Object *object, const char *name) {
-    return json_value_get_number(json_object_dotget_value(object, name));
-}
-
-JSON_Object * json_object_dotget_object(const JSON_Object *object, const char *name) {
-    return json_value_get_object(json_object_dotget_value(object, name));
-}
-
-JSON_Array * json_object_dotget_array(const JSON_Object *object, const char *name) {
-    return json_value_get_array(json_object_dotget_value(object, name));
-}
-
-int json_object_dotget_boolean(const JSON_Object *object, const char *name) {
-    return json_value_get_boolean(json_object_dotget_value(object, name));
-}
-
-size_t json_object_get_count(const JSON_Object *object) {
-    return object ? object->count : 0;
-}
-
-const char * json_object_get_name(const JSON_Object *object, size_t index) {
-    if (object == NULL || index >= json_object_get_count(object)) {
-        return NULL;
-    }
-    return object->names[index];
-}
-
-JSON_Value * json_object_get_value_at(const JSON_Object *object, size_t index) {
-    if (object == NULL || index >= json_object_get_count(object)) {
-        return NULL;
-    }
-    return object->values[index];
-}
-
-JSON_Value *json_object_get_wrapping_value(const JSON_Object *object) {
-    return object->wrapping_value;
-}
-
-int json_object_has_value (const JSON_Object *object, const char *name) {
-    return json_object_get_value(object, name) != NULL;
-}
-
-int json_object_has_value_of_type(const JSON_Object *object, const char *name, JSON_Value_Type type) {
-    JSON_Value *val = json_object_get_value(object, name);
-    return val != NULL && json_value_get_type(val) == type;
-}
-
-int json_object_dothas_value (const JSON_Object *object, const char *name) {
-    return json_object_dotget_value(object, name) != NULL;
-}
-
-int json_object_dothas_value_of_type(const JSON_Object *object, const char *name, JSON_Value_Type type) {
-    JSON_Value *val = json_object_dotget_value(object, name);
-    return val != NULL && json_value_get_type(val) == type;
-}
-
-/* JSON Array API */
-JSON_Value * json_array_get_value(const JSON_Array *array, size_t index) {
-    if (array == NULL || index >= json_array_get_count(array)) {
-        return NULL;
-    }
-    return array->items[index];
-}
-
-const char * json_array_get_string(const JSON_Array *array, size_t index) {
-    return json_value_get_string(json_array_get_value(array, index));
-}
-
-double json_array_get_number(const JSON_Array *array, size_t index) {
-    return json_value_get_number(json_array_get_value(array, index));
-}
-
-JSON_Object * json_array_get_object(const JSON_Array *array, size_t index) {
-    return json_value_get_object(json_array_get_value(array, index));
-}
-
-JSON_Array * json_array_get_array(const JSON_Array *array, size_t index) {
-    return json_value_get_array(json_array_get_value(array, index));
-}
-
-int json_array_get_boolean(const JSON_Array *array, size_t index) {
-    return json_value_get_boolean(json_array_get_value(array, index));
-}
-
-size_t json_array_get_count(const JSON_Array *array) {
-    return array ? array->count : 0;
-}
-
-JSON_Value * json_array_get_wrapping_value(const JSON_Array *array) {
-    return array->wrapping_value;
-}
-
-/* JSON Value API */
-JSON_Value_Type json_value_get_type(const JSON_Value *value) {
-    return value ? value->type : JSONError;
-}
-
-JSON_Object * json_value_get_object(const JSON_Value *value) {
-    return json_value_get_type(value) == JSONObject ? value->value.object : NULL;
-}
-
-JSON_Array * json_value_get_array(const JSON_Value *value) {
-    return json_value_get_type(value) == JSONArray ? value->value.array : NULL;
-}
-
-const char * json_value_get_string(const JSON_Value *value) {
-    return json_value_get_type(value) == JSONString ? value->value.string : NULL;
-}
-
-double json_value_get_number(const JSON_Value *value) {
-    return json_value_get_type(value) == JSONNumber ? value->value.number : 0;
-}
-
-int json_value_get_boolean(const JSON_Value *value) {
-    return json_value_get_type(value) == JSONBoolean ? value->value.boolean : -1;
-}
-
-JSON_Value * json_value_get_parent (const JSON_Value *value) {
-    return value ? value->parent : NULL;
-}
-
-void json_value_free(JSON_Value *value) {
-    switch (json_value_get_type(value)) {
-        case JSONObject:
-            json_object_free(value->value.object);
-            break;
-        case JSONString:
-            parson_free(value->value.string);
-            break;
-        case JSONArray:
-            json_array_free(value->value.array);
-            break;
-        default:
-            break;
-    }
-    parson_free(value);
-}
-
-JSON_Value * json_value_init_object(void) {
-    JSON_Value *new_value = (JSON_Value*)parson_malloc(sizeof(JSON_Value));
-    if (!new_value) {
-        return NULL;
-    }
-    new_value->parent = NULL;
-    new_value->type = JSONObject;
-    new_value->value.object = json_object_init(new_value);
-    if (!new_value->value.object) {
-        parson_free(new_value);
-        return NULL;
-    }
-    return new_value;
-}
-
-JSON_Value * json_value_init_array(void) {
-    JSON_Value *new_value = (JSON_Value*)parson_malloc(sizeof(JSON_Value));
-    if (!new_value) {
-        return NULL;
-    }
-    new_value->parent = NULL;
-    new_value->type = JSONArray;
-    new_value->value.array = json_array_init(new_value);
-    if (!new_value->value.array) {
-        parson_free(new_value);
-        return NULL;
-    }
-    return new_value;
-}
-
-JSON_Value * json_value_init_string(const char *string) {
-    char *copy = NULL;
-    JSON_Value *value;
-    size_t string_len = 0;
-    if (string == NULL) {
-        return NULL;
-    }
-    string_len = strlen(string);
-    if (!is_valid_utf8(string, string_len)) {
-        return NULL;
-    }
-    copy = parson_strndup(string, string_len);
-    if (copy == NULL) {
-        return NULL;
-    }
-    value = json_value_init_string_no_copy(copy);
-    if (value == NULL) {
-        parson_free(copy);
-    }
-    return value;
-}
-
-JSON_Value * json_value_init_number(double number) {
-    JSON_Value *new_value = (JSON_Value*)parson_malloc(sizeof(JSON_Value));
-    if (!new_value) {
-        return NULL;
-    }
-    new_value->parent = NULL;
-    new_value->type = JSONNumber;
-    new_value->value.number = number;
-    return new_value;
-}
-
-JSON_Value * json_value_init_boolean(int boolean) {
-    JSON_Value *new_value = (JSON_Value*)parson_malloc(sizeof(JSON_Value));
-    if (!new_value) {
-        return NULL;
-    }
-    new_value->parent = NULL;
-    new_value->type = JSONBoolean;
-    new_value->value.boolean = boolean ? 1 : 0;
-    return new_value;
-}
-
-JSON_Value * json_value_init_null(void) {
-    JSON_Value *new_value = (JSON_Value*)parson_malloc(sizeof(JSON_Value));
-    if (!new_value) {
-        return NULL;
-    }
-    new_value->parent = NULL;
-    new_value->type = JSONNull;
-    return new_value;
-}
-
-JSON_Value * json_value_deep_copy(const JSON_Value *value) {
-    size_t i = 0;
-    JSON_Value *return_value = NULL, *temp_value_copy = NULL, *temp_value = NULL;
-    const char *temp_string = NULL, *temp_key = NULL;
-    char *temp_string_copy = NULL;
-    JSON_Array *temp_array = NULL, *temp_array_copy = NULL;
-    JSON_Object *temp_object = NULL, *temp_object_copy = NULL;
-
-    switch (json_value_get_type(value)) {
-        case JSONArray:
-            temp_array = json_value_get_array(value);
-            return_value = json_value_init_array();
-            if (return_value == NULL) {
-                return NULL;
-            }
-            temp_array_copy = json_value_get_array(return_value);
-            for (i = 0; i < json_array_get_count(temp_array); i++) {
-                temp_value = json_array_get_value(temp_array, i);
-                temp_value_copy = json_value_deep_copy(temp_value);
-                if (temp_value_copy == NULL) {
-                    json_value_free(return_value);
-                    return NULL;
-                }
-                if (json_array_add(temp_array_copy, temp_value_copy) == JSONFailure) {
-                    json_value_free(return_value);
-                    json_value_free(temp_value_copy);
-                    return NULL;
-                }
-            }
-            return return_value;
-        case JSONObject:
-            temp_object = json_value_get_object(value);
-            return_value = json_value_init_object();
-            if (return_value == NULL) {
-                return NULL;
-            }
-            temp_object_copy = json_value_get_object(return_value);
-            for (i = 0; i < json_object_get_count(temp_object); i++) {
-                temp_key = json_object_get_name(temp_object, i);
-                temp_value = json_object_get_value(temp_object, temp_key);
-                temp_value_copy = json_value_deep_copy(temp_value);
-                if (temp_value_copy == NULL) {
-                    json_value_free(return_value);
-                    return NULL;
-                }
-                if (json_object_add(temp_object_copy, temp_key, temp_value_copy) == JSONFailure) {
-                    json_value_free(return_value);
-                    json_value_free(temp_value_copy);
-                    return NULL;
-                }
-            }
-            return return_value;
-        case JSONBoolean:
-            return json_value_init_boolean(json_value_get_boolean(value));
-        case JSONNumber:
-            return json_value_init_number(json_value_get_number(value));
-        case JSONString:
-            temp_string = json_value_get_string(value);
-            if (temp_string == NULL) {
-                return NULL;
-            }
-            temp_string_copy = parson_strdup(temp_string);
-            if (temp_string_copy == NULL) {
-                return NULL;
-            }
-            return_value = json_value_init_string_no_copy(temp_string_copy);
-            if (return_value == NULL) {
-                parson_free(temp_string_copy);
-            }
-            return return_value;
-        case JSONNull:
-            return json_value_init_null();
-        case JSONError:
-            return NULL;
-        default:
-            return NULL;
-    }
-}
-
-size_t json_serialization_size(const JSON_Value *value) {
-    char num_buf[1100]; /* recursively allocating buffer on stack is a bad idea, so let's do it only once */
-    int res = json_serialize_to_buffer_r(value, NULL, 0, 0, num_buf);
-    return res < 0 ? 0 : (size_t)(res + 1);
-}
-
-JSON_Status json_serialize_to_buffer(const JSON_Value *value, char *buf, size_t buf_size_in_bytes) {
-    int written = -1;
-    size_t needed_size_in_bytes = json_serialization_size(value);
-    if (needed_size_in_bytes == 0 || buf_size_in_bytes < needed_size_in_bytes) {
-        return JSONFailure;
-    }
-    written = json_serialize_to_buffer_r(value, buf, 0, 0, NULL);
-    if (written < 0) {
-        return JSONFailure;
-    }
-    return JSONSuccess;
-}
-
-JSON_Status json_serialize_to_file(const JSON_Value *value, const char *filename) {
-    JSON_Status return_code = JSONSuccess;
-    FILE *fp = NULL;
-    char *serialized_string = json_serialize_to_string(value);
-    if (serialized_string == NULL) {
-        return JSONFailure;
-    }
-    fp = fopen (filename, "w");
-    if (fp == NULL) {
-        json_free_serialized_string(serialized_string);
-        return JSONFailure;
-    }
-    if (fputs(serialized_string, fp) == EOF) {
-        return_code = JSONFailure;
-    }
-    if (fclose(fp) == EOF) {
-        return_code = JSONFailure;
-    }
-    json_free_serialized_string(serialized_string);
-    return return_code;
-}
-
-char * json_serialize_to_string(const JSON_Value *value) {
-    JSON_Status serialization_result = JSONFailure;
-    size_t buf_size_bytes = json_serialization_size(value);
-    char *buf = NULL;
-    if (buf_size_bytes == 0) {
-        return NULL;
-    }
-    buf = (char*)parson_malloc(buf_size_bytes);
-    if (buf == NULL) {
-        return NULL;
-    }
-    serialization_result = json_serialize_to_buffer(value, buf, buf_size_bytes);
-    if (serialization_result == JSONFailure) {
-        json_free_serialized_string(buf);
-        return NULL;
-    }
-    return buf;
-}
-
-size_t json_serialization_size_pretty(const JSON_Value *value) {
-    char num_buf[1100]; /* recursively allocating buffer on stack is a bad idea, so let's do it only once */
-    int res = json_serialize_to_buffer_r(value, NULL, 0, 1, num_buf);
-    return res < 0 ? 0 : (size_t)(res + 1);
-}
-
-JSON_Status json_serialize_to_buffer_pretty(const JSON_Value *value, char *buf, size_t buf_size_in_bytes) {
-    int written = -1;
-    size_t needed_size_in_bytes = json_serialization_size_pretty(value);
-    if (needed_size_in_bytes == 0 || buf_size_in_bytes < needed_size_in_bytes) {
-        return JSONFailure;
-    }
-    written = json_serialize_to_buffer_r(value, buf, 0, 1, NULL);
-    if (written < 0) {
-        return JSONFailure;
-    }
-    return JSONSuccess;
-}
-
-JSON_Status json_serialize_to_file_pretty(const JSON_Value *value, const char *filename) {
-    JSON_Status return_code = JSONSuccess;
-    FILE *fp = NULL;
-    char *serialized_string = json_serialize_to_string_pretty(value);
-    if (serialized_string == NULL) {
-        return JSONFailure;
-    }
-    fp = fopen (filename, "w");
-    if (fp == NULL) {
-        json_free_serialized_string(serialized_string);
-        return JSONFailure;
-    }
-    if (fputs(serialized_string, fp) == EOF) {
-        return_code = JSONFailure;
-    }
-    if (fclose(fp) == EOF) {
-        return_code = JSONFailure;
-    }
-    json_free_serialized_string(serialized_string);
-    return return_code;
-}
-
-char * json_serialize_to_string_pretty(const JSON_Value *value) {
-    JSON_Status serialization_result = JSONFailure;
-    size_t buf_size_bytes = json_serialization_size_pretty(value);
-    char *buf = NULL;
-    if (buf_size_bytes == 0) {
-        return NULL;
-    }
-    buf = (char*)parson_malloc(buf_size_bytes);
-    if (buf == NULL) {
-        return NULL;
-    }
-    serialization_result = json_serialize_to_buffer_pretty(value, buf, buf_size_bytes);
-    if (serialization_result == JSONFailure) {
-        json_free_serialized_string(buf);
-        return NULL;
-    }
-    return buf;
-}
-
-void json_free_serialized_string(char *string) {
-    parson_free(string);
-}
-
-JSON_Status json_array_remove(JSON_Array *array, size_t ix) {
-    JSON_Value *temp_value = NULL;
-    size_t last_element_ix = 0;
-    if (array == NULL || ix >= json_array_get_count(array)) {
-        return JSONFailure;
-    }
-    last_element_ix = json_array_get_count(array) - 1;
-    json_value_free(json_array_get_value(array, ix));
-    if (ix != last_element_ix) { /* Replace value with one from the end of array */
-        temp_value = json_array_get_value(array, last_element_ix);
-        if (temp_value == NULL) {
-            return JSONFailure;
-        }
-        array->items[ix] = temp_value;
-    }
-    array->count -= 1;
-    return JSONSuccess;
-}
-
-JSON_Status json_array_replace_value(JSON_Array *array, size_t ix, JSON_Value *value) {
-    if (array == NULL || value == NULL || value->parent != NULL || ix >= json_array_get_count(array)) {
-        return JSONFailure;
-    }
-    json_value_free(json_array_get_value(array, ix));
-    value->parent = json_array_get_wrapping_value(array);
-    array->items[ix] = value;
-    return JSONSuccess;
-}
-
-JSON_Status json_array_replace_string(JSON_Array *array, size_t i, const char* string) {
-    JSON_Value *value = json_value_init_string(string);
-    if (value == NULL) {
-        return JSONFailure;
-    }
-    if (json_array_replace_value(array, i, value) == JSONFailure) {
-        json_value_free(value);
-        return JSONFailure;
-    }
-    return JSONSuccess;
-}
-
-JSON_Status json_array_replace_number(JSON_Array *array, size_t i, double number) {
-    JSON_Value *value = json_value_init_number(number);
-    if (value == NULL) {
-        return JSONFailure;
-    }
-    if (json_array_replace_value(array, i, value) == JSONFailure) {
-        json_value_free(value);
-        return JSONFailure;
-    }
-    return JSONSuccess;
-}
-
-JSON_Status json_array_replace_boolean(JSON_Array *array, size_t i, int boolean) {
-    JSON_Value *value = json_value_init_boolean(boolean);
-    if (value == NULL) {
-        return JSONFailure;
-    }
-    if (json_array_replace_value(array, i, value) == JSONFailure) {
-        json_value_free(value);
-        return JSONFailure;
-    }
-    return JSONSuccess;
-}
-
-JSON_Status json_array_replace_null(JSON_Array *array, size_t i) {
-    JSON_Value *value = json_value_init_null();
-    if (value == NULL) {
-        return JSONFailure;
-    }
-    if (json_array_replace_value(array, i, value) == JSONFailure) {
-        json_value_free(value);
-        return JSONFailure;
-    }
-    return JSONSuccess;
-}
-
-JSON_Status json_array_clear(JSON_Array *array) {
-    size_t i = 0;
-    if (array == NULL) {
-        return JSONFailure;
-    }
-    for (i = 0; i < json_array_get_count(array); i++) {
-        json_value_free(json_array_get_value(array, i));
-    }
-    array->count = 0;
-    return JSONSuccess;
-}
-
-JSON_Status json_array_append_value(JSON_Array *array, JSON_Value *value) {
-    if (array == NULL || value == NULL || value->parent != NULL) {
-        return JSONFailure;
-    }
-    return json_array_add(array, value);
-}
-
-JSON_Status json_array_append_string(JSON_Array *array, const char *string) {
-    JSON_Value *value = json_value_init_string(string);
-    if (value == NULL) {
-        return JSONFailure;
-    }
-    if (json_array_append_value(array, value) == JSONFailure) {
-        json_value_free(value);
-        return JSONFailure;
-    }
-    return JSONSuccess;
-}
-
-JSON_Status json_array_append_number(JSON_Array *array, double number) {
-    JSON_Value *value = json_value_init_number(number);
-    if (value == NULL) {
-        return JSONFailure;
-    }
-    if (json_array_append_value(array, value) == JSONFailure) {
-        json_value_free(value);
-        return JSONFailure;
-    }
-    return JSONSuccess;
-}
-
-JSON_Status json_array_append_boolean(JSON_Array *array, int boolean) {
-    JSON_Value *value = json_value_init_boolean(boolean);
-    if (value == NULL) {
-        return JSONFailure;
-    }
-    if (json_array_append_value(array, value) == JSONFailure) {
-        json_value_free(value);
-        return JSONFailure;
-    }
-    return JSONSuccess;
-}
-
-JSON_Status json_array_append_null(JSON_Array *array) {
-    JSON_Value *value = json_value_init_null();
-    if (value == NULL) {
-        return JSONFailure;
-    }
-    if (json_array_append_value(array, value) == JSONFailure) {
-        json_value_free(value);
-        return JSONFailure;
-    }
-    return JSONSuccess;
-}
-
-JSON_Status json_object_set_value(JSON_Object *object, const char *name, JSON_Value *value) {
-    size_t i = 0;
-    JSON_Value *old_value;
-    if (object == NULL || name == NULL || value == NULL || value->parent != NULL) {
-        return JSONFailure;
-    }
-    old_value = json_object_get_value(object, name);
-    if (old_value != NULL) { /* free and overwrite old value */
-        json_value_free(old_value);
-        for (i = 0; i < json_object_get_count(object); i++) {
-            if (strcmp(object->names[i], name) == 0) {
-                value->parent = json_object_get_wrapping_value(object);
-                object->values[i] = value;
-                return JSONSuccess;
-            }
-        }
-    }
-    /* add new key value pair */
-    return json_object_add(object, name, value);
-}
-
-JSON_Status json_object_set_string(JSON_Object *object, const char *name, const char *string) {
-    return json_object_set_value(object, name, json_value_init_string(string));
-}
-
-JSON_Status json_object_set_number(JSON_Object *object, const char *name, double number) {
-    return json_object_set_value(object, name, json_value_init_number(number));
-}
-
-JSON_Status json_object_set_boolean(JSON_Object *object, const char *name, int boolean) {
-    return json_object_set_value(object, name, json_value_init_boolean(boolean));
-}
-
-JSON_Status json_object_set_null(JSON_Object *object, const char *name) {
-    return json_object_set_value(object, name, json_value_init_null());
-}
-
-JSON_Status json_object_dotset_value(JSON_Object *object, const char *name, JSON_Value *value) {
-    const char *dot_pos = NULL;
-    char *current_name = NULL;
-    JSON_Object *temp_obj = NULL;
-    JSON_Value *new_value = NULL;
-    if (value == NULL || name == NULL || value == NULL) {
-        return JSONFailure;
-    }
-    dot_pos = strchr(name, '.');
-    if (dot_pos == NULL) {
-        return json_object_set_value(object, name, value);
-    } else {
-        current_name = parson_strndup(name, dot_pos - name);
-        temp_obj = json_object_get_object(object, current_name);
-        if (temp_obj == NULL) {
-            new_value = json_value_init_object();
-            if (new_value == NULL) {
-                parson_free(current_name);
-                return JSONFailure;
-            }
-            if (json_object_add(object, current_name, new_value) == JSONFailure) {
-                json_value_free(new_value);
-                parson_free(current_name);
-                return JSONFailure;
-            }
-            temp_obj = json_object_get_object(object, current_name);
-        }
-        parson_free(current_name);
-        return json_object_dotset_value(temp_obj, dot_pos + 1, value);
-    }
-}
-
-JSON_Status json_object_dotset_string(JSON_Object *object, const char *name, const char *string) {
-    JSON_Value *value = json_value_init_string(string);
-    if (value == NULL) {
-        return JSONFailure;
-    }
-    if (json_object_dotset_value(object, name, value) == JSONFailure) {
-        json_value_free(value);
-        return JSONFailure;
-    }
-    return JSONSuccess;
-}
-
-JSON_Status json_object_dotset_number(JSON_Object *object, const char *name, double number) {
-    JSON_Value *value = json_value_init_number(number);
-    if (value == NULL) {
-        return JSONFailure;
-    }
-    if (json_object_dotset_value(object, name, value) == JSONFailure) {
-        json_value_free(value);
-        return JSONFailure;
-    }
-    return JSONSuccess;
-}
-
-JSON_Status json_object_dotset_boolean(JSON_Object *object, const char *name, int boolean) {
-    JSON_Value *value = json_value_init_boolean(boolean);
-    if (value == NULL) {
-        return JSONFailure;
-    }
-    if (json_object_dotset_value(object, name, value) == JSONFailure) {
-        json_value_free(value);
-        return JSONFailure;
-    }
-    return JSONSuccess;
-}
-
-JSON_Status json_object_dotset_null(JSON_Object *object, const char *name) {
-    JSON_Value *value = json_value_init_null();
-    if (value == NULL) {
-        return JSONFailure;
-    }
-    if (json_object_dotset_value(object, name, value) == JSONFailure) {
-        json_value_free(value);
-        return JSONFailure;
-    }
-    return JSONSuccess;
-}
-
-JSON_Status json_object_remove(JSON_Object *object, const char *name) {
-    size_t i = 0, last_item_index = 0;
-    if (object == NULL || json_object_get_value(object, name) == NULL) {
-        return JSONFailure;
-    }
-    last_item_index = json_object_get_count(object) - 1;
-    for (i = 0; i < json_object_get_count(object); i++) {
-        if (strcmp(object->names[i], name) == 0) {
-            parson_free(object->names[i]);
-            json_value_free(object->values[i]);
-            if (i != last_item_index) { /* Replace key value pair with one from the end */
-                object->names[i] = object->names[last_item_index];
-                object->values[i] = object->values[last_item_index];
-            }
-            object->count -= 1;
-            return JSONSuccess;
-        }
-    }
-    return JSONFailure; /* No execution path should end here */
-}
-
-JSON_Status json_object_dotremove(JSON_Object *object, const char *name) {
-    const char *dot_pos = strchr(name, '.');
-    char *current_name = NULL;
-    JSON_Object *temp_obj = NULL;
-    if (dot_pos == NULL) {
-        return json_object_remove(object, name);
-    } else {
-        current_name = parson_strndup(name, dot_pos - name);
-        temp_obj = json_object_get_object(object, current_name);
-        parson_free(current_name);
-        if (temp_obj == NULL) {
-            return JSONFailure;
-        }
-        return json_object_dotremove(temp_obj, dot_pos + 1);
-    }
-}
-
-JSON_Status json_object_clear(JSON_Object *object) {
-    size_t i = 0;
-    if (object == NULL) {
-        return JSONFailure;
-    }
-    for (i = 0; i < json_object_get_count(object); i++) {
-        parson_free(object->names[i]);
-        json_value_free(object->values[i]);
-    }
-    object->count = 0;
-    return JSONSuccess;
-}
-
-JSON_Status json_validate(const JSON_Value *schema, const JSON_Value *value) {
-    JSON_Value *temp_schema_value = NULL, *temp_value = NULL;
-    JSON_Array *schema_array = NULL, *value_array = NULL;
-    JSON_Object *schema_object = NULL, *value_object = NULL;
-    JSON_Value_Type schema_type = JSONError, value_type = JSONError;
-    const char *key = NULL;
-    size_t i = 0, count = 0;
-    if (schema == NULL || value == NULL) {
-        return JSONFailure;
-    }
-    schema_type = json_value_get_type(schema);
-    value_type = json_value_get_type(value);
-    if (schema_type != value_type && schema_type != JSONNull) { /* null represents all values */
-        return JSONFailure;
-    }
-    switch (schema_type) {
-        case JSONArray:
-            schema_array = json_value_get_array(schema);
-            value_array = json_value_get_array(value);
-            count = json_array_get_count(schema_array);
-            if (count == 0) {
-                return JSONSuccess; /* Empty array allows all types */
-            }
-            /* Get first value from array, rest is ignored */
-            temp_schema_value = json_array_get_value(schema_array, 0);
-            for (i = 0; i < json_array_get_count(value_array); i++) {
-                temp_value = json_array_get_value(value_array, i);
-                if (json_validate(temp_schema_value, temp_value) == JSONFailure) {
-                    return JSONFailure;
-                }
-            }
-            return JSONSuccess;
-        case JSONObject:
-            schema_object = json_value_get_object(schema);
-            value_object = json_value_get_object(value);
-            count = json_object_get_count(schema_object);
-            if (count == 0) {
-                return JSONSuccess; /* Empty object allows all objects */
-            } else if (json_object_get_count(value_object) < count) {
-                return JSONFailure; /* Tested object mustn't have less name-value pairs than schema */
-            }
-            for (i = 0; i < count; i++) {
-                key = json_object_get_name(schema_object, i);
-                temp_schema_value = json_object_get_value(schema_object, key);
-                temp_value = json_object_get_value(value_object, key);
-                if (temp_value == NULL) {
-                    return JSONFailure;
-                }
-                if (json_validate(temp_schema_value, temp_value) == JSONFailure) {
-                    return JSONFailure;
-                }
-            }
-            return JSONSuccess;
-        case JSONString: case JSONNumber: case JSONBoolean: case JSONNull:
-            return JSONSuccess; /* equality already tested before switch */
-        case JSONError: default:
-            return JSONFailure;
-    }
-}
-
-JSON_Status json_value_equals(const JSON_Value *a, const JSON_Value *b) {
-    JSON_Object *a_object = NULL, *b_object = NULL;
-    JSON_Array *a_array = NULL, *b_array = NULL;
-    const char *a_string = NULL, *b_string = NULL;
-    const char *key = NULL;
-    size_t a_count = 0, b_count = 0, i = 0;
-    JSON_Value_Type a_type, b_type;
-    a_type = json_value_get_type(a);
-    b_type = json_value_get_type(b);
-    if (a_type != b_type) {
-        return 0;
-    }
-    switch (a_type) {
-        case JSONArray:
-            a_array = json_value_get_array(a);
-            b_array = json_value_get_array(b);
-            a_count = json_array_get_count(a_array);
-            b_count = json_array_get_count(b_array);
-            if (a_count != b_count) {
-                return 0;
-            }
-            for (i = 0; i < a_count; i++) {
-                if (!json_value_equals(json_array_get_value(a_array, i),
-                                       json_array_get_value(b_array, i))) {
-                    return 0;
-                }
-            }
-            return 1;
-        case JSONObject:
-            a_object = json_value_get_object(a);
-            b_object = json_value_get_object(b);
-            a_count = json_object_get_count(a_object);
-            b_count = json_object_get_count(b_object);
-            if (a_count != b_count) {
-                return 0;
-            }
-            for (i = 0; i < a_count; i++) {
-                key = json_object_get_name(a_object, i);
-                if (!json_value_equals(json_object_get_value(a_object, key),
-                                       json_object_get_value(b_object, key))) {
-                    return 0;
-                }
-            }
-            return 1;
-        case JSONString:
-            a_string = json_value_get_string(a);
-            b_string = json_value_get_string(b);
-            if (a_string == NULL || b_string == NULL) {
-                return 0; /* shouldn't happen */
-            }
-            return strcmp(a_string, b_string) == 0;
-        case JSONBoolean:
-            return json_value_get_boolean(a) == json_value_get_boolean(b);
-        case JSONNumber:
-            return fabs(json_value_get_number(a) - json_value_get_number(b)) < 0.000001; /* EPSILON */
-        case JSONError:
-            return 1;
-        case JSONNull:
-            return 1;
-        default:
-            return 1;
-    }
-}
-
-JSON_Value_Type json_type(const JSON_Value *value) {
-    return json_value_get_type(value);
-}
-
-JSON_Object * json_object (const JSON_Value *value) {
-    return json_value_get_object(value);
-}
-
-JSON_Array * json_array  (const JSON_Value *value) {
-    return json_value_get_array(value);
-}
-
-const char * json_string (const JSON_Value *value) {
-    return json_value_get_string(value);
-}
-
-double json_number (const JSON_Value *value) {
-    return json_value_get_number(value);
-}
-
-int json_boolean(const JSON_Value *value) {
-    return json_value_get_boolean(value);
-}
-
-void json_set_allocation_functions(JSON_Malloc_Function malloc_fun, JSON_Free_Function free_fun) {
-    parson_malloc = malloc_fun;
-    parson_free = free_fun;
-}
diff --git a/ext/parson/parson.cmake b/ext/parson/parson.cmake
deleted file mode 100644
index d55228b..0000000
--- a/ext/parson/parson.cmake
+++ /dev/null
@@ -1,6 +0,0 @@
-get_filename_component(ARCHIVE_NAME "${CMAKE_CURRENT_LIST_DIR}" NAME)
-message("${ARCHIVE_NAME}@${CMAKE_CURRENT_LIST_DIR} using: ${CMAKE_CURRENT_LIST_FILE} ")
-
-file(GLOB HEADER_FILES "${CMAKE_CURRENT_LIST_DIR}/*.h")
-file(GLOB SOURCE_FILES "${CMAKE_CURRENT_LIST_DIR}/*.c")
-add_library("${ARCHIVE_NAME}" "${HEADER_FILES}" "${SOURCE_FILES}")
diff --git a/ext/parson/parson.h b/ext/parson/parson.h
deleted file mode 100644
index 6438c93..0000000
--- a/ext/parson/parson.h
+++ /dev/null
@@ -1,234 +0,0 @@
-/*
- Parson ( http://kgabis.github.com/parson/ )
- Copyright (c) 2012 - 2017 Krzysztof Gabis
-
- Permission is hereby granted, free of charge, to any person obtaining a copy
- of this software and associated documentation files (the "Software"), to deal
- in the Software without restriction, including without limitation the rights
- to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- copies of the Software, and to permit persons to whom the Software is
- furnished to do so, subject to the following conditions:
-
- The above copyright notice and this permission notice shall be included in
- all copies or substantial portions of the Software.
-
- 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.
-*/
-
-#ifndef parson_parson_h
-#define parson_parson_h
-
-#ifdef __cplusplus
-extern "C"
-{
-#endif
-
-#include <stddef.h>   /* size_t */
-
-/* Types and enums */
-typedef struct json_object_t JSON_Object;
-typedef struct json_array_t  JSON_Array;
-typedef struct json_value_t  JSON_Value;
-
-enum json_value_type {
-    JSONError   = -1,
-    JSONNull    = 1,
-    JSONString  = 2,
-    JSONNumber  = 3,
-    JSONObject  = 4,
-    JSONArray   = 5,
-    JSONBoolean = 6
-};
-typedef int JSON_Value_Type;
-
-enum json_result_t {
-    JSONSuccess = 0,
-    JSONFailure = -1
-};
-typedef int JSON_Status;
-
-typedef void * (*JSON_Malloc_Function)(size_t);
-typedef void   (*JSON_Free_Function)(void *);
-
-/* Call only once, before calling any other function from parson API. If not called, malloc and free
-   from stdlib will be used for all allocations */
-void json_set_allocation_functions(JSON_Malloc_Function malloc_fun, JSON_Free_Function free_fun);
-
-/* Parses first JSON value in a file, returns NULL in case of error */
-JSON_Value * json_parse_file(const char *filename);
-
-/* Parses first JSON value in a file and ignores comments (/ * * / and //),
-   returns NULL in case of error */
-JSON_Value * json_parse_file_with_comments(const char *filename);
-
-/*  Parses first JSON value in a string, returns NULL in case of error */
-JSON_Value * json_parse_string(const char *string);
-
-/*  Parses first JSON value in a string and ignores comments (/ * * / and //),
-    returns NULL in case of error */
-JSON_Value * json_parse_string_with_comments(const char *string);
-
-/* Serialization */
-size_t      json_serialization_size(const JSON_Value *value); /* returns 0 on fail */
-JSON_Status json_serialize_to_buffer(const JSON_Value *value, char *buf, size_t buf_size_in_bytes);
-JSON_Status json_serialize_to_file(const JSON_Value *value, const char *filename);
-char *      json_serialize_to_string(const JSON_Value *value);
-
-/* Pretty serialization */
-size_t      json_serialization_size_pretty(const JSON_Value *value); /* returns 0 on fail */
-JSON_Status json_serialize_to_buffer_pretty(const JSON_Value *value, char *buf, size_t buf_size_in_bytes);
-JSON_Status json_serialize_to_file_pretty(const JSON_Value *value, const char *filename);
-char *      json_serialize_to_string_pretty(const JSON_Value *value);
-
-void        json_free_serialized_string(char *string); /* frees string from json_serialize_to_string and json_serialize_to_string_pretty */
-
-/* Comparing */
-int  json_value_equals(const JSON_Value *a, const JSON_Value *b);
-
-/* Validation
-   This is *NOT* JSON Schema. It validates json by checking if object have identically
-   named fields with matching types.
-   For example schema {"name":"", "age":0} will validate
-   {"name":"Joe", "age":25} and {"name":"Joe", "age":25, "gender":"m"},
-   but not {"name":"Joe"} or {"name":"Joe", "age":"Cucumber"}.
-   In case of arrays, only first value in schema is checked against all values in tested array.
-   Empty objects ({}) validate all objects, empty arrays ([]) validate all arrays,
-   null validates values of every type.
- */
-JSON_Status json_validate(const JSON_Value *schema, const JSON_Value *value);
-
-/*
- * JSON Object
- */
-JSON_Value  * json_object_get_value  (const JSON_Object *object, const char *name);
-const char  * json_object_get_string (const JSON_Object *object, const char *name);
-JSON_Object * json_object_get_object (const JSON_Object *object, const char *name);
-JSON_Array  * json_object_get_array  (const JSON_Object *object, const char *name);
-double        json_object_get_number (const JSON_Object *object, const char *name); /* returns 0 on fail */
-int           json_object_get_boolean(const JSON_Object *object, const char *name); /* returns -1 on fail */
-
-/* dotget functions enable addressing values with dot notation in nested objects,
- just like in structs or c++/java/c# objects (e.g. objectA.objectB.value).
- Because valid names in JSON can contain dots, some values may be inaccessible
- this way. */
-JSON_Value  * json_object_dotget_value  (const JSON_Object *object, const char *name);
-const char  * json_object_dotget_string (const JSON_Object *object, const char *name);
-JSON_Object * json_object_dotget_object (const JSON_Object *object, const char *name);
-JSON_Array  * json_object_dotget_array  (const JSON_Object *object, const char *name);
-double        json_object_dotget_number (const JSON_Object *object, const char *name); /* returns 0 on fail */
-int           json_object_dotget_boolean(const JSON_Object *object, const char *name); /* returns -1 on fail */
-
-/* Functions to get available names */
-size_t        json_object_get_count   (const JSON_Object *object);
-const char  * json_object_get_name    (const JSON_Object *object, size_t index);
-JSON_Value  * json_object_get_value_at(const JSON_Object *object, size_t index);
-JSON_Value  * json_object_get_wrapping_value(const JSON_Object *object);
-
-/* Functions to check if object has a value with a specific name. Returned value is 1 if object has
- * a value and 0 if it doesn't. dothas functions behave exactly like dotget functions. */
-int json_object_has_value        (const JSON_Object *object, const char *name);
-int json_object_has_value_of_type(const JSON_Object *object, const char *name, JSON_Value_Type type);
-
-int json_object_dothas_value        (const JSON_Object *object, const char *name);
-int json_object_dothas_value_of_type(const JSON_Object *object, const char *name, JSON_Value_Type type);
-
-/* Creates new name-value pair or frees and replaces old value with a new one.
- * json_object_set_value does not copy passed value so it shouldn't be freed afterwards. */
-JSON_Status json_object_set_value(JSON_Object *object, const char *name, JSON_Value *value);
-JSON_Status json_object_set_string(JSON_Object *object, const char *name, const char *string);
-JSON_Status json_object_set_number(JSON_Object *object, const char *name, double number);
-JSON_Status json_object_set_boolean(JSON_Object *object, const char *name, int boolean);
-JSON_Status json_object_set_null(JSON_Object *object, const char *name);
-
-/* Works like dotget functions, but creates whole hierarchy if necessary.
- * json_object_dotset_value does not copy passed value so it shouldn't be freed afterwards. */
-JSON_Status json_object_dotset_value(JSON_Object *object, const char *name, JSON_Value *value);
-JSON_Status json_object_dotset_string(JSON_Object *object, const char *name, const char *string);
-JSON_Status json_object_dotset_number(JSON_Object *object, const char *name, double number);
-JSON_Status json_object_dotset_boolean(JSON_Object *object, const char *name, int boolean);
-JSON_Status json_object_dotset_null(JSON_Object *object, const char *name);
-
-/* Frees and removes name-value pair */
-JSON_Status json_object_remove(JSON_Object *object, const char *name);
-
-/* Works like dotget function, but removes name-value pair only on exact match. */
-JSON_Status json_object_dotremove(JSON_Object *object, const char *key);
-
-/* Removes all name-value pairs in object */
-JSON_Status json_object_clear(JSON_Object *object);
-
-/*
- *JSON Array
- */
-JSON_Value  * json_array_get_value  (const JSON_Array *array, size_t index);
-const char  * json_array_get_string (const JSON_Array *array, size_t index);
-JSON_Object * json_array_get_object (const JSON_Array *array, size_t index);
-JSON_Array  * json_array_get_array  (const JSON_Array *array, size_t index);
-double        json_array_get_number (const JSON_Array *array, size_t index); /* returns 0 on fail */
-int           json_array_get_boolean(const JSON_Array *array, size_t index); /* returns -1 on fail */
-size_t        json_array_get_count  (const JSON_Array *array);
-JSON_Value  * json_array_get_wrapping_value(const JSON_Array *array);
-    
-/* Frees and removes value at given index, does nothing and returns JSONFailure if index doesn't exist.
- * Order of values in array may change during execution.  */
-JSON_Status json_array_remove(JSON_Array *array, size_t i);
-
-/* Frees and removes from array value at given index and replaces it with given one.
- * Does nothing and returns JSONFailure if index doesn't exist.
- * json_array_replace_value does not copy passed value so it shouldn't be freed afterwards. */
-JSON_Status json_array_replace_value(JSON_Array *array, size_t i, JSON_Value *value);
-JSON_Status json_array_replace_string(JSON_Array *array, size_t i, const char* string);
-JSON_Status json_array_replace_number(JSON_Array *array, size_t i, double number);
-JSON_Status json_array_replace_boolean(JSON_Array *array, size_t i, int boolean);
-JSON_Status json_array_replace_null(JSON_Array *array, size_t i);
-
-/* Frees and removes all values from array */
-JSON_Status json_array_clear(JSON_Array *array);
-
-/* Appends new value at the end of array.
- * json_array_append_value does not copy passed value so it shouldn't be freed afterwards. */
-JSON_Status json_array_append_value(JSON_Array *array, JSON_Value *value);
-JSON_Status json_array_append_string(JSON_Array *array, const char *string);
-JSON_Status json_array_append_number(JSON_Array *array, double number);
-JSON_Status json_array_append_boolean(JSON_Array *array, int boolean);
-JSON_Status json_array_append_null(JSON_Array *array);
-
-/*
- *JSON Value
- */
-JSON_Value * json_value_init_object (void);
-JSON_Value * json_value_init_array  (void);
-JSON_Value * json_value_init_string (const char *string); /* copies passed string */
-JSON_Value * json_value_init_number (double number);
-JSON_Value * json_value_init_boolean(int boolean);
-JSON_Value * json_value_init_null   (void);
-JSON_Value * json_value_deep_copy   (const JSON_Value *value);
-void         json_value_free        (JSON_Value *value);
-
-JSON_Value_Type json_value_get_type   (const JSON_Value *value);
-JSON_Object *   json_value_get_object (const JSON_Value *value);
-JSON_Array  *   json_value_get_array  (const JSON_Value *value);
-const char  *   json_value_get_string (const JSON_Value *value);
-double          json_value_get_number (const JSON_Value *value);
-int             json_value_get_boolean(const JSON_Value *value);
-JSON_Value  *   json_value_get_parent (const JSON_Value *value);
-
-/* Same as above, but shorter */
-JSON_Value_Type json_type   (const JSON_Value *value);
-JSON_Object *   json_object (const JSON_Value *value);
-JSON_Array  *   json_array  (const JSON_Value *value);
-const char  *   json_string (const JSON_Value *value);
-double          json_number (const JSON_Value *value);
-int             json_boolean(const JSON_Value *value);
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif
diff --git a/ext/picohttpparser/README.md b/ext/picohttpparser/README.md
deleted file mode 100644
index cb32f58..0000000
--- a/ext/picohttpparser/README.md
+++ /dev/null
@@ -1,116 +0,0 @@
-PicoHTTPParser
-=============
-
-Copyright (c) 2009-2014 [Kazuho Oku](https://github.com/kazuho), [Tokuhiro Matsuno](https://github.com/tokuhirom), [Daisuke Murase](https://github.com/typester), [Shigeo Mitsunari](https://github.com/herumi)
-
-PicoHTTPParser is a tiny, primitive, fast HTTP request/response parser.
-
-Unlike most parsers, it is stateless and does not allocate memory by itself.
-All it does is accept pointer to buffer and the output structure, and setups the pointers in the latter to point at the necessary portions of the buffer.
-
-The code is widely deployed within Perl applications through popular modules that use it, including [Plack](https://metacpan.org/pod/Plack), [Starman](https://metacpan.org/pod/Starman), [Starlet](https://metacpan.org/pod/Starlet), [Furl](https://metacpan.org/pod/Furl).  It is also the HTTP/1 parser of [H2O](https://github.com/h2o/h2o).
-
-Check out [test.c] to find out how to use the parser.
-
-The software is dual-licensed under the Perl License or the MIT License.
-
-Usage
------
-
-The library exposes four functions: `phr_parse_request`, `phr_parse_response`, `phr_parse_headers`, `phr_decode_chunked`.
-
-### phr_parse_request
-
-The example below reads an HTTP request from socket `sock` using `read(2)`, parses it using `phr_parse_request`, and prints the details.
-
-```c
-char buf[4096], *method, *path;
-int pret, minor_version;
-struct phr_header headers[100];
-size_t buflen = 0, prevbuflen = 0, method_len, path_len, num_headers;
-ssize_t rret;
-
-while (1) {
-    /* read the request */
-    while ((rret = read(sock, buf + buflen, sizeof(buf) - buflen)) == -1 && errno == EINTR)
-        ;
-    if (rret <= 0)
-        return IOError;
-    prevbuflen = buflen;
-    buflen += rret;
-    /* parse the request */
-    num_headers = sizeof(headers) / sizeof(headers[0]);
-    pret = phr_parse_request(buf, buflen, &method, &method_len, &path, &path_len,
-                             &minor_version, headers, &num_headers, prevbuflen);
-    if (pret > 0)
-        break; /* successfully parsed the request */
-    else if (pret == -1)
-        return ParseError;
-    /* request is incomplete, continue the loop */
-    assert(pret == -2);
-    if (buflen == sizeof(buf))
-        return RequestIsTooLongError;
-}
-
-printf("request is %d bytes long\n", pret);
-printf("method is %.*s\n", (int)method_len, method);
-printf("path is %.*s\n", (int)path_len, path);
-printf("HTTP version is 1.%d\n", minor_version);
-printf("headers:\n");
-for (i = 0; i != num_headers; ++i) {
-    printf("%.*s: %.*s\n", (int)headers[i].name_len, headers[i].name,
-           (int)headers[i].value_len, headers[i].value);
-}
-```
-
-### phr_parse_response, phr_parse_headers
-
-`phr_parse_response` and `phr_parse_headers` provide similar interfaces as `phr_parse_request`.  `phr_parse_response` parses an HTTP response, and `phr_parse_headers` parses the headers only.
-
-### phr_decode_chunked
-
-The example below decodes incoming data in chunked-encoding.  The data is decoded in-place.
-
-```c
-struct phr_chunked_decoder decoder = {}; /* zero-clear */
-char *buf = malloc(4096);
-size_t size = 0, capacity = 4096, rsize;
-ssize_t rret, pret;
-
-/* set consume_trailer to 1 to discard the trailing header, or the application
- * should call phr_parse_headers to parse the trailing header */
-decoder.consume_trailer = 1;
-
-do {
-    /* expand the buffer if necessary */
-    if (size == capacity) {
-        capacity *= 2;
-        buf = realloc(buf, capacity);
-        assert(buf != NULL);
-    }
-    /* read */
-    while ((rret = read(sock, buf + size, capacity - size)) == -1 && errno == EINTR)
-        ;
-    if (rret <= 0)
-        return IOError;
-    /* decode */
-    rsize = rret;
-    pret = phr_decode_chunked(&decoder, buf + size, &rsize);
-    if (pret == -1)
-        return ParseError;
-    size += rsize;
-} while (pret == -2);
-
-/* successfully decoded the chunked data */
-assert(pret >= 0);
-printf("decoded data is at %p (%zu bytes)\n", buf, size);
-```
-
-Benchmark
----------
-
-![benchmark results](http://i.gyazo.com/a85c18d3162dfb46b485bb41e0ad443a.png)
-
-The benchmark code is from [fukamachi/fast-http@6b91103](https://github.com/fukamachi/fast-http/tree/6b9110347c7a3407310c08979aefd65078518478).
-
-The internals of picohttpparser has been described to some extent in [my blog entry]( http://blog.kazuhooku.com/2014/11/the-internals-h2o-or-how-to-write-fast.html).
diff --git a/ext/picohttpparser/picohttpparser.c b/ext/picohttpparser/picohttpparser.c
deleted file mode 100644
index 6a2d872..0000000
--- a/ext/picohttpparser/picohttpparser.c
+++ /dev/null
@@ -1,620 +0,0 @@
-/*
- * Copyright (c) 2009-2014 Kazuho Oku, Tokuhiro Matsuno, Daisuke Murase,
- *                         Shigeo Mitsunari
- *
- * The software is licensed under either the MIT License (below) or the Perl
- * license.
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to
- * deal in the Software without restriction, including without limitation the
- * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
- * sell copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in
- * all copies or substantial portions of the Software.
- *
- * 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 <assert.h>
-#include <stddef.h>
-#include <string.h>
-#ifdef __SSE4_2__
-#ifdef _MSC_VER
-#include <nmmintrin.h>
-#else
-#include <x86intrin.h>
-#endif
-#endif
-#include "picohttpparser.h"
-
-/* $Id: a707070d11d499609f99d09f97535642cec910a8 $ */
-
-#if __GNUC__ >= 3
-#define likely(x) __builtin_expect(!!(x), 1)
-#define unlikely(x) __builtin_expect(!!(x), 0)
-#else
-#define likely(x) (x)
-#define unlikely(x) (x)
-#endif
-
-#ifdef _MSC_VER
-#define ALIGNED(n) _declspec(align(n))
-#else
-#define ALIGNED(n) __attribute__((aligned(n)))
-#endif
-
-#define IS_PRINTABLE_ASCII(c) ((unsigned char)(c)-040u < 0137u)
-
-#define CHECK_EOF()                                                                                                                \
-    if (buf == buf_end) {                                                                                                          \
-        *ret = -2;                                                                                                                 \
-        return NULL;                                                                                                               \
-    }
-
-#define EXPECT_CHAR_NO_CHECK(ch)                                                                                                   \
-    if (*buf++ != ch) {                                                                                                            \
-        *ret = -1;                                                                                                                 \
-        return NULL;                                                                                                               \
-    }
-
-#define EXPECT_CHAR(ch)                                                                                                            \
-    CHECK_EOF();                                                                                                                   \
-    EXPECT_CHAR_NO_CHECK(ch);
-
-#define ADVANCE_TOKEN(tok, toklen)                                                                                                 \
-    do {                                                                                                                           \
-        const char *tok_start = buf;                                                                                               \
-        static const char ALIGNED(16) ranges2[] = "\000\040\177\177";                                                              \
-        int found2;                                                                                                                \
-        buf = findchar_fast(buf, buf_end, ranges2, sizeof(ranges2) - 1, &found2);                                                  \
-        if (!found2) {                                                                                                             \
-            CHECK_EOF();                                                                                                           \
-        }                                                                                                                          \
-        while (1) {                                                                                                                \
-            if (*buf == ' ') {                                                                                                     \
-                break;                                                                                                             \
-            } else if (unlikely(!IS_PRINTABLE_ASCII(*buf))) {                                                                      \
-                if ((unsigned char)*buf < '\040' || *buf == '\177') {                                                              \
-                    *ret = -1;                                                                                                     \
-                    return NULL;                                                                                                   \
-                }                                                                                                                  \
-            }                                                                                                                      \
-            ++buf;                                                                                                                 \
-            CHECK_EOF();                                                                                                           \
-        }                                                                                                                          \
-        tok = tok_start;                                                                                                           \
-        toklen = buf - tok_start;                                                                                                  \
-    } while (0)
-
-static const char *token_char_map = "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
-                                    "\0\1\0\1\1\1\1\1\0\0\1\1\0\1\1\0\1\1\1\1\1\1\1\1\1\1\0\0\0\0\0\0"
-                                    "\0\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\0\0\0\1\1"
-                                    "\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\0\1\0\1\0"
-                                    "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
-                                    "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
-                                    "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
-                                    "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0";
-
-static const char *findchar_fast(const char *buf, const char *buf_end, const char *ranges, size_t ranges_size, int *found)
-{
-    *found = 0;
-#if __SSE4_2__
-    if (likely(buf_end - buf >= 16)) {
-        __m128i ranges16 = _mm_loadu_si128((const __m128i *)ranges);
-
-        size_t left = (buf_end - buf) & ~15;
-        do {
-            __m128i b16 = _mm_loadu_si128((const __m128i *)buf);
-            int r = _mm_cmpestri(ranges16, ranges_size, b16, 16, _SIDD_LEAST_SIGNIFICANT | _SIDD_CMP_RANGES | _SIDD_UBYTE_OPS);
-            if (unlikely(r != 16)) {
-                buf += r;
-                *found = 1;
-                break;
-            }
-            buf += 16;
-            left -= 16;
-        } while (likely(left != 0));
-    }
-#else
-    /* suppress unused parameter warning */
-    (void)buf_end;
-    (void)ranges;
-    (void)ranges_size;
-#endif
-    return buf;
-}
-
-static const char *get_token_to_eol(const char *buf, const char *buf_end, const char **token, size_t *token_len, int *ret)
-{
-    const char *token_start = buf;
-
-#ifdef __SSE4_2__
-    static const char ranges1[] = "\0\010"
-                                  /* allow HT */
-                                  "\012\037"
-                                  /* allow SP and up to but not including DEL */
-                                  "\177\177"
-        /* allow chars w. MSB set */
-        ;
-    int found;
-    buf = findchar_fast(buf, buf_end, ranges1, sizeof(ranges1) - 1, &found);
-    if (found)
-        goto FOUND_CTL;
-#else
-    /* find non-printable char within the next 8 bytes, this is the hottest code; manually inlined */
-    while (likely(buf_end - buf >= 8)) {
-#define DOIT()                                                                                                                     \
-    do {                                                                                                                           \
-        if (unlikely(!IS_PRINTABLE_ASCII(*buf)))                                                                                   \
-            goto NonPrintable;                                                                                                     \
-        ++buf;                                                                                                                     \
-    } while (0)
-        DOIT();
-        DOIT();
-        DOIT();
-        DOIT();
-        DOIT();
-        DOIT();
-        DOIT();
-        DOIT();
-#undef DOIT
-        continue;
-    NonPrintable:
-        if ((likely((unsigned char)*buf < '\040') && likely(*buf != '\011')) || unlikely(*buf == '\177')) {
-            goto FOUND_CTL;
-        }
-        ++buf;
-    }
-#endif
-    for (;; ++buf) {
-        CHECK_EOF();
-        if (unlikely(!IS_PRINTABLE_ASCII(*buf))) {
-            if ((likely((unsigned char)*buf < '\040') && likely(*buf != '\011')) || unlikely(*buf == '\177')) {
-                goto FOUND_CTL;
-            }
-        }
-    }
-FOUND_CTL:
-    if (likely(*buf == '\015')) {
-        ++buf;
-        EXPECT_CHAR('\012');
-        *token_len = buf - 2 - token_start;
-    } else if (*buf == '\012') {
-        *token_len = buf - token_start;
-        ++buf;
-    } else {
-        *ret = -1;
-        return NULL;
-    }
-    *token = token_start;
-
-    return buf;
-}
-
-static const char *is_complete(const char *buf, const char *buf_end, size_t last_len, int *ret)
-{
-    int ret_cnt = 0;
-    buf = last_len < 3 ? buf : buf + last_len - 3;
-
-    while (1) {
-        CHECK_EOF();
-        if (*buf == '\015') {
-            ++buf;
-            CHECK_EOF();
-            EXPECT_CHAR('\012');
-            ++ret_cnt;
-        } else if (*buf == '\012') {
-            ++buf;
-            ++ret_cnt;
-        } else {
-            ++buf;
-            ret_cnt = 0;
-        }
-        if (ret_cnt == 2) {
-            return buf;
-        }
-    }
-
-    *ret = -2;
-    return NULL;
-}
-
-#define PARSE_INT(valp_, mul_)                                                                                                     \
-    if (*buf < '0' || '9' < *buf) {                                                                                                \
-        buf++;                                                                                                                     \
-        *ret = -1;                                                                                                                 \
-        return NULL;                                                                                                               \
-    }                                                                                                                              \
-    *(valp_) = (mul_) * (*buf++ - '0');
-
-#define PARSE_INT_3(valp_)                                                                                                         \
-    do {                                                                                                                           \
-        int res_ = 0;                                                                                                              \
-        PARSE_INT(&res_, 100)                                                                                                      \
-        *valp_ = res_;                                                                                                             \
-        PARSE_INT(&res_, 10)                                                                                                       \
-        *valp_ += res_;                                                                                                            \
-        PARSE_INT(&res_, 1)                                                                                                        \
-        *valp_ += res_;                                                                                                            \
-    } while (0)
-
-/* returned pointer is always within [buf, buf_end), or null */
-static const char *parse_http_version(const char *buf, const char *buf_end, int *minor_version, int *ret)
-{
-    /* we want at least [HTTP/1.<two chars>] to try to parse */
-    if (buf_end - buf < 9) {
-        *ret = -2;
-        return NULL;
-    }
-    EXPECT_CHAR_NO_CHECK('H');
-    EXPECT_CHAR_NO_CHECK('T');
-    EXPECT_CHAR_NO_CHECK('T');
-    EXPECT_CHAR_NO_CHECK('P');
-    EXPECT_CHAR_NO_CHECK('/');
-    EXPECT_CHAR_NO_CHECK('1');
-    EXPECT_CHAR_NO_CHECK('.');
-    PARSE_INT(minor_version, 1);
-    return buf;
-}
-
-static const char *parse_headers(const char *buf, const char *buf_end, struct phr_header *headers, size_t *num_headers,
-                                 size_t max_headers, int *ret)
-{
-    for (;; ++*num_headers) {
-        CHECK_EOF();
-        if (*buf == '\015') {
-            ++buf;
-            EXPECT_CHAR('\012');
-            break;
-        } else if (*buf == '\012') {
-            ++buf;
-            break;
-        }
-        if (*num_headers == max_headers) {
-            *ret = -1;
-            return NULL;
-        }
-        if (!(*num_headers != 0 && (*buf == ' ' || *buf == '\t'))) {
-            /* parsing name, but do not discard SP before colon, see
-             * http://www.mozilla.org/security/announce/2006/mfsa2006-33.html */
-            headers[*num_headers].name = buf;
-            static const char ALIGNED(16) ranges1[] = "\x00 "  /* control chars and up to SP */
-                                                      "\"\""   /* 0x22 */
-                                                      "()"     /* 0x28,0x29 */
-                                                      ",,"     /* 0x2c */
-                                                      "//"     /* 0x2f */
-                                                      ":@"     /* 0x3a-0x40 */
-                                                      "[]"     /* 0x5b-0x5d */
-                                                      "{\377"; /* 0x7b-0xff */
-            int found;
-            buf = findchar_fast(buf, buf_end, ranges1, sizeof(ranges1) - 1, &found);
-            if (!found) {
-                CHECK_EOF();
-            }
-            while (1) {
-                if (*buf == ':') {
-                    break;
-                } else if (!token_char_map[(unsigned char)*buf]) {
-                    *ret = -1;
-                    return NULL;
-                }
-                ++buf;
-                CHECK_EOF();
-            }
-            if ((headers[*num_headers].name_len = buf - headers[*num_headers].name) == 0) {
-                *ret = -1;
-                return NULL;
-            }
-            ++buf;
-            for (;; ++buf) {
-                CHECK_EOF();
-                if (!(*buf == ' ' || *buf == '\t')) {
-                    break;
-                }
-            }
-        } else {
-            headers[*num_headers].name = NULL;
-            headers[*num_headers].name_len = 0;
-        }
-        if ((buf = get_token_to_eol(buf, buf_end, &headers[*num_headers].value, &headers[*num_headers].value_len, ret)) == NULL) {
-            return NULL;
-        }
-    }
-    return buf;
-}
-
-static const char *parse_request(const char *buf, const char *buf_end, const char **method, size_t *method_len, const char **path,
-                                 size_t *path_len, int *minor_version, struct phr_header *headers, size_t *num_headers,
-                                 size_t max_headers, int *ret)
-{
-    /* skip first empty line (some clients add CRLF after POST content) */
-    CHECK_EOF();
-    if (*buf == '\015') {
-        ++buf;
-        EXPECT_CHAR('\012');
-    } else if (*buf == '\012') {
-        ++buf;
-    }
-
-    /* parse request line */
-    ADVANCE_TOKEN(*method, *method_len);
-    ++buf;
-    ADVANCE_TOKEN(*path, *path_len);
-    ++buf;
-    if ((buf = parse_http_version(buf, buf_end, minor_version, ret)) == NULL) {
-        return NULL;
-    }
-    if (*buf == '\015') {
-        ++buf;
-        EXPECT_CHAR('\012');
-    } else if (*buf == '\012') {
-        ++buf;
-    } else {
-        *ret = -1;
-        return NULL;
-    }
-
-    return parse_headers(buf, buf_end, headers, num_headers, max_headers, ret);
-}
-
-int phr_parse_request(const char *buf_start, size_t len, const char **method, size_t *method_len, const char **path,
-                      size_t *path_len, int *minor_version, struct phr_header *headers, size_t *num_headers, size_t last_len)
-{
-    const char *buf = buf_start, *buf_end = buf_start + len;
-    size_t max_headers = *num_headers;
-    int r;
-
-    *method = NULL;
-    *method_len = 0;
-    *path = NULL;
-    *path_len = 0;
-    *minor_version = -1;
-    *num_headers = 0;
-
-    /* if last_len != 0, check if the request is complete (a fast countermeasure
-       againt slowloris */
-    if (last_len != 0 && is_complete(buf, buf_end, last_len, &r) == NULL) {
-        return r;
-    }
-
-    if ((buf = parse_request(buf, buf_end, method, method_len, path, path_len, minor_version, headers, num_headers, max_headers,
-                             &r)) == NULL) {
-        return r;
-    }
-
-    return (int)(buf - buf_start);
-}
-
-static const char *parse_response(const char *buf, const char *buf_end, int *minor_version, int *status, const char **msg,
-                                  size_t *msg_len, struct phr_header *headers, size_t *num_headers, size_t max_headers, int *ret)
-{
-    /* parse "HTTP/1.x" */
-    if ((buf = parse_http_version(buf, buf_end, minor_version, ret)) == NULL) {
-        return NULL;
-    }
-    /* skip space */
-    if (*buf++ != ' ') {
-        *ret = -1;
-        return NULL;
-    }
-    /* parse status code, we want at least [:digit:][:digit:][:digit:]<other char> to try to parse */
-    if (buf_end - buf < 4) {
-        *ret = -2;
-        return NULL;
-    }
-    PARSE_INT_3(status);
-
-    /* skip space */
-    if (*buf++ != ' ') {
-        *ret = -1;
-        return NULL;
-    }
-    /* get message */
-    if ((buf = get_token_to_eol(buf, buf_end, msg, msg_len, ret)) == NULL) {
-        return NULL;
-    }
-
-    return parse_headers(buf, buf_end, headers, num_headers, max_headers, ret);
-}
-
-int phr_parse_response(const char *buf_start, size_t len, int *minor_version, int *status, const char **msg, size_t *msg_len,
-                       struct phr_header *headers, size_t *num_headers, size_t last_len)
-{
-    const char *buf = buf_start, *buf_end = buf + len;
-    size_t max_headers = *num_headers;
-    int r;
-
-    *minor_version = -1;
-    *status = 0;
-    *msg = NULL;
-    *msg_len = 0;
-    *num_headers = 0;
-
-    /* if last_len != 0, check if the response is complete (a fast countermeasure
-       against slowloris */
-    if (last_len != 0 && is_complete(buf, buf_end, last_len, &r) == NULL) {
-        return r;
-    }
-
-    if ((buf = parse_response(buf, buf_end, minor_version, status, msg, msg_len, headers, num_headers, max_headers, &r)) == NULL) {
-        return r;
-    }
-
-    return (int)(buf - buf_start);
-}
-
-int phr_parse_headers(const char *buf_start, size_t len, struct phr_header *headers, size_t *num_headers, size_t last_len)
-{
-    const char *buf = buf_start, *buf_end = buf + len;
-    size_t max_headers = *num_headers;
-    int r;
-
-    *num_headers = 0;
-
-    /* if last_len != 0, check if the response is complete (a fast countermeasure
-       against slowloris */
-    if (last_len != 0 && is_complete(buf, buf_end, last_len, &r) == NULL) {
-        return r;
-    }
-
-    if ((buf = parse_headers(buf, buf_end, headers, num_headers, max_headers, &r)) == NULL) {
-        return r;
-    }
-
-    return (int)(buf - buf_start);
-}
-
-enum {
-    CHUNKED_IN_CHUNK_SIZE,
-    CHUNKED_IN_CHUNK_EXT,
-    CHUNKED_IN_CHUNK_DATA,
-    CHUNKED_IN_CHUNK_CRLF,
-    CHUNKED_IN_TRAILERS_LINE_HEAD,
-    CHUNKED_IN_TRAILERS_LINE_MIDDLE
-};
-
-static int decode_hex(int ch)
-{
-    if ('0' <= ch && ch <= '9') {
-        return ch - '0';
-    } else if ('A' <= ch && ch <= 'F') {
-        return ch - 'A' + 0xa;
-    } else if ('a' <= ch && ch <= 'f') {
-        return ch - 'a' + 0xa;
-    } else {
-        return -1;
-    }
-}
-
-ssize_t phr_decode_chunked(struct phr_chunked_decoder *decoder, char *buf, size_t *_bufsz)
-{
-    size_t dst = 0, src = 0, bufsz = *_bufsz;
-    ssize_t ret = -2; /* incomplete */
-
-    while (1) {
-        switch (decoder->_state) {
-        case CHUNKED_IN_CHUNK_SIZE:
-            for (;; ++src) {
-                int v;
-                if (src == bufsz)
-                    goto Exit;
-                if ((v = decode_hex(buf[src])) == -1) {
-                    if (decoder->_hex_count == 0) {
-                        ret = -1;
-                        goto Exit;
-                    }
-                    break;
-                }
-                if (decoder->_hex_count == sizeof(size_t) * 2) {
-                    ret = -1;
-                    goto Exit;
-                }
-                decoder->bytes_left_in_chunk = decoder->bytes_left_in_chunk * 16 + v;
-                ++decoder->_hex_count;
-            }
-            decoder->_hex_count = 0;
-            decoder->_state = CHUNKED_IN_CHUNK_EXT;
-        /* fallthru */
-        case CHUNKED_IN_CHUNK_EXT:
-            /* RFC 7230 A.2 "Line folding in chunk extensions is disallowed" */
-            for (;; ++src) {
-                if (src == bufsz)
-                    goto Exit;
-                if (buf[src] == '\012')
-                    break;
-            }
-            ++src;
-            if (decoder->bytes_left_in_chunk == 0) {
-                if (decoder->consume_trailer) {
-                    decoder->_state = CHUNKED_IN_TRAILERS_LINE_HEAD;
-                    break;
-                } else {
-                    goto Complete;
-                }
-            }
-            decoder->_state = CHUNKED_IN_CHUNK_DATA;
-        /* fallthru */
-        case CHUNKED_IN_CHUNK_DATA: {
-            size_t avail = bufsz - src;
-            if (avail < decoder->bytes_left_in_chunk) {
-                if (dst != src)
-                    memmove(buf + dst, buf + src, avail);
-                src += avail;
-                dst += avail;
-                decoder->bytes_left_in_chunk -= avail;
-                goto Exit;
-            }
-            if (dst != src)
-                memmove(buf + dst, buf + src, decoder->bytes_left_in_chunk);
-            src += decoder->bytes_left_in_chunk;
-            dst += decoder->bytes_left_in_chunk;
-            decoder->bytes_left_in_chunk = 0;
-            decoder->_state = CHUNKED_IN_CHUNK_CRLF;
-        }
-        /* fallthru */
-        case CHUNKED_IN_CHUNK_CRLF:
-            for (;; ++src) {
-                if (src == bufsz)
-                    goto Exit;
-                if (buf[src] != '\015')
-                    break;
-            }
-            if (buf[src] != '\012') {
-                ret = -1;
-                goto Exit;
-            }
-            ++src;
-            decoder->_state = CHUNKED_IN_CHUNK_SIZE;
-            break;
-        case CHUNKED_IN_TRAILERS_LINE_HEAD:
-            for (;; ++src) {
-                if (src == bufsz)
-                    goto Exit;
-                if (buf[src] != '\015')
-                    break;
-            }
-            if (buf[src++] == '\012')
-                goto Complete;
-            decoder->_state = CHUNKED_IN_TRAILERS_LINE_MIDDLE;
-        /* fallthru */
-        case CHUNKED_IN_TRAILERS_LINE_MIDDLE:
-            for (;; ++src) {
-                if (src == bufsz)
-                    goto Exit;
-                if (buf[src] == '\012')
-                    break;
-            }
-            ++src;
-            decoder->_state = CHUNKED_IN_TRAILERS_LINE_HEAD;
-            break;
-        default:
-            assert(!"decoder is corrupt");
-        }
-    }
-
-Complete:
-    ret = bufsz - src;
-Exit:
-    if (dst != src)
-        memmove(buf + dst, buf + src, bufsz - src);
-    *_bufsz = dst;
-    return ret;
-}
-
-int phr_decode_chunked_is_in_data(struct phr_chunked_decoder *decoder)
-{
-    return decoder->_state == CHUNKED_IN_CHUNK_DATA;
-}
-
-#undef CHECK_EOF
-#undef EXPECT_CHAR
-#undef ADVANCE_TOKEN
diff --git a/ext/picohttpparser/picohttpparser.cmake b/ext/picohttpparser/picohttpparser.cmake
deleted file mode 100644
index d55228b..0000000
--- a/ext/picohttpparser/picohttpparser.cmake
+++ /dev/null
@@ -1,6 +0,0 @@
-get_filename_component(ARCHIVE_NAME "${CMAKE_CURRENT_LIST_DIR}" NAME)
-message("${ARCHIVE_NAME}@${CMAKE_CURRENT_LIST_DIR} using: ${CMAKE_CURRENT_LIST_FILE} ")
-
-file(GLOB HEADER_FILES "${CMAKE_CURRENT_LIST_DIR}/*.h")
-file(GLOB SOURCE_FILES "${CMAKE_CURRENT_LIST_DIR}/*.c")
-add_library("${ARCHIVE_NAME}" "${HEADER_FILES}" "${SOURCE_FILES}")
diff --git a/ext/picohttpparser/picohttpparser.h b/ext/picohttpparser/picohttpparser.h
deleted file mode 100644
index a8fad71..0000000
--- a/ext/picohttpparser/picohttpparser.h
+++ /dev/null
@@ -1,89 +0,0 @@
-/*
- * Copyright (c) 2009-2014 Kazuho Oku, Tokuhiro Matsuno, Daisuke Murase,
- *                         Shigeo Mitsunari
- *
- * The software is licensed under either the MIT License (below) or the Perl
- * license.
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to
- * deal in the Software without restriction, including without limitation the
- * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
- * sell copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in
- * all copies or substantial portions of the Software.
- *
- * 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.
- */
-
-#ifndef picohttpparser_h
-#define picohttpparser_h
-
-#include <sys/types.h>
-
-#ifdef _MSC_VER
-#define ssize_t intptr_t
-#endif
-
-/* $Id: 67fd3ee74103ada60258d8a16e868f483abcca87 $ */
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/* contains name and value of a header (name == NULL if is a continuing line
- * of a multiline header */
-struct phr_header {
-    const char *name;
-    size_t name_len;
-    const char *value;
-    size_t value_len;
-};
-
-/* returns number of bytes consumed if successful, -2 if request is partial,
- * -1 if failed */
-int phr_parse_request(const char *buf, size_t len, const char **method, size_t *method_len, const char **path, size_t *path_len,
-                      int *minor_version, struct phr_header *headers, size_t *num_headers, size_t last_len);
-
-/* ditto */
-int phr_parse_response(const char *_buf, size_t len, int *minor_version, int *status, const char **msg, size_t *msg_len,
-                       struct phr_header *headers, size_t *num_headers, size_t last_len);
-
-/* ditto */
-int phr_parse_headers(const char *buf, size_t len, struct phr_header *headers, size_t *num_headers, size_t last_len);
-
-/* should be zero-filled before start */
-struct phr_chunked_decoder {
-    size_t bytes_left_in_chunk; /* number of bytes left in current chunk */
-    char consume_trailer;       /* if trailing headers should be consumed */
-    char _hex_count;
-    char _state;
-};
-
-/* the function rewrites the buffer given as (buf, bufsz) removing the chunked-
- * encoding headers.  When the function returns without an error, bufsz is
- * updated to the length of the decoded data available.  Applications should
- * repeatedly call the function while it returns -2 (incomplete) every time
- * supplying newly arrived data.  If the end of the chunked-encoded data is
- * found, the function returns a non-negative number indicating the number of
- * octets left undecoded at the tail of the supplied buffer.  Returns -1 on
- * error.
- */
-ssize_t phr_decode_chunked(struct phr_chunked_decoder *decoder, char *buf, size_t *bufsz);
-
-/* returns if the chunked decoder is in middle of chunked data */
-int phr_decode_chunked_is_in_data(struct phr_chunked_decoder *decoder);
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif
diff --git a/ext/sds/LICENSE b/ext/sds/LICENSE
deleted file mode 100644
index d1199bc..0000000
--- a/ext/sds/LICENSE
+++ /dev/null
@@ -1,24 +0,0 @@
-Copyright (c) 2006-2014, Salvatore Sanfilippo <antirez at gmail dot com>
-
-All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
-* Redistributions of source code must retain the above copyright notice,
-  this list of conditions and the following disclaimer.
-
-* Redistributions in binary form must reproduce the above copyright notice,
-  this list of conditions and the following disclaimer in the documentation
-  and/or other materials provided with the distribution.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
-ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
-DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
-ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
-ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
diff --git a/ext/sds/README.md b/ext/sds/README.md
deleted file mode 100644
index 91cf301..0000000
--- a/ext/sds/README.md
+++ /dev/null
@@ -1,892 +0,0 @@
-Simple Dynamic Strings
-===
-
-**Notes about verison 2**: this is an updated version of SDS in an attempt
-to finally unify Redis, Disque, Hiredis, and the stand alone SDS versions.
-This version is **NOT* binary compatible** with SDS verison 1, but the API
-is 99% compatible so switching to the new lib should be trivial.
-
-Note that this version of SDS may be a slower with certain workloads, but
-uses less memory compared to V1 since header size is dynamic and depends to
-the string to alloc.
-
-Moreover it includes a few more API functions, notably `sdscatfmt` which
-is a faster version of `sdscatprintf` that can be used for the simpler
-cases in order to avoid the libc `printf` family functions performance
-penalty.
-
-How SDS stirngs work
-===
-
-SDS is a string library for C designed to augment the limited libc string
-handling functionalities by adding heap allocated strings that are:
-
-* Simpler to use.
-* Binary safe.
-* Computationally more efficient.
-* But yet... Compatible with normal C string functions.
-
-This is achieved using an alternative design in which instead of using a C
-structure to represent a string, we use a binary prefix that is stored
-before the actual pointer to the string that is returned by SDS to the user.
-
-    +--------+-------------------------------+-----------+
-    | Header | Binary safe C alike string... | Null term |
-    +--------+-------------------------------+-----------+
-             |
-             `-> Pointer returned to the user.
-
-Because of meta data stored before the actual returned pointer as a prefix,
-and because of every SDS string implicitly adding a null term at the end of
-the string regardless of the actual content of the string, SDS strings work
-well together with C strings and the user is free to use them interchangeably
-with real-only functions that access the string in read-only.
-
-SDS was a C string I developed in the past for my everyday C programming needs,
-later it was moved into Redis where it is used extensively and where it was
-modified in order to be suitable for high performance operations. Now it was
-extracted from Redis and forked as a stand alone project.
-
-Because of its many years life inside Redis, SDS provides both higher level
-functions for easy strings manipulation in C, but also a set of low level
-functions that make it possible to write high performance code without paying
-a penalty for using an higher level string library.
-
-Advantages and disadvantages of SDS
-===
-
-Normally dynamic string libraries for C are implemented using a structure
-that defines the string. The structure has a pointer field that is managed
-by the string function, so it looks like this:
-
-```c
-struct yourAverageStringLibrary {
-    char *buf;
-    size_t len;
-    ... possibly more fields here ...
-};
-```
-
-SDS strings are already mentioned don't follow this schema, and are instead
-a single allocation with a prefix that lives *before* the address actually
-returned for the string.
-
-There are advantages and disadvantages with this approach over the traditional
-approach:
-
-**Disadvantage #1**: many functions return the new string as value, since sometimes SDS requires to create a new string with more space, so the most SDS API calls look like this:
-
-```c
-s = sdscat(s,"Some more data");
-```
-
-As you can see `s` is used as input for `sdscat` but is also set to the value
-returned by the SDS API call, since we are not sure if the call modified the
-SDS string we passed or allocated a new one. Not remembering to assign back
-the return value of `sdscat` or similar functions to the variable holding
-the SDS string will result in a bug.
-
-**Disadvantage #2**: if an SDS string is shared in different places in your program you have to modify all the references when you modify the string. However most of the times when you need to share SDS strings it is much better to encapsulate them into structures with a `reference count` otherwise it is too easy to incur into memory leaks.
-
-**Advantage #1**: you can pass SDS strings to functions designed for C functions without accessing a struct member or calling a function, like this:
-
-```c
-printf("%s\n", sds_string);
-```
-
-In most other libraries this will be something like:
-
-```c
-printf("%s\n", string->buf);
-```
-
-Or:
-
-```c
-printf("%s\n", getStringPointer(string));
-```
-
-**Advantage #2**: accessing individual chars is straightforward. C is a low level language so this is an important operation in many programs. With SDS strings accessing individual chars is very natural:
-
-```c
-printf("%c %c\n", s[0], s[1]);
-```
-
-With other libraries your best chance is to assign `string->buf` (or call the function to get the string pointer) to a `char` pointer and work with this. However since the other libraries may reallocate the buffer implicitly every time you call a function that may modify the string you have to get a reference to the buffer again.
-
-**Advantage #3**: single allocation has better cache locality. Usually when you access a string created by a string library using a structure, you have two different allocations for the structure representing the string, and the actual buffer holding the string. Over the time the buffer is reallocated, and it is likely that it ends in a totally different part of memory compared to the structure itself. Since modern programs performances are often dominated by cache misses, SDS may perform better in many workloads.
-
-SDS basics
-===
-
-The type of SDS strings is just the char pointer `char *`. However SDS defines
-an `sds` type as alias of `char *` in its header file: you should use the
-`sds` type in order to make sure you remember that a given variable in your
-program holds an SDS string and not a C string, however this is not mandatory.
-
-This is the simplest SDS program you can write that does something:
-
-```c
-sds mystring = sdsnew("Hello World!");
-printf("%s\n", mystring);
-sdsfree(mystring);
-
-output> Hello World!
-```
-
-The above small program already shows a few important things about SDS:
-
-* SDS strings are created, and heap allocated, via the `sdsnew()` function, or other similar functions that we'll see in a moment.
-* SDS strings can be passed to `printf()` like any other C string.
-* SDS strings require to be freed with `sdsfree()`, since they are heap allocated.
-
-Creating SDS strings
----
-
-```c
-sds sdsnewlen(const void *init, size_t initlen);
-sds sdsnew(const char *init);
-sds sdsempty(void);
-sds sdsdup(const sds s);
-```
-
-There are many ways to create SDS strings:
-
-* The `sdsnew` function creates an SDS string starting from a C null terminated string. We already saw how it works in the above example.
-* The `sdsnewlen` function is similar to `sdsnew` but instead of creating the string assuming that the input string is null terminated, it gets an additional length parameter. This way you can create a string using binary data:
-
-    ```c
-    char buf[3];
-    sds mystring;
-
-    buf[0] = 'A';
-    buf[1] = 'B';
-    buf[2] = 'C';
-    mystring = sdsnewlen(buf,3);
-    printf("%s of len %d\n", mystring, (int) sdslen(mystring));
-
-    output> ABC of len 3
-    ```
-
-  Note: `sdslen` return value is casted to `int` because it returns a `size_t`
-type. You can use the right `printf` specifier instead of casting.
-
-* The `sdsempty()` function creates an empty zero-length string:
-
-    ```c
-    sds mystring = sdsempty();
-    printf("%d\n", (int) sdslen(mystring));
-
-    output> 0
-    ```
-
-* The `sdsdup()` function duplicates an already existing SDS string:
-
-    ```c
-    sds s1, s2;
-
-    s1 = sdsnew("Hello");
-    s2 = sdsdup(s1);
-    printf("%s %s\n", s1, s2);
-
-    output> Hello Hello
-    ```
-
-Obtaining the string length
----
-
-```c
-size_t sdslen(const sds s);
-```
-
-In the examples above we already used the `sdslen` function in order to get
-the length of the string. This function works like `strlen` of the libc
-except that:
-
-* It runs in constant time since the length is stored in the prefix of SDS strings, so calling `sdslen` is not expensive even when called with very large strings.
-* The function is binary safe like any other SDS string function, so the length is the true length of the string regardless of the content, there is no problem if the string includes null term characters in the middle.
-
-As an example of the binary safeness of SDS strings, we can run the following
-code:
-
-```c
-sds s = sdsnewlen("A\0\0B",4);
-printf("%d\n", (int) sdslen(s));
-
-output> 4
-```
-
-Note that SDS strings are always null terminated at the end, so even in that
-case `s[4]` will be a null term, however printing the string with `printf`
-would result in just `"A"` to be printed since libc will treat the SDS string
-like a normal C string.
-
-Destroying strings
----
-
-```c
-void sdsfree(sds s);
-```
-
-The destroy an SDS string there is just to call `sdsfree` with the string
-pointer. However note that empty strings created with `sdsempty` need to be
-destroyed as well otherwise they'll result into a memory leak.
-
-The function `sdsfree` does not perform any operation if instead of an SDS
-string pointer, `NULL` is passed, so you don't need to check for `NULL` explicitly before calling it:
-
-```c
-if (string) sdsfree(string); /* Not needed. */
-sdsfree(string); /* Same effect but simpler. */
-```
-
-Concatenating strings
----
-
-Concatenating strings to other strings is likely the operation you will end
-using the most with a dynamic C string library. SDS provides different
-functions to concatenate strings to existing strings.
-
-```c
-sds sdscatlen(sds s, const void *t, size_t len);
-sds sdscat(sds s, const char *t);
-```
-
-The main string concatenation functions are `sdscatlen` and `sdscat` that are
-identical, the only difference being that `sdscat` does not have an explicit
-length argument since it expects a null terminated string.
-
-```c
-sds s = sdsempty();
-s = sdscat(s, "Hello ");
-s = sdscat(s, "World!");
-printf("%s\n", s);
-
-output> Hello World!
-```
-
-Sometimes you want to cat an SDS string to another SDS string, so you don't
-need to specify the length, but at the same time the string does not need to
-be null terminated but can contain any binary data. For this there is a
-special function:
-
-```c
-sds sdscatsds(sds s, const sds t);
-```
-
-Usage is straightforward:
-
-```c
-sds s1 = sdsnew("aaa");
-sds s2 = sdsnew("bbb");
-s1 = sdscatsds(s1,s2);
-sdsfree(s2);
-printf("%s\n", s1);
-
-output> aaabbb
-```
-
-Sometimes you don't want to append any special data to the string, but you want
-to make sure that there are at least a given number of bytes composing the
-whole string.
-
-```c
-sds sdsgrowzero(sds s, size_t len);
-```
-
-The `sdsgrowzero` function will do nothing if the current string length is
-already `len` bytes, otherwise it will enlarge the string to `len` just padding
-it with zero bytes.
-
-```c
-sds s = sdsnew("Hello");
-s = sdsgrowzero(s,6);
-s[5] = '!'; /* We are sure this is safe because of sdsgrowzero() */
-printf("%s\n', s);
-
-output> Hello!
-```
-
-Formatting strings
----
-
-There is a special string concatenation function that accepts a `printf` alike
-format specifier and cats the formatted string to the specified string.
-
-```c
-sds sdscatprintf(sds s, const char *fmt, ...) {
-```
-
-Example:
-
-```c
-sds s;
-int a = 10, b = 20;
-s = sdsnew("The sum is: ");
-s = sdscatprintf(s,"%d+%d = %d",a,b,a+b);
-```
-
-Often you need to create SDS string directly from `printf` format specifiers.
-Because `sdscatprintf` is actually a function that concatenates strings all
-you need is to concatenate your string to an empty string:
-
-
-```c
-char *name = "Anna";
-int loc = 2500;
-sds s;
-s = sdscatprintf(sdsempty(), "%s wrote %d lines of LISP\n", name, loc);
-```
-
-You can use `sdscatprintf` in order to convert numbers into SDS strings:
-
-```c
-int some_integer = 100;
-sds num = sdscatprintf(sdsempty(),"%d\n", some_integer);
-```
-
-However this is slow and we have a special function to make it efficient.
-
-Fast number to string operations
----
-
-Creating an SDS string from an integer may be a common operation in certain
-kind of programs, and while you may do this with `sdscatprintf` the performance
-hit is big, so SDS provides a specialized function.
-
-```c
-sds sdsfromlonglong(long long value);
-```
-
-Use it like this:
-
-```c
-sds s = sdsfromlonglong(10000);
-printf("%d\n", (int) sdslen(s));
-
-output> 5
-```
-
-Trimming strings and getting ranges
----
-
-String trimming is a common operation where a set of characters are
-removed from the left and the right of the string. Another useful operation
-regarding strings is the ability to just take a range out of a larger
-string.
-
-```c
-void sdstrim(sds s, const char *cset);
-void sdsrange(sds s, int start, int end);
-```
-
-SDS provides both the operations with the `sdstrim` and `sdsrange` functions.
-However note that both functions work differently than most functions modifying
-SDS strings since the return value is null: basically those functions always
-destructively modify the passed SDS string, never allocating a new one, because
-both trimming and ranges will never need more room: the operations can only
-remove characters from the original strings.
-
-Because of this behavior, both functions are fast and don't involve reallocation.
-
-This is an example of string trimming where newlines and spaces are removed
-from an SDS strings:
-
-```c
-sds s = sdsnew("         my string\n\n  ");
-sdstrim(s," \n");
-printf("-%s-\n",s);
-
-output> -my string-
-```
-
-Basically `sdstrim` takes the SDS string to trim as first argument, and a
-null terminated set of characters to remove from left and right of the string.
-The characters are removed as long as they are not interrupted by a character
-that is not in the list of characters to trim: this is why the space between
-`"my"` and `"string"` was preserved in the above example.
-
-Taking ranges is similar, but instead to take a set of characters, it takes
-to indexes, representing the start and the end as specified by zero-based
-indexes inside the string, to obtain the range that will be retained.
-
-```c
-sds s = sdsnew("Hello World!");
-sdsrange(s,1,4);
-printf("-%s-\n");
-
-output> -ello-
-```
-
-Indexes can be negative to specify a position starting from the end of the
-string, so that `-1` means the last character, `-2` the penultimate, and so forth:
-
-```c
-sds s = sdsnew("Hello World!");
-sdsrange(s,6,-1);
-printf("-%s-\n");
-sdsrange(s,0,-2);
-printf("-%s-\n");
-
-output> -World!-
-output> -World-
-```
-
-`sdsrange` is very useful when implementing networking servers processing
-a protocol or sending messages. For example the following code is used
-implementing the write handler of the Redis Cluster message bus between
-nodes:
-
-```c
-void clusterWriteHandler(..., int fd, void *privdata, ...) {
-    clusterLink *link = (clusterLink*) privdata;
-    ssize_t nwritten = write(fd, link->sndbuf, sdslen(link->sndbuf));
-    if (nwritten <= 0) {
-        /* Error handling... */
-    }
-    sdsrange(link->sndbuf,nwritten,-1);
-    ... more code here ...
-}
-```
-
-Every time the socket of the node we want to send the message to is writable
-we attempt to write as much bytes as possible, and we use `sdsrange` in order
-to remove from the buffer what was already sent.
-
-The function to queue new messages to send to some node in the cluster will
-simply use `sdscatlen` in order to put more data in the send buffer.
-
-Note that the Redis Cluster bus implements a binary protocol, but since SDS
-is binary safe this is not a problem, so the goal of SDS is not just to provide
-an high level string API for the C programmer but also dynamically allocated
-buffers that are easy to manage.
-
-String copying
----
-
-The most dangerous and infamus function of the standard C library is probably
-`strcpy`, so perhaps it is funny how in the context of better designed dynamic
-string libraries the concept of copying strings is almost irrelevant. Usually
-what you do is to create strings with the content you want, or concatenating
-more content as needed.
-
-However SDS features a string copy function that is useful in performance
-critical code sections, however I guess its practical usefulness is limited
-as the function never managed to get called in the context of the 50k
-lines of code composing the Redis code base.
-
-```c
-sds sdscpylen(sds s, const char *t, size_t len);
-sds sdscpy(sds s, const char *t);
-```
-
-The string copy function of SDS is called `sdscpylen` and works like that:
-
-```c
-s = sdsnew("Hello World!");
-s = sdscpylen(s,"Hello Superman!",15);
-```
-
-As you can see the function receives as input the SDS string `s`, but also
-returns an SDS string. This is common to many SDS functions that modify the
-string: this way the returned SDS string may be the original one modified
-or a newly allocated one (for example if there was not enough room in the
-old SDS string).
-
-The `sdscpylen` will simply replace what was in the old SDS string with the
-new data you pass using the pointer and length argument. There is a similar
-function called `sdscpy` that does not need a length but expects a null
-terminated string instead.
-
-You may wonder why it makes sense to have a string copy function in the
-SDS library, since you can simply create a new SDS string from scratch
-with the new value instead of copying the value in an existing SDS string.
-The reason is efficiency: `sdsnewlen` will always allocate a new string
-while `sdscpylen` will try to reuse the existing string if there is enough
-room to old the new content specified by the user, and will allocate a new
-one only if needed.
-
-Quoting strings
----
-
-In order to provide consistent output to the program user, or for debugging
-purposes, it is often important to turn a string that may contain binary
-data or special characters into a quoted string. Here for quoted string
-we mean the common format for String literals in programming source code.
-However today this format is also part of the well known serialization formats
-like JSON and CSV, so it definitely escaped the simple gaol of representing
-literals strings in the source code of programs.
-
-An example of quoted string literal is the following:
-
-```c
-"\x00Hello World\n"
-```
-
-The first byte is a zero byte while the last byte is a newline, so there are
-two non alphanumerical characters inside the string.
-
-SDS uses a concatenation function for this goal, that concatenates to an
-existing string the quoted string representation of the input string.
-
-```c
-sds sdscatrepr(sds s, const char *p, size_t len);
-```
-
-The `scscatrepr` (where `repr` means *representation*) follows the usualy
-SDS string function rules accepting a char pointer and a length, so you can
-use it with SDS strings, normal C strings by using strlen() as `len` argument,
-or binary data. The following is an example usage:
-
-```c
-sds s1 = sdsnew("abcd");
-sds s2 = sdsempty();
-s[1] = 1;
-s[2] = 2;
-s[3] = '\n';
-s2 = sdscatrepr(s2,s1,sdslen(s1));
-printf("%s\n", s2);
-
-output> "a\x01\x02\n"
-```
-
-This is the rules `sdscatrepr` uses for conversion:
-
-* `\` and `"` are quoted with a backslash.
-* It quotes special characters `'\n'`, `'\r'`, `'\t'`, `'\a'` and `'\b'`.
-* All the other non printable characters not passing the `isprint` test are quoted in `\x..` form, that is: backslash followed by `x` followed by two digit hex number representing the character byte value.
-* The function always adds initial and final double quotes characters.
-
-There is an SDS function that is able to perform the reverse conversion and is
-documented in the *Tokenization* paragraph below.
-
-Tokenization
----
-
-Tokenization is the process of splitting a larger string into smaller strings.
-In this specific case, the split is performed specifying another string that
-acts as separator. For example in the following string there are two substrings
-that are separated by the `|-|` separator:
-
-```
-foo|-|bar|-|zap
-```
-
-A more common separator that consists of a single character is the comma:
-
-```
-foo,bar,zap
-```
-
-In many progrems it is useful to process a line in order to obtain the sub
-strings it is composed of, so SDS provides a function that returns an
-array of SDS strings given a string and a separator.
-
-```c
-sds *sdssplitlen(const char *s, int len, const char *sep, int seplen, int *count);
-void sdsfreesplitres(sds *tokens, int count);
-```
-
-As usually the function can work with both SDS strings or normal C strings.
-The first two arguments `s` and `len` specify the string to tokenize, and the
-other two arguments `sep` and `seplen` the separator to use during the
-tokenization. The final argument `count` is a pointer to an integer that will
-be set to the number of tokens (sub strings) returned.
-
-The return value is a heap allocated array of SDS strings.
-
-```c
-sds *tokens;
-int count, j;
-
-sds line = sdsnew("Hello World!");
-tokens = sdssplitlen(line,sdslen(line)," ",1,&count);
-
-for (j = 0; j < count; j++)
-    printf("%s\n", tokens[j]);
-sdsfreesplitres(tokens,count);
-
-output> Hello
-output> World!
-```
-
-The returned array is heap allocated, and the single elements of the array
-are normal SDS strings. You can free everything calling `sdsfreesplitres`
-as in the example. Alternativey you are free to release the array yourself
-using the `free` function and use and/or free the individual SDS strings
-as usually.
-
-A valid approach is to set the array elements you reused in some way to
-`NULL`, and use `sdsfreesplitres` to free all the rest.
-
-Command line oriented tokenization
----
-
-Splitting by a separator is a useful operation, but usually it is not enough
-to perform one of the most common tasks involving some non trivial string
-manipulation, that is, implementing a **Command Line Interface** for a program.
-
-This is why SDS also provides an additional function that allows you to split
-arguments provided by the user via the keyboard in an interactive manner, or
-via a file, network, or any other mean, into tokens.
-
-```c
-sds *sdssplitargs(const char *line, int *argc);
-```
-
-The `sdssplitargs` function returns an array of SDS strings exactly like
-`sdssplitlen`. The function to free the result is also identical, and is
-`sdsfreesplitres`. The difference is in the way the tokenization is performed.
-
-For example if the input is the following line:
-
-```
-call "Sabrina"    and "Mark Smith\n"
-```
-
-The function will return the following tokens:
-
-* "call"
-* "Sabrina"
-* "and"
-* "Mark Smith\n"
-
-Basically different tokens need to be separated by one or more spaces, and
-every single token can also be a quoted string in the same format that
-`sdscatrepr` is able to emit.
-
-String joining
----
-
-There are two functions doing the reverse of tokenization by joining strings
-into a single one.
-
-```c
-sds sdsjoin(char **argv, int argc, char *sep, size_t seplen);
-sds sdsjoinsds(sds *argv, int argc, const char *sep, size_t seplen);
-```
-
-The two functions take as input an array of strings of length `argc` and
-a separator and its length, and produce as output an SDS string consisting
-of all the specified strings separated by the specified separator.
-
-The difference between `sdsjoin` and `sdsjoinsds` is that the former accept
-C null terminated strings as input while the latter requires all the strings
-in the array to be SDS strings. However because of this only `sdsjoinsds` is
-able to deal with binary data.
-
-```c
-char *tokens[3] = {"foo","bar","zap"};
-sds s = sdsjoin(tokens,3,"|",1);
-printf("%s\n", s);
-
-output> foo|bar|zap
-```
-
-Error handling
----
-
-All the SDS functions that return an SDS pointer may also return `NULL` on
-out of memory, this is basically the only check you need to perform.
-
-However many modern C programs handle out of memory simply aborting the program
-so you may want to do this as well by wrapping `malloc` and other related
-memory allocation calls directly.
-
-SDS internals and advanced usage
-===
-
-At the very beginning of this documentation it was explained how SDS strings
-are allocated, however the prefix stored before the pointer returned to the
-user was classified as an *header* without further details. For an advanced
-usage it is better to dig more into the internals of SDS and show the
-structure implementing it:
-
-```c
-struct sdshdr {
-    int len;
-    int free;
-    char buf[];
-};
-```
-
-As you can see, the structure may resemble the one of a conventional string
-library, however the `buf` field of the structure is different since it is
-not a pointer but an array without any length declared, so `buf` actually
-points at the first byte just after the `free` integer. So in order to create
-an SDS string we just allocate a piece of memory that is as large as the
-`sdshdr` structure plus the length of our string, plus an additional byte
-for the mandatory null term that every SDS string has.
-
-The `len` field of the structure is quite obvious, and is the current length
-of the SDS string, always computed every time the string is modified via
-SDS function calls. The `free` field instead represents the amount of free
-memory in the current allocation that can be used to store more characters.
-
-So the actual SDS layout is this one:
-
-    +------------+------------------------+-----------+---------------\
-    | Len | Free | H E L L O W O R L D \n | Null term |  Free space   \
-    +------------+------------------------+-----------+---------------\
-                 |
-                 `-> Pointer returned to the user.
-
-You may wonder why there is some free space at the end of the string, it
-looks like a waste. Actually after a new SDS string is created, there is no
-free space at the end at all: the allocation will be as small as possible to
-just hold the header, string, and null term. However other access patterns
-will create extra free space at the end, like in the following program:
-
-```c
-s = sdsempty();
-s = sdscat(s,"foo");
-s = sdscat(s,"bar");
-s = sdscat(s,"123");
-```
-
-Since SDS tries to be efficient it can't afford to reallocate the string every
-time new data is appended, since this would be very inefficient, so it uses
-the **preallocation of some free space** every time you enlarge the string.
-
-The preallocation algorithm used is the following: every time the string
-is reallocated in order to hold more bytes, the actual allocation size performed
-is two times the minimum required. So for instance if the string currently
-is holding 30 bytes, and we concatenate 2 more bytes, instead of allocating 32
-bytes in total SDS will allocate 64 bytes.
-
-However there is an hard limit to the allocation it can perform ahead, and is
-defined by `SDS_MAX_PREALLOC`. SDS will never allocate more than 1MB of
-additional space (by default, you can change this default).
-
-Shrinking strings
----
-
-```c
-sds sdsRemoveFreeSpace(sds s);
-size_t sdsAllocSize(sds s);
-```
-
-Sometimes there are class of programs that require to use very little memory.
-After strings concatenations, trimming, ranges, the string may end having
-a non trivial amount of additional space at the end.
-
-It is possible to resize a string back to its minimal size in order to hold
-the current content by using the function `sdsRemoveFreeSpace`.
-
-```c
-s = sdsRemoveFreeSpace(s);
-```
-
-There is also a function that can be used in order to get the size of the
-total allocation for a given string, and is called `sdsAllocSize`.
-
-```c
-sds s = sdsnew("Ladies and gentlemen");
-s = sdscat(s,"... welcome to the C language.");
-printf("%d\n", (int) sdsAllocSize(s));
-s = sdsRemoveFreeSpace(s);
-printf("%d\n", (int) sdsAllocSize(s));
-
-output> 109
-output> 59
-```
-
-NOTE: SDS Low level API use cammelCase in order to warn you that you are playing with the fire.
-
-Manual modifications of SDS strings
----
-
-    void sdsupdatelen(sds s);
-
-Sometimes you may want to hack with an SDS string manually, without using
-SDS functions. In the following example we implicitly change the length
-of the string, however we want the logical length to reflect the null terminated
-C string.
-
-The function `sdsupdatelen` does just that, updating the internal length
-information for the specified string to the length obtained via `strlen`.
-
-```c
-sds s = sdsnew("foobar");
-s[2] = '\0';
-printf("%d\n", sdslen(s));
-sdsupdatelen(s);
-printf("%d\n", sdslen(s));
-
-output> 6
-output> 2
-```
-
-Sharing SDS strings
----
-
-If you are writing a program in which it is advantageous to share the same
-SDS string across different data structures, it is absolutely advised to
-encapsulate SDS strings into structures that remember the number of references
-of the string, with functions to increment and decrement the number of references.
-
-This approach is a memory management technique called *reference counting* and
-in the context of SDS has two advantages:
-
-* It is less likely that you'll create memory leaks or bugs due to non freeing SDS strings or freeing already freed strings.
-* You'll not need to update every reference to an SDS string when you modify it (since the new SDS string may point to a different memory location).
-
-While this is definitely a very common programming technique I'll outline
-the basic ideas here. You create a structure like that:
-
-```c
-struct mySharedStrings {
-    int refcount;
-    sds string;
-}
-```
-
-When new strings are created, the structure is allocated and returned with
-`refcount` set to 1. The you have two functions to change the reference count
-of the shared string:
-
-* `incrementStringRefCount` will simply increment `refcount` of 1 in the structure. It will be called every time you add a reference to the string on some new data structure, variable, or whatever.
-* `decrementStringRefCount` is used when you remove a reference. This function is however special since when the `refcount` drops to zero, it automatically frees the SDS string, and the `mySharedString` structure as well.
-
-Interactions with heap checkers
----
-
-Because SDS returns pointers into the middle of memory chunks allocated with
-`malloc`, heap checkers may have issues, however:
-
-* The popular Valgrind program will detect SDS strings are *possibly lost* memory and never as *definitely lost*, so it is easy to tell if there is a leak or not. I used Valgrind with Redis for years and every real leak was consistently detected as "definitely lost".
-* OSX instrumentation tools don't detect SDS strings as leaks but are able to correctly handle pointers pointing to the middle of memory chunks.
-
-Zero copy append from syscalls
-----
-
-At this point you should have all the tools to dig more inside the SDS
-library by reading the source code, however there is an interesting pattern
-you can mount using the low level API exported, that is used inside Redis
-in order to improve performances of the networking code.
-
-Using `sdsIncrLen()` and `sdsMakeRoomFor()` it is possible to mount the
-following schema, to cat bytes coming from the kernel to the end of an
-sds string without copying into an intermediate buffer:
-
-```c
-oldlen = sdslen(s);
-s = sdsMakeRoomFor(s, BUFFER_SIZE);
-nread = read(fd, s+oldlen, BUFFER_SIZE);
-... check for nread <= 0 and handle it ...
-sdsIncrLen(s, nread);
-```
-
-`sdsIncrLen` is documented inside the source code of `sds.c`.
-
-Embedding SDS into your project
-===
-
-This is as simple as copying the `sds.c` and `sds.h` files inside your
-project. The source code is small and every C99 compiler should deal with
-it without issues.
-
-Credits and license
-===
-
-SDS was created by Salvatore Sanfilippo and is released under the BDS two clause license. See the LICENSE file in this source distribution for more information.
diff --git a/ext/sds/sds.c b/ext/sds/sds.c
deleted file mode 100644
index aff9cd1..0000000
--- a/ext/sds/sds.c
+++ /dev/null
@@ -1,1264 +0,0 @@
-/* SDSLib 2.0 -- A C dynamic strings library
- *
- * Copyright (c) 2006-2015, Salvatore Sanfilippo <antirez at gmail dot com>
- * Copyright (c) 2015, Redis Labs, Inc
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- *
- *   * Redistributions of source code must retain the above copyright notice,
- *     this list of conditions and the following disclaimer.
- *   * Redistributions in binary form must reproduce the above copyright
- *     notice, this list of conditions and the following disclaimer in the
- *     documentation and/or other materials provided with the distribution.
- *   * Neither the name of Redis nor the names of its contributors may be used
- *     to endorse or promote products derived from this software without
- *     specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
- * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
- * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
- * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
- * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
- * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
- * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
- * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
- * POSSIBILITY OF SUCH DAMAGE.
- */
-
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include <ctype.h>
-#include <assert.h>
-#include "sds.h"
-#include "sdsalloc.h"
-
-static inline int sdsHdrSize(char type) {
-    switch(type&SDS_TYPE_MASK) {
-        case SDS_TYPE_5:
-            return sizeof(struct sdshdr5);
-        case SDS_TYPE_8:
-            return sizeof(struct sdshdr8);
-        case SDS_TYPE_16:
-            return sizeof(struct sdshdr16);
-        case SDS_TYPE_32:
-            return sizeof(struct sdshdr32);
-        case SDS_TYPE_64:
-            return sizeof(struct sdshdr64);
-    }
-    return 0;
-}
-
-static inline char sdsReqType(size_t string_size) {
-    if (string_size < 32)
-        return SDS_TYPE_5;
-    if (string_size < 0xff)
-        return SDS_TYPE_8;
-    if (string_size < 0xffff)
-        return SDS_TYPE_16;
-    if (string_size < 0xffffffff)
-        return SDS_TYPE_32;
-    return SDS_TYPE_64;
-}
-
-/* Create a new sds string with the content specified by the 'init' pointer
- * and 'initlen'.
- * If NULL is used for 'init' the string is initialized with zero bytes.
- *
- * The string is always null-termined (all the sds strings are, always) so
- * even if you create an sds string with:
- *
- * mystring = sdsnewlen("abc",3);
- *
- * You can print the string with printf() as there is an implicit \0 at the
- * end of the string. However the string is binary safe and can contain
- * \0 characters in the middle, as the length is stored in the sds header. */
-sds sdsnewlen(const void *init, size_t initlen) {
-    void *sh;
-    sds s;
-    char type = sdsReqType(initlen);
-    /* Empty strings are usually created in order to append. Use type 8
-     * since type 5 is not good at this. */
-    if (type == SDS_TYPE_5 && initlen == 0) type = SDS_TYPE_8;
-    int hdrlen = sdsHdrSize(type);
-    unsigned char *fp; /* flags pointer. */
-
-    sh = s_malloc(hdrlen+initlen+1);
-    if (!init)
-        memset(sh, 0, hdrlen+initlen+1);
-    if (sh == NULL) return NULL;
-    s = (char*)sh+hdrlen;
-    fp = ((unsigned char*)s)-1;
-    switch(type) {
-        case SDS_TYPE_5: {
-            *fp = type | (initlen << SDS_TYPE_BITS);
-            break;
-        }
-        case SDS_TYPE_8: {
-            SDS_HDR_VAR(8,s);
-            sh->len = initlen;
-            sh->alloc = initlen;
-            *fp = type;
-            break;
-        }
-        case SDS_TYPE_16: {
-            SDS_HDR_VAR(16,s);
-            sh->len = initlen;
-            sh->alloc = initlen;
-            *fp = type;
-            break;
-        }
-        case SDS_TYPE_32: {
-            SDS_HDR_VAR(32,s);
-            sh->len = initlen;
-            sh->alloc = initlen;
-            *fp = type;
-            break;
-        }
-        case SDS_TYPE_64: {
-            SDS_HDR_VAR(64,s);
-            sh->len = initlen;
-            sh->alloc = initlen;
-            *fp = type;
-            break;
-        }
-    }
-    if (initlen && init)
-        memcpy(s, init, initlen);
-    s[initlen] = '\0';
-    return s;
-}
-
-/* Create an empty (zero length) sds string. Even in this case the string
- * always has an implicit null term. */
-sds sdsempty(void) {
-    return sdsnewlen("",0);
-}
-
-/* Create a new sds string starting from a null terminated C string. */
-sds sdsnew(const char *init) {
-    size_t initlen = (init == NULL) ? 0 : strlen(init);
-    return sdsnewlen(init, initlen);
-}
-
-/* Duplicate an sds string. */
-sds sdsdup(const sds s) {
-    return sdsnewlen(s, sdslen(s));
-}
-
-/* Free an sds string. No operation is performed if 's' is NULL. */
-void sdsfree(sds s) {
-    if (s == NULL) return;
-    s_free((char*)s-sdsHdrSize(s[-1]));
-}
-
-/* Set the sds string length to the length as obtained with strlen(), so
- * considering as content only up to the first null term character.
- *
- * This function is useful when the sds string is hacked manually in some
- * way, like in the following example:
- *
- * s = sdsnew("foobar");
- * s[2] = '\0';
- * sdsupdatelen(s);
- * printf("%d\n", sdslen(s));
- *
- * The output will be "2", but if we comment out the call to sdsupdatelen()
- * the output will be "6" as the string was modified but the logical length
- * remains 6 bytes. */
-void sdsupdatelen(sds s) {
-    int reallen = strlen(s);
-    sdssetlen(s, reallen);
-}
-
-/* Modify an sds string in-place to make it empty (zero length).
- * However all the existing buffer is not discarded but set as free space
- * so that next append operations will not require allocations up to the
- * number of bytes previously available. */
-void sdsclear(sds s) {
-    sdssetlen(s, 0);
-    s[0] = '\0';
-}
-
-/* Enlarge the free space at the end of the sds string so that the caller
- * is sure that after calling this function can overwrite up to addlen
- * bytes after the end of the string, plus one more byte for nul term.
- *
- * Note: this does not change the *length* of the sds string as returned
- * by sdslen(), but only the free buffer space we have. */
-sds sdsMakeRoomFor(sds s, size_t addlen) {
-    void *sh, *newsh;
-    size_t avail = sdsavail(s);
-    size_t len, newlen;
-    char type, oldtype = s[-1] & SDS_TYPE_MASK;
-    int hdrlen;
-
-    /* Return ASAP if there is enough space left. */
-    if (avail >= addlen) return s;
-
-    len = sdslen(s);
-    sh = (char*)s-sdsHdrSize(oldtype);
-    newlen = (len+addlen);
-    if (newlen < SDS_MAX_PREALLOC)
-        newlen *= 2;
-    else
-        newlen += SDS_MAX_PREALLOC;
-
-    type = sdsReqType(newlen);
-
-    /* Don't use type 5: the user is appending to the string and type 5 is
-     * not able to remember empty space, so sdsMakeRoomFor() must be called
-     * at every appending operation. */
-    if (type == SDS_TYPE_5) type = SDS_TYPE_8;
-
-    hdrlen = sdsHdrSize(type);
-    if (oldtype==type) {
-        newsh = s_realloc(sh, hdrlen+newlen+1);
-        if (newsh == NULL) return NULL;
-        s = (char*)newsh+hdrlen;
-    } else {
-        /* Since the header size changes, need to move the string forward,
-         * and can't use realloc */
-        newsh = s_malloc(hdrlen+newlen+1);
-        if (newsh == NULL) return NULL;
-        memcpy((char*)newsh+hdrlen, s, len+1);
-        s_free(sh);
-        s = (char*)newsh+hdrlen;
-        s[-1] = type;
-        sdssetlen(s, len);
-    }
-    sdssetalloc(s, newlen);
-    return s;
-}
-
-/* Reallocate the sds string so that it has no free space at the end. The
- * contained string remains not altered, but next concatenation operations
- * will require a reallocation.
- *
- * After the call, the passed sds string is no longer valid and all the
- * references must be substituted with the new pointer returned by the call. */
-sds sdsRemoveFreeSpace(sds s) {
-    void *sh, *newsh;
-    char type, oldtype = s[-1] & SDS_TYPE_MASK;
-    int hdrlen;
-    size_t len = sdslen(s);
-    sh = (char*)s-sdsHdrSize(oldtype);
-
-    type = sdsReqType(len);
-    hdrlen = sdsHdrSize(type);
-    if (oldtype==type) {
-        newsh = s_realloc(sh, hdrlen+len+1);
-        if (newsh == NULL) return NULL;
-        s = (char*)newsh+hdrlen;
-    } else {
-        newsh = s_malloc(hdrlen+len+1);
-        if (newsh == NULL) return NULL;
-        memcpy((char*)newsh+hdrlen, s, len+1);
-        s_free(sh);
-        s = (char*)newsh+hdrlen;
-        s[-1] = type;
-        sdssetlen(s, len);
-    }
-    sdssetalloc(s, len);
-    return s;
-}
-
-/* Return the total size of the allocation of the specifed sds string,
- * including:
- * 1) The sds header before the pointer.
- * 2) The string.
- * 3) The free buffer at the end if any.
- * 4) The implicit null term.
- */
-size_t sdsAllocSize(sds s) {
-    size_t alloc = sdsalloc(s);
-    return sdsHdrSize(s[-1])+alloc+1;
-}
-
-/* Return the pointer of the actual SDS allocation (normally SDS strings
- * are referenced by the start of the string buffer). */
-void *sdsAllocPtr(sds s) {
-    return (void*) (s-sdsHdrSize(s[-1]));
-}
-
-/* Increment the sds length and decrements the left free space at the
- * end of the string according to 'incr'. Also set the null term
- * in the new end of the string.
- *
- * This function is used in order to fix the string length after the
- * user calls sdsMakeRoomFor(), writes something after the end of
- * the current string, and finally needs to set the new length.
- *
- * Note: it is possible to use a negative increment in order to
- * right-trim the string.
- *
- * Usage example:
- *
- * Using sdsIncrLen() and sdsMakeRoomFor() it is possible to mount the
- * following schema, to cat bytes coming from the kernel to the end of an
- * sds string without copying into an intermediate buffer:
- *
- * oldlen = sdslen(s);
- * s = sdsMakeRoomFor(s, BUFFER_SIZE);
- * nread = read(fd, s+oldlen, BUFFER_SIZE);
- * ... check for nread <= 0 and handle it ...
- * sdsIncrLen(s, nread);
- */
-void sdsIncrLen(sds s, int incr) {
-    unsigned char flags = s[-1];
-    size_t len;
-    switch(flags&SDS_TYPE_MASK) {
-        case SDS_TYPE_5: {
-            unsigned char *fp = ((unsigned char*)s)-1;
-            unsigned char oldlen = SDS_TYPE_5_LEN(flags);
-            assert((incr > 0 && oldlen+incr < 32) || (incr < 0 && oldlen >= (unsigned int)(-incr)));
-            *fp = SDS_TYPE_5 | ((oldlen+incr) << SDS_TYPE_BITS);
-            len = oldlen+incr;
-            break;
-        }
-        case SDS_TYPE_8: {
-            SDS_HDR_VAR(8,s);
-            assert((incr >= 0 && sh->alloc-sh->len >= incr) || (incr < 0 && sh->len >= (unsigned int)(-incr)));
-            len = (sh->len += incr);
-            break;
-        }
-        case SDS_TYPE_16: {
-            SDS_HDR_VAR(16,s);
-            assert((incr >= 0 && sh->alloc-sh->len >= incr) || (incr < 0 && sh->len >= (unsigned int)(-incr)));
-            len = (sh->len += incr);
-            break;
-        }
-        case SDS_TYPE_32: {
-            SDS_HDR_VAR(32,s);
-            assert((incr >= 0 && sh->alloc-sh->len >= (unsigned int)incr) || (incr < 0 && sh->len >= (unsigned int)(-incr)));
-            len = (sh->len += incr);
-            break;
-        }
-        case SDS_TYPE_64: {
-            SDS_HDR_VAR(64,s);
-            assert((incr >= 0 && sh->alloc-sh->len >= (uint64_t)incr) || (incr < 0 && sh->len >= (uint64_t)(-incr)));
-            len = (sh->len += incr);
-            break;
-        }
-        default: len = 0; /* Just to avoid compilation warnings. */
-    }
-    s[len] = '\0';
-}
-
-/* Grow the sds to have the specified length. Bytes that were not part of
- * the original length of the sds will be set to zero.
- *
- * if the specified length is smaller than the current length, no operation
- * is performed. */
-sds sdsgrowzero(sds s, size_t len) {
-    size_t curlen = sdslen(s);
-
-    if (len <= curlen) return s;
-    s = sdsMakeRoomFor(s,len-curlen);
-    if (s == NULL) return NULL;
-
-    /* Make sure added region doesn't contain garbage */
-    memset(s+curlen,0,(len-curlen+1)); /* also set trailing \0 byte */
-    sdssetlen(s, len);
-    return s;
-}
-
-/* Append the specified binary-safe string pointed by 't' of 'len' bytes to the
- * end of the specified sds string 's'.
- *
- * After the call, the passed sds string is no longer valid and all the
- * references must be substituted with the new pointer returned by the call. */
-sds sdscatlen(sds s, const void *t, size_t len) {
-    size_t curlen = sdslen(s);
-
-    s = sdsMakeRoomFor(s,len);
-    if (s == NULL) return NULL;
-    memcpy(s+curlen, t, len);
-    sdssetlen(s, curlen+len);
-    s[curlen+len] = '\0';
-    return s;
-}
-
-/* Append the specified null termianted C string to the sds string 's'.
- *
- * After the call, the passed sds string is no longer valid and all the
- * references must be substituted with the new pointer returned by the call. */
-sds sdscat(sds s, const char *t) {
-    return sdscatlen(s, t, strlen(t));
-}
-
-/* Append the specified sds 't' to the existing sds 's'.
- *
- * After the call, the modified sds string is no longer valid and all the
- * references must be substituted with the new pointer returned by the call. */
-sds sdscatsds(sds s, const sds t) {
-    return sdscatlen(s, t, sdslen(t));
-}
-
-/* Destructively modify the sds string 's' to hold the specified binary
- * safe string pointed by 't' of length 'len' bytes. */
-sds sdscpylen(sds s, const char *t, size_t len) {
-    if (sdsalloc(s) < len) {
-        s = sdsMakeRoomFor(s,len-sdslen(s));
-        if (s == NULL) return NULL;
-    }
-    memcpy(s, t, len);
-    s[len] = '\0';
-    sdssetlen(s, len);
-    return s;
-}
-
-/* Like sdscpylen() but 't' must be a null-termined string so that the length
- * of the string is obtained with strlen(). */
-sds sdscpy(sds s, const char *t) {
-    return sdscpylen(s, t, strlen(t));
-}
-
-/* Helper for sdscatlonglong() doing the actual number -> string
- * conversion. 's' must point to a string with room for at least
- * SDS_LLSTR_SIZE bytes.
- *
- * The function returns the length of the null-terminated string
- * representation stored at 's'. */
-#define SDS_LLSTR_SIZE 21
-int sdsll2str(char *s, long long value) {
-    char *p, aux;
-    unsigned long long v;
-    size_t l;
-
-    /* Generate the string representation, this method produces
-     * an reversed string. */
-    v = (value < 0) ? -value : value;
-    p = s;
-    do {
-        *p++ = '0'+(v%10);
-        v /= 10;
-    } while(v);
-    if (value < 0) *p++ = '-';
-
-    /* Compute length and add null term. */
-    l = p-s;
-    *p = '\0';
-
-    /* Reverse the string. */
-    p--;
-    while(s < p) {
-        aux = *s;
-        *s = *p;
-        *p = aux;
-        s++;
-        p--;
-    }
-    return l;
-}
-
-/* Identical sdsll2str(), but for unsigned long long type. */
-int sdsull2str(char *s, unsigned long long v) {
-    char *p, aux;
-    size_t l;
-
-    /* Generate the string representation, this method produces
-     * an reversed string. */
-    p = s;
-    do {
-        *p++ = '0'+(v%10);
-        v /= 10;
-    } while(v);
-
-    /* Compute length and add null term. */
-    l = p-s;
-    *p = '\0';
-
-    /* Reverse the string. */
-    p--;
-    while(s < p) {
-        aux = *s;
-        *s = *p;
-        *p = aux;
-        s++;
-        p--;
-    }
-    return l;
-}
-
-/* Create an sds string from a long long value. It is much faster than:
- *
- * sdscatprintf(sdsempty(),"%lld\n", value);
- */
-sds sdsfromlonglong(long long value) {
-    char buf[SDS_LLSTR_SIZE];
-    int len = sdsll2str(buf,value);
-
-    return sdsnewlen(buf,len);
-}
-
-/* Like sdscatprintf() but gets va_list instead of being variadic. */
-sds sdscatvprintf(sds s, const char *fmt, va_list ap) {
-    va_list cpy;
-    char staticbuf[1024], *buf = staticbuf, *t;
-    size_t buflen = strlen(fmt)*2;
-
-    /* We try to start using a static buffer for speed.
-     * If not possible we revert to heap allocation. */
-    if (buflen > sizeof(staticbuf)) {
-        buf = s_malloc(buflen);
-        if (buf == NULL) return NULL;
-    } else {
-        buflen = sizeof(staticbuf);
-    }
-
-    /* Try with buffers two times bigger every time we fail to
-     * fit the string in the current buffer size. */
-    while(1) {
-        buf[buflen-2] = '\0';
-        va_copy(cpy,ap);
-        vsnprintf(buf, buflen, fmt, cpy);
-        va_end(cpy);
-        if (buf[buflen-2] != '\0') {
-            if (buf != staticbuf) s_free(buf);
-            buflen *= 2;
-            buf = s_malloc(buflen);
-            if (buf == NULL) return NULL;
-            continue;
-        }
-        break;
-    }
-
-    /* Finally concat the obtained string to the SDS string and return it. */
-    t = sdscat(s, buf);
-    if (buf != staticbuf) s_free(buf);
-    return t;
-}
-
-/* Append to the sds string 's' a string obtained using printf-alike format
- * specifier.
- *
- * After the call, the modified sds string is no longer valid and all the
- * references must be substituted with the new pointer returned by the call.
- *
- * Example:
- *
- * s = sdsnew("Sum is: ");
- * s = sdscatprintf(s,"%d+%d = %d",a,b,a+b).
- *
- * Often you need to create a string from scratch with the printf-alike
- * format. When this is the need, just use sdsempty() as the target string:
- *
- * s = sdscatprintf(sdsempty(), "... your format ...", args);
- */
-sds sdscatprintf(sds s, const char *fmt, ...) {
-    va_list ap;
-    char *t;
-    va_start(ap, fmt);
-    t = sdscatvprintf(s,fmt,ap);
-    va_end(ap);
-    return t;
-}
-
-/* This function is similar to sdscatprintf, but much faster as it does
- * not rely on sprintf() family functions implemented by the libc that
- * are often very slow. Moreover directly handling the sds string as
- * new data is concatenated provides a performance improvement.
- *
- * However this function only handles an incompatible subset of printf-alike
- * format specifiers:
- *
- * %s - C String
- * %S - SDS string
- * %i - signed int
- * %I - 64 bit signed integer (long long, int64_t)
- * %u - unsigned int
- * %U - 64 bit unsigned integer (unsigned long long, uint64_t)
- * %% - Verbatim "%" character.
- */
-sds sdscatfmt(sds s, char const *fmt, ...) {
-    size_t initlen = sdslen(s);
-    const char *f = fmt;
-    int i;
-    va_list ap;
-
-    va_start(ap,fmt);
-    f = fmt;    /* Next format specifier byte to process. */
-    i = initlen; /* Position of the next byte to write to dest str. */
-    while(*f) {
-        char next, *str;
-        size_t l;
-        long long num;
-        unsigned long long unum;
-
-        /* Make sure there is always space for at least 1 char. */
-        if (sdsavail(s)==0) {
-            s = sdsMakeRoomFor(s,1);
-        }
-
-        switch(*f) {
-        case '%':
-            next = *(f+1);
-            f++;
-            switch(next) {
-            case 's':
-            case 'S':
-                str = va_arg(ap,char*);
-                l = (next == 's') ? strlen(str) : sdslen(str);
-                if (sdsavail(s) < l) {
-                    s = sdsMakeRoomFor(s,l);
-                }
-                memcpy(s+i,str,l);
-                sdsinclen(s,l);
-                i += l;
-                break;
-            case 'i':
-            case 'I':
-                if (next == 'i')
-                    num = va_arg(ap,int);
-                else
-                    num = va_arg(ap,long long);
-                {
-                    char buf[SDS_LLSTR_SIZE];
-                    l = sdsll2str(buf,num);
-                    if (sdsavail(s) < l) {
-                        s = sdsMakeRoomFor(s,l);
-                    }
-                    memcpy(s+i,buf,l);
-                    sdsinclen(s,l);
-                    i += l;
-                }
-                break;
-            case 'u':
-            case 'U':
-                if (next == 'u')
-                    unum = va_arg(ap,unsigned int);
-                else
-                    unum = va_arg(ap,unsigned long long);
-                {
-                    char buf[SDS_LLSTR_SIZE];
-                    l = sdsull2str(buf,unum);
-                    if (sdsavail(s) < l) {
-                        s = sdsMakeRoomFor(s,l);
-                    }
-                    memcpy(s+i,buf,l);
-                    sdsinclen(s,l);
-                    i += l;
-                }
-                break;
-            default: /* Handle %% and generally %<unknown>. */
-                s[i++] = next;
-                sdsinclen(s,1);
-                break;
-            }
-            break;
-        default:
-            s[i++] = *f;
-            sdsinclen(s,1);
-            break;
-        }
-        f++;
-    }
-    va_end(ap);
-
-    /* Add null-term */
-    s[i] = '\0';
-    return s;
-}
-
-/* Remove the part of the string from left and from right composed just of
- * contiguous characters found in 'cset', that is a null terminted C string.
- *
- * After the call, the modified sds string is no longer valid and all the
- * references must be substituted with the new pointer returned by the call.
- *
- * Example:
- *
- * s = sdsnew("AA...AA.a.aa.aHelloWorld     :::");
- * s = sdstrim(s,"Aa. :");
- * printf("%s\n", s);
- *
- * Output will be just "Hello World".
- */
-sds sdstrim(sds s, const char *cset) {
-    char *start, *end, *sp, *ep;
-    size_t len;
-
-    sp = start = s;
-    ep = end = s+sdslen(s)-1;
-    while(sp <= end && strchr(cset, *sp)) sp++;
-    while(ep > sp && strchr(cset, *ep)) ep--;
-    len = (sp > ep) ? 0 : ((ep-sp)+1);
-    if (s != sp) memmove(s, sp, len);
-    s[len] = '\0';
-    sdssetlen(s,len);
-    return s;
-}
-
-/* Turn the string into a smaller (or equal) string containing only the
- * substring specified by the 'start' and 'end' indexes.
- *
- * start and end can be negative, where -1 means the last character of the
- * string, -2 the penultimate character, and so forth.
- *
- * The interval is inclusive, so the start and end characters will be part
- * of the resulting string.
- *
- * The string is modified in-place.
- *
- * Example:
- *
- * s = sdsnew("Hello World");
- * sdsrange(s,1,-1); => "ello World"
- */
-void sdsrange(sds s, int start, int end) {
-    size_t newlen, len = sdslen(s);
-
-    if (len == 0) return;
-    if (start < 0) {
-        start = len+start;
-        if (start < 0) start = 0;
-    }
-    if (end < 0) {
-        end = len+end;
-        if (end < 0) end = 0;
-    }
-    newlen = (start > end) ? 0 : (end-start)+1;
-    if (newlen != 0) {
-        if (start >= (signed)len) {
-            newlen = 0;
-        } else if (end >= (signed)len) {
-            end = len-1;
-            newlen = (start > end) ? 0 : (end-start)+1;
-        }
-    } else {
-        start = 0;
-    }
-    if (start && newlen) memmove(s, s+start, newlen);
-    s[newlen] = 0;
-    sdssetlen(s,newlen);
-}
-
-/* Apply tolower() to every character of the sds string 's'. */
-void sdstolower(sds s) {
-    int len = sdslen(s), j;
-
-    for (j = 0; j < len; j++) s[j] = tolower(s[j]);
-}
-
-/* Apply toupper() to every character of the sds string 's'. */
-void sdstoupper(sds s) {
-    int len = sdslen(s), j;
-
-    for (j = 0; j < len; j++) s[j] = toupper(s[j]);
-}
-
-/* Compare two sds strings s1 and s2 with memcmp().
- *
- * Return value:
- *
- *     positive if s1 > s2.
- *     negative if s1 < s2.
- *     0 if s1 and s2 are exactly the same binary string.
- *
- * If two strings share exactly the same prefix, but one of the two has
- * additional characters, the longer string is considered to be greater than
- * the smaller one. */
-int sdscmp(const sds s1, const sds s2) {
-    size_t l1, l2, minlen;
-    int cmp;
-
-    l1 = sdslen(s1);
-    l2 = sdslen(s2);
-    minlen = (l1 < l2) ? l1 : l2;
-    cmp = memcmp(s1,s2,minlen);
-    if (cmp == 0) return l1-l2;
-    return cmp;
-}
-
-/* Split 's' with separator in 'sep'. An array
- * of sds strings is returned. *count will be set
- * by reference to the number of tokens returned.
- *
- * On out of memory, zero length string, zero length
- * separator, NULL is returned.
- *
- * Note that 'sep' is able to split a string using
- * a multi-character separator. For example
- * sdssplit("foo_-_bar","_-_"); will return two
- * elements "foo" and "bar".
- *
- * This version of the function is binary-safe but
- * requires length arguments. sdssplit() is just the
- * same function but for zero-terminated strings.
- */
-sds *sdssplitlen(const char *s, int len, const char *sep, int seplen, int *count) {
-    int elements = 0, slots = 5, start = 0, j;
-    sds *tokens;
-
-    if (seplen < 1 || len < 0) return NULL;
-
-    tokens = s_malloc(sizeof(sds)*slots);
-    if (tokens == NULL) return NULL;
-
-    if (len == 0) {
-        *count = 0;
-        return tokens;
-    }
-    for (j = 0; j < (len-(seplen-1)); j++) {
-        /* make sure there is room for the next element and the final one */
-        if (slots < elements+2) {
-            sds *newtokens;
-
-            slots *= 2;
-            newtokens = s_realloc(tokens,sizeof(sds)*slots);
-            if (newtokens == NULL) goto cleanup;
-            tokens = newtokens;
-        }
-        /* search the separator */
-        if ((seplen == 1 && *(s+j) == sep[0]) || (memcmp(s+j,sep,seplen) == 0)) {
-            tokens[elements] = sdsnewlen(s+start,j-start);
-            if (tokens[elements] == NULL) goto cleanup;
-            elements++;
-            start = j+seplen;
-            j = j+seplen-1; /* skip the separator */
-        }
-    }
-    /* Add the final element. We are sure there is room in the tokens array. */
-    tokens[elements] = sdsnewlen(s+start,len-start);
-    if (tokens[elements] == NULL) goto cleanup;
-    elements++;
-    *count = elements;
-    return tokens;
-
-cleanup:
-    {
-        int i;
-        for (i = 0; i < elements; i++) sdsfree(tokens[i]);
-        s_free(tokens);
-        *count = 0;
-        return NULL;
-    }
-}
-
-/* Free the result returned by sdssplitlen(), or do nothing if 'tokens' is NULL. */
-void sdsfreesplitres(sds *tokens, int count) {
-    if (!tokens) return;
-    while(count--)
-        sdsfree(tokens[count]);
-    s_free(tokens);
-}
-
-/* Append to the sds string "s" an escaped string representation where
- * all the non-printable characters (tested with isprint()) are turned into
- * escapes in the form "\n\r\a...." or "\x<hex-number>".
- *
- * After the call, the modified sds string is no longer valid and all the
- * references must be substituted with the new pointer returned by the call. */
-sds sdscatrepr(sds s, const char *p, size_t len) {
-    s = sdscatlen(s,"\"",1);
-    while(len--) {
-        switch(*p) {
-        case '\\':
-        case '"':
-            s = sdscatprintf(s,"\\%c",*p);
-            break;
-        case '\n': s = sdscatlen(s,"\\n",2); break;
-        case '\r': s = sdscatlen(s,"\\r",2); break;
-        case '\t': s = sdscatlen(s,"\\t",2); break;
-        case '\a': s = sdscatlen(s,"\\a",2); break;
-        case '\b': s = sdscatlen(s,"\\b",2); break;
-        default:
-            if (isprint(*p))
-                s = sdscatprintf(s,"%c",*p);
-            else
-                s = sdscatprintf(s,"\\x%02x",(unsigned char)*p);
-            break;
-        }
-        p++;
-    }
-    return sdscatlen(s,"\"",1);
-}
-
-/* Helper function for sdssplitargs() that returns non zero if 'c'
- * is a valid hex digit. */
-int is_hex_digit(char c) {
-    return (c >= '0' && c <= '9') || (c >= 'a' && c <= 'f') ||
-           (c >= 'A' && c <= 'F');
-}
-
-/* Helper function for sdssplitargs() that converts a hex digit into an
- * integer from 0 to 15 */
-int hex_digit_to_int(char c) {
-    switch(c) {
-    case '0': return 0;
-    case '1': return 1;
-    case '2': return 2;
-    case '3': return 3;
-    case '4': return 4;
-    case '5': return 5;
-    case '6': return 6;
-    case '7': return 7;
-    case '8': return 8;
-    case '9': return 9;
-    case 'a': case 'A': return 10;
-    case 'b': case 'B': return 11;
-    case 'c': case 'C': return 12;
-    case 'd': case 'D': return 13;
-    case 'e': case 'E': return 14;
-    case 'f': case 'F': return 15;
-    default: return 0;
-    }
-}
-
-/* Split a line into arguments, where every argument can be in the
- * following programming-language REPL-alike form:
- *
- * foo bar "newline are supported\n" and "\xff\x00otherstuff"
- *
- * The number of arguments is stored into *argc, and an array
- * of sds is returned.
- *
- * The caller should free the resulting array of sds strings with
- * sdsfreesplitres().
- *
- * Note that sdscatrepr() is able to convert back a string into
- * a quoted string in the same format sdssplitargs() is able to parse.
- *
- * The function returns the allocated tokens on success, even when the
- * input string is empty, or NULL if the input contains unbalanced
- * quotes or closed quotes followed by non space characters
- * as in: "foo"bar or "foo'
- */
-sds *sdssplitargs(const char *line, int *argc) {
-    const char *p = line;
-    char *current = NULL;
-    char **vector = NULL;
-
-    *argc = 0;
-    while(1) {
-        /* skip blanks */
-        while(*p && isspace(*p)) p++;
-        if (*p) {
-            /* get a token */
-            int inq=0;  /* set to 1 if we are in "quotes" */
-            int insq=0; /* set to 1 if we are in 'single quotes' */
-            int done=0;
-
-            if (current == NULL) current = sdsempty();
-            while(!done) {
-                if (inq) {
-                    if (*p == '\\' && *(p+1) == 'x' &&
-                                             is_hex_digit(*(p+2)) &&
-                                             is_hex_digit(*(p+3)))
-                    {
-                        unsigned char byte;
-
-                        byte = (hex_digit_to_int(*(p+2))*16)+
-                                hex_digit_to_int(*(p+3));
-                        current = sdscatlen(current,(char*)&byte,1);
-                        p += 3;
-                    } else if (*p == '\\' && *(p+1)) {
-                        char c;
-
-                        p++;
-                        switch(*p) {
-                        case 'n': c = '\n'; break;
-                        case 'r': c = '\r'; break;
-                        case 't': c = '\t'; break;
-                        case 'b': c = '\b'; break;
-                        case 'a': c = '\a'; break;
-                        default: c = *p; break;
-                        }
-                        current = sdscatlen(current,&c,1);
-                    } else if (*p == '"') {
-                        /* closing quote must be followed by a space or
-                         * nothing at all. */
-                        if (*(p+1) && !isspace(*(p+1))) goto err;
-                        done=1;
-                    } else if (!*p) {
-                        /* unterminated quotes */
-                        goto err;
-                    } else {
-                        current = sdscatlen(current,p,1);
-                    }
-                } else if (insq) {
-                    if (*p == '\\' && *(p+1) == '\'') {
-                        p++;
-                        current = sdscatlen(current,"'",1);
-                    } else if (*p == '\'') {
-                        /* closing quote must be followed by a space or
-                         * nothing at all. */
-                        if (*(p+1) && !isspace(*(p+1))) goto err;
-                        done=1;
-                    } else if (!*p) {
-                        /* unterminated quotes */
-                        goto err;
-                    } else {
-                        current = sdscatlen(current,p,1);
-                    }
-                } else {
-                    switch(*p) {
-                    case ' ':
-                    case '\n':
-                    case '\r':
-                    case '\t':
-                    case '\0':
-                        done=1;
-                        break;
-                    case '"':
-                        inq=1;
-                        break;
-                    case '\'':
-                        insq=1;
-                        break;
-                    default:
-                        current = sdscatlen(current,p,1);
-                        break;
-                    }
-                }
-                if (*p) p++;
-            }
-            /* add the token to the vector */
-            vector = s_realloc(vector,((*argc)+1)*sizeof(char*));
-            vector[*argc] = current;
-            (*argc)++;
-            current = NULL;
-        } else {
-            /* Even on empty input string return something not NULL. */
-            if (vector == NULL) vector = s_malloc(sizeof(void*));
-            return vector;
-        }
-    }
-
-err:
-    while((*argc)--)
-        sdsfree(vector[*argc]);
-    s_free(vector);
-    if (current) sdsfree(current);
-    *argc = 0;
-    return NULL;
-}
-
-/* Modify the string substituting all the occurrences of the set of
- * characters specified in the 'from' string to the corresponding character
- * in the 'to' array.
- *
- * For instance: sdsmapchars(mystring, "ho", "01", 2)
- * will have the effect of turning the string "hello" into "0ell1".
- *
- * The function returns the sds string pointer, that is always the same
- * as the input pointer since no resize is needed. */
-sds sdsmapchars(sds s, const char *from, const char *to, size_t setlen) {
-    size_t j, i, l = sdslen(s);
-
-    for (j = 0; j < l; j++) {
-        for (i = 0; i < setlen; i++) {
-            if (s[j] == from[i]) {
-                s[j] = to[i];
-                break;
-            }
-        }
-    }
-    return s;
-}
-
-/* Join an array of C strings using the specified separator (also a C string).
- * Returns the result as an sds string. */
-sds sdsjoin(char **argv, int argc, char *sep) {
-    sds join = sdsempty();
-    int j;
-
-    for (j = 0; j < argc; j++) {
-        join = sdscat(join, argv[j]);
-        if (j != argc-1) join = sdscat(join,sep);
-    }
-    return join;
-}
-
-/* Like sdsjoin, but joins an array of SDS strings. */
-sds sdsjoinsds(sds *argv, int argc, const char *sep, size_t seplen) {
-    sds join = sdsempty();
-    int j;
-
-    for (j = 0; j < argc; j++) {
-        join = sdscatsds(join, argv[j]);
-        if (j != argc-1) join = sdscatlen(join,sep,seplen);
-    }
-    return join;
-}
-
-#if defined(SDS_TEST_MAIN)
-#include <stdio.h>
-#include "testhelp.h"
-#include "limits.h"
-
-#define UNUSED(x) (void)(x)
-int sdsTest(void) {
-    {
-        sds x = sdsnew("foo"), y;
-
-        test_cond("Create a string and obtain the length",
-            sdslen(x) == 3 && memcmp(x,"foo\0",4) == 0)
-
-        sdsfree(x);
-        x = sdsnewlen("foo",2);
-        test_cond("Create a string with specified length",
-            sdslen(x) == 2 && memcmp(x,"fo\0",3) == 0)
-
-        x = sdscat(x,"bar");
-        test_cond("Strings concatenation",
-            sdslen(x) == 5 && memcmp(x,"fobar\0",6) == 0);
-
-        x = sdscpy(x,"a");
-        test_cond("sdscpy() against an originally longer string",
-            sdslen(x) == 1 && memcmp(x,"a\0",2) == 0)
-
-        x = sdscpy(x,"xyzxxxxxxxxxxyyyyyyyyyykkkkkkkkkk");
-        test_cond("sdscpy() against an originally shorter string",
-            sdslen(x) == 33 &&
-            memcmp(x,"xyzxxxxxxxxxxyyyyyyyyyykkkkkkkkkk\0",33) == 0)
-
-        sdsfree(x);
-        x = sdscatprintf(sdsempty(),"%d",123);
-        test_cond("sdscatprintf() seems working in the base case",
-            sdslen(x) == 3 && memcmp(x,"123\0",4) == 0)
-
-        sdsfree(x);
-        x = sdsnew("--");
-        x = sdscatfmt(x, "Hello %s World %I,%I--", "Hi!", LLONG_MIN,LLONG_MAX);
-        test_cond("sdscatfmt() seems working in the base case",
-            sdslen(x) == 60 &&
-            memcmp(x,"--Hello Hi! World -9223372036854775808,"
-                     "9223372036854775807--",60) == 0)
-        printf("[%s]\n",x);
-
-        sdsfree(x);
-        x = sdsnew("--");
-        x = sdscatfmt(x, "%u,%U--", UINT_MAX, ULLONG_MAX);
-        test_cond("sdscatfmt() seems working with unsigned numbers",
-            sdslen(x) == 35 &&
-            memcmp(x,"--4294967295,18446744073709551615--",35) == 0)
-
-        sdsfree(x);
-        x = sdsnew(" x ");
-        sdstrim(x," x");
-        test_cond("sdstrim() works when all chars match",
-            sdslen(x) == 0)
-
-        sdsfree(x);
-        x = sdsnew(" x ");
-        sdstrim(x," ");
-        test_cond("sdstrim() works when a single char remains",
-            sdslen(x) == 1 && x[0] == 'x')
-
-        sdsfree(x);
-        x = sdsnew("xxciaoyyy");
-        sdstrim(x,"xy");
-        test_cond("sdstrim() correctly trims characters",
-            sdslen(x) == 4 && memcmp(x,"ciao\0",5) == 0)
-
-        y = sdsdup(x);
-        sdsrange(y,1,1);
-        test_cond("sdsrange(...,1,1)",
-            sdslen(y) == 1 && memcmp(y,"i\0",2) == 0)
-
-        sdsfree(y);
-        y = sdsdup(x);
-        sdsrange(y,1,-1);
-        test_cond("sdsrange(...,1,-1)",
-            sdslen(y) == 3 && memcmp(y,"iao\0",4) == 0)
-
-        sdsfree(y);
-        y = sdsdup(x);
-        sdsrange(y,-2,-1);
-        test_cond("sdsrange(...,-2,-1)",
-            sdslen(y) == 2 && memcmp(y,"ao\0",3) == 0)
-
-        sdsfree(y);
-        y = sdsdup(x);
-        sdsrange(y,2,1);
-        test_cond("sdsrange(...,2,1)",
-            sdslen(y) == 0 && memcmp(y,"\0",1) == 0)
-
-        sdsfree(y);
-        y = sdsdup(x);
-        sdsrange(y,1,100);
-        test_cond("sdsrange(...,1,100)",
-            sdslen(y) == 3 && memcmp(y,"iao\0",4) == 0)
-
-        sdsfree(y);
-        y = sdsdup(x);
-        sdsrange(y,100,100);
-        test_cond("sdsrange(...,100,100)",
-            sdslen(y) == 0 && memcmp(y,"\0",1) == 0)
-
-        sdsfree(y);
-        sdsfree(x);
-        x = sdsnew("foo");
-        y = sdsnew("foa");
-        test_cond("sdscmp(foo,foa)", sdscmp(x,y) > 0)
-
-        sdsfree(y);
-        sdsfree(x);
-        x = sdsnew("bar");
-        y = sdsnew("bar");
-        test_cond("sdscmp(bar,bar)", sdscmp(x,y) == 0)
-
-        sdsfree(y);
-        sdsfree(x);
-        x = sdsnew("aar");
-        y = sdsnew("bar");
-        test_cond("sdscmp(bar,bar)", sdscmp(x,y) < 0)
-
-        sdsfree(y);
-        sdsfree(x);
-        x = sdsnewlen("\a\n\0foo\r",7);
-        y = sdscatrepr(sdsempty(),x,sdslen(x));
-        test_cond("sdscatrepr(...data...)",
-            memcmp(y,"\"\\a\\n\\x00foo\\r\"",15) == 0)
-
-        {
-            unsigned int oldfree;
-            char *p;
-            int step = 10, j, i;
-
-            sdsfree(x);
-            sdsfree(y);
-            x = sdsnew("0");
-            test_cond("sdsnew() free/len buffers", sdslen(x) == 1 && sdsavail(x) == 0);
-
-            /* Run the test a few times in order to hit the first two
-             * SDS header types. */
-            for (i = 0; i < 10; i++) {
-                int oldlen = sdslen(x);
-                x = sdsMakeRoomFor(x,step);
-                int type = x[-1]&SDS_TYPE_MASK;
-
-                test_cond("sdsMakeRoomFor() len", sdslen(x) == oldlen);
-                if (type != SDS_TYPE_5) {
-                    test_cond("sdsMakeRoomFor() free", sdsavail(x) >= step);
-                    oldfree = sdsavail(x);
-                }
-                p = x+oldlen;
-                for (j = 0; j < step; j++) {
-                    p[j] = 'A'+j;
-                }
-                sdsIncrLen(x,step);
-            }
-            test_cond("sdsMakeRoomFor() content",
-                memcmp("0ABCDEFGHIJABCDEFGHIJABCDEFGHIJABCDEFGHIJABCDEFGHIJABCDEFGHIJABCDEFGHIJABCDEFGHIJABCDEFGHIJABCDEFGHIJ",x,101) == 0);
-            test_cond("sdsMakeRoomFor() final length",sdslen(x)==101);
-
-            sdsfree(x);
-        }
-    }
-    test_report()
-    return 0;
-}
-#endif
-
-#ifdef SDS_TEST_MAIN
-int main(void) {
-    return sdsTest();
-}
-#endif
diff --git a/ext/sds/sds.cmake b/ext/sds/sds.cmake
deleted file mode 100644
index d55228b..0000000
--- a/ext/sds/sds.cmake
+++ /dev/null
@@ -1,6 +0,0 @@
-get_filename_component(ARCHIVE_NAME "${CMAKE_CURRENT_LIST_DIR}" NAME)
-message("${ARCHIVE_NAME}@${CMAKE_CURRENT_LIST_DIR} using: ${CMAKE_CURRENT_LIST_FILE} ")
-
-file(GLOB HEADER_FILES "${CMAKE_CURRENT_LIST_DIR}/*.h")
-file(GLOB SOURCE_FILES "${CMAKE_CURRENT_LIST_DIR}/*.c")
-add_library("${ARCHIVE_NAME}" "${HEADER_FILES}" "${SOURCE_FILES}")
diff --git a/ext/sds/sds.h b/ext/sds/sds.h
deleted file mode 100644
index 20eaac0..0000000
--- a/ext/sds/sds.h
+++ /dev/null
@@ -1,264 +0,0 @@
-/* SDSLib 2.0 -- A C dynamic strings library
- *
- * Copyright (c) 2006-2015, Salvatore Sanfilippo <antirez at gmail dot com>
- * Copyright (c) 2015, Redis Labs, Inc
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- *
- *   * Redistributions of source code must retain the above copyright notice,
- *     this list of conditions and the following disclaimer.
- *   * Redistributions in binary form must reproduce the above copyright
- *     notice, this list of conditions and the following disclaimer in the
- *     documentation and/or other materials provided with the distribution.
- *   * Neither the name of Redis nor the names of its contributors may be used
- *     to endorse or promote products derived from this software without
- *     specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
- * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
- * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
- * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
- * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
- * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
- * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
- * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
- * POSSIBILITY OF SUCH DAMAGE.
- */
-
-#ifndef __SDS_H
-#define __SDS_H
-
-#define SDS_MAX_PREALLOC (1024*1024)
-
-#include <sys/types.h>
-#include <stdarg.h>
-#include <stdint.h>
-
-typedef char *sds;
-
-/* Note: sdshdr5 is never used, we just access the flags byte directly.
- * However is here to document the layout of type 5 SDS strings. */
-struct __attribute__ ((__packed__)) sdshdr5 {
-    unsigned char flags; /* 3 lsb of type, and 5 msb of string length */
-    char buf[];
-};
-struct __attribute__ ((__packed__)) sdshdr8 {
-    uint8_t len; /* used */
-    uint8_t alloc; /* excluding the header and null terminator */
-    unsigned char flags; /* 3 lsb of type, 5 unused bits */
-    char buf[];
-};
-struct __attribute__ ((__packed__)) sdshdr16 {
-    uint16_t len; /* used */
-    uint16_t alloc; /* excluding the header and null terminator */
-    unsigned char flags; /* 3 lsb of type, 5 unused bits */
-    char buf[];
-};
-struct __attribute__ ((__packed__)) sdshdr32 {
-    uint32_t len; /* used */
-    uint32_t alloc; /* excluding the header and null terminator */
-    unsigned char flags; /* 3 lsb of type, 5 unused bits */
-    char buf[];
-};
-struct __attribute__ ((__packed__)) sdshdr64 {
-    uint64_t len; /* used */
-    uint64_t alloc; /* excluding the header and null terminator */
-    unsigned char flags; /* 3 lsb of type, 5 unused bits */
-    char buf[];
-};
-
-#define SDS_TYPE_5  0
-#define SDS_TYPE_8  1
-#define SDS_TYPE_16 2
-#define SDS_TYPE_32 3
-#define SDS_TYPE_64 4
-#define SDS_TYPE_MASK 7
-#define SDS_TYPE_BITS 3
-#define SDS_HDR_VAR(T,s) struct sdshdr##T *sh = (void*)((s)-(sizeof(struct sdshdr##T)));
-#define SDS_HDR(T,s) ((struct sdshdr##T *)((s)-(sizeof(struct sdshdr##T))))
-#define SDS_TYPE_5_LEN(f) ((f)>>SDS_TYPE_BITS)
-
-static inline size_t sdslen(const sds s) {
-    unsigned char flags = s[-1];
-    switch(flags&SDS_TYPE_MASK) {
-        case SDS_TYPE_5:
-            return SDS_TYPE_5_LEN(flags);
-        case SDS_TYPE_8:
-            return SDS_HDR(8,s)->len;
-        case SDS_TYPE_16:
-            return SDS_HDR(16,s)->len;
-        case SDS_TYPE_32:
-            return SDS_HDR(32,s)->len;
-        case SDS_TYPE_64:
-            return SDS_HDR(64,s)->len;
-    }
-    return 0;
-}
-
-static inline size_t sdsavail(const sds s) {
-    unsigned char flags = s[-1];
-    switch(flags&SDS_TYPE_MASK) {
-        case SDS_TYPE_5: {
-            return 0;
-        }
-        case SDS_TYPE_8: {
-            SDS_HDR_VAR(8,s);
-            return sh->alloc - sh->len;
-        }
-        case SDS_TYPE_16: {
-            SDS_HDR_VAR(16,s);
-            return sh->alloc - sh->len;
-        }
-        case SDS_TYPE_32: {
-            SDS_HDR_VAR(32,s);
-            return sh->alloc - sh->len;
-        }
-        case SDS_TYPE_64: {
-            SDS_HDR_VAR(64,s);
-            return sh->alloc - sh->len;
-        }
-    }
-    return 0;
-}
-
-static inline void sdssetlen(sds s, size_t newlen) {
-    unsigned char flags = s[-1];
-    switch(flags&SDS_TYPE_MASK) {
-        case SDS_TYPE_5:
-            {
-                unsigned char *fp = ((unsigned char*)s)-1;
-                *fp = SDS_TYPE_5 | (newlen << SDS_TYPE_BITS);
-            }
-            break;
-        case SDS_TYPE_8:
-            SDS_HDR(8,s)->len = newlen;
-            break;
-        case SDS_TYPE_16:
-            SDS_HDR(16,s)->len = newlen;
-            break;
-        case SDS_TYPE_32:
-            SDS_HDR(32,s)->len = newlen;
-            break;
-        case SDS_TYPE_64:
-            SDS_HDR(64,s)->len = newlen;
-            break;
-    }
-}
-
-static inline void sdsinclen(sds s, size_t inc) {
-    unsigned char flags = s[-1];
-    switch(flags&SDS_TYPE_MASK) {
-        case SDS_TYPE_5:
-            {
-                unsigned char *fp = ((unsigned char*)s)-1;
-                unsigned char newlen = SDS_TYPE_5_LEN(flags)+inc;
-                *fp = SDS_TYPE_5 | (newlen << SDS_TYPE_BITS);
-            }
-            break;
-        case SDS_TYPE_8:
-            SDS_HDR(8,s)->len += inc;
-            break;
-        case SDS_TYPE_16:
-            SDS_HDR(16,s)->len += inc;
-            break;
-        case SDS_TYPE_32:
-            SDS_HDR(32,s)->len += inc;
-            break;
-        case SDS_TYPE_64:
-            SDS_HDR(64,s)->len += inc;
-            break;
-    }
-}
-
-/* sdsalloc() = sdsavail() + sdslen() */
-static inline size_t sdsalloc(const sds s) {
-    unsigned char flags = s[-1];
-    switch(flags&SDS_TYPE_MASK) {
-        case SDS_TYPE_5:
-            return SDS_TYPE_5_LEN(flags);
-        case SDS_TYPE_8:
-            return SDS_HDR(8,s)->alloc;
-        case SDS_TYPE_16:
-            return SDS_HDR(16,s)->alloc;
-        case SDS_TYPE_32:
-            return SDS_HDR(32,s)->alloc;
-        case SDS_TYPE_64:
-            return SDS_HDR(64,s)->alloc;
-    }
-    return 0;
-}
-
-static inline void sdssetalloc(sds s, size_t newlen) {
-    unsigned char flags = s[-1];
-    switch(flags&SDS_TYPE_MASK) {
-        case SDS_TYPE_5:
-            /* Nothing to do, this type has no total allocation info. */
-            break;
-        case SDS_TYPE_8:
-            SDS_HDR(8,s)->alloc = newlen;
-            break;
-        case SDS_TYPE_16:
-            SDS_HDR(16,s)->alloc = newlen;
-            break;
-        case SDS_TYPE_32:
-            SDS_HDR(32,s)->alloc = newlen;
-            break;
-        case SDS_TYPE_64:
-            SDS_HDR(64,s)->alloc = newlen;
-            break;
-    }
-}
-
-sds sdsnewlen(const void *init, size_t initlen);
-sds sdsnew(const char *init);
-sds sdsempty(void);
-sds sdsdup(const sds s);
-void sdsfree(sds s);
-sds sdsgrowzero(sds s, size_t len);
-sds sdscatlen(sds s, const void *t, size_t len);
-sds sdscat(sds s, const char *t);
-sds sdscatsds(sds s, const sds t);
-sds sdscpylen(sds s, const char *t, size_t len);
-sds sdscpy(sds s, const char *t);
-
-sds sdscatvprintf(sds s, const char *fmt, va_list ap);
-#ifdef __GNUC__
-sds sdscatprintf(sds s, const char *fmt, ...)
-    __attribute__((format(printf, 2, 3)));
-#else
-sds sdscatprintf(sds s, const char *fmt, ...);
-#endif
-
-sds sdscatfmt(sds s, char const *fmt, ...);
-sds sdstrim(sds s, const char *cset);
-void sdsrange(sds s, int start, int end);
-void sdsupdatelen(sds s);
-void sdsclear(sds s);
-int sdscmp(const sds s1, const sds s2);
-sds *sdssplitlen(const char *s, int len, const char *sep, int seplen, int *count);
-void sdsfreesplitres(sds *tokens, int count);
-void sdstolower(sds s);
-void sdstoupper(sds s);
-sds sdsfromlonglong(long long value);
-sds sdscatrepr(sds s, const char *p, size_t len);
-sds *sdssplitargs(const char *line, int *argc);
-sds sdsmapchars(sds s, const char *from, const char *to, size_t setlen);
-sds sdsjoin(char **argv, int argc, char *sep);
-sds sdsjoinsds(sds *argv, int argc, const char *sep, size_t seplen);
-
-/* Low level functions exposed to the user API */
-sds sdsMakeRoomFor(sds s, size_t addlen);
-void sdsIncrLen(sds s, int incr);
-sds sdsRemoveFreeSpace(sds s);
-size_t sdsAllocSize(sds s);
-void *sdsAllocPtr(sds s);
-
-#ifdef REDIS_TEST
-int sdsTest(int argc, char *argv[]);
-#endif
-
-#endif
diff --git a/ext/sds/sdsalloc.h b/ext/sds/sdsalloc.h
deleted file mode 100644
index 152976c..0000000
--- a/ext/sds/sdsalloc.h
+++ /dev/null
@@ -1,41 +0,0 @@
-/* SDSLib 2.0 -- A C dynamic strings library
- *
- * Copyright (c) 2006-2015, Salvatore Sanfilippo <antirez at gmail dot com>
- * Copyright (c) 2015, Redis Labs, Inc
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- *
- *   * Redistributions of source code must retain the above copyright notice,
- *     this list of conditions and the following disclaimer.
- *   * Redistributions in binary form must reproduce the above copyright
- *     notice, this list of conditions and the following disclaimer in the
- *     documentation and/or other materials provided with the distribution.
- *   * Neither the name of Redis nor the names of its contributors may be used
- *     to endorse or promote products derived from this software without
- *     specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
- * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
- * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
- * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
- * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
- * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
- * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
- * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
- * POSSIBILITY OF SUCH DAMAGE.
- */
-
-/* SDS allocator selection.
- *
- * This file is used in order to change the SDS allocator at compile time.
- * Just define the following defines to what you want to use. Also add
- * the include of your alternate allocator if needed (not needed in order
- * to use the default libc allocator). */
-
-#define s_malloc malloc
-#define s_realloc realloc
-#define s_free free
diff --git a/http.cmake b/http.cmake
deleted file mode 100644
index 9c4597a..0000000
--- a/http.cmake
+++ /dev/null
@@ -1,7 +0,0 @@
-get_filename_component(ARCHIVE_NAME "${CMAKE_CURRENT_LIST_DIR}" NAME)
-message("${ARCHIVE_NAME}@${CMAKE_CURRENT_LIST_DIR} using: ${CMAKE_CURRENT_LIST_FILE} ")
-
-file(GLOB HEADER_FILES "${CMAKE_CURRENT_LIST_DIR}/*.h")
-file(GLOB SOURCE_FILES "${CMAKE_CURRENT_LIST_DIR}/*.c")
-add_library("${ARCHIVE_NAME}" "${HEADER_FILES}" "${SOURCE_FILES}")
-target_link_libraries("${ARCHIVE_NAME}" PRIVATE curl)
diff --git a/include/http/http.h b/include/http/http.h
deleted file mode 100644
index f9414de..0000000
--- a/include/http/http.h
+++ /dev/null
@@ -1,45 +0,0 @@
-/*
- * C Header File
- *
- * Author: Davide Di Carlo
- * Date:   February 11, 2017
- * email:  daddinuz@gmail.com
- */
-
-#ifndef __HTTP_H__
-#define __HTTP_H__
-
-#define HTTP_VERSION "0.2.6"
-
-#include <stdbool.h>
-#include "http_status.h"
-#include "http_method.h"
-#include "http_request.h"
-#include "http_response.h"
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-typedef struct http_params {
-    bool no_follow_location;
-    bool no_peer_verification;
-    bool no_host_verification;
-    long timeout;
-} http_params_t;
-
-/**
- * Compose and send an HTTP request.
- * If memory allocation fails, this function returns NULL, and errno is set to ENOMEM.
- *
- * @param request The HTTP request to be performed
- * @param params The request parameters
- * @return A new `http_response_t *` instance.
- */
-extern http_response_t *http_perform(http_request_t *request, http_params_t *params);
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /* __HTTP_H__ */
diff --git a/include/http/http_method.h b/include/http/http_method.h
deleted file mode 100644
index 4f214c2..0000000
--- a/include/http/http_method.h
+++ /dev/null
@@ -1,56 +0,0 @@
-/*
- * C Header File
- *
- * Author: Davide Di Carlo
- * Date:   February 11, 2017 
- * email:  daddinuz@gmail.com
- */
-
-#ifndef __HTTP_METHOD_H__
-#define __HTTP_METHOD_H__
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-typedef enum http_method {
-    HTTP_METHOD_DELETE,
-    HTTP_METHOD_GET,
-    HTTP_METHOD_HEAD,
-    HTTP_METHOD_POST,
-    HTTP_METHOD_PUT,
-    HTTP_METHOD_CONNECT,
-    HTTP_METHOD_OPTIONS,
-    HTTP_METHOD_TRACE,
-    HTTP_METHOD_COPY,
-    HTTP_METHOD_LOCK,
-    HTTP_METHOD_MKCOL,
-    HTTP_METHOD_MOVE,
-    HTTP_METHOD_PROPFIND,
-    HTTP_METHOD_PROPPATCH,
-    HTTP_METHOD_SEARCH,
-    HTTP_METHOD_UNLOCK,
-    HTTP_METHOD_BIND,
-    HTTP_METHOD_REBIND,
-    HTTP_METHOD_UNBIND,
-    HTTP_METHOD_ACL,
-    HTTP_METHOD_REPORT,
-    HTTP_METHOD_MKACTIVITY,
-    HTTP_METHOD_CHECKOUT,
-    HTTP_METHOD_MERGE,
-    HTTP_METHOD_MSEARCH,
-    HTTP_METHOD_NOTIFY,
-    HTTP_METHOD_SUBSCRIBE,
-    HTTP_METHOD_UNSUBSCRIBE,
-    HTTP_METHOD_PATCH,
-    HTTP_METHOD_PURGE,
-    HTTP_METHOD_MKCALENDAR,
-    HTTP_METHOD_LINK,
-    HTTP_METHOD_UNLINK
-} http_method_t;
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /* __HTTP_METHOD_H__ */
diff --git a/include/http/http_request.h b/include/http/http_request.h
deleted file mode 100644
index ad317ce..0000000
--- a/include/http/http_request.h
+++ /dev/null
@@ -1,58 +0,0 @@
-/*
- * C Header File
- *
- * Author: Davide Di Carlo
- * Date:   May 26, 2017 
- * email:  daddinuz@gmail.com
- */
-
-#ifndef __HTTP_REQUEST_H__
-#define __HTTP_REQUEST_H__
-
-#include "http_method.h"
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/**
- * http_request_t opaque type.
- */
-struct http_request {
-    const http_method_t method;
-    const char *const url;
-    const char *const headers;
-    const char *const body;
-};
-
-typedef const struct http_request http_request_t;
-
-/**
- * Create a new `http_request_t *` instance.
- * If memory allocation fails, this function returns NULL, and errno is set to ENOMEM.
- *
- * @param method The HTTP request method.
- * @param url The HTTP request URL.
- * @param headers The HTTP request headers.
- * @param body The HTTP request body.
- * @return A new `http_request_t *` instance.
- */
-extern http_request_t *http_request_new(
-        const http_method_t method,
-        const char *const url,
-        const char *const headers,
-        const char *const body
-);
-
-/**
- * Delete an already created `http_request_t *` instance.
- *
- * @param self The `http_request_t *` instance.
- */
-extern void http_request_delete(http_request_t *self);
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /* __HTTP_REQUEST_H__ */
diff --git a/include/http/http_response.h b/include/http/http_response.h
deleted file mode 100644
index 76a0059..0000000
--- a/include/http/http_response.h
+++ /dev/null
@@ -1,44 +0,0 @@
-/*
- * C Header File
- *
- * Author: Davide Di Carlo
- * Date:   May 26, 2017 
- * email:  daddinuz@gmail.com
- */
-
-#ifndef __HTTP_RESPONSE_H__
-#define __HTTP_RESPONSE_H__
-
-#include "http_request.h"
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/**
- * http_response_t opaque type.
- */
-struct http_response {
-    http_request_t *const request;
-    const char *const url;
-    const char *const headers;
-    const char *const body;
-    const size_t headers_length;
-    const size_t body_length;
-    const int status;
-};
-
-typedef const struct http_response http_response_t;
-
-/**
- * Delete an already created `http_response_t *` instance.
- *
- * @param self The `http_response_t *` instance.
- */
-extern void http_response_delete(http_response_t *self);
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /* __HTTP_RESPONSE_H__ */
diff --git a/include/http/http_status.h b/include/http/http_status.h
deleted file mode 100644
index 2862148..0000000
--- a/include/http/http_status.h
+++ /dev/null
@@ -1,82 +0,0 @@
-/*
- * C Header File
- *
- * Author: Davide Di Carlo
- * Date:   February 11, 2017 
- * email:  daddinuz@gmail.com
- */
-
-#ifndef __HTTP_STATUS_H__
-#define __HTTP_STATUS_H__
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-typedef enum http_status {
-    HTTP_STATUS_CONTINUE = 100,                         /* Continue                        */
-    HTTP_STATUS_SWITCHING_PROTOCOLS = 101,              /* Switching Protocols             */
-    HTTP_STATUS_PROCESSING = 102,                       /* Processing                      */
-    HTTP_STATUS_OK = 200,                               /* OK                              */
-    HTTP_STATUS_CREATED = 201,                          /* Created                         */
-    HTTP_STATUS_ACCEPTED = 202,                         /* Accepted                        */
-    HTTP_STATUS_NON_AUTHORITATIVE_INFORMATION = 203,    /* Non-Authoritative Information   */
-    HTTP_STATUS_NO_CONTENT = 204,                       /* No Content                      */
-    HTTP_STATUS_RESET_CONTENT = 205,                    /* Reset Content                   */
-    HTTP_STATUS_PARTIAL_CONTENT = 206,                  /* Partial Content                 */
-    HTTP_STATUS_MULTI_STATUS = 207,                     /* Multi-Status                    */
-    HTTP_STATUS_ALREADY_REPORTED = 208,                 /* Already Reported                */
-    HTTP_STATUS_IM_USED = 226,                          /* IM Used                         */
-    HTTP_STATUS_MULTIPLE_CHOICES = 300,                 /* Multiple Choices                */
-    HTTP_STATUS_MOVED_PERMANENTLY = 301,                /* Moved Permanently               */
-    HTTP_STATUS_FOUND = 302,                            /* Found                           */
-    HTTP_STATUS_SEE_OTHER = 303,                        /* See Other                       */
-    HTTP_STATUS_NOT_MODIFIED = 304,                     /* Not Modified                    */
-    HTTP_STATUS_USE_PROXY = 305,                        /* Use Proxy                       */
-    HTTP_STATUS_TEMPORARY_REDIRECT = 307,               /* Temporary Redirect              */
-    HTTP_STATUS_PERMANENT_REDIRECT = 308,               /* Permanent Redirect              */
-    HTTP_STATUS_BAD_REQUEST = 400,                      /* Bad Request                     */
-    HTTP_STATUS_UNAUTHORIZED = 401,                     /* Unauthorized                    */
-    HTTP_STATUS_PAYMENT_REQUIRED = 402,                 /* Payment Required                */
-    HTTP_STATUS_FORBIDDEN = 403,                        /* Forbidden                       */
-    HTTP_STATUS_NOT_FOUND = 404,                        /* Not Found                       */
-    HTTP_STATUS_METHOD_NOT_ALLOWED = 405,               /* Method Not Allowed              */
-    HTTP_STATUS_NOT_ACCEPTABLE = 406,                   /* Not Acceptable                  */
-    HTTP_STATUS_PROXY_AUTHENTICATION_REQUIRED = 407,    /* Proxy Authentication Required   */
-    HTTP_STATUS_REQUEST_TIMEOUT = 408,                  /* Request Timeout                 */
-    HTTP_STATUS_CONFLICT = 409,                         /* Conflict                        */
-    HTTP_STATUS_GONE = 410,                             /* Gone                            */
-    HTTP_STATUS_LENGTH_REQUIRED = 411,                  /* Length Required                 */
-    HTTP_STATUS_PRECONDITION_FAILED = 412,              /* Precondition Failed             */
-    HTTP_STATUS_PAYLOAD_TOO_LARGE = 413,                /* Payload Too Large               */
-    HTTP_STATUS_URI_TOO_LONG = 414,                     /* URI Too Long                    */
-    HTTP_STATUS_UNSUPPORTED_MEDIA_TYPE = 415,           /* Unsupported Media Type          */
-    HTTP_STATUS_RANGE_NOT_SATISFIABLE = 416,            /* Range Not Satisfiable           */
-    HTTP_STATUS_EXPECTATION_FAILED = 417,               /* Expectation Failed              */
-    HTTP_STATUS_MISDIRECTED_REQUEST = 421,              /* Misdirected Request             */
-    HTTP_STATUS_UNPROCESSABLE_ENTITY = 422,             /* Unprocessable Entity            */
-    HTTP_STATUS_LOCKED = 423,                           /* Locked                          */
-    HTTP_STATUS_FAILED_DEPENDENCY = 424,                /* Failed Dependency               */
-    HTTP_STATUS_UPGRADE_REQUIRED = 426,                 /* Upgrade Required                */
-    HTTP_STATUS_PRECONDITION_REQUIRED = 428,            /* Precondition Required           */
-    HTTP_STATUS_TOO_MANY_REQUESTS = 429,                /* Too Many Requests               */
-    HTTP_STATUS_REQUEST_HEADER_FIELDS_TOO_LARGE = 431,  /* Request Header Fields Too Large */
-    HTTP_STATUS_UNAVAILABLE_FOR_LEGAL_REASONS = 451,    /* Unavailable For Legal Reasons   */
-    HTTP_STATUS_INTERNAL_SERVER_ERROR = 500,            /* Internal Server Error           */
-    HTTP_STATUS_NOT_IMPLEMENTED = 501,                  /* Not Implemented                 */
-    HTTP_STATUS_BAD_GATEWAY = 502,                      /* Bad Gateway                     */
-    HTTP_STATUS_SERVICE_UNAVAILABLE = 503,              /* Service Unavailable             */
-    HTTP_STATUS_GATEWAY_TIMEOUT = 504,                  /* Gateway Timeout                 */
-    HTTP_STATUS_VERSION_NOT_SUPPORTED = 505,            /* HTTP Version Not Supported      */
-    HTTP_STATUS_VARIANT_ALSO_NEGOTIATES = 506,          /* Variant Also Negotiates         */
-    HTTP_STATUS_INSUFFICIENT_STORAGE = 507,             /* Insufficient Storage            */
-    HTTP_STATUS_LOOP_DETECTED = 508,                    /* Loop Detected                   */
-    HTTP_STATUS_NOT_EXTENDED = 510,                     /* Not Extended                    */
-    HTTP_STATUS_NETWORK_AUTHENTICATION_REQUIRED = 511   /* Network Authentication Required */
-} http_status_t;
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /* __HTTP_STATUS_H__ */
diff --git a/package.json b/package.json
index 7b871bf..4ef0a21 100644
--- a/package.json
+++ b/package.json
@@ -1,23 +1,41 @@
 {
   "name": "http",
-  "version": "0.2.6",
   "repo": "daddinuz/http",
+  "version": "0.3.0",
+  "license": "MIT",
   "description": "HTTP requests made easier.",
   "keywords": [
     "http",
     "https",
     "requests"
   ],
-  "license": "MIT",
-  "makefile": "http.cmake",
   "src": [
-    "include/http/http.h",
-    "include/http/http_method.h",
-    "include/http/http_request.h",
-    "include/http/http_response.h",
-    "include/http/http_status.h",
-    "src/http.c",
-    "src/http_request.c",
-    "src/http_response.c"
-  ]
+    "sources/http.c",
+    "sources/http.h",
+    "sources/http_error.c",
+    "sources/http_error.h",
+    "sources/http_fire_result.c",
+    "sources/http_fire_result.h",
+    "sources/http_maybe_text.c",
+    "sources/http_maybe_text.h",
+    "sources/http_method.c",
+    "sources/http_method.h",
+    "sources/http_request.c",
+    "sources/http_request.h",
+    "sources/http_response.c",
+    "sources/http_response.h",
+    "sources/http_status.c",
+    "sources/http_status.h"
+  ],
+  "dependencies": {
+    "daddinuz/atom": "0.1.0",
+    "daddinuz/text": "0.1.0",
+    "daddinuz/error": "0.2.0",
+    "daddinuz/panic": "0.3.0"
+  },
+  "development": {
+    "daddinuz/traits": "3.2.0",
+    "daddinuz/traits-unit": "3.0.0"
+  },
+  "makefile": "sources/build.cmake"
 }
diff --git a/sources/build.cmake b/sources/build.cmake
new file mode 100644
index 0000000..e3f0beb
--- /dev/null
+++ b/sources/build.cmake
@@ -0,0 +1,10 @@
+add_library(http
+        ${CMAKE_CURRENT_LIST_DIR}/http.h ${CMAKE_CURRENT_LIST_DIR}/http.c
+        ${CMAKE_CURRENT_LIST_DIR}/http_error.h ${CMAKE_CURRENT_LIST_DIR}/http_error.c
+        ${CMAKE_CURRENT_LIST_DIR}/http_fire_result.h ${CMAKE_CURRENT_LIST_DIR}/http_fire_result.c
+        ${CMAKE_CURRENT_LIST_DIR}/http_maybe_text.h ${CMAKE_CURRENT_LIST_DIR}/http_maybe_text.c
+        ${CMAKE_CURRENT_LIST_DIR}/http_method.h ${CMAKE_CURRENT_LIST_DIR}/http_method.c
+        ${CMAKE_CURRENT_LIST_DIR}/http_request.h ${CMAKE_CURRENT_LIST_DIR}/http_request.c
+        ${CMAKE_CURRENT_LIST_DIR}/http_response.h ${CMAKE_CURRENT_LIST_DIR}/http_response.c
+        ${CMAKE_CURRENT_LIST_DIR}/http_status.h ${CMAKE_CURRENT_LIST_DIR}/http_status.c)
+target_link_libraries(http PRIVATE curl atom text error panic option alligator)
diff --git a/sources/http.c b/sources/http.c
new file mode 100644
index 0000000..3736946
--- /dev/null
+++ b/sources/http.c
@@ -0,0 +1,220 @@
+/*
+ * Author: daddinuz
+ * email:  daddinuz@gmail.com
+ *
+ * Copyright (c) 2018 Davide Di Carlo
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * 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 <http.h>
+#include <assert.h>
+#include <stdlib.h>
+#include <curl/curl.h>
+#include <panic/panic.h>
+
+static Text emptyString = NULL;
+static bool initialized = false;
+
+static void cleanupEmptyString(void) {
+    Text_delete(emptyString);
+}
+
+static Text readFile(FILE *file) {
+    assert(file);
+    const long start = ftell(file);
+    if (start < 0) {
+        Panic_terminate("Unable to determinate file size\n");
+    }
+    if (fseek(file, 0L, SEEK_END) != 0) {
+        Panic_terminate("Unable to determinate file size\n");
+    }
+    const long end = ftell(file);
+    if (end < 0) {
+        Panic_terminate("Unable to determinate file size\n");
+    }
+    rewind(file);
+    const size_t length = (size_t) end;
+    Text text = Text_withCapacity(length);
+    const size_t read = fread(text, sizeof(text[0]), length, file);
+    if (read != length) {
+        Panic_terminate("Unable to read file\n");
+    }
+    Text_setLength(text, length);
+    text[length] = 0;
+    return text;
+}
+
+void Http_initialize(void) {
+    if (!initialized) {
+        const CURLcode e = curl_global_init(CURL_GLOBAL_ALL);
+        if (CURLE_OK != e) {
+            Panic_terminate("Unable to initialize CURL\n%s\n", curl_easy_strerror(e));
+        }
+        initialized = true;
+    }
+}
+
+void Http_terminate(void) {
+    if (initialized) {
+        curl_global_cleanup();
+    }
+}
+
+TextView Http_getEmptyString(void) {
+    if (NULL == emptyString) {
+        emptyString = Text_new();
+        atexit(cleanupEmptyString);
+    }
+    return emptyString;
+}
+
+Http_FireResult HttpRequest_fire(const struct HttpRequest **ref) {
+    assert(ref);
+    assert(*ref);
+    assert(initialized);
+    Error error;
+    CURL *curlHandler = NULL;
+    struct curl_slist *curlHeaders = NULL;
+    const struct HttpRequest *request = *ref;
+    FILE *responseHeadersFile, *responseBodyFile = NULL;
+
+    curlHandler = curl_easy_init();
+    if (NULL == curlHandler) {
+        Panic_terminate("Out of memory\n");
+    }
+
+    responseHeadersFile = tmpfile();
+    if (NULL == responseHeadersFile) {
+        Panic_terminate("Unable to open temporary file\n");
+    }
+
+    responseBodyFile = tmpfile();
+    if (NULL == responseBodyFile) {
+        Panic_terminate("Unable to open temporary file\n");
+    }
+
+    if (Text_length(HttpRequest_getHeaders(request)) > 0) {
+        curlHeaders = curl_slist_append(curlHeaders, HttpRequest_getHeaders(request));
+        if (NULL == curlHeaders) {
+            Panic_terminate("Out of memory\n");
+        }
+    }
+
+    // Set request url and method
+    curl_easy_setopt(curlHandler, CURLOPT_URL, HttpRequest_getUrl(request));
+    curl_easy_setopt(curlHandler, CURLOPT_CUSTOMREQUEST, HttpMethod_explain(HttpRequest_getMethod(request)));
+
+    // Set request headers
+    curl_easy_setopt(curlHandler, CURLOPT_HTTPHEADER, curlHeaders);
+
+    // Set request body
+    TextView requestBody = HttpRequest_getBody(request);
+    curl_easy_setopt(curlHandler, CURLOPT_POSTFIELDS, requestBody);
+    curl_easy_setopt(curlHandler, CURLOPT_POSTFIELDSIZE, Text_length(requestBody));
+
+    // Set request parameters
+    curl_easy_setopt(curlHandler, CURLOPT_FOLLOWLOCATION, HttpRequest_getFollowLocation(request));
+    curl_easy_setopt(curlHandler, CURLOPT_SSL_VERIFYPEER, HttpRequest_getPeerVerification(request));
+    curl_easy_setopt(curlHandler, CURLOPT_SSL_VERIFYHOST, HttpRequest_getHostVerification(request));
+    curl_easy_setopt(curlHandler, CURLOPT_TIMEOUT, HttpRequest_getTimeout(request));
+
+    // Set request callbacks in order to store the response data
+    curl_easy_setopt(curlHandler, CURLOPT_HEADERDATA, responseHeadersFile);
+    curl_easy_setopt(curlHandler, CURLOPT_WRITEDATA, responseBodyFile);
+
+#ifdef HTTP_DEBUG
+    // Set verbose debug output
+    curl_easy_setopt(curlHandler, CURLOPT_VERBOSE, 1L);
+#endif
+
+    const CURLcode e = curl_easy_perform(curlHandler);
+    switch (e) {
+        case CURLE_OK:
+            error = Ok;
+            break;
+        case CURLE_COULDNT_CONNECT:
+            error = HttpError_ConnectionFailed;
+            break;
+        case CURLE_OPERATION_TIMEDOUT:
+            error = HttpError_ConnectionTimedOut;
+            break;
+        case CURLE_SSL_CONNECT_ERROR:
+            error = HttpError_ConnectionSSLFailed;
+            break;
+        case CURLE_LOGIN_DENIED:
+            error = HttpError_AuthenticationFailed;
+            break;
+        case CURLE_COULDNT_RESOLVE_HOST:
+            error = HttpError_UnableToResolveHost;
+            break;
+        case CURLE_COULDNT_RESOLVE_PROXY:
+            error = HttpError_UnableToResolveProxy;
+            break;
+        case CURLE_SEND_ERROR:
+            error = HttpError_UnableToSendData;
+            break;
+        default:
+            fprintf(stderr, "%s\n", curl_easy_strerror(e));
+            error = HttpError_NetworkingError;
+    }
+
+    if (Ok == error) {
+        struct HttpResponseBuilder *responseBuilder = HttpResponseBuilder_new(ref);
+
+        // set response effective url
+        if (HttpRequest_getFollowLocation(request)) {
+            char *tmp = NULL;
+            curl_easy_getinfo(curlHandler, CURLINFO_EFFECTIVE_URL, &tmp);
+            HttpResponseBuilder_setUrl(responseBuilder, Atom_fromLiteral(tmp));
+        }
+
+        // set response status
+        long responseStatus;
+        curl_easy_getinfo(curlHandler, CURLINFO_RESPONSE_CODE, &responseStatus);
+        HttpResponseBuilder_setStatus(responseBuilder, (enum HttpStatus) responseStatus);
+
+        // set response headers
+        Text responseHeaders = readFile(responseHeadersFile);
+        HttpResponseBuilder_setHeaders(responseBuilder, &responseHeaders);
+
+        // set response body
+        Text responseBody = readFile(responseBodyFile);
+        HttpResponseBuilder_setBody(responseBuilder, &responseBody);
+
+        // perform cleanups
+        curl_slist_free_all(curlHeaders);
+        curl_easy_cleanup(curlHandler);
+        fclose(responseHeadersFile);
+        fclose(responseBodyFile);
+
+        return Http_FireResult_ok(HttpResponseBuilder_build(&responseBuilder));
+    } else {
+        // perform cleanups
+        curl_slist_free_all(curlHeaders);
+        curl_easy_cleanup(curlHandler);
+        fclose(responseHeadersFile);
+        fclose(responseBodyFile);
+
+        return Http_FireResult_error(error);
+    }
+}
diff --git a/sources/http.h b/sources/http.h
new file mode 100644
index 0000000..9a7b324
--- /dev/null
+++ b/sources/http.h
@@ -0,0 +1,77 @@
+/*
+ * Author: daddinuz
+ * email:  daddinuz@gmail.com
+ *
+ * Copyright (c) 2018 Davide Di Carlo
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * 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.
+ */
+
+#pragma once
+
+#include <stddef.h>
+#include <stdbool.h>
+
+#include <atom/atom.h>
+#include <text/text.h>
+#include <error/error.h>
+
+#include <http_error.h>
+#include <http_fire_result.h>
+#include <http_maybe_text.h>
+#include <http_method.h>
+#include <http_request.h>
+#include <http_response.h>
+#include <http_status.h>
+
+#if !(defined(__GNUC__) || defined(__clang__))
+#define __attribute__(...)
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * Initializes http module.
+ *
+ * @attention must be called at least once in every program that uses the http module, before firing any request.
+ */
+extern void Http_initialize(void);
+
+/**
+ * Terminates the http module freeing memory.
+ * 
+ * @attention must be called at least once in every program that uses the http module; After calling this functions 
+ * it's not allowed to fire a request without calling Http_initialize() before.
+ */
+extern void Http_terminate(void);
+
+/**
+ * Gets the singleton instance of a readonly  empty string.
+ */
+extern TextView Http_getEmptyString(void)
+__attribute__((__warn_unused_result__));
+
+#ifdef __cplusplus
+}
+#endif
diff --git a/sources/http_error.c b/sources/http_error.c
new file mode 100644
index 0000000..b83c7b5
--- /dev/null
+++ b/sources/http_error.c
@@ -0,0 +1,38 @@
+/*
+ * Author: daddinuz
+ * email:  daddinuz@gmail.com
+ *
+ * Copyright (c) 2018 Davide Di Carlo
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * 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 <http.h>
+
+const Error HttpError_NetworkingError = Error_new("Networking error");
+const Error HttpError_ConnectionFailed = Error_new("Connection failed");
+const Error HttpError_ConnectionTimedOut = Error_new("Connection timed out");
+const Error HttpError_ConnectionSSLFailed = Error_new("Connection SSL failed");
+const Error HttpError_AuthenticationFailed = Error_new("Authentication failed");
+const Error HttpError_UnableToResolveHost = Error_new("Unable to resolve host");
+const Error HttpError_UnableToResolveProxy = Error_new("Unable to resolve proxy");
+const Error HttpError_UnableToSendData = Error_new("Unable to send data");
diff --git a/sources/http_error.h b/sources/http_error.h
new file mode 100644
index 0000000..c073656
--- /dev/null
+++ b/sources/http_error.h
@@ -0,0 +1,52 @@
+/*
+ * Author: daddinuz
+ * email:  daddinuz@gmail.com
+ *
+ * Copyright (c) 2018 Davide Di Carlo
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * 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.
+ */
+
+#pragma once
+
+#include <http.h>
+
+#if !(defined(__GNUC__) || defined(__clang__))
+#define __attribute__(...)
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+extern const Error HttpError_NetworkingError;
+extern const Error HttpError_ConnectionFailed;
+extern const Error HttpError_ConnectionTimedOut;
+extern const Error HttpError_ConnectionSSLFailed;
+extern const Error HttpError_AuthenticationFailed;
+extern const Error HttpError_UnableToResolveHost;
+extern const Error HttpError_UnableToResolveProxy;
+extern const Error HttpError_UnableToSendData;
+
+#ifdef __cplusplus
+}
+#endif
diff --git a/sources/http_fire_result.c b/sources/http_fire_result.c
new file mode 100644
index 0000000..eb2efcf
--- /dev/null
+++ b/sources/http_fire_result.c
@@ -0,0 +1,65 @@
+/*
+ * Author: daddinuz
+ * email:  daddinuz@gmail.com
+ *
+ * Copyright (c) 2018 Davide Di Carlo
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * 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 <http.h>
+#include <assert.h>
+#include <panic/panic.h>
+
+Http_FireResult Http_FireResult_ok(const struct HttpResponse *response) {
+    assert(response);
+    return (Http_FireResult) {.__response=response, .__isOk=true};
+}
+
+Http_FireResult Http_FireResult_error(Error error) {
+    assert(error);
+    return (Http_FireResult) {.__error=error, .__isOk=false};
+}
+
+const struct HttpResponse *__Http_FireResult_unwrap(const char *file, int line, const Http_FireResult self) {
+    assert(file);
+    if (Http_FireResult_isOk(self)) {
+        return self.__response;
+    }
+    __Panic_terminate(file, line, "Error: %s.\n", Error_explain(self.__error));
+}
+
+Error __Http_FireResult_unwrapError(const char *file, int line, const Http_FireResult self) {
+    assert(file);
+    if (Http_FireResult_isError(self)) {
+        return self.__error;
+    }
+    __Panic_terminate(file, line, "Error: %s.\n", "Unable to unwrap error");
+}
+
+bool Http_FireResult_isOk(const Http_FireResult self) {
+    return self.__isOk;
+}
+
+bool Http_FireResult_isError(const Http_FireResult self) {
+    return !self.__isOk;
+}
diff --git a/sources/http_fire_result.h b/sources/http_fire_result.h
new file mode 100644
index 0000000..90c6279
--- /dev/null
+++ b/sources/http_fire_result.h
@@ -0,0 +1,114 @@
+/*
+ * Author: daddinuz
+ * email:  daddinuz@gmail.com
+ *
+ * Copyright (c) 2018 Davide Di Carlo
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * 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.
+ */
+
+#pragma once
+
+#include <http.h>
+
+#if !(defined(__GNUC__) || defined(__clang__))
+#define __attribute__(...)
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * Unwraps the http response.
+ * @attention Terminates execution if the result is not wrapping an http response.
+ */
+#define Http_FireResult_unwrap(self) \
+    __Http_FireResult_unwrap(__FILE__, __LINE__, (self))
+
+/**
+ * Unwraps the error.
+ * @attention Terminates execution if the result is wrapping an http response.
+ */
+#define Http_FireResult_unwrapError(self) \
+    __Http_FireResult_unwrapError(__FILE__, __LINE__, (self))
+
+/**
+ * Either type: Either(Error, struct HttpResponse *)
+ */
+typedef struct __Http_FireResult {
+    union {
+        const struct HttpResponse *__response;
+        const Error __error;
+    };
+    const bool __isOk;
+} Http_FireResult;
+
+/**
+ * Constructs a fire result wrapping the response from the server.
+ *
+ * @attention response must not be NULL.
+ */
+extern Http_FireResult Http_FireResult_ok(const struct HttpResponse *response)
+__attribute__((__warn_unused_result__, __nonnull__));
+
+/**
+ * Constructs a fire result wrapping the error.
+ *
+ * @attention error must not be NULL.
+ */
+extern Http_FireResult Http_FireResult_error(Error error)
+__attribute__((__warn_unused_result__, __nonnull__));
+
+/**
+ * NOTE: Do NOT use this function directly, @see Http_FireResult_unwrap.
+ *
+ * Unwraps the http response.
+ * @attention Terminates execution if the result is not Ok.
+ */
+extern const struct HttpResponse *__Http_FireResult_unwrap(const char *file, int line, Http_FireResult self)
+__attribute__((__warn_unused_result__, __nonnull__));
+
+/**
+ * NOTE: Do NOT use this function directly, @see Http_FireResult_unwrapError.
+ *
+ * Unwraps the error.
+ * @attention Terminates execution if the result is Ok.
+ */
+extern Error __Http_FireResult_unwrapError(const char *file, int line, Http_FireResult self)
+__attribute__((__warn_unused_result__, __nonnull__));
+
+/**
+ * @return true if the result wraps an http response else false
+ */
+extern bool Http_FireResult_isOk(Http_FireResult self)
+__attribute__((__warn_unused_result__));
+
+/**
+ * @return true if the result wraps an error else false
+ */
+extern bool Http_FireResult_isError(Http_FireResult self)
+__attribute__((__warn_unused_result__));
+
+#ifdef __cplusplus
+}
+#endif
diff --git a/sources/http_maybe_text.c b/sources/http_maybe_text.c
new file mode 100644
index 0000000..4360e9b
--- /dev/null
+++ b/sources/http_maybe_text.c
@@ -0,0 +1,47 @@
+/*
+ * Author: daddinuz
+ * email:  daddinuz@gmail.com
+ *
+ * Copyright (c) 2018 Davide Di Carlo
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * 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 <http.h>
+#include <assert.h>
+#include <panic/panic.h>
+
+Http_MaybeText Http_MaybeText_new(Text text) {
+    return (Http_MaybeText) {.__text = text};
+}
+
+Text __Http_MaybeText_unwrap(const char *const file, const int line, const Http_MaybeText self) {
+    assert(file);
+    if (Http_MaybeText_isPresent(self)) {
+        return self.__text;
+    }
+    __Panic_terminate(file, line, "Error: %s.\n", "Unable to unwrap value");
+}
+
+bool Http_MaybeText_isPresent(const Http_MaybeText self) {
+    return NULL != self.__text;
+}
diff --git a/sources/http_maybe_text.h b/sources/http_maybe_text.h
new file mode 100644
index 0000000..f1c63fe
--- /dev/null
+++ b/sources/http_maybe_text.h
@@ -0,0 +1,78 @@
+/*
+ * Author: daddinuz
+ * email:  daddinuz@gmail.com
+ *
+ * Copyright (c) 2018 Davide Di Carlo
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * 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.
+ */
+
+#pragma once
+
+#include <http.h>
+
+#if !(defined(__GNUC__) || defined(__clang__))
+#define __attribute__(...)
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * Unwraps the text.
+ * @attention Terminates execution if text is not present.
+ */
+#define Http_MaybeText_unwrap(self) \
+    __Http_MaybeText_unwrap(__FILE__, __LINE__, (self))
+
+/**
+ * Maybe type: eg Maybe(Text)
+ */
+typedef struct __Http_MaybeText {
+    Text __text;
+} Http_MaybeText;
+
+/**
+ * Constructs an instance of Http_MaybeText from text.
+ */
+extern Http_MaybeText Http_MaybeText_new(Text text)
+__attribute__((__warn_unused_result__));
+
+/**
+ * NOTE: Do NOT use this function directly, @see Http_MaybeText_unwrap.
+ *
+ * Unwraps the text.
+ * @attention Terminates execution if text is not present.
+ */
+extern Text __Http_MaybeText_unwrap(const char *file, int line, Http_MaybeText self)
+__attribute__((__warn_unused_result__, __nonnull__));
+
+/**
+ * @return true if text is present (non-null) else false.
+ */
+extern bool Http_MaybeText_isPresent(Http_MaybeText self)
+__attribute__((__warn_unused_result__, __nonnull__));
+
+#ifdef __cplusplus
+}
+#endif
diff --git a/sources/http_method.c b/sources/http_method.c
new file mode 100644
index 0000000..78486bc
--- /dev/null
+++ b/sources/http_method.c
@@ -0,0 +1,116 @@
+/*
+ * Author: daddinuz
+ * email:  daddinuz@gmail.com
+ *
+ * Copyright (c) 2018 Davide Di Carlo
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * 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 <http.h>
+#include <panic/panic.h>
+
+static const char HTTP_METHOD_DELETE_EXPLANATION[] = "DELETE";
+static const char HTTP_METHOD_GET_EXPLANATION[] = "GET";
+static const char HTTP_METHOD_HEAD_EXPLANATION[] = "HEAD";
+static const char HTTP_METHOD_POST_EXPLANATION[] = "POST";
+static const char HTTP_METHOD_PUT_EXPLANATION[] = "PUT";
+static const char HTTP_METHOD_CONNECT_EXPLANATION[] = "CONNECT";
+static const char HTTP_METHOD_OPTIONS_EXPLANATION[] = "OPTIONS";
+static const char HTTP_METHOD_TRACE_EXPLANATION[] = "TRACE";
+static const char HTTP_METHOD_COPY_EXPLANATION[] = "COPY";
+static const char HTTP_METHOD_LOCK_EXPLANATION[] = "LOCK";
+static const char HTTP_METHOD_MOVE_EXPLANATION[] = "MOVE";
+static const char HTTP_METHOD_SEARCH_EXPLANATION[] = "SEARCH";
+static const char HTTP_METHOD_UNLOCK_EXPLANATION[] = "UNLOCK";
+static const char HTTP_METHOD_BIND_EXPLANATION[] = "BIND";
+static const char HTTP_METHOD_REBIND_EXPLANATION[] = "REBIND";
+static const char HTTP_METHOD_UNBIND_EXPLANATION[] = "UNBIND";
+static const char HTTP_METHOD_REPORT_EXPLANATION[] = "REPORT";
+static const char HTTP_METHOD_CHECKOUT_EXPLANATION[] = "CHECKOUT";
+static const char HTTP_METHOD_MERGE_EXPLANATION[] = "MERGE";
+static const char HTTP_METHOD_NOTIFY_EXPLANATION[] = "NOTIFY";
+static const char HTTP_METHOD_SUBSCRIBE_EXPLANATION[] = "SUBSCRIBE";
+static const char HTTP_METHOD_UNSUBSCRIBE_EXPLANATION[] = "UNSUBSCRIBE";
+static const char HTTP_METHOD_PATCH_EXPLANATION[] = "PATCH";
+static const char HTTP_METHOD_PURGE_EXPLANATION[] = "PURGE";
+static const char HTTP_METHOD_LINK_EXPLANATION[] = "LINK";
+static const char HTTP_METHOD_UNLINK_EXPLANATION[] = "UNLINK";
+
+const char *HttpMethod_explain(const enum HttpMethod method) {
+    switch (method) {
+        case HTTP_METHOD_DELETE:
+            return HTTP_METHOD_DELETE_EXPLANATION;
+        case HTTP_METHOD_GET:
+            return HTTP_METHOD_GET_EXPLANATION;
+        case HTTP_METHOD_HEAD:
+            return HTTP_METHOD_HEAD_EXPLANATION;
+        case HTTP_METHOD_POST:
+            return HTTP_METHOD_POST_EXPLANATION;
+        case HTTP_METHOD_PUT:
+            return HTTP_METHOD_PUT_EXPLANATION;
+        case HTTP_METHOD_CONNECT:
+            return HTTP_METHOD_CONNECT_EXPLANATION;
+        case HTTP_METHOD_OPTIONS:
+            return HTTP_METHOD_OPTIONS_EXPLANATION;
+        case HTTP_METHOD_TRACE:
+            return HTTP_METHOD_TRACE_EXPLANATION;
+        case HTTP_METHOD_COPY:
+            return HTTP_METHOD_COPY_EXPLANATION;
+        case HTTP_METHOD_LOCK:
+            return HTTP_METHOD_LOCK_EXPLANATION;
+        case HTTP_METHOD_MOVE:
+            return HTTP_METHOD_MOVE_EXPLANATION;
+        case HTTP_METHOD_SEARCH:
+            return HTTP_METHOD_SEARCH_EXPLANATION;
+        case HTTP_METHOD_UNLOCK:
+            return HTTP_METHOD_UNLOCK_EXPLANATION;
+        case HTTP_METHOD_BIND:
+            return HTTP_METHOD_BIND_EXPLANATION;
+        case HTTP_METHOD_REBIND:
+            return HTTP_METHOD_REBIND_EXPLANATION;
+        case HTTP_METHOD_UNBIND:
+            return HTTP_METHOD_UNBIND_EXPLANATION;
+        case HTTP_METHOD_REPORT:
+            return HTTP_METHOD_REPORT_EXPLANATION;
+        case HTTP_METHOD_CHECKOUT:
+            return HTTP_METHOD_CHECKOUT_EXPLANATION;
+        case HTTP_METHOD_MERGE:
+            return HTTP_METHOD_MERGE_EXPLANATION;
+        case HTTP_METHOD_NOTIFY:
+            return HTTP_METHOD_NOTIFY_EXPLANATION;
+        case HTTP_METHOD_SUBSCRIBE:
+            return HTTP_METHOD_SUBSCRIBE_EXPLANATION;
+        case HTTP_METHOD_UNSUBSCRIBE:
+            return HTTP_METHOD_UNSUBSCRIBE_EXPLANATION;
+        case HTTP_METHOD_PATCH:
+            return HTTP_METHOD_PATCH_EXPLANATION;
+        case HTTP_METHOD_PURGE:
+            return HTTP_METHOD_PURGE_EXPLANATION;
+        case HTTP_METHOD_LINK:
+            return HTTP_METHOD_LINK_EXPLANATION;
+        case HTTP_METHOD_UNLINK:
+            return HTTP_METHOD_UNLINK_EXPLANATION;
+        default:
+            Panic_terminate("Unknown method: %d", method);
+    }
+}
diff --git a/sources/http_method.h b/sources/http_method.h
new file mode 100644
index 0000000..14bd54c
--- /dev/null
+++ b/sources/http_method.h
@@ -0,0 +1,80 @@
+/*
+ * Author: daddinuz
+ * email:  daddinuz@gmail.com
+ *
+ * Copyright (c) 2018 Davide Di Carlo
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * 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.
+ */
+
+#pragma once
+
+#if !(defined(__GNUC__) || defined(__clang__))
+#define __attribute__(...)
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+enum HttpMethod {
+    HTTP_METHOD_DELETE,
+    HTTP_METHOD_GET,
+    HTTP_METHOD_HEAD,
+    HTTP_METHOD_POST,
+    HTTP_METHOD_PUT,
+    HTTP_METHOD_CONNECT,
+    HTTP_METHOD_OPTIONS,
+    HTTP_METHOD_TRACE,
+    HTTP_METHOD_COPY,
+    HTTP_METHOD_LOCK,
+    HTTP_METHOD_MOVE,
+    HTTP_METHOD_SEARCH,
+    HTTP_METHOD_UNLOCK,
+    HTTP_METHOD_BIND,
+    HTTP_METHOD_REBIND,
+    HTTP_METHOD_UNBIND,
+    HTTP_METHOD_REPORT,
+    HTTP_METHOD_CHECKOUT,
+    HTTP_METHOD_MERGE,
+    HTTP_METHOD_NOTIFY,
+    HTTP_METHOD_SUBSCRIBE,
+    HTTP_METHOD_UNSUBSCRIBE,
+    HTTP_METHOD_PATCH,
+    HTTP_METHOD_PURGE,
+    HTTP_METHOD_LINK,
+    HTTP_METHOD_UNLINK
+};
+
+/**
+ * Returns the string representation of the http method.
+ *
+ * @param method The http method.
+ * @return The string representation of the http method.
+ */
+extern const char *
+HttpMethod_explain(enum HttpMethod method)
+__attribute__((__warn_unused_result__));
+
+#ifdef __cplusplus
+}
+#endif
diff --git a/sources/http_request.c b/sources/http_request.c
new file mode 100644
index 0000000..4cd6333
--- /dev/null
+++ b/sources/http_request.c
@@ -0,0 +1,210 @@
+/*
+ * Author: daddinuz
+ * email:  daddinuz@gmail.com
+ *
+ * Copyright (c) 2018 Davide Di Carlo
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * 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 <http.h>
+#include <assert.h>
+#include <alligator/alligator.h>
+
+struct HttpRequest {
+    Atom url;
+    Text headers;
+    Text body;
+    size_t timeout;
+    bool followLocation;
+    bool peerVerification;
+    bool hostVerification;
+    enum HttpMethod method;
+};
+
+enum HttpMethod HttpRequest_getMethod(const struct HttpRequest *self) {
+    assert(self);
+    return self->method;
+}
+
+Atom HttpRequest_getUrl(const struct HttpRequest *self) {
+    assert(self);
+    return self->url;
+}
+
+TextView HttpRequest_getHeaders(const struct HttpRequest *self) {
+    assert(self);
+    return NULL == self->headers ? Http_getEmptyString() : self->headers;
+}
+
+TextView HttpRequest_getBody(const struct HttpRequest *self) {
+    assert(self);
+    return NULL == self->body ? Http_getEmptyString() : self->body;
+}
+
+size_t HttpRequest_getTimeout(const struct HttpRequest *self) {
+    assert(self);
+    return self->timeout;
+}
+
+bool HttpRequest_getFollowLocation(const struct HttpRequest *self) {
+    assert(self);
+    return self->followLocation;
+}
+
+bool HttpRequest_getPeerVerification(const struct HttpRequest *self) {
+    assert(self);
+    return self->peerVerification;
+}
+
+bool HttpRequest_getHostVerification(const struct HttpRequest *self) {
+    assert(self);
+    return self->hostVerification;
+}
+
+void HttpRequest_delete(const struct HttpRequest *self) {
+    if (self) {
+        Text_delete(self->body);
+        Text_delete(self->headers);
+        Alligator_free((void *) self);
+    }
+}
+
+struct HttpRequestBuilder {
+    struct HttpRequest *request;
+};
+
+struct HttpRequestBuilder *HttpRequestBuilder_new(enum HttpMethod method, Atom url) {
+    assert(url);
+    struct HttpRequest *request = Option_unwrap(Alligator_malloc(sizeof(*request)));
+    struct HttpRequestBuilder *self = Option_unwrap(Alligator_malloc(sizeof(*self)));
+    request->url = url;
+    request->headers = NULL;
+    request->body = NULL;
+    request->timeout = 0;
+    request->followLocation = true;
+    request->peerVerification = true;
+    request->hostVerification = true;
+    request->method = method;
+    self->request = request;
+    return self;
+}
+
+enum HttpMethod HttpRequestBuilder_setMethod(struct HttpRequestBuilder *self, enum HttpMethod method) {
+    assert(self);
+    const enum HttpMethod previousMethod = self->request->method;
+    self->request->method = method;
+    return previousMethod;
+}
+
+Atom HttpRequestBuilder_setUrl(struct HttpRequestBuilder *self, Atom url) {
+    assert(self);
+    Atom previousUrl = self->request->url;
+    self->request->url = url;
+    return previousUrl;
+}
+
+Http_MaybeText HttpRequestBuilder_setHeaders(struct HttpRequestBuilder *self, Text *ref) {
+    assert(self);
+    Text previousHeaders = self->request->headers;
+    if (NULL != ref) {
+        assert(*ref);
+        self->request->headers = *ref;
+        *ref = NULL;
+    }
+    return Http_MaybeText_new(previousHeaders);
+}
+
+Http_MaybeText HttpRequestBuilder_emplaceHeaders(struct HttpRequestBuilder *self, const char *format, ...) {
+    assert(self);
+    assert(format);
+    va_list args;
+    va_start(args, format);
+    Text headers = Text_vFormat(format, args);
+    va_end(args);
+    return HttpRequestBuilder_setHeaders(self, &headers);
+}
+
+Http_MaybeText HttpRequestBuilder_setBody(struct HttpRequestBuilder *self, Text *ref) {
+    assert(self);
+    Text previousBody = self->request->body;
+    if (NULL != ref) {
+        assert(*ref);
+        self->request->body = *ref;
+        *ref = NULL;
+    }
+    return Http_MaybeText_new(previousBody);
+}
+
+Http_MaybeText HttpRequestBuilder_emplaceBody(struct HttpRequestBuilder *self, const char *format, ...) {
+    assert(self);
+    assert(format);
+    va_list args;
+    va_start(args, format);
+    Text body = Text_vFormat(format, args);
+    va_end(args);
+    return HttpRequestBuilder_setBody(self, &body);
+}
+
+size_t HttpRequestBuilder_setTimeout(struct HttpRequestBuilder *self, size_t timeout) {
+    assert(self);
+    const size_t previousTimeout = self->request->timeout;
+    self->request->timeout = timeout;
+    return previousTimeout;
+}
+
+bool HttpRequestBuilder_setFollowLocation(struct HttpRequestBuilder *self, bool enable) {
+    assert(self);
+    const bool previousFollowLocation = self->request->followLocation;
+    self->request->followLocation = enable;
+    return previousFollowLocation;
+}
+
+bool HttpRequestBuilder_setPeerVerification(struct HttpRequestBuilder *self, bool enable) {
+    assert(self);
+    const bool previousPeerVerification = self->request->peerVerification;
+    self->request->peerVerification = enable;
+    return previousPeerVerification;
+}
+
+bool HttpRequestBuilder_setHostVerification(struct HttpRequestBuilder *self, bool enable) {
+    assert(self);
+    const bool previousHostVerification = self->request->hostVerification;
+    self->request->hostVerification = enable;
+    return previousHostVerification;
+}
+
+const struct HttpRequest *HttpRequestBuilder_build(struct HttpRequestBuilder **ref) {
+    assert(ref);
+    assert(*ref);
+    const struct HttpRequest *request = (*ref)->request;
+    Alligator_free(*ref);
+    *ref = NULL;
+    return request;
+}
+
+void HttpRequestBuilder_delete(struct HttpRequestBuilder *self) {
+    if (self) {
+        HttpRequest_delete(self->request);
+        Alligator_free(self);
+    }
+}
diff --git a/sources/http_request.h b/sources/http_request.h
new file mode 100644
index 0000000..95110aa
--- /dev/null
+++ b/sources/http_request.h
@@ -0,0 +1,291 @@
+/*
+ * Author: daddinuz
+ * email:  daddinuz@gmail.com
+ *
+ * Copyright (c) 2018 Davide Di Carlo
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * 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.
+ */
+
+#pragma once
+
+#include <http.h>
+
+#if !(defined(__GNUC__) || defined(__clang__))
+#define __attribute__(...)
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+struct HttpRequest;
+
+/**
+ * Returns the http method associated to this request.
+ *
+ * @attention self must not be NULL.
+ */
+extern enum HttpMethod
+HttpRequest_getMethod(const struct HttpRequest *self)
+__attribute__((__warn_unused_result__, __nonnull__));
+
+/**
+ * Returns the url associated to this request.
+ *
+ * @attention self must not be NULL.
+ */
+extern Atom
+HttpRequest_getUrl(const struct HttpRequest *self)
+__attribute__((__warn_unused_result__, __nonnull__));
+
+/**
+ * Returns the headers associated to this request.
+ * Note: The current request is the owner of these headers, therefore they must be considered read-only.
+ *
+ * @attention self must not be NULL.
+ */
+extern TextView
+HttpRequest_getHeaders(const struct HttpRequest *self)
+__attribute__((__warn_unused_result__, __nonnull__));
+
+/**
+ * Returns the body associated to this request.
+ * Note: The current request is the owner of the body, therefore it must be considered read-only.
+ *
+ * @attention self must not be NULL.
+ */
+extern TextView
+HttpRequest_getBody(const struct HttpRequest *self)
+__attribute__((__warn_unused_result__, __nonnull__));
+
+/**
+ * Returns the timeout for this request.
+ *
+ * @attention self must not be NULL.
+ */
+extern size_t
+HttpRequest_getTimeout(const struct HttpRequest *self)
+__attribute__((__warn_unused_result__, __nonnull__));
+
+/**
+ * Returns true if follow location is enabled for this request else false.
+ *
+ * @attention self must not be NULL.
+ */
+extern bool
+HttpRequest_getFollowLocation(const struct HttpRequest *self)
+__attribute__((__warn_unused_result__, __nonnull__));
+
+/**
+ * Returns true if peer verification is enabled for this request else false.
+ *
+ * @attention self must not be NULL.
+ */
+extern bool
+HttpRequest_getPeerVerification(const struct HttpRequest *self)
+__attribute__((__warn_unused_result__, __nonnull__));
+
+/**
+ * Returns true if host verification is enabled for this request else false.
+ *
+ * @attention self must not be NULL.
+ */
+extern bool
+HttpRequest_getHostVerification(const struct HttpRequest *self)
+__attribute__((__warn_unused_result__, __nonnull__));
+
+/**
+ * Sends the http request to the server waiting for response.
+ *
+ * @attention self must not be NULL.
+ * @attention on success this function moves the ownership of the request to the resulting response
+ * invalidating any previous reference to the request, on error the reference to the request is left untouched.
+ */
+extern Http_FireResult
+HttpRequest_fire(const struct HttpRequest **ref)
+__attribute__((__warn_unused_result__, __nonnull__));
+
+/**
+ * Deletes this request freeing memory.
+ * Note: If self is NULL no action will be performed.
+ */
+extern void
+HttpRequest_delete(const struct HttpRequest *self);
+
+/*
+ * Builder
+ */
+
+struct HttpRequestBuilder;
+
+/**
+ * Creates a new request builder.
+ *
+ * @attention url must not be NULL.
+ * @attention the lifetime of url must be greater of the builder instance or the built request (if any).
+ */
+extern struct HttpRequestBuilder *
+HttpRequestBuilder_new(enum HttpMethod method, Atom url)
+__attribute__((__warn_unused_result__, __nonnull__));
+
+/**
+ * Sets the method for the request stored into this builder.
+ *
+ * @attention self must not be NULL.
+ *
+ * @return The previous http method stored into this builder.
+ */
+extern enum HttpMethod
+HttpRequestBuilder_setMethod(struct HttpRequestBuilder *self, enum HttpMethod method)
+__attribute__((__nonnull__));
+
+/**
+ * Sets the url for the request stored into this builder.
+ * 
+ * @attention self must not be NULL.
+ * @attention url must not be NULL.
+ * @attention the lifetime of url must be greater of the builder instance or the built request (if any).
+ *
+ * @return The previous url stored into this builder.
+ */
+extern Atom
+HttpRequestBuilder_setUrl(struct HttpRequestBuilder *self, Atom url)
+__attribute__((__nonnull__));
+
+/**
+ * Sets the headers for the request stored into this builder.
+ *
+ * @attention self must not be NULL.
+ * @attention the user is responsible to free the replaced headers (if any).
+ * @attention this function moves the ownership of the headers to this builder invalidating every previous reference.
+ *
+ * @return The previous headers stored into this builder.
+ */
+extern Http_MaybeText
+HttpRequestBuilder_setHeaders(struct HttpRequestBuilder *self, Text *ref)
+__attribute__((__nonnull__(1)));
+
+/**
+ * Construct in place and replace the headers for the request stored into this builder.
+ * 
+ * @attention self must not be NULL.
+ * @attention format must not be NULL.
+ * @attention the user is responsible to free the replaced headers (if any).
+ * 
+ * @return The previous headers stored into this builder.
+ */
+extern Http_MaybeText
+HttpRequestBuilder_emplaceHeaders(struct HttpRequestBuilder *self, const char *format, ...)
+__attribute__((__nonnull__(1, 2), __format__(printf, 2, 3)));
+
+/**
+ * Sets the body for the request stored into this builder.
+ *
+ * @attention self must not be NULL.
+ * @attention the user is responsible to free the replaced body (if any).
+ * @attention this function moves the ownership of the body to this builder invalidating every previous reference.
+ *
+ * @return The previous body stored into this builder.
+ */
+extern Http_MaybeText
+HttpRequestBuilder_setBody(struct HttpRequestBuilder *self, Text *ref)
+__attribute__((__nonnull__(1)));
+
+/**
+ * Construct in place and replace the body for the request stored into this builder.
+ * 
+ * @attention self must not be NULL.
+ * @attention format must not be NULL.
+ * @attention the user is responsible to free the replaced body (if any).
+ * 
+ * @return The previous body stored into this builder.
+ */
+extern Http_MaybeText
+HttpRequestBuilder_emplaceBody(struct HttpRequestBuilder *self, const char *format, ...)
+__attribute__((__nonnull__(1, 2), __format__(printf, 2, 3)));
+
+/**
+ * Sets the timeout for the request stored into this builder.
+ *
+ * @attention self must not be NULL.
+ *
+ * @return The previous timeout stored into this builder.
+ */
+extern size_t
+HttpRequestBuilder_setTimeout(struct HttpRequestBuilder *self, size_t timeout)
+__attribute__((__nonnull__));
+
+/**
+ * Enables or disables follow location for the request stored into this builder.
+ *
+ * @attention self must not be NULL.
+ *
+ * @return The previous value stored into this builder.
+ */
+extern bool
+HttpRequestBuilder_setFollowLocation(struct HttpRequestBuilder *self, bool enable)
+__attribute__((__nonnull__));
+
+/**
+ * Enables or disables peer verification for the request stored into this builder.
+ *
+ * @attention self must not be NULL.
+ *
+ * @return The previous value stored into this builder.
+ */
+extern bool
+HttpRequestBuilder_setPeerVerification(struct HttpRequestBuilder *self, bool enable)
+__attribute__((__nonnull__));
+
+/**
+ * Enables or disables host verification for the request stored into this builder.
+ *
+ * @attention self must not be NULL.
+ *
+ * @return The previous value stored into this builder.
+ */
+extern bool
+HttpRequestBuilder_setHostVerification(struct HttpRequestBuilder *self, bool enable)
+__attribute__((__nonnull__));
+
+/**
+ * Constructs the http request and deletes this builder freeing memory.
+ *
+ * @attention ref must not be NULL.
+ * @attention *ref must not be NULL.
+ * @attention this functions takes the ownership of this builder invalidating every previous reference.
+ */
+extern const struct HttpRequest *
+HttpRequestBuilder_build(struct HttpRequestBuilder **ref)
+__attribute__((__warn_unused_result__, __nonnull__));
+
+/**
+ * Deletes this builder freeing memory.
+ * If self is NULL no action will be performed.
+ */
+extern void
+HttpRequestBuilder_delete(struct HttpRequestBuilder *self);
+
+#ifdef __cplusplus
+}
+#endif
diff --git a/sources/http_response.c b/sources/http_response.c
new file mode 100644
index 0000000..628f049
--- /dev/null
+++ b/sources/http_response.c
@@ -0,0 +1,164 @@
+/*
+ * Author: daddinuz
+ * email:  daddinuz@gmail.com
+ *
+ * Copyright (c) 2018 Davide Di Carlo
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * 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 <http.h>
+#include <assert.h>
+#include <alligator/alligator.h>
+
+struct HttpResponse {
+    const struct HttpRequest *request;
+    Atom url;
+    Text headers;
+    Text body;
+    enum HttpStatus status;
+};
+
+const struct HttpRequest *HttpResponse_getRequest(const struct HttpResponse *self) {
+    assert(self);
+    return self->request;
+}
+
+Atom HttpResponse_getUrl(const struct HttpResponse *self) {
+    assert(self);
+    return self->url;
+}
+
+TextView HttpResponse_getHeaders(const struct HttpResponse *self) {
+    assert(self);
+    return NULL == self->headers ? Http_getEmptyString() : self->headers;
+}
+
+TextView HttpResponse_getBody(const struct HttpResponse *self) {
+    assert(self);
+    return NULL == self->body ? Http_getEmptyString() : self->body;
+}
+
+enum HttpStatus HttpResponse_getStatus(const struct HttpResponse *self) {
+    assert(self);
+    return self->status;
+}
+
+void HttpResponse_delete(const struct HttpResponse *self) {
+    if (self) {
+        HttpRequest_delete(self->request);
+        Text_delete(self->body);
+        Text_delete(self->headers);
+        Alligator_free((void *) self);
+    }
+}
+
+struct HttpResponseBuilder {
+    struct HttpResponse *response;
+};
+
+struct HttpResponseBuilder *HttpResponseBuilder_new(const struct HttpRequest **ref) {
+    assert(ref);
+    assert(*ref);
+    struct HttpResponse *response = Option_unwrap(Alligator_malloc(sizeof(*response)));
+    struct HttpResponseBuilder *self = Option_unwrap(Alligator_malloc(sizeof(*self)));
+    response->request = *ref;
+    response->url = HttpRequest_getUrl(*ref);
+    response->headers = NULL;
+    response->body = NULL;
+    response->status = HTTP_STATUS_OK;
+    self->response = response;
+    *ref = NULL;
+    return self;
+}
+
+enum HttpStatus HttpResponseBuilder_setStatus(struct HttpResponseBuilder *self, enum HttpStatus status) {
+    assert(self);
+    const enum HttpStatus previousStatus = self->response->status;
+    self->response->status = status;
+    return previousStatus;
+}
+
+Atom HttpResponseBuilder_setUrl(struct HttpResponseBuilder *self, Atom url) {
+    assert(self);
+    Atom previousUrl = self->response->url;
+    self->response->url = url;
+    return previousUrl;
+}
+
+Http_MaybeText HttpResponseBuilder_setHeaders(struct HttpResponseBuilder *self, Text *ref) {
+    assert(self);
+    Text previousHeaders = self->response->headers;
+    if (NULL != ref) {
+        assert(*ref);
+        self->response->headers = *ref;
+        *ref = NULL;
+    }
+    return Http_MaybeText_new(previousHeaders);
+}
+
+Http_MaybeText HttpResponseBuilder_emplaceHeaders(struct HttpResponseBuilder *self, const char *format, ...) {
+    assert(self);
+    assert(format);
+    va_list args;
+    va_start(args, format);
+    Text headers = Text_vFormat(format, args);
+    va_end(args);
+    return HttpResponseBuilder_setHeaders(self, &headers);
+}
+
+Http_MaybeText HttpResponseBuilder_setBody(struct HttpResponseBuilder *self, Text *ref) {
+    assert(self);
+    Text previousBody = self->response->body;
+    if (NULL != ref) {
+        assert(*ref);
+        self->response->body = *ref;
+        *ref = NULL;
+    }
+    return Http_MaybeText_new(previousBody);
+}
+
+Http_MaybeText HttpResponseBuilder_emplaceBody(struct HttpResponseBuilder *self, const char *format, ...) {
+    assert(self);
+    assert(format);
+    va_list args;
+    va_start(args, format);
+    Text body = Text_vFormat(format, args);
+    va_end(args);
+    return HttpResponseBuilder_setBody(self, &body);
+}
+
+const struct HttpResponse *HttpResponseBuilder_build(struct HttpResponseBuilder **ref) {
+    assert(ref);
+    assert(*ref);
+    const struct HttpResponse *response = (*ref)->response;
+    Alligator_free(*ref);
+    *ref = NULL;
+    return response;
+}
+
+void HttpResponseBuilder_delete(struct HttpResponseBuilder *self) {
+    if (self) {
+        HttpResponse_delete(self->response);
+        Alligator_free(self);
+    }
+}
diff --git a/sources/http_response.h b/sources/http_response.h
new file mode 100644
index 0000000..9111efc
--- /dev/null
+++ b/sources/http_response.h
@@ -0,0 +1,211 @@
+/*
+ * Author: daddinuz
+ * email:  daddinuz@gmail.com
+ *
+ * Copyright (c) 2018 Davide Di Carlo
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * 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.
+ */
+
+#pragma once
+
+#include <http.h>
+
+#if !(defined(__GNUC__) || defined(__clang__))
+#define __attribute__(...)
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+struct HttpResponse;
+
+/**
+ * Returns the http request that generated this response.
+ * 
+ * @attention self must not be NULL.
+ */
+extern const struct HttpRequest *
+HttpResponse_getRequest(const struct HttpResponse *self)
+__attribute__((__warn_unused_result__, __nonnull__));
+
+/**
+ * Returns the effective url associated to this response.
+ * Note: response url may be different from request url if follow location were enabled for the request.
+ *
+ * @attention self must not be NULL.
+ */
+extern Atom
+HttpResponse_getUrl(const struct HttpResponse *self)
+__attribute__((__warn_unused_result__, __nonnull__));
+
+/**
+ * Returns the headers associated to this response.
+ * Note: The current response is the owner of these headers, therefore they must be considered read-only.
+ *
+ * @attention self must not be NULL.
+ */
+extern TextView
+HttpResponse_getHeaders(const struct HttpResponse *self)
+__attribute__((__warn_unused_result__, __nonnull__));
+
+/**
+ * Returns the body associated to this response.
+ * Note: The current response is the owner of the body, therefore it must be considered read-only.
+ *
+ * @attention self must not be NULL.
+ */
+extern TextView
+HttpResponse_getBody(const struct HttpResponse *self)
+__attribute__((__warn_unused_result__, __nonnull__));
+
+/**
+ * Returns the http status code associated to this response.
+ *
+ * @attention self must not be NULL.
+ */
+extern enum HttpStatus
+HttpResponse_getStatus(const struct HttpResponse *self)
+__attribute__((__warn_unused_result__, __nonnull__));
+
+/**
+ * Deletes this response freeing memory.
+ * Note: If self is NULL no action will be performed.
+ */
+extern void
+HttpResponse_delete(const struct HttpResponse *self);
+
+/*
+ * Builder
+ */
+
+struct HttpResponseBuilder;
+
+/**
+ * Creates a new response builder.
+ *
+ * @attention ref must not be NULL.
+ * @attention *ref must not be NULL.
+ * @attention this function moves the ownership of the request to this builder invalidating every previous reference.
+ */
+extern struct HttpResponseBuilder *
+HttpResponseBuilder_new(const struct HttpRequest **ref)
+__attribute__((__warn_unused_result__, __nonnull__));
+
+/**
+ * Sets the http status for the response stored into this builder.
+ *
+ * @attention self must not be NULL.
+ *
+ * @return The previous http status stored into this builder.
+ */
+extern enum HttpStatus
+HttpResponseBuilder_setStatus(struct HttpResponseBuilder *self, enum HttpStatus status)
+__attribute__((__nonnull__));
+
+/**
+ * Sets the url for the response stored into this builder.
+ * 
+ * @attention self must not be NULL.
+ * @attention url must not be NULL.
+ * @attention the lifetime of url must be greater of the builder instance or the built response (if any).
+ *
+ * @return The previous url stored into this builder.
+ */
+extern Atom
+HttpResponseBuilder_setUrl(struct HttpResponseBuilder *self, Atom url)
+__attribute__((__nonnull__));
+
+/**
+ * Sets the headers for the response stored into this builder.
+ *
+ * @attention self must not be NULL.
+ * @attention the user is responsible to free the replaced headers (if any).
+ * @attention this function moves the ownership of the headers to this builder invalidating every previous reference.
+ *
+ * @return The previous headers stored into this builder.
+ */
+extern Http_MaybeText
+HttpResponseBuilder_setHeaders(struct HttpResponseBuilder *self, Text *ref)
+__attribute__((__nonnull__(1)));
+
+/**
+ * Construct in place and replace the headers for the response stored into this builder.
+ * 
+ * @attention self must not be NULL.
+ * @attention format must not be NULL.
+ * @attention the user is responsible to free the replaced headers (if any).
+ * 
+ * @return The previous headers stored into this builder.
+ */
+extern Http_MaybeText
+HttpResponseBuilder_emplaceHeaders(struct HttpResponseBuilder *self, const char *format, ...)
+__attribute__((__nonnull__(1, 2), __format__(printf, 2, 3)));
+
+/**
+ * Sets the body for the response stored into this builder.
+ *
+ * @attention self must not be NULL.
+ * @attention the user is responsible to free the replaced body (if any).
+ * @attention this function moves the ownership of the body to this builder invalidating every previous reference.
+ *
+ * @return The previous body stored into this builder.
+ */
+extern Http_MaybeText
+HttpResponseBuilder_setBody(struct HttpResponseBuilder *self, Text *ref)
+__attribute__((__nonnull__(1)));
+
+/**
+ * Construct in place and replace the body for the response stored into this builder.
+ * 
+ * @attention self must not be NULL.
+ * @attention format must not be NULL.
+ * @attention the user is responsible to free the replaced body (if any).
+ * 
+ * @return The previous body stored into this builder.
+ */
+extern Http_MaybeText
+HttpResponseBuilder_emplaceBody(struct HttpResponseBuilder *self, const char *format, ...)
+__attribute__((__nonnull__(1, 2), __format__(printf, 2, 3)));
+
+/**
+ * Constructs the http response and deletes this builder freeing memory.
+ *
+ * @attention ref must not be NULL.
+ * @attention *ref must not be NULL.
+ * @attention this functions takes the ownership of this builder invalidating every previous reference.
+ */
+extern const struct HttpResponse *
+HttpResponseBuilder_build(struct HttpResponseBuilder **ref)
+__attribute__((__warn_unused_result__, __nonnull__));
+
+/**
+ * Deletes this builder freeing memory.
+ * If self is NULL no action will be performed.
+ */
+extern void
+HttpResponseBuilder_delete(struct HttpResponseBuilder *self);
+
+#ifdef __cplusplus
+}
+#endif
diff --git a/sources/http_status.c b/sources/http_status.c
new file mode 100644
index 0000000..69c3cfe
--- /dev/null
+++ b/sources/http_status.c
@@ -0,0 +1,215 @@
+/*
+ * Author: daddinuz
+ * email:  daddinuz@gmail.com
+ *
+ * Copyright (c) 2018 Davide Di Carlo
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * 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 <http.h>
+#include <panic/panic.h>
+
+static const char HTTP_STATUS_CONTINUE_EXPLANATION[] = "Continue";
+static const char HTTP_STATUS_SWITCHING_PROTOCOLS_EXPLANATION[] = "Switching Protocols";
+static const char HTTP_STATUS_PROCESSING_EXPLANATION[] = "Processing";
+static const char HTTP_STATUS_OK_EXPLANATION[] = "OK";
+static const char HTTP_STATUS_CREATED_EXPLANATION[] = "Created";
+static const char HTTP_STATUS_ACCEPTED_EXPLANATION[] = "Accepted";
+static const char HTTP_STATUS_NON_AUTHORITATIVE_INFORMATION_EXPLANATION[] = "Non-Authoritative Information";
+static const char HTTP_STATUS_NO_CONTENT_EXPLANATION[] = "No Content";
+static const char HTTP_STATUS_RESET_CONTENT_EXPLANATION[] = "Reset Content";
+static const char HTTP_STATUS_PARTIAL_CONTENT_EXPLANATION[] = "Partial Content";
+static const char HTTP_STATUS_MULTI_STATUS_EXPLANATION[] = "Multi-Status";
+static const char HTTP_STATUS_ALREADY_REPORTED_EXPLANATION[] = "Already Reported";
+static const char HTTP_STATUS_IM_USED_EXPLANATION[] = "IM Used";
+static const char HTTP_STATUS_MULTIPLE_CHOICES_EXPLANATION[] = "Multiple Choices";
+static const char HTTP_STATUS_MOVED_PERMANENTLY_EXPLANATION[] = "Moved Permanently";
+static const char HTTP_STATUS_FOUND_EXPLANATION[] = "Found";
+static const char HTTP_STATUS_SEE_OTHER_EXPLANATION[] = "See Other";
+static const char HTTP_STATUS_NOT_MODIFIED_EXPLANATION[] = "Not Modified";
+static const char HTTP_STATUS_USE_PROXY_EXPLANATION[] = "Use Proxy";
+static const char HTTP_STATUS_TEMPORARY_REDIRECT_EXPLANATION[] = "Temporary Redirect";
+static const char HTTP_STATUS_PERMANENT_REDIRECT_EXPLANATION[] = "Permanent Redirect";
+static const char HTTP_STATUS_BAD_REQUEST_EXPLANATION[] = "Bad Request";
+static const char HTTP_STATUS_UNAUTHORIZED_EXPLANATION[] = "Unauthorized";
+static const char HTTP_STATUS_PAYMENT_REQUIRED_EXPLANATION[] = "Payment Required";
+static const char HTTP_STATUS_FORBIDDEN_EXPLANATION[] = "Forbidden";
+static const char HTTP_STATUS_NOT_FOUND_EXPLANATION[] = "Not Found";
+static const char HTTP_STATUS_METHOD_NOT_ALLOWED_EXPLANATION[] = "Method Not Allowed";
+static const char HTTP_STATUS_NOT_ACCEPTABLE_EXPLANATION[] = "Not Acceptable";
+static const char HTTP_STATUS_PROXY_AUTHENTICATION_REQUIRED_EXPLANATION[] = "Proxy Authentication Required";
+static const char HTTP_STATUS_REQUEST_TIMEOUT_EXPLANATION[] = "Request Timeout";
+static const char HTTP_STATUS_CONFLICT_EXPLANATION[] = "Conflict";
+static const char HTTP_STATUS_GONE_EXPLANATION[] = "Gone";
+static const char HTTP_STATUS_LENGTH_REQUIRED_EXPLANATION[] = "Length Required";
+static const char HTTP_STATUS_PRECONDITION_FAILED_EXPLANATION[] = "Precondition Failed";
+static const char HTTP_STATUS_PAYLOAD_TOO_LARGE_EXPLANATION[] = "Payload Too Large";
+static const char HTTP_STATUS_URI_TOO_LONG_EXPLANATION[] = "URI Too Long";
+static const char HTTP_STATUS_UNSUPPORTED_MEDIA_TYPE_EXPLANATION[] = "Unsupported Media Type";
+static const char HTTP_STATUS_RANGE_NOT_SATISFIABLE_EXPLANATION[] = "Range Not Satisfiable";
+static const char HTTP_STATUS_EXPECTATION_FAILED_EXPLANATION[] = "Expectation Failed";
+static const char HTTP_STATUS_MISDIRECTED_REQUEST_EXPLANATION[] = "Misdirected Request";
+static const char HTTP_STATUS_UNPROCESSABLE_ENTITY_EXPLANATION[] = "Unprocessable Entity";
+static const char HTTP_STATUS_LOCKED_EXPLANATION[] = "Locked";
+static const char HTTP_STATUS_FAILED_DEPENDENCY_EXPLANATION[] = "Failed Dependency";
+static const char HTTP_STATUS_UPGRADE_REQUIRED_EXPLANATION[] = "Upgrade Required";
+static const char HTTP_STATUS_PRECONDITION_REQUIRED_EXPLANATION[] = "Precondition Required";
+static const char HTTP_STATUS_TOO_MANY_REQUESTS_EXPLANATION[] = "Too Many Requests";
+static const char HTTP_STATUS_REQUEST_HEADER_FIELDS_TOO_LARGE_EXPLANATION[] = "Request Header Fields Too Large";
+static const char HTTP_STATUS_UNAVAILABLE_FOR_LEGAL_REASONS_EXPLANATION[] = "Unavailable For Legal Reasons";
+static const char HTTP_STATUS_INTERNAL_SERVER_ERROR_EXPLANATION[] = "Internal Server Error";
+static const char HTTP_STATUS_NOT_IMPLEMENTED_EXPLANATION[] = "Not Implemented";
+static const char HTTP_STATUS_BAD_GATEWAY_EXPLANATION[] = "Bad Gateway";
+static const char HTTP_STATUS_SERVICE_UNAVAILABLE_EXPLANATION[] = "Service Unavailable";
+static const char HTTP_STATUS_GATEWAY_TIMEOUT_EXPLANATION[] = "Gateway Timeout";
+static const char HTTP_STATUS_VERSION_NOT_SUPPORTED_EXPLANATION[] = "HTTP Version Not Supported";
+static const char HTTP_STATUS_VARIANT_ALSO_NEGOTIATES_EXPLANATION[] = "Variant Also Negotiates";
+static const char HTTP_STATUS_INSUFFICIENT_STORAGE_EXPLANATION[] = "Insufficient Storage";
+static const char HTTP_STATUS_LOOP_DETECTED_EXPLANATION[] = "Loop Detected";
+static const char HTTP_STATUS_NOT_EXTENDED_EXPLANATION[] = "Not Extended";
+static const char HTTP_STATUS_NETWORK_AUTHENTICATION_REQUIRED_EXPLANATION[] = "Authentication Required";
+
+const char *HttpStatus_explain(enum HttpStatus status) {
+    switch (status) {
+        case HTTP_STATUS_CONTINUE:
+            return HTTP_STATUS_CONTINUE_EXPLANATION;
+        case HTTP_STATUS_SWITCHING_PROTOCOLS:
+            return HTTP_STATUS_SWITCHING_PROTOCOLS_EXPLANATION;
+        case HTTP_STATUS_PROCESSING:
+            return HTTP_STATUS_PROCESSING_EXPLANATION;
+        case HTTP_STATUS_OK:
+            return HTTP_STATUS_OK_EXPLANATION;
+        case HTTP_STATUS_CREATED:
+            return HTTP_STATUS_CREATED_EXPLANATION;
+        case HTTP_STATUS_ACCEPTED:
+            return HTTP_STATUS_ACCEPTED_EXPLANATION;
+        case HTTP_STATUS_NON_AUTHORITATIVE_INFORMATION:
+            return HTTP_STATUS_NON_AUTHORITATIVE_INFORMATION_EXPLANATION;
+        case HTTP_STATUS_NO_CONTENT:
+            return HTTP_STATUS_NO_CONTENT_EXPLANATION;
+        case HTTP_STATUS_RESET_CONTENT:
+            return HTTP_STATUS_RESET_CONTENT_EXPLANATION;
+        case HTTP_STATUS_PARTIAL_CONTENT:
+            return HTTP_STATUS_PARTIAL_CONTENT_EXPLANATION;
+        case HTTP_STATUS_MULTI_STATUS:
+            return HTTP_STATUS_MULTI_STATUS_EXPLANATION;
+        case HTTP_STATUS_ALREADY_REPORTED:
+            return HTTP_STATUS_ALREADY_REPORTED_EXPLANATION;
+        case HTTP_STATUS_IM_USED:
+            return HTTP_STATUS_IM_USED_EXPLANATION;
+        case HTTP_STATUS_MULTIPLE_CHOICES:
+            return HTTP_STATUS_MULTIPLE_CHOICES_EXPLANATION;
+        case HTTP_STATUS_MOVED_PERMANENTLY:
+            return HTTP_STATUS_MOVED_PERMANENTLY_EXPLANATION;
+        case HTTP_STATUS_FOUND:
+            return HTTP_STATUS_FOUND_EXPLANATION;
+        case HTTP_STATUS_SEE_OTHER:
+            return HTTP_STATUS_SEE_OTHER_EXPLANATION;
+        case HTTP_STATUS_NOT_MODIFIED:
+            return HTTP_STATUS_NOT_MODIFIED_EXPLANATION;
+        case HTTP_STATUS_USE_PROXY:
+            return HTTP_STATUS_USE_PROXY_EXPLANATION;
+        case HTTP_STATUS_TEMPORARY_REDIRECT:
+            return HTTP_STATUS_TEMPORARY_REDIRECT_EXPLANATION;
+        case HTTP_STATUS_PERMANENT_REDIRECT:
+            return HTTP_STATUS_PERMANENT_REDIRECT_EXPLANATION;
+        case HTTP_STATUS_BAD_REQUEST:
+            return HTTP_STATUS_BAD_REQUEST_EXPLANATION;
+        case HTTP_STATUS_UNAUTHORIZED:
+            return HTTP_STATUS_UNAUTHORIZED_EXPLANATION;
+        case HTTP_STATUS_PAYMENT_REQUIRED:
+            return HTTP_STATUS_PAYMENT_REQUIRED_EXPLANATION;
+        case HTTP_STATUS_FORBIDDEN:
+            return HTTP_STATUS_FORBIDDEN_EXPLANATION;
+        case HTTP_STATUS_NOT_FOUND:
+            return HTTP_STATUS_NOT_FOUND_EXPLANATION;
+        case HTTP_STATUS_METHOD_NOT_ALLOWED:
+            return HTTP_STATUS_METHOD_NOT_ALLOWED_EXPLANATION;
+        case HTTP_STATUS_NOT_ACCEPTABLE:
+            return HTTP_STATUS_NOT_ACCEPTABLE_EXPLANATION;
+        case HTTP_STATUS_PROXY_AUTHENTICATION_REQUIRED:
+            return HTTP_STATUS_PROXY_AUTHENTICATION_REQUIRED_EXPLANATION;
+        case HTTP_STATUS_REQUEST_TIMEOUT:
+            return HTTP_STATUS_REQUEST_TIMEOUT_EXPLANATION;
+        case HTTP_STATUS_CONFLICT:
+            return HTTP_STATUS_CONFLICT_EXPLANATION;
+        case HTTP_STATUS_GONE:
+            return HTTP_STATUS_GONE_EXPLANATION;
+        case HTTP_STATUS_LENGTH_REQUIRED:
+            return HTTP_STATUS_LENGTH_REQUIRED_EXPLANATION;
+        case HTTP_STATUS_PRECONDITION_FAILED:
+            return HTTP_STATUS_PRECONDITION_FAILED_EXPLANATION;
+        case HTTP_STATUS_PAYLOAD_TOO_LARGE:
+            return HTTP_STATUS_PAYLOAD_TOO_LARGE_EXPLANATION;
+        case HTTP_STATUS_URI_TOO_LONG:
+            return HTTP_STATUS_URI_TOO_LONG_EXPLANATION;
+        case HTTP_STATUS_UNSUPPORTED_MEDIA_TYPE:
+            return HTTP_STATUS_UNSUPPORTED_MEDIA_TYPE_EXPLANATION;
+        case HTTP_STATUS_RANGE_NOT_SATISFIABLE:
+            return HTTP_STATUS_RANGE_NOT_SATISFIABLE_EXPLANATION;
+        case HTTP_STATUS_EXPECTATION_FAILED:
+            return HTTP_STATUS_EXPECTATION_FAILED_EXPLANATION;
+        case HTTP_STATUS_MISDIRECTED_REQUEST:
+            return HTTP_STATUS_MISDIRECTED_REQUEST_EXPLANATION;
+        case HTTP_STATUS_UNPROCESSABLE_ENTITY:
+            return HTTP_STATUS_UNPROCESSABLE_ENTITY_EXPLANATION;
+        case HTTP_STATUS_LOCKED:
+            return HTTP_STATUS_LOCKED_EXPLANATION;
+        case HTTP_STATUS_FAILED_DEPENDENCY:
+            return HTTP_STATUS_FAILED_DEPENDENCY_EXPLANATION;
+        case HTTP_STATUS_UPGRADE_REQUIRED:
+            return HTTP_STATUS_UPGRADE_REQUIRED_EXPLANATION;
+        case HTTP_STATUS_PRECONDITION_REQUIRED:
+            return HTTP_STATUS_PRECONDITION_REQUIRED_EXPLANATION;
+        case HTTP_STATUS_TOO_MANY_REQUESTS:
+            return HTTP_STATUS_TOO_MANY_REQUESTS_EXPLANATION;
+        case HTTP_STATUS_REQUEST_HEADER_FIELDS_TOO_LARGE:
+            return HTTP_STATUS_REQUEST_HEADER_FIELDS_TOO_LARGE_EXPLANATION;
+        case HTTP_STATUS_UNAVAILABLE_FOR_LEGAL_REASONS:
+            return HTTP_STATUS_UNAVAILABLE_FOR_LEGAL_REASONS_EXPLANATION;
+        case HTTP_STATUS_INTERNAL_SERVER_ERROR:
+            return HTTP_STATUS_INTERNAL_SERVER_ERROR_EXPLANATION;
+        case HTTP_STATUS_NOT_IMPLEMENTED:
+            return HTTP_STATUS_NOT_IMPLEMENTED_EXPLANATION;
+        case HTTP_STATUS_BAD_GATEWAY:
+            return HTTP_STATUS_BAD_GATEWAY_EXPLANATION;
+        case HTTP_STATUS_SERVICE_UNAVAILABLE:
+            return HTTP_STATUS_SERVICE_UNAVAILABLE_EXPLANATION;
+        case HTTP_STATUS_GATEWAY_TIMEOUT:
+            return HTTP_STATUS_GATEWAY_TIMEOUT_EXPLANATION;
+        case HTTP_STATUS_VERSION_NOT_SUPPORTED:
+            return HTTP_STATUS_VERSION_NOT_SUPPORTED_EXPLANATION;
+        case HTTP_STATUS_VARIANT_ALSO_NEGOTIATES:
+            return HTTP_STATUS_VARIANT_ALSO_NEGOTIATES_EXPLANATION;
+        case HTTP_STATUS_INSUFFICIENT_STORAGE:
+            return HTTP_STATUS_INSUFFICIENT_STORAGE_EXPLANATION;
+        case HTTP_STATUS_LOOP_DETECTED:
+            return HTTP_STATUS_LOOP_DETECTED_EXPLANATION;
+        case HTTP_STATUS_NOT_EXTENDED:
+            return HTTP_STATUS_NOT_EXTENDED_EXPLANATION;
+        case HTTP_STATUS_NETWORK_AUTHENTICATION_REQUIRED:
+            return HTTP_STATUS_NETWORK_AUTHENTICATION_REQUIRED_EXPLANATION;
+        default:
+            Panic_terminate("Unknown status: %d", status);
+    }
+}
diff --git a/sources/http_status.h b/sources/http_status.h
new file mode 100644
index 0000000..886bdee
--- /dev/null
+++ b/sources/http_status.h
@@ -0,0 +1,113 @@
+/*
+ * Author: daddinuz
+ * email:  daddinuz@gmail.com
+ *
+ * Copyright (c) 2018 Davide Di Carlo
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * 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.
+ */
+
+#pragma once
+
+#if !(defined(__GNUC__) || defined(__clang__))
+#define __attribute__(...)
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+enum HttpStatus {
+    HTTP_STATUS_CONTINUE = 100,
+    HTTP_STATUS_SWITCHING_PROTOCOLS = 101,
+    HTTP_STATUS_PROCESSING = 102,
+    HTTP_STATUS_OK = 200,
+    HTTP_STATUS_CREATED = 201,
+    HTTP_STATUS_ACCEPTED = 202,
+    HTTP_STATUS_NON_AUTHORITATIVE_INFORMATION = 203,
+    HTTP_STATUS_NO_CONTENT = 204,
+    HTTP_STATUS_RESET_CONTENT = 205,
+    HTTP_STATUS_PARTIAL_CONTENT = 206,
+    HTTP_STATUS_MULTI_STATUS = 207,
+    HTTP_STATUS_ALREADY_REPORTED = 208,
+    HTTP_STATUS_IM_USED = 226,
+    HTTP_STATUS_MULTIPLE_CHOICES = 300,
+    HTTP_STATUS_MOVED_PERMANENTLY = 301,
+    HTTP_STATUS_FOUND = 302,
+    HTTP_STATUS_SEE_OTHER = 303,
+    HTTP_STATUS_NOT_MODIFIED = 304,
+    HTTP_STATUS_USE_PROXY = 305,
+    HTTP_STATUS_TEMPORARY_REDIRECT = 307,
+    HTTP_STATUS_PERMANENT_REDIRECT = 308,
+    HTTP_STATUS_BAD_REQUEST = 400,
+    HTTP_STATUS_UNAUTHORIZED = 401,
+    HTTP_STATUS_PAYMENT_REQUIRED = 402,
+    HTTP_STATUS_FORBIDDEN = 403,
+    HTTP_STATUS_NOT_FOUND = 404,
+    HTTP_STATUS_METHOD_NOT_ALLOWED = 405,
+    HTTP_STATUS_NOT_ACCEPTABLE = 406,
+    HTTP_STATUS_PROXY_AUTHENTICATION_REQUIRED = 407,
+    HTTP_STATUS_REQUEST_TIMEOUT = 408,
+    HTTP_STATUS_CONFLICT = 409,
+    HTTP_STATUS_GONE = 410,
+    HTTP_STATUS_LENGTH_REQUIRED = 411,
+    HTTP_STATUS_PRECONDITION_FAILED = 412,
+    HTTP_STATUS_PAYLOAD_TOO_LARGE = 413,
+    HTTP_STATUS_URI_TOO_LONG = 414,
+    HTTP_STATUS_UNSUPPORTED_MEDIA_TYPE = 415,
+    HTTP_STATUS_RANGE_NOT_SATISFIABLE = 416,
+    HTTP_STATUS_EXPECTATION_FAILED = 417,
+    HTTP_STATUS_MISDIRECTED_REQUEST = 421,
+    HTTP_STATUS_UNPROCESSABLE_ENTITY = 422,
+    HTTP_STATUS_LOCKED = 423,
+    HTTP_STATUS_FAILED_DEPENDENCY = 424,
+    HTTP_STATUS_UPGRADE_REQUIRED = 426,
+    HTTP_STATUS_PRECONDITION_REQUIRED = 428,
+    HTTP_STATUS_TOO_MANY_REQUESTS = 429,
+    HTTP_STATUS_REQUEST_HEADER_FIELDS_TOO_LARGE = 431,
+    HTTP_STATUS_UNAVAILABLE_FOR_LEGAL_REASONS = 451,
+    HTTP_STATUS_INTERNAL_SERVER_ERROR = 500,
+    HTTP_STATUS_NOT_IMPLEMENTED = 501,
+    HTTP_STATUS_BAD_GATEWAY = 502,
+    HTTP_STATUS_SERVICE_UNAVAILABLE = 503,
+    HTTP_STATUS_GATEWAY_TIMEOUT = 504,
+    HTTP_STATUS_VERSION_NOT_SUPPORTED = 505,
+    HTTP_STATUS_VARIANT_ALSO_NEGOTIATES = 506,
+    HTTP_STATUS_INSUFFICIENT_STORAGE = 507,
+    HTTP_STATUS_LOOP_DETECTED = 508,
+    HTTP_STATUS_NOT_EXTENDED = 510,
+    HTTP_STATUS_NETWORK_AUTHENTICATION_REQUIRED = 511
+};
+
+/**
+ * Returns the string representation of the http status code.
+ *
+ * @param status The http status code.
+ * @return The string representation of the http status code.
+ */
+extern const char *
+HttpStatus_explain(enum HttpStatus status)
+__attribute__((__warn_unused_result__));
+
+#ifdef __cplusplus
+}
+#endif
diff --git a/src/http.c b/src/http.c
deleted file mode 100644
index 74ac343..0000000
--- a/src/http.c
+++ /dev/null
@@ -1,266 +0,0 @@
-/*
- * C Source File
- *
- * Author: Davide Di Carlo
- * Date:   May 26, 2017
- * email:  daddinuz@gmail.com
- */
-
-#include <stdlib.h>
-#include <string.h>
-#include <assert.h>
-#include <stdio.h>
-#include <errno.h>
-#include <curl/curl.h>
-#include "http.h"
-
-typedef struct {
-    size_t size;
-    char *memory;
-} buffer_t;
-
-static const char *const __HTTP_METHOD_DELETE = "DELETE";
-static const char *const __HTTP_METHOD_GET = "GET";
-static const char *const __HTTP_METHOD_HEAD = "HEAD";
-static const char *const __HTTP_METHOD_POST = "POST";
-static const char *const __HTTP_METHOD_PUT = "PUT";
-static const char *const __HTTP_METHOD_CONNECT = "CONNECT";
-static const char *const __HTTP_METHOD_OPTIONS = "OPTIONS";
-static const char *const __HTTP_METHOD_TRACE = "TRACE";
-static const char *const __HTTP_METHOD_COPY = "COPY";
-static const char *const __HTTP_METHOD_LOCK = "LOCK";
-static const char *const __HTTP_METHOD_MKCOL = "MKCOL";
-static const char *const __HTTP_METHOD_MOVE = "MOVE";
-static const char *const __HTTP_METHOD_PROPFIND = "PROPFIND";
-static const char *const __HTTP_METHOD_PROPPATCH = "PROPPATCH";
-static const char *const __HTTP_METHOD_SEARCH = "SEARCH";
-static const char *const __HTTP_METHOD_UNLOCK = "UNLOCK";
-static const char *const __HTTP_METHOD_BIND = "BIND";
-static const char *const __HTTP_METHOD_REBIND = "REBIND";
-static const char *const __HTTP_METHOD_UNBIND = "UNBIND";
-static const char *const __HTTP_METHOD_ACL = "ACL";
-static const char *const __HTTP_METHOD_REPORT = "REPORT";
-static const char *const __HTTP_METHOD_MKACTIVITY = "MKACTIVITY";
-static const char *const __HTTP_METHOD_CHECKOUT = "CHECKOUT";
-static const char *const __HTTP_METHOD_MERGE = "MERGE";
-static const char *const __HTTP_METHOD_MSEARCH = "M-SEARCH";
-static const char *const __HTTP_METHOD_NOTIFY = "NOTIFY";
-static const char *const __HTTP_METHOD_SUBSCRIBE = "SUBSCRIBE";
-static const char *const __HTTP_METHOD_UNSUBSCRIBE = "UNSUBSCRIBE";
-static const char *const __HTTP_METHOD_PATCH = "PATCH";
-static const char *const __HTTP_METHOD_PURGE = "PURGE";
-static const char *const __HTTP_METHOD_MKCALENDAR = "MKCALENDAR";
-static const char *const __HTTP_METHOD_LINK = "LINK";
-static const char *const __HTTP_METHOD_UNLINK = "UNLINK";
-
-static http_response_t *__http_response_new(
-        const http_request_t *request,
-        const char *url,
-        const char *headers,
-        const char *body,
-        const size_t headers_length,
-        const size_t body_length,
-        int status
-);
-static const char *__http_method_to_string(http_method_t method);
-static void __die(const char *file, int line, const char *message);
-static size_t __callback(void *content, size_t member_size, size_t members_count, void *user_data);
-
-http_response_t *http_perform(http_request_t *request, http_params_t *params) {
-    assert(request);
-    int status_code = 0;
-    buffer_t body_buffer = {0};
-    buffer_t headers_buffer = {0};
-    const char *effective_url = NULL;
-    struct curl_slist *headers_list = NULL;
-    CURL *handler = curl_easy_init();
-
-    /* Set request url and method */
-    curl_easy_setopt(handler, CURLOPT_URL, request->url);
-    curl_easy_setopt(handler, CURLOPT_CUSTOMREQUEST, __http_method_to_string(request->method));
-
-    /* Set request headers */
-    if (request->headers) {
-        headers_list = curl_slist_append(headers_list, request->headers);
-        curl_easy_setopt(handler, CURLOPT_HTTPHEADER, headers_list);
-    }
-
-    /* Set request body */
-    if (request->body) {
-        curl_easy_setopt(handler, CURLOPT_POSTFIELDS, request->body);
-        curl_easy_setopt(handler, CURLOPT_POSTFIELDSIZE, strlen(request->body));
-    }
-
-    /* Set request parameters */
-    if (params) {
-        curl_easy_setopt(handler, CURLOPT_FOLLOWLOCATION, !params->no_follow_location);
-        curl_easy_setopt(handler, CURLOPT_SSL_VERIFYPEER, !params->no_peer_verification);
-        curl_easy_setopt(handler, CURLOPT_SSL_VERIFYHOST, !params->no_host_verification);
-        if (params->timeout > 0) {
-            curl_easy_setopt(handler, CURLOPT_TIMEOUT, params->timeout);
-        }
-    }
-
-    /* Set request callbacks in order to store the response data */
-    curl_easy_setopt(handler, CURLOPT_HEADERFUNCTION, __callback);
-    curl_easy_setopt(handler, CURLOPT_HEADERDATA, &headers_buffer);
-    curl_easy_setopt(handler, CURLOPT_WRITEFUNCTION, __callback);
-    curl_easy_setopt(handler, CURLOPT_WRITEDATA, &body_buffer);
-
-#ifndef NDEBUG
-    /* Set verbose debug output */
-    curl_easy_setopt(handler, CURLOPT_VERBOSE, 1L);
-#endif
-
-    /* Perform the request */
-    CURLcode curl_errno = curl_easy_perform(handler);
-    if (CURLE_OK != curl_errno) {
-        __die(__FILE__, __LINE__, curl_easy_strerror(curl_errno));
-    }
-
-    /* Get response's info */
-    curl_easy_getinfo(handler, CURLINFO_RESPONSE_CODE, &status_code);
-    if (params && params->no_follow_location) {
-        effective_url = strdup(request->url);
-    } else {
-        char *tmp = NULL;
-        curl_easy_getinfo(handler, CURLINFO_EFFECTIVE_URL, &tmp);
-        effective_url = strdup(tmp);
-    }
-
-    /* Terminate */
-    curl_slist_free_all(headers_list);
-    curl_easy_cleanup(handler);
-
-    return __http_response_new(
-            request,
-            effective_url,
-            headers_buffer.memory,
-            body_buffer.memory,
-            headers_buffer.size,
-            body_buffer.size,
-            status_code
-    );
-}
-
-http_response_t *__http_response_new(
-        const http_request_t *request,
-        const char *url,
-        const char *headers,
-        const char *body,
-        const size_t headers_length,
-        const size_t body_length,
-        int status
-) {
-    struct http_response *self = malloc(sizeof(http_response_t));
-    if (NULL == self) {
-        errno = ENOMEM;
-        return NULL;
-    }
-    const http_response_t initializer = {
-            .request=request,
-            .url=url,
-            .headers=headers,
-            .body=body,
-            .headers_length=headers_length,
-            .body_length=body_length,
-            .status=status
-    };
-    memcpy(self, &initializer, sizeof(http_response_t));
-    return self;
-}
-
-const char *__http_method_to_string(http_method_t method) {
-    switch (method) {
-        case HTTP_METHOD_DELETE:
-            return __HTTP_METHOD_DELETE;
-        case HTTP_METHOD_GET:
-            return __HTTP_METHOD_GET;
-        case HTTP_METHOD_HEAD:
-            return __HTTP_METHOD_HEAD;
-        case HTTP_METHOD_POST:
-            return __HTTP_METHOD_POST;
-        case HTTP_METHOD_PUT:
-            return __HTTP_METHOD_PUT;
-        case HTTP_METHOD_CONNECT:
-            return __HTTP_METHOD_CONNECT;
-        case HTTP_METHOD_OPTIONS:
-            return __HTTP_METHOD_OPTIONS;
-        case HTTP_METHOD_TRACE:
-            return __HTTP_METHOD_TRACE;
-        case HTTP_METHOD_COPY:
-            return __HTTP_METHOD_COPY;
-        case HTTP_METHOD_LOCK:
-            return __HTTP_METHOD_LOCK;
-        case HTTP_METHOD_MKCOL:
-            return __HTTP_METHOD_MKCOL;
-        case HTTP_METHOD_MOVE:
-            return __HTTP_METHOD_MOVE;
-        case HTTP_METHOD_PROPFIND:
-            return __HTTP_METHOD_PROPFIND;
-        case HTTP_METHOD_PROPPATCH:
-            return __HTTP_METHOD_PROPPATCH;
-        case HTTP_METHOD_SEARCH:
-            return __HTTP_METHOD_SEARCH;
-        case HTTP_METHOD_UNLOCK:
-            return __HTTP_METHOD_UNLOCK;
-        case HTTP_METHOD_BIND:
-            return __HTTP_METHOD_BIND;
-        case HTTP_METHOD_REBIND:
-            return __HTTP_METHOD_REBIND;
-        case HTTP_METHOD_UNBIND:
-            return __HTTP_METHOD_UNBIND;
-        case HTTP_METHOD_ACL:
-            return __HTTP_METHOD_ACL;
-        case HTTP_METHOD_REPORT:
-            return __HTTP_METHOD_REPORT;
-        case HTTP_METHOD_MKACTIVITY:
-            return __HTTP_METHOD_MKACTIVITY;
-        case HTTP_METHOD_CHECKOUT:
-            return __HTTP_METHOD_CHECKOUT;
-        case HTTP_METHOD_MERGE:
-            return __HTTP_METHOD_MERGE;
-        case HTTP_METHOD_MSEARCH:
-            return __HTTP_METHOD_MSEARCH;
-        case HTTP_METHOD_NOTIFY:
-            return __HTTP_METHOD_NOTIFY;
-        case HTTP_METHOD_SUBSCRIBE:
-            return __HTTP_METHOD_SUBSCRIBE;
-        case HTTP_METHOD_UNSUBSCRIBE:
-            return __HTTP_METHOD_UNSUBSCRIBE;
-        case HTTP_METHOD_PATCH:
-            return __HTTP_METHOD_PATCH;
-        case HTTP_METHOD_PURGE:
-            return __HTTP_METHOD_PURGE;
-        case HTTP_METHOD_MKCALENDAR:
-            return __HTTP_METHOD_MKCALENDAR;
-        case HTTP_METHOD_LINK:
-            return __HTTP_METHOD_LINK;
-        case HTTP_METHOD_UNLINK:
-            return __HTTP_METHOD_UNLINK;
-        default:
-            __die(__FILE__, __LINE__, "Unknown HTTP method");
-            return NULL;
-    }
-}
-
-void __die(const char *file, int line, const char *message) {
-    fprintf(stderr, "\nAt: %s:%d\nError: %s\n", file, line, message);
-    abort();
-}
-
-size_t __callback(void *content, size_t member_size, size_t members_count, void *user_data) {
-    buffer_t *const buffer = user_data;
-    const size_t real_size = member_size * members_count;
-
-    buffer->memory = realloc(buffer->memory, buffer->size + real_size + 1);
-    if (NULL == buffer->memory) {
-        __die(__FILE__, __LINE__, strerror(errno));
-    }
-
-    memcpy(&(buffer->memory[buffer->size]), content, real_size);
-    buffer->size += real_size;
-    buffer->memory[buffer->size] = 0;
-
-    return real_size;
-}
diff --git a/src/http_request.c b/src/http_request.c
deleted file mode 100644
index 4013e64..0000000
--- a/src/http_request.c
+++ /dev/null
@@ -1,38 +0,0 @@
-/*
- * C Source File
- *
- * Author: Davide Di Carlo
- * Date:   May 26, 2017 
- * email:  daddinuz@gmail.com
- */
-
-#include <stdlib.h>
-#include <string.h>
-#include <errno.h>
-#include "http_method.h"
-#include "http_request.h"
-
-http_request_t *http_request_new(
-        const http_method_t method,
-        const char *const url,
-        const char *const headers,
-        const char *const body
-) {
-    struct http_request *self = malloc(sizeof(http_request_t));
-    if (NULL == self) {
-        errno = ENOMEM;
-        return NULL;
-    }
-    const http_request_t initializer = {
-            .method=method,
-            .url=url,
-            .headers=headers,
-            .body=body
-    };
-    memcpy(self, &initializer, sizeof(http_request_t));
-    return self;
-}
-
-void http_request_delete(http_request_t *self) {
-    free((void *) self);
-}
diff --git a/src/http_response.c b/src/http_response.c
deleted file mode 100644
index 89167fa..0000000
--- a/src/http_response.c
+++ /dev/null
@@ -1,19 +0,0 @@
-/*
- * C Source File
- *
- * Author: Davide Di Carlo
- * Date:   May 26, 2017
- * email:  daddinuz@gmail.com
- */
-
-#include <stdlib.h>
-#include "http_response.h"
-
-void http_response_delete(http_response_t *self) {
-    if (self) {
-        free((void *) self->url);
-        free((void *) self->headers);
-        free((void *) self->body);
-        free((void *) self);
-    }
-}
diff --git a/tests/unit/build.cmake b/tests/unit/build.cmake
new file mode 100644
index 0000000..07aea2c
--- /dev/null
+++ b/tests/unit/build.cmake
@@ -0,0 +1,14 @@
+add_library(feature-http-fire-result ${CMAKE_CURRENT_LIST_DIR}/features/http_fire_result.h ${CMAKE_CURRENT_LIST_DIR}/features/http_fire_result.c)
+target_link_libraries(feature-http-fire-result PRIVATE http traits-unit)
+
+add_library(feature-http-maybe-text ${CMAKE_CURRENT_LIST_DIR}/features/http_maybe_text.h ${CMAKE_CURRENT_LIST_DIR}/features/http_maybe_text.c)
+target_link_libraries(feature-http-maybe-text PRIVATE http traits-unit)
+
+add_library(fixtures ${CMAKE_CURRENT_LIST_DIR}/fixtures.h ${CMAKE_CURRENT_LIST_DIR}/fixtures.c)
+target_link_libraries(fixtures PRIVATE http traits-unit)
+
+add_executable(describe ${CMAKE_CURRENT_LIST_DIR}/describe.c)
+target_link_libraries(describe PRIVATE traits-unit fixtures feature-http-fire-result feature-http-maybe-text)
+
+add_test(describe describe)
+enable_testing()
diff --git a/tests/unit/describe.c b/tests/unit/describe.c
new file mode 100644
index 0000000..f6e827c
--- /dev/null
+++ b/tests/unit/describe.c
@@ -0,0 +1,40 @@
+/*
+ * Author: daddinuz
+ * email:  daddinuz@gmail.com
+ *
+ * Copyright (c) 2018 Davide Di Carlo
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * 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 <traits-unit/traits-unit.h>
+#include <unit/fixtures.h>
+#include <unit/features/http_fire_result.h>
+#include <unit/features/http_maybe_text.h>
+
+Describe("Http",
+         Trait("Http_FireResult",
+               Run(Http_FireResult_ok, RequestFixture),
+               Run(Http_FireResult_error)),
+         Trait("Http_MaybeText",
+               Run(Http_MaybeText_new)),
+)
diff --git a/tests/unit/features/http_fire_result.c b/tests/unit/features/http_fire_result.c
new file mode 100644
index 0000000..889e367
--- /dev/null
+++ b/tests/unit/features/http_fire_result.c
@@ -0,0 +1,98 @@
+/*
+ * Author: daddinuz
+ * email:  daddinuz@gmail.com
+ *
+ * Copyright (c) 2018 Davide Di Carlo
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * 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 <http.h>
+#include <traits/traits.h>
+#include <unit/features/http_fire_result.h>
+
+Feature(Http_FireResult_ok) {
+    const struct HttpRequest *request = traits_unit_get_context();
+    const struct HttpResponse *response = NULL;
+
+    {
+        const size_t counter = traits_unit_get_wrapped_signals_counter();
+
+        traits_unit_wraps(SIGABRT) {
+            Http_FireResult sut = Http_FireResult_ok(response);
+            (void) sut;
+        }
+
+        assert_equal(counter + 1, traits_unit_get_wrapped_signals_counter());
+    }
+
+    struct HttpResponseBuilder *responseBuilder = HttpResponseBuilder_new(&request);
+    response = HttpResponseBuilder_build(&responseBuilder);
+
+    Http_FireResult sut = Http_FireResult_ok(response);
+    assert_true(Http_FireResult_isOk(sut));
+    assert_false(Http_FireResult_isError(sut));
+    assert_equal(Http_FireResult_unwrap(sut), response);
+
+    {
+        const size_t counter = traits_unit_get_wrapped_signals_counter();
+
+        traits_unit_wraps(SIGABRT) {
+            Error error = Http_FireResult_unwrapError(sut);
+            (void) error;
+        }
+
+        assert_equal(counter + 1, traits_unit_get_wrapped_signals_counter());
+    }
+}
+
+Feature(Http_FireResult_error) {
+    volatile Error error = NULL;
+
+    {
+        const size_t counter = traits_unit_get_wrapped_signals_counter();
+
+        traits_unit_wraps(SIGABRT) {
+            Http_FireResult sut = Http_FireResult_error(error);
+            (void) sut;
+        }
+
+        assert_equal(counter + 1, traits_unit_get_wrapped_signals_counter());
+    }
+
+    error = HttpError_NetworkingError;
+    Http_FireResult sut = Http_FireResult_error(error);
+    assert_false(Http_FireResult_isOk(sut));
+    assert_true(Http_FireResult_isError(sut));
+    assert_equal(Http_FireResult_unwrapError(sut), error);
+
+    {
+        const size_t counter = traits_unit_get_wrapped_signals_counter();
+
+        traits_unit_wraps(SIGABRT) {
+            const struct HttpResponse *response = Http_FireResult_unwrap(sut);
+            (void) response;
+        }
+
+        assert_equal(counter + 1, traits_unit_get_wrapped_signals_counter());
+    }
+}
diff --git a/tests/unit/features/http_fire_result.h b/tests/unit/features/http_fire_result.h
new file mode 100644
index 0000000..61be636
--- /dev/null
+++ b/tests/unit/features/http_fire_result.h
@@ -0,0 +1,42 @@
+/*
+ * Author: daddinuz
+ * email:  daddinuz@gmail.com
+ *
+ * Copyright (c) 2018 Davide Di Carlo
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * 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.
+ */
+
+#pragma once
+
+#include <traits-unit/traits-unit.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+Feature(Http_FireResult_ok);
+Feature(Http_FireResult_error);
+
+#ifdef __cplusplus
+}
+#endif
diff --git a/tests/unit/features/http_maybe_text.c b/tests/unit/features/http_maybe_text.c
new file mode 100644
index 0000000..4e462da
--- /dev/null
+++ b/tests/unit/features/http_maybe_text.c
@@ -0,0 +1,48 @@
+/*
+ * Author: daddinuz
+ * email:  daddinuz@gmail.com
+ *
+ * Copyright (c) 2018 Davide Di Carlo
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * 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 <http.h>
+#include <traits/traits.h>
+#include <unit/features/http_maybe_text.h>
+
+Feature(Http_MaybeText_new) {
+    {
+        Text text = NULL;
+        Http_MaybeText maybeText = Http_MaybeText_new(text);
+        const size_t counter = traits_unit_get_wrapped_signals_counter();
+
+        assert_false(Http_MaybeText_isPresent(maybeText));
+
+        traits_unit_wraps(SIGABRT) {
+            text = Http_MaybeText_unwrap(maybeText);
+            (void) text;
+        }
+
+        assert_equal(counter + 1, traits_unit_get_wrapped_signals_counter());
+    }
+}
diff --git a/tests/unit/features/http_maybe_text.h b/tests/unit/features/http_maybe_text.h
new file mode 100644
index 0000000..87c2050
--- /dev/null
+++ b/tests/unit/features/http_maybe_text.h
@@ -0,0 +1,41 @@
+/*
+ * Author: daddinuz
+ * email:  daddinuz@gmail.com
+ *
+ * Copyright (c) 2018 Davide Di Carlo
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * 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.
+ */
+
+#pragma once
+
+#include <traits-unit/traits-unit.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+Feature(Http_MaybeText_new);
+
+#ifdef __cplusplus
+}
+#endif
diff --git a/tests/unit/fixtures.c b/tests/unit/fixtures.c
new file mode 100644
index 0000000..f7351dd
--- /dev/null
+++ b/tests/unit/fixtures.c
@@ -0,0 +1,42 @@
+/*
+ * Author: daddinuz
+ * email:  daddinuz@gmail.com
+ *
+ * Copyright (c) 2018 Davide Di Carlo
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * 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 <http.h>
+#include <unit/fixtures.h>
+
+Setup(RequestSetup) {
+    struct HttpRequestBuilder *requestBuilder = HttpRequestBuilder_new(HTTP_METHOD_GET,
+                                                                       Atom_fromLiteral("http://google.com"));
+    return (void *) HttpRequestBuilder_build(&requestBuilder);
+}
+
+Teardown(RequestTeardown) {
+    HttpRequest_delete(traits_unit_get_context());
+}
+
+FixtureImplements(RequestFixture, RequestSetup, RequestTeardown);
diff --git a/tests/unit/fixtures.h b/tests/unit/fixtures.h
new file mode 100644
index 0000000..c956418
--- /dev/null
+++ b/tests/unit/fixtures.h
@@ -0,0 +1,41 @@
+/*
+ * Author: daddinuz
+ * email:  daddinuz@gmail.com
+ *
+ * Copyright (c) 2018 Davide Di Carlo
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * 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.
+ */
+
+#pragma once
+
+#include <traits-unit/traits-unit.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+Fixture(RequestFixture);
+
+#ifdef __cplusplus
+}
+#endif
diff --git a/valgrind.sh b/valgrind.sh
new file mode 100755
index 0000000..72bea39
--- /dev/null
+++ b/valgrind.sh
@@ -0,0 +1,4 @@
+#!/usr/bin/env  bash
+
+set -e
+valgrind --trace-children=yes --track-origins=yes --leak-check=full --show-leak-kinds=all --log-file=valgrind.log "${@}"