Merge lp:unity-scopes-api/staging into lp:unity-scopes-api

[Marcus Tomlinson]

* Got rid of category header background, as per design (Bug #1446216).
* Re-enabled license/copyright test for xenial+.
* Removed libjson-cpp and replaced with json-glib based implementation (Bug #1360247).
* Fixed Yakkety build.

[lp:unity-scopes-api/staging]

319. By Marcus Tomlinson on 2016-05-23

Sync changelog

320. By Marcus Tomlinson on 2016-05-23

Update changelog and RELEASE_NOTES.md

321. By Marcus Tomlinson on 2016-05-23

Bump version

322. By Marcus Tomlinson on 2016-05-30

Merge devel

323. By Marcus Tomlinson on 2016-05-30

Merged devel

324. By Paweł Stołowski on 2016-06-17

Merged devel changes

[Robert Bruce Park (robru)]

Changelog nitpick inline.

=== modified file 'CMakeLists.txt'
--- CMakeLists.txt	2016-03-31 23:48:56 +0000
+++ CMakeLists.txt	2016-06-17 07:24:44 +0000
@@ -66,11 +66,11 @@
 pkg_check_modules(APPARMOR REQUIRED libapparmor REQUIRED)
 pkg_check_modules(LTTNG_UST lttng-ust REQUIRED)
 pkg_check_modules(LIBURCU_BP liburcu-bp REQUIRED)
-pkg_check_modules(JSONCPP jsoncpp REQUIRED)
 pkg_check_modules(LIBACCOUNTS libaccounts-glib REQUIRED)
 pkg_check_modules(LIBSIGNON libsignon-glib REQUIRED)
 pkg_check_modules(ZMQLIB libzmq REQUIRED)
 pkg_check_modules(NET_CPP net-cpp>=1.2.0 REQUIRED)
+pkg_check_modules(JSON_GLIB json-glib-1.0 REQUIRED)
 
 find_library(ZMQPPLIB zmqpp)
 if(NOT ZMQPPLIB)
@@ -140,10 +140,10 @@
 )
 
 set(OTHER_INCLUDE_DIRS ${OTHER_INCLUDE_DIRS} ${UNITY_API_INCLUDE_DIRS} ${Boost_INCLUDE_DIRS}
-                       ${JSONCPP_INCLUDE_DIRS} ${PROCESS_CPP_INCLUDE_DIRS} ${APPARMOR_INCLUDE_DIRS}
+                       ${JSON_GLIB_INCLUDE_DIRS} ${PROCESS_CPP_INCLUDE_DIRS} ${APPARMOR_INCLUDE_DIRS}
                        ${LIBACCOUNTS_INCLUDE_DIRS} ${LIBSIGNON_INCLUDE_DIRS} ${NET_CPP_INCLUDE_DIRS})
 set(OTHER_LIBS ${OTHER_LIBS} ${UNITY_API_LDFLAGS} ${APPARMOR_LDFLAGS} ${LIBACCOUNTS_LIBRARIES}
-               ${LIBSIGNON_LIBRARIES} ${Boost_LIBRARIES} ${JSONCPP_LDFLAGS} ${PROCESS_CPP_LDFLAGS}
+               ${LIBSIGNON_LIBRARIES} ${Boost_LIBRARIES} ${JSON_GLIB_LDFLAGS} ${PROCESS_CPP_LDFLAGS}
                ${ZMQPPLIB} ${ZMQLIB_LDFLAGS} ${CAPNPLIB} ${KJLIB} ${DLLIB} ${NET_CPP_LDFLAGS} pthread)
 
 # Standard install paths
 
=== modified file 'RELEASE_NOTES.md'
--- RELEASE_NOTES.md	2016-04-11 07:58:52 +0000
+++ RELEASE_NOTES.md	2016-06-17 07:24:44 +0000
@@ -1,6 +1,13 @@
 Release notes
 =============
 
+Changes in version 1.0.6
+========================
+  - Got rid of category header background, as per design (Bug #1446216).
+  - Re-enabled license/copyright test for xenial+.
+  - Removed libjson-cpp and replaced with json-glib based implementation (Bug #1360247).
+  - Fixed Yakkety build.
+
 Changes in version 1.0.5
 ========================
   - Simplify debian/control munging.
 
=== modified file 'debian/VERSION'
--- debian/VERSION	2016-03-31 23:48:56 +0000
+++ debian/VERSION	2016-06-17 07:24:44 +0000
@@ -1,1 +1,1 @@
-1.0.5
+1.0.6
 
=== modified file 'debian/changelog'
--- debian/changelog	2016-04-13 09:51:48 +0000
+++ debian/changelog	2016-06-17 07:24:44 +0000
@@ -1,3 +1,25 @@
+unity-scopes-api (1.0.6+16.10.20160520.3-0ubuntu2) UNRELEASED; urgency=medium
+
+  * Got rid of category header background, as per design (Bug #1446216).
+  * Re-enabled license/copyright test for xenial+.
+  * Removed libjson-cpp and replaced with json-glib based implementation (Bug #1360247).
+  * Fixed Yakkety build.
+
+ -- Marcus Tomlinson <marcustomlinson@ubuntu>  Mon, 23 May 2016 09:54:28 +0200
+
+unity-scopes-api (1.0.6+16.10.20160520.3-0ubuntu1) yakkety; urgency=medium
+
+  [ CI Train Bot ]
+  * No-change rebuild.
+
+ -- Marcus Tomlinson <[e-mail]>  Fri, 20 May 2016 14:55:39 +0000
+
+unity-scopes-api (1.0.5+16.04.20160413.1-0ubuntu2) yakkety; urgency=medium
+
+  * No-change rebuild of latest xenial trunk against current archive.
+
+ -- Łukasz 'sil2100' Zemczak <[e-mail]>  Thu, 19 May 2016 19:19:30 +0200
+
 unity-scopes-api (1.0.5+16.04.20160413.1-0ubuntu1) xenial; urgency=medium
 
   [ Marcus Tomlinson ]
 
=== modified file 'debian/control.in'
--- debian/control.in	2016-03-16 12:35:22 +0000
+++ debian/control.in	2016-06-17 07:24:44 +0000
@@ -21,7 +21,7 @@
                libboost-thread-dev,
                libcapnp-dev (>= 0.4.0),
                libdbustest1-dev,
-               libjsoncpp-dev,
+               libjson-glib-dev,
                liblttng-ust-dev,
                libnet-cpp-dev (>= 1.2.0),
                libprocess-cpp-dev (>= 1.0.1),
 
=== modified file 'doc/tutorial.dox'
--- doc/tutorial.dox	2016-03-16 12:35:22 +0000
+++ doc/tutorial.dox	2016-06-17 07:24:44 +0000
@@ -636,6 +636,102 @@
 call to your `activate()` method. Your implementation of `activate()` should follow the same guidelines as for
 `perform_action()` (except that widget and action identifiers do not apply to result activation).
 
+\paragraph resultaction Handling result action activation
+
+Search results can embed simple action buttons (icons) in their cards. When the user taps an action icon, the scope gets notified and can update
+the affected result card to reflect the new state. A typical use case for this is to offer "social" actions, such as thumbs up/down buttons.
+
+The following snippet demonstrates how two actions can be added to a \link unity::scopes::CategorisedResult CategorisedResult\endlink:
+
+\code
+CategorisedResult res(cat);
+res.set_uri("myuri");
+res.set_title("My Title");
+
+// Add result actions
+VariantBuilder builder;
+builder.add_tuple({
+        {"id", Variant("thumbsup")},
+        {"icon", Variant("thOff")},
+        {"temporaryIcon", Variant("thOn")},
+        {"label", Variant("I like it")},
+});
+builder.add_tuple({
+        {"id", Variant("flag")},
+        {"icon", Variant("flag")},
+        {"temporaryIcon", Variant("flagOn")},
+        {"label", Variant("Flag this result")},
+});
+res["social-actions"] = builder.end();
+\endcode
+
+The attributes of result actions are as follows:
+<ul>
+<li>id - unique action identifier that will be reported to the scope.
+<li>icon - the icon for the action button.
+<li>temporaryIcon (optional) - defines an icon that will be shown immediately when the user taps the button, before the scope reacts to the action.
+<li>label - the text shown next to the icon.
+</ul>
+
+To respond to activation of result actions, your scope must implement
+\link unity::scopes::ScopeBase::activate_result_action ScopeBase::activate_result_action\endlink:
+
+\code{.cpp}
+class MyScope : public ScopeBase
+{
+    ...
+    ActivationQueryBase::UPtr activate_result_action(Result const& result,
+            ActionMetadata const& metadata,
+            std::string const& action_id) override;
+    ...
+}
+\endcode
+
+Like `search()` and `preview()`, `activate_result_action()` is a factory method. It must return an
+instance that derives from \link unity::scopes::ActivationQueryBase ActivationQueryBase\endlink.
+Your derived class must implement the \link unity::scopes::ActivationQueryBase::activate activate()\endlink method,
+whose job it is to respond to the activation (that is, the user pressing action button). `activate` must return
+an \link unity::scopes::ActivationResponse ActivationResponse\endlink, which tells the UI how it should
+behave in response to the result action activation. For result actions the typical and recommended behavior is to update the card
+for the result whose action was activated.
+
+For example, here is how to update the actions of an affected card in response to a "thumbsup" action, so that tapping the "thumbsup" action button replaces that
+button with "thumbsdown":
+
+\code{.cpp}
+class MyActivation : public ActivationQueryBase
+{
+    MyActivation(Result const& result, unity::scopes::ActionMetadata const& metadata, std::string const& action_id) :
+        ActivationQueryBase(result, metadata, action_id)
+    {
+    }
+
+    virtual ActivationResponse activate() override
+    {
+        if (action_id() == "thumbsup")
+        {
+            // ... update backend data for 'thumbs up' action ...
+
+            // get the affect result and update it
+            Result updatedRes(result());
+            VariantBuilder builder;
+            builder.add_tuple({
+                    {"id", Variant("thumbsdown")},
+                    {"icon", Variant("thOn")},
+                    {"temporaryIcon", Variant("thOff")},
+                    {"label", Variant("I don't like it")},
+            });
+            builder.add_tuple({ ... })
+            updatedRes["social-actions"] = builder.end();
+            return ActivationResponse(updatedRes);
+        }
+
+        if (action_id() == "thumbsdown")
+        ...
+    }
+};
+\endcode
+
 \paragraph export Exporting a scope
 
 Your scope must be compiled into a `.so` shared library and, to be successfully
@@ -1430,7 +1526,6 @@
     ForegroundColor = default text color (defaults to theme-provided foreground color)
     BackgroundColor = color of scope background (default is transparent)
     ShapeImages = whether to use Ubuntu-shape for all cards and artwork (defaults to true)
-    CategoryHeaderBackground = background scheme of the results categories
     PreviewButtonColor = color of preview buttons (defaults to theme-provided color)
     LogoOverlayColor = color for the overlay in scopes overview (defaults to semi-transparent black)
     PageHeader.Logo = image containing scope's logo
 
=== modified file 'include/unity/scopes/internal/JsonCppNode.h'
--- include/unity/scopes/internal/JsonCppNode.h	2014-11-03 05:31:30 +0000
+++ include/unity/scopes/internal/JsonCppNode.h	2016-06-17 07:24:44 +0000
@@ -19,9 +19,15 @@
 #pragma once
 
 #include <unity/scopes/internal/JsonNodeInterface.h>
-#include <jsoncpp/json/value.h>
+
+#include <unity/scopes/internal/gobj_memory.h>
 #include <unity/scopes/Variant.h>
 
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wold-style-cast"
+#include <json-glib/json-glib.h>
+#pragma GCC diagnostic pop
+
 namespace unity
 {
 
@@ -34,10 +40,11 @@
 class JsonCppNode : public JsonNodeInterface
 {
 public:
-    explicit JsonCppNode(std::string const& json_string = "");
-    explicit JsonCppNode(const Json::Value& root);
-    explicit JsonCppNode(const Variant& var);
-    ~JsonCppNode();
+    JsonCppNode();
+    JsonCppNode(std::string const& json_string);
+    explicit JsonCppNode(JsonNode* root);
+    explicit JsonCppNode(Variant const& var);
+    ~JsonCppNode() = default;
 
     void clear() override;
     void read_json(std::string const& json_string) override;
@@ -49,8 +56,7 @@
     NodeType type() const override;
 
     std::string as_string() const override;
-    int as_int() const override;
-    unsigned int as_uint() const override;
+    int64_t as_int() const override;
     double as_double() const override;
     bool as_bool() const override;
 
@@ -61,9 +67,10 @@
     JsonNodeInterface::SPtr get_node(unsigned int node_index) const override;
 
 private:
-    static Json::Value from_variant(Variant const& var);
-    static Variant to_variant(Json::Value const &val);
-    Json::Value root_;
+    void init_from_string(std::string const& jscon_string);
+
+    typedef std::unique_ptr<JsonNode, decltype(&json_node_free)> NodePtr;
+    NodePtr root_;
 };
 
 } // namespace internal
 
=== modified file 'include/unity/scopes/internal/JsonNodeInterface.h'
--- include/unity/scopes/internal/JsonNodeInterface.h	2014-11-03 05:31:30 +0000
+++ include/unity/scopes/internal/JsonNodeInterface.h	2016-06-17 07:24:44 +0000
@@ -42,7 +42,7 @@
 
     enum NodeType
     {
-        Null, Array, Object, String, Int, UInt, Real, Bool
+        Null, Array, Object, String, Int, Real, Bool
     };
 
     JsonNodeInterface() = default;
@@ -58,8 +58,7 @@
     virtual NodeType type() const = 0;
 
     virtual std::string as_string() const = 0;
-    virtual int as_int() const = 0;
-    virtual unsigned int as_uint() const = 0;
+    virtual int64_t as_int() const = 0;
     virtual double as_double() const = 0;
     virtual bool as_bool() const = 0;
 
 
=== modified file 'include/unity/scopes/internal/JsonSettingsSchema.h'
--- include/unity/scopes/internal/JsonSettingsSchema.h	2014-11-03 05:31:30 +0000
+++ include/unity/scopes/internal/JsonSettingsSchema.h	2016-06-17 07:24:44 +0000
@@ -49,7 +49,7 @@
     void add_location_setting() override;
 
 private:
-    JsonSettingsSchema(std::string const& ini_file);
+    JsonSettingsSchema(std::string const& json_string);
 
     JsonSettingsSchema();
 
 
=== added file 'include/unity/scopes/internal/gobj_memory.h'
--- include/unity/scopes/internal/gobj_memory.h	1970-01-01 00:00:00 +0000
+++ include/unity/scopes/internal/gobj_memory.h	2016-06-17 07:24:44 +0000
@@ -0,0 +1,212 @@
+/*
+ * Copyright (C) 2013 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Jussi Pakkanen <[e-mail]>
+ */
+
+#pragma once
+
+#include <stdexcept>
+
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wold-style-cast"
+#pragma GCC diagnostic ignored "-Wcast-qual"
+#include <glib-object.h>
+
+namespace unity
+{
+
+namespace scopes
+{
+
+namespace internal
+{
+
+/**
+ * This class is meant for automatically managing the lifetime of C objects derived
+ * from gobject. Its API perfectly mirrors the API of unique_ptr except that you
+ * can't define your own deleter function as it is always g_object_unref.
+ *
+ * API/ABI stability is not guaranteed. If you need to pass the object across an ABI
+ * boundary, pass the plain gobject.
+ *
+ * This is how you would use gobj_ptr 99% of the time:
+ *
+ * gobj_ptr<GSomeType> o(g_some_type_new(...));
+ *
+ * More specifically, the object will decrement the gobject reference count
+ * of the object it points to when it goes out of scope. It will never increment it.
+ * Thus you should only assign to it when already holding a reference. gobj_ptr
+ * will then take ownership of that particular reference.
+ *
+ * Floating gobjects can not be put in this container as they are meant to be put
+ * into native gobject aware containers immediately upon construction. Trying to insert
+ * a floating gobject into a gobj_ptr will throw an invalid_argument exception. To
+ * prevent accidental memory leaks, the floating gobject is unreffed in this case.
+ */
+template <typename T>
+class gobj_ptr final
+{
+private:
+    T* u;
+
+    void validate_float(T* t)
+    {
+        if (t != nullptr && g_object_is_floating(G_OBJECT(t)))
+        {
+            // LCOV_EXCL_START  // False negative from gcovr.
+            throw std::invalid_argument("Tried to add a floating gobject into a gobj_ptr.");
+            // LCOV_EXCL_STOP
+        }
+    }
+
+public:
+    typedef T element_type;
+    typedef T* pointer;
+    typedef decltype(g_object_unref) deleter_type;
+
+    constexpr gobj_ptr() noexcept : u(nullptr)
+    {
+    }
+    explicit gobj_ptr(T* t)
+        : u(t)
+    {
+        // What should we do if validate throws? Unreffing unknown objs
+        // is dodgy but not unreffing runs the risk of
+        // memory leaks. Currently unrefs as u is destroyed
+        // when this exception is thrown.
+        validate_float(t);
+    }
+    constexpr gobj_ptr(std::nullptr_t) noexcept : u(nullptr){};
+    gobj_ptr(gobj_ptr&& o) noexcept
+    {
+        u = o.u;
+        o.u = nullptr;
+    }
+    gobj_ptr(const gobj_ptr& o)
+        : u(nullptr)
+    {
+        *this = o;
+    }
+    gobj_ptr& operator=(const gobj_ptr& o)
+    {
+        if (o.u != nullptr)
+        {
+            g_object_ref(o.u);
+        }
+        reset(o.u);
+        return *this;
+    }
+    ~gobj_ptr()
+    {
+        reset();
+    }
+
+    deleter_type& get_deleter() noexcept
+    {
+        return g_object_unref;
+    }
+    deleter_type& get_deleter() const noexcept
+    {
+        return g_object_unref;
+    }
+
+    void swap(gobj_ptr<T>& o) noexcept
+    {
+        T* tmp = u;
+        u = o.u;
+        o.u = tmp;
+    }
+    void reset(pointer p = pointer())
+    {
+        if (u != nullptr)
+        {
+            g_object_unref(G_OBJECT(u));
+            u = nullptr;
+        }
+        // Same throw dilemma as in pointer constructor.
+        u = p;
+        validate_float(p);
+    }
+
+    T* release() noexcept
+    {
+        T* r = u;
+        u = nullptr;
+        return r;
+    }
+    T* get() const noexcept
+    {
+        return u;
+    }
+
+    T& operator*() const
+    {
+        return *u;
+    }
+    T* operator->() const noexcept
+    {
+        return u;
+    }
+    explicit operator bool() const noexcept
+    {
+        return u != nullptr;
+    }
+
+    gobj_ptr& operator=(gobj_ptr&& o) noexcept
+    {
+        reset();
+        u = o.u;
+        o.u = nullptr;
+        return *this;
+    }
+    gobj_ptr& operator=(std::nullptr_t) noexcept
+    {
+        reset();
+        return *this;
+    }
+    bool operator==(const gobj_ptr<T>& o) const noexcept
+    {
+        return u == o.u;
+    }
+    bool operator!=(const gobj_ptr<T>& o) const noexcept
+    {
+        return u != o.u;
+    }
+    bool operator<(const gobj_ptr<T>& o) const noexcept
+    {
+        return u < o.u;
+    }
+    bool operator<=(const gobj_ptr<T>& o) const noexcept
+    {
+        return u <= o.u;
+    }
+    bool operator>(const gobj_ptr<T>& o) const noexcept
+    {
+        return u > o.u;
+    }
+    bool operator>=(const gobj_ptr<T>& o) const noexcept
+    {
+        return u >= o.u;
+    }
+};
+
+}  // namespace internal
+
+}  // namespace scopes
+
+}  // namespace unity
+
+#pragma GCC diagnostic pop
 
=== modified file 'scoperegistry/scoperegistry.cpp'
--- scoperegistry/scoperegistry.cpp	2015-09-11 07:29:12 +0000
+++ scoperegistry/scoperegistry.cpp	2016-06-17 07:24:44 +0000
@@ -338,7 +338,6 @@
         convert_relative_attribute(inner_map, "navigation-background", scope_dir);
         app_attrs["page-header"] = Variant(inner_map);
     }
-    convert_relative_attribute(app_attrs, "category-header-background", scope_dir);
     mi->set_appearance_attributes(app_attrs);
 
     mi->set_scope_directory(scope_dir.native());
 
=== modified file 'src/scopes/CategoryRenderer.cpp'
--- src/scopes/CategoryRenderer.cpp	2016-03-08 10:09:42 +0000
+++ src/scopes/CategoryRenderer.cpp	2016-06-17 07:24:44 +0000
@@ -66,7 +66,7 @@
 \arg \c card-layout Specifies layout of the individual result cards; possible values: \c "vertical" (default), \c "horizontal"
 \arg \c card-size Size of the result cards; possible values: \c "small", \c "medium" (default), \c "large"; when using <tt>"category-layout": "vertical-journal"</tt> any integer between 12 and 38
 \arg \c overlay Overlay text data on top of the art; boolean, default false
-\arg \c collapsed-rows Number of result rows displayed while the category is collapsed; possible values: any non-negative integer, where 0 fully expands the category (only affects grid and vertical journal)
+\arg \c collapsed-rows Number of result rows displayed while the category is collapsed; possible values: any non-negative integer, where 0 fully expands the category (only affects grid)
 \arg \c card-background Background color for the cards; string; URI in the format \verbatim color:///#rrggbb \endverbatim or \verbatim color:///color_name
 \endverbatim or \verbatim gradient:///#rrggbb/#rrggbb \endverbatim or an image URI (will be stretched)
 \arg \c quick-preview-type The type of media content represented by result cards, for use with inline playback; the only currently supported type is "audio".
 
=== modified file 'src/scopes/PreviewWidget.cpp'
--- src/scopes/PreviewWidget.cpp	2016-01-18 19:50:19 +0000
+++ src/scopes/PreviewWidget.cpp	2016-06-17 07:24:44 +0000
@@ -431,15 +431,18 @@
 \subsection expandable expandable widget
 
 The expandable widget is used to group several widgets into an expandable pane.
+The expandable widget can be collapsed or uncollapsed. When it's uncollapsed then
+all the contained widgets are shown. When collapsed, only the first few widgets determined
+by collapsed-widgets attribute are shown.
 
 List of attributes:
 \arg \c title A string specifying the title
-\arg \c collapsed-widgets Optional number of collapsed widgets (0 makes all of them visible)
+\arg \c collapsed-widgets A number of widgets to show when the expandable widget is collapsed (optional).
 
 \code
     PreviewWidget expandable("exp", "expandable");
     expandable.add_attribute_value("title", Variant("This is an expandable widget"));
-    expandable.add_attribute_value("collapsed-widgets", Variant(0));
+    expandable.add_attribute_value("collapsed-widgets", Variant(2));
 
     PreviewWidget w1("w1", "text");
     w1.add_attribute_value("title", Variant("Subwidget 1"));
@@ -447,8 +450,12 @@
     PreviewWidget w2("w2", "text");
     w2.add_attribute_value("title", Variant("Subwidget 2"));
     w2.add_attribute_value("text", Variant("A text"));
+    PreviewWidget w3("w3", "text");
+    w3.add_attribute_value("title", Variant("Subwidget 3"));
+    w3.add_attribute_value("text", Variant("A text"));
     expandable.add_widget(w1);
     expandable.add_widget(w2);
+    expandable.add_widget(w3);
     ...
 \endcode
 
 
=== modified file 'src/scopes/internal/JsonCppNode.cpp'
--- src/scopes/internal/JsonCppNode.cpp	2015-11-02 05:08:08 +0000
+++ src/scopes/internal/JsonCppNode.cpp	2016-06-17 07:24:44 +0000
@@ -14,316 +14,399 @@
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  *
  * Authored by: Marcus Tomlinson <[e-mail]>
+ *              Michi Henning <[e-mail]>
  */
 
 #include <unity/scopes/internal/JsonCppNode.h>
+
 #include <unity/UnityExceptions.h>
-#include <jsoncpp/json/reader.h>
-#include <jsoncpp/json/writer.h>
-#include <sstream>
 
+using namespace std;
 using namespace unity::scopes;
 using namespace unity::scopes::internal;
 
-JsonCppNode::JsonCppNode(std::string const& json_string)
-{
-    if (!json_string.empty())
-    {
-        read_json(json_string);
-    }
-}
-
-JsonCppNode::JsonCppNode(const Json::Value& root)
-    : root_(root)
-{
-}
-
-JsonCppNode::JsonCppNode(const Variant& var)
-{
-    root_ = from_variant(var);
-}
-
-JsonCppNode::~JsonCppNode()
-{
-}
-
-Json::Value JsonCppNode::from_variant(Variant const& var)
-{
+void JsonCppNode::init_from_string(string const& json_string)
+{
+    if (json_string.find_first_not_of(" \t\n") == std::string::npos)
+    {
+        throw unity::ResourceException("JsonCppNode(): empty string is not a valid JSON");
+    }
+
+    gobj_ptr<JsonParser> parser(json_parser_new());
+    GError *err = nullptr;
+    if (!json_parser_load_from_data(parser.get(), json_string.c_str(), json_string.size(), &err))
+    {
+        string msg = string("JsonCppNode(); parse error: ") + err->message;
+        g_error_free(err);
+        throw unity::ResourceException(msg);
+    }
+    root_.reset(json_node_copy(json_parser_get_root(parser.get())));
+}
+
+JsonCppNode::JsonCppNode()
+    : root_(json_node_alloc(), json_node_free)
+{
+    json_node_init_null(root_.get());
+}
+
+JsonCppNode::JsonCppNode(string const& json_string)
+    : JsonCppNode()
+{
+    init_from_string(json_string);
+}
+
+JsonCppNode::JsonCppNode(JsonNode* node)
+    : root_(json_node_copy(node), json_node_free)
+{
+}
+
+namespace
+{
+
+// Allocates a new node for each value. Caller is responsible for deallocating the root node.
+
+JsonNode* variant_to_node(Variant const& var)
+{
+    unique_ptr<JsonNode, decltype(&json_node_free)> node_guard(json_node_alloc(), json_node_free);
+    auto node = node_guard.get();
     switch (var.which())
     {
+        case Variant::Type::Null:
+            json_node_init_null(node);
+            break;
+        case Variant::Type::Array:
+        {
+            unique_ptr<JsonArray, decltype(&json_array_unref)> array(json_array_new(), json_array_unref);
+            for (auto const& v : var.get_array())
+            {
+                json_array_add_element(array.get(), variant_to_node(v));
+            }
+            json_node_init_array(node, array.get());
+            break;
+        }
+        case Variant::Type::Dict:
+        {
+            unique_ptr<JsonObject, decltype(&json_object_unref)> object(json_object_new(), json_object_unref);
+            for (auto const& v : var.get_dict())
+            {
+                json_object_set_member(object.get(), v.first.c_str(), variant_to_node(v.second));
+            }
+            json_node_set_object(node, object.get());
+            break;
+        }
+        case Variant::Type::String:
+            json_node_init_string(node, var.get_string().c_str());
+            break;
         case Variant::Type::Int:
-            return Json::Value(var.get_int());
+            json_node_init_int(node, int64_t(var.get_int()));
+            break;
         case Variant::Type::Int64:
-            return Json::Value(static_cast<Json::Int64>(var.get_int64_t()));
+            json_node_init_int(node, var.get_int64_t());
+            break;
+        case Variant::Type::Double:
+            json_node_init_double(node, var.get_double());
+            break;
         case Variant::Type::Bool:
-            return Json::Value(var.get_bool());
-        case Variant::Type::String:
-            return Json::Value(var.get_string());
-        case Variant::Type::Double:
-            return Json::Value(var.get_double());
-        case Variant::Type::Dict:
-            {
-                Json::Value val(Json::ValueType::objectValue);
-                for (auto const& v: var.get_dict())
-                {
-                    val[v.first] = from_variant(v.second);
-                }
-                return val;
-            }
-        case Variant::Type::Array:
-            {
-                Json::Value val(Json::ValueType::arrayValue);
-                for (auto const& v: var.get_array())
-                {
-                    val.append(from_variant(v));
-                }
-                return val;
-            }
-        case Variant::Type::Null:
-            return Json::Value(Json::ValueType::nullValue);
+        {
+            json_node_init_boolean(node, var.get_bool());
+            break;
+        }
         default:
-            {
-                std::ostringstream s;
-                s << "JsonCppNode::from_variant(): unsupported variant type ";
-                s << static_cast<int>(var.which());
-                throw unity::LogicException(s.str());
-            }
+        {
+            abort();  // LCOV_EXCL_LINE  // Impossible
+        }
     }
-}
-
-Variant JsonCppNode::to_variant(Json::Value const& value)
-{
-    switch (value.type())
+    return node_guard.release();
+}
+
+}  // namespace
+
+JsonCppNode::JsonCppNode(Variant const& var)
+    : root_(variant_to_node(var), json_node_free)
+{
+}
+
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wold-style-cast"
+
+namespace
+{
+
+Variant node_to_variant(JsonNode* node);  // Mutual recursion, need forward declaration.
+
+extern "C"
+void add_to_array(JsonArray* /* array */, guint /* index */, JsonNode* element_node, gpointer user_data)
+{
+    VariantArray* va = reinterpret_cast<VariantArray*>(user_data);
+    va->push_back(node_to_variant(element_node));
+}
+
+extern "C"
+void add_to_map(JsonObject* /* object */, gchar const* member_name, JsonNode* member_node, gpointer user_data)
+{
+    VariantMap* vm = reinterpret_cast<VariantMap*>(user_data);
+    (*vm)[member_name] = node_to_variant(member_node);
+}
+
+Variant node_to_variant(JsonNode* node)
+{
+    switch (json_node_get_node_type(node))
     {
-        case Json::ValueType::nullValue:
+        case JSON_NODE_NULL:
             return Variant::null();
-        case Json::ValueType::arrayValue:
-            {
-                VariantArray arr;
-                for (unsigned int i=0; i<value.size(); ++i)
-                {
-                    arr.push_back(to_variant(value[i]));
-                }
-                return Variant(arr);
-            }
-        case Json::ValueType::objectValue:
-            {
-                VariantMap var;
-                for (auto const& m: value.getMemberNames())
-                {
-                    var[m] = to_variant(value[m]);
-                }
-                return Variant(var);
-            }
-        case Json::ValueType::stringValue:
-            return Variant(value.asString());
-        case Json::ValueType::intValue:
-        case Json::ValueType::uintValue:
-            // this can throw std::runtime_error from jsoncpp if unsigned int to int conversion is not possible
-            if (value.isInt())
-            {
-                return Variant(value.asInt());
-            }
-            return Variant(static_cast<int64_t>(value.asInt64()));
-        case Json::ValueType::realValue:
-            return Variant(value.asDouble());
-        case Json::ValueType::booleanValue:
-            return Variant(value.asBool());
+        case JSON_NODE_ARRAY:
+        {
+            VariantArray va;
+            auto array = json_node_get_array(node);
+            json_array_foreach_element(array, add_to_array, &va);
+            return Variant(va);
+        }
+        case JSON_NODE_OBJECT:
+        {
+            VariantMap vm;
+            auto object = json_node_get_object(node);
+            json_object_foreach_member(object, add_to_map, &vm);
+            return Variant(vm);
+        }
+        case JSON_NODE_VALUE:
+        {
+            switch (json_node_get_value_type(node))
+            {
+                case G_TYPE_STRING:
+                    return Variant(string(json_node_get_string(node)));
+                case G_TYPE_INT64:
+                {
+                    // HACK: If the value fits into a 32-bit int, return an Int
+                    //       variant. Otherwise, return an Int64 variant.
+                    int64_t val64 = json_node_get_int(node);
+                    if (val64 < INT32_MIN || val64 > INT32_MAX)
+                    {
+                        return Variant(val64);
+                    }
+                    int32_t val32 = val64;
+                    return Variant(val32);
+                }
+                case G_TYPE_DOUBLE:
+                    return Variant(json_node_get_double(node));
+                case G_TYPE_BOOLEAN:
+                    return Variant(bool(json_node_get_boolean(node)));
+                default:
+                    abort();  // LCOV_EXCL_LINE  // Impossible
+            }
+        }
         default:
-            {
-                std::ostringstream s;
-                s << "JsonCppNode::to_variant(): unsupported json type ";
-                s << static_cast<int>(value.type());
-                throw unity::LogicException(s.str());
-            }
+            abort();  // LCOV_EXCL_LINE  // Impossible
     }
 }
 
+}  // namespace
+
 Variant JsonCppNode::to_variant() const
 {
-    return to_variant(root_);
+    return node_to_variant(root_.get());
 }
 
 void JsonCppNode::clear()
 {
-    root_.clear();
-}
-
-void JsonCppNode::read_json(std::string const& json_string)
-{
-    Json::Reader reader;
-    clear();
-
-    if (!reader.parse(json_string, root_))
-    {
-        throw unity::ResourceException("Failed to parse json string: " + reader.getFormattedErrorMessages());
-    }
-}
-
-std::string JsonCppNode::to_json_string() const
-{
-    Json::FastWriter writer;
-    return writer.write(root_);
+    json_node_init_null(root_.get());
+}
+
+void JsonCppNode::read_json(string const& json_string)
+{
+    init_from_string(json_string);
+}
+
+string JsonCppNode::to_json_string() const
+{
+    gobj_ptr<JsonGenerator> generator(json_generator_new());
+    json_generator_set_root(generator.get(), root_.get());
+
+    gsize len;
+    unique_ptr<gchar, decltype(&g_free)> data(json_generator_to_data(generator.get(), &len), g_free);
+    string result(data.get(), len);
+    result += '\n';
+    return result;
 }
 
 int JsonCppNode::size() const
 {
-    return root_.size();
-}
-
-std::vector<std::string> JsonCppNode::member_names() const
-{
-    if (root_.type() != Json::objectValue)
+    switch (json_node_get_node_type(root_.get()))
+    {
+        case JSON_NODE_ARRAY:
+        {
+            auto array = json_node_get_array(root_.get());
+            return json_array_get_length(array);
+        }
+        case JSON_NODE_OBJECT:
+        {
+            auto object = json_node_get_object(root_.get());
+            return json_object_get_size(object);
+        }
+        default:
+            return 0;
+    }
+}
+
+namespace
+{
+
+extern "C"
+void add_name(JsonObject* /* object */, gchar const* member_name, JsonNode* /* member_node */, gpointer user_data)
+{
+    vector<string>* names = reinterpret_cast<vector<string>*>(user_data);
+    names->push_back(member_name);
+}
+
+}
+
+vector<string> JsonCppNode::member_names() const
+{
+    if (!JSON_NODE_HOLDS_OBJECT(root_.get()))
     {
         throw unity::LogicException("Root node is not an object");
     }
-    return root_.getMemberNames();
+
+    vector<string> names;
+    auto object = json_node_get_object(root_.get());
+    json_object_foreach_member(object, add_name, &names);
+    return names;
 }
 
 JsonNodeInterface::NodeType JsonCppNode::type() const
 {
-    switch (root_.type())
+    switch (json_node_get_node_type(root_.get()))
     {
-        case Json::nullValue:
+        case JSON_NODE_NULL:
             return Null;
-        case Json::arrayValue:
+        case JSON_NODE_ARRAY:
             return Array;
-        case Json::objectValue:
+        case JSON_NODE_OBJECT:
             return Object;
-        case Json::stringValue:
-            return String;
-        case Json::intValue:
-            return Int;
-        case Json::uintValue:
-            return UInt;
-        case Json::realValue:
-            return Real;
-        case Json::booleanValue:
-            return Bool;
+        case JSON_NODE_VALUE:
+        {
+            switch (json_node_get_value_type(root_.get()))
+            {
+                case G_TYPE_STRING:
+                    return String;
+                case G_TYPE_INT64:
+                    return Int;
+                case G_TYPE_DOUBLE:
+                    return Real;
+                case G_TYPE_BOOLEAN:
+                    return Bool;
+                default:
+                    abort();  // LCOV_EXCL_LINE  // Impossible
+            }
+        }
         default:
-            break;
+            abort();  // LCOV_EXCL_LINE  // Impossible
     }
 
-    return Null;
+    abort();  // LCOV_EXCL_LINE
 }
 
-std::string JsonCppNode::as_string() const
+string JsonCppNode::as_string() const
 {
-    if (!root_.isConvertibleTo(Json::stringValue))
+    if (JSON_NODE_HOLDS_NULL(root_.get()))
+    {
+        return string();
+    }
+    if (!JSON_NODE_HOLDS_VALUE(root_.get()) || json_node_get_value_type(root_.get()) != G_TYPE_STRING)
     {
         throw unity::LogicException("Node does not contain a string value");
     }
 
-    return root_.asString();
+    return string(json_node_get_string(root_.get()));
 }
 
-int JsonCppNode::as_int() const
+int64_t JsonCppNode::as_int() const
 {
-    if (!root_.isConvertibleTo(Json::intValue))
+    if (!JSON_NODE_HOLDS_VALUE(root_.get()) || json_node_get_value_type(root_.get()) != G_TYPE_INT64)
     {
         throw unity::LogicException("Node does not contain an int value");
     }
 
-    return root_.asInt();
-}
-
-unsigned int JsonCppNode::as_uint() const
-{
-    if (!root_.isConvertibleTo(Json::uintValue))
-    {
-        throw unity::LogicException("Node does not contain a unsigned int value");
-    }
-
-    return root_.asUInt();
+    return json_node_get_int(root_.get());
 }
 
 double JsonCppNode::as_double() const
 {
-    if (!root_.isConvertibleTo(Json::realValue))
+    if (!JSON_NODE_HOLDS_VALUE(root_.get()) || json_node_get_value_type(root_.get()) != G_TYPE_DOUBLE)
     {
         throw unity::LogicException("Node does not contain a double value");
     }
 
-    return root_.asDouble();
+    return json_node_get_double(root_.get());
 }
 
 bool JsonCppNode::as_bool() const
 {
-    if (!root_.isConvertibleTo(Json::booleanValue))
+    if (!JSON_NODE_HOLDS_VALUE(root_.get()) || json_node_get_value_type(root_.get()) != G_TYPE_BOOLEAN)
     {
         throw unity::LogicException("Node does not contain a bool value");
     }
 
-    return root_.asBool();
+    return json_node_get_boolean(root_.get());
 }
 
-bool JsonCppNode::has_node(std::string const& node_name) const
+#pragma GCC diagnostic pop
+
+bool JsonCppNode::has_node(string const& node_name) const
 {
-    if (!root_)
+    if (JSON_NODE_HOLDS_NULL(root_.get()))
     {
         throw unity::LogicException("Current node is empty");
     }
 
-    if (root_.type() != Json::objectValue)
+    if (!JSON_NODE_HOLDS_OBJECT(root_.get()))
     {
         throw unity::LogicException("Root node is not an object");
     }
 
-    return root_.isMember(node_name);
+    return json_object_has_member(json_node_get_object(root_.get()), node_name.c_str());
 }
 
 JsonNodeInterface::SPtr JsonCppNode::get_node() const
 {
-    if (!root_)
+    if (JSON_NODE_HOLDS_NULL(root_.get()))
     {
         throw unity::LogicException("Current node is empty");
     }
 
-    return std::make_shared<JsonCppNode>(root_);
+    return make_shared<JsonCppNode>(root_.get());
 }
 
-JsonNodeInterface::SPtr JsonCppNode::get_node(std::string const& node_name) const
+JsonNodeInterface::SPtr JsonCppNode::get_node(string const& node_name) const
 {
-    if (!root_)
-    {
-        throw unity::LogicException("Current node is empty");
-    }
-
-    if (root_.type() != Json::objectValue)
-    {
-        throw unity::LogicException("Root node is not an object");
-    }
-    if (!root_.isMember(node_name))
+    if (!has_node(node_name))
     {
         throw unity::LogicException("Node " + node_name + " does not exist");
     }
 
-    const Json::Value& value_node = root_[node_name];
-    return std::make_shared<JsonCppNode>(value_node);
+    auto object = json_node_get_object(root_.get());
+    auto member = json_object_get_member(object, node_name.c_str());
+    return make_shared<JsonCppNode>(member);
 }
 
 JsonNodeInterface::SPtr JsonCppNode::get_node(unsigned int node_index) const
 {
-    if (!root_)
+    if (JSON_NODE_HOLDS_NULL(root_.get()))
     {
         throw unity::LogicException("Current node is empty");
     }
 
-    if (root_.type() != Json::arrayValue)
+    if (!JSON_NODE_HOLDS_ARRAY(root_.get()))
     {
         throw unity::LogicException("Root node is not an array");
     }
-    else if (node_index >= root_.size())
-    {
-        throw unity::LogicException("Invalid array index");
-    }
-
-    const Json::Value& value_node = root_[node_index];
-
-    if (!value_node)
-    {
-        throw unity::LogicException("Node " + std::to_string(node_index) + " does not exist");
-    }
-
-    return std::make_shared <JsonCppNode> (value_node);
+
+    auto array = json_node_get_array(root_.get());
+    auto size = json_array_get_length(array);
+    if (node_index >= size)
+    {
+        throw unity::LogicException("Invalid array index: " + to_string(node_index));
+    }
+
+    auto element = json_array_get_element(array, node_index);
+    return make_shared<JsonCppNode>(element);
 }
 
=== modified file 'src/scopes/internal/JsonSettingsSchema.cpp'
--- src/scopes/internal/JsonSettingsSchema.cpp	2015-03-02 03:59:01 +0000
+++ src/scopes/internal/JsonSettingsSchema.cpp	2016-06-17 07:24:44 +0000
@@ -19,10 +19,10 @@
 #include <unity/scopes/internal/JsonSettingsSchema.h>
 
 #include <unity/scopes/internal/DfltConfig.h>
+#include <unity/scopes/internal/JsonCppNode.h>
 
 #include <boost/algorithm/string/predicate.hpp>
 #include <boost/filesystem.hpp>
-#include <jsoncpp/json/json.h>
 #include <unity/UnityExceptions.h>
 
 #include <set>
@@ -52,7 +52,7 @@
 public:
     NONCOPYABLE(Setting);
 
-    Setting(Json::Value const& v);
+    Setting(Variant const& v);
     Setting(string const& id,
             string const& type,
             string const& display_name,
@@ -68,13 +68,13 @@
 
 private:
 
-    Json::Value get_mandatory(Json::Value const& v, Json::StaticString const& key, Json::ValueType expected_type) const;
-    void set_default_value(Json::Value const& v, Type expected_type);
-    Variant get_bool_default(Json::Value const& v) const;
-    Variant get_enum_default(Json::Value const& v);
-    Variant get_double_default(Json::Value const& v) const;
-    Variant get_string_default(Json::Value const& v) const;
-    void set_enumerators(Json::Value const& v);
+    Variant get_mandatory(Variant const& v, string const& key, Variant::Type expected_type) const;
+    void set_default_value(Variant const& v, Type expected_type);
+    Variant get_bool_default(Variant const& v) const;
+    Variant get_enum_default(Variant const& v);
+    Variant get_double_default(Variant const& v) const;
+    Variant get_string_default(Variant const& v) const;
+    void set_enumerators(Variant const& v);
 
     string id_;
     string type_;
@@ -90,32 +90,32 @@
                                                       { "string",  Setting::StringT },
                                                     };
 
-Setting::Setting(Json::Value const& v)
+Setting::Setting(Variant const& v)
 {
-    assert(v.isObject());
-
-    static auto const id_key = Json::StaticString("id");
-    static auto const type_key = Json::StaticString("type");
-    static auto const display_name_key = Json::StaticString("displayName");
-
-    id_ = get_mandatory(v, id_key, Json::stringValue).asString();
+    assert(v.which() == Variant::Type::Dict);
+
+    static string const id_key = "id";
+    static string const type_key = "type";
+    static string const display_name_key = "displayName";
+
+    id_ = get_mandatory(v, id_key, Variant::Type::String).get_string();
     if (id_.empty())
     {
-        throw ResourceException(string("JsonSettingsSchema(): invalid empty \"") + id_key.c_str() + "\" definition");
+        throw ResourceException(string("JsonSettingsSchema(): invalid empty \"") + id_key + "\" definition");
     }
 
-    auto v_type = get_mandatory(v, type_key, Json::stringValue);
-    string type_string = v_type.asString();
+    auto v_type = get_mandatory(v, type_key, Variant::Type::String);
+    string type_string = v_type.get_string();
     auto const it = VALID_TYPES.find(type_string);
     if (it == VALID_TYPES.end())
     {
-        throw ResourceException(string("JsonSettingsSchema(): invalid \"") + type_key.c_str() + "\" setting: \""
-                                       + type_string + "\", " "id = \"" + id_ + "\"");
+        throw ResourceException(string("JsonSettingsSchema(): invalid \"") + type_key + "\" definition: \""
+                                + type_string + "\", " "id = \"" + id_ + "\"");
     }
     type_ = it->first;
     set_default_value(v, it->second);
 
-    display_name_ = get_mandatory(v, display_name_key, Json::stringValue).asString();
+    display_name_ = get_mandatory(v, display_name_key, Variant::Type::String).get_string();
 }
 
 Setting::Setting(string const& id,
@@ -131,11 +131,7 @@
     assert(!id.empty());
 
     auto const it = VALID_TYPES.find(type);
-    if (it == VALID_TYPES.end())
-    {
-        throw ResourceException(string("JsonSettingsSchema(): invalid \"type\" definition: \"")
-                                + type + "\", setting = \"" + id_ + "\"");
-    }
+    assert(it != VALID_TYPES.end());
     type_ = it->first;
 }
 
@@ -158,35 +154,33 @@
     return Variant(schema);
 }
 
-Json::Value Setting::get_mandatory(Json::Value const& v,
-                                   Json::StaticString const& key,
-                                   Json::ValueType expected_type) const
+Variant Setting::get_mandatory(Variant const& v, string const& key, Variant::Type expected_type) const
 {
-    assert(v.isObject());
-    auto val = v[key];
-    if (val.isNull())
+    assert(v.which() == Variant::Type::Dict);
+    auto val = v.get_dict()[key];
+    if (val.is_null())
     {
-        throw ResourceException(string("JsonSettingsSchema(): missing \"") + key.c_str() + "\" definition"
-                                       + (!id_.empty() ? ", id = \"" + id_ + "\"" : string()));
+        throw ResourceException(string("JsonSettingsSchema(): missing \"") + key + "\" definition"
+                                + (!id_.empty() ? ", id = \"" + id_ + "\"" : string()));
     }
-    if (val.type() != expected_type)
+    if (val.which() != expected_type)
     {
-        throw ResourceException(string("JsonSettingsSchema(): invalid value type for \"") + key.c_str() + "\" definition, "
-                                       + "id = \"" + id_ + "\"");
+        throw ResourceException(string("JsonSettingsSchema(): invalid value type for \"") + key
+                                + "\" definition, " + "id = \"" + id_ + "\"");
     }
     return val;
 }
 
-static auto const parameters_key = Json::StaticString("parameters");
+static string const parameters_key = "parameters";
 
-void Setting::set_default_value(Json::Value const& v, Type expected_type)
+void Setting::set_default_value(Variant const& v, Type expected_type)
 {
-    auto v_param = v[parameters_key];
-    if (v_param.isNull())
+    auto v_param = v.get_dict()[parameters_key];
+    if (v_param.is_null())
     {
         return;
     }
-    else if (!v_param.isObject())
+    else if (v_param.which() != Variant::Type::Dict)
     {
         throw ResourceException("JsonSettingsSchema(): expected value of type object for \"parameters\", id = \"" + id_ + "\"");
     }
@@ -219,124 +213,120 @@
     }
 }
 
-static auto const dflt_key = Json::StaticString("defaultValue");
-
-Variant Setting::get_bool_default(Json::Value const& v) const
-{
-    if (v.isNull())  // No "parameters" key
-    {
-        return Variant();
-    }
-    auto v_dflt = v[dflt_key];
-    if (v_dflt.isNull())
-    {
-        return Variant();  // No "defaultValue" key
-    }
-    if (!v_dflt.isBool())
-    {
-        throw ResourceException(string("JsonSettingsSchema(): invalid value type for \"") + dflt_key.c_str()
-                                       + "\" definition, id = \"" + id_ + "\"");
-    }
-    return Variant(v_dflt.asBool());
-}
-
-Variant Setting::get_double_default(Json::Value const& v) const
-{
-    if (v.isNull())  // No "parameters" key
-    {
-        return Variant();
-    }
-    auto v_dflt = v[dflt_key];
-    if (v_dflt.isNull())
-    {
-        return Variant();  // No "defaultValue" key
-    }
-    if (!v_dflt.isNumeric())
-    {
-        throw ResourceException(string("JsonSettingsSchema(): invalid value type for \"") + dflt_key.c_str()
-                                       + "\" definition, id = \"" + id_ + "\"");
-    }
-    return Variant(v_dflt.asDouble());
-}
-
-Variant Setting::get_enum_default(Json::Value const& v)
-{
-    assert(v.isObject());
-
-    if (v.isNull())  // No "parameters" key
-    {
-        throw ResourceException(string("JsonSettingsSchema(): missing \"") + parameters_key.c_str()
-                                       + "\" definition, id = \"" + id_ + "\"");
-    }
-    auto v_dflt = v[dflt_key];
-    if (v_dflt.isNull())
-    {
-        return Variant();  // No "defaultValue" key
-    }
-    if (!v_dflt.isInt())
-    {
-        throw ResourceException(string("JsonSettingsSchema(): invalid value type for \"") + dflt_key.c_str()
-                                       + "\" definition, id = \"" + id_ + "\"");
-    }
-
-    static auto const values_key = Json::StaticString("values");
-
-    auto v_vals = v[values_key];
-    if (!v_vals.isArray())
-    {
-        throw ResourceException(string("JsonSettingsSchema(): invalid value type for \"") + values_key.c_str()
-                                       + "\" definition, id = \"" + id_ + "\"");
-    }
-    if (v_vals.size() < 1)
-    {
-        throw ResourceException(string("JsonSettingsSchema(): invalid empty \"") + values_key.c_str()
-                                       + "\" definition, id = \"" + id_ + "\"");
+static string const dflt_key = "defaultValue";
+
+Variant Setting::get_bool_default(Variant const& v) const
+{
+    assert(!v.is_null());
+
+    auto v_dflt = v.get_dict()[dflt_key];
+    if (v_dflt.is_null())
+    {
+        return Variant();  // No "defaultValue" key
+    }
+    if (v_dflt.which() != Variant::Type::Bool)
+    {
+        throw ResourceException(string("JsonSettingsSchema(): invalid value type for \"") + dflt_key
+                                + "\" definition, id = \"" + id_ + "\"");
+    }
+    return v_dflt;
+}
+
+Variant Setting::get_double_default(Variant const& v) const
+{
+    assert(!v.is_null());
+
+    auto v_dflt = v.get_dict()[dflt_key];
+    if (v_dflt.is_null())
+    {
+        return Variant();  // No "defaultValue" key
+    }
+    switch (v_dflt.which())
+    {
+        case Variant::Type::Int:
+            return Variant(double(v_dflt.get_int()));
+        case Variant::Type::Int64:
+            return Variant(double(v_dflt.get_int64_t()));
+        case Variant::Type::Double:
+            return v_dflt;
+        default:
+            throw ResourceException(string("JsonSettingsSchema(): invalid value type for \"") + dflt_key
+                                    + "\" definition, id = \"" + id_ + "\"");
+    }
+}
+
+Variant Setting::get_enum_default(Variant const& v)
+{
+    assert(v.which() == Variant::Type::Dict);
+
+    auto v_dflt = v.get_dict()[dflt_key];
+    if (v_dflt.is_null())
+    {
+        return Variant();  // No "defaultValue" key
+    }
+    if (v_dflt.which() != Variant::Type::Int)
+    {
+        throw ResourceException(string("JsonSettingsSchema(): invalid value type for \"") + dflt_key
+                                + "\" definition, id = \"" + id_ + "\"");
+    }
+
+    static string const values_key = "values";
+
+    auto v_vals = v.get_dict()[values_key];
+    if (v_vals.which() != Variant::Type::Array)
+    {
+        throw ResourceException(string("JsonSettingsSchema(): invalid value type for \"") + values_key
+                                + "\" definition, id = \"" + id_ + "\"");
+    }
+    if (v_vals.get_array().size() == 0)
+    {
+        throw ResourceException(string("JsonSettingsSchema(): invalid empty \"") + values_key
+                                + "\" definition, id = \"" + id_ + "\"");
     }
 
     set_enumerators(v_vals);
 
-    auto val = v_dflt.asInt();
-    if (val < 0 || val >= static_cast<int>(v_vals.size()))
+    auto val = v_dflt.get_int();
+    if (val < 0 || val >= static_cast<int>(v_vals.get_array().size()))
     {
-        throw ResourceException(string("JsonSettingsSchema(): \"") + dflt_key.c_str()
-                                       + "\" out of range, id = \"" + id_ + "\"");
+        throw ResourceException(string("JsonSettingsSchema(): \"") + dflt_key
+                                + "\" out of range, id = \"" + id_ + "\"");
     }
-    return Variant(v_dflt.asInt());
+    return v_dflt;
 }
 
-Variant Setting::get_string_default(Json::Value const& v) const
+Variant Setting::get_string_default(Variant const& v) const
 {
-    if (v.isNull())  // No "parameters" key
-    {
-        return Variant();
-    }
-    auto v_dflt = v[dflt_key];
-    if (v_dflt.isNull())
+    assert(!v.is_null());
+
+    auto v_dflt = v.get_dict()[dflt_key];
+    if (v_dflt.is_null())
     {
         return Variant();  // No "defaultValue" key
     }
-    if (!v_dflt.isString())
+    if (v_dflt.which() != Variant::Type::String)
     {
-        throw ResourceException(string("JsonSettingsSchema(): invalid value type for \"") + dflt_key.c_str()
-                                       + "\" definition, id = \"" + id_ + "\"");
+        throw ResourceException(string("JsonSettingsSchema(): invalid value type for \"") + dflt_key
+                                + "\" definition, id = \"" + id_ + "\"");
     }
-    return Variant(v_dflt.asString());
+    return v_dflt;
 }
 
-void Setting::set_enumerators(Json::Value const& v)
+void Setting::set_enumerators(Variant const& v)
 {
-    assert(v.isArray());
+    assert(v.which() == Variant::Type::Array);
 
     set<string> enums_seen;
 
-    for (unsigned i = 0; i < v.size(); ++i)
+    VariantArray va = v.get_array();
+    for (unsigned i = 0; i < va.size(); ++i)
     {
-        Json::Value enumerator = v[i];
-        if (!enumerator.isString())
+        Variant enumerator = v.get_array()[i];
+        if (enumerator.which() != Variant::Type::String)
         {
             throw ResourceException(string("JsonSettingsSchema(): invalid enumerator type, id = \"") + id_ + "\"");
         }
-        string enum_str = enumerator.asString();
+        string enum_str = enumerator.get_string();
         if (enum_str.empty())
         {
             throw ResourceException(string("JsonSettingsSchema(): invalid empty enumerator, id = \"") + id_ + "\"");
@@ -347,7 +337,7 @@
                                     + "\", id = \"" + id_ + "\"");
         }
         enums_seen.insert(enum_str);
-        enumerators_.emplace_back(Variant(enum_str));
+        enumerators_.emplace_back(enumerator);
     }
 }
 
@@ -367,39 +357,36 @@
 {
     try
     {
-        Json::Value root;
-        Json::Reader reader;
-        if (!reader.parse(json_string, root))
-        {
-            throw ResourceException("JsonSettingsSchema(): cannot parse schema: " + reader.getFormattedErrorMessages());
-        }
-
-        if (!root.isArray())
-        {
-            root = root["settings"];
-        }
-        if (root.isNull())
-        {
-            throw ResourceException("JsonSettingsSchema(): missing \"settings\" definition");
-        }
-        if (!root.isArray())
-        {
-            throw ResourceException("JsonSettingsSchema(): value \"settings\" must be an array");
-        }
+        JsonCppNode::SPtr root = make_shared<JsonCppNode>(json_string);
+
+        if (root->type() != JsonNodeInterface::Array)
+        {
+            if (root->type() != JsonNodeInterface::Object || !root->has_node("settings"))
+            {
+                throw ResourceException("JsonSettingsSchema(): missing \"settings\" definition");
+            }
+            root = root->get_node("settings");
+            if (root->type() != JsonNodeInterface::Array)
+            {
+                throw ResourceException("JsonSettingsSchema(): value \"settings\" must be an array");
+            }
+        }
+
         set<string> seen_settings;
-        for (unsigned i = 0; i < root.size(); ++i)
+        for (int i = 0; i < root->size(); ++i)
         {
-            Setting s(root[i]);
+            Setting s(root->get_node(i)->to_variant());
             if (starts_with(s.id(), "internal."))
             {
-                throw ResourceException(string("JsonSettingsSchema(): invalid key \"") + s.id() + "\" prefixed with \"internal.\"");
+                throw ResourceException(string("JsonSettingsSchema(): invalid key \"") + s.id()
+                                        + "\" prefixed with \"internal.\"");
             }
             if (seen_settings.find(s.id()) != seen_settings.end())
             {
                 throw ResourceException("JsonSettingsSchema(): duplicate definition, id = \"" + s.id() + "\"");
             }
+            seen_settings.insert(s.id());
             definitions_.push_back(s.to_schema_definition());
-            seen_settings.insert(s.id());
         }
     }
     catch (ResourceException const&)
 
=== modified file 'src/scopes/internal/Logger.cpp'
--- src/scopes/internal/Logger.cpp	2016-02-22 05:00:23 +0000
+++ src/scopes/internal/Logger.cpp	2016-06-17 07:24:44 +0000
@@ -41,10 +41,10 @@
 static array<string, 5> const severities = {{"INFO", "WARNING", "ERROR", "FATAL", "TRACE"}};
 
 static array<pair<string, LoggerChannel>, int(LoggerChannel::LastChannelEnum_)> const channel_names =
-{
+{ {
     pair<string, LoggerChannel>{"", LoggerChannel::DefaultChannel},
     pair<string, LoggerChannel>{"IPC", LoggerChannel::IPC}
-};
+} };
 
 }  // namespace
 
 
=== modified file 'src/scopes/internal/RuntimeImpl.cpp'
--- src/scopes/internal/RuntimeImpl.cpp	2016-02-22 14:16:26 +0000
+++ src/scopes/internal/RuntimeImpl.cpp	2016-06-17 07:24:44 +0000
@@ -366,7 +366,7 @@
         string settings_schema = scope_dir.native() + "/" + scope_id_ + "-settings.ini";
 
         boost::system::error_code ec;
-        if (boost::filesystem::exists(settings_schema, ec))
+        if (boost::filesystem::exists(settings_schema, ec) && boost::filesystem::file_size(settings_schema) > 0)
         {
             shared_ptr<SettingsDB> db(SettingsDB::create_from_ini_file(settings_db, settings_schema));
             scope_base->p->set_settings_db(db);
 
=== modified file 'src/scopes/internal/ScopeConfig.cpp'
--- src/scopes/internal/ScopeConfig.cpp	2015-07-17 09:03:33 +0000
+++ src/scopes/internal/ScopeConfig.cpp	2016-06-17 07:24:44 +0000
@@ -67,7 +67,6 @@
     const string fg_color_key = "ForegroundColor";
     const string bg_color_key = "BackgroundColor";
     const string shape_images_key = "ShapeImages";
-    const string category_header_bg_key = "CategoryHeaderBackground";
     const string preview_button_color_key = "PreviewButtonColor";
     const string logo_overlay_color_key = "LogoOverlayColor";
     const string pageheader_logo_key = "PageHeader.Logo";
@@ -317,7 +316,6 @@
                fg_color_key,
                bg_color_key,
                shape_images_key,
-               category_header_bg_key,
                preview_button_color_key,
                logo_overlay_color_key,
                pageheader_logo_key,
 
=== modified file 'src/scopes/internal/smartscopes/SmartScopesClient.cpp'
--- src/scopes/internal/smartscopes/SmartScopesClient.cpp	2016-02-25 11:40:06 +0000
+++ src/scopes/internal/smartscopes/SmartScopesClient.cpp	2016-06-17 07:24:44 +0000
@@ -592,6 +592,11 @@
 
 void SmartScopesClient::handle_line(std::string const& json, PreviewReplyHandler const& handler)
 {
+    if (json.empty())
+    {
+        return;
+    }
+
     JsonNodeInterface::SPtr root_node;
     JsonNodeInterface::SPtr child_node;
     {
@@ -640,6 +645,11 @@
 
 void SmartScopesClient::handle_line(std::string const& json, SearchReplyHandler& handler)
 {
+    if (json.empty())
+    {
+        return;
+    }
+
     JsonNodeInterface::SPtr root_node;
     JsonNodeInterface::SPtr child_node;
 
 
=== modified file 'src/scopes/internal/zmq_middleware/StopPublisher.cpp'
--- src/scopes/internal/zmq_middleware/StopPublisher.cpp	2014-11-18 07:04:04 +0000
+++ src/scopes/internal/zmq_middleware/StopPublisher.cpp	2016-06-17 07:24:44 +0000
@@ -121,7 +121,7 @@
             s.set(zmqpp::socket_option::linger, 0);
             s.connect(endpoint_);
             s.subscribe("");
-            return move(s);
+            return s;
         }
     }
 }
 
=== modified file 'src/scopes/testing/ScopeMetadataBuilder.cpp'
--- src/scopes/testing/ScopeMetadataBuilder.cpp	2015-02-22 22:27:09 +0000
+++ src/scopes/testing/ScopeMetadataBuilder.cpp	2016-06-17 07:24:44 +0000
@@ -212,9 +212,7 @@
     if (p->is_aggregator)
         impl->set_is_aggregator(*p->is_aggregator);
 
-    return unity::scopes::internal::ScopeMetadataImpl::create(
-                std::move(
-                    std::unique_ptr<internal::ScopeMetadataImpl>{impl}));
+    return unity::scopes::internal::ScopeMetadataImpl::create(std::unique_ptr<internal::ScopeMetadataImpl>{impl});
 }
 
 /// @endcond
 
=== modified file 'test/copyright/check_copyright.sh'
--- test/copyright/check_copyright.sh	2015-11-13 06:33:11 +0000
+++ test/copyright/check_copyright.sh	2016-06-17 07:24:44 +0000
@@ -31,13 +31,7 @@
 [ $# -lt 1 ] && usage
 [ $# -gt 2 ] && usage
 
-# TODO: Temporary hack to work around broken licensecheck on xenial. Remove this once that is fixed.
-distro=$(lsb_release -c -s)
-[ "$distro" = "xenial" ] && {
-    exit 0
-}
-
-ignore_pat="\\.sci$"
+ignore_pat="\\.sci$|.bzr|debian|tsan-suppress|valgrind-suppress|RELEASE_NOTES.md|partnerid|suppressions|README|_clang-format|TODO|CONFIGFILES|astyle-config|no_.*_cache|\\.txt$|\\.in$|\\.ini$|\\.xml$|\\.json$|\\.swp$|\\.gz$|\\.service$|\\.map$|\\.dox$|\\.html$|ParseArguments\\.cmake"
 
 #
 # We don't use the -i option of licensecheck to add ignore_dir to the pattern because Jenkins creates directories
 
=== modified file 'test/gtest/scopes/Registry/Registry_test.cpp'
--- test/gtest/scopes/Registry/Registry_test.cpp	2015-07-06 13:47:54 +0000
+++ test/gtest/scopes/Registry/Registry_test.cpp	2016-06-17 07:24:44 +0000
@@ -122,7 +122,6 @@
     EXPECT_EQ("fg_color", attrs["foreground-color"].get_string());
     EXPECT_EQ("bg_color", attrs["background-color"].get_string());
     EXPECT_TRUE(attrs["shape-images"].get_bool());
-    EXPECT_EQ(TEST_SCOPE_A_PATH "/cat_header_bg_scheme", attrs["category-header-background"].get_string());
     EXPECT_EQ("preview_button_color", attrs["preview-button-color"].get_string());
     EXPECT_EQ("overlay_color", attrs["logo-overlay-color"].get_string());
     auto page_hdr = attrs["page-header"].get_dict();
 
=== modified file 'test/gtest/scopes/Registry/scopes/testscopeA/testscopeA.ini.in'
--- test/gtest/scopes/Registry/scopes/testscopeA/testscopeA.ini.in	2014-12-03 09:25:10 +0000
+++ test/gtest/scopes/Registry/scopes/testscopeA/testscopeA.ini.in	2016-06-17 07:24:44 +0000
@@ -16,7 +16,6 @@
 ForegroundColor = fg_color
 BackgroundColor = bg_color
 ShapeImages = true
-CategoryHeaderBackground = cat_header_bg_scheme
 PreviewButtonColor = preview_button_color
 LogoOverlayColor = overlay_color
 PageHeader.Logo = some_url
 
=== modified file 'test/gtest/scopes/internal/CMakeLists.txt'
--- test/gtest/scopes/internal/CMakeLists.txt	2016-02-22 00:19:46 +0000
+++ test/gtest/scopes/internal/CMakeLists.txt	2016-06-17 07:24:44 +0000
@@ -1,6 +1,7 @@
 add_subdirectory(CategoryRegistry)
 add_subdirectory(ConfigBase)
 add_subdirectory(DynamicLoader)
+add_subdirectory(gobj_ptr)
 add_subdirectory(IniSettingsSchema)
 add_subdirectory(JsonNode)
 add_subdirectory(JsonSettingsSchema)
 
=== modified file 'test/gtest/scopes/internal/JsonNode/JsonNode_test.cpp'
--- test/gtest/scopes/internal/JsonNode/JsonNode_test.cpp	2015-11-02 03:42:05 +0000
+++ test/gtest/scopes/internal/JsonNode/JsonNode_test.cpp	2016-06-17 07:24:44 +0000
@@ -43,6 +43,35 @@
     JsonNodeInterface::SPtr root_node_;
 };
 
+TEST_F(JsonNodeTest, basic)
+{
+    try
+    {
+        JsonCppNode node("");
+        FAIL();
+    }
+    catch (unity::ResourceException const&)
+    {
+    }
+
+    EXPECT_EQ(0, root_node_->size());
+    EXPECT_EQ(JsonNodeInterface::Null, root_node_->type());
+
+    auto json = root_node_->to_json_string();
+    EXPECT_EQ("null\n", json);
+
+    root_node_->read_json("42");
+    EXPECT_EQ(JsonNodeInterface::Int, root_node_->type());
+    auto n = root_node_->get_node();
+    EXPECT_EQ(42, n->as_int());
+
+    EXPECT_THROW(root_node_->read_json(""), unity::ResourceException);
+    EXPECT_THROW(root_node_->read_json("    "), unity::ResourceException);
+
+    root_node_->clear();
+    EXPECT_EQ(JsonNodeInterface::Null, root_node_->type());
+}
+
 TEST_F(JsonNodeTest, flat_values)
 {
     std::string json_string = R"({
@@ -170,23 +199,45 @@
 
 TEST_F(JsonNodeTest, from_variant)
 {
-    VariantArray va({Variant(1), Variant(2), Variant(true)});
-    VariantMap vm;
-    vm["foo"] = "bar";
-    vm["baz"] = 1;
-    vm["boo"] = 2.0f;
-    vm["zee"] = true;
-    vm["wee"] = Variant(va);
-
-    Variant var(vm);
-    JsonCppNode node(var);
-    EXPECT_EQ("bar", node.get_node("foo")->as_string());
-    EXPECT_EQ(1, node.get_node("baz")->as_int());
-    EXPECT_TRUE(node.get_node("boo")->as_double() - 2.0f < 0.00001f);
-    EXPECT_TRUE(node.get_node("zee")->as_bool());
-    EXPECT_EQ(1, node.get_node("wee")->get_node(0)->as_int());
-    EXPECT_EQ(2, node.get_node("wee")->get_node(1)->as_int());
-    EXPECT_TRUE(node.get_node("wee")->get_node(2)->as_bool());
+    {
+        VariantArray va({Variant(1), Variant(2), Variant(true)});
+        VariantMap vm;
+        vm["foo"] = "bar";
+        vm["baz"] = 1;
+        vm["boo"] = 2.0f;
+        vm["zee"] = true;
+        vm["wee"] = Variant(va);
+
+        Variant var(vm);
+        JsonCppNode node(var);
+        EXPECT_EQ(JsonNodeInterface::Object, node.type());
+        EXPECT_EQ("bar", node.get_node("foo")->as_string());
+        EXPECT_EQ(JsonNodeInterface::String, node.get_node("foo")->type());
+        EXPECT_EQ(1, node.get_node("baz")->as_int());
+        EXPECT_EQ(JsonNodeInterface::Real, node.get_node("boo")->type());
+        EXPECT_TRUE(node.get_node("boo")->as_double() - 2.0f < 0.00001f);
+        EXPECT_EQ(JsonNodeInterface::Bool, node.get_node("zee")->type());
+        EXPECT_TRUE(node.get_node("zee")->as_bool());
+        EXPECT_EQ(JsonNodeInterface::Array, node.get_node("wee")->type());
+        EXPECT_EQ(1, node.get_node("wee")->get_node(0)->as_int());
+        EXPECT_EQ(2, node.get_node("wee")->get_node(1)->as_int());
+        EXPECT_TRUE(node.get_node("wee")->get_node(2)->as_bool());
+    }
+
+    {
+        Variant var(1);
+        JsonCppNode node(var);
+        EXPECT_EQ(1, node.to_variant().get_int());
+    }
+
+    {
+        Variant var(2147483648);  // > 2^31 - 1
+        JsonCppNode node(var);
+        EXPECT_EQ(2147483648, node.to_variant().get_int64_t());
+    }
+
+    JsonCppNode null_node((Variant()));
+    EXPECT_EQ(JsonNodeInterface::Null, null_node.type());
 }
 
 TEST_F(JsonNodeTest, to_variant)
@@ -206,4 +257,89 @@
     EXPECT_EQ("foo", arr[2].get_string());
 }
 
+TEST_F(JsonNodeTest, exceptions)
+{
+    EXPECT_THROW(JsonCppNode("syntax error"), unity::ResourceException);
+
+    try
+    {
+        JsonCppNode().member_names();
+        FAIL();
+    }
+    catch (unity::LogicException const& e)
+    {
+        EXPECT_STREQ("unity::LogicException: Root node is not an object", e.what());
+    }
+
+    try
+    {
+        JsonCppNode().has_node("x");
+        FAIL();
+    }
+    catch (unity::LogicException const& e)
+    {
+        EXPECT_STREQ("unity::LogicException: Current node is empty", e.what());
+    }
+
+    try
+    {
+        JsonCppNode("42").as_string();
+        FAIL();
+    }
+    catch (unity::LogicException const& e)
+    {
+        EXPECT_STREQ("unity::LogicException: Node does not contain a string value", e.what());
+    }
+
+    try
+    {
+        JsonCppNode("true").as_double();
+        FAIL();
+    }
+    catch (unity::LogicException const& e)
+    {
+        EXPECT_STREQ("unity::LogicException: Node does not contain a double value", e.what());
+    }
+
+    try
+    {
+        JsonCppNode("true").as_int();
+        FAIL();
+    }
+    catch (unity::LogicException const& e)
+    {
+        EXPECT_STREQ("unity::LogicException: Node does not contain an int value", e.what());
+    }
+
+    try
+    {
+        JsonCppNode("3.14").as_bool();
+        FAIL();
+    }
+    catch (unity::LogicException const& e)
+    {
+        EXPECT_STREQ("unity::LogicException: Node does not contain a bool value", e.what());
+    }
+
+    try
+    {
+        JsonCppNode().get_node(25);
+        FAIL();
+    }
+    catch (unity::LogicException const& e)
+    {
+        EXPECT_STREQ("unity::LogicException: Current node is empty", e.what());
+    }
+
+    try
+    {
+        JsonCppNode().get_node();
+        FAIL();
+    }
+    catch (unity::LogicException const& e)
+    {
+        EXPECT_STREQ("unity::LogicException: Current node is empty", e.what());
+    }
+}
+
 } // namespace
 
=== modified file 'test/gtest/scopes/internal/JsonSettingsSchema/JsonSettingsSchema_test.cpp'
--- test/gtest/scopes/internal/JsonSettingsSchema/JsonSettingsSchema_test.cpp	2015-01-13 11:44:33 +0000
+++ test/gtest/scopes/internal/JsonSettingsSchema/JsonSettingsSchema_test.cpp	2016-06-17 07:24:44 +0000
@@ -22,7 +22,6 @@
 #include <unity/util/FileIO.h>
 
 #include <gtest/gtest.h>
-#include <jsoncpp/json/json.h>
 
 using namespace unity;
 using namespace unity::scopes;
@@ -153,6 +152,41 @@
     EXPECT_EQ(Variant(), defs[10].get_dict()["defaultValue"]);
 }
 
+TEST(JsonSettingsSchema, integer_sizes)
+{
+    char const* schema = R"delimiter(
+    {
+        "settings":
+        [
+            {
+                "id": "double_temp",
+                "displayName": "floating-point default",
+                "type": "number",
+                "parameters": {
+                    "defaultValue": 3.14
+                }
+            },
+            {
+                "id": "too_old",
+                "displayName": "won't fit into 32 bits",
+                "type": "number",
+                "parameters": {
+                    "defaultValue": 2147483648
+                }
+            }
+        ]
+    }
+    )delimiter";
+
+    auto s = JsonSettingsSchema::create(schema);
+
+    auto defs = s->definitions();
+    EXPECT_EQ(2, defs.size());
+
+    EXPECT_EQ(3.14, defs[0].get_dict()["defaultValue"].get_double());
+    EXPECT_EQ(2147483648, defs[1].get_dict()["defaultValue"].get_double());
+}
+
 TEST(JsonSettingsSchema, exceptions)
 {
     try
@@ -162,9 +196,7 @@
     }
     catch (ResourceException const& e)
     {
-        EXPECT_STREQ("unity::ResourceException: JsonSettingsSchema(): cannot parse schema: * Line 1, Column 1\n"
-                     "  Syntax error: value, object or array expected.\n",
-                     e.what());
+        EXPECT_STREQ("unity::ResourceException: JsonCppNode(): empty string is not a valid JSON", e.what());
     }
 
     try
@@ -335,7 +367,7 @@
     }
     catch (ResourceException const& e)
     {
-        EXPECT_STREQ("unity::ResourceException: JsonSettingsSchema(): invalid \"type\" setting: "
+        EXPECT_STREQ("unity::ResourceException: JsonSettingsSchema(): invalid \"type\" definition: "
                      "\"no_such_type\", id = \"x\"",
                      e.what());
     }
 
=== modified file 'test/gtest/scopes/internal/SettingsDB/SettingsDB_test.cpp'
--- test/gtest/scopes/internal/SettingsDB/SettingsDB_test.cpp	2015-11-26 05:48:01 +0000
+++ test/gtest/scopes/internal/SettingsDB/SettingsDB_test.cpp	2016-06-17 07:24:44 +0000
@@ -22,6 +22,7 @@
 
 #include <unity/UnityExceptions.h>
 
+#include <boost/algorithm/string.hpp>
 #include <boost/regex.hpp>  // Use Boost implementation until http://gcc.gnu.org/bugzilla/show_bug.cgi?id=53631 is fixed.
 #include <gtest/gtest.h>
 #include <fcntl.h>
@@ -321,10 +322,9 @@
     }
     catch (ResourceException const& e)
     {
-        EXPECT_STREQ("unity::ResourceException: SettingsDB::create_from_json_string(): cannot parse schema, db = unused:\n"
-                     "    unity::ResourceException: JsonSettingsSchema(): cannot parse schema: * Line 1, Column 1\n"
-                     "  Syntax error: value, object or array expected.\n",
-                     e.what());
+        EXPECT_TRUE(boost::starts_with(e.what(),
+                    "unity::ResourceException: SettingsDB::create_from_json_string(): cannot parse "
+                    "schema, db = unused:")) << e.what();
     }
 
     try
 
=== added directory 'test/gtest/scopes/internal/gobj_ptr'
=== added file 'test/gtest/scopes/internal/gobj_ptr/CMakeLists.txt'
--- test/gtest/scopes/internal/gobj_ptr/CMakeLists.txt	1970-01-01 00:00:00 +0000
+++ test/gtest/scopes/internal/gobj_ptr/CMakeLists.txt	2016-06-17 07:24:44 +0000
@@ -0,0 +1,3 @@
+add_executable(gobj_ptr_test gobj_ptr_test.cpp)
+target_link_libraries(gobj_ptr_test ${TESTLIBS})
+add_test(gobj_ptr gobj_ptr_test)
 
=== added file 'test/gtest/scopes/internal/gobj_ptr/gobj_ptr_test.cpp'
--- test/gtest/scopes/internal/gobj_ptr/gobj_ptr_test.cpp	1970-01-01 00:00:00 +0000
+++ test/gtest/scopes/internal/gobj_ptr/gobj_ptr_test.cpp	2016-06-17 07:24:44 +0000
@@ -0,0 +1,208 @@
+/*
+ * Copyright (C) 2013 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Jussi Pakkanen <[e-mail]>
+ */
+
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wold-style-cast"
+#pragma GCC diagnostic ignored "-Wcast-qual"
+
+#include <unity/scopes/internal/gobj_memory.h>
+#include <glib-object.h>
+#include <gtest/gtest.h>
+
+using namespace std;
+using namespace unity::scopes::internal;
+
+TEST(Gobj_ptr, trivial)
+{
+    gobj_ptr<GObject> basic(G_OBJECT(g_object_new(G_TYPE_OBJECT, nullptr)));
+    EXPECT_TRUE(bool(basic));
+    EXPECT_TRUE(G_IS_OBJECT(basic.get()));
+}
+
+TEST(Gobj_ptr, compare)
+{
+    GObject* o1 = G_OBJECT(g_object_new(G_TYPE_OBJECT, nullptr));
+    GObject* o2 = G_OBJECT(g_object_new(G_TYPE_OBJECT, nullptr));
+    if (o1 > o2)
+    {
+        std::swap(o1, o2);
+    }
+    ASSERT_TRUE(o1 < o2);
+    gobj_ptr<GObject> u1(o1);
+    gobj_ptr<GObject> u2(o2);
+
+    EXPECT_TRUE(!(u1 == nullptr));
+    EXPECT_TRUE(u1 != nullptr);
+    EXPECT_TRUE(u1 != u2);
+    EXPECT_TRUE(!(u1 == u2));
+    EXPECT_TRUE(u1 < u2);
+    EXPECT_TRUE(!(u2 < u1));
+    EXPECT_TRUE(!(u1 == u2));
+    EXPECT_TRUE(!(u2 == u1));
+    EXPECT_TRUE(u1 <= u2);
+    EXPECT_TRUE(!(u2 <= u1));
+}
+
+// This is its own thing due to need to avoid double release.
+
+TEST(Gobj_ptr, equality)
+{
+    GObject* o = G_OBJECT(g_object_new(G_TYPE_OBJECT, nullptr));
+    gobj_ptr<GObject> u1(o);
+    g_object_ref(o);
+    gobj_ptr<GObject> u2(o);
+    EXPECT_TRUE(u1 == u2);
+    EXPECT_TRUE(u2 == u1);
+    EXPECT_TRUE(!(u1 != u2));
+    EXPECT_TRUE(!(u2 != u1));
+}
+
+TEST(Gobj_ptr, release)
+{
+    GObject* o = G_OBJECT(g_object_new(G_TYPE_OBJECT, nullptr));
+    gobj_ptr<GObject> u(o);
+    EXPECT_TRUE(u != nullptr);
+    EXPECT_TRUE(u.get() != nullptr);
+    EXPECT_TRUE(o == u.release());
+    EXPECT_TRUE(!u);
+    EXPECT_TRUE(u.get() == nullptr);
+    g_object_unref(o);
+}
+
+TEST(Gobj_ptr, refcount)
+{
+    GObject* o = G_OBJECT(g_object_new(G_TYPE_OBJECT, nullptr));
+    EXPECT_EQ(1, o->ref_count);
+    g_object_ref(o);
+
+    {
+        EXPECT_EQ(2, o->ref_count);
+        gobj_ptr<GObject> u(o);
+        EXPECT_EQ(2, o->ref_count);
+        // Now it dies and refcount is reduced.
+    }
+
+    EXPECT_EQ(1, o->ref_count);
+    g_object_unref(o);
+}
+
+TEST(Gobj_ptr, copy)
+{
+    GObject* o = G_OBJECT(g_object_new(G_TYPE_OBJECT, nullptr));
+    gobj_ptr<GObject> u(o);
+    EXPECT_EQ(1, u->ref_count);
+    gobj_ptr<GObject> u2(u);
+    EXPECT_EQ(2, u->ref_count);
+    gobj_ptr<GObject> u3 = u2;
+    EXPECT_EQ(3, u->ref_count);
+    u3.reset();
+    u2.reset();
+    EXPECT_EQ(1, u->ref_count);
+}
+
+TEST(Gobj_ptr, swap)
+{
+    GObject* o1 = G_OBJECT(g_object_new(G_TYPE_OBJECT, nullptr));
+    GObject* o2 = G_OBJECT(g_object_new(G_TYPE_OBJECT, nullptr));
+    gobj_ptr<GObject> u1(o1);
+    gobj_ptr<GObject> u2(o2);
+
+    u1.swap(u2);
+    EXPECT_EQ(o2, u1.get());
+    EXPECT_EQ(o1, u2.get());
+
+    std::swap(u1, u2);
+    EXPECT_EQ(o1, u1.get());
+    EXPECT_EQ(o2, u2.get());
+}
+
+TEST(Gobj_ptr, floating)
+{
+    GObject* o = G_OBJECT(g_object_new(G_TYPE_INITIALLY_UNOWNED, nullptr));
+    try
+    {
+        gobj_ptr<GObject> u(o);
+        FAIL();
+    }
+    catch (const invalid_argument& c)
+    {
+        EXPECT_EQ("Tried to add a floating gobject into a gobj_ptr.", string(c.what()));
+    }
+    // Object accepted after sinking.
+    g_object_ref_sink(o);
+    gobj_ptr<GObject> u(o);
+}
+
+TEST(Gobj_ptr, move)
+{
+    GObject* o1 = G_OBJECT(g_object_new(G_TYPE_OBJECT, nullptr));
+    GObject* o2 = G_OBJECT(g_object_new(G_TYPE_OBJECT, nullptr));
+    g_object_ref(o1);
+    gobj_ptr<GObject> u1(o1);
+    gobj_ptr<GObject> u2(o2);
+    u1 = std::move(u2);
+    EXPECT_TRUE(u1.get() == o2);
+    EXPECT_TRUE(!u2);
+    EXPECT_TRUE(o1->ref_count == 1);
+    g_object_unref(o1);
+}
+
+TEST(Gobj_ptr, null)
+{
+    GObject* o1 = NULL;
+    GObject* o3 = G_OBJECT(g_object_new(G_TYPE_OBJECT, nullptr));
+    gobj_ptr<GObject> u1(o1);
+    gobj_ptr<GObject> u2(nullptr);
+    gobj_ptr<GObject> u3(o3);
+
+    EXPECT_TRUE(!u1);
+    EXPECT_TRUE(!u2);
+    u3 = nullptr;
+    EXPECT_TRUE(!u3);
+}
+
+TEST(Gobj_ptr, reset)
+{
+    GObject* o1 = G_OBJECT(g_object_new(G_TYPE_OBJECT, nullptr));
+    GObject* o2 = G_OBJECT(g_object_new(G_TYPE_OBJECT, nullptr));
+    gobj_ptr<GObject> u(o1);
+
+    u.reset(o2);
+    EXPECT_EQ(o2, u.get());
+    u.reset(nullptr);
+    EXPECT_TRUE(!u);
+}
+
+TEST(Gobj_ptr, sizeoftest)
+{
+    EXPECT_EQ(sizeof(GObject*), sizeof(gobj_ptr<GObject>));
+}
+
+TEST(Gobj_ptr, deleter)
+{
+    gobj_ptr<GObject> u1;
+    EXPECT_TRUE(g_object_unref == u1.get_deleter());
+}
+
+int main(int argc, char** argv)
+{
+    ::testing::InitGoogleTest(&argc, argv);
+    return RUN_ALL_TESTS();
+}
+
+#pragma GCC diagnostic pop
 
=== modified file 'test/gtest/scopes/internal/smartscopes/SmartScopesClient/SmartScopesClient_test.cpp'
--- test/gtest/scopes/internal/smartscopes/SmartScopesClient/SmartScopesClient_test.cpp	2016-02-29 15:57:12 +0000
+++ test/gtest/scopes/internal/smartscopes/SmartScopesClient/SmartScopesClient_test.cpp	2016-06-17 07:24:44 +0000
@@ -130,13 +130,41 @@
     EXPECT_EQ(nullptr, scopes[2].art);
     EXPECT_FALSE(scopes[2].invisible);
     EXPECT_EQ(nullptr, scopes[2].appearance);
-    EXPECT_EQ("[{\"displayName\":\"Location\",\"id\":\"location\",\"parameters\":{\"defaultValue\":"
-              "\"London\"},\"type\":\"string\"},{\"displayName\":\"Temperature Units\",\"id\":"
-              "\"unitTemp\",\"parameters\":{\"defaultValue\":1,\"values\":[\"Celsius\",\"Fahrenheit"
-              "\"]},\"type\":\"list\"},{\"displayName\":\"Age\",\"id\":\"age\",\"parameters\":{"
-              "\"defaultValue\":23},\"type\":\"number\"},{\"displayName\":\"Enabled\",\"id\":"
-              "\"enabled\",\"parameters\":{\"defaultValue\":true},\"type\":\"boolean\"}]\n",
-              *scopes[2].settings);
+    {
+        JsonCppNode node(*scopes[2].settings);
+        Variant v = node.to_variant();
+
+        VariantMap vm = v.get_array()[0].get_dict();
+        EXPECT_EQ("Location", vm["displayName"].get_string());
+        EXPECT_EQ("location", vm["id"].get_string());
+        EXPECT_EQ("string", vm["type"].get_string());
+        VariantMap params = vm["parameters"].get_dict();
+        EXPECT_EQ("London", params["defaultValue"].get_string());
+
+        vm = v.get_array()[1].get_dict();
+        EXPECT_EQ("Temperature Units", vm["displayName"].get_string());
+        EXPECT_EQ("unitTemp", vm["id"].get_string());
+        EXPECT_EQ("list", vm["type"].get_string());
+        params = vm["parameters"].get_dict();
+        EXPECT_EQ(1, params["defaultValue"].get_int());
+        VariantArray choices = params["values"].get_array();
+        EXPECT_EQ("Celsius", choices[0].get_string());
+        EXPECT_EQ("Fahrenheit", choices[1].get_string());
+
+        vm = v.get_array()[2].get_dict();
+        EXPECT_EQ("Age", vm["displayName"].get_string());
+        EXPECT_EQ("age", vm["id"].get_string());
+        EXPECT_EQ("number", vm["type"].get_string());
+        params = vm["parameters"].get_dict();
+        EXPECT_EQ(23, params["defaultValue"].get_int());
+
+        vm = v.get_array()[3].get_dict();
+        EXPECT_EQ("Enabled", vm["displayName"].get_string());
+        EXPECT_EQ("enabled", vm["id"].get_string());
+        EXPECT_EQ("boolean", vm["type"].get_string());
+        params = vm["parameters"].get_dict();
+        EXPECT_TRUE(params["defaultValue"].get_bool());
+    }
     ASSERT_EQ(4, scopes[2].keywords.size());
     EXPECT_NE(scopes[2].keywords.end(), scopes[2].keywords.find("music"));
     EXPECT_NE(scopes[2].keywords.end(), scopes[2].keywords.find("video"));
@@ -392,10 +420,30 @@
     EXPECT_EQ("widget_id_C", columns[2][2][0]);
 
     ASSERT_EQ(3u, widgets.size());
-
-    EXPECT_EQ("{\"id\":\"widget_id_A\",\"text\":\"First widget.\",\"title\":\"Widget A\",\"type\":\"text\"}\n", widgets[0]);
-    EXPECT_EQ("{\"id\":\"widget_id_B\",\"text\":\"Second widget.\",\"title\":\"Widget B\",\"type\":\"text\"}\n", widgets[1]);
-    EXPECT_EQ("{\"id\":\"widget_id_C\",\"text\":\"Third widget.\",\"title\":\"Widget C\",\"type\":\"text\"}\n", widgets[2]);
+    {
+        auto json = widgets[0];
+        JsonCppNode node(json);
+        EXPECT_EQ("widget_id_A", node.get_node("id")->as_string());
+        EXPECT_EQ("First widget.", node.get_node("text")->as_string());
+        EXPECT_EQ("Widget A", node.get_node("title")->as_string());
+        EXPECT_EQ("text", node.get_node("type")->as_string());
+    }
+    {
+        auto json = widgets[1];
+        JsonCppNode node(json);
+        EXPECT_EQ("widget_id_B", node.get_node("id")->as_string());
+        EXPECT_EQ("Second widget.", node.get_node("text")->as_string());
+        EXPECT_EQ("Widget B", node.get_node("title")->as_string());
+        EXPECT_EQ("text", node.get_node("type")->as_string());
+    }
+    {
+        auto json = widgets[2];
+        JsonCppNode node(json);
+        EXPECT_EQ("widget_id_C", node.get_node("id")->as_string());
+        EXPECT_EQ("Third widget.", node.get_node("text")->as_string());
+        EXPECT_EQ("Widget C", node.get_node("title")->as_string());
+        EXPECT_EQ("text", node.get_node("type")->as_string());
+    }
 }
 
 TEST_F(SmartScopesClientTest, consecutive_searches)