graphql 0.10.4 → 0.10.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 47e57c2465fd5d01d22c69ddfc1e964dc0b93239
-  data.tar.gz: c759b0a07b75f19ac51f31c77c89be361c5ab897
+  metadata.gz: 6cd1237e5dde15c5cfa1dbd20213f6c2dcadd533
+  data.tar.gz: e45738645ee04b67b211f66b3f7f56b84bd195da
 SHA512:
-  metadata.gz: e16ebf74d11acb3deece7cab048c89b99a1d564b2daba526bc0234609c56fded00beb8fa38066aa8c0330dc29c5aef532e4231cfd485ff615547ee6eb60ae538
-  data.tar.gz: 84c3ec086585193859acc914e29cf74f62473360994394125e12b83a0ee67d3e5382fc0c4c1f537a706f5a4d0c6c9f07ad8f6c3b6cb762f8de4cb9cbd02d7dd5
+  metadata.gz: bc1b9ee393c15f7e9424a144ed6dbf6b3f724e6041236f995668a18cfb7d328d380624441921a16cd50d22cb6a87d8423a75772a9d28d06e0e4610a303c8b4df
+  data.tar.gz: 32205354a511517f5fac3d83b431d633035edc5799b73dc5fbb660f091dbe1de06e582779245a00d8bf11cb8e38164af252205852c990c111f289b20ba8aca9c

data/lib/graphql/definition_helpers/defined_by_config.rb

@@ -66,7 +66,7 @@ module GraphQL::DefinitionHelpers::DefinedByConfig
 
     # For EnumType
     def value(name, desc = nil, deprecation_reason: nil, value: name)
-      values << GraphQL::EnumType::EnumValue.new(name: name, description: description, deprecation_reason: deprecation_reason, value: value)
+      values << GraphQL::EnumType::EnumValue.new(name: name, description: desc, deprecation_reason: deprecation_reason, value: value)
     end
 
     # For InputObjectType

data/lib/graphql/input_object_type.rb

@@ -10,6 +10,7 @@
 class GraphQL::InputObjectType < GraphQL::BaseType
   attr_accessor :name, :description, :input_fields
   defined_by_config :name, :description, :input_fields
+  alias :arguments :input_fields
 
   def input_fields=(new_fields)
     @input_fields = GraphQL::DefinitionHelpers::StringNamedHash.new(new_fields).to_h

data/lib/graphql/language/parser.rb

@@ -64,7 +64,7 @@ module GraphQL
       }
 
       rule(:field_alias) { name.as(:alias_name) >> space? >> str(":") >> space? }
-      rule(:field_arguments) { str("(") >> field_argument.repeat(1) >> str(")") }
+      rule(:field_arguments) { str("(") >> space? >> field_argument.repeat(1) >> space? >> str(")") }
       rule(:field_argument) { name.as(:field_argument_name) >> str(":") >> space? >> value.as(:field_argument_value) >> separator? }
 
       rule(:directives) { (directive >> separator?).repeat(1) }
@@ -94,7 +94,7 @@ module GraphQL
       rule(:value_array) { (str("[") >> space? >> (value >> separator?).repeat(0) >> str("]")).as(:array) }
       rule(:value_boolean) { (str("true") | str("false")).as(:boolean) }
       rule(:value_float) { (value_sign? >> match('\d').repeat(1) >> str(".") >> match('\d').repeat(1) >> (match("[eE]") >> value_sign? >> match('\d').repeat(1)).maybe).as(:float) }
-      rule(:value_input_object) { str("{") >> space? >> value_input_object_pair.repeat(1).as(:input_object) >> space? >> str("}") }
+      rule(:value_input_object) { str("{") >> space? >> value_input_object_pair.repeat(0).as(:input_object) >> space? >> str("}") }
       rule(:value_input_object_pair) { space? >> name.as(:input_object_name) >>  space? >> str(":") >> space? >> value.as(:input_object_value) >> separator? }
       rule(:value_int) { (value_sign? >> match('\d').repeat(1)).as(:int) }
       rule(:value_string) { str('"') >> value_string_char.repeat.maybe.as(:optional_string_content).as(:string) >> str('"')}

data/lib/graphql/language/transform.rb

