liquid2 0.1.0

data/lib/liquid2/utils/chain_hash.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Liquid2
+  # Combine multiple hashes for sequential lookup.
+  class ReadOnlyChainHash
+    # @param hashes
+    def initialize(*hashes)
+      @hashes = hashes.to_a
+    end
+
+    def [](key)
+      index = @hashes.length - 1
+      while index >= 0
+        h = @hashes[index]
+        index -= 1
+        return h[key] if h.key?(key)
+      end
+    end
+
+    def key?(key)
+      !@hashes.rindex { |h| h.key?(key) }.nil?
+    end
+
+    def fetch(key, default = :undefined)
+      index = @hashes.length - 1
+      while index >= 0
+        h = @hashes[index]
+        index -= 1
+        return h[key] if h.key?(key)
+      end
+
+      default
+    end
+
+    def size = @hashes.length
+    def push(hash) = @hashes << hash
+    alias << push
+    def pop = @hashes.pop
+  end
+end

data/lib/liquid2/utils/unescape.rb

@@ -0,0 +1,119 @@
+# frozen_string_literal: true
+
+module Liquid2 # :nodoc:
+  # Replace escape sequences with their equivalent Unicode code point.
+  # This is a bit like Ruby's String#undump, but assumes surrounding quotes have been removed
+  # and follows JSON escaping semantics.
+  # @param value [String]
+  # @param quote [String] one of '"' or "'".
+  # @param token [Token]
+  # @return [String] A new string without escape sequences.
+  def self.unescape_string(value, quote, token)
+    unescaped = String.new(encoding: "UTF-8")
+    index = 0
+    length = value.length
+
+    while index < length
+      ch = value[index] || raise
+      if ch == "\\"
+        index += 1
+        case value[index]
+        when quote
+          unescaped << quote
+        when "\\"
+          unescaped << "\\"
+        when "/"
+          unescaped << "/"
+        when "b"
+          unescaped << "\x08"
+        when "f"
+          unescaped << "\x0C"
+        when "n"
+          unescaped << "\n"
+        when "r"
+          unescaped << "\r"
+        when "t"
+          unescaped << "\t"
+        when "u"
+          code_point, index = Liquid2.decode_hex_char(value, index, token)
+          unescaped << Liquid2.code_point_to_string(code_point, token)
+        when "$"
+          unescaped << "$"
+        else
+          raise LiquidSyntaxError.new("unknown escape sequence", token)
+        end
+      else
+        # raise LiquidSyntaxError.new("invalid character #{ch.inspect}", token) if ch.ord <= 0x1F
+
+        unescaped << ch
+      end
+
+      index += 1
+
+    end
+
+    unescaped
+  end
+
+  def self.decode_hex_char(value, index, token)
+    length = value.length
+
+    raise LiquidSyntaxError.new("incomplete escape sequence", token) if index + 4 >= length
+
+    index += 1 # move past 'u'
+    code_point = parse_hex_digits(value[index, 4] || raise, token)
+
+    raise LiquidSyntaxError.new("unexpected low surrogate", token) if low_surrogate?(code_point)
+
+    return [code_point, index + 3] unless high_surrogate?(code_point)
+
+    unless index + 9 < length && value[index + 4] == "\\" && value[index + 5] == "u"
+      raise LiquidSyntaxError.new("incomplete escape sequence", token)
+    end
+
+    low_surrogate = parse_hex_digits(value[index + 6, 10] || raise, token)
+
+    unless low_surrogate?(low_surrogate)
+      raise LiquidSyntaxError.new("unexpected low surrogate",
+                                  token)
+    end
+
+    code_point = 0x10000 + (
+      ((code_point & 0x03FF) << 10) | (low_surrogate & 0x03FF)
+    )
+
+    [code_point, index + 9]
+  end
+
+  def self.parse_hex_digits(digits, token)
+    code_point = 0
+    digits.each_byte do |b|
+      code_point <<= 4
+      case b
+      when 48..57
+        code_point |= b - 48
+      when 65..70
+        code_point |= b - 65 + 10
+      when 97..102
+        code_point |= b - 97 + 10
+      else
+        raise LiquidSyntaxError.new("invalid escape sequence", token)
+      end
+    end
+    code_point
+  end
+
+  def self.high_surrogate?(code_point)
+    code_point.between?(0xD800, 0xDBFF)
+  end
+
+  def self.low_surrogate?(code_point)
+    code_point.between?(0xDC00, 0xDFFF)
+  end
+
+  def self.code_point_to_string(code_point, token)
+    raise LiquidSyntaxError.new("invalid character", token) if code_point <= 8
+
+    code_point.chr(Encoding::UTF_8)
+  end
+end

