hcl-rs

A rust library for interacting with the Hashicorp Configuration Language (HCL).

Features

• A parser for the HCL syntax specification
• Types for all HCL structures, e.g. body, blocks and attributes
• Supporting macros like body! for constructing HCL data structures
• Supports the expression and template sub-languages in attribute values
• Support for deserializing and serializing arbitrary types that implement serde::Deserialize or serde::Serialize
• Evaluation of the HCL expression and template sub-languages

Deserialization examples

Deserialize arbitrary HCL according to the HCL JSON Specification:

```rust use serde_json::{json, Value};

let input = r#" some_attr = { foo = [1, 2] bar = true }

some_block "some_block_label" {
  attr = "value"
}

"#;

let expected = json!({ "someattr": { "foo": [1, 2], "bar": true }, "someblock": { "someblocklabel": { "attr": "value" } } });

let value: Value = hcl::from_str(input).unwrap();

assert_eq!(value, expected); ```

If you need to preserve context about the HCL structure, deserialize into hcl::Body instead:

```rust use hcl::{Block, Body, Expression};

let input = r#" some_attr = { "foo" = [1, 2] "bar" = true }

some_block "some_block_label" {
  attr = "value"
}

"#;

let expected = Body::builder() .addattribute(( "someattr", Expression::fromiter([ ("foo", Expression::from(vec![1, 2])), ("bar", Expression::Bool(true)), ]), )) .addblock( Block::builder("someblock") .addlabel("someblocklabel") .add_attribute(("attr", "value")) .build(), ) .build();

let body: Body = hcl::from_str(input).unwrap();

assert_eq!(body, expected); ```

Serialization examples

An example to serialize some terraform configuration:

```rust use hcl::expr::Traversal; use hcl::{Block, Body, Variable};

let body = Body::builder() .addblock( Block::builder("resource") .addlabel("awssnstopicsubscription") .addlabel("my-subscription") .addattribute(( "topicarn", Traversal::builder(Variable::new("awssnstopic").unwrap()) .attr("my-topic") .attr("arn") .build(), )) .addattribute(("protocol", "sqs")) .addattribute(( "endpoint", Traversal::builder(Variable::new("awssqsqueue").unwrap()) .attr("my-queue") .attr("arn") .build(), )) .build(), ) .build();

let expected = r#" resource "awssnstopicsubscription" "my-subscription" { topicarn = awssnstopic.my-topic.arn protocol = "sqs" endpoint = awssqsqueue.my-queue.arn } "#.trim_start();

let serialized = hcl::to_string(&body).unwrap();

assert_eq!(serialized, expected); ```

Also have a look at the other examples provided in the documentation of the ser module to learn how you can construct HCL blocks when serializing custom types.

Expression evaluation

The eval module documentation contains more details and examples for expression and template evaluation, but here's a very short example:

```rust use hcl::Value; use hcl::eval::{Context, Evaluate}; use hcl::expr::TemplateExpr;

let expr = TemplateExpr::from("Hello ${name}!");

let mut ctx = Context::new(); ctx.declare_var("name", "World");

assert_eq!(expr.evaluate(&ctx).unwrap(), Value::from("Hello World!")); ```

Macros

This crate provides a couple of macros to ease building HCL data structures. Have a look at their documentation for usage examples.

Contributing

Contributions are welcome! Please read CONTRIBUTING.md before creating a PR.

License

The source code of hcl-rs is released under the MIT License. See the bundled LICENSE file for details.