graphql 0.1.0 → 0.2.0

data/lib/graph_ql/types/scalar_type.rb

@@ -2,4 +2,8 @@ class GraphQL::ScalarType < GraphQL::ObjectType
   def kind
     GraphQL::TypeKinds::SCALAR
   end
+
+  def to_s
+    "<GraphQL::ScalarType #{name} >"
+  end
 end

data/lib/graph_ql/types/string_type.rb

@@ -1,6 +1,6 @@
-GraphQL::STRING_TYPE = GraphQL::ScalarType.new do
-  name "String"
-  def coerce(value)
+GraphQL::STRING_TYPE = GraphQL::ScalarType.new do |t|
+  t.name "String"
+  def t.coerce(value)
     value.to_s
   end
 end

data/lib/graph_ql/types/type_definer.rb

@@ -1,14 +1,10 @@
 class GraphQL::TypeDefiner
-  TYPES = {
-    Int:     GraphQL::INT_TYPE,
-    String:  GraphQL::STRING_TYPE,
-    Float:   GraphQL::FLOAT_TYPE,
-    Boolean: GraphQL::BOOLEAN_TYPE,
-  }
+  include Singleton
 
-  TYPES.each do |method_name, type|
-    define_method(method_name) { type }
-  end
+  def Int;      GraphQL::INT_TYPE;      end
+  def String;   GraphQL::STRING_TYPE;   end
+  def Float;    GraphQL::FLOAT_TYPE;    end
+  def Boolean;  GraphQL::BOOLEAN_TYPE;  end
 
   def [](type)
     GraphQL::ListType.new(of_type: type)

data/lib/graph_ql/union.rb

@@ -1,25 +1,14 @@
 class GraphQL::Union
   include GraphQL::NonNullWithBang
-  attr_reader :name, :possible_types
-  def initialize(name, types)
-    if types.length < 2
-      raise ArgumentError, "Union #{name} must be defined with 2 or more types, not #{types.length}"
-    end
-
-    non_object_types = types.select {|t| t.kind != GraphQL::TypeKinds::OBJECT}
-    if non_object_types.any?
-      types_string = non_object_types.map{|t| "#{t.name} #{t.kind}"}.join(", ")
-      raise ArgumentError, "Unions can only consist of Object types, but #{name} has non-object types: #{types_string}"
-    end
-
+  attr_reader :name, :description, :possible_types
+  def initialize(name, desc, types)
     @name = name
+    @description = desc
     @possible_types = types
   end
 
-  def kind; GraphQL::TypeKinds::UNION; end
-
-  def include?(type)
-    possible_types.include?(type)
+  def kind
+    GraphQL::TypeKinds::UNION
   end
 
   # Find a type in this union for a given object.
@@ -30,6 +19,6 @@ class GraphQL::Union
   end
 
   def to_s
-    "<GraphQL::Union #{name} [#{possible_types.map(&:name).join(", ")}]>"
+    "<GraphQL::Union #{name}>"
   end
 end

data/lib/graph_ql/version.rb

@@ -1,3 +1,3 @@
 module GraphQL
-  VERSION = "0.1.0"
+  VERSION = "0.2.0"
 end

data/lib/graphql.rb

@@ -1,84 +1,8 @@
-require "active_support/core_ext/object/blank"
-require "active_support/core_ext/string/inflections"
-require "active_support/dependencies/autoload"
 require "json"
 require "parslet"
+require "singleton"
 
 module GraphQL
