graphlyte 0.2.4 → 0.3.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5e01c43639c294e8ae4121522a6b0a5e498e69fd9e4f91e9f3e0a3a04753f826
-  data.tar.gz: 985c22c79e96547fdb5da497b52b5c2e8d03621f38253847e57afb932e18c752
+  metadata.gz: 93f97fef094a43b1c151dee58329d7b198210246b1fec046e18263d65437d3f4
+  data.tar.gz: 3d057d189d9a93e601c7b91ce5ad1feb1fd00b0ab17e1c772ebdbff58cbe8349
 SHA512:
-  metadata.gz: 54d9dc438641a2f9f800eff0ade575f893472bbf96faba57e9d69171efbae8a8bd8caf50bdaeb4d7e71aadc37161c61e55c2385a1da98f04d0b687b20b6d654e
-  data.tar.gz: 671f0580825f19ce0f010926a40a4cdece1ddb408dbda8ec10120c80ad0a2274680fae80085679a1e5f688fc5049e9ad1efae52b21c595ddfa166f2c759fc509
+  metadata.gz: 8f106a673e0d70b97d0a4d5634c5c5b03c540fa4e4b857465e2da4252053744f2950e1b78021b99fd0ff3a4fb7bdd896aedbe775a9afc5c2e50b9017692dc626
+  data.tar.gz: 5ce5c740e6b25fca56736261db1596e25471f1e7bf5bd91785f81da8d2d8d6641b75487b325063ff115a2a3594c6f3fb891e47613c93e2ea5d53529240251b06

data/lib/graphlyte/arguments/set.rb

@@ -12,6 +12,22 @@ module Graphlyte
         @values = expand_arguments(data) unless data.nil?
       end
 
+      def resolve_lazy_special_args(parser_special_args)
+        @values&.each do |key, value|
+          if value.is_a?(Set)
+            value.resolve_lazy_special_args(parser_special_args) if value.is_a?(Set)
+          elsif value.is_a?(Array)
+            value.each do |it|
+              it.refresh(parser_special_args) if it.is_a?(Value)
+              it.resolve_lazy_special_args(parser_special_args) if it.is_a?(Set)
+            end
+          else
+            value.refresh(parser_special_args)
+          end
+          [key, value]
+        end.to_h
+      end
+
       def extract_variables(values=@values, variables=[])
         values&.each do |key, value|
           if value.is_a?(Set)
@@ -62,27 +78,17 @@ module Graphlyte
       end
 
       def expand_arguments(data)
-        data.inject({}) do |memo, (k, v)|
-          if v.is_a?(Array)
-            memo[k] = v.map do |item|
-              if item.is_a?(Value)
-                item
-              else
-                Value.new(item)
-              end
-            end
-          elsif v.is_a?(Hash)
-            memo[k] = Set.new(v)
+        data.transform_values do |value|
+          case value
+          when Array
+            value.map { |item| Value.from(item) }
+          when Hash
+            Set.new(value)
           else
-            if v.is_a?(Value)
-              memo[k] = v
-            else
-              memo[k] = Value.new(v)
-            end
+            Value.from(value)
           end
-          memo
         end
       end
     end
   end
-end
+end

data/lib/graphlyte/arguments/value.rb

@@ -11,6 +11,12 @@ module Graphlyte
         @value = value
       end
 
+      def self.from(value)
+        return value if value.is_a? self
+
+        new(value)
+      end
+
       def symbol?
         value.is_a? Symbol
       end
@@ -19,6 +25,10 @@ module Graphlyte
         value.is_a? Schema::Types::Base
       end
 
+      def refresh(args)
+        @value = value.call(args) if value.is_a? Proc
+      end
+
       def to_s(raw = false)
         return "$#{value.to_s.to_camel_case}" if value.is_a? Symbol
         return value if value.is_a? Numeric

data/lib/graphlyte/arguments/value_literal.rb

@@ -0,0 +1,17 @@
+module Graphlyte
+  module Arguments
+    class ValueLiteral
+      attr_reader :value
+
+      def initialize(string)
+        raise 'Value must be a string' unless string.class == String
+
+        @value = string
+      end
+
+      def to_s
+        @value
+      end
+    end
+  end
+end

data/lib/graphlyte/builder.rb

