Merge branch 'develop_consolidation' into 'develop'

v2.0.0

See merge request libremfg/b2mml-batchml!5

Author: tomhollingworth

Docs/content/posts/version-v1.0.0.md

@@ -1,5 +1,5 @@
 +++
-title = 'Version v1.0.0'
+title = 'Version 1.0.0'
 date = 2024-07-12T18:43:31Z
 +++
 

Docs/content/posts/version-v2.0.0.md

@@ -31,7 +31,7 @@ Based on the works of https://github.com/MESAInternational/B2MML-BatchML.
 Start out by importing the schema and using it in your JSON documents. 
 
 ```
-"$schema": "{{< siteurl >}}schemas"
+"$schema": "{{< siteurl >}}schemas/"
 ```
 
 Here is an example using the JSON schema in a `NotifyWorkDefined` message.

scripts/baseToDt.go

@@ -8,49 +8,38 @@ import (
 
 // This is a very specific script that took all the definitions within v2.0.0.dataType.schema.json and checked if it existed within the base file
 // if it existed (which they all do) then it will copy the reference over, which saves a lot of tedious copy and pasting
-
-func DTchangeReferences() {
-	jsonFile := "/Users/mattprincev/Documents/Rhize/JSON Schema/b2mml-batchml/dataTypeTest.json"
-	baseFile := "/Users/mattprincev/Documents/Rhize/JSON Schema/b2mml-batchml/oldSchema/v2.0.0.base.schema.json"
+func DTchangeReferences(newFile string, baseFile string) (int, error) {
 
 	// Extract keys from the JSON file
-	keys, err := DTextractKeys(jsonFile)
+	keys, err := DTextractKeys(newFile)
 	if err != nil {
-		fmt.Println("Error extracting keys:", err)
-		return
+		return fmt.Println("Error extracting keys:", err)
 	}
 
-	// fmt.Println("Extracted keys:", keys)
-	// fmt.Println("Length of extracted keys:", len(keys))
-
 	// Get the $ref values from the base file
 	refs, err := DTgetRefs(keys, baseFile)
 	if err != nil {
-		fmt.Println("Error getting references:", err)
-		return
+		return fmt.Println("Error getting references:", err)
 	}
 
-	// Print the map of refs
-	// refsJSON, err := json.MarshalIndent(refs, "", "  ")
-	// if err != nil {
-	// 	fmt.Println("Error marshalling refs:", err)
-	// 	return
-	// }
-	// fmt.Println("Refs:", string(refsJSON))
-	// fmt.Println("refs:", refs)
-
 	// Replace the $ref values in the output file
-	if err := DTreplacesRefs(jsonFile, refs); err != nil {
-		fmt.Println("Error replacing references:", err)
+	if err := DTreplacesRefs(newFile, refs); err != nil {
+		return fmt.Println("Error replacing references:", err)
 	}
+
+	return 0, nil
 }
 
+// Extracts the definitions keys from the dataType schema file
 func DTextractKeys(jsonFile string) ([]string, error) {
+
+	// read the json file
 	data, err := os.ReadFile(jsonFile)
 	if err != nil {
 		return nil, fmt.Errorf("error reading JSON file: %v", err)
 	}
 
+	// unmarshall the data from reading the json file and map it to the struct in main
 	var jsonData map[string]interface{}
 	if err := json.Unmarshal(data, &jsonData); err != nil {
 		return nil, fmt.Errorf("error unmarshalling JSON data: %v", err)
@@ -62,6 +51,7 @@ func DTextractKeys(jsonFile string) ([]string, error) {
 		return nil, fmt.Errorf("$defs section not found or is not an object")
 	}
 
+	// create string array for mapping definitions from schema
 	var keys []string
 	for key := range defs {
 		keys = append(keys, key)
@@ -70,7 +60,9 @@ func DTextractKeys(jsonFile string) ([]string, error) {
 	return keys, nil
 }
 
+// Finds the references within the base schema file and creates a map containing them
 func DTgetRefs(keys []string, baseFile string) (map[string]string, error) {
+
 	// Read the JSON file
 	data, err := os.ReadFile(baseFile)
 	if err != nil {
@@ -105,7 +97,9 @@ func DTgetRefs(keys []string, baseFile string) (map[string]string, error) {
 	return refMap, nil
 }
 
+// This will write the references found in the base file to the dataType schema file
 func DTreplacesRefs(outputFile string, refValues map[string]string) error {
+
 	// Read the JSON file
 	data, err := os.ReadFile(outputFile)
 	if err != nil {
@@ -143,6 +137,7 @@ func DTreplacesRefs(outputFile string, refValues map[string]string) error {
 
 // updateRefs recursively updates the $ref values in the $defs section
 func updateRefs(data interface{}, refValues map[string]string) {
+
 	switch v := data.(type) {
 	case map[string]interface{}:
 		for key, value := range v {

scripts/findPropRefs.go

@@ -6,48 +6,48 @@ import (
 	"os"
 )
 
-func findPropRefs(schemaFile string) {
-	// Command-line argument to implement
-	// xsdFile := flag.String("xsd", "b2mml-batchml/B2MML-ConfirmBOD .xsd", "XSD file to parse")
-	// jsonFile := flag.String("json", "b2mml-batchml/Schema/v2.0.0.base.schema.json", "JSON file to parse")
-	// outputFile := flag.String("output", "testFile.json", "Output file name")
-	// flag.Parse()
+// After converting an XSD file to a JSON file, this script adds all references found
+// within the specified base file to the designated schema file.
+func findPropRefs(schemaFile string, baseFile string) (int, error) {
 
-	// schemaFile := "/Users/mattprincev/Documents/Rhize/JSON Schema/b2mml-batchml/errorTest.json"
-	baseFile := "/Users/mattprincev/Documents/Rhize/JSON Schema/b2mml-batchml/schemas/v2.0.0.batchInformation.schema.json"
-
-	// Get the list of names from the XSD file
+	// Gets the list of names from the XSD file
 	propNames, err := getPropNames(schemaFile)
 	if err != nil {
-		fmt.Println("Error parsing schema file:", err)
-		return
+		return fmt.Println("Error parsing schema file:", err)
 	}
 
+	// Gets the name of the references needed to search for in the basefile
 	baseRefs, err := getBaseRefs(propNames, baseFile)
 	if err != nil {
-		fmt.Println("Error getting base references:", err)
-		return
+		return fmt.Println("Error getting base references:", err)
 	}
 
+	// Adds each instance of a reference to the definition
 	err = addDefs(baseRefs, schemaFile)
 	if err != nil {
-		fmt.Println("Error adding definitions:", err)
-		return
+		return fmt.Println("Error adding definitions:", err)
 	}
+
+	return 0, nil
 }
 
+// Reads the property names that need to be searched for in the base file
 func getPropNames(jsonFile string) (map[string]interface{}, error) {
+
+	// Read the inputted schema file
 	data, err := os.ReadFile(jsonFile)
 	if err != nil {
 		return nil, fmt.Errorf("error reading JSON file: %v", err)
 	}
 
+	// unmarshal the read data into the JSON struct
 	var jsonData JSONStructure
 	if err := json.Unmarshal(data, &jsonData); err != nil {
 		return nil, fmt.Errorf("error unmarshalling JSON data: %v", err)
 	}
 
-	var refProps = make(map[string]interface{}) // Initialize the map
+	// Initialize the map
+	var refProps = make(map[string]interface{})
 
 	for key, value := range jsonData.Properties {
 		refProps[key] = value
@@ -56,7 +56,9 @@ func getPropNames(jsonFile string) (map[string]interface{}, error) {
 	return refProps, nil
 }
 
+// Gets the property names from the base schema and adds them to the json structure
 func getBaseRefs(propNames map[string]interface{}, baseSchema string) (map[string]interface{}, error) {
+
 	data, err := os.ReadFile(baseSchema)
 	if err != nil {
 		return nil, fmt.Errorf("error reading JSON file: %v", err)
@@ -79,7 +81,9 @@ func getBaseRefs(propNames map[string]interface{}, baseSchema string) (map[strin
 	return propNames, nil
 }
 
+// Adds the definitions found from the base file into the inputted schema file
 func addDefs(definitions map[string]interface{}, schemaFile string) error {
+
 	data, err := os.ReadFile(schemaFile)
 	if err != nil {
 		return fmt.Errorf("error reading JSON file: %v", err)
@@ -90,7 +94,6 @@ func addDefs(definitions map[string]interface{}, schemaFile string) error {
 		return fmt.Errorf("error unmarshalling JSON data: %v", err)
 	}
 
-	// var refProps = make(map[string]interface{})
 	for key, value := range definitions {
 		jsonData.Defs[key] = value
 	}
@@ -100,7 +103,7 @@ func addDefs(definitions map[string]interface{}, schemaFile string) error {
 		return fmt.Errorf("error marshalling JSON data: %v", err)
 	}
 
-	// Step 5: Write the updated JSON content back to the file
+	// Write the updated JSON content back to the file
 	if err := os.WriteFile(schemaFile, updatedContent, 0644); err != nil {
 		return fmt.Errorf("error writing to file: %v", err)
 	}

scripts/main.go

@@ -1,5 +1,10 @@
 package main
 
+import (
+	"flag"
+	"fmt"
+)
+
 // Struct to represent the JSON structure with generic map
 type JSONStructure struct {
 	ID          string                 `json:"$id"`
@@ -14,22 +19,70 @@ type JSONStructure struct {
 }
 
 func main() {
-	jsonFile := "/Users/mattprincev/Documents/Rhize/JSON Schema/b2mml-batchml/schemas/v2.0.0.generalRecipe.schema.json"
-	// findPropRefs(jsonFile)
-	changeReferences(jsonFile)
-
-	// DTchangeReferences()
-	// parse()
-	// schemaFile := "oldSchema/v2.0.0.base.schema.json"
-
-	// // Load the schema
-	// schemaLoader := gojsonschema.NewReferenceLoader(schemaFile)
-
-	// // Try to compile the schema
-	// _, err := gojsonschema.NewSchema(schemaLoader)
-	// if err != nil {
-	// 	log.Fatalf("Schema compilation error: %s", err)
-	// } else {
-	// 	log.Println("Schema compiled successfully.")
-	// }
+	// Define command-line flags
+
+	// Flag variables for baseToDt.go
+	// example command: go run ./ --dtNewFile=myDataType.json --baseFile=myBaseFile.json
+	dtNewFile := flag.String("dtNewFile", "", "Path to the dataType file")
+	dTBaseFile := flag.String("baseFile", "", "Path to the dataType base file")
+
+	// Flag variables for findPropRefs.go
+	// example command: go run ./ --propRefNewFile=myDataType.json --propRefBaseFile=myBaseFile.json
+	propRefNewFile := flag.String("propRefNewFile", "", "Path to the file that the property references will be added to")
+	propRefBaseFile := flag.String("propRefBaseFile", "", "Path to the base file that contains the property references")
+
+	// Flag variables for refFinder.go
+	// example command: go run ./ --refFinderNewFile=myDataType.json --refFinderBaseFile=myBaseFile.json
+	refFinderNewFile := flag.String("refFinderNewFile", "", "Path to the file that the conatins the reference names that will be searched for")
+	refFinderBaseFile := flag.String("refFinderBaseFile", "", "Path to the directory containing the schema files to be referenced.")
+
+	// Flag variables for xsdToJson.go
+	// example command: go run ./ --dtNewFile=myDataType.json --baseFile=myBaseFile.json
+	xsdFile := flag.String("xsdFile", "", "Path to the xsd schema file")
+	baseJsonFile := flag.String("baseJsonFile", "", "Path to the base json schema file")
+	outputFile := flag.String("outputFile", "", "Name of the output file that will be created")
+
+	// Parse the command-line flags
+	flag.Parse()
+
+	// Check if DTchangeReferences should be called
+	if *dtNewFile != "" && *dTBaseFile != "" {
+		fmt.Println("Running baseToDt.go")
+		if _, err := DTchangeReferences(*dtNewFile, *dTBaseFile); err != nil {
+			return
+		}
+		// fmt.Println(*dtNewFile, *dTBaseFile)
+	} else {
+		fmt.Println("Flags for dataType file are empty")
+	}
+
+	if *propRefNewFile != "" && *propRefBaseFile != "" {
+		fmt.Println("Running findPropRefs.go")
+		if _, err := findPropRefs(*propRefNewFile, *propRefBaseFile); err != nil {
+			return
+		}
+		// fmt.Println(*propRefNewFile, *propRefBaseFile)
+	} else {
+		fmt.Println("Flags for property reference finder are empty")
+	}
+
+	if *refFinderNewFile != "" && *refFinderBaseFile != "" {
+		fmt.Println("Running refFinder.go")
+		if _, err := changeReferences(*refFinderNewFile, *refFinderBaseFile); err != nil {
+			return
+		}
+		// fmt.Println(*refFinderNewFile, *refFinderBaseFile)
+	} else {
+		fmt.Println("Flags for reference finding are empty")
+	}
+
+	if *xsdFile != "" && *baseJsonFile != "" && *outputFile != "" {
+		fmt.Println("Running refFinder.go")
+		if _, err := parse(*xsdFile, *baseJsonFile, *outputFile); err != nil {
+			return
+		}
+		// fmt.Println(*xsdFile, *baseJsonFile, *outputFile)
+	} else {
+		fmt.Println("Flags for xsd to JSON conversion are empty")
+	}
 }