liquid_xlsx 0.1.0

data/lib/liquid_xlsx/worksheet.rb

@@ -0,0 +1,436 @@
+# frozen_string_literal: true
+
+module LiquidXlsx
+  # Represents and processes a single worksheet.
+  class Worksheet
+    attr_reader :name, :sheet_xml, :shared_strings
+
+    # Element order of CT_Worksheet children per the OOXML schema.
+    CT_WORKSHEET_ORDER = %w[
+      sheetPr dimension sheetViews sheetFormatPr cols sheetData sheetCalcPr
+      sheetProtection protectedRanges scenarios autoFilter sortState
+      dataConsolidate customSheetViews mergeCells phoneticPr
+      conditionalFormatting dataValidations hyperlinks printOptions pageMargins
+      pageSetup headerFooter rowBreaks colBreaks customProperties cellWatches
+      ignoredErrors smartTags drawing drawingHF picture oleObjects controls
+      webPublishItems tableParts extLst
+    ].freeze
+
+    # Excel's hard limit on cell text length.
+    EXCEL_MAX_CELL_LENGTH = 32_767
+
+    # Characters invalid in XML 1.0 (except TAB, LF, CR which are legal).
+    ILLEGAL_XML_CHARS = /[\x00-\x08\x0B\x0C\x0E-\x1F]/
+
+    # Make a string safe to embed in worksheet XML: valid UTF-8, no illegal
+    # control characters, within Excel's cell length limit.
+    def self.sanitize_text(value)
+      s = value.to_s
+      s = if s.encoding == Encoding::UTF_8
+            s.valid_encoding? ? s : s.scrub("\u{FFFD}")
+          else
+            s.encode(Encoding::UTF_8, invalid: :replace, undef: :replace, replace: "\u{FFFD}")
+          end
+      s = s.gsub(ILLEGAL_XML_CHARS, "")
+      s = s[0, EXCEL_MAX_CELL_LENGTH] if s.length > EXCEL_MAX_CELL_LENGTH
+      s
+    end
+
+    # Insert a child element into a worksheet root at its schema-mandated
+    # position (before the first existing element that must come after it).
+    def self.insert_child_in_order(root, node)
+      idx = CT_WORKSHEET_ORDER.index(node.name)
+      anchor = idx && root.element_children.find do |child|
+        ci = CT_WORKSHEET_ORDER.index(child.name)
+        ci && ci > idx
+      end
+      anchor ? anchor.add_previous_sibling(node) : root.add_child(node)
+      node
+    end
+
+    def initialize(xml, name, shared_strings)
+      @original_xml = xml
+      @name = name
+      @shared_strings = shared_strings
+      @doc = Nokogiri::XML(xml)
+    end
+
+    # Parse rows from the worksheet.
+    # @return [Array<Hash>] rows with :row_number, :row_xml, :cells, :row_attrs
+    def parse_rows
+      rows = []
+      ns = @doc.root&.namespace
+      return rows unless ns
+
+      collect_shared_formula_masters(ns)
+
+      last_row_num = 0
+      @doc.xpath("//xmlns:sheetData/xmlns:row", "xmlns" => ns.href).each do |row_elem|
+        row_num = row_elem["r"]&.to_i
+        row_num = last_row_num + 1 if row_num.nil? || row_num < 1
+        last_row_num = row_num
+        cells = parse_cells(row_elem, row_num)
+        rows << {
+          row_number: row_num,
+          row_xml: row_elem.to_xml(indent: 0),
+          cells: cells,
+          row_attrs: row_attributes(row_elem)
+        }
+      end
+      rows
+    end
+
+    # Get merge cells from the worksheet.
+    # @return [Array<Hash>] each: {ref: "A3:B3", start_row:, end_row:}
+    def merge_cells
+      return [] unless merge_elem
+
+      merge_elem["count"]&.to_i
+      merge_elem.xpath("xmlns:mergeCell").map do |mc|
+        ref = mc["ref"]
+        parts = ref.split(":")
+        start = CellReference.new(parts[0])
+        end_ref = CellReference.new(parts[1] || parts[0])
+        {
+          ref: ref,
+          start_row: start.row,
+          end_row: end_ref.row
+        }
+      end
+    end
+
+    # Get the mergeCells element.
+    # @return [Nokogiri::XML::Element, nil]
+    def merge_elem
+      ns = @doc.root&.namespace
+      return nil unless ns
+
+      @doc.at_xpath("//xmlns:mergeCells", "xmlns" => ns.href)
+    end
+
+    # Rebuild sheetData with rendered rows.
+    # @param rendered_rows [Array<Hash>] array of {cells:, original_row_num:, row_attrs:}
+    # @param start_row [Integer] first row number in the output
+    def rebuild_sheet_data(rendered_rows, start_row = 1)
+      ns = @doc.root&.namespace
+      return unless ns
+
+      sheet_data = @doc.at_xpath("//xmlns:sheetData", "xmlns" => ns.href)
+      unless sheet_data
+        sheet_data = Nokogiri::XML::Node.new("sheetData", @doc)
+        @doc.root.add_child(sheet_data)
+      end
+
+      # Remove all existing rows
+      sheet_data.xpath("xmlns:row").each(&:remove)
+
+      current_row_num = start_row
+      sheet_data.namespace
+
+      rendered_rows.each do |row_info|
+        next if row_info.nil?
+
+        row_elem = Nokogiri::XML::Node.new("row", @doc)
+        row_elem["r"] = current_row_num.to_s
+
+        # Restore original row attributes (height, hidden, etc.)
+        apply_row_attributes(row_elem, row_info[:row_attrs])
+
+        (row_info[:cells] || []).each do |cell_data|
+          next unless cell_data
+
+          row_elem.add_child(build_cell(cell_data, current_row_num))
+        end
+
+        sheet_data.add_child(row_elem)
+        current_row_num += 1
+      end
+    end
+
+    # Build a single <c> element for a rendered cell.
+    def build_cell(cell_data, current_row_num)
+      c = Nokogiri::XML::Node.new("c", @doc)
+      c["r"] = "#{cell_data[:col]}#{current_row_num}"
+      c["s"] = cell_data[:style].to_s if cell_data[:style]
+
+      if cell_data[:formula]
+        # Only override type if original explicitly had t="str" (not for numeric formulas)
+        c["t"] = "str" if cell_data[:original_type] == "str"
+        f = Nokogiri::XML::Node.new("f", @doc)
+        (cell_data[:formula_attrs] || {}).each { |k, val| f[k] = val if val }
+        f.content = cell_data[:formula]
+        c.add_child(f)
+      elsif cell_data[:inline_str]
+        add_inline_str(c, cell_data[:rendered_value])
+      elsif cell_data[:type] == "s" && cell_data[:text]
+        # Shared string reference — keep as is
+        c["t"] = "s"
+        v_el = Nokogiri::XML::Node.new("v", @doc)
+        v_el.content = cell_data[:value].to_s if cell_data[:value]
+        c.add_child(v_el)
+      elsif cell_data[:rendered_value].is_a?(Numeric)
+        v_el = Nokogiri::XML::Node.new("v", @doc)
+        v_el.content = cell_data[:rendered_value].to_s
+        c.add_child(v_el)
+      elsif cell_data[:rendered_value].is_a?(TrueClass) || cell_data[:rendered_value].is_a?(FalseClass)
+        c["t"] = "b"
+        v_el = Nokogiri::XML::Node.new("v", @doc)
+        v_el.content = cell_data[:rendered_value] ? "1" : "0"
+        c.add_child(v_el)
+      elsif cell_data[:original_value] && !%w[s inlineStr].include?(cell_data[:type])
+        # Non-template value cell (numeric, boolean, raw) — preserve as-is
+        c["t"] = cell_data[:type] if cell_data[:type]
+        v_el = Nokogiri::XML::Node.new("v", @doc)
+        v_el.content = cell_data[:original_value].to_s
+        c.add_child(v_el)
+      else
+        # String — use inlineStr
+        add_inline_str(c, cell_data[:rendered_value])
+      end
+
+      c
+    end
+
+    # Append <is><t>...</t></is> to a cell element.
+    def add_inline_str(c, value)
+      c["t"] = "inlineStr"
+      is_el = Nokogiri::XML::Node.new("is", @doc)
+      c.add_child(is_el)
+      is_el.add_child(build_inline_text(value))
+    end
+
+    # Update the dimension element.
+    # @param total_rows [Integer]
+    def update_dimension(total_rows)
+      ns = @doc.root&.namespace
+      return unless ns
+
+      dim = @doc.at_xpath("//xmlns:dimension", "xmlns" => ns.href)
+      unless dim
+        dim = Nokogiri::XML::Node.new("dimension", @doc)
+        @doc.root.children.first&.add_previous_sibling(dim)
+      end
+
+      # Find max column using column index (not string comparison)
+      max_col = "A"
+      max_col_idx = 0
+      @doc.xpath("//xmlns:c").each do |c|
+        ref = c["r"]
+        col = ref&.gsub(/\d+/, "")
+        next unless col
+
+        col_idx = CellReference.col_to_index(col)
+        if col_idx > max_col_idx
+          max_col_idx = col_idx
+          max_col = col
+        end
+      end
+
+      total_rows = 1 if total_rows < 1
+      dim["ref"] = "A1:#{max_col}#{total_rows}"
+      dim
+    end
+
+    # Build a sanitized <t> element for inline strings, preserving significant
+    # whitespace via xml:space when needed.
+    def build_inline_text(value)
+      t_el = Nokogiri::XML::Node.new("t", @doc)
+      text = self.class.sanitize_text(value)
+      t_el.content = text
+      t_el["xml:space"] = "preserve" if text.match?(/\A\s|\s\z/) || text.include?("\n")
+      t_el
+    end
+
+    # Update merged cells with new ranges.
+    # @param merge_ranges [Array<String>] e.g. ["A3:B3", "A4:B4"]
+    def update_merge_cells(merge_ranges)
+      ns = @doc.root&.namespace
+      return unless ns
+
+      # Remove existing mergeCells
+      existing = @doc.at_xpath("//xmlns:mergeCells", "xmlns" => ns.href)
+      existing&.remove
+
+      return if merge_ranges.empty?
+
+      mc_elem = Nokogiri::XML::Node.new("mergeCells", @doc)
+      mc_elem["count"] = merge_ranges.length.to_s
+
+      merge_ranges.each do |ref|
+        mc = Nokogiri::XML::Node.new("mergeCell", @doc)
+        mc["ref"] = ref
+        mc_elem.add_child(mc)
+      end
+
+      # Insert at the schema-mandated position within CT_Worksheet
+      self.class.insert_child_in_order(@doc.root, mc_elem)
+    end
+
+    # Remove calc chain cached values from formula cells.
+    def remove_cached_formula_values
+      @doc.xpath("//xmlns:f").each do |f|
+        # Remove sibling <v> elements
+        parent = f.parent
+        parent.xpath("xmlns:v").each(&:remove)
+      end
+    end
+
+    # Serialize back to XML string.
+    # @return [String]
+    def to_xml
+      @doc.to_xml(indent: 0, encoding: "UTF-8")
+    end
+
+    # Extract row-level attributes to preserve.
+    def row_attributes(row_elem)
+      {
+        s: row_elem["s"],
+        ht: row_elem["ht"],
+        customHeight: row_elem["customHeight"],
+        hidden: row_elem["hidden"],
+        outlineLevel: row_elem["outlineLevel"],
+        customFormat: row_elem["customFormat"],
+        spans: row_elem["spans"],
+        thickTop: row_elem["thickTop"],
+        thickBot: row_elem["thickBot"]
+      }
+    end
+
+    # Apply preserved row-level attributes to a rebuilt row element.
+    def apply_row_attributes(row_elem, attrs)
+      return unless attrs
+
+      row_elem["s"] = attrs[:s] if attrs[:s]
+      row_elem["ht"] = attrs[:ht] if attrs[:ht]
+      row_elem["customHeight"] = attrs[:customHeight] if attrs[:customHeight]
+      row_elem["hidden"] = attrs[:hidden] if attrs[:hidden]
+      row_elem["outlineLevel"] = attrs[:outlineLevel] if attrs[:outlineLevel]
+      row_elem["customFormat"] = attrs[:customFormat] if attrs[:customFormat]
+      row_elem["spans"] = attrs[:spans] if attrs[:spans]
+      row_elem["thickTop"] = attrs[:thickTop] if attrs[:thickTop]
+      row_elem["thickBot"] = attrs[:thickBot] if attrs[:thickBot]
+    end
+
+    private
+
+    # Collect master formulas of shared formula groups (si => formula + origin)
+    # so follower cells (<f t="shared" si="N"/> without text) can be
+    # materialized into plain formulas.
+    def collect_shared_formula_masters(ns)
+      @shared_formula_masters = {}
+      @doc.xpath("//xmlns:f[@t='shared']", "xmlns" => ns.href).each do |f|
+        si = f["si"]
+        next unless si
+        next if f.text.to_s.empty?
+        next if @shared_formula_masters.key?(si)
+
+        ref = f.parent["r"]
+        next unless ref
+
+        cr = CellReference.new(ref)
+        @shared_formula_masters[si] = {
+          formula: f.text,
+          row: cr.row,
+          col_idx: CellReference.col_to_index(cr.col)
+        }
+      end
+    end
+
+    # Resolve the formula text and extra <f> attributes for a cell.
+    # Shared formulas are materialized into plain per-cell formulas; array
+    # formulas keep their t/ref attributes.
+    def resolve_formula(formula_el, col, row_num)
+      return [nil, nil] unless formula_el
+
+      t = formula_el["t"]
+      text = formula_el.text
+      text, attrs = case t
+                    when "shared"
+                      if text.to_s.empty?
+                        master = (@shared_formula_masters || {})[formula_el["si"]]
+                        if master
+                          row_delta = row_num - master[:row]
+                          col_delta = CellReference.col_to_index(col) - master[:col_idx]
+                          text = FormulaTranslator.new.translate(master[:formula], row_delta, col_delta)
+                        end
+                      end
+                      [text, nil]
+                    when "array"
+                      [text, { "t" => "array", "ref" => formula_el["ref"] }]
+                    when nil
+                      [text, nil]
+                    else
+                      [text, { "t" => t }]
+                    end
+      text = nil if text.to_s.empty?
+      [text, attrs]
+    end
+
+    def parse_cells(row_elem, row_num = nil)
+      cells = []
+      row_elem.namespace
+      row_num ||= row_elem["r"].to_i
+
+      next_col_idx = 0
+      row_elem.xpath("xmlns:c").each do |c|
+        ref = c["r"]
+        col = ref&.gsub(/\d+/, "")
+        # Cells without an r attribute are legal: derive column from position
+        col = CellReference.index_to_col(next_col_idx) if col.nil? || col.empty?
+        next_col_idx = CellReference.col_to_index(col) + 1
+        type = c["t"]
+        style = c["s"]
+        formula = c.at_xpath("xmlns:f")
+        v = c.at_xpath("xmlns:v")
+
+        text, template = extract_cell_text(c, type, v, formula)
+        formula_text, formula_attrs = resolve_formula(formula, col, row_num)
+
+        cells << {
+          col: col,
+          text: text,
+          template: template,
+          formula: formula_text,
+          formula_attrs: formula_attrs,
+          style: style,
+          type: type,
+          value: v&.text,
+          raw_cell: c
+        }
+      end
+
+      cells
+    end
+
+    # Determine the visible text (and Liquid template, if any) of a cell.
+    # @return [Array(String, String)] [text, template] (both may be nil)
+    def extract_cell_text(c, type, v, formula)
+      text = nil
+      template = nil
+
+      if type == "s" && v
+        idx = v.text.to_i
+        text = @shared_strings[idx]
+        template = text if text && (text.include?("{{") || text.include?("{%"))
+      elsif type == "inlineStr"
+        is_el = c.at_xpath("xmlns:is")
+        t_el = is_el&.at_xpath("xmlns:t")
+        text = t_el&.text || ""
+        template = text if text.include?("{{") || text.include?("{%")
+      elsif formula
+        # Formula cell — keep the formula
+        text = nil
+      elsif type == "b" && v
+        # Boolean cell
+        text = v.text == "1" ? "TRUE" : "FALSE"
+      elsif v
+        text = v.text
+      end
+
+      # Shared string reference without sharedStrings table
+      text = "" if type == "s" && !v
+
+      [text, template]
+    end
+  end
+end

