graphql 0.9.5 → 0.10.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: e860d8ee6cbcf24b38c43ea7182153e9e1ea6c17
-  data.tar.gz: 6ffcb982ea45a2e3c16fb68726a1c583849f5184
+  metadata.gz: 9cb8700392b11bc4b4e577e38b424c13b3d33dd9
+  data.tar.gz: 36f2b6d48b2d11084aeb4d0ea50c194e1f2a4b27
 SHA512:
-  metadata.gz: 6990e5ed872ebf7efed61846915a57ed7e21b76ab82ea9c33233bb4747cdb49c435c2e2d2f0a7b8942dbded68800ca54fe517643a9b1bb4a1fb3cfc0f1cd98c4
-  data.tar.gz: a4740639e811cd70e43b01fa22e8a9d35005b5825778bfa1b5ce31940cf1fc9dc8bb2fc2c262579cd2548645bfc982054fa055eae4ea3d9e4c941015f789def5
+  metadata.gz: c8498188be3457f626d74653e48bee19558fc3030f383d8fe65cdf3cfa7f0cf9c8eeabafb1de634a48f9f991de77a0e2630056356de5854af78adbc03881cc14
+  data.tar.gz: de3a1fcfdecefe84e9ed578c9840e861670df763dfb7bd96b11e97e7971c6cbd10c669674cc574904ae9fd0b0db29d70f3dac1bf2aa1f3e430320067dd88859a

data/lib/graphql/base_type.rb

@@ -20,6 +20,16 @@ module GraphQL
       self
     end
 
+    # @return [GraphQL::NonNullType] a non-null version of this type
+    def to_non_null_type
+      GraphQL::NonNullType.new(of_type: self)
+    end
+
+    # @return [GraphQL::ListType] a list version of this type
+    def to_list_type
+      GraphQL::ListType.new(of_type: self)
+    end
+
     module ModifiesAnotherType
       def unwrap
         self.of_type.unwrap
@@ -65,5 +75,19 @@ module GraphQL
     end
 
     alias :inspect :to_s
+
+    # Coerce `input_value` according to this type's `coerce` method.
+    # Raise an error if the value becomes nil.
+    # @param [Object] Incoming query value
+    # @return [Object] Coerced value for query execution
+    def coerce_input!(input_value)
+      coerced_value = coerce_input(input_value)
+
+      if coerced_value.nil?
+        raise GraphQL::ExecutionError.new("Couldn't coerce #{input_value.inspect} to #{self.unwrap.name}")
+      end
+
+      coerced_value
+    end
   end
 end

data/lib/graphql/definition_helpers/defined_by_config.rb

@@ -31,7 +31,9 @@ module GraphQL::DefinitionHelpers::DefinedByConfig
       :possible_types, # interface / union
       :default_value, # argument
       :on, # directive
-      :coerce #scalar
+      :coerce, #scalar
+      :coerce_input, #scalar
+      :coerce_result #scalar
 
     attr_reader :fields, :input_fields, :arguments, :values
 
@@ -41,7 +43,7 @@ module GraphQL::DefinitionHelpers::DefinedByConfig
       @on = []
       @fields = {}
       @arguments = {}
-      @values = {}
+      @values = []
       @input_fields = {}
     end
 
@@ -64,8 +66,7 @@ module GraphQL::DefinitionHelpers::DefinedByConfig
 
     # For EnumType
     def value(name, desc = nil, deprecation_reason: nil, value: name)
-      value = GraphQL::EnumType::EnumValue.new(name: name, description: description, deprecation_reason: deprecation_reason, value: value)
-      values[name] = value
+      values << GraphQL::EnumType::EnumValue.new(name: name, description: description, deprecation_reason: deprecation_reason, value: value)
     end
 
     # For InputObjectType

data/lib/graphql/definition_helpers/non_null_with_bang.rb

@@ -6,6 +6,6 @@ module GraphQL::DefinitionHelpers::NonNullWithBang
   # Make the type non-null
   # @return [GraphQL::NonNullType] a non-null type which wraps the original type
   def !
-    GraphQL::NonNullType.new(of_type: self)
+    to_non_null_type
   end
 end

