Refactor namespace

Stillpoint-Software · Jun 12, 2024 · 147345b · 147345b
1 parent cc46d7e
commit 147345b
Show file tree

Hide file tree

Showing 46 changed files with 349 additions and 263 deletions.
diff --git a/...rser/Element/JsonElementTypeDescriptor.cs → ...criptors/Element/ElementTypeDescriptor.cs b/...rser/Element/JsonElementTypeDescriptor.cs → ...criptors/Element/ElementTypeDescriptor.cs
@@ -1,19 +1,30 @@
-namespace Hyperbee.Json.Evaluators.Parser.Element;
+using System.Text.Json;
+using Hyperbee.Json.Descriptors.Element.Functions;
+using Hyperbee.Json.Filters;
+using Hyperbee.Json.Filters.Parser;
 
-public class JsonElementTypeDescriptor : IJsonTypeDescriptor
+namespace Hyperbee.Json.Descriptors.Element;
+
+public class ElementTypeDescriptor : ITypeDescriptor<JsonElement>
 {
+    private FilterEvaluator<JsonElement> _evaluator;
+    private ElementValueAccessor _accessor;
     public Dictionary<string, FunctionCreator> Functions { get; init; }
 
-    public IJsonValueAccessor<TElement> GetAccessor<TElement>() =>
-        new JsonElementValueAccessor() as IJsonValueAccessor<TElement>;
+    public IValueAccessor<JsonElement> Accessor
+    {
+        get => _accessor ??= new ElementValueAccessor();
+    }
 
-    public IJsonPathFilterEvaluator<TElement> GetFilterEvaluator<TElement>() =>
-        new JsonPathFilterEvaluator<TElement>( this );
+    public IFilterEvaluator<JsonElement> FilterEvaluator
+    {
+        get => _evaluator ??= new FilterEvaluator<JsonElement>( this );
+    }
 
     public FilterFunction GetFilterFunction( ParseExpressionContext context ) =>
         new FilterElementFunction( context );
 
-    public JsonElementTypeDescriptor()
+    public ElementTypeDescriptor()
     {
         Functions = new Dictionary<string, FunctionCreator>(
         [

diff --git a/...arser/Element/JsonElementValueAccessor.cs → ...scriptors/Element/ElementValueAccessor.cs b/...arser/Element/JsonElementValueAccessor.cs → ...scriptors/Element/ElementValueAccessor.cs
@@ -1,10 +1,11 @@
 using System.Globalization;
 using System.Runtime.CompilerServices;
 using System.Text.Json;
+using Hyperbee.Json.Filters;
 
-namespace Hyperbee.Json.Evaluators.Parser.Element;
+namespace Hyperbee.Json.Descriptors.Element;
 
-public class JsonElementValueAccessor : IJsonValueAccessor<JsonElement>
+public class ElementValueAccessor : IValueAccessor<JsonElement>
 {
     public IEnumerable<(JsonElement, string)> EnumerateChildValues( JsonElement value )
     {

diff --git a/...ors/Parser/Element/FilterElementHelper.cs → ...escriptors/Element/FilterElementHelper.cs b/...ors/Parser/Element/FilterElementHelper.cs → ...escriptors/Element/FilterElementHelper.cs
@@ -1,13 +1,12 @@
 using System.Reflection;
 using System.Text.Json;
 
-namespace Hyperbee.Json.Evaluators.Parser.Element;
+namespace Hyperbee.Json.Descriptors.Element;
 
 public static class FilterElementHelper
 {
     public static readonly MethodInfo SelectFirstElementValueMethod;
     public static readonly MethodInfo SelectFirstMethod;
-
     public static readonly MethodInfo SelectElementsMethod;
 
     static FilterElementHelper()

diff --git a/...rs/Parser/Element/CountElementFunction.cs → ...Element/Functions/CountElementFunction.cs b/...rs/Parser/Element/CountElementFunction.cs → ...Element/Functions/CountElementFunction.cs
@@ -1,11 +1,12 @@
 using System.Linq.Expressions;
 using System.Reflection;
 using System.Text.Json;
+using Hyperbee.Json.Filters.Parser;
 
-namespace Hyperbee.Json.Evaluators.Parser.Element;
+namespace Hyperbee.Json.Descriptors.Element.Functions;
 
 public class CountElementFunction( string methodName, IList<string> arguments, ParseExpressionContext context ) :
-    FilterExpressionFunction( methodName, arguments, context )
+    FilterExtensionFunction( methodName, arguments, context )
 {
     public const string Name = "count";
 
@@ -22,7 +23,7 @@ static CountElementFunction()
             .MakeGenericMethod( typeof( JsonElement ) );
     }
 
-    public override Expression GetExpression( string methodName, IList<string> arguments, ParseExpressionContext context )
+    public override Expression GetExtensionExpression( string methodName, IList<string> arguments, ParseExpressionContext context )
     {
         if ( arguments.Count != 1 )
         {

diff --git a/...s/Parser/Element/FilterElementFunction.cs → ...lement/Functions/FilterElementFunction.cs b/...s/Parser/Element/FilterElementFunction.cs → ...lement/Functions/FilterElementFunction.cs
@@ -1,10 +1,11 @@
 using System.Linq.Expressions;
+using Hyperbee.Json.Filters.Parser;
 
-namespace Hyperbee.Json.Evaluators.Parser.Element;
+namespace Hyperbee.Json.Descriptors.Element.Functions;
 
 public class FilterElementFunction( ParseExpressionContext context ) : FilterFunction
 {
-    protected override Expression Evaluate( ReadOnlySpan<char> data, ReadOnlySpan<char> item, ref int start, ref int from )
+    protected override Expression GetExpressionImpl( ReadOnlySpan<char> data, ReadOnlySpan<char> item, ref int start, ref int from )
     {
         var queryExp = Expression.Constant( item.ToString() );
 

diff --git a/...s/Parser/Element/LengthElementFunction.cs → ...lement/Functions/LengthElementFunction.cs b/...s/Parser/Element/LengthElementFunction.cs → ...lement/Functions/LengthElementFunction.cs
@@ -1,10 +1,11 @@
 using System.Linq.Expressions;
 using System.Reflection;
 using System.Text.Json;
+using Hyperbee.Json.Filters.Parser;
 
-namespace Hyperbee.Json.Evaluators.Parser.Element;
+namespace Hyperbee.Json.Descriptors.Element.Functions;
 
-public class LengthElementFunction( string methodName, IList<string> arguments, ParseExpressionContext context ) : FilterExpressionFunction( methodName, arguments, context )
+public class LengthElementFunction( string methodName, IList<string> arguments, ParseExpressionContext context ) : FilterExtensionFunction( methodName, arguments, context )
 {
     public const string Name = "length";
 
@@ -15,7 +16,7 @@ static LengthElementFunction()
         LengthMethod = typeof( LengthElementFunction ).GetMethod( nameof( Length ), [typeof( JsonElement )] );
     }
 
-    public override Expression GetExpression( string methodName, IList<string> arguments, ParseExpressionContext context )
+    public override Expression GetExtensionExpression( string methodName, IList<string> arguments, ParseExpressionContext context )
     {
         if ( arguments.Count != 1 )
         {

diff --git a/...rs/Parser/Element/MatchElementFunction.cs → ...Element/Functions/MatchElementFunction.cs b/...rs/Parser/Element/MatchElementFunction.cs → ...Element/Functions/MatchElementFunction.cs
@@ -2,10 +2,11 @@
 using System.Reflection;
 using System.Text.Json;
 using System.Text.RegularExpressions;
+using Hyperbee.Json.Filters.Parser;
 
-namespace Hyperbee.Json.Evaluators.Parser.Element;
+namespace Hyperbee.Json.Descriptors.Element.Functions;
 
-public class MatchElementFunction( string methodName, IList<string> arguments, ParseExpressionContext context ) : FilterExpressionFunction( methodName, arguments, context )
+public class MatchElementFunction( string methodName, IList<string> arguments, ParseExpressionContext context ) : FilterExtensionFunction( methodName, arguments, context )
 {
     public const string Name = "match";
 
@@ -16,7 +17,7 @@ static MatchElementFunction()
         MatchMethod = typeof( MatchElementFunction ).GetMethod( nameof( Match ), [typeof( JsonElement ), typeof( string )] );
     }
 
-    public override Expression GetExpression( string methodName, IList<string> arguments, ParseExpressionContext context )
+    public override Expression GetExtensionExpression( string methodName, IList<string> arguments, ParseExpressionContext context )
     {
         if ( arguments.Count != 2 )
         {

diff --git a/...s/Parser/Element/SearchElementFunction.cs → ...lement/Functions/SearchElementFunction.cs b/...s/Parser/Element/SearchElementFunction.cs → ...lement/Functions/SearchElementFunction.cs
@@ -2,10 +2,11 @@
 using System.Reflection;
 using System.Text.Json;
 using System.Text.RegularExpressions;
+using Hyperbee.Json.Filters.Parser;
 
-namespace Hyperbee.Json.Evaluators.Parser.Element;
+namespace Hyperbee.Json.Descriptors.Element.Functions;
 
-public class SearchElementFunction( string methodName, IList<string> arguments, ParseExpressionContext context ) : FilterExpressionFunction( methodName, arguments, context )
+public class SearchElementFunction( string methodName, IList<string> arguments, ParseExpressionContext context ) : FilterExtensionFunction( methodName, arguments, context )
 {
     public const string Name = "search";
 
@@ -16,7 +17,7 @@ static SearchElementFunction()
         SearchMethod = typeof( SearchElementFunction ).GetMethod( nameof( Search ), [typeof( JsonElement ), typeof( string )] );
     }
 
-    public override Expression GetExpression( string methodName, IList<string> arguments, ParseExpressionContext context )
+    public override Expression GetExtensionExpression( string methodName, IList<string> arguments, ParseExpressionContext context )
     {
         if ( arguments.Count != 2 )
         {

diff --git a/...rs/Parser/Element/ValueElementFunction.cs → ...Element/Functions/ValueElementFunction.cs b/...rs/Parser/Element/ValueElementFunction.cs → ...Element/Functions/ValueElementFunction.cs
@@ -1,12 +1,13 @@
 using System.Linq.Expressions;
+using Hyperbee.Json.Filters.Parser;
 
-namespace Hyperbee.Json.Evaluators.Parser.Element;
+namespace Hyperbee.Json.Descriptors.Element.Functions;
 
-public class ValueElementFunction( string methodName, IList<string> arguments, ParseExpressionContext context ) : FilterExpressionFunction( methodName, arguments, context )
+public class ValueElementFunction( string methodName, IList<string> arguments, ParseExpressionContext context ) : FilterExtensionFunction( methodName, arguments, context )
 {
     public const string Name = "value";
 
-    public override Expression GetExpression( string methodName, IList<string> arguments, ParseExpressionContext context )
+    public override Expression GetExtensionExpression( string methodName, IList<string> arguments, ParseExpressionContext context )
     {
         if ( arguments.Count != 1 )
         {

diff --git a/src/Hyperbee.Json/Descriptors/ITypeDescriptor.cs b/src/Hyperbee.Json/Descriptors/ITypeDescriptor.cs
@@ -0,0 +1,18 @@
+using Hyperbee.Json.Filters;
+using Hyperbee.Json.Filters.Parser;
+
+namespace Hyperbee.Json.Descriptors;
+
+
+public interface IJsonTypeDescriptor
+{
+    public Dictionary<string, FunctionCreator> Functions { get; }
+
+    public FilterFunction GetFilterFunction( ParseExpressionContext context );
+}
+
+public interface ITypeDescriptor<TElement> : IJsonTypeDescriptor
+{
+    public IValueAccessor<TElement> Accessor { get; }
+    public IFilterEvaluator<TElement> FilterEvaluator { get; }
+}
diff --git a/...bee.Json/Evaluators/IJsonValueAccessor.cs → ...perbee.Json/Descriptors/IValueAccessor.cs b/...bee.Json/Evaluators/IJsonValueAccessor.cs → ...perbee.Json/Descriptors/IValueAccessor.cs
@@ -1,6 +1,6 @@
-namespace Hyperbee.Json.Evaluators;
+namespace Hyperbee.Json.Descriptors;
 
-public interface IJsonValueAccessor<TElement>
+public interface IValueAccessor<TElement>
 {
     IEnumerable<(TElement, string)> EnumerateChildValues( TElement value );
     TElement GetElementAt( TElement value, int index );

diff --git a/...valuators/Parser/Node/FilterNodeHelper.cs → ...Json/Descriptors/Node/FilterNodeHelper.cs b/...valuators/Parser/Node/FilterNodeHelper.cs → ...Json/Descriptors/Node/FilterNodeHelper.cs
@@ -3,7 +3,7 @@
 using System.Text.Json.Nodes;
 using Hyperbee.Json.Extensions;
 
-namespace Hyperbee.Json.Evaluators.Parser.Node;
+namespace Hyperbee.Json.Descriptors.Node;
 
 public static class FilterNodeHelper
 {

diff --git a/...aluators/Parser/Node/CountNodeFunction.cs → ...ptors/Node/Functions/CountNodeFunction.cs b/...aluators/Parser/Node/CountNodeFunction.cs → ...ptors/Node/Functions/CountNodeFunction.cs
@@ -1,11 +1,12 @@
 using System.Linq.Expressions;
 using System.Reflection;
 using System.Text.Json.Nodes;
+using Hyperbee.Json.Filters.Parser;
 
-namespace Hyperbee.Json.Evaluators.Parser.Node;
+namespace Hyperbee.Json.Descriptors.Node.Functions;
 
 public class CountNodeFunction( string methodName, IList<string> arguments, ParseExpressionContext context ) :
-    FilterExpressionFunction( methodName, arguments, context )
+    FilterExtensionFunction( methodName, arguments, context )
 {
     public const string Name = "count";
 
@@ -22,7 +23,7 @@ static CountNodeFunction()
             .MakeGenericMethod( typeof( JsonNode ) );
     }
 
-    public override Expression GetExpression( string methodName, IList<string> arguments, ParseExpressionContext context )
+    public override Expression GetExtensionExpression( string methodName, IList<string> arguments, ParseExpressionContext context )
     {
         if ( arguments.Count != 1 )
         {

diff --git a/...luators/Parser/Node/FilterNodeFunction.cs → ...tors/Node/Functions/FilterNodeFunction.cs b/...luators/Parser/Node/FilterNodeFunction.cs → ...tors/Node/Functions/FilterNodeFunction.cs
@@ -1,10 +1,11 @@
 using System.Linq.Expressions;
+using Hyperbee.Json.Filters.Parser;
 
-namespace Hyperbee.Json.Evaluators.Parser.Node;
+namespace Hyperbee.Json.Descriptors.Node.Functions;
 
 public class FilterNodeFunction( ParseExpressionContext context ) : FilterFunction
 {
-    protected override Expression Evaluate( ReadOnlySpan<char> data, ReadOnlySpan<char> item, ref int start, ref int from )
+    protected override Expression GetExpressionImpl( ReadOnlySpan<char> data, ReadOnlySpan<char> item, ref int start, ref int from )
     {
         var queryExp = Expression.Constant( item.ToString() );
 

diff --git a/...luators/Parser/Node/LengthNodeFunction.cs → ...tors/Node/Functions/LengthNodeFunction.cs b/...luators/Parser/Node/LengthNodeFunction.cs → ...tors/Node/Functions/LengthNodeFunction.cs
@@ -2,10 +2,11 @@
 using System.Reflection;
 using System.Text.Json;
 using System.Text.Json.Nodes;
+using Hyperbee.Json.Filters.Parser;
 
-namespace Hyperbee.Json.Evaluators.Parser.Node;
+namespace Hyperbee.Json.Descriptors.Node.Functions;
 
-public class LengthNodeFunction( string methodName, IList<string> arguments, ParseExpressionContext context ) : FilterExpressionFunction( methodName, arguments, context )
+public class LengthNodeFunction( string methodName, IList<string> arguments, ParseExpressionContext context ) : FilterExtensionFunction( methodName, arguments, context )
 {
     public const string Name = "length";
 
@@ -16,7 +17,7 @@ static LengthNodeFunction()
         LengthMethod = typeof( LengthNodeFunction ).GetMethod( nameof( Length ), [typeof( JsonNode )] );
     }
 
-    public override Expression GetExpression( string methodName, IList<string> arguments, ParseExpressionContext context )
+    public override Expression GetExtensionExpression( string methodName, IList<string> arguments, ParseExpressionContext context )
     {
         if ( arguments.Count != 1 )
         {

diff --git a/...aluators/Parser/Node/MatchNodeFunction.cs → ...ptors/Node/Functions/MatchNodeFunction.cs b/...aluators/Parser/Node/MatchNodeFunction.cs → ...ptors/Node/Functions/MatchNodeFunction.cs
@@ -2,10 +2,11 @@
 using System.Reflection;
 using System.Text.Json.Nodes;
 using System.Text.RegularExpressions;
+using Hyperbee.Json.Filters.Parser;
 
-namespace Hyperbee.Json.Evaluators.Parser.Node;
+namespace Hyperbee.Json.Descriptors.Node.Functions;
 
-public class MatchNodeFunction( string methodName, IList<string> arguments, ParseExpressionContext context ) : FilterExpressionFunction( methodName, arguments, context )
+public class MatchNodeFunction( string methodName, IList<string> arguments, ParseExpressionContext context ) : FilterExtensionFunction( methodName, arguments, context )
 {
     public const string Name = "match";
 
@@ -16,7 +17,7 @@ static MatchNodeFunction()
         MatchMethod = typeof( MatchNodeFunction ).GetMethod( nameof( Match ), [typeof( JsonNode ), typeof( string )] );
     }
 
-    public override Expression GetExpression( string methodName, IList<string> arguments, ParseExpressionContext context )
+    public override Expression GetExtensionExpression( string methodName, IList<string> arguments, ParseExpressionContext context )
     {
         if ( arguments.Count != 2 )
         {

diff --git a/...tors/Parser/Node/SearchElementFunction.cs → ...s/Node/Functions/SearchElementFunction.cs b/...tors/Parser/Node/SearchElementFunction.cs → ...s/Node/Functions/SearchElementFunction.cs
@@ -2,10 +2,11 @@
 using System.Reflection;
 using System.Text.Json.Nodes;
 using System.Text.RegularExpressions;
+using Hyperbee.Json.Filters.Parser;
 
-namespace Hyperbee.Json.Evaluators.Parser.Node;
+namespace Hyperbee.Json.Descriptors.Node.Functions;
 
-public class SearchNodeFunction( string methodName, IList<string> arguments, ParseExpressionContext context ) : FilterExpressionFunction( methodName, arguments, context )
+public class SearchNodeFunction( string methodName, IList<string> arguments, ParseExpressionContext context ) : FilterExtensionFunction( methodName, arguments, context )
 {
     public const string Name = "search";
 
@@ -16,7 +17,7 @@ static SearchNodeFunction()
         SearchMethod = typeof( SearchNodeFunction ).GetMethod( nameof( Search ), [typeof( JsonNode ), typeof( string )] );
     }
 
-    public override Expression GetExpression( string methodName, IList<string> arguments, ParseExpressionContext context )
+    public override Expression GetExtensionExpression( string methodName, IList<string> arguments, ParseExpressionContext context )
     {
         if ( arguments.Count != 2 )
         {

diff --git a/...ators/Parser/Node/ValueElementFunction.cs → ...rs/Node/Functions/ValueElementFunction.cs b/...ators/Parser/Node/ValueElementFunction.cs → ...rs/Node/Functions/ValueElementFunction.cs
@@ -1,12 +1,13 @@
 using System.Linq.Expressions;
+using Hyperbee.Json.Filters.Parser;
 
-namespace Hyperbee.Json.Evaluators.Parser.Node;
+namespace Hyperbee.Json.Descriptors.Node.Functions;
 
-public class ValueNodeFunction( string methodName, IList<string> arguments, ParseExpressionContext context ) : FilterExpressionFunction( methodName, arguments, context )
+public class ValueNodeFunction( string methodName, IList<string> arguments, ParseExpressionContext context ) : FilterExtensionFunction( methodName, arguments, context )
 {
     public const string Name = "value";
 
-    public override Expression GetExpression( string methodName, IList<string> arguments, ParseExpressionContext context )
+    public override Expression GetExtensionExpression( string methodName, IList<string> arguments, ParseExpressionContext context )
     {
         if ( arguments.Count != 1 )
         {

diff --git a/...ors/Parser/Node/JsonNodeTypeDescriptor.cs → ...on/Descriptors/Node/NodeTypeDescriptor.cs b/...ors/Parser/Node/JsonNodeTypeDescriptor.cs → ...on/Descriptors/Node/NodeTypeDescriptor.cs
@@ -1,19 +1,30 @@
-namespace Hyperbee.Json.Evaluators.Parser.Node;
+using System.Text.Json.Nodes;
+using Hyperbee.Json.Descriptors.Node.Functions;
+using Hyperbee.Json.Filters;
+using Hyperbee.Json.Filters.Parser;
 
-public class JsonNodeTypeDescriptor : IJsonTypeDescriptor
+namespace Hyperbee.Json.Descriptors.Node;
+
+public class NodeTypeDescriptor : ITypeDescriptor<JsonNode>
 {
-    public Dictionary<string, FunctionCreator> Functions { get; }
+    private FilterEvaluator<JsonNode> _evaluator;
+    private NodeValueAccessor _accessor;
+    public Dictionary<string, FunctionCreator> Functions { get; init; }
 
-    public IJsonValueAccessor<TElement> GetAccessor<TElement>() =>
-        new JsonNodeValueAccessor() as IJsonValueAccessor<TElement>;
+    public IValueAccessor<JsonNode> Accessor
+    {
+        get => _accessor ??= new NodeValueAccessor();
+    }
 
-    public IJsonPathFilterEvaluator<TElement> GetFilterEvaluator<TElement>() =>
-        new JsonPathFilterEvaluator<TElement>( this );
+    public IFilterEvaluator<JsonNode> FilterEvaluator
+    {
+        get => _evaluator ??= new FilterEvaluator<JsonNode>( this );
+    }
 
     public FilterFunction GetFilterFunction( ParseExpressionContext context ) =>
         new FilterNodeFunction( context );
 
-    public JsonNodeTypeDescriptor()
+    public NodeTypeDescriptor()
     {
         Functions = new Dictionary<string, FunctionCreator>(
         [