data/lib/liquid_xlsx.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+require "liquid"
+
+require_relative "liquid_xlsx/version"
+require_relative "liquid_xlsx/errors"
+require_relative "liquid_xlsx/cell_reference"
+require_relative "liquid_xlsx/shared_strings"
+require_relative "liquid_xlsx/template_nodes"
+require_relative "liquid_xlsx/template_parser"
+require_relative "liquid_xlsx/formula_translator"
+require_relative "liquid_xlsx/merge_cells_transformer"
+require_relative "liquid_xlsx/filters"
+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/package"
+require_relative "liquid_xlsx/worksheet"
+require_relative "liquid_xlsx/renderer"
+require_relative "liquid_xlsx/workbook"
+require_relative "liquid_xlsx/template"
+
+# LiquidXlsx is a Ruby gem for generating .xlsx files from Excel templates
+# with Liquid syntax. Edit templates in Excel, write Liquid in cells,
+# and render the final file preserving styles, formulas, and merged cells.
+module LiquidXlsx
+  class << self
+    # Dedicated Liquid environment with the gem's custom tags. Using a scoped
+    # environment (instead of registering tags on Liquid::Environment.default)
+    # keeps the host application's Liquid configuration untouched.
+    def liquid_environment
+      @liquid_environment ||= Liquid::Environment.build do |env|
+        env.register_tag("sheet", Tags::SheetTag)
+        env.register_tag("image_tag", Tags::ImageTag)
+      end
+    end
+
+    # High-level API: render a template with data and save to output.
+    #
+    # @example
+    #   LiquidXlsx.render(
+    #     template: "invoice_template.xlsx",
+    #     output: "invoice.xlsx",
+    #     data: {
+    #       invoice: { number: "INV-001", paid: true },
+    #       customer: { name: "ООО Ромашка" },
+    #       items: [
+    #         { title: "Разработка", qty: 10, price: 100 },
+    #         { title: "Поддержка", qty: 5, price: 50 }
+    #       ]
+    #     }
+    #   )
+    #
+    # @param template [String] path to .xlsx template file
+    # @param output [String] path to output .xlsx file
+    # @param data [Hash, Liquid::Drop, #to_liquid] data to render. A Hash, a
+    #   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 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
+    # @param images [Hash] image rendering options: { loader:, default_dpi: }
+    # @param liquid_resource_limits [Hash, nil] optional Liquid resource limits:
+    #   { render_length_limit:, render_score_limit:, assign_score_limit: }
+    # rubocop:disable Metrics/ParameterLists
+    def render(template:, output:, data:,
+               strict_variables: false, strict_filters: false,
+               recalculate_formulas: false, remove_template_comments: false,
+               dynamic_sheets: false, hide_control_sheets: true,
+               hide_template_sheets: false, images: nil,
+               liquid_resource_limits: nil)
+      tpl = Template.new(template, {
+                           strict_variables: strict_variables,
+                           strict_filters: strict_filters,
+                           recalculate_formulas: recalculate_formulas,
+                           remove_template_comments: remove_template_comments,
+                           dynamic_sheets: dynamic_sheets,
+                           hide_control_sheets: hide_control_sheets,
+                           hide_template_sheets: hide_template_sheets,
+                           images: images || {},
+                           liquid_resource_limits: liquid_resource_limits
+                         })
+      # rubocop:enable Metrics/ParameterLists
+      tpl.render_to_file(data, output)
+    end
+  end
+end