@@ -8,19 +8,31 @@ module Graphlyte
     end
 
     def <<(buildable)
-      raise "Must pass a Fieldset or Fragment" unless [Fragment, Fieldset].include?(buildable.class)
+      raise "Must pass a Fieldset or Fragment" unless [Fragment, Fieldset, InlineFragment].include?(buildable.class)
 
       @fields.concat(buildable.fields) if buildable.class.eql? Fieldset
 
       # todo: handle fragments better, it's not a field
-      @fields << buildable if buildable.class.eql? Fragment
+      @fields << buildable if [InlineFragment, Fragment].include? buildable.class
+    end
+
+    def remove(field_symbol)
+      @fields.reject! do |field|
+        field.class == Fragment ? false : field.name == field_symbol.to_s
+      end
+
+      @fields.select { |field| field.class == Fragment }.each do |fragment|
+        fragment.fields.reject! do |field|
+          field.name == field_symbol.to_s
+        end
+      end
     end
     
     def method_missing(method, fieldset_or_hargs=nil, hargs={}, &block)
       # todo: camel case method
 
       # hack for ruby bug in lower versions
-      if [Fieldset, Fragment].include?(fieldset_or_hargs.class)
+      if [Fieldset, Fragment, InlineFragment].include?(fieldset_or_hargs.class)
         field = Field.new(method, fieldset_or_hargs, hargs)
       else
         field = Field.new(method, Fieldset.empty, fieldset_or_hargs)

data/lib/graphlyte/directive.rb

@@ -0,0 +1,25 @@
+require_relative 'arguments/set'
+
+module Graphlyte
+  class Directive
+    attr_reader :name, :inputs
+
+    def initialize(name, **hargs)
+      @name = name
+      @inputs = Arguments::Set.new(hargs)
+    end
+
+    def inflate(indent, string, field: nil, args: nil)
+      # add directive after fieldname?
+      string += ' ' * indent unless indent.nil?
+      if !args.nil? && args.to_s.empty?
+        string += "#{field} " if field
+      else
+        string += "#{field}#{args.to_s} "
+      end
+      string += "@#{name}"
+      string += @inputs.to_s unless @inputs.to_s.empty?
+      string
+    end
+  end
+end

data/lib/graphlyte/field.rb

@@ -1,25 +1,39 @@
 require_relative "./arguments/set"
+require_relative 'directive'
 require_relative "./refinements/string_refinement"
 module Graphlyte
   class Field
     using Refinements::StringRefinement
 
-    attr_reader :name, :fieldset, :inputs, :alias
+    attr_reader :name, :fieldset, :inputs, :directive
 
-    def initialize(name, fieldset, hargs, inputs: Arguments::Set.new(hargs))
+    def initialize(name, fieldset, hargs, directive: nil, inputs: Arguments::Set.new(hargs))
       @name = name.to_s.to_camel_case
       @fieldset = fieldset
       @inputs = inputs
       @alias = nil
+      @directive = directive
     end
 
     def atomic?
       fieldset.empty?
-    end   
+    end
 
     def alias(name, &block)
       @alias = name
-      fieldset.builder.>.instance_eval(&block) if block
+      if block
+        fieldset.builder.>.instance_eval(&block)
+      else
+        self
+      end
+    end
+
+    def include(**hargs, &block)
+      make_directive('include', **hargs, &block)
+    end
+
+    def skip(**hargs, &block)
+      make_directive('skip', **hargs, &block)
     end
 
     def to_s(indent=0)
@@ -27,12 +41,25 @@ module Graphlyte
       actual_indent = ("\s" * indent) * 2
       if @alias
         str += "#{actual_indent}#{@alias}: #{name}"
-        str += inputs.to_s.empty? ? "()" : inputs.to_s 
+        str += inputs.to_s.empty? ? "()" : inputs.to_s
+      elsif @directive
+        str = @directive.inflate(indent * 2, str, field: name, args: inputs)
       else
         str += "#{actual_indent}#{name}#{inputs.to_s}"
       end
       str += " {\n#{fieldset.to_s(indent + 1)}\n#{actual_indent}}" unless atomic?
       str
     end
