gql 0.0.1

data/lib/gql/executor.rb

@@ -0,0 +1,18 @@
+module GQL
+  class Executor
+    def initialize(ast_root)
+      @ast_root = ast_root
+      @variables = ast_root.variables
+    end
+
+    def execute(context = {})
+      root_class = Schema.root
+
+      raise Errors::UndefinedRoot if root_class.nil?
+      raise Errors::InvalidNodeClass.new(root_class, Node) unless root_class < Node
+
+      root = root_class.new(@ast_root, nil, @variables, context)
+      root.__value
+    end
+  end
+end

data/lib/gql/field.rb

@@ -0,0 +1,7 @@
+module GQL
+  class Field < Node
+    def __raw_value
+      __target
+    end
+  end
+end

data/lib/gql/fields/boolean.rb

@@ -0,0 +1,6 @@
+module GQL
+  module Fields
+    class Boolean < Field
+    end
+  end
+end

data/lib/gql/fields/connection.rb

@@ -0,0 +1,29 @@
+module GQL
+  module Fields
+    class Connection < Field
+      def __value
+        if @ast_node.fields
+          __raw_value
+        else
+          super
+        end
+      end
+
+      def __raw_value
+        raise Errors::InvalidNodeClass.new(__connection_class__, GQL::Connection) unless __connection_class__ < GQL::Connection
+
+        connection = __connection_class__.new(__node_class__, @ast_node, __target, @variables, __context)
+        connection.__value
+      end
+
+      private
+        def __connection_class__
+          self.class.const_get :CONNECTION_CLASS
+        end
+
+        def __node_class__
+          self.class.const_get :NODE_CLASS
+        end
+    end
+  end
+end

data/lib/gql/fields/float.rb

@@ -0,0 +1,6 @@
+module GQL
+  module Fields
+    class Float < Field
+    end
+  end
+end

data/lib/gql/fields/integer.rb

@@ -0,0 +1,10 @@
+module GQL
+  module Fields
+    class Integer < Field
+      # This is just an example call, monkeypatch to add your own.
+      call :is_zero, returns: Boolean do
+        target.zero?
+      end
+    end
+  end
+end

data/lib/gql/fields/object.rb

@@ -0,0 +1,17 @@
+module GQL
+  module Fields
+    class Object < Field
+      def __value
+        raise Errors::InvalidNodeClass.new(__node_class__, Node) unless __node_class__ < Node
+
+        node = __node_class__.new(@ast_node, __target, @variables, __context)
+        node.__value
+      end
+
+      private
+        def __node_class__
+          self.class.const_get :NODE_CLASS
+        end
+    end
+  end
+end

data/lib/gql/fields/string.rb

@@ -0,0 +1,19 @@
+module GQL
+  module Fields
+    class String < Field
+      call :upcase do
+        target.upcase
+      end
+
+      call :downcase do
+        target.downcase
+      end
+
+      call :length, returns: Integer do
+        target.size
+      end
+
+      # These are just example calls, monkeypatch to add your own.
+    end
+  end
+end

data/lib/gql/node.rb

