aam-rs 2.0.1

A Rust implementation of the Abstract Alias Mapping (AAM) framework for aliasing and maping aam files.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133

using System;
using System.Collections.Generic;
using System.IO;
using System.Text;

namespace AamCsharp;

public readonly struct SchemaField
{
    public string Name { get; }
    public string TypeName { get; }
    public bool Optional { get; }

    private SchemaField(string name, string typeName, bool optional)
    {
        Name = name;
        TypeName = typeName;
        Optional = optional;
    }

    public static SchemaField Required(string name, string typeName) => new(name, typeName, false);
    public static SchemaField OptionalField(string name, string typeName) => new(name, typeName, true);

    public string ToAam() => Optional ? $"{Name}*: {TypeName}" : $"{Name}: {TypeName}";
}

public sealed class AamBuilder
{
    private readonly StringBuilder _buffer;

    public AamBuilder() : this(0)
    {
    }

    public AamBuilder(int capacity)
    {
        _buffer = capacity > 0 ? new StringBuilder(capacity) : new StringBuilder();
    }

    public AamBuilder AddLine(string key, string value)
    {
        PushSeparator();
        _buffer.Append(key).Append(" = ").Append(value);
        return this;
    }

    public AamBuilder Comment(string text)
    {
        PushSeparator();
        _buffer.Append("# ").Append(text);
        return this;
    }

    public AamBuilder Schema(string name, IEnumerable<SchemaField> fields)
    {
        PushSeparator();
        _buffer.Append("@schema ").Append(name).Append(" { ");

        var first = true;
        foreach (var field in fields)
        {
            if (!first)
            {
                _buffer.Append(", ");
            }

            _buffer.Append(field.ToAam());
            first = false;
        }

        _buffer.Append(" }");
        return this;
    }

    public AamBuilder SchemaMultiline(string name, IEnumerable<SchemaField> fields)
    {
        PushSeparator();
        _buffer.Append("@schema ").Append(name).Append(" {");
        foreach (var field in fields)
        {
            _buffer.AppendLine();
            _buffer.Append("    ").Append(field.ToAam());
        }

        _buffer.AppendLine();
        _buffer.Append('}');
        return this;
    }

    public AamBuilder Derive(string path, IEnumerable<string> schemas)
    {
        PushSeparator();
        _buffer.Append("@derive ").Append(path);
        foreach (var schema in schemas)
        {
            _buffer.Append("::").Append(schema);
        }

        return this;
    }

    public AamBuilder Import(string path)
    {
        PushSeparator();
        _buffer.Append("@import ").Append(path);
        return this;
    }

    public AamBuilder TypeAlias(string alias, string typeName)
    {
        PushSeparator();
        _buffer.Append("@type ").Append(alias).Append(" = ").Append(typeName);
        return this;
    }

    public string Build() => _buffer.ToString();

    public void ToFile(string path)
    {
        File.WriteAllText(path, _buffer.ToString());
    }

    public override string ToString() => _buffer.ToString();

    private void PushSeparator()
    {
        if (_buffer.Length > 0)
        {
            _buffer.AppendLine();
        }
    }
}