graphql 0.3.0 → 0.4.0

data/lib/graph_ql/definition_helpers/forwardable.rb

@@ -1,10 +0,0 @@
-# Get `delegate` like Rails has
-module GraphQL::Forwardable
-  def delegate(*methods, to:)
-    methods.each do |method_name|
-      define_method(method_name) do |*args|
-        self.public_send(to).public_send(method_name, *args)
-      end
-    end
-  end
-end

data/lib/graph_ql/parser/parser.rb

@@ -1,108 +0,0 @@
-# Parser is a [parslet](http://kschiess.github.io/parslet/) parser for parsing queries.
-#
-# If it failes to parse, a {SyntaxError} is raised.
-class GraphQL::Parser < Parslet::Parser
-  root(:document)
-  rule(:document) { (
-      space                |
-      operation_definition |
-      fragment_definition
-    ).repeat(1).as(:document_parts)
-  }
-
-  # TODO: whitespace sensitive regarding `on`, eg `onFood`, see lookahead note in spec
-  rule(:fragment_definition) {
-    str("fragment").as(:fragment_keyword) >>
-     space? >> name.as(:fragment_name) >>
-     space? >> str("on") >> space? >> name.as(:type_condition) >>
-     space? >> directives.maybe.as(:optional_directives).as(:directives) >>
-     space? >> selections.as(:selections)
-  }
-
-  rule(:fragment_spread) {
-    spread.as(:fragment_spread_keyword) >> space? >>
-    name.as(:fragment_spread_name) >> space? >>
-    directives.maybe.as(:optional_directives).as(:directives)
-  }
-  rule(:spread) { str("...") }
-  # TODO: `on` bug, see spec
-  rule(:inline_fragment) {
-    spread.as(:fragment_spread_keyword) >> space? >>
-    str("on ") >> name.as(:inline_fragment_type) >> space? >>
-    directives.maybe.as(:optional_directives).as(:directives) >> space? >>
-    selections.as(:selections)
-  }
-
-  rule(:operation_definition) { (unnamed_selections | named_operation_definition) }
-  rule(:unnamed_selections) { selections.as(:unnamed_selections)}
-  rule(:named_operation_definition) {
-    operation_type.as(:operation_type) >> space? >>
-    name.as(:name) >> space? >>
-    operation_variable_definitions.maybe.as(:optional_variables).as(:variables) >> space? >>
-    directives.maybe.as(:optional_directives).as(:directives) >> space? >>
-    selections.as(:selections)
-  }
-  rule(:operation_type) { (str("query") | str("mutation")) }
-  rule(:operation_variable_definitions) { str("(") >> space? >> (operation_variable_definition >> separator?).repeat(1) >> space? >> str(")") }
-  rule(:operation_variable_definition) {
-    value_variable.as(:variable_name) >> space? >>
-    str(":") >> space? >>
-    type.as(:variable_type) >> space? >>
-    (str("=") >> space? >> value.as(:variable_default_value)).maybe.as(:variable_optional_default_value)}
-
-  rule(:selection) { (inline_fragment | fragment_spread | field) >> space? >> separator? }
-  rule(:selections) { str("{") >> space? >> selection.repeat(1) >> space? >> str("}")}
-
-  rule(:field) {
-    field_alias.maybe.as(:alias) >>
-    name.as(:field_name) >>
-    field_arguments.maybe.as(:optional_field_arguments).as(:field_arguments) >> space? >>
-    directives.maybe.as(:optional_directives).as(:directives) >> space? >>
-    selections.maybe.as(:optional_selections).as(:selections)
-  }
-
-  rule(:field_alias) { name.as(:alias_name) >> space? >> str(":") >> space? }
-  rule(:field_arguments) { str("(") >> field_argument.repeat(1) >> str(")") }
-  rule(:field_argument) { name.as(:field_argument_name) >> str(":") >> space? >> value.as(:field_argument_value) >> separator? }
-
-  rule(:directives) { (directive >> separator?).repeat(1) }
-  rule(:directive) {
-    str("@") >> name.as(:directive_name) >>
-    directive_arguments.maybe.as(:optional_directive_arguments).as(:directive_arguments)
-  }
-  rule(:directive_arguments) { str("(") >> directive_argument.repeat(1) >> str(")") }
-  rule(:directive_argument) { name.as(:directive_argument_name) >> str(":") >> space? >> value.as(:directive_argument_value) >> separator? }
-
-  rule(:type) { (non_null_type | list_type | type_name)}
-  rule(:list_type) { str("[") >> type.as(:list_type) >> str("]")}
-  rule(:non_null_type) { (list_type | type_name).as(:non_null_type) >> str("!") }
-  rule(:type_name) { name.as(:type_name) }
-
-  rule(:value) {(
-    value_input_object  |
-    value_float         |
-    value_int           |
-    value_string        |
-    value_boolean       |
-    value_array         |
-    value_variable      |
-    value_enum
-  )}
-  rule(:value_sign?) { match('[\-\+]').maybe }
-  rule(:value_array) { (str("[") >> (value >> separator?).repeat(0) >> str("]")).as(:array) }
-  rule(:value_boolean) { (str("true") | str("false")).as(:boolean) }
-  rule(:value_float) { (value_sign? >> match('\d').repeat(1) >> str(".") >> match('\d').repeat(1) >> (match("[eE]") >> value_sign? >> match('\d').repeat(1)).maybe).as(:float) }
-  rule(:value_input_object) { str("{") >> value_input_object_pair.repeat(1).as(:input_object) >> str("}") }
-  rule(:value_input_object_pair) { space? >> name.as(:input_object_name) >>  space? >> str(":") >> space? >> value.as(:input_object_value) >> separator? }
-  rule(:value_int) { (value_sign? >> match('\d').repeat(1)).as(:int) }
-  # TODO: support unicode, escaped chars (match the spec)
-  rule(:value_string) { str('"') >> match('[^\"]').repeat(1).as(:string) >> str('"')}
-  rule(:value_enum) { name.as(:enum) }
-  rule(:value_variable) { str("$") >> name.as(:variable) }
-
-  rule(:separator?) { (space? >> str(",") >> space?).maybe }
-  rule(:name) { match('[_A-Za-z]') >> match('[_0-9A-Za-z]').repeat(0) }
-  rule(:comment) { str("#") >> match('[^\r\n]').repeat(0) }
-  rule(:space) { (match('[\s\n]+') | comment).repeat(1) }
-  rule(:space?) { space.maybe }
-end

