JSON ⇔ YAML ⇔ TOML mutual format conversion tool | ZeroTools

The three major data serialization languages, Jason as defined by RFC 8259, Yamul as defined in the 1.2 standard, and Tommul as in the version 1.0.0 specification, each have their own syntax rules and data structure semantics.

At the core of this interconverter is an advanced parsing engine that allows for bidirectional transpilation of data between these three languages ​​without data degradation.

Each language's parser converts the input text stream into an abstract syntax tree and maps it to a common intermediate representation data model.

This intermediate representation maintains a pure hierarchical structure of information, free from language-specific constraints, and is reassembled into an optimal structure when passed to the serializer of the target language.

For example, Jason's strict parenthesis nesting is mathematically rearranged to match each language's parsing context, such as Yamul's indentation-based block style and Tommul's flat key-value stores and inline tables.

Inside the transpile engine, a cyclic reference detection mechanism is constantly running to prevent infinite loops and memory leaks, allowing analysis to be completed in near constant time even with deep hierarchical data.

The reference structure using anchors and aliases, which are advanced functions unique to Yamul, cannot be expressed in their original form when converted to Jason or Tomuru, so dynamic entity expansion in memory is essential.

When the conversion engine scans Yamul's abstract syntax tree, it registers the anchor node pointer in the symbol table, and when an alias node appears, it copies and replaces the corresponding data block from the symbol table.

During this process, a resolution algorithm based on depth-first search accurately resolves dependencies even in the presence of recursive alias references.

On the other hand, Toml's unique square bracket table definitions and double square bracket table array definitions are seamlessly mapped to hierarchical associative arrays.

The deep nested structure represented by Toml's dot-separated keys is interpreted in the intermediate representation as a tree node addition operation, and during inverse transformation, a self-organizing heuristic is applied that measures the tree depth and automatically switches from an inline table to a header table definition if it exceeds a certain threshold.

This ensures beautifully structured output that maximizes human readability.

A non-destructive data replacement algorithm operates to accommodate differences in data types supported between the three languages.

The offset date/time and local date/time types that Tomru natively supports are automatically cast to an ISOO 8601 format string when converted to Jason, and in the reverse conversion, a regular expression-based parser detects the date string and restores it to a timestamp object.

When converting between arrays and associative arrays, it verifies the type homogeneity of elements within a collection, and performs safe type inference downcasting from dynamically typed lists to statically typed arrays when outputting to languages ​​with strict type constraints such as Toml.

Different representations of infinity and non-numbers in floating point numbers, as well as different representations of boolean values, are normalized into a common token sequence during the lexical analysis phase.

Furthermore, for numerical data that may cause overflow, such as large-length integers, the limit of 64-bit floating point precision is automatically detected, and if necessary, a fallback to uppercase string representation is encouraged, thereby eliminating rounding errors in the computer environment.

To maximize client-side computational resources, all of this transpilation processing is performed synchronously within the web browser's local memory space.

Since no communication to an external server is required, the conversion process can be completed with no risk of information leakage, even for configuration files containing highly confidential authentication information or dump data of system environment variables.

The conversion pipeline fires in milliseconds, triggered by a key press event in the text area, and immediately renders the output on screen in synchronization with updates to the virtual document object model.

By buffering the input stream and utilizing asynchronous workers, a non-blocking architecture has been implemented that allows parsing to continue in the background without blocking the main thread, and to smoothly update the screen as soon as it is completed, even when inputting a huge data set of tens of thousands of rows.

This allows users to visually check the conversion results literally in real time while editing the code.

Indentation depth and style, which affect code readability, are finely controlled depending on the output format. Not only are formatting rules that are most appropriate for the language specifications of the output destination automatically applied, such as Jason's tab characters and number of spaces, and Yamul's block style indentation width for each level, but they can also be overridden by the user's arbitrary settings.

Furthermore, we have implemented a unique comment node extraction function for comment lines in code, which is the element most often lost in data conversion tools.

End-of-line comments and start-of-line comments that begin with a pound sign entered in Yamul or Tommul are temporarily stored as metadata attached to the nearest data node in the abstract syntax tree.

Due to the specifications, it is not possible to maintain comments when converting to Jason, but when converting back to Yamul or Tomuru, this memorized metadata is referenced and the comments are reversibly restored to their original positions.

Converted data is expanded into memory as a binary large object, and can be written directly to the system clipboard or exported for instant download as a file with a specified extension in one click.

This mutual conversion engine shows its true value in managing configuration files for various tools that are essential in modern software development.

For example, compose files used by the containerization technology Docker are usually written in Yamul, but by converting them to Jason, you can easily build a pipeline that mechanically extracts and inspects configuration values ​​from shell scripts or external parsing tools using JQ commands.

It also functions as a pre-processing process to jasonize the Couvernetis manifest files and pass the secret resource values ​​to the automatic encryption tool.

Even when transferring configuration information between different ecosystems, such as Cargotoml, which is used by Cargo, the last language package manager, and PackageJason, which is NodeJS's standard, it is possible to rewrite it into an accurate expression that matches the manners of the other language, without breaking the definition structure of the dependency list or build script.

This breaks down file format barriers in the context of infrastructure-as-code and supports seamless integration between disparate technologies.