graphql-libgraphqlparser 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: a36c8dfc90001ecf63d6032683987c72cea30a09
+  data.tar.gz: 1dc323ff5bd90ff440849ad4146761818bf32f04
+SHA512:
+  metadata.gz: 087f862222ee9b94bc373f47d4333cf6df42ad12205c6a13c7f743fdd21ea86743eb1271e4487dd3b9be72f44627f69d0de36dc5fcb9e74a7cacddb4a6de2204
+  data.tar.gz: 4542c42448fb8e552b4a708592d083590120463c9de175b45ab55f8aa41cd28983c4543ceb4833463a7c39292dba11d47b20b077f32f54bb8832fe70454ed0b2

data/.gitignore

@@ -0,0 +1,5 @@
+*.bundle
+*.so
+Gemfile.lock
+pkg
+tmp

data/.travis.yml

@@ -0,0 +1,25 @@
+language: ruby
+cache: bundler
+sudo: required
+rvm:
+  - 2.1
+  - 2.2
+addons:
+  apt:
+    packages:
+    - cmake
+before_install:
+  - sudo add-apt-repository -y ppa:ubuntu-toolchain-r/test
+  - sudo apt-get -qq update
+  - sudo apt-get install build-essential
+  - sudo apt-get -qq install g++-5
+  - sudo unlink /usr/bin/g++ && sudo ln -s /usr/bin/g++-5 /usr/bin/g++
+  - g++ --version
+  - sudo apt-get install bison
+  - wget https://github.com/graphql/libgraphqlparser/archive/v0.4.0.tar.gz
+  - tar -xzvf v0.4.0.tar.gz
+  - cd libgraphqlparser-0.4.0/ && sudo cmake . && sudo make && sudo make install
+  - gem update --system
+  - gem install bundler
+script:
+  - bundle exec rake

data/Gemfile

@@ -0,0 +1,2 @@
+source 'https://rubygems.org'
+gemspec

data/Guardfile

@@ -0,0 +1,16 @@
+guard :bundler do
+  watch('Gemfile')
+  # Uncomment next line if your Gemfile contains the `gemspec' command.
+  watch(/^.+\.gemspec/)
+end
+
+guard :minitest do
+  watch(%r{^test/(.*)_test\.rb})
+  watch(%r{^lib/(.+)\.rb})          { |m| "test/#{m[1]}_test.rb" }
+  watch(%r{^test/test_helper\.rb})  { 'test' }
+  watch(%r{^test/support/.*\.rb})   { 'test' }
+end
+
+guard 'rake', task: 'compile' do
+  watch(%r{^ext/libgraphqlparser/.+$})
+end

data/README.md