data/lib/graphql/definition_helpers/type_definer.rb

@@ -20,6 +20,6 @@ class GraphQL::DefinitionHelpers::TypeDefiner
   # @param type [Type] A type to be wrapped in a ListType
   # @return [GraphQL::ListType] A ListType wrapping `type`
   def [](type)
-    GraphQL::ListType.new(of_type: type)
+    type.to_list_type
   end
 end

data/lib/graphql/enum_type.rb

@@ -14,8 +14,17 @@ class GraphQL::EnumType < GraphQL::BaseType
   attr_accessor :name, :description, :values
   defined_by_config :name, :description, :values
 
+  def values=(values)
+    @values_by_name = {}
+    @values_by_value = {}
+    values.each do |enum_value|
+      @values_by_name[enum_value.name] = enum_value
+      @values_by_value[enum_value.value] = enum_value
+    end
+  end
+
   def values
-    @values ||= {}
+    @values_by_name
   end
 
   # Define a value within this enum
@@ -40,8 +49,12 @@ class GraphQL::EnumType < GraphQL::BaseType
   #
   # @param value_name [String] the string representation of this enum value
   # @return [Object] the underlying value for this enum value
-  def coerce(value_name)
-    values[value_name].value
+  def coerce_input(value_name)
+    @values_by_name.fetch(value_name).value
+  end
+
+  def coerce_result(value)
+    @values_by_value.fetch(value).name
   end
 
   def to_s

data/lib/graphql/input_object_type.rb

@@ -18,4 +18,14 @@ class GraphQL::InputObjectType < GraphQL::BaseType
   def kind
     GraphQL::TypeKinds::INPUT_OBJECT
   end
+
+  def coerce_input(value)
+    input_values = {}
+    input_fields.each do |input_key, input_field_defn|
+      raw_value = value.fetch(input_key, input_field_defn.default_value)
+      field_type = input_field_defn.type
+      input_values[input_key] = field_type.coerce_input!(raw_value)
+    end
+    GraphQL::Query::Arguments.new(input_values)
+  end
 end

data/lib/graphql/language.rb

@@ -1,8 +1,3 @@
-module GraphQL
-  module Language
-  end
-end
-
 require 'graphql/language/parser'
 require 'graphql/language/transform'
 require 'graphql/language/nodes'

data/lib/graphql/language/nodes.rb

@@ -1,89 +1,93 @@
-module GraphQL::Language::Nodes
-  # AbstractNode creates classes who:
-  # - require their keyword arguments, throw ArgumentError if they don't match
-  # - expose accessors for keyword arguments
-  class AbstractNode
-    attr_accessor :line, :col
+module GraphQL
+  module Language
+    module Nodes
+      # AbstractNode creates classes who:
+      # - require their keyword arguments, throw ArgumentError if they don't match
+      # - expose accessors for keyword arguments
+      class AbstractNode
+        attr_accessor :line, :col
 
-    # @param options [Hash] Must contain all attributes defined by {required_attrs}, may also include `position_source`
-    def initialize(options)
-      required_keys = self.class.required_attrs
-      allowed_keys = required_keys + [:line, :col]
-      position_source = options.delete(:position_source)
-      if !position_source.nil?
-        options[:line], options[:col] = position_source.line_and_column
-      end
+        # @param options [Hash] Must contain all attributes defined by {required_attrs}, may also include `position_source`
+        def initialize(options)
+          required_keys = self.class.required_attrs
+          allowed_keys = required_keys + [:line, :col]
+          position_source = options.delete(:position_source)
+          if !position_source.nil?
+            options[:line], options[:col] = position_source.line_and_column
+          end
 
-      present_keys = options.keys
-      extra_keys = present_keys - allowed_keys
-      if extra_keys.any?
-        raise ArgumentError, "#{self.class.name} Extra arguments: #{extra_keys}"
-      end
+          present_keys = options.keys
+          extra_keys = present_keys - allowed_keys
+          if extra_keys.any?
+            raise ArgumentError, "#{self.class.name} Extra arguments: #{extra_keys}"
+          end
 
