rails-graphql 0.1.0

data/ext/graphqlparser/AstNode.h

@@ -0,0 +1,36 @@
+/**
+ * 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.
+ */
+
+#pragma once
+
+#include "location.hh"
+
+namespace facebook {
+namespace graphql {
+namespace ast {
+
+namespace visitor {
+class AstVisitor;
+}
+
+class Node {
+  yy::location location_;
+public:
+  explicit Node(const yy::location &location)
+    : location_(location) {}
+
+  virtual ~Node() {}
+
+  const yy::location &getLocation() const
+  { return location_; }
+
+  virtual void accept(visitor::AstVisitor *visitor) const = 0;
+};
+
+}
+}
+}

data/ext/graphqlparser/AstVisitor.h

@@ -0,0 +1,137 @@
+/**
+ * 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.
+ */
+/** @generated */
+
+#pragma once
+
+#include "Ast.h"
+
+namespace facebook {
+namespace graphql {
+namespace ast {
+namespace visitor {
+
+class AstVisitor {
+public:
+  virtual ~AstVisitor() {}
+
+  virtual bool visitDocument(const Document &document) { return true; }
+  virtual void endVisitDocument(const Document &document) { }
+
+  virtual bool visitOperationDefinition(const OperationDefinition &operationDefinition) { return true; }
+  virtual void endVisitOperationDefinition(const OperationDefinition &operationDefinition) { }
+
+  virtual bool visitVariableDefinition(const VariableDefinition &variableDefinition) { return true; }
+  virtual void endVisitVariableDefinition(const VariableDefinition &variableDefinition) { }
+
+  virtual bool visitSelectionSet(const SelectionSet &selectionSet) { return true; }
+  virtual void endVisitSelectionSet(const SelectionSet &selectionSet) { }
+
+  virtual bool visitField(const Field &field) { return true; }
+  virtual void endVisitField(const Field &field) { }
+
+  virtual bool visitArgument(const Argument &argument) { return true; }
+  virtual void endVisitArgument(const Argument &argument) { }
+
+  virtual bool visitFragmentSpread(const FragmentSpread &fragmentSpread) { return true; }
+  virtual void endVisitFragmentSpread(const FragmentSpread &fragmentSpread) { }
+
+  virtual bool visitInlineFragment(const InlineFragment &inlineFragment) { return true; }
+  virtual void endVisitInlineFragment(const InlineFragment &inlineFragment) { }
+
+  virtual bool visitFragmentDefinition(const FragmentDefinition &fragmentDefinition) { return true; }
+  virtual void endVisitFragmentDefinition(const FragmentDefinition &fragmentDefinition) { }
+
+  virtual bool visitVariable(const Variable &variable) { return true; }
+  virtual void endVisitVariable(const Variable &variable) { }
+
+  virtual bool visitIntValue(const IntValue &intValue) { return true; }
+  virtual void endVisitIntValue(const IntValue &intValue) { }
+
+  virtual bool visitFloatValue(const FloatValue &floatValue) { return true; }
+  virtual void endVisitFloatValue(const FloatValue &floatValue) { }
+
+  virtual bool visitStringValue(const StringValue &stringValue) { return true; }
+  virtual void endVisitStringValue(const StringValue &stringValue) { }
+
+  virtual bool visitBooleanValue(const BooleanValue &booleanValue) { return true; }
+  virtual void endVisitBooleanValue(const BooleanValue &booleanValue) { }
+
+  virtual bool visitNullValue(const NullValue &nullValue) { return true; }
+  virtual void endVisitNullValue(const NullValue &nullValue) { }
+
+  virtual bool visitEnumValue(const EnumValue &enumValue) { return true; }
+  virtual void endVisitEnumValue(const EnumValue &enumValue) { }
+
+  virtual bool visitListValue(const ListValue &listValue) { return true; }
+  virtual void endVisitListValue(const ListValue &listValue) { }
+
+  virtual bool visitObjectValue(const ObjectValue &objectValue) { return true; }
+  virtual void endVisitObjectValue(const ObjectValue &objectValue) { }
+
+  virtual bool visitObjectField(const ObjectField &objectField) { return true; }
+  virtual void endVisitObjectField(const ObjectField &objectField) { }
+
+  virtual bool visitDirective(const Directive &directive) { return true; }
+  virtual void endVisitDirective(const Directive &directive) { }
+
+  virtual bool visitNamedType(const NamedType &namedType) { return true; }
+  virtual void endVisitNamedType(const NamedType &namedType) { }
+
+  virtual bool visitListType(const ListType &listType) { return true; }
+  virtual void endVisitListType(const ListType &listType) { }
+
+  virtual bool visitNonNullType(const NonNullType &nonNullType) { return true; }
+  virtual void endVisitNonNullType(const NonNullType &nonNullType) { }
+
+  virtual bool visitName(const Name &name) { return true; }
+  virtual void endVisitName(const Name &name) { }
+
+  virtual bool visitSchemaDefinition(const SchemaDefinition &schemaDefinition) { return true; }
+  virtual void endVisitSchemaDefinition(const SchemaDefinition &schemaDefinition) { }
+
+  virtual bool visitOperationTypeDefinition(const OperationTypeDefinition &operationTypeDefinition) { return true; }
+  virtual void endVisitOperationTypeDefinition(const OperationTypeDefinition &operationTypeDefinition) { }
+
+  virtual bool visitScalarTypeDefinition(const ScalarTypeDefinition &scalarTypeDefinition) { return true; }
+  virtual void endVisitScalarTypeDefinition(const ScalarTypeDefinition &scalarTypeDefinition) { }
+
+  virtual bool visitObjectTypeDefinition(const ObjectTypeDefinition &objectTypeDefinition) { return true; }
+  virtual void endVisitObjectTypeDefinition(const ObjectTypeDefinition &objectTypeDefinition) { }
+
+  virtual bool visitFieldDefinition(const FieldDefinition &fieldDefinition) { return true; }
+  virtual void endVisitFieldDefinition(const FieldDefinition &fieldDefinition) { }
+
+  virtual bool visitInputValueDefinition(const InputValueDefinition &inputValueDefinition) { return true; }
+  virtual void endVisitInputValueDefinition(const InputValueDefinition &inputValueDefinition) { }
+
+  virtual bool visitInterfaceTypeDefinition(const InterfaceTypeDefinition &interfaceTypeDefinition) { return true; }
+  virtual void endVisitInterfaceTypeDefinition(const InterfaceTypeDefinition &interfaceTypeDefinition) { }
+
+  virtual bool visitUnionTypeDefinition(const UnionTypeDefinition &unionTypeDefinition) { return true; }
+  virtual void endVisitUnionTypeDefinition(const UnionTypeDefinition &unionTypeDefinition) { }
+
+  virtual bool visitEnumTypeDefinition(const EnumTypeDefinition &enumTypeDefinition) { return true; }
+  virtual void endVisitEnumTypeDefinition(const EnumTypeDefinition &enumTypeDefinition) { }
+
+  virtual bool visitEnumValueDefinition(const EnumValueDefinition &enumValueDefinition) { return true; }
+  virtual void endVisitEnumValueDefinition(const EnumValueDefinition &enumValueDefinition) { }
+
+  virtual bool visitInputObjectTypeDefinition(const InputObjectTypeDefinition &inputObjectTypeDefinition) { return true; }
+  virtual void endVisitInputObjectTypeDefinition(const InputObjectTypeDefinition &inputObjectTypeDefinition) { }
+
+  virtual bool visitTypeExtensionDefinition(const TypeExtensionDefinition &typeExtensionDefinition) { return true; }
+  virtual void endVisitTypeExtensionDefinition(const TypeExtensionDefinition &typeExtensionDefinition) { }
+
+  virtual bool visitDirectiveDefinition(const DirectiveDefinition &directiveDefinition) { return true; }
+  virtual void endVisitDirectiveDefinition(const DirectiveDefinition &directiveDefinition) { }
+
+};
+
+}
+}
+}
+}

