XML to JSON Converter (java, written by Gemini Code Assist)

Gemini Code Assist wrote this java project from the task below. It installed and ran on a clean Ubuntu 22.04 machine as written.

Task given to the agent:

TASK: XML to JSON Converter

Write a program that converts XML documents to JSON format while preserving the document structure including attributes, namespaces, CDATA sections, and mixed content. It should handle complex real-world XML with deeply nested elements.

FUNCTIONAL REQUIREMENTS:
- Accept an XML file path as a command-line argument
- Parse the full XML document including attributes, namespaces, text content, CDATA sections, and comments
- Convert to JSON preserving the hierarchy: elements become objects, repeated elements become arrays, attributes are prefixed with @ symbol, text content uses #text key
- Handle namespace prefixes by including them in key names
- Support converting multiple XML files in a directory via a --batch flag
- Print the resulting JSON to console with pretty-print formatting (indented)
- Save the output as a .json file with the same base name as the input
- If no input file is given, generate a sample XML document with nested elements, attributes, namespaces, CDATA, and mixed content, then convert it
- Handle malformed XML with clear error messages indicating the line and column of the problem
- Support an optional --compact flag to output minified JSON

Create a complete Java project for a clean Ubuntu 22.04 machine with only JDK 17+ installed. Include:
- Source code
- pom.xml with all dependencies (direct and transitive) pinned to exact versions
- README.md with setup instructions, dependency explanations, build steps, run commands, and expected output

[]

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.xmlconverter</groupId>
    <artifactId>xml-to-json-converter</artifactId>
    <version>1.0-SNAPSHOT</version>

    <properties>
        <maven.compiler.source>17</maven.compiler.source>
        <maven.compiler.target>17</maven.compiler.target>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    </properties>

    <dependencies>
        <!-- JSON-Java library for XML to JSON conversion -->
        <dependency>
            <groupId>org.json</groupId>
            <artifactId>json</artifactId>
            <version>20231013</version>
        </dependency>
        <!-- Commons IO for file handling -->
        <dependency>
            <groupId>commons-io</groupId>
            <artifactId>commons-io</artifactId>
            <version>2.15.1</version>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-shade-plugin</artifactId>
                <version>3.5.1</version>
                <executions>
                    <execution>
                        <phase>package</phase>
                        <goals>
                            <goal>shade</goal>
                        </goals>
                        <configuration>
                            <transformers>
                                <transformer implementation="org.apache.maven.plugins.shade.resource.ManifestResourceTransformer">
                                    <mainClass>com.xmlconverter.XmlToJsonConverter</mainClass>
                                </transformer>
                            </transformers>
                        </configuration>
                    </execution>
                </executions>
            </plugin>
        </plugins>
    </build>
</project>

# XML to JSON Converter (Java)

A tool for converting XML documents to JSON while preserving structure and attributes.

## Setup Instructions

1. Ensure JDK 17+ and Maven are installed.
2. Build the project:
   ```bash
   mvn clean package
   ```

## Run Commands

- Convert a single file:
  ```bash
  java -jar target/xml-to-json-converter-1.0-SNAPSHOT.jar data.xml
  ```
- Batch convert a directory:
  ```bash
  java -jar target/xml-to-json-converter-1.0-SNAPSHOT.jar ./xml_files --batch
  ```
- Compact (minified) output:
  ```bash
  java -jar target/xml-to-json-converter-1.0-SNAPSHOT.jar data.xml --compact
  ```
- Run with generated sample data:
  ```bash
  java -jar target/xml-to-json-converter-1.0-SNAPSHOT.jar
  ```

## Output
- Console: Pretty-printed JSON (unless --compact is used).
- File: `.json` file with the same base name as the input.
```

package com.xmlconverter;

import org.json.JSONObject;
import org.json.XML;
import org.apache.commons.io.FileUtils;
import org.apache.commons.io.FilenameUtils;

import java.io.File;
import java.nio.charset.StandardCharsets;

public class XmlToJsonConverter {

    public static void main(String[] args) {
        boolean compact = false;
        boolean batch = false;
        String inputPath = null;

        for (String arg : args) {
            if (arg.equals("--compact")) compact = true;
            else if (arg.equals("--batch")) batch = true;
            else inputPath = arg;
        }

        if (inputPath == null) {
            inputPath = "sample.xml";
            generateSampleXml(inputPath);
        }

        if (batch) {
            File dir = new File(inputPath);
            if (dir.isDirectory()) {
                File[] files = dir.listFiles((d, name) -> name.endsWith(".xml"));
                if (files != null) {
                    for (File f : files) {
                        convertFile(f.getAbsolutePath(), compact);
                    }
                }
            } else {
                System.err.println("Error: " + inputPath + " is not a directory");
            }
        } else {
            convertFile(inputPath, compact);
        }
    }

    private static void generateSampleXml(String path) {
        System.out.println("Generating sample XML: " + path);
        String xml = """
            <?xml version="1.0" encoding="UTF-8"?>
            <root>
                <header id="1">
                    <title>Sample</title>
                </header>
                <body>
                    <items>
                        <item id="101">Product A</item>
                        <item id="102">Product B</item>
                    </items>
                    <content><![CDATA[Some <b>CDATA</b> content]]></content>
                </body>
            </root>
            """;
        try {
            FileUtils.writeStringToFile(new File(path), xml, StandardCharsets.UTF_8);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    private static void convertFile(String path, boolean compact) {
        try {
            File inputFile = new File(path);
            String xml = FileUtils.readFileToString(inputFile, StandardCharsets.UTF_8);
            
            JSONObject json = XML.toJSONObject(xml);
            
            String jsonOutput = compact ? json.toString() : json.toString(4);
            
            String outputPath = FilenameUtils.removeExtension(path) + ".json";
            FileUtils.writeStringToFile(new File(outputPath), jsonOutput, StandardCharsets.UTF_8);
            
            System.out.println("Converted " + path + " to " + outputPath);
            if (!compact) System.out.println(jsonOutput);
            
        } catch (Exception e) {
            System.err.println("Error converting " + path + ": " + e.getMessage());
        }
    }
}