Visual Examples Gallery

This gallery showcases xlsxrb DSL usage side-by-side with the visual rendering in LibreOffice Calc.

◄ Back to README

Capability Overview

Feature	Visual Preview	Link to Detail
Align Horizontal		View Code & Detail
Align Horizontal Fill		View Code & Detail
Align Horizontal Justify		View Code & Detail
Align Indent		View Code & Detail
Align Text Rotation		View Code & Detail
Align Text Wrap		View Code & Detail
Align Vertical		View Code & Detail
Basic Data		View Code & Detail
Borders		View Code & Detail
Cell Booleans		View Code & Detail
Cell Dates		View Code & Detail
Cell Formulas		View Code & Detail
Cell Num Currency Jpy		View Code & Detail
Cell Num Custom Colors		View Code & Detail
Cell Num Fractions		View Code & Detail
Cell Num Percent Decimals		View Code & Detail
Cell Num Scientific		View Code & Detail
Cell Numbers		View Code & Detail
Cell Rich Text		View Code & Detail
Cell Times		View Code & Detail
Cf Begins With		View Code & Detail
Cf Cell Between		View Code & Detail
Cf Cell Equal To		View Code & Detail
Cf Cell Greater Equal		View Code & Detail
Cf Cell Greater Than		View Code & Detail
Cf Cell Less Than		View Code & Detail
Cf Color Scale		View Code & Detail
Cf Contains Text		View Code & Detail
Cf Data Bar		View Code & Detail
Cf Ends With		View Code & Detail
Cf Expression Formula		View Code & Detail
Cf Icon Set		View Code & Detail
Chart Area		View Code & Detail
Chart Area Stacked		View Code & Detail
Chart Bar		View Code & Detail
Chart Bar Percent Stacked		View Code & Detail
Chart Bar Stacked		View Code & Detail
Chart Doughnut		View Code & Detail
Chart Line		View Code & Detail
Chart Line Stacked		View Code & Detail
Chart Pie		View Code & Detail
Chart Radar		View Code & Detail
Chart Scatter		View Code & Detail
Col Grouping		View Code & Detail
Col Width Tall		View Code & Detail
Col Widths		View Code & Detail
Conditional Formatting		View Code & Detail
Drawing Shapes		View Code & Detail
Embedded Images		View Code & Detail
Fill Gradients		View Code & Detail
Fill Patterns		View Code & Detail
Fill Solid Colors		View Code & Detail
Fonts		View Code & Detail
Interactive Autofilter		View Code & Detail
Interactive Comments		View Code & Detail
Interactive Validation Custom		View Code & Detail
Interactive Validation Date		View Code & Detail
Interactive Validation List		View Code & Detail
Interactive Validation Range		View Code & Detail
Interactive Validation Text Length		View Code & Detail
Interactive Validation Time		View Code & Detail
Japanese Text		View Code & Detail
Merge Freeze		View Code & Detail
Page Grid Lines Print		View Code & Detail
Page Header Footer		View Code & Detail
Page Headings Print		View Code & Detail
Page Margins Narrow		View Code & Detail
Page Margins Wide		View Code & Detail
Page Orientation Landscape		View Code & Detail
Page Paper Size A3		View Code & Detail
Pivot Table		View Code & Detail
Row Grouping		View Code & Detail
Row Height Tall		View Code & Detail
Row Heights		View Code & Detail
Sheet Tab Colors		View Code & Detail
Sparkline Column		View Code & Detail
Sparkline Line		View Code & Detail
Styles Fonts Fills		View Code & Detail
Table Styles		View Code & Detail
View Show Grid Lines		View Code & Detail
View Zoom Scale		View Code & Detail
Workbook Three Sheets		View Code & Detail

Align Horizontal

Demonstrates horizontal text alignment (left, center, right).

Rendered Output (LibreOffice Calc)

DSL Code

# frozen_string_literal: true

require "xlsxrb"
output_path = ARGV[0] || "align_horizontal.xlsx"
Xlsxrb.write(output_path) do |wb|
  wb.style("left") { |s| s.align_horizontal("left") }
  wb.style("center") { |s| s.align_horizontal("center") }
  wb.style("right") { |s| s.align_horizontal("right") }
  wb.sheet("Alignment") do |s|
    s.print_options(:grid_lines, true)
    s.column(0, width: 20)
    s.column(1, width: 20)
    s.column(2, width: 20)
    s.row(%w[Left Center Right], styles: { 0 => "left", 1 => "center", 2 => "right" })
  end
end

# 2. Read the generated sheet and print the parsed alignments
puts "=== Read Alignment (Xlsxrb.read) ==="
workbook = Xlsxrb.read(output_path).load
sheet = workbook.sheets.first
row = sheet.rows.first

row.cells.each do |c|
  xf = workbook.styles[:cell_xfs][c.style_index] if c.style_index
  align_h = xf&.dig(:alignment, :horizontal)
  puts "Cell #{c.ref} ('#{c.value}'): align_horizontal = #{align_h.inspect}"
end

Console Output

=== Read Alignment (Xlsxrb.read) ===
Cell A1 ('Left'): align_horizontal = "left"
Cell B1 ('Center'): align_horizontal = "center"
Cell C1 ('Right'): align_horizontal = "right"

Align Horizontal Fill

Demonstrates horizontal fill alignment (repeats value to fill cell width).

Rendered Output (LibreOffice Calc)

DSL Code

# frozen_string_literal: true

require "xlsxrb"
output_path = ARGV[0] || "align_horizontal_fill.xlsx"
Xlsxrb.write(output_path) do |wb|
  wb.style("fill_align") { |s| s.align_horizontal("fill") }
  wb.sheet("Alignment") do |s|
    s.column(0, width: 30)
    s.row(["X "], styles: { 0 => "fill_align" })
  end
end

# 2. Read the generated sheet and print the parsed alignments
puts "=== Read Validation ==="
workbook = Xlsxrb.read(output_path).load
sheet = workbook.sheets.first
row = sheet.rows.first
row.cells.each do |c|
  xf = workbook.styles[:cell_xfs][c.style_index] if c.style_index
  align_h = xf&.dig(:alignment, :horizontal)
  align_v = xf&.dig(:alignment, :vertical)
  wrap = xf&.dig(:alignment, :wrap_text)
  indent = xf&.dig(:alignment, :indent)
  rot = xf&.dig(:alignment, :text_rotation)
  shrink = xf&.dig(:alignment, :shrink_to_fit)
  puts "Cell #{c.ref} ('#{c.value}'): align_h=#{align_h.inspect}, align_v=#{align_v.inspect}, wrap=#{wrap.inspect}, indent=#{indent.inspect}, rotation=#{rot.inspect}, shrink=#{shrink.inspect}"
end

Console Output

=== Read Validation ===
Cell A1 ('X '): align_h="fill", align_v=nil, wrap=nil, indent=nil, rotation=nil, shrink=nil

Align Horizontal Justify

Demonstrates horizontal justify text alignment.

Rendered Output (LibreOffice Calc)

DSL Code

# frozen_string_literal: true

require "xlsxrb"
output_path = ARGV[0] || "align_horizontal_justify.xlsx"
Xlsxrb.write(output_path) do |wb|
  wb.style("justify_align") do |s|
    s.align_horizontal("justify")
    s.wrap_text(true)
  end
  wb.sheet("Alignment") do |s|
    s.column(0, width: 25)
    s.row(["Justified alignment wraps and distributes text evenly."], styles: { 0 => "justify_align" })
  end
end

# 2. Read the generated sheet and print the parsed alignments
puts "=== Read Validation ==="
workbook = Xlsxrb.read(output_path).load
sheet = workbook.sheets.first
row = sheet.rows.first
row.cells.each do |c|
  xf = workbook.styles[:cell_xfs][c.style_index] if c.style_index
  align_h = xf&.dig(:alignment, :horizontal)
  align_v = xf&.dig(:alignment, :vertical)
  wrap = xf&.dig(:alignment, :wrap_text)
  indent = xf&.dig(:alignment, :indent)
  rot = xf&.dig(:alignment, :text_rotation)
  shrink = xf&.dig(:alignment, :shrink_to_fit)
  puts "Cell #{c.ref} ('#{c.value}'): align_h=#{align_h.inspect}, align_v=#{align_v.inspect}, wrap=#{wrap.inspect}, indent=#{indent.inspect}, rotation=#{rot.inspect}, shrink=#{shrink.inspect}"
