gql 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 40a578a7c57911bdf4d1b7c062259f3e47bfee30
+  data.tar.gz: 8dbc6b5ddf034a2fa5f939aa401c1ea2c031412a
+SHA512:
+  metadata.gz: f13475e99d0efe4cac42faecb6d8128d861dbb74bd89ae971adf2613d17d47a5d8108be0bcf412eb8b00fbdfd41e1deae26a0291c5424012a1518df73929f0d2
+  data.tar.gz: b47a428fd3e2235fb38c81434651ffa06195f8b98c40abb0215b0e1d039a02346c7e0153a4735f2de09a5d23db6f04e0cac9793d5b69ffa42540cc9730196356

data/.gitignore

@@ -0,0 +1,10 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+/lib/gql/parser.output

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in gql.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2015 Martin Andert
+
+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.md

@@ -0,0 +1,160 @@
+# GQL
+
+An attempted implementation of Facebook's yet-to-be-released GraphQL specification, heavily inspired by [graphql-ruby](https://github.com/rmosolgo/graphql-ruby), but with other/more/less features/bugs.
+
+Caution! This is pre-alpha software. Use at your own risk.
+
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'gql'
+```
+
+And then execute:
+
+```sh
+$ bundle
+```
+
+Or install it yourself as:
+
+```
+$ gem install gql
+```
+
+
+## Usage
+
+TODO: Write usage instructions here
+
+
+## Example
+
+Run `bin/console` for an interactive prompt and enter the following:
+
+```ruby
+puts q(<<-QUERY_STRING).to_json
+  user(<token>) {
+    id,
+    is_admin,
+    full_name as name,
+    created_at { year, month } as created_year_and_month,
+    created_at.format("long") as created,
+    account {
+      bank_name,
+      iban,
+      saldo as saldo_string,
+      saldo {
+        currency,
+        cents   /* silly block comment */
+      }
+    },
+    albums.first(2) {
+      count,
+      edges {
+        cursor,
+        node {
+          artist,
+          title,
+          songs.first(2) {
+            edges {
+              id,
+              title.upcase as upcased_title,
+              title.upcase.length as upcased_title_length
+            }
+          }
+        }
+      }
+    }
+  }
+
+  <token> = "ma"  // a variable
+QUERY_STRING
+```
+
+This should result in the following JSON (after prettyfication):
+
+```json
+  {
+    "id": "ma",
+    "is_admin": true,
+    "name": "Martin Andert",
+    "created_year_and_month": {
+      "year": 2010,
+      "month": 3
+    },
+    "created": "March 04, 2010 14:04",
+    "account": {
+      "bank_name": "Foo Bank",
+      "iban": "987654321",
+      "saldo_string": "100000.00 EUR",
+      "saldo": {
+        "currency": "EUR",
+        "cents": 10000000
+      }
+    },
+    "albums": {
+      "count": 2,
+      "edges": [
+        {
+          "cursor": "1",
+          "node": {
+            "artist": "Metallica",
+            "title": "Black Album",
+            "songs": {
+              "edges": [
+                {
+                  "id": 1,
+                  "upcased_title": "ENTER SANDMAN",
+                  "upcased_title_length": 13
+                }, {
+                  "id": 2,
+                  "upcased_title": "SAD BUT TRUE",
+                  "upcased_title_length": 12
+                }
+              ]
+            }
+          }
+        }, {
+          "cursor": "2",
+          "node": {
+            "artist": "Nirvana",
+            "title": "Nevermind",
+            "songs": {
+              "edges": [
+                {
+                  "id": 5,
+                  "upcased_title": "SMELLS LIKE TEEN SPIRIT",
+                  "upcased_title_length": 23
+                }, {
+                  "id": 6,
+                  "upcased_title": "COME AS YOU ARE",
+                  "upcased_title_length": 15
+                }
+              ]
+            }
+          }
+        }
+      ]
+    }
+  }
+```
+
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release` to create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+
+## Contributing
+
+1. Fork it ( https://github.com/martinandert/gql/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request

data/Rakefile

@@ -0,0 +1,22 @@
+require 'bundler/gem_tasks'
+require 'rake/testtask'
+
+Rake::TestTask.new :test => :compile do |t|
+  t.libs << 'test'
+end
+
+file 'lib/gql/tokenizer.rb' => 'lib/gql/tokenizer.rex' do |t|
+  sh "bundle exec rex #{t.prerequisites.first} --output-file #{t.name}"
+end
+
+file 'lib/gql/parser.rb' => 'lib/gql/parser.y' do |t|
+  if ENV['DEBUG']
+    sh "bundle exec racc --debug --verbose --output-file=#{t.name} #{t.prerequisites.first}"
+  else
+    sh "bundle exec racc --output-file=#{t.name} #{t.prerequisites.first}"
+  end
+end
+
+task :compile => ['lib/gql/tokenizer.rb', 'lib/gql/parser.rb']
+
+task :default => :test

data/bin/console

@@ -0,0 +1,25 @@
+#!/usr/bin/env ruby
+
+require 'bundler/setup'
+require 'gql'
+
+require_relative '../test/example'
+
+def ctxt
+  @ctxt ||= { auth_token: 'ma' }
+end
+
+def q(string, context = ctxt)
+  GQL.execute string, context
+end
+
+def p(string)
+  GQL.parse string
+end
+
+def t(string, &block)
+  GQL.tokenize string, &block
+end
+
+require 'irb'
+IRB.start

data/bin/setup

@@ -0,0 +1,5 @@
+#!/bin/bash
+set -euo pipefail
+IFS=$'\n\t'
+
+bundle install

data/gql.gemspec

@@ -0,0 +1,30 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+
+require 'gql/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'gql'
+  spec.version       = GQL::VERSION
+  spec.authors       = ['Martin Andert']
+  spec.email         = ['mandert@gmail.com']
+
+  spec.summary       = 'An attempted Ruby implementation of Facebook\'s yet-to-be-released GraphQL specification.'
+  spec.homepage      = 'https://github.com/martinandert/gql'
+  spec.license       = 'MIT'
+
+  spec.required_ruby_version = '>= 2.2.0'
+
+  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  spec.bindir        = 'exe'
+  spec.require_paths = ['lib']
+
+  spec.add_development_dependency 'bundler', '~> 1.8'
+  spec.add_development_dependency 'rake', '~> 10.0'
+  spec.add_development_dependency 'minitest'
+  spec.add_development_dependency 'rexical', '~> 1.0'
+  spec.add_development_dependency 'racc', '~> 1.4'
+
+  spec.add_dependency 'activesupport', '~> 4.2'
+end

data/lib/gql.rb

@@ -0,0 +1,68 @@
+module GQL
+  autoload :Call,       'gql/call'
+  autoload :Connection, 'gql/connection'
+  autoload :Executor,   'gql/executor'
+  autoload :Field,      'gql/field'
+  autoload :Node,       'gql/node'
+  autoload :Parser,     'gql/parser'
+  autoload :Schema,     'gql/schema'
+  autoload :Tokenizer,  'gql/tokenizer'
+  autoload :VERSION,    'gql/version'
+
+  module Errors
+    autoload :InvalidNodeClass, 'gql/errors'
+    autoload :ParseError,       'gql/errors'
+    autoload :UndefinedCall,    'gql/errors'
+    autoload :UndefinedField,   'gql/errors'
+    autoload :UndefinedRoot,    'gql/errors'
+    autoload :UndefinedType,    'gql/errors'
+  end
+
+  module Fields
+    autoload :Boolean,      'gql/fields/boolean'
+    autoload :Connection,   'gql/fields/connection'
+    autoload :Float,        'gql/fields/float'
+    autoload :Integer,      'gql/fields/integer'
+    autoload :Object,       'gql/fields/object'
+    autoload :String,       'gql/fields/string'
+  end
+
+  Schema.fields.update(
+    boolean:    Fields::Boolean,
+    connection: Fields::Connection,
+    float:      Fields::Float,
+    integer:    Fields::Integer,
+    object:     Fields::Object,
+    string:     Fields::String
+  )
+
+  extend(Module.new {
+    def execute(input, context = {})
+      ast = parse(input)
+
+      executor = Executor.new(ast)
+      executor.execute context
+    end
+
+    def parse(input)
+      input = input.read if input.respond_to?(:read)
+
+      tokenizer = Tokenizer.new
+      tokenizer.scan_setup input
+
+      parser = Parser.new(tokenizer)
+      parser.parse
+    end
+
+    def tokenize(input)
+      input = input.read if input.respond_to?(:read)
+
+      tokenizer = Tokenizer.new
+      tokenizer.scan_setup input
+
+      while token = tokenizer.next_token
+        yield token
+      end
+    end
+  })
+end

data/lib/gql/call.rb

@@ -0,0 +1,22 @@
+module GQL
+  class Call
+    attr_reader :target, :context
+
+    def initialize(caller, ast_node, target, definition, variables, context)
+      @caller, @ast_node, @target = caller, ast_node, target
+      @definition, @variables, @context = definition, variables, context
+    end
+
+    def execute
+      args = @ast_node.arguments.map { |arg| arg.is_a?(Symbol) ? @variables[arg] : arg }
+      target = instance_exec(*args, &@definition[:body])
+
+      node_class = @definition[:returns] || @caller.class
+
+      raise Errors::InvalidNodeClass.new(node_class, Node) unless node_class < Node
+
+      node = node_class.new(@ast_node, target, @variables, context)
+      node.__value
+    end
+  end
+end

data/lib/gql/connection.rb

@@ -0,0 +1,32 @@
+module GQL
+  class Connection < Node
+    field :edges
+
+    def initialize(node_class, *args)
+      super(*args)
+
+      @node_class = node_class
+    end
+
+    alias :items :__target
+
+    def edges_ast_node
+      @edges_ast_node ||= @ast_node.fields.find { |f| f.name == :edges }
+    end
+
+    def edges
+      raise Errors::InvalidNodeClass.new(@node_class, Node) unless @node_class < Node
+
+      items.map do |item|
+        node = @node_class.new(edges_ast_node, item, @variables, __context)
+        node.__value
+      end
+    end
+
+    EdgesField.class_eval do
+      def __value
+        __target
+      end
+    end
+  end
+end

data/lib/gql/errors.rb

@@ -0,0 +1,58 @@
+require 'active_support/core_ext/array/conversions'
+
+module GQL
+  class Error < StandardError
+  end
+
+  module Errors
+    class SchemaError < Error
+    end
+
+    class UndefinedRoot < SchemaError
+      def initialize
+        super('No root node class is known to the schema. Assign it with `GQL::Schema.root = MyRootNode`.')
+      end
+    end
+
+    class InvalidNodeClass < SchemaError
+      def initialize(node_class, super_class)
+        super("#{node_class} must be a subclass of #{super_class}.")
+      end
+    end
+
+    class UndefinedType < SchemaError
+      def initialize(name)
+        types = Schema.fields.keys.sort.map { |name| "`#{name}`" }
+        types = types.size > 0 ? " Available types are #{types.to_sentence}." : ''
+
+        super("The field type `#{name}` is not known to the schema. Define it with `GQL::Schema.fields[my_type] = MyFieldType`.#{types}")
+      end
+    end
+
+    class UndefinedCall < SchemaError
+      def initialize(name, node_class)
+        calls = node_class.call_definitions.keys.sort.map { |name| "`#{name}`" }
+        calls = calls.size > 0 ? " Available calls are #{calls.to_sentence}." : ''
+
+        super("#{node_class} has no call named `#{name}`.#{calls}")
+      end
+    end
+
+    class UndefinedField < SchemaError
+      def initialize(name, node_class)
+        fields = node_class.field_classes.keys.sort.map { |name| "`#{name}`" }
+        fields = fields.size > 0 ? " Available fields are #{fields.to_sentence}." : ''
+
+        super("#{node_class} has no field named `#{name}`.#{fields}")
+      end
+    end
+
+    class ParseError < Error
+      def initialize(value, token)
+        token = 'value' if token == 'error'
+
+        super("Unexpected #{token}: `#{value}`.")
+      end
+    end
+  end
+end