graphql-libgraphqlparser 0.5.2 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: f6cf3ad5756b38f8d762f2b1be281f3d60277540
-  data.tar.gz: 7bc86127e0cec28ffd67056e2bd8a9ba3c1920da
+  metadata.gz: d5f809dc67b6cd33f071581cc7cb1afbf8f30ef4
+  data.tar.gz: d277a96dfbc145f057d82a6f7e87415d3f4c9b12
 SHA512:
-  metadata.gz: 6ca22312deb59ff1f3f6212fcefea9b795c9e1f69ea38b524cafec5847dc6412cb9e6058324c4b7a507f8dec3f305f86194f41dbe47a5acc00d124e16c0d48a8
-  data.tar.gz: 3babaec33904481768fa00233cc45ddea67898edf33aa7ab7df9034f1df6828a28994456bad4d773c5aeef1d1119e53a9348cf3b28171c067e291ff0f6a6d0c6
+  metadata.gz: e57017016982b4268d335afea057394ee3373429f7c9d2ad601c67899c661ad3dc90d7d66b0eaccf575121c206b2570dda6dc2dac25159dc1c2e1560eb43205c
+  data.tar.gz: 3ad7dd6c81802dc3b711f456282ed72a9ea1cb4f65bd2fddaeb61bf6514eca075d35566d333da6876926363a30d1e35a8b9a9cacc36466691125a8a44edf6fb5

data/.yardopts

@@ -0,0 +1 @@
+--markup=markdown

data/README.md

@@ -5,18 +5,20 @@ Make [`graphql`](https://github.com/rmosolgo/graphql-ruby) faster with [`libgrap
 It's faster:
 
 ```
-~/projects/graphql-libgraphqlparser $ be ruby benchmark.rb
+~/projects/graphql-libgraphqlparser $ bundle exec 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
+Ruby      0.090000   0.000000   0.090000 (  0.088713)
+C         0.010000   0.000000   0.010000 (  0.012827)
+~/projects/graphql-libgraphqlparser $ bundle exec 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
+Ruby      0.090000   0.010000   0.100000 (  0.090548)
+C         0.010000   0.000000   0.010000 (  0.013126)
+~/projects/graphql-libgraphqlparser $ bundle exec 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)
+Ruby      0.080000   0.000000   0.080000 (  0.090066)
+C         0.020000   0.000000   0.020000 (  0.011790)
+~/projects/graphql-libgraphqlparser $ bundle show graphql
+~/.rbenv/versions/2.1.0/lib/ruby/gems/2.1.0/gems/graphql-0.19.4
 ```
 
 ## Installation

data/ext/graphql_libgraphqlparser_ext/visitor_functions.c

@@ -1,60 +1,20 @@
 #include "graphql_libgraphqlparser_ext.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) \
-    );                              \
-  set_node_location((struct GraphQLAstNode *)node, rb_node);
-
-#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(type)           \
-  rb_funcall(                             \
-    rb_node,                              \
-    type_set_intern,                      \
-    1,                                    \
-    rb_str_new2(                          \
-      GraphQLAstName_get_value(           \
-        GraphQLAstNamedType_get_name(     \
-          type                            \
-        )                                 \
-      )                                   \
-    )                                     \
-  );                                      \
+// Get the name from `node` using `get_name_fn`,
+// then assign it to `rb_node` with `#name=`
+#define ASSIGN_NAME(rb_node, node, get_name_fn) \
+  rb_funcall(rb_node, name_set_intern, 1,       \
+    rb_str_new2(                                \
+      GraphQLAstName_get_value(                 \
+          get_name_fn(node)                     \
+        )                                       \
+      )                                         \
+    );                                          \
 
 VALUE type_set_intern, name_set_intern, add_value_intern, end_visit_intern, begin_visit_intern, line_set_intern, col_set_intern;
+int rb_utf_8_enc;
 
+// Get the line & column from `node` and assign it to `rb_node`
 inline void set_node_location(const struct GraphQLAstNode *node, VALUE rb_node) {
   struct GraphQLAstLocation location = {0};
   graphql_node_get_location(node, &location);
@@ -62,6 +22,38 @@ inline void set_node_location(const struct GraphQLAstNode *node, VALUE rb_node)
   rb_funcall(rb_node, col_set_intern, 1, INT2NUM(location.beginColumn));
 }
 