data/lib/liquid2/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Liquid2
+  VERSION = "0.1.0"
+end

data/lib/liquid2.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+require "json"
+require_relative "liquid2/environment"
+require_relative "liquid2/context"
+require_relative "liquid2/filter"
+require_relative "liquid2/scanner"
+require_relative "liquid2/loader"
+require_relative "liquid2/parser"
+require_relative "liquid2/version"
+require_relative "liquid2/undefined"
+require_relative "liquid2/utils/chain_hash"
+require_relative "liquid2/utils/unescape"
+require_relative "liquid2/static_analysis"
+require_relative "liquid2/loaders/file_system_loader"
+
+# Liquid template engine.
+module Liquid2
+  DEFAULT_ENVIRONMENT = Environment.new
+
+  # Parse _source_ text as a template using the default Liquid environment.
+  # @param source [String]
+  # @param data [?Hash[String, untyped]?]
+  # @return [Template]
+  def self.parse(source, globals: nil)
+    DEFAULT_ENVIRONMENT.parse(source, globals: globals)
+  end
+
+  # Parse and render template _source_ with _data_ as template variables and
+  # the default Liquid environment.
+  # @param source [String]
+  # @param data [?Hash[String, untyped]?]
+  # @return [String]
+  def self.render(source, data = nil)
+    DEFAULT_ENVIRONMENT.render(source, data)
+  end
+
+  # Stringify an object. Use this anywhere a string is expected, like in a filter.
+  def self.to_liquid_string(obj)
+    case obj
+    when Hash, Array
+      JSON.generate(obj)
+    else
+      obj.to_s
+    end
+  end
+
+  # Stringify an object for output. Use this when writing directly to an output buffer.
+  def self.to_output_string(obj)
+    case obj
+    when Array
+      # Concatenate string representations of array elements.
+      obj.map do |item|
+        Liquid2.to_s(item)
+      end.join
+    when BigDecimal
+      # TODO: test capture
+      # TODO: are there any scenarios where we need to cast to_f before output?
+      obj.to_f.to_s
+    else
+      Liquid2.to_s(obj)
+    end
+  end
+
+  def self.to_liquid_int(obj, default: 0)
+    Float(obj).to_i
+  rescue ArgumentError, TypeError
+    default
+  end
+
+  # Return `true` if _obj_ is Liquid truthy.
+  # @param context [RenderContext]
+  # @param obj [Object]
+  # @return [bool]
+  def self.truthy?(context, obj)
+    obj = obj.to_liquid(context) if obj.respond_to?(:to_liquid)
+    !!obj
+  end
+
+  # Return `true` if _obj_ is undefined.
+  def self.undefined?(obj)
+    obj.is_a?(Undefined)
+  end
+
+  class << self
+    alias to_s to_liquid_string
+    alias to_output_s to_output_string
+    alias to_i to_liquid_int
+  end
+end

data/performance/benchmark.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+require "benchmark/ips"
+require "json"
+require "optparse"
+require "pathname"
+require "liquid2"
+
+# A benchmark fixture
+class Fixture
+  attr_reader :templates, :data, :name
+
+  # @param path [Pathname]
+  def initialize(path)
+    @root = path
+    @name = @root.basename.to_s
+    # rubocop:disable Style/StringConcatenation
+    @data = JSON.parse((@root + "data.json").read)
+    @templates = (@root + "templates").glob("*liquid").to_h { |p| [p.basename.to_s, p.read] }
+    # rubocop:enable Style/StringConcatenation
+  end
+
+  def env
+    Liquid2::Environment.new(loader: Liquid2::HashLoader.new(@templates), globals: @data)
+  end
+end
+
+options = {
+  fixture: "002"
+}
+
+OptionParser.new do |parser|
+  parser.banner = <<~BANNER
+    Run one of the benchmarks in ./tests/cts/benchmark_fixtures.
+    Example: ruby benchmark.rb -f 002
+  BANNER
+
+  parser.on("-f FIXTURE", "--fixture FIXTURE",
+            "The name of the benchmark fixture to run. Defaults to '002'.") do |value|
+    options[:fixture] = value
+  end
+
+  parser.parse!
+end
+
+fixture = Fixture.new(Pathname.new("test/golden_liquid/benchmark_fixtures") + options[:fixture])
+env = fixture.env
+source = fixture.templates["index.liquid"]
+template = env.get_template("index.liquid")
+
+# scanner = StringScanner.new("")
+
+Benchmark.ips do |x|
+  # Configure the number of seconds used during
+  # the warmup phase (default 2) and calculation phase (default 5)
+  x.config(warmup: 2, time: 5)
+
+  # x.report("tokenize (#{fixture.name}):") do
+  #   Liquid2::Scanner.tokenize(source, scanner)
+  # end
+
+  x.report("parse (#{fixture.name}):") do
+    env.parse(source)
+  end
+
+  x.report("render (#{fixture.name}):") do
+    template.render
+  end
+
+  x.report("both (#{fixture.name}):") do
+    env.parse(source).render
+  end
+end

