graphql 0.0.4 → 0.1.0

data/lib/graphql/root_call_argument.rb

@@ -1,11 +0,0 @@
-# Created by {RootCall.argument}, used internally by GraphQL
-class GraphQL::RootCallArgument
-  attr_reader :type, :name, :any_number
-  attr_accessor :index
-  def initialize(type:, name:, any_number: false, index: nil)
-    @type = type
-    @name = name
-    @any_number = any_number
-    @index = index
-  end
-end

data/lib/graphql/root_call_argument_definer.rb

@@ -1,17 +0,0 @@
-# Enables the {RootCall.argument} API, used internall by GraphQL
-class GraphQL::RootCallArgumentDefiner
-  ARGUMENT_TYPES = [:string, :object, :number]
-
-  def initialize(owner)
-    @owner = owner
-  end
-
-  def none
-  end
-
-  ARGUMENT_TYPES.each do |arg_type|
-    define_method arg_type do |name, any_number: false|
-      @owner.add_argument(GraphQL::RootCallArgument.new(type: arg_type.to_s, name: name.to_s, any_number: any_number))
-    end
-  end
-end

data/lib/graphql/schema/all.rb

@@ -1,46 +0,0 @@
-# This query string yields the whole schema. Access it from {GraphQL::Schema::Schema#all}
-GraphQL::Schema::ALL = "
-schema() {
-      calls {
-        count,
-        edges {
-          node {
-            name,
-            returns,
-            arguments {
-              edges {
-                node {
-                  name, type
-                }
-              }
-            }
-          }
-        }
-      },
-      types {
-        count,
-        edges {
-          node {
-            name,
-            fields {
-              count,
-              edges {
-                node {
-                  name,
-                  type,
-                  calls {
-                    count,
-                    edges {
-                      node {
-                        name,
-                        arguments
-                      }
-                    }
-                  }
-                }
-              }
-            }
-          }
-        }
-      }
-    }"

data/lib/graphql/schema/schema.rb

@@ -1,87 +0,0 @@
-# {GraphQL::SCHEMA} keeps track of defined nodes, fields and calls.
-#
-# Although you don't interact with it directly, it responds to queries for `schema()` and `__type__` info.
-#
-# You can validate it at runtime with {#validate}
-# @example
-#   # validate the schema
-#   GraphQL::SCHEMA.validate
-#
-require "singleton"
-
-class GraphQL::Schema::Schema
-  include Singleton
-  attr_reader :types, :calls, :class_names
-  def initialize
-    @types = {}
-    @class_names = {}
-    @calls = {}
-  end
-
-  # Queries the whole schema and returns the result
-  def all
-    GraphQL::Query.new(GraphQL::Schema::ALL).as_result
-  end
-
-  def validate
-    validation = GraphQL::Schema::SchemaValidation.new
-    validation.validate(self)
-  end
-
-  def add_call(call_class)
-    remove_call(call_class)
-    raise "You can't make #{call_class.name}'s type '#{call_class.schema_name}'" if call_class.schema_name.blank?
-    @calls[call_class.schema_name] = call_class
-  end
-
-  def get_call(identifier)
-    @calls[identifier.to_s] || raise(GraphQL::RootCallNotDefinedError.new(identifier))
-  end
-
-  def remove_call(call_class)
-    existing_name = @calls.key(call_class)
-    if existing_name
-      @calls.delete(existing_name)
-    end
-  end
-
-  def call_names
-    @calls.keys
-  end
-
-  def add_type(node_class)
-    existing_name = @types.key(node_class)
-    if existing_name
-      @types.delete(existing_name)
-    end
-
-    node_class.exposes_class_names.each do |exposes_class_name|
-      @class_names[exposes_class_name] = node_class
-    end
-
-    @types[node_class.schema_name] = node_class
-  end
-
-  def get_type(identifier)
-    @types[identifier.to_s] || raise(GraphQL::NodeNotDefinedError.new(identifier))
-  end
-
-  def type_names
-    @types.keys.sort
-  end
-
-  def type_for_object(app_object)
-    registered_class_names = @class_names.keys
-    if app_object.is_a?(Class)
-      app_class = app_object
-    else
-      app_class = app_object.class
-    end
-    app_class.ancestors.map(&:name).each do |class_name|
-      if registered_class_names.include?(class_name)
-        return @class_names[class_name]
-      end
-    end
-    raise "Couldn't find node for class #{app_class} \"#{app_object}\" (ancestors: #{app_class.ancestors.map(&:name)}, defined: #{registered_class_names})"
-  end
-end

data/lib/graphql/schema/schema_validation.rb

