Merge branch 'devel'

include/curseOutput.hh

@@ -128,8 +128,6 @@ class CurseOutput
         unsigned int write(const int &x, const int &y, JSonElement *item, unsigned int maxWidth, const OutputFlag);
         virtual unsigned int write(const int &x, const int &y, const std::string &item, const size_t len, unsigned int maxWidth, const OutputFlag) =0;
         virtual unsigned int write(const int &x, const int &y, const char item, unsigned int maxWidth, const OutputFlag) =0;
-        virtual bool writeKey(const std::string &key, const size_t keylen, const std::string &after, const size_t afterlen, t_Cursor &cursor, const t_Cursor &maxWidth, OutputFlag) =0;
-        virtual bool writeKey(const std::string &key, const size_t keylen, const std::string &after, t_Cursor &cursor, const t_Cursor &maxWidth, OutputFlag);
 
         /**
          * prompt for user input, and return it

include/curseSimpleOutput.hh

@@ -42,6 +42,7 @@ class CurseSimpleOutput: public CurseOutput
         void write(const std::string &str, const OutputFlag flags) const;
         bool writeKey(const std::string &key, const size_t keylen, t_Cursor &cursor, const t_Cursor &maxWidth, OutputFlag, unsigned int extraLen =0);
         bool writeKey(const std::string &key, const size_t keylen, const std::string &after, size_t afterlen, t_Cursor &cursor, const t_Cursor &maxSize, OutputFlag flags);
+        bool writeKey(const std::string &key, const size_t keylen, const std::string &after, t_Cursor &cursor, const t_Cursor &maxWidth, OutputFlag);
         bool writeContainer(t_Cursor &, const t_Cursor &maxSize, const JSonContainer *);
         bool writeContent(t_Cursor &cursor, const t_Cursor &maxSize, std::list<JSonElement *> * obj);
         bool redraw(t_Cursor &, const t_Cursor &, JSonElement *);

include/curseSplitOutput.hh

@@ -7,6 +7,7 @@
 #include "jsonContainer.hh"
 
 class LevenshteinMatrice_base;
+class JSonObjectEntry;
 
 typedef struct
 {
@@ -36,16 +37,17 @@ class CurseSplitOutput: public CurseOutput
         void checkSelection(const JSonElement *item);
 
         bool redraw();
-        bool redraw(const t_Cursor &screenSize, std::pair<int, JSonContainer *> &);
-        bool redraw(const t_Cursor &screenSize, JSonElement *);
+        bool redraw(t_subWindow &, const t_Cursor &screenSize, std::pair<int, JSonContainer *> &);
+        bool redraw(t_subWindow &, const t_Cursor &screenSize, JSonElement *);
         const Optional<bool> redrawOneItemToWorkingWin(t_subWindow &w, const t_Cursor &);
         bool isAdded(const std::pair<int, JSonContainer *> &) const;
         bool isAdded(const JSonElement *e) const;
 
         bool writeContainer(const t_Cursor &maxSize, JSonContainer *, bool opening = true);
-        bool writeContent(const t_Cursor &maxSize, std::list<JSonElement*> *_item);
-        bool writeKey(const std::string &key, const size_t keylen, const t_Cursor &maxSize, OutputFlag flags, unsigned int extraLen =0);
-        bool writeKey(const std::string &key, const size_t keylen, const std::string &after, const size_t afterlen, t_Cursor &cursor, const t_Cursor &maxWidth, OutputFlag);
+        bool writeObjectEntry(t_subWindow &w, const t_Cursor &maxSize, JSonObjectEntry *item);
+        bool writeKey(t_subWindow &, const std::string &key, const size_t keylen, const t_Cursor &maxSize, OutputFlag flags, unsigned int extraLen =0);
+        bool writeKey(t_subWindow &, const std::string &key, const size_t keylen, const std::string &after, const size_t afterlen, t_Cursor &cursor, const t_Cursor &maxWidth, OutputFlag);
+        bool writeKey(t_subWindow &, const std::string &key, const size_t keylen, const std::string &after, t_Cursor &cursor, const t_Cursor &maxWidth, OutputFlag);
         unsigned int write(const int &x, const int &y, const char item, unsigned int maxWidth, OutputFlag flags);
         unsigned int write(const int &x, const int &y, const std::string &str, const size_t strlen, unsigned int maxWidth, const OutputFlag flags);
         void write(const std::string &str, const OutputFlag flags) const;
@@ -103,8 +105,6 @@ class CurseSplitOutput: public CurseOutput
         **/
         unsigned short nbInputs, selectedWin, workingWin;
 
