Reinclude tools

Example.Shared/Example.Shared.csproj

@@ -7,10 +7,14 @@
     </PropertyGroup>
 
     <ItemGroup>
-        <ProjectReference Include="..\mROA.Cbor\mROA.Cbor.csproj"/>
+        <ProjectReference Include="..\mROA.Cbor\mROA.Cbor.csproj" />
         <ProjectReference Include="..\mROA\mROA.csproj"/>
         <ProjectReference Include="..\mROA.Codegen\mROA.Codegen.csproj" OutputItemType="Analyzer" ReferenceOutputAssembly="false"/>
 
     </ItemGroup>
 
+    <ItemGroup>
+      <PackageReference Include="mROA.Codegen" Version="2.0.5" />
+    </ItemGroup>
+
 </Project>

mROA.Codegen/Tools/DefineTemplateSection.cs

@@ -0,0 +1,30 @@
+namespace mROA.CodegenTools
+{
+    public class DefineTemplateSection : ITagged
+    {
+        public DefineTemplateSection(string storedText, string tag, TemplateDocument context)
+        {
+            StoredText = storedText;
+            Tag = tag;
+            Context = context;
+        }
+
+        public string StoredText { get; }
+        public TemplateDocument Context { get; set; }
+
+        public string Tag { get; }
+
+        public int TargetLength => StoredText.Length;
+
+        public object Clone()
+        {
+            return new DefineTemplateSection(StoredText, Tag, Context);
+        }
+
+
+        public override string ToString()
+        {
+            return StoredText;
+        }
+    }
+}

mROA.Codegen/Tools/ITemplateSection.cs

@@ -0,0 +1,20 @@
+using System;
+
+namespace mROA.CodegenTools
+{
+    public interface ITemplateSection : ICloneable
+    {
+        TemplateDocument Context { get; set; }
+        int TargetLength { get; }
+    }
+
+    public interface IBaking
+    {
+        string Bake();
+    }
+
+    public interface ITagged : ITemplateSection
+    {
+        string Tag { get; }
+    }
+}

mROA.Codegen/Tools/InnerTemplateSection.cs

@@ -0,0 +1,24 @@
+namespace mROA.CodegenTools
+{
+    public class InnerTemplateSection : ITemplateSection, ITagged
+    {
+        public InnerTemplateSection(string tag, TemplateDocument innerTemplate, TemplateDocument context)
+        {
+            Tag = tag;
+            Context = context;
+            InnerTemplate = innerTemplate;
+        }
+
+        public TemplateDocument InnerTemplate { get; }
+
+        public string Tag { get; }
+
+        public TemplateDocument Context { get; set; }
+        public int TargetLength => 0;
+
+        public object Clone()
+        {
+            return new InnerTemplateSection(Tag, InnerTemplate, Context);
+        }
+    }
+}

mROA.Codegen/Tools/InsertTemplateSection.cs

@@ -0,0 +1,86 @@
+using System.Collections.Generic;
+using System.Linq;
+
+namespace mROA.CodegenTools
+{
+    public class InsertTemplateSection : ITagged, IBaking
+    {
+        public readonly List<string> Parameters;
+        private object _insertedValue;
+
+        public InsertTemplateSection(string tag, TemplateDocument context, params string[] parameters)
+        {
+            Tag = tag;
+            Parameters = parameters.ToList();
+            Context = context;
+        }
+
+        public string Bake()
+        {
+            switch (_insertedValue)
+            {
+                case null:
+                    return string.Empty;
+                case string s:
+                    return s;
+                default:
+                    return ((ITemplateSection)_insertedValue).ToString();
+            }
+        }
+
+        public string Tag { get; private set; }
+
+        public TemplateDocument Context { get; set; }
+
+
+        public int TargetLength => 0;
+
+        public object Clone()
+        {
+            return new InsertTemplateSection(Tag, Context, Parameters.ToArray());
+        }
+
+        private bool IsInserted(object value)
+        {
+            if (Parameters.IndexOf("r") == -1) return false;
+
+            ProduceInserted(value);
+
+            return true;
+        }
+
+        private void ProduceInserted(object value)
+        {
+            var currentIndex = Context.Parts.IndexOf(this);
+            var clone = (InsertTemplateSection)MemberwiseClone();
+            clone.Tag += "+";
+
+            clone._insertedValue = value;
+
+            Context.Parts.Insert(currentIndex, clone);
+
+            InsertSeparator(currentIndex + 1);
+        }
+
+        private void InsertSeparator(int currentIndex)
+        {
+            var sepIndex = Parameters.IndexOf("sep");
+            if (sepIndex == -1)
+                return;
+
+            Context.Parts.Insert(currentIndex,
+                new LiteralTemplateSection(Context[Parameters[sepIndex + 1]].ToString(), Context));
+        }
+
+
+        public void Setup(object value)
+        {
+            if (!(value is string) && !(value is ITemplateSection))
+                return;
+            if (IsInserted(value))
+                return;
+
+            _insertedValue = value;
+        }
+    }
+}

