graphlyte 0.1.3 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 82edd3a321164acd153524e98420c75175deb60d1fd56d28f72f52917e35dac4
-  data.tar.gz: '049a43943a6ba45edff3a73347c903be52f0d4e4d7e9f76a9be50e0e45ed11a6'
+  metadata.gz: 1fb8e6d42096e7e5c6e90a08a6c41e3cf3e149ecea8be199b13b22e7d23f5ba9
+  data.tar.gz: 14f1a49e6137b351abad7905f6a404cfb7d8185e8e9737eb461f7585493f29fd
 SHA512:
-  metadata.gz: a1a81b6258e70829db7010ce3c2ca3cdd818dadd0cdc21878c6e10eaefd7baa54d816fd3810c92f330699d905ed5ad00f7865c169f0290e96f4290dbf5cf8160
-  data.tar.gz: b3bc5db253642508d0f9e93c7882525706fe7c9e1ec687e4b7f506a6096a9ba8ecb2a6e6cc1653318467911b70c01243a4bf9f55d7cd22ccf2618cfff912bfbd
+  metadata.gz: 25307883854658ec75267848491b2e76fa1ded6af1f0b8fee7b6315627c9adc7183ebe1d863efd1759c67f1d4241cc2677cfef23219c2add4526e9af28d282e5
+  data.tar.gz: 87bc35ce7157b1f53f59b23f389c7be03db2fec9c883e6db05c0a8f8e5799f00dc6b048174ef1f8f7ff7e480615d0cc0a171d8e2b339ab3da55a3774874641f2

data/lib/graphlyte/arguments/set.rb

@@ -1,7 +1,9 @@
 require_relative "./value"
+require_relative "./../refinements/string_refinement"
 module Graphlyte
   module Arguments
     class Set
+      using Refinements::StringRefinement
 
       attr_reader :values
 
@@ -9,16 +11,44 @@ module Graphlyte
         raise ArgumentError, "input #{data} must be a hash" unless data.nil? || data.is_a?(Hash)
         @values = expand_arguments(data) unless data.nil?
       end
+
+      def extract_variables(values=@values, variables=[])
+        values&.each do |key, value|
+          if value.is_a?(Set)
+            variables.concat extract_variables(value.values)
+          elsif value.is_a?(Array)
+          elsif value.symbol?
+            variables << value
+          elsif value.formal?
+            variables << value
+          end
+        end
+        variables
+      end
+
+      def to_h(inner = false)
+        return {} unless values && !values.empty?
+        values.inject({}) do |memo, (k, v)|
+          if v.is_a?(Array)
+            memo[k.to_s.to_camel_case] = v.map(&:to_s)
+          elsif v.is_a?(Set)
+            memo[k.to_s.to_camel_case] = v.to_h
+          else
+            memo[k.to_s.to_camel_case] = v.to_s
+          end
+          memo
+        end
+      end
       
       def to_s(inner = false)
         return "" unless values && !values.empty?
         arr = values.map do |k,v| 
           if v.is_a?(Array)
-            "#{k}: [#{v.map(&:to_s).join(", ")}]"
+            "#{k.to_s.to_camel_case}: [#{v.map(&:to_s).join(", ")}]"
           elsif v.is_a?(Set)
-            "#{k}: { #{v.to_s(true)} }"
+            "#{k.to_s.to_camel_case}: { #{v.to_s(true)} }"
           else
-            "#{k}: #{v.to_s}"
+            "#{k.to_s.to_camel_case}: #{v.to_s}"
           end
         end
         return arr.join(", ") if inner
@@ -31,12 +61,20 @@ module Graphlyte
         data.inject({}) do |memo, (k, v)|
           if v.is_a?(Array)
             memo[k] = v.map do |item|
-              Value.new(item)
+              if item.is_a?(Value)
+                item
+              else
+                Value.new(item)
+              end
             end
           elsif v.is_a?(Hash)
             memo[k] = Set.new(v)
           else
