zf

render.ex (5899B)

---

 defmodule Absinthe.Language.Render do
   @moduledoc false
   import Inspect.Algebra
   import Absinthe.Utils.Render
 
   @line_width 120
 
   def inspect(term, %{pretty: true}) do
     term
     |> render()
     |> concat(line())
     |> format(@line_width)
     |> to_string
   end
 
   def inspect(term, options) do
     Inspect.Any.inspect(term, options)
   end
 
   defp render(bp)
 
   defp render(%Absinthe.Language.Document{} = doc) do
     doc.definitions |> Enum.map(&render/1) |> join([line(), line()])
   end
 
   defp render(%Absinthe.Language.OperationDefinition{} = op) do
     if op.shorthand do
       concat(operation_definition(op), block(render_list(op.selection_set.selections)))
     else
       glue(
         concat([to_string(op.operation), operation_definition(op)]),
         block(render_list(op.selection_set.selections))
       )
     end
   end
 
   defp render(%Absinthe.Language.Field{} = field) do
     case field.selection_set do
       nil ->
         field_definition(field)
 
       selection_set ->
         concat([
           field_definition(field),
           " ",
           block(render_list(selection_set.selections))
         ])
     end
   end
 
   defp render(%Absinthe.Language.VariableDefinition{} = variable_definition) do
     concat([
       "$",
       variable_definition.variable.name,
       ": ",
       render(variable_definition.type),
       default_value(variable_definition)
     ])
   end
 
   defp render(%Absinthe.Language.NamedType{} = named_type) do
     named_type.name
   end
 
   defp render(%Absinthe.Language.NonNullType{} = non_null) do
     concat(render(non_null.type), "!")
   end
 
   defp render(%Absinthe.Language.Argument{} = argument) do
     concat([argument.name, ": ", render(argument.value)])
   end
 
   defp render(%Absinthe.Language.Directive{} = directive) do
     concat([" @", directive.name, arguments(directive.arguments)])
   end
 
   defp render(%Absinthe.Language.FragmentSpread{} = spread) do
     concat(["...", spread.name, directives(spread.directives)])
   end
 
   defp render(%Absinthe.Language.InlineFragment{} = fragment) do
     concat([
       "...",
       inline_fragment_name(fragment),
       directives(fragment.directives),
       " ",
       block(render_list(fragment.selection_set.selections))
     ])
   end
 
   defp render(%Absinthe.Language.Variable{} = variable) do
     concat("$", variable.name)
   end
 
   defp render(%Absinthe.Language.StringValue{value: value}) do
     render_string_value(value)
   end
 
   defp render(%Absinthe.Language.FloatValue{value: value}) do
     "#{value}"
   end
 
   defp render(%Absinthe.Language.ObjectField{} = object_field) do
     concat([object_field.name, ": ", render(object_field.value)])
   end
 
   defp render(%Absinthe.Language.ObjectValue{fields: fields}) do
     fields = fields |> Enum.map(&render(&1)) |> join(", ")
 
     concat(["{ ", fields, " }"])
   end
 
   defp render(%Absinthe.Language.NullValue{}) do
     "null"
   end
 
   defp render(%Absinthe.Language.ListType{type: type}) do
     concat(["[", render(type), "]"])
   end
 
   defp render(%Absinthe.Language.ListValue{values: values}) do
     values = values |> Enum.map(&render(&1)) |> join(", ")
 
     concat(["[", values, "]"])
   end
 
   defp render(%Absinthe.Language.Fragment{} = fragment) do
     concat([
       "fragment ",
       fragment.name,
       " on ",
       fragment.type_condition.name,
       directives(fragment.directives)
     ])
     |> block(render_list(fragment.selection_set.selections))
   end
 
   defp render(%{value: value}) do
     to_string(value)
   end
 
   defp operation_definition(%{name: nil} = op) do
     case op.variable_definitions do
       [] ->
         concat(
           variable_definitions(op.variable_definitions),
           directives(op.directives)
         )
 
       _ ->
         operation_definition(%{op | name: ""})
     end
   end
 
   defp operation_definition(%{name: name} = op) do
     concat([" ", name, variable_definitions(op.variable_definitions), directives(op.directives)])
   end
 
   defp variable_definitions([]) do
     empty()
   end
 
   defp variable_definitions(definitions) do
     definitions = Enum.map(definitions, &render(&1))
 
     concat([
       "(",
       join(definitions, ", "),
       ")"
     ])
   end
 
   defp field_definition(field) do
     concat([
       field_alias(field),
       field.name,
       arguments(field.arguments),
       directives(field.directives)
     ])
   end
 
   defp default_value(%{default_value: nil}) do
     empty()
   end
 
   defp default_value(%{default_value: value}) do
     concat(" = ", render(value))
   end
 
   defp directives([]) do
     empty()
   end
 
   defp directives(directives) do
     directives |> Enum.map(&render(&1)) |> join(" ")
   end
 
   defp inline_fragment_name(%{type_condition: nil}) do
     empty()
   end
 
   defp inline_fragment_name(%{type_condition: %{name: name}}) do
     " on #{name}"
   end
 
   defp field_alias(%{alias: nil}) do
     empty()
   end
 
   defp field_alias(%{alias: alias}) do
     concat(alias, ": ")
   end
 
   defp arguments([]) do
     empty()
   end
 
   defp arguments(args) do
     group(
       glue(
         nest(
           glue(
             "(",
             "",
             render_list(args, ", ")
           ),
           2,
           :break
         ),
         "",
         ")"
       )
     )
   end
 
   # Helpers
 
   defp block(docs) do
     do_block(docs)
   end
 
   defp block(:doc_nil, docs) do
     do_block(docs)
   end
 
   defp block(name, docs) do
     glue(
       name,
       do_block(docs)
     )
   end
 
   defp do_block(docs) do
     group(
       glue(
         nest(
           force_unfit(
             glue(
               "{",
               "",
               docs
             )
           ),
           2,
           :always
         ),
         "",
         "}"
       )
     )
   end
 
   defp render_list(items, separator \\ line()) do
     List.foldr(items, :doc_nil, fn
       item, :doc_nil -> render(item)
       item, acc -> concat([render(item)] ++ [separator] ++ [acc])
     end)
   end
 end