tinygql 0.1.4 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ef7a07443c070f78f1ad6324890611e1ea70298c7d67eac591911c208b42aa0f
-  data.tar.gz: 3311b13953c075059a737b46f82f50aa3fd2428d844499c64354a285aa2774cd
+  metadata.gz: 114da94b6827645fb92f0f3e85b9e4f34b64aaee8449c143217cc75fc903ab3c
+  data.tar.gz: 27031f9423d30f0453a6737be1184cb8c724a6290bc432b7e35dea255fa549a5
 SHA512:
-  metadata.gz: 814659e285e05236a4861931cf548eabab4abeaccdbc5b959adc12e3a3e6f6b9a67ea5626117ae44f46a9316c8d3210adafbf269730aec23b8c9d5ac0a538832
-  data.tar.gz: 3603440c4c6aa2aed7c361439299b8218b2f01a2c5ea96ed100da5028ac6fe391d62322a4431124861db7de50c60c69fd50d3da92178c12ef04dd58fbe63e2d3
+  metadata.gz: a4362f8d3c3d638c715c4686ec9714d59f59d411be390cf115d0b7e8bc4f710fcbfe935ca058092f24935964fd29905643e6f1f4edeb84e238e1af0d5d2eff4e
+  data.tar.gz: 5ec4f82ff306221b2c8e008b3bb76feb1c55917ab26334e1531f7eb8e58f03e44a29901fe92765585cfa195c41a107fdd13337b3bb844f13bb9985f1394f8ee0

data/bin/bench.rb

@@ -20,3 +20,41 @@ Benchmark.ips do |x|
     end
   end
 end
+
+module Benchmark
+  def self.allocs; yield Allocs; end
+end
+
+class Allocs
+  def self.report name, &block
+    allocs = nil
+
+    2.times do # 2 times to heat caches
+      allocs = 10.times.map {
+        x = GC.stat(:total_allocated_objects)
+        yield
+        GC.stat(:total_allocated_objects) - x
+      }.inject(:+) / 10
+    end
+
+    puts name.rjust(20) + allocs.to_s.rjust(10)
+  end
+end
+
+print "#" * 30
+print " ALLOCATIONS "
+puts "#" * 30
+
+Benchmark.allocs do |x|
+  x.report "kitchen-sink" do
+    TinyGQL.parse source
+  end
+
+  files.each do |file_name|
+    data = File.read file_name
+    name = File.basename(file_name, File.extname(file_name))
+    x.report name do
+      TinyGQL.parse data
+    end
+  end
+end

data/lib/tinygql/lexer.rb

@@ -16,27 +16,29 @@ module TinyGQL
     FLOAT_EXP =     /[eE][+-]?[0-9]+/
     NUMERIC =  /#{INT}(#{FLOAT_DECIMAL}#{FLOAT_EXP}|#{FLOAT_DECIMAL}|#{FLOAT_EXP})?/
 
-    KEYWORDS = {
-      "on" => :ON,
-      "fragment" => :FRAGMENT,
-      "true" => :TRUE,
-      "false" => :FALSE,
-      "null" => :NULL,
-      "query" => :QUERY,
-      "mutation" => :MUTATION,
-      "subscription" => :SUBSCRIPTION,
-      "schema" => :SCHEMA,
-      "scalar" => :SCALAR,
-      "type" => :TYPE,
-      "extend" => :EXTEND,
-      "implements" => :IMPLEMENTS,
-      "interface" => :INTERFACE,
-      "union" => :UNION,
-      "enum" => :ENUM,
-      "input" => :INPUT,
-      "directive" => :DIRECTIVE,
-      "repeatable" => :REPEATABLE
-    }.freeze
+    KEYWORDS = [
+      "on",
+      "fragment",
+      "true",
+      "false",
+      "null",
+      "query",
+      "mutation",
+      "subscription",
+      "schema",
+      "scalar",
+      "type",
+      "extend",
+      "implements",
+      "interface",
+      "union",
+      "enum",
+      "input",
+      "directive",
+      "repeatable"
+    ].freeze
+
+    KW_RE = /#{Regexp.union(KEYWORDS.sort)}\b/
 
     module Literals
       LCURLY =        '{'
@@ -48,13 +50,14 @@ module TinyGQL
       COLON =         ':'
       VAR_SIGN =      '$'
       DIR_SIGN =      '@'
-      ELLIPSIS =      '...'
       EQUALS =        '='
       BANG =          '!'
       PIPE =          '|'
       AMP =           '&'
     end
 
+    ELLIPSIS =      '...'
+
     include Literals
 
     QUOTE =         '"'
@@ -68,8 +71,8 @@ module TinyGQL
     ESCAPED_QUOTE = /\\"/;
     STRING_CHAR = /#{ESCAPED_QUOTE}|[^"\\]|#{UNICODE_ESCAPE}|#{STRING_ESCAPE}/
 