+// Call the finalizer method on `builder_ptr`
+inline void end_visit(void * builder_ptr) {
+  rb_funcall(
+    (VALUE) builder_ptr,
+    end_visit_intern,
+    0
+  );
+}
+
+// Build a Ruby node named `node_name_string` out of `node` and return it
+inline VALUE build_rb_node(struct GraphQLAstNode* node, char* node_name_string, void* builder_ptr) {
+  VALUE rb_node = rb_funcall(
+      (VALUE) builder_ptr,
+      begin_visit_intern,
+      1,
+      rb_str_new2(node_name_string)
+    );
+  set_node_location(node, rb_node);
+  return rb_node;
+}
+
+// Send `rb_literal_value` to the current node's `#value=` method
+inline void assign_literal_value(VALUE rb_literal_value, void* builder_ptr) {
+  rb_funcall(
+      (VALUE) builder_ptr,
+      add_value_intern,
+      1,
+      rb_literal_value
+  );
+}
+
+// Prepare a bunch of global Ruby method IDs
 void init_visitor_functions() {
   type_set_intern = rb_intern("type=");
   name_set_intern = rb_intern("name=");
@@ -70,6 +62,7 @@ void init_visitor_functions() {
   begin_visit_intern = rb_intern("begin_visit");
   line_set_intern = rb_intern("line=");
   col_set_intern = rb_intern("col=");
+  rb_utf_8_enc = rb_enc_find_index("UTF-8");
 }
 
 // There's a `begin_visit` and `end_visit` for each node.
@@ -77,7 +70,7 @@ void init_visitor_functions() {
 // It lets us use macros in the other files.
 
 int document_begin_visit(const struct GraphQLAstDocument* node, void* builder_ptr) {
-  BEGIN("Document")
+  build_rb_node((struct GraphQLAstNode*) node, "Document", builder_ptr);
   return 1;
 }
 
@@ -87,9 +80,9 @@ 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;
+  VALUE operation_type_str, rb_node;
 
-  BEGIN("OperationDefinition")
+  rb_node = build_rb_node((struct GraphQLAstNode*) node, "OperationDefinition", builder_ptr);
 
   ast_operation_name = GraphQLAstOperationDefinition_get_name(node);
   if (ast_operation_name) {
@@ -111,48 +104,47 @@ int operation_definition_begin_visit(const struct GraphQLAstOperationDefinition*
 }
 
 void operation_definition_end_visit(const struct GraphQLAstOperationDefinition* node, void* builder_ptr) {
-  END
+  end_visit(builder_ptr);
 }
 
 int variable_definition_begin_visit(const struct GraphQLAstVariableDefinition* node, void* builder_ptr) {
-  BEGIN("VariableDefinition")
+  build_rb_node((struct GraphQLAstNode*) node, "VariableDefinition", builder_ptr);
   return 1;
 }
 
 void variable_definition_end_visit(const struct GraphQLAstVariableDefinition* node, void* builder_ptr) {
-  END
+  end_visit(builder_ptr);
 }
 
 
 int fragment_definition_begin_visit(const struct GraphQLAstFragmentDefinition* node, void* builder_ptr) {
-  BEGIN("FragmentDefinition")
-  ASSIGN_NAME(GraphQLAstFragmentDefinition_get_name)
-  const struct GraphQLAstNamedType *type = GraphQLAstFragmentDefinition_get_type_condition(node);
-  ASSIGN_NAMED_TYPE(type)
+  VALUE rb_node = build_rb_node((struct GraphQLAstNode*) node, "FragmentDefinition", builder_ptr);
+  ASSIGN_NAME(rb_node, node, GraphQLAstFragmentDefinition_get_name)
   return 1;
 }
 
 void fragment_definition_end_visit(const struct GraphQLAstFragmentDefinition* node, void* builder_ptr) {
-  END
+  end_visit(builder_ptr);
 }
 
 
 int variable_begin_visit(const struct GraphQLAstVariable* node, void* builder_ptr) {
-  BEGIN("VariableIdentifier")
+  VALUE rb_node = build_rb_node((struct GraphQLAstNode*) node, "VariableIdentifier", builder_ptr);
   // This might actually assign the name of a VariableDefinition:
-  ASSIGN_NAME(GraphQLAstVariable_get_name)
+  ASSIGN_NAME(rb_node, node, GraphQLAstVariable_get_name)
   return 1;
 }
 
 void variable_end_visit(const struct GraphQLAstVariable* node, void* builder_ptr) {
-  END
+  end_visit(builder_ptr);
 }
 
 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)
+  VALUE rb_node = build_rb_node((struct GraphQLAstNode*) node, "Field", builder_ptr);
+
+  ASSIGN_NAME(rb_node, node, GraphQLAstField_get_name)
 
   ast_field_alias = GraphQLAstField_get_alias(node);
   if (ast_field_alias) {
@@ -163,87 +155,83 @@ int field_begin_visit(const struct GraphQLAstField* node, void* builder_ptr) {
 }
 
 void field_end_visit(const struct GraphQLAstField* node, void* builder_ptr) {
-  END
+  end_visit(builder_ptr);
 }
 
 int directive_begin_visit(const struct GraphQLAstDirective* node, void* builder_ptr) {
-  BEGIN("Directive")
-  ASSIGN_NAME(GraphQLAstDirective_get_name)
+  VALUE rb_node = build_rb_node((struct GraphQLAstNode*) node, "Directive", builder_ptr);
+
+  ASSIGN_NAME(rb_node, node, GraphQLAstDirective_get_name)
   return 1;
 }
 
 void directive_end_visit(const struct GraphQLAstDirective* node, void* builder_ptr) {
-  END
+  end_visit(builder_ptr);
 }
 
 int argument_begin_visit(const struct GraphQLAstArgument* node, void* builder_ptr) {
-  BEGIN("Argument")
-  ASSIGN_NAME(GraphQLAstArgument_get_name)
+  VALUE rb_node = build_rb_node((struct GraphQLAstNode*) node, "Argument", builder_ptr);
+  ASSIGN_NAME(rb_node, node, GraphQLAstArgument_get_name)
   return 1;
 }
 
 void argument_end_visit(const struct GraphQLAstArgument* node, void* builder_ptr) {
-  END
+  end_visit(builder_ptr);
 }
 
 int fragment_spread_begin_visit(const struct GraphQLAstFragmentSpread* node, void* builder_ptr) {
-  BEGIN("FragmentSpread")
-  ASSIGN_NAME(GraphQLAstFragmentSpread_get_name)
+  VALUE rb_node = build_rb_node((struct GraphQLAstNode*) node, "FragmentSpread", builder_ptr);
+  ASSIGN_NAME(rb_node, node, GraphQLAstFragmentSpread_get_name)
   return 1;
 }
 
 void fragment_spread_end_visit(const struct GraphQLAstFragmentSpread* node, void* builder_ptr) {
-  END
+  end_visit(builder_ptr);
 }
 
 int inline_fragment_begin_visit(const struct GraphQLAstInlineFragment* node, void* builder_ptr) {
-  BEGIN("InlineFragment")
-  const struct GraphQLAstNamedType *type = GraphQLAstInlineFragment_get_type_condition(node);
-  if (type) {
-    ASSIGN_NAMED_TYPE(type)
-  }
-
+  build_rb_node((struct GraphQLAstNode*) node, "InlineFragment", builder_ptr);
   return 1;
 }
 
 void inline_fragment_end_visit(const struct GraphQLAstInlineFragment* node, void* builder_ptr) {
-  END
+  end_visit(builder_ptr);
 }
 
 int list_type_begin_visit(const struct GraphQLAstListType* node, void* builder_ptr) {
-  BEGIN("ListType")
+  build_rb_node((struct GraphQLAstNode*) node, "ListType", builder_ptr);
   return 1;
 }
 
 void list_type_end_visit(const struct GraphQLAstListType* node, void* builder_ptr) {
-  END
+  end_visit(builder_ptr);
 }
 
 
 int non_null_type_begin_visit(const struct GraphQLAstNonNullType* node, void* builder_ptr) {
-  BEGIN("NonNullType")
+  build_rb_node((struct GraphQLAstNode*) node, "NonNullType", builder_ptr);
   return 1;
 }
 
 void non_null_type_end_visit(const struct GraphQLAstNonNullType* node, void* builder_ptr) {
-  END
+  end_visit(builder_ptr);
 }
 
 int named_type_begin_visit(const struct GraphQLAstNamedType* node, void* builder_ptr) {
-  BEGIN("TypeName")
-  ASSIGN_NAME(GraphQLAstNamedType_get_name)
+  VALUE rb_node = build_rb_node((struct GraphQLAstNode*) node, "TypeName", builder_ptr);
+  ASSIGN_NAME(rb_node, node, GraphQLAstNamedType_get_name)
   return 1;
 }
 
 void named_type_end_visit(const struct GraphQLAstNamedType* node, void* builder_ptr) {
-  END
+  end_visit(builder_ptr);
 }
 
 
 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);
+  assign_literal_value(rb_float, builder_ptr);
   return 1;
 }
 
@@ -253,7 +241,7 @@ void float_value_end_visit(const struct GraphQLAstFloatValue* node, void* builde
 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);
+  assign_literal_value(rb_int, builder_ptr);
   return 1;
 }
 
