jnunemaker-siren 0.1.1

data/lib/json_query.tt

@@ -0,0 +1,162 @@
+grammar JsonQuery
+  rule expression
+    additive / multiplicative / atom
+  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
+    (field_access / boolean_filter / map_filter / sort_filter) <Filter>
+  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
+    "[?" boolean_expression "]" <BooleanFilter>
+  end
+  
+  rule map_filter
+    "[=" expression "]" <MapFilter>
+  end
+  
+  rule sort_filter
+    "[" sorter expression "]" <SortFilter>
+  end
+  
+  rule sorter
+    space ("/" / "\\") space <Sorter>
+  end
+  
+  rule boolean_expression
+    or_expression / and_expression / boolean_atom
+  end
+  
+  rule or_expression
+    first:and_expression "|" second:or_expression <Or> / and_expression
+  end
+  
+  rule and_expression
+    first:boolean_atom "&" second:and_expression <And> / boolean_atom
+  end
+  
+  rule boolean_atom
+    space ("(" boolean_expression ")" / first:expression comparator second:expression) space <BooleanAtom>
+  end
+  
+  rule additive
+    first:multiplicative operator:(add / subtract) second:additive <Additive> / multiplicative
+  end
+  
+  rule multiplicative
+    first:atom operator:(times / divide) second:multiplicative <Multiplicative> / 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 / lt / gt) <Comparator>
+  end
+  
+  rule equal
+    "=" <Equal>
+  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
+end
+

data/lib/json_query/nodes.rb

@@ -0,0 +1,260 @@
+module JsonQuery
+  
+  class Query < Treetop::Runtime::SyntaxNode
+    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
+  
+  class Root < Treetop::Runtime::SyntaxNode
+    def value(root, symbols, current = nil)
+      root
+    end
+  end
+  
+  class Current < Treetop::Runtime::SyntaxNode
+    def value(root, symbols, current = nil)
+      current
+    end
+  end
+  
+  class Symbol < Treetop::Runtime::SyntaxNode
+    def value(root, symbols, current = nil)
+      symbols[text_value] || FieldAccess.access(current, text_value)
+    end
+  end
+  
+  module Filter
+  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
+  
+  class FieldAccessExpression < Treetop::Runtime::SyntaxNode
+    def value(root, symbols, current = nil)
+      exprs = [first] + others.elements.map { |e| e.expression }
+      exprs.map { |e| e.value(root, symbols, current) }
+    end
+  end
+  
+  class AllFilter < Treetop::Runtime::SyntaxNode
+    def value(root, symbols, current = nil)
+      [:*]
+    end
+  end
+  
+  class BooleanFilter < Treetop::Runtime::SyntaxNode
+    def value(list, root, symbols, current = nil)
+      list.select do |object|
+        boolean_expression.value(root, symbols, object)
+      end
+    end
+  end
+  
+  class MapFilter < Treetop::Runtime::SyntaxNode
+    def value(list, root, symbols, current = nil)
+      list.map do |object|
+        expression.value(root, symbols, object)
+      end
+    end
+  end
+  
+  class SortFilter < Treetop::Runtime::SyntaxNode
+    def value(list, root, symbols, current = nil)
+      result = list.sort_by { |object| expression.value(root, symbols, object) }
+      result.reverse! if sorter.text_value == "\\"
+      result
+    end
+  end
+  
+  class Sorter < Treetop::Runtime::SyntaxNode
+  end
+  
+  class And < Treetop::Runtime::SyntaxNode
+    def value(root, symbols, current = nil)
+      first.value(root, symbols, current) && second.value(root, symbols, current)
+    end
+  end
+  
+  class Or < Treetop::Runtime::SyntaxNode
+    def value(root, symbols, current = nil)
+      first.value(root, symbols, current) || second.value(root, symbols, current)
+    end
+  end
+  
+  class BooleanAtom < Treetop::Runtime::SyntaxNode
+    def value(root, symbols, current = nil)
+      element = elements[1]
+      return element.boolean_expression.value(root, symbols, current) if element.respond_to?(:boolean_expression)
+      comparator.value(first.value(root, symbols, current), second.value(root, symbols, current))
+    end
+    
+    def comparator
+      elements[1].comparator
+    end
+    
+    def first
+      elements[1].first
+    end
+    
+    def second
+      elements[1].second
+    end
+  end
+  
+  class Multiplicative < Treetop::Runtime::SyntaxNode
+    def value(root, symbols, current = nil)
+      operator.value(first.value(root, symbols, current), second.value(root, symbols, current))
+    end
+  end
+  
+  class Additive < Treetop::Runtime::SyntaxNode
+    def value(root, symbols, current = nil)
+      operator.value(first.value(root, symbols, current), second.value(root, symbols, current))
+    end
+  end
+  
+  class Atom < Treetop::Runtime::SyntaxNode
+    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
+  
+  class Multiplication < Treetop::Runtime::SyntaxNode
+    def value(expr1, expr2)
+      expr1 * expr2
+    end
+  end
+  
+  class Division < Treetop::Runtime::SyntaxNode
+    def value(expr1, expr2)
+      expr1 / expr2
+    end
+  end
+  
+  class Addition < Treetop::Runtime::SyntaxNode
+    def value(expr1, expr2)
+      String === expr1 || String === expr2 ?
+          expr1.to_s + expr2.to_s :
+          expr1 + expr2
+    end
+  end
+  
+  class Subtraction < Treetop::Runtime::SyntaxNode
+    def value(expr1, expr2)
+      expr1 - expr2
+    end
+  end
+  
+  module Comparator
+  end
+  
+  class Equal < Treetop::Runtime::SyntaxNode
+    def value(expr1, expr2)
+      expr1 == expr2
+    end
+  end
+  
+  class NotEqual < Treetop::Runtime::SyntaxNode
+    def value(expr1, expr2)
+      expr1 != expr2
+    end
+  end
+  
+  class LessThan < Treetop::Runtime::SyntaxNode
+    def value(expr1, expr2)
+      expr1 < expr2
+    end
+  end
+  
+  class LessThanOrEqual < Treetop::Runtime::SyntaxNode
+    def value(expr1, expr2)
+      expr1 <= expr2
+    end
+  end
+  
+  class GreaterThan < Treetop::Runtime::SyntaxNode
+    def value(expr1, expr2)
+      expr1 > expr2
+    end
+  end
+  
+  class GreaterThanOrEqual < Treetop::Runtime::SyntaxNode
+    def value(expr1, expr2)
+      expr1 >= expr2
+    end
+  end
+  
+  class String < Treetop::Runtime::SyntaxNode
+    def value(root, symbols, current = nil)
+      @value ||= eval(text_value)
+    end
+  end
+  
+  class Number < Treetop::Runtime::SyntaxNode
+    def value(root, symbols, current = nil)
+      @value ||= eval(text_value)
+    end
+  end
+  
+  module Boolean
+    def value(root, symbols, current = nil)
+      data.value
+    end
+  end
+  
+  class True < Treetop::Runtime::SyntaxNode
+    def value(root, symbols, current = nil)
+      true
+    end
+  end
+  
+  class False < Treetop::Runtime::SyntaxNode
+    def value(root, symbols, current = nil)
+      false
+    end
+  end
+  
+  class Null < Treetop::Runtime::SyntaxNode
+    def value(root, symbols, current = nil)
+      nil
+    end
+  end
+  
+end
+