end

Console Output

=== Read Validation ===
Cell A1 ('Justified alignment wraps and distributes text evenly.'): align_h="justify", align_v=nil, wrap=true, indent=nil, rotation=nil, shrink=nil

Align Indent

Demonstrates text indentation inside cells.

Rendered Output (LibreOffice Calc)

DSL Code

# frozen_string_literal: true

require "xlsxrb"
output_path = ARGV[0] || "align_indent.xlsx"
Xlsxrb.write(output_path) do |wb|
  wb.style("indent_1") { |s| s.align_horizontal("left").indent(1) }
  wb.style("indent_3") { |s| s.align_horizontal("left").indent(3) }
  wb.sheet("Indent") do |s|
    s.column(0, width: 25)
    s.column(1, width: 25)
    s.print_options(:grid_lines, true)
    s.row(["No Indent"])
    s.row(["Indent 1"], styles: { 0 => "indent_1" })
    s.row(["Indent 3"], styles: { 0 => "indent_3" })
  end
end

# 2. Read the generated sheet and print the parsed alignments
puts "=== Read Validation ==="
workbook = Xlsxrb.read(output_path).load
sheet = workbook.sheets.first
row = sheet.rows.first
row.cells.each do |c|
  xf = workbook.styles[:cell_xfs][c.style_index] if c.style_index
  align_h = xf&.dig(:alignment, :horizontal)
  align_v = xf&.dig(:alignment, :vertical)
  wrap = xf&.dig(:alignment, :wrap_text)
  indent = xf&.dig(:alignment, :indent)
  rot = xf&.dig(:alignment, :text_rotation)
  shrink = xf&.dig(:alignment, :shrink_to_fit)
  puts "Cell #{c.ref} ('#{c.value}'): align_h=#{align_h.inspect}, align_v=#{align_v.inspect}, wrap=#{wrap.inspect}, indent=#{indent.inspect}, rotation=#{rot.inspect}, shrink=#{shrink.inspect}"
end

Console Output

=== Read Validation ===
Cell A1 ('No Indent'): align_h=nil, align_v=nil, wrap=nil, indent=nil, rotation=nil, shrink=nil

Align Text Rotation

Demonstrates text rotated by specific angles (45, 90 degrees).

Rendered Output (LibreOffice Calc)

DSL Code

# frozen_string_literal: true

require "xlsxrb"
output_path = ARGV[0] || "align_text_rotation.xlsx"
Xlsxrb.write(output_path) do |wb|
  wb.style("rot_45") { |s| s.text_rotation(45) }
  wb.style("rot_90") { |s| s.text_rotation(90) }
  wb.sheet("Rotation") do |s|
    s.column(0, width: 25)
    s.column(1, width: 25)
    s.print_options(:grid_lines, true)
    s.row(["Rotated 45", "Rotated 90"], styles: { 0 => "rot_45", 1 => "rot_90" }, height: 50)
  end
end

# 2. Read the generated sheet and print the parsed alignments
puts "=== Read Validation ==="
workbook = Xlsxrb.read(output_path).load
sheet = workbook.sheets.first
row = sheet.rows.first
row.cells.each do |c|
  xf = workbook.styles[:cell_xfs][c.style_index] if c.style_index
  align_h = xf&.dig(:alignment, :horizontal)
  align_v = xf&.dig(:alignment, :vertical)
  wrap = xf&.dig(:alignment, :wrap_text)
  indent = xf&.dig(:alignment, :indent)
  rot = xf&.dig(:alignment, :text_rotation)
  shrink = xf&.dig(:alignment, :shrink_to_fit)
  puts "Cell #{c.ref} ('#{c.value}'): align_h=#{align_h.inspect}, align_v=#{align_v.inspect}, wrap=#{wrap.inspect}, indent=#{indent.inspect}, rotation=#{rot.inspect}, shrink=#{shrink.inspect}"
end

Console Output

=== Read Validation ===
Cell A1 ('Rotated 45'): align_h=nil, align_v=nil, wrap=nil, indent=nil, rotation=45, shrink=nil
Cell B1 ('Rotated 90'): align_h=nil, align_v=nil, wrap=nil, indent=nil, rotation=90, shrink=nil

Align Text Wrap

Demonstrates auto-wrapping multi-line text inside narrow cells.

Rendered Output (LibreOffice Calc)

DSL Code

# frozen_string_literal: true

require "xlsxrb"
output_path = ARGV[0] || "align_text_wrap.xlsx"
Xlsxrb.write(output_path) do |wb|
  wb.style("wrap", &:wrap_text)
  wb.sheet("Text Wrap") do |s|
    s.print_options(:grid_lines, true)
    s.column(0, width: 15)
    s.row(["This is a long sentence that wraps inside the cell."], styles: { 0 => "wrap" })
  end
end

# 2. Read the generated sheet and print the parsed alignments
puts "=== Read Validation ==="
workbook = Xlsxrb.read(output_path).load
sheet = workbook.sheets.first
row = sheet.rows.first
row.cells.each do |c|
  xf = workbook.styles[:cell_xfs][c.style_index] if c.style_index
  align_h = xf&.dig(:alignment, :horizontal)
  align_v = xf&.dig(:alignment, :vertical)
  wrap = xf&.dig(:alignment, :wrap_text)
  indent = xf&.dig(:alignment, :indent)
  rot = xf&.dig(:alignment, :text_rotation)
  shrink = xf&.dig(:alignment, :shrink_to_fit)
  puts "Cell #{c.ref} ('#{c.value}'): align_h=#{align_h.inspect}, align_v=#{align_v.inspect}, wrap=#{wrap.inspect}, indent=#{indent.inspect}, rotation=#{rot.inspect}, shrink=#{shrink.inspect}"
end

Console Output

=== Read Validation ===
Cell A1 ('This is a long sentence that wraps inside the cell.'): align_h=nil, align_v=nil, wrap=true, indent=nil, rotation=nil, shrink=nil

Align Vertical

Demonstrates vertical text alignment (top, center, bottom).

Rendered Output (LibreOffice Calc)

DSL Code

# frozen_string_literal: true

require "xlsxrb"
output_path = ARGV[0] || "align_vertical.xlsx"
Xlsxrb.write(output_path) do |wb|
  wb.style("top") { |s| s.align_vertical("top") }
  wb.style("center") { |s| s.align_vertical("center") }
  wb.style("bottom") { |s| s.align_vertical("bottom") }
  wb.sheet("Vertical Alignment") do |s|
    s.column(0, width: 25)
    s.column(1, width: 25)
    s.print_options(:grid_lines, true)
    s.row(%w[Top Center Bottom], styles: { 0 => "top", 1 => "center", 2 => "bottom" }, height: 40)
  end
end

# 2. Read the generated sheet and print the parsed alignments
puts "=== Read Validation ==="
workbook = Xlsxrb.read(output_path).load
sheet = workbook.sheets.first
row = sheet.rows.first
row.cells.each do |c|
  xf = workbook.styles[:cell_xfs][c.style_index] if c.style_index
  align_h = xf&.dig(:alignment, :horizontal)
  align_v = xf&.dig(:alignment, :vertical)
  wrap = xf&.dig(:alignment, :wrap_text)
  indent = xf&.dig(:alignment, :indent)
  rot = xf&.dig(:alignment, :text_rotation)
  shrink = xf&.dig(:alignment, :shrink_to_fit)
  puts "Cell #{c.ref} ('#{c.value}'): align_h=#{align_h.inspect}, align_v=#{align_v.inspect}, wrap=#{wrap.inspect}, indent=#{indent.inspect}, rotation=#{rot.inspect}, shrink=#{shrink.inspect}"
end

Console Output

