updated to return tree

query-syntax.peg

start =
  compoundExp
  / exp
 
 
 
op =
  equals
  / logicalOp
  / stringOp
  / compareOp

 
compareOp =
  gtOrEqOp
  / ltOrEqOp
  / gtOp
  / ltOp


logicalOp =
  andOp
  /orOp
 
stringOp =
  negateOp
  / likeOp
  / isOp
 
 
equals =
  '=' { return 'equals' }

gtOp =
  '>' { return 'gt' }

ltOp = 
  '<' { return 'lt' }

gtOrEqOp =
  '>=' {return 'gte' }

ltOrEqOp =
  '<=' { return 'lte' }

 
andOp =
  'and'

orOp =
  'or'

negateOp =
  isNot
  / notLike

isNot =
  isOp _ 'not'
  { return 'isNot' }

notLike =
  'not' _ likeOp
  { return 'notLike' }
 
isOp =
  'is'
 
likeOp =
  'like'
 
_ = 
 ' '+ 

value =
  numericValue
  / stringValue
 
property = 
  w:word
  { return { this: w } }
 
stringValue =
  "'" value:word "'" { return { value: value } }
  /'"' value:word '"' { return { value: value } }
 
word =
  first:letter rest:letter*
  { return first + rest.join('') }
 
letter = [a-zA-Z]
 
 
numericValue = 
  n:decimal { return { value: n } }
  / n:integer
  { return { value: n } }
 
decimal =
  first:integer "." rest:digit* 
  { return parseFloat(first + '.' + rest.join('')) }
  / first:zero "." rest:digit* 
  { return parseFloat(first + '.' + rest.join('')) }
 
integer = 
  first:nonZeroDigit rest:digit*
  { return parseInt(first + rest.join('')); }
  / zero
 
digit = [0-9]
 
nonZeroDigit = [1-9]

zero = '0'
 
boolValue = 
  true
  / false
 
true = 'true' { return { value: true } }
 
false = 'false' { return { value: false } }


boolExp =
  numericExp
  / stringExp

numericExp =
  left:property _ op:compareOp _ right:numericValue
  { return { left: left, op: op, right: right } }

stringExp =
  left:property _ op:stringOp _ right:stringValue
  { return { left: left, op: op, right: right } }
 
compoundExp =
  left:boolExp _ op:logicalOp _ right:boolExp
  { return { left: left, op: op, right: right } } 
 
 
exp = 
  left:property _ op:op _ right:value
  { return { left: left, op: op, right: right } }