fix: 🐛 correct crlf

Author: Thomas G.

src/common-utils/_normalize-json.sh

@@ -20,7 +20,7 @@ help
 
 # Check if JSON exists and is readable
 if test -z "$json" && test ! -f "$json"; then
-    echo -e "${Red}JSON is missing${None}"
+    echo -e "${Red}JSON is missing${None}\r"
     exit 1
 fi
 
@@ -165,7 +165,7 @@ get_schema_json() {
     curl -s $url | load_json_schema $url -
 
     if [ $? -ne 0 ]; then
-        echo -e "${Red}Unable to download schema file $schema${None}" >&2
+        echo -e "${Red}Unable to download schema file $schema${None}\r" >&2
         exit 1
     fi
 }
@@ -178,25 +178,25 @@ get_schema() {
 
     # if schema is a file, load it
     if test -f "$schema"; then
-        echo -e "${lvl}${Green}Loading schema ${UGreen}$schema${None}" >&2
+        echo -e "${lvl}${Green}Loading schema ${UGreen}$schema${None}\r" >&2
         schema=$(load_json_schema $schema)
     fi
 
     # if schema is a url, download it
     if test -n "$(echo $schema | grep -E '^http')"; then
-        echo -e "${lvl}${Green}Downloading schema ${UGreen}$schema${None}" >&2
+        echo -e "${lvl}${Green}Downloading schema ${UGreen}$schema${None}\r" >&2
         schema=$(get_schema_json $schema)
     fi
 
     # if schema is not a valid JSON, return error
     if ! is_json <<<"$schema"; then
-        echo -e "${Red}Invalid schema${None}" >&2
+        echo -e "${Red}Invalid schema${None}\r" >&2
         exit 1
     fi
 
     # if allow flag is set, allow additional properties at root level
     if test -n "$allow"; then
-        echo -e "${lvl}${Purple}Additional properties allowed at root level${None}" >&2
+        echo -e "${lvl}${Purple}Additional properties allowed at root level${None}\r" >&2
         echo $schema | jq '. + {"additionalProperties": true}'
     else
         echo $schema
@@ -249,13 +249,13 @@ validate() {
 
     # if json does not start with '{' and is a file, load it
     if test -f "$json"; then
-        echo -e "${lvl}${Green}Loading json ${UGreen}$json${None}" >&2
+        echo -e "${lvl}${Green}Loading json ${UGreen}$json${None}\r" >&2
         json=$(load_json $json)
     fi
 
     # if schema is not a valid JSON, return error
     if ! is_json <<<"$json"; then
-        echo -e "${Red}Invalid json${None}" >&2
+        echo -e "${Red}Invalid json${None}\r" >&2
         exit 1
     fi
 
@@ -286,7 +286,7 @@ validate() {
     fi
 
     # Log
-    echo -e "${lvl}${Blue}Parsing schema <${path:-.}> == <${real:-.}>${None} at level <$level>" >&2
+    echo -e "${lvl}${Blue}Parsing schema <${path:-.}> == <${real:-.}>${None} at level <$level>\r" >&2
 
     # get 1st level entry points (oneOf, allOf, anyOf, properties) and loop through them
     for entry in '"$id"' '"not"' '"oneOf"' '"allOf"' '"anyOf"' '"type"' '"required"' '"$ref"' '"properties"' '"items"' '"additionalProperties"'; do
@@ -296,20 +296,20 @@ validate() {
             continue
         fi
 
-        echo -e "${lvl}- Processing <${Blue}${path}:$entry${None}>" >&2
+        echo -e "${lvl}- Processing <${Blue}${path}:$entry${None}>\r" >&2
 
         case $entry in
 
         \"\$id\")
 
             #log
-            echo -e "${lvl}- Processing ${BWhite}\$id${None}" >&2
+            echo -e "${lvl}- Processing ${BWhite}\$id${None}\r" >&2
 
             # get id from schema
             id=$(get_json "$path.$entry" <<<"$schema" || echo ".")
 
             # log
-            echo -e "${lvl}- Resolving ${Yellow}$id${None}" >&2
+            echo -e "${lvl}- Resolving ${Yellow}$id${None}\r" >&2
             ;;
 
         \"\$ref\")
@@ -318,62 +318,62 @@ validate() {
             local ref=$(get_path "$path.$entry" <<<"$schema")
 
             if test "$ref" == "null" || test -z "$ref"; then
-                echo -e "${Red}Reference not found for $path.$entry${None}" >&2
+                echo -e "${Red}Reference not found for $path.$entry${None}\r" >&2
                 exit 1
             fi
 
-            echo -e "${lvl}- Ref is ${Yellow}${ref}${None}" >&2
-            echo -e "${lvl}  From ${Yellow}${id}${None}..." >&2
+            echo -e "${lvl}- Ref is ${Yellow}${ref}${None}\r" >&2
+            echo -e "${lvl}  From ${Yellow}${id}${None}...\r" >&2
 
             # separate uri before # from fragment after #
             local uri=$(echo $ref | awk -F '#' '{print $1}')
             local fgt=$(echo $ref | awk -F '#' '{print $2}')
 
             # if ref is a url, download it and use it as schema
             if test -n "$(echo $uri | grep -E '^http')"; then
-                echo -e "${lvl}- Loading ${Yellow}${uri}${None}..." >&2
+                echo -e "${lvl}- Loading ${Yellow}${uri}${None}...\r" >&2
                 schema=$(get_schema_json $uri)
             elif test -n "$uri"; then
                 # check if file exists
                 if test -f "$uri"; then
-                    echo -e "${lvl}- Loading ${Yellow}${uri}${None}..." >&2
+                    echo -e "${lvl}- Loading ${Yellow}${uri}${None}...\r" >&2
                     schema=$(load_json_schema $uri)
                 elif test -n "$id"; then
                     # load schema from file
-                    echo -e "${lvl}- Loading ${Yellow}$(dirname $id)/$uri${None}..." >&2
+                    echo -e "${lvl}- Loading ${Yellow}$(dirname $id)/$uri${None}...\r" >&2
                     schema=$(get_schema_json $(dirname $id)/$uri)
                 else
-                    echo -e "${Red}Unable to resolve reference $ref with $id${None}" >&2
+                    echo -e "${Red}Unable to resolve reference $ref with $id${None}\r" >&2
                     exit 1
                 fi
 
             fi
 
             # if schema is not a valid JSON, return error
             if ! validate "$json" "$schema" "$(echo $fgt | tr '/' '.')" "$real" "$path" "$not" "$level"; then
-                echo -e "${lvl}- ${Yellow}Reference $ref is invalid${None}" >&2
+                echo -e "${lvl}- ${Yellow}Reference $ref is invalid${None}\r" >&2
                 return 1
             fi
 
             ;;
 
         \"not\")
-            echo -e "${lvl}- ${Purple}Start Not${None}" >&2
+            echo -e "${lvl}- ${Purple}Start Not${None}\r" >&2
 
             # Parse sub schema with not flag
             if ! validate "$json" "$schema" "$path.$entry" "$real" "$path.$entry" "!" "$level"; then
-                echo -e "${lvl}- ${Yellow}Condition is invalid${None}" >&2
+                echo -e "${lvl}- ${Yellow}Condition is invalid${None}\r" >&2
                 return 1
             fi
 
-            echo -e "${lvl}- ${Purple}End Not${None}" >&2
+            echo -e "${lvl}- ${Purple}End Not${None}\r" >&2
 
             ;;
 
         \"oneOf\" | \"allOf\" | \"anyOf\")
 
             if ! is_json_array "$path.$entry" <<<"$schema"; then
-                echo -e "${Red}Invalid $entry schema${None}" >&2
+                echo -e "${Red}Invalid $entry schema${None}\r" >&2
                 exit 1
             fi
 
@@ -382,7 +382,7 @@ validate() {
             local last=$(expr $size - 1)
             local count=0
 
-            echo -e "${lvl}- ${Cyan}Start $entry loop${None}" >&2
+            echo -e "${lvl}- ${Cyan}Start $entry loop${None}\r" >&2
 
             for i in $(seq 0 $last); do
                 if validate "$json" "$schema" "$path.$entry[$i]" "$real" "$path.$entry[$i]" "$not" "$level"; then
@@ -391,14 +391,14 @@ validate() {
                 ${entry//\"/}_rule $size $count $i && break
             done
 
-            echo -e "${lvl}- ${Cyan}End $entry loop ($count/$size)${None}" >&2
+            echo -e "${lvl}- ${Cyan}End $entry loop ($count/$size)${None}\r" >&2
             ${entry//\"/}_rule $size $count $last || return 1
             ;;
 
         \"type\")
 
             # Log
-            echo -e "${lvl}- Processing ${BWhite}Type${None}" >&2
+            echo -e "${lvl}- Processing ${BWhite}Type${None}\r" >&2
 
             local type_json=$(get_json_type "$real" <<<"$json")
 
@@ -420,14 +420,14 @@ validate() {
 
             # If no type was found, return error
             if test -z "$type"; then
-                echo -e "${lvl}- ${Yellow}Property ${real:-.} is ${type_json}, not of expected type ${type_schema}${None}" >&2
+                echo -e "${lvl}- ${Yellow}Property ${real:-.} is ${type_json}, not of expected type ${type_schema}${None}\r" >&2
                 return 1
             fi
 
             echo ${real:-.}
 
             # Log
-            echo -e "${lvl}- ${Green}Property ${real:-.} is of expected type ${type}${None}" >&2
+            echo -e "${lvl}- ${Green}Property ${real:-.} is of expected type ${type}${None}\r" >&2
             ;;
 
         \"required\")
@@ -437,7 +437,7 @@ validate() {
 
             # if type is not an object, do not process
             if test "$type" != "\"object\""; then
-                echo -e "${lvl}- ${Yellow}Skip required not an object ($type)${None}" >&2
+                echo -e "${lvl}- ${Yellow}Skip required not an object ($type)${None}\r" >&2
                 continue
             fi
 
@@ -448,30 +448,30 @@ validate() {
 
                 if is_existing_path "$real.$prop" <<<"$json"; then
                     if test -n "$not"; then
-                        echo -e "${lvl}- ${Yellow}Property $prop is present but not required${None}" >&2
+                        echo -e "${lvl}- ${Yellow}Property $prop is present but not required${None}\r" >&2
                         return 1
                     fi
                 else
                     if test -z "$not"; then
-                        echo -e "${lvl}- ${Yellow}Property $prop is missing but required${None}" >&2
+                        echo -e "${lvl}- ${Yellow}Property $prop is missing but required${None}\r" >&2
                         return 1
                     fi
                 fi
 
-                echo -e "${lvl}- ${Green}Property requirement is valid for $prop${None}" >&2
+                echo -e "${lvl}- ${Green}Property requirement is valid for $prop${None}\r" >&2
             done
             ;;
 
         \"items\")
 
             # If items is not an array, do not process
             if test "$type" != "\"array\""; then
-                echo -e "${lvl}- ${Yellow}Skip properties not an  ($type)${None}" >&2
+                echo -e "${lvl}- ${Yellow}Skip properties not an  ($type)${None}\r" >&2
                 continue
             fi
 
             # Log
-            echo -e "${lvl}- Processing ${BWhite}Items${None}" >&2
+            echo -e "${lvl}- Processing ${BWhite}Items${None}\r" >&2
 
             # get items schema
             items=$(get_path "$path.$entry" <<<"$schema")
@@ -480,10 +480,10 @@ validate() {
             for item in $(get_keys "$real" <<<"$json" | sort); do
 
                 # Log
-                echo -e "${lvl}- Processing item ${Purple}$item${None}" >&2
+                echo -e "${lvl}- Processing item ${Purple}$item${None}\r" >&2
 
                 if ! validate "$json" "$schema" "$path.$entry" "$real.$item" "$path.$entry" "$not" "$level"; then
-                    echo -e "${lvl}- ${Orange}Item $item is invalid${None}" >&2
+                    echo -e "${lvl}- ${Orange}Item $item is invalid${None}\r" >&2
                     return 1
                 fi
             done
@@ -493,12 +493,12 @@ validate() {
 
             # If items is not an object, do not process
             if test "$type" != "\"object\""; then
-                echo -e "${lvl}- ${Yellow}Skip properties not an object ($type)${None}" >&2
+                echo -e "${lvl}- ${Yellow}Skip properties not an object ($type)${None}\r" >&2
                 continue
             fi
 
             # Log
-            echo -e "${lvl}- Processing ${BWhite}Properties${None}" >&2
+            echo -e "${lvl}- Processing ${BWhite}Properties${None}\r" >&2
 
             # get properties list
             props=$(get_keys "$path.$entry" <<<"$schema" | tr "\n" " ")
@@ -509,11 +509,11 @@ validate() {
             # Loop through properties
             for prop in $props; do
 
-                #echo -e "${lvl}- Processing property ${Purple}$prop${None}" >&2
+                #echo -e "${lvl}- Processing property ${Purple}$prop${None}\r" >&2
                 if $not is_existing_path "$real.$prop" <<<"$json"; then
 
                     # Log
-                    echo -e "${lvl}- Processing <${Purple}$prop${None}>" >&2
+                    echo -e "${lvl}- Processing <${Purple}$prop${None}>\r" >&2
 
                     # Parse sub schema
                     if ! validate "$json" "$schema" "$path.$entry.$prop" "$real.$prop" "$path.$entry.$prop" "$not" "$level"; then
@@ -522,7 +522,7 @@ validate() {
                     fi
                 else
                     # Log
-                    echo -e "${lvl}- ${Yellow}Skip property $real.$prop not present${None}" >&2
+                    echo -e "${lvl}- ${Yellow}Skip property $real.$prop not present${None}\r" >&2
                 fi
             done
 
@@ -531,15 +531,15 @@ validate() {
 
         \"additionalProperties\")
 
-            echo -e "${lvl}- Processing ${BWhite}Additional properties${None}" >&2
+            echo -e "${lvl}- Processing ${BWhite}Additional properties${None}\r" >&2
             if is_existing_path "$path.$entry" <<<"$schema"; then
 
-                echo -e "${lvl}- ${Purple}Additional properties allowed for ${real:-.}${None}" >&2
+                echo -e "${lvl}- ${Purple}Additional properties allowed for ${real:-.}${None}\r" >&2
 
                 for prop in $(get_keys "$real" <<<"$json" | sort); do
 
                     if ! grep -q "$prop" <<<"$props"; then
-                        echo -e "${lvl}- Adding additional property <${Purple}$real.$prop${None}>" >&2
+                        echo -e "${lvl}- Adding additional property <${Purple}$real.$prop${None}>\r" >&2
 
                         # Keep track of validated path
                         echo "$real.$prop"
@@ -551,7 +551,7 @@ validate() {
     done
 
     # Log
-    echo -e "${lvl}${Blue}End Parsing, all valid!${None}" >&2
+    echo -e "${lvl}${Blue}End Parsing, all valid!${None}\r" >&2
 }
 
 # if local flag is set, get schema from json file name
@@ -564,7 +564,7 @@ if [ -n "$local" ]; then
     schema=$local/_$type.schema.json
 
     # log
-    echo -e "${Yellow}Infering schema from local folder for ${UYellow}$json${None}" >&2
+    echo -e "${Yellow}Infering schema from local folder for ${UYellow}$json${None}\r" >&2
 fi
 
 # Check if schema file exists, and if not and import allowed, download it from schema store
@@ -576,7 +576,7 @@ if [ -n "$import" ] && [ ! -f "$schema" ]; then
     schema=$(get_schema_url $search)
 
     # log
-    echo -e "${Yellow}Infering schema from schema store for ${UYellow}$search${Yellow} ${schema:+"found!"}${None}" >&2
+    echo -e "${Yellow}Infering schema from schema store for ${UYellow}$search${Yellow} ${schema:+"found!"}${None}\r" >&2
 fi
 
 # if schema file does not exist, use fallback schema
@@ -596,12 +596,12 @@ if [ -n "$fallback" ] && [ -z "$schema" ]; then
     fi
 
     # log
-    echo -e "${Yellow}Using fallback schema ${UYellow}$schema${None}" >&2
+    echo -e "${Yellow}Using fallback schema ${UYellow}$schema${None}\r" >&2
 fi
 
 # Check if schema is readable
 if test -z "$schema"; then
-    echo -e "${Red}Schema is missing${None}" >&2
+    echo -e "${Red}Schema is missing${None}\r" >&2
     exit 1
 fi
 
@@ -611,9 +611,9 @@ schema=$(get_schema "$schema" "" "$allow")
 # Strip comments from JSON and go through normalization
 # if parse "$json" "$schema" >/dev/null; then ## Uncomment this line to enable debug output
 if validate "$json" "$schema"; then
-    echo -e "${Green}JSON is valid and normalized${None}" >&2
+    echo -e "${Green}JSON is valid and normalized${None}\r" >&2
 else
-    echo -e "${Red}JSON is empty or invalid${None}" >&2
+    echo -e "${Red}JSON is empty or invalid${None}\r" >&2
     exit 1
 fi >/tmp/$$.json