@@ -1,32 +0,0 @@
-# Validates a schema (specifically, {GraphQL::SCHEMA}).
-#
-# It checks:
-# - All classes exposed by nodes actually exist
-# - Field types requested by nodes actually exist
-# - Fields' corresponding methods actually exist
-#
-# To validate a schema, use {GraphQL::Schema::Schema#validate}.
-class GraphQL::Schema::SchemaValidation
-  # Validates the schema
-  def validate(schema)
-    schema.types.each do |type_name, type_class|
-
-      type_class.exposes_class_names.each do |exposes_class_name|
-        begin
-          Object.const_get(exposes_class_name)
-        rescue NameError
-          raise GraphQL::ExposesClassMissingError.new(type_class)
-        end
-      end
-
-      type_class.all_fields.each do |field_name, field_mapping|
-        # Make sure the type exists
-        field_mapping.type_class
-        # Make sure the node can handle it
-        if !type_class.respond_to_field?(field_mapping.name)
-          raise GraphQL::FieldNotDefinedError.new(type_class, field_mapping.name)
-        end
-      end
-    end
-  end
-end

data/lib/graphql/syntax/call.rb

@@ -1,8 +0,0 @@
-class GraphQL::Syntax::Call
-  attr_reader :identifier, :arguments, :calls
-  def initialize(identifier:, arguments: nil, calls: [])
-    @identifier = identifier
-    @arguments = arguments
-    @calls = calls
-  end
-end

data/lib/graphql/syntax/field.rb

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

data/lib/graphql/syntax/fragment.rb

@@ -1,7 +0,0 @@
-class GraphQL::Syntax::Fragment
-  attr_reader :identifier, :fields
-  def initialize(identifier:, fields:)
-    @identifier = identifier
-    @fields = fields
-  end
-end

data/lib/graphql/syntax/node.rb

@@ -1,8 +0,0 @@
-class GraphQL::Syntax::Node
-  attr_reader :identifier, :arguments, :fields
-  def initialize(identifier:, arguments:, fields: [])
-    @identifier = identifier
-    @arguments = arguments
-    @fields = fields
-  end
-end

data/lib/graphql/syntax/query.rb

@@ -1,8 +0,0 @@
-class GraphQL::Syntax::Query
-  attr_reader :nodes, :variables, :fragments
-  def initialize(nodes:, variables:, fragments:)
-    @nodes = nodes
-    @variables = variables
-    @fragments = fragments
-  end
-end

data/lib/graphql/syntax/variable.rb

@@ -1,7 +0,0 @@
-class GraphQL::Syntax::Variable
-  attr_reader :identifier, :json_string
-  def initialize(identifier:, json_string:)
-    @identifier = identifier
-    @json_string = json_string
-  end
-end

data/lib/graphql/types/boolean_type.rb

@@ -1,3 +0,0 @@
-class GraphQL::Types::BooleanType < GraphQL::Types::ObjectType
-  exposes("TrueClass", "FalseClass")
-end

data/lib/graphql/types/number_type.rb

@@ -1,3 +0,0 @@
-class GraphQL::Types::NumberType < GraphQL::Types::ObjectType
-  exposes("Numeric")
-end

data/lib/graphql/types/object_type.rb

@@ -1,6 +0,0 @@
-class GraphQL::Types::ObjectType < GraphQL::Node
-  exposes("Object")
-  def as_result
-    target
-  end
-end

data/lib/graphql/types/string_type.rb

@@ -1,3 +0,0 @@
-class GraphQL::Types::StringType < GraphQL::Types::ObjectType
-  exposes("String")
-end

data/lib/graphql/version.rb

@@ -1,3 +0,0 @@
-module GraphQL
-  VERSION = "0.0.4"
-end

data/spec/graphql/node_spec.rb