@@ -95,7 +95,7 @@ module GraphQL
       rule(array: sequence(:v)) { v }
       rule(array: simple(:v)) { [] } # just `nil`
       rule(boolean: simple(:v)) { v == "true" ? true : false }
-      rule(input_object: sequence(:v)) { create_node(:InputObject, pairs: v, line: v.first.line, col: v.first.col) }
+      rule(input_object: sequence(:v)) { create_node(:InputObject, pairs: v, line: (v.first ? v.first.line : 1), col: (v.first ? v.first.col : 1)) }
       rule(input_object_name: simple(:n), input_object_value: simple(:v)) { create_node(:Argument, name: n.to_s, value: v, position_source: n)}
       rule(input_object_name: simple(:n), input_object_value: sequence(:v)) { create_node(:Argument, name: n.to_s, value: v, position_source: n)}
       rule(int: simple(:v)) { v.to_i }

data/lib/graphql/static_validation/arguments_validator.rb

@@ -5,8 +5,21 @@ class GraphQL::StaticValidation::ArgumentsValidator
   def validate(context)
     visitor = context.visitor
     visitor[GraphQL::Language::Nodes::Argument] << -> (node, parent) {
-      return if parent.is_a?(GraphQL::Language::Nodes::InputObject) || context.skip_field?(parent.name)
-      if parent.is_a?(GraphQL::Language::Nodes::Directive)
+      if parent.is_a?(GraphQL::Language::Nodes::InputObject)
+        arg_defn = context.argument_definition
+        if arg_defn.nil?
+          return
+        else
+          parent_defn = arg_defn.type.unwrap
+          puts "#{node}"
+          puts "#{parent_defn}"
+          if parent_defn.is_a?(GraphQL::ScalarType)
+            return
+          end
+        end
+      elsif context.skip_field?(parent.name)
+        return
+      elsif parent.is_a?(GraphQL::Language::Nodes::Directive)
         parent_defn = context.schema.directives[parent.name]
       else
         parent_defn = context.field_definition
@@ -14,4 +27,20 @@ class GraphQL::StaticValidation::ArgumentsValidator
       validate_node(parent, node, parent_defn, context)
     }
   end
+
+  private
+
+  def parent_name(parent, type_defn)
+    field_name = if parent.is_a?(GraphQL::Language::Nodes::Field)
+      parent.alias || parent.name
+    elsif parent.is_a?(GraphQL::Language::Nodes::InputObject)
+      type_defn.name
+    else
+      parent.name
+    end
+  end
+
+  def node_type(parent)
+    parent.class.name.split("::").last
+  end
 end

data/lib/graphql/static_validation/rules/argument_literals_are_compatible.rb

@@ -5,12 +5,9 @@ class GraphQL::StaticValidation::ArgumentLiteralsAreCompatible < GraphQL::Static
     arg_defn = defn.arguments[node.name]
     valid = validator.validate(node.value, arg_defn.type)
     if !valid
-      field_name = if parent.respond_to?(:alias)
-        parent.alias || parent.name
-      else
-        parent.name
-      end
-      context.errors << message("Argument #{node.name} on #{parent.class.name.split("::").last} '#{field_name}' has an invalid value", parent)
+      kind_of_node = node_type(parent)
+      error_arg_name = parent_name(parent, defn)
+      context.errors << message("Argument '#{node.name}' on #{kind_of_node} '#{error_arg_name}' has an invalid value", parent)
     end
   end
 end

data/lib/graphql/static_validation/rules/arguments_are_defined.rb

@@ -2,7 +2,9 @@ class GraphQL::StaticValidation::ArgumentsAreDefined < GraphQL::StaticValidation
   def validate_node(parent, node, defn, context)
     argument_defn = defn.arguments[node.name]
     if argument_defn.nil?
-      context.errors << message("#{parent.class.name.split("::").last} '#{parent.name}' doesn't accept argument #{node.name}", parent)
+      kind_of_node = node_type(parent)
+      error_arg_name = parent_name(parent, defn)
+      context.errors << message("#{kind_of_node} '#{error_arg_name}' doesn't accept argument '#{node.name}'", parent)
       GraphQL::Language::Visitor::SKIP
     else
       nil

data/lib/graphql/static_validation/rules/variable_usages_are_allowed.rb