data/lib/graph_ql/parser/transform.rb

@@ -1,87 +0,0 @@
-# {Transform} is a [parslet](http://kschiess.github.io/parslet/) transform for for turning the AST into objects in {GraphQL::Nodes} objects.
-class GraphQL::Transform < Parslet::Transform
-  # Get syntax classes by shallow name:
-  include GraphQL::Nodes
-
-  def self.optional_sequence(name)
-    rule(name => simple(:val)) { [] }
-    rule(name => sequence(:val)) { val }
-  end
-
-  # Document
-  rule(document_parts: sequence(:p)) { Document.new(parts: p, line: p.first.line, col: p.first.col)}
-
-  # Fragment Definition
-  rule(
-    fragment_keyword: simple(:kw),
-    fragment_name:  simple(:name),
-    type_condition: simple(:type),
-    directives:     sequence(:directives),
-    selections:     sequence(:selections)
-  ) {FragmentDefinition.new(name: name.to_s, type: type.to_s, directives: directives, selections: selections, position_source: kw)}
-
-  rule(
-    fragment_spread_keyword: simple(:kw),
-    fragment_spread_name: simple(:n),
-    directives:           sequence(:d)
-  ) { FragmentSpread.new(name: n.to_s, directives: d, position_source: kw)}
-
-  rule(
-    fragment_spread_keyword: simple(:kw),
-    inline_fragment_type: simple(:n),
-    directives: sequence(:d),
-    selections: sequence(:s),
-  ) { InlineFragment.new(type: n.to_s, directives: d, selections: s, position_source: kw)}
-
-  # Operation Definition
-  rule(
-    operation_type: simple(:ot),
-    name:           simple(:n),
-    variables:      sequence(:v),
-    directives:     sequence(:d),
-    selections:     sequence(:s),
-  ) { OperationDefinition.new(operation_type: ot.to_s, name: n.to_s, variables: v, directives: d, selections: s, position_source: ot) }
-  optional_sequence(:optional_variables)
-  rule(variable_name: simple(:n), variable_type: simple(:t), variable_optional_default_value: simple(:v)) { Variable.new(name: n.name, type: t, default_value: v, line: n.line, col: n.col)}
-  rule(variable_name: simple(:n), variable_type: simple(:t), variable_optional_default_value: sequence(:v)) { Variable.new(name: n.name, type: t, default_value: v, line: n.line, col: n.col)}
-  rule(variable_default_value: simple(:v) ) { v }
-  rule(variable_default_value: sequence(:v) ) { v }
-  # Query short-hand
-  rule(unnamed_selections: sequence(:s)) { OperationDefinition.new(selections: s, operation_type: "query", name: nil, variables: [], directives: [], line: s.first.line, col: s.first.col)}
-
-  # Field
-  rule(
-    alias: simple(:a),
-    field_name: simple(:name),
-    field_arguments: sequence(:args),
-    directives: sequence(:dir),
-    selections: sequence(:sel)
-  ) { Field.new(alias: a && a.to_s, name: name.to_s, arguments: args, directives: dir, selections: sel, position_source: [a, name].find { |part| !part.nil? }) }
-
-  rule(alias_name: simple(:a)) { a }
-  optional_sequence(:optional_field_arguments)
-  rule(field_argument_name: simple(:n), field_argument_value: simple(:v)) { Argument.new(name: n.to_s, value: v, position_source: n)}
-  optional_sequence(:optional_selections)
-  optional_sequence(:optional_directives)
-
-  # Directive
-  rule(directive_name: simple(:name), directive_arguments: sequence(:args)) { Directive.new(name: name.to_s, arguments: args, position_source: name ) }
-  rule(directive_argument_name: simple(:n), directive_argument_value: simple(:v)) { Argument.new(name: n.to_s, value: v, position_source: n)}
-  optional_sequence(:optional_directive_arguments)
-
-  # Type Defs
-  rule(type_name: simple(:n))     { TypeName.new(name: n.to_s, position_source: n) }
-  rule(list_type: simple(:t))     { ListType.new(of_type: t, line: t.line, col: t.col)}
-  rule(non_null_type: simple(:t)) { NonNullType.new(of_type: t, line: t.line, col: t.col)}
-
-  # Values
-  rule(array: sequence(:v)) { v }
-  rule(boolean: simple(:v)) { v == "true" ? true : false }
-  rule(input_object: sequence(:v)) { InputObject.new(pairs: v, line: v.first.line, col: v.first.col) }
-  rule(input_object_name: simple(:n), input_object_value: simple(:v)) { Argument.new(name: n.to_s, value: v, position_source: n)}
-  rule(int: simple(:v)) { v.to_i }
-  rule(float: simple(:v)) { v.to_f }
-  rule(string: simple(:v)) { v.to_s }
-  rule(variable: simple(:v)) { VariableIdentifier.new(name: v.to_s, position_source: v) }
-  rule(enum: simple(:v)) { Enum.new(name: v.to_s, position_source: v)}
-end