-    LIT_NAME_LUT = Literals.constants.each_with_object({}) { |n, o|
-      o[Literals.const_get(n)] = n
+    LIT_NAME_LUT = Literals.constants.each_with_object([]) { |n, o|
+      o[Literals.const_get(n).ord] = n
     }
 
     LIT = Regexp.union(Literals.constants.map { |n| Literals.const_get(n) })
@@ -90,9 +93,12 @@ module TinyGQL
     def initialize string
       raise unless string.valid_encoding?
 
+      @string = string
       @scan = StringScanner.new string
-      @token_name = nil
-      @token_value = nil
+    end
+
+    def pos
+      @scan.pos
     end
 
     def line
@@ -103,31 +109,97 @@ module TinyGQL
       @scan.eos?
     end
 
+    KW_LUT = [:FRAGMENT,
+              :INTERFACE,
+              :MUTATION,
+              :EXTEND,
+              :FALSE,
+              :ENUM,
+              :TRUE,
+              :NULL,
+              nil,
+              nil,
+              nil,
+              nil,
+              nil,
+              nil,
+              :QUERY,
+              nil,
+              nil,
+              nil,
+              :REPEATABLE,
+              :IMPLEMENTS,
+              :INPUT,
+              :TYPE,
+              :SCHEMA,
+              nil,
+              nil,
+              nil,
+              :DIRECTIVE,
+              :UNION,
+              nil,
+              nil,
+              :SCALAR]
+
     def advance
       @scan.skip(IGNORE)
 
       case
-      when str = @scan.scan(LIT)           then return emit(LIT_NAME_LUT[str], str)
-      when str = @scan.scan(IDENTIFIER)    then return emit(KEYWORDS.fetch(str, :IDENTIFIER), str)
-      when @scan.skip(BLOCK_STRING)        then return emit_block(@scan[1])
-      when @scan.skip(QUOTED_STRING)       then return emit_string(@scan[1])
-      when str = @scan.scan(NUMERIC)       then return emit(@scan[1] ? :FLOAT : :INT, str)
-      when @scan.eos?                      then emit(nil, nil) and return false
+      when @scan.eos?                      then false
+      when @scan.skip(ELLIPSIS)            then :ELLIPSIS
+      when tok = LIT_NAME_LUT[@string.getbyte(@scan.pos)] then
+        @scan.pos += 1
+        tok
+      when @scan.skip(KW_RE) then
+        len = @scan.matched_size
+        return :ON if len == 2
+        return :SUBSCRIPTION if len == 12
+
+        pos = @scan.pos - len
+
+        # First 3 bytes are unique, so we'll hash on those
+        key = (@string.getbyte(pos + 2) << 16) |
+          (@string.getbyte(pos + 1) << 8) |
+          @string.getbyte(pos + 0)
+
+        KW_LUT[hash(key)]
+      when @scan.skip(IDENTIFIER)    then :IDENTIFIER
+      when @scan.skip(BLOCK_STRING)  then :STRING
+      when @scan.skip(QUOTED_STRING) then :STRING
+      when @scan.skip(NUMERIC) then (@scan[1] ? :FLOAT : :INT)
       else
-        emit(:UNKNOWN_CHAR, @scan.getch)
+        @scan.getch
+        :UNKNOWN_CHAR
       end
     end
 
-    attr_reader :token_name, :token_value
+    def token_value
+      @string.byteslice(@scan.pos - @scan.matched_size, @scan.matched_size)
+    end
 
-    def emit token_name, token_value
-      @token_name = token_name
-      @token_value = token_value
-      true
+    def string_value
+      str = token_value
+      block = str.start_with?('"""')
+      str.gsub!(/\A"*|"*\z/, '')
+
+      if block
+        emit_block str
+      else
+        emit_string str
+      end
     end
 
     def next_token
-      advance && [@token_name, @token_value]
+      return unless tok = advance
+      val = case tok
+      when :STRING then string_value
+      when *Literals.constants
+        @string.byteslice(@scan.pos - 1, 1)
+      else
+        token_value
+      end
+
+      [tok, val]
     end
 
     # Replace any escaped unicode or whitespace with the _actual_ characters
@@ -184,7 +256,7 @@ module TinyGQL
         if !value.valid_encoding?
           emit(:BAD_UNICODE_ESCAPE, value)
         else
-          emit(:STRING, value)
+          value
         end
       end
     end
@@ -242,5 +314,11 @@ module TinyGQL
       # Rebuild the string
       lines.size > 1 ? lines.join("\n") : (lines.first || "".dup)
     end
+
+    def hash key
+      # Constant came from perfect hash generation
+      m = key * 145291
+      (m >> 28) & 0x1f
+    end
   end
 end