How to use the command 'zek' (with examples)

The zek command is a tool designed to generate Go structs from XML data. It operates directly on the XML provided via standard input and outputs the equivalent Go struct code. This is particularly handy for Go developers who need to work with XML data in their applications, as it saves time and reduces the likelihood of errors that can occur when manually translating XML structures into Go structs. With zek, developers can quickly convert complex XML data into workable Go code, streamlining their workflow and enhancing productivity.

Use case 1: Generate a Go struct from a given XML from stdin and display output on stdout

Code:

cat path/to/input.xml | zek

Motivation:

Imagine you’re working on a Go application that interacts with an external web service providing XML data. Converting this XML data into Go structs allows you to work with it more effectively within your application, making data manipulation and access easier. By using this command, you immediately see the Go struct representation in your terminal, allowing for an instantaneous visual assessment of the structure’s accuracy and suitability for your needs.

Explanation:

• cat path/to/input.xml: This command reads the XML data from a specified file and outputs it, effectively feeding it into the pipeline.
• | (pipe operator): This sends the output of the cat command into the zek tool via standard input.
• zek: The command-line tool that processes the XML data fed into it and outputs the corresponding Go struct to standard output (stdout).

Example output:

Upon executing the above command, the output might look like this:

type Example struct {
    Name string `xml:"name"`
    Age  int    `xml:"age"`
}

This is a simple Go struct with two fields derived from the XML’s elements.

Use case 2: Generate a Go struct from a given XML from stdin and send output to a file

Code:

curl -s https://url/to/xml | zek -o path/to/output.go

Motivation:

Fetching XML data from an online source and needing to store the resulting Go structs in a file is a common task. This is particularly useful when you’re preparing template code to be included as part of a larger project. By saving it directly to a file, you eliminate the need to manually redirect output, which can save time and prevent errors, ensuring that the code is correctly formatted and ready for integration or further development.

Explanation:

• curl -s https://url/to/xml: Fetches XML data from the specified URL. The -s flag (silent) prevents curl from displaying progress and error messages.
• | (pipe operator): Directs the fetched XML data to zek.
• zek -o path/to/output.go: zek processes the input XML, and -o specifies that the output should be written to the file located at path/to/output.go.

Example output:

The output file path/to/output.go will contain something like:

type Response struct {
    Status  string `xml:"status"`
    Message string `xml:"message"`
}

This Go struct is based on the XML structure retrieved from the URL.

Use case 3: Generate an example Go program from a given XML from stdin and send output to a file

Code:

cat path/to/input.xml | zek -p -o path/to/output.go

Motivation:

Sometimes, it’s beneficial to not only generate the Go structs but also see them in the context of a fully working Go application. This is helpful for educational purposes, prototyping, or testing. Using this command, you can create a minimal Go program that demonstrates how to work with the generated structs, providing a practical example that can be adapted for more sophisticated use.

Explanation:

• cat path/to/input.xml: Reads the XML data from a specified file.
• | (pipe operator): Passes the XML data to zek.
• zek -p: The -p option directs zek to generate a complete example program, showcasing the struct in use.
• -o path/to/output.go: This flag specifies the file path where the complete program will be saved.

Example output:

Upon successful execution, the path/to/output.go file might contain:

package main

import (
    "encoding/xml"
    "fmt"
    "os"
)

type Person struct {
    Name string `xml:"name"`
    Age  int    `xml:"age"`
}

func main() {
    data := `<person><name>John Doe</name><age>30</age></person>`
    var p Person
    err := xml.Unmarshal([]byte(data), &p)
    if err != nil {
        fmt.Println("Error unmarshalling XML:", err)
        os.Exit(1)
    }
    fmt.Printf("Person: %#v\n", p)
}

This is a complete Go program that uses the generated Person struct to deserialize the example XML data.

Conclusion:

These examples illustrate how the zek command can be a powerful tool for Go developers working with XML data. Whether you need a quick conversion to a Go struct or a comprehensive example program, zek simplifies the process, improving productivity and accuracy in your development workflow. By understanding these use cases, you can more effectively harness its capabilities to suit your specific project needs.