-  extend ActiveSupport::Autoload
-  autoload(:Directive)
-  autoload(:Enum)
-  autoload(:Interface)
-  autoload(:Parser)
-  autoload(:Query)
-  autoload(:Repl)
-  autoload(:Schema)
-  autoload(:TypeKinds)
-  autoload(:Union)
-  autoload(:Validator)
-  autoload(:VERSION)
-
-  autoload_under "directives" do
-    autoload(:DirectiveChain)
-    autoload(:IncludeDirective)
-    autoload(:SkipDirective)
-  end
-
-  autoload_under "fields" do
-    autoload(:AbstractField)
-    autoload(:AccessField)
-    autoload(:Field)
-  end
-
-  autoload_under "introspection" do
-    autoload(:ArgumentsField)
-    autoload(:DirectiveType)
-    autoload(:EnumValuesField)
-    autoload(:EnumValueType)
-    autoload(:FieldType)
-    autoload(:FieldsField)
-    autoload(:InputValueType)
-    autoload(:InputFieldsField)
-    autoload(:OfTypeField)
-    autoload(:PossibleTypesField)
-    autoload(:SchemaType)
-    autoload(:TypeKindEnum)
-    autoload(:TypeType)
-  end
-
-  autoload_under "parser" do
-    autoload(:Nodes)
-    autoload(:Parser)
-    autoload(:Transform)
-    autoload(:Visitor)
-  end
-
-  autoload_under "types" do
-    autoload(:AbstractType)
-    autoload(:BOOLEAN_TYPE)
-    autoload(:ScalarType)
-    autoload(:FLOAT_TYPE)
-    autoload(:InputObjectType)
-    autoload(:InputValue)
-    autoload(:INT_TYPE)
-    autoload(:ListType)
-    autoload(:NonNullType)
-    autoload(:NonNullWithBang)
-    autoload(:ObjectType)
-    autoload(:STRING_TYPE)
-    autoload(:TypeDefiner)
-  end
-
-  module Validations
-    extend ActiveSupport::Autoload
-    autoload(:FieldsWillMerge)
-    autoload(:FragmentsAreUsed)
-    autoload(:FieldsAreDefinedOnType)
-  end
-
-  PARSER = Parser.new
-  TRANSFORM = Transform.new
-
   def self.parse(string, as: nil)
     parser = as ? GraphQL::PARSER.send(as) : GraphQL::PARSER
     tree = parser.parse(string)
@@ -88,7 +12,6 @@ module GraphQL
     raise [line, col, string].join(", ")
   end
 
-
   module Definable
     def attr_definable(*names)
       attr_accessor(*names)
@@ -111,4 +34,61 @@ module GraphQL
       end
     end
   end
+
+  module Introspection; end
 end
+
+# Order matters for these:
+
+require 'graph_ql/types/non_null_with_bang'
+require 'graph_ql/types/object_type'
+require 'graph_ql/types/list_type'
+require 'graph_ql/types/scalar_type'
+require 'graph_ql/types/non_null_type'
+require 'graph_ql/types/input_value'
+require 'graph_ql/types/input_object_type'
+
+require 'graph_ql/types/type_definer'
+require 'graph_ql/types/field_definer'
+require 'graph_ql/types/argument_definer'
+
+require 'graph_ql/enum'
+require 'graph_ql/field'
+require 'graph_ql/union'
+require 'graph_ql/type_kinds'
+require 'graph_ql/introspection/typename_field'
+
+require 'graph_ql/types/int_type'
+require 'graph_ql/types/string_type'
+require 'graph_ql/types/float_type'
+require 'graph_ql/types/boolean_type'
+
+require 'graph_ql/introspection/input_value_type'
+require 'graph_ql/introspection/enum_value_type'
+require 'graph_ql/introspection/type_kind_enum'
+
+require 'graph_ql/introspection/fields_field'
+require 'graph_ql/introspection/of_type_field'
+require 'graph_ql/introspection/input_fields_field'
+require 'graph_ql/introspection/possible_types_field'
+require 'graph_ql/introspection/enum_values_field'
+require 'graph_ql/introspection/interfaces_field'
+
+require 'graph_ql/introspection/type_type'
+require 'graph_ql/introspection/field_type'
+
+require 'graph_ql/introspection/arguments_field'
+require 'graph_ql/introspection/directive_type'
+require 'graph_ql/introspection/schema_type'
+
+require 'graph_ql/parser'
+require 'graph_ql/directive'
+require 'graph_ql/schema'
+
+# Order does not matter for these:
+
+require 'graph_ql/interface'
+require 'graph_ql/query'
+require 'graph_ql/repl'
+require 'graph_ql/static_validation'
+require 'graph_ql/version'

