graphql 0.0.3 → 0.0.4

data/lib/graphql/root_call_argument.rb

@@ -1,9 +1,11 @@
 # Created by {RootCall.argument}, used internally by GraphQL
 class GraphQL::RootCallArgument
   attr_reader :type, :name, :any_number
-  def initialize(type:, name:, any_number: false)
+  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

@@ -2,20 +2,16 @@
 class GraphQL::RootCallArgumentDefiner
   ARGUMENT_TYPES = [:string, :object, :number]
 
-  attr_reader :arguments
-
-  def initialize(call_class)
-    @call_class = call_class
-    @arguments = []
+  def initialize(owner)
+    @owner = owner
   end
 
   def none
-    @arguments = []
   end
 
   ARGUMENT_TYPES.each do |arg_type|
     define_method arg_type do |name, any_number: false|
-      @arguments << GraphQL::RootCallArgument.new(type: arg_type.to_s, name: name.to_s, any_number: any_number)
+      @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

@@ -0,0 +1,46 @@
+# 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.rb → schema/schema.rb}

@@ -1,19 +1,36 @@
 # {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.
-class GraphQL::Schema
+#
+# 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, :fields, :class_names, :connections
+  attr_reader :types, :calls, :class_names
   def initialize
     @types = {}
-    @connections = {}
-    @fields = {}
     @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
 
@@ -38,7 +55,10 @@ class GraphQL::Schema
       @types.delete(existing_name)
     end
 
-    @class_names[node_class.ruby_class_name] = node_class
+    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
 
@@ -47,7 +67,7 @@ class GraphQL::Schema
   end
 
   def type_names
-    @types.keys
+    @types.keys.sort
   end
 
   def type_for_object(app_object)
@@ -62,38 +82,6 @@ class GraphQL::Schema
         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
-
-  def add_connection(node_class)
-    existing_name = @connections.key(node_class)
-    if existing_name
-      @connections.delete(existing_name)
-    end
-    @connections[node_class.schema_name.to_s] = node_class
-  end
-
-  def get_connection(identifier)
-    @connections[identifier] || GraphQL::Connection.default_connection || raise(GraphQL::ConnectionNotDefinedError.new(identifier))
-  end
-
-  def connection_names
-    @connections.keys
-  end
-
-  def add_field(field_class)
-    existing_name = @fields.key(field_class)
-    if existing_name
-      @fields.delete(existing_name)
-    end
-    @fields[field_class.schema_name.to_s] = field_class
-  end
-
-  def get_field(identifier)
-    @fields[identifier.to_s] || raise(GraphQL::FieldNotDefinedError.new("<unknown>", identifier))
-  end
-
-  def field_names
-    @fields.keys
+    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

@@ -0,0 +1,32 @@
+# 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/fragment.rb

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

data/lib/graphql/syntax/query.rb

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

data/lib/graphql/types/boolean_type.rb

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

data/lib/graphql/types/number_type.rb

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

data/lib/graphql/types/object_type.rb

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

data/lib/graphql/types/string_type.rb

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

data/lib/graphql/version.rb

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

data/readme.md

