2025-01-22  Rolf Ade  <[email protected]>

        Added the "virtual" JSON type BOOLEAN for text nodes. If the
        text node value is a boolean in the sense of Tcl then the node
        serialize to the approprate JSON type. Otherwise it will be a
        JSON string.

2025-01-15  Rolf Ade  <[email protected]>

        Added the flag -notempty to dom createNodeCmd. If this flag is
        used the element will only appear in the tree if it is not
        empty. 

<syntax>
<cmd>textNodeCmd</cmd> ?-disableOutputEscaping? <m>?data?</m>
</syntax>

<p>If the json type of the created text node is NULL, TRUE or FALSE
then the <m>data</m> argument is optional, otherwise it this argument
must be given.</p>

<p>If the json type of the created text node is the virtual type
BOOLEAN then if the text value is a boolean as recognized by
Tcl_GetBooleanFromObj() the json value will according and if the text
node value is not a boolean value understood by Tcl the value will be
writen as json string.</p>

<p>If the optional flag <m>-disableOutputEscaping</m> is given, the
escaping of the ampersand character (&amp;) and the left angle bracket (&lt;)
inside the data is disabled. You should use this flag carefully.</p>

<p>If the first argument of the method is <m>commentNode</m> or 
<m>cdataNode</m> the command will create an comment node or CDATA section 

#define JSON_ARRAY 1
#define JSON_OBJECT 2
#define JSON_NULL 3
#define JSON_TRUE 4
#define JSON_FALSE 5
#define JSON_STRING 6
#define JSON_NUMBER 7
#define JSON_BOOLEAN 8

domDocument *
JSON_Parse (
    char *json,    /* Complete text of the json string being parsed */
    char *documentElement, /* name of the root element, may be NULL */
    int   maxnesting,
    char **errStr,

        "NONE",
        "ARRAY",
        "OBJECT",
        "NULL",
        "TRUE",
        "FALSE",
        "STRING",
        "NUMBER",
        "BOOLEAN"
    };

    if (objc < 3 ) {
        goto usage;
    }

    while (objc > 3) {

            } else {
                type = TEXT_NODE;
            }
        } else {
            if (jsonType < 3 && jsonType > 0) {
                Tcl_SetResult(interp, "For a text node the jsonType "
                              "argument must be one out of this list: "
                              "TRUE FALSE NULL NUMBER STRING NONE or BOOLEAN",
                              NULL);
                return TCL_ERROR;
            }
            type = TEXT_NODE;
        }
        break;
    case CDS_NODE: 

    "ARRAY",
    "OBJECT",
    "NULL",
    "TRUE",
    "FALSE",
    "STRING",
    "NUMBER",
    "BOOLEAN",
    NULL
};