data/ext/graphqlparser/GraphQLParser.cpp

@@ -0,0 +1,76 @@
+/**
+ * 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.
+ */
+
+#include "GraphQLParser.h"
+
+#include "AstNode.h"
+
+#include "parser.tab.hpp"
+#include "lexer.h"
+#include "syntaxdefs.h"
+
+namespace facebook {
+namespace graphql {
+
+// Given properly-configured yylex, run the parser and return the
+// result.
+static std::unique_ptr<ast::Node> doParse(const char **outError, yyscan_t scanner, bool enableSchema) {
+  Node *outAST = nullptr;
+  yy::GraphQLParserImpl parser(enableSchema, &outAST, outError, scanner);
+  int failure = parser.parse();
+  if (failure) {
+    delete outAST;
+  }
+  return !failure ? std::unique_ptr<ast::Node>(outAST) : nullptr;
+}
+
+static std::unique_ptr<ast::Node> parseStringImpl(const char *text, const char **error, bool enableSchema) {
+  yyscan_t scanner;
+  struct LexerExtra extra;
+  yylex_init_extra(&extra, &scanner);
+  YY_BUFFER_STATE buffer = yy_scan_string(text, scanner);
+  yy_switch_to_buffer(buffer, scanner);
+
+  auto result = doParse(error, scanner, enableSchema);
+  yylex_destroy(scanner);
+  return result;
+}
+
+std::unique_ptr<ast::Node> parseString(const char *text, const char **error) {
+  return parseStringImpl(text, error, false);
+}
+
+std::unique_ptr<ast::Node> parseStringWithExperimentalSchemaSupport(
+    const char *text, const char **error) {
+  return parseStringImpl(text, error, true);
+}
+
+static std::unique_ptr<ast::Node> parseFileImpl(
+    FILE *file, const char **error, bool enableSchema) {
+  yyscan_t scanner;
+  struct LexerExtra extra;
+  yylex_init_extra(&extra, &scanner);
+  yyset_in(file, scanner);
+
+  auto result = doParse(error, scanner, enableSchema);
+  yylex_destroy(scanner);
+
+  return result;
+}
+
+std::unique_ptr<ast::Node> parseFile(FILE *file, const char **error) {
+  return parseFileImpl(file, error, false);
+}
+
+std::unique_ptr<ast::Node> parseFileWithExperimentalSchemaSupport(
+    FILE *file, const char **error) {
+  return parseFileImpl(file, error, true);
+}
+
+
+}  // namespace graphql
+}  // namespace facebook

