Module: Liquid2::StaticAnalysis

Defined in:

lib/liquid2/static_analysis.rb

Overview

Template static analysis.

Defined Under Namespace

Classes: Result, Span, StaticScope, Variable, VariableMap

Class Method Summary

• .analyze(template, include_partials:) ⇒ Object
• .analyze_variables(expression, template_name, scope, globals, variables) ⇒ Object
• .extract_filters(expression, template_name) ⇒ Object
• .segments(path, template_name) ⇒ Object

Class Method Details

.analyze(template, include_partials:) ⇒ Object

# File 'lib/liquid2/static_analysis.rb', line 153

def self.analyze(template, include_partials:)
  variables = VariableMap.new
  globals = VariableMap.new
  locals = VariableMap.new

  # @type var filters: Hash[String, Array[Span]]
  filters = Hash.new { |hash, key| hash[key] = [] }
  # @type var tags: Hash[String, Array[Span]]
  tags = Hash.new { |hash, key| hash[key] = [] }

  # @type var template_scope: Set[String]
  template_scope = Set[]
  root_scope = StaticScope.new(template_scope)
  static_context = Liquid2::RenderContext.new(template)

  # Names of partial templates that have already been analyzed.
  # @type var seen: Set[String]
  seen = Set[]

  # @type var visit: ^(Node, String, StaticScope) -> void
  visit = lambda do |node, template_name, scope|
    seen.add(template_name) unless template_name.empty?

    # Update tags
    tags[node.name] << Span.new(template_name, node.token.last) if node.is_a?(Liquid2::Tag)

    # Update variables from node.expressions
    node.expressions.each do |expr|
      if expr.is_a?(Liquid2::Expression)
        analyze_variables(expr, template_name, scope, globals,
                          variables)
      end

      # Update filters from expr
      extract_filters(expr, template_name).each do |name, span|
        filters[name] << span
      end
    end

    # Update template scope from node.template_scope
    node.template_scope.each do |ident|
      scope.add(ident.name)
      locals.add(Variable.new([ident.name], Span.new(template_name, ident.token.last)))
    end

    if (partial = node.partial_scope)
      partial_name = static_context.evaluate(partial.name).to_s

      unless seen.include?(partial_name)
        partial_scope = if partial.scope == :isolated
                          StaticScope.new(Set.new(partial.in_scope.map(&:name)))
                        else
                          root_scope.push(Set.new(partial.in_scope.map(&:name)))
                        end

        node.children(static_context, include_partials: include_partials).each do |child|
          seen.add(partial_name)
          visit.call(child, partial_name, partial_scope) if child.is_a?(Liquid2::Node)
        end

        partial_scope.pop
      end
    else
      scope.push(Set.new(node.block_scope.map(&:name)))
      node.children(static_context, include_partials: include_partials).each do |child|
        visit.call(child, template_name, scope) if child.is_a?(Liquid2::Node)
      end
      scope.pop
    end
  end

  template.ast.each do |node|
    visit.call(node, template.name, root_scope) if node.is_a?(Liquid2::Node)
  end

  Result.new(variables.data, globals.data, locals.data, filters, tags)
end

.analyze_variables(expression, template_name, scope, globals, variables) ⇒ Object

# File 'lib/liquid2/static_analysis.rb', line 257

def self.analyze_variables(expression, template_name, scope, globals, variables)
  if expression.is_a?(Path)
    var = Variable.new(segments(expression, template_name),
                       Span.new(template_name, expression.token.last))
    variables.add(var)

    root = var.segments.first.to_s
    globals.add(var) unless scope.include?(root)
  end

  if (child_scope = expression.scope)
    scope.push(Set.new(child_scope.map(&:name)))
    expression.children.each do |expr|
      if expr.is_a?(Expression)
        analyze_variables(expr, template_name, scope, globals,
                          variables)
      end
    end
    scope.pop
  else
    expression.children.each do |expr|
      if expr.is_a?(Expression)
        analyze_variables(expr, template_name, scope, globals,
                          variables)
      end
    end
  end
end

.extract_filters(expression, template_name) ⇒ Object

# File 'lib/liquid2/static_analysis.rb', line 231

def self.extract_filters(expression, template_name)
  filters = [] # : Array[[String, Span]]

  if expression.is_a?(Liquid2::FilteredExpression) && !expression.filters.nil?
    expression.filters.each do |filter|
      filters << [filter.name, Span.new(template_name, filter.token.last)]
    end
  elsif expression.is_a?(Liquid2::TernaryExpression)
    expression.filters.each do |filter|
      filters << [filter.name, Span.new(template_name, filter.token.last)]
    end

    expression.tail_filters.each do |filter|
      filters << [filter.name, Span.new(template_name, filter.token.last)]
    end
  end

  if expression.is_a?(Liquid2::Expression)
    expression.children.each do |expr|
      filters.concat(extract_filters(expr, template_name))
    end
  end

  filters
end

.segments(path, template_name) ⇒ Object

# File 'lib/liquid2/static_analysis.rb', line 286

def self.segments(path, template_name)
  # @type var segments_: Array[untyped]
  segments_ = [path.head.is_a?(Path) ? segments(path.head, template_name) : path.head]

  path.segments.each do |segment|
    segments_ << if segment.is_a?(Path)
                   segments(segment, template_name)
                 else
                   segment
                 end
  end

  segments_
end