@@ -1,69 +0,0 @@
-require 'spec_helper'
-
-describe GraphQL::Node do
-  let(:query_string) { "type(post) { name, description, fields { count, edges { node { name, type }}} }"}
-  let(:result) { GraphQL::Query.new(query_string).as_result}
-
-  describe '__type__' do
-    let(:title_field) { result["post"]["fields"]["edges"].find {|e| e["node"]["name"] == "title"}["node"] }
-
-    it 'has name' do
-      assert_equal "post", result["post"]["name"]
-    end
-
-    it 'has description' do
-      assert_equal "A blog post entry", result["post"]["description"]
-    end
-
-    it 'has fields' do
-      assert_equal 8, result["post"]["fields"]["count"]
-      assert_equal({ "name" => "title", "type" => "string"}, title_field)
-    end
-
-    describe 'getting the __type__ field' do
-      before do
-        @post = Post.create(id: 155, content: "Hello world")
-      end
-
-      after do
-        @post.destroy
-      end
-
-      let(:query_string) { "post(155) { __type__ { name, fields { count } } }"}
-
-      it 'exposes the type' do
-        assert_equal "post", result["155"]["__type__"]["name"]
-        assert_equal 8, result["155"]["__type__"]["fields"]["count"]
-      end
-    end
-  end
-
-  describe '.node_name' do
-    let(:query_string) { "type(upvote) { name }"}
-
-    it 'overrides __type__.name' do
-      assert_equal "upvote", result["upvote"]["name"]
-    end
-  end
-
-  describe '.field' do
-    it 'doesnt add the field twice if you call it twice' do
-      assert_equal 5, Nodes::CommentNode.all_fields.size
-      Nodes::CommentNode.field.number(:id)
-      Nodes::CommentNode.field.number(:id)
-      assert_equal 5, Nodes::CommentNode.all_fields.size
-      Nodes::CommentNode.remove_field(:id)
-    end
-
-    describe 'type:' do
-      it 'uses symbols to find built-ins' do
-        field_mapping = Nodes::CommentNode.all_fields["id"]
-        assert_equal GraphQL::Types::NumberType, field_mapping.type_class
-      end
-      it 'uses the provided class as a superclass' do
-        letters_field = Nodes::CommentNode.all_fields["letters"]
-        assert_equal Nodes::LetterSelectionType, letters_field.type_class
-      end
-    end
-  end
-end

data/spec/graphql/parser/parser_spec.rb

@@ -1,168 +0,0 @@
-require 'spec_helper'
-
-describe GraphQL::Parser::Parser do
-  let(:parser) { GraphQL::PARSER }
-
-  describe 'query' do
-    let(:query) { parser.query }
-    it 'parses node-only' do
-      assert query.parse_with_debug("node(4) { id, name } ")
-    end
-    it 'parses node and variables' do
-      assert query.parse_with_debug(%{
-        like_page(<page>) {
-          $pageFragment
-        }
-        <page>: {
-          "page": {"id": 1},
-          "person" : { "id", 4}
-        }
-        <other>: {
-          "page": {"id": 1},
-          "person" : { "id", 4}
-        }
-
-        $pageFragment: {
-          page { id }
-        }
-      })
-    end
-  end
-
-  describe 'field' do
-    let(:field) { parser.field }
-    it 'finds words' do
-      assert field.parse_with_debug("date_of_birth")
-    end
-
-    it 'finds aliases' do
-      assert field.parse_with_debug("name as moniker")
-    end
-
-    it 'finds calls on fields' do
-      assert field.parse_with_debug("url.site(www).upcase()")
-    end
-
-    describe 'fields that return objects' do
-      it 'finds them' do
-        assert field.parse_with_debug("birthdate { month, year }")
-      end
-
-      it 'finds them with aliases' do
-        assert field.parse_with_debug("birthdate as d_o_b { month, year }")
-      end
-
-      it 'finds them with calls' do
-        assert field.parse_with_debug("friends.after(123) { count { edges { node { id } } } }")
-      end
-
-      it 'finds them with calls and aliases' do
-        assert field.parse_with_debug("friends.after(123) as pals { count { edges { node { id } } } }")
-      end
-    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
-
-    it 'finds calls with multiple arguments' do
-      assert call.parse_with_debug("node(4, 6)")
-    end
-
-    it 'finds calls with variables' do
-      assert call.parse_with_debug("like_page(<page>)")
-    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 query fragments' do
-      assert node.parse_with_debug("viewer() { id, $someFrag }")
-    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
-
-  describe 'variable' do
-    let(:variable) { parser.variable }
-
-    it 'gets scalar variables' do
-      assert variable.parse_with_debug(%{<some_number>: 888})
-      assert variable.parse_with_debug(%{<some_string>: my_string})
-    end
-    it 'gets json variables' do
-      assert variable.parse_with_debug(%{<my_input>: {"key": "value"}})
-    end
-
-    it 'gets variables with nesting' do
-      assert variable.parse_with_debug(%{
-      <my_input>: {
-        "key": "value",
-        "1": 2,
-        "true": false,
-        "nested": {
-          "key" : "value"
-          }
-        }
-      })
-    end
-  end
-
-  describe 'fragment' do
-    let(:fragment) { parser.fragment }
-
-    it 'gets parts of queries' do
-      assert fragment.parse_with_debug(%{ $frag: { id } })
-    end
-
-    it 'gets nested parts of queries' do
-      assert fragment.parse_with_debug(%{
-        $frag: {
-          item {
-            name,
-            price
-          },
-          $qtyFragment
-        }
-      })
-    end
-  end
-end