@@ -0,0 +1,121 @@
+require 'active_support/core_ext/class/attribute'
+require 'active_support/core_ext/string/inflections'
+
+module GQL
+  class Node
+    class_attribute :call_definitions
+    self.call_definitions = {}
+
+    class_attribute :field_classes
+    self.field_classes = {}
+
+    class << self
+      def cursor(method_name)
+        define_method :cursor do
+          __target.send(method_name).to_s
+        end
+      end
+
+      def call(name, options = {}, &block)
+        definition = {
+          returns: options[:returns],
+          body: block || lambda { |*args| __target.public_send(name, *args) }
+        }
+
+        self.call_definitions = call_definitions.merge(name => definition)
+      end
+
+      def fields(&block)
+        instance_eval &block
+      end
+
+      def field(*names, base_class: nil, node_class: nil, connection_class: nil)
+        classes = names.reduce({}) do |result, name|
+          field_class = Class.new(base_class || Field)
+          field_class.const_set :NAME, name
+          field_class.const_set :NODE_CLASS, node_class
+          field_class.const_set :CONNECTION_CLASS, connection_class
+
+          self.const_set "#{name.to_s.camelize}Field", field_class
+
+          result.merge name => field_class
+        end
+
+        self.field_classes = field_classes.merge(classes)
+      end
+
+      def method_missing(method, *args, &block)
+        if base_class = Schema.fields[method]
+          options = args.extract_options!
+
+          field(*args, options.merge(base_class: base_class))
+        else
+          super
+        end
+      rescue NoMethodError => exc
+        raise Errors::UndefinedType, method
+      end
+    end
+
+    call :_identity do
+      target
+    end
+
+    attr_reader :__target, :__context
+
+    def initialize(ast_node, target, variables, context)
+      @ast_node, @__target = ast_node, target
+      @variables, @__context = variables, context
+    end
+
+    def __value
+      if ast_call = @ast_node.call
+        definition = self.class.call_definitions[ast_call.name]
+
+        raise Errors::UndefinedCall.new(ast_call.name, self.class) if definition.nil?
+
+        call = Call.new(self, ast_call, __target, definition, @variables, __context)
+        call.execute
+      elsif ast_fields = @ast_node.fields
+        ast_fields.reduce({}) do |memo, ast_field|
+          key = ast_field.alias_name || ast_field.name
+
+          val =
+            case key
+            when :node
+              field = self.class.new(ast_field, __target, @variables, __context)
+              field.__value
+            when :cursor
+              cursor
+            else
+              target = public_send(ast_field.name)
+              field_class = self.class.field_classes[ast_field.name]
+
+              raise Errors::InvalidNodeClass.new(field_class.superclass, Field) unless field_class < Field
+
+              field = field_class.new(ast_field, target, @variables, __context)
+              field.__value
+            end
+
+          memo.merge key => val
+        end
+      else
+        __raw_value
+      end
+    end
+
+    def __raw_value
+      nil
+    end
+
+    def method_missing(method, *args, &block)
+      if __target.respond_to? method
+        __target.public_send method, *args, &block
+      else
+        super
+      end
+    rescue NoMethodError => exc
+      raise Errors::UndefinedField.new(method, self.class)
+    end
+  end
+end

data/lib/gql/parser.rb

