tinygql 0.1.4 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ef7a07443c070f78f1ad6324890611e1ea70298c7d67eac591911c208b42aa0f
-  data.tar.gz: 3311b13953c075059a737b46f82f50aa3fd2428d844499c64354a285aa2774cd
+  metadata.gz: e6f2ac9d1c4531277689c6eec21fd29cd1e6fe9715284813b57c741e3e9bace2
+  data.tar.gz: b9cd18ac29f1aeea347296f0408deadddec7a902d25495e3232b472180718695
 SHA512:
-  metadata.gz: 814659e285e05236a4861931cf548eabab4abeaccdbc5b959adc12e3a3e6f6b9a67ea5626117ae44f46a9316c8d3210adafbf269730aec23b8c9d5ac0a538832
-  data.tar.gz: 3603440c4c6aa2aed7c361439299b8218b2f01a2c5ea96ed100da5028ac6fe391d62322a4431124861db7de50c60c69fd50d3da92178c12ef04dd58fbe63e2d3
+  metadata.gz: 63c931df357b6091070a7cd0adab859f7a7489f8fa1220ffa2cfb7fc6a7af6660ede87af6c3a8b804ef1a2114594aa3086a3792b5d3ef40e20ac1a4546d13120
+  data.tar.gz: 96e0a9164e835cb382391c9ea761cdf2405ac6f38e268034f810f8ce369d4e968ec5a2c174f22f03f50a99bd1f155449e5d9e7b46c65fc771263cbc03a8f2f8b

data/README.md

@@ -66,6 +66,29 @@ ast = TinyGQL.parse "{ neat { cool } }"
 p ast.fold(Fold, []) # => ["neat", "cool"]
 ```
 
+Nodes store their position in the source GraphQL document.
+If you'd like to extract the line number of the node, you'll need to keep a reference to the document and pass it to the `line` method on the node:
+
+```ruby
+doc = <<-eod
+mutation {
+  likeStory(sturyID: 12345) {
+    story {
+      likeCount
+    }
+  }
+}
+
+eod
+
+parser = TinyGQL::Parser.new doc
+ast = parser.parse
+
+ast.find_all(&:field?).each { |node|
+  p node.name => node.line(doc)
+}
+```
+
 ## LICENSE:
 
 I've licensed this code as Apache 2.0, but the lexer is from [GraphQL-Ruby](https://github.com/rmosolgo/graphql-ruby/blob/772734dfcc7aa0513c867259912474ef0ba799c3/lib/graphql/language/lexer.rb) and is under the MIT license.

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/bin/make_hash.rb

@@ -0,0 +1,51 @@
+require "tinygql"
+
+# Calculate a perfect hash for GraphQL keywords
+
+def bits x
+  count = 0
+  while x > 0
+    count += 1
+    x >>= 1
+  end
+  count
+end
+
+# on is too short, and subscription is the longest.
+# The lexer can easily detect them by length, so lets calculate a perfect
+# hash for the rest.
+kws = TinyGQL::Lexer::KEYWORDS - ["on", "subscription"]
+MASK = (1 << bits(kws.length)) - 1
+
+prefixes = kws.map { |word| word[1, 2] }
+
+# make sure they're unique
+raise "Not unique" unless prefixes.uniq == prefixes
+
+keys = prefixes.map { |prefix|
+  prefix.bytes.reverse.inject(0) { |c, byte|
+    c << 8 | byte
+  }
+}
+
+shift = 32 - bits(kws.length) # use the top bits
+
+c = 13
+loop do
+  z = keys.map { |k| ((k * c) >> shift) & MASK }
+  break if z.uniq.length == z.length
+  c += 1
+end
+
+table = kws.zip(keys).each_with_object([]) { |(word, k), o|
+  hash = ((k * c) >> shift) & MASK
+  o[hash] = word.upcase.to_sym
+}
+
+print "KW_LUT ="
+pp table
+puts <<-eomethod
+def hash key
+  (key * #{c}) >> #{shift} & #{sprintf("%#0x", MASK)}
+end
+eomethod

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,12 +71,10 @@ 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) })
-
     QUOTED_STRING = %r{#{QUOTE} ((?:#{STRING_CHAR})*) #{QUOTE}}x
     BLOCK_STRING = %r{
         #{BLOCK_QUOTE}
@@ -90,11 +91,13 @@ module TinyGQL
     def initialize string
       raise unless string.valid_encoding?
 
+      @string = string
       @scan = StringScanner.new string
-      @token_name = nil
-      @token_value = nil
+      @start = nil
     end
 
+    attr_reader :start
+
     def line
       @scan.string[0, @scan.pos].count("\n") + 1
     end
@@ -106,28 +109,61 @@ module TinyGQL
     def advance
       @scan.skip(IGNORE)
 
+      @start = @scan.pos
+
       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(@start)] then
+        @scan.pos += 1
+        tok
+      when len = @scan.skip(KW_RE) then
+        return :ON if len == 2
+        return :SUBSCRIPTION if len == 12
+
+        pos = @start
+
+        # Second 2 bytes are unique, so we'll hash on those
+        key = (@string.getbyte(pos + 2) << 8) | @string.getbyte(pos + 1)
+
+        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 string_value
+      str = token_value
+      block = str.start_with?('"""')
+      str.gsub!(/\A"*|"*\z/, '')
 
-    def emit token_name, token_value
-      @token_name = token_name
-      @token_value = token_value
-      true
+      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 +220,7 @@ module TinyGQL
         if !value.valid_encoding?
           emit(:BAD_UNICODE_ESCAPE, value)
         else
-          emit(:STRING, value)
+          value
         end
       end
     end
@@ -242,5 +278,42 @@ module TinyGQL
       # Rebuild the string
       lines.size > 1 ? lines.join("\n") : (lines.first || "".dup)
     end
+
+    KW_LUT =[:INTERFACE,
+             :MUTATION,
+             :EXTEND,
+             :FALSE,
+             :ENUM,
+             :TRUE,
+             :NULL,
+             nil,
+             nil,
+             nil,
+             nil,
+             nil,
+             nil,
+             nil,
+             :QUERY,
+             nil,
+             nil,
+             :REPEATABLE,
+             :IMPLEMENTS,
+             :INPUT,
+             :TYPE,
+             :SCHEMA,
+             nil,
+             nil,
+             nil,
+             :DIRECTIVE,
+             :UNION,
+             nil,
+             nil,
+             :SCALAR,
+             nil,
+             :FRAGMENT]
+
+    def _hash key
+      (key * 18592990) >> 27 & 0x1f
+    end
   end
 end