Crate edres

If serde turns your structs into markup files,

then edres turns your markup files into structs.

This crate has three main related functionalities:

1. Generate a set of structs representing the contents of a single markup file.
2. Generate an enum to represent the keys of a map in a single markup file (and optionally structs to represent the values).
3. Generate an enum to represent the files of a directory (and optionally structs to represent the contents of those files).

The crate is mainly intended to be used in build.rs build scripts, but could also be used inside a proc-macro. (See the codegen module.)

To use this crate, make sure you enable at least one of the serde features to support the kinds of files you’re using:

1. json
2. toml
3. yaml

There are two sets of functions provided at the top level: the create_ functions which will write a Rust source file, and the generate_ functions which simply return Rust code as a string.

Examples

Generating structs

This example takes a single config file and generates a struct that is compatible with it:

let my_file_content = "
title = \"My TOML file\"

[my_table]
value = 10
";

let generated_code = generate_structs_from_source(
    my_file_content,
    "MyStruct",
    Format::Toml,
    &Options::minimal(),
).unwrap();

assert_eq!(generated_code, quote!(
    #[allow(non_camel_case_types)]
    pub struct MyStruct {
        pub title: std::borrow::Cow<'static, str>,
        pub my_table: MyStruct__my_table,
    }

    #[allow(non_camel_case_types)]
    pub struct MyStruct__my_table {
        pub value: i64,
    }
).to_string());

Generating enums

This example takes a single config file and generates an enum for the keys of the file, and structs for the values:

let my_file_content = "
    Key1:
        name: First key
    Key2:
        name: Second key
";

let generated_code = generate_enum_from_source(
    my_file_content,
    "MyEnum",
    Format::Yaml,
    &Options {
        enums: EnumOptions {
            values_struct: Some(ValuesStructOptions::minimal()),
            ..EnumOptions::minimal()
        },
        ..Options::minimal()
    },
).unwrap();

assert_eq!(generated_code, quote!(
    pub enum MyEnum {
        Key1,
        Key2,
    }

    #[allow(non_camel_case_types)]
    pub struct MyEnum__Value {
        pub name: std::borrow::Cow<'static, str>,
    }
).to_string());

Generating file enums

This example a directory full of JSON files and generates an enum variant for each file name, and a struct to represent the contents of them all.

/* Example JSON file:
{
    "name": "file1.json",
    "number": 1
}
*/

let generated_code = generate_enum_from_filenames(
    "./dir_full_of_json_files",
    "MyFileEnum",
    &Options {
        enums: EnumOptions {
            values_struct: Some(ValuesStructOptions::minimal()),
            ..EnumOptions::minimal()
        },
        ..Options::minimal()
    },
).unwrap();

assert_eq!(generated_code, quote!(
    pub enum MyFileEnum {
        File1,
        File2,
        File3,
    }

    #[allow(non_camel_case_types)]
    pub struct MyFileEnum__Value {
        pub name: std::borrow::Cow<'static, str>,
        pub number: i32,
    }
).to_string());

Modules

codegen

The purpose of this module is to convert generic Values to Rust structs and enums.

options

This module contains the structs for configuring the behaviour of the public APIs.

parsing

This module contains all of the utilities for parsing markup files.

value

Contains the Value type - a markup-agnostic generic value.

Structs

EnumOptions

Options specific to how edres should generate enums.

FilesOptions

Options specific to how edres should handle input files.

Options

Contains the full set of options for all public APIs in this crate.

OutputOptions

Options specific to how edres should handle its output.

ParseOptions

Options specific to how edres should parse markup.

StructOptions

Options specific to how edres should generate structs.

ValuesStructOptions

Options specific to how edres should generate structs for values associated with enum variants.

Enums

Error

An error type for errors while generating config struct modules.

FloatSize

Used to specify the default size of floating point values (providing they fit within the given size).

Format

Represents an input markup format for a config file.

IntSize

Used to specify the default size of integer values (providing they fit within the given size).

SerdeSupport

Options for serde support.

Functions

create_enum

Create a Rust source file that defines an enum based on the map keys of the given markup file.

create_enum_from_filenames

Create a Rust source file that defines an enum based on the file names within the given directory.

create_enum_from_source

Create a Rust source file that defines an enum based on the map keys of the given markup source.

create_structs

Create a Rust source file that defines a set of structs based on a given markup file.

create_structs_from_files

Create a Rust source file that defines a set of structs based on the contents of the files in the given directory.

create_structs_from_source

Create a Rust source file that defines a set of structs based on the given markup source.

generate_enum

Generate Rust code that defines an enum based on the map keys of the given markup file.

generate_enum_from_filenames

Generate Rust code that defines an enum based on the file names within the given directory.

generate_enum_from_source

Generate Rust code that defines an enum based on the map keys of the given markup source.

generate_structs

Generate Rust code that defines a set of structs based on a given markup file.

generate_structs_from_files

Generate Rust code that defines a set of structs based on the contents of the files in the given directory.

generate_structs_from_source

Generate Rust code that defines a set of structs based on the given markup source.