tinygql 0.1.3 → 0.2.0

data/lib/tinygql/nodes.yml

@@ -84,7 +84,7 @@ nodes:
   - name: Directive
     fields:
       - name: literal
-      - arguments: list
+      - arguments?: list
 
   - name: TypeCondition
     fields:
@@ -98,19 +98,19 @@ nodes:
 
   - name: FragmentSpread
     fields:
-      - fragment_name
+      - fragment_name: literal
       - directives?: list
 
   - name: FragmentDefinition
     fields:
-      - fragment_name
+      - fragment_name: literal
       - type_condition
       - directives?: list
       - selection_set: list
 
   - name: RootOperationTypeDefinition
     fields:
-      - operation_type
+      - operation_type: literal
       - named_type
 
   - name: SchemaDefinition
@@ -204,3 +204,33 @@ nodes:
       - name: literal
       - arguments_definition?: list
       - directive_locations: list
+
+  - name: ScalarTypeExtension
+    fields:
+      - name: literal
+      - directives?: list
+
+  - name: InterfaceTypeExtension
+    fields:
+      - name: literal
+      - implements_interfaces?: list
+      - directives?: list
+      - fields_definition?: list
+
+  - name: UnionTypeExtension
+    fields:
+      - name: literal
+      - directives?: list
+      - union_member_types?: list
+
+  - name: EnumTypeExtension
+    fields:
+      - name: literal
+      - directives?: list
+      - enum_value_definition?: list
+
+  - name: InputObjectTypeExtension
+    fields:
+      - name: literal
+      - directives?: list
+      - input_fields_definition?: list

data/lib/tinygql/parser.rb

@@ -13,8 +13,7 @@ module TinyGQL
 
     def initialize doc
       @lexer = Lexer.new doc
-      @lexer.advance
-      @token_name = @lexer.token_name
+      @token_name = @lexer.advance
     end
 
     def parse
@@ -25,8 +24,13 @@ module TinyGQL
 
     attr_reader :token_name
 
+    def pos
+      @lexer.pos
+    end
+
     def document
-      Nodes::Document.new definition_list
+      loc = pos
+      Nodes::Document.new loc, definition_list
     end
 
     def definition_list
@@ -53,19 +57,70 @@ module TinyGQL
     def type_system_extension
       expect_token :EXTEND
       case token_name
+      when :SCALAR then scalar_type_extension
       when :TYPE then object_type_extension
+      when :INTERFACE then interface_type_extension
+      when :UNION then union_type_extension
+      when :ENUM then enum_type_extension
+      when :INPUT then input_object_type_extension
       else
-        expect_token :FAIL
+        expect_token :SCALAR
       end
     end
 
+    def input_object_type_extension
+      loc = pos
+      expect_token :INPUT
+      name = self.name
+      directives = if at?(:DIR_SIGN); self.directives; end
+      input_fields_definition = if at?(:LCURLY); self.input_fields_definition; end
+      Nodes::InputObjectTypeExtension.new(loc, name, directives, input_fields_definition)
+    end
+
+    def enum_type_extension
+      loc = pos
+      expect_token :ENUM
+      name = self.name
+      directives = if at?(:DIR_SIGN); self.directives; end
+      enum_values_definition = if at?(:LCURLY); self.enum_values_definition; end
+      Nodes::EnumTypeExtension.new(loc, name, directives, enum_values_definition)
+    end
+
+    def union_type_extension
+      loc = pos
+      expect_token :UNION
+      name = self.name
+      directives = if at?(:DIR_SIGN); self.directives; end
+      union_member_types = if at?(:EQUALS); self.union_member_types; end
+      Nodes::UnionTypeExtension.new(loc, name, directives, union_member_types)
+    end
+
+    def interface_type_extension
+      loc = pos
+      expect_token :INTERFACE
+      name = self.name
+      implements_interfaces = if at?(:IMPLEMENTS); self.implements_interfaces; end
+      directives           = if at?(:DIR_SIGN); self.directives; end
+      fields_definition   = if at?(:LCURLY); self.fields_definition; end
+      Nodes::InterfaceTypeExtension.new(loc, name, implements_interfaces, directives, fields_definition)
+    end
+
+    def scalar_type_extension
+      loc = pos
+      expect_token :SCALAR
+      name = self.name
+      directives = if at?(:DIR_SIGN); self.directives; end
+      Nodes::ScalarTypeExtension.new(loc, name, directives)
+    end
+
     def object_type_extension