-      missing_keys = required_keys - present_keys
-      if missing_keys.any?
-        raise ArgumentError, "#{self.class.name} Missing arguments: #{missing_keys}"
-      end
+          missing_keys = required_keys - present_keys
+          if missing_keys.any?
+            raise ArgumentError, "#{self.class.name} Missing arguments: #{missing_keys}"
+          end
 
-      allowed_keys.each do |key|
-        if options.has_key?(key)
-          value = options[key]
-          self.send("#{key}=", value)
+          allowed_keys.each do |key|
+            if options.has_key?(key)
+              value = options[key]
+              self.send("#{key}=", value)
+            end
+          end
         end
-      end
-    end
 
-    # Test all attributes, checking for any other nodes below this one
-    def children
-      self.class.required_attrs
-        .map { |attr| send(attr) }
-        .flatten
-        .select { |val| val.is_a?(GraphQL::Language::Nodes::AbstractNode) }
-    end
+        # Test all attributes, checking for any other nodes below this one
+        def children
+          self.class.required_attrs
+            .map { |attr| send(attr) }
+            .flatten
+            .select { |val| val.is_a?(GraphQL::Language::Nodes::AbstractNode) }
+        end
 
-    class << self
-      attr_reader :required_attrs
-      # Defines attributes which are required at initialization.
-      def attr_required(*attr_names)
-        @required_attrs ||= []
-        @required_attrs += attr_names
-        attr_accessor(*attr_names)
-      end
+        class << self
+          attr_reader :required_attrs
+          # Defines attributes which are required at initialization.
+          def attr_required(*attr_names)
+            @required_attrs ||= []
+            @required_attrs += attr_names
+            attr_accessor(*attr_names)
+          end
 
-      # Create a new AbstractNode child which
-      # requires and exposes {attr_names}.
-      # @param attr_names [Array<Symbol>] Attributes this node class will have
-      # @param block [Block] Block passed to `Class.new`
-      # @return [Class] A new node class
-      def create(*attr_names, &block)
-        cls = Class.new(self, &block)
-        cls.attr_required(*attr_names)
-        cls
+          # Create a new AbstractNode child which
+          # requires and exposes {attr_names}.
+          # @param attr_names [Array<Symbol>] Attributes this node class will have
+          # @param block [Block] Block passed to `Class.new`
+          # @return [Class] A new node class
+          def create(*attr_names, &block)
+            cls = Class.new(self, &block)
+            cls.attr_required(*attr_names)
+            cls
+          end
+        end
       end
-    end
-  end
 
-  Argument = AbstractNode.create(:name, :value)
-  Directive = AbstractNode.create(:name, :arguments)
-  Document = AbstractNode.create(:parts)
-  Enum = AbstractNode.create(:name)
-  Field = AbstractNode.create(:name, :alias, :arguments, :directives, :selections)
-  FragmentDefinition = AbstractNode.create(:name, :type, :directives, :selections)
-  FragmentSpread = AbstractNode.create(:name, :directives)
-  InlineFragment = AbstractNode.create(:type, :directives, :selections)
-  InputObject = AbstractNode.create(:pairs) do
-    def to_h(options={})
-      pairs.inject({}) do |memo, pair|
-        v = pair.value
-        memo[pair.name] = v.is_a?(InputObject) ? v.to_h : v
-        memo
+      Argument = AbstractNode.create(:name, :value)
+      Directive = AbstractNode.create(:name, :arguments)
+      Document = AbstractNode.create(:parts)
+      Enum = AbstractNode.create(:name)
+      Field = AbstractNode.create(:name, :alias, :arguments, :directives, :selections)
+      FragmentDefinition = AbstractNode.create(:name, :type, :directives, :selections)
+      FragmentSpread = AbstractNode.create(:name, :directives)
+      InlineFragment = AbstractNode.create(:type, :directives, :selections)
+      InputObject = AbstractNode.create(:pairs) do
+        def to_h(options={})
+          pairs.inject({}) do |memo, pair|
+            v = pair.value
+            memo[pair.name] = v.is_a?(InputObject) ? v.to_h : v
+            memo
+          end
+        end
       end