-            memo[k] = Value.new(v)
+            if v.is_a?(Value)
+              memo[k] = v
+            else
+              memo[k] = Value.new(v)
+            end
           end
           memo
         end

data/lib/graphlyte/arguments/value.rb

@@ -1,17 +1,36 @@
+require_relative "./../refinements/string_refinement"
 module Graphlyte
   module Arguments
     class Value
-      attr_reader :value
+      using Refinements::StringRefinement
 
-      def initialize(value)
+      attr_reader :value, :default
+
+      def initialize(value, default = nil)
         raise ArgumentError, "Hash not allowed in this context" if value.is_a? Hash
-        @value = value
+        if value.is_a?(Value)
+          @value = value.value
+          @default = value.default
+        else
+          @value = value
+          @default = default
+        end
+      end
+
+      def symbol?
+        value.is_a? Symbol
+      end
+
+      def formal?
+        value.is_a? Schema::Types::Base
       end
 
       def to_s
+        return "$#{value.to_s.to_camel_case}" if value.is_a? Symbol
         return value if value.is_a? Numeric
         return "\"#{value}\"" if value.is_a? String
         return "null" if value.nil?
+        return "$#{value.placeholder.to_camel_case}" if value.is_a? Schema::Types::Base
         value.to_s
       end
     end

data/lib/graphlyte/builder.rb

@@ -3,8 +3,8 @@ require_relative "./fieldset"
 
 module Graphlyte
   class Builder
-    def initialize
-      @fields = []
+    def initialize(fields = [])
+      @fields = fields
     end
 
     def <<(buildable)
@@ -17,7 +17,7 @@ module Graphlyte
     end
     
     def method_missing(method, fieldset_or_hargs=nil, hargs={}, &block)
-      # todo: camel case method 
+      # todo: camel case method
 
       # hack for ruby bug in lower versions
       if [Fieldset, Fragment].include?(fieldset_or_hargs.class)
@@ -26,14 +26,22 @@ module Graphlyte
         field = Field.new(method, Fieldset.empty, fieldset_or_hargs)
       end
 
-      block.call(field.fieldset.builder) if block
+      field.fieldset.builder.>.instance_eval(&block) if block
       @fields << field
       field
     end
 
+    def respond_to_missing
+      true
+    end
+
     # for internal use only
     def >>
       @fields
     end
+
+    def >
+      self
+    end
   end
 end

data/lib/graphlyte/field.rb

@@ -1,11 +1,13 @@
 require_relative "./arguments/set"
-
+require_relative "./refinements/string_refinement"
 module Graphlyte
   class Field
+    using Refinements::StringRefinement
+
     attr_reader :name, :fieldset, :inputs, :alias
 
     def initialize(name, fieldset, hargs, inputs: Arguments::Set.new(hargs))
-      @name = to_camel_case(name.to_s)
+      @name = name.to_s.to_camel_case
       @fieldset = fieldset
       @inputs = inputs
       @alias = nil
@@ -17,7 +19,7 @@ module Graphlyte
 
     def alias(name, &block)
       @alias = name
-      block.call(fieldset.builder) if block
+      fieldset.builder.>.instance_eval(&block) if block
     end
 
     def to_s(indent=0)
@@ -32,16 +34,5 @@ module Graphlyte
       str += " {\n#{fieldset.to_s(indent + 1)}\n#{actual_indent}}" unless atomic?
       str
     end
-
-    def to_camel_case(string)
-      start_of_string = string.match(/(^_+)/)&.[](0)
-      end_of_string = string.match(/(_+$)/)&.[](0)
-  
-      middle = string.split("_").reject(&:empty?).inject([]) do |memo, str|
-        memo << (memo.empty? ? str : str.capitalize)
-      end.join("")
-    
-      "#{start_of_string}#{middle}#{end_of_string}"
-    end 
   end
 end