+      loc = pos
       expect_token :TYPE
       name = self.name
       implements_interfaces = if at?(:IMPLEMENTS); self.implements_interfaces; end
       directives           = if at?(:DIR_SIGN); self.directives; end
       fields_definition   = if at?(:LCURLY); self.fields_definition; end
-      Nodes::ObjectTypeExtension.new(name, implements_interfaces, directives, fields_definition)
+      Nodes::ObjectTypeExtension.new(loc, name, implements_interfaces, directives, fields_definition)
     end
 
     def type_system_definition desc
@@ -78,13 +133,14 @@ module TinyGQL
     end
 
     def directive_defintion desc
+      loc = pos
       expect_token :DIRECTIVE
       expect_token :DIR_SIGN
       name = self.name
       arguments_definition = if at?(:LPAREN); self.arguments_definition; end
       expect_token :ON
       directive_locations = self.directive_locations
-      Nodes::DirectiveDefinition.new(desc, name, arguments_definition, directive_locations)
+      Nodes::DirectiveDefinition.new(loc, desc, name, arguments_definition, directive_locations)
     end
 
     def directive_locations
@@ -97,11 +153,12 @@ module TinyGQL
     end
 
     def directive_location
+      loc = pos
       directive = expect_token_value :IDENTIFIER
 
       case directive
       when "QUERY", "MUTATION", "SUBSCRIPTION", "FIELD", "FRAGMENT_DEFINITION", "FRAGMENT_SPREAD", "INLINE_FRAGMENT"
-        Nodes::ExecutableDirectiveLocation.new(directive)
+        Nodes::ExecutableDirectiveLocation.new(loc, directive)
       when "SCHEMA",
         "SCALAR",
         "OBJECT",
@@ -113,7 +170,7 @@ module TinyGQL
         "ENUM_VALUE",
         "INPUT_OBJECT",
         "INPUT_FIELD_DEFINITION"
-        Nodes::TypeSystemDirectiveLocation.new(directive)
+        Nodes::TypeSystemDirectiveLocation.new(loc, directive)
       else
         raise UnexpectedToken, "Expected directive #{directive}"
       end
@@ -128,16 +185,17 @@ module TinyGQL
       when :ENUM then enum_type_definition(desc)
       when :INPUT then input_object_type_definition(desc)
       else
-        expect_token :FAIL
+        expect_token :TYPE
       end
     end
 
     def input_object_type_definition desc
+      loc = pos
       expect_token :INPUT
       name = self.name
       directives = if at?(:DIR_SIGN); self.directives; end
       input_fields_definition = if at?(:LCURLY); self.input_fields_definition; end
-      Nodes::InputObjectTypeDefinition.new(desc, name, directives, input_fields_definition)
+      Nodes::InputObjectTypeDefinition.new(loc, desc, name, directives, input_fields_definition)
     end
 
     def input_fields_definition
@@ -151,11 +209,12 @@ module TinyGQL
     end
 
     def enum_type_definition desc
+      loc = pos
       expect_token :ENUM
       name = self.name
       directives = if at?(:DIR_SIGN); self.directives; end
       enum_values_definition = if at?(:LCURLY); self.enum_values_definition; end
-      Nodes::EnumTypeDefinition.new(desc, name, directives, enum_values_definition)
+      Nodes::EnumTypeDefinition.new(loc, desc, name, directives, enum_values_definition)
     end
 
     def enum_values_definition
@@ -169,25 +228,28 @@ module TinyGQL
     end
 
     def enum_value_definition