+
+    private
+
+    def method_missing(symbol, **hargs, &block)
+      make_directive(symbol.to_s, **hargs, &block)
+    end
+
+    def make_directive(name, **hargs, &block)
+      @directive = Directive.new(name, **hargs)
+      fieldset.builder.>.instance_eval(&block) if block
+    end
   end
 end

data/lib/graphlyte/inline_fragment.rb

@@ -0,0 +1,29 @@
+require_relative "./fieldset"
+
+module Graphlyte
+  class InlineFragment < Fieldset
+    attr_reader :directive
+
+    def self.from_directive(directive, **hargs)
+      new(nil, directive: directive, **hargs)
+    end
+
+    def initialize(model = nil, directive: nil, **hargs)
+      @directive = directive
+      super(model, **hargs)
+    end
+
+    def to_s(indent=0)
+      actual_indent = ("\s" * indent) * 2
+      string = '...'
+      string += " on #{model_name}" if model_name
+      inflate_indent = model_name ? 1 : 0
+      string = directive.inflate(0, string) if directive
+      string += " {\n"
+      string += super(indent + 1)
+      string += "\n#{actual_indent}}"
+
+      "#{actual_indent}#{string}"
+    end
+  end
+end

data/lib/graphlyte/query.rb

@@ -1,6 +1,37 @@
 require_relative "./refinements/string_refinement"
 require "json"
 module Graphlyte
+  class Selector
+    def initialize(selector)
+      @selector_tokens = selector.split('.')
+    end
+
+    def modify(fields, selector_tokens = @selector_tokens, &block)
+      token = selector_tokens.shift
+
+      if token == '*'
+        fields.each do |field|
+          next if field.class == Fragment
+
+          modify(field.fieldset.fields, [token], &block)
+          field.fieldset.builder.instance_eval(&block) unless field.fieldset.fields.empty?
+        end
+      else
+        needle = fields.find do |field|
+          field.name == token
+        end
+
+        raise "#{token} not found in query" unless needle
+
+        if selector_tokens.size.zero?
+          needle.fieldset.builder.instance_eval(&block)
+        else
+          modify(needle.fieldset.fields, selector_tokens, &block)
+        end
+      end
+    end
+  end
+
   class Query < Fieldset
     using Refinements::StringRefinement
     attr_reader :name, :type
@@ -11,6 +42,10 @@ module Graphlyte
       super(**hargs)
     end
 
+    def at(selector, &block)
+      Selector.new(selector).modify(fields, &block)
+    end
+
     def placeholders
       flatten_variables(builder.>>).map do |value|
         unless value.formal?
@@ -62,7 +97,7 @@ module Graphlyte
           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}]"
+            memo << "[#{merge_variable_types(var.value, hargs).first}]"
           end
         else
           memo << [var.value.placeholder, var.value.name, var.value.default]
@@ -83,8 +118,9 @@ module Graphlyte
 
     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)
+        variables.concat field.inputs.extract_variables unless [InlineFragment, Fragment].include? field.class
+        variables.concat field.directive.inputs.extract_variables if field.respond_to?(:directive) && field.directive
+        if [InlineFragment, Fragment].include? field.class
           flatten_variables(field.fields, variables)
         else
           flatten_variables(field.fieldset.fields, variables)
@@ -95,6 +131,7 @@ module Graphlyte
 
     def flatten(fields, new_fields = {})
       fields.each do |field|
+        next if field.class == InlineFragment
         if field.class.eql?(Fragment)
           new_fields[field.fragment] = field
           unless field.empty?

data/lib/graphlyte/refinements/string_refinement.rb

@@ -10,11 +10,11 @@ module Graphlyte
         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

data/lib/graphlyte/schema/parser.rb

@@ -4,6 +4,7 @@ require_relative "../query"
 require_relative "../fragment"
 require_relative "../schema_query"
 require_relative "../types"
+require_relative "../arguments/value_literal"
 
 module Graphlyte
   module Schema
@@ -13,18 +14,31 @@ module Graphlyte
         fields
       end
 
+      def skip_fieldset
+        expect(:FIELDSET)
+        parse_fields
+        need(:END_FIELDSET)
+      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)
+        elsif expect(:INLINE_FRAGMENT)
+          field = parse_inline_fragment
+        elsif expect(:FIELDSET)
+
+        elsif (field = expect(:FIELD_NAME))
           args = parse_args