data/lib/graphlyte/query.rb

@@ -1,21 +1,70 @@
+require_relative "./refinements/string_refinement"
+require "json"
 module Graphlyte
   class Query < Fieldset
+    using Refinements::StringRefinement
+    attr_reader :name, :type
 
-    attr_reader :name
-
-    def initialize(query_name=nil, **hargs)
-      @name = query_name
+    def initialize(query_name=nil, type=:query, **hargs)
+      @name = query_name || "anonymousQuery"
+      @type = type
       super(**hargs)
     end
 
-    def to_json
-      { query: to_s }.to_json
+    def placeholders
+      flatten_variables(builder.>>).map do |value|
+        unless value.formal?
+          str = ":#{value.value.to_sym.inspect} of unknown"
+        else
+          str = ":#{value.value.placeholder} of #{value.value.name}"
+        end
+
+        if value.default
+          str += " with default #{value.default.to_s}"
+        end
+        str
+      end.join("\n")
+    end
+
+    def to_json(query_name=name, **hargs)
+      variables = flatten_variables(builder.>>).uniq { |v| v.value }
+      types = merge_variable_types(variables, hargs)
+
+      str = "#{type} #{query_name}"
+      unless types.empty?
+        type_new = types.map do |type_arr|
+          "$#{type_arr[0].to_camel_case}: #{type_arr[1]}"
+        end
+        str += "(#{type_new.join(", ")})"
+      end
+      { query: "#{str} #{to_s(1)}", variables: Arguments::Set.new(hargs).to_h }.to_json
     end
 
     def to_s(indent=0)
       "{\n#{super(indent + 1)}\n}#{format_fragments}"
     end
     
+    def merge_variable_types(variables=[], hargs)
+      variables.inject([]) do |memo, var|
+        unless var.formal?
+          if hargs[var.value].is_a? String
+            memo << [var.value.to_camel_case, "String"]
+          elsif [TrueClass, FalseClass].include? hargs[var.value].class
+            memo << [var.value ,"Boolean"]
+          elsif hargs[var.value].is_a? Float
+            memo << [var.value, "Float"]
+          elsif hargs[var.value].is_a? Integer
+            memo << [var.value, "Int"]
+          elsif hargs[var.value].is_a? Array
+            memo <<  "[#{merge_variable_types(var.value, hargs).first}]"
+          end
+        else
+          memo << [var.value.placeholder, var.value.name]
+        end
+        memo
+      end
+    end
+    
     def format_fragments
       str = "\n"
       flatten(builder.>>).each do |_, fragment|
@@ -26,6 +75,18 @@ module Graphlyte
       str
     end
 
+    def flatten_variables(fields, variables=[])
+      fields.each do |field|
+        variables.concat field.inputs.extract_variables unless field.class.eql?(Fragment)
+        if field.class.eql?(Fragment)
+          flatten_variables(field.fields, variables)
+        else
+          flatten_variables(field.fieldset.fields, variables)
+        end
+      end
+      variables
+    end
+
     def flatten(fields, new_fields = {})
       fields.each do |field|
         if field.class.eql?(Fragment)
@@ -36,10 +97,8 @@ module Graphlyte
         else
           if field.fieldset.class.eql?(Fragment)
             new_fields[field.fieldset.fragment] = field.fieldset
-            flatten(field.fieldset.fields, new_fields) unless field.atomic?
-          else
-            flatten(field.fieldset.fields, new_fields) unless field.atomic?
           end
+          flatten(field.fieldset.fields, new_fields) unless field.atomic?
         end
       end
       new_fields

data/lib/graphlyte/refinements/string_refinement.rb