/*----------------------------------------------------------------------------
|   Types
|
\---------------------------------------------------------------------------*/

    int          indent,
    int          outputFlags,
    int          level,
    int          inside
    )
{
    domTextNode *textNode;
    Tcl_Obj *valueObj;
    int bool;
    
    switch (node->nodeType) {
    case TEXT_NODE:
        if (inside == JSON_OBJECT) {
            /* We're inside a JSON object. A text node can not be
             * meaningful interpreted as member of an object. Ignore
             * the node */

            break;
        case JSON_TRUE:
            writeChars(jstring, channel, "true",4);
            break;
        case JSON_FALSE:
            writeChars(jstring, channel, "false",5);
            break;
        case JSON_BOOLEAN:
            valueObj = Tcl_NewStringObj (textNode->nodeValue,
                                         textNode->valueLength);
            if (Tcl_GetBooleanFromObj(NULL, valueObj, &bool) == TCL_OK) {
                if (bool) {
                    writeChars(jstring, channel, "true",4);
                } else {
                    writeChars(jstring, channel, "false",5);
                }
                Tcl_DecrRefCount (valueObj);
                break;
            }
            Tcl_DecrRefCount (valueObj);
            /* Fall through */
        case JSON_STRING:
            /* Fall through */
        default:
            tcldom_AppendEscapedJSON (jstring, channel,
                                      textNode->nodeValue,
                                      textNode->valueLength);
            break;

                        return TCL_ERROR;
                    }
                }
                node->info = jsonType;
                SetIntResult(jsonType);
                return TCL_OK;
            }
            if (node->info > 8) {
                SetResult(jsonTypes[0]);
            } else {
                SetResult(jsonTypes[node->info]);
            }
            return TCL_OK;
            
        TDomThreaded(

        "NONE",
        "ARRAY",
        "OBJECT",
        "NULL",
        "TRUE",
        "FALSE",
        "STRING",
        "NUMBER",
        "BOOLEAN"
    };

    Tcl_ResetResult (interp);

    /*------------------------------------------------------------------------
    |   Need parent node to get the owner document and to append new 
    |   child tag to it. The current parent node is stored on the stack.

    catch {dom createDocumentNode -foo NULL docNode} errMsg
    set errMsg
} {bad option "-foo": must be -jsonType}

test dom-8.11 {createDocumentNode} {
    catch {dom createDocumentNode -jsonType FOO docNode} errMsg
    set errMsg
} {bad jsonType "FOO": must be NONE, ARRAY, OBJECT, NULL, TRUE, FALSE, STRING, NUMBER, or BOOLEAN}

test dom-8.12 {createDocumentNode - method check} {
    set docNode [dom createDocumentNode]
    set result [$docNode documentElement]
    $docNode delete
    set result
} {}

    dom createNodeCmd textNode    t
    dom createNodeCmd -jsonType TRUE textNode true
    dom createNodeCmd -jsonType FALSE textNode false
    dom createNodeCmd -jsonType NULL textNode null
    dom createNodeCmd -jsonType NUMBER textNode number
    dom createNodeCmd cdataNode   cdata
    dom createNodeCmd piNode      pi
    dom createNodeCmd -jsonType BOOLEAN textNode boolean
}

test json-1.1 {Parse JSON} {
    set doc [dom parse -json {{"a":"avalue","b":"bvalue","c":0.123}}]
    set result [$doc asXML -indent none]
    $doc delete
    set result

        nodeCmds::null
        nodeCmds::true
        nodeCmds::false
    }
    set result [$doc asXML -indent none]
    $doc delete
    set result
} {<doc/>}

test json-8.10 {text node json type BOOLEAN} {
    set doc [dom createDocumentNode]
    $doc jsonType ARRAY
    $doc appendFromScript {
        nodeCmds::boolean foo
        nodeCmds::boolean true
        nodeCmds::boolean false
    }
    set result [$doc asJSON]
    $doc delete
    set result
} {["foo",true,false]}

test json-8.11 {text node json type BOOLEAN} {
    set doc [dom createDocumentNode]
    $doc jsonType ARRAY
    foreach value {foo 1 0} {
        set newtextnode [$doc createTextNode $value]
        $newtextnode jsonType BOOLEAN
        $doc appendChild $newtextnode
    }
    set result [$doc asJSON]
    $doc delete
    set result
} {["foo",true,false]}

test json-8.12 {text node json type BOOLEAN} {
    set doc [dom createDocumentNode]
    $doc jsonType ARRAY
    $doc appendFromScript {
        foreach value {foo 1 0 true false TRue falSE yes no YES NO bar} {
            nodeCmds::boolean $value
        }
    }
    set result [$doc asJSON]
    $doc delete
    set result
} {["foo",true,false,true,false,true,false,true,false,true,false,"bar"]}
}

test json-9.1 {cloneNode -deep} {
    dom parse -json {[["a",1,"b",{"foo":"bar","baz":"boo"},null],"",null]} doc
    dom createDocument some other
    $other documentElement root
    $root appendChild [[$doc firstChild] cloneNode -deep]