mROA.Codegen/Tools/LinkTemplateSection.cs

@@ -0,0 +1,39 @@
+namespace mROA.CodegenTools
+{
+    public class LinkTemplateSection : ITemplateSection, IBaking
+    {
+        public LinkTemplateSection(string linkedTag, TemplateDocument context)
+        {
+            LinkedTag = linkedTag;
+            Context = context;
+        }
+
+        public string LinkedTag { get; }
+
+        public string Bake()
+        {
+            return Context[LinkedTag]?.ToString();
+        }
+
+        public TemplateDocument Context { get; set; }
+
+        public int TargetLength
+        {
+            get
+            {
+                var attached = Context[LinkedTag];
+                return attached?.TargetLength ?? 0;
+            }
+        }
+
+        public object Clone()
+        {
+            return new LinkTemplateSection(LinkedTag, Context);
+        }
+
+        public override string ToString()
+        {
+            return $"{nameof(LinkedTag)}: {LinkedTag}";
+        }
+    }
+}

mROA.Codegen/Tools/LiteralTemplateSection.cs

@@ -0,0 +1,31 @@
+namespace mROA.CodegenTools
+{
+    public class LiteralTemplateSection : ITemplateSection, IBaking
+    {
+        private readonly string _internalText;
+
+        public LiteralTemplateSection(string internalText, TemplateDocument context)
+        {
+            _internalText = internalText;
+            Context = context;
+        }
+
+        public string Bake()
+        {
+            return ToString();
+        }
+
+        public TemplateDocument Context { get; set; }
+        public int TargetLength => _internalText.Length;
+
+        public object Clone()
+        {
+            return new LiteralTemplateSection(_internalText, Context);
+        }
+
+        public override string ToString()
+        {
+            return _internalText;
+        }
+    }
+}

mROA.Codegen/Tools/ProgrammableTextSection.cs

@@ -0,0 +1,29 @@
+using System;
+
+namespace mROA.CodegenTools
+{
+    public class ProgrammableTextSection : ITemplateSection, IBaking
+    {
+        private readonly Func<object, string> _bakeFunc;
+
+        public ProgrammableTextSection(Func<object, string> bakeFunc, TemplateDocument context)
+        {
+            _bakeFunc = bakeFunc;
+            Context = context;
+        }
+
+
+        public string Bake()
+        {
+            return _bakeFunc(Context.AdditionalContext);
+        }
+
+        public TemplateDocument Context { get; set; }
+        public int TargetLength => 0;
+
+        public object Clone()
+        {
+            return new ProgrammableTextSection(_bakeFunc, Context);
+        }
+    }
+}

mROA.Codegen/Tools/Reading/DefineSectionReader.cs

@@ -0,0 +1,24 @@
+using System;
+
+namespace mROA.CodegenTools.Reading
+{
+    public class DefineSectionReader : LeadingTextSectionReader
+    {
+        public DefineSectionReader() : base("<!D")
+        {
+        }
+
+        public override ITemplateSection ExtractSection(ref int index, TemplateDocument document)
+        {
+            var tagEnd = TemplateText.IndexOf(">", index, StringComparison.Ordinal);
+            var sectionName = GetTagValue(index, tagEnd);
+            tagEnd += 1;
+            var endIndex = TemplateText.IndexOf("<!D>", tagEnd, StringComparison.Ordinal);
+            var storedText = TemplateText.Substring(tagEnd, endIndex - tagEnd);
+            index = endIndex + 4;
+            PassCaretToCloseSymbol();
+            PassCaretToCloseSymbol();
+            return new DefineTemplateSection(storedText, sectionName, document);
+        }
+    }
+}

mROA.Codegen/Tools/Reading/ISectionReader.cs

@@ -0,0 +1,9 @@
+namespace mROA.CodegenTools.Reading
+{
+    public interface ISectionReader
+    {
+        string TemplateText { get; set; }
+        int GetNextSectionIndex(int currentIndex);
+        ITemplateSection ExtractSection(ref int index, TemplateDocument document);
+    }
+}