=== Read Validation ===
Cell A1 ('Top'): align_h=nil, align_v="top", wrap=nil, indent=nil, rotation=nil, shrink=nil
Cell B1 ('Center'): align_h=nil, align_v="center", wrap=nil, indent=nil, rotation=nil, shrink=nil
Cell C1 ('Bottom'): align_h=nil, align_v="bottom", wrap=nil, indent=nil, rotation=nil, shrink=nil

Basic Data

Demonstrates simple tabular data writing with basic Ruby types (Strings, Numbers, Dates, Booleans).

Rendered Output (LibreOffice Calc)

DSL Code

# frozen_string_literal: true

require "xlsxrb"
require "date"

output_path = ARGV[0] || "basic_data.xlsx"

Xlsxrb.write(output_path) do |wb|
  wb.style("currency") { |style| style.number_format("$#,##0.00") }
  wb.style("date") { |style| style.number_format("yyyy-mm-dd") }
  wb.sheet("Basic Data") do |sheet|
    sheet.sheet_properties(:fit_to_page, true)
    sheet.page_setup(fit_to_width: 1, fit_to_height: 1)
    sheet.column(0, width: 25)
    sheet.column(1, width: 25)
    sheet.row(%w[Product Qty Price Date Active])
    sheet.row(["Gadget A", 10, 99.99, Date.new(2026, 1, 15), true], styles: { 2 => "currency", 3 => "date" })
    sheet.row(["Widget B", 5, 49.50, Date.new(2026, 2, 20), false], styles: { 2 => "currency", 3 => "date" })
  end
end

# 2. Read the generated sheet and print parsed cell values and Ruby classes
puts "=== Read Validation ==="
workbook = Xlsxrb.read(output_path).load
sheet = workbook.sheets.first
sheet.rows.each do |row|
  row_cells = row.cells.map do |c|
    "#{c.ref}: #{c.value.inspect} (#{c.value.class})"
  end
  puts "Row #{row.index}: #{row_cells.join(", ")}"
end

Console Output

=== Read Validation ===
Row 0: A1: "Product" (String), B1: "Qty" (String), C1: "Price" (String), D1: "Date" (String), E1: "Active" (String)
Row 1: A2: "Gadget A" (String), B2: 10 (Integer), C2: 99.99 (Float), D2: 46037 (Integer), E2: true (TrueClass)
Row 2: A3: "Widget B" (String), B3: 5 (Integer), C3: 49.5 (Float), D3: 46073 (Integer), E3: false (FalseClass)

Borders

Demonstrates border styles (thin, medium, thick, hair, dashed, medium dashed, dotted, double, dash-dot, medium dash-dot, dash-dot-dot, slanted, and diagonal cross borders) applied to cell ranges.

Rendered Output (LibreOffice Calc)

DSL Code

# frozen_string_literal: true

require "xlsxrb"

output_path = ARGV[0] || "borders.xlsx"

Xlsxrb.write(output_path) do |wb|
  wb.style("thin") { |s| s.border_all(style: "thin", color: "FF000000") }
  wb.style("medium") { |s| s.border_all(style: "medium", color: "FF000000") }
  wb.style("thick") { |s| s.border_all(style: "thick", color: "FF000000") }
  wb.style("hair") { |s| s.border_all(style: "hair", color: "FF000000") }
  wb.style("dashed") { |s| s.border_all(style: "dashed", color: "FF000000") }
  wb.style("medium_dashed") { |s| s.border_all(style: "mediumDashed", color: "FF000000") }
  wb.style("dotted") { |s| s.border_all(style: "dotted", color: "FF000000") }
  wb.style("double") { |s| s.border_all(style: "double", color: "FF000000") }
  wb.style("dash_dot") { |s| s.border_all(style: "dashDot", color: "FF000000") }
  wb.style("medium_dash_dot") { |s| s.border_all(style: "mediumDashDot", color: "FF000000") }
  wb.style("dash_dot_dot") { |s| s.border_all(style: "dashDotDot", color: "FF000000") }
  wb.style("slanted") { |s| s.border_all(style: "slantedDashDot", color: "FF000000") }
  wb.style("diagonal") { |s| s.border_diagonal(style: "thin", color: "FF000000", up: true, down: true) }

  wb.sheet("Borders") do |s|
    s.column(0, width: 25)
    s.column(1, width: 25)
    s.print_options(:grid_lines, true)

    s.row(["Border Style", "Cell Preview"])
    s.row(["Thin", "Thin Border"], styles: { 1 => "thin" })
    s.row(["Medium", "Medium Border"], styles: { 1 => "medium" })
    s.row(["Thick", "Thick Border"], styles: { 1 => "thick" })
    s.row(["Hair", "Hair Border"], styles: { 1 => "hair" })
    s.row(["Dashed", "Dashed Border"], styles: { 1 => "dashed" })
    s.row(["Medium Dashed", "Medium Dashed"], styles: { 1 => "medium_dashed" })
    s.row(["Dotted", "Dotted Border"], styles: { 1 => "dotted" })
    s.row(["Double", "Double Border"], styles: { 1 => "double" })
    s.row(["Dash-Dot", "Dash-Dot Border"], styles: { 1 => "dash_dot" })
    s.row(["Medium Dash-Dot", "Medium Dash-Dot"], styles: { 1 => "medium_dash_dot" })
    s.row(%w[Dash-Dot-Dot Dash-Dot-Dot], styles: { 1 => "dash_dot_dot" })
    s.row(["Slanted Dash-Dot", "Slanted Border"], styles: { 1 => "slanted" })
    s.row(["Diagonal (Cross)", "Diagonal Border"], styles: { 1 => "diagonal" })
  end
end

# Read check
puts "=== Read Validation ==="
workbook = Xlsxrb.read(output_path).load
sheet = workbook.sheets.first
sheet.rows.each do |row|
  row_cells = row.cells.map do |c|
    xf = workbook.styles[:cell_xfs][c.style_index] if c.style_index
    border_id = xf ? xf[:border_id] : 0
    "#{c.ref}: #{c.value.inspect} (border_id: #{border_id})"
  end
  puts "Row #{row.index}: #{row_cells.join(", ")}"
end

Console Output

=== Read Validation ===
Row 0: A1: "Border Style" (border_id: 0), B1: "Cell Preview" (border_id: 0)
Row 1: A2: "Thin" (border_id: 0), B2: "Thin Border" (border_id: 1)
Row 2: A3: "Medium" (border_id: 0), B3: "Medium Border" (border_id: 2)
Row 3: A4: "Thick" (border_id: 0), B4: "Thick Border" (border_id: 3)
Row 4: A5: "Hair" (border_id: 0), B5: "Hair Border" (border_id: 4)
Row 5: A6: "Dashed" (border_id: 0), B6: "Dashed Border" (border_id: 5)
Row 6: A7: "Medium Dashed" (border_id: 0), B7: "Medium Dashed" (border_id: 6)
Row 7: A8: "Dotted" (border_id: 0), B8: "Dotted Border" (border_id: 7)
Row 8: A9: "Double" (border_id: 0), B9: "Double Border" (border_id: 8)
Row 9: A10: "Dash-Dot" (border_id: 0), B10: "Dash-Dot Border" (border_id: 9)
Row 10: A11: "Medium Dash-Dot" (border_id: 0), B11: "Medium Dash-Dot" (border_id: 10)
Row 11: A12: "Dash-Dot-Dot" (border_id: 0), B12: "Dash-Dot-Dot" (border_id: 11)
Row 12: A13: "Slanted Dash-Dot" (border_id: 0), B13: "Slanted Border" (border_id: 12)
Row 13: A14: "Diagonal (Cross)" (border_id: 0), B14: "Diagonal Border" (border_id: 13)

Cell Booleans

Demonstrates boolean values serialized and rendered.

Rendered Output (LibreOffice Calc)

DSL Code

# frozen_string_literal: true

require "xlsxrb"
output_path = ARGV[0] || "cell_booleans.xlsx"
Xlsxrb.write(output_path) do |wb|
  wb.sheet("Booleans") do |s|
    s.column(0, width: 25)
    s.column(1, width: 25)
    s.row(["Label", "Boolean Value"])
    s.row(["Is Active", true])
    s.row(["Is Pending", false])
  end
end

