graphql 1.8.0 → 1.12.12

data/lib/graphql/language/lexer.rl

@@ -20,6 +20,7 @@
   SCHEMA =        'schema';
   SCALAR =        'scalar';
   TYPE =          'type';
+  EXTEND =        'extend';
   IMPLEMENTS =    'implements';
   INTERFACE =     'interface';
   UNION =         'union';
@@ -34,11 +35,17 @@
   RBRACKET =      ']';
   COLON =         ':';
   QUOTE =         '"';
+  BACKSLASH = '\\';
+  # Could limit to hex here, but “bad unicode escape” on 0XXF is probably a
+  # more helpful error than “unknown char”
+  UNICODE_ESCAPE = '\\u' [0-9A-Za-z]{4};
+  # https://graphql.github.io/graphql-spec/June2018/#sec-String-Value
+  STRING_ESCAPE = '\\' [\\/bfnrt];
   BLOCK_QUOTE =   '"""';
   ESCAPED_BLOCK_QUOTE = '\\"""';
-  BLOCK_STRING_CHAR = (ESCAPED_BLOCK_QUOTE | ^'"""');
+  BLOCK_STRING_CHAR = (ESCAPED_BLOCK_QUOTE | ^QUOTE | QUOTE{1,2} ^QUOTE);
   ESCAPED_QUOTE = '\\"';
-  STRING_CHAR =   (ESCAPED_QUOTE | ^'"');
+  STRING_CHAR =   ((ESCAPED_QUOTE | ^QUOTE) - BACKSLASH) | UNICODE_ESCAPE | STRING_ESCAPE;
   VAR_SIGN =      '$';
   DIR_SIGN =      '@';
   ELLIPSIS =      '...';
@@ -48,46 +55,52 @@
   AMP =           '&';
 
   QUOTED_STRING = QUOTE STRING_CHAR* QUOTE;
-  BLOCK_STRING = BLOCK_QUOTE BLOCK_STRING_CHAR* BLOCK_QUOTE;
+  BLOCK_STRING = BLOCK_QUOTE BLOCK_STRING_CHAR* QUOTE{0,2} BLOCK_QUOTE;
   # catch-all for anything else. must be at the bottom for precedence.
   UNKNOWN_CHAR =         /./;
 
+  # Used with ragel -V for graphviz visualization
+  str := |*
+      QUOTED_STRING => { emit_string(ts, te, meta, block: false) };
+  *|;
+
   main := |*
     INT           => { emit(:INT, ts, te, meta) };
     FLOAT         => { emit(:FLOAT, ts, te, meta) };
-    ON            => { emit(:ON, ts, te, meta) };
-    FRAGMENT      => { emit(:FRAGMENT, ts, te, meta) };
-    TRUE          => { emit(:TRUE, ts, te, meta) };
-    FALSE         => { emit(:FALSE, ts, te, meta) };
-    NULL          => { emit(:NULL, ts, te, meta) };
-    QUERY         => { emit(:QUERY, ts, te, meta) };
-    MUTATION      => { emit(:MUTATION, ts, te, meta) };
-    SUBSCRIPTION  => { emit(:SUBSCRIPTION, ts, te, meta) };
+    ON            => { emit(:ON, ts, te, meta, "on") };
+    FRAGMENT      => { emit(:FRAGMENT, ts, te, meta, "fragment") };
+    TRUE          => { emit(:TRUE, ts, te, meta, "true") };
+    FALSE         => { emit(:FALSE, ts, te, meta, "false") };
+    NULL          => { emit(:NULL, ts, te, meta, "null") };
+    QUERY         => { emit(:QUERY, ts, te, meta, "query") };
+    MUTATION      => { emit(:MUTATION, ts, te, meta, "mutation") };
+    SUBSCRIPTION  => { emit(:SUBSCRIPTION, ts, te, meta, "subscription") };
     SCHEMA        => { emit(:SCHEMA, ts, te, meta) };
     SCALAR        => { emit(:SCALAR, ts, te, meta) };
     TYPE          => { emit(:TYPE, ts, te, meta) };
+    EXTEND        => { emit(:EXTEND, ts, te, meta) };
     IMPLEMENTS    => { emit(:IMPLEMENTS, ts, te, meta) };
     INTERFACE     => { emit(:INTERFACE, ts, te, meta) };
     UNION         => { emit(:UNION, ts, te, meta) };
     ENUM          => { emit(:ENUM, ts, te, meta) };
     INPUT         => { emit(:INPUT, ts, te, meta) };
     DIRECTIVE     => { emit(:DIRECTIVE, ts, te, meta) };
-    RCURLY        => { emit(:RCURLY, ts, te, meta) };
-    LCURLY        => { emit(:LCURLY, ts, te, meta) };
-    RPAREN        => { emit(:RPAREN, ts, te, meta) };
-    LPAREN        => { emit(:LPAREN, ts, te, meta) };
-    RBRACKET      => { emit(:RBRACKET, ts, te, meta) };
-    LBRACKET      => { emit(:LBRACKET, ts, te, meta) };
-    COLON         => { emit(:COLON, ts, te, meta) };
+    RCURLY        => { emit(:RCURLY, ts, te, meta, "}") };
+    LCURLY        => { emit(:LCURLY, ts, te, meta, "{") };
+    RPAREN        => { emit(:RPAREN, ts, te, meta, ")") };
+    LPAREN        => { emit(:LPAREN, ts, te, meta, "(")};
+    RBRACKET      => { emit(:RBRACKET, ts, te, meta, "]") };
+    LBRACKET      => { emit(:LBRACKET, ts, te, meta, "[") };
+    COLON         => { emit(:COLON, ts, te, meta, ":") };
     QUOTED_STRING => { emit_string(ts, te, meta, block: false) };
     BLOCK_STRING  => { emit_string(ts, te, meta, block: true) };