data/ext/graphqlparser/GraphQLParser.h

@@ -0,0 +1,55 @@
+/**
+ * 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.
+ */
+
+/**
+ * The purpose of this file is to provide a nice interface to parsing
+ * GraphQL, rather than the old-fashioned interface provided by bison
+ * and flex.
+ */
+
+#pragma once
+
+#include <memory>
+#include <stdio.h>
+
+namespace facebook {
+namespace graphql {
+
+namespace ast {
+  class Node;
+}
+
+/**
+ * Parse the given GraphQL source string, returning an AST. Returns
+ * nullptr on error and, if error is not null, places a string
+ * describing what went wrong in error that must be freed with free(3).
+ */
+std::unique_ptr<ast::Node> parseString(const char *text, const char **error);
+
+/**
+ * Like parseString, but enables support for the experimental type
+ * definition syntax from https://github.com/facebook/graphql/pull/90 .
+ */
+std::unique_ptr<ast::Node> parseStringWithExperimentalSchemaSupport(
+  const char *text, const char **error);
+
+/**
+ * Read and parse GraphQL source from the given file, returning an
+ * AST. Returns nullptr on error and, if error is not null, places an
+ * error string in error that must be freed with free(3).
+ */
+std::unique_ptr<ast::Node> parseFile(FILE *file, const char **error);
+
+/**
+ * Like parseFile, but enables support for the experimental type
+ * definition syntax from https://github.com/facebook/graphql/pull/90 .
+ */
+std::unique_ptr<ast::Node> parseFileWithExperimentalSchemaSupport(
+  FILE *file, const char **error);
+
+}
+}

data/ext/graphqlparser/JsonVisitor.cpp

