graphlyte 0.1.6 → 0.2.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6daff225ff526c8866c59601de914bbf7cac87c0393d5a3918a16f78c249eaa7
-  data.tar.gz: 104deccd41d6dc5fd2be8a263f8549e5190f088717737fed61b9ae9da78aca6d
+  metadata.gz: 4993b6b7dba33932ac40eff10ac57644a120ee41d23df9408d70ea3c5fe12aec
+  data.tar.gz: f7fba13051b20ad335936347753ec3507b113852bcbdd4c5ad62ac3b127496ec
 SHA512:
-  metadata.gz: 539c3dfd3b611f79341f32b8eb61db2c76d0c92fd3e2e3d7312dd6d1946ec51463ac7f7f8db09e663a8681e9afc065f5cf0b7a5788d5129ca6e08d5b4870ce28
-  data.tar.gz: 642ca3c211d11e1b6613a6910ed618685d9a87ae3057438f7f5ab3ccc63dba26041691a4a81309b77e41b682b86ad4aefe6789631fd3b0ddccb11b882d959947
+  metadata.gz: 3bab812cb94fd2abeb816180683297c4c95f1486368a5f3029a9917fcf4dcf505d8b6c82777ef4574f550fdc8cd6f0878a92bebcbeb09702b3d832f664e4a0fa
+  data.tar.gz: cbbfbbff19e0f789d09b01e8581ded8892601b85710b9c9a84ffcc9e393c1ef69aa27c094deb2a81a23078614982519d6ee0f8047ff63d3f1991fddab764a39f

data/lib/graphlyte/arguments/set.rb

@@ -16,6 +16,7 @@ module Graphlyte
         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?
@@ -41,7 +42,15 @@ module Graphlyte
       
       def to_s(inner = false)
         return "" unless values && !values.empty?
-        arr = values.map do |k,v| 
+        arr = stringify_arguments
+        return arr.join(", ") if inner
+        "(#{arr.join(", ")})"
+      end
+
+      private 
+
+      def stringify_arguments
+        values.map do |k,v|
           if v.is_a?(Array)
             "#{k.to_s.to_camel_case}: [#{v.map(&:to_s).join(", ")}]"
           elsif v.is_a?(Set)
@@ -50,22 +59,26 @@ module Graphlyte
             "#{k.to_s.to_camel_case}: #{v.to_s}"
           end
         end
-        return arr.join(", ") if inner
-        "(#{arr.join(", ")})"
       end
 
-      private 
-
       def expand_arguments(data)
         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/builder.rb

@@ -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)
@@ -31,6 +31,10 @@ module Graphlyte
       field
     end
 
+    def respond_to_missing
+      true
+    end
+
     # for internal use only
     def >>
       @fields

data/lib/graphlyte/query.rb

@@ -1,29 +1,45 @@
 require_relative "./refinements/string_refinement"
+require "json"
 module Graphlyte
   class Query < Fieldset
     using Refinements::StringRefinement
     attr_reader :name, :type
 
     def initialize(query_name=nil, type=:query, **hargs)
-      @name = query_name
+      @name = query_name || "anonymousQuery"
       @type = type
       super(**hargs)
     end
 
     def placeholders
       flatten_variables(builder.>>).map do |value|
-        ":#{value.value.placeholder} of #{value.value.name}"
+        unless value.formal?
+          str = ":#{value.value.to_sym.inspect} of unknown"
+        else
+          str = ":#{value.value.placeholder} of #{value.value.name}"
+        end
+
+        if value.value.default
+          str += " with default "
+          value.value.default.merge!(str)
+        end
+        str
       end.join("\n")
     end
 
-    def to_json(name="anonymousQuery", **hargs)
+    def to_json(query_name=name, **hargs)
       variables = flatten_variables(builder.>>).uniq { |v| v.value }
       types = merge_variable_types(variables, hargs)
 
-      str = "#{type} #{name}"
+      str = "#{type} #{query_name}"
       unless types.empty?
         type_new = types.map do |type_arr|
-          "$#{type_arr[0].to_camel_case}: #{type_arr[1]}"
+          type_str = "$#{type_arr[0].to_camel_case}: #{type_arr[1]}"
+          unless type_arr[2].nil?
+            type_str << " = "
+            type_arr[2].merge!(type_str)
+          end
+          type_str
         end
         str += "(#{type_new.join(", ")})"
       end
@@ -49,7 +65,7 @@ module Graphlyte
             memo <<  "[#{merge_variable_types(var.value, hargs).first}]"
           end
         else
-          memo << [var.value.placeholder, var.value.name]
+          memo << [var.value.placeholder, var.value.name, var.value.default]
         end
         memo
       end

data/lib/graphlyte/schema/parser.rb

@@ -0,0 +1,521 @@
+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 = {}
+          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
+        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]
+          @special_args[ref]
+        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)
+          hash = {}
+          hash[key[0][1]] = value
+          hash
+          if new_hash = parse_arg_hash
+            hash.merge!(new_hash)
+          else
+            need(:ARG_HASH_END)
+            hash
+          end
+        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)
+          parse_args
+          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[0][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 /\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 /,/
+              #
+            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
+          # 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
+        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

@@ -1,12 +1,50 @@
 module Graphlyte
   module Schema
     module Types
+      class Defaults
+        attr_reader :value
+        def initialize(value)
+          @value = value
+        end
+
+        def merge!(str)
+          parse_value(@value, str)
+        end
+
+        def parse_value(value, str)
+          if value.is_a?(Hash)
+            str << "{ "
+            value.each_with_index do |(k, v), idx|
+              str << "#{k}: "
+              parse_value(v, str)
+              str << ", " if idx < (value.size - 1)
+            end
+            str << " }"
+          elsif value.is_a?(Array)
+            str << "["
+            value.each_with_index do |item, idx|
+              parse_value(item, str)
+              str << ", " if idx < (value.size - 1)
+            end
+            str << "]"
+          else
+            str << "#{Arguments::Value.new(value).to_s}"
+          end
+        end
+      end
+
       class Base
         attr_reader :name, :placeholder
 
-        def initialize(name, placeholder)
+        def initialize(name, placeholder, defaults=nil)
           @name = name
           @placeholder = placeholder
+          @defaults = defaults
+        end
+
+        def default
+          return nil if @defaults.class == NilClass
+          Defaults.new(@defaults)
         end
       end
     end

data/lib/graphlyte.rb

@@ -4,12 +4,17 @@ 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, :query, builder: build(&block))
   end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: graphlyte
 version: !ruby/object:Gem::Version
-  version: 0.1.6
+  version: 0.2.3
 platform: ruby
 authors:
 - Sean Gregory
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-11-06 00:00:00.000000000 Z
+date: 2021-12-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
@@ -53,6 +53,7 @@ files:
 - 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
@@ -60,8 +61,8 @@ 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
@@ -76,8 +77,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.2.22
-signing_key: 
+rubygems_version: 3.2.31
+signing_key:
 specification_version: 4
 summary: craft graphql queries with ruby
 test_files: []