Broke down the Executor into modules and protocols

The code is now in smaller chunks and easier to understand but tests now
run 2 seconds slower on my MacBook Pro. (4.0s -> 6.0s).

I think this is mostly down to the introduction Completion protocol
which replaced all of the complete_value methods in the Executor.

Author: freshtonic

lib/graphql/execution/arguments.ex

@@ -0,0 +1,26 @@
+
+defmodule GraphQL.Execution.Arguments do
+  alias GraphQL.Execution.ASTValue
+
+  def argument_values(arg_defs, arg_asts, variable_values) do
+    arg_ast_map = Enum.reduce arg_asts, %{}, fn(arg_ast, result) ->
+      Map.put(result, String.to_atom(arg_ast.name.value), arg_ast)
+    end
+    Enum.reduce(arg_defs, %{}, fn(arg_def, result) ->
+      {arg_def_name, arg_def_type} = arg_def
+      value_ast = Map.get(arg_ast_map, arg_def_name)
+
+      value = ASTValue.value_from_ast(value_ast, arg_def_type.type, variable_values)
+      value = if is_nil(value) do
+        Map.get(arg_def_type, :defaultValue)
+      else
+        value
+      end
+      if is_nil(value) do
+        result
+      else
+        Map.put(result, arg_def_name, value)
+      end
+    end)
+  end
+end

lib/graphql/execution/ast_value.ex

@@ -0,0 +1,59 @@
+
+defmodule GraphQL.Execution.ASTValue do
+  alias GraphQL.Type.NonNull
+  alias GraphQL.Type.List
+  alias GraphQL.Type.Input
+  alias GraphQL.Type.NonNull
+  alias GraphQL.Type.CompositeType
+
+  def value_from_ast(value_ast, %NonNull{ofType: inner_type}, variable_values) do
+    value_from_ast(value_ast, inner_type, variable_values)
+  end
+
+  def value_from_ast(%{value: obj=%{kind: :ObjectValue}}, type=%Input{}, variable_values) do
+    input_fields = CompositeType.get_fields(type)
+    field_asts = Enum.reduce(obj.fields, %{}, fn(ast, result) ->
+      Map.put(result, ast.name.value, ast)
+    end)
+    Enum.reduce(Map.keys(input_fields), %{}, fn(field_name, result) ->
+      field = Map.get(input_fields, field_name)
+      field_ast =  Map.get(field_asts, to_string(field_name)) # this feels... brittle.
+      inner_result = value_from_ast(field_ast, field.type, variable_values)
+      case inner_result do
+        nil -> result
+        _ -> Map.put(result, field_name, inner_result)
+      end
+    end)
+  end
+
+  def value_from_ast(%{value: %{kind: :Variable, name: %{value: value}}}, type, variable_values) do
+    case Map.get(variable_values, value) do
+      nil -> nil
+      variable_value -> GraphQL.Types.parse_value(type, variable_value)
+    end
+  end
+
+  # if it isn't a variable or object input type, that means it's invalid
+  # and we shoud return a nil
+  def value_from_ast(_, %Input{}, _), do: nil
+
+  def value_from_ast(%{value: %{kind: :ListValue, values: values_ast}}, type, _) do
+    GraphQL.Types.parse_value(type, Enum.map(values_ast, fn(value_ast) ->
+      value_ast.value
+    end))
+  end
+
+  def value_from_ast(value_ast, %List{ofType: inner_type}, variable_values) do
+    [value_from_ast(value_ast, inner_type, variable_values)]
+  end
+
+  def value_from_ast(nil, _, _), do: nil # remove once NonNull is actually done..
+
+  def value_from_ast(value_ast, type, variable_values) when is_atom(type) do
+    value_from_ast(value_ast, type.type, variable_values)
+  end
+
+  def value_from_ast(value_ast, type, _) do
+    GraphQL.Types.parse_literal(type, value_ast.value)
+  end
+end

lib/graphql/execution/completion.ex

@@ -0,0 +1,8 @@
+
+defprotocol GraphQL.Execution.Completion do
+  @fallback_to_any true
+
+  @spec complete_value(any, ExecutionContext.t, GraphQL.Document.t, map, map) :: {ExecutionContext.t, any}
+  def complete_value(type, context, field_asts, info, result)
+end
+

lib/graphql/execution/completion_any.ex

@@ -0,0 +1,9 @@
+
+defimpl GraphQL.Execution.Completion, for: Any do
+  alias GraphQL.Execution.Types
+
+  def complete_value(return_type, context, _field_asts, _info, result) do
+    {context, GraphQL.Types.serialize(Types.unwrap_type(return_type), result)}
+  end
+end
+

lib/graphql/execution/completion_atom.ex

@@ -0,0 +1,9 @@
+defimpl GraphQL.Execution.Completion, for: Atom do
+  alias GraphQL.Execution.Completion
+  alias GraphQL.Execution.Types
+
+  def complete_value(return_type, context, field_asts, info, result) do
+    Completion.complete_value(Types.unwrap_type(return_type), context, field_asts, info, result)
+  end
+end
+

lib/graphql/execution/directives.ex

@@ -0,0 +1,15 @@
+
+defmodule GraphQL.Execution.Directives do
+  alias GraphQL.Execution.Arguments
+
+  def resolve_directive(context, directives, directive_name) do
+    ast = Enum.find(directives, fn(d) -> d.name.value == Atom.to_string(directive_name) end)
+    if ast do
+      directive = apply(GraphQL.Type.Directives, directive_name, [])
+      %{if: val} = Arguments.argument_values(directive.args, ast.arguments, context.variable_values)
+      val
+    else
+      directive_name == :include
+    end
+  end
+end