-        class reachNext {};
-
         // TODO t_subWindow &workingSubwin, &selectedSubwin ??
 };
 

src/curseOutput.cpp

@@ -143,11 +143,6 @@ bool CurseOutput::redraw(const std::string &errorMsg)
     return result;
 }
 
-bool CurseOutput::writeKey(const std::string &key, const size_t keylen, const std::string &after, t_Cursor &cursor, const t_Cursor &maxSize, OutputFlag flags)
-{
-    return writeKey(key, keylen, after, after.size(), cursor, maxSize, flags);
-}
-
 unsigned int CurseOutput::write(const int &x, const int &y, JSonElement *item, unsigned int maxWidth, OutputFlag flags)
 {
     return write(x, y, item->stringify(), item->lazystrlen(), maxWidth, flags);

src/curseSimpleOutput.cpp

@@ -255,10 +255,10 @@ bool CurseSimpleOutput::writeContent(t_Cursor &cursor, const t_Cursor &maxSize,
             {
                 if (dynamic_cast<JSonObject *>(**ent))
                 {
-                    if (!CurseOutput::writeKey(key, ent->lazystrlen(), "{ ... }", cursor, maxSize, CurseSimpleOutput::getFlag(ent)) || (cursor.second - scrollTop > 0 && (cursor.second - scrollTop) > maxSize.second -1))
+                    if (!writeKey(key, ent->lazystrlen(), "{ ... }", cursor, maxSize, CurseSimpleOutput::getFlag(ent)) || (cursor.second - scrollTop > 0 && (cursor.second - scrollTop) > maxSize.second -1))
                         break;
                 }
-                else if (!CurseOutput::writeKey(key, ent->lazystrlen(), "[ ... ]", cursor, maxSize, CurseSimpleOutput::getFlag(ent)) || (cursor.second - scrollTop > 0 && (cursor.second - scrollTop) > maxSize.second -1))
+                else if (!writeKey(key, ent->lazystrlen(), "[ ... ]", cursor, maxSize, CurseSimpleOutput::getFlag(ent)) || (cursor.second - scrollTop > 0 && (cursor.second - scrollTop) > maxSize.second -1))
                     break;
             }
             else if (!isContainer)
@@ -271,10 +271,10 @@ bool CurseSimpleOutput::writeContent(t_Cursor &cursor, const t_Cursor &maxSize,
             {
                 if (dynamic_cast<const JSonObject *>(**ent) )
                 {
-                    if (!CurseOutput::writeKey(key, ent->lazystrlen(), "{ }", cursor, maxSize, CurseSimpleOutput::getFlag(ent)) || (cursor.second - scrollTop > 0 && (cursor.second - scrollTop) > maxSize.second -1))
+                    if (!writeKey(key, ent->lazystrlen(), "{ }", cursor, maxSize, CurseSimpleOutput::getFlag(ent)) || (cursor.second - scrollTop > 0 && (cursor.second - scrollTop) > maxSize.second -1))
                         break;
                 }
-                else if (!CurseOutput::writeKey(key, ent->lazystrlen(), "[ ]", cursor, maxSize, CurseSimpleOutput::getFlag(ent)) || (cursor.second - scrollTop > 0 && (cursor.second - scrollTop) > maxSize.second -1))
+                else if (!writeKey(key, ent->lazystrlen(), "[ ]", cursor, maxSize, CurseSimpleOutput::getFlag(ent)) || (cursor.second - scrollTop > 0 && (cursor.second - scrollTop) > maxSize.second -1))
                     break;
             }
             else
@@ -341,6 +341,11 @@ bool CurseSimpleOutput::writeKey(const std::string &key, const size_t keylen, co
     return (cursor.second >= scrollTop || (cursor.second - scrollTop) <= maxSize.second);
 }
 
+bool CurseSimpleOutput::writeKey(const std::string &key, const size_t keylen, const std::string &after, t_Cursor &cursor, const t_Cursor &maxSize, OutputFlag flags)
+{
+    return writeKey(key, keylen, after, after.size(), cursor, maxSize, flags);
+}
+
 unsigned int CurseSimpleOutput::write(const int &x, const int &y, const char item, unsigned int maxWidth, OutputFlag flags)
 {
     int offsetY = y - scrollTop;

src/curseSplitOutput.cpp

@@ -237,6 +237,8 @@ inputResult CurseSplitOutput::changeWindow(char d, bool c)
         return inputResult::nextInput;
     selectedWin = (selectedWin +d) % nbInputs;
     t_subWindow &w = subWindows.at(selectedWin);
+
+    //Restore selection
     if (!w.selection)
     {
         size_t i =0;
@@ -279,7 +281,7 @@ void CurseSplitOutput::checkSelection(const JSonElement *item)
                 w.lastSelection != parent &&
                 dynamic_cast<const JSonObjectEntry*>(parent))
             item = parent;
-        if (!parent || !dynamic_cast<const JSonObjectEntry*>(parent))
+        if (!item->getParent() || !dynamic_cast<const JSonObjectEntry*>(item->getParent()))
             w.select_down = item;
     }
 }
@@ -374,18 +376,14 @@ const Optional<bool> CurseSplitOutput::redrawOneItemToWorkingWin(t_subWindow &w,
 
     try {
         if (w.parentsIterators.empty())
-            result = redraw(screenSize, w.root);
+            result = redraw(w, screenSize, w.root);
         else
-            result = redraw(screenSize, w.parentsIterators.top());
+            result = redraw(w, screenSize, w.parentsIterators.top());
     }
     catch (SelectionOutOfRange &e)
     {
         return Optional<bool>::empty;
     }
-    catch (CurseSplitOutput::reachNext &)
-    {
-        result = true;
-    }
     if (!result || w.parentsIterators.empty())
     {
         if (!result)
@@ -507,102 +505,31 @@ bool CurseSplitOutput::writeContainer(const t_Cursor &maxSize, JSonContainer *it
     else
         memcpy(childDelimiter, "[]", sizeof(*childDelimiter) * 2);
 
-    if (!opening)
+    if (!opening) // Display close brackets
     {
         w.cursor.first -= INDENT_LEVEL;
         w.cursor.second += write(w.cursor.first, w.cursor.second, childDelimiter[1], maxSize.first, CurseSplitOutput::getFlag(item));
     }
-    else if (collapsed.find((const JSonContainer *)item) != collapsed.end())
+    else if (collapsed.find((const JSonContainer *)item) != collapsed.end()) // inline collapsed
     {
         std::string ss;
         ss.append(&childDelimiter[0], 1).append(" ... ").append(&childDelimiter[1], 1);
         w.cursor.second += write(w.cursor.first, w.cursor.second, ss, 7, maxSize.first, CurseSplitOutput::getFlag(item));
     }
-    else
+    else // Display open brackets
     {
         w.cursor.second += write(w.cursor.first, w.cursor.second, childDelimiter[0], maxSize.first, CurseSplitOutput::getFlag(item));
         if (w.cursor.second > w.scrollTop && (w.cursor.second - w.scrollTop) > maxSize.second -1)
             return false;
         w.parentsIterators.push(std::pair<int, JSonContainer *>(-1, item));
-        if (!writeContent(maxSize, (std::list<JSonElement *> *)item))
-        {
-            w.parentsIterators.pop();
-            return false;
-        }
-        w.parentsIterators.pop();
-        w.cursor.second += write(w.cursor.first, w.cursor.second, childDelimiter[1], maxSize.first, CurseSplitOutput::getFlag(item));
+        w.cursor.first += INDENT_LEVEL;
+        return true;
     }
     return (w.cursor.second < w.scrollTop || (w.cursor.second - w.scrollTop) <= maxSize.second -1);
 }
 
-bool CurseSplitOutput::writeContent(const t_Cursor &maxSize, std::list<JSonElement*> *_item)
-{
-    t_subWindow &w = subWindows.at(workingWin);
-    JSonContainer *item = (JSonContainer *)_item;
-    bool containerIsObject = (dynamic_cast<JSonObject *>(item) != nullptr);
-    bool result = true;
-    w.cursor.first += INDENT_LEVEL;
-    const unsigned int scrollTop = w.scrollTop;
-
-    for (JSonElement *i : *item)
-    {
-        result = false;
-        if (containerIsObject)
-        {
-            JSonObjectEntry *ent = (JSonObjectEntry*) i;
-            bool isContainer = (dynamic_cast<JSonContainer *>(**ent) != nullptr);
-            std::string key = ent->stringify();
-            checkSelection(ent);
-            if (isContainer && collapsed.find((JSonContainer*)(**ent)) != collapsed.cend())
-            {
-                if (dynamic_cast<JSonObject *>(**ent))
-                {
-                    if (!CurseOutput::writeKey(key, ent->lazystrlen(), "{ ... }", w.cursor, maxSize, CurseSplitOutput::getFlag(ent)) || (w.cursor.second > scrollTop && (w.cursor.second - scrollTop) > maxSize.second -1))
-                        break;
-                }
-                else if (!CurseOutput::writeKey(key, ent->lazystrlen(), "[ ... ]", w.cursor, maxSize, CurseSplitOutput::getFlag(ent)) || (w.cursor.second > scrollTop && (w.cursor.second - scrollTop) > maxSize.second -1))
-                    break;
-            }
-            else if (!isContainer)
-            {
-                JSonElement *eContent = **ent;
-                if (!writeKey(key, ent->lazystrlen(), eContent->stringify(), eContent->lazystrlen(), w.cursor, maxSize, CurseSplitOutput::getFlag(ent)) || (w.cursor.second > scrollTop && (w.cursor.second - scrollTop) > maxSize.second -1))
-                    break;
-            }
-            else if (((JSonContainer*)(**ent))->size() == 0)
-            {
-                if (dynamic_cast<const JSonObject *>(**ent) )
-                {
-                    if (!CurseOutput::writeKey(key, ent->lazystrlen(), "{ }", w.cursor, maxSize, CurseSplitOutput::getFlag(ent)) || (w.cursor.second > scrollTop && (w.cursor.second - scrollTop) > maxSize.second -1))
-                        break;
-                }
-                else if (!CurseOutput::writeKey(key, ent->lazystrlen(), "[ ]", w.cursor, maxSize, CurseSplitOutput::getFlag(ent)) || (w.cursor.second > scrollTop && (w.cursor.second - scrollTop) > maxSize.second -1))
-                    break;
-            }
-            else
-            {
-                if (!writeKey(key, ent->lazystrlen(), maxSize, getFlag(ent)))
-                    break;
-                const JSonElement *saveSelection = w.lastSelection;
-                if (saveSelection == ent)
-                    w.selection = w.lastSelection = **ent;
-                w.cursor.first += INDENT_LEVEL /2;
-                throw CurseSplitOutput::reachNext();
-            }
-        }
-        else
-            throw CurseSplitOutput::reachNext();
-        result = true;
-    }
-    w.cursor.first -= INDENT_LEVEL;
-    //result will be false if for loop break'd at some time, true otherwise
-    return result;
-}
-
-bool CurseSplitOutput::writeKey(const std::string &key, const size_t keylen, const t_Cursor &maxSize, OutputFlag flags, unsigned int extraLen)
+bool CurseSplitOutput::writeKey(t_subWindow &w, const std::string &key, const size_t keylen, const t_Cursor &maxSize, OutputFlag flags, unsigned int extraLen)
 {
-    t_subWindow &w = subWindows.at(workingWin);
-
     if (w.cursor.second <= w.scrollTop)
     {
         w.cursor.second++;
@@ -617,10 +544,8 @@ bool CurseSplitOutput::writeKey(const std::string &key, const size_t keylen, con
     return (w.cursor.second < w.scrollTop || (w.cursor.second - w.scrollTop) <= maxSize.second);
 }
 
-bool CurseSplitOutput::writeKey(const std::string &key, const size_t keylen, const std::string &after, const size_t afterlen, t_Cursor &cursor, const t_Cursor &maxWidth, OutputFlag flags)
+bool CurseSplitOutput::writeKey(t_subWindow &w, const std::string &key, const size_t keylen, const std::string &after, const size_t afterlen, t_Cursor &cursor, const t_Cursor &maxWidth, OutputFlag flags)
 {
-    t_subWindow &w = subWindows.at(workingWin);
-
     if (cursor.second <= w.scrollTop)
     {
         cursor.second++;
@@ -637,6 +562,11 @@ bool CurseSplitOutput::writeKey(const std::string &key, const size_t keylen, con
     return (cursor.second < w.scrollTop || (cursor.second - w.scrollTop) <= maxWidth.second);
 }
 
+bool CurseSplitOutput::writeKey(t_subWindow &w, const std::string &key, const size_t keylen, const std::string &after, t_Cursor &cursor, const t_Cursor &maxWidth, OutputFlag flags)
+{
+    return writeKey(w, key, keylen, after, after.length(), cursor, maxWidth, flags);
+}
+
 bool CurseSplitOutput::isAdded(const JSonElement *e) const
 {
     return diffMatrice->getEquivalence(e) == nullptr;
@@ -653,51 +583,81 @@ bool CurseSplitOutput::isAdded(const std::pair<int, JSonContainer *> &item) cons
     return isAdded(e);
 }
 
-bool CurseSplitOutput::redraw(const t_Cursor &maxSize, std::pair<int, JSonContainer *> &item)
+bool CurseSplitOutput::redraw(t_subWindow &w, const t_Cursor &maxSize, std::pair<int, JSonContainer *> &item)
 {
-    t_subWindow &w = subWindows.at(workingWin);
     JSonElement *currentItem;
 
     (item.first)++;
     if ((unsigned int) item.first == item.second->size())
     {
         w.parentsIterators.pop();
-        if (!writeContainer(maxSize, item.second, false))
-            return false;
-        throw CurseSplitOutput::reachNext();
+        return writeContainer(maxSize, item.second, false);
     }
     currentItem = list_at<JSonElement*>(*(item.second), item.first);
-    checkSelection(currentItem);
-    if (dynamic_cast<const JSonContainer*>(currentItem))
+    return redraw(w, maxSize, currentItem);
+}
+
+bool CurseSplitOutput::redraw(t_subWindow &w, const t_Cursor &maxSize, JSonElement *item)
+{
+    checkSelection(item);
+    if (dynamic_cast<const JSonContainer*>(item))
     {
-        if (!writeContainer(maxSize, (JSonContainer*) currentItem))
+        if (!writeContainer(maxSize, (JSonContainer *) item))
             return false;
     }
+    else if (dynamic_cast<JSonObjectEntry*>(item))
+    {
+        return writeObjectEntry(w, maxSize, (JSonObjectEntry*) item);
+    }
     else
     {
-        w.cursor.second += CurseOutput::write(w.cursor.first, w.cursor.second, currentItem, maxSize.first, CurseSplitOutput::getFlag(currentItem));
+        w.cursor.second += CurseOutput::write(w.cursor.first, w.cursor.second, item, maxSize.first, CurseSplitOutput::getFlag(item));
         if (w.cursor.second > w.scrollTop && (w.cursor.second - w.scrollTop) > maxSize.second -1)
             return false;
     }
     return true;
 }
 
-bool CurseSplitOutput::redraw(const t_Cursor &maxSize, JSonElement *item)
+bool CurseSplitOutput::writeObjectEntry(t_subWindow &w, const t_Cursor &maxSize, JSonObjectEntry *ent)
 {
-    checkSelection(item);
-    if (dynamic_cast<const JSonContainer*>(item))
+    bool isContainer = (dynamic_cast<JSonContainer *>(**ent) != nullptr);
+    std::string key = ent->stringify();
+
+    if (isContainer && collapsed.find((JSonContainer*)(**ent)) != collapsed.cend()) // inline collapsed container
     {
-        if (!writeContainer(maxSize, (JSonContainer *) item))
+        if (dynamic_cast<JSonObject *>(**ent))
+        {
+            if (!writeKey(w, key, ent->lazystrlen(), "{ ... }", w.cursor, maxSize, getFlag(ent)) || (w.cursor.second > w.scrollTop && (w.cursor.second - w.scrollTop) > maxSize.second -1))
+                return false;
+        }
+        else if (!writeKey(w, key, ent->lazystrlen(), "[ ... ]", w.cursor, maxSize, getFlag(ent)) || (w.cursor.second > w.scrollTop && (w.cursor.second - w.scrollTop) > maxSize.second -1))
             return false;
     }
-    else
+    else if (!isContainer) // inline value
     {
-        t_subWindow &w = subWindows.at(workingWin);
-
-        w.cursor.second += CurseOutput::write(w.cursor.first, w.cursor.second, item, maxSize.first, CurseSplitOutput::getFlag(item));
-        if (w.cursor.second > w.scrollTop && (w.cursor.second - w.scrollTop) > maxSize.second -1)
+        JSonElement *eContent = **ent;
+        if (!writeKey(w, key, ent->lazystrlen(), eContent->stringify(), eContent->lazystrlen(), w.cursor, maxSize, getFlag(ent))
+                || (w.cursor.second > w.scrollTop && (w.cursor.second - w.scrollTop) > maxSize.second -1))
             return false;
     }
+    else if (((JSonContainer*)(**ent))->size() == 0) // inline empty
+    {
+        if (dynamic_cast<const JSonObject *>(**ent) )
+        {
+            if (!writeKey(w, key, ent->lazystrlen(), "{ }", w.cursor, maxSize, getFlag(ent)) || (w.cursor.second > w.scrollTop && (w.cursor.second - w.scrollTop) > maxSize.second -1))
+                return false;
+        }
+        else if (!writeKey(w, key, ent->lazystrlen(), "[ ]", w.cursor, maxSize, getFlag(ent)) || (w.cursor.second > w.scrollTop && (w.cursor.second - w.scrollTop) > maxSize.second -1))
+            return false;
+    }
+    else // Container
+    {
+        if (!writeKey(w, key, ent->lazystrlen(), maxSize, getFlag(ent)))
+            return false;
+        writeContainer(maxSize, (JSonContainer*)(**ent), true);
+    }
+    if (w.cursor.second > w.scrollTop && (w.cursor.second - w.scrollTop) > maxSize.second -1)
+        return false;
     return true;
 }
 
@@ -856,7 +816,8 @@ const OutputFlag CurseSplitOutput::getFlag(const JSonElement *item, const JSonEl
     OutputFlag res;
     const JSonElement *i = dynamic_cast<const JSonObjectEntry*>(item) ? **((const JSonObjectEntry*)item) : item;
 
-    res.selected(item == selection);
+    res.selected(item == selection
+            || (item->getParent() && dynamic_cast<const JSonObjectEntry*>(item->getParent()) && selection == item->getParent()));
     res.searched(std::find(subWindows.at(selectedWin).searchResults.cbegin(),
                 subWindows.at(selectedWin).searchResults.cend(),
                 item) != subWindows.at(selectedWin).searchResults.cend());

src/levenshtein.cpp

@@ -84,12 +84,16 @@ LevenshteinMatrice_base *LevenshteinMatrice_base::Builder::build(const JSonEleme
     {
         const bool aIsObject = ((dynamic_cast<const JSonObjectEntry*>(a)) != nullptr);
         const bool bIsObject = ((dynamic_cast<const JSonObjectEntry*>(b)) != nullptr);
-        float result = levenshteinPercent(a->stringify(), b->stringify());
 
-        if (aIsObject && bIsObject) {
-            result *= levenshteinPercent((*(const JSonObjectEntry&)(*a))->stringify(), (*(const JSonObjectEntry&)(*b))->stringify());
+        if (aIsObject && bIsObject)
+        {
+            if (a->stringify() == b->stringify() && (*(const JSonObjectEntry&)(*a))->stringify() == (*(const JSonObjectEntry&)(*b))->stringify())
+                return LevenshteinMatrice_base::Builder::build(*(const JSonObjectEntry&)(*a), *(const JSonObjectEntry&)(*b));
+            return new LevenshteinMatriceWithScore(0.f, a, b);
         }
-        return new LevenshteinMatriceWithScore(result, a, b);
+        else if (aIsObject || bIsObject)
+            return new LevenshteinMatriceWithScore(0.f, a, b);
+        return new LevenshteinMatriceWithScore(levenshteinPercent(a->stringify(), b->stringify()), a, b);
     }
 }
 

test/testDiffObj.1.json

@@ -0,0 +1,11 @@
+{
+    "a": true
+    ,"b": true
+    ,"c": false
+    ,"d": [
+        1
+        ,2
+        ,3
+        ,4
+    ]
+}

test/testDiffObj.2.json

@@ -0,0 +1,11 @@
+{
+    "a": false
+    ,"b": true
+    ,"c": null
+    ,"d": [
+        4
+        ,2
+        ,7
+        ,4
+    ]
+}

test/testDiffObj.3.json

@@ -0,0 +1,5 @@
+{
+    "a": true
+    ,"b": true
+    ,"c": false
+}

test/testDiffObj.4.json

@@ -0,0 +1,5 @@
+{
+    "a": null
+    ,"b": true
+    ,"c": false
+}

test/testDiffObj.5.json

@@ -0,0 +1,11 @@
+{
+    "a": false
+    ,"b": false
+    ,"c": true
+    ,"d": {
+        "1": 42
+        ,"2": 43
+        ,"3": 44
+        ,"4": 45
+    }
+}

test/testDiffObj.6.json

@@ -0,0 +1,11 @@
+{
+    "a": true
+    ,"b": true
+    ,"c": false
+    ,"d": {
+        "1": 46
+        ,"2": 47
+        ,"3": 48
+        ,"4": 49
+    }
+}

test/testDiffObjSimple.1.json

@@ -0,0 +1 @@
+{"a":[1, 3, 4]}

test/testDiffObjSimple.2.json

@@ -0,0 +1 @@
+{"a":[1, 2, 3]}

test/testDiffObjSimple.3.json

@@ -0,0 +1 @@
+{"a":[1, 2, 4]}

test/testDiffObjSimple.4.json

@@ -0,0 +1 @@
+{"a":[true, true, true]}