siren 0.2.0

data/lib/siren/json_query.tt

@@ -0,0 +1,184 @@
+module Siren
+  grammar JsonQuery
+    rule expression
+      sum / product / divmod / atom
+    end
+    
+    rule boolean_expression
+      or_expression / and_expression / comparison / boolean_atom
+    end
+    
+    rule or_expression
+      first:and_expression "|" second:or_expression <Or> / and_expression
+    end
+    
+    rule and_expression
+      first:comparison "&" second:and_expression <And> / comparison
+    end
+    
+    rule comparison
+      first:expression comparator second:expression <Comparison> / boolean_atom
+    end
+    
+    rule boolean_atom
+      space ("(" boolean_expression ")" / boolean) space <BooleanAtom>
+    end
+    
+    rule sum
+      first:product operator:(add / subtract) second:sum <Sum> / product
+    end
+    
+    rule product
+      first:divmod operator:(times / divide) second:product <Product> / divmod
+    end
+    
+    rule divmod
+      first:atom '%' second:divmod <Divmod> / atom
+    end
+    
+    rule atom
+      space ("(" expression ")" / query / number / string / boolean / null) space <Atom>
+    end
+    
+    rule times
+      "*" <Multiplication>
+    end
+    
+    rule divide
+      "/" <Division>
+    end
+    
+    rule add
+      "+" <Addition>
+    end
+    
+    rule subtract
+      "-" <Subtraction>
+    end
+    
+    rule comparator
+      (not_equal / lte / gte / equal / match / lt / gt) <Comparator>
+    end
+    
+    rule equal
+      "=" <Equal>
+    end
+    
+    rule match
+      "~" <Match>
+    end
+    
+    rule not_equal
+      "!=" <NotEqual>
+    end
+    
+    rule lt
+      "<" <LessThan>
+    end
+    
+    rule lte
+      "<=" <LessThanOrEqual>
+    end
+    
+    rule gt
+      ">" <GreaterThan>
+    end
+    
+    rule gte
+      ">=" <GreaterThanOrEqual>
+    end
+    
+    rule string
+      "'" ('\\' ("'" / '\\' / '/' / 'b' / 'f' / 'n' / 'r' / 't' / 'u' hex hex hex hex) / [^\'\\])* "'" <String>
+    end
+    
+    rule number
+      "-"? ("0" / [1-9] digit*) ("." digit+)? ([eE] [+-]? digit+)? <Number>
+    end
+    
+    rule digit
+      [0-9]
+    end
+    
+    rule boolean
+      (true / false) <Boolean>
+    end
+    
+    rule true
+      "true" <True>
+    end
+    
+    rule false
+      "false" <False>
+    end
+    
+    rule null
+      "null" <Null>
+    end
+    
+    rule space
+      " "*
+    end
+    
+    rule query
+      identifier filter* <Query>
+    end
+    
+    rule identifier
+      (root / current / symbol) <Identifier>
+    end
+    
+    rule root
+      "$" <Root>
+    end
+    
+    rule current
+      "@" <Current>
+    end
+    
+    rule symbol
+      [A-Za-z$_] [A-Za-z0-9$_]* <Symbol>
+    end
+    
+    rule filter
+      (slice_access / recursive_access / field_access / boolean_filter / map_filter / sort_filter) <Filter>
+    end
+    
+    rule slice_access
+      "[" head:number ":" tail:number step:(":" number)? "]" <SliceAccess>
+    end
+    
+    rule recursive_access
+      ".." symbol <RecursiveAccess>
+    end
+    
+    rule field_access
+      ("." (symbol / all) / "[" (field_access_expression / all) "]") <FieldAccess>
+    end
+    
+    rule field_access_expression
+      first:expression others:("," expression)* <FieldAccessExpression>
+    end
+    
+    rule all
+      "*" <AllFilter>
+    end
+    
+    rule boolean_filter
+      recursive:".."? "[?" boolean_expression "]" <BooleanFilter>
+    end
+    
+    rule map_filter
+      "[=" expression "]" <MapFilter>
+    end
+    
+    rule sort_filter
+      "[" first:(sorter expression) others:("," sorter expression)* "]" <SortFilter>
+    end
+    
+    rule sorter
+      space ("/" / "\\") space <Sorter>
+    end
+  end
+end
+

data/lib/siren/json_query_nodes.rb

@@ -0,0 +1,333 @@
+module Siren
+  module JsonQuery
+    
+    module Query
+      def value(root, symbols, current = nil)
+        object = identifier.value(root, symbols, current)
+        filters.inject(object) { |value, filter| filter.value(value, root, symbols, current) }
+      end
+      
+      def filters
+        elements[1].elements
+      end
+    end
+    
+    module Identifier
+    end
+    
+    module Root
+      def value(root, symbols, current = nil)
+        root
+      end
+    end
+    
+    module Current
+      def value(root, symbols, current = nil)
+        current
+      end
+    end
+    
+    module Symbol
+      def value(root, symbols, current = nil)
+        symbols[text_value] || FieldAccess.access(current, text_value)
+      end
+    end
+    
+    module Filter
+    end
+    
+    module SliceAccess
+      def value(object, root, symbols, current = nil)
+        a, b = *[head, tail].map { |x| x.value(root, symbols, current) }
+        s = step.respond_to?(:number) ? step.number.value(root, symbols, current) : 1
+        result = []
+        while a <= b
+          result << object[a]
+          a += s
+        end
+        result
+      end
+    end
+    
+    module RecursiveAccess
+      def value(object, root, symbols, current = nil)
+        name = elements[1].text_value
+        results, visited = [], Set.new
+        
+        visitor = lambda do |visitee|
+          return unless visited.add?(visitee)
+          Siren.each(visitee) do |index, value|
+            results << value if index == name
+            visitor.call(value)
+          end
+        end
+        
+        visitor.call(object)
+        results
+      end
+    end
+    
+    module FieldAccess
+      def index(object, root, symbols, current = nil)
+        element = elements[1]
+        return [element.text_value] if Symbol === element
+        element.value(root, symbols, object)
+      end
+      
+      def value(object, root, symbols, current = nil)
+        indexes = index(object, root, symbols, current)
+        indexes.size == 1 ?
+            FieldAccess.access(object, indexes.first) :
+            indexes.map { |i| FieldAccess.access(object, i) }
+      end
+      
+      def self.access(object, index)
+        return (Hash === object ? object.values : object) if index == :*
+        return object[index] if Array === object and Numeric === index
+        
+        if Hash === object
+          key = [index, index.to_s, index.to_sym].find { |i| object.has_key?(i) }
+          return object[key] if key
+        end
+        
+        return object.__send__(index) if object.respond_to?(index)
+        object.instance_variable_get("@#{ index }")
+      end
+    end
+    
+    module FieldAccessExpression
+      def value(root, symbols, current = nil)
+        exprs = [first] + others.elements.map { |e| e.expression }
+        exprs.map { |e| e.value(root, symbols, current) }
+      end
+    end
+    
+    module AllFilter
+      def value(root, symbols, current = nil)
+        [:*]
+      end
+    end
+    
+    module BooleanFilter
+      def value(list, root, symbols, current = nil)
+        results, visited = [], Set.new
+        
+        visitor = lambda do |visitee|
+          return unless visited.add?(visitee)
+          Siren.each(visitee) do |index, value|
+            begin
+              results << value if boolean_expression.value(root, symbols, value)
+            rescue
+            end
+            visitor.call(value) if recursive.text_value == '..'
+          end
+        end
+        
+        visitor.call(list)
+        results
+      end
+    end
+    
+    module MapFilter
+      def value(list, root, symbols, current = nil)
+        list.map do |object|
+          expression.value(root, symbols, object)
+        end
+      end
+    end
+    
+    module SortFilter
+      def value(list, root, symbols, current = nil)
+        sorters = [[first.expression, first.sorter]] +
+                  others.elements.map { |e| [e.expression, e.sorter] }
+        
+        list.sort do |a, b|
+          sorters.inject(0) do |outcome, sorter|
+            if outcome.nonzero?
+              outcome
+            else
+              f, g = sorter[0].value(root, symbols, a), sorter[0].value(root, symbols, b)
+              sorter[1].value * (f <=> g)
+            end
+          end
+        end
+      end
+    end
+    
+    module Sorter
+      ORDERS = {"/" => 1, "\\" => -1}
+      
+      def value
+        ORDERS[elements[1].text_value]
+      end
+    end
+    
+    module And
+      def value(root, symbols, current = nil)
+        first.value(root, symbols, current) && second.value(root, symbols, current)
+      end
+    end
+    
+    module Or
+      def value(root, symbols, current = nil)
+        first.value(root, symbols, current) || second.value(root, symbols, current)
+      end
+    end
+    
+    module Comparison
+      def value(root, symbols, current = nil)
+        comparator.value(first.value(root, symbols, current), second.value(root, symbols, current))
+      end
+    end
+    
+    module BooleanAtom
+      def value(root, symbols, current = nil)
+        element = elements[1]
+        return element.boolean_expression.value(root, symbols, current) if element.respond_to?(:boolean_expression)
+        element.value(root, symbols, current)
+      end
+    end
+    
+    module Divmod
+      def value(root, symbols, current = nil)
+        first.value(root, symbols, current) % second.value(root, symbols, current)
+      end
+    end
+    
+    module Product
+      def value(root, symbols, current = nil)
+        operator.value(first.value(root, symbols, current), second.value(root, symbols, current))
+      end
+    end
+    
+    module Sum
+      def value(root, symbols, current = nil)
+        operator.value(first.value(root, symbols, current), second.value(root, symbols, current))
+      end
+    end
+    
+    module Atom
+      def value(root, symbols, current = nil)
+        element = elements[1]
+        return element.expression.value(root, symbols, current) if element.respond_to?(:expression)
+        element.value(root, symbols, current)
+      end
+    end
+    
+    module Multiplication
+      def value(expr1, expr2)
+        expr1 * expr2
+      end
+    end
+    
+    module Division
+      def value(expr1, expr2)
+        expr1 / expr2
+      end
+    end
+    
+    module Addition
+      def value(expr1, expr2)
+        String === expr1 || String === expr2 ?
+            expr1.to_s + expr2.to_s :
+            expr1 + expr2
+      end
+    end
+    
+    module Subtraction
+      def value(expr1, expr2)
+        expr1 - expr2
+      end
+    end
+    
+    module Comparator
+    end
+    
+    module Equal
+      def value(expr1, expr2)
+        return expr1 == expr2 unless expr2.respond_to?(:gsub)
+        expr1 =~ %r{^#{Match.convert(expr2)}$}
+      end
+    end
+    
+    module Match
+      def value(expr1, expr2)
+        return expr1 == expr2 unless expr2.respond_to?(:gsub)
+        expr1 =~ %r{^#{Match.convert(expr2)}$}i
+      end
+      
+      def self.convert(string)
+        string.gsub(/([\.\+\[\]\{\}\(\)\^\$])/) { "\\#{$1}" }.
+               gsub('*', '.*').gsub('?', '.')
+      end
+    end
+    
+    module NotEqual
+      def value(expr1, expr2)
+        expr1 != expr2
+      end
+    end
+    
+    module LessThan
+      def value(expr1, expr2)
+        expr1 < expr2
+      end
+    end
+    
+    module LessThanOrEqual
+      def value(expr1, expr2)
+        expr1 <= expr2
+      end
+    end
+    
+    module GreaterThan
+      def value(expr1, expr2)
+        expr1 > expr2
+      end
+    end
+    
+    module GreaterThanOrEqual
+      def value(expr1, expr2)
+        expr1 >= expr2
+      end
+    end
+    
+    module String
+      def value(root, symbols, current = nil)
+        @value ||= eval(text_value)
+      end
+    end
+    
+    module Number
+      def value(root, symbols, current = nil)
+        @value ||= eval(text_value)
+      end
+    end
+    
+    module Boolean
+      def value(root, symbols, current = nil)
+        data.value
+      end
+    end
+    
+    module True
+      def value(root, symbols, current = nil)
+        true
+      end
+    end
+    
+    module False
+      def value(root, symbols, current = nil)
+        false
+      end
+    end
+    
+    module Null
+      def value(root, symbols, current = nil)
+        nil
+      end
+    end
+    
+  end
+end
+