rails-graphql 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 49e43687d5292b789a8bd31a328c7788e65ea18fa9e7210804a6d2b5fa626a55
+  data.tar.gz: e18c7462267165fbc6c891cb6abcd8e1d58a7c4e4cef52209d8b7cd779775768
+SHA512:
+  metadata.gz: 9a389ad749b2de6f1109b81e675ab78adad048b2d621e268c2d22a7ed7ace9f76aa2ab7b82510a2089cdced461f3df721a89f3a86a9c4fca5215458266b274c3
+  data.tar.gz: ac5b71676b2bded14527eed7d2b2b7242c3258f9ee0aaddc562d9ea7a58931aa1372d54634176058e0e1f4b959c712db95831dbcd2b1f15473652b13aa8126aa

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2020 "VirtualShield LLC"
+
+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.

data/README.rdoc

@@ -0,0 +1,19 @@
+= Torque PostgreSQL
+
+
+== Download and installation
+
+The latest version of Rails GraphQL can be installed with RubyGems:
+
+  $ gem install rails-graphql
+
+Source code can be downloaded direct from the GitHub repository:
+
+* https://github.com/virtualshield/rails-graphql
+
+
+== License
+
+Rails GraphQL is released under the MIT license:
+
+* http://www.opensource.org/licenses/MIT

data/Rakefile

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+# Rake tasks for development purposes
+
+begin
+  require 'bundler/setup'
+rescue LoadError
+  puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
+end
+
+require 'rdoc/task'
+require 'rake/testtask'
+
+require_relative 'tasks/libgraphqlparser'
+
+task default: :test
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'test'
+  t.warning = true
+  t.verbose = true
+  t.test_files = Dir.glob("test/**/*_test.rb")
+end
+
+RDoc::Task.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'Rails::GraphQL'
+  rdoc.options << '--line-numbers'
+  rdoc.rdoc_files.include('README.rdoc')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+

data/ext/depend

@@ -0,0 +1,3 @@
+# Replaces default mkmf dependencies. Default mkmf dependencies include all libruby headers.
+# We don't need libruby and some of these headers are missing on JRuby (breaking compilation there).
+$(OBJS): $(HDRS)

data/ext/extconf.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+gem_root = File.expand_path('..', __dir__)
+precomp_dir = File.join(gem_root, 'ext', 'graphqlparser')
+
+abort 'The libgraphqlparser must be pre-compile first!' \
+  unless File.directory?(precomp_dir)
+
+require 'mkmf'
+
+# Define a version variable
+version = File.read(File.join(precomp_dir, 'VERSION'))
+$defs << "-DGRAPHQLPARSER_VERSION=\\\"#{version}\\\""
+
+# Set necessary flags and includes
+$CXXFLAGS << ' -std=gnu++11' << ' -g' << ' -Wall'
+
+# Set to true when building binary gems
+if enable_config('static-stdlib', false)
+  $LDFLAGS << ' -static-libgcc -static-libstdc++'
+end
+
+# Enable maintainer mode for better log
+if ENV['MAINTAINER_MODE']
+  require 'pry'
+
+  $stderr.puts 'Maintainer mode enabled'
+  $CFLAGS << ' -ggdb' << ' -DDEBUG' << ' -pedantic'
+end
+
+# Disable noisy compilation warnings.
+$warnflags = ''
+$CFLAGS.gsub!(/[\s+](-ansi|-std=[^\s]+)/, '')
+
+$VPATH << "$(srcdir)/graphqlparser/"
+$VPATH << "$(srcdir)/graphqlparser/c/"
+$VPATH << "$(srcdir)/graphqlparser/parsergen/"
+
+$INCFLAGS << " -I$(srcdir)/graphqlparser/"
+$INCFLAGS << " -I$(srcdir)/graphqlparser/c/"
+$INCFLAGS << " -I$(srcdir)/graphqlparser/parsergen/"
+
+$srcs = [
+  File.join(precomp_dir, 'Ast.cpp'),
+  File.join(precomp_dir, 'JsonVisitor.cpp'),
+  File.join(precomp_dir, 'parsergen', 'parser.tab.cpp'),
+  File.join(precomp_dir, 'parsergen', 'lexer.cpp'),
+  File.join(precomp_dir, 'c', 'GraphQLAst.cpp'),
+  File.join(precomp_dir, 'c', 'GraphQLAstNode.cpp'),
+  File.join(precomp_dir, 'c', 'GraphQLAstToJSON.cpp'),
+  File.join(precomp_dir, 'c', 'GraphQLAstVisitor.cpp'),
+  File.join(precomp_dir, 'GraphQLParser.cpp'),
+  File.join(gem_root, 'ext', 'version.cpp'),
+]
+
+create_header
+create_makefile 'graphqlparser'