# 2. Read the generated sheet and print parsed cell values and Ruby classes
puts "=== Read Validation ==="
workbook = Xlsxrb.read(output_path).load
sheet = workbook.sheets.first
sheet.rows.each do |row|
  row_cells = row.cells.map do |c|
    "#{c.ref}: #{c.value.inspect} (#{c.value.class})"
  end
  puts "Row #{row.index}: #{row_cells.join(", ")}"
end

Console Output

=== Read Validation ===
Row 0: A1: "Label" (String), B1: "Boolean Value" (String)
Row 1: A2: "Is Active" (String), B2: true (TrueClass)
Row 2: A3: "Is Pending" (String), B3: false (FalseClass)

Cell Dates

Demonstrates dates serialized natively and formatted with standard or custom format strings.

Rendered Output (LibreOffice Calc)

DSL Code

# frozen_string_literal: true

require "xlsxrb"
require "date"
output_path = ARGV[0] || "cell_dates.xlsx"
Xlsxrb.write(output_path) do |wb|
  wb.style("custom_date") { |s| s.num_fmt("yyyy-mm-dd") }
  wb.sheet("Dates") do |s|
    s.column(0, width: 25)
    s.column(1, width: 25)
    s.row(["Format", "Date Value"])
    s.row(["Default Date", Date.new(2026, 7, 1)])
    s.row(["Formatted Date", Date.new(2026, 12, 25)], styles: { 1 => "custom_date" })
  end
end

# 2. Read the generated sheet and print parsed cell values and Ruby classes
puts "=== Read Validation ==="
workbook = Xlsxrb.read(output_path).load
sheet = workbook.sheets.first
sheet.rows.each do |row|
  row_cells = row.cells.map do |c|
    "#{c.ref}: #{c.value.inspect} (#{c.value.class})"
  end
  puts "Row #{row.index}: #{row_cells.join(", ")}"
end

Console Output

=== Read Validation ===
Row 0: A1: "Format" (String), B1: "Date Value" (String)
Row 1: A2: "Default Date" (String), B2: 46204 (Integer)
Row 2: A3: "Formatted Date" (String), B3: 46381 (Integer)

Cell Formulas

Demonstrates standard spreadsheet calculations and formulas (SUM, AVERAGE).

Rendered Output (LibreOffice Calc)

DSL Code

# frozen_string_literal: true

require "xlsxrb"
output_path = ARGV[0] || "cell_formulas.xlsx"
Xlsxrb.write(output_path) do |wb|
  wb.sheet("Formulas") do |s|
    s.column(0, width: 25)
    s.column(1, width: 25)
    s.row(%w[Item Value])
    s.row(["A", 10])
    s.row(["B", 20])
    s.row(["SUM", Xlsxrb::Elements::Formula.new(expression: "SUM(B2:B3)", cached_value: 30)])
    s.row(["AVERAGE", Xlsxrb::Elements::Formula.new(expression: "AVERAGE(B2:B3)", cached_value: 15)])
  end
end

# 2. Read the generated sheet and print parsed cell values and Ruby classes
puts "=== Read Validation ==="
workbook = Xlsxrb.read(output_path).load
sheet = workbook.sheets.first
sheet.rows.each do |row|
  row_cells = row.cells.map do |c|
    "#{c.ref}: #{c.value.inspect} (#{c.value.class})"
  end
  puts "Row #{row.index}: #{row_cells.join(", ")}"
end

Console Output

=== Read Validation ===
Row 0: A1: "Item" (String), B1: "Value" (String)
Row 1: A2: "A" (String), B2: 10 (Integer)
Row 2: A3: "B" (String), B3: 20 (Integer)
Row 3: A4: "SUM" (String), B4: 30 (Integer)
Row 4: A5: "AVERAGE" (String), B5: 15 (Integer)

Cell Num Currency Jpy

Demonstrates Yen Currency format code formatting.

Rendered Output (LibreOffice Calc)

DSL Code

# frozen_string_literal: true

require "xlsxrb"
output_path = ARGV[0] || "cell_num_currency_jpy.xlsx"
Xlsxrb.write(output_path) do |wb|
  wb.style("jpy") { |s| s.num_fmt("¥#,##0;[Red]¥-#,##0") }
  wb.sheet("JPY Currency") do |s|
    s.column(0, width: 25)
    s.column(1, width: 25)
    s.row(%w[Format Value])
    s.row(["Positive Yen", 12_500], styles: { 1 => "jpy" })
    s.row(["Negative Yen", -8000], styles: { 1 => "jpy" })
  end
end

# 2. Read the generated sheet and print parsed cell numbers and format codes
puts "=== Read Validation ==="
workbook = Xlsxrb.read(output_path).load
sheet = workbook.sheets.first
sheet.rows.each do |row|
  row_cells = row.cells.map do |c|
    xf = workbook.styles[:cell_xfs][c.style_index] if c.style_index
    num_fmt = xf ? workbook.styles[:num_fmts][xf[:num_fmt_id]] : nil
    "#{c.ref}: #{c.value.inspect} (Format ID: #{xf&.[](:num_fmt_id)}, Code: #{num_fmt.inspect})"
  end
  puts "Row #{row.index}: #{row_cells.join(", ")}"
end

Console Output

=== Read Validation ===
Row 0: A1: "Format" (Format ID: , Code: nil), B1: "Value" (Format ID: , Code: nil)
Row 1: A2: "Positive Yen" (Format ID: , Code: nil), B2: 12500 (Format ID: 164, Code: "¥#,##0;[Red]¥-#,##0")
Row 2: A3: "Negative Yen" (Format ID: , Code: nil), B3: -8000 (Format ID: 164, Code: "¥#,##0;[Red]¥-#,##0")

Cell Num Custom Colors

Demonstrates custom colored formats for positive and negative numbers.

Rendered Output (LibreOffice Calc)

DSL Code

# frozen_string_literal: true

require "xlsxrb"
output_path = ARGV[0] || "cell_num_custom_colors.xlsx"
Xlsxrb.write(output_path) do |wb|
  wb.style("custom_color") { |s| s.num_fmt("[Green]#,##0;[Red]-#,##0") }
  wb.sheet("Custom Colors") do |s|
    s.column(0, width: 25)
    s.column(1, width: 25)
    s.row(%w[Format Value])
    s.row(["Positive (Green)", 5000], styles: { 1 => "custom_color" })
    s.row(["Negative (Red)", -2500], styles: { 1 => "custom_color" })
  end
end

# 2. Read the generated sheet and print parsed cell numbers and format codes
puts "=== Read Validation ==="
workbook = Xlsxrb.read(output_path).load
sheet = workbook.sheets.first
sheet.rows.each do |row|
  row_cells = row.cells.map do |c|
    xf = workbook.styles[:cell_xfs][c.style_index] if c.style_index
    num_fmt = xf ? workbook.styles[:num_fmts][xf[:num_fmt_id]] : nil
    "#{c.ref}: #{c.value.inspect} (Format ID: #{xf&.[](:num_fmt_id)}, Code: #{num_fmt.inspect})"
  end
  puts "Row #{row.index}: #{row_cells.join(", ")}"
end

Console Output

=== Read Validation ===
Row 0: A1: "Format" (Format ID: , Code: nil), B1: "Value" (Format ID: , Code: nil)
Row 1: A2: "Positive (Green)" (Format ID: , Code: nil), B2: 5000 (Format ID: 164, Code: "[Green]#,##0;[Red]-#,##0")
Row 2: A3: "Negative (Red)" (Format ID: , Code: nil), B3: -2500 (Format ID: 164, Code: "[Green]#,##0;[Red]-#,##0")

Cell Num Fractions

