graphlyte 0.3.0 → 1.0.0

data/lib/graphlyte/parsing/backtracking_parser.rb

@@ -0,0 +1,160 @@
+# frozen_string_literal: true
+
+require_relative '../errors'
+
+module Graphlyte
+  module Parsing
+    # Basic back-tracking parser, with parser-combinator methods and exceptional
+    # control-flow.
+    #
+    # This class is just scaffolding - all domain specific parsing should
+    # go in subclasses.
+    class BacktrackingParser
+      attr_reader :tokens
+      attr_accessor :max_depth
+
+      def initialize(tokens:, max_depth: nil)
+        @tokens = tokens
+        @index = -1
+        @max_depth = max_depth
+        @current_depth = 0
+      end
+
+      def inspect
+        "#<#{self.class} @index=#{@index} @current=#{current.inspect} ...>"
+      end
+
+      def to_s
+        inspect
+      end
+
+      def peek(offset: 0)
+        @tokens[@index + offset] || raise("No token at #{@index + offset}")
+      end
+
+      def current
+        @current ||= peek
+      end
+
+      def advance
+        @current = nil
+        @index += 1
+      end
+
+      def next_token
+        advance
+        current
+      end
+
+      def expect(type, value = nil)
+        try_parse do
+          t = next_token
+
+          if value
+            raise Expected.new(t, expected: value) unless t.type == type && t.value == value
+          else
+            raise Unexpected, t unless t.type == type
+          end
+
+          t.value
+        end
+      end
+
+      def optional(&block)
+        try_parse(&block)
+      rescue ParseError, IllegalValue
+        nil
+      end
+
+      def optional_list(&block)
+        optional(&block) || []
+      end
+
+      def many(limit: nil, &block)
+        ret = []
+
+        until ret.length == limit
+          begin
+            ret << try_parse(&block)
+          rescue ParseError
+            return ret
+          end
+        end
+
+        ret
+      end
+
+      def some(&block)
+        one = yield
+        rest = many(&block)
+
+        [one] + rest
+      end
+
+      def try_parse
+        idx = @index
+        yield
+      rescue ParseError => e
+        @index = idx
+        raise e
+      rescue IllegalValue => e
+        t = current
+        @index = idx
+        raise Illegal, t, e.message
+      end
+
+      def one_of(*alternatives)
+        err = nil
+        all_symbols = alternatives.all? { _1.is_a?(Symbol) }
+
+        alternatives.each do |alt|
+          case alt
+          when Symbol then return try_parse { send(alt) }
+          when Proc then return try_parse { alt.call }
+          else
+            raise 'Not an alternative'
+          end
+        rescue ParseError => e
+          err = e
+        end
+
+        raise ParseError, "At #{current.location}: Expected one of #{alternatives.join(', ')}" if err && all_symbols
+        raise err if err
+      end
+
+      def punctuator(token)
+        expect(:PUNCTUATOR, token)
+      end
+
+      def name(value = nil)
+        expect(:NAME, value)
+      end
+
+      def bracket(lhs, rhs, &block)
+        expect(:PUNCTUATOR, lhs)
+        raise TooDeep, current.location if too_deep?
+
+        ret = subfeature(&block)
+
+        expect(:PUNCTUATOR, rhs)
+
+        ret
+      end
+
+      def too_deep?
+        return false if max_depth.nil?
+
+        @current_depth > max_depth
+      end
+
+      def subfeature
+        d = @current_depth
+        @current_depth += 1
+
+        yield
+      ensure
+        @current_depth = d
+      end
+    end
+  end
+end

data/lib/graphlyte/refinements/string_refinement.rb

@@ -1,22 +1,28 @@
+# frozen_string_literal: true
+
 module Graphlyte
   module Refinements
+    # Adds `camelize` methods to `Symbol` and `String`.
     module StringRefinement
-      refine Symbol do 
-        def to_camel_case
-          to_s.to_camel_case
+      refine Symbol do
+        def camelize
+          to_s.camelize
         end
       end
-      refine String do 
-        def to_camel_case
+
+      refine String do
+        def camelize
+          return self if match(/^_*$/)
+
           start_of_string = match(/(^_+)/)&.[](0)
           end_of_string = match(/(_+$)/)&.[](0)
 
-          middle = split("_").reject(&:empty?).inject([]) do |memo, str|
+          middle = split('_').reject(&:empty?).inject([]) do |memo, str|
             memo << (memo.empty? ? str : str.capitalize)
-          end.join("")
+          end.join
 
           "#{start_of_string}#{middle}#{end_of_string}"
-        end 
+        end
       end
     end
   end

