graphql 0.16.0 → 2.0.15

data/lib/graphql/language/nodes.rb

@@ -1,204 +1,716 @@
+# frozen_string_literal: true
 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
+      # {AbstractNode} is the base class for all nodes in a GraphQL AST.
+      #
+      # It provides some APIs for working with ASTs:
+      # - `children` returns all AST nodes attached to this one. Used for tree traversal.
+      # - `scalars` returns all scalar (Ruby) values attached to this one. Used for comparing nodes.
+      # - `to_query_string` turns an AST node into a GraphQL string
       class AbstractNode
-        attr_accessor :line, :col
+        module DefinitionNode
+          # This AST node's {#line} returns the first line, which may be the description.
+          # @return [Integer] The first line of the definition (not the description)
+          attr_reader :definition_line
+
+          def initialize(options = {})
+            @definition_line = options.delete(:definition_line)
+            super(options)
+          end
+        end
 
-        # @param options [Hash] Must contain all attributes defined by {required_attrs}, may also include `position_source`
-        def initialize(options={})
+        attr_reader :line, :col, :filename
+
+        # Initialize a node by extracting its position,
+        # then calling the class's `initialize_node` method.
+        # @param options [Hash] Initial attributes for this node
+        def initialize(options = {})
           if options.key?(:position_source)
             position_source = options.delete(:position_source)
-            @line, @col = position_source.line_and_column
-          elsif options.key?(:line)
-            @line = options.delete(:line)
-            @col = options.delete(:col)
+            @line = position_source.line
+            @col = position_source.col
           end
 
-          initialize_node(options)
+          @filename = options.delete(:filename)
+
+          initialize_node(**options)
         end
 
-        # This is called with node-specific options
-        def initialize_node(options={})
-          raise NotImplementedError
+        # Value equality
+        # @return [Boolean] True if `self` is equivalent to `other`
+        def ==(other)
+          return true if equal?(other)
+          other.kind_of?(self.class) &&
+            other.scalars == self.scalars &&
+            other.children == self.children
         end
 
-        # @return [GraphQL::Language::Nodes::AbstractNode] all nodes in the tree below this one
+        NO_CHILDREN = [].freeze
+
+        # @return [Array<GraphQL::Language::Nodes::AbstractNode>] all nodes in the tree below this one
         def children
-          self.class.child_attributes
-            .map { |attr_name| public_send(attr_name) }
-            .flatten
+          NO_CHILDREN
         end
 
-        class << self
-          def child_attributes(*attr_names)
-            @child_attributes ||= []
-            @child_attributes += attr_names
-          end
+        # @return [Array<Integer, Float, String, Boolean, Array>] Scalar values attached to this node
+        def scalars
+          NO_CHILDREN
+        end
+
+        # This might be unnecessary, but its easiest to add it here.
+        def initialize_copy(other)
+          @children = nil
+          @scalars = nil
+          @query_string = nil
+        end
+
+        def children_method_name
+          self.class.children_method_name
         end
 
         def position
           [line, col]
         end
 
-        def to_query_string
-          Generation.generate(self)
+        def to_query_string(printer: GraphQL::Language::Printer.new)
+          if printer.is_a?(GraphQL::Language::Printer)
+            @query_string ||= printer.print(self)
+          else
+            printer.print(self)
+          end
         end
-      end
 
-      class WrapperType < AbstractNode
-        attr_accessor :of_type
-        def initialize_node(of_type: nil)
-          @of_type = of_type
+        # This creates a copy of `self`, with `new_options` applied.
+        # @param new_options [Hash]
+        # @return [AbstractNode] a shallow copy of `self`
+        def merge(new_options)
+          dup.merge!(new_options)
         end
 
-        def children
-          [].freeze
+        # Copy `self`, but modify the copy so that `previous_child` is replaced by `new_child`
+        def replace_child(previous_child, new_child)
+          # Figure out which list `previous_child` may be found in
+          method_name = previous_child.children_method_name
+          # Get the value from this (original) node
+          prev_children = public_send(method_name)
+          if prev_children.is_a?(Array)
+            # Copy that list, and replace `previous_child` with `new_child`
+            # in the list.
+            new_children = prev_children.dup
+            prev_idx = new_children.index(previous_child)
+            new_children[prev_idx] = new_child
+          else
+            # Use the new value for the given attribute
+            new_children = new_child
+          end
+          # Copy this node, but with the new child value
+          copy_of_self = merge(method_name => new_children)
+          # Return the copy:
+          copy_of_self
         end