mROA.Codegen/Tools/Reading/InnerTemplateSectionReader.cs

@@ -0,0 +1,39 @@
+using System;
+
+namespace mROA.CodegenTools.Reading
+{
+    public class InnerTemplateSectionReader : LeadingTextSectionReader
+    {
+        public InnerTemplateSectionReader()
+            : base("<!T")
+        {
+        }
+
+
+        public override ITemplateSection ExtractSection(ref int index, TemplateDocument document)
+        {
+            var end = FindEnd(index + 4);
+            var from = index;
+            index = PassCaretToCloseSymbol();
+            var to = index - 1;
+
+            var tagName = GetTagValue(from, to);
+
+            var innerDocText = TemplateText.Substring(index, end - index);
+            var innerDoc = TemplateReader.Parse(innerDocText);
+            _currentCaretPosition = end + 4;
+            index = _currentCaretPosition;
+            return new InnerTemplateSection(tagName, innerDoc, document);
+        }
+
+        private int FindEnd(int start)
+        {
+            var endSymbol = TemplateText.IndexOf("<!T>", start, StringComparison.Ordinal);
+            var innerStartSymbol = TemplateText.IndexOf("<!T ", start, StringComparison.Ordinal);
+            if (endSymbol < innerStartSymbol || innerStartSymbol == -1)
+                return endSymbol;
+
+            return FindEnd(endSymbol + 4);
+        }
+    }
+}

mROA.Codegen/Tools/Reading/InsertSectionReader.cs

@@ -0,0 +1,24 @@
+using System.Linq;
+
+namespace mROA.CodegenTools.Reading
+{
+    public class InsertSectionReader : LeadingTextSectionReader
+    {
+        public InsertSectionReader() : base("<!I")
+        {
+        }
+
+
+        public override ITemplateSection ExtractSection(ref int index, TemplateDocument document)
+        {
+            var from = index;
+            index = PassCaretToCloseSymbol();
+            var to = index - 1;
+
+            var tagText = GetTagValue(from, to);
+            var parts = tagText.Split(' ');
+
+            return new InsertTemplateSection(parts[0], document, parts.Skip(1).ToArray());
+        }
+    }
+}

mROA.Codegen/Tools/Reading/LeadingTextSectionReader.cs

@@ -0,0 +1,40 @@
+using System;
+
+namespace mROA.CodegenTools.Reading
+{
+    public abstract class LeadingTextSectionReader : ISectionReader
+    {
+        private readonly string _tagLeading;
+        protected int _currentCaretPosition;
+
+        protected LeadingTextSectionReader(string tagLeading)
+        {
+            _tagLeading = tagLeading + " ";
+        }
+
+        public string TemplateText { get; set; }
+
+        public int GetNextSectionIndex(int currentIndex)
+        {
+            _currentCaretPosition = Math.Max(currentIndex, _currentCaretPosition);
+            var index = TemplateText.IndexOf(_tagLeading, _currentCaretPosition, StringComparison.Ordinal);
+            _currentCaretPosition = index;
+            return index;
+        }
+
+        public abstract ITemplateSection ExtractSection(ref int index, TemplateDocument document);
+
+        protected int PassCaretToCloseSymbol()
+        {
+            _currentCaretPosition = TemplateText.IndexOf(">", _currentCaretPosition, StringComparison.Ordinal) + 1;
+            return _currentCaretPosition;
+        }
+
+        protected string GetTagValue(int from, int to)
+        {
+            var realStart = from + 4;
+            var span = TemplateText.Substring(realStart, to - realStart);
+            return span;
+        }
+    }
+}

mROA.Codegen/Tools/Reading/LinkSectionReader.cs

@@ -0,0 +1,20 @@
+namespace mROA.CodegenTools.Reading
+{
+    public class LinkSectionReader : LeadingTextSectionReader
+    {
+        public LinkSectionReader() : base("<!L")
+        {
+        }
+
+
+        public override ITemplateSection ExtractSection(ref int index, TemplateDocument document)
+        {
+            var from = index;
+            index = PassCaretToCloseSymbol();
+            var to = index - 1;
+
+            var tagText = GetTagValue(from, to);
+            return new LinkTemplateSection(tagText, document);
+        }
+    }
+}

mROA.Codegen/Tools/Reading/TemplateReader.cs

