rails-graphql 0.2.1 → 1.0.0.beta

data/ext/graphqlparser/c/GraphQLAstVisitor.cpp

@@ -1,55 +0,0 @@
-/**
- * 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 "c/GraphQLAstVisitor.h"
-#include "AstVisitor.h"
-
-using namespace facebook::graphql::ast; // NOLINT
-
-#include "c/GraphQLAstForEachConcreteType.h"
-
-#define DECLARE_VISIT(type, snake_type) \
-  bool visit##type(const type &node) override; \
-  void endVisit##type(const type &node) override;
-
-class CVisitorBridge : public visitor::AstVisitor {
-  const struct GraphQLAstVisitorCallbacks *callbacks_;
-  void *userData_;
-public:
-  explicit CVisitorBridge(const struct GraphQLAstVisitorCallbacks *callbacks,
-                          void *userData)
-    : callbacks_(callbacks), userData_(userData) {}
-
-  FOR_EACH_CONCRETE_TYPE(DECLARE_VISIT)
-};
-
-#define IMPLEMENT_VISIT(type, snake_type)                                \
-  bool CVisitorBridge::visit##type(const type &node) {                  \
-    if (callbacks_->visit_##snake_type) {                               \
-      return callbacks_->visit_##snake_type(                            \
-        (const struct GraphQLAst##type *)&node, userData_);             \
-    }                                                                   \
-    return true;                                                        \
-  }                                                                     \
-  void CVisitorBridge::endVisit##type(const type &node) {               \
-    if (callbacks_->end_visit_##snake_type) {                           \
-      callbacks_->end_visit_##snake_type(                               \
-        (const struct GraphQLAst##type *)&node, userData_);             \
-    }                                                                   \
-  }
-
-FOR_EACH_CONCRETE_TYPE(IMPLEMENT_VISIT)
-
-void graphql_node_visit(const struct GraphQLAstNode *node,
-                        const struct GraphQLAstVisitorCallbacks *callbacks,
-                        void *userData)
-{
-  CVisitorBridge visitor(callbacks, userData);
-  if (node) {
-    reinterpret_cast<const facebook::graphql::ast::Node *>(node)->accept(&visitor);
-  }
-}

data/ext/graphqlparser/c/GraphQLAstVisitor.h

@@ -1,53 +0,0 @@
-/**
- * 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 "c/GraphQLAst.h"
-#include "c/GraphQLAstForEachConcreteType.h"
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-  
-#define TYPEDEFS(type, snake_type)                                      \
-  typedef int (*visit_##snake_type##_func)(const struct GraphQLAst##type *snake_type, void *user_data); \
-  typedef void (*end_visit_##snake_type##_func)(const struct GraphQLAst##type *snake_type, void *user_data);
-
-FOR_EACH_CONCRETE_TYPE(TYPEDEFS)
-
-#define FUNC_MEMBER(type, snake_type)           \
-  visit_##snake_type##_func visit_##snake_type; \
-  end_visit_##snake_type##_func end_visit_##snake_type;
-/**
- * Functions to be called when particular AST nodes are encountered.
- * visit_* functions are called in pre-order, and may return non-zero to
- * continue recursing into children (if any), or zero to skip them. end_visit_*
- * functions are called in post-order. Any particular function may be set to
- * NULL to indicate that the caller is not interested in the corresponding type
- * of AST node. (NULL visit_* functions act as though they simply returned
- * non-zero.)
- */
-struct GraphQLAstVisitorCallbacks {
-  FOR_EACH_CONCRETE_TYPE(FUNC_MEMBER)
-};
-
-struct GraphQLAstNode;
-
-/**
- * Walk the AST rooted at the given node, issuing callbacks from the given
- * callbacks struct as appropriate. userData will be passed as the userData
- * argument to each callback.
- */
-void graphql_node_visit(const struct GraphQLAstNode *node,
-                        const struct GraphQLAstVisitorCallbacks *callbacks,
-                        void *userData);
-
-#ifdef __cplusplus
-}
-#endif
-

data/ext/graphqlparser/c/GraphQLParser.cpp