@@ -15,6 +15,10 @@ class GraphQL::StaticValidation::VariableUsagesAreAllowed
         arguments = context.field_definition.arguments
       elsif parent.is_a?(GraphQL::Language::Nodes::Directive)
         arguments = context.directive_definition.arguments
+      elsif parent.is_a?(GraphQL::Language::Nodes::InputObject)
+        arguments = context.argument_definition.type.unwrap.input_fields
+      else
+        raise("Unexpected argument parent: #{parent}")
       end
       var_defn_ast = declared_variables[node.value.name]
       # Might be undefined :(

data/lib/graphql/static_validation/type_stack.rb

@@ -24,6 +24,9 @@ class GraphQL::StaticValidation::TypeStack
   # @return [Array<GraphQL::Node::Directive>] directives which have been entered
   attr_reader :directive_definitions
 
+  # @return [Array<GraphQL::Node::Argument>] arguments which have been entered
+  attr_reader :argument_definitions
+
   # @param schema [GraphQL::Schema] the schema whose types to use when climbing this document
   # @param visitor [GraphQL::Language::Visitor] a visitor to follow & watch the types
   def initialize(schema, visitor)
@@ -31,6 +34,7 @@ class GraphQL::StaticValidation::TypeStack
     @object_types = []
     @field_definitions = []
     @directive_definitions = []
+    @argument_definitions = []
     visitor.enter << -> (node, parent) { PUSH_STRATEGIES[node.class].push(self, node) }
     visitor.leave << -> (node, parent) { PUSH_STRATEGIES[node.class].pop(self, node) }
   end
@@ -65,7 +69,7 @@ class GraphQL::StaticValidation::TypeStack
 
   class OperationDefinitionStrategy
     def push(stack, node)
-      # query or mutation
+      # eg, QueryType, MutationType
       object_type = stack.schema.public_send(node.operation_type)
       stack.object_types.push(object_type)
     end
@@ -110,6 +114,33 @@ class GraphQL::StaticValidation::TypeStack
     end
   end
 
+  class ArgumentStrategy
+    # Push `argument_defn` onto the stack.
+    # It's possible that `argument_defn` will be nil.
+    # Push it anyways so `pop` has something to pop.
+    def push(stack, node)
+      if stack.argument_definitions.last
+        arg_type = stack.argument_definitions.last.type.unwrap
+        if arg_type.kind.input_object?
+          argument_defn = arg_type.input_fields[node.name]
+        else
+          argument_defn = nil
+        end
+      elsif stack.directive_definitions.last
+        argument_defn = stack.directive_definitions.last.arguments[node.name]
+      elsif stack.field_definitions.last
+        argument_defn = stack.field_definitions.last.arguments[node.name]
+      else
+        argument_defn = nil
+      end
+      stack.argument_definitions.push(argument_defn)
+    end
+
+    def pop(stack, node)
+      stack.argument_definitions.pop
+    end
+  end
+
   # A no-op strategy (don't handle this node)
   class NullStrategy
     def self.new; self; end

data/lib/graphql/static_validation/validator.rb

@@ -54,14 +54,23 @@ class GraphQL::StaticValidation::Validator
       @type_stack.object_types
     end
 
+    # @return [GraphQL::Field, nil] The most-recently-entered GraphQL::Field, if currently inside one
     def field_definition
       @type_stack.field_definitions.last
     end
 
+    # @return [GraphQL::Directive, nil] The most-recently-entered GraphQL::Directive, if currently inside one
     def directive_definition
       @type_stack.directive_definitions.last
     end
 
+    # @return [GraphQL::Argument, nil] The most-recently-entered GraphQL::Argument, if currently inside one
+    def argument_definition
+      # Don't get the _last_ one because that's the current one.
+      # Get the second-to-last one, which is the parent of the current one.
+      @type_stack.argument_definitions[-2]
+    end
+
     # Don't try to validate dynamic fields
     # since they aren't defined by the type system
     def skip_field?(field_name)

data/lib/graphql/version.rb

@@ -1,3 +1,3 @@
 module GraphQL
-  VERSION = "0.10.4"
+  VERSION = "0.10.5"
 end

data/readme.md

