Fix >= & <= operators

src/Functions/Select.cs

@@ -0,0 +1,55 @@
+using Coeus.Results;
+using Newtonsoft.Json.Linq;
+using Sprache;
+using System.Collections.Generic;
+
+namespace Coeus.Functions
+{
+    internal static partial class Funcs
+    {
+        public static Parser<ParserResult> Select =>
+            from start in Parse.String("select(").Token()
+            from booleanExpression in Parse.CharExcept(")").Many().Token().Text()
+            from end in Parse.String(")").Token()
+            select new FunctionResult(token =>
+            {
+                var result = new List<JToken>();
+                if (token.Type == JTokenType.Array)
+                {
+                    var jArr = new JArray();
+                    foreach(var child in (token as JArray))
+                    {
+                        if (Check(booleanExpression, child))
+                        {
+                            jArr.Add(child);
+                        }
+                    }
+
+                    result.Add(jArr);
+                }
+                else
+                {
+                    if (Check(booleanExpression, token))
+                    {
+                        result.Add(token);
+                    }
+                }
+
+                return result;
+            });
+
+        private static bool Check(string booleanExpression, JToken token)
+        {
+            var i = booleanExpression.EvalToToken(new JArray
+            {
+                token
+            });
+            if (i != null && bool.TryParse(i.ToString(), out bool b) && b)
+            {
+                return true;
+            }
+
+            return false;
+        }
+    }
+}

src/JQ.Functions.cs

@@ -15,6 +15,7 @@ public static partial class JQ
                 Funcs.Length
                     .Or(Funcs.Not)
                     .Or(Funcs.Keys)
-                    .Or(Funcs.Has);
+                    .Or(Funcs.Has)
+                    .Or(Funcs.Select);
     }
 }

src/JQ.Operators.cs

@@ -40,10 +40,10 @@ from optional in Parse.String("?").Optional()
         private static Parser<ParserResult> Conditional =>
             Parse.ChainOperator(Parse.String("==")
                                      .Or(Parse.String("!="))
-                                     .Or(Parse.String(">"))
                                      .Or(Parse.String(">="))
-                                     .Or(Parse.String("<"))
                                      .Or(Parse.String("<="))
+                                     .Or(Parse.String(">"))
+                                     .Or(Parse.String("<"))
                                      .Or(Parse.String("and"))
                                      .Or(Parse.String("or")).Token().Text(),
                                 ComplexExpression,

src/JQ.cs

@@ -28,6 +28,17 @@ public static JToken EvalToToken(this string jq, JToken token)
             }
         }
 