data/performance/memory_profile.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+require "memory_profiler"
+require "json"
+require "optparse"
+require "pathname"
+require "liquid2"
+
+# A benchmark fixture
+class Fixture
+  attr_reader :templates, :data
+
+  # @param path [Pathname]
+  def initialize(path)
+    @root = path
+    @name = @root.basename.to_s
+    # rubocop:disable Style/StringConcatenation
+    @data = JSON.parse((@root + "data.json").read)
+    @templates = (@root + "templates").glob("*liquid").to_h { |p| [p.basename.to_s, p.read] }
+    # rubocop:enable Style/StringConcatenation
+  end
+
+  def env
+    Liquid2::Environment.new(loader: Liquid2::HashLoader.new(@templates), globals: @data)
+  end
+end
+
+# TODO: add an option to profile parsing or rendering of Liquid templates
+
+options = {
+  fixture: "002"
+}
+
+OptionParser.new do |parser|
+  parser.banner = <<~BANNER
+    Run one of the benchmarks in ./tests/cts/benchmark_fixtures.
+    Example: ruby benchmark.rb -f 002
+  BANNER
+
+  parser.on("-f FIXTURE", "--fixture FIXTURE",
+            "The name of the benchmark fixture to run. Defaults to '002'.") do |value|
+    options[:fixture] = value
+  end
+
+  parser.parse!
+end
+
+fixture = Fixture.new(Pathname.new("test/golden_liquid/benchmark_fixtures") + options[:fixture])
+env = fixture.env
+# source = fixture.templates["index.liquid"]
+template = env.get_template("index.liquid")
+
+n = 1000
+
+report = MemoryProfiler.report do
+  n.times do
+    template.render
+    # Liquid2.tokenize(source)
+  end
+end
+
+report.pretty_print

data/performance/profile.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+require "stackprof"
+require "optparse"
+require "pathname"
+require "json"
+require "liquid2"
+
+# A benchmark fixture
+class Fixture
+  attr_reader :templates, :data
+
+  # @param path [Pathname]
+  def initialize(path)
+    @root = path
+    @name = @root.basename.to_s
+    # rubocop:disable Style/StringConcatenation
+    @data = JSON.parse((@root + "data.json").read)
+    @templates = (@root + "templates").glob("*liquid").to_h { |p| [p.basename.to_s, p.read] }
+    # rubocop:enable Style/StringConcatenation
+  end
+
+  def env
+    Liquid2::Environment.new(loader: Liquid2::HashLoader.new(@templates), globals: @data)
+  end
+end
+
+options = {
+  fixture: "002"
+}
+
+OptionParser.new do |parser|
+  parser.banner = <<~BANNER
+    Run one of the benchmarks in ./tests/cts/benchmark_fixtures.
+    Example: ruby benchmark.rb -f 002
+  BANNER
+
+  parser.on("-f FIXTURE", "--fixture FIXTURE",
+            "The name of the benchmark fixture to run. Defaults to '002'.") do |value|
+    options[:fixture] = value
+  end
+
+  parser.parse!
+end
+
+fixture = Fixture.new(Pathname.new("test/golden_liquid/benchmark_fixtures") + options[:fixture])
+env = fixture.env
+source = fixture.templates["index.liquid"]
+template = env.get_template("index.liquid")
+
+n = 1000
+
+scanner = StringScanner.new("")
+
+StackProf.run(mode: :cpu, raw: true, out: ".stackprof-cpu-scan.dump") do
+  n.times do
+    Liquid2::Scanner.tokenize(source, scanner)
+  end
+end
+
+StackProf.run(mode: :cpu, raw: true, out: ".stackprof-cpu-parse.dump") do
+  n.times do
+    env.parse(source)
+  end
+end
+
+StackProf.run(mode: :cpu, raw: true, out: ".stackprof-cpu-render.dump") do
+  n.times do
+    template.render
+  end
+end