-    VAR_SIGN      => { emit(:VAR_SIGN, ts, te, meta) };
-    DIR_SIGN      => { emit(:DIR_SIGN, ts, te, meta) };
-    ELLIPSIS      => { emit(:ELLIPSIS, ts, te, meta) };
-    EQUALS        => { emit(:EQUALS, ts, te, meta) };
-    BANG          => { emit(:BANG, ts, te, meta) };
-    PIPE          => { emit(:PIPE, ts, te, meta) };
-    AMP           => { emit(:AMP, ts, te, meta) };
+    VAR_SIGN      => { emit(:VAR_SIGN, ts, te, meta, "$") };
+    DIR_SIGN      => { emit(:DIR_SIGN, ts, te, meta, "@") };
+    ELLIPSIS      => { emit(:ELLIPSIS, ts, te, meta, "...") };
+    EQUALS        => { emit(:EQUALS, ts, te, meta, "=") };
+    BANG          => { emit(:BANG, ts, te, meta, "!") };
+    PIPE          => { emit(:PIPE, ts, te, meta, "|") };
+    AMP           => { emit(:AMP, ts, te, meta, "&") };
     IDENTIFIER    => { emit(:IDENTIFIER, ts, te, meta) };
     COMMENT       => { record_comment(ts, te, meta) };
 
@@ -103,10 +116,15 @@
   *|;
 }%%
 
+# frozen_string_literal: true
 
 module GraphQL
   module Language
     module Lexer
+      if !String.method_defined?(:match?)
+        using GraphQL::StringMatchBackport
+      end
+
       def self.tokenize(query_string)
         run_lexer(query_string)
       end
@@ -124,7 +142,7 @@ module GraphQL
       %% write data;
 
       def self.run_lexer(query_string)
-        data = query_string.unpack("c*")
+        data = query_string.unpack(PACK_DIRECTIVE)
         eof = data.length
 
         # Since `Lexer` is a module, store all lexer state
@@ -149,11 +167,11 @@ module GraphQL
 
       def self.record_comment(ts, te, meta)
         token = GraphQL::Language::Token.new(
-          name: :COMMENT,
-          value: meta[:data][ts...te].pack(PACK_DIRECTIVE).force_encoding(UTF_8_ENCODING),
-          line: meta[:line],
-          col: meta[:col],
-          prev_token: meta[:previous_token],
+          :COMMENT,
+          meta[:data][ts, te - ts].pack(PACK_DIRECTIVE).force_encoding(UTF_8_ENCODING),
+          meta[:line],
+          meta[:col],
+          meta[:previous_token],
         )
 
         meta[:previous_token] = token
@@ -161,13 +179,14 @@ module GraphQL
         meta[:col] += te - ts
       end
 
-      def self.emit(token_name, ts, te, meta)
+      def self.emit(token_name, ts, te, meta, token_value = nil)
+        token_value ||= meta[:data][ts, te - ts].pack(PACK_DIRECTIVE).force_encoding(UTF_8_ENCODING)
         meta[:tokens] << token = GraphQL::Language::Token.new(
-          name: token_name,
-          value: meta[:data][ts...te].pack(PACK_DIRECTIVE).force_encoding(UTF_8_ENCODING),
-          line: meta[:line],
-          col: meta[:col],
-          prev_token: meta[:previous_token],
+          token_name,
+          token_value,
+          meta[:line],
+          meta[:col],
+          meta[:previous_token],
         )
         meta[:previous_token] = token
         # Bump the column counter for the next token
@@ -196,33 +215,47 @@ module GraphQL
 
       def self.emit_string(ts, te, meta, block:)
         quotes_length = block ? 3 : 1
-        ts += quotes_length
-        value = meta[:data][ts...te - quotes_length].pack(PACK_DIRECTIVE).force_encoding(UTF_8_ENCODING)
-        if block
+        value = meta[:data][ts + quotes_length, te - ts - 2 * quotes_length].pack(PACK_DIRECTIVE).force_encoding(UTF_8_ENCODING) || ''
+        line_incr = 0
+        if block && !value.empty?
+          line_incr = value.count("\n")
           value = GraphQL::Language::BlockString.trim_whitespace(value)
         end
-        if value !~ VALID_STRING
+        # TODO: replace with `String#match?` when we support only Ruby 2.4+
+        # (It's faster: https://bugs.ruby-lang.org/issues/8110)
+        if !value.valid_encoding? || !value.match?(VALID_STRING)
           meta[:tokens] << token = GraphQL::Language::Token.new(
-            name: :BAD_UNICODE_ESCAPE,
-            value: value,
-            line: meta[:line],
-            col: meta[:col],
-            prev_token: meta[:previous_token],
+            :BAD_UNICODE_ESCAPE,
+            value,
+            meta[:line],
+            meta[:col],
+            meta[:previous_token],
           )
         else
           replace_escaped_characters_in_place(value)
 
-          meta[:tokens] << token = GraphQL::Language::Token.new(
-            name: :STRING,
-            value: value,
-            line: meta[:line],
-            col: meta[:col],
-            prev_token: meta[:previous_token],
-          )
+          if !value.valid_encoding?
+            meta[:tokens] << token = GraphQL::Language::Token.new(
+              :BAD_UNICODE_ESCAPE,
+              value,
+              meta[:line],
+              meta[:col],
+              meta[:previous_token],
+            )
+          else
+            meta[:tokens] << token = GraphQL::Language::Token.new(
+              :STRING,
+              value,
+              meta[:line],
+              meta[:col],
+              meta[:previous_token],
+            )
+          end
         end
 
         meta[:previous_token] = token
         meta[:col] += te - ts
+        meta[:line] += line_incr
       end
     end
   end