Demonstrates fraction number formats (# ?/?).

Rendered Output (LibreOffice Calc)

DSL Code

# frozen_string_literal: true

require "xlsxrb"
output_path = ARGV[0] || "cell_num_fractions.xlsx"
Xlsxrb.write(output_path) do |wb|
  wb.style("frac") { |s| s.num_fmt("# ?/?") }
  wb.sheet("Fractions") do |s|
    s.column(0, width: 25)
    s.column(1, width: 25)
    s.row(%w[Format Value])
    s.row(["Half", 0.5], styles: { 1 => "frac" })
    s.row(["Third", 0.3333], styles: { 1 => "frac" })
    s.row(["Quarter", 0.75], styles: { 1 => "frac" })
  end
end

# 2. Read the generated sheet and print parsed cell numbers and format codes
puts "=== Read Validation ==="
workbook = Xlsxrb.read(output_path).load
sheet = workbook.sheets.first
sheet.rows.each do |row|
  row_cells = row.cells.map do |c|
    xf = workbook.styles[:cell_xfs][c.style_index] if c.style_index
    num_fmt = xf ? workbook.styles[:num_fmts][xf[:num_fmt_id]] : nil
    "#{c.ref}: #{c.value.inspect} (Format ID: #{xf&.[](:num_fmt_id)}, Code: #{num_fmt.inspect})"
  end
  puts "Row #{row.index}: #{row_cells.join(", ")}"
end

Console Output

=== Read Validation ===
Row 0: A1: "Format" (Format ID: , Code: nil), B1: "Value" (Format ID: , Code: nil)
Row 1: A2: "Half" (Format ID: , Code: nil), B2: 0.5 (Format ID: 164, Code: "# ?/?")
Row 2: A3: "Third" (Format ID: , Code: nil), B3: 0.3333 (Format ID: 164, Code: "# ?/?")
Row 3: A4: "Quarter" (Format ID: , Code: nil), B4: 0.75 (Format ID: 164, Code: "# ?/?")

Cell Num Percent Decimals

Demonstrates percentages with two decimal places (0.00%).

Rendered Output (LibreOffice Calc)

DSL Code

# frozen_string_literal: true

require "xlsxrb"
output_path = ARGV[0] || "cell_num_percent_decimals.xlsx"
Xlsxrb.write(output_path) do |wb|
  wb.style("pct2") { |s| s.num_fmt("0.00%") }
  wb.sheet("Percents") do |s|
    s.column(0, width: 25)
    s.column(1, width: 25)
    s.row(%w[Format Value])
    s.row(["Percent with 2 Decimals", 0.12345], styles: { 1 => "pct2" })
  end
end

# 2. Read the generated sheet and print parsed cell numbers and format codes
puts "=== Read Validation ==="
workbook = Xlsxrb.read(output_path).load
sheet = workbook.sheets.first
sheet.rows.each do |row|
  row_cells = row.cells.map do |c|
    xf = workbook.styles[:cell_xfs][c.style_index] if c.style_index
    num_fmt = xf ? workbook.styles[:num_fmts][xf[:num_fmt_id]] : nil
    "#{c.ref}: #{c.value.inspect} (Format ID: #{xf&.[](:num_fmt_id)}, Code: #{num_fmt.inspect})"
  end
  puts "Row #{row.index}: #{row_cells.join(", ")}"
end

Console Output

=== Read Validation ===
Row 0: A1: "Format" (Format ID: , Code: nil), B1: "Value" (Format ID: , Code: nil)
Row 1: A2: "Percent with 2 Decimals" (Format ID: , Code: nil), B2: 0.12345 (Format ID: 164, Code: "0.00%")

Cell Num Scientific

Demonstrates scientific number formats (0.00E+00).

Rendered Output (LibreOffice Calc)

DSL Code

# frozen_string_literal: true

require "xlsxrb"
output_path = ARGV[0] || "cell_num_scientific.xlsx"
Xlsxrb.write(output_path) do |wb|
  wb.style("sci") { |s| s.num_fmt("0.00E+00") }
  wb.sheet("Scientific") do |s|
    s.column(0, width: 25)
    s.column(1, width: 25)
    s.row(%w[Format Value])
    s.row(["Scientific", 123_456_789.0], styles: { 1 => "sci" })
    s.row(["Small Scientific", 0.00001234], styles: { 1 => "sci" })
  end
end

# 2. Read the generated sheet and print parsed cell numbers and format codes
puts "=== Read Validation ==="
workbook = Xlsxrb.read(output_path).load
sheet = workbook.sheets.first
sheet.rows.each do |row|
  row_cells = row.cells.map do |c|
    xf = workbook.styles[:cell_xfs][c.style_index] if c.style_index
    num_fmt = xf ? workbook.styles[:num_fmts][xf[:num_fmt_id]] : nil
    "#{c.ref}: #{c.value.inspect} (Format ID: #{xf&.[](:num_fmt_id)}, Code: #{num_fmt.inspect})"
  end
  puts "Row #{row.index}: #{row_cells.join(", ")}"
end

Console Output

=== Read Validation ===
Row 0: A1: "Format" (Format ID: , Code: nil), B1: "Value" (Format ID: , Code: nil)
Row 1: A2: "Scientific" (Format ID: , Code: nil), B2: 123456789.0 (Format ID: 164, Code: "0.00E+00")
Row 2: A3: "Small Scientific" (Format ID: , Code: nil), B3: 1.234e-05 (Format ID: 164, Code: "0.00E+00")

Cell Numbers

Demonstrates custom formatting for integers, floating point numbers, currencies, and percentages.

Rendered Output (LibreOffice Calc)

DSL Code

# frozen_string_literal: true

require "xlsxrb"
output_path = ARGV[0] || "cell_numbers.xlsx"
Xlsxrb.write(output_path) do |wb|
  wb.style("currency") { |s| s.num_fmt("$#,##0.00") }
  wb.style("percent") { |s| s.num_fmt("0.0%") }
  wb.sheet("Numbers") do |s|
    s.column(0, width: 25)
    s.column(1, width: 25)
    s.row(%w[Format Value])
    s.row(["Integer", 12_345])
    s.row(["Float", 123.456])
    s.row(["Currency", 1234.5], styles: { 1 => "currency" })
    s.row(["Percentage", 0.85], styles: { 1 => "percent" })
  end
end

# 2. Read the generated sheet and print parsed cell values and Ruby classes
puts "=== Read Validation ==="
workbook = Xlsxrb.read(output_path).load
sheet = workbook.sheets.first
sheet.rows.each do |row|
  row_cells = row.cells.map do |c|
    "#{c.ref}: #{c.value.inspect} (#{c.value.class})"
  end
  puts "Row #{row.index}: #{row_cells.join(", ")}"
end

Console Output

=== Read Validation ===
Row 0: A1: "Format" (String), B1: "Value" (String)
Row 1: A2: "Integer" (String), B2: 12345 (Integer)
Row 2: A3: "Float" (String), B3: 123.456 (Float)
Row 3: A4: "Currency" (String), B4: 1234.5 (Float)
Row 4: A5: "Percentage" (String), B5: 0.85 (Float)

Cell Rich Text

Demonstrates Rich Text cells with multiple font weights, styles, and colors in a single cell.

Rendered Output (LibreOffice Calc)

DSL Code

# frozen_string_literal: true

require "xlsxrb"
output_path = ARGV[0] || "cell_rich_text.xlsx"
Xlsxrb.write(output_path) do |wb|
  rt = Xlsxrb.rich_text(
    { text: "Normal " },
    { text: "BOLD RED ", font: { bold: true, color: "FFC00000", sz: 16 } },
    { text: "ITALIC BLUE", font: { italic: true, color: :blue, sz: 20 } }
  )
  wb.sheet("Rich Text") do |s|
    s.column(0, width: 25)
    s.column(1, width: 25)
    s.row(%w[Format Value])
    s.row(["Rich Text Cell", rt])
  end
end

# 2. Read the generated sheet and print parsed cell values and Ruby classes
puts "=== Read Validation ==="
workbook = Xlsxrb.read(output_path).load
sheet = workbook.sheets.first
sheet.rows.each do |row|
  row_cells = row.cells.map do |c|
    "#{c.ref}: #{c.value.inspect} (#{c.value.class})"
  end
  puts "Row #{row.index}: #{row_cells.join(", ")}"
end

Console Output

=== Read Validation ===
Row 0: A1: "Format" (String), B1: "Value" (String)
Row 1: A2: "Rich Text Cell" (String), B2: "Normal BOLD RED ITALIC BLUE" (String)

Cell Times

Demonstrates timestamp values serialized natively and formatted showing hours, minutes, and seconds.

Rendered Output (LibreOffice Calc)

DSL Code

# frozen_string_literal: true

require "xlsxrb"
require "time"
output_path = ARGV[0] || "cell_times.xlsx"
Xlsxrb.write(output_path) do |wb|
  wb.style("time_fmt") { |s| s.num_fmt("hh:mm:ss") }
  wb.sheet("Times") do |s|
    s.column(0, width: 25)
    s.column(1, width: 25)
    s.row(["Format", "Time Value"])
    s.row(["DateTime", Time.new(2026, 7, 1, 12, 34, 56)])
    s.row(["Time Only", Time.new(2026, 7, 1, 9, 15, 0)], styles: { 1 => "time_fmt" })
  end
end

# 2. Read the generated sheet and print parsed cell values and Ruby classes
puts "=== Read Validation ==="
workbook = Xlsxrb.read(output_path).load
sheet = workbook.sheets.first
sheet.rows.each do |row|
  row_cells = row.cells.map do |c|
    "#{c.ref}: #{c.value.inspect} (#{c.value.class})"
  end
  puts "Row #{row.index}: #{row_cells.join(", ")}"
end

Console Output

=== Read Validation ===
Row 0: A1: "Format" (String), B1: "Time Value" (String)
Row 1: A2: "DateTime" (String), B2: 46204.52425925926 (Float)
Row 2: A3: "Time Only" (String), B3: 46204.385416666664 (Float)

Cf Begins With

Demonstrates conditional formatting highlighting cells starting with specific text.

Rendered Output (LibreOffice Calc)

DSL Code

# frozen_string_literal: true

require "xlsxrb"
output_path = ARGV[0] || "cf_begins_with.xlsx"
Xlsxrb.write(output_path) do |wb|
  wb.sheet("CF Begins") do |s|
    s.column(0, width: 25)
    s.column(1, width: 25)
    s.row(["Code"])
    s.row(["A-100"])
    s.row(["B-200"])
    s.row(["A-300"])
    s.conditional_format("A2:A4", type: "beginsWith", operator: "beginsWith", text: "A", formula: 'LEFT(A2,1)="A"', fill_color: "FFFFC7CE")
  end
end

# 2. Read the generated sheet and print cell values
puts "=== Read Validation ==="
workbook = Xlsxrb.read(output_path).load
sheet = workbook.sheets.first
sheet.rows.first(5).each do |row|
  row_cells = row.cells.map { |c| "#{c.ref}: #{c.value.inspect}" }
  puts "Row #{row.index}: #{row_cells.join(", ")}"
end

Console Output

=== Read Validation ===
Row 0: A1: "Code"
Row 1: A2: "A-100"
Row 2: A3: "B-200"
Row 3: A4: "A-300"

Cf Cell Between

Demonstrates conditional formatting highlighting cells within a range.

Rendered Output (LibreOffice Calc)

DSL Code

# frozen_string_literal: true

require "xlsxrb"
output_path = ARGV[0] || "cf_cell_between.xlsx"
Xlsxrb.write(output_path) do |wb|
  wb.style("center") { |style| style.align_horizontal("center") }
  wb.sheet("CF Between") do |s|
    s.column(0, width: 25)
    s.column(1, width: 25)
    s.row(["Values"])
    s.row([15], styles: "center")
    s.row([25], styles: "center")
    s.row([5], styles: "center")
    s.conditional_format("A2:A4", type: "cellIs", operator: "between", formulas: %w[10 20], fill_color: :green)
  end
end

# 2. Read the generated sheet and print cell values
puts "=== Read Validation ==="
workbook = Xlsxrb.read(output_path).load
sheet = workbook.sheets.first
sheet.rows.first(5).each do |row|
  row_cells = row.cells.map { |c| "#{c.ref}: #{c.value.inspect}" }
  puts "Row #{row.index}: #{row_cells.join(", ")}"
end

Console Output

=== Read Validation ===
Row 0: A1: "Values"
Row 1: A2: 15
Row 2: A3: 25
Row 3: A4: 5

Cf Cell Equal To

Demonstrates conditional formatting highlighting cells equal to a target value.

Rendered Output (LibreOffice Calc)

DSL Code

# frozen_string_literal: true

require "xlsxrb"
output_path = ARGV[0] || "cf_cell_equal_to.xlsx"
Xlsxrb.write(output_path) do |wb|
  wb.style("center") { |style| style.align_horizontal("center") }
  wb.sheet("CF Equal") do |s|
    s.column(0, width: 25)
    s.column(1, width: 25)
    s.row(["Values"])
    s.row([10], styles: "center")
    s.row([20], styles: "center")
    s.row([10], styles: "center")
    s.conditional_format("A2:A4", type: "cellIs", operator: "equal", formula: "10", fill_color: "FFFFC7CE")
  end
end

# 2. Read the generated sheet and print cell values
puts "=== Read Validation ==="
workbook = Xlsxrb.read(output_path).load
sheet = workbook.sheets.first
sheet.rows.first(5).each do |row|
  row_cells = row.cells.map { |c| "#{c.ref}: #{c.value.inspect}" }
  puts "Row #{row.index}: #{row_cells.join(", ")}"
end

Console Output

=== Read Validation ===
Row 0: A1: "Values"
Row 1: A2: 10
Row 2: A3: 20
Row 3: A4: 10

Cf Cell Greater Equal

Demonstrates conditional formatting highlighting cells greater than or equal to a threshold.

Rendered Output (LibreOffice Calc)

DSL Code

# frozen_string_literal: true

require "xlsxrb"
output_path = ARGV[0] || "cf_cell_greater_equal.xlsx"
Xlsxrb.write(output_path) do |wb|
  wb.style("center") { |style| style.align_horizontal("center") }
  wb.sheet("CF Greater Equal") do |s|
    s.column(0, width: 25)
    s.column(1, width: 25)
    s.row(["Values"])
    s.row([10], styles: "center")
    s.row([50], styles: "center")
    s.row([100], styles: "center")
    s.conditional_format("A2:A4", type: "cellIs", operator: "greaterThanOrEqual", formula: "50", fill_color: "FFFFC7CE")
  end
end

# 2. Read the generated sheet and print cell values
puts "=== Read Validation ==="
workbook = Xlsxrb.read(output_path).load
sheet = workbook.sheets.first
sheet.rows.first(5).each do |row|
  row_cells = row.cells.map { |c| "#{c.ref}: #{c.value.inspect}" }
  puts "Row #{row.index}: #{row_cells.join(", ")}"
end

Console Output

=== Read Validation ===
Row 0: A1: "Values"
Row 1: A2: 10
Row 2: A3: 50
Row 3: A4: 100

Cf Cell Greater Than

Demonstrates conditional formatting highlighting cells greater than a threshold.

Rendered Output (LibreOffice Calc)

DSL Code

# frozen_string_literal: true

require "xlsxrb"
output_path = ARGV[0] || "cf_cell_greater_than.xlsx"
Xlsxrb.write(output_path) do |wb|
  wb.style("center") { |style| style.align_horizontal("center") }
  wb.sheet("CF Greater") do |s|
    s.column(0, width: 25)
    s.column(1, width: 25)
    s.row(["Values"])
    s.row([25], styles: "center")
    s.row([75], styles: "center")
    s.row([10], styles: "center")
    s.conditional_format("A2:A4", type: "cellIs", operator: "greaterThan", formula: "50", fill_color: "FFFFC7CE")
  end
end

# 2. Read the generated sheet and print cell values
puts "=== Read Validation ==="
workbook = Xlsxrb.read(output_path).load
sheet = workbook.sheets.first
sheet.rows.first(5).each do |row|
  row_cells = row.cells.map { |c| "#{c.ref}: #{c.value.inspect}" }
  puts "Row #{row.index}: #{row_cells.join(", ")}"
end

Console Output

=== Read Validation ===
Row 0: A1: "Values"
Row 1: A2: 25
Row 2: A3: 75
Row 3: A4: 10

Cf Cell Less Than

Demonstrates conditional formatting highlighting cells less than a threshold.

Rendered Output (LibreOffice Calc)

DSL Code

# frozen_string_literal: true

require "xlsxrb"
output_path = ARGV[0] || "cf_cell_less_than.xlsx"
Xlsxrb.write(output_path) do |wb|
  wb.style("center") { |style| style.align_horizontal("center") }
  wb.sheet("CF Less") do |s|
    s.column(0, width: 25)
    s.column(1, width: 25)
    s.row(["Values"])
    s.row([25], styles: "center")
    s.row([75], styles: "center")
    s.row([10], styles: "center")
    s.conditional_format("A2:A4", type: "cellIs", operator: "lessThan", formula: "20", fill_color: "FFFFC7CE")
  end
end

# 2. Read the generated sheet and print cell values
puts "=== Read Validation ==="
workbook = Xlsxrb.read(output_path).load
sheet = workbook.sheets.first
sheet.rows.first(5).each do |row|
  row_cells = row.cells.map { |c| "#{c.ref}: #{c.value.inspect}" }
  puts "Row #{row.index}: #{row_cells.join(", ")}"
end

Console Output

=== Read Validation ===
Row 0: A1: "Values"
Row 1: A2: 25
Row 2: A3: 75
Row 3: A4: 10

Cf Color Scale

Demonstrates color scale/heatmap conditional formatting.

Rendered Output (LibreOffice Calc)

DSL Code

# frozen_string_literal: true

require "xlsxrb"
output_path = ARGV[0] || "cf_color_scale.xlsx"
Xlsxrb.write(output_path) do |wb|
  wb.style("center") { |style| style.align_horizontal("center") }
  wb.sheet("Colors") do |s|
    s.column(0, width: 25)
    s.column(1, width: 25)
    s.row([10], styles: "center")
    s.row([50], styles: "center")
    s.row([90], styles: "center")
    s.conditional_format("A1:A3", type: :colorScale, priority: 1)
  end
end

# 2. Read the generated sheet and print cell values
puts "=== Read Validation ==="
workbook = Xlsxrb.read(output_path).load
sheet = workbook.sheets.first
sheet.rows.first(5).each do |row|
  row_cells = row.cells.map { |c| "#{c.ref}: #{c.value.inspect}" }
  puts "Row #{row.index}: #{row_cells.join(", ")}"
end

Console Output

=== Read Validation ===
Row 0: A1: 10
Row 1: A2: 50
Row 2: A3: 90

Cf Contains Text

Demonstrates conditional formatting highlighting cells containing specific text.

Rendered Output (LibreOffice Calc)

DSL Code

# frozen_string_literal: true

require "xlsxrb"
output_path = ARGV[0] || "cf_contains_text.xlsx"
Xlsxrb.write(output_path) do |wb|
  wb.sheet("CF Contains") do |s|
    s.column(0, width: 25)
    s.column(1, width: 25)
    s.row(["Status"])
    s.row(["Error"])
    s.row(["Success"])
    s.row(["Pending"])
    s.conditional_format("A2:A4", type: "containsText", operator: "containsText", text: "Error", formula: 'NOT(ISERROR(SEARCH("Error",A2)))', fill_color: :red)
  end
end

# 2. Read the generated sheet and print cell values
puts "=== Read Validation ==="
workbook = Xlsxrb.read(output_path).load
sheet = workbook.sheets.first
sheet.rows.first(5).each do |row|
  row_cells = row.cells.map { |c| "#{c.ref}: #{c.value.inspect}" }
  puts "Row #{row.index}: #{row_cells.join(", ")}"
end

Console Output

=== Read Validation ===
Row 0: A1: "Status"
Row 1: A2: "Error"
Row 2: A3: "Success"
Row 3: A4: "Pending"

Cf Data Bar

Demonstrates data bar visual conditional formatting indicators.

Rendered Output (LibreOffice Calc)

DSL Code

# frozen_string_literal: true

require "xlsxrb"
output_path = ARGV[0] || "cf_data_bar.xlsx"
Xlsxrb.write(output_path) do |wb|
  wb.style("center") { |style| style.align_horizontal("center") }
  wb.sheet("Data Bars") do |s|
    s.column(0, width: 25)
    s.column(1, width: 25)
    s.row([20], styles: "center")
    s.row([60], styles: "center")
    s.row([100], styles: "center")
    s.conditional_format("A1:A3", type: :dataBar, priority: 1, color: "FF0070C0")
  end
end

# 2. Read the generated sheet and print cell values
puts "=== Read Validation ==="
workbook = Xlsxrb.read(output_path).load
sheet = workbook.sheets.first
sheet.rows.first(5).each do |row|
  row_cells = row.cells.map { |c| "#{c.ref}: #{c.value.inspect}" }
  puts "Row #{row.index}: #{row_cells.join(", ")}"
end

Console Output

=== Read Validation ===
Row 0: A1: 20
Row 1: A2: 60
Row 2: A3: 100

Cf Ends With

Demonstrates conditional formatting highlighting cells ending with specific text.

Rendered Output (LibreOffice Calc)

DSL Code

# frozen_string_literal: true

require "xlsxrb"
output_path = ARGV[0] || "cf_ends_with.xlsx"
Xlsxrb.write(output_path) do |wb|
  wb.sheet("CF Ends") do |s|
    s.column(0, width: 25)
    s.column(1, width: 25)
    s.row(["Code"])
    s.row(["100-Z"])
    s.row(["200-Y"])
    s.row(["300-Z"])
    s.conditional_format("A2:A4", type: "endsWith", operator: "endsWith", text: "Z", formula: 'RIGHT(A2,1)="Z"', fill_color: "FFFFC7CE")
  end
end

# 2. Read the generated sheet and print cell values
puts "=== Read Validation ==="
workbook = Xlsxrb.read(output_path).load
sheet = workbook.sheets.first
sheet.rows.first(5).each do |row|
  row_cells = row.cells.map { |c| "#{c.ref}: #{c.value.inspect}" }
  puts "Row #{row.index}: #{row_cells.join(", ")}"
end

Console Output

=== Read Validation ===
Row 0: A1: "Code"
Row 1: A2: "100-Z"
Row 2: A3: "200-Y"
Row 3: A4: "300-Z"

Cf Expression Formula

Demonstrates conditional formatting using a custom formula expression.

Rendered Output (LibreOffice Calc)

DSL Code

# frozen_string_literal: true

require "xlsxrb"
output_path = ARGV[0] || "cf_expression_formula.xlsx"
Xlsxrb.write(output_path) do |wb|
  wb.style("center") { |style| style.align_horizontal("center") }
  wb.sheet("CF Expression") do |s|
    s.column(0, width: 25)
    s.column(1, width: 25)
    s.row(["Values"])
    s.row([10], styles: "center")
    s.row([20], styles: "center")
    s.row([30], styles: "center")
    s.row([100], styles: "center") # Average is 40. 100 is above average.
    s.conditional_format("A2:A5", type: "expression", formula: "A2>AVERAGE($A$2:$A$5)", fill_color: "FFFFC7CE")
  end
end

# 2. Read the generated sheet and print cell values
puts "=== Read Validation ==="
workbook = Xlsxrb.read(output_path).load
sheet = workbook.sheets.first
sheet.rows.first(5).each do |row|
  row_cells = row.cells.map { |c| "#{c.ref}: #{c.value.inspect}" }
  puts "Row #{row.index}: #{row_cells.join(", ")}"
end

Console Output

=== Read Validation ===
Row 0: A1: "Values"
Row 1: A2: 10
Row 2: A3: 20
Row 3: A4: 30
Row 4: A5: 100

Cf Icon Set

Demonstrates icon set indicators (red/yellow/green arrows).

Rendered Output (LibreOffice Calc)

DSL Code

# frozen_string_literal: true

require "xlsxrb"
output_path = ARGV[0] || "cf_icon_set.xlsx"
Xlsxrb.write(output_path) do |wb|
  wb.style("center") { |style| style.align_horizontal("center") }
  wb.sheet("Icons") do |s|
    s.column(0, width: 25)
    s.column(1, width: 25)
    s.row([25], styles: "center")
    s.row([50], styles: "center")
    s.row([75], styles: "center")
    s.conditional_format("A1:A3", type: :iconSet, icon_style: "3Arrows", priority: 1)
  end
end

# 2. Read the generated sheet and print cell values
puts "=== Read Validation ==="
workbook = Xlsxrb.read(output_path).load
sheet = workbook.sheets.first
sheet.rows.first(5).each do |row|
  row_cells = row.cells.map { |c| "#{c.ref}: #{c.value.inspect}" }
  puts "Row #{row.index}: #{row_cells.join(", ")}"
end

Console Output

=== Read Validation ===
Row 0: A1: 25
Row 1: A2: 50
Row 2: A3: 75

Chart Area

Demonstrates embedding a standard 2D Area Chart.

Rendered Output (LibreOffice Calc)

DSL Code

# frozen_string_literal: true

require "xlsxrb"
output_path = ARGV[0] || "chart_area.xlsx"
Xlsxrb.write(output_path) do |wb|
  wb.sheet("Data") do |s|
    s.sheet_properties(:fit_to_page, true)
    s.page_setup(fit_to_width: 1, fit_to_height: 1)
    s.column(0, width: 25)
    s.column(1, width: 25)
    s.row(%w[Day Value])
    s.row(["Mon", 10])
    s.row(["Tue", 15])
    s.chart(
      type: :area,
      title: "Daily Area",
      from_col: 3, from_row: 0, to_col: 8, to_row: 12,
      series: [{ cat_ref: "Data!$A$2:$A$3", val_ref: "Data!$B$2:$B$3", fill_color: "4F81BD" }]
    )
  end
end

# 2. Read the generated sheet and print the chart count
puts "=== Read Validation ==="
workbook = Xlsxrb.read(output_path).load
sheet = workbook.sheets.first
puts "Sheet '#{sheet.name}' has #{sheet.charts.size} chart(s)"

Console Output

=== Read Validation ===
Sheet 'Data' has 0 chart(s)

Chart Area Stacked

Demonstrates embedding a stacked 2D Area Chart.

Rendered Output (LibreOffice Calc)

DSL Code

# frozen_string_literal: true

require "xlsxrb"
output_path = ARGV[0] || "chart_area_stacked.xlsx"
Xlsxrb.write(output_path) do |wb|
  wb.sheet("Data") do |s|
    s.column(0, width: 25)
    s.column(1, width: 25)
    s.row(["Year", "Sales A", "Sales B"])
    s.row([2024, 100, 150])
    s.row([2025, 120, 180])
    s.row([2026, 140, 210])
    s.sheet_properties(:fit_to_page, true)
    s.page_setup(fit_to_width: 1, fit_to_height: 1)
    s.chart(
      type: :area,
      grouping: :stacked,
      title: "Stacked Area Chart",
      from_col: 0, from_row: 5, to_col: 6, to_row: 17,
      series: [
        { cat_ref: "'Data'!$A$2:$A$4", val_ref: "'Data'!$B$2:$B$4", name: "'Data'!$B$1", fill_color: "4F81BD" },
        { cat_ref: "'Data'!$A$2:$A$4", val_ref: "'Data'!$C$2:$C$4", name: "'Data'!$C$1", fill_color: "C0504D" }
      ]
    )
  end
end

# 2. Read the generated sheet and print the chart count
puts "=== Read Validation ==="
workbook = Xlsxrb.read(output_path).load
sheet = workbook.sheets.first
puts "Sheet '#{sheet.name}' has #{sheet.charts.size} chart(s)"

Console Output

=== Read Validation ===
Sheet 'Data' has 0 chart(s)

Chart Bar

Demonstrates embedding a standard 2D Bar Chart referencing worksheet cell ranges.

Rendered Output (LibreOffice Calc)

DSL Code

# frozen_string_literal: true

require "xlsxrb"

output_path = ARGV[0] || "chart_bar.xlsx"

Xlsxrb.write(output_path) do |wb|
  wb.sheet("Sales Data") do |s|
    s.sheet_properties(:fit_to_page, true)
    s.page_setup(fit_to_width: 1, fit_to_height: 1)
    s.column(0, width: 25)
    s.column(1, width: 25)
    s.row(%w[Month Value])
    s.row(["Jan", 100])
    s.row(["Feb", 200])

    s.chart(
      type: :bar,
      title: "Monthly Sales",
      from_col: 3,
      from_row: 0,
      to_col: 8,
      to_row: 12,
      series: [
        { cat_ref: "'Sales Data'!$A$2:$A$3", val_ref: "'Sales Data'!$B$2:$B$3", fill_color: "4F81BD" }
      ]
    )
  end
end

# 2. Read the generated sheet and print the chart count
puts "=== Read Validation ==="
workbook = Xlsxrb.read(output_path).load
sheet = workbook.sheets.first
puts "Sheet '#{sheet.name}' has #{sheet.charts.size} chart(s)"

Console Output

=== Read Validation ===
Sheet 'Sales Data' has 0 chart(s)

Chart Bar Percent Stacked

Demonstrates embedding a 100% stacked 2D Bar Chart.

Rendered Output (LibreOffice Calc)

DSL Code

# frozen_string_literal: true

require "xlsxrb"
output_path = ARGV[0] || "chart_bar_percent_stacked.xlsx"
Xlsxrb.write(output_path) do |wb|
  wb.sheet("Data") do |s|
    s.column(0, width: 25)
    s.column(1, width: 25)
    s.row(["Year", "Sales A", "Sales B"])
    s.row([2024, 100, 150])
    s.row([2025, 120, 180])
    s.row([2026, 140, 210])
    s.sheet_properties(:fit_to_page, true)
    s.page_setup(fit_to_width: 1, fit_to_height: 1)
    s.chart(
      type: :bar,
      grouping: :percentStacked,
      title: "100% Stacked Bar Chart",
      from_col: 0, from_row: 5, to_col: 6, to_row: 17,
      series: [
        { cat_ref: "'Data'!$A$2:$A$4", val_ref: "'Data'!$B$2:$B$4", name: "'Data'!$B$1", fill_color: "4F81BD" },
        { cat_ref: "'Data'!$A$2:$A$4", val_ref: "'Data'!$C$2:$C$4", name: "'Data'!$C$1", fill_color: "C0504D" }
      ]
    )
  end
end

# 2. Read the generated sheet and print the chart count
puts "=== Read Validation ==="
workbook = Xlsxrb.read(output_path).load
sheet = workbook.sheets.first
puts "Sheet '#{sheet.name}' has #{sheet.charts.size} chart(s)"

Console Output

=== Read Validation ===
Sheet 'Data' has 0 chart(s)

Chart Bar Stacked

Demonstrates embedding a stacked 2D Bar Chart.

Rendered Output (LibreOffice Calc)

DSL Code

# frozen_string_literal: true

require "xlsxrb"
output_path = ARGV[0] || "chart_bar_stacked.xlsx"
Xlsxrb.write(output_path) do |wb|
  wb.sheet("Data") do |s|
    s.column(0, width: 25)
    s.column(1, width: 25)
    s.row(["Year", "Sales A", "Sales B"])
    s.row([2024, 100, 150])
    s.row([2025, 120, 180])
    s.row([2026, 140, 210])
    s.sheet_properties(:fit_to_page, true)
    s.page_setup(fit_to_width: 1, fit_to_height: 1)
    s.chart(
      type: :bar,
      grouping: :stacked,
      title: "Stacked Bar Chart",
      from_col: 0, from_row: 5, to_col: 6, to_row: 17,
      series: [
        { cat_ref: "'Data'!$A$2:$A$4", val_ref: "'Data'!$B$2:$B$4", name: "'Data'!$B$1", fill_color: "4F81BD" },
        { cat_ref: "'Data'!$A$2:$A$4", val_ref: "'Data'!$C$2:$C$4", name: "'Data'!$C$1", fill_color: "C0504D" }
      ]
    )
  end
end

# 2. Read the generated sheet and print the chart count
puts "=== Read Validation ==="
workbook = Xlsxrb.read(output_path).load
sheet = workbook.sheets.first
puts "Sheet '#{sheet.name}' has #{sheet.charts.size} chart(s)"