graphlyte 0.1.5 → 0.2.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e9b09edacd482f9beb267eed78593bc26f5f0563648399f60fec47d1552052eb
-  data.tar.gz: 39756650800195570dc38a7f7990e0b0efc001033045d6865f16b275749d3de5
+  metadata.gz: 25e9370260ac88d2a810c879bf663c4965340c6838e8e19b18f19309d81ffec1
+  data.tar.gz: dc7c5ba7909fb9f4615021e07e819771f66a0d73ba8cc5772928cb896808b2e8
 SHA512:
-  metadata.gz: e084fd25d75112d2d97a994c63259d436a684e6880a8ea9ef47a56337012f78615bdeb89cb03a39603bdbb5dabd30c07e8b0167f46facae650a990f11dba4377
-  data.tar.gz: 88cd8dd425fc74a8707b203683d76b5d168649b979708deffcec92f867c569a4f465ea0c30350ce9caa459c5b9ba667835f9e7ada7e9df4bee85b19bce7dda7b
+  metadata.gz: 77b742ef11daf4270c22e9ede3ae848dfb0d81a6ad4717c7a6a75ffa88ecf9f688630aa1348d7b8092d0096314596ccef9a34d95ef87486f2292481795763669
+  data.tar.gz: 53c19eab7a95e2ee2b4d5f2d9412560035c511c5be12bc8af443cad6f742aea36aa34ffffc5242cc58fe9ab685f0465f1e67344905f5baadd196a4b0552148d2

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?
@@ -60,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

@@ -4,11 +4,17 @@ module Graphlyte
     class Value
       using Refinements::StringRefinement
 
-      attr_reader :value
+      attr_reader :value, :default
 
-      def initialize(value)
+      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?

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,25 +1,36 @@
 require_relative "./refinements/string_refinement"
+require "json"
 module Graphlyte
   class Query < Fieldset
     using Refinements::StringRefinement
-    attr_reader :name
+    attr_reader :name, :type
 
-    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 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.default
+          str += " with default #{value.default.to_s}"
+        end
+        str
       end.join("\n")
     end
 
-    def to_json(name="anonymousQuery", **hargs)
-      variables = flatten_variables(builder.>>)
+    def to_json(query_name=name, **hargs)
+      variables = flatten_variables(builder.>>).uniq { |v| v.value }
       types = merge_variable_types(variables, hargs)
 
-      str = "query #{name}"
+      str = "#{type} #{query_name}"
       unless types.empty?
         type_new = types.map do |type_arr|
           "$#{type_arr[0].to_camel_case}: #{type_arr[1]}"

data/lib/graphlyte/schema/parser.rb

@@ -0,0 +1,520 @@
+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)
+          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.rb

@@ -4,14 +4,23 @@ 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)

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: graphlyte
 version: !ruby/object:Gem::Version
-  version: 0.1.5
+  version: 0.2.2
 platform: ruby
 authors:
 - Sean Gregory
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-08-14 00:00:00.000000000 Z
+date: 2021-11-21 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.3
-signing_key: 
+rubygems_version: 3.2.31
+signing_key:
 specification_version: 4
 summary: craft graphql queries with ruby
 test_files: []