graphql 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: c86e3ad590a80d6430b2fd781fb097e433d5e5c4
+  data.tar.gz: 60d41b9666ffaa6d63a73238fd572fdbbba38218
+SHA512:
+  metadata.gz: 27b1a4571a57b15e35dff3dcab058d8f8b9926c374361a6df52930296a1be705a49a5b345e23ad128d73eb81675a0b798e0b225c0c5fc92904cb76ebf3aaccfe
+  data.tar.gz: 5594ef107005a1d7abca4e9f6099a6c4f515176679d4421126e7a332a433271f367d447a981263a89accd573b8060ec22b1ee7f71809cb5a8c23e19d534eccee

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright 2015 Robert Mosolgo
+
+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/lib/graphql.rb

@@ -0,0 +1,26 @@
+require "parslet"
+require "active_support/core_ext/string/inflections"
+require "active_support/core_ext/object/blank"
+
+module GraphQL
+  VERSION = "0.0.1"
+
+  autoload(:CollectionEdge,   "graphql/collection_edge")
+  autoload(:Parser,           "graphql/parser")
+  autoload(:Query,            "graphql/query")
+  autoload(:Node,             "graphql/node")
+  autoload(:Transform,        "graphql/transform")
+
+  module Syntax
+    autoload(:Call,       "graphql/syntax/call")
+    autoload(:Edge,       "graphql/syntax/edge")
+    autoload(:Field,      "graphql/syntax/field")
+    autoload(:Node,       "graphql/syntax/node")
+  end
+
+  PARSER = Parser.new
+  TRANSFORM = Transform.new
+
+  class FieldNotDefinedError < RuntimeError
+  end
+end

data/lib/graphql/collection_edge.rb

@@ -0,0 +1,62 @@
+class GraphQL::CollectionEdge
+  attr_accessor :fields, :edge_class, :calls, :fields
+
+  def initialize(items:, edge_class:)
+    @items = items
+    @edge_class = edge_class
+  end
+
+  def to_json
+    json = {}
+    fields.each do |field|
+      name = field.identifier
+      if name == "edges"
+        json["edges"] = edges(fields: field.fields)
+      else
+        json[name] = safe_send(name)
+      end
+    end
+    json
+  end
+
+  def count
+    @items.count
+  end
+
+  def apply_calls(unfiltered_items, call_hash)
+    # override this to apply calls to your items
+    unfiltered_items
+  end
+
+  def edges(fields:)
+    filtered_items = apply_calls(items, calls)
+    filtered_items.map do |item|
+      node = edge_class.new(item)
+      json = {}
+      fields.each do |field|
+        name = field.identifier
+        if name == "node" # it's magic
+          node.fields = field.fields
+          json[name] = node.to_json
+        else
+          json[name] = node.safe_send(name)
+        end
+      end
+      json
+    end
+  end
+
+  def safe_send(identifier)
+    if respond_to?(identifier)
+      public_send(identifier)
+    else
+      raise GraphQL::FieldNotDefinedError, "#{self.class.name}##{identifier} was requested, but it isn't defined."
+    end
+  end
+
+  private
+
+  def items
+    @items
+  end
+end

data/lib/graphql/node.rb