@@ -0,0 +1,161 @@
+/**
+ * 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.
+ */
+
+#include "position.hh"
+#include "JsonVisitor.h"
+
+#include <cassert>
+#include <iterator>
+
+namespace facebook {
+namespace graphql {
+namespace ast {
+namespace visitor {
+
+static std::string escape(const char *s) {
+  static char hex[16] = {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f'};
+  std::string result;
+  while (unsigned char ch = *s++) {
+    if (ch >= '\0' && ch <= '\x1f') {
+      result.push_back('\\');
+      result.push_back('u');
+      result.push_back('0');
+      result.push_back('0');
+      result.push_back(ch >= 16 ? '1' : '0');
+      result.push_back(hex[ch % 16]);
+    } else if (ch == '"') {
+      result.push_back('\\');
+      result.push_back('"');
+    } else if (ch == '\\') {
+      result.push_back('\\');
+      result.push_back('\\');
+    } else {
+      result.push_back(ch);
+    }
+  }
+  return result;
+}
+
+JsonVisitor::NodeFieldPrinter::NodeFieldPrinter(
+    JsonVisitor &visitor,
+    const char *nodeKind,
+    const Node &node)
+    : visitor_(visitor)
+{
+  if (!visitor_.printed_.empty()) {
+    nextChild_ = visitor_.printed_.back().begin();
+  }
+  // NOTE: If you're an Emacs user and this file's use of C++11 raw
+  // strings doesn't highlight correctly in c++-mode, try upgrading to
+  // Emacs 26 if you can.
+  out_ << R"({"kind":")" << nodeKind << R"(","loc":)";
+  printLocation(out_, node.getLocation());
+}
+
+std::string JsonVisitor::NodeFieldPrinter::finishPrinting() {
+  assert(!out_.str().empty());
+  out_ << '}';
+  auto result(out_.str());
+#ifndef NDEBUG
+  out_.str("");
+#endif
+  return result;
+
+}
+
+void JsonVisitor::NodeFieldPrinter::printFieldSeparator()
+{
+  out_ << ',';
+}
+
+void JsonVisitor::NodeFieldPrinter::printSingularPrimitiveField(
+    const char *fieldName,
+    const char *value) {
+  printFieldSeparator();
+  out_ << '"' << fieldName << R"(":)";
+  out_ << '"' << escape(value) << '"';
+}
+
+void JsonVisitor::NodeFieldPrinter::printSingularBooleanField(
+    const char *fieldName,
+    bool value) {
+  printFieldSeparator();
+  out_ << '"' << fieldName << R"(":)";
+  out_ << (value ? "true" : "false");
+}
+
+void JsonVisitor::NodeFieldPrinter::printSingularObjectField(const char *fieldName) {
+  printFieldSeparator();
+  out_ << '"' << fieldName << R"(":)";
+  assert(!visitor_.printed_.empty());
+  out_ << *nextChild_++;
+}
+
+void JsonVisitor::NodeFieldPrinter::printNullableSingularObjectField(
+    const char *fieldName,
+    const void *value) {
+  printFieldSeparator();
+  out_ << '"' << fieldName << R"(":)";
+  if (value != nullptr) {
+    assert(!visitor_.printed_.empty());
+    out_ << *nextChild_++;
+  } else {
+    out_ << "null";
+  }
+}
+
+// Method invariant: printed_ contains strings for this node's children.
+void JsonVisitor::NodeFieldPrinter::printLocation(
+    std::ostringstream &out,
+    const yy::location &location)
+{
+  out << R"({"start": {"line": )" << location.begin.line
+       << R"(,"column":)" << location.begin.column
+       << R"(}, "end": {"line":)" << location.end.line
+       << R"(,"column":)" << location.end.column
+       << "}}";
+}
+
+void JsonVisitor::NodeFieldPrinter::printChildList(
+    std::ostringstream &out,
+    const std::vector<std::string>::const_iterator &childIterator,
+    size_t numChildren) {
+  out << '[';
+  for (size_t ii = 0; ii < numChildren; ++ii) {
+    if (ii != 0) {
+      out << ',';
+    }
+    out << *(childIterator + ii);
+  }
+  out << ']';
+}
+
+JsonVisitor::JsonVisitor() {
+  printed_.emplace_back();
+}
+
+void JsonVisitor::visitNode() {
+  printed_.emplace_back();
+}
+
+void JsonVisitor::endVisitNode(std::string &&str) {
+  printed_.pop_back();
+  printed_.back().emplace_back(std::move(str));
+}
+
+std::string JsonVisitor::getResult() const {
+  assert(printed_.size() == 1);
+  assert(printed_[0].size() == 1);
+  return printed_[0][0];
+}
+
+#include "JsonVisitor.cpp.inc"
+
+}  // namespace visitor
+}  // namespace ast
+}  // namespace graphql
+}  // namespace facebook