@@ -0,0 +1,23 @@
+module Graphlyte
+  module Refinements
+    module StringRefinement
+      refine Symbol do 
+        def to_camel_case
+          to_s.to_camel_case
+        end
+      end
+      refine String do 
+        def to_camel_case
+          start_of_string = match(/(^_+)/)&.[](0)
+          end_of_string = match(/(_+$)/)&.[](0)
+      
+          middle = split("_").reject(&:empty?).inject([]) do |memo, str|
+            memo << (memo.empty? ? str : str.capitalize)
+          end.join("")
+        
+          "#{start_of_string}#{middle}#{end_of_string}"
+        end 
+      end
+    end
+  end
+end

data/lib/graphlyte/schema/parser.rb

@@ -0,0 +1,517 @@
+require "strscan"
+require_relative "../fieldset"
+require_relative "../query"
+require_relative "../fragment"
+require_relative "../schema_query"
+require_relative "../types"
+
+module Graphlyte
+  module Schema
+    module ParserHelpers
+      def parse_fields
+        fields = repeat(:parse_field)
+        fields
+      end
+
+      def parse_field
+        alias_field = expect(:ALIAS)
+        if token = expect(:FRAGMENT_REF)
+          raise "Can't find fragment #{token[0][1]}" unless fragments_dictionary[token[0][1]]
+          fragments_dictionary[token[0][1]]
+        elsif field = expect(:FIELD_NAME)
+          args = parse_args
+          if fieldset = parse_fieldset
+            need(:END_FIELD)
+            field = Field.new(field[0][1], fieldset, args)
+          else
+            field = Field.new(field[0][1], Fieldset.empty, args)
+          end
+
+          if alias_field
+            field.alias(alias_field[0][1])
+          end
+
+          field
+        end
+      end
+
+      def parse_fieldset
+        if expect(:START_FIELD)
+          fields = parse_fields
+          Fieldset.new(builder: Builder.new(fields))
+        end
+      end
+
+      def parse_args
+        if expect(:START_ARGS)
+          args = repeat(:parse_arg).inject(&:merge)
+          need(:END_ARGS)
+          args
+        end
+      end
+
+      def parse_default
+        if expect(:START_DEFAULT_VALUE)
+          value = parse_value
+          need(:END_DEFAULT_VALUE)
+          value
+        end
+      end
+
+      def parse_arg
+        if (token = expect(:ARG_KEY)) && (value = parse_value)
+          defaults = parse_default
+          key = token[0][1]
+          hash = {}
+          if [Array, Hash].include?(value.class)
+            hash[key] = value
+          else
+            hash[key] = Graphlyte::Arguments::Value.new(value, defaults)
+          end
+          hash
+        elsif (token = expect(:SPECIAL_ARG_KEY)) && (value = parse_value)
+          defaults = parse_default
+          @special_args ||= {}
+          arg = {}
+          if [Array, Hash].include?(value.class)
+            arg[token[0][1]] = value
+          else
+            arg[token[0][1]] = Graphlyte::Arguments::Value.new(value, defaults)
+          end
+          @special_args.merge!(arg)
+          arg
+        end
+      end
+
+      def parse_value
+        if token = expect(:ARG_NUM_VALUE) || expect(:ARG_STRING_VALUE) || expect(:ARG_BOOL_VALUE) || expect(:ARG_FLOAT_VALUE)
+          token[0][1]
+        elsif token = expect(:SPECIAL_ARG_REF)
+          ref = token[0][1]
+          raise "Can't find ref $#{ref}" unless @special_args[ref]
+          value = @special_args[ref]
+          Arguments::Value.new(Graphlyte::TYPES.send(value.value, ref.to_sym), value.default)
+        elsif token = expect(:SPECIAL_ARG_VAL)
+          token[0][1]
+        elsif token = expect(:ARG_HASH_START)
+          parse_arg_hash
+        elsif expect(:ARG_ARRAY_START)
+          parse_arg_array
+        end
+      end
+
+      def parse_arg_array
+        args = repeat(:parse_value)
+        need(:ARG_ARRAY_END)
+        args
+      end
+
+      def parse_arg_hash
+        if (key = expect(:ARG_KEY)) && (value = parse_value)
+          need(:ARG_HASH_END)
+          hash = {}
+          hash[key[0][1]] = value
+          hash
+        end
+      end
+
+      def repeat(method)
+        results = []
+
+        while result = send(method)
+          results << result
+        end
+
+        results
+      end
+
+      def expect(*expected_tokens)
+        upcoming = tokens[position, expected_tokens.size]
+        if upcoming.map(&:first) == expected_tokens
+          advance(expected_tokens.size)
+          upcoming
+        end
+      end
+
+      def need(*required_tokens)
+        upcoming = tokens[position, required_tokens.size]
+        expect(*required_tokens) or raise "Unexpected tokens. Expected #{required_tokens.inspect} but got #{upcoming.inspect}"
+      end
+
+      def advance(offset = 1)
+        @position += offset
+      end
+
+      def sort_fragments(sorted = [], fragments)
+        return sorted if !fragments || fragments.empty?
+        fragment_tokens = fragments.shift
+
+        current_ref = fragment_tokens.find do |token|
+          token[0] == :FRAGMENT_REF
+        end
+
+        if current_ref
+          exists = sorted.any? do |frags|
+            frags.find do |el|
+              el[0] == :START_FRAGMENT && el[1] == current_ref[1]
+            end
+          end
+          if exists
+            sorted << fragment_tokens
+            sort_fragments(sorted, fragments)
+          else
+            fragments.push fragment_tokens
+            sort_fragments(sorted, fragments)
+          end
+        else
+          sorted << fragment_tokens
+          sort_fragments(sorted, fragments)
+        end
+      end
+
+      def take_fragments
+        aggregate = @tokens.inject({taking: false, idx: 0,  fragments: []}) do |memo, token_arr|
+          if token_arr[0] == :END_FRAGMENT
+            memo[:fragments][memo[:idx]] << token_arr
+            memo[:taking] = false
+            memo[:idx] += 1
+          elsif token_arr[0] === :START_FRAGMENT
+            memo[:fragments][memo[:idx]] = [token_arr]
+            memo[:taking] = true
+          elsif memo[:taking]
+            memo[:fragments][memo[:idx]] << token_arr
+          end
+          memo
+        end
+        aggregate[:fragments]
+      end
+    end
+
+    class FragmentParser
+      attr_reader :tokens, :position, :fragments_dictionary
+
+      include ParserHelpers
+
+      def initialize(tokens)
+        @tokens = tokens.flatten(1)
+        @position = 0
+        @fragments_dictionary = {}
+      end
+
+      def parse_fragments
+        repeat(:parse_fragment)
+        fragments_dictionary
+      end
+
+      def parse_fragment
+        if token = expect(:START_FRAGMENT)
+          builder = Builder.new parse_fields
+          fragment = Fragment.new(token[0][1], token[0][2], builder: builder)
+          @fragments_dictionary[token[0][1]] = fragment
+          need(:END_FRAGMENT)
+        end
+      end
+    end
+
+    class Parser
+      attr_reader :tokens, :position, :fragments_dictionary
+
+      include ParserHelpers
+
+      def self.parse(gql)
+        obj = new Lexer.new(gql).tokenize
+        obj.parse
+      end
+
+      def initialize(tokens)
+        @tokens = tokens
+        @fragment_tokens = sort_fragments([], take_fragments)
+        @fragments_dictionary = {}
+        @fragments_dictionary = @fragment_tokens.any? ? FragmentParser.new(@fragment_tokens).parse_fragments : {}
+        @position = 0
+      end
+
+      def parse
+        if token = expect(:START_QUERY)
+          parse_query(token[0][1])
+        elsif token = expect(:START_MUTATION)
+          parse_mutation(token[1])
+        else
+          raise "INVALID"
+        end
+      end
+
+      def parse_query(name)
+        parse_args
+        builder = Builder.new parse_fields
+        query = Query.new(name, :query, builder: builder)
+        need(:END_QUERY)
+        query
+      end
+
+      def parse_mutation(name)
+        builder = Builder.new parse_fields
+        mutation = Query.new(name, :mutation, builder: builder)
+        need(:END_MUTATION)
+        mutation
+      end
+    end
+
+    class Lexer
+      attr_reader :stack, :scanner
+
+      def initialize(gql, scanner: StringScanner.new(gql))
+        @original_string = gql
+        @scanner = scanner
+        @tokens = []
+      end
+
+      SPECIAL_ARG_REGEX = /^\s*(?:(?<![\"\{]))([\w\!\[\]]+)(?:(?![\"\}]))/
+      SIMPLE_EXPRESSION = /(query|mutation|fragment)\s*\w+\s*on\w*.*\{\s*\n*[.|\w\s]*\}/
+      START_MAP = {
+        'query' => :START_QUERY,
+        'mutation' => :START_MUTATION,
+        'fragment' => :START_FRAGMENT
+      }
+
+      def tokenize
+        until scanner.eos?
+          case state
+          when :default
+            if scanner.scan /^query (\w+)/
+              @tokens << [:START_QUERY, scanner[1]]
+              push_state :query
+            elsif scanner.scan /^mutation (\w+)/
+              @tokens << [:START_MUTATION, scanner[1]]
+              push_state :mutation
+            elsif scanner.scan /\s*fragment\s*(\w+)\s*on\s*(\w+)/
+              @tokens << [:START_FRAGMENT, scanner[1], scanner[2]]
+              push_state :fragment
+            elsif scanner.scan /\s*{\s*/
+              @tokens << [:START_FIELD]
+              push_state :field
+            elsif scanner.scan /\s*}\s*/
+              @tokens << [:END_EXPRESSION_SHOULDNT_GET_THIS]
+            else
+              advance
+            end
+          when :fragment
+            if scanner.scan /\s*\}\s*/
+              @tokens << [:END_FRAGMENT]
+              pop_state
+              pop_context
+            elsif scanner.check /^\s*\{\s*$/
+              if get_context == :field
+                push_state :field
+                push_context :field
+              else
+                scanner.scan /^\s*\{\s*$/
+                push_context :field
+              end
+            else
+              handle_field
+            end
+          when :mutation
+            if scanner.scan /\}/
+              @tokens << [:END_MUTATION]
+              pop_state
+              pop_context
+            elsif scanner.check /^\s*\{\s*$/
+              if get_context == :field
+                push_state :field
+              else
+                scanner.scan /^\s*\{\s*$/
+                push_context :field
+              end
+            else
+              handle_field
+            end
+          when :query
+            if scanner.scan /\}/
+              @tokens << [:END_QUERY]
+              pop_state
+              pop_context
+            elsif scanner.check /^\s*\{\s*$/
+              if get_context == :field
+                push_state :field
+                push_context :field
+              else
+                scanner.scan /^\s*\{\s*$/
+                push_context :field
+              end
+            else
+              handle_field
+            end
+          when :field
+            if scanner.check /\s*\}\s*/
+              if get_context == :field
+                scanner.scan /\s*\}\s*/
+                @tokens << [:END_FIELD]
+                pop_state
+              else
+                pop_state
+              end
+            else
+              handle_field
+            end
+          when :hash_arguments
+            handle_hash_arguments
+          when :array_arguments
+            handle_array_arguments
+          when :arguments
+            if scanner.scan /\s*\)\s*/
+              @tokens << [:END_ARGS]
+              pop_state
+            elsif scanner.scan /\=/
+              @tokens << [:START_DEFAULT_VALUE]
+              push_state :argument_defaults
+            elsif scanner.scan /,/
+              #
+            else
+              handle_shared_arguments
+            end
+          when :argument_defaults
+            if @stack.reverse.take(2).eql?([:argument_defaults, :argument_defaults])
+              @tokens << [:END_DEFAULT_VALUE]
+              pop_state
+              pop_state
+            else
+              push_state :argument_defaults
+              handle_shared_arguments
+            end
+          when :special_args
+            handle_special_args
+          end
+        end
+        @tokens
+      end
+
+      private
+
+      def handle_field
+        if scanner.scan /\s*\{\s*/
+          @context = :field
+          @tokens << [:START_FIELD]
+          push_state :field
+        elsif scanner.check /\.{3}(\w+)\s*\}/
+          scanner.scan /\.{3}(\w+)/
+          @tokens << [:FRAGMENT_REF, scanner[1]]
+          pop_context
+          pop_state if scanner.check /\s*\}\s*\}/
+        elsif scanner.scan /\.{3}(\w+)/
+          @tokens << [:FRAGMENT_REF, scanner[1]]
+        elsif scanner.scan /\s*(\w+):\s*/
+          @tokens << [:ALIAS, scanner[1]]
+        elsif scanner.check /\s*(\w+)\s*\}/
+          scanner.scan /\s*(\w+)\s*/
+          @tokens << [:FIELD_NAME, scanner[1]]
+          pop_context
+          pop_state if scanner.check /\s*\}\s*\}/
+        elsif scanner.scan /\s*(\w+)\s*/
+          @tokens << [:FIELD_NAME, scanner[1]]
+        elsif scanner.scan /^\s*\(/
+          @tokens << [:START_ARGS]
+          push_state :arguments
+        else
+          advance
+        end
+      end
+
+      def handle_shared_arguments
+        if scanner.scan /^(\w+):/
+          @tokens << [:ARG_KEY, scanner[1]]
+        elsif scanner.scan /^\s*\{\s*?/
+          @tokens << [:ARG_HASH_START]
+          push_state :hash_arguments
+        elsif scanner.scan /\s*\[\s*/
+          @tokens << [:ARG_ARRAY_START]
+          push_state :array_arguments
+        elsif scanner.scan /\s?\"([\w\s]+)\"/
+          @tokens << [:ARG_STRING_VALUE, scanner[1]]
+        elsif scanner.scan /\s?(\d+\.\d+)/
+          @tokens << [:ARG_FLOAT_VALUE, scanner[1].to_f]
+        elsif scanner.scan /\s?(\d+)/
+          @tokens << [:ARG_NUM_VALUE, scanner[1].to_i]
+        elsif scanner.scan /\s?(true|false)\s?/
+          bool = scanner[1] == "true"
+          @tokens << [:ARG_BOOL_VALUE, bool]
+        elsif scanner.scan /\$(\w+):/
+          @tokens << [:SPECIAL_ARG_KEY, scanner[1]]
+          push_state :special_args
+        elsif scanner.scan /\$(\w+)/
+          @tokens << [:SPECIAL_ARG_REF, scanner[1]]
+        else
+          advance
+        end
+      end
+
+      def handle_special_args
+        if scanner.check SPECIAL_ARG_REGEX
+          scanner.scan SPECIAL_ARG_REGEX
+          @tokens << [:SPECIAL_ARG_VAL, scanner[1]]
+          pop_state
+        else
+          pop_state
+        end
+      end
+
+      def handle_hash_arguments
+        if scanner.scan /\}/
+          @tokens << [:ARG_HASH_END]
+          pop_state
+        else
+          handle_shared_arguments
+        end
+      end
+
+      def handle_array_arguments
+        if scanner.scan /\s*\]\s*/
+          @tokens << [:ARG_ARRAY_END]   
+          pop_state   
+        else
+          handle_shared_arguments
+        end
+      end
+
+      def env
+        @ctx ||= []
+      end
+
+      def get_context
+        env.last || :default
+      end
+
+      def push_context(context)
+        env << context
+      end
+
+      def pop_context
+        env.pop
+      end
+
+      def rewind
+        scanner.pos = scanner.pos - 1
+      end
+
+      def advance
+        scanner.pos = scanner.pos + 1
+      end
+
+      def stack
+        @stack ||= []
+      end
+
+      def state
+        stack.last || :default
+      end
+
+      def push_state(state)
+        stack << state
+      end
+
+      def pop_state
+        stack.pop
+      end
+    end
+  end
+end

data/lib/graphlyte/schema/types/base.rb

@@ -0,0 +1,14 @@
+module Graphlyte
+  module Schema
+    module Types
+      class Base
+        attr_reader :name, :placeholder
+
+        def initialize(name, placeholder)
+          @name = name
+          @placeholder = placeholder
+        end
+      end
+    end
+  end
+end

data/lib/graphlyte/schema_query.rb

@@ -0,0 +1,83 @@
+
+module Graphlyte
+  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
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }
+      end
+
+      input_value_fragment = Graphlyte.fragment('InputValues', '__InputValue') do
+        name
+        description
+        type type_ref_fragment
+        default_value
+      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
+        end
+        input_fields input_value_fragment
+        interfaces type_ref_fragment
+        enum_values(includeDeprecated: true) do
+          name
+          description
+          is_deprecated
+          deprecation_reason
+        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
+          end
+        end
+      end
+    end
+  end
+end