+      ListType = AbstractNode.create(:of_type)
+      NonNullType = AbstractNode.create(:of_type)
+      OperationDefinition = AbstractNode.create(:operation_type, :name, :variables, :directives, :selections)
+      TypeName = AbstractNode.create(:name)
+      Variable = AbstractNode.create(:name, :type, :default_value)
+      VariableIdentifier = AbstractNode.create(:name)
     end
   end
-  ListType = AbstractNode.create(:of_type)
-  NonNullType = AbstractNode.create(:of_type)
-  OperationDefinition = AbstractNode.create(:operation_type, :name, :variables, :directives, :selections)
-  TypeName = AbstractNode.create(:name)
-  Variable = AbstractNode.create(:name, :type, :default_value)
-  VariableIdentifier = AbstractNode.create(:name)
 end

data/lib/graphql/language/parser.rb

@@ -1,118 +1,121 @@
-module GraphQL::Language
-  # Parser is a [parslet](http://kschiess.github.io/parslet/) parser for parsing queries.
-  #
-  class Parser < Parslet::Parser
-    root(:document)
-    rule(:document) { (
-        space                |
-        operation_definition |
-        fragment_definition
-      ).repeat.as(:document_parts)
-    }
+module GraphQL
+  module Language
+    # Parser is a [parslet](http://kschiess.github.io/parslet/) parser for parsing queries.
+    #
+    class Parser < Parslet::Parser
+      root(:document)
+      rule(:document) { (
+          space                |
+          operation_definition |
+          fragment_definition
+        ).repeat.as(:document_parts)
+      }
 
-    # TODO: whitespace sensitive regarding `on`, eg `onFood`, see lookahead note in spec
-    rule(:fragment_definition) {
-      str("fragment").as(:fragment_keyword) >>
-       space? >> name.as(:fragment_name) >>
-       space? >> str("on") >> space? >> name.as(:type_condition) >>
-       space? >> directives.maybe.as(:optional_directives).as(:directives) >>
-       space? >> selections.as(:selections)
-    }
+      # TODO: whitespace sensitive regarding `on`, eg `onFood`, see lookahead note in spec
+      rule(:fragment_definition) {
+        str("fragment").as(:fragment_keyword) >>
+         space? >> name.as(:fragment_name) >>
+         space? >> str("on") >> space? >> name.as(:type_condition) >>
+         space? >> directives.maybe.as(:optional_directives).as(:directives) >>
+         space? >> selections.as(:selections)
+      }
 
-    rule(:fragment_spread) {
-      spread.as(:fragment_spread_keyword) >> space? >>
-      name.as(:fragment_spread_name) >> space? >>
-      directives.maybe.as(:optional_directives).as(:directives)
-    }
-    rule(:spread) { str("...") }
-    # TODO: `on` bug, see spec
-    rule(:inline_fragment) {
-      spread.as(:fragment_spread_keyword) >> space? >>
-      str("on ") >> name.as(:inline_fragment_type) >> space? >>
-      directives.maybe.as(:optional_directives).as(:directives) >> space? >>
-      selections.as(:selections)
-    }
+      rule(:fragment_spread) {
+        spread.as(:fragment_spread_keyword) >> space? >>
+        name.as(:fragment_spread_name) >> space? >>
+        directives.maybe.as(:optional_directives).as(:directives)
+      }
+      rule(:spread) { str("...") }
+      # TODO: `on` bug, see spec
+      rule(:inline_fragment) {
+        spread.as(:fragment_spread_keyword) >> space? >>
+        str("on ") >> name.as(:inline_fragment_type) >> space? >>
+        directives.maybe.as(:optional_directives).as(:directives) >> space? >>
+        selections.as(:selections)
+      }
 
