Demo JSON Library: "Lib_JSON.lg32"

[(X)]

I am trying to create a demo of a 100% GB32 library solution to Load, View, Edit and Save JSON data using a Treeview control.

The essential code should be packed into this library:"Lib_JSON.lg32"

I asked BING:

Given a json data file, how can we code functions in vb6 to load, view, edit and save the new json data to file using:

Dim scriptControl As Object
Set scriptControl = CreateObject("MSScriptControl.ScriptControl")
scriptControl.Language = "JScript"


Dim jsonParsed As Object
Set jsonParsed = scriptControl.Eval("(" & jsonResponse & ")")

BING's response:
' Create a ScriptControl object
Dim scriptControl As Object
Set scriptControl = CreateObject("MSScriptControl.ScriptControl")
scriptControl.Language = "JScript"

' Load JSON data from a file
Dim fileSystem As Object
Set fileSystem = CreateObject("Scripting.FileSystemObject")
Dim file As Object
Set file = fileSystem.OpenTextFile("path_to_your_json_file", 1)
Dim jsonResponse As String
jsonResponse = file.ReadAll
file.Close

' Parse JSON data
Dim jsonParsed As Object
Set jsonParsed = scriptControl.Eval("(" & jsonResponse & ")")

' View JSON data
' Assuming the JSON data is an array of objects
Dim i As Integer
For i = 0 To UBound(jsonParsed)
   Debug.Print jsonParsed(i)("key") ' Replace "key" with the actual key in your JSON data
Next i

' Edit JSON data
' Assuming the JSON data is an array of objects
jsonParsed(0)("key") = "new_value" ' Replace "key" with the actual key in your JSON data

' Save JSON data to a file
Dim jsonSerialized As String
jsonSerialized = scriptControl.Run("JSON.stringify", jsonParsed)
Set file = fileSystem.OpenTextFile("path_to_your_json_file", 2)
file.Write jsonSerialized
file.Close

I am looking into why BING suggested jsonParsed should be an array...

[Roger Cabo]

You cannot iterate through an Object in gb32. Methods are not accessible for any reason.



Dim scriptControl As Object
Set scriptControl = CreateObject("MSScriptControl.ScriptControl")
scriptControl.Language = "JScript"

Dim jsCode As String
jsCode = "function getValueByKey(json, key) {" & #13#10 & _
 "    return json[key] || 'Key not found';" & #13#10 & _
 "}"

scriptControl.AddCode jsCode

Dim jsonResponse As String
jsonResponse = "{""key1"": ""value1"", ""key2"": ""value2""}"

Dim jsonParsed As Object
Set jsonParsed = scriptControl.Eval("(" & jsonResponse & ")")

Dim searchKey As String
searchKey = "key1"

Dim keyValue As String
keyValue = scriptControl.Run("getValueByKey", jsonParsed, searchKey)

MsgBox "'" & searchKey & " = " & keyValue

I think you should write java code like in sql.

[Roger Cabo]

XML:

Let watch this XML example:

<a size="189" class="main-content" style="color:blue;"> Body
   <b woman="possibly"> Foot
       <c> Ears
       </c>
   </b>
   <z unwashed="don't know"> Foot
       <c> can fly
       </c>
   </z>
   <d> Arm
       <e> too long
       </e>
   </d>
</a>




Dim xmlDoc As Object
Set xmlDoc = CreateObject("MSXML2.DOMDocument")

Dim xmlPath As String
xmlPath = "C:\Users\X\Downloads\xml.txt"