@@ -5,7 +5,8 @@
 [![Dependency Status](https://gemnasium.com/rmosolgo/graphql-ruby.svg)](https://gemnasium.com/rmosolgo/graphql-ruby)
 [![Code Climate](https://codeclimate.com/github/rmosolgo/graphql-ruby/badges/gpa.svg)](https://codeclimate.com/github/rmosolgo/graphql-ruby)
 [![Test Coverage](https://codeclimate.com/github/rmosolgo/graphql-ruby/badges/coverage.svg)](https://codeclimate.com/github/rmosolgo/graphql-ruby)
-![image](https://cloud.githubusercontent.com/assets/2231765/6424458/d5fd3896-beae-11e4-892a-77e135e6bf37.png)
+[![built with love](https://cloud.githubusercontent.com/assets/2231765/6766607/d07992c6-cfc9-11e4-813f-d9240714dd50.png)](http://rmosolgo.github.io/react-badges/)
+
 
 Create a GraphQL interface by implementing [__nodes__](#nodes) and [__calls__](#calls), then running [__queries__](#queries).
 
@@ -13,14 +14,11 @@ API Docs: <http://rubydoc.info/gems/graphql>
 
 ## To do:
 
-- Allow a default connection class, or some way to infer connection from name
-  - right now, `Introspection::Connection` isn't getting used, only `ApplicationConnection` is.
 - How do you express failure? HTTP response? `errors` key?
 - Handle blank objects in nested calls (how? wait for spec)
 - Implement calls as arguments
 - double-check how to handle `pals.first(3) { count }`
 - Implement call argument introspection (wait for spec)
-- For fields that return objects, can they be queried _without_ other fields? Or must they always have fields?
 
 ## Example Implementation
 
@@ -48,7 +46,8 @@ class FishNode < GraphQL::Node
   field.number(:id)
   field.string(:name)
   field.string(:species)
-  field.object(:aquarium)
+  # specify an `AquariumNode`:
+  field.aquarium(:aquarium)
 end
 ```
 
@@ -64,6 +63,48 @@ class AquariumNode < GraphQL::Node
 end
 ```
 
+You can make custom connections:
+
+```ruby
+class FishSchoolConnection < GraphQL::Connection
+  type :fish_school # now it is a field type
+  call :largest, -> (prev_value, number)  { fishes.sort_by(&:weight).first(number.to_i) }
+
+  field.number(:count) # delegated to `target`
+  field.boolean(:has_more)
+
+  def has_more
+    # the `largest()` call may have removed some items:
+    target.count < original_target.count
+  end
+end
+```
+
+Then use them:
+
+```ruby
+class AquariumNode < GraphQL::Node
+  field.fish_school(:fishes)
+end
+```
+
+And in queries:
+
+```
+aquarium(1) {
+  name,
+  occupancy,
+  fishes.largest(3) {
+      edges {
+        node { name, species }
+      },
+      count,
+      has_more
+    }
+  }
+}
+```
+
 ### Calls
 
 Calls selectively expose your application to the world. They always return values and they may perform mutations.

data/spec/graphql/node_spec.rb

@@ -1,11 +1,12 @@
 require 'spec_helper'
 
 describe GraphQL::Node do
-  let(:query_string) { "type(post) { name, description, fields { count, edges { node { name, description }}} }"}
+  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
@@ -16,7 +17,7 @@ describe GraphQL::Node do
 
     it 'has fields' do
       assert_equal 8, result["post"]["fields"]["count"]
-      assert_equal({ "name" => "title", "description" => nil}, title_field)
+      assert_equal({ "name" => "title", "type" => "string"}, title_field)
     end
 
     describe 'getting the __type__ field' do
@@ -56,12 +57,12 @@ describe GraphQL::Node do
 
     describe 'type:' do
       it 'uses symbols to find built-ins' do
-        id_field = Nodes::CommentNode.all_fields["id"]
-        assert id_field.superclass == GraphQL::Types::NumberField
+        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 letters_field.superclass == Nodes::LetterSelectionField
+        assert_equal Nodes::LetterSelectionType, letters_field.type_class
       end
     end
   end

data/spec/graphql/{parser_spec.rb → parser/parser_spec.rb}

@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-describe GraphQL::Parser do
+describe GraphQL::Parser::Parser do
   let(:parser) { GraphQL::PARSER }
 
   describe 'query' do
@@ -11,7 +11,7 @@ describe GraphQL::Parser do
     it 'parses node and variables' do
       assert query.parse_with_debug(%{
         like_page(<page>) {
-          page { id }
+          $pageFragment
         }
         <page>: {
           "page": {"id": 1},
@@ -21,9 +21,14 @@ describe GraphQL::Parser do
           "page": {"id": 1},
           "person" : { "id", 4}
         }
+
+        $pageFragment: {
+          page { id }
+        }
       })
     end
   end
+
   describe 'field' do
     let(:field) { parser.field }
     it 'finds words' do
@@ -94,6 +99,10 @@ describe GraphQL::Parser 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)
@@ -136,4 +145,24 @@ describe GraphQL::Parser do
       })
     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