data/lib/siren.rb

@@ -0,0 +1,63 @@
+require 'rubygems'
+require 'treetop'
+
+%w(walker parser node reference observer).each do |path|
+  require File.dirname(__FILE__) + '/siren/' + path
+end
+%w(json json_query json_query/nodes).each do |path|
+  require File.dirname(__FILE__) + '/' + path
+end
+
+$p = JsonQueryParser.new
+
+class JsonParser
+  include Siren::Walker
+end
+
+module Siren  
+  TYPE_FIELD = "type"
+  ID_FIELD   = "id"
+  REF_FIELD  = "$ref"
+  
+  def self.parse(string, &block)
+    @json_parser ||= JsonParser.new
+    Reference.flush!
+    @symbols = {}
+    
+    result = @json_parser.parse(string).value rescue nil
+    
+    @json_parser.walk(result) do |holder, key, value|
+      if Hash === value && value[REF_FIELD]
+        value = Reference.new(value) do |ref, root, symbols|
+          holder[key] = ref.find(root, symbols, holder)
+        end
+      end
+      value
+    end
+    
+    @json_parser.walk(result) do |holder, key, value|
+      if Hash === value
+        id = value[ID_FIELD]
+        value = Node.from_json(value)
+        @symbols[id] = value
+      end
+      value
+    end
+    
+    Reference.resolve!(result, @symbols)
+    @json_parser.walk(result, &block) if block_given?
+    
+    result
+  end
+  
+  def self.query(expression, root)
+    compile_query(expression).value(root, @symbols ||{})
+  end
+  
+  def self.compile_query(expression)
+    @query_parser ||= JsonQueryParser.new
+    @query_cache  ||= {}
+    @query_cache[expression] ||= @query_parser.parse(expression)
+  end
+end
+