@@ -0,0 +1,82 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Reflection;
+
+namespace mROA.CodegenTools.Reading
+{
+    public static class TemplateReader
+    {
+        private static readonly List<Type> ReaderTypes = new()
+        {
+            typeof(DefineSectionReader),
+            typeof(InsertSectionReader),
+            typeof(LinkSectionReader),
+            typeof(InnerTemplateSectionReader)
+        };
+
+        public static TemplateDocument Parse(string templateText)
+        {
+            var currentIndex = 0;
+            var activeReaders = new List<ISectionReader>();
+
+            foreach (var readerType in ReaderTypes)
+            {
+                var reader = Activator.CreateInstance(readerType) as ISectionReader;
+                reader.TemplateText = templateText;
+                activeReaders.Add(reader);
+            }
+
+            var doc = new TemplateDocument();
+
+            while (currentIndex < templateText.Length)
+            {
+                List<(ISectionReader reader, int index)> indices = activeReaders
+                    .Select(i => ((ISectionReader Readers, int index))(i, i.GetNextSectionIndex(currentIndex)))
+                    .Where(i => i.index > -1).ToList();
+                var minIndex = templateText.Length;
+                ISectionReader minReader = null;
+                if (indices.Count != 0)
+                {
+                    minIndex = indices.Min(i => i.index);
+                    minReader = indices.FirstOrDefault(i => i.index == minIndex).reader;
+
+                    if (indices.Count != activeReaders.Count) activeReaders = indices.Select(i => i.reader).ToList();
+                }
+
+
+                if (currentIndex != minIndex)
+                {
+                    var literalText = templateText.Substring(currentIndex, minIndex - currentIndex);
+                    var literal =
+                        new LiteralTemplateSection(literalText, doc);
+                    doc.Parts.Add(literal);
+                    currentIndex = minIndex;
+                }
+
+                if (indices.Count != 0)
+                {
+                    var section = minReader.ExtractSection(ref currentIndex, doc);
+                    doc.Parts.Add(section);
+                }
+            }
+
+            return doc;
+        }
+
+        public static TemplateDocument FromEmbeddedResource(string resourceName)
+        {
+            return FromEmbeddedResource(resourceName, Assembly.GetCallingAssembly());
+        }
+
+        public static TemplateDocument FromEmbeddedResource(string resourceName, Assembly assembly)
+        {
+            var fileName = assembly.GetManifestResourceNames().First(n => n.EndsWith(resourceName));
+            var res = assembly.GetManifestResourceStream(fileName);
+            var reader = new StreamReader(res);
+            var templateText = reader.ReadToEnd();
+            return Parse(templateText);
+        }
+    }
+}

mROA.Codegen/Tools/TemplateDocument.cs

@@ -0,0 +1,61 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace mROA.CodegenTools
+{
+    public class TemplateDocument : ICloneable
+    {
+        public List<ITemplateSection> Parts { get; set; } = new();
+        public object AdditionalContext { get; set; }
+        public ITagged? this[string tag] => Parts.OfType<ITagged>().FirstOrDefault(i => i.Tag == tag);
+
+        public object Clone()
+        {
+            var cloneDoc = new TemplateDocument
+            {
+                AdditionalContext = AdditionalContext is ICloneable c ? c.Clone() : AdditionalContext
+            };
+
+            cloneDoc.Parts = Parts.Select(i =>
+            {
+                var clone = i.Clone() as ITemplateSection;
+                clone.Context = cloneDoc;
+                return clone;
+            }).ToList();
+
+            return cloneDoc;
+        }
+
+        public void Insert(string tag, object value)
+        {
+            var selectedPart = this[tag];
+            if (selectedPart is InsertTemplateSection itp) itp.Setup(value);
+        }
+
+        public string Compile()
+        {
+            var approximatelyLength = Parts.Sum(i => i.TargetLength);
+            var stringBuilder = new StringBuilder(approximatelyLength);
+
+            foreach (var part in Parts.OfType<IBaking>())
+            {
+                var baked = part.Bake();
+                stringBuilder.Append(baked);
+            }
+
+            return stringBuilder.ToString();
+        }
+
+        public void AddDefine(string tag, string text)
+        {
+            Parts.Add(new DefineTemplateSection(text, tag, this));
+        }
+
+        public void AddDefine(string tag, object value)
+        {
+            AddDefine(tag, value.ToString());
+        }
+    }
+}

mROA.Codegen/mROA.Codegen.csproj

@@ -26,7 +26,6 @@
             <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
         </PackageReference>
         <PackageReference Include="Microsoft.CodeAnalysis.CSharp" Version="4.3.0" />
-        <PackageReference Include="mROA.CodegenTools" Version="1.0.0" GeneratePathProperty="true" PrivateAssets="all"/>
     </ItemGroup>
 
     <ItemGroup>