// Load from path
°If Not xmlDoc.Load(xmlPath) Then
°  MsgBox "Error loading xml file"
°Else
°  '''
°End If

// Set from string. In this case you can get the complete content of a tag and explore as well
Dim xmlstr As String
xmlstr = "<a size=""189"" class=""main-content"" style=""color:blue;""> Body" & #13#10 & _
 "    <b woman=""possibly""> Foot" & #13#10 & _
 "        <c> Ears" & #13#10 & _
 "        </c>" & #13#10 & _
 "    </b>" & #13#10 & _
 "    <z unwashed=""don't know""> Foot" & #13#10 & _
 "        <c> can fly" & #13#10 & _
 "        </c>" & #13#10 & _
 "    </z>" & #13#10 & _
 "    <d> Arm" & #13#10 & _
 "        <e> too long" & #13#10 & _
 "        </e>" & #13#10 & _
 "        </d>" & #13#10 & _
 "</a>"
Debug
Debug xmlstr
Debug
Debug "---- Get the content of //b -----------------------"

If Not xmlDoc.LoadXML(xmlstr) Then
 MsgBox "Fehler beim Laden des XML-Strings!"
Else
End If

Dim node As Object
Set node = xmlDoc.SelectSingleNode("//b")
Debug.Show
If Not node Is Nothing Then
 Debug node.Text
Else
 Debug "Tag nicht gefunden"
EndIf

Debug
Debug "---- Now get the attributes of //a -----------------------"

Set node = xmlDoc.SelectSingleNode("//a")

If Not node Is Nothing Then
 Dim i As Integer
 For i = 0 To node.Attributes.Length - 1
   Dim attr As Object
   Set attr = node.Attributes.Item(i)
   Debug "Attribut: " & attr.Name & ", Wert: " & attr.Value
 Next i
Else
 Debug "Element <a> nicht gefunden"
End If

Stop


[(X)]

It seems access to JScript via GFA-BASIC 32 is a great asset.

The following code seems to do everything I want, but, it only goes part way.

' Parse JSON data
Dim jsonParsed As Object
Set jsonParsed = scriptControl.Eval("(" & jsonResponse & ")")
Then, if the JSON data is stored 'as an array', apparently, we need to switch to reading data into an array as if the JSON data will either be in nested format or record format when it could be in both or either, in the same data file.  So, in my mind, I don't see the full picture of how to use JScript to 'more easily'* accomplish my goal.

* This is 'my' fault for not knowing JScript well enough.

My goal:

I would like to be able to create a simple Home-Grown GB32 Library: "Lib_JSON.LG32" that can be imported into GB32 code to permit basic database actions: Load, View, Edit and Save JSON data using a Treeview control.

 

I have searched for BING and ChatGPT solutions but I only get half answers.

I was part way to getting a demo working a few days ago and I'm going to keep pushing in that direction.

If anyone has any suggestions or solutions feel free to 'chime in'.

[(X)]

I just watched a great video about JSON with Douglas Crockford; the man that invented it!

youtu.be/TjVcVWB0oFk?list=PLEzQf147-uEoNCeDlRrXv6ClsLDN-HtNm

[Roger Cabo]

I can provide some deeper info about JSON. There are some ugly pitfalls in JSON!

---------------

* I think, you want to build up an open source project?
* JSON can define Arrays inside Arrays! But the "Inside-Array" is not defined.
* The char codec should be always UTF8, and not ASCII.
* Can be as well UTF-16,UTF-32, ASCII. There is no info in JSON about the file format. You must simply guess by try by code!

Example: Variant Array 2x2x2

{
 "myArray": [
   [
     ["Hello", 42],         // Erste Ebene, 1. Array
     [3.14, true]           // Erste Ebene, 2. Array
   ],
   [
     [null, {"key": "value"}], // Zweite Ebene, 1. Array
     [[1, 2, 3], false] // SubArray, bool
   ]
 ]
}

   myArray[0][0][0] = "Hello"
   myArray[0][0][1] = 42
   myArray[0][1][0] = true
   myArray[0][1][1] = null             // Object or Collection =  null
   myArray[1][0][0] = 3.14
   myArray[1][0][1] = {"key": "value"} // Object type.
   myArray[1][1][0] = [1, 2, 3] (Here [1, 2, 3] the Sub Array) How ever this should be done.
   myArray[1][1][1] = false

a) In this case myArray[1][1][0] = is not defined. [1, 2, 3] could be subArray(0,0,0) or subArray(2)..

b) Then we have the special chars as content like "こんにちは" You must simply guess by any self written code if its UTF8,UTF16,UTF32, ASCII
The most JSON files are in UTF8 but not ASCII.

c)  A list of signs are should be pre "\"

   \" - Double quote
   \\ - Backslash
   \/ - Forward slash (though escaping forward slashes in JSON is not always necessary)
   \b - Backspace
   \f - Form feed
   \n - Line feed/New line
   \r - Carriage return
   \t - Horizontal tab
   \uXXXX - Unicode character (where XXXX is the hexadecimal Unicode number)


Perhaps this helps a bit to decide what to realize in the JSON (gfa32-lib)

[(X)]

I do want to make "Lib_JSON.LG32" 'open source' so I will provide an uncompiled G32 library file asap.

I am still working on a demo in straight GB32 code.

I am at the stage of generating a number based 'key' to 'point to' each JSON data key and value.

I am using for reference, Crockford's 'one page' reference to JSON standard:

www.json.org/json-en.html

[(X)]

OOOOh! What a find!

Apparently all the source code for a host of JSON functions in Pure Basic are laid out here:

www.purebasic.com/documentation/json/index.html

PureBasic - Json

Overview

The JSON library provides functions to parse, create or modify data in JSON format.

[(X)]

The GFA JSON Parser code is still in it's infancy, but, as they say: "First get it working then optimize."

This GFA based JSON Parser is able to read a JSON data file and display it in a Treeview Control.

What I thought was going to be a few days of work turned out to be bit of a marathon of trial and error.

My goal is to squeeze all of this into a library: "Lib_JSON" with minimal hassle for the coder to implement and provide an intuitive Treeview based user interface to Load, View, Edit and Save any JSON file.

[(X)]

Here are some of my guidelines / notes for this project.

Ideally, practically none of this will be exposed to the coder or user.  

They should only have to deal with the Treeview and various DB like commands.

Proc P_Notes

''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
'
' Some notes on this project.
'
''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
'
' THE MAIN QUEST:
'
' "Is it possible to produce a "Lib_JSON.LG32" GB32 for Windows library?"
'
' I'm basing my efforts on this website: www.json.org/json-en.html
'
''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
'
' FEATURES
'
' This GFA library should include:
'
' I/O FUNCTIONS
'
' - LOAD JSON file to: JSON String variable: sJSON
' - SAVE JSON String variable to: JSON file: fJSON
'
' PROCESSING FUNCTIONS
'
' - PARSE JSON String to: JSON Hash Table: H_JSON
' - ENCRYPT JSON file to: Encrypted File: eJSON
'
' INTERFACE
'
' A Treeview control to:
'
' - DISPLAY JSON data as a hierarchy
' - EDIT JSON data manually
' - DRAG_DROP JSON data
' - MOVE
' - COPY
' - PASTE
'
' DATABASE FUNCTIONS
'
' Lets the coder interact with names and values by 'key' or index to:
'
' - GET
' - SET
' - ADD
' - REMOVE
' - REPLACE
' - SEARCH
' - FILTER
' - SORT
' - LIST
' - REPORT
' - EMAIL
' - POST to: URL or Shared Drive.
' - SHARE to: Social Media
'
''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
'
' ABBREVIATIONS
'
' I've come up with some JSON component abbreviations, by using a string
' enclosed in: '<>'. For example: <0> for a null.
'
' ABBR. DESCRIPTION
' ======= ==================================================================
' <0> null
'
' <#> a number: {integer, floating point, sci-notation}.
' Ex: {1, 3.14, 2.99e8}
'
' <b> Boolean value: {true, false}
'
' <s> string, a set of characters* within double quotes: "".
' Ex: "some chrs"
' * may include 'escaped chrs' for CR, LF, Tab etc...
' Ex: "\r" == CR == Chr(13)
'
' <n> name, a string for a name or value within double quotes: "" .
'
' <v> value, can be: {<o>,<a>,<s>,<#>,<b>,<0>}
'
' <nvp> name value pair.
' Ex: <n>:<v>
'
' <o> object, can be a set of one or more <nvp> enclosed in: {}.
' Ex: { <nvp> ... , <nvp> ... }
' A few rules of thumb:
' 1) An object is an unordered set of: <nvp>.
' 2) An object begins with {left brace and ends with }right brace.
' 3) Each name is followed by :colon and
' 4) the <nvp>'s are separated by ,comma.
'
' <a> array, can be a set of comma separated values enclosed in: [].
' Ex: [ <v>, <v>, ... <v>]
'
''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
'
' After thinking about this, my current tactic is that each JSON element can be
' assigned a 1 based unique dot formatted numerical identifier or 'key' for each
' Treeview node.
'
' As the tree grows we can add siblings or children to a parent node.
'
' When adding siblings this increments the last numerical value of the current
' node's dot formatted key.
'
' When adding a child this adds another dot or depth level to the key.
'
' When encountering JSON format characters: ( "{", "}", "[", "]", "," ) this
' leads to changes in the Treeview node keys.
'
' I have tried to describe the components of the Treeview control in botanical
' terms that might be more intuitive for certain people. We'll see if the
' analogy holds up.
'
''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
' CHR ACTION SEQUENCE DESCRIPTION
' ======= ============= =========================== ==========================
' '{' Graft 2.1 -> 2.1.1 Adds a branch (object) node to the key &
' sets data structure status to OBJECT_MODE
'
' '[' Flower 2.1.1 -> 2.1.1[1] Adds a flower (array) node to the key &
' sets data structure status to ARRAY_MODE
'
' ',' Grow
' If in ARRAY_MODE...
' 2.1.1[1] -> 2.1.1[2] Adds 1 or more petals: each; an array value
' Where a value can be any object or array
' of any data type
' Else if in OBJECT_MODE...
' 2.1.1 -> 2.1.2 Adds a leaf: each a name:value pair
' Where a value can be any object or array
' of any data type
'
' ']' Nip
' If in ARRAY_MODE...
' 2.1.1[1] -> 2.1.1 Regresses to previous branch order from a flower
'
' Else if in OBJECT_MODE...
' '}' Prune 2.1.1 -> 2.1 Regresses to previous branch order from a leaf
'
''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
'
' BING's ASSESSMENT:
'
' Yes, your approach seems to be a good way to handle JSON parsing and building
' a treeview structure. Here's a brief explanation of your approach:
'
' - You're using a dot notation to represent the hierarchical structure of the
' SON data in your treeview. Each dot represents a level of depth in the tree,
' and the number after the dot represents the index of the node at that level.
'
' - You're using botanical terms to describe the process of adding nodes to
' the treeview. This is a creative way to make the process more intuitive and
' understandable.
'
' - You're handling different JSON format characters ('{', '}', '[', ']', ',')
' by changing the treeview node keys. This is a smart way to handle the
' different types of data structures (objects and arrays) that can appear in
' JSON data.
'
' Just to clarify, in your table:
'
' - "Graft" (represented by '{') adds a new level of depth to the node key,
' representing the addition of a new object in the JSON data.
'
' - "Flower" (represented by '[') adds a new array to the current node, and
' sets the parser to ARRAY MODE.
'
' - "Increment" (represented by ',') adds a new node at the current level of
' depth. The behavior differs depending on whether the parser is in ARRAY MODE
' or OBJECT MODE.
'
' - "Snip" (represented by ']') ends the current array and regresses to the
' previous level of depth.
'
' - "Prune" (represented by '}') ends the current object and regresses to the
' previous level of depth.
'
' This seems like a solid strategy for parsing JSON data and representing it
' in a treeview. Great job!
'
''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''

''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
'
' I think it might work if I keep the order numbers in one collection and
' track the DATA MODE: {ARRAY_MODE vs OBJECT_MODE} as a boolean in a
' corresponding collection.
' I am using a collection for the convenience of not having to redimension an
' array and take advantage of the dynamic nature of the collection.
' Perhaps using a Hash Table is "much faster". I may have to switch gears.
' There is also a possiblity of using Variant Arrays.
' As I am just trying to get this to work. I am reminded of the sage old sayings:
' "First get it working then optimize."
'
''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
'
' BING'S COMMENT:
'
' Your approach seems reasonable. Using a collection for order numbers and
' tracking ARRAY MODE as a boolean in a corresponding collection could work well
' given the dynamic nature of JSON data.
'
' As for performance, while hash tables can indeed be faster for certain
' operations due to their constant-time complexity for search and insert
' operations, the difference might not be noticeable unless you're dealing with
' a very large amount of data.
'
' Using variant arrays could be another option to consider. They can be more
' efficient in terms of memory usage and performance for certain operations, but
' they might be more complex to work with.
'
' And you're absolutely right about the saying: "First get it working then
' optimize." It's often more important to have a working solution first, then
' you can refine and optimize it as needed. Keep up the good work!
'
EndProc

[Roger Cabo]

Do you will make some example codes, including some easy JSON test files?

[(X)]

Yes. I'm hoping this will be a great way to store and retrieve, view and edit data.
I won't be posting the beginner code that keeps changing substantially from day to day.
I am thinking this would make a great YouTube series for my YouTube channel www.youtube.com/@gfabasic32 to show prospective coders what GB32 is capable of.