data/lib/graphlyte/refinements/syntax_refinements.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module Graphlyte
+  module Refinements
+    # Adds `to_input_value` method to classes we can interpret as an input value.
+    module SyntaxRefinements
+      refine Hash do
+        def to_input_value
+          transform_keys(&:to_s).transform_values(&:to_input_value)
+        end
+      end
+
+      refine Array do
+        def to_input_value
+          map(&:to_input_value)
+        end
+      end
+
+      refine String do
+        def to_input_value
+          Syntax::Value.new(self, :STRING)
+        end
+      end
+
+      refine Symbol do
+        def to_input_value
+          Syntax::Value.new(self, :ENUM)
+        end
+      end
+
+      refine Integer do
+        def to_input_value
+          Syntax::Value.new(self, :NUMBER)
+        end
+      end
+
+      refine Float do
+        def to_input_value
+          Syntax::Value.new(self, :NUMBER)
+        end
+      end
+
+      refine TrueClass do
+        def to_input_value
+          Syntax::Value.new(Syntax::TRUE, :BOOL)
+        end
+      end
+
+      refine FalseClass do
+        def to_input_value
+          Syntax::Value.new(Syntax::FALSE, :BOOL)
+        end
+      end
+
+      refine NilClass do
+        def to_input_value
+          Syntax::Value.new(Syntax::NULL, :NULL)
+        end
+      end
+    end
+  end
+end

data/lib/graphlyte/schema.rb

@@ -0,0 +1,165 @@
+# frozen_string_literal: true
+
+require_relative './data'
+
+module Graphlyte
+  # Represents a schema definition, containing all type definitions available in a server
+  # Reflects the response to a [schema query](./schema_query.rb)
+  class Schema < Graphlyte::Data
+    # A directive adds metadata to a defintion.
+    # See: https://spec.graphql.org/October2021/#sec-Language.Directives
+    class Directive < Graphlyte::Data
+      attr_accessor :description, :name
+      attr_reader :arguments
+
+      def initialize(**)
+        super
+
+        @arguments ||= {}
+      end
+
+      def self.from_schema_response(data)
+        new(
+          name: data['name'],
+          description: data['description'],
+          arguments: Schema.entity_map(InputValue, data['arguments'])
+        )
+      end
+    end
+
+    # An input value defines the values of arguments and the fields of input objects.
+    class InputValue < Graphlyte::Data
+      attr_accessor :name, :description, :type, :default_value
+
+      def self.from_schema_response(data)
+        value = new
+
+        value.name = data['name']
+        value.description = data['description']
+        value.default_value = data['defaultValue']
+        value.type = TypeRef.from_schema_response(data['type'])
+
+        value
+      end
+    end
+
+    # A type ref names a run-time type
+    # See `Type` for the full type definition.
+    class TypeRef < Graphlyte::Data
+      attr_accessor :kind, :name, :of_type
+
+      def self.from_schema_response(data)
+        return unless data
+
+        ref = new
+
+        ref.name = data['name']
+        ref.kind = data['kind'].to_sym
+        ref.of_type = TypeRef.from_schema_response(data['ofType'])
+
+        ref
+      end
+
+      def unpack
+        return of_type.unpack if of_type
+
+        name
+      end
+    end
+
+    # The description of an enum member
+    class Enum < Graphlyte::Data
+      attr_accessor :name, :description, :is_deprecated, :deprecation_reason
+
+      def self.from_schema_response(data)
+        new(**data)
+      end
+    end
+
+    # A full type definition.
+    class Type < Graphlyte::Data
+      attr_accessor :kind, :name, :description
+      attr_reader :fields, :input_fields, :interfaces, :enums, :possible_types
+
+      def initialize(**)
+        super
+        @fields ||= {}
+        @input_fields ||= {}
+        @interfaces ||= []
+        @enums ||= {}
+        @possible_types ||= []
+      end
+
+      def self.from_schema_response(data)
+        new(
+          kind: data['kind'].to_sym,
+          name: data['name'],
+          description: data['description'],
+          fields: Schema.entity_map(Field, data['fields']),
+          input_fields: Schema.entity_map(InputValue, data['inputFields']),
+          enums: Schema.entity_map(Enum, data['enumValues']),
+          interfaces: Schema.entity_list(TypeRef, data['interfaces']),
+          possible_types: Schema.entity_list(TypeRef, data['possibleTypes'])
+        )
+      end
+    end
+
+    # A field definition
+    class Field < Graphlyte::Data
+      attr_accessor :name, :description, :type, :is_deprecated, :deprecation_reason
+      attr_reader :arguments
+
+      def initialize(**)
+        super
+
+        @arguments ||= {}
+      end
+
+      def self.from_schema_response(data)
+        new(
+          name: data['name'],
+          description: data['description'],
+          type: TypeRef.from_schema_response(data['type']),
+          is_deprecated: data['isDeprecated'],
+          deprecation_reason: data['deprecationReason'],
+          arguments: Schema.entity_map(InputValue, data['arguments'])
+        )
+      end
+    end
+
+    attr_accessor :query_type, :mutation_type, :subscription_type
+    attr_reader :types, :directives
+
+    def initialize(**)
+      super
+
+      @types ||= {}
+      @directives ||= {}
+    end
+
+    def self.from_schema_response(response)
+      data = response.dig('data', '__schema')
+      raise Argument, 'No data' unless data
+
+      new(
+        query_type: data.dig('queryType', 'name'),
+        mutation_type: data.dig('queryType', 'name'),
+        subscription_type: data.dig('subscriptionType', 'name'),
+        types: entity_map(Type, data['types']),
+        directives: entity_map(Directive, data['directives'])
+      )
+    end
+
+    def self.entity_list(entity, resp)
+      return unless resp
+
+      resp.map { entity.from_schema_response(_1) }
+    end
+
+    def self.entity_map(entity, resp)
+      return unless resp
+
+      resp.to_h { |entry| [entry['name'], entity.from_schema_response(entry)] }
+    end
+  end
+end