-          if fieldset = parse_fieldset
-            need(:END_FIELD)
-            field = Field.new(field[0][1], fieldset, args)
+          directive = parse_directive
+
+          if builder = parse_fieldset_into_builder
+            need(:END_FIELDSET)
+            fieldset = Fieldset.new(builder: builder)
+            field = Field.new(field[0][1], fieldset, args, directive: directive)
           else
-            field = Field.new(field[0][1], Fieldset.empty, args)
+            field = Field.new(field[0][1], Fieldset.empty, args, directive: directive)
           end
 
           if alias_field
@@ -35,10 +49,29 @@ module Graphlyte
         end
       end
 
-      def parse_fieldset
-        if expect(:START_FIELD)
+      def parse_inline_fragment
+        model_name = expect(:MODEL_NAME)&.dig(0, 1)
+        directive = parse_directive
+        inputs = directive ? (parse_args || {}) : {}
+        fields = expect(:FIELDSET) ? parse_fields : []
+        need(:END_FIELDSET)
+
+        InlineFragment.new(model_name, directive: directive, builder: Builder.new(fields), **inputs)
+      end
+
+      def parse_directive
+        if token = expect(:DIRECTIVE)
+          inputs = parse_args || {}
+
+          Directive.new(token[0][1], **inputs)
+        end
+      end
+
+      def parse_fieldset_into_builder
+        fields = []
+        if expect(:FIELDSET)
           fields = parse_fields
-          Fieldset.new(builder: Builder.new(fields))
+          Builder.new(fields)
         end
       end
 
@@ -51,7 +84,7 @@ module Graphlyte
       end
 
       def parse_default
-        if expect(:START_DEFAULT_VALUE)
+        if expect(:DEFAULT_VALUE)
           value = parse_value
           need(:END_DEFAULT_VALUE)
           value
@@ -60,38 +93,55 @@ module Graphlyte
 
       def parse_arg
         if (token = expect(:ARG_KEY)) && (value = parse_value)
-          defaults = parse_default
+          parse_default
           key = token[0][1]
-          hash = {}
-          hash[key] = value
-          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
-            new_val = Schema::Types::Base.new(value, token[0][1], defaults)
-            arg[token[0][1]] = new_val
-          end
-          @special_args.merge!(arg)
-          arg
+          arg[key] = value
+        elsif (token = expect(:SPECIAL_ARG_KEY)) && (value = parse_value)
+          arg = expect_and_inflate_special_args(token, value)
+        end
+
+        arg
+      end
+
+      def expect_and_inflate_special_args(token, value)
+        return { token[0][1] => value } if value.class == Schema::Types::Base
+
+        defaults = parse_default
+        @special_args ||= {}
+        arg = {}
+        if [Array, Hash].include?(value.class)
+          arg[token[0][1]] = value
+        else
+          new_val = Schema::Types::Base.new(value, token[0][1], defaults)
+          arg[token[0][1]] = new_val
         end
+        @special_args.merge!(arg)
+        arg
       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(:ARG_LITERAL_VALUE)
+          Graphlyte::Arguments::ValueLiteral.new(token[0][1])
         elsif token = expect(:SPECIAL_ARG_REF)
           ref = token[0][1]
-          raise "Can't find ref $#{ref}" unless @special_args[ref]
-          @special_args[ref]
+          # can't prove if this exists yet, so lets add it to the list
+          unless @special_args&.dig(ref)
+            @refs_to_validate ||= []
+            @refs_to_validate << ref
+            -> (args) do
+              args[ref]
+            end
+          else
+            @special_args[ref]
+          end
         elsif token = expect(:SPECIAL_ARG_VAL)
           token[0][1]
-        elsif token = expect(:ARG_HASH_START)
+        elsif token = expect(:ARG_HASH)
           parse_arg_hash
-        elsif expect(:ARG_ARRAY_START)
+        elsif expect(:ARG_ARRAY)
           parse_arg_array
         end
       end
@@ -134,6 +184,10 @@ module Graphlyte
         end
       end
 
+      def tokens?
+        !tokens[position].nil?
+      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}"
@@ -154,7 +208,7 @@ module Graphlyte
         if current_ref
           exists = sorted.any? do |frags|
             frags.find do |el|