-      end
 
-      class NameOnlyNode < AbstractNode
-        attr_accessor :name
-        def initialize_node(name: nil)
-          @name = name
+        # TODO DRY with `replace_child`
+        def delete_child(previous_child)
+          # Figure out which list `previous_child` may be found in
+          method_name = previous_child.children_method_name
+          # Copy that list, and delete previous_child
+          new_children = public_send(method_name).dup
+          new_children.delete(previous_child)
+          # Copy this node, but with the new list of children:
+          copy_of_self = merge(method_name => new_children)
+          # Return the copy:
+          copy_of_self
         end
 
-        def children
-          [].freeze
+        protected
+
+        def merge!(new_options)
+          new_options.each do |key, value|
+            instance_variable_set(:"@#{key}", value)
+          end
+          self
         end
+
+        class << self
+          # Add a default `#visit_method` and `#children_method_name` using the class name
+          def inherited(child_class)
+            super
+            name_underscored = child_class.name
+              .split("::").last
+              .gsub(/([a-z])([A-Z])/,'\1_\2') # insert underscores
+              .downcase # remove caps
+
+            child_class.module_eval <<-RUBY
+              def visit_method
+                :on_#{name_underscored}
+              end
+
+              class << self
+                attr_accessor :children_method_name
+              end
+              self.children_method_name = :#{name_underscored}s
+            RUBY
+          end
+
+          private
+
+          # Name accessors which return lists of nodes,
+          # along with the kind of node they return, if possible.
+          # - Add a reader for these children
+          # - Add a persistent update method to add a child
+          # - Generate a `#children` method
+          def children_methods(children_of_type)
+            if defined?(@children_methods)
+              raise "Can't re-call .children_methods for #{self} (already have: #{@children_methods})"
+            else
+              @children_methods = children_of_type
+            end
+
+            if children_of_type == false
+              @children_methods = {}
+              # skip
+            else
+
+              children_of_type.each do |method_name, node_type|
+                module_eval <<-RUBY, __FILE__, __LINE__
+                  # A reader for these children
+                  attr_reader :#{method_name}
+                RUBY
+
+                if node_type
+                  # Only generate a method if we know what kind of node to make
+                  module_eval <<-RUBY, __FILE__, __LINE__
+                    # Singular method: create a node with these options
+                    # and return a new `self` which includes that node in this list.
+                    def merge_#{method_name.to_s.sub(/s$/, "")}(node_opts)
+                      merge(#{method_name}: #{method_name} + [#{node_type.name}.new(node_opts)])
+                    end
+                  RUBY
+                end
+              end
+
+              if children_of_type.size == 1
+                module_eval <<-RUBY, __FILE__, __LINE__
+                  alias :children #{children_of_type.keys.first}
+                RUBY
+              else
+                module_eval <<-RUBY, __FILE__, __LINE__
+                  def children
+                    @children ||= begin
+                      if #{children_of_type.keys.map { |k| "@#{k}.any?" }.join(" || ")}
+                        new_children = []
+                        #{children_of_type.keys.map { |k| "new_children.concat(@#{k})" }.join("; ")}
+                        new_children.freeze
+                        new_children
+                      else
+                        NO_CHILDREN
+                      end
+                    end
+                  end
+                RUBY
+              end
+            end
+
+            if defined?(@scalar_methods)
+              if !method_defined?(:initialize_node)
+                generate_initialize_node
+              else
+                # This method was defined manually
+              end
+            else
+              raise "Can't generate_initialize_node because scalar_methods wasn't called; call it before children_methods"
+            end
+          end
+
+          # These methods return a plain Ruby value, not another node
+          # - Add reader methods
+          # - Add a `#scalars` method
+          def scalar_methods(*method_names)
+            if defined?(@scalar_methods)
+              raise "Can't re-call .scalar_methods for #{self} (already have: #{@scalar_methods})"
+            else
+              @scalar_methods = method_names
+            end
+
+            if method_names == [false]
+              @scalar_methods = []
+              # skip it
+            else
+              module_eval <<-RUBY, __FILE__, __LINE__
+                # add readers for each scalar
+                attr_reader #{method_names.map { |m| ":#{m}"}.join(", ")}
+
+                def scalars
+                  @scalars ||= [#{method_names.map { |k| "@#{k}" }.join(", ")}].freeze
+                end
+              RUBY
+            end
+          end
+
+          def generate_initialize_node
+            scalar_method_names = @scalar_methods
+            # TODO: These probably should be scalar methods, but `types` returns an array
+            [:types, :description].each do |extra_method|
+              if method_defined?(extra_method)
+                scalar_method_names += [extra_method]
+              end
+            end
+
+            all_method_names = scalar_method_names + @children_methods.keys
+            if all_method_names.include?(:alias)
+              # Rather than complicating this special case,
+              # let it be overridden (in field)
+              return
+            else
+              arguments = scalar_method_names.map { |m| "#{m}: nil"} +
+                @children_methods.keys.map { |m| "#{m}: NO_CHILDREN" }
+
+              assignments = scalar_method_names.map { |m| "@#{m} = #{m}"} +
+                @children_methods.keys.map { |m| "@#{m} = #{m}.freeze" }
+
+              module_eval <<-RUBY, __FILE__, __LINE__
+                def initialize_node #{arguments.join(", ")}
+                  #{assignments.join("\n")}
+                end
+              RUBY
+            end
+          end
+        end
+      end
+
+      # Base class for non-null type names and list type names
+      class WrapperType < AbstractNode
+        scalar_methods :of_type
+        children_methods(false)
       end
 
+      # Base class for nodes whose only value is a name (no child nodes or other scalars)
+      class NameOnlyNode < AbstractNode
+        scalar_methods :name
+        children_methods(false)
+      end
 
+      # A key-value pair for a field's inputs
       class Argument < AbstractNode
-        attr_accessor :name, :value
+        scalar_methods :name, :value
+        children_methods(false)
 
-        def initialize_node(name: nil, value: nil)
-          @name = name
-          @value = value
-        end
+        # @!attribute name
+        #   @return [String] the key for this argument
+
+        # @!attribute value
+        #   @return [String, Float, Integer, Boolean, Array, InputObject] The value passed for this key
 
         def children
-          [value].flatten.select { |v| v.is_a?(AbstractNode) }
+          @children ||= Array(value).flatten.select { |v| v.is_a?(AbstractNode) }
         end
       end
 
       class Directive < AbstractNode
-        attr_accessor :name, :arguments
-        child_attributes :arguments
+        scalar_methods :name
+        children_methods(arguments: GraphQL::Language::Nodes::Argument)
+      end
 
-        def initialize_node(name: nil, arguments: [])
-          @name = name
-          @arguments = arguments
-        end
+      class DirectiveLocation < NameOnlyNode
       end
 
+      class DirectiveDefinition < AbstractNode
+        include DefinitionNode
+        attr_reader :description
+        scalar_methods :name, :repeatable
+        children_methods(
+          locations: Nodes::DirectiveLocation,
+          arguments: Nodes::Argument,
+        )
+      end
+
+      # This is the AST root for normal queries
+      #
+      # @example Deriving a document by parsing a string
+      #   document = GraphQL.parse(query_string)
+      #
+      # @example Creating a string from a document
+      #   document.to_query_string
+      #   # { ... }
+      #
+      # @example Creating a custom string from a document
+      #  class VariableScrubber < GraphQL::Language::Printer
+      #    def print_argument(arg)
+      #      "#{arg.name}: <HIDDEN>"
+      #    end
+      #  end
+      #
+      #  document.to_query_string(printer: VariableScrubber.new)
+      #
       class Document < AbstractNode
-        attr_accessor :definitions
-        child_attributes :definitions
+        scalar_methods false
+        children_methods(definitions: nil)
+        # @!attribute definitions
+        #   @return [Array<OperationDefinition, FragmentDefinition>] top-level GraphQL units: operations or fragments
 
-        def initialize_node(definitions: [])
-          @definitions = definitions
+        def slice_definition(name)
+          GraphQL::Language::DefinitionSlice.slice(self, name)
         end
       end
 
-      class Enum < NameOnlyNode; end
+      # An enum value. The string is available as {#name}.
+      class Enum < NameOnlyNode
+      end
+
+      # A null value literal.
+      class NullValue < NameOnlyNode
+      end
 
+      # A single selection in a GraphQL query.
       class Field < AbstractNode
-        attr_accessor :name, :alias, :arguments, :directives, :selections
-        child_attributes :arguments, :directives, :selections
-
-        def initialize_node(name: nil, arguments: [], directives: [], selections: [], **kwargs)
-          @name = name
+        NONE = [].freeze
+
+        scalar_methods :name, :alias
+        children_methods({
+          arguments: GraphQL::Language::Nodes::Argument,
+          selections: GraphQL::Language::Nodes::Field,
+          directives: GraphQL::Language::Nodes::Directive,
+        })
+
+        # @!attribute selections
+        #   @return [Array<Nodes::Field>] Selections on this object (or empty array if this is a scalar field)
+
+        def initialize_node(attributes)
+          @name = attributes[:name]
+          @arguments = attributes[:arguments] || NONE
+          @directives = attributes[:directives] || NONE
+          @selections = attributes[:selections] || NONE
           # oops, alias is a keyword:
-          @alias = kwargs.fetch(:alias, nil)
-          @arguments = arguments
-          @directives = directives
-          @selections = selections
+          @alias = attributes[:alias]
         end
+
+        # Override this because default is `:fields`
+        self.children_method_name = :selections
       end
 
+      # A reusable fragment, defined at document-level.
       class FragmentDefinition < AbstractNode
-        attr_accessor :name, :type, :directives, :selections
-        child_attributes :directives, :selections
+        # @!attribute name
+        #   @return [String] the identifier for this fragment, which may be applied with `...#{name}`
 
+        # @!attribute type
+        #   @return [String] the type condition for this fragment (name of type which it may apply to)
         def initialize_node(name: nil, type: nil, directives: [], selections: [])
           @name = name
           @type = type
           @directives = directives
           @selections = selections
         end
+
+        scalar_methods :name, :type
+        children_methods({
+          selections: GraphQL::Language::Nodes::Field,
+          directives: GraphQL::Language::Nodes::Directive,
+        })
+
+        self.children_method_name = :definitions
       end
 
+      # Application of a named fragment in a selection
       class FragmentSpread < AbstractNode
-        attr_accessor :name, :directives
-        child_attributes :directives
+        scalar_methods :name
+        children_methods(directives: GraphQL::Language::Nodes::Directive)
 
-        def initialize_node(name: nil, directives: [])
-          @name = name
-          @directives = directives
-        end
+        self.children_method_name = :selections
+
+        # @!attribute name
+        #   @return [String] The identifier of the fragment to apply, corresponds with {FragmentDefinition#name}
       end
 
+      # An unnamed fragment, defined directly in the query with `... {  }`
       class InlineFragment < AbstractNode
-        attr_accessor :type, :directives, :selections
-        child_attributes :directives, :selections
+        scalar_methods :type
+        children_methods({
+          selections: GraphQL::Language::Nodes::Field,
+          directives: GraphQL::Language::Nodes::Directive,
+        })
 
-        def initialize_node(type: nil, directives: [], selections: [])
-          @type = type
-          @directives = directives
-          @selections = selections
-        end
+        self.children_method_name = :selections
+
+        # @!attribute type
+        #   @return [String, nil] Name of the type this fragment applies to, or `nil` if this fragment applies to any type
       end
 
+      # A collection of key-value inputs which may be a field argument
       class InputObject < AbstractNode
-        attr_accessor :arguments
-        child_attributes :arguments
+        scalar_methods(false)
+        children_methods(arguments: GraphQL::Language::Nodes::Argument)
 
-        def initialize_node(arguments: [])
-          @arguments = arguments
-        end
+        # @!attribute arguments
+        #   @return [Array<Nodes::Argument>] A list of key-value pairs inside this input object
 
+        # @return [Hash<String, Any>] Recursively turn this input object into a Ruby Hash
         def to_h(options={})
           arguments.inject({}) do |memo, pair|
             v = pair.value
-            memo[pair.name] = v.is_a?(InputObject) ? v.to_h : v
+            memo[pair.name] = serialize_value_for_hash v
             memo
           end
         end
+
+        self.children_method_name = :value
+
+        private
+
+        def serialize_value_for_hash(value)
+          case value
+          when InputObject
+            value.to_h
+          when Array
+            value.map do |v|
+              serialize_value_for_hash v
+            end
+          when Enum
+            value.name
+          when NullValue
+            nil
+          else
+            value
+          end
+        end
       end
 
+      # A list type definition, denoted with `[...]` (used for variable type definitions)
+      class ListType < WrapperType
+      end
 
+      # A non-null type definition, denoted with `...!` (used for variable type definitions)
+      class NonNullType < WrapperType
+      end
+
+      # An operation-level query variable
+      class VariableDefinition < AbstractNode
+        scalar_methods :name, :type, :default_value
+        children_methods false
+        # @!attribute default_value
+        #   @return [String, Integer, Float, Boolean, Array, NullValue] A Ruby value to use if no other value is provided
+
+        # @!attribute type
+        #   @return [TypeName, NonNullType, ListType] The expected type of this value
 
-      class ListType < WrapperType; end
-      class NonNullType < WrapperType; end
+        # @!attribute name
+        #   @return [String] The identifier for this variable, _without_ `$`
 
+        self.children_method_name = :variables
+      end
+
+      # A query, mutation or subscription.
+      # May be anonymous or named.
+      # May be explicitly typed (eg `mutation { ... }`) or implicitly a query (eg `{ ... }`).
       class OperationDefinition < AbstractNode
-        attr_accessor :operation_type, :name, :variables, :directives, :selections
-        child_attributes :variables, :directives, :selections
+        scalar_methods :operation_type, :name
+        children_methods({
+          variables: GraphQL::Language::Nodes::VariableDefinition,
+          selections: GraphQL::Language::Nodes::Field,
+          directives: GraphQL::Language::Nodes::Directive,
+        })
 
-        def initialize_node(operation_type: nil, name: nil, variables: [], directives: [], selections: [])
-          @operation_type = operation_type
-          @name = name
-          @variables = variables
-          @directives = directives
-          @selections = selections
-        end
+        # @!attribute variables
+        #   @return [Array<VariableDefinition>] Variable $definitions for this operation
+
+        # @!attribute selections
+        #   @return [Array<Field>] Root-level fields on this operation
+
+        # @!attribute operation_type
+        #   @return [String, nil] The root type for this operation, or `nil` for implicit `"query"`
+
+        # @!attribute name
+        #   @return [String, nil] The name for this operation, or `nil` if unnamed
+
+        self.children_method_name = :definitions
       end
 
-      class TypeName < NameOnlyNode; end
+      # A type name, used for variable definitions
+      class TypeName < NameOnlyNode
+      end
 
-      class VariableDefinition < AbstractNode
-        attr_accessor :name, :type, :default_value
-        def initialize_node(name: nil, type: nil, default_value: nil)
-          @name = name
-          @type = type
-          @default_value = default_value
+      # Usage of a variable in a query. Name does _not_ include `$`.
+      class VariableIdentifier < NameOnlyNode
+        self.children_method_name = :value
+      end
+
+      class SchemaDefinition < AbstractNode
+        include DefinitionNode
+        scalar_methods :query, :mutation, :subscription
+        children_methods({
+          directives: GraphQL::Language::Nodes::Directive,
+        })
+        self.children_method_name = :definitions
+      end
+
+      class SchemaExtension < AbstractNode
+        scalar_methods :query, :mutation, :subscription
+        children_methods({
+          directives: GraphQL::Language::Nodes::Directive,
+        })
+        self.children_method_name = :definitions
+      end
+
+      class ScalarTypeDefinition < AbstractNode
+        include DefinitionNode
+        attr_reader :description
+        scalar_methods :name
+        children_methods({
+          directives: GraphQL::Language::Nodes::Directive,
+        })
+        self.children_method_name = :definitions
+      end
+
+      class ScalarTypeExtension < AbstractNode
+        scalar_methods :name
+        children_methods({
+          directives: GraphQL::Language::Nodes::Directive,
+        })
+        self.children_method_name = :definitions
+      end
+
+      class InputValueDefinition < AbstractNode
+        include DefinitionNode
+        attr_reader :description
+        scalar_methods :name, :type, :default_value
+        children_methods({
+          directives: GraphQL::Language::Nodes::Directive,
+        })
+        self.children_method_name = :fields
+      end
+
+      class FieldDefinition < AbstractNode
+        include DefinitionNode
+        attr_reader :description
+        scalar_methods :name, :type
+        children_methods({
+          directives: GraphQL::Language::Nodes::Directive,
+          arguments: GraphQL::Language::Nodes::InputValueDefinition,
+        })
+        self.children_method_name = :fields
+
+        # this is so that `children_method_name` of `InputValueDefinition` works properly
+        # with `#replace_child`
+        alias :fields :arguments
+        def merge(new_options)
+          if (f = new_options.delete(:fields))
+            new_options[:arguments] = f
+          end
+          super
         end
       end
 
-      class VariableIdentifier < NameOnlyNode; end
+      class ObjectTypeDefinition < AbstractNode
+        include DefinitionNode
+        attr_reader :description
+        scalar_methods :name, :interfaces
+        children_methods({
+          directives: GraphQL::Language::Nodes::Directive,
+          fields: GraphQL::Language::Nodes::FieldDefinition,
+        })
+        self.children_method_name = :definitions
+      end
+
+      class ObjectTypeExtension < AbstractNode
+        scalar_methods :name, :interfaces
+        children_methods({
+          directives: GraphQL::Language::Nodes::Directive,
+          fields: GraphQL::Language::Nodes::FieldDefinition,
+        })
+        self.children_method_name = :definitions
+      end
+
+      class InterfaceTypeDefinition < AbstractNode
+        include DefinitionNode
+        attr_reader :description
+        scalar_methods :name
+        children_methods({
+          interfaces: GraphQL::Language::Nodes::TypeName,
+          directives: GraphQL::Language::Nodes::Directive,
+          fields: GraphQL::Language::Nodes::FieldDefinition,
+        })
+        self.children_method_name = :definitions
+      end
+
+      class InterfaceTypeExtension < AbstractNode
+        scalar_methods :name
+        children_methods({
+          interfaces: GraphQL::Language::Nodes::TypeName,
+          directives: GraphQL::Language::Nodes::Directive,
+          fields: GraphQL::Language::Nodes::FieldDefinition,
+        })
+        self.children_method_name = :definitions
+      end
+
+      class UnionTypeDefinition < AbstractNode
+        include DefinitionNode
+        attr_reader :description, :types
+        scalar_methods :name
+        children_methods({
+          directives: GraphQL::Language::Nodes::Directive,
+        })
+        self.children_method_name = :definitions
+      end
+
+      class UnionTypeExtension < AbstractNode
+        attr_reader :types
+        scalar_methods :name
+        children_methods({
+          directives: GraphQL::Language::Nodes::Directive,
+        })
+        self.children_method_name = :definitions
+      end
+
+      class EnumValueDefinition < AbstractNode
+        include DefinitionNode
+        attr_reader :description
+        scalar_methods :name
+        children_methods({
+          directives: GraphQL::Language::Nodes::Directive,
+        })
+        self.children_method_name = :values
+      end
+
+      class EnumTypeDefinition < AbstractNode
+        include DefinitionNode
+        attr_reader :description
+        scalar_methods :name
+        children_methods({
+          directives: GraphQL::Language::Nodes::Directive,
+          values: GraphQL::Language::Nodes::EnumValueDefinition,
+        })
+        self.children_method_name = :definitions
+      end
+
+      class EnumTypeExtension < AbstractNode
+        scalar_methods :name
+        children_methods({
+          directives: GraphQL::Language::Nodes::Directive,
+          values: GraphQL::Language::Nodes::EnumValueDefinition,
+        })
+        self.children_method_name = :definitions
+      end
+
+      class InputObjectTypeDefinition < AbstractNode
+        include DefinitionNode
+        attr_reader :description
+        scalar_methods :name
+        children_methods({
+          directives: GraphQL::Language::Nodes::Directive,
+          fields: GraphQL::Language::Nodes::InputValueDefinition,
+        })
+        self.children_method_name = :definitions
+      end
+
+      class InputObjectTypeExtension < AbstractNode
+        scalar_methods :name
+        children_methods({
+          directives: GraphQL::Language::Nodes::Directive,
+          fields: GraphQL::Language::Nodes::InputValueDefinition,
+        })
+        self.children_method_name = :definitions
+      end
     end
   end
 end