@@ -0,0 +1,61 @@
+class GraphQL::Node
+  attr_accessor :fields
+
+  def initialize(target=nil)
+    # DONT EXPOSE Node#target! otherwise you might be able to access it
+    @target = target
+  end
+
+  def safe_send(identifier)
+    if respond_to?(identifier)
+      public_send(identifier)
+    else
+      raise GraphQL::FieldNotDefinedError, "#{self.class.name}##{identifier} was requested, but it isn't defined."
+    end
+  end
+
+  def to_json
+    json = {}
+    fields.each do |field|
+      name = field.identifier
+      if field.is_a?(GraphQL::Syntax::Field)
+        json[name] = safe_send(name)
+      elsif field.is_a?(GraphQL::Syntax::Edge)
+        edge = safe_send(field.identifier)
+        edge.calls = field.call_hash
+        edge.fields = field.fields
+        json[name] = edge.to_json
+      end
+    end
+    json
+  end
+
+
+  def self.call(argument)
+    raise NotImplementedError, "Implement #{name}#call(argument) to use this node as a call"
+  end
+
+  def self.field_reader(*field_names)
+    field_names.each do |field_name|
+      define_method(field_name) do
+        @target.public_send(field_name)
+      end
+    end
+  end
+
+  def self.edges(field_name, collection_class_name:, edge_class_name:)
+    define_method(field_name) do
+      collection_items = @target.send(field_name)
+      collection_class = Object.const_get(collection_class_name)
+      edge_class = Object.const_get(edge_class_name)
+      collection = collection_class.new(items: collection_items, edge_class: edge_class)
+    end
+  end
+
+
+  def self.cursor(field_name)
+    define_method "cursor" do
+      safe_send(field_name).to_s
+    end
+  end
+end

data/lib/graphql/parser.rb

@@ -0,0 +1,20 @@
+class GraphQL::Parser < Parslet::Parser
+  root(:node)
+
+  rule(:node) { space? >> call >> space? >> fields.as(:fields) }
+
+  rule(:fields) { str("{") >> space? >> ((edge | field) >> str(",").maybe >> space?).repeat(1) >> space? >> str("}") >> space?}
+
+  rule(:edge) { call_chain >> space? >> fields.as(:fields) }
+  rule(:call_chain) { identifier >> (dot >> call).repeat(0).as(:calls) }
+
+  rule(:call) { identifier >> str("(") >> name.maybe.as(:argument) >> str(")") }
+  rule(:dot) { str(".") }
+
+  rule(:field) { identifier }
+
+  rule(:identifier) { name.as(:identifier) }
+  rule(:name) { match('\w').repeat(1) }
+  rule(:space) { match('[\s\n]+').repeat(1) }
+  rule(:space?) { space.maybe }
+end

data/lib/graphql/query.rb

@@ -0,0 +1,41 @@
+class GraphQL::Query
+  attr_reader :query_string, :root, :namespace
+  def initialize(query_string, namespace: Object)
+    if !query_string.is_a?(String) || query_string.length == 0
+      raise "You must send a query string, not a #{query_string.class.name}"
+    end
+    @query_string = query_string
+    @root = parse(query_string)
+    @namespace = namespace
+  end
+
+  def to_json
+    root_node = make_call(nil, root.identifier, root.argument)
+    raise "Couldn't find root for #{root.identifier}(#{root.argument})" if root.nil?
+
+    root_node.fields = root.fields
+    {
+      root_node.cursor => root_node.to_json
+    }
+  end
+
+  def get_node(identifier)
+    name = "#{identifier}_node"
+    namespace.const_get(name.camelize)
+  end
+
+  def make_call(context, name, *arguments)
+    if context.nil?
+      context = get_node(name)
+      name = "call"
+    end
+    context.send(name, *arguments)
+  end
+
+  private
+
+  def parse(query_string)
+    parsed_hash = GraphQL::PARSER.parse(query_string)
+    root_node = GraphQL::TRANSFORM.apply(parsed_hash)
+  end
+end

data/lib/graphql/syntax/call.rb

@@ -0,0 +1,17 @@
+class GraphQL::Syntax::Call
+  attr_reader :identifier, :argument, :calls
+  def initialize(identifier:, argument: nil, calls: [])
+    @identifier = identifier
+    @argument = argument
+    @calls = calls
+  end
+
+  def execute!(query)
+    node_class = query.get_node(identifier)
+    node_class.call(argument)
+  end
+
+  def to_query
+    (["#{identifier}(#{argument})"] + calls.map(&:to_query)).join(".")
+  end
+end

data/lib/graphql/syntax/edge.rb