data/lib/graphlyte/types.rb

@@ -0,0 +1,9 @@
+require_relative "schema/types/base"
+
+module Graphlyte
+  class Types
+    def method_missing(method, placeholder)
+      Schema::Types::Base.new(method, placeholder)
+    end
+  end
+end

data/lib/graphlyte.rb

@@ -2,10 +2,25 @@ require 'json'
 require_relative "./graphlyte/fieldset"
 require_relative "./graphlyte/query"
 require_relative "./graphlyte/fragment"
+require_relative "./graphlyte/schema_query"
+require_relative "./graphlyte/types"
+require_relative "./graphlyte/schema/parser"
 
 module Graphlyte
+  extend SchemaQuery
+  
+  TYPES = Types.new
+
+  def self.parse(gql)
+    Graphlyte::Schema::Parser.parse(gql)
+  end
+
   def self.query(name = nil, &block)
-    Query.new(name, builder: build(&block))
+    Query.new(name, :query, builder: build(&block))
+  end
+
+  def self.mutation(name = nil, &block)
+    Query.new(name, :mutation, builder: build(&block))
   end
 
   def self.fragment(fragment_name, model_name, &block)
@@ -20,7 +35,7 @@ module Graphlyte
 
   def self.build(&block)
     builder = Builder.new
-    block.call(builder) if block
+    builder.>.instance_eval(&block)
     builder
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: graphlyte
 version: !ruby/object:Gem::Version
-  version: 0.1.3
+  version: 0.2.0
 platform: ruby
 authors:
 - Sean Gregory
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-07-11 00:00:00.000000000 Z
+date: 2021-11-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
@@ -52,12 +52,17 @@ files:
 - lib/graphlyte/fieldset.rb
 - lib/graphlyte/fragment.rb
 - lib/graphlyte/query.rb
+- lib/graphlyte/refinements/string_refinement.rb
+- lib/graphlyte/schema/parser.rb
+- lib/graphlyte/schema/types/base.rb
+- lib/graphlyte/schema_query.rb
+- lib/graphlyte/types.rb
 homepage: https://rubygems.org/gems/graphlyte
 licenses:
 - MIT
 metadata:
-  source_code_uri: https://github.com/skinnyjames/graphlyte
-post_install_message: 
+  source_code_uri: https://gitlab.com/seanchristophergregory/graphlyte
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -72,8 +77,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.2.3
-signing_key: 
+rubygems_version: 3.2.22
+signing_key:
 specification_version: 4
 summary: craft graphql queries with ruby
 test_files: []