luoma 0.1.0

data/lib/luoma/filters/sort.rb

@@ -0,0 +1,113 @@
+# frozen_string_literal: true
+
+module Luoma
+  module Filters
+    INFINITY_ARRAY = [Float::INFINITY].freeze # : [Float]
+
+    # Return a sorted array of items from _left_. If _left_ contains
+    # incomparable items, return _left_ as an array with its original
+    # ordering.
+    #
+    # Coerce _left_ to an array if it's not one already.
+    def self.sort(context, left, key = nil)
+      left = context.to_a(left)
+
+      # @type var sort_: ^(Array[untyped]) ?{ (untyped, Integer) -> untyped } -> Array[untyped]
+      sort_ = lambda do |array, &key|
+        decorated = array.each_with_index.map do |item, index|
+          [item, key ? key.call(item, index) : item]
+        end
+
+        begin
+          decorated.sort! do |(_, a), (_, b)|
+            cmp = context.cmp(a, b)
+
+            case cmp
+            when nil
+              if a.nil? || context.nothing?(a)
+                1
+              elsif b.nil? || context.nothing?(b)
+                -1
+              else
+                raise IncomparableValuesError
+              end
+            else
+              cmp
+            end
+          end
+        rescue IncomparableValuesError
+          raise LuomaError.new("Cannot sort incomparable values") if context.render_context.env.strict
+
+          return array # rubocop:disable Lint/NoReturnInBeginEndBlocks
+        end
+
+        decorated.map!(&:first)
+      end
+
+      if key.nil? || context.nothing?(key)
+        sort_.call(left)
+      elsif key.is_a?(ExpressionDrop)
+        sort_.call(left) { |item, index| key.expr.call_with_index(item, index) }
+      else
+        key = context.to_string(key)
+        sort_.call(left) { |item, _index| context.fetch(item, key) }
+      end
+    end
+
+    def self.sort_natural(context, left, key = :nothing)
+      left = context.to_enumerable(left)
+
+      if key.nil? || context.nothing?(key)
+        left.sort { |a, b| nil_safe_casecmp(a, b) }
+      elsif key.is_a?(ExpressionDrop)
+        key.expr.broadcast_with_index(left).zip(left).sort do |a, b|
+          nil_safe_casecmp(a.first, b.first)
+        end.map(&:last)
+      else
+        key = context.to_string(key)
+        left.sort { |a, b| nil_safe_casecmp(context.fetch(a, key), context.fetch(b, key)) }
+      end
+    end
+
+    def self.sort_numeric(context, left, key = :nothing)
+      left = context.to_enumerable(left)
+
+      if key.nil? || context.nothing?(key)
+        left.sort { |a, b| numeric_compare(a, b, context) }
+      elsif key.is_a?(ExpressionDrop)
+        key.expr.broadcast_with_index(left).zip(left).sort do |a, b|
+          numeric_compare(a.first, b.first, context)
+        end.map(&:last)
+      else
+        key = context.to_string(key)
+        left.sort { |a, b| numeric_compare(context.fetch(a, key), context.fetch(b, key), context) }
+      end
+    end
+
+    def self.nil_safe_casecmp(left, right)
+      if !left.nil? && !right.nil?
+        left.to_s.casecmp(right.to_s)
+      elsif left.nil? && right.nil?
+        0
+      else
+        left.nil? ? 1 : -1
+      end
+    end
+
+    def self.numeric_compare(left, right, context)
+      res = ints(left, context) <=> ints(right, context)
+      res || -1
+    end
+
+    def self.ints(obj, context)
+      if obj.is_a?(Integer) || obj.is_a?(Float) || obj.is_a?(BigDecimal)
+        [obj]
+      else
+        numeric = context.to_string(obj).scan(/(?<=\.)0+|-?\d+/)
+        return INFINITY_ARRAY if numeric.nil? || numeric.empty?
+
+        numeric.map(&:to_i) # steep:ignore
+      end
+    end
+  end
+end

data/lib/luoma/filters/string.rb