-              el[0] == :START_FRAGMENT && el[1] == current_ref[1]
+              el[0] == :FRAGMENT && el[1] == current_ref[1]
             end
           end
           if exists
@@ -170,26 +224,38 @@ module Graphlyte
         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
+      # Select the fragments tokens as an array of arrays
+      # @return Array [[[:FRAGMENT, 'foo', bar], [:FIELDSET], [:END_FIELDSET]], [[:FRAGMENT 'buzz', 'bazz']...
+      def fetch_fragments(tokens = @tokens.dup, fragment_tokens = [], memo = { active: false, starts: 0, ends: 0, idx: 0 })
+        token_arr = tokens.shift
+        return fragment_tokens if token_arr.nil?
+
+        if memo[:active] == true
+          fragment_tokens[memo[:idx]] << token_arr
+        end
+
+        if token_arr[0] == :END_FIELDSET && memo[:active] == true
+          memo[:ends] += 1
+          if memo[:starts] == memo[:ends] + 1
+            memo[:active] = false
+            memo[:ends] = 0
+            memo[:starts] = 0
             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
+        elsif token_arr[0] == :FRAGMENT
+          memo[:active] = true
+          memo[:starts] += 1
+          fragment_tokens[memo[:idx]] = [token_arr]
+        elsif token_arr[0] == :FIELDSET && memo[:active] == true
+          memo[:starts] += 1
         end
-        aggregate[:fragments]
+
+        fetch_fragments(tokens, fragment_tokens, memo)
       end
     end
 
     class FragmentParser
-      attr_reader :tokens, :position, :fragments_dictionary
+      attr_reader :tokens, :position, :fragments_dictionary, :special_args
 
       include ParserHelpers
 
@@ -205,12 +271,16 @@ module Graphlyte
       end
 
       def parse_fragment
-        if token = expect(:START_FRAGMENT)
+        if token = expect(:FRAGMENT)
           parse_args
-          builder = Builder.new parse_fields
-          fragment = Fragment.new(token[0][1], token[0][2], builder: builder)
+          if builder = parse_fieldset_into_builder
+            fragment = Fragment.new(token[0][1], token[0][2], builder: builder)
+            need(:END_FIELDSET) if tokens?
+          elsif fields = parse_fields
+            builder = Builder.new(fields)
+            fragment = Fragment.new(token[0][1], token[0][2], builder: builder)
+          end
           @fragments_dictionary[token[0][1]] = fragment
-          need(:END_FRAGMENT)
         end
       end
     end
@@ -227,41 +297,61 @@ module Graphlyte
 
       def initialize(tokens)
         @tokens = tokens
-        @fragment_tokens = sort_fragments([], take_fragments)
+
+        @fragment_tokens = sort_fragments([], fetch_fragments)
         @fragments_dictionary = {}
         @fragments_dictionary = @fragment_tokens.any? ? FragmentParser.new(@fragment_tokens).parse_fragments : {}
         @position = 0
       end
 
+      def refresh_lazy_refs(fields)
+        fields.each do |field|
+          if field.is_a? Fieldset
+            refresh_lazy_refs(field.fields)
+          else
+            field.inputs.resolve_lazy_special_args(@special_args)
+            refresh_lazy_refs(field.fieldset.fields)
+          end
+        end
+      end
+
       def parse
-        if token = expect(:START_QUERY)
-          parse_query(token[0][1])
-        elsif token = expect(:START_MUTATION)
-          parse_mutation(token[0][1])
+        if token = expect(:EXPRESSION)
+          value = parse_expression(token[0][1], token[0][2])
+
+          # validate fragment refs
+          @refs_to_validate&.each do |ref|
+            raise "Argument reference #{ref} doesn't exist" unless @special_args[ref]
+          end
+
+          refresh_lazy_refs(value.builder.>>)
+
+          value
+        elsif expect(:FRAGMENT)
+          skip_fragments
+          parse
         else
-          raise "INVALID"
+          raise "Expression or Fragment not found"
         end
       end
 
-      def parse_query(name)
-        parse_args
-        builder = Builder.new parse_fields
-        query = Query.new(name, :query, builder: builder)
-        need(:END_QUERY)
-        query
+      def skip_fragments
+        skip_fieldset
       end
 