-    rule(:operation_definition) { (unnamed_selections | named_operation_definition) }
-    rule(:unnamed_selections) { selections.as(:unnamed_selections)}
-    rule(:named_operation_definition) {
-      operation_type.as(:operation_type) >> space? >>
-      name.as(:name) >> space? >>
-      operation_variable_definitions.maybe.as(:optional_variables).as(:variables) >> space? >>
-      directives.maybe.as(:optional_directives).as(:directives) >> space? >>
-      selections.as(:selections)
-    }
-    rule(:operation_type) { (str("query") | str("mutation")) }
-    rule(:operation_variable_definitions) { str("(") >> space? >> (operation_variable_definition >> separator?).repeat(1) >> space? >> str(")") }
-    rule(:operation_variable_definition) {
-      value_variable.as(:variable_name) >> space? >>
-      str(":") >> space? >>
-      type.as(:variable_type) >> space? >>
-      (str("=") >> space? >> value.as(:variable_default_value)).maybe.as(:variable_optional_default_value)}
+      rule(:operation_definition) { (unnamed_selections | typed_operation_definition) }
+      rule(:unnamed_selections) { selections.as(:unnamed_selections)}
+      rule(:typed_operation_definition) {
+        operation_type.as(:operation_type) >> space? >>
+        name.maybe.as(:name) >> space? >>
+        operation_variable_definitions.maybe.as(:optional_variables).as(:variables) >> space? >>
+        directives.maybe.as(:optional_directives).as(:directives) >> space? >>
+        selections.as(:selections)
+      }
+      rule(:operation_type) { (str("query") | str("mutation")) }
+      rule(:operation_variable_definitions) { str("(") >> space? >> (operation_variable_definition >> separator?).repeat(1) >> space? >> str(")") }
+      rule(:operation_variable_definition) {
+        value_variable.as(:variable_name) >> space? >>
+        str(":") >> space? >>
+        type.as(:variable_type) >> space? >>
+        (str("=") >> space? >> value.as(:variable_default_value)).maybe.as(:variable_optional_default_value)
+      }
 
-    rule(:selection) { (inline_fragment | fragment_spread | field) >> space? >> separator? }
-    rule(:selections) { str("{") >> space? >> selection.repeat(1) >> space? >> str("}")}
+      rule(:selection) { (inline_fragment | fragment_spread | field) >> space? >> separator? }
+      rule(:selections) { str("{") >> space? >> selection.repeat(1) >> space? >> str("}")}
 
-    rule(:field) {
-      field_alias.maybe.as(:alias) >>
-      name.as(:field_name) >>
-      field_arguments.maybe.as(:optional_field_arguments).as(:field_arguments) >> space? >>
-      directives.maybe.as(:optional_directives).as(:directives) >> space? >>
-      selections.maybe.as(:optional_selections).as(:selections)
-    }
+      rule(:field) {
+        field_alias.maybe.as(:alias) >>
+        name.as(:field_name) >>
+        field_arguments.maybe.as(:optional_field_arguments).as(:field_arguments) >> space? >>
+        directives.maybe.as(:optional_directives).as(:directives) >> space? >>
+        selections.maybe.as(:optional_selections).as(:selections)
+      }
 
-    rule(:field_alias) { name.as(:alias_name) >> space? >> str(":") >> space? }
-    rule(:field_arguments) { str("(") >> field_argument.repeat(1) >> str(")") }
-    rule(:field_argument) { name.as(:field_argument_name) >> str(":") >> space? >> value.as(:field_argument_value) >> separator? }
+      rule(:field_alias) { name.as(:alias_name) >> space? >> str(":") >> space? }
+      rule(:field_arguments) { str("(") >> field_argument.repeat(1) >> str(")") }
+      rule(:field_argument) { name.as(:field_argument_name) >> str(":") >> space? >> value.as(:field_argument_value) >> separator? }
 
-    rule(:directives) { (directive >> separator?).repeat(1) }
-    rule(:directive) {
-      str("@") >> name.as(:directive_name) >>
-      directive_arguments.maybe.as(:optional_directive_arguments).as(:directive_arguments)
-    }
-    rule(:directive_arguments) { str("(") >> directive_argument.repeat(1) >> str(")") }
-    rule(:directive_argument) { name.as(:directive_argument_name) >> str(":") >> space? >> value.as(:directive_argument_value) >> separator? }
+      rule(:directives) { (directive >> separator?).repeat(1) }
+      rule(:directive) {
+        str("@") >> name.as(:directive_name) >>
+        directive_arguments.maybe.as(:optional_directive_arguments).as(:directive_arguments)
+      }
+      rule(:directive_arguments) { str("(") >> directive_argument.repeat(1) >> str(")") }
+      rule(:directive_argument) { name.as(:directive_argument_name) >> str(":") >> space? >> value.as(:directive_argument_value) >> separator? }
 
