SimpleParser 1.0.0-VER-01.58

SimpleParser

This project solves serveral problems

• Parse expression to ast tree and the possibilty of calculating the result
• Parse conditions 5+3 = 8 & 2*3 = 6
  • support =, !=, >, <, >=, ⇐, &, |
• Use external variables in an expression
• Use external functions in an expression
• Parse view template $"string length = {{2+2}}", result is "string length = 4"
• Serialize ast tree to json
• Parse type as Guid, DateTime with timezone, Time span (05:30)
• Types support, string, number, boolean, datetime, timespan, guid
• Add support Array, Object, get item of array by index
• Add IdentTabe, external variable holder
• Add trinary operation 3+1 = 2*2 ? "OK" : "ERR"
• Get value by index from identifier of any types
• You can use functions with the same name and a different number of parameters
• Add (if, each) statement for template string, see example
• Add filter statement for template string, see example
• Add AstAnalyzer, get info from ast tree, return (functions, constants, identifiers)
• Parse time as 1d + 21h + 30m + 10s = '1.21:30:10'
• Add internal function get each index ⇒ index(this.p), see example
• Breaking changes, the expression in the template is wrapped in two brackets "result is {{2+3}}"
• Support cyrillic name variables
• Add support type Sha256

How to use (Example)

internal static class InternalFuncs
{
    [FuncName("len")]
    public static ComputedResult Len(IFuncExecuteContext context, string str)
    {
        return new ComputedResult(str?.Length ?? default);
    }

    [FuncName("distination")]
    public static ComputedResult CalculateDistination(IFuncExecuteContext context, double x1, double y1, double x2, double y2)
    {
        var result = CalculateDistinationInternal(x1, y1, x2, y2);

        return new ComputedResult(result);
    }

    [FuncName("distination")]
    public static ComputedResult CalculateDistination(IFuncExecuteContext context, ComputedResult point1, ComputedResult point2)
    {
        var p1 = point1.Value;
        var p2 = point2.Value;

        var result = CalculateDistinationInternal(
            p1.GetProperty("x"),
            p1.GetProperty("y"),
            p2.GetProperty("x"),
            p2.GetProperty("y"));

        return new ComputedResult(result);
    }

    private static double CalculateDistinationInternal(double x1, double y1, double x2, double y2)
    {
        var a = Math.Pow(x2 - x1, 2);
        var b = Math.Pow(y2 - y1, 2);
            
        return Math.Sqrt(a + b);
    }
}

var identifier = new Dictionary<string, object>
{
    [x] = 5,
    [str] = "hello",
    ["point1"] = new Dictionary<string, object>
    {
        ["x"] = x1,
        ["y"] = y1,
    },
    ["point2"] = new Dictionary<string, object>
    {
        ["x"] = x2,
        ["y"] = y2,
    }
};

var funcTable = FuncTable.Create(typeof(InternalFuncs));
var identTable = IdentTable.Create(identifier);

var tree = LineParser.Parse("len(str)+x*2");

var result = AstCalculator.Calculate(tree, identTable, funcTable);

Assert.True(result.IsNumber());
Assert.Equal(15, result.ToNumber());

var treeCondition = LineParser.Parse("len(str) = 5");
result = AstCalculator.Calculate(treeCondition, identTable, funcTable);

Assert.True(result.IsBoolean());
Assert.True(result.ToBoolean());

tree = LineParser.Parse("distination(point1, point2)");
result = AstCalculator.Calculate(tree, identTabe, funcTable);
Assert.True(result.IsNumber());

tree = LineParser.Parse("distination(1, 2, 3, 4)");
result = AstCalculator.Calculate(tree, identTabe, funcTable);
Assert.True(result.IsNumber());

Type operations

Template string example

var departaments = new JsonArray
{
    new JsonObject
    {
        ["id"] = 12,
        ["name"] = "Cosmos"
    },
    new JsonObject
    {
        ["id"] = 4,
        ["name"] = "Buki"
    },
    new JsonObject
    {
        ["id"] = 9,
        ["name"] = "Durion"
    }
};

var persons = new JsonArray
{
    new JsonObject
    {
        ["id"] = 1,
        ["firstName"] = "Smith",
        ["lastName"] = "Ford",
        ["depCode"] = 12
    },
    new JsonObject
    {
        ["id"] = 2,
        ["firstName"] = "Ivan",
        ["lastName"] = "Petrov",
        ["depCode"] = 4
    },
    new JsonObject
    {
        ["id"] = 3,
        ["firstName"] = "Tim",
        ["lastName"] = "Cook",
        ["depCode"] = 9
    },
};

var source = @"$""Start
{#each deps dep filter this.dep.id>1 } 
    {index(this.dep)} Department: { this.dep.name}
    {#each persons p}
        {#if this.p.depCode=this.dep.id}
            {index(this.p)} Invite {this.p.id} with name: {this.p.firstName}
        {#else}
            {index(this.p)} go home: {this.p.lastName}
        {/if}
    {/each}
{/each}End""";

var tree = LineParser.Parse(source);

var identTable = IdentTable.Create(new JsonObject
{
    ["persons"] = persons,
    ["deps"] = departaments
});

var result = AstCalculator.Calculate(tree, identTable);

Console.WriteLine(result.ToString());