@@ -0,0 +1,186 @@
+# frozen_string_literal: true
+
+require "cgi/escape"
+
+module Luoma
+  module Filters
+    # Return _left_ concatenated with _right_.
+    # Coerce _left_ and _right_ to strings if they aren't strings already.
+    def self.append(context, left, right)
+      context.to_string(left) + context.to_string(right)
+    end
+
+    # Return _left_ with the first character in uppercase and the rest lowercase.
+    # Coerce _left_ to a string if it is not one already.
+    def self.capitalize(context, left)
+      context.to_string(left).capitalize
+    end
+
+    # Return _left_ with all characters converted to lowercase.
+    # Coerce _left_ to a string if it is not one already.
+    def self.downcase(context, left)
+      context.to_string(left).downcase
+    end
+
+    # Return _left_ with all characters converted to uppercase.
+    # Coerce _left_ to a string if it is not one already.
+    def self.upcase(context, left)
+      context.to_string(left).upcase
+    end
+
+    # Return _left_ with special HTML characters replaced with their HTML-safe escape sequences.
+    # Coerce _left_ to a string if it is not one already.
+    def self.escape(context, left)
+      CGI.escape_html(context.to_string(left)) unless left.nil?
+    end
+
+    # Return _left_ with special HTML characters replaced with their HTML-safe escape sequences.
+    # Coerce _left_ to a string if it is not one already.
+    #
+    # It is safe to use `escape_once` on string values that already contain HTML-escape sequences.
+    def self.escape_once(context, left)
+      CGI.escape_html(CGI.unescape_html(context.to_string(left)))
+    end
+
+    # Return _left_ with leading whitespace removed.
+    # Coerce _left_ to a string if it is not one already.
+    def self.lstrip(context, left)
+      context.to_string(left).lstrip
+    end
+
+    # Return _left_ with trailing whitespace removed.
+    # Coerce _left_ to a string if it is not one already.
+    def self.rstrip(context, left)
+      context.to_string(left).rstrip
+    end
+
+    # Return _left_ with leading and trailing whitespace removed.
+    # Coerce _left_ to a string if it is not one already.
+    def self.strip(context, left)
+      context.to_string(left).strip
+    end
+
+    # Return _left_ with LF or CRLF replaced with `<br />\n`.
+    def self.newline_to_br(context, left)
+      context.to_string(left).gsub(/\r?\n/, "<br />\n")
+    end
+
+    # Return _right_ concatenated with _left_.
+    # Coerce _left_ and _right_ to strings if they aren't strings already.
+    def self.prepend_(context, left, right)
+      context.to_string(right) + context.to_string(left)
+    end
+
+    # Return _left_ with all occurrences of _pattern_ replaced with _replacement_.
+    # All arguments are coerced to strings if they aren't strings already.
+    def self.replace(context, left, pattern, replacement = "")
+      context.to_string(left).gsub(context.to_string(pattern), context.to_string(replacement))
+    end
+
+    # Return _left_ with the first occurrence of _pattern_ replaced with _replacement_.
+    # All arguments are coerced to strings if they aren't strings already.
+    def self.replace_first(context, left, pattern, replacement = "")
+      context.to_string(left).sub(context.to_string(pattern), context.to_string(replacement))
+    end
+
+    # Return _left_ with the last occurrence of _pattern_ replaced with _replacement_.
+    # All arguments are coerced to strings if they aren't strings already.
+    def self.replace_last(context, left, pattern, replacement)
+      return left + replacement if context.nothing?(pattern)
+
+      head, match, tail = context.to_string(left).rpartition(context.to_string(pattern))
+      return left if match.empty?
+
+      head + context.to_string(replacement) + tail
+    end
+
+    # Return _left_ with all occurrences of _pattern_ removed.
+    # All arguments are coerced to strings if they aren't strings already.
+    def self.remove(context, left, pattern)
+      context.to_string(left).gsub(context.to_string(pattern), context.to_string(""))
+    end
+
+    # Return _left_ with the first occurrence of _pattern_ removed.
+    # All arguments are coerced to strings if they aren't strings already.
+    def self.remove_first(context, left, pattern)
+      context.to_string(left).sub(context.to_string(pattern), context.to_string(""))
+    end
+
+    # Return _left_ with the last occurrence of _pattern_ removed.
+    # All arguments are coerced to strings if they aren't strings already.
+    def self.remove_last(context, left, pattern)
+      return left if context.nothing?(pattern)
+
+      head, match, tail = context.to_string(left).rpartition(context.to_string(pattern))
+      return left if match.empty?
+
+      head + tail
+    end
+
+    # Split _left_ on every occurrence of _pattern_.
+    def self.split(context, left, pattern)
+      context.to_string(left).split(context.to_string(pattern))
+    end
+
+    RE_HTML_BLOCKS = Regexp.union(
+      %r{<script.*?</script>}m,
+      /<!--.*?-->/m,
+      %r{<style.*?</style>}m
+    )
+
+    RE_HTML_TAGS = /<.*?>/m
+
+    # Return _left_ with HTML tags removed.
+    def self.strip_html(context, left)
+      context.to_string(left).gsub(RE_HTML_BLOCKS, "").gsub(RE_HTML_TAGS, "")
+    end
+
+    # Return _left_ with CR and LF removed.
+    def self.strip_newlines(context, left)
+      context.to_string(left).gsub(/\r?\n/, "")
+    end
+
+    def self.truncate(context, left, max_length = 50, ellipsis = "...")
+      return if left.nil? || context.nothing?(left)
+
+      left = context.to_string(left)
+      max_length = context.to_i(max_length)
+      return left if left.length <= max_length
+
+      ellipsis = context.to_string(ellipsis)
+      return ellipsis[0, max_length] if ellipsis.length >= max_length
+
+      "#{left[0...(max_length - ellipsis.length)]}#{ellipsis}"
+    end
+
+    def self.truncatewords(context, left, max_words = 15, ellipsis = "...")
+      return if left.nil? || context.nothing?(left)
+
+      left = context.to_string(left)
+      max_words = context.to_i(max_words).clamp(1, 10_000)
+      words = left.split(" ", max_words + 1)
+      return left if words.length <= max_words
+
+      ellipsis = context.to_string(ellipsis)
+      words.pop
+      "#{words.join(" ")}#{ellipsis}"
+    end
+
+    def self.url_encode(context, left)
+      CGI.escape(context.to_string(left)) unless left.nil? || context.nothing?(left)
+    end
+
+    def self.url_decode(context, left)
+      return if left.nil? || context.nothing?(left)
+
+      decoded = CGI.unescape(context.to_string(left))
+      raise context.argument_error("invalid byte sequence") unless decoded.valid_encoding?
+
+      decoded
+    end
+
+    def self.squish(context, left)
+      context.to_string(left).strip.gsub(/\s+/, " ") unless left.nil?
+    end
+  end
+end