@@ -0,0 +1,12 @@
+class GraphQL::Syntax::Edge
+  attr_reader :identifier, :fields, :calls
+  def initialize(identifier:, fields:, calls:)
+    @identifier = identifier
+    @calls = calls
+    @fields = fields
+  end
+
+  def call_hash
+    calls.inject({}) { |memo, call| memo[call.identifier] = call.argument; memo }
+  end
+end

data/lib/graphql/syntax/field.rb

@@ -0,0 +1,7 @@
+class GraphQL::Syntax::Field
+  attr_reader :identifier, :calls
+  def initialize(identifier:, calls: [])
+    @identifier = identifier
+    @calls = calls
+  end
+end

data/lib/graphql/syntax/node.rb

@@ -0,0 +1,15 @@
+class GraphQL::Syntax::Node
+  attr_reader :identifier, :argument, :fields
+  def initialize(identifier:, argument:, fields: [])
+    @identifier = identifier
+    @argument = argument
+    @fields = fields
+  end
+
+  def execute!(query)
+    obj = identifier.execute!(query)
+    fields.each do |field|
+      obj.apply_field(field)
+    end
+  end
+end

data/lib/graphql/transform.rb

@@ -0,0 +1,10 @@
+class GraphQL::Transform < Parslet::Transform
+  # node
+  rule(identifier: simple(:i), argument: simple(:a), fields: sequence(:f)) {GraphQL::Syntax::Node.new(identifier: i.to_s, argument: a, fields: f)}
+  # edge
+  rule(identifier: simple(:i), calls: sequence(:c), fields: sequence(:f)) { GraphQL::Syntax::Edge.new(identifier: i.to_s, fields: f, calls: c)}
+  # field
+  rule(identifier: simple(:i)) { GraphQL::Syntax::Field.new(identifier: i.to_s)}
+  # call
+  rule(identifier: simple(:i), argument: simple(:a)) { GraphQL::Syntax::Call.new(identifier: i.to_s, argument: a) }
+end

data/readme.md