data/lib/graphlyte/schema_query.rb

@@ -1,83 +1,100 @@
+# frozen_string_literal: true
+
+require_relative './dsl'
 
 module Graphlyte
+  # extend this module to gain access to a schema_query method
   module SchemaQuery
     def schema_query
-      type_ref_fragment = Graphlyte.fragment('TypeRef', '__Type') do
-        kind
-        name
-        of_type { 
-          kind
-          name
-          of_type {
-            kind
-            name
-            of_type {
-              kind
-              name
-              of_type {
-                kind
-                name
-                of_type {
-                  kind
-                  name
-                  of_type {
-                    kind
-                    name
-                    of_type {
-                      kind
-                      name
-                    }
-                  }
-                }
-              }
-            }
-          }
-        }
+      SchemaQuery::Query.new.build
+    end
+
+    # Builder for a schema query
+    class Query
+      attr_reader :dsl, :doc
+
+      def initialize
+        @dsl = DSL.new
+        @doc = Graphlyte::Document.new
+      end
+
+      def build
+        @build ||= dsl.query('Schema', doc) do |q|
+          q.__schema do |s|
+            s.query_type(&:name)
+            s.mutation_type(&:name)
+            s.subscription_type(&:name)
+            s.types(full_type_fragment)
+            query_directives(s)
+          end
+        end
+      end
+
+      def query_directives(schema)
+        schema.directives do |d|
+          d.name
+          d.description
+          d.args(input_value_fragment)
+        end
       end
 
-      input_value_fragment = Graphlyte.fragment('InputValues', '__InputValue') do
-        name
-        description
-        type type_ref_fragment
-        default_value
+      def type_ref_fragment
+        @type_ref_fragment ||= dsl.fragment(on: '__Type', doc: doc) do |t|
+          select_type_reference(t)
+        end
       end
 
-      full_type_fragment = Graphlyte.fragment('FullType', '__Type') do
-        kind
-        name
-        description
-        fields(includeDeprecated: true) do
-          name
-          description
-          args input_value_fragment
-          type type_ref_fragment
-          is_deprecated
-          deprecation_reason
+      def select_type_reference(node, depth: 0)
+        node.kind
+        node.name
+        node.of_type { |child| select_type_reference(child, depth: depth + 1) } if depth < 8
+      end
+
+      def full_type_fragment
+        @full_type_fragment ||= dsl.fragment(on: '__Type', doc: doc) do |t|
+          t.kind
+          t.name
+          t.description
+          t << fields_fragment
+          t.input_fields(input_value_fragment)
+          t.interfaces(type_ref_fragment)
+          t << enums_fragment
+          t.possible_types(type_ref_fragment)
         end
-        input_fields input_value_fragment
-        interfaces type_ref_fragment
-        enum_values(includeDeprecated: true) do
-          name
-          description
-          is_deprecated
-          deprecation_reason
+      end
+
+      def enums_fragment
+        @enums_fragment ||= dsl.fragment(on: '__Type', doc: doc) do |t|
+          t.enum_values(include_deprecated: true) do |e|
+            e.name
+            e.description
+            e.is_deprecated
+            e.deprecation_reason
+          end
         end
-        possible_types type_ref_fragment
       end
 
-      Graphlyte.query do
-        __schema do
-          query_type { name }
-          mutation_type { name }
-          subscription_type { name }
-          types full_type_fragment
-          directives do 
-            name 
-            description
-            args input_value_fragment
+      def fields_fragment
+        @fields_fragment ||= dsl.fragment(on: '__Type', doc: doc) do |t|
+          t.fields(include_deprecated: true) do |f|
+            f.name
+            f.description
+            f.args(input_value_fragment)
+            f.type(type_ref_fragment)
+            f.is_deprecated
+            f.deprecation_reason
           end
         end
       end
+
+      def input_value_fragment
+        @input_value_fragment ||= dsl.fragment(on: '__InputValue', doc: doc) do |v|
+          v.name
+          v.description
+          v.type type_ref_fragment
+          v.default_value
+        end
+      end
     end
   end
 end