-      def parse_mutation(name)
-        builder = Builder.new parse_fields
-        mutation = Query.new(name, :mutation, builder: builder)
-        need(:END_MUTATION)
-        mutation
+      def parse_expression(type, name)
+        parse_args
+        builder = parse_fieldset_into_builder
+        need(:END_FIELDSET)
+        query = Query.new(name, type.to_sym, builder: builder)
+        query
       end
     end
 
+    class LexerError < StandardError; end
+
     class Lexer
       attr_reader :stack, :scanner
-
       def initialize(gql, scanner: StringScanner.new(gql))
         @original_string = gql
         @scanner = scanner
@@ -269,211 +359,283 @@ module Graphlyte
       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 /\s*\}\s*/
-              @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 /,/
-              #
+          tokenize_objects
+        end
+
+        @tokens
+      end
+
+      def tokenize_objects
+        case state
+        when :default # the stack is empty, can only process top level fragments or expressions
+          if scanner.scan %r{\s*fragment\s*(\w+)\s*on\s*(\w+)}
+            @tokens << [:FRAGMENT, scanner[1], scanner[2]]
+            push_context :fragments
+            # check for a fieldset
+            if scanner.check %r[\s*{]
+              tokenize_fieldset
             else
-              handle_shared_arguments
+              scanner.scan /\(/
+              @tokens << [:START_ARGS]
+              push_state :arguments
             end
-          when :argument_defaults
-            if @stack.reverse.take(2).eql?([:argument_defaults, :argument_defaults])
-              @tokens << [:END_DEFAULT_VALUE]
-              pop_state
-              pop_state
+          elsif scanner.check /\{/
+            @tokens << [:EXPRESSION, 'query', nil] if get_context == :default
+            push_context :fieldset
+
+            tokenize_fieldset
+          elsif scanner.scan %r{^(\w+) (\w+)?}
+            @tokens << [:EXPRESSION, scanner[1], scanner[2]]
+            push_context :expression
+            # check for a fieldset
+            if scanner.check %r[\s*{]
+              tokenize_fieldset
             else
-              push_state :argument_defaults
-              handle_shared_arguments
+              scanner.scan /\(/
+              @tokens << [:START_ARGS]
+              push_state :arguments
             end
-          when :special_args
-            handle_special_args
+          elsif scanner.check /\s*\}/
+            end_fieldset
+          else
+            advance
           end
+        when :fieldset
+          tokenize_fields
+        when :arguments
+          tokenize_arguments
+        when :argument_defaults
+          tokenize_argument_defaults
+        when :hash_arguments
+          tokenize_hash_arguments
+        when :array_arguments
+          tokenize_array_arguments
+        when :special_args
+          tokenize_special_arguments
+        when :inline_fragment
+          tokenize_inline_fragment
         end
-        @tokens
       end
 
-      private
+      def check_for_last(regex = /\s*\}/)
+        scanner.check regex
+      end
 
-      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
-          # we need to pop state if we are nested in a field, and not in the query context
-          pop_state if get_context == :field
-        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
-          # we need to pop state if we are nested in a field, and not in the query context
-          pop_state if get_context == :field
-        elsif scanner.scan /\s*(\w+)\s*/
-          @tokens << [:FIELD_NAME, scanner[1]]
-        elsif scanner.scan /^\s*\(/
-          @tokens << [:START_ARGS]
-          push_state :arguments
+      def check_for_final
+        scanner.check /\s*\}(?!\s*\})/
+      end
+
+      def check_for_not_last
+        scanner.check /\s*\}(?=\s*\})/
+      end
+
+      def tokenize_inline_fragment
+        if scanner.scan /on (\w+)/
+          @tokens << [:MODEL_NAME, scanner[1]]
+
+          pop_state
+        elsif scanner.scan /@(\w+)/
+          @tokens << [:DIRECTIVE, scanner[1]]
+
+          pop_state
         else
+          # throw an error here?
           advance
         end
       end
 
