liquid_xlsx 0.2.2 → 0.4.0

data/lib/liquid_xlsx/validation/usage.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module LiquidXlsx
+  module Validation
+    # One variable reference found in a template fragment.
+    #
+    # `segments` is the lookup chain after the root: `invoice.items.first.name`
+    # becomes root "invoice" with segments ["items", "first", "name"].
+    #
+    # `truncated` marks a path the host application must not check past its last
+    # segment: a dynamic lookup (`items[idx].name`) hides what comes next, and
+    # reporting "no such field" for it would be a false alarm.
+    VariableUse = Struct.new(:root, :segments, :truncated, keyword_init: true) do
+      def path
+        ([root] + Array(segments)).join(".")
+      end
+
+      def truncated?
+        truncated ? true : false
+      end
+
+      def to_h
+        { root: root, segments: Array(segments), truncated: truncated?, path: path }
+      end
+    end
+
+    # Everything a single template fragment refers to.
+    #
+    # A fragment is one unit of Liquid the renderer will actually parse: a cell
+    # template, a structural `{% for %}` collection or an `{% if %}` condition.
+    # `kind` says which, so a host application can phrase its diagnostics in the
+    # user's terms ("cell B12" vs "the {% if %} in row 12").
+    # `kind` is one of :cell, :condition, :loop.
+    Usage = Struct.new(:sheet, :row, :cell, :kind, :source, :variables, :filters,
+                       :assigns, :locals, keyword_init: true) do
+      def variables
+        self[:variables] || []
+      end
+
+      def filters
+        self[:filters] || []
+      end
+
+      # Names bound by the fragment itself ({% assign %}, {% capture %}).
+      def assigns
+        self[:assigns] || []
+      end
+
+      # Names bound for the fragment's body ({% for item in ... %}, sheet `as:`).
+      def locals
+        self[:locals] || []
+      end
+
+      def to_h
+        { sheet: sheet, row: row, cell: cell, kind: kind, source: source,
+          variables: variables.map(&:to_h), filters: filters,
+          assigns: assigns, locals: locals }
+      end
+    end
+  end
+end

data/lib/liquid_xlsx/validator.rb