@@ -0,0 +1,18 @@
+# graphql
+
+- Parser & tranform from [parslet](http://kschiess.github.io/parslet/)
+- Your app can implement nodes
+- You can pass strings to `GraphQL::Query` and execute them with your nodes
+
+See `/spec/support/dummy_app/nodes.rb` for node examples
+
+__Nodes__ provide information to queries by mapping to application objects (via `.call` and `field_reader`) or implementing fields themselves (eg `Nodes::PostNode#teaser`).
+
+__Edges__ handle node-to-node relationships.
+
+
+## To do:
+
+- Better class inference. Declaring edge classes is stupid.
+- How to authenticate?
+- What do graphql mutation queries even look like?

data/spec/graphql/parser_spec.rb

@@ -0,0 +1,89 @@
+require 'spec_helper'
+
+describe GraphQL::Parser do
+  let(:node_name) { "" }
+  let(:fields) { "id, name"}
+  let(:query) { "#{node_name} { #{fields} }"}
+  let(:parser) { GraphQL::PARSER }
+
+  describe 'field' do
+    let(:field) { parser.field }
+    it 'finds words' do
+      assert field.parse_with_debug("name")
+      assert field.parse_with_debug("date_of_birth")
+    end
+  end
+
+  describe 'edge' do
+    let(:edge) { parser.edge }
+
+    it 'finds calls on fields' do
+      assert edge.parse_with_debug("friends.first(1) {
+              count,
+              edges {
+                cursor,
+                node {
+                  name
+                }
+              }
+            }
+        ")
+    end
+  end
+
+  describe 'call' do
+    let(:call) { parser.call }
+    it 'finds bare calls' do
+      assert call.parse_with_debug("node(123)")
+      assert call.parse_with_debug("viewer()")
+    end
+  end
+
+  describe 'call_chain' do
+    let(:call_chain) { parser.call_chain }
+    it 'finds deep calls' do
+      assert call_chain.parse_with_debug("friends.after(123).first(2)")
+    end
+    it 'finds chain with no calls' do
+      assert call_chain.parse_with_debug("friends")
+    end
+  end
+
+  describe 'fields' do
+    let(:fields) { parser.fields }
+
+    it 'finds fields' do
+      assert fields.parse_with_debug("{id,name}")
+      assert fields.parse_with_debug("{ id, name, favorite_food }")
+      assert fields.parse_with_debug("{\n  id,\n  name,\n  favorite_food\n}")
+    end
+
+    it 'finds nested field list' do
+      assert fields.parse_with_debug("{id,date_of_birth{month, year}}")
+    end
+  end
+
+  describe 'node' do
+    let(:node) { parser.node }
+
+    it 'parses root calls' do
+      assert node.parse_with_debug("viewer() {id}")
+    end
+
+    it 'parses nested nodes' do
+      assert node.parse_with_debug("node(someone)
+            {
+              id,
+              name,
+              friends.after(12345).first(3) {
+                cursor,
+                node {
+                  id,
+                  name
+                }
+              }
+            }
+          ")
+    end
+  end
+end

data/spec/graphql/query_spec.rb

@@ -0,0 +1,154 @@
+require 'spec_helper'
+
+describe GraphQL::Query do
+  let(:query_string) { "post(123) { title, content } "}
+  let(:namespace) { Nodes }
+  let(:query) { GraphQL::Query.new(query_string, namespace: namespace) }
+
+  describe '#root' do
+    it 'contains the first node of the graph' do
+      assert query.root.is_a?(GraphQL::Syntax::Node)
+    end
+  end
+
+  describe '#to_json' do
+    before do
+      @post = Post.create(id: 123, content: "So many great things", title: "My great post")
+      @comment1 = Comment.create(id: 444, post_id: 123, content: "I agree")
+      @comment2 = Comment.create(id: 445, post_id: 123, content: "I disagree")
+    end
+
+    after do
+      @post.destroy
+      @comment1.destroy
+      @comment2.destroy
+    end
+
+    it 'performs the root node call' do
+      assert_send([Nodes::PostNode, :call, "123"])
+      query.to_json
+    end
+
+    it 'finds fields that delegate to a target' do
+      assert_equal query.to_json, {
+        "123" => {
+          "title" => "My great post",
+          "content" => "So many great things"
+        }
+      }
+    end
+
+    describe 'when requesting fields defined on the node' do
+      let(:query_string) { "post(123) { teaser } "}
+      it 'finds fields defined on the node' do
+        assert_equal query.to_json, { "123" => { "teaser" => @post.content[0,10] + "..."}}
+      end
+    end
+
+
+    describe 'when requesting an undefined field' do
+      let(:query_string) { "post(123) { destroy } "}
+      it 'raises a FieldNotDefined error' do
+        assert_raises(GraphQL::FieldNotDefinedError) { query.to_json }
+        assert(Post.find(123).present?)
+      end
+    end
+
+    describe 'when the root call doesnt have an argument' do
+      let(:query_string) { "viewer() { name }"}
+      it 'calls the node with nil' do
+        assert_send([Nodes::ViewerNode, :call, nil])
+        query.to_json
+      end
+    end
+
+    describe  'when requesting a collection' do
+      let(:query_string) { "post(123) {
+          title,
+          comments {
+            count,
+            edges {
+              cursor,
+              node {
+                content
+              }
+            }
+          }
+        }"}
+      it 'returns collection data' do
+        assert_equal query.to_json, {
+            "123" => {
+              "title" => "My great post",
+              "comments" => {
+                "count" => 2,
+                "edges" => [
+                  {
+                    "cursor" => "444",
+                    "node" => {
+                      "content" => "I agree"
+                    }
+                  },
+                  {
+                    "cursor" => "445",
+                    "node" => {
+                      "content" => "I disagree"
+                    }
+                  }
+                ]
+              }
+            }
+          }
+      end
+    end
+
+    describe  'when making calls on a collection' do
+      let(:query_string) { "post(123) {
+          comments.first(1) {
+            edges { cursor, node { content } }
+          }
+        }"}
+
+      it 'executes those calls' do
+        assert_equal query.to_json, {
+            "123" => {
+              "comments" => {
+                "edges" => [
+                  {
+                    "cursor" => "444",
+                    "node" => {
+                      "content" => "I agree"
+                    }
+                  }
+                ]
+              }
+            }
+          }
+      end
+    end
+
+    describe  'when making DEEP calls on a collection' do
+      let(:query_string) { "post(123) {
+          comments.after(444).first(1) {
+            edges { cursor, node { content } }
+          }
+        }"}
+
+      it 'executes those calls' do
+        assert_equal query.to_json, {
+            "123" => {
+              "comments" => {
+                "edges" => [
+                  {
+                    "cursor" => "445",
+                    "node" => {
+                      "content" => "I disagree"
+                    }
+                  }
+                ]
+              }
+            }
+          }
+      end
+    end
+  end
+end

data/spec/graphql/transform_spec.rb

@@ -0,0 +1,58 @@
+require 'spec_helper'
+
+describe GraphQL::Transform do
+  let(:transform) { GraphQL::TRANSFORM }
+  let(:parser) { GraphQL::PARSER }
+
+  describe '#apply' do
+    it 'turns a simple node into a Node' do
+      tree = parser.parse("post(123) { name }")
+      res = transform.apply(tree)
+      assert(res.is_a?(GraphQL::Syntax::Node), 'it gets a node')
+    end
+
+    it 'turns a node into a Node' do
+      tree = parser.parse("viewer() { name, friends.first(10) { birthdate } }")
+      res = transform.apply(tree)
+      assert(res.is_a?(GraphQL::Syntax::Node), 'it gets a node')
+      assert(res.identifier == "viewer")
+      assert(res.fields.length == 2)
+      assert(res.fields[0].is_a?(GraphQL::Syntax::Field), 'it gets a field')
+      assert(res.fields[1].is_a?(GraphQL::Syntax::Edge), 'it gets an edge')
+    end
+
+    it 'turns a field into a Field' do
+      tree = parser.field.parse("friends")
+      res = transform.apply(tree)
+      assert(res.is_a?(GraphQL::Syntax::Field))
+      assert(res.identifier == "friends")
+    end
+
+    it 'turns edge into an Edge' do
+      tree = parser.edge.parse("friends.after(123).first(2) { count, edges { node { name } } }")
+      res = transform.apply(tree)
+      assert(res.is_a?(GraphQL::Syntax::Edge), 'it gets the Edge')
+      assert(res.identifier == "friends")
+      assert(res.calls.length == 2, 'it tracks calls')
+      assert(res.calls[0].identifier == "after")
+      assert(res.calls[1].identifier == "first")
+      assert_equal(res.call_hash, {"after" => "123", "first" => "2"})
+    end
+
+    it 'turns call into a Call' do
+      tree = parser.call.parse("node(123)")
+      res = transform.apply(tree)
+      assert(res.is_a?(GraphQL::Syntax::Call))
+      assert(res.identifier == "node")
+      assert(res.argument == "123")
+    end
+
+    it 'turns a call without an argument into a Call' do
+      tree = parser.call.parse("viewer()")
+      res = transform.apply(tree)
+      assert(res.is_a?(GraphQL::Syntax::Call))
+      assert(res.identifier == "viewer")
+      assert(res.argument == nil)
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,15 @@
+require "minitest/autorun"
+require "minitest/focus"
+require "minitest/reporters"
+
+Minitest::Reporters.use! Minitest::Reporters::SpecReporter.new
+
+# Filter out Minitest backtrace while allowing backtrace from other libraries
+# to be shown.
+Minitest.backtrace_filter = Minitest::BacktraceFilter.new
+
+# # Load support files
+Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each { |f| require f }
+
+require 'parslet'
+require 'parslet/convenience'

data/spec/support/dummy_app.rb

@@ -0,0 +1,61 @@
+class InadequateRecordBase
+  def initialize(attributes={})
+    attributes.each do |key, value|
+      self.send("#{key}=", value)
+    end
+  end
+
+  def destroy
+    self.class.objects.delete(self)
+  end
+
+  class << self
+    attr_accessor :_objects
+    def objects
+      @_objects ||= []
+    end
+  end
+
+  def self.find(id)
+    objects.find { |object| object.id.to_s == id.to_s}
+  end
+
+  def self.where(query={})
+    result = []
+    objects.each do |object|
+      match = true
+
+      query.each do |key, value|
+        if object.send(key) != value
+          match = false
+        end
+      end
+
+      result << object if match
+    end
+    result
+  end
+
+  def self.create(attributes)
+    instance = self.new(attributes)
+    objects << instance
+    instance
+  end
+end
+
+class Post < InadequateRecordBase
+  attr_accessor :id, :title, :content
+
+  def comments
+    Comment.where(post_id: id)
+  end
+end
+
+class Comment < InadequateRecordBase
+  attr_accessor :id, :post_id, :content
+  def post
+    Post.find(post_id)
+  end
+end
+
+

data/spec/support/nodes.rb

@@ -0,0 +1,59 @@
+module Nodes
+  class PostNode < GraphQL::Node
+    field_reader :id, :title, :content
+    cursor :id
+
+    edges :comments,
+      collection_class_name: "Nodes::ApplicationCollectionEdge",
+      edge_class_name: "Nodes::CommentNode"
+
+    def teaser
+      content.length > 10 ? "#{content[0..9]}..." : content
+    end
+
+    def self.call(argument)
+      post = Post.find(argument.to_i)
+      self.new(post)
+    end
+  end
+
+  class CommentNode < GraphQL::Node
+    field_reader :id, :post, :content
+    cursor :id
+
+    def self.call(argument)
+      obj = Comment.find(argument)
+      self.new(obj)
+    end
+  end
+
+  class ViewerNode < GraphQL::Node
+    def name
+      "It's you again"
+    end
+
+    def cursor
+      "viewer"
+    end
+
+    def self.call(argument)
+      self.new
+    end
+  end
+
+  class ApplicationCollectionEdge < GraphQL::CollectionEdge
+    def apply_calls(items, calls)
+      filtered_items = items
+
+      if calls["after"].present?
+        filtered_items = filtered_items.select {|i| i.id > calls["after"].to_i }
+      end
+
+      if calls["first"].present?
+        filtered_items = filtered_items.first(calls["first"].to_i)
+      end
+
+      filtered_items
+    end
+  end
+end

metadata

@@ -0,0 +1,180 @@
+--- !ruby/object:Gem::Specification
+name: graphql
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Robert Mosolgo
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-01-30 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '4'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '4'
+- !ruby/object:Gem::Dependency
+  name: parslet
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.6.2
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.6.2
+- !ruby/object:Gem::Dependency
+  name: guard
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: guard-bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: guard-minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: minitest-focus
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: minitest-reporters
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: A GraphQL adapter for Ruby
+email:
+- rdmosolgo@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- MIT-LICENSE
+- lib/graphql.rb
+- lib/graphql/collection_edge.rb
+- lib/graphql/node.rb
+- lib/graphql/parser.rb
+- lib/graphql/query.rb
+- lib/graphql/syntax/call.rb
+- lib/graphql/syntax/edge.rb
+- lib/graphql/syntax/field.rb
+- lib/graphql/syntax/node.rb
+- lib/graphql/transform.rb
+- readme.md
+- spec/graphql/parser_spec.rb
+- spec/graphql/query_spec.rb
+- spec/graphql/transform_spec.rb
+- spec/spec_helper.rb
+- spec/support/dummy_app.rb
+- spec/support/nodes.rb
+homepage: http://github.com/rmosolgo/graphql
+licenses:
+- MIT
+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: GraphQL
+test_files:
+- spec/graphql/parser_spec.rb
+- spec/graphql/query_spec.rb
+- spec/graphql/transform_spec.rb
+- spec/spec_helper.rb
+- spec/support/dummy_app.rb
+- spec/support/nodes.rb