data/lib/luoma/fnv.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Luoma
+  def self.fnv1a32(s)
+    hash = 0x811c9dc5 # offset basis for 32 bit hash
+
+    s.bytes do |b|
+      hash ^= b
+      hash *= 0x01000193 # FNV prime for 32 bit hash
+      hash &= (1 << 32) - 1
+    end
+
+    hash
+  end
+end

data/lib/luoma/lexer.rb

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+require "strscan"
+
+module Luoma
+  # The base class for template source code tokenizers.
+  class BaseLexer
+    attr_reader :tokens
+
+    #: (Environment, String) -> Array[t_token]
+    def self.tokenize(env, source)
+      lexer = new(env, source)
+      lexer.go
+      lexer.tokens
+    end
+
+    #: (Environment, String) -> void
+    def initialize(env, source)
+      @env = env
+      @source = source
+      @scanner = StringScanner.new(source)
+      @start = 0
+      @tokens = [] #: Array[t_token]
+    end
+
+    #: () -> void
+    def go
+      state = :scan_markup
+      state = send(state) until state.nil?
+    end
+
+    protected
+
+    # Scanner entry point. If a symbol is returned it should match the name of
+    # a method implementing the next state. A return value of `nil` means we
+    # should stop scanning.
+    #: () -> Symbol?
+    def scan_markup
+      raise "not implemented"
+    end
+
+    # Emit a token of `kind` spanning @start to @scanner.pos.
+    #: (t_token_kind) -> void
+    def emit(kind)
+      # @tokens << { kind: kind, start: @start, stop: @scanner.pos - 1 }
+      @tokens << [kind, @start, @scanner.pos - 1]
+      @start = @scanner.pos
+    end
+
+    # Return the start index of the next match of `pattern` without advancing
+    # the scanner.
+    #
+    # It's faster to use `@scanner.string.byteindex(s, @scanner.pos)` if you
+    # are searching for a string literal instead of a pattern.
+    #
+    #: (Regexp) -> Integer?
+    def index(pattern)
+      byte_offset = @scanner.exist?(pattern)
+      return nil unless byte_offset
+
+      @scanner.pos + byte_offset - (@scanner.matched_size || raise)
+    end
+
+    #: (Regexp) -> String?
+    def scan(pattern)
+      # NOTE: calling @scanner.scan directly yields a significant increase in
+      # performance
+      @scanner.scan(pattern)
+    end
+
+    # Scan up to but not including `pattern`.
+    #: (Regexp) -> bool
+    def scan_until?(pattern)
+      byte_offset = @scanner.exist?(pattern)
+      if byte_offset.nil?
+        false
+      else
+        @scanner.pos += byte_offset - (@scanner.matched_size || raise)
+        true
+      end
+    end
+
+    #: (Regexp) -> bool
+    def skip?(pattern)
+      if @scanner.scan(pattern)
+        @start = @scanner.pos
+        true
+      else
+        false
+      end
+    end
+
+    # Skip up to but not including `pattern`.
+    #: (Regexp) -> bool
+    def skip_until?(pattern)
+      byte_offset = @scanner.exist?(pattern)
+      if byte_offset.nil?
+        false
+      else
+        @scanner.pos += byte_offset - (@scanner.matched_size || raise)
+        @start = @scanner.pos
+        true
+      end
+    end
+  end
+end