liquid_xlsx 0.1.0

data/lib/liquid_xlsx/template_parser.rb

@@ -0,0 +1,446 @@
+# frozen_string_literal: true
+
+module LiquidXlsx
+  # Parses worksheet rows into an AST of template nodes.
+  class TemplateParser # rubocop:disable Metrics/ClassLength
+    FOR_START = /\A\{%-?\s*for\s+(\w+)\s+in\s+([\w.]+)\s*-?%\}\z/
+    FOR_END   = /\A\{%-?\s*endfor\s*-?%\}\z/
+    IF_START  = /\A\{%-?\s*if\s+((?:(?!%\}).)+)\s*-?%\}\z/
+    ELSIF     = /\A\{%-?\s*elsif\s+((?:(?!%\}).)+)\s*-?%\}\z/
+    ELSE_TAG  = /\A\{%-?\s*else\s*-?%\}\z/
+    ENDIF     = /\A\{%-?\s*endif\s*-?%\}\z/
+    STRUCTURAL_KEYWORDS = /\A\{%-?\s*(for|endfor|if|elsif|else|endif)\b/
+    MIXED_STRUCTURAL = /\{%-?\s*(?:for|endfor|if|elsif|else|endif)\b/
+    PURE_STRUCTURAL = [FOR_START, FOR_END, IF_START, ELSIF, ELSE_TAG, ENDIF].freeze
+
+    # Matches balanced pairs of non-structural Liquid blocks so they can be
+    # masked before MIXED_STRUCTURAL checks.
+    NON_STRUCTURAL_PAIR_RE = /
+      \{%-?\s*
+      (case|unless|capture|comment|raw|tablerow)
+      \b
+      .*?%\}
+      .*?
+      \{%-?\s*end\1\s*-?%\}
+    /mx
+
+    attr_reader :sheet_name
+
+    def initialize(rows, sheet_name = "Sheet1")
+      @rows = rows
+      @sheet_name = sheet_name
+      @pos = 0
+    end
+
+    def parse
+      nodes = []
+      nodes << parse_element while @pos < @rows.length
+      nodes
+    end
+
+    private
+
+    def current_row
+      @rows[@pos]
+    end
+
+    def advance
+      @pos += 1
+    end
+
+    # Iteratively remove balanced non-structural Liquid blocks (case/endcase,
+    # unless/endunless, capture/endcapture, comment/endcomment, raw/endraw,
+    # tablerow/endtablerow) so that inner {% else %}, {% if %}, etc. do not
+    # trigger false-positive MIXED_STRUCTURAL matches.
+    def mask_non_structural_blocks(text)
+      result = text.dup
+      prev = nil
+      while result != prev
+        prev = result
+        result = result.gsub(NON_STRUCTURAL_PAIR_RE, "")
+      end
+      result
+    end
+
+    # Check if a row is a pure structural tag row.
+    # This means the first cell contains ONLY a structural tag (nothing before/after),
+    # and no other cells have content.
+    def structural_row?(row)
+      first = first_cell_value(row)
+      return false unless first
+
+      stripped = first.strip
+      masked = mask_non_structural_blocks(stripped)
+      if masked.match?(MIXED_STRUCTURAL) && !stripped.match?(STRUCTURAL_KEYWORDS)
+        raise TemplateSyntaxError.new(
+          "Structural tag must be placed on a dedicated row. Found mixed content: #{stripped.inspect}",
+          sheet: @sheet_name,
+          row: row[:row_number],
+          cell: cell_reference(row),
+          tag: stripped
+        )
+      end
+
+      return false unless stripped.match?(STRUCTURAL_KEYWORDS)
+
+      # Must match exactly one of the structural patterns
+      matches_any = [FOR_START, FOR_END, IF_START, ELSIF, ELSE_TAG, ENDIF].any? do |pat|
+        first.strip.match?(pat)
+      end
+      return false unless matches_any
+
+      # Other cells must be empty
+      cells = row[:cells]
+      return true if cells.nil? || cells.length <= 1
+
+      sorted = cells.sort_by { |c| CellReference.col_to_index(c[:col]) }
+      first_content = sorted.find { |c| cell_content(c) }
+      return false unless first_content
+
+      # All cells AFTER the first content cell must be empty
+      first_idx = sorted.index(first_content)
+      sorted[(first_idx + 1)..].all? { |c| cell_content(c).nil? }
+    end
+
+    # Raise TemplateSyntaxError if any cell mixes structural tag with other content,
+    # or if a row has a structural tag in one cell and other content cells.
+    def validate_no_mixed_structural_content(row)
+      check_mixed_content_in_cells(row)
+      check_tag_cell_with_other_content(row)
+    end
+
+    def check_mixed_content_in_cells(row)
+      row[:cells].each do |c|
+        cell_val = c[:text] || c[:template]
+        next unless cell_val
+
+        stripped = cell_val.strip
+        next unless stripped.match?(MIXED_STRUCTURAL)
+
+        masked = mask_non_structural_blocks(stripped)
+        next unless masked.match?(MIXED_STRUCTURAL)
+        next if stripped.match?(STRUCTURAL_KEYWORDS)
+
+        raise TemplateSyntaxError.new(
+          "Structural tag must be placed on a dedicated row. " \
+          "Found mixed content: #{stripped.inspect}",
+          sheet: @sheet_name,
+          row: row[:row_number],
+          cell: "#{c[:col]}#{row[:row_number]}",
+          tag: stripped
+        )
+      end
+    end
+
+    def check_tag_cell_with_other_content(row)
+      cells_with_tag = row[:cells].select do |c|
+        val = c[:text] || c[:template]
+        next unless val
+
+        PURE_STRUCTURAL.any? { |pat| val.strip.match?(pat) }
+      end
+      cells_with_content = row[:cells].select do |c|
+        val = cell_content(c)
+        next unless val
+        next if PURE_STRUCTURAL.any? { |pat| val.strip.match?(pat) }
+
+        true
+      end
+      return unless cells_with_tag.any? && cells_with_content.any?
+
+      tag_cell = cells_with_tag.first
+      tag_text = tag_cell[:text] || tag_cell[:template]
+      raise TemplateSyntaxError.new(
+        "Structural tag must be on a dedicated row. " \
+        "Found tag in #{tag_cell[:col]}#{row[:row_number]} with other cells having content.",
+        sheet: @sheet_name,
+        row: row[:row_number],
+        cell: "#{tag_cell[:col]}#{row[:row_number]}",
+        tag: tag_text.strip
+      )
+    end
+
+    def parse_element
+      row = current_row
+
+      validate_no_mixed_structural_content(row)
+
+      first = first_cell_value(row)
+
+      # Check if first cell is a structural tag but row has other content
+      if first&.strip&.match?(STRUCTURAL_KEYWORDS)
+        pure_tag = [FOR_START, FOR_END, IF_START, ELSIF, ELSE_TAG, ENDIF].any? do |pat|
+          first.strip.match?(pat)
+        end
+        if pure_tag
+          # First cell is a structural tag. Check that other cells are empty.
+          cells = row[:cells]
+          if cells && cells.length > 1
+            sorted = cells.sort_by { |c| CellReference.col_to_index(c[:col]) }
+            first_content = sorted.find { |c| cell_content(c) }
+            other_have_content = if first_content
+                                   first_idx = sorted.index(first_content)
+                                   sorted[(first_idx + 1)..].any? { |c| cell_content(c) }
+                                 else
+                                   false
+                                 end
+            if other_have_content
+              raise TemplateSyntaxError.new(
+                "Structural tag must be placed on a dedicated row.",
+                sheet: @sheet_name,
+                row: row[:row_number],
+                cell: cell_reference(row),
+                tag: first.strip
+              )
+            end
+          end
+        end
+      end
+
+      return advance && Nodes::RowNode.new(row) unless structural_row?(row)
+
+      first_cell_text = first_cell_value(row).strip
+
+      case first_cell_text
+      when FOR_START
+        parse_for(::Regexp.last_match(1), ::Regexp.last_match(2))
+      when IF_START
+        parse_if(::Regexp.last_match(1))
+      when FOR_END
+        raise TemplateSyntaxError.new(
+          "Unexpected {% endfor %}",
+          sheet: @sheet_name,
+          row: row[:row_number],
+          cell: cell_reference(row),
+          tag: first_cell_text
+        )
+      when ENDIF
+        raise TemplateSyntaxError.new(
+          "Unexpected {% endif %}",
+          sheet: @sheet_name,
+          row: row[:row_number],
+          cell: cell_reference(row),
+          tag: first_cell_text
+        )
+      when ELSIF
+        raise TemplateSyntaxError.new(
+          "Unexpected {% elsif %} outside if block",
+          sheet: @sheet_name,
+          row: row[:row_number],
+          cell: cell_reference(row),
+          tag: first_cell_text
+        )
+      when ELSE_TAG
+        raise TemplateSyntaxError.new(
+          "Unexpected {% else %} outside if/for block",
+          sheet: @sheet_name,
+          row: row[:row_number],
+          cell: cell_reference(row),
+          tag: first_cell_text
+        )
+      else
+        advance
+        Nodes::RowNode.new(row)
+      end
+    end
+
+    def parse_for(var_name, collection_name)
+      for_tag_row = current_row[:row_number]
+      advance # skip for tag
+      body = []
+      else_body = nil
+
+      while @pos < @rows.length
+        row = current_row
+        first_cell_value(row)
+
+        if match_row?(row, FOR_END)
+          validate_no_mixed_structural_content(row)
+          endfor_tag_row = row[:row_number]
+          advance
+          return Nodes::ForNode.new(var_name, collection_name, body, else_body,
+                                    for_row: for_tag_row, endfor_row: endfor_tag_row)
+        elsif match_row?(row, ELSE_TAG)
+          validate_no_mixed_structural_content(row)
+          advance
+          else_body = []
+          while @pos < @rows.length
+            else_row = current_row
+            if match_row?(else_row, FOR_END)
+              validate_no_mixed_structural_content(else_row)
+              endfor_tag_row = else_row[:row_number]
+              advance
+              return Nodes::ForNode.new(var_name, collection_name, body, else_body,
+                                        for_row: for_tag_row, endfor_row: endfor_tag_row)
+            end
+            if match_row?(else_row, ENDIF)
+              validate_no_mixed_structural_content(else_row)
+              raise TemplateSyntaxError.new(
+                "Unexpected {% endif %} inside a {% for %} block — check that " \
+                "{% for %} is closed with {% endfor %}",
+                sheet: @sheet_name,
+                row: else_row[:row_number],
+                cell: cell_reference(else_row),
+                tag: first_cell_value(else_row).strip
+              )
+            end
+            else_body << parse_element
+          end
+          raise TemplateSyntaxError.new(
+            "Unclosed {% for %} block (missing {% endfor %})",
+            sheet: @sheet_name,
+            row: @rows[@pos > 0 ? @pos - 1 : 0][:row_number],
+            tag: "{% for #{var_name} in #{collection_name} %}"
+          )
+        elsif match_row?(row, ENDIF)
+          validate_no_mixed_structural_content(row)
+          raise TemplateSyntaxError.new(
+            "Unexpected {% endif %} inside a {% for %} block — check that " \
+            "{% for %} is closed with {% endfor %}",
+            sheet: @sheet_name,
+            row: row[:row_number],
+            cell: cell_reference(row),
+            tag: first_cell_value(row).strip
+          )
+        end
+
+        body << parse_element
+      end
+
+      raise TemplateSyntaxError.new(
+        "Unclosed {% for %} block (missing {% endfor %})",
+        sheet: @sheet_name,
+        row: @rows.last[:row_number],
+        tag: "{% for #{var_name} in #{collection_name} %}"
+      )
+    end
+
+    def parse_if(condition)
+      condition = condition.strip
+      if_tag_row = current_row[:row_number]
+      advance # skip if tag
+      branches = [{ condition: condition, body: [] }]
+
+      while @pos < @rows.length
+        row = current_row
+        first_cell_value(row)
+
+        if match_row?(row, ENDIF)
+          validate_no_mixed_structural_content(row)
+          endif_tag_row = row[:row_number]
+          advance
+          return Nodes::IfNode.new(branches, if_row: if_tag_row, endif_row: endif_tag_row)
+        end
+
+        elsif_match = match_row_with_capture(row, ELSIF)
+        if elsif_match
+          validate_no_mixed_structural_content(row)
+          advance
+          branches << { condition: elsif_match[1].strip, body: [] }
+          next
+        end
+
+        if match_row?(row, ELSE_TAG)
+          validate_no_mixed_structural_content(row)
+          advance
+          branches << { condition: nil, body: [] }
+          while @pos < @rows.length
+            else_row = current_row
+            if match_row?(else_row, ENDIF)
+              validate_no_mixed_structural_content(else_row)
+              endif_tag_row = else_row[:row_number]
+              advance
+              return Nodes::IfNode.new(branches, if_row: if_tag_row, endif_row: endif_tag_row)
+            end
+            if match_row?(else_row, FOR_END)
+              validate_no_mixed_structural_content(else_row)
+              raise TemplateSyntaxError.new(
+                "Unexpected {% endfor %} inside an {% if %} block — check that " \
+                "{% if %} is closed with {% endif %}",
+                sheet: @sheet_name,
+                row: else_row[:row_number],
+                cell: cell_reference(else_row),
+                tag: first_cell_value(else_row).strip
+              )
+            end
+            branches.last[:body] << parse_element
+          end
+          raise TemplateSyntaxError.new(
+            "Unclosed {% if %} block (missing {% endif %})",
+            sheet: @sheet_name,
+            row: @rows[@pos > 0 ? @pos - 1 : 0][:row_number],
+            tag: "{% if #{condition} %}"
+          )
+        end
+
+        if match_row?(row, FOR_END)
+          validate_no_mixed_structural_content(row)
+          raise TemplateSyntaxError.new(
+            "Unexpected {% endfor %} inside an {% if %} block — check that " \
+            "{% if %} is closed with {% endif %}",
+            sheet: @sheet_name,
+            row: row[:row_number],
+            cell: cell_reference(row),
+            tag: first_cell_value(row).strip
+          )
+        end
+
+        branches.last[:body] << parse_element
+      end
+
+      raise TemplateSyntaxError.new(
+        "Unclosed {% if %} block (missing {% endif %})",
+        sheet: @sheet_name,
+        row: @rows.last[:row_number],
+        tag: "{% if #{condition} %}"
+      )
+    end
+
+    # Match a row against a pattern (returns MatchData or nil)
+    def match_row_with_capture(row, pattern)
+      first = first_cell_value(row)
+      return nil unless first
+
+      first.strip.match(pattern)
+    end
+
+    # Check if a row matches a pattern (returns boolean)
+    def match_row?(row, pattern)
+      first = first_cell_value(row)
+      return false unless first
+
+      first.strip.match?(pattern)
+    end
+
+    # Effective content of a cell for "dedicated row" validation.
+    # Formula cells count as content (represented as "=FORMULA") so they are
+    # not silently swallowed by structural tag rows.
+    def cell_content(cell)
+      val = cell[:text] || cell[:template]
+      return val if val && !val.strip.empty?
+      return "=#{cell[:formula]}" if cell[:formula]
+
+      nil
+    end
+
+    def first_cell_value(row)
+      cells = row[:cells]
+      return nil if cells.nil? || cells.empty?
+
+      # Find the first NON-EMPTY cell by column order (A, B, C...)
+      sorted = cells.sort_by { |c| CellReference.col_to_index(c[:col]) }
+      first = sorted.find { |c| cell_content(c) }
+      return nil unless first
+
+      cell_content(first)
+    end
+
+    def cell_reference(row)
+      cells = row[:cells]
+      return nil if cells.nil? || cells.empty?
+
+      sorted = cells.sort_by { |c| CellReference.col_to_index(c[:col]) }
+      "#{sorted.first[:col]}#{row[:row_number]}"
+    end
+  end
+end

data/lib/liquid_xlsx/version.rb

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