rails-graphql 0.1.0

data/ext/libgraphqlparser/CONTRIBUTING.md

@@ -0,0 +1,23 @@
+# Contributing to libgraphqlparser
+
+Please see the Code of Conduct featured at https://github.com/graphql/foundation
+
+## Pull Requests
+We actively welcome your pull requests.
+
+1. Fork the repo and create your branch from `master`.
+2. If you've added code that should be tested, add tests
+3. If you've changed APIs, update the documentation.
+4. Ensure the test suite passes.
+5. Make sure your code lints.
+
+## Issues
+We use GitHub issues to track public bugs. Please ensure your description is
+clear and has sufficient instructions to be able to reproduce the issue.
+
+If you find a security bug, please contact the project administrators,
+and do not file a public issue.
+
+## License
+By contributing to libgraphqlparser, you agree that your contributions
+will be licensed under the LICENSE file in the project root directory.

data/ext/libgraphqlparser/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/libgraphqlparser/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/libgraphqlparser/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

data/ext/libgraphqlparser/JsonVisitor.h

@@ -0,0 +1,121 @@
+/**
+ * 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 "AstNode.h"
+#include "AstVisitor.h"
+
+#include <sstream>
+#include <vector>
+
+namespace facebook {
+namespace graphql {
+namespace ast {
+namespace visitor {
+
+/**
+ * Produces a JSON string describing the visited AST, in a format that
+ * would be a valid graphql-js AST when parsed.
+ */
+class JsonVisitor : public AstVisitor {
+ private:
+  using ChildrenList = std::vector<std::string>;
+  // Stack of lists of printed children.
+  // Postvisit method precondition: printed.back() contains strings
+  // for this node's children.
+  // Postvisit method postcondition: *(printed.rbegin() - 1) has had this
+  std::vector<ChildrenList> printed_;
+
+  // Interface to print fields for each kind of node.
+  // Note that, because of the post-order traversal for printing,
+  // field values need not be passed explicitly; they are grabbed from
+  // the passed-in visitor!
+  class NodeFieldPrinter {
+   private:
+    JsonVisitor &visitor_;
+    ChildrenList::const_iterator nextChild_;
+    std::ostringstream out_;
+
+    void printFieldSeparator();
+
+    // Prints a non-null array of n children from the given
+    // iterator. Does not update the iterator.
+    void printChildList(
+      std::ostringstream &out,
+      const std::vector<std::string>::const_iterator &childIterator,
+      size_t numChildren);
+
+    void printLocation(std::ostringstream &out, const yy::location &location);
+
+   public:
+    // Begin printing the fields for a node of the given kind at the
+    // given location.
+    NodeFieldPrinter(
+      JsonVisitor &visitor,
+      const char *nodeKind,
+      const Node &node);
+
+    std::string finishPrinting();
+
+    void printSingularPrimitiveField(const char *fieldName, const char *value);
+    void printSingularBooleanField(const char *fieldName, bool value);
+    void printSingularObjectField(const char *fieldName);
+    void printNullableSingularObjectField(const char *fieldName, const void *value);
+
+    template <typename T>
+      void printPluralField(
+        const char *fieldName,
+        const std::vector<std::unique_ptr<T>> &value) {
+      printFieldSeparator();
+      out_ << '"' << fieldName << "\":";
+      printChildList(out_, nextChild_, value.size());
+      nextChild_ += value.size();
+    }
+
+    template <typename T>
+    void printNullablePluralField(
+        const char *fieldName,
+        const std::vector<std::unique_ptr<T>> *value) {
+      printFieldSeparator();
+      out_ << '"' << fieldName << "\":";
+      if (value == nullptr) {
+        out_ << "null";
+      } else {
+        printChildList(out_, nextChild_, value->size());
+        nextChild_ += value->size();
+      }
+    }
+  };
+
+  // Must be called at the start of all visit methods for node types
+  // that have children. Maintains printed_.
+  void visitNode();
+
+  // Must be called at the end of all visit methods for node types
+  // that have children, passing the text for this node. Maintains
+  // printed_.
+  void endVisitNode(std::string &&str);
+
+  // Prints one of the many FooValue types that is prepresented with a
+  // single string.
+  template <typename ValueNode>
+  void endVisitValueRepresentedAsString(const char *valueKind, const ValueNode &value);
+
+public:
+  JsonVisitor();
+  ~JsonVisitor() {}
+
+  std::string getResult() const;
+
+  #include "JsonVisitor.h.inc"
+};
+
+}
+}
+}
+}

data/ext/libgraphqlparser/LICENSE

@@ -0,0 +1,22 @@
+MIT License
+
+Copyright 2015-2018, Facebook, Inc.
+Copyright 2019-present, GraphQL Foundation
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.