data/lib/graph_ql/scalars/scalar_type.rb

@@ -1,5 +0,0 @@
-class GraphQL::ScalarType < GraphQL::ObjectType
-  def kind
-    GraphQL::TypeKinds::SCALAR
-  end
-end

data/lib/graph_ql/types/enum.rb

@@ -1,32 +0,0 @@
-class GraphQL::Enum
-  include GraphQL::NonNullWithBang
-  extend GraphQL::Definable
-  attr_definable :name, :description
-  attr_reader :values
-  def initialize
-    @values = {}
-    yield(self, GraphQL::TypeDefiner.instance, GraphQL::FieldDefiner.instance, GraphQL::ArgumentDefiner.instance)
-  end
-
-  def value(name, description=nil, deprecation_reason: nil, value: name)
-    @values[name] = EnumValue.new(name: name, description: description, deprecation_reason: deprecation_reason, value: value)
-  end
-
-  def kind
-    GraphQL::TypeKinds::ENUM
-  end
-
-  def coerce(value_name)
-    @values[value_name].value
-  end
-
-  class EnumValue
-    attr_reader :name, :description, :deprecation_reason, :value
-    def initialize(name:, description:, deprecation_reason:, value:)
-      @name = name
-      @description = description
-      @deprecation_reason = deprecation_reason
-      @value = value
-    end
-  end
-end