@@ -0,0 +1,704 @@
+#
+# DO NOT MODIFY!!!!
+# This file is automatically generated by Racc 1.4.12
+# from Racc grammer file "".
+#
+
+require 'racc/parser.rb'
+
+
+require 'json'
+require 'active_support/core_ext/object/blank'
+
+module GQL
+  class Parser < Racc::Parser
+
+module_eval(<<'...end parser.y/module_eval...', 'parser.y', 145)
+
+  class QueryNode < Struct.new(:call, :variables)
+  end
+
+  class FieldNode < Struct.new(:name, :alias_name, :call, :fields)
+  end
+
+  class CallNode < Struct.new(:name, :arguments, :call, :fields)
+  end
+
+  class JSONHandler
+    attr_reader :stack
+
+    def initialize
+      clear
+    end
+
+    def start_object
+      push [:hash]
+    end
+
+    def start_array
+      push [:array]
+    end
+
+    def end_array
+      @stack.pop
+    end
+
+    alias :end_object :end_array
+
+    def scalar(s)
+      @stack.last << [:scalar, s]
+    end
+
+    def push(o)
+      @stack.last << o
+      @stack << o
+    end
+
+    def result
+      root = @stack.first.last
+      value = process(root.first, root.drop(1))
+      clear
+      value
+    end
+
+    private
+      def clear
+        @stack = [[:json]]
+      end
+
+      def process(type, rest)
+        case type
+        when :array
+          rest.map { |x| process(x.first, x.drop(1)) }
+        when :hash
+          Hash[rest.map { |x|
+            process(x.first, x.drop(1))
+          }.each_slice(2).to_a]
+        when :scalar
+          rest.first
+        end
+      end
+  end
+
+  UNESCAPE_MAP = Hash.new { |h, k| h[k] = k.chr }
+
+  UNESCAPE_MAP.update(
+    ?"  => '"',
+    ?\\ => '\\',
+    ?/  => '/',
+    ?b  => "\b",
+    ?f  => "\f",
+    ?n  => "\n",
+    ?r  => "\r",
+    ?t  => "\t",
+    ?u  => nil,
+  )
+
+  EMPTY_8BIT_STRING = ''
+
+  if String.method_defined? :encode
+    EMPTY_8BIT_STRING.force_encoding Encoding::ASCII_8BIT
+  end
+
+  def initialize(tokenizer)
+    super()
+
+    @tokenizer = tokenizer
+  end
+
+  def next_token
+    @tokenizer.next_token
+  end
+
+  def parse
+    @json = JSONHandler.new
+    do_parse
+  end
+
+  def on_error(token, value, vstack)
+    raise Errors::ParseError.new(value, token_to_str(token))
+  end
+
+  private
+    def unescape_string(str)
+      string = str.gsub(%r((?:\\[\\bfnrt"/]|(?:\\u(?:[A-Fa-f\d]{4}))+|\\[\x20-\xff]))n) do |c|
+        if u = UNESCAPE_MAP[$&[1]]
+          u
+        else # \uXXXX
+          bytes = EMPTY_8BIT_STRING.dup
+          i = 0
+
+          while c[6 * i] == ?\\ && c[6 * i + 1] == ?u
+            bytes << c[6 * i + 2, 2].to_i(16) << c[6 * i + 4, 2].to_i(16)
+            i += 1
+          end
+
+          JSON.iconv('utf-8', 'utf-16be', bytes)
+        end
+      end
+
+      if string.respond_to? :force_encoding
+        string.force_encoding ::Encoding::UTF_8
+      end
+
+      string
+    end
+
+    def convert_number(str)
+      str.count('.') > 0 ? str.to_f : str.to_i
+    end
+
+    def convert_variables(arr1, arr2)
+      Hash[*arr1.flatten(1)].merge Hash[*arr2.flatten(1)]
+    end
+...end parser.y/module_eval...
+##### State transition tables begin ###
+
+racc_action_table = [
+    30,    31,    32,    33,    34,    30,    31,    32,    33,    34,
+    38,    25,    65,     6,    39,    10,    25,    27,    52,    30,
+    52,    55,    27,    30,    31,    32,    33,    34,    62,     7,
+    47,    47,    40,    71,    25,    38,    67,     6,    66,    39,
+    27,    30,    31,    32,    33,    34,    30,    31,    32,    33,
+    34,    10,    25,    59,    60,     6,     6,    25,    27,    12,
+    10,    14,     6,    27,    30,    31,    32,    33,    34,    17,
+    35,    10,    63,    30,    10,    25,    71,    71,    10,   nil,
+   nil,    27 ]
+
+racc_action_check = [
+    26,    26,    26,    26,    26,    12,    12,    12,    12,    12,
+    16,    26,    51,     0,    16,    39,    12,    26,    26,    24,
+    51,    39,    12,    17,    17,    17,    17,    17,    46,     1,
+    46,    24,    17,    58,    17,    58,    56,    17,    56,    58,
+    17,    60,    60,    60,    60,    60,    63,    63,    63,    63,
+    63,     2,    60,    41,    41,    60,     3,    63,    60,     5,
+     6,     7,     8,    63,    65,    65,    65,    65,    65,     9,
+    13,    38,    49,    62,    67,    65,    68,    69,    71,   nil,
+   nil,    65 ]
+
+racc_action_pointer = [
+    -3,    29,    43,    40,   nil,    44,    52,    61,    46,    59,
+   nil,   nil,     3,    53,   nil,   nil,     1,    21,   nil,   nil,
+   nil,   nil,   nil,   nil,    17,   nil,    -2,   nil,   nil,   nil,
+   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,    63,     7,
+   nil,    42,   nil,   nil,   nil,   nil,    16,   nil,   nil,    54,
+   nil,     0,   nil,   nil,   nil,   nil,    24,   nil,    26,   nil,
+    39,   nil,    71,    44,   nil,    62,   nil,    66,    69,    70,
+   nil,    70,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil ]
+
+racc_action_default = [
+   -24,   -56,   -56,   -25,   -26,   -56,   -56,   -56,   -24,    -6,
+   -55,   -27,   -56,   -56,    80,    -1,    -4,   -56,   -28,   -30,
+   -31,   -32,   -33,   -34,   -56,   -37,   -56,   -44,   -48,   -49,
+   -50,   -51,   -52,   -53,   -54,   -29,    -2,    -3,   -56,   -56,
+    -7,   -56,   -10,   -11,   -12,   -35,   -56,   -38,   -40,   -56,
+   -42,   -56,   -45,   -47,    -5,   -13,   -56,   -16,   -22,    -8,
+   -56,   -36,   -56,   -56,   -43,   -56,   -14,   -56,   -20,   -21,
+   -19,   -56,    -9,   -39,   -41,   -46,   -15,   -17,   -18,   -23 ]
+
+racc_goto_table = [
+    13,    42,    43,    53,    36,    37,    57,     8,    45,    70,
+    48,    49,    50,     2,     1,    16,    41,    19,    56,    77,
+    78,    15,    11,    18,    46,    51,   nil,   nil,   nil,   nil,
+    61,   nil,   nil,    58,    76,   nil,   nil,    64,   nil,   nil,
+    74,   nil,    75,    54,    72,    43,    68,    69,    73,    49,
+   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,
+   nil,    58,   nil,   nil,   nil,    79 ]
+
+racc_goto_check = [
+     4,     9,    10,    18,     6,     7,    13,     3,    23,    14,
+    25,    26,    28,     2,     1,     5,     8,    11,    12,    14,
+    14,     2,    16,    17,    24,    29,   nil,   nil,   nil,   nil,
+    23,   nil,   nil,     4,    13,   nil,   nil,    28,   nil,   nil,
+    18,   nil,    18,     3,     9,    10,     6,     7,    25,    26,
+   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,
+   nil,     4,   nil,   nil,   nil,     4 ]
+
+racc_goto_pointer = [
+   nil,    14,    13,     5,    -6,     6,   -12,   -11,    -1,   -16,
+   -15,     5,   -21,   -33,   -49,   nil,    19,    11,   -23,   nil,
+   nil,   nil,   nil,   -16,     0,   -14,   -13,   nil,   -14,    -1,
+   nil ]
+
+racc_goto_default = [
+   nil,   nil,   nil,   nil,     9,   nil,   nil,   nil,   nil,   nil,
+     5,    44,   nil,   nil,   nil,     3,     4,   nil,    20,    21,
+    22,    23,    24,   nil,   nil,   nil,    28,    26,   nil,   nil,
+    29 ]
+
+racc_reduce_table = [
+  0, 0, :racc_error,
+  3, 22, :_reduce_1,
+  3, 24, :_reduce_2,
+  3, 24, :_reduce_3,
+  2, 24, :_reduce_4,
+  2, 28, :_reduce_5,
+  0, 26, :_reduce_6,
+  2, 26, :_reduce_7,
+  3, 26, :_reduce_8,
+  3, 29, :_reduce_9,
+  1, 29, :_reduce_10,
+  1, 30, :_reduce_none,
+  1, 30, :_reduce_none,
+  2, 27, :_reduce_13,
+  3, 27, :_reduce_14,
+  3, 33, :_reduce_15,
+  1, 33, :_reduce_16,
+  3, 34, :_reduce_17,
+  3, 34, :_reduce_18,
+  2, 34, :_reduce_19,
+  2, 34, :_reduce_20,
+  2, 34, :_reduce_21,
+  1, 34, :_reduce_22,
+  2, 35, :_reduce_23,
+  0, 23, :_reduce_24,
+  1, 23, :_reduce_25,
+  1, 36, :_reduce_26,
+  2, 36, :_reduce_27,
+  3, 37, :_reduce_28,
+  3, 31, :_reduce_29,
+  1, 38, :_reduce_none,
+  1, 32, :_reduce_31,
+  1, 39, :_reduce_none,
+  1, 39, :_reduce_none,
+  1, 39, :_reduce_none,
+  2, 40, :_reduce_none,
+  3, 40, :_reduce_none,
+  1, 43, :_reduce_37,
+  1, 44, :_reduce_38,
+  3, 45, :_reduce_none,
+  1, 45, :_reduce_none,
+  3, 46, :_reduce_none,
+  2, 41, :_reduce_none,
+  3, 41, :_reduce_none,
+  1, 48, :_reduce_44,
+  1, 49, :_reduce_45,
+  3, 50, :_reduce_none,
+  1, 50, :_reduce_none,
+  1, 42, :_reduce_none,
+  1, 42, :_reduce_49,
+  1, 47, :_reduce_50,
+  1, 51, :_reduce_51,
+  1, 51, :_reduce_52,
+  1, 51, :_reduce_53,
+  1, 51, :_reduce_54,
+  1, 25, :_reduce_55 ]
+
+racc_reduce_n = 56
+
+racc_shift_n = 80
+
+racc_token_table = {
+  false => 0,
+  :error => 1,
+  :STRING => 2,
+  :NUMBER => 3,
+  :TRUE => 4,
+  :FALSE => 5,
+  :NULL => 6,
+  :AS => 7,
+  :IDENT => 8,
+  "." => 9,
+  "(" => 10,
+  ")" => 11,
+  "," => 12,
+  "{" => 13,
+  "}" => 14,
+  "=" => 15,
+  "<" => 16,
+  ">" => 17,
+  ":" => 18,
+  "[" => 19,
+  "]" => 20 }
+
+racc_nt_base = 21
+
+racc_use_result_var = true
+
+Racc_arg = [
+  racc_action_table,
+  racc_action_check,
+  racc_action_default,
+  racc_action_pointer,
+  racc_goto_table,
+  racc_goto_check,
+  racc_goto_default,
+  racc_goto_pointer,
+  racc_nt_base,
+  racc_reduce_table,
+  racc_token_table,
+  racc_shift_n,
+  racc_reduce_n,
+  racc_use_result_var ]
+
+Racc_token_to_s_table = [
+  "$end",
+  "error",
+  "STRING",
+  "NUMBER",
+  "TRUE",
+  "FALSE",
+  "NULL",
+  "AS",
+  "IDENT",
+  "\".\"",
+  "\"(\"",
+  "\")\"",
+  "\",\"",
+  "\"{\"",
+  "\"}\"",
+  "\"=\"",
+  "\"<\"",
+  "\">\"",
+  "\":\"",
+  "\"[\"",
+  "\"]\"",
+  "$start",
+  "query",
+  "variables",
+  "call",
+  "identifier",
+  "arguments",
+  "fields",
+  "sub_call",
+  "argument_list",
+  "argument",
+  "variable_identifier",
+  "json_text",
+  "field_list",
+  "field",
+  "alias_identifier",
+  "variable_list",
+  "variable",
+  "variable_value",
+  "json_value",
+  "object",
+  "array",
+  "scalar",
+  "start_object",
+  "end_object",
+  "pairs",
+  "pair",
+  "string",
+  "start_array",
+  "end_array",
+  "values",
+  "literal" ]
+
+Racc_debug_parser = false
+
+##### State transition tables end #####
+
+# reduce 0 omitted
+
+module_eval(<<'.,.,', 'parser.y', 4)
+  def _reduce_1(val, _values, result)
+      result = QueryNode.new(val[1], convert_variables(val[0], val[2]))  
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'parser.y', 8)
+  def _reduce_2(val, _values, result)
+       result = CallNode.new(val[0], val[1], nil, val[2].presence)   
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'parser.y', 9)
+  def _reduce_3(val, _values, result)
+       result = CallNode.new(val[0], val[1], val[2], nil)            
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'parser.y', 10)
+  def _reduce_4(val, _values, result)
+       result = CallNode.new(val[0], val[1], nil, nil)               
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'parser.y', 14)
+  def _reduce_5(val, _values, result)
+       result = val[1]   
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'parser.y', 18)
+  def _reduce_6(val, _values, result)
+       result = []       
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'parser.y', 19)
+  def _reduce_7(val, _values, result)
+       result = []       
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'parser.y', 20)
+  def _reduce_8(val, _values, result)
+       result = val[1]   
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'parser.y', 24)
+  def _reduce_9(val, _values, result)
+       result.push val[2]    
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'parser.y', 25)
+  def _reduce_10(val, _values, result)
+       result = val          
+    result
+  end
+.,.,
+
+# reduce 11 omitted
+
+# reduce 12 omitted
+
+module_eval(<<'.,.,', 'parser.y', 34)
+  def _reduce_13(val, _values, result)
+       result = []       
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'parser.y', 35)
+  def _reduce_14(val, _values, result)
+       result = val[1]   
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'parser.y', 39)
+  def _reduce_15(val, _values, result)
+       result.push val[2]    
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'parser.y', 40)
+  def _reduce_16(val, _values, result)
+       result = val          
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'parser.y', 44)
+  def _reduce_17(val, _values, result)
+       result = FieldNode.new(val[0], val[2], nil,    val[1].presence)   
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'parser.y', 45)
+  def _reduce_18(val, _values, result)
+       result = FieldNode.new(val[0], val[2], val[1], nil)               
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'parser.y', 46)
+  def _reduce_19(val, _values, result)
+       result = FieldNode.new(val[0], val[1], nil,    nil)               
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'parser.y', 47)
+  def _reduce_20(val, _values, result)
+       result = FieldNode.new(val[0], nil,    nil,    val[1].presence)   
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'parser.y', 48)
+  def _reduce_21(val, _values, result)
+       result = FieldNode.new(val[0], nil,    val[1], nil)               
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'parser.y', 49)
+  def _reduce_22(val, _values, result)
+       result = FieldNode.new(val[0], nil,    nil,    nil)               
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'parser.y', 53)
+  def _reduce_23(val, _values, result)
+       result = val[1]       
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'parser.y', 57)
+  def _reduce_24(val, _values, result)
+       result = []           
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'parser.y', 58)
+  def _reduce_25(val, _values, result)
+       result = val[0]       
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'parser.y', 62)
+  def _reduce_26(val, _values, result)
+       result = val 
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'parser.y', 63)
+  def _reduce_27(val, _values, result)
+       result.push val[1]    
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'parser.y', 67)
+  def _reduce_28(val, _values, result)
+       result = [val[0], val[2]]     
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'parser.y', 71)
+  def _reduce_29(val, _values, result)
+       result = val[1]   
+    result
+  end
+.,.,
+
+# reduce 30 omitted
+
+module_eval(<<'.,.,', 'parser.y', 79)
+  def _reduce_31(val, _values, result)
+       result = @json.result   
+    result
+  end
+.,.,
+
+# reduce 32 omitted
+
+# reduce 33 omitted
+
+# reduce 34 omitted
+
+# reduce 35 omitted
+
+# reduce 36 omitted
+
+module_eval(<<'.,.,', 'parser.y', 92)
+  def _reduce_37(val, _values, result)
+       @json.start_object    
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'parser.y', 93)
+  def _reduce_38(val, _values, result)
+       @json.end_object      
+    result
+  end
+.,.,
+
+# reduce 39 omitted
+
+# reduce 40 omitted
+
+# reduce 41 omitted
+
+# reduce 42 omitted
+
+# reduce 43 omitted
+
+module_eval(<<'.,.,', 'parser.y', 109)
+  def _reduce_44(val, _values, result)
+       @json.start_array     
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'parser.y', 110)
+  def _reduce_45(val, _values, result)
+       @json.end_array       
+    result
+  end
+.,.,
+
+# reduce 46 omitted
+
+# reduce 47 omitted
+
+# reduce 48 omitted
+
+module_eval(<<'.,.,', 'parser.y', 119)
+  def _reduce_49(val, _values, result)
+       @json.scalar val[0]   
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'parser.y', 123)
+  def _reduce_50(val, _values, result)
+       @json.scalar unescape_string(val[0])   
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'parser.y', 127)
+  def _reduce_51(val, _values, result)
+       result = convert_number(val[0])   
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'parser.y', 128)
+  def _reduce_52(val, _values, result)
+       result = true                     
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'parser.y', 129)
+  def _reduce_53(val, _values, result)
+       result = false                    
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'parser.y', 130)
+  def _reduce_54(val, _values, result)
+       result = nil                      
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'parser.y', 134)
+  def _reduce_55(val, _values, result)
+       result = val[0].to_sym    
+    result
+  end
+.,.,
+
+def _reduce_none(val, _values, result)
+  val[0]
+end
+
+  end   # class Parser
+  end   # module GQL