Add suffix system

Author: Quicksilver0218

C Sharp/Object Validator Test/Object Validator Test.csproj

@@ -15,7 +15,7 @@
     <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.8.0" />
     <PackageReference Include="MSTest.TestAdapter" Version="3.1.1" />
     <PackageReference Include="MSTest.TestFramework" Version="3.1.1" />
-    <PackageReference Include="Quicksilver0218.ObjectValidator" Version="1.0.3" />
+    <PackageReference Include="Quicksilver0218.ObjectValidator" Version="2.0.0" />
     <None Include="rules.json">
       <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
     </None>

C Sharp/Object Validator/Object Validator.csproj

@@ -6,7 +6,7 @@
     <ImplicitUsings>enable</ImplicitUsings>
     <Nullable>enable</Nullable>
     <PackageId>Quicksilver0218.ObjectValidator</PackageId>
-    <PackageVersion>1.0.3</PackageVersion>
+    <PackageVersion>2.0.0</PackageVersion>
     <Authors>Quicksilver0218</Authors>
     <Copyright>Copyright (c) Quicksilver0218 2024</Copyright>
     <Description>

C Sharp/Object Validator/Runtime/Condition.cs

@@ -6,13 +6,39 @@ abstract class Condition(bool reversed, string? fieldExpression)
     protected readonly bool reversed = reversed;
     protected readonly string? fieldExpression = fieldExpression;
 
