Fixes #84: Implement validity check when comparing, and ensure that i…

…nvalid type comparisons

           will result in a resolve state that is neither true nor false. This will help
           ensure a more well-defined matcher behavior and easier to be documented and understood.
           Based on the validity component, null comparisons (Issue #84) can now be addressed
           correctly without the use of workarounds such as math.MaxUint or the like.

bintree.go

@@ -347,9 +347,9 @@ func (state *binTreeState) checkNode(index int) {
  return
  } else if defNode.NodeType == nodeTypeNot {
  if state.data[defNode.Left] == binTreeStateTrue {
- state.MarkNode(index, !true)
+ state.MarkNode(index, false)
  } else if state.data[defNode.Left] == binTreeStateFalse {
- state.MarkNode(index, !false)
+ state.MarkNode(index, true)
  }
  return
  } else if defNode.NodeType == nodeTypeLoop {
@@ -374,6 +374,7 @@ func (state *binTreeState) MarkNode(index int, value bool) {
  } else {
  state.data[index] = binTreeStateFalse
  }
+
  state.resolveRecursive(index)
 
  // We are done if we are the root node

fastMatcher.go

@@ -265,27 +265,39 @@ func (m *FastMatcher) matchOp(op *OpNode, litVal *FastVal) error {
  }
 
  var opRes bool
+ var validOp bool
+ var compareOut int
  switch op.Op {
  case OpTypeEquals:
- opRes = lhsVal.Equals(rhsVal)
+ opRes, validOp = lhsVal.Equals(rhsVal)
  case OpTypeLessThan:
- opRes = lhsVal.Compare(rhsVal) < 0
+ compareOut, validOp = lhsVal.Compare(rhsVal)
+ opRes = compareOut < 0
  case OpTypeLessEquals:
- opRes = lhsVal.Compare(rhsVal) <= 0
+ compareOut, validOp = lhsVal.Compare(rhsVal)
+ opRes = compareOut <= 0
  case OpTypeGreaterThan:
- opRes = lhsVal.Compare(rhsVal) > 0
+ compareOut, validOp = lhsVal.Compare(rhsVal)
+ opRes = compareOut > 0
  case OpTypeGreaterEquals:
- opRes = lhsVal.Compare(rhsVal) >= 0
+ compareOut, validOp = lhsVal.Compare(rhsVal)
+ opRes = compareOut >= 0
  case OpTypeMatches:
- opRes = lhsVal.Matches(rhsVal)
+ opRes, validOp = lhsVal.Matches(rhsVal)
  case OpTypeExists:
  opRes = true
+ validOp = true
  default:
  panic("invalid op type")
  }
 
  // Mark the result of this operation
- m.buckets.MarkNode(bucketIdx, opRes)
+ if !validOp {
+ // TODO FIX
+ m.buckets.MarkNode(bucketIdx, false)
+ } else {
+ m.buckets.MarkNode(bucketIdx, opRes)
+ }
 
  // Check if running this values ops has resolved the entirety
  // of the expression, if so we can leave immediately.
@@ -498,7 +510,11 @@ func (m *FastMatcher) matchLoop(token tokenType, tokenData []byte, loop *LoopNod
  m.buckets.SetStallIndex(previousStallIndex)
 
  // Apply the overall loop result to the binary tree
- m.buckets.MarkNode(loopBucketIdx, loopState)
+ if loopState {
+ m.buckets.MarkNode(loopBucketIdx, true)
+ } else {
+ m.buckets.MarkNode(loopBucketIdx, false)
+ }
 
  return nil
 }

fastMatcher_test.go

@@ -158,9 +158,9 @@ func TestMatcherNotTrueEquals(t *testing.T) {
 }
 
 func TestMatcherMissingNotEquals(t *testing.T) {
- // This tests a specific case where a missing value should actually
- // result in a truthy result in the expression. Due to the nature
- // of our bintree implementation, this needs special handling.
+ // This tests a specific case where both missing value and false booleans
+ // will return truthy results, since the "true" value here translates to
+ // a true boolean
  runJSONExprMatchTest(t, `
  ["not",
  ["equals",
@@ -169,14 +169,15 @@ func TestMatcherMissingNotEquals(t *testing.T) {
  ]
  ]
  `, []string{
- "5b47eb0950e9076fc0aecd52",
  "5b47eb093771f06ced629663",
  "5b47eb09ffac5a6ce37042e7",
  "5b47eb095c3ad73b9925f7f8",
  "5b47eb0962222a37d066e231",
  "5b47eb09996a4154c35b2f98",
  "5b47eb091f57571d3c3b1aa1",
  "5b47eb098eee4b4c4330ec64",
+ "5b47eb0936ff92a567a0307e",
+ "5b47eb096b1d911c0b9492fb",
  })
 }
 
@@ -214,22 +215,6 @@ func TestMatcherNotExists(t *testing.T) {
  })
 }
 
-func TestMatcherDisparateTypeEquals(t *testing.T) {
- // TODO(brett19): Should probably discuss whether type-cast equals
- // actually makes sense... This validates that these something like:
- // (true == "thisShouldBeABoolean") === true
- // which may not actually make a whole lot of sense...
- runJSONExprMatchTest(t, `
- ["equals",
- ["field", "sometimesValue"],
- ["value", "thisShouldBeABoolean"]
- ]
- `, []string{
- "5b47eb0936ff92a567a0307e",
- "5b47eb096b1d911c0b9492fb",
- })
-}
-
 func TestMatcherSometimesMissingBoolEquals(t *testing.T) {
  runJSONExprMatchTest(t, `
  ["equals",