data/lib/graph_ql/types/input_object_type.rb

@@ -1,14 +0,0 @@
-class GraphQL::InputObjectType < GraphQL::ObjectType
-  attr_definable :input_fields
-
-  def input_fields(new_fields=nil)
-    if !new_fields.nil?
-      @new_fields = GraphQL::StringNamedHash.new(new_fields).to_h
-    end
-    @new_fields
-  end
-
-  def kind
-    GraphQL::TypeKinds::INPUT_OBJECT
-  end
-end

data/lib/graph_ql/types/interface.rb

@@ -1,14 +0,0 @@
-class GraphQL::Interface < GraphQL::ObjectType
-  def kind
-    GraphQL::TypeKinds::INTERFACE
-  end
-
-  def possible_types
-    @possible_types ||= []
-  end
-
-  # Might have to override this in your own interface
-  def resolve_type(object)
-    @possible_types.find {|t| t.name == object.class.name }
-  end
-end

data/lib/graph_ql/types/object_type.rb

@@ -1,66 +0,0 @@
-class GraphQL::ObjectType
-  extend GraphQL::Definable
-  attr_definable :name, :description, :interfaces, :fields
-  include GraphQL::NonNullWithBang
-
-  def initialize(&block)
-    self.fields = []
-    self.interfaces = []
-    yield(self, GraphQL::TypeDefiner.instance, GraphQL::FieldDefiner.instance, GraphQL::ArgumentDefiner.instance)
-  end
-
-  def fields(new_fields=nil)
-    if !new_fields.nil?
-      self.fields = new_fields
-    end
-    @fields
-  end
-
-  def fields=(new_fields)
-    stringified_fields = GraphQL::StringNamedHash.new(new_fields).to_h
-    # TODO: should this field be exposed during introspection? https://github.com/graphql/graphql-js/issues/73
-    stringified_fields["__typename"] = GraphQL::Introspection::TypenameField.create(self)
-    @fields = stringified_fields
-  end
-
-  def interfaces(new_interfaces=nil)
-    if !new_interfaces.nil?
-      # if you define interfaces twice, you're gonna have a bad time :(
-      # (because it gets registered with that interface, then overriden)
-      @interfaces = new_interfaces
-      new_interfaces.each {|i| i.possible_types << self }
-    end
-    @interfaces
-  end
-
-  def kind
-    GraphQL::TypeKinds::OBJECT
-  end
-
-  def to_s
-    Printer.instance.print(self)
-  end
-
-  alias :inspect :to_s
-
-  def ==(other)
-    if other.is_a?(GraphQL::ObjectType)
-      self.to_s == other.to_s
-    else
-      super
-    end
-  end
-
-  class Printer
-    include Singleton
-    def print(type)
-      if type.kind.non_null?
-        "#{print(type.of_type)}!"
-      elsif type.kind.list?
-        "[#{print(type.of_type)}]"
-      else
-        type.name
-      end
-    end
-  end
-end