@@ -0,0 +1,51 @@
+# graphql-libgraphqlparser [![Build Status](https://travis-ci.org/rmosolgo/graphql-libgraphqlparser-ruby.svg?branch=master)](https://travis-ci.org/rmosolgo/graphql-libgraphqlparser-ruby)
+
+Make [`graphql`](https://github.com/rmosolgo/graphql-ruby) faster with [`libgraphqlparser`](https://github.com/graphql/libgraphqlparser). Ruby bindings to a C-level GraphQL parser.
+
+It's faster:
+
+```
+~/projects/graphql-libgraphqlparser $ be ruby benchmark.rb
+              user     system      total        real
+Ruby      1.140000   0.010000   1.150000 (  1.161160)
+C         0.000000   0.000000   0.000000 (  0.009008)
+~/projects/graphql-libgraphqlparser $ be ruby benchmark.rb
+              user     system      total        real
+Ruby      1.180000   0.000000   1.180000 (  1.185929)
+C         0.000000   0.000000   0.000000 (  0.008688)
+~/projects/graphql-libgraphqlparser $ be ruby benchmark.rb
+              user     system      total        real
+Ruby      1.220000   0.010000   1.230000 (  1.233795)
+C         0.010000   0.000000   0.010000 (  0.008584)
+```
+
+## Installation
+
+This gem depends on [libgraphqlparser](https://github.com/graphql/libgraphqlparser). You can install it a few ways:
+
+- __Homebrew__: `brew install libgraphqlparser`
+- __From Source__:
+
+  ```
+  wget https://github.com/graphql/libgraphqlparser/archive/v0.4.0.tar.gz
+  tar -xzvf v0.4.0.tar.gz
+  cd libgraphqlparser-0.4.0/ && cmake . && make && make install
+  ```
+
+Then, install this gem:
+
+```ruby
+gem "graphql-libgraphqlparser"
+```
+
+When you `require` this gem, it overrides `GraphQL.parse`:
+
+```ruby
+require "graphql/libgraphqlparser"
+```
+
+## Todo
+
+- Get directives from OperationDefinitions
+- AbstractNode overrides are full of tension. Resolve that tension with GraphQL main.
+- Node `#type` is sometimes a String, sometimes a Node. That should always be the same.

data/Rakefile

@@ -0,0 +1,17 @@
+require 'bundler/setup'
+require 'rake/extensiontask'
+
+Bundler::GemHelper.install_tasks
+
+require 'rake/testtask'
+
+Rake::TestTask.new do |t|
+  t.libs << "test" << "lib"
+  t.pattern = "test/**/*_test.rb"
+end
+
+Rake::ExtensionTask.new "libgraphqlparser" do |ext|
+  ext.lib_dir = "lib/graphql/libgraphqlparser"
+end
+
+task default: [:clobber, :compile, :test]

data/benchmark.rb

@@ -0,0 +1,10 @@
+require 'benchmark'
+require 'graphql'
+require 'graphql/libgraphqlparser'
+
+query_string = GraphQL::Introspection::INTROSPECTION_QUERY
+
+Benchmark.bm(7) do |x|
+  x.report("Ruby")   { 20.times { GraphQL.parse_without_libgraphqlparser(query_string) } }
+  x.report("C")      { 20.times { GraphQL.parse(query_string) } }
+end

data/ext/libgraphqlparser/extconf.rb

@@ -0,0 +1,6 @@
+require 'mkmf'
+
+dir_config('graphql', '/usr/local/include/graphqlparser', '/usr/local/lib')
+abort 'missing libgraphqlparser' unless have_library 'graphqlparser'
+
+create_makefile "libgraphqlparser"

data/ext/libgraphqlparser/libgraphqlparser.c

@@ -0,0 +1,67 @@
+#include "libgraphqlparser.h"
+#include "visitor_functions.h"
+
+#define ATTACH_CALLBACKS(node_name)                                         \
+  Libgraphqlparser_Callbacks.visit_##node_name = node_name##_begin_visit;   \
+  Libgraphqlparser_Callbacks.end_visit_##node_name = node_name##_end_visit; \
+
+VALUE Libgraphqlparser_ParseError;
+VALUE Libgraphqlparser_Builder;
+
+static struct GraphQLAstVisitorCallbacks Libgraphqlparser_Callbacks;
+
+// Given a Ruby querystring, return a
+// GraphQL::Nodes::Document instance.
+VALUE GraphQL_Libgraphqlparser_parse(VALUE self, VALUE query_string) {
+  const char* c_query_string = StringValuePtr(query_string);
+  const char* parse_error_message;
+  VALUE exception;
+  VALUE builder = Qnil;
+
+  struct GraphQLAstNode *parse_result = graphql_parse_string(c_query_string, &parse_error_message);
+
+  if (parse_result == NULL) {
+      exception = rb_exc_new_cstr(Libgraphqlparser_ParseError, parse_error_message);
+      graphql_error_free(parse_error_message);
+      rb_exc_raise(exception);
+  } else {
+    builder = rb_class_new_instance(0, NULL, Libgraphqlparser_Builder);
+    graphql_node_visit(parse_result, &Libgraphqlparser_Callbacks, (void*)builder);
+  }
+
+  return builder;
+}
+
+// Initialize the extension
+void Init_libgraphqlparser() {
+  VALUE GraphQL = rb_define_module("GraphQL");
+  VALUE Libgraphqlparser = rb_define_module_under(GraphQL, "Libgraphqlparser");
+  rb_define_singleton_method(Libgraphqlparser, "builder_parse", GraphQL_Libgraphqlparser_parse, 1);
+
+  Libgraphqlparser_ParseError = rb_define_class_under(Libgraphqlparser, "ParseError", rb_eStandardError);
+  Libgraphqlparser_Builder = rb_const_get(Libgraphqlparser, rb_intern("Builder"));
+
+  init_visitor_functions();
+  // Attach the functions to the Callbacks struct
+  ATTACH_CALLBACKS(document);
+  ATTACH_CALLBACKS(operation_definition);
+  ATTACH_CALLBACKS(variable_definition);
+  ATTACH_CALLBACKS(fragment_definition);
+  ATTACH_CALLBACKS(variable);
+  ATTACH_CALLBACKS(field);
+  ATTACH_CALLBACKS(directive);
+  ATTACH_CALLBACKS(argument);
+  ATTACH_CALLBACKS(fragment_spread);
+  ATTACH_CALLBACKS(inline_fragment);
+  ATTACH_CALLBACKS(list_type);
+  ATTACH_CALLBACKS(non_null_type);
+  ATTACH_CALLBACKS(named_type);
+  ATTACH_CALLBACKS(float_value);
+  ATTACH_CALLBACKS(int_value);
+  ATTACH_CALLBACKS(boolean_value);
+  ATTACH_CALLBACKS(string_value);
+  ATTACH_CALLBACKS(enum_value);
+  ATTACH_CALLBACKS(array_value);
+  ATTACH_CALLBACKS(object_value);
+  ATTACH_CALLBACKS(object_field);
+}

data/ext/libgraphqlparser/libgraphqlparser.h

@@ -0,0 +1,13 @@
+#ifndef Libgraphqlparser_EXT_H
+#define Libgraphqlparser_EXT_H
+
+#include <ruby.h>
+#include <ruby/encoding.h>
+#include <c/GraphQLParser.h>
+#include <c/GraphQLAstNode.h>
+#include <c/GraphQLAstVisitor.h>
+#include <c/GraphQLAst.h>
+
+void Init_libgraphqlparser();
+
+#endif

data/ext/libgraphqlparser/visitor_functions.c

@@ -0,0 +1,317 @@
+#include "libgraphqlparser.h"
+
+// These macros are a bit janky,
+// they depend on the function signature
+// being the same all the time: `(GraphQLAstNode* node, void* builder_ptr)`.
+//
+// Then they provide `rb_node` that you can work on in the function body.
+#define BEGIN(node_name_string)     \
+  VALUE rb_node = rb_funcall(       \
+      (VALUE) builder_ptr,          \
+      begin_visit_intern,           \
+      1,                            \
+      rb_str_new2(node_name_string) \
+    );                              \
+  struct GraphQLAstLocation* location = malloc(sizeof(struct GraphQLAstLocation)); \
+  graphql_node_get_location((struct GraphQLAstNode *)node, location);            \
+  rb_funcall(rb_node, line_set_intern, 1, INT2NUM(location->beginLine)); \
+  rb_funcall(rb_node, col_set_intern, 1, INT2NUM(location->beginColumn)); \
+  free(location);                   \
+
+#define END                         \
+  rb_funcall(                       \
+    (VALUE) builder_ptr,            \
+    end_visit_intern,               \
+    0                               \
+  );                                \
+
+#define ADD_LITERAL(rb_value)       \
+  rb_funcall(                       \
+      (VALUE) builder_ptr,          \
+      add_value_intern,             \
+      1,                            \
+      rb_value                      \
+  );                                \
+
+
+#define ASSIGN_NAME(get_name_fn)              \
+  rb_funcall(rb_node, name_set_intern, 1,     \
+    rb_str_new2(                              \
+      GraphQLAstName_get_value(               \
+          get_name_fn(node)                   \
+        )                                     \
+      )                                       \
+    );                                        \
+
+#define ASSIGN_NAMED_TYPE(get_type_fn)    \
+  rb_funcall(                             \
+    rb_node,                              \
+    type_set_intern,                      \
+    1,                                    \
+    rb_str_new2(                          \
+      GraphQLAstName_get_value(           \
+        GraphQLAstNamedType_get_name(     \
+          get_type_fn(node)               \
+        )                                 \
+      )                                   \
+    )                                     \
+  );                                      \
+
+VALUE type_set_intern, name_set_intern, add_value_intern, end_visit_intern, begin_visit_intern, line_set_intern, col_set_intern;
+void init_visitor_functions() {
+  type_set_intern = rb_intern("type=");
+  name_set_intern = rb_intern("name=");
+  add_value_intern = rb_intern("add_value");
+  end_visit_intern = rb_intern("end_visit");
+  begin_visit_intern = rb_intern("begin_visit");
+  line_set_intern = rb_intern("line=");
+  col_set_intern = rb_intern("col=");
+}
+
+// There's a `begin_visit` and `end_visit` for each node.
+// Some of the end_visit callbacks are empty but that's ok,
+// It lets us use macros in the other files.
+
+int document_begin_visit(const struct GraphQLAstDocument* node, void* builder_ptr) {
+  BEGIN("Document")
+  return 1;
+}
+
+void document_end_visit(const struct GraphQLAstDocument* node, void* builder_ptr) {
+}
+
+int operation_definition_begin_visit(const struct GraphQLAstOperationDefinition* node, void* builder_ptr) {
+  const struct GraphQLAstName* ast_operation_name;
+  const char* operation_type;
+  VALUE operation_type_str;
+
+  BEGIN("OperationDefinition")
+
+  ast_operation_name = GraphQLAstOperationDefinition_get_name(node);
+  if (ast_operation_name) {
+    const char* operation_name = GraphQLAstName_get_value(ast_operation_name);
+    rb_funcall(rb_node, name_set_intern, 1, rb_str_new2(operation_name));
+  }
+
+  operation_type = GraphQLAstOperationDefinition_get_operation(node);
+
+  if (operation_type) {
+    operation_type_str = rb_str_new2(operation_type);
+  } else {
+    operation_type_str = rb_str_new2("query");
+  }
+
+  rb_funcall(rb_node, rb_intern("operation_type="), 1, operation_type_str);
+
+  return 1;
+}
+
+void operation_definition_end_visit(const struct GraphQLAstOperationDefinition* node, void* builder_ptr) {
+  END
+}
+
+int variable_definition_begin_visit(const struct GraphQLAstVariableDefinition* node, void* builder_ptr) {
+  BEGIN("VariableDefinition")
+  return 1;
+}
+
+void variable_definition_end_visit(const struct GraphQLAstVariableDefinition* node, void* builder_ptr) {
+  END
+}
+
+
+int fragment_definition_begin_visit(const struct GraphQLAstFragmentDefinition* node, void* builder_ptr) {
+  BEGIN("FragmentDefinition")
+  ASSIGN_NAME(GraphQLAstFragmentDefinition_get_name)
+  ASSIGN_NAMED_TYPE(GraphQLAstFragmentDefinition_get_type_condition)
+  return 1;
+}
+
+void fragment_definition_end_visit(const struct GraphQLAstFragmentDefinition* node, void* builder_ptr) {
+  END
+}
+
+
+int variable_begin_visit(const struct GraphQLAstVariable* node, void* builder_ptr) {
+  BEGIN("VariableIdentifier")
+  // This might actually assign the name of a VariableDefinition:
+  ASSIGN_NAME(GraphQLAstVariable_get_name)
+  return 1;
+}
+
+void variable_end_visit(const struct GraphQLAstVariable* node, void* builder_ptr) {
+  END
+}
+
+int field_begin_visit(const struct GraphQLAstField* node, void* builder_ptr) {
+  const struct GraphQLAstName* ast_field_alias;
+  const char* str_field_alias;
+  BEGIN("Field")
+  ASSIGN_NAME(GraphQLAstField_get_name)
+
+  ast_field_alias = GraphQLAstField_get_alias(node);
+  if (ast_field_alias) {
+    str_field_alias = GraphQLAstName_get_value(ast_field_alias);
+    rb_funcall(rb_node, rb_intern("alias="), 1, rb_str_new2(str_field_alias));
+  }
+  return 1;
+}
+
+void field_end_visit(const struct GraphQLAstField* node, void* builder_ptr) {
+  END
+}
+
+int directive_begin_visit(const struct GraphQLAstDirective* node, void* builder_ptr) {
+  BEGIN("Directive")
+  ASSIGN_NAME(GraphQLAstDirective_get_name)
+  return 1;
+}
+
+void directive_end_visit(const struct GraphQLAstDirective* node, void* builder_ptr) {
+  END
+}
+
+int argument_begin_visit(const struct GraphQLAstArgument* node, void* builder_ptr) {
+  BEGIN("Argument")
+  ASSIGN_NAME(GraphQLAstArgument_get_name)
+  return 1;
+}
+
+void argument_end_visit(const struct GraphQLAstArgument* node, void* builder_ptr) {
+  END
+}
+
+int fragment_spread_begin_visit(const struct GraphQLAstFragmentSpread* node, void* builder_ptr) {
+  BEGIN("FragmentSpread")
+  ASSIGN_NAME(GraphQLAstFragmentSpread_get_name)
+  return 1;
+}
+
+void fragment_spread_end_visit(const struct GraphQLAstFragmentSpread* node, void* builder_ptr) {
+  END
+}
+
+int inline_fragment_begin_visit(const struct GraphQLAstInlineFragment* node, void* builder_ptr) {
+  BEGIN("InlineFragment")
+  ASSIGN_NAMED_TYPE(GraphQLAstInlineFragment_get_type_condition)
+  return 1;
+}
+
+void inline_fragment_end_visit(const struct GraphQLAstInlineFragment* node, void* builder_ptr) {
+  END
+}
+
+int list_type_begin_visit(const struct GraphQLAstListType* node, void* builder_ptr) {
+  BEGIN("ListType")
+  return 1;
+}
+
+void list_type_end_visit(const struct GraphQLAstListType* node, void* builder_ptr) {
+  END
+}
+
+
+int non_null_type_begin_visit(const struct GraphQLAstNonNullType* node, void* builder_ptr) {
+  BEGIN("NonNullType")
+  return 1;
+}
+
+void non_null_type_end_visit(const struct GraphQLAstNonNullType* node, void* builder_ptr) {
+  END
+}
+
+int named_type_begin_visit(const struct GraphQLAstNamedType* node, void* builder_ptr) {
+  BEGIN("TypeName")
+  ASSIGN_NAME(GraphQLAstNamedType_get_name)
+  return 1;
+}
+
+void named_type_end_visit(const struct GraphQLAstNamedType* node, void* builder_ptr) {
+  END
+}
+
+
+int float_value_begin_visit(const struct GraphQLAstFloatValue* node, void* builder_ptr) {
+  const char* str_float = GraphQLAstFloatValue_get_value(node);
+  VALUE rb_float = rb_funcall(rb_str_new2(str_float), rb_intern("to_f"), 0);
+  ADD_LITERAL(rb_float);
+  return 1;
+}
+
+void float_value_end_visit(const struct GraphQLAstFloatValue* node, void* builder_ptr) {
+}
+
+int int_value_begin_visit(const struct GraphQLAstIntValue* node, void* builder_ptr) {
+  const char* str_int = GraphQLAstIntValue_get_value(node);
+  VALUE rb_int = rb_funcall(rb_str_new2(str_int), rb_intern("to_i"), 0);
+  ADD_LITERAL(rb_int);
+  return 1;
+}
+
+void int_value_end_visit(const struct GraphQLAstIntValue* node, void* builder_ptr) {
+}
+
+int boolean_value_begin_visit(const struct GraphQLAstBooleanValue* node, void* builder_ptr) {
+  const int bool_value = GraphQLAstBooleanValue_get_value(node);
+  if (bool_value) {
+    ADD_LITERAL(Qtrue)
+  } else {
+    ADD_LITERAL(Qfalse)
+  }
+  return 1;
+}
+
+void boolean_value_end_visit(const struct GraphQLAstBooleanValue* node, void* builder_ptr) {
+}
+
+int string_value_begin_visit(const struct GraphQLAstStringValue* node, void* builder_ptr) {
+  const char* str_value = GraphQLAstStringValue_get_value(node);
+  VALUE rb_string = rb_str_new2(str_value);
+  int enc = rb_enc_find_index("UTF-8");
+  rb_enc_associate_index(rb_string, enc);
+  ADD_LITERAL(rb_string);
+  return 1;
+}
+
+void string_value_end_visit(const struct GraphQLAstStringValue* node, void* builder_ptr) {
+}
+
+int enum_value_begin_visit(const struct GraphQLAstEnumValue* node, void* builder_ptr) {
+  const char* str_value = GraphQLAstEnumValue_get_value(node);
+  VALUE rb_string = rb_str_new2(str_value);
+  int enc = rb_enc_find_index("UTF-8");
+  rb_enc_associate_index(rb_string, enc);
+  ADD_LITERAL(rb_string);
+  return 1;
+}
+
+void enum_value_end_visit(const struct GraphQLAstEnumValue* node, void* builder_ptr) {
+}
+
+int array_value_begin_visit(const struct GraphQLAstArrayValue* node, void* builder_ptr) {
+  BEGIN("ArrayLiteral")
+  return 1;
+}
+
+void array_value_end_visit(const struct GraphQLAstArrayValue* node, void* builder_ptr) {
+  END
+}
+
+int object_value_begin_visit(const struct GraphQLAstObjectValue* node, void* builder_ptr) {
+  BEGIN("InputObject")
+  return 1;
+}
+
+void object_value_end_visit(const struct GraphQLAstObjectValue* node, void* builder_ptr) {
+  END
+}
+
+int object_field_begin_visit(const struct GraphQLAstObjectField* node, void* builder_ptr) {
+  BEGIN("Argument")
+  ASSIGN_NAME(GraphQLAstObjectField_get_name)
+  return 1;
+}
+
+void object_field_end_visit(const struct GraphQLAstObjectField* node, void* builder_ptr) {
+  END
+}

data/ext/libgraphqlparser/visitor_functions.h

@@ -0,0 +1,31 @@
+#ifndef Libgraphqlparser_visitor_functions_H
+#define Libgraphqlparser_visitor_functions_H
+
+#define VISITOR_CALLBACKS(snake_name, camel_name) \
+  int snake_name##_begin_visit(const struct GraphQLAst##camel_name* document, void* builder_ptr); \
+  void snake_name##_end_visit(const struct GraphQLAst##camel_name* document, void* builder_ptr); \
+
+void init_visitor_functions();
+VISITOR_CALLBACKS(document, Document);
+VISITOR_CALLBACKS(operation_definition, OperationDefinition);
+VISITOR_CALLBACKS(variable_definition, VariableDefinition);
+VISITOR_CALLBACKS(fragment_definition, FragmentDefinition);
+VISITOR_CALLBACKS(variable, Variable);
+VISITOR_CALLBACKS(field, Field);
+VISITOR_CALLBACKS(directive, Directive);
+VISITOR_CALLBACKS(argument, Argument);
+VISITOR_CALLBACKS(fragment_spread, FragmentSpread);
+VISITOR_CALLBACKS(inline_fragment, InlineFragment);
+VISITOR_CALLBACKS(list_type, ListType);
+VISITOR_CALLBACKS(non_null_type, NonNullType);
+VISITOR_CALLBACKS(named_type, NamedType);
+VISITOR_CALLBACKS(float_value, FloatValue);
+VISITOR_CALLBACKS(int_value, IntValue);
+VISITOR_CALLBACKS(boolean_value, BooleanValue);
+VISITOR_CALLBACKS(string_value, StringValue);
+VISITOR_CALLBACKS(enum_value, EnumValue);
+VISITOR_CALLBACKS(array_value, ArrayValue);
+VISITOR_CALLBACKS(object_value, ObjectValue);
+VISITOR_CALLBACKS(object_field, ObjectField);
+
+#endif

data/graphql-libgraphqlparser.gemspec

@@ -0,0 +1,30 @@
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'graphql/libgraphqlparser/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'graphql-libgraphqlparser'
+  spec.version       = GraphQL::Libgraphqlparser::VERSION
+  spec.authors       = ['Robert Mosolgo']
+  spec.homepage      = 'https://github.com/rmosolgo/graphql-libgraphqlparser-ruby'
+  spec.email         = ['rdmosolgo@gmail.com']
+  spec.summary       = "Use Libgraphqlparser to parse queries for the GraphQL gem"
+  spec.license       = "minitest"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ['lib']
+
+  spec.add_runtime_dependency 'graphql', '~> 0.10.0'
+
+  spec.add_development_dependency 'bundler', '~> 1.0'
+  spec.add_development_dependency "guard", "~> 2.12"
+  spec.add_development_dependency "guard-bundler", "~> 2.1"
+  spec.add_development_dependency "guard-minitest", "~> 2.4"
+  spec.add_development_dependency "guard-rake", "~> 1.0"
+  spec.add_development_dependency 'minitest', '~> 5.8'
+  spec.add_development_dependency "minitest-reporters", "~>1.0"
+  spec.add_development_dependency 'rake', '~> 10.0'
+  spec.add_development_dependency 'rake-compiler', '~> 0.9'
+end

data/lib/graphql/libgraphqlparser/builder.rb

@@ -0,0 +1,69 @@
+module GraphQL
+  module Libgraphqlparser
+    # Keeps a stack of parse results, exposing the latest one.
+    # The C parser can call methods on this object, assuming
+    # they'll be applied to the right object.
+    class Builder
+      include GraphQL::Language
+
+      def initialize
+        @ast_stack = []
+      end
+
+      def document
+        @ast_stack.first
+      end
+
+      def current
+        @ast_stack.last
+      end
+
+      def begin_visit(node_class_name)
+        # p "--> BEGIN #{node_class_name}"
+        node_class = Nodes.const_get(node_class_name)
+        node = node_class.new
+        case node
+        when Nodes::OperationDefinition, Nodes::FragmentDefinition
+          current.definitions << node
+        when Nodes::VariableDefinition
+          current.variables << node
+        when Nodes::VariableIdentifier
+          if current.is_a?(Nodes::VariableDefinition)
+            node = current
+          else
+            current.value = node
+          end
+        when Nodes::Directive
+          current.directives << node
+        when Nodes::Argument
+          current.arguments << node
+        when Nodes::InlineFragment, Nodes::FragmentSpread, Nodes::Field
+          current.selections << node
+        when Nodes::TypeName, Nodes::ListType, Nodes::NonNullType
+          # Using ||= because FragmentDefinition has already assigned
+          # this as a plain string :(
+          current.type ||= node
+        when Nodes::ArrayLiteral
+          # mutability! 🎉
+          current.value = node.values
+        when Nodes::InputObject
+          current.value = node
+        end
+
+        @ast_stack.push(node)
+        node
+      end
+
+      def end_visit
+        removed = @ast_stack.pop
+        # p "--> END   #{removed}"
+        removed
+      end
+
+      # This is for convenience from C
+      def add_value(string_value)
+        current.value = string_value
+      end
+    end
+  end
+end

data/lib/graphql/libgraphqlparser/monkey_patches/abstract_node.rb

@@ -0,0 +1,132 @@
+module GraphQL
+  module Language
+    module Nodes
+      class AbstractNode
+        alias :old_initialize :initialize
+        # Allow initialize with no args
+        def initialize(*args)
+          if args.any?
+            old_initialize(*args)
+          end
+        end
+
+        def position
+          [line, col]
+        end
+      end
+
+      # Document = AbstractNode.create(:parts)
+      class Document
+        def definitions
+          @parts ||= []
+        end
+      end
+
+      # OperationDefinition = AbstractNode.create(:operation_type, :name, :variables, :directives, :selections)
+      class OperationDefinition
+        def variables
+          @variables ||= []
+        end
+
+        def selections
+          @selections ||= []
+        end
+      end
+
+      # Variable = AbstractNode.create(:name, :type, :default_value)
+      VariableDefinition = Variable
+      class VariableDefinition
+        # Make it behave like an Argument
+        def value=(new_value)
+          @default_value = new_value
+        end
+      end
+
+      # VariableIdentifier = AbstractNode.create(:name)
+
+      # FragmentDefinition = AbstractNode.create(:name, :type, :directives, :selections)
+      class FragmentDefinition
+        def selections
+          @selections ||= []
+        end
+      end
+
+      # Field = AbstractNode.create(:name, :alias, :arguments, :directives, :selections)
+      class Field
+        def selections
+          @selections ||= []
+        end
+
+        def directives
+          @directives ||= []
+        end
+
+        def arguments
+          @arguments ||= []
+        end
+      end
+
+      # Directive = AbstractNode.create(:name, :arguments)
+      class Directive
+        def arguments
+          @arguments ||= []
+        end
+      end
+
+      # FragmentSpread = AbstractNode.create(:name, :directives)
+      class FragmentSpread
+        def directives
+          @directives ||= []
+        end
+      end
+
+      # InlineFragment = AbstractNode.create(:type, :directives, :selections)
+      class InlineFragment
+        def directives
+          @directives ||= []
+        end
+        def selections
+          @selections ||= []
+        end
+      end
+
+      # ListType = AbstractNode.create(:of_type)
+      # NonNullType = AbstractNode.create(:of_type)
+      # TypeName = AbstractNode.create(:name)
+      class ListType
+        def type=(inner_type)
+          self.of_type = inner_type
+        end
+        def type; self.of_type; end
+      end
+      class NonNullType
+        def type=(inner_type)
+          self.of_type = inner_type
+        end
+        def type; self.of_type; end
+      end
+
+      # Argument = AbstractNode.create(:name, :value)
+      # Enum = AbstractNode.create(:name)
+      class InputObject
+        def arguments
+          @pairs ||= []
+        end
+      end
+
+      class ArrayLiteral < AbstractNode
+        attr_reader :values
+
+        def initialize
+          @values = []
+        end
+
+        # This makes it behave like Argument,
+        # while it's on the stack it can gobble up values
+        def value=(new_value)
+          values << new_value
+        end
+      end
+    end
+  end
+end

data/lib/graphql/libgraphqlparser/version.rb

@@ -0,0 +1,5 @@
+module GraphQL
+  module Libgraphqlparser
+    VERSION = '0.0.1'
+  end
+end

data/lib/graphql/libgraphqlparser.rb

@@ -0,0 +1,26 @@
+require 'graphql'
+require 'graphql/libgraphqlparser/builder'
+require 'graphql/libgraphqlparser/libgraphqlparser'
+require 'graphql/libgraphqlparser/monkey_patches/abstract_node'
+require 'graphql/libgraphqlparser/version'
+
+module GraphQL
+  module Libgraphqlparser
+    def self.parse(string)
+      builder = builder_parse(string)
+      builder.document
+    end
+  end
+
+  class << self
+    def parse_with_libgraphqlparser(string)
+      Libgraphqlparser.parse(string)
+    end
+
+    alias :parse_without_libgraphqlparser :parse
+
+    def parse(string, as: nil)
+      parse_with_libgraphqlparser(string)
+    end
+  end
+end

data/test/graphql/libgraphqlparser_test.rb

@@ -0,0 +1,231 @@
+require 'test_helper'
+
+describe GraphQL::Libgraphqlparser do
+  let(:document) { GraphQL::Libgraphqlparser.parse(query_string) }
+  let(:query_string) {%|
+    query getStuff($someVar: Int = 1, $anotherVar: [String!] ) {
+      myField: someField(someArg: $someVar, ok: 1.4) @skip(if: $anotherVar) @thing(or: "Whatever")
+
+      anotherField(someArg: [1,2,3]) {
+        nestedField
+        ... moreNestedFields @skip(if: true)
+      }
+
+      ... on OtherType @include(unless: false){
+        field
+        anotherField
+      }
+
+    }
+
+    fragment moreNestedFields on NestedType {
+      anotherNestedField
+    }
+  |}
+
+  describe '.parse' do
+    it 'parses queries' do
+      assert document
+    end
+
+    describe "visited nodes" do
+      let(:query) { document.definitions.first }
+      let(:fragment_def) { document.definitions.last }
+
+      it "creates a valid document" do
+        assert document.is_a?(GraphQL::Language::Nodes::Document)
+        assert_equal 2, document.definitions.length
+      end
+
+      it "creates a valid operation" do
+        assert query.is_a?(GraphQL::Language::Nodes::OperationDefinition)
+        assert_equal "getStuff", query.name
+        assert_equal "query", query.operation_type
+        assert_equal 2, query.variables.length
+        assert_equal 3, query.selections.length
+        assert_equal [2, 5], [query.line, query.col]
+      end
+
+      it "creates a valid fragment definition" do
+        assert fragment_def.is_a?(GraphQL::Language::Nodes::FragmentDefinition)
+        assert_equal "moreNestedFields", fragment_def.name
+        assert_equal 1, fragment_def.selections.length
+        assert_equal "NestedType", fragment_def.type
+        assert_equal [17, 5], fragment_def.position
+      end
+
+      describe "variable definitions" do
+        let(:optional_var) { query.variables.first }
+        it "gets name and type" do
+          assert_equal "someVar", optional_var.name
+          assert_equal "Int", optional_var.type.name
+        end
+
+        it "gets default value" do
+          assert_equal 1, optional_var.default_value
+        end
+
+        it "gets position info" do
+          assert_equal [2, 20], optional_var.position
+        end
+      end
+
+      describe "fields" do
+        let(:leaf_field) { query.selections.first }
+        let(:parent_field) { query.selections[1] }
+
+        it "gets name, alias, arguments and directives" do
+          assert_equal "someField", leaf_field.name
+          assert_equal "myField", leaf_field.alias
+          assert_equal 2, leaf_field.directives.length
+          assert_equal 2, leaf_field.arguments.length
+        end
+
+        it "gets nested fields" do
+          assert_equal 2, parent_field.selections.length
+        end
+
+        it "gets location info" do
+          assert_equal [3 ,7], leaf_field.position
+        end
+      end
+
+      describe "arguments" do
+        let(:literal_argument) { query.selections.first.arguments.last }
+        let(:variable_argument) { query.selections.first.arguments.first }
+
+        it "gets name and literal value" do
+          assert_equal "ok", literal_argument.name
+          assert_equal 1.4, literal_argument.value
+        end
+
+        it "gets name and variable value" do
+          assert_equal "someArg", variable_argument.name
+          assert_equal "someVar", variable_argument.value.name
+        end
+
+        it "gets position info" do
+          assert_equal [3, 26], variable_argument.position
+        end
+      end
+
+      describe "fragment spreads" do
+        let(:fragment_spread) { query.selections[1].selections.last }
+        it "gets the name and directives" do
+          assert_equal "moreNestedFields", fragment_spread.name
+          assert_equal 1, fragment_spread.directives.length
+        end
+
+        it "gets position info" do
+          assert_equal [7, 9], fragment_spread.position
+        end
+      end
+
+      describe "directives" do
+        let(:variable_directive) { query.selections.first.directives.first }
+
+        it "gets the name and arguments" do
+          assert_equal "skip", variable_directive.name
+          assert_equal "if", variable_directive.arguments.first.name
+          assert_equal 1, variable_directive.arguments.length
+        end
+
+        it "gets position info" do
+          assert_equal [3, 54], variable_directive.position
+        end
+      end
+
+      describe "inline fragments" do
+        let(:inline_fragment) { query.selections[2] }
+        it "gets the type and directives" do
+          assert_equal "OtherType", inline_fragment.type
+          assert_equal 2, inline_fragment.selections.length
+          assert_equal 1, inline_fragment.directives.length
+        end
+
+        it "gets position info" do
+          assert_equal [10, 7], inline_fragment.position
+        end
+      end
+
+      describe "inputs" do
+        let(:query_string) {%|
+          {
+            field(
+              int: 3,
+              float: 4.7e-24,
+              bool: false,
+              string: "☀︎🏆",
+              enum: ENUM_NAME,
+              array: [7, 8, 9]
+              object: {a: [1,2,3], b: {c: "4"}}
+            )
+          }
+        |}
+
+        let(:inputs) { document.definitions.first.selections.first.arguments }
+
+        it "parses ints" do
+          assert_equal 3, inputs[0].value
+        end
+
+        it "parses floats" do
+          assert_equal 0.47e-23, inputs[1].value
+        end
+
+        it "parses booleans" do
+          assert_equal false, inputs[2].value
+        end
+
+        it "parses UTF-8 strings" do
+          assert_equal "☀︎🏆", inputs[3].value
+        end
+
+        it "parses enums" do
+          assert_equal "ENUM_NAME", inputs[4].value
+        end
+
+        it "parses arrays" do
+          assert_equal [7,8,9], inputs[5].value
+        end
+
+        it "parses objects" do
+          obj = inputs[6].value
+          assert_equal "a", obj.arguments[0].name
+          assert_equal [1,2,3], obj.arguments[0].value
+          assert_equal "b", obj.arguments[1].name
+          assert_equal "c", obj.arguments[1].value.arguments[0].name
+          assert_equal "4", obj.arguments[1].value.arguments[0].value
+        end
+      end
+    end
+
+    describe "unnamed queries" do
+      let(:query_string) {%|
+        { name, age, height }
+      |}
+      let(:operation) { document.definitions.first }
+
+      it "parses unnamed queries" do
+        assert_equal 1, document.definitions.length
+        assert_equal "query", operation.operation_type
+        assert_equal nil, operation.name
+        assert_equal 3, operation.selections.length
+      end
+    end
+
+    describe "introspection query" do
+      let(:query_string) { GraphQL::Introspection::INTROSPECTION_QUERY }
+      it "parses a big ol' query" do
+        assert(document)
+      end
+    end
+  end
+
+  describe "errors" do
+    let(:query_string) {%| query doSomething { bogus { } |}
+    it "raises a parse error" do
+      err = assert_raises(GraphQL::Libgraphqlparser::ParseError) { document }
+    end
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,6 @@
+require 'graphql'
+require 'graphql/libgraphqlparser'
+require 'minitest'
+require 'minitest/autorun'
+require "minitest/reporters"
+Minitest::Reporters.use! Minitest::Reporters::SpecReporter.new

metadata

@@ -0,0 +1,205 @@
+--- !ruby/object:Gem::Specification
+name: graphql-libgraphqlparser
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Robert Mosolgo
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-02-09 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: graphql
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.10.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.10.0
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: guard
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.12'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.12'
+- !ruby/object:Gem::Dependency
+  name: guard-bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.1'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.1'
+- !ruby/object:Gem::Dependency
+  name: guard-minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.4'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.4'
+- !ruby/object:Gem::Dependency
+  name: guard-rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.8'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.8'
+- !ruby/object:Gem::Dependency
+  name: minitest-reporters
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rake-compiler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.9'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.9'
+description: 
+email:
+- rdmosolgo@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".travis.yml"
+- Gemfile
+- Guardfile
+- README.md
+- Rakefile
+- benchmark.rb
+- ext/libgraphqlparser/extconf.rb
+- ext/libgraphqlparser/libgraphqlparser.c
+- ext/libgraphqlparser/libgraphqlparser.h
+- ext/libgraphqlparser/visitor_functions.c
+- ext/libgraphqlparser/visitor_functions.h
+- graphql-libgraphqlparser.gemspec
+- lib/graphql/libgraphqlparser.rb
+- lib/graphql/libgraphqlparser/builder.rb
+- lib/graphql/libgraphqlparser/monkey_patches/abstract_node.rb
+- lib/graphql/libgraphqlparser/version.rb
+- test/graphql/libgraphqlparser_test.rb
+- test/test_helper.rb
+homepage: https://github.com/rmosolgo/graphql-libgraphqlparser-ruby
+licenses:
+- minitest
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: Use Libgraphqlparser to parse queries for the GraphQL gem
+test_files:
+- test/graphql/libgraphqlparser_test.rb
+- test/test_helper.rb