@@ -96,8 +96,7 @@ If you're building a backend for [Relay](http://facebook.github.io/relay/), you'
 ## To Do
 
 - Code clean-up
-  - Raise if you try to configure an attribute which doesn't suit the type
-    - ie, if you try to define `resolve` on an ObjectType, it should somehow raise
+  - Raise if you try to configure an attribute which doesn't suit the type (ie, if you try to define `resolve` on an ObjectType, it should somehow raise)
   - Clean up file structure in `lib/query` (don't need serial_execution namespace anymore)
   - Overriding `!` on types breaks ActiveSupport `.blank?`
 
@@ -109,17 +108,19 @@ If you're building a backend for [Relay](http://facebook.github.io/relay/), you'
     my_type.blank?
     # => MyType!
     ```
+
+- Accept strings for circular type references
+- Interface's possible types should be a property of the schema, not the interface
 - Statically validate type of variables (see early return in LiteralValidator)
 - Big ideas:
-  - Use [graphql-parser](https://github.com/shopify/graphql-parser) (Ruby bindings for [libgraphqlparser](https://github.com/graphql/libgraphqlparser)) instead of Parslet
+  - Use [graphql-parser](https://github.com/shopify/graphql-parser) (Ruby bindings for [libgraphqlparser](https://github.com/graphql/libgraphqlparser)) instead of Parslet ([underway-ish](https://github.com/rmosolgo/graphql-libgraphqlparser-ruby))
   - Revamp the fixture Schema to be more useful (better names, more extensible)
   - __Subscriptions__
     - This is a good chance to make an `Operation` abstraction of which `query`, `mutation` and `subscription` are members
     - For a subscription, `graphql` would send an outbound message to the system (allow the host application to manage its own subscriptions via Pusher, ActionCable, whatever)
-  - Pre-process query strings?
-    - Remove `@skip`-ed things
-    - Inline any fragments
-    - Inline variables?
+- Documentation
+  - Write a "Getting started with Rails"-type blog post
+  - Compile existing articles & slide decks and link to them from a guide
 
 ## Goals
 

data/spec/graphql/enum_type_spec.rb

@@ -8,8 +8,12 @@ describe GraphQL::EnumType do
     assert_equal(1, enum.coerce_input("COW"))
   end
 
-  it 'coerces result values to value name' do
+  it "coerces result values to value's value" do
     assert_equal("YAK", enum.coerce_result("YAK"))
     assert_equal("COW", enum.coerce_result(1))
   end
+
+  it 'has value description' do
+    assert_equal("Animal with horns", enum.values['GOAT'].description)
+  end
 end

data/spec/graphql/language/parser_spec.rb

@@ -15,7 +15,9 @@ describe GraphQL::Language::Parser do
       $input: SomeInputType = {key: "value"},
     ) @veggie, @healthy(vitamins: true) {
       # change the cucumber
-      changeStuff(thing: $cucumbers) {
+      changeStuff(
+        thing: $cucumbers
+      ) {
         id,
         name,
         ... on Species { color },
@@ -23,13 +25,13 @@ describe GraphQL::Language::Parser do
       }
     }
     subscription watchStuff {
-      field, otherField
+      field(emptyObj: {}), otherField
     }
 
     # a fragment:
     fragment family on Species {
       family {
-        name,                                       # name of the family
+        name,                                     # name of the family
         members(first: 3, query: {isPlant: true}) # some of the other examples
       }
     }
@@ -125,6 +127,8 @@ describe GraphQL::Language::Parser do
       assert(parser.value.parse_with_debug('{name: "tomato", calories: 50}'), 'gets scalar values')
       assert(parser.value.parse_with_debug('{listOfValues: [1, 2, [3]], nestedObject: {nestedKey: "nested{Value}"}}'), 'gets complex values')
       assert(parser.value.parse_with_debug('{variableKey: $variableValue}'), 'gets variables')
+      assert(parser.value.parse_with_debug('{}'), 'gets empty')
+      assert(parser.value.parse_with_debug('{  }'), 'gets empty')
     end
 
     it 'gets enums' do

data/spec/graphql/language/transform_spec.rb

@@ -23,6 +23,7 @@ describe GraphQL::Language::Transform do
           ...personInfo
           someStuff(vars: [1,2,3])
           someOtherStuff(input: {ints: [1,2,3]})
+          someEmptyStuff(emptyObj: {}, emptySpaceObj: { })
         }
       }
 
@@ -109,6 +110,24 @@ describe GraphQL::Language::Transform do
     assert_equal(2, res.selections.length)
   end
 
+  it 'transforms input objects' do
+    res_one_pair    = get_result(%q|{one: 1}|, parse: :value_input_object)
+    res_two_pair    = get_result(%q|{first: "Apple", second: "Banana"}|, parse: :value_input_object)
+    res_empty       = get_result(%q|{}|, parse: :value_input_object)
+    res_empty_space = get_result(%q|{ }|, parse: :value_input_object)
+
+    assert_equal('one', res_one_pair.pairs[0].name)
+    assert_equal(1    , res_one_pair.pairs[0].value)
+
+    assert_equal('first' , res_two_pair.pairs[0].name)
+    assert_equal('Apple' , res_two_pair.pairs[0].value)
+    assert_equal('second', res_two_pair.pairs[1].name)
+    assert_equal('Banana', res_two_pair.pairs[1].value)
+
+    assert_equal([], res_empty.pairs)
+    assert_equal([], res_empty_space.pairs)
+  end
+
   it 'transforms directives' do
     res = get_result('@doSomething(vigorously: "\"true\u0025\"")', parse: :directive)
     assert_equal("doSomething", res.name, 'gets the name without @')

data/spec/graphql/static_validation/rules/argument_literals_are_compatible_spec.rb

@@ -5,7 +5,7 @@ describe GraphQL::StaticValidation::ArgumentLiteralsAreCompatible do
     query getCheese {
       cheese(id: "aasdlkfj") { source }
       cheese(id: 1) { source @skip(if: {id: 1})}
-      yakSource: searchDairy(product: [{source: YAK, fatContent: 1.1}]) { source }
+      yakSource: searchDairy(product: [{source: COW, fatContent: 1.1}]) { source }
       badSource: searchDairy(product: [{source: 1.1}]) { source }
       missingSource: searchDairy(product: [{fatContent: 1.1}]) { source }
     }
@@ -19,34 +19,40 @@ describe GraphQL::StaticValidation::ArgumentLiteralsAreCompatible do
   let(:errors) { validator.validate(document) }
 
   it 'finds undefined or missing-required arguments to fields and directives' do
-    assert_equal(5, errors.length)
+    assert_equal(6, errors.length)
 
     query_root_error = {
-      "message"=>"Argument id on Field 'cheese' has an invalid value",
+      "message"=>"Argument 'id' on Field 'cheese' has an invalid value",
       "locations"=>[{"line"=>3, "column"=>7}]
     }
     assert_includes(errors, query_root_error)
 
     directive_error = {
-      "message"=>"Argument if on Directive 'skip' has an invalid value",
+      "message"=>"Argument 'if' on Directive 'skip' has an invalid value",
       "locations"=>[{"line"=>4, "column"=>31}]
     }
     assert_includes(errors, directive_error)
 
     input_object_error = {
-      "message"=>"Argument product on Field 'badSource' has an invalid value",
+      "message"=>"Argument 'product' on Field 'badSource' has an invalid value",
       "locations"=>[{"line"=>6, "column"=>7}]
     }
     assert_includes(errors, input_object_error)
 
+    input_object_field_error = {
+      "message"=>"Argument 'source' on InputObject 'DairyProductInput' has an invalid value",
+      "locations"=>[{"line"=>6, "column"=>41}]
+    }
+    assert_includes(errors, input_object_field_error)
+
     missing_required_field_error = {
-      "message"=>"Argument product on Field 'missingSource' has an invalid value",
+      "message"=>"Argument 'product' on Field 'missingSource' has an invalid value",
       "locations"=>[{"line"=>7, "column"=>7}]
     }
     assert_includes(errors, missing_required_field_error)
 
     fragment_error = {
-      "message"=>"Argument source on Field 'similarCheese' has an invalid value",
+      "message"=>"Argument 'source' on Field 'similarCheese' has an invalid value",
       "locations"=>[{"line"=>11, "column"=>7}]
     }
     assert_includes(errors, fragment_error)

data/spec/graphql/static_validation/rules/arguments_are_defined_spec.rb

@@ -5,6 +5,7 @@ describe GraphQL::StaticValidation::ArgumentsAreDefined do
     query getCheese {
       cheese(id: 1) { source }
       cheese(silly: false) { source }
+      searchDairy(product: [{wacky: 1}])
     }
 
     fragment cheeseFields on Cheese {
@@ -17,23 +18,29 @@ describe GraphQL::StaticValidation::ArgumentsAreDefined do
   let(:errors) { validator.validate(document) }
 
   it 'finds undefined arguments to fields and directives' do
-    assert_equal(3, errors.length)
+    assert_equal(4, errors.length)
 
     query_root_error = {
-      "message"=>"Field 'cheese' doesn't accept argument silly",
+      "message"=>"Field 'cheese' doesn't accept argument 'silly'",
       "locations"=>[{"line"=>4, "column"=>7}]
     }
     assert_includes(errors, query_root_error)
 
+    input_obj_record = {
+      "message"=>"InputObject 'DairyProductInput' doesn't accept argument 'wacky'",
+      "locations"=>[{"line"=>5, "column"=>30}]
+    }
+    assert_includes(errors, input_obj_record)
+
     fragment_error = {
-      "message"=>"Field 'similarCheese' doesn't accept argument nonsense",
-      "locations"=>[{"line"=>8, "column"=>7}]
+      "message"=>"Field 'similarCheese' doesn't accept argument 'nonsense'",
+      "locations"=>[{"line"=>9, "column"=>7}]
     }
     assert_includes(errors, fragment_error)
 
     directive_error = {
-      "message"=>"Directive 'skip' doesn't accept argument something",
-      "locations"=>[{"line"=>9, "column"=>11}]
+      "message"=>"Directive 'skip' doesn't accept argument 'something'",
+      "locations"=>[{"line"=>10, "column"=>11}]
     }
     assert_includes(errors, directive_error)
   end

data/spec/graphql/static_validation/rules/variable_usages_are_allowed_spec.rb

@@ -10,6 +10,7 @@ describe GraphQL::StaticValidation::VariableUsagesAreAllowed do
         $goodAnimals: [DairyAnimal!]!,
         $badAnimals: [DairyAnimal]!,
         $deepAnimals: [[DairyAnimal!]!]!,
+        $goodSource: DairyAnimal!,
     ) {
       goodCheese:   cheese(id: $goodInt)  { source }
       okCheese:     cheese(id: $okInt)    { source }
@@ -24,6 +25,10 @@ describe GraphQL::StaticValidation::VariableUsagesAreAllowed do
       milk(id: 1) {
         flavors(limit: $okInt)
       }
+
+      searchDairy(product: [{source: $goodSource}]) {
+        ... on Cheese { id }
+      }
     }
   ')}
 
@@ -35,19 +40,19 @@ describe GraphQL::StaticValidation::VariableUsagesAreAllowed do
     expected = [
       {
         "message"=>"Nullability mismatch on variable $badInt and argument id (Int / Int!)",
-        "locations"=>[{"line"=>13, "column"=>28}]
+        "locations"=>[{"line"=>14, "column"=>28}]
       },
       {
         "message"=>"Type mismatch on variable $badStr and argument id (String! / Int!)",
-        "locations"=>[{"line"=>14, "column"=>28}]
+        "locations"=>[{"line"=>15, "column"=>28}]
       },
       {
         "message"=>"Nullability mismatch on variable $badAnimals and argument source ([DairyAnimal]! / [DairyAnimal!]!)",
-        "locations"=>[{"line"=>17, "column"=>30}]
+        "locations"=>[{"line"=>18, "column"=>30}]
       },
       {
         "message"=>"List dimension mismatch on variable $deepAnimals and argument source ([[DairyAnimal!]!]! / [DairyAnimal!]!)",
-        "locations"=>[{"line"=>18, "column"=>32}]
+        "locations"=>[{"line"=>19, "column"=>32}]
       }
     ]
     assert_equal(expected, errors)

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: graphql
 version: !ruby/object:Gem::Version
-  version: 0.10.4
+  version: 0.10.5
 platform: ruby
 authors:
 - Robert Mosolgo
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-11-24 00:00:00.000000000 Z
+date: 2015-12-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: parslet