metadata

@@ -0,0 +1,142 @@
+--- !ruby/object:Gem::Specification
+name: liquid_xlsx
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Ivan Khlipitkin
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: base64
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.2'
+- !ruby/object:Gem::Dependency
+  name: liquid
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '5.4'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '6'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '5.4'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '6'
+- !ruby/object:Gem::Dependency
+  name: nokogiri
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.14'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.14'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '2'
+- !ruby/object:Gem::Dependency
+  name: rubyzip
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '2.3'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '4'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '2.3'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '4'
+description: A Ruby library for generating .xlsx files from Excel templates using
+  Liquid template syntax. Edit your template in Excel, write {{ variables }} and {%
+  for %} loops in cells, and render the final file preserving styles, formulas, and
+  merged cells.
+email:
+- ivan.khlipitkin@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- LICENSE.txt
+- README.md
+- lib/liquid_xlsx.rb
+- lib/liquid_xlsx/cell_reference.rb
+- lib/liquid_xlsx/drawing_builder.rb
+- lib/liquid_xlsx/errors.rb
+- lib/liquid_xlsx/filters.rb
+- lib/liquid_xlsx/formula_translator.rb
+- lib/liquid_xlsx/image.rb
+- lib/liquid_xlsx/merge_cells_transformer.rb
+- lib/liquid_xlsx/package.rb
+- lib/liquid_xlsx/renderer.rb
+- lib/liquid_xlsx/shared_strings.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/version.rb
+- lib/liquid_xlsx/workbook.rb
+- lib/liquid_xlsx/worksheet.rb
+homepage: https://rubygems.org/gems/liquid_xlsx
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://rubygems.org/gems/liquid_xlsx
+  documentation_uri: https://rubydoc.info/gems/liquid_xlsx
+  rubygems_mfa_required: 'true'
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.1'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.9
+specification_version: 4
+summary: Generate .xlsx files from Excel templates with Liquid syntax
+test_files: []