@@ -262,11 +250,9 @@ void int_value_end_visit(const struct GraphQLAstIntValue* node, void* builder_pt
 
 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)
-  }
+  VALUE rb_bool = bool_value ? Qtrue : Qfalse;
+  assign_literal_value(rb_bool, builder_ptr);
+
   return 1;
 }
 
@@ -276,9 +262,8 @@ void boolean_value_end_visit(const struct GraphQLAstBooleanValue* node, void* bu
 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);
+  rb_enc_associate_index(rb_string, rb_utf_8_enc);
+  assign_literal_value(rb_string, builder_ptr);
   return 1;
 }
 
@@ -288,43 +273,42 @@ void string_value_end_visit(const struct GraphQLAstStringValue* node, void* buil
 int enum_value_begin_visit(const struct GraphQLAstEnumValue* node, void* builder_ptr) {
   const char* str_value;
   VALUE rb_string;
-  int enc = rb_enc_find_index("UTF-8");
-  BEGIN("Enum");
+  VALUE rb_node = build_rb_node((struct GraphQLAstNode*) node, "Enum", builder_ptr);
   str_value = GraphQLAstEnumValue_get_value(node);
   rb_string = rb_str_new2(str_value);
-  rb_enc_associate_index(rb_string, enc);
+  rb_enc_associate_index(rb_string, rb_utf_8_enc);
   rb_funcall(rb_node, name_set_intern, 1, rb_string);
   return 1;
 }
 
 void enum_value_end_visit(const struct GraphQLAstEnumValue* node, void* builder_ptr) {
-  END;
+  end_visit(builder_ptr);
 }
 
 int list_value_begin_visit(const struct GraphQLAstListValue* node, void* builder_ptr) {
-  BEGIN("ListLiteral")
+  VALUE rb_node = build_rb_node((struct GraphQLAstNode*) node, "ListLiteral", builder_ptr);
   return 1;
 }
 
 void list_value_end_visit(const struct GraphQLAstListValue* node, void* builder_ptr) {
-  END
+  end_visit(builder_ptr);
 }
 
 int object_value_begin_visit(const struct GraphQLAstObjectValue* node, void* builder_ptr) {
-  BEGIN("InputObject")
+  VALUE rb_node = build_rb_node((struct GraphQLAstNode*) node, "InputObject", builder_ptr);
   return 1;
 }
 
 void object_value_end_visit(const struct GraphQLAstObjectValue* node, void* builder_ptr) {
-  END
+  end_visit(builder_ptr);
 }
 
 int object_field_begin_visit(const struct GraphQLAstObjectField* node, void* builder_ptr) {
-  BEGIN("Argument")
-  ASSIGN_NAME(GraphQLAstObjectField_get_name)
+  VALUE rb_node = build_rb_node((struct GraphQLAstNode*) node, "Argument", builder_ptr);
+  ASSIGN_NAME(rb_node, node, GraphQLAstObjectField_get_name)
   return 1;
 }
 
 void object_field_end_visit(const struct GraphQLAstObjectField* node, void* builder_ptr) {
-  END
+  end_visit(builder_ptr);
 }

data/graphql-libgraphqlparser.gemspec

@@ -17,7 +17,7 @@ Gem::Specification.new do |spec|
   spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
   spec.require_paths = ['lib']
 
-  spec.add_runtime_dependency 'graphql', '~> 0.11', '< 1.0.0'
+  spec.add_runtime_dependency 'graphql', '~> 1.0'
 
   spec.add_development_dependency 'bundler', '~> 1.0'
   spec.add_development_dependency "guard", "~> 2.12"

data/lib/graphql/libgraphqlparser/builder.rb

@@ -40,9 +40,7 @@ module GraphQL
         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
+          current.type = node
         when Nodes::ListLiteral
           # mutability! 🎉
           current.value = node.values

data/lib/graphql/libgraphqlparser/version.rb

@@ -1,5 +1,5 @@
 module GraphQL
   module Libgraphqlparser
-    VERSION = '0.5.2'
+    VERSION = "1.0.0"
   end
 end

data/test/graphql/libgraphqlparser_test.rb

@@ -51,7 +51,7 @@ describe GraphQL::Libgraphqlparser 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 "NestedType", fragment_def.type.name
         assert_equal 1, fragment_def.directives.length
         assert_equal [17, 5], fragment_def.position
       end
@@ -140,7 +140,7 @@ describe GraphQL::Libgraphqlparser do
       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 "OtherType", inline_fragment.type.name
           assert_equal 2, inline_fragment.selections.length
           assert_equal 1, inline_fragment.directives.length
         end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: graphql-libgraphqlparser
 version: !ruby/object:Gem::Version
-  version: 0.5.2
+  version: 1.0.0
 platform: ruby
 authors:
 - Robert Mosolgo
@@ -16,20 +16,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.11'
-    - - "<"
-      - !ruby/object:Gem::Version
-        version: 1.0.0
+        version: '1.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.11'
-    - - "<"
-      - !ruby/object:Gem::Version
-        version: 1.0.0
+        version: '1.0'
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -180,6 +174,7 @@ extra_rdoc_files: []
 files:
 - ".gitignore"
 - ".travis.yml"
+- ".yardopts"
 - CHANGELOG.md
 - Gemfile
 - Guardfile