@@ -0,0 +1,386 @@
+# frozen_string_literal: true
+
+module LiquidXlsx
+  # Checks a template without rendering it and without any data.
+  #
+  # Why this is not "render and see what happens": the renderer parses only the
+  # Liquid it actually executes (Renderer#cached_parse), so a typo inside an
+  # {% if %} branch that this document does not take, or inside a loop over an
+  # empty collection, stays invisible until the day some other document takes
+  # that branch. It also stops at the first failure, and rendering executes the
+  # template against live records — printing a document is a side effect nobody
+  # asked for when all they did was upload a file.
+  #
+  # So: parse everything, execute nothing, and report every problem found.
+  class Validator
+    LIQUID_MARKER = /\{\{|\{%/
+
+    # @param template_path [String] path to the .xlsx template
+    # @param dynamic_sheets [Boolean] whether the caller renders with
+    #   dynamic_sheets: true — {% sheet %} is an error when it does not
+    # @param known_filters [Array<String>, nil] filter names available at render
+    #   time; nil disables the unknown-filter check
+    def initialize(template_path, dynamic_sheets: false, known_filters: nil)
+      @template_path  = template_path
+      @dynamic_sheets = dynamic_sheets
+      @known_filters  = known_filters&.map(&:to_s)
+      @result         = Validation::Result.new
+    end
+
+    # @return [Validation::Result]
+    def call
+      package = open_package
+      return @result if package.nil?
+
+      sheet_names = safe_sheet_names(package)
+      @result.sheets.concat(sheet_names)
+
+      package.sheets.each { |sheet_info| validate_sheet(package, sheet_info) }
+
+      check_sheet_tags(sheet_names)
+      check_filters
+
+      @result
+    rescue Nokogiri::XML::SyntaxError => e
+      invalid_xlsx("Corrupt XML inside the workbook: #{e.message}")
+    end
+
+    private
+
+    attr_reader :result
+
+    def open_package
+      package = Package.new(@template_path)
+      package.read
+      package
+    rescue InvalidXlsxError => e
+      invalid_xlsx(e.message)
+      nil
+    rescue Zip::Error, Errno::ENOENT, Errno::EACCES, Errno::EISDIR => e
+      invalid_xlsx("#{e.class}: #{e.message}")
+      nil
+    end
+
+    def invalid_xlsx(message)
+      @result.add(code: :invalid_xlsx, message: "Not a readable .xlsx workbook. #{message}")
+      @result
+    end
+
+    # Sheet names are needed for {% sheet template: "X" %}; a workbook broken
+    # enough to fail here still gets its parts validated below.
+    def safe_sheet_names(package)
+      package.sheet_names
+    rescue StandardError
+      []
+    end
+
+    def validate_sheet(package, sheet_info)
+      name = sheet_info[:name]
+      xml  = worksheet_xml(package, sheet_info)
+      return if xml.nil?
+
+      worksheet = Worksheet.new(xml, name, SharedStrings.new(package.shared_strings_xml))
+      rows      = worksheet.parse_rows
+
+      check_formulas(name, rows)
+      check_rich_text(name, xml)
+
+      ast = parse_structure(name, rows)
+      # Structure did not parse: the cells are still worth checking, and a flat
+      # pass over them is exactly what the caller wants to see next to the
+      # structural error.
+      return validate_cells_flat(name, rows) if ast.nil?
+
+      validate_nodes(name, ast)
+      check_merges(name, worksheet, ast)
+    rescue Nokogiri::XML::SyntaxError => e
+      @result.add(code: :invalid_xlsx, sheet: name,
+                  message: "Corrupt XML in sheet '#{name}': #{e.message}")
+    end
+
+    # A workbook with no readable relationships part makes the lookup itself
+    # fail; for the caller that is the same problem as a missing sheet file, and
+    # the validator must not propagate it as a crash.
+    def worksheet_xml(package, sheet_info)
+      xml = begin
+        package.worksheet_xml(sheet_info[:r_id])
+      rescue StandardError
+        nil
+      end
+      return xml if xml
+
+      @result.add(code: :missing_worksheet, sheet: sheet_info[:name],
+                  message: "The workbook lists sheet '#{sheet_info[:name]}' " \
+                           "(#{sheet_info[:r_id]}) but the file for it is missing from the package.")
+      nil
+    end
+
+    # @return [Array<Nodes::Base>, nil] nil when the structure is broken
+    def parse_structure(name, rows)
+      TemplateParser.new(rows, name).parse
+    rescue TemplateSyntaxError => e
+      @result.add(code: :template_syntax, sheet: e.sheet || name, row: e.row, cell: e.cell,
+                  message: e.message.lines.first.to_s.strip, source: e.tag)
+      nil
+    end
+
+    # --- fragments ---------------------------------------------------------
+
+    def validate_nodes(sheet, nodes)
+      Array(nodes).each do |node|
+        case node
+        when Nodes::RowNode then validate_row(sheet, node.row_data)
+        when Nodes::ForNode then validate_for(sheet, node)
+        when Nodes::IfNode  then validate_if(sheet, node)
+        end
+      end
+    end
+
+    def validate_row(sheet, row)
+      row[:cells].each do |cell|
+        next unless cell[:template]
+
+        parse_fragment(sheet: sheet, row: row[:row_number], cell: "#{cell[:col]}#{row[:row_number]}",
+                       kind: :cell, source: cell[:template])
+      end
+    end
+
+    # The renderer looks the collection up by name (Renderer#resolve_for_collection),
+    # so validating `{{ name }}` sees exactly what it will see.
+    def validate_for(sheet, node)
+      usage = parse_fragment(sheet: sheet, row: node.for_row, kind: :loop,
+                             source: "{% for #{node.variable_name} in #{node.collection_name} %}",
+                             liquid: "{{ #{node.collection_name} }}")
+      if usage
+        usage.locals.push(node.variable_name.to_s, "forloop")
+        usage.locals.uniq!
+      end
+
+      validate_nodes(sheet, node.body)
+      validate_nodes(sheet, node.else_body)
+    end
+
+    # Conditions are wrapped exactly as Renderer#evaluate_condition wraps them:
+    # validating a different string than the one that gets executed would check
+    # the wrong thing.
+    def validate_if(sheet, node)
+      node.branches.each do |branch|
+        condition = branch[:condition]
+        if condition
+          parse_fragment(sheet: sheet, row: node.if_row, kind: :condition,
+                         source: "{% if #{condition} %}",
+                         liquid: "{% if #{condition} %}true{% endif %}")
+        end
+
+        validate_nodes(sheet, branch[:body])
+      end
+    end
+
+    # Cells of a sheet whose structure did not parse.
+    def validate_cells_flat(sheet, rows)
+      rows.each { |row| validate_row(sheet, row) }
+    end
+
+    # Fragments are parsed twice, in strict mode and in Liquid's default lax
+    # mode, because the two modes answer different questions.
+    #
+    # Lax mode is what the renderer uses, so a fragment it rejects will not
+    # print — that is an error. What lax mode accepts, it may still not read the
+    # way the author meant: `{{ invoice.total b c }}` and `{{ invoice..total }}`
+    # both render the total and quietly drop the rest. Strict mode is the only
+    # thing that notices, and the right word for it is a warning, not an error:
+    # the document does print, and calling it broken would be false.
+    #
+    # @return [Validation::Usage, nil] nil when the fragment does not parse
+    def parse_fragment(sheet:, kind:, source:, row: nil, cell: nil, liquid: nil)
+      text     = liquid || source
+      template = parse_liquid(text, :strict)
+      usage    = build_usage(template, sheet: sheet, row: row, cell: cell, kind: kind, source: source)
+      @result.add_usage(usage)
+      usage
+    rescue ::Liquid::SyntaxError => e
+      report_syntax_error(e, text: text, sheet: sheet, row: row, cell: cell, source: source)
+      nil
+    rescue TemplateSyntaxError, LiquidXlsx::Error => e
+      # Tag constructors of this gem validate their own arguments at parse time
+      # ({% sheet %} without `template:`, for instance).
+      @result.add(code: :liquid_syntax, sheet: sheet, row: row, cell: cell,
+                  message: e.message.lines.first.to_s.strip, source: source)
+      nil
+    end
+
+    def parse_liquid(text, error_mode)
+      ::Liquid::Template.parse(text, environment: LiquidXlsx.liquid_environment, error_mode: error_mode)
+    end
+
+    # Two different problems wear the same exception, and a user needs to tell
+    # them apart: a fragment the renderer will refuse outright (error), and a
+    # fragment it will accept while silently ignoring part of what was written
+    # (warning).
+    def report_syntax_error(error, text:, sheet:, row:, cell:, source:)
+      if parses_leniently?(text)
+        @result.add(code: :liquid_expression, severity: :warning, sheet: sheet, row: row, cell: cell,
+                    message: "Liquid does not read this expression the way it is written and will " \
+                             "ignore part of it: #{error.message}",
+                    source: source)
+      else
+        @result.add(code: :liquid_syntax, sheet: sheet, row: row, cell: cell,
+                    message: error.message, source: source)
+      end
+    end
+
+    def parses_leniently?(text)
+      parse_liquid(text, :lax)
+      true
+    rescue ::Liquid::SyntaxError, LiquidXlsx::Error
+      false
+    end
+
+    def build_usage(template, sheet:, row:, cell:, kind:, source:)
+      collected = Validation::LiquidUsage.call(template.root)
+      @sheet_tags = (@sheet_tags || []).concat(collect_sheet_tags(template.root, sheet, row, cell))
+
+      Validation::Usage.new(
+        sheet: sheet, row: row, cell: cell, kind: kind, source: source,
+        variables: collected.variables.uniq(&:path),
+        filters: collected.filters.uniq,
+        assigns: collected.assigns.uniq,
+        locals: collected.locals.uniq
+      )
+    end
+
+    # --- whole-workbook checks --------------------------------------------
+
+    def collect_sheet_tags(node, sheet, row, cell)
+      found = []
+      walk_liquid(node) do |child|
+        next unless child.is_a?(Tags::SheetTag)
+
+        found << { tag: child, sheet: sheet, row: row, cell: cell }
+      end
+      found
+    end
+
+    def walk_liquid(node, &block)
+      yield node
+      return unless node.respond_to?(:nodelist) && node.nodelist
+
+      node.nodelist.each do |child|
+        next if child.is_a?(::String)
+
+        walk_liquid(child, &block)
+      end
+    end
+
+    # {% sheet %} needs two things the fragment itself cannot know: the caller
+    # must render with dynamic_sheets, and the sheet named in `template:` must
+    # exist. Both fail at render time today, long after the template was saved.
+    def check_sheet_tags(sheet_names)
+      Array(@sheet_tags).each do |entry|
+        tag = entry[:tag]
+
+        unless @dynamic_sheets
+          @result.add(code: :sheet_tag_disabled, sheet: entry[:sheet], row: entry[:row], cell: entry[:cell],
+                      message: "{% sheet %} requires rendering with dynamic_sheets: true.")
+        end
+
+        template_name = tag.template_name
+        next if template_name.nil? || sheet_names.empty? || sheet_names.include?(template_name)
+
+        @result.add(code: :sheet_template_missing, sheet: entry[:sheet], row: entry[:row], cell: entry[:cell],
+                    message: "{% sheet %} refers to template sheet '#{template_name}', " \
+                             "which does not exist in this workbook.")
+      end
+    end
+
+    def check_filters
+      return if @known_filters.nil?
+
+      @result.usages.each do |usage|
+        usage.filters.each do |filter|
+          next if @known_filters.include?(filter)
+
+          @result.add(code: :unknown_filter, sheet: usage.sheet, row: usage.row, cell: usage.cell,
+                      message: "Unknown filter '#{filter}'.", source: usage.source)
+        end
+      end
+    end
+
+    # Liquid inside a formula is never evaluated: Worksheet#extract_cell_text
+    # keeps formula cells as formulas, so the tag travels into the output file
+    # untouched. Silent, and hard to spot in a large sheet.
+    def check_formulas(sheet, rows)
+      rows.each do |row|
+        row[:cells].each do |cell|
+          formula = cell[:formula]
+          next unless formula&.match?(LIQUID_MARKER)
+
+          @result.add(code: :liquid_in_formula, severity: :warning, sheet: sheet,
+                      row: row[:row_number], cell: "#{cell[:col]}#{row[:row_number]}",
+                      message: "Liquid inside a formula is not evaluated.",
+                      source: "=#{formula}")
+        end
+      end
+    end
+
+    # Rich-text inline strings: text split into runs (<is><r><t>) is not read by
+    # the renderer, so Liquid written there disappears from the output without
+    # any error. Editors produce runs as soon as part of a cell is formatted
+    # differently — a bold word inside the cell is enough.
+    def check_rich_text(sheet, xml)
+      doc = Nokogiri::XML(xml)
+      ns  = doc.root&.namespace
+      return unless ns
+
+      doc.xpath("//xmlns:c[@t='inlineStr']", "xmlns" => ns.href).each do |cell|
+        is_element = cell.at_xpath("xmlns:is")
+        next if is_element.nil? || is_element.at_xpath("xmlns:t")
+
+        text = is_element.xpath(".//xmlns:t").map(&:text).join
+        next unless text.match?(LIQUID_MARKER)
+
+        @result.add(code: :liquid_in_rich_text, severity: :warning, sheet: sheet,
+                    cell: cell["r"],
+                    message: "Liquid in a rich-text cell is not read. Retype the cell " \
+                             "so all of its text has the same formatting.",
+                    source: text)
+      end
+    end
+
+    def check_merges(sheet, worksheet, ast)
+      merges = worksheet.merge_cells
+      return if merges.empty?
+
+      blocks = collect_blocks(ast)
+      return if blocks.empty?
+
+      merges.each do |merge|
+        blocks.each do |block|
+          next unless Validation::BlockBoundary.crosses?(merge[:start_row], merge[:end_row],
+                                                         block[:start], block[:end])
+
+          @result.add(code: :merged_cell_crosses_block, sheet: sheet, row: block[:start],
+                      message: "Merged cell '#{merge[:ref]}' crosses the boundary of a " \
+                               "#{block[:type]} block (rows #{block[:start]}-#{block[:end]}).",
+                      source: merge[:ref])
+        end
+      end
+    end
+
+    def collect_blocks(nodes, blocks = [])
+      Array(nodes).each do |node|
+        case node
+        when Nodes::ForNode
+          blocks << { type: :for, start: node.for_row, end: node.endfor_row } if node.for_row && node.endfor_row
+          collect_blocks(node.body, blocks)
+          collect_blocks(node.else_body, blocks)
+        when Nodes::IfNode
+          blocks << { type: :if, start: node.if_row, end: node.endif_row } if node.if_row && node.endif_row
+          node.branches.each { |branch| collect_blocks(branch[:body], blocks) }
+        end
+      end
+
+      blocks
+    end
+  end
+end

data/lib/liquid_xlsx/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module LiquidXlsx
-  VERSION = "0.2.2"
+  VERSION = "0.4.0"
 end

data/lib/liquid_xlsx/workbook.rb

@@ -16,6 +16,8 @@ module LiquidXlsx
     #   or any object whose `#to_liquid` returns one)
     # @return [Package] modified package
     def render(data)
+      return render_streaming(data) if @options[:streaming]
+
       all_image_ops = []
 
       if @options[:dynamic_sheets]
@@ -47,6 +49,31 @@ module LiquidXlsx
 
     private
 
+    # Preflight every worksheet before executing user data or creating row files.
+    def render_streaming(data)
+      renderers = package.sheets.map do |sheet_info|
+        worksheet = Worksheet.new(worksheet_xml!(sheet_info), sheet_info[:name], @shared_strings)
+        renderer = StreamingRenderer.new(worksheet, @options)
+        renderer.prepare
+        [sheet_info[:r_id], renderer]
+      end
+      looping = renderers.map(&:last).select(&:loops?)
+      if looping.size > 1
+        raise StreamingUnsupportedError.new(
+          "Only one worksheet may contain loops in streaming mode",
+          sheet: looping[1].worksheet.name
+        )
+      end
+      renderers.each do |r_id, renderer|
+        package.save_worksheet_xml(r_id, renderer.render(data))
+      end
+      if @options[:recalculate_formulas]
+        package.remove_calc_chain if package.calc_chain_xml
+        package.set_recalculation_flags
+      end
+      package
+    end
+
     # Worksheet part behind a <sheet> entry of workbook.xml.
     #
     # A workbook that lists a sheet whose part cannot be resolved is broken, and

data/lib/liquid_xlsx/worksheet.rb

@@ -303,6 +303,30 @@ module LiquidXlsx
       @doc.to_xml(indent: 0, encoding: "UTF-8")
     end
 
+    # Serialize only the small worksheet envelope; rows are supplied from disk.
+    def streaming_envelope(total_rows, max_col)
+      root = @doc.root
+      ns = { "xmlns" => root.namespace.href }
+      sheet_data = root.at_xpath("xmlns:sheetData", ns)
+      unless sheet_data
+        sheet_data = Nokogiri::XML::Node.new("sheetData", @doc)
+        self.class.insert_child_in_order(root, sheet_data)
+      end
+      sheet_data.children.remove
+      token = +"liquid_xlsx_rows"
+      comments = @doc.xpath("//comment()").map(&:content)
+      token << "_" while comments.include?(token)
+      marker = Nokogiri::XML::Comment.new(@doc, token)
+      sheet_data.add_child(marker)
+      dim = root.at_xpath("xmlns:dimension", ns)
+      unless dim
+        dim = Nokogiri::XML::Node.new("dimension", @doc)
+        self.class.insert_child_in_order(root, dim)
+      end
+      dim["ref"] = "A1:#{max_col}#{[total_rows, 1].max}"
+      to_xml.split("<!--#{token}-->", 2)
+    end
+
     # Extract row-level attributes to preserve.
     def row_attributes(row_elem)
       {

data/lib/liquid_xlsx.rb

@@ -15,11 +15,20 @@ require_relative "liquid_xlsx/tags/sheet_tag"
 require_relative "liquid_xlsx/tags/image_tag"
 require_relative "liquid_xlsx/image"
 require_relative "liquid_xlsx/drawing_builder"
+require_relative "liquid_xlsx/file_part"
 require_relative "liquid_xlsx/package"
 require_relative "liquid_xlsx/worksheet"
 require_relative "liquid_xlsx/renderer"
+require_relative "liquid_xlsx/streaming_context"
+require_relative "liquid_xlsx/streaming_renderer"
 require_relative "liquid_xlsx/workbook"
 require_relative "liquid_xlsx/template"
+require_relative "liquid_xlsx/validation/issue"
+require_relative "liquid_xlsx/validation/usage"
+require_relative "liquid_xlsx/validation/result"
+require_relative "liquid_xlsx/validation/block_boundary"
+require_relative "liquid_xlsx/validation/liquid_usage"
+require_relative "liquid_xlsx/validator"
 
 # LiquidXlsx is a Ruby gem for generating .xlsx files from Excel templates
 # with Liquid syntax. Edit templates in Excel, write Liquid in cells,
@@ -58,6 +67,7 @@ module LiquidXlsx
     #   Liquid::Drop, or any object whose `#to_liquid` returns a Hash/Drop.
     # @param strict_variables [Boolean] raise error on missing variables
     # @param strict_filters [Boolean] raise error on unknown filters
+    # @param streaming [Boolean] stream worksheet rows to disk (restricted templates)
     # @param dynamic_sheets [Boolean] enable {% sheet %} tag for dynamic sheet creation
     # @param hide_control_sheets [Boolean] hide sheets that contained {% sheet %} tags
     # @param hide_template_sheets [Boolean] hide template sheets after cloning
@@ -73,7 +83,7 @@ module LiquidXlsx
                recalculate_formulas: false, remove_template_comments: false,
                dynamic_sheets: false, hide_control_sheets: true,
                hide_template_sheets: false, images: nil,
-               liquid_resource_limits: nil, filters: nil)
+               liquid_resource_limits: nil, filters: nil, streaming: false)
       tpl = Template.new(template, {
                            strict_variables: strict_variables,
                            strict_filters: strict_filters,
@@ -84,10 +94,44 @@ module LiquidXlsx
                            hide_template_sheets: hide_template_sheets,
                            images: images || {},
                            liquid_resource_limits: liquid_resource_limits,
-                           filters: filters
+                           filters: filters,
+                           streaming: streaming
                          })
       # rubocop:enable Metrics/ParameterLists
       tpl.render_to_file(data, output)
     end
+
+    # Check a template without rendering it and without any data.
+    #
+    # Unlike a trial render, this parses every cell and every branch — including
+    # the ones a particular document would not take — collects all problems
+    # instead of stopping at the first, and executes nothing, so validating a
+    # template has no side effects on the application's records.
+    #
+    #   result = LiquidXlsx.validate(template: "invoice.xlsx",
+    #                                known_filters: MyFilters.public_instance_methods(false))
+    #   result.valid?   # => false
+    #   result.issues   # => [#<Issue code: :liquid_syntax, sheet: "Sheet1", cell: "B12", ...>]
+    #   result.roots    # => ["invoice", "customer"]  — what the template expects as input
+    #
+    # @param template [String] path to the .xlsx template
+    # @param dynamic_sheets [Boolean] pass true if you render with dynamic_sheets:
+    #   true; otherwise {% sheet %} in the template is reported as an error,
+    #   because that is what rendering it would do
+    # @param known_filters [Array<String, Symbol>, nil] filter names available at
+    #   render time (standard Liquid filters are included automatically); nil
+    #   disables the unknown-filter check
+    # @return [Validation::Result]
+    def validate(template:, dynamic_sheets: false, known_filters: nil)
+      Validator.new(template,
+                    dynamic_sheets: dynamic_sheets,
+                    known_filters: known_filters && (known_filters.map(&:to_s) + standard_filters))
+               .call
+    end
+
+    # Filters every Liquid template can use without the host registering anything.
+    def standard_filters
+      @standard_filters ||= ::Liquid::StandardFilters.public_instance_methods(false).map(&:to_s)
+    end
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: liquid_xlsx
 version: !ruby/object:Gem::Version
-  version: 0.2.2
+  version: 0.4.0
 platform: ruby
 authors:
 - Ivan Khlipitkin
@@ -100,6 +100,7 @@ files:
 - lib/liquid_xlsx/cell_reference.rb
 - lib/liquid_xlsx/drawing_builder.rb
 - lib/liquid_xlsx/errors.rb
+- lib/liquid_xlsx/file_part.rb
 - lib/liquid_xlsx/filters.rb
 - lib/liquid_xlsx/formula_translator.rb
 - lib/liquid_xlsx/image.rb
@@ -107,11 +108,19 @@ files:
 - lib/liquid_xlsx/package.rb
 - lib/liquid_xlsx/renderer.rb
 - lib/liquid_xlsx/shared_strings.rb
+- lib/liquid_xlsx/streaming_context.rb
+- lib/liquid_xlsx/streaming_renderer.rb
 - lib/liquid_xlsx/tags/image_tag.rb
 - lib/liquid_xlsx/tags/sheet_tag.rb
 - lib/liquid_xlsx/template.rb
 - lib/liquid_xlsx/template_nodes.rb
 - lib/liquid_xlsx/template_parser.rb
+- lib/liquid_xlsx/validation/block_boundary.rb
+- lib/liquid_xlsx/validation/issue.rb
+- lib/liquid_xlsx/validation/liquid_usage.rb
+- lib/liquid_xlsx/validation/result.rb
+- lib/liquid_xlsx/validation/usage.rb
+- lib/liquid_xlsx/validator.rb
 - lib/liquid_xlsx/version.rb
 - lib/liquid_xlsx/workbook.rb
 - lib/liquid_xlsx/worksheet.rb