data/ext/graphqlparser/Ast.cpp

@@ -0,0 +1,346 @@
+/**
+ * Copyright 2019-present GraphQL Foundation
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+/** @generated */
+
+#include "Ast.h"
+#include "AstVisitor.h"
+
+namespace facebook {
+namespace graphql {
+namespace ast {
+
+void Document::accept(visitor::AstVisitor *visitor) const {
+  if (visitor->visitDocument(*this)) {
+
+    { for (const auto &x : *definitions_) { x->accept(visitor); } }
+  }
+  visitor->endVisitDocument(*this);
+}
+
+void OperationDefinition::accept(visitor::AstVisitor *visitor) const {
+  if (visitor->visitOperationDefinition(*this)) {
+
+    if (name_) { name_->accept(visitor); }
+    if (variableDefinitions_) { for (const auto &x : *variableDefinitions_) { x->accept(visitor); } }
+    if (directives_) { for (const auto &x : *directives_) { x->accept(visitor); } }
+    selectionSet_->accept(visitor);
+  }
+  visitor->endVisitOperationDefinition(*this);
+}
+
+void VariableDefinition::accept(visitor::AstVisitor *visitor) const {
+  if (visitor->visitVariableDefinition(*this)) {
+
+    variable_->accept(visitor);
+    type_->accept(visitor);
+    if (defaultValue_) { defaultValue_->accept(visitor); }
+  }
+  visitor->endVisitVariableDefinition(*this);
+}
+
+void SelectionSet::accept(visitor::AstVisitor *visitor) const {
+  if (visitor->visitSelectionSet(*this)) {
+
+    { for (const auto &x : *selections_) { x->accept(visitor); } }
+  }
+  visitor->endVisitSelectionSet(*this);
+}
+
+void Field::accept(visitor::AstVisitor *visitor) const {
+  if (visitor->visitField(*this)) {
+
+    if (alias_) { alias_->accept(visitor); }
+    name_->accept(visitor);
+    if (arguments_) { for (const auto &x : *arguments_) { x->accept(visitor); } }
+    if (directives_) { for (const auto &x : *directives_) { x->accept(visitor); } }
+    if (selectionSet_) { selectionSet_->accept(visitor); }
+  }
+  visitor->endVisitField(*this);
+}
+
+void Argument::accept(visitor::AstVisitor *visitor) const {
+  if (visitor->visitArgument(*this)) {
+
+    name_->accept(visitor);
+    value_->accept(visitor);
+  }
+  visitor->endVisitArgument(*this);
+}
+
+void FragmentSpread::accept(visitor::AstVisitor *visitor) const {
+  if (visitor->visitFragmentSpread(*this)) {
+
+    name_->accept(visitor);
+    if (directives_) { for (const auto &x : *directives_) { x->accept(visitor); } }
+  }
+  visitor->endVisitFragmentSpread(*this);
+}
+
+void InlineFragment::accept(visitor::AstVisitor *visitor) const {
+  if (visitor->visitInlineFragment(*this)) {
+
+    if (typeCondition_) { typeCondition_->accept(visitor); }
+    if (directives_) { for (const auto &x : *directives_) { x->accept(visitor); } }
+    selectionSet_->accept(visitor);
+  }
+  visitor->endVisitInlineFragment(*this);
+}
+
+void FragmentDefinition::accept(visitor::AstVisitor *visitor) const {
+  if (visitor->visitFragmentDefinition(*this)) {
+
+    name_->accept(visitor);
+    typeCondition_->accept(visitor);
+    if (directives_) { for (const auto &x : *directives_) { x->accept(visitor); } }
+    selectionSet_->accept(visitor);
+  }
+  visitor->endVisitFragmentDefinition(*this);
+}
+
+void Variable::accept(visitor::AstVisitor *visitor) const {
+  if (visitor->visitVariable(*this)) {
+
+    name_->accept(visitor);
+  }
+  visitor->endVisitVariable(*this);
+}
+
+void IntValue::accept(visitor::AstVisitor *visitor) const {
+  if (visitor->visitIntValue(*this)) {
+
+  }
+  visitor->endVisitIntValue(*this);
+}
+
+void FloatValue::accept(visitor::AstVisitor *visitor) const {
+  if (visitor->visitFloatValue(*this)) {
+
+  }
+  visitor->endVisitFloatValue(*this);
+}
+
+void StringValue::accept(visitor::AstVisitor *visitor) const {
+  if (visitor->visitStringValue(*this)) {
+
+  }
+  visitor->endVisitStringValue(*this);
+}
+
+void BooleanValue::accept(visitor::AstVisitor *visitor) const {
+  if (visitor->visitBooleanValue(*this)) {
+
+  }
+  visitor->endVisitBooleanValue(*this);
+}
+
+void NullValue::accept(visitor::AstVisitor *visitor) const {
+  if (visitor->visitNullValue(*this)) {
+
+  }
+  visitor->endVisitNullValue(*this);
+}
+
+void EnumValue::accept(visitor::AstVisitor *visitor) const {
+  if (visitor->visitEnumValue(*this)) {
+
+  }
+  visitor->endVisitEnumValue(*this);
+}
+
+void ListValue::accept(visitor::AstVisitor *visitor) const {
+  if (visitor->visitListValue(*this)) {
+
+    { for (const auto &x : *values_) { x->accept(visitor); } }
+  }
+  visitor->endVisitListValue(*this);
+}
+
+void ObjectValue::accept(visitor::AstVisitor *visitor) const {
+  if (visitor->visitObjectValue(*this)) {
+
+    { for (const auto &x : *fields_) { x->accept(visitor); } }
+  }
+  visitor->endVisitObjectValue(*this);
+}
+
+void ObjectField::accept(visitor::AstVisitor *visitor) const {
+  if (visitor->visitObjectField(*this)) {
+
+    name_->accept(visitor);
+    value_->accept(visitor);
+  }
+  visitor->endVisitObjectField(*this);
+}
+
+void Directive::accept(visitor::AstVisitor *visitor) const {
+  if (visitor->visitDirective(*this)) {
+
+    name_->accept(visitor);
+    if (arguments_) { for (const auto &x : *arguments_) { x->accept(visitor); } }
+  }
+  visitor->endVisitDirective(*this);
+}
+
+void NamedType::accept(visitor::AstVisitor *visitor) const {
+  if (visitor->visitNamedType(*this)) {
+
+    name_->accept(visitor);
+  }
+  visitor->endVisitNamedType(*this);
+}
+
+void ListType::accept(visitor::AstVisitor *visitor) const {
+  if (visitor->visitListType(*this)) {
+
+    type_->accept(visitor);
+  }
+  visitor->endVisitListType(*this);
+}
+
+void NonNullType::accept(visitor::AstVisitor *visitor) const {
+  if (visitor->visitNonNullType(*this)) {
+
+    type_->accept(visitor);
+  }
+  visitor->endVisitNonNullType(*this);
+}
+
+void Name::accept(visitor::AstVisitor *visitor) const {
+  if (visitor->visitName(*this)) {
+
+  }
+  visitor->endVisitName(*this);
+}
+
+void SchemaDefinition::accept(visitor::AstVisitor *visitor) const {
+  if (visitor->visitSchemaDefinition(*this)) {
+
+    if (directives_) { for (const auto &x : *directives_) { x->accept(visitor); } }
+    { for (const auto &x : *operationTypes_) { x->accept(visitor); } }
+  }
+  visitor->endVisitSchemaDefinition(*this);
+}
+
+void OperationTypeDefinition::accept(visitor::AstVisitor *visitor) const {
+  if (visitor->visitOperationTypeDefinition(*this)) {
+
+    type_->accept(visitor);
+  }
+  visitor->endVisitOperationTypeDefinition(*this);
+}
+
+void ScalarTypeDefinition::accept(visitor::AstVisitor *visitor) const {
+  if (visitor->visitScalarTypeDefinition(*this)) {
+
+    name_->accept(visitor);
+    if (directives_) { for (const auto &x : *directives_) { x->accept(visitor); } }
+  }
+  visitor->endVisitScalarTypeDefinition(*this);
+}
+
+void ObjectTypeDefinition::accept(visitor::AstVisitor *visitor) const {
+  if (visitor->visitObjectTypeDefinition(*this)) {
+
+    name_->accept(visitor);
+    if (interfaces_) { for (const auto &x : *interfaces_) { x->accept(visitor); } }
+    if (directives_) { for (const auto &x : *directives_) { x->accept(visitor); } }
+    { for (const auto &x : *fields_) { x->accept(visitor); } }
+  }
+  visitor->endVisitObjectTypeDefinition(*this);
+}
+
+void FieldDefinition::accept(visitor::AstVisitor *visitor) const {
+  if (visitor->visitFieldDefinition(*this)) {
+
+    name_->accept(visitor);
+    if (arguments_) { for (const auto &x : *arguments_) { x->accept(visitor); } }
+    type_->accept(visitor);
+    if (directives_) { for (const auto &x : *directives_) { x->accept(visitor); } }
+  }
+  visitor->endVisitFieldDefinition(*this);
+}
+
+void InputValueDefinition::accept(visitor::AstVisitor *visitor) const {
+  if (visitor->visitInputValueDefinition(*this)) {
+
+    name_->accept(visitor);
+    type_->accept(visitor);
+    if (defaultValue_) { defaultValue_->accept(visitor); }
+    if (directives_) { for (const auto &x : *directives_) { x->accept(visitor); } }
+  }
+  visitor->endVisitInputValueDefinition(*this);
+}
+
+void InterfaceTypeDefinition::accept(visitor::AstVisitor *visitor) const {
+  if (visitor->visitInterfaceTypeDefinition(*this)) {
+
+    name_->accept(visitor);
+    if (directives_) { for (const auto &x : *directives_) { x->accept(visitor); } }
+    { for (const auto &x : *fields_) { x->accept(visitor); } }
+  }
+  visitor->endVisitInterfaceTypeDefinition(*this);
+}
+
+void UnionTypeDefinition::accept(visitor::AstVisitor *visitor) const {
+  if (visitor->visitUnionTypeDefinition(*this)) {
+
+    name_->accept(visitor);
+    if (directives_) { for (const auto &x : *directives_) { x->accept(visitor); } }
+    { for (const auto &x : *types_) { x->accept(visitor); } }
+  }
+  visitor->endVisitUnionTypeDefinition(*this);
+}
+
+void EnumTypeDefinition::accept(visitor::AstVisitor *visitor) const {
+  if (visitor->visitEnumTypeDefinition(*this)) {
+
+    name_->accept(visitor);
+    if (directives_) { for (const auto &x : *directives_) { x->accept(visitor); } }
+    { for (const auto &x : *values_) { x->accept(visitor); } }
+  }
+  visitor->endVisitEnumTypeDefinition(*this);
+}
+
+void EnumValueDefinition::accept(visitor::AstVisitor *visitor) const {
+  if (visitor->visitEnumValueDefinition(*this)) {
+
+    name_->accept(visitor);
+    if (directives_) { for (const auto &x : *directives_) { x->accept(visitor); } }
+  }
+  visitor->endVisitEnumValueDefinition(*this);
+}
+
+void InputObjectTypeDefinition::accept(visitor::AstVisitor *visitor) const {
+  if (visitor->visitInputObjectTypeDefinition(*this)) {
+
+    name_->accept(visitor);
+    if (directives_) { for (const auto &x : *directives_) { x->accept(visitor); } }
+    { for (const auto &x : *fields_) { x->accept(visitor); } }
+  }
+  visitor->endVisitInputObjectTypeDefinition(*this);
+}
+
+void TypeExtensionDefinition::accept(visitor::AstVisitor *visitor) const {
+  if (visitor->visitTypeExtensionDefinition(*this)) {
+
+    definition_->accept(visitor);
+  }
+  visitor->endVisitTypeExtensionDefinition(*this);
+}
+
+void DirectiveDefinition::accept(visitor::AstVisitor *visitor) const {
+  if (visitor->visitDirectiveDefinition(*this)) {
+
+    name_->accept(visitor);
+    if (arguments_) { for (const auto &x : *arguments_) { x->accept(visitor); } }
+    { for (const auto &x : *locations_) { x->accept(visitor); } }
+  }
+  visitor->endVisitDirectiveDefinition(*this);
+}
+
+}  // namespace ast
+}  // namespace graphql
+}  // namespace facebook