Merge pull request #12 from relogiclabs/develop

Update Scripting Functionalities

Author: zhossain-info

.gitignore

@@ -43,3 +43,5 @@ build/
 .vscode/
 .DS_Store
 
+### Temporary Files ###
+/temp/**

README.md

@@ -1,10 +1,10 @@
-# JSchema - The New JSON Schema
+# JSchema - The Customizable JSON Schema
 A JSON Schema is crucial for making communication, interoperability, validation, testing, documentation, and specification seamless. All of this combined contributes to better maintenance and evolution of data-driven applications and systems. If you are interested in a comprehensive overview of the roles and uses of JSON Schema in modern web applications, check out our in-depth post [here](https://www.relogiclabs.com/2023/01/the-roles-of-json-schema.html).
 
 ## Design Goals
 The traditional standard JSON Schema rigorously follows the conventional JSON structure, which unfortunately comes at the expense of simplicity, conciseness, and readability. Our goal is to develop a new JSON Schema that promotes these essential aspects that were previously missing.
 
-This new schema is simple, lucid, easy to grasp, and doesn't require much prior knowledge to understand it. It also offers a shallow learning curve for both reading and writing. Additionally, its simplicity and conciseness allow us and machines to read-write more efficiently. Moreover, a large set of constraint data types and functions within the core schema promotes the precise definition of JSON documents, significantly reducing the potential for communication gaps among collaborators. Furthermore, its inherent extensibility not only facilitates the test automation process in API testing but also simplifies the integrations of new constraints and functionalities to meet the diverse requirements of modern web services.
+This new schema is simple, lucid, easy to grasp, and doesn't require much prior knowledge to get started. Additionally, its simplicity and conciseness allow us and machines to read-write more efficiently. Moreover, a large set of constraint data types and functions within the core schema promotes the precise definition of JSON documents, significantly reducing the potential for communication gaps among collaborators. Furthermore, its inherent extensibility not only facilitates the test automation process in API testing but also simplifies the integrations of new constraints and functionalities to meet the diverse requirements of modern web services.
 
 ## Basic Example
 Let's explore an example of our schema for a typical JSON API response containing information about a user profile or account. The schema is very self-explanatory and thus almost no prior knowledge is required to understand the schema and the JSON responses specified by this schema.
@@ -95,7 +95,7 @@ The next example represents an expanded version of the previous one, which bring
 %define $tags: @length(1, 10) #string*($tag) #array
 %define $tag: @length(3, 20) @regex("[A-Za-z_]+") #string
 
-%schema: 
+%schema:
 {
     "user": {
         "id": @range(1, 10000) #integer,
@@ -135,16 +135,16 @@ The next example represents an expanded version of the previous one, which bring
 
 %script: {
     constraint function checkAccess(role) {
-        // Receiver &role received only one value
+        // Auto-unpacking unwraps single-value '&role' array into its value
         // 'target' keyword refers to the target JSON value
-        if(role[0] == "user" && target > 5) return fail(
+        if(role == "user" && target > 5) return fail(
             "ERRACCESS01", "Data access incompatible with 'user' role",
             expected("an access at most 5 for 'user' role"),
             actual("found access " + target + " which is greater than 5"));
     }
 }
 ```
-The subsequent JSON sample is an illustrative example that successfully validates against the expanded schema mentioned earlier. Within this example, recurring JSON structures appear that can be validated by defining components or nested functions and data types. Besides, reusing simple component definitions, you can achieve a clear and concise schema when validating large JSON with repetitive structures instead of duplicating or referring to various structures across the schema. This improves the overall readability and maintainability of the schema.
+The subsequent JSON sample is an illustrative example that successfully validates against the expanded schema mentioned earlier. Within this example, recurring JSON structures appear that can be validated by defining components or nested functions and data types. Besides, reusing simple component definitions, you can achieve a clear and concise schema when validating large JSON with repetitive structures. This improves the overall readability and maintainability of the schema.
 ```json
 {
     "user": {
@@ -218,10 +218,10 @@ The subsequent JSON sample is an illustrative example that successfully validate
             "id": "p2",
             "name": "Laptop",
             "brand": "SuperTech",
-            "price": 1299.99,
+            "price": 11.99,
             "inStock": false,
             "specs": {
-                "cpu": "Ryzen 11",
+                "cpu": "Ryzen",
                 "ram": "11GB",
                 "storage": "11GB SSD"
             }

doc/content/_index.md

@@ -4,7 +4,7 @@ date = 2023-10-08T09:38:53+06:00
 +++
 
 # Introduction
-JSchema, a new JSON Schema, prioritizes simplicity, conciseness, and readability, making it intuitive and accessible without the need for extensive prior knowledge. It offers efficient read-write facilities, precise JSON document definition through various data types and functions, and extensibility to meet modern web service diverse requirements.
+JSchema, a customizable JSON Schema, prioritizes simplicity, conciseness, and readability, making it intuitive and accessible without the need for extensive prior knowledge. It offers efficient read-write facilities, precise JSON document definition through various data types and functions, and extensibility to meet modern web service diverse requirements.
 
 JSON, short for JavaScript Object Notation, is one of the most widely used data exchange formats that are both user-friendly and machine-readable. JSchema is a practical tool for defining and validating the structure of JSON documents. The following guides provide comprehensive details about the JSchema.
 <br/>

doc/content/articles/cscript.md

@@ -18,7 +18,7 @@ Here is a list of keywords (reserved words) in the CScript language. You cannot
 | Conditional Flow Control  | `if`; `else`; (`switch`; `case`; `default`)      |
 | Iterative Flow Control    | `for`; `foreach`; `while`; (`do`)                |
 | Jump Control              | `break`; (`continue`)                            |
-| Membership Management     | `in`                                             |
+| Membership Management     | `in`; (`not`)                                    |
 | Function Declaration      | `function`; `constraint`; `future`; `subroutine` |
 | Function Data & Control   | `return`; `target`; `caller`                     |
 | Literals Value            | `true`; `false`; `null`; `undefined`             |
@@ -38,7 +38,7 @@ Composite types include `#array` and `#object`, while the remaining types fall u
 | 3  | `#double`    | `10.5`; `20E-5`; `5E+5`                    |
 | 4  | `#integer`   | `10`; `20`; `100`; `500`                   |
 | 5  | `#null`      | `null`                                     |
-| 6  | `#object`    | `{ k1: "text", k2: { "k11" : 10 } }`; `{}` |             
+| 6  | `#object`    | `{ k1: "text", k2: { "k11" : 10 } }`; `{}` |
 | 7  | `#range`     | `1..10`; `-10..-5`; `-10..`; `..100`       |
 | 8  | `#string`    | `"any text"`; `""`                         |
 | 9  | `#undefined` | `undefined`                                |
@@ -49,20 +49,20 @@ The `#void` type is reserved for internal operations, including initializing una
 ## Operators & Precedences
 CScript operators are symbols that are used to perform operations on variables and values. The direct operation of any operator that requires a modifiable l-value including `++`, `--` or `=` will raise an exception for the readonly schema nodes. The following table lists the operators according to their precedences from the highest to the lowest:
 
-| SN | Category                      | Operator             |
-|----|-------------------------------|----------------------|
-| 1  | Property Access & Parentheses | `.`; `[]`; `()`      |
-| 2  | Unary Minus & Logical Not     | `-`; `!`             |
-| 3  | Postfix Increment/Decrement   | `i++`; `i--`         |
-| 4  | Prefix Increment/Decrement    | `++i`; `--i`         |
-| 5  | Arithmetic Multiplicative     | `*`; `/`             |
-| 6  | Arithmetic Additive           | `+`; `-`             |
-| 7  | Sequence Range                | `..`                 |
-| 8  | Relational Comparison         | `>`; `<`; `>=`; `<=` |
-| 9  | Equality Comparison           | `==`; `!=`           |
-| 10 | Logical And (Short-Circuit)   | `&&`                 |
-| 11 | Logical Or (Short-Circuit)    | `\|\|`               |
-| 12 | Assignment                    | `=`                  |
+| SN | Category                      | Operator                          |
+|----|-------------------------------|-----------------------------------|
+| 1  | Property Access & Parentheses | `.`; `[]`; `()`                   |
+| 2  | Unary Minus & Logical Not     | `-`; `!`                          |
+| 3  | Postfix Increment/Decrement   | `i++`; `i--`                      |
+| 4  | Prefix Increment/Decrement    | `++i`; `--i`                      |
+| 5  | Arithmetic Multiplicative     | `*`; `/`; `%`                     |
+| 6  | Arithmetic Additive           | `+`; `-`                          |
+| 7  | Sequence Range                | `..`                              |
+| 8  | Relational Comparison         | `>`; `<`; `>=`; `<=`              |
+| 9  | Equality Comparison           | `==`; `!=`                        |
+| 10 | Logical And (Short-Circuit)   | `&&`                              |
+| 11 | Logical Or (Short-Circuit)    | `\|\|`                            |
+| 12 | Assignment                    | `=`; `+=`; `-=`; `*=`; `/=`; `%=` |
 
 ## Function Types
 Function types are essential for specifying the executable units that serve as the building-blocks of validation process within CScript. All function types can also accept variable number of arguments, specified by an ellipsis `...` after the last parameter name which is then bound to an array containing the remaining arguments.

doc/content/articles/introduction.md

@@ -5,7 +5,7 @@ weight = 1
 +++
 
 # Introduction
-JSchema, a new JSON Schema, prioritizes simplicity, conciseness, and readability, making it intuitive and accessible without the need for extensive prior knowledge. It offers efficient read-write facilities, precise JSON document definition through various data types and functions, and extensibility to meet modern web service diverse requirements.
+JSchema, a customizable JSON Schema, prioritizes simplicity, conciseness, and readability, making it intuitive and accessible without the need for extensive prior knowledge. It offers efficient read-write facilities, precise JSON document definition through various data types and functions, and extensibility to meet modern web service diverse requirements.
 
 JSON, short for JavaScript Object Notation, is one of the most widely used data exchange formats that are both user-friendly and machine-readable. JSchema is a practical tool for defining and validating the structure of JSON documents. The following guides provide comprehensive details about the JSchema.
 <br/>

doc/content/articles/quickstart.md

@@ -8,7 +8,7 @@ weight = 2
 This guide will walk you through the essential steps to quickly get up and running with the JSchema library. It is also assumed a modest familiarity with the Java language, Java SDK, and Java command-line interface, including basic familiarity with Maven packages.
 
 ## Maven Library Package
-To get started, launch your preferred IDE (such as IntelliJ IDEA, NetBeans IDE, Eclipse IDE, or VS Code) and open the Java project where you intend to include this library package. If you are using a build tool like Maven or Gradle, adding the library to your project is straightforward. For example in Maven project, navigate to the Maven `pom.xml` file and locate the section named `<dependencies>` and add the following XML snippet within the section of the file, replacing `2.x.x` with either the latest version or your preferred version:
+To get started, launch your preferred IDE (such as IntelliJ IDEA, NetBeans IDE, Eclipse IDE, or VS Code) and open the Java project where you intend to include this library package. If you are using a build tool like Maven or Gradle, adding the library to your project is straightforward. For example in Maven project, navigate to the Maven `pom.xml` file and locate the section named `<dependencies>` and add the following XML snippet within the section, replacing `2.x.x` with either the latest version or your preferred version:
 ```xml
 <dependency>
     <groupId>com.relogiclabs.json</groupId>

doc/content/articles/sourcebuild.md

@@ -20,7 +20,7 @@ mvn clean install
 Maven will resolve the library's dependencies, compile the code, and create a jar file which will be installed in the local Maven repository.
 
 ## Add the Library to Your Project
-To integrate the library into your project, open it in your preferred IDE (such as IntelliJ IDEA, NetBeans IDE, Eclipse IDE, or VS Code). If you are using a build tool like Maven or Gradle, adding the library to your project is straightforward. For example in a Maven project, navigate to the Maven `pom.xml` file and locate the section named `<dependencies>` and add the following XML snippet within the section of the file, replacing `2.x.x` with the version you have built:
+To integrate the library into your project, open it in your preferred IDE (such as IntelliJ IDEA, NetBeans IDE, Eclipse IDE, or VS Code). If you are using a build tool like Maven or Gradle, adding the library to your project is straightforward. For example in a Maven project, navigate to the Maven `pom.xml` file and locate the section named `<dependencies>` and add the following XML snippet within the section, replacing `2.x.x` with the version you have built:
 ```xml
 <dependency>
     <groupId>com.relogiclabs.json</groupId>

doc/content/articles/specification.md

@@ -20,7 +20,7 @@ schema
     validator
 
 schema-header-opt
-    title-opt version-opt includes-opt pragmas-opt
+    title-opt version-opt imports-opt pragmas-opt
 
 title-opt
     ''
@@ -30,15 +30,15 @@ version-opt
     ''
     '%version' ':' string
 
-includes-opt
+imports-opt
     ''
-    includes
+    imports
 
-includes
-    include includes
+imports
+    import imports
 
-include
-    '%include' ':' class-identifier
+import
+    '%import' ':' class-identifier
 
 class-identifier
     identifier

doc/layouts/_default/baseof.html

@@ -1,14 +1,14 @@
 <!DOCTYPE html>
 <html lang="{{ .Site.LanguageCode }}">
-{{- partial "head.html" . -}}
+{{ partial "head.html" . }}
 
 <body>
-    {{- partial "header.html" . -}}
-    {{- partial "sidebar.html" . -}}
+    {{ partial "header.html" . }}
+    {{ partial "sidebar.html" . }}
     <main>
-        {{- block "main" . }}{{- end }}
+        {{ block "main" . }}{{ end }}
     </main>
-    {{- partial "footer.html" . -}}
+    {{ partial "footer.html" . }}
 </body>
 
 </html>

doc/layouts/partials/sidebar.html

@@ -3,11 +3,11 @@
 <div class="sidebar">
     <ul>
         {{ range .Site.Home.Sections.ByWeight }}
-        <li class="section-header {{ if eq .File.UniqueID $CurrentPage.File.UniqueID }}active{{ end }}">
+        <li class="section-header{{ if eq .Permalink $CurrentPage.Permalink }} active{{ end }}">
             <a href="{{ .RelPermalink }}">{{ .Title }}</a>
         </li>
         {{ range .Pages.ByWeight }}
-        <li class="section-item {{ if eq .File.UniqueID $CurrentPage.File.UniqueID }}active{{ end }}">
+        <li class="section-item{{ if eq .Permalink $CurrentPage.Permalink }} active{{ end }}">
             <a href="{{ .RelPermalink }}">{{ .Title }}</a>
         </li>
         {{ end }}