-      def handle_shared_arguments
+      def end_fieldset
+        scanner.scan /\s*\}/
+        @tokens << [:END_FIELDSET]
+        pop_state
+        pop_context if state == :default
+      end
+
+      def end_arguments
+        scanner.scan /\s*\)/
+        @tokens << [:END_ARGS]
+        pop_state if state == :argument_defaults
+        pop_state
+        end_fieldset while check_for_last && state == :fieldset
+      end
+
+      # to tired to figure out why this is right now
+      def tokenize_argument_defaults
+        if scanner.check /\)/
+          @tokens << [:END_DEFAULT_VALUE]
+          pop_state
+        elsif scanner.scan /[\n|,]/
+          @tokens << [:END_DEFAULT_VALUE]
+          pop_state
+        else
+          tokenize_shared_arguments
+        end
+      end
+
+      def tokenize_special_arguments
+        if scanner.check SPECIAL_ARG_REGEX
+          scanner.scan SPECIAL_ARG_REGEX
+
+          @tokens << [:SPECIAL_ARG_VAL, scanner[1]]
+
+          pop_state
+
+          end_arguments if check_for_last(/\s*\)/)
+        else
+          # revisit this.. should we throw an error here?
+          pop_state
+          raise LexerError, "why can't we parse #{scanner.peek(5)}"
+        end
+      end
+
+      def tokenize_array_arguments
+        if scanner.scan /\]/
+          @tokens << [:ARG_ARRAY_END]
+
+          pop_state
+          # if check_for_last(')')
+          #   pop_state
+          # end
+        else
+          tokenize_shared_arguments
+        end
+      end
+
+      def tokenize_hash_arguments
+        if scanner.scan /\}/
+          @tokens << [:ARG_HASH_END]
+
+          pop_state
+          # if this is the last argument in the list, maybe get back to the field scope?
+          # if check_for_last(')')
+          #   pop_state
+          # end
+        else
+          tokenize_shared_arguments
+        end
+      end
+
+      def pop_argument_state
+        if check_for_last(/\s*\)/)
+          @tokens << [:END_DEFAULT_VALUE] if state == :argument_defaults
+          end_arguments
+        else
+          pop_state unless %i[arguments argument_defaults hash_arguments array_arguments special_args].include?(state)
+        end
+      end
+
+      def tokenize_arguments
+        # pop argument state if arguments are finished
+        if scanner.scan %r{\)}
+          @tokens << [:END_ARGS]
+
+          pop_state
+        # something(argument: $argument = true)
+        elsif scanner.scan %r{=}
+          @tokens << [:DEFAULT_VALUE]
+
+          push_state :argument_defaults
+        # noop, should expect this, but not important
+        elsif scanner.scan %r{,}
+          nil
+        else
+          tokenize_shared_arguments
+        end
+      end
+
+      def tokenize_shared_arguments
         if scanner.scan /^(\w+):/
           @tokens << [:ARG_KEY, scanner[1]]
