Parsers

cd python/
pip install -r requirements.txt

python parser.py input.3tl              # Compact JSON
python parser.py input.3tl --pretty     # Pretty-printed
python validator.py input.3tl           # Validate only

from parser import parse_file, parse_string, to_json

# Parse file
doc = parse_file('data.3tl')

# Parse string
doc = parse_string('''
#! User
#@ id:uint, name:str
1, Alice
''')

# Access data
for table in doc.tables:
    print(f"Table: {table.name}")
    for col in table.columns:
        print(f"  {col.name}: {col.type.base_type}")
    for row in table.rows:
        print(f"  Row: {row}")

# Convert to JSON
json_str = to_json(doc, pretty=True)

@dataclass
class TypeInfo:
    base_type: str
    is_array: bool = False
    is_nullable: bool = False
    params: Optional[dict[str, Any]] = None

@dataclass
class Column:
    name: str
    type: TypeInfo

@dataclass
class Table:
    name: str
    columns: list[Column]
    rows: list[list[Any]]

@dataclass
class Document:
    tables: list[Table]

python -m pytest test_parser.py

cd javascript/
npm install

node src/cli.js input.3tl              # Compact JSON
node src/cli.js input.3tl --pretty     # Pretty-printed

import { parseFile, parseString, toJSON } from './src/parser.js';

// Parse file
const doc = parseFile('../examples/products.3tl');

// Parse string
const doc = parseString(`
#! User
#@ id:uint, name:str
1, Alice
`);

// Access data
for (const table of doc.tables) {
  console.log(`Table: ${table.name}`);
  for (const col of table.columns) {
    console.log(`  ${col.name}: ${col.type}`);
  }
  for (const row of table.rows) {
    console.log(`  Row: ${row}`);
  }
}

// Convert to JSON
const json = toJSON(doc, true);
console.log(json);

{
  tables: [
    {
      name: 'User',
      columns: [
        { name: 'id', type: 'uint' },
        { name: 'name', type: 'str' }
      ],
      rows: [
        [1, 'Alice'],
        [2, 'Bob']
      ]
    }
  ]
}

npm test

cd clojure/
# Dependencies auto-downloaded via deps.edn

clojure -M -m three-tl.parser input.3tl        # Compact JSON
clojure -M -m three-tl.parser input.3tl true   # Pretty-printed

(require '[three-tl.parser :as parser])

;; Parse file
(def doc (parser/parse-file "../examples/products.3tl"))

;; Parse string
(def doc (parser/parse-string 
  "#! User
   #@ id:uint, name:str
   1, Alice"))

;; Access data
(doseq [table (:tables doc)]
  (println "Table:" (:name table))
  (doseq [col (:columns table)]
    (println "  " (:name col) ":" (:type col)))
  (doseq [row (:rows table)]
    (println "  Row:" row)))

;; Convert to JSON
(parser/to-json doc true)

{:tables
 [{:name "User"
   :columns [{:name "id" :type {:base-type "uint"}}
             {:name "name" :type {:base-type "str"}}]
   :rows [[1 "Alice"]
          [2 "Bob"]]}]}

clojure -X:test

cd go/
go mod download

go run ./cmd/3tl-parser input.3tl              # Compact JSON
go run ./cmd/3tl-parser input.3tl --pretty     # Pretty-printed

package main

import (
    "fmt"
    "log"
    "github.com/jiriknesl/3tl/pkg/parser"
)

func main() {
    // Parse file
    doc, err := parser.ParseFile("../examples/products.3tl")
    if err != nil {
        log.Fatal(err)
    }

    // Parse string
    doc, err = parser.ParseString(`
#! User
#@ id:uint, name:str
1, Alice
`)
    if err != nil {
        log.Fatal(err)
    }

    // Access data
    for _, table := range doc.Tables {
        fmt.Printf("Table: %s\n", table.Name)
        for _, col := range table.Columns {
            fmt.Printf("  %s: %s\n", col.Name, col.Type)
        }
        for _, row := range table.Rows {
            fmt.Printf("  Row: %v\n", row)
        }
    }

    // Convert to JSON
    json, err := parser.ToJSON(doc, true)
    if err != nil {
        log.Fatal(err)
    }
    fmt.Println(json)
}

type Document struct {
    Tables []Table `json:"tables"`
}

type Table struct {
    Name    string     `json:"name"`
    Columns []Column   `json:"columns"`
    Rows    [][]any    `json:"rows"`
}

type Column struct {
    Name string `json:"name"`
    Type string `json:"type"`
}

go test ./pkg/parser -v

{
  "tables": [
    {
      "name": "User",
      "columns": [
        {
          "name": "id",
          "type": "uint"
        },
        {
          "name": "name",
          "type": "str"
        }
      ],
      "rows": [
        [1, "Alice"],
        [2, "Bob"]
      ]
    }
  ]
}