Hcl

HCL is a configuration language implementation designed for parsing, evaluating, and encoding structured settings through the use of blocks and attributes. It functions as a configuration AST parser and a schema-based decoder that maps attributes and blocks to internal data structures using predefined rules.

The project includes an expression evaluation engine that resolves dynamic values and cross-references through multi-phase processing of variables and functions. It also provides a configuration file formatter to standardize the layout and indentation of source code for consistent visual styling.

The system covers a broad set of capabilities including configuration schema validation, dynamic expression evaluation, and the ability to merge multiple configuration files. It supports the conversion of source code into abstract syntax trees for structural analysis and manipulation, as well as the processing of JSON input through a consistent internal representation.

The implementation is written in Go.

Features

Infrastructure Configuration Languages - Implements a structured language for defining software settings using human-readable blocks and attributes.
AST Parsers - Converts raw configuration text into a manipulatable abstract syntax tree for structural analysis.
Configuration File Formatters - Standardizes the layout, style, and indentation of configuration files.
Configuration Schemas - Enforces formal definitions that specify required structures, data types, and constraints for configuration files.
Dynamic Configuration Expressions - Implements runtime evaluation of expressions to compute values for infrastructure and resource configuration.
Abstract Syntax Tree Parsing - Provides a parser that converts configuration source code into an abstract syntax tree for structural analysis.
AST Manipulation Libraries - Converts source code into an abstract syntax tree to analyze or rewrite specific configuration elements.
Configuration Decoders - Deserializes configuration attributes and blocks into strongly typed language structures with source range tracking.
Configuration Language Implementations - Provides a full implementation for parsing, evaluating, and encoding a structured configuration language.
Configuration Parsers - Converts formatted configuration text into structured data that applications can use.
Expression Evaluators - Provides an engine for processing mathematical and logical expressions during the configuration evaluation process.
Multi-Phase Resolvers - Resolves dynamic values and cross-references through multi-phase processing to handle inter-dependent configuration settings.
Source File Parsing - Parses formatted configuration text files into structured abstract syntax trees for internal logic.
Hierarchical Configuration Structures - Allows organizing settings into a hierarchy of attributed bodies and named blocks to represent application configuration.
Abstract Syntax Tree Parsing - Converts configuration source code into an abstract syntax tree for structural analysis and manipulation.
Configuration Formats and Schemas - Filters and validates configuration content against a predefined schema to retrieve specific attributes and blocks.
Application Configuration - Converts human-readable configuration files into structured data objects for use within applications.
Data Validation Schemas - Ensures input data conforms to a predefined structure of required attributes and blocks.
Dynamic Configuration Evaluators - Computes configuration values at runtime using variables, functions, and logical expressions.
Schema-Based Decoders - Maps configuration attributes and blocks to internal data structures using predefined schemas and validation rules.
Source Code Formatting - Standardizes the visual layout and indentation of configuration source code for consistent project styling.
JSON-Compatible Pipelines - Processes JSON input through a consistent internal AST pipeline to ensure behavioral parity with native HCL syntax.
Configuration Rewriters - Updates specific block types, labels, or attributes within existing files without reconstructing the entire document.
Configuration Merging - Combines multiple configuration fragments into a single consolidated representation based on a defined schema.
JSON to Configuration Conversions - Processes JSON input through a consistent internal representation to ensure parity with native syntax.
Splat Initializers - Provides splat operators to generate new tuples or objects by projecting attributes from existing collections.
Configuration Encoders - Transforms internal data structures into formatted text representations for application configuration.
Configuration Logic Functions - Enables the creation of named functions with specific parameters and result types for use within configuration logic.
Configuration Expression Resolvers - Converts configuration expressions into traversal steps to locate specific referenced attributes or objects.
Context Extensions - Defines the environment of available variables and functions for evaluation using hierarchical relationships.
Multi-Phase Evaluation - Processes configuration in multiple phases to resolve advanced patterns and cross-references between different sections of a file.
JSON Parsing - Processes JSON input using the same internal architecture as the native HCL syntax for behavioral consistency.
String Interpolation - Combines literal text with expressions and directives to produce dynamic strings in single or multi-line formats.
Variable Scope Management - Manages a hierarchy of parent and child contexts to resolve symbolic variables during expression evaluation.
Human-Readable Formatting - Converts internal data structures into a human-readable format suitable for persistence and external sharing.
Default Configuration Values - Implements systems for defining and applying fallback settings when explicit configuration values are omitted.
Error Reporting - Captures configuration anomalies with severity levels and source ranges to guide users in fixing issues.
Variable Reference Resolvers - Converts expressions into structural traversals to identify the names of variables and attributes.
Configuration Type Enforcers - Enforces type requirements on values and handles default values for omitted object attributes.
Structural Static Analysis - Inspects the physical syntax of lists, maps, and function calls without executing the expressions.
Source Position Locators - Identifies blocks, expressions, or attributes that contain a specific source position to retrieve nested or top-level structures.
Static Expression Evaluation - Analyzes expression types in the native syntax to provide interpretation without dynamic evaluation.
Configuration Management - HashiCorp Configuration Language parser.

google/cel-go

2,875View on GitHub

cel-go is a Go implementation of the Common Expression Language, providing a type-safe engine for the evaluation of non-Turing complete, side-effect-free expressions. It functions as an embedded expression engine that converts human-readable strings into type-checked abstract syntax trees to ensure safe execution. The system utilizes a compile-once evaluate-many model, parsing and validating expressions into cached programs for repeated execution across different datasets. It further distinguishes itself as a partial state evaluator, using commutative logic to compute results and return resid

dtolnay/syn

3,292View on GitHub

syn is a Rust syntax tree parser and token stream converter. It serves as a toolkit for procedural macro development, providing a framework to parse Rust source code into structured syntax trees for analysis and transformation. The project enables the manipulation of Rust abstract syntax trees through specialized visitor and folder patterns for traversing and mutating nodes. It provides a bidirectional mapping that allows developers to convert token streams into structured trees and print those trees back into tokens for code generation. The library covers a broad range of syntax analysis ca

oils-for-unix/oils

3,288View on GitHub

Oils is a Unix shell interpreter and scripting language runtime that combines a modern shell language with POSIX and Bash compatibility. It functions as a structured data shell, integrating JSON and J8 formats to manage complex data without relying on string parsing. The system is distinguished by a C++ transpiled interpreter that converts a subset of Python source code into strongly typed C++ for high-performance execution. It features a garbage-collected typed runtime that supports prototype-based polymorphism, lexical closures, and reference-based variable mutation. To decouple shell logic

sideway/joi

21,192View on GitHub

Joi is a JavaScript data validation library used to define schemas that ensure the structure and data types of objects remain consistent. It functions as a schema-based validator and object schema definition tool, preventing invalid information from entering an application by checking data against predefined constraints and rules. The library employs a chainable fluent interface and a constraint-based validation engine to build complex validation pipelines. It utilizes recursive tree traversal to validate nested data structures and a type-coercion pipeline to transform input values into the t

hashicorphcl

Features