rails-graphql 0.1.0

data/ext/libgraphqlparser/README.clang-tidy

@@ -0,0 +1,7 @@
+* readability-implicit-bool is disabled because I disagree with it.
+
+* cppcoreguidelines-pro-type-reinterpret-cast is disabled because we use it
+  to implement our C API.
+  
+* cppcoreguidelines-pro-bounds-array-to-pointer-decay is disabled
+  because it fires a false positive on every use of assert().

data/ext/libgraphqlparser/README.md

@@ -0,0 +1,84 @@
+# libgraphqlparser
+
+libgraphqlparser is a parser for
+[GraphQL](http://graphql.org/), a query language for describing data
+requirements on complex application data models, implemented in C++11.
+It can be used on its own in C++ code (or in C code via the pure C API
+defined in the `c` subdirectory), or you can use it as the basis for an
+extension module for your favorite programming language instead of writing
+your own parser from scratch.
+
+## Example
+
+The provided `dump_json_ast` is a simple program that reads GraphQL
+text on stdin and prints a JSON representation of the AST to stdout.
+
+The `python` subdirectory contains an example Python binding for the
+pure C API.
+
+## Requirements
+
+libgraphqlparser requires a C++ compiler that supports C++11. It
+also requires Mac OS X or Linux.
+
+To run tests, first, compile and install the library as described above. Then,
+please download googletest from
+https://github.com/google/googletest/archive/release-1.8.0.zip
+and unzip it in the `test` subdirectory. In consequence, a folder
+`googletest-release-1.8.0` should be contained in `test`. Next, within the
+`test` folder, run `cmake .` and `make` to generate the `runTests` binary.
+To execute the tests run `./test/runTests` from the main folder.
+
+## Building libgraphqlparser
+
+libgraphqlparser is built with [CMake](http://www.cmake.org/). If a
+sufficiently-recent version of [Flex](http://flex.sourceforge.net/) and [Bison](http://www.gnu.org/software/bison/) are installed on your
+system, it will use them; otherwise, it will rely on the checked-in
+`parser.tab.{c,h}pp` and `lexer.{h,cpp}`.
+
+To build libgraphqlparser from source:
+
+```
+$ # inside the project root:
+$ cmake .
+$ make
+```
+
+Then, to install it on your system:
+
+```
+$ make install
+```
+
+## How libgraphqlparser works
+
+libgraphqlparser uses flex and bison to generate a C++ parser for
+GraphQL. These tools work well but have idiosyncratic interfaces by
+modern standards, so GraphQLParser.h provides a simple interface to
+parse GraphQL.
+
+In order to make it simpler to write code based around the GraphQL
+AST, libgraphqlparser includes an extremely simple code generation
+framework in the `ast/` subdirectory. This framework is used to build
+the AST classes themselves, as well as a visitor over the AST. It may
+be easier to understand the output of the generation steps directly
+(i.e., Ast.h, Ast.cpp, and AstVisitor.h) rather than trying to read
+the generation scripts. Simply building libgraphqlparser will cause
+these files to be generated.
+
+libgraphqlparser also uses the AST generation framework to build a
+pure C API in the `c` subdirectory. This API can be used from C code,
+and it should also simplify the task of creating bindings to other
+programming languages.
+
+## License
+
+libgraphqlparser is MIT-licensed.
+
+## Related Projects
+
+- [graphql-parser (Ruby interface)](https://github.com/Shopify/graphql-parser)
+- [py-graphqlparser (Python interface)](https://github.com/elastic-coders/py-graphqlparser)
+- [graphql_parser (Elixir interface)](https://github.com/aarvay/graphql_parser)
+- [graphql-parser-php (PHP interface)](https://github.com/dosten/graphql-parser-php)
+- [graphql-libgraphqlparser (Ruby interface)](https://github.com/rmosolgo/graphql-libgraphqlparser-ruby)

data/ext/libgraphqlparser/ast/ast.ast

@@ -0,0 +1,203 @@
+# Copyright 2019-present, GraphQL Foundation
+
+# Mini-language for AST definition.
+# All AST nodes extend AstNode.
+# All AST nodes are visitible.
+# All AST fields have a getter and a setter and are a constructor argument.
+# We have concrete types (code T) and unions (code U).
+# S for singular field, P for plural, ? for nullable.
+# O for option in a union.
+# Scalar type ontology: string, boolean
+
+# Definitions other than OperationDefinition and FragmentDefinition
+# are experimental additions for schema parsing. (We don't support
+# nested unions in the AST mini-language, so I've flattened and elided
+# TypeSystemDefinition and TypeDefinition.)
+U Definition
+O OperationDefinition
+O FragmentDefinition
+O SchemaDefinition
+O ScalarTypeDefinition
+O ObjectTypeDefinition
+O InterfaceTypeDefinition
+O UnionTypeDefinition
+O EnumTypeDefinition
+O InputObjectTypeDefinition
+O TypeExtensionDefinition
+O DirectiveDefinition
+
+
+T Document
+P Definition definitions
+
+T OperationDefinition
+S OperationKind operation
+S? Name name
+P? VariableDefinition variableDefinitions
+P? Directive directives
+S SelectionSet selectionSet
+
+T VariableDefinition
+S Variable variable
+S Type type
+S? Value defaultValue
+
+T SelectionSet
+P Selection selections
+
+U Selection
+O Field
+O FragmentSpread
+O InlineFragment
+
+T Field
+S? Name alias
+S Name name
+P? Argument arguments
+P? Directive directives
+S? SelectionSet selectionSet
+
+T Argument
+S Name name
+S Value value
+
+T FragmentSpread
+S Name name
+P? Directive directives
+
+T InlineFragment
+S? NamedType typeCondition
+P? Directive directives
+S SelectionSet selectionSet
+
+T FragmentDefinition
+S Name name
+S NamedType typeCondition
+P? Directive directives
+S SelectionSet selectionSet
+
+U Value
+O Variable
+O IntValue
+O FloatValue
+O StringValue
+O BooleanValue
+O NullValue
+O EnumValue
+O ListValue
+O ObjectValue
+
+T Variable
+S Name name
+
+T IntValue
+S string value
+
+T FloatValue
+S string value
+
+T StringValue
+S string value
+
+T BooleanValue
+S boolean value
+
+T NullValue
+
+T EnumValue
+S string value
+
+T ListValue
+P Value values
+
+T ObjectValue
+P ObjectField fields
+
+T ObjectField
+S Name name
+S Value value
+
+T Directive
+S Name name
+P? Argument arguments
+
+U Type
+O NamedType
+O ListType
+O NonNullType
+
+T NamedType
+S Name name
+
+T ListType
+S Type type
+
+T NonNullType
+# JS version prohibits nesting nonnull in nonnull, we can't because we
+# can't support multiple unions. Fix?
+S Type type
+
+T Name
+S string value
+
+T SchemaDefinition
+P? Directive directives
+P OperationTypeDefinition operationTypes
+
+T OperationTypeDefinition
+S OperationKind operation
+S NamedType type
+
+T ScalarTypeDefinition
+S Name name
+P? Directive directives
+
+T ObjectTypeDefinition
+S Name name
+P? NamedType interfaces
+P? Directive directives
+P FieldDefinition fields
+
+T FieldDefinition
+S Name name
+P? InputValueDefinition arguments
+S Type type
+P? Directive directives
+
+T InputValueDefinition
+S Name name
+S Type type
+S? Value defaultValue
+P? Directive directives
+
+T InterfaceTypeDefinition
+S Name name
+P? Directive directives
+P FieldDefinition fields
+
+T UnionTypeDefinition
+S Name name
+P? Directive directives
+P NamedType types
+
+T EnumTypeDefinition
+S Name name
+P? Directive directives
+P EnumValueDefinition values
+
+T EnumValueDefinition
+S Name name
+P? Directive directives
+
+T InputObjectTypeDefinition
+S Name name
+P? Directive directives
+P InputValueDefinition fields
+
+T TypeExtensionDefinition
+S ObjectTypeDefinition definition
+
+T DirectiveDefinition
+S Name name
+P? InputValueDefinition arguments
+P Name locations

data/ext/libgraphqlparser/ast/ast.py

@@ -0,0 +1,61 @@
+#!/usr/bin/env python
+# Copyright 2019-present, GraphQL Foundation
+#
+# This source code is licensed under the MIT license found in the
+# LICENSE file in the root directory of this source tree.
+
+from importlib import import_module
+
+def load_lang(lang):
+  return import_module(lang).Printer()
+
+
+def print_ast(lang_module, input_file):
+  lang_module.start_file()
+  line = input_file.readline()
+  while line:
+    line = line.strip()
+    if line.startswith('#') or not line:
+      line = input_file.readline()
+      continue
+
+    code, rest = line.split(None, 1)
+    if code[0] == 'T':
+      lang_module.start_type(rest)
+      field_line = input_file.readline().strip()
+      while field_line:
+        if field_line.startswith('#'):
+          field_line = input_file.readline().strip()
+          continue
+        field_kind, field_type, field_name = field_line.split()
+        nullable = len(field_kind) > 1 and field_kind[1] == '?'
+        if field_kind[0] == 'S':
+          plural = False
+        elif field_kind[0] == 'P':
+          plural = True
+        else:
+          raise Error('Unknown field kind: ' + field_kind)
+        lang_module.field(field_type, field_name, nullable, plural)
+        field_line = input_file.readline().strip()
+      lang_module.end_type(rest)
+    elif code[0] == 'U':
+      lang_module.start_union(rest)
+      field_line = input_file.readline().strip()
+      while field_line:
+        option_code, option_type = field_line.split()
+        if option_code != 'O':
+          raise Error('Unknown code in union: ' + option_code)
+        lang_module.union_option(option_type)
+        field_line = input_file.readline().strip()
+      lang_module.end_union(rest)
+    line = input_file.readline()
+
+  lang_module.end_file()
+if __name__ == '__main__':
+  import sys
+  lang = sys.argv[1]
+  filename = sys.argv[2]
+
+  lang_module = load_lang(lang)
+
+  print_ast(lang_module, open(filename, 'r'))

data/ext/libgraphqlparser/ast/c.py

@@ -0,0 +1,100 @@
+# Copyright 2019-present, GraphQL Foundation
+#
+# This source code is licensed under the MIT license found in the
+# LICENSE file in the root directory of this source tree.
+
+from casing import snake
+
+from license import C_LICENSE_COMMENT
+
+def struct_name(type):
+  return 'GraphQLAst' + type
+
+
+def return_type(type):
+  if type == 'OperationKind' or type == 'string':
+    return 'const char *'
+
+  if type == 'boolean':
+    return 'int'
+
+  return 'const struct %s *' % struct_name(type)
+
+
+def field_prototype(owning_type, type, name, nullable, plural):
+  st_name = struct_name(owning_type)
+  if plural:
+    return 'int %s_get_%s_size(const struct %s *node)' % (
+      st_name, snake(name), st_name)
+  else:
+    ret_type = return_type(type)
+    return '%s %s_get_%s(const struct %s *node)' % (
+      ret_type, st_name, snake(name), st_name)
+
+
+class Printer(object):
+  '''Printer for the pure C interface to the AST.
+
+  Merely a set of wrappers around the C++ interface; makes it possible
+  to use the AST from C code and simplifies the task of writing
+  bindings for other langugages.
+
+  The mapping is as follows:
+
+  - For each concrete type, you get an opaque C struct type,
+  accessible only by pointer.
+
+  - For each singular field of a concrete type, you get an accessor
+  function, returning said field in the obvious way.
+
+  - For each plural field of a concrete type, you get an accessor
+  function telling you its size. For access to elements of a plural
+  field, you can use the visitor API.
+
+  - For each union type, you get nothing specific (REVIEW), but you
+    can use the visitor API to work around this entirely.
+
+  '''
+
+  def __init__(self):
+    self._current_type = None
+
+  def start_file(self):
+    print C_LICENSE_COMMENT + '''/** @generated */
+
+#pragma once
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+'''
+
+  def end_file(self):
+    print '''
+
+#ifdef __cplusplus
+}
+#endif
+'''
+
+  def start_type(self, name):
+    # Forward declarations for AST nodes.
+    st_name = struct_name(name)
+    print 'struct ' + st_name + ';'
+    self._current_type = name
+
+  def field(self, type, name, nullable, plural):
+    print field_prototype(self._current_type, type, name, nullable, plural) + ';'
+
+  def end_type(self, name):
+    print
+
+  def start_union(self, name):
+    print 'struct ' + struct_name(name) + ';'
+
+  def union_option(self, option):
+    pass
+
+  def end_union(self, name):
+    print