+      loc = pos
       description = if at?(:STRING); string_value; end
       enum_value = self.enum_value
       directives = if at?(:DIR_SIGN); self.directives; end
-      Nodes::EnumValueDefinition.new(description, enum_value, directives)
+      Nodes::EnumValueDefinition.new(loc, description, enum_value, directives)
     end
 
     def scalar_type_definition desc
+      loc = pos
       expect_token :SCALAR
       name = self.name
       directives = if at?(:DIR_SIGN); self.directives; end
-      Nodes::ScalarTypeDefinition.new(desc, name, directives)
+      Nodes::ScalarTypeDefinition.new(loc, desc, name, directives)
     end
 
     def union_type_definition desc
+      loc = pos
       expect_token :UNION
       name = self.name
       directives = if at?(:DIR_SIGN); self.directives; end
       union_member_types = if at?(:EQUALS); self.union_member_types; end
-      Nodes::UnionTypeDefinition.new(desc, name, directives, union_member_types)
+      Nodes::UnionTypeDefinition.new(loc, desc, name, directives, union_member_types)
     end
 
     def union_member_types
@@ -201,21 +263,23 @@ module TinyGQL
     end
 
     def interface_type_definition desc
+      loc = pos
       expect_token :INTERFACE
       name = self.name
       directives           = if at?(:DIR_SIGN); self.directives; end
       fields_definition   = if at?(:LCURLY); self.fields_definition; end
-      Nodes::InterfaceTypeDefinition.new(desc, name, directives, fields_definition)
+      Nodes::InterfaceTypeDefinition.new(loc, desc, name, directives, fields_definition)
     end
 
     def object_type_definition desc
+      loc = pos
       expect_token :TYPE
       name = self.name
       implements_interfaces = if at?(:IMPLEMENTS); self.implements_interfaces; end
       directives           = if at?(:DIR_SIGN); self.directives; end
       fields_definition   = if at?(:LCURLY); self.fields_definition; end
 
-      Nodes::ObjectTypeDefinition.new(desc, name, implements_interfaces, directives, fields_definition)
+      Nodes::ObjectTypeDefinition.new(loc, desc, name, implements_interfaces, directives, fields_definition)
     end
 
     def fields_definition
@@ -229,6 +293,7 @@ module TinyGQL
     end
 
     def field_definition
+      loc = pos
       description = if at?(:STRING); string_value; end
       name = self.name
       arguments_definition = if at?(:LPAREN); self.arguments_definition; end
@@ -236,7 +301,7 @@ module TinyGQL
       type = self.type
       directives           = if at?(:DIR_SIGN); self.directives; end
 
-      Nodes::FieldDefinition.new(description, name, arguments_definition, type, directives)
+      Nodes::FieldDefinition.new(loc, description, name, arguments_definition, type, directives)
     end
 
     def arguments_definition
@@ -250,13 +315,14 @@ module TinyGQL
     end
 
     def input_value_definition
+      loc = pos
       description = if at?(:STRING); string_value; end
       name = self.name
       expect_token :COLON
       type = self.type
       default_value = if at?(:EQUALS); self.default_value; end
       directives           = if at?(:DIR_SIGN); self.directives; end
-      Nodes::InputValueDefinition.new(description, name, type, default_value, directives)
+      Nodes::InputValueDefinition.new(loc, description, name, type, default_value, directives)
     end
 
     def implements_interfaces
@@ -271,21 +337,23 @@ module TinyGQL
     end
 
     def schema_definition desc
+      loc = pos
       expect_token :SCHEMA
 
       directives = if at?(:DIR_SIGN); self.directives; end
       expect_token :LCURLY
       defs = root_operation_type_definition
       expect_token :RCURLY
-      Nodes::SchemaDefinition.new(desc, directives, defs)
+      Nodes::SchemaDefinition.new(loc, desc, directives, defs)
     end
 
     def root_operation_type_definition
       list = []
       while !at?(:RCURLY)
+        loc = pos
         operation_type = self.operation_type
         expect_token :COLON
