chore: initial git load of code space
This commit is contained in:
Thom Lamb
@@ -0,0 +1,398 @@
|
||||
using System.Text.RegularExpressions;
|
||||
|
||||
namespace Strata.SqlTools.Rules.Rule.Expression;
|
||||
|
||||
/// <summary>
|
||||
/// Parses markdown/LaTeX mathematical expressions and converts them to Expression objects.
|
||||
/// Supports parsing of logical operations, comparisons, properties, and literals.
|
||||
/// </summary>
|
||||
public static class Markdown
|
||||
{
|
||||
private static readonly Dictionary<string, Func<Expression, Expression, BoolExpr>> LogicalOperators = new()
|
||||
{
|
||||
{ "\\land", (left, right) => new And((BoolExpr)left, (BoolExpr)right) },
|
||||
{ "\\lor", (left, right) => new Or((BoolExpr)left, (BoolExpr)right) },
|
||||
{ "\\wedge", (left, right) => new And((BoolExpr)left, (BoolExpr)right) },
|
||||
{ "\\vee", (left, right) => new Or((BoolExpr)left, (BoolExpr)right) },
|
||||
{ "AND", (left, right) => new And((BoolExpr)left, (BoolExpr)right) },
|
||||
{ "OR", (left, right) => new Or((BoolExpr)left, (BoolExpr)right) },
|
||||
};
|
||||
|
||||
private static readonly Dictionary<string, Func<Expression, Expression, Comparison>> ComparisonOperators = new()
|
||||
{
|
||||
{ "=", (left, right) => new Equal(left, right) },
|
||||
{ "\\neq", (left, right) => new NotEqual(left, right) },
|
||||
{ "!=", (left, right) => new NotEqual(left, right) },
|
||||
{ ">", (left, right) => new GreaterThan(left, right) },
|
||||
{ "\\gt", (left, right) => new GreaterThan(left, right) },
|
||||
};
|
||||
|
||||
/// <summary>
|
||||
/// Parses a markdown/LaTeX string into an Expression object.
|
||||
/// </summary>
|
||||
/// <param name="markdown">The markdown/LaTeX string to parse.</param>
|
||||
/// <returns>The parsed Expression object.</returns>
|
||||
/// <exception cref="ArgumentException">Thrown when the markdown cannot be parsed.</exception>
|
||||
public static Expression Parse(string markdown)
|
||||
{
|
||||
if (string.IsNullOrWhiteSpace(markdown))
|
||||
{
|
||||
throw new ArgumentException("Markdown cannot be null or empty", nameof(markdown));
|
||||
}
|
||||
|
||||
// Remove common markdown delimiters
|
||||
markdown = markdown.Trim();
|
||||
markdown = StripMarkdownDelimiters(markdown);
|
||||
|
||||
return ParseExpression(markdown);
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Attempts to parse a markdown/LaTeX string into an Expression object.
|
||||
/// </summary>
|
||||
/// <param name="markdown">The markdown/LaTeX string to parse.</param>
|
||||
/// <param name="expression">The parsed Expression object if successful.</param>
|
||||
/// <returns>True if parsing was successful, false otherwise.</returns>
|
||||
public static bool TryParse(string markdown, out Expression? expression)
|
||||
{
|
||||
try
|
||||
{
|
||||
expression = Parse(markdown);
|
||||
return true;
|
||||
}
|
||||
catch
|
||||
{
|
||||
expression = null;
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
private static string StripMarkdownDelimiters(string text)
|
||||
{
|
||||
// Remove $...$ or $$...$$ delimiters
|
||||
text = Regex.Replace(text, @"^\$\$?\s*", "");
|
||||
text = Regex.Replace(text, @"\s*\$\$?$", "");
|
||||
|
||||
// Remove ```math...``` code fence
|
||||
text = Regex.Replace(text, @"^```math\s*", "", RegexOptions.Multiline);
|
||||
text = Regex.Replace(text, @"\s*```$", "", RegexOptions.Multiline);
|
||||
|
||||
return text.Trim();
|
||||
}
|
||||
|
||||
private static Expression ParseExpression(string text)
|
||||
{
|
||||
text = text.Trim();
|
||||
|
||||
// Try to parse logical operations (lowest precedence)
|
||||
var logicalExpr = TryParseLogicalOperation(text);
|
||||
if (logicalExpr is not null)
|
||||
{
|
||||
return logicalExpr;
|
||||
}
|
||||
|
||||
// Try to parse comparison operations
|
||||
var comparisonExpr = TryParseComparison(text);
|
||||
if (comparisonExpr is not null)
|
||||
{
|
||||
return comparisonExpr;
|
||||
}
|
||||
|
||||
// Handle parentheses
|
||||
var parenthesisExpr = TryParseParentheses(text);
|
||||
if (parenthesisExpr is not null)
|
||||
{
|
||||
return parenthesisExpr;
|
||||
}
|
||||
|
||||
// Parse property, literal, or other atomic expressions
|
||||
return ParseAtomicExpression(text);
|
||||
}
|
||||
|
||||
private static Expression? TryParseLogicalOperation(string text)
|
||||
{
|
||||
foreach (var op in LogicalOperators.Keys)
|
||||
{
|
||||
var parts = SplitByOperator(text, op);
|
||||
if (parts.Length == 2)
|
||||
{
|
||||
var left = ParseExpression(parts[0]);
|
||||
var right = ParseExpression(parts[1]);
|
||||
return LogicalOperators[op](left, right);
|
||||
}
|
||||
}
|
||||
return null;
|
||||
}
|
||||
|
||||
private static Expression? TryParseComparison(string text)
|
||||
{
|
||||
foreach (var op in ComparisonOperators.Keys)
|
||||
{
|
||||
var parts = SplitByOperator(text, op);
|
||||
if (parts.Length == 2)
|
||||
{
|
||||
var left = ParseExpression(parts[0]);
|
||||
var right = ParseExpression(parts[1]);
|
||||
return ComparisonOperators[op](left, right);
|
||||
}
|
||||
}
|
||||
return null;
|
||||
}
|
||||
|
||||
private static Expression? TryParseParentheses(string text)
|
||||
{
|
||||
// Handle regular parentheses
|
||||
if (text.StartsWith('(') && text.EndsWith(')'))
|
||||
{
|
||||
var inner = text.Substring(1, text.Length - 2);
|
||||
if (IsBalanced(inner))
|
||||
{
|
||||
return ParseExpression(inner);
|
||||
}
|
||||
}
|
||||
|
||||
// Handle LaTeX \left( and \right)
|
||||
if (text.StartsWith("\\left(") && text.EndsWith("\\right)"))
|
||||
{
|
||||
var inner = text.Substring(6, text.Length - 13);
|
||||
if (IsBalanced(inner))
|
||||
{
|
||||
return ParseExpression(inner);
|
||||
}
|
||||
}
|
||||
|
||||
return null;
|
||||
}
|
||||
|
||||
private static Expression ParseAtomicExpression(string text)
|
||||
{
|
||||
// Try parsing as property access
|
||||
var propertyExpr = TryParseProperty(text);
|
||||
if (propertyExpr is not null)
|
||||
{
|
||||
return propertyExpr;
|
||||
}
|
||||
|
||||
// Try parsing as literal
|
||||
var literalExpr = TryParseLiteral(text);
|
||||
if (literalExpr is not null)
|
||||
{
|
||||
return literalExpr;
|
||||
}
|
||||
|
||||
throw new ArgumentException($"Unable to parse expression: {text}");
|
||||
}
|
||||
|
||||
private static Expression? TryParseProperty(string text)
|
||||
{
|
||||
// Parse property access (e.g., x.PropertyName or \text{x.PropertyName})
|
||||
var propertyMatch = Regex.Match(text, @"^([a-zA-Z_][a-zA-Z0-9_]*)\.([a-zA-Z_][a-zA-Z0-9_]*)$");
|
||||
if (propertyMatch.Success)
|
||||
{
|
||||
return new Property(propertyMatch.Groups[1].Value, propertyMatch.Groups[2].Value);
|
||||
}
|
||||
|
||||
// Parse \text{...} property access
|
||||
var textMatch = Regex.Match(text, @"^\\text\{([^}]+)\}$");
|
||||
if (textMatch.Success)
|
||||
{
|
||||
var textContent = textMatch.Groups[1].Value;
|
||||
var propMatch = Regex.Match(textContent, @"^([a-zA-Z_][a-zA-Z0-9_]*)\.([a-zA-Z_][a-zA-Z0-9_]*)$");
|
||||
if (propMatch.Success)
|
||||
{
|
||||
return new Property(propMatch.Groups[1].Value, propMatch.Groups[2].Value);
|
||||
}
|
||||
|
||||
// Check for boolean literals in \text{} format
|
||||
if (textContent.Equals("true", StringComparison.OrdinalIgnoreCase))
|
||||
{
|
||||
return new Literal(true);
|
||||
}
|
||||
|
||||
if (textContent.Equals("false", StringComparison.OrdinalIgnoreCase))
|
||||
{
|
||||
return new Literal(false);
|
||||
}
|
||||
|
||||
// Single property name
|
||||
if (Regex.IsMatch(textContent, @"^[a-zA-Z_][a-zA-Z0-9_]*$"))
|
||||
{
|
||||
return new Property(textContent);
|
||||
}
|
||||
|
||||
// String literal
|
||||
return new StringLiteral(textContent);
|
||||
}
|
||||
|
||||
// Check for boolean literals before simple property
|
||||
if (text.Equals("true", StringComparison.OrdinalIgnoreCase))
|
||||
{
|
||||
return new Literal(true);
|
||||
}
|
||||
|
||||
if (text.Equals("false", StringComparison.OrdinalIgnoreCase))
|
||||
{
|
||||
return new Literal(false);
|
||||
}
|
||||
|
||||
// Parse simple property without parameter
|
||||
if (Regex.IsMatch(text, @"^[a-zA-Z_][a-zA-Z0-9_]*$"))
|
||||
{
|
||||
return new Property(text);
|
||||
}
|
||||
|
||||
return null;
|
||||
}
|
||||
|
||||
private static Expression? TryParseLiteral(string text)
|
||||
{
|
||||
// Parse string literals (quoted)
|
||||
var stringMatch = Regex.Match(text, @"^[""'](.+?)[""']$");
|
||||
if (stringMatch.Success)
|
||||
{
|
||||
return new StringLiteral(stringMatch.Groups[1].Value);
|
||||
}
|
||||
|
||||
// Parse empty string literals
|
||||
if (text == "\"\"" || text == "''")
|
||||
{
|
||||
return new StringLiteral(string.Empty);
|
||||
}
|
||||
|
||||
// Parse numeric literals
|
||||
if (int.TryParse(text, out var intValue))
|
||||
{
|
||||
return new NumberLiteral(intValue);
|
||||
}
|
||||
|
||||
if (decimal.TryParse(text, out var decimalValue))
|
||||
{
|
||||
return new NumberLiteral(decimalValue);
|
||||
}
|
||||
|
||||
return null;
|
||||
}
|
||||
|
||||
private static string[] SplitByOperator(string text, string op)
|
||||
{
|
||||
var result = new List<string>();
|
||||
int depth = 0;
|
||||
int lastIndex = 0;
|
||||
int i = 0;
|
||||
|
||||
while (i < text.Length)
|
||||
{
|
||||
i = ProcessParentheses(text, i, ref depth);
|
||||
if (i >= text.Length)
|
||||
{
|
||||
break;
|
||||
}
|
||||
|
||||
// Check if we found the operator at depth 0
|
||||
if (depth == 0 && i + op.Length <= text.Length && TryMatchOperator(text, i, op))
|
||||
{
|
||||
result.Add(text.Substring(lastIndex, i - lastIndex).Trim());
|
||||
lastIndex = i + op.Length;
|
||||
i += op.Length;
|
||||
continue;
|
||||
}
|
||||
|
||||
i++;
|
||||
}
|
||||
|
||||
if (result.Count == 0)
|
||||
{
|
||||
return new[] { text };
|
||||
}
|
||||
|
||||
result.Add(text.Substring(lastIndex).Trim());
|
||||
return result.ToArray();
|
||||
}
|
||||
|
||||
private static int ProcessParentheses(string text, int index, ref int depth)
|
||||
{
|
||||
// Track parentheses depth
|
||||
if (text[index] == '(' || (index + 5 < text.Length && text.Substring(index, 6) == "\\left("))
|
||||
{
|
||||
depth++;
|
||||
if (text[index] == '\\')
|
||||
{
|
||||
return index + 6;
|
||||
}
|
||||
else
|
||||
{
|
||||
return index + 1;
|
||||
}
|
||||
}
|
||||
|
||||
if (text[index] == ')' || (index + 6 < text.Length && text.Substring(index, 7) == "\\right)"))
|
||||
{
|
||||
depth--;
|
||||
if (text[index] == '\\')
|
||||
{
|
||||
return index + 7;
|
||||
}
|
||||
else
|
||||
{
|
||||
return index + 1;
|
||||
}
|
||||
}
|
||||
|
||||
return index;
|
||||
}
|
||||
|
||||
private static bool TryMatchOperator(string text, int index, string op)
|
||||
{
|
||||
var substring = text.Substring(index, op.Length);
|
||||
if (substring != op)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
|
||||
// Make sure it's a separate operator, not part of a larger token
|
||||
bool validBefore = (index == 0 || char.IsWhiteSpace(text[index - 1]) || text[index] == '\\');
|
||||
bool validAfter = (index + op.Length >= text.Length || char.IsWhiteSpace(text[index + op.Length]));
|
||||
|
||||
return validBefore && validAfter;
|
||||
}
|
||||
|
||||
private static bool IsBalanced(string text)
|
||||
{
|
||||
int depth = 0;
|
||||
int i = 0;
|
||||
|
||||
while (i < text.Length)
|
||||
{
|
||||
if (text[i] == '(')
|
||||
{
|
||||
depth++;
|
||||
}
|
||||
else if (text[i] == ')')
|
||||
{
|
||||
depth--;
|
||||
if (depth < 0)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
}
|
||||
else if (i + 5 < text.Length && text.Substring(i, 6) == "\\left(")
|
||||
{
|
||||
depth++;
|
||||
i += 5;
|
||||
}
|
||||
else if (i + 6 < text.Length && text.Substring(i, 7) == "\\right)")
|
||||
{
|
||||
depth--;
|
||||
if (depth < 0)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
i += 6;
|
||||
}
|
||||
|
||||
i++;
|
||||
}
|
||||
|
||||
return depth == 0;
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user