-    rule(:type) { (non_null_type | list_type | type_name)}
-    rule(:list_type) { str("[") >> type.as(:list_type) >> str("]")}
-    rule(:non_null_type) { (list_type | type_name).as(:non_null_type) >> str("!") }
-    rule(:type_name) { name.as(:type_name) }
+      rule(:type) { (non_null_type | list_type | type_name)}
+      rule(:list_type) { str("[") >> type.as(:list_type) >> str("]")}
+      rule(:non_null_type) { (list_type | type_name).as(:non_null_type) >> str("!") }
+      rule(:type_name) { name.as(:type_name) }
 
-    rule(:value) {(
-      value_input_object  |
-      value_float         |
-      value_int           |
-      value_string        |
-      value_boolean       |
-      value_array         |
-      value_variable      |
-      value_enum
-    )}
-    rule(:value_sign?) { match('[\-\+]').maybe }
-    rule(:value_array) { (str("[") >> (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_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.as(:string) >> str('"')}
-    rule(:value_string_char) { value_string_escaped_char | value_string_escaped_unicode | value_string_source_char}
-    rule(:value_string_escaped_char) { str("\\") >> match('["\/bfnrt]') }
-    rule(:value_string_escaped_unicode) { str("\\") >> match('u[\dA-Fa-f]{4}')}
-    rule(:value_string_source_char) { (str('"') | str("\\") | value_string_line_terminator).absent? >> any }
-    rule(:value_string_line_terminator) {
-      str('\u000A') | # new line
-      str('\u000D') | # carriage return
-      str('\u2028') | # line separator
-      str('\u2029')   # paragraph separator
-    }
-    rule(:value_enum) { name.as(:enum) }
-    rule(:value_variable) { str("$") >> name.as(:variable) }
+      rule(:value) {(
+        value_input_object  |
+        value_float         |
+        value_int           |
+        value_string        |
+        value_boolean       |
+        value_array         |
+        value_variable      |
+        value_enum
+      )}
+      rule(:value_sign?) { match('[\-\+]').maybe }
+      rule(:value_array) { (str("[") >> (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_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.as(:string) >> str('"')}
+      rule(:value_string_char) { value_string_escaped_char | value_string_escaped_unicode | value_string_source_char}
+      rule(:value_string_escaped_char) { str("\\") >> match('["\/bfnrt]') }
+      rule(:value_string_escaped_unicode) { str("\\") >> match('u[\dA-Fa-f]{4}')}
+      rule(:value_string_source_char) { (str('"') | str("\\") | value_string_line_terminator).absent? >> any }
+      rule(:value_string_line_terminator) {
+        str('\u000A') | # new line
+        str('\u000D') | # carriage return
+        str('\u2028') | # line separator
+        str('\u2029')   # paragraph separator
+      }
+      rule(:value_enum) { name.as(:enum) }
+      rule(:value_variable) { str("$") >> name.as(:variable) }
 
-    rule(:separator?) { (space? >> str(",") >> space?).maybe }
-    rule(:name) { match('[_A-Za-z]') >> match('[_0-9A-Za-z]').repeat(0) }
-    rule(:comment) { str("#") >> match('[^\r\n]').repeat(0) }
-    rule(:space) { (match('[\s\n]+') | comment).repeat(1) }
-    rule(:space?) { space.maybe }
+      rule(:separator?) { space? >> str(",").maybe >> space? }
+      rule(:name) { match('[_A-Za-z]') >> match('[_0-9A-Za-z]').repeat(0) }
+      rule(:comment) { str("#") >> match('[^\r\n]').repeat(0) }
+      rule(:space) { (match('[\s\n]+') | comment).repeat(1) }
+      rule(:space?) { space.maybe }
+    end
   end
 end