-        list << Nodes::RootOperationTypeDefinition.new(operation_type, named_type)
+        list << Nodes::RootOperationTypeDefinition.new(loc, operation_type, named_type)
       end
       list
     end
@@ -299,18 +367,20 @@ module TinyGQL
     end
 
     def fragment_definition
+      loc = pos
       expect_token :FRAGMENT
-      expect_token(:FAIL) if at?(:ON)
+      expect_token(:IDENTIFIER) if at?(:ON)
       name = self.name
       tc = self.type_condition
       directives = if at?(:DIR_SIGN)
         self.directives
       end
 
-      Nodes::FragmentDefinition.new(name, tc, directives, selection_set)
+      Nodes::FragmentDefinition.new(loc, name, tc, directives, selection_set)
     end
 
     def operation_definition
+      loc = pos
       case token_name
       when :QUERY, :MUTATION, :SUBSCRIPTION
         type = self.operation_type
@@ -320,6 +390,7 @@ module TinyGQL
       end
 
       Nodes::OperationDefinition.new(
+        loc,
         type,
         ident,
         variable_definitions,
@@ -353,20 +424,22 @@ module TinyGQL
       when :ON, :DIR_SIGN, :LCURLY then inline_fragment
       when :IDENTIFIER then fragment_spread
       else
-        expect_token :FAIL
+        expect_token :IDENTIFIER
       end
     end
 
     def fragment_spread
+      loc = pos
       name = self.name
-      directives = if at?(:DIR_SIGN)
-        self.directives
-      end
+      directives = if at?(:DIR_SIGN); self.directives; end
 
-      Nodes::FragmentSpread.new(name, directives)
+      expect_token(:IDENTIFIER) if at?(:ON)
+
+      Nodes::FragmentSpread.new(loc, name, directives)
     end
 
     def inline_fragment
+      loc = pos
       type_condition = if at?(:ON)
         self.type_condition
       end
@@ -375,15 +448,17 @@ module TinyGQL
         self.directives
       end
 
-      Nodes::InlineFragment.new(type_condition, directives, selection_set)
+      Nodes::InlineFragment.new(loc, type_condition, directives, selection_set)
     end
 
     def type_condition
+      loc = pos
       expect_token :ON
-      Nodes::TypeCondition.new(named_type)
+      Nodes::TypeCondition.new(loc, named_type)
     end
 
     def field
+      loc = pos
       name = self.name
 
       aliaz = nil
@@ -398,7 +473,7 @@ module TinyGQL
       directives = if at?(:DIR_SIGN); self.directives; end
       selection_set = if at?(:LCURLY); self.selection_set; end
 
-      Nodes::Field.new(aliaz, name, arguments, directives, selection_set)
+      Nodes::Field.new(loc, aliaz, name, arguments, directives, selection_set)
     end
 
     def operation_type
@@ -414,13 +489,14 @@ module TinyGQL
     end
 
     def directive
+      loc = pos
       expect_token(:DIR_SIGN)
       name = self.name
       arguments = if at?(:LPAREN)
         self.arguments
       end
 
-      Nodes::Directive.new(name, arguments)
+      Nodes::Directive.new(loc, name, arguments)
     end
 
     def arguments
@@ -434,9 +510,10 @@ module TinyGQL
     end
 
     def argument
+      loc = pos
       name = self.name
       expect_token(:COLON)
-      Nodes::Argument.new(name, value)
+      Nodes::Argument.new(loc, name, value)
     end
 
     def variable_definitions
@@ -450,6 +527,7 @@ module TinyGQL
     end
 
     def variable_definition
+      loc = pos
       var = variable
       expect_token(:COLON)
       type = self.type
@@ -457,7 +535,7 @@ module TinyGQL
         self.default_value
       end
 
-      Nodes::VariableDefinition.new(var, type, default_value)
+      Nodes::VariableDefinition.new(loc, var, type, default_value)
     end
 
     def default_value
@@ -477,54 +555,66 @@ module TinyGQL
       when :LCURLY then object_value
       when :VAR_SIGN then variable
       else
-        expect_token :FAIL
+        expect_token :INT
       end
     end
 
     def object_value
+      start = pos
       expect_token(:LCURLY)
       list = []
       while !at?(:RCURLY)
+        loc = pos
         n = name
         expect_token(:COLON)
-        list << Nodes::ObjectField.new(n, value)
+        list << Nodes::ObjectField.new(loc, n, value)
       end
       expect_token(:RCURLY)
-      Nodes::ObjectValue.new(list)
+      Nodes::ObjectValue.new(start, list)
     end
 
     def list_value
+      loc = pos
       expect_token(:LBRACKET)
       list = []
       while !at?(:RBRACKET)
         list << value
       end
       expect_token(:RBRACKET)
-      Nodes::ListValue.new(list)
+      Nodes::ListValue.new(loc, list)
     end
 
     def enum_value
-      Nodes::EnumValue.new(expect_token_value(:IDENTIFIER))
+      Nodes::EnumValue.new(pos, expect_token_value(:IDENTIFIER))
     end
 
     def float_value
-      Nodes::FloatValue.new(expect_token_value(:FLOAT))
+      Nodes::FloatValue.new(pos, expect_token_value(:FLOAT))
     end
 
     def int_value
-      Nodes::IntValue.new(expect_token_value(:INT))
+      Nodes::IntValue.new(pos, expect_token_value(:INT))
     end
 
     def string_value
-      Nodes::StringValue.new(expect_token_value(:STRING))
+      Nodes::StringValue.new(pos, expect_string_value)
     end
 
     def boolean_value
-      Nodes::BooleanValue.new(expect_tokens([:TRUE, :FALSE]))
+      if at?(:TRUE)
+        accept_token
+        Nodes::BooleanValue.new(pos, "true")
+      elsif at?(:FALSE)
+        accept_token
+        Nodes::BooleanValue.new(pos, "false")
+      else
+        expect_tokens([:TRUE, :FALSE])
+      end
     end
 
     def null_value
-      Nodes::NullValue.new(expect_token_value(:NULL))
+      expect_token :NULL
+      Nodes::NullValue.new(pos, "null")
     end
 
     def type
@@ -534,40 +624,50 @@ module TinyGQL
       end
 
       if at?(:BANG)
-        Nodes::NotNullType.new type
+        Nodes::NotNullType.new pos, type
         expect_token(:BANG)
       end
       type
     end
 
     def list_type
+      loc = pos
       expect_token(:LBRACKET)
-      type = Nodes::ListType.new(self.type)
+      type = Nodes::ListType.new(loc, self.type)
       expect_token(:RBRACKET)
       type
     end
 
     def named_type
-      Nodes::NamedType.new(name)
+      Nodes::NamedType.new(pos, name)
     end
 
     def variable
       return unless at?(:VAR_SIGN)
+      loc = pos
       accept_token
-      Nodes::Variable.new name
+      Nodes::Variable.new loc, name
     end
 
     def name
       case token_name
-      when :IDENTIFIER, :INPUT, :QUERY, :TYPE then accept_token_value
+      when :IDENTIFIER then accept_token_value
+      when :TYPE then
+        accept_token
+        "type"
+      when :QUERY then
+        accept_token
+        "query"
+      when :INPUT then
+        accept_token
+        "input"
       else
         expect_token_value(:IDENTIFIER)
       end
     end
 
     def accept_token
-      @lexer.advance
-      @token_name = @lexer.token_name
+      @token_name = @lexer.advance
     end
 
     # Only use when we care about the accepted token's value
@@ -591,6 +691,12 @@ module TinyGQL
       token_value
     end
 
+    def expect_string_value
+      token_value = @lexer.string_value
+      expect_token :STRING
+      token_value
+    end
+
     def expect_tokens toks
       token_value = @lexer.token_value
       unless toks.any? { |tok| at?(tok) }

data/lib/tinygql/version.rb

@@ -1,3 +1,3 @@
 module TinyGQL
-  VERSION = '0.1.3'
+  VERSION = '0.2.0'
 end