@@ -1,35 +0,0 @@
-/**
- * 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 "../GraphQLParser.h"
-#include "../AstNode.h"
-
-#include <cstdlib>
-
-struct GraphQLAstNode *graphql_parse_string(const char *text, const char **error) {
-  return reinterpret_cast<struct GraphQLAstNode *>(facebook::graphql::parseString(text, error).release());
-}
-
-struct GraphQLAstNode *graphql_parse_string_with_experimental_schema_support(
-    const char *text, const char **error) {
-  return reinterpret_cast<struct GraphQLAstNode *>(facebook::graphql::parseStringWithExperimentalSchemaSupport(
-                                                     text, error).release());
-}
-
-struct GraphQLAstNode *graphql_parse_file(FILE *file, const char **error) {
-  return reinterpret_cast<struct GraphQLAstNode *>(facebook::graphql::parseFile(file, error).release());
-}
-
-struct GraphQLAstNode *graphql_parse_file_with_experimental_schema_support(
-    FILE *file, const char **error) {
-  return reinterpret_cast<struct GraphQLAstNode *>(facebook::graphql::parseFileWithExperimentalSchemaSupport(file, error).release());
-}
-
-void graphql_error_free(const char *error) {
-  std::free((void *)(error)); // NOLINT
-}

data/ext/graphqlparser/c/GraphQLParser.h

@@ -1,54 +0,0 @@
-/**
- * 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 <stdio.h>
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/**
- * This file provides C wrappers for ../GraphQLParser.h.
- */
-
-struct GraphQLAstNode;
-
-/**
- * Parse the given GraphQL source string, returning an AST. Returns
- * NULL on error. Return value must be freed with
- * graphql_node_free(). If NULL is returned and error is not NULL, an
- * error message is placed in error and must be freed with
- * graphql_error_free().
- */
-struct GraphQLAstNode *graphql_parse_string(
-    const char *text, const char **error);
-
-struct GraphQLAstNode *graphql_parse_string_with_experimental_schema_support(
-    const char *text, const char **error);
-
-/**
- * Read and parse GraphQL source from the given file, returning an
- * AST. Returns nullptr on error. Return value must be freed with
- * graphql_node_free(). If NULL is returned and error is not NULL, an
- * error message is placed in error and must be freed with
- * graphql_error_free().
- */
-struct GraphQLAstNode *graphql_parse_file(FILE *file, const char **error);
-
-struct GraphQLAstNode *graphql_parse_file_with_experimental_schema_support(
-    FILE *file, const char **error);
-
-/**
- * Frees an error.
- */
-void graphql_error_free(const char *error);
-
-#ifdef __cplusplus
-}
-#endif

data/ext/graphqlparser/dump_json_ast.cpp