data/readme.md

@@ -6,23 +6,96 @@
 [![Test Coverage](https://codeclimate.com/github/rmosolgo/graphql-ruby/badges/coverage.svg)](https://codeclimate.com/github/rmosolgo/graphql-ruby)
 [![built with love](https://cloud.githubusercontent.com/assets/2231765/6766607/d07992c6-cfc9-11e4-813f-d9240714dd50.png)](http://rmosolgo.github.io/react-badges/)
 
-__Current status__: rewriting according to spec, see also the previous [prototype implementation](https://github.com/rmosolgo/graphql-ruby/tree/74ad3c30a6d8db010ec3856f5871f8a02fcfba42)!
-
 ## Overview
 
-- See the __[test schema](https://github.com/rmosolgo/graphql-ruby/blob/master/spec/support/dummy_app.rb)__ for an example GraphQL schema in Ruby.
-- See __[query_spec.rb](https://github.com/rmosolgo/graphql-ruby/blob/master/spec/graph_ql/query_spec.rb)__ for an example of query execution.
+- __Install the gem__:
+
+  ```ruby
+  # Gemfile
+  gem 'graphql'
+  ```
+
+  ```
+  $ bundle install
+  ```
+
+- __Declare types & build a schema__:
+
+  ```ruby
+  # Declare a type...
+  PostType = GraphQL::ObjectType.new do |t, types, field|
+    t.name "Post"
+    t.description "A blog post"
+    t.fields({
+      id:       field.build(type: !types.Int)
+      title:    field.build(type: !types.String),
+      body:     field.build(type: !types.String),
+      comments: field.build(type: types[!CommentType])
+    })
+  end
+
+  # ...and a query root
+  QueryType = GraphQL::ObjectType.new do |t, types, field, arg|
+    t.name "Query"
+    t.description "The query root of this schema"
+    t.fields({
+      post: GraphQL::Field.new do |f|
+        f.arguments(id: arg.build(type: !types.Int))
+        f.resolve -> (object, args, context) {
+          Post.find(args["id"])
+        }
+      end
+    })
+  end
+
+  # Then create your schema
+  Schema = GraphQL::Schema.new(query: QueryType, mutation: nil)
+  ```
+
+  See also:
+    - the [test schema](https://github.com/rmosolgo/graphql-ruby/blob/master/spec/support/dummy_app.rb)
+    - [`graphql-ruby-demo`](https://github.com/rmosolgo/graphql-ruby-demo) for an example schema on Rails
+
+- __Execute queries__:
+
+  ```ruby
+  query = GraphQL::Query.new(Schema, query_string)
+  result_hash = query.result
+  # {
+  #   "data" => {
+  #     "post" => {
+  #        "id" => 1,
+  #        "title" => "GraphQL is nice"
+  #     }
+  #   }
+  # }
+  ```
+
+  See also:
+  - [query_spec.rb](https://github.com/rmosolgo/graphql-ruby/blob/master/spec/graph_ql/query_spec.rb) for an example of query execution.
+  -  [`queries_controller.rb`](https://github.com/rmosolgo/graphql-ruby-demo/blob/master/app/controllers/queries_controller.rb) for a Rails example
+  - Try it on [heroku](http://graphql-ruby-demo.herokuapp.com)
 
 ## To Do:
 
 - Validations:
-  - implement lots of validators
-  - build error object with position
-  - Express failure with `errors` key (http://facebook.github.io/graphql/#sec-Errors)
+  - Implement validations:
+    - [Fragment spreads are on Object/Union/Interface](http://facebook.github.io/graphql/#sec-Fragments-On-Composite-Types)
+    - [Fragments don't go infinite](http://facebook.github.io/graphql/#sec-Fragment-spreads-must-not-form-cycles)
+    - [Fragment spreads are possible](http://facebook.github.io/graphql/#sec-Fragment-spread-is-possible)
+    - [In object scope, object-typed fragments are the same type](http://facebook.github.io/graphql/#sec-Object-Spreads-In-Object-Scope)
+    - [In object scope, abstract-typed fragments fit that object](http://facebook.github.io/graphql/#sec-Abstract-Spreads-in-Object-Scope)
+    - [In abstract scope, object-typed fragments fit that type](http://facebook.github.io/graphql/#sec-Object-Spreads-In-Abstract-Scope)
+    - [In abstract scope, abstract-typed fragments must share a type](http://facebook.github.io/graphql/#sec-Abstract-Spreads-in-Abstract-Scope)
+    - everything in [Variables](http://facebook.github.io/graphql/#sec-Validation.Operations.Variables)
 - directives:
   - `@skip` has precedence over `@include`
   - directives on fragments: http://facebook.github.io/graphql/#sec-Fragment-Directives
+- Support any "real" value for enum, not just stringified name (see `Character::EPISODES` in demo)
 - field merging (https://github.com/graphql/graphql-js/issues/19#issuecomment-118515077)
+- Code clean-up
+  - Unify unwrapping types (It's on `TypeKind` but it's still not right)
+  - de-dup stringify keys logic in `Field` and `ObjectType` and `Directive`
 
 ## Goals:
 

data/spec/graph_ql/interface_spec.rb

@@ -1,7 +1,7 @@
 require 'spec_helper'
 
 describe GraphQL::Interface do
-  let(:interface) { Edible }
+  let(:interface) { EdibleInterface }
   it 'has possible types' do
     assert_equal([CheeseType, MilkType], interface.possible_types)
   end
@@ -10,4 +10,18 @@ describe GraphQL::Interface do
     assert_equal(CheeseType, interface.resolve_type(CHEESES.values.first))
     assert_equal(MilkType, interface.resolve_type(MILKS.values.first))
   end
+
+  describe 'query evaluation' do
+    let(:query) { GraphQL::Query.new(DummySchema, query_string, context: {}, params: {"cheeseId" => 2})}
+    let(:result) { query.result }
+    let(:query_string) {%|
+      query fav {
+        favoriteEdible { fatContent }
+      }
+    |}
+    it 'gets fields from the type for the given object' do
+      expected = {"data"=>{"fav"=>{"favoriteEdible"=>{"fatContent"=>0.04}}}}
+      assert_equal(expected, result)
+    end
+  end
 end

data/spec/graph_ql/introspection/directive_type_spec.rb

@@ -1,10 +1,10 @@
 require 'spec_helper'
 
-describe GraphQL::DirectiveType do
+describe GraphQL::Introspection::DirectiveType do
   let(:query_string) {%|
     query getDirectives {
       __schema {
-        directives { name, args { name, type { name, ofType { name }} }, onField, onFragment, onOperation }
+        directives { name, args { name, type { name, ofType { name } } }, onField, onFragment, onOperation }
       }
     }
   |}

data/spec/graph_ql/introspection/schema_type_spec.rb

@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-describe GraphQL::SchemaType do
+describe GraphQL::Introspection::SchemaType do
   let(:query_string) {%|
     query getSchema {
       __schema {
@@ -21,6 +21,7 @@ describe GraphQL::SchemaType do
             {"name"=>"fromSource"},
             {"name"=>"favoriteEdible"},
             {"name"=>"searchDairy"},
+            {"name"=>"error"},
             {"name"=>"__typename"},
             {"name"=>"__type"},
             {"name"=>"__schema"},

data/spec/graph_ql/introspection/type_type_spec.rb

@@ -1,9 +1,10 @@
 require 'spec_helper'
 
-describe GraphQL::TypeType do
+describe GraphQL::Introspection::TypeType do
   let(:query_string) {%|
      query introspectionQuery {
        cheeseType:    __type(name: "Cheese") { name, kind, fields { name, isDeprecated, type { name, ofType { name } } } }
+       milkType:      __type(name: "Milk") { interfaces { name }, fields { type { name, ofType { name } } } }
        dairyAnimal:   __type(name: "DairyAnimal") { name, kind, enumValues(includeDeprecated: false) { name, isDeprecated } }
        dairyProduct:  __type(name: "DairyProduct") { name, kind, possibleTypes { name } }
        animalProduct: __type(name: "AnimalProduct") { name, kind, possibleTypes { name }, fields { name } }
@@ -14,6 +15,7 @@ describe GraphQL::TypeType do
     {"name"=>"id",          "isDeprecated" => false, "type" => { "name" => "Non-Null", "ofType" => { "name" => "Int"}}},
     {"name"=>"flavor",      "isDeprecated" => false, "type" => { "name" => "Non-Null", "ofType" => { "name" => "String"}}},
     {"name"=>"source",      "isDeprecated" => false, "type" => { "name" => "Non-Null", "ofType" => { "name" => "DairyAnimal"}}},
+    {"name"=>"similarCheeses", "isDeprecated"=>false, "type"=>{"name"=>"Cheese", "ofType"=>nil}},
     {"name"=>"__typename",  "isDeprecated"=>false,    "type"=> { "name" => "Non-Null", "ofType" => { "name" => "String"}}},
   ]}
 
@@ -29,6 +31,19 @@ describe GraphQL::TypeType do
         "kind" => "OBJECT",
         "fields"=> cheese_fields
       },
+      "milkType"=>{
+        "interfaces"=>[
+          {"name"=>"Edible"},
+          {"name"=>"AnimalProduct"}
+        ],
+        "fields"=>[
+          {"type"=>{"name"=>"Non-Null", "ofType"=>{"name"=>"Int"}}},
+          {"type"=>{"name"=>"DairyAnimal", "ofType"=>nil}},
+          {"type"=>{"name"=>"Non-Null", "ofType"=>{"name"=>"Float"}}},
+          {"type"=>{"name"=>"List", "ofType"=>{"name"=>"String"}}},
+          {"type"=>{"name"=>"Non-Null", "ofType"=>{"name"=>"String"}}}
+        ]
+      },
       "dairyAnimal"=>{
         "name"=>"DairyAnimal",
         "kind"=>"ENUM",

data/spec/graph_ql/parser/parser_spec.rb

@@ -38,7 +38,7 @@ describe GraphQL::Parser do
     assert(parser.operation_definition.parse_with_debug(%|{id, name, ...people}|), "just a selection")
     assert(parser.operation_definition.parse_with_debug(%|query personStuff {id, name, ...people, ... stuff}|), "named fetch")
     assert(parser.operation_definition.parse_with_debug(%|query personStuff @flagDirective {id, name, ...people}|), "with a directive")
-    assert(parser.operation_definition.parse_with_debug(%|mutation changeStuff($stuff: Int = 1, $things: [Boolean]!) {id, name, ...people}|), "mutation with arguments")
+    assert(parser.operation_definition.parse_with_debug(%|mutation changeStuff($stuff: Int = 1, $things: [SomeType]!) {id, name, ...people}|), "mutation with arguments")
   end
 
   it 'parses fragment definitions' do
@@ -85,7 +85,9 @@ describe GraphQL::Parser do
     it 'gets floats' do
       assert(parser.value.parse_with_debug("1.14"), 'no exponent')
       assert(parser.value.parse_with_debug("6.7e-9"), 'negative exponent')
+      assert(parser.value.parse_with_debug("6.7e+9"), 'positive exponent')
       assert(parser.value.parse_with_debug("0.4e12"), 'exponent')
+      assert(parser.value.parse_with_debug("6.7E+9"), 'big e')
     end
 
     it 'gets booleans' do