+    private static void HandleField(object o, string field, List<object?> fields) {
+        fields.Add(o.GetType().GetField(field)!.GetValue(o));
+    }
+
+    private static void HandleIndex(IList list, int index, List<object?> fields) {
+        fields.Add(list[index]);
+    }
+
+    private static void HandleKey(IDictionary map, string key, List<object?> fields) {
+        fields.Add(map[key]);
+    }
+
+    private static void HandleFields(List<object?> fields, string name, List<object?> newFields) {
+        foreach (object? o in fields)
+            if (o == null)
+                newFields.Add(null);
+            else if (o is IDictionary d)
+                HandleKey(d, name, newFields);
+            else if (o is IList l && int.TryParse(name, out int index))
+                HandleIndex(l, index, newFields);
+            else
+                HandleField(o, name, newFields);
+    }
+
     internal bool Check(object? root, string? rootFieldExpression, HashSet<string> passedFields, HashSet<string> failedFields) {
         List<object?> fields = [root];
         if (fieldExpression != null) {
-            if (root != null)
+            if (root != null) {
+                string fullName = "";
                 foreach (string name in fieldExpression.Split('.')) {
                     List<object?> newFields = [];
-                    if (name == "*")
+                    fullName += name;
+                    if (fullName == "*")
                         foreach (object? o in fields)
                             if (o == null)
                                 newFields.Add(null);
@@ -21,28 +47,47 @@ internal bool Check(object? root, string? rootFieldExpression, HashSet<string> p
                                     newFields.Add(item);
                             else
                                 throw new Exception("Unsupported type for iteration: " + o.GetType());
-                    else {
-                        string newName;
-                        foreach (char c in name)
-                            if (c != '*') {
-                                newName = name;
-                                goto Handle;
-                            }
-                        newName = name[1..];
-                        Handle:
-                        foreach (object? o in fields)
-                            if (o == null)
-                                newFields.Add(null);
-                            else if (o is IDictionary d)
-                                newFields.Add(d[newName]);
-                            else if (o is IList l && int.TryParse(newName, out int index)) {
-                                if (index < l.Count)
-                                    newFields.Add(l[index]);
-                            } else
-                                newFields.Add(o.GetType().GetField(newName)!.GetValue(o));
-                    }
+                    else if (name.Length >= 3 && name[^3..^1] == "//")
+                        fullName = fullName[0..^3] + fullName[^2..];
+                    else if (name.Length >= 2 && name[^2] == '/') {
+                        fullName = fullName[0..^2];
+                        switch (char.ToUpper(name[^1])) {
+                            case 'C':
+                                fullName += ".";
+                                continue;
+                            case 'F':
+                                foreach (object? o in fields)
+                                    if (o == null)
+                                        newFields.Add(null);
+                                    else
+                                        HandleField(o, fullName, newFields);
+                                break;
+                            case 'I':
+                                foreach (object? o in fields)
+                                    if (o == null)
+                                        newFields.Add(null);
+                                    else
+                                        HandleIndex((IList)o, int.Parse(fullName), newFields);
+                                break;
+                            case 'K':
+                                foreach (object? o in fields)
+                                    if (o == null)
+                                        newFields.Add(null);
+                                    else
+                                        HandleKey((IDictionary)o, fullName, newFields);
+                                break;
+                            case '*':
+                                HandleFields(fields, fullName + "*", newFields);
+                                break;
+                            default:
+                                throw new Exception("Unsupported suffix: " + name[^1]);
+                        }
+                    } else
+                        HandleFields(fields, name, newFields);
                     fields = newFields;
+                    fullName = "";
                 }
+            }
             if (rootFieldExpression != null)
                 rootFieldExpression += "." + fieldExpression;
             else

Document.md

@@ -3,6 +3,9 @@
     - [Field Expression](#field-expression)
         - [General](#general)
         - [Iterable](#iterable)
+        - [Type Precedence and Suffixes](#type-precedence-and-suffixes)
+            - [Type Precedence](#type-precedence)
+            - [Suffixes](#suffixes)
     - [Condition Types](#condition-types)
         - [Not (!)](#not-)
         - [And](#and)
@@ -161,9 +164,39 @@ For iterable objects (e.g. `Set`), iteration can be performed by using `*`. Cons
 }
 ```
 
-If a string only containing 1 or more `*` should be used as a key in a map (dictionary), an extra `*` should be added. e.g. `"**"` represents `"*"` as a key and `"***"` represents `"**"` as a key.
+If you want to use `*` as a key in a `Map` (`Dictionary`), please put `/*` or `*/K` into the expression instead. (Please see [Suffixes](#suffixes) for detail.)
 
-For array-like objects (e.g. `Array`), indices can also be used. e.g. `phoneNumber.0.type`. While using an index out of bounds throws an exception in C♯ and Java, it is valid and `undefined` is returned in JavaScript / TypeScript.
+For lists and arrays, indices can also be used. e.g. `phoneNumber.0.type`. While using an index out of bounds throws an exception in C♯ and Java, it is valid and `undefined` is returned in JavaScript / TypeScript.
+
+#### Type Precedence and Suffixes
+##### Type Precedence
+By default, a field name will be handled in this order:
+1. If the upper-level object is a `Map` (`Dictionary`), the field name will be treated as a key.
+2. If the upper-level object is a `List` / `Array` and the field name can be parsed to an integer, the field name will be treated as an index.
+3. The field name will be treated as a field name.
+
+Therefore, if you want to express a field of a `Map` (`Dictionary`), a [Suffix](#suffixes) is required.
+
+##### Suffixes
+Field names ending with `/?` will be treated as having a suffix, where `?` can be any character. Suffixes are case-insensitive. Supported suffixes are listed below.
+
+###### C
+`C` stands for 'Concat'. This should be used when you want to have `.` in a field name. e.g. `part1/C.part2` represents `part1.part2` as a whole field name.
+
+###### F
+`F` stands for 'Field'. Field names with this suffix will be forcefully treated as a field name.
+
+###### I
+`I` stands for 'Index'. Field names with this suffix will be forcefully treated as an index in a `List` / `Array`.
+
+###### K
+`K` stands for 'Key'. Field names with this suffix will be forcefully treated as a key in a `Map` (`Dictionary`).
+
+###### *
+This can be used when you want to use `*` as a field name. e.g. `/*` represents `*` as a field name.
+
+###### Escape Character (/)
+Sometimes a field name without suffixes looks like having a suffix. You can prevent a field name such as this from being treated as having a suffix by adding one more `/` before `/`. e.g. `//A` represents `/A` as a field name.
 
 ### Condition Types
 #### Not (!)

Java/Object Validator/.gitignore

@@ -4,4 +4,5 @@
 # Ignore Gradle build output directory
 build
 
+lib/bin
 .vscode