-        elsif scanner.scan /^\s*\{\s*?/
-          @tokens << [:ARG_HASH_START]
+        elsif scanner.scan %r[{]
+          @tokens << [:ARG_HASH]
+
           push_state :hash_arguments
-        elsif scanner.scan /\s*\[\s*/
-          @tokens << [:ARG_ARRAY_START]
+        elsif scanner.scan /\[/
+          @tokens << [:ARG_ARRAY]
+
           push_state :array_arguments
-        elsif scanner.scan /\s?\"([\w\s]+)\"/
+        elsif scanner.scan %r{"(.*?)"}
           @tokens << [:ARG_STRING_VALUE, scanner[1]]
-        elsif scanner.scan /\s?(\d+\.\d+)/
+
+          pop_argument_state
+        elsif scanner.scan /(\d+\.\d+)/
           @tokens << [:ARG_FLOAT_VALUE, scanner[1].to_f]
-        elsif scanner.scan /\s?(\d+)/
+
+          pop_argument_state
+        elsif scanner.scan /(\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]
+
+          pop_argument_state
+        elsif scanner.scan /(true|false)/
+          @tokens << [:ARG_BOOL_VALUE, (scanner[1] == 'true')]
+
+          pop_argument_state
         elsif scanner.scan /\$(\w+):/
           @tokens << [:SPECIAL_ARG_KEY, scanner[1]]
+
           push_state :special_args
         elsif scanner.scan /\$(\w+)/
           @tokens << [:SPECIAL_ARG_REF, scanner[1]]
+
+          pop_argument_state
+        elsif scanner.scan /,/
+          # no-op
+        elsif scanner.scan /([A-Za-z_"]+)/
+          @tokens << [:ARG_LITERAL_VALUE, scanner[1]]
+
+        elsif check_for_last(/\s*\)/)
+          @tokens << [:END_DEFAULT_VALUE] if state == :argument_defaults
+          end_arguments
         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 tokenize_fields
+        if scanner.check %r[\s*{]
+          tokenize_fieldset
+        # ... on Model - or - ... @directive
+        elsif scanner.scan %r{\.{3}\s}
+          @tokens << [:INLINE_FRAGMENT]
+          push_state :inline_fragment
+        # @directive
+        elsif scanner.scan %r{@(\w+)}
+          @tokens << [:DIRECTIVE, scanner[1]]
 
-      def handle_hash_arguments
-        if scanner.scan /\}/
-          @tokens << [:ARG_HASH_END]
-          pop_state
+          end_fieldset while check_for_last && state == :fieldset
+          # ...fragmentReference (check for last since it is a field literal)
+        elsif scanner.scan /\.{3}(\w+)/
+          @tokens << [:FRAGMENT_REF, scanner[1]]
+
+          end_fieldset while check_for_last && state == :fieldset
+        # alias:
+        elsif scanner.scan %r{(\w+):}
+          @tokens << [:ALIAS, scanner[1]]
+        # fieldLiteral
+        elsif scanner.scan %r{(\w+)}
+          @tokens << [:FIELD_NAME, scanner[1]]
+
+          end_fieldset while check_for_last && state == :fieldset
+        # (arguments: true)
+        elsif scanner.scan /^\s*\(/
+          @tokens << [:START_ARGS]
+
+          push_state :arguments
         else
-          handle_shared_arguments
+          advance
         end
       end
 
-      def handle_array_arguments
-        if scanner.scan /\s*\]\s*/
-          @tokens << [:ARG_ARRAY_END]   
-          pop_state   
+      def tokenize_fieldset
+        if scanner.scan %r[\s*{]
+          @tokens << [:FIELDSET]
+
+          push_state :fieldset
         else
-          handle_shared_arguments
+          raise LexerError, "Expecting `{` got `#{scanner.peek(3)}`"
         end
       end
 
@@ -498,6 +660,10 @@ module Graphlyte
       end
 
       def advance
+        unless scanner.check /\s/
+          raise LexerError, "Unexpected Char: '#{scanner.peek(20)}'"
+        end
+
         scanner.pos = scanner.pos + 1
       end
 

data/lib/graphlyte.rb

@@ -2,13 +2,14 @@ require 'json'
 require_relative "./graphlyte/fieldset"
 require_relative "./graphlyte/query"
 require_relative "./graphlyte/fragment"
+require_relative 'graphlyte/inline_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)
@@ -23,6 +24,18 @@ module Graphlyte
     Query.new(name, :mutation, builder: build(&block))
   end
 
+  def self.custom(name, type, &block)
+    Query.new(name, type.to_sym, builder: build(&block))
+  end
+
+  def self.inline_fragment(model_name, &block)
+    InlineFragment.new(model_name, builder: build(&block))
+  end
+
+  def self.inline_directive(directive, **hargs, &block)
+    InlineFragment.from_directive(directive, **hargs, builder: build(&block) )
+  end
+
   def self.fragment(fragment_name, model_name, &block)
     Fragment.new(fragment_name, model_name, builder: build(&block))
   end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: graphlyte
 version: !ruby/object:Gem::Version
-  version: 0.2.4
+  version: 0.3.2
 platform: ruby
 authors:
 - Sean Gregory
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-03-24 00:00:00.000000000 Z
+date: 2022-03-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
@@ -47,10 +47,13 @@ files:
 - lib/graphlyte.rb
 - lib/graphlyte/arguments/set.rb
 - lib/graphlyte/arguments/value.rb
+- lib/graphlyte/arguments/value_literal.rb
 - lib/graphlyte/builder.rb
+- lib/graphlyte/directive.rb
 - lib/graphlyte/field.rb
 - lib/graphlyte/fieldset.rb
 - lib/graphlyte/fragment.rb
+- lib/graphlyte/inline_fragment.rb
 - lib/graphlyte/query.rb
 - lib/graphlyte/refinements/string_refinement.rb
 - lib/graphlyte/schema/parser.rb