@@ -1,48 +0,0 @@
-/**
- * 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 "AstNode.h"
-#include "GraphQLParser.h"
-#include "c/GraphQLAstToJSON.h"
-
-#include <cstdio>
-#include <cstdlib>
-#include <iostream>
-
-
-using std::cout;
-using std::cerr;
-using std::endl;
-using std::fopen;
-using std::fclose;
-using std::free;
-
-
-int main(int argc, char **argv) {
-  const char *error;
-  FILE * in;
-  if (argc > 1) {
-    in = fopen(argv[1], "r"); // NOLINT
-  } else {
-    in = stdin;
-  }
-  auto AST = facebook::graphql::parseFile(in, &error);
-  if (argc > 1) {
-    fclose(in);
-  }
-  if (!AST) {
-    cerr << "Parser failed with error: " << error << endl;
-    free((void *)error);  // NOLINT
-    return 1;
-  }
-
-  const char *json = graphql_ast_to_json(reinterpret_cast<const struct GraphQLAstNode *>(AST.get()));
-  puts(json);
-  free((void *)json);  // NOLINT
-
-  return 0;
-}

data/ext/graphqlparser/lexer.lpp

@@ -1,324 +0,0 @@
-/**
- * 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 <algorithm>
-#include <cassert>
-#include <cctype>
-#include <climits>
-#include <cstdio>
-#include <string>
-#include <vector>
-#include "location.hh"
-#include "position.hh"
-#include "parser.tab.hpp"
-#include "syntaxdefs.h"
-
-// Keep track of token lengths.
-#define YY_USER_ACTION yyextra->loc.columns(yyleng);
-
-static void escape(char c, char *buf);
-
-static std::string clean_up_block_string(const std::string &str);
-
-%}
-
-%option bison-bridge bison-locations
-%option noyywrap batch noinput nounput
-%option reentrant
-%option extra-type="struct LexerExtra *"
-
-%x STRING_STATE
-%x BLOCK_STRING_STATE
-%x C_COMMENT_STATE
-%x LINE_COMMENT_STATE
-
-FLOAT -?(0|[1-9][0-9]*)(\.[0-9]+)?([eE][+-]?[0-9]+)?
-INTEGER -?(0|[1-9][0-9]*)
-IDENTIFIER [_A-Za-z][_0-9A-Za-z]*
-VARIABLE $[_0-9A-Za-z]+
-BOM \xef\xbb\xbf
-CRLF \r\n
-BADCHAR [\x00-\x08\x0b\x0c\x0e-\x1f]
-GOODCHAR [^\x00-\x08\x0b\x0c\x0e-\x1f]
-STRINGCHAR [^\x00-\x1f\\\x22]
-
-blank [ \t,]
-newline [\n\r]
-notnewline [^\n\r]
-
-%%
-
-%{
-  yyextra->loc.step();
-%}
-
-<STRING_STATE>{
-  \"    {
-    BEGIN(INITIAL);
-    yylval->str = yyextra->str.c_str();
-    *yylloc = yyextra->loc;
-    return yy::GraphQLParserImpl::token::TOK_STRING;
-  }
-
-  {newline} {
-    throw make_error(yyextra->loc, "Unterminated string");
-  }
-
-  <<EOF>> {
-    throw make_error(yyextra->loc, "Unterminated string at EOF");
-  }
-
-  {STRINGCHAR}+  {
-    char *p = yytext;
-    while (*p) {
-      yyextra->str.push_back(*p++);
-    }
-  }
-
-  \\\" { yyextra->str.push_back('"'); }
-  \\\\ { yyextra->str.push_back('\\'); }
-  \\\/ { yyextra->str.push_back('/'); }
-  \\n { yyextra->str.push_back('\n'); }
-  \\t { yyextra->str.push_back('\t'); }
-  \\r { yyextra->str.push_back('\r'); }
-  \\b { yyextra->str.push_back('\b'); }
-  \\f { yyextra->str.push_back('\f'); }
-
-  \\u[0-9A-Fa-f]{4} {
-    int ch;
-    sscanf(yytext + 2, "%x", &ch);
-    yyextra->str.push_back(ch);
-  }
-
-  \\u { throw make_error(yyextra->loc, "bad Unicode escape sequence"); }
-  \\. { throw make_error(yyextra->loc, std::string("bad escape sequence \\") + yytext[1]); }
-
-}
-
-<BLOCK_STRING_STATE>{
-  <<EOF>> {
-     throw make_error(yyextra->loc, "Unterminated block string at EOF");
-  }
-
-  {BADCHAR} {
-     throw make_error(yyextra->loc, std::string("Invalid character ") + yytext[0]);
-  }
-
-  {GOODCHAR} {
-    /* Can't use {GOODCHAR}+ because that would be a better match for
-       """ than the explicit rule! */
-    yyextra->str.push_back(*yytext);
-  }
-
-  \\\"\"\" {
-    yyextra->str.append(3, '"');
-  }
-
-  \"\"\" {
-    BEGIN(INITIAL);
-    yyextra->str = clean_up_block_string(yyextra->str);
-    yylval->str = yyextra->str.c_str();
-    *yylloc = yyextra->loc;
-    return yy::GraphQLParserImpl::token::TOK_STRING;
-  }
-}
-
-<LINE_COMMENT_STATE>{
-  {CRLF} { yyextra->loc.lines(yyleng / 2); yyextra->loc.step(); BEGIN(INITIAL); }
-  {newline} { yyextra->loc.lines(yyleng); yyextra->loc.step(); BEGIN(INITIAL); }
-  {notnewline}+ /* eat comment character */
-}
-
-<INITIAL>{
-  {blank}+ { yyextra->loc.step(); }
-  {BOM}+ { yyextra->loc.step(); yyextra->loc.step(); yyextra->loc.step(); }
-  {CRLF}+ { yyextra->loc.lines(yyleng / 2); yyextra->loc.step(); }
-  {newline}+ { yyextra->loc.lines(yyleng); yyextra->loc.step(); }
-
-  # {yyextra->loc.step(); BEGIN(LINE_COMMENT_STATE); }
-
-  directive   { yylval->str = yytext; *yylloc = yyextra->loc; return yy::GraphQLParserImpl::token::TOK_DIRECTIVE; }
-  enum   { yylval->str = yytext; *yylloc = yyextra->loc; return yy::GraphQLParserImpl::token::TOK_ENUM; }
-  extend   { yylval->str = yytext; *yylloc = yyextra->loc; return yy::GraphQLParserImpl::token::TOK_EXTEND; }
-  false   { yylval->str = yytext; *yylloc = yyextra->loc; return yy::GraphQLParserImpl::token::TOK_FALSE; }
-  fragment { yylval->str = yytext; *yylloc = yyextra->loc; return yy::GraphQLParserImpl::token::TOK_FRAGMENT; }
-  implements { yylval->str = yytext; *yylloc = yyextra->loc; return yy::GraphQLParserImpl::token::TOK_IMPLEMENTS; }
-  input { yylval->str = yytext; *yylloc = yyextra->loc; return yy::GraphQLParserImpl::token::TOK_INPUT; }
-  interface { yylval->str = yytext; *yylloc = yyextra->loc; return yy::GraphQLParserImpl::token::TOK_INTERFACE; }
-  mutation { yylval->str = yytext; *yylloc = yyextra->loc; return yy::GraphQLParserImpl::token::TOK_MUTATION; }
-  null { yylval->str = yytext; *yylloc = yyextra->loc; return yy::GraphQLParserImpl::token::TOK_NULL; }
-  on { yylval->str = yytext; *yylloc = yyextra->loc; return yy::GraphQLParserImpl::token::TOK_ON; }
-  query { yylval->str = yytext; *yylloc = yyextra->loc; return yy::GraphQLParserImpl::token::TOK_QUERY; }
-  scalar { yylval->str = yytext; *yylloc = yyextra->loc; return yy::GraphQLParserImpl::token::TOK_SCALAR; }
-  schema { yylval->str = yytext; *yylloc = yyextra->loc; return yy::GraphQLParserImpl::token::TOK_SCHEMA; }
-  subscription { yylval->str = yytext; *yylloc = yyextra->loc; return yy::GraphQLParserImpl::token::TOK_SUBSCRIPTION; }
-  true { yylval->str = yytext; *yylloc = yyextra->loc; return yy::GraphQLParserImpl::token::TOK_TRUE; }
-  type { yylval->str = yytext; *yylloc = yyextra->loc; return yy::GraphQLParserImpl::token::TOK_TYPE; }
-  union { yylval->str = yytext; *yylloc = yyextra->loc; return yy::GraphQLParserImpl::token::TOK_UNION; }
-
-  {INTEGER} { yylval->str = yytext; *yylloc = yyextra->loc; return yy::GraphQLParserImpl::token::TOK_INTEGER; }
-  {FLOAT} { yylval->str = yytext; *yylloc = yyextra->loc; return yy::GraphQLParserImpl::token::TOK_FLOAT; }
-  {IDENTIFIER} { yylval->str = yytext; *yylloc = yyextra->loc; return yy::GraphQLParserImpl::token::TOK_IDENTIFIER; }
-  {VARIABLE} { yylval->str = yytext + 1; *yylloc = yyextra->loc; return yy::GraphQLParserImpl::token::TOK_VARIABLE; }
-
-  "!" { *yylloc = yyextra->loc; return yy::GraphQLParserImpl::token::TOK_BANG; }
-  "(" { *yylloc = yyextra->loc; return yy::GraphQLParserImpl::token::TOK_LPAREN; }
-  ")" { *yylloc = yyextra->loc; return yy::GraphQLParserImpl::token::TOK_RPAREN; }
-  "..." { *yylloc = yyextra->loc; return yy::GraphQLParserImpl::token::TOK_ELLIPSIS; }
-  ":" { *yylloc = yyextra->loc; return yy::GraphQLParserImpl::token::TOK_COLON; }
-  "=" { *yylloc = yyextra->loc; return yy::GraphQLParserImpl::token::TOK_EQUAL; }
-  "@" { *yylloc = yyextra->loc; return yy::GraphQLParserImpl::token::TOK_AT; }
-  "[" { *yylloc = yyextra->loc; return yy::GraphQLParserImpl::token::TOK_LBRACKET; }
-  "]" { *yylloc = yyextra->loc; return yy::GraphQLParserImpl::token::TOK_RBRACKET; }
-  "{" { *yylloc = yyextra->loc; return yy::GraphQLParserImpl::token::TOK_LBRACE; }
-  "|" { *yylloc = yyextra->loc; return yy::GraphQLParserImpl::token::TOK_PIPE; }
-  "}" { *yylloc = yyextra->loc; return yy::GraphQLParserImpl::token::TOK_RBRACE; }
-
-
-  <<EOF>> { *yylloc = yyextra->loc; return yy::GraphQLParserImpl::token::TOK_EOF; }
-
-  \"\"\" {
-    BEGIN(BLOCK_STRING_STATE);
-    yyextra->str.clear();
-  }
-
-  \"   {
-    BEGIN(STRING_STATE);
-    yyextra->str.clear();
-  }
-}
-
-<INITIAL,STRING_STATE,LINE_COMMENT_STATE>. {
-  char buf[6];
-  escape(yytext[0], buf);
-  throw make_error(
-    yyextra->loc,
-    std::string("unrecognized character ") + buf);
-}
-
-%%
-
-static void escape(char c, char *buf) {
-  if (std::isgraph(c)) {
-    *buf = c;
-    buf[1] = '\0';
-  } else {
-    buf[0] = '\\';
-    buf[2] = '\0';
-    switch (c) {
-    case '\a':
-      buf[1] = 'a';
-      break;
-    case '\b':
-      buf[1] = 'b';
-      break;
-    case '\f':
-      buf[1] = 'f';
-      break;
-    case '\n':
-      buf[1] = 'n';
-      break;
-    case '\r':
-      buf[1] = 'r';
-      break;
-    case '\t':
-      buf[1] = 't';
-      break;
-    case '\v':
-      buf[1] = 'v';
-      break;
-    default:
-      buf[1] = 'x';
-      std::snprintf(buf + 2, 3, "%x", ((int)c & 0xFF));
-      break;
-    }
-  }
-}
-
-static std::vector<std::string> splitLines(const std::string &str) {
-  std::vector<std::string> lines;
-  auto it = str.begin();
-  while (it != str.end()) {
-    static char terminators[2] = {'\r', '\n'};
-    auto nextIt = std::find_first_of(it, str.end(), terminators, terminators + sizeof(terminators));
-    lines.emplace_back(str.data() + (it - str.begin()), nextIt - it);
-    if (nextIt != str.end()) {
-      auto advancedIt = nextIt + 1;
-      if (advancedIt != str.end()) {
-        if (*nextIt == '\r' && *advancedIt == '\n') {
-          ++advancedIt;
-        }
-      }
-      nextIt = std::move(advancedIt);
-    }
-    it = std::move(nextIt);
-  }
-  return lines;
-}
-
-static int count_leading_whitespace(const std::string &str) {
-  auto pos = str.find_first_not_of(" \t", 0, strlen(" \t"));
-  if (pos == std::string::npos) {
-    return str.length();
-  }
-  return pos;
-}
-
-static bool is_all_whitespace(const std::string &str) {
-  return count_leading_whitespace(str) == str.length();
-}
-
-static std::string clean_up_block_string(const std::string &str) {
-  auto lines = splitLines(str);
-  bool first = true;
-  int commonIndent = INT_MAX;
-  for (const auto &line : lines) {
-    if (first) {
-      first = false;
-      continue;
-    }
-    const auto indent = count_leading_whitespace(line);
-    if (indent < line.length()) {
-      if (indent < commonIndent) {
-        commonIndent = indent;
-      }
-    }
-  }
-  if (commonIndent != INT_MAX) {
-    first = true;
-    for (auto &line : lines) {
-      if (first) {
-        first = false;
-        continue;
-      }
-      line.erase(0, commonIndent);
-    }
-  }
-
-  const auto firstNonBlankIt = std::find_if(lines.begin(), lines.end(), [](const std::string &line) {
-      return !is_all_whitespace(line);
-  });
-  lines.erase(lines.begin(), firstNonBlankIt);
-
-  const auto firstNonBlankReverseIt = std::find_if(lines.rbegin(), lines.rend(), [](const std::string &line) {
-      return !is_all_whitespace(line);
-  });
-  lines.erase(lines.end() - (firstNonBlankReverseIt - lines.rbegin()), lines.end());
-
-  std::string formatted;
-  first = true;
-  for (const auto &line: lines) {
-    if (first) {
-      first = false;
-    } else {
-      formatted.push_back('\n');
-    }
-    formatted.append(line);
-  }
-  return formatted;
-}