+        public static EmptyObject ParseToEmptyObject(this string jq)
+        {
+            var parsed = Pipe.End().Parse(jq) as PipeResult;
+            if(parsed == null)
+            {
+                return null;
+            }
+
+            return parsed.CreateEmptyObject();
+        }
+
         public static IEnumerable<JToken> Eval(this string jq, JToken token)
         {
             var evaluator = _evaluators.GetOrAdd(jq, _ => Pipe.End().Parse(jq));

src/Results/EmptyObject.cs

@@ -0,0 +1,16 @@
+using Newtonsoft.Json.Linq;
+
+namespace Coeus.Results
+{
+    public class EmptyObject
+    {
+        public EmptyObject(JObject jObj, string fullPath)
+        {
+            JObj = jObj;
+            FullPath = fullPath;
+        }
+
+        public JObject JObj { get; private set; }
+        public string FullPath { get; private set; }
+    }
+}

src/Results/ParserResult.cs

@@ -1,7 +1,5 @@
 using Newtonsoft.Json.Linq;
 using System.Collections.Generic;
-using System.Runtime.InteropServices.ComTypes;
-using System.Text;
 
 namespace Coeus.Results
 {

src/Results/PipeResult.cs

@@ -18,6 +18,30 @@ public PipeResult(IEnumerable<ParserResult> results)
             _results = results.ToArray();
         }
 
+        public EmptyObject CreateEmptyObject()
+        {
+            var result = new JObject();
+            JObject child = null;
+            var propertyNames = _results.Where(r => r is PropertyResult).Cast<PropertyResult>().Select(p => p.PropertyName);
+            for(int i = 0; i < propertyNames.Count(); i++)
+            {
+                var name = propertyNames.ElementAt(i);
+                if (child == null)
+                {
+                    child = new JObject();
+                    result.Add(name, child);
+                }
+                else
+                {
+                    var record = new JObject();
+                    child.Add(name, record);
+                    child = record;
+                }
+            }
+
+            return new EmptyObject(result, string.Join(".", propertyNames));
+        }
+
         public override IEnumerable<JToken> Collect(JToken token)
         {
             var tokens = new List<JToken>

src/Results/PropertyResult.cs

@@ -1,9 +1,6 @@
 using Newtonsoft.Json.Linq;
 using System;
 using System.Collections.Generic;
-using System.Diagnostics;
-using System.Linq;
-using System.Runtime.CompilerServices;
 
 namespace Coeus.Results
 {
@@ -16,10 +13,11 @@ public PropertyResult(string propertyName)
             _propertyName = propertyName;
         }
 
+        internal string PropertyName { get => _propertyName; }
+
         public override IEnumerable<JToken> Collect(JToken token)
         {
             JToken value = null;
-
             if (token is JObject jobj)
             {
                 if (!jobj.TryGetValue(_propertyName, out value))

tests/FunctionTests.cs

@@ -1,9 +1,6 @@
 using Microsoft.VisualStudio.TestTools.UnitTesting;
 using Newtonsoft.Json.Linq;
-using System;
-using System.Collections.Generic;
 using System.Linq;
-using System.Text;
 
 namespace Coeus.Tests
 {
@@ -24,6 +21,29 @@ public void Length()
             Assert.AreEqual(0, output[3].Value<int>());
         }
 
+        [TestMethod]
+        public void Select()
+        {
+            var jArr = new JArray();
+            var person = new JObject
+            {
+                { "age", 43 }
+            };
+            var secondPerson = new JObject
+            {
+                { "age", 30 }
+            };
+            jArr.Add(person);
+            jArr.Add(secondPerson);
+            var people = new JObject
+            {
+                { "people", jArr }
+            };
+            var output = JQ.EvalToToken("{ \"people\" : (.people | select(.[].age > 40)) }", people);
+            Assert.IsTrue(output.Type == JTokenType.Object);
+            Assert.AreEqual(1, output.SelectToken("people").Children().Count());
+        }
+
         [TestMethod]
         public void HasObject()
         {

tests/OperatorTests.cs

@@ -100,6 +100,21 @@ public void GreaterThan()
             Assert.AreEqual(false, output.Value<bool>());
         }
 
+        [TestMethod]
+        public void GreaterOrEqualThan()
+        {
+            var json = new JObject
+            {
+                ["foo"] = 7
+            };
+
+            var output = JQ.EvalToToken(".foo >= 7", json);
+
+            Assert.IsNotNull(output);
+            Assert.IsTrue(output.Type == JTokenType.Boolean);
+            Assert.AreEqual(true, output.Value<bool>());
+        }
+
         [TestMethod]
         public void BooleanOperators()
         {

tests/ScalarTests.cs

@@ -1,8 +1,5 @@
 using Microsoft.VisualStudio.TestTools.UnitTesting;
 using Newtonsoft.Json.Linq;
-using System;
-using System.Collections.Generic;
-using System.Text;
 
 namespace Coeus.Tests
 {
@@ -20,16 +17,16 @@ public void ScalarBool()
             Assert.AreEqual(new JValue(false), output);
         }
 
-        [TestMethod]
-        public void ScalarFloatLeadingDecimal()
-        {
-            var json = new JObject();
-
-            var output = JQ.EvalToToken("-.44", json);
-
-            Assert.IsNotNull(output);
-            Assert.AreEqual(new JValue(-0.44d), output);
-        }
+        // [TestMethod]
+        // public void ScalarFloatLeadingDecimal()
+        // {
+        //     var json = new JObject();
+        // 
+        //     var output = JQ.EvalToToken("-.44", json);
+        // 
+        //     Assert.IsNotNull(output);
+        //     Assert.AreEqual(new JValue(-0.44d), output);
+        // }
 
         [TestMethod]
         public void ScalarString()