liquid2 0.1.0

data/lib/liquid2/filters/string.rb

@@ -0,0 +1,204 @@
+# frozen_string_literal: true
+
+require "base64"
+require "cgi"
+
+module Liquid2
+  # Liquid filters and helper methods.
+  module Filters
+    # Return _left_ concatenated with _right_.
+    # Coerce _left_ and _right_ to strings if they aren't strings already.
+    def self.append(left, right)
+      Liquid2.to_s(left) + Liquid2.to_s(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(left)
+      Liquid2.to_s(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(left)
+      Liquid2.to_s(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(left)
+      Liquid2.to_s(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(left)
+      CGI.escape_html(Liquid2.to_s(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(left)
+      CGI.escape_html(CGI.unescape_html(Liquid2.to_s(left)))
+    end
+
+    # Return _left_ with leading whitespace removed.
+    # Coerce _left_ to a string if it is not one already.
+    def self.lstrip(left)
+      Liquid2.to_s(left).lstrip
+    end
+
+    # Return _left_ with trailing whitespace removed.
+    # Coerce _left_ to a string if it is not one already.
+    def self.rstrip(left)
+      Liquid2.to_s(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(left)
+      Liquid2.to_s(left).strip
+    end
+
+    # Return _left_ with LF or CRLF replaced with `<br />\n`.
+    def self.newline_to_br(left)
+      Liquid2.to_s(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(left, right)
+      Liquid2.to_s(right) + Liquid2.to_s(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(left, pattern, replacement = "")
+      Liquid2.to_s(left).gsub(Liquid2.to_s(pattern), Liquid2.to_s(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(left, pattern, replacement = "")
+      Liquid2.to_s(left).sub(Liquid2.to_s(pattern), Liquid2.to_s(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(left, pattern, replacement)
+      return left + replacement if Liquid2.undefined?(pattern)
+
+      head, match, tail = Liquid2.to_s(left).rpartition(Liquid2.to_s(pattern))
+      return left if match.empty?
+
+      head + Liquid2.to_s(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(left, pattern)
+      Liquid2.to_s(left).gsub(Liquid2.to_s(pattern), Liquid2.to_s(""))
+    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(left, pattern)
+      Liquid2.to_s(left).sub(Liquid2.to_s(pattern), Liquid2.to_s(""))
+    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(left, pattern)
+      return left if Liquid2.undefined?(pattern)
+
+      head, match, tail = Liquid2.to_s(left).rpartition(Liquid2.to_s(pattern))
+      return left if match.empty?
+
+      head + tail
+    end
+
+    # Split _left_ on every occurrence of _pattern_.
+    def self.split(left, pattern)
+      Liquid2.to_s(left).split(Liquid2.to_s(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(left)
+      Liquid2.to_s(left).gsub(RE_HTML_BLOCKS, "").gsub(RE_HTML_TAGS, "")
+    end
+
+    # Return _left_ with CR and LF removed.
+    def self.strip_newlines(left)
+      Liquid2.to_s(left).gsub(/\r?\n/, "")
+    end
+
+    def self.truncate(left, max_length = 50, ellipsis = "...")
+      return if left.nil? || Liquid2.undefined?(left)
+
+      left = Liquid2.to_s(left)
+      max_length = to_integer(max_length)
+      return left if left.length <= max_length
+
+      ellipsis = Liquid2.to_s(ellipsis)
+      return ellipsis[0, max_length] if ellipsis.length >= max_length
+
+      "#{left[0...max_length - ellipsis.length]}#{ellipsis}"
+    end
+
+    def self.truncatewords(left, max_words = 15, ellipsis = "...")
+      return if left.nil? || Liquid2.undefined?(left)
+
+      left = Liquid2.to_s(left)
+      max_words = to_integer(max_words).clamp(1, 10_000)
+      words = left.split(" ", max_words + 1)
+      return left if words.length <= max_words
+
+      ellipsis = Liquid2.to_s(ellipsis)
+      words.pop
+      "#{words.join(" ")}#{ellipsis}"
+    end
+
+    def self.url_encode(left)
+      CGI.escape(Liquid2.to_s(left)) unless left.nil? || Liquid2.undefined?(left)
+    end
+
+    def self.url_decode(left)
+      return if left.nil? || Liquid2.undefined?(left)
+
+      decoded = CGI.unescape(Liquid2.to_s(left))
+      unless decoded.valid_encoding?
+        raise Liquid2::LiquidArgumentError.new("invalid byte sequence", nil)
+      end
+
+      decoded
+    end
+
+    def self.base64_encode(left)
+      Base64.strict_encode64(Liquid2.to_s(left)).force_encoding(Encoding::UTF_8)
+    end
+
+    def self.base64_decode(left)
+      decoded = Base64.strict_decode64(Liquid2.to_s(left)).force_encoding(Encoding::UTF_8)
+      decoded if decoded.valid_encoding?
+    end
+
+    def self.base64_url_safe_encode(left)
+      Base64.urlsafe_encode64(Liquid2.to_s(left)).force_encoding(Encoding::UTF_8)
+    end
+
+    def self.base64_url_safe_decode(left)
+      decoded = Base64.urlsafe_decode64(Liquid2.to_s(left)).force_encoding(Encoding::UTF_8)
+      decoded if decoded.valid_encoding?
+    end
+  end
+end

data/lib/liquid2/loader.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+require "pathname"
+
+module Liquid2
+  # Liquid template source text and meta data.
+  class TemplateSource
+    attr_reader :source, :name, :up_to_date, :matter
+
+    def initialize(source:, name:, up_to_date: nil, matter: nil)
+      @source = source
+      @name = name
+      @up_to_date = up_to_date
+      @matter = matter
+    end
+  end
+
+  # The base class for all template loaders.
+  class TemplateLoader
+    # Load and return template source text and any associated data.
+    # @param env [Environment] The current Liquid environment.
+    # @param name [String] A name or identifier for the target template source text.
+    # @param context [RenderContext?] The current render context, if one is available.
+    # @param *kwargs Arbitrary arguments that can be used to narrow the template source
+    #   search space.
+    # @return [TemplateSource]
+    def get_source(env, name, context: nil, **kwargs) # rubocop:disable Lint/UnusedMethodArgument
+      raise "template loaders must implement `get_source`"
+    end
+
+    def load(env, name, globals: nil, context: nil, **kwargs)
+      data = get_source(env, name, context: context, **kwargs)
+      path = Pathname.new(data.name)
+      env.parse(data.source,
+                name: path.basename.to_s,
+                path: data.name,
+                globals: globals,
+                up_to_date: data.up_to_date,
+                overlay: data.matter)
+    end
+  end
+
+  # A template loader that reads templates from a hash.
+  class HashLoader < TemplateLoader
+    # @param templates [Hash<String, String>] A mapping of template names to template source text.
+    def initialize(templates)
+      super()
+      @templates = templates
+    end
+
+    def get_source(env, name, context: nil, **kwargs) # rubocop:disable Lint/UnusedMethodArgument
+      if (text = @templates[name])
+        TemplateSource.new(source: text, name: name)
+      else
+        raise LiquidTemplateNotFoundError.new("template not found #{name}", nil)
+      end
+    end
+  end
+end

data/lib/liquid2/loaders/file_system_loader.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+require "pathname"
+require_relative "../loader"
+require_relative "mixins"
+
+module Liquid2
+  # A template loader that reads template from a file system.
+  class FileSystemLoader < TemplateLoader
+    def initialize(search_path, default_extension: nil)
+      super()
+      @search_path = if search_path.is_a?(Array)
+                       search_path.map { |p| Pathname.new(p) }
+                     else
+                       [Pathname.new(search_path)]
+                     end
+
+      @default_extension = default_extension
+    end
+
+    def get_source(_env, name, context: nil, **_kwargs)
+      path = resolve_path(name)
+      mtime = path.mtime
+      up_to_date = -> { path.mtime == mtime }
+      TemplateSource.new(source: path.read, name: path.to_s, up_to_date: up_to_date)
+    end
+
+    def resolve_path(template_name)
+      template_path = Pathname.new(template_name)
+
+      # Append the default file extension if needed.
+      if @default_extension && template_path.extname.empty?
+        template_path = template_path.sub_ext(@default_extension || raise)
+      end
+
+      # Don't alow template names to escape the search path with "../".
+      template_path.each_filename do |part|
+        if part == ".."
+          raise LiquidTemplateNotFoundError.new("template not found #{template_name}",
+                                                nil)
+        end
+      end
+
+      # Search each path in turn.
+      @search_path.each do |path|
+        source_path = path.join(template_path)
+        return source_path if source_path.file?
+      end
+
+      raise LiquidTemplateNotFoundError.new("template not found #{template_name}", nil)
+    end
+  end
+
+  # A file system template loader that caches parsed templates.
+  class CachingFileSystemLoader < FileSystemLoader
+    include CachingLoaderMixin
+
+    def initialize(
+      search_path,
+      default_extension: nil,
+      auto_reload: true,
+      namespace_key: "",
+      capacity: 300,
+      thread_safe: false
+    )
+      super(search_path, default_extension: default_extension)
+
+      initialize_cache(
+        auto_reload: auto_reload,
+        namespace_key: namespace_key,
+        capacity: capacity,
+        thread_safe: thread_safe
+      )
+    end
+  end
+end

data/lib/liquid2/loaders/mixins.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require_relative "../utils/cache"
+
+module Liquid2
+  # A mixin that adds caching to a template loader.
+  module CachingLoaderMixin
+    def initialize_cache(auto_reload: true, namespace_key: "", capacity: 300, thread_safe: false)
+      @auto_reload = auto_reload
+      @namespace_key = namespace_key
+      @cache = if thread_safe
+                 ThreadSafeLRUCache.new(capacity)
+               else
+                 LRUCache.new(capacity)
+               end
+    end
+
+    def load(env, name, globals: nil, context: nil, **kwargs)
+      key = cache_key(name, context: context, **kwargs)
+
+      # @type var template: Liquid2::Template
+      # @type var cached_template: Liquid2::Template
+      if (cached_template = @cache[key])
+        if @auto_reload && cached_template.up_to_date? == false
+          template = super
+          @cache[key] = template
+          template
+        else
+          cached_template
+        end
+      else
+        template = super
+        @cache[key] = template
+        template
+      end
+    end
+
+    def cache_key(name, context: nil, **kwargs)
+      return name unless @namespace_key
+
+      key = (@namespace_key || raise).to_sym
+      return "#{kwargs[key]}/#{name}" if kwargs.include?(key)
+      return name unless context
+
+      if (namespace = context.globals[@namespace_key || raise])
+        "#{namespace}/#{name}"
+      else
+        name
+      end
+    end
+  end
+end

data/lib/liquid2/node.rb

@@ -0,0 +1,113 @@
+# frozen_string_literal: true
+
+module Liquid2
+  # The base class for all nodes in a Liquid syntax tree.
+  class Node
+    attr_reader :token
+    attr_accessor :blank
+
+    # @param token [[Symbol, String?, Integer]]
+    def initialize(token)
+      @token = token
+      @blank = true
+    end
+
+    def render(_context, _buffer)
+      raise "nodes must implement `render: (RenderContext, String) -> void`"
+    end
+
+    def render_with_disabled_tag_check(context, buffer)
+      if context.disabled_tags.empty? ||
+         !is_a?(Tag) ||
+         !context.disabled_tags.include?(@token[1] || raise)
+        return render(context, buffer)
+      end
+
+      raise DisabledTagError.new("#{@token[1]} is not allowed in this context", @token)
+    end
+
+    # Return all children of this node.
+    def children(_static_context, include_partials: true) = []
+
+    # Return this node's expressions.
+    def expressions = []
+
+    # Return variables this node adds to the template local scope.
+    def template_scope = []
+
+    # Return variables this nodes adds to its block scope.
+    def block_scope = []
+
+    # Return information about a partial template loaded by this node.
+    def partial_scope = nil
+  end
+
+  # Partial template meta data.
+  class Partial
+    attr_reader :name, :scope, :in_scope
+
+    # @param name [Expression | String] The name of the partial template.
+    # @param scope [:shared | :isolated | :inherited] A symbol indicating the kind of
+    #   scope the partial template should have when loaded.
+    # @param in_scope [Array[Identifier]] Names that will be added to the scope of the
+    #   partial template.
+    def initialize(name, scope, in_scope)
+      @name = name
+      @scope = scope
+      @in_scope = in_scope
+    end
+  end
+
+  # An node representing a block of Liquid markup.
+  # Essentially an array of other nodes and strings.
+  # @param token [[Symbol, String?, Integer]]
+  # @param nodes [Array[Node | String]]
+  class Block < Node
+    def initialize(token, nodes)
+      super(token)
+      @nodes = nodes
+      @blank = nodes.all? do |n|
+        (n.is_a?(String) && n.match(/\A\s*\Z/)) || (n.is_a?(Node) && n.blank)
+      end
+    end
+
+    def render(context, buffer)
+      buffer = +"" if context.env.suppress_blank_control_flow_blocks && @blank
+      index = 0
+      while (node = @nodes[index])
+        index += 1
+        case node
+        when String
+          buffer << node
+        else
+          node.render_with_disabled_tag_check(context, buffer)
+        end
+
+        context.raise_for_output_limit(buffer.bytesize)
+        return unless context.interrupts.empty?
+      end
+    end
+
+    def children(_static_context, include_partials: true) = @nodes
+  end
+
+  # A Liquid block guarded by an expression.
+  # Only if the expression evaluates to a truthy value will the block be rendered.
+  class ConditionalBlock < Node
+    attr_reader :expression, :block
+
+    def initialize(token, expression, block)
+      super(token)
+      @expression = expression
+      @block = block
+      @blank = block.blank
+    end
+
+    def render(context, buffer)
+      @expression.evaluate(context) ? @block.render(context, buffer) : 0
+    end
+
+    def children(_static_context, include_partials: true) = [@block]
+    def expressions = [@expression]
+  end
+end

data/lib/liquid2/nodes/comment.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require_relative "../node"
+
+module Liquid2
+  # `{# comment #}` style comments.
+  class Comment < Node
+    attr_reader :text
+
+    # @param text [String]
+    def initialize(token, text)
+      super(token)
+      @text = text
+    end
+
+    def render(_context, _buffer) = 0
+  end
+end

data/lib/liquid2/nodes/output.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require_relative "../node"
+
+module Liquid2
+  # The AST node representing output statements.
+  class Output < Node
+    attr_reader :expression
+
+    # @param token [[Symbol, String?, Integer]]
+    # @param expression [Expression]
+    def initialize(token, expression)
+      super(token)
+      @expression = expression
+      @blank = false
+    end
+
+    def render(context, buffer)
+      buffer << Liquid2.to_output_s(@expression.evaluate(context))
+    end
+
+    def expressions = [@expression]
+  end
+end

data/lib/liquid2/nodes/tags/assign.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require_relative "../../tag"
+
+module Liquid2
+  # The standard _assign_ tag.
+  class AssignTag < Tag
+    # @param parser [Parser]
+    # @return [AssignTag]
+    def self.parse(token, parser)
+      name = parser.parse_identifier(trailing_question: false)
+      parser.eat(:token_assign, "malformed identifier or missing assignment operator")
+      expression = parser.parse_filtered_expression
+      parser.carry_whitespace_control
+      parser.eat(:token_tag_end)
+      new(token, name, expression)
+    end
+
+    # @param token [[Symbol, String?, Integer]]
+    # @param name [Identifier]
+    # @param expression [Expression]
+    def initialize(token, name, expression)
+      super(token)
+      @name = name
+      @expression = expression
+    end
+
+    def render(context, _buffer)
+      context.assign(@name.name, context.evaluate(@expression))
+    end
+
+    def expressions = [@expression]
+    def template_scope = [@name]
+  end
+end

data/lib/liquid2/nodes/tags/block_comment.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require_relative "../../tag"
+
+module Liquid2
+  # The standard _comment_ tag.
+  class BlockComment < Tag
+    attr_reader :text
+
+    def self.parse(token, parser)
+      parser.carry_whitespace_control
+      parser.eat(:token_tag_end)
+      comment = parser.eat(:token_comment)
+      parser.eat_empty_tag("endcomment")
+      new(token, comment[1] || raise)
+    end
+
+    # @param text [String]
+    def initialize(token, text)
+      super(token)
+      @text = text
+    end
+
+    def render(_context, _buffer) = 0
+  end
+end

data/lib/liquid2/nodes/tags/capture.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require_relative "../../tag"
+
+module Liquid2
+  # The standard _capture_ tag.
+  class CaptureTag < Tag
+    END_BLOCK = Set["endcapture"]
+
+    # @param parser [Parser]
+    # @return [CaptureTag]
+    def self.parse(token, parser)
+      name = parser.parse_identifier(trailing_question: false)
+      parser.carry_whitespace_control
+      parser.eat(:token_tag_end)
+      block = parser.parse_block(END_BLOCK)
+      parser.eat_empty_tag("endcapture")
+      new(token, name, block)
+    end
+
+    # @param name [Identifier]
+    # @param block [Block]
+    def initialize(token, name, block)
+      super(token)
+      @name = name
+      @block = block
+      @block.blank = false
+      @blank = true
+    end
+
+    def render(context, _buffer)
+      buf = +""
+      @block.render(context, buf)
+      context.assign(@name.name, buf)
+    end
+
+    def children(_static_context, include_partials: true) = [@block]
+    def template_scope = [@name]
+  end
+end