document formated

Author: ishaileshmishra

pom.xml

@@ -30,7 +30,7 @@
         <maven-release-plugin.version>2.5.3</maven-release-plugin.version>
         <validation-version>2.0.1.Final</validation-version>
         <json-version>20230227</json-version>
-        <spring-web-version>6.0.7</spring-web-version>
+        <spring-web-version>6.0.11</spring-web-version>
         <org.apache.commons-text>1.10.0</org.apache.commons-text>
     </properties>
 

src/main/java/com/contentstack/utils/AutomateCommon.java

@@ -29,11 +29,16 @@ private AutomateCommon() {
     }
 
     /**
-     * Find dot separated keys
+     * The function "findContent" splits a given path string into an array of strings, and then calls the
+     * "getContent" function with the array, a JSONObject, and a contentCallback as parameters.
      *
-     * @param entryObj        Json Object
-     * @param path            keyPath
-     * @param contentCallback content callback
+     * @param entryObj        A JSONObject that contains the data you want to search through.
+     * @param path            The `path` parameter is a string that represents the path to a specific content in a
+     *                        JSON object. It is used to navigate through the JSON object and find the desired content.
+     * @param contentCallback The `contentCallback` parameter is an instance of the `ContentCallback`
+     *                        interface. It is used to provide a callback mechanism for handling the content found during the
+     *                        search process. The `ContentCallback` interface typically defines a method that will be called with
+     *                        the content found at each step of the search.
      */
     protected static void findContent(JSONObject entryObj, String path, ContentCallback contentCallback) {
         String[] arrayString = path.split("\\.");
@@ -42,9 +47,15 @@ protected static void findContent(JSONObject entryObj, String path, ContentCallb
 
 
     /**
-     * @param arrayString     list of keys available
-     * @param entryObj        entry object
-     * @param contentCallback content callback
+     * The function `getContent` recursively traverses a JSON object and modifies its content based on
+     * a callback function.
+     *
+     * @param arrayString     An array of strings representing the path to the content in the JSON object.
+     * @param entryObj        The `entryObj` parameter is a JSONObject that contains the data to be processed.
+     * @param contentCallback The `contentCallback` parameter is an instance of the `ContentCallback`
+     *                        interface. This interface defines a method called `contentObject()` which takes an object as
+     *                        input and returns a modified version of that object. The purpose of this callback is to allow
+     *                        the caller of the `getContent()` method to customize
      */
     private static void getContent(String[] arrayString, JSONObject entryObj, ContentCallback contentCallback) {
         if (arrayString != null && arrayString.length != 0) {
@@ -71,6 +82,20 @@ private static void getContent(String[] arrayString, JSONObject entryObj, Conten
     }
 
 
+    /**
+     * The function returns a string representation of an option by rendering it with the provided
+     * content and metadata, falling back to default options if necessary.
+     *
+     * @param option        The "option" parameter is an object of type Option, which represents a specific
+     *                      option that can be rendered. It likely has properties and methods that allow it to generate the
+     *                      desired output based on the provided content and metadata.
+     * @param metadata      Metadata is an object that contains additional information about the option. It
+     *                      may include details such as the option's label, description, and any other relevant information.
+     * @param contentToPass The `contentToPass` parameter is a `JSONObject` that contains the data or
+     *                      content that needs to be passed to the `renderOptions` method of the `Option` or `DefaultOption`
+     *                      class. This data or content is used to generate the string representation of the option.
+     * @return The method is returning a string value.
+     */
     protected static String getStringOption(Option option, Metadata metadata, JSONObject contentToPass) {
         String stringOption = option.renderOptions(contentToPass, metadata);
         if (stringOption == null) {
@@ -81,6 +106,17 @@ protected static String getStringOption(Option option, Metadata metadata, JSONOb
     }
 
 
+    /**
+     * The function retrieves embedded objects from an HTML document and passes them to a callback
+     * function for further processing.
+     *
+     * @param html             The "html" parameter is a Document object that represents an HTML document. It is
+     *                         used to extract embedded objects from the HTML document.
+     * @param metadataCallback The `metadataCallback` parameter is an instance of a class that
+     *                         implements the `MetadataCallback` interface. This interface defines a method called
+     *                         `embeddedObject` which is called for each embedded object found in the HTML document. The
+     *                         `embeddedObject` method takes a `Metadata` object as a parameter,
+     */
     protected static void getEmbeddedObjects(Document html, MetadataCallback metadataCallback) {
         Elements embeddedEntries = html.body().getElementsByClass("embedded-entry");
         Elements embeddedAssets = html.body().getElementsByClass("embedded-asset");
@@ -107,6 +143,16 @@ protected static void getEmbeddedObjects(Document html, MetadataCallback metadat
     }
 
 
+    /**
+     * The function takes a JSONArray of content, iterates through each element, and calls another
+     * function to render and enumerate the content, returning a JSONArray of the rendered content.
+     *
+     * @param contentArray A JSONArray containing the content to be enumerated.
+     * @param renderObject The renderObject parameter is an instance of the Option class.
+     * @param item         The "item" parameter is a callback function that takes in a "Meta" object and
+     *                     returns a value to be embedded in the rendered content.
+     * @return The method is returning a JSONArray object.
+     */
     protected static Object enumerateContents(JSONArray contentArray, Option renderObject, MetaToEmbedCallback item) {
         JSONArray jsonArrayRTEContent = new JSONArray();
         for (Object RTE : contentArray) {
@@ -117,8 +163,19 @@ protected static Object enumerateContents(JSONArray contentArray, Option renderO
         return jsonArrayRTEContent;
     }
 
+    /**
+     * The function checks if a JSON object has a specific type and children, and if so, it performs
+     * some processing on the children.
+     *
+     * @param jsonObject   A JSONObject that contains the content to be enumerated.
+     * @param renderObject The `renderObject` parameter is of type `Option`. It is used as an argument
+     *                     in the `doRawProcessing` method.
+     * @param item         The "item" parameter is a callback function that takes in a "Meta" object and returns
+     *                     a string.
+     * @return An empty string.
+     */
     protected static String enumerateContent(JSONObject jsonObject, Option renderObject, MetaToEmbedCallback item) {
-        if (jsonObject.length() > 0 && jsonObject.has("type") && jsonObject.has("children")) {
+        if (!jsonObject.isEmpty() && jsonObject.has("type") && jsonObject.has("children")) {
             if (jsonObject.opt("type").equals("doc")) {
                 return doRawProcessing(jsonObject.optJSONArray("children"), renderObject, item);
             }
@@ -127,6 +184,17 @@ protected static String enumerateContent(JSONObject jsonObject, Option renderObj
     }
 
 
+    /**
+     * The function `doRawProcessing` processes a JSONArray of children, extracting keys from each
+     * child and appending the results to a StringBuilder, then returns the final string.
+     *
+     * @param children     A JSONArray containing the children items to process.
+     * @param renderObject The parameter "renderObject" is of type "Option". It is used as an option to
+     *                     specify how the keys should be rendered during processing.
+     * @param embedItem    The `embedItem` parameter is a callback function that takes a `Meta` object as
+     *                     input and returns an embedded representation of that object.
+     * @return The method is returning a string.
+     */
     private static String doRawProcessing(@NotNull JSONArray children, Option renderObject, MetaToEmbedCallback embedItem) {
         StringBuilder stringBuilder = new StringBuilder();
         children.forEach(item -> {
@@ -140,6 +208,20 @@ private static String doRawProcessing(@NotNull JSONArray children, Option render
     }
 
 
+    /**
+     * The function extracts keys from a JSON object and returns a string based on the type of the
+     * node.
+     *
+     * @param jsonNode     The `jsonNode` parameter is a `JSONObject` that represents a node in a JSON
+     *                     structure. It is used to extract information from the node and perform certain operations based
+     *                     on its properties.
+     * @param renderObject The `renderObject` parameter is an object of type `Option`. It is used to
+     *                     specify rendering options for the extracted keys.
+     * @param embedItem    The `embedItem` parameter is a callback function that takes a `Metadata` object
+     *                     as input and returns an optional `JSONObject`. This callback is used to embed metadata into the
+     *                     rendered content.
+     * @return The method is returning a String.
+     */
     private static String extractKeys(@NotNull JSONObject jsonNode, Option renderObject, MetaToEmbedCallback embedItem) {
 
         if (!jsonNode.has("type") && jsonNode.has("text")) {

src/main/java/com/contentstack/utils/GQL.java

@@ -12,28 +12,35 @@
 
 import static com.contentstack.utils.AutomateCommon.*;
 
-/**
- * The type Gql.
- */
+
 public class GQL {
 
 
+    // The `private GQL() throws IllegalAccessException` is a private constructor of the `GQL` class. It is
+// throwing an `IllegalAccessException` with a message "Invalid Access! Could not create instance of
+// GQL".
     private GQL() throws IllegalAccessException {
         throw new IllegalAccessException("Invalid Access! Could not create instance of GQL");
     }
 
 
+    // The line `static JSONArray embeddedItems = null` declares a static variable named
+    // `embeddedItems` of type `JSONArray` and initializes it with a value of `null`. This
+    // variable is used to store the embedded items extracted from the GraphQL entry object
+    // during the conversion process.
     private static JSONArray embeddedItems = null;
 
+
     /**
-     * Json to html.
+     * The function `jsonToHTML` converts a JSON object to HTML based on a given path and render
+     * option.
      *
-     * @param gqlEntry
-     *         the gql entry is entry @{@link JSONObject}
-     * @param path
-     *         the path is array of @{@link String}
-     * @param renderOption
-     *         the render option is instance of @{@link DefaultOption}
+     * @param gqlEntry     The `gqlEntry` parameter is a JSONObject that represents the GraphQL entry
+     *                     object. It contains the data that needs to be converted to HTML.
+     * @param path         An array of strings representing the path to the desired content in the JSON object.
+     * @param renderOption The `renderOption` parameter is of type `DefaultOption` and is used to
+     *                     specify the rendering options for the HTML output. It is an enum that contains different options
+     *                     for rendering the content.
      */
     public static void jsonToHTML(@NotNull JSONObject gqlEntry, @NotNull String[] path, @NotNull DefaultOption renderOption) {
 
@@ -49,16 +56,14 @@ public static void jsonToHTML(@NotNull JSONObject gqlEntry, @NotNull String[] pa
             if (contentDict.has("json")) {
                 MetaToEmbedCallback converter = metadata -> {
                     if (embeddedItems != null) {
-                        Optional<JSONObject> filteredContent = StreamSupport.stream(embeddedItems.spliterator(), false)
-                                .map(JSONObject.class::cast)
-                                .filter(itemDict -> {
-                                    JSONObject nodeObject = itemDict.optJSONObject("node");
-                                    if (nodeObject.has("uid")) {
-                                        String uid = nodeObject.optString("uid");
-                                        return uid.equals(metadata.getItemUid());
-                                    }
-                                    return false;
-                                }).findFirst();
+                        Optional<JSONObject> filteredContent = StreamSupport.stream(embeddedItems.spliterator(), false).map(JSONObject.class::cast).filter(itemDict -> {
+                            JSONObject nodeObject = itemDict.optJSONObject("node");
+                            if (nodeObject.has("uid")) {
+                                String uid = nodeObject.optString("uid");
+                                return uid.equals(metadata.getItemUid());
+                            }
+                            return false;
+                        }).findFirst();
                         if (filteredContent.isPresent()) {
                             return filteredContent;
                         }