xlsxrb 0.1.0

data/docs/wasm/wasm_doc_helper.css

@@ -0,0 +1,189 @@
+/* wasm_doc_helper.css */
+.wasm-playground-wrapper {
+  margin: 1.5em 0;
+  position: relative;
+}
+
+/* 'Try in Browser' Button */
+.wasm-try-btn {
+  display: inline-flex;
+  align-items: center;
+  justify-content: center;
+  background: linear-gradient(135deg, #4f46e5 0%, #3b82f6 100%);
+  color: white !important;
+  border: none;
+  padding: 8px 16px;
+  font-size: 13px;
+  font-weight: 600;
+  border-radius: 6px;
+  cursor: pointer;
+  box-shadow: 0 4px 12px rgba(59, 130, 246, 0.25);
+  transition: all 0.2s ease;
+  margin-bottom: 8px;
+  outline: none;
+}
+
+.wasm-try-btn:hover {
+  background: linear-gradient(135deg, #4338ca 0%, #2563eb 100%);
+  transform: translateY(-1px);
+  box-shadow: 0 6px 16px rgba(59, 130, 246, 0.35);
+}
+
+.wasm-try-btn:active {
+  transform: translateY(1px);
+  box-shadow: 0 2px 6px rgba(59, 130, 246, 0.2);
+}
+
+/* Loader indicator */
+.wasm-loader {
+  display: flex;
+  align-items: center;
+  gap: 12px;
+  padding: 16px;
+  background-color: #f3f4f6;
+  border: 1px solid #e5e7eb;
+  border-radius: 8px;
+  font-size: 14px;
+  color: #374151;
+}
+
+.wasm-loader-text {
+  font-weight: 500;
+}
+
+.wasm-spinner {
+  width: 20px;
+  height: 20px;
+  border: 3px solid rgba(59, 130, 246, 0.2);
+  border-top-color: #3b82f6;
+  border-radius: 50%;
+  animation: wasm-spin 0.8s linear infinite;
+}
+
+@keyframes wasm-spin {
+  to { transform: rotate(360deg); }
+}
+
+/* Playground main container */
+.wasm-playground-container {
+  display: flex;
+  flex-direction: column;
+  border: 1px solid #e5e7eb;
+  border-radius: 8px;
+  overflow: hidden;
+  box-shadow: 0 10px 25px -5px rgba(0, 0, 0, 0.05), 0 8px 10px -6px rgba(0, 0, 0, 0.05);
+  background: #ffffff;
+  transition: border-color 0.3s ease;
+}
+
+/* Editor (textarea) */
+.wasm-editor {
+  width: 100%;
+  box-sizing: border-box;
+  padding: 16px;
+  font-family: ui-monospace, SFMono-Regular, Menlo, Monaco, Consolas, "Liberation Mono", "Courier New", monospace;
+  font-size: 13.5px;
+  line-height: 1.6;
+  color: #1f2937;
+  background-color: #fafafa;
+  border: none;
+  border-bottom: 1px solid #e5e7eb;
+  resize: vertical;
+  outline: none;
+  tab-size: 2;
+}
+
+.wasm-editor:focus {
+  background-color: #ffffff;
+}
+
+/* Action bar container */
+.wasm-action-bar {
+  display: flex;
+  gap: 8px;
+  padding: 10px 16px;
+  background-color: #f9fafb;
+  border-bottom: 1px solid #e5e7eb;
+}
+
+/* Common action buttons style */
+.wasm-action-bar button {
+  padding: 6px 12px;
+  font-size: 12.5px;
+  font-weight: 600;
+  border-radius: 4px;
+  cursor: pointer;
+  transition: all 0.15s ease;
+  outline: none;
+}
+
+.wasm-run-btn {
+  background-color: #10b981;
+  color: white;
+  border: 1px solid #059669;
+}
+
+.wasm-run-btn:hover:not(:disabled) {
+  background-color: #059669;
+}
+
+.wasm-run-btn:disabled {
+  background-color: #a7f3d0;
+  border-color: #a7f3d0;
+  cursor: not-allowed;
+}
+
+.wasm-reset-btn {
+  background-color: white;
+  color: #4b5563;
+  border: 1px solid #d1d5db;
+}
+
+.wasm-reset-btn:hover {
+  background-color: #f3f4f6;
+  color: #1f2937;
+  border-color: #9ca3af;
+}
+
+.wasm-close-btn {
+  background-color: white;
+  color: #ef4444;
+  border: 1px solid #fca5a5;
+  margin-left: auto; /* Align to the right edge */
+}
+
+.wasm-close-btn:hover {
+  background-color: #fef2f2;
+  border-color: #ef4444;
+}
+
+/* Console output logs area */
+.wasm-console {
+  margin: 0;
+  padding: 14px 16px;
+  font-family: ui-monospace, SFMono-Regular, Menlo, Monaco, Consolas, "Liberation Mono", "Courier New", monospace;
+  font-size: 12.5px;
+  line-height: 1.5;
+  background-color: #1e293b;
+  color: #e2e8f0;
+  overflow-x: auto;
+  max-height: 200px;
+  border-top: none;
+}
+
+.wasm-console.running {
+  color: #93c5fd;
+}
+
+.wasm-console.success {
+  color: #a7f3d0;
+}
+
+.wasm-console.error {
+  color: #fca5a5;
+}
+
+.wasm-error {
+  color: #ef4444;
+  font-weight: 600;
+}

data/docs/wasm/wasm_doc_helper.js

@@ -0,0 +1,320 @@
+// wasm_doc_helper.js
+(function () {
+  // Detect all pre.ruby blocks to setup interactive playgrounds
+  document.addEventListener("DOMContentLoaded", () => {
+    const codeBlocks = document.querySelectorAll("pre.ruby");
+    codeBlocks.forEach((block, index) => {
+      setupPlayground(block, index);
+    });
+  });
+
+  let rubyVM = null;
+  let isInitializing = false;
+  const initListeners = [];
+  let consoleBuffer = ""; // Temporary buffer to capture stdout/stderr
+
+  // Helper to initialize and retrieve the Ruby Wasm VM
+  async function ensureRubyWasm() {
+    if (rubyVM) return rubyVM;
+    if (isInitializing) {
+      return new Promise((resolve) => initListeners.push(resolve));
+    }
+    isInitializing = true;
+
+    // Load browser.umd.js dynamically from CDN
+    await loadScript("https://cdn.jsdelivr.net/npm/@ruby/wasm-wasi@2.9.3-2.9.4/dist/browser.umd.js");
+
+    // Fetch and compile the custom prepackaged ruby.wasm module
+    const prefix = window.rdoc_rel_prefix || "./";
+    const response = await fetch(`${prefix}wasm/ruby.wasm?cb=${Date.now()}`);
+    const buffer = await response.arrayBuffer();
+    const module = await WebAssembly.compile(buffer);
+
+    // Capture stdout/stderr streams to buffer during execution
+    const rubyWasm = window.rubyWasm || window["ruby-wasm-wasi"];
+    const DefaultRubyVM = rubyWasm.DefaultRubyVM;
+    let vmInit;
+
+    const options = {
+      stdout: (str) => { consoleBuffer += str; },
+      stderr: (str) => { consoleBuffer += str; }
+    };
+
+    // Handle initialization polymorphism across various ruby-wasm versions
+    if (typeof DefaultRubyVM.initialize === "function") {
+      vmInit = DefaultRubyVM.initialize(module, options);
+    } else if (typeof DefaultRubyVM.initializeVM === "function") {
+      vmInit = DefaultRubyVM.initializeVM(module, options);
+    } else if (typeof DefaultRubyVM === "function") {
+      try {
+        vmInit = DefaultRubyVM(module, options);
+      } catch (e) {
+        const instance = new DefaultRubyVM();
+        const initFn = instance.initialize || instance.initializeVM;
+        if (typeof initFn === "function") {
+          vmInit = initFn.call(instance, module, options);
+        } else {
+          throw new Error("No initialization method found on DefaultRubyVM instance");
+        }
+      }
+    } else {
+      throw new Error("DefaultRubyVM is not available");
+    }
+    const { vm } = await vmInit;
+    
+    rubyVM = vm;
+
+    isInitializing = false;
+    const listeners = [...initListeners];
+    initListeners.length = 0;
+    listeners.forEach((resolve) => resolve(rubyVM));
+    return rubyVM;
+  }
+
+  // Inject script tags dynamically
+  function loadScript(src) {
+    return new Promise((resolve, reject) => {
+      if (document.querySelector(`script[src="${src}"]`)) {
+        resolve();
+        return;
+      }
+      const script = document.createElement("script");
+      script.src = src;
+      script.onload = resolve;
+      script.onerror = reject;
+      document.head.appendChild(script);
+    });
+  }
+
+  // Setup playground UI elements around a code block
+  function setupPlayground(block, index) {
+    const originalCode = block.textContent;
+
+    const btn = document.createElement("button");
+    btn.className = "wasm-try-btn";
+    btn.innerHTML = `
+      <svg width="14" height="14" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" style="margin-right: 6px; vertical-align: middle;">
+        <polygon points="5 3 19 12 5 21 5 3"></polygon>
+      </svg>Try it in Browser
+    `;
+    
+    const wrapper = document.createElement("div");
+    wrapper.className = "wasm-playground-wrapper";
+    
+    block.parentNode.insertBefore(wrapper, block);
+    wrapper.appendChild(block);
+    wrapper.insertBefore(btn, block);
+
+    btn.addEventListener("click", async () => {
+      btn.style.display = "none";
+      
+      const loader = document.createElement("div");
+      loader.className = "wasm-loader";
+      loader.innerHTML = `
+        <span class="wasm-loader-text">Loading Ruby Wasm Engine...</span>
+        <div class="wasm-spinner"></div>
+      `;
+      wrapper.insertBefore(loader, block);
+
+      try {
+        const vm = await ensureRubyWasm();
+        loader.remove();
+        activatePlayground(wrapper, block, originalCode, vm);
+      } catch (e) {
+        loader.innerHTML = `<span class="wasm-error">Error loading Wasm: ${e.message}</span>`;
+        console.error(e);
+      }
+    });
+
+    // Auto-trigger load under E2E testing mode
+    if (window.location.hash === "#test-mode" && index === 0) {
+      setTimeout(() => {
+        console.log("[Script Mock] Test mode detected. Triggering playground load...");
+        btn.click();
+        
+        const interval = setInterval(() => {
+          const runBtn = wrapper.querySelector(".wasm-run-btn");
+          if (runBtn && !runBtn.disabled) {
+            clearInterval(interval);
+            console.log("[Script Mock] Playground loaded. Triggering run...");
+            setTimeout(() => {
+              runBtn.click();
+            }, 1000);
+          }
+        }, 500);
+      }, 1000);
+    }
+  }
+
+  // Replace block with the interactive editor and console
+  function activatePlayground(wrapper, originalBlock, code, vm) {
+    originalBlock.style.display = "none";
+
+    const playgroundContainer = document.createElement("div");
+    playgroundContainer.className = "wasm-playground-container";
+
+    const textarea = document.createElement("textarea");
+    textarea.className = "wasm-editor";
+    textarea.value = code;
+    textarea.rows = Math.max(8, code.split("\n").length + 2);
+
+    const actionBar = document.createElement("div");
+    actionBar.className = "wasm-action-bar";
+
+    const runBtn = document.createElement("button");
+    runBtn.className = "wasm-run-btn";
+    runBtn.textContent = "Run & Download";
+
+    const resetBtn = document.createElement("button");
+    resetBtn.className = "wasm-reset-btn";
+    resetBtn.textContent = "Reset";
+
+    const closeBtn = document.createElement("button");
+    closeBtn.className = "wasm-close-btn";
+    closeBtn.textContent = "Close";
+
+    actionBar.appendChild(runBtn);
+    actionBar.appendChild(resetBtn);
+    actionBar.appendChild(closeBtn);
+
+    const consoleArea = document.createElement("pre");
+    consoleArea.className = "wasm-console";
+    consoleArea.textContent = "Ready to run. Output and status will be shown here.";
+
+    playgroundContainer.appendChild(textarea);
+    playgroundContainer.appendChild(actionBar);
+    playgroundContainer.appendChild(consoleArea);
+    wrapper.appendChild(playgroundContainer);
+
+    resetBtn.addEventListener("click", () => {
+      textarea.value = code;
+      consoleArea.textContent = "Reset to original code.";
+      consoleArea.className = "wasm-console";
+    });
+
+    closeBtn.addEventListener("click", () => {
+      playgroundContainer.remove();
+      originalBlock.style.display = "block";
+      wrapper.querySelector(".wasm-try-btn").style.display = "inline-flex";
+    });
+
+    runBtn.addEventListener("click", async () => {
+      runBtn.disabled = true;
+      runBtn.textContent = "Running...";
+      consoleArea.textContent = "Executing Ruby code...";
+      consoleArea.className = "wasm-console running";
+      consoleBuffer = "";
+
+      // Clear any preexisting XLSX files in the virtual FS root to avoid collision/leak
+      clearXlsxFiles(vm, "/");
+
+      try {
+        let userCode = textarea.value;
+        if (!userCode.includes('require "xlsxrb"') && !userCode.includes("require 'xlsxrb'")) {
+          userCode = 'require "xlsxrb"\n' + userCode;
+        }
+        // Force include the current directory in load path
+        userCode = '$LOAD_PATH << Dir.pwd unless $LOAD_PATH.include?(Dir.pwd)\n' + userCode;
+
+        // Evaluate the user code in Wasm VM
+        vm.eval(userCode);
+
+        // Scan virtual FS for new XLSX output files
+        const generatedFiles = scanXlsxFiles(vm, "/");
+        
+        consoleArea.className = "wasm-console success";
+        let output = consoleBuffer;
+
+        if (generatedFiles.length > 0) {
+          const mainFile = generatedFiles[0];
+          output += `\n[Success] Generated file: ${mainFile}\nTriggering download...`;
+          downloadFileFromVfs(vm, mainFile);
+        } else {
+          output += `\n[Warning] Execution succeeded, but no .xlsx file was generated in the root directory.`;
+        }
+
+        consoleArea.textContent = output || "Execution completed successfully (no stdout).";
+
+      } catch (err) {
+        consoleArea.className = "wasm-console error";
+        consoleArea.textContent = `Error during execution:\n${err.message}\n\nConsole output:\n${consoleBuffer}`;
+        console.error(err);
+
+        // Send runtime errors back to test server under E2E testing
+        if (window.location.hash === "#test-mode") {
+          fetch("http://localhost:9001/error", {
+            method: "POST",
+            body: `Error during execution:\n${err.message}\n\nConsole output:\n${consoleBuffer}`
+          }).catch(e => console.error("Failed to post back error:", e));
+        }
+      } finally {
+        runBtn.disabled = false;
+        runBtn.textContent = "Run & Download";
+      }
+    });
+  }
+
+  // Delete all .xlsx files recursively under the virtual directory
+  function clearXlsxFiles(vm, dir) {
+    try {
+      vm.eval(`
+        Dir.glob("${dir}/**/*.xlsx").each do |file|
+          File.delete(file) rescue nil
+        end
+      `);
+    } catch (e) {
+      console.error("Error clearing XLSX files:", e);
+    }
+  }
+
+  // Recursively scan virtual directory for generated .xlsx files
+  function scanXlsxFiles(vm, dir) {
+    try {
+      const filesStr = vm.eval(`
+        Dir.glob("${dir}/**/*.xlsx").join(",")
+      `).toString();
+      return filesStr ? filesStr.split(",") : [];
+    } catch (e) {
+      console.error("Error scanning XLSX files:", e);
+      return [];
+    }
+  }
+
+  // Fetch binary contents of a VFS file and trigger browser download
+  function downloadFileFromVfs(vm, filepath) {
+    try {
+      // Hex bridge unpacking to transfer binary data safely to JS
+      const hexData = vm.eval(`
+        File.binread("${filepath}").unpack1("H*")
+      `).toString();
+
+      const len = hexData.length;
+      const bytes = new Uint8Array(len / 2);
+      for (let i = 0; i < len; i += 2) {
+        bytes[i / 2] = parseInt(hexData.substr(i, 2), 16);
+      }
+
+      const filename = filepath.split("/").pop();
+      const blob = new Blob([bytes], { type: "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet" });
+      const url = URL.createObjectURL(blob);
+      const a = document.createElement("a");
+      a.href = url;
+      a.download = filename;
+      document.body.appendChild(a);
+      a.click();
+      document.body.removeChild(a);
+      setTimeout(() => URL.revokeObjectURL(url), 10000);
+
+      // Post binary data back to test server under E2E testing
+      if (window.location.hash === "#test-mode") {
+        console.log("[Script Mock] Test mode detected. Sending generated file back to test server...");
+        fetch("http://localhost:9001/upload", {
+          method: "POST",
+          body: bytes
+        }).catch(err => console.error("Failed to post back test file:", err));
+      }
+    } catch (e) {
+      console.error("Error downloading file from Vfs:", e);
+    }
+  }
+})();

data/lib/xlsxrb/elements/cell.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+module Xlsxrb
+  module Elements
+    # Represents a single cell in a worksheet.
+    # All indices are 0-based.
+    Cell = Data.define(:row_index, :column_index, :value, :formula, :style_index, :unmapped_data, :errors) do
+      def initialize(row_index:, column_index:, value: nil, formula: nil, style_index: nil, unmapped_data: {}, errors: nil)
+        computed_errors = errors || self.class.validate(row_index, column_index, value)
+        computed_errors = computed_errors.freeze unless computed_errors.frozen?
+        super(row_index: row_index, column_index: column_index, value: value, formula: formula,
+              style_index: style_index, unmapped_data: unmapped_data, errors: computed_errors)
+      end
+
+      def valid?
+        errors.empty?
+      end
+
+      # Excel-style reference (e.g. "A1").
+      def ref
+        "#{self.class.column_letter(column_index)}#{row_index + 1}"
+      end
+
+      # Cache column letters up to Excel's limit (16,384)
+      @column_letters = (0...16_384).map do |index|
+        result = +""
+        i = index
+        loop do
+          result.prepend(("A".ord + (i % 26)).chr)
+          i = (i / 26) - 1
+          break if i.negative?
+        end
+        result.freeze
+      end.freeze
+
+      # Converts a 0-based column index to a letter (0 -> "A", 25 -> "Z", 26 -> "AA").
+      def self.column_letter(index)
+        @column_letters[index] || begin
+          result = +""
+          i = index
+          loop do
+            result.prepend(("A".ord + (i % 26)).chr)
+            i = (i / 26) - 1
+            break if i.negative?
+          end
+          result
+        end
+      end
+
+      # Parses an Excel-style reference to [row_index, col_index] (both 0-based).
+      def self.parse_ref(ref)
+        match = ref.match(/\A([A-Z]+)(\d+)\z/)
+        return nil unless match
+
+        col = match[1].chars.reduce(0) { |acc, c| (acc * 26) + (c.ord - "A".ord + 1) } - 1
+        row = match[2].to_i - 1
+        [row, col]
+      end
+
+      def self.validate(row_index, column_index, value)
+        if row_index.is_a?(Integer) && row_index >= 0 && row_index < 1_048_576 &&
+           column_index.is_a?(Integer) && column_index >= 0 && column_index < 16_384 &&
+           (value.nil? || value.is_a?(String) || value.is_a?(Numeric) || value == true || value == false || value.is_a?(Date) || value.is_a?(Time))
+          return [].freeze
+        end
+
+        errs = []
+        errs << "row_index must be a non-negative Integer (got #{row_index.inspect})" if !row_index.is_a?(Integer) || row_index.negative?
+        errs << "column_index must be a non-negative Integer (got #{column_index.inspect})" if !column_index.is_a?(Integer) || column_index.negative?
+        errs << "row_index must be < 1048576 (got #{row_index}, max row is 1048575)" if row_index.is_a?(Integer) && row_index >= 1_048_576
+        errs << "column_index must be < 16384 (got #{column_index}, max column is XFD=16383)" if column_index.is_a?(Integer) && column_index >= 16_384
+        errs << "unsupported value type: #{value.class} (#{value.inspect}) — supported types: String, Numeric, true/false, Date, Time, or nil" unless value.nil? || value.is_a?(String) || value.is_a?(Numeric) || value == true || value == false || value.is_a?(Date) || value.is_a?(Time)
+        errs
+      end
+    end
+  end
+end

data/lib/xlsxrb/elements/column.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Xlsxrb
+  module Elements
+    # Represents column formatting in a worksheet.
+    # index is 0-based.
+    Column = Data.define(:index, :width, :hidden, :custom_width, :outline_level, :unmapped_data, :errors) do
+      def initialize(index:, width: nil, hidden: false, custom_width: false, outline_level: nil,
+                     unmapped_data: {}, errors: nil)
+        computed_errors = errors || self.class.validate(index)
+        super(index: index, width: width, hidden: hidden, custom_width: custom_width,
+              outline_level: outline_level, unmapped_data: unmapped_data,
+              errors: computed_errors.freeze)
+      end
+
+      def valid?
+        errors.empty?
+      end
+
+      def self.validate(index)
+        errs = []
+        errs << "index must be a non-negative Integer (got #{index.inspect})" if !index.is_a?(Integer) || index.negative?
+        errs << "index must be < 16384 (got #{index}, max column is XFD=16383)" if index.is_a?(Integer) && index >= 16_384
+        errs
+      end
+    end
+  end
+end

data/lib/xlsxrb/elements/row.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module Xlsxrb
+  module Elements
+    # Represents a single row in a worksheet.
+    # index is 0-based.
+    Row = Data.define(:index, :cells, :height, :hidden, :custom_height, :outline_level, :unmapped_data, :errors) do
+      def initialize(index:, cells: [], height: nil, hidden: false, custom_height: false, outline_level: nil,
+                     unmapped_data: {}, errors: nil)
+        computed_errors = errors || self.class.validate(index, cells)
+        computed_errors = computed_errors.freeze unless computed_errors.frozen?
+        cells = cells.freeze unless cells.frozen?
+        super(index: index, cells: cells, height: height, hidden: hidden,
+              custom_height: custom_height, outline_level: outline_level,
+              unmapped_data: unmapped_data, errors: computed_errors)
+      end
+
+      def valid?
+        errors.empty?
+      end
+
+      # Returns the cell at the given 0-based column index, or nil.
+      def cell_at(column_index)
+        cells.find { |c| c.column_index == column_index }
+      end
+
+      # Returns cell values as an Array (sparse columns get nil).
+      def values
+        return [] if cells.empty?
+
+        max_col = cells.max_by(&:column_index).column_index
+        result = Array.new(max_col + 1)
+        cells.each { |c| result[c.column_index] = c.value }
+        result
+      end
+
+      def self.validate(index, cells)
+        return [].freeze if index.is_a?(Integer) && index >= 0 && cells.is_a?(Array)
+
+        errs = []
+        errs << "index must be a non-negative Integer (got #{index.inspect})" if !index.is_a?(Integer) || index.negative?
+        errs << "cells must be an Array (got #{cells.class})" unless cells.is_a?(Array)
+        errs
+      end
+    end
+  end
+end

data/lib/xlsxrb/elements/types.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Xlsxrb
+  module Elements
+    # Represents a formula with an optional cached value.
+    # Optional: type (:shared, :array), ref (range), shared_index (si for shared formulas)
+    Formula = Data.define(:expression, :cached_value, :type, :ref, :shared_index, :calculate_always, :aca, :bx, :dt2d, :dtr, :r1, :r2) do
+      def initialize(expression:, cached_value: nil, type: nil, ref: nil, shared_index: nil, calculate_always: nil, aca: nil, bx: nil, dt2d: nil, dtr: nil, r1: nil, r2: nil) # rubocop:disable Naming/MethodParameterName
+        super
+      end
+    end
+
+    # Represents a cell error value (e.g. #N/A, #REF!, #DIV/0!).
+    VALID_ERROR_CODES = %w[#NULL! #DIV/0! #VALUE! #REF! #NAME? #NUM! #N/A #GETTING_DATA].freeze
+    CellError = Data.define(:code) do
+      def initialize(code:)
+        raise ArgumentError, "invalid error code: #{code.inspect} (must be one of #{VALID_ERROR_CODES.join(", ")})" unless VALID_ERROR_CODES.include?(code)
+
+        super
+      end
+
+      def to_s
+        code
+      end
+    end
+
+    # Represents a rich text string with formatting runs.
+    # runs: array of hashes, each with :text and optional :font (hash of font properties).
+    # Font properties: :bold, :italic, :underline, :sz, :color, :name
+    RichText = Data.define(:runs) do
+      def to_s
+        runs.map { |r| r[:text] }.join
+      end
+    end
+  end
+end