lesath 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: '08725b38f6494e679c2239f228fdee59dc79febcb8f9d14daadb44fdcec5848d'
+  data.tar.gz: 44d47d31ad5fbdf6a61bfeb5f6e1202f7aab7b508670468360dbe6e5ccccfabd
+SHA512:
+  metadata.gz: '09e88095d742b34f4e22bfb6a58c3e9ec86234ca40c5ed0e70d41787f5a59b843b3ccf2a34bdc1dc1e16334a03cf82e622646b0cca90cd152c63dc803b429735'
+  data.tar.gz: c47989d1574c9decd0f806827ff002f741553fab9078724fa92ab601d08a6e716f0997d2eaa7b0ae14a713af44ac0fe11d42ea2ae34789ff0dbf610db35a0685

data/CHANGELOG.md

@@ -0,0 +1,5 @@
+# Changelog
+
+## [0.1.0] - 2026-09-24
+
+- Initial release.

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2026 Yudai Takada
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,53 @@
+# Lesath
+
+Lesath (υ Scorpii) is a small library for strict spreadsheet interchange.
+The star's name comes from Arabic *lasʿa*, “sting.” It reads and writes a
+documented subset of `.xlsx` and `.ods` with no UI or calculation engine.
+
+```ruby
+require "lesath"
+
+book = Lesath::Workbook.new
+book.add_sheet("Sales").add_sheet("Summary")
+book.set("Sales", 1, 1, "Item")
+book.set("Sales", 2, 1, "Tea")
+book.set("Sales", 2, 2, 12.5)
+Lesath.write(book, "sales.xlsx")
+copy = Lesath.read("sales.xlsx")
+copy.cell("Sales", 2, 2).value # => 12.5
+```
+
+Coordinates are one-based. `Lesath.read` / `Lesath.write` infer the format from
+the filename or accept `format: :xlsx` / `format: :ods`. Writing refuses to
+replace an existing target. The API stores formula text and its cached scalar;
+it does not calculate or translate formulas. XLSX formulas begin with `=`, ODS
+formulas with `of:=`. A workbook containing formulas cannot be written to the
+other format. ODS formulas need a cached value. The caller must recalculate
+before exporting changed formula inputs.
+
+Supported cells are strings, finite integers/floats, booleans and empty cells,
+with up to 100,000 populated cells, 200 sheets, 1,048,576 rows, 16,384
+columns, 15-digit integers, 32,767 UTF-16 units per string and 31 characters per sheet name. XLSX inline strings and simple scalar cached
+formulas are supported. ODS unstyled scalar cells and simple repeated blank
+rows/cells are supported. Multiple sheets retain their order and names.
+ODS strings needing `<text:s>`, tabs or line breaks are rejected rather than
+exported with altered display text. Outputs are checked against the same ZIP
+limits as imports before being moved to the target path.
+
+Imported files containing cell styles, rich text, dates/times, merged cells,
+comments, charts, images, macros, validations, hyperlinks, named ranges,
+external links, other unsupported package parts or XML elements raise
+`Lesath::UnsupportedFeature`. ZIP and XML limits raise
+`Lesath::InvalidPackage`. This is deliberately not a general Excel/LibreOffice
+round-trip editor. See [ADR 001](docs/adr/001-lossless-subset.md) for the exact
+boundary and source standards.
+
+`Rukbat::Workbook` is not directly accepted: it has richer formatting and
+formula semantics, so an adapter must explicitly choose a loss policy. CSV
+remains the appropriate broad interchange path until that adapter exists.
+
+```sh
+bundle install
+bundle exec rake spec
+gem build --strict lesath.gemspec
+```

data/docs/adr/001-lossless-subset.md

@@ -0,0 +1,60 @@
+# ADR 001: Reject unsupported spreadsheet features on import
+
+- Status: Accepted
+- Date: 2026-09-24
+- Author: Yudai Takada
+
+## Context
+
+Q9-a asks for xlsx/ODS interchange. Rukbat's workbook holds sparse cell input,
+formulas, formats, comments, ranges and print metadata, while its CSV route
+exports a single sheet with explicit input/calculated-value choice. XLSX and
+ODS are package formats with many more features. Reading only visible values
+then saving would quietly destroy unsupported content.
+
+## Decision
+
+Lesath has its own small workbook model. Import validates every ZIP part and
+supported XML element/attribute. Unknown or unsupported content raises an
+error before returning a workbook. Export creates a new package and never
+overwrites an existing path. The initial subset contains ordered sheets,
+one-based sparse cells, strings, finite numbers, booleans and same-format
+formula text with a cached scalar. It does not evaluate formulas. Cross-format
+formula export is rejected because SpreadsheetML and OpenFormula use different
+syntax and function semantics. Input values are stored separately from
+formula text. Formula caches may be stale; callers must recalculate them.
+
+Cell formatting, date/time serial interpretation, rich text, shared formulas,
+styles, merged cells, validation, protection, named ranges, drawing/chart
+parts, embedded objects, signatures, encryption, macros and external
+relationships are outside the subset and rejected. XLSX's default numeric
+cell has no date inference; non-default style references are rejected. ODS
+supports only `string`, `float`, `boolean` value types. These are explicit
+compatibility limits, not an implicit lossy conversion option.
+
+ZIP input is restricted to 256 entries, 20 MiB per part, 50 MiB total and a
+1,000:1 advertised compression ratio; paths, duplicate names and encrypted
+entries are rejected. XML DTD/entity declarations are rejected before parsing.
+Package part allowlists and XML element/attribute allowlists prevent silent
+loss of unknown features. This limits supported real-world files, including
+many office-generated workbooks with default style or metadata parts. Expand
+the subset only with a fixture proving that each added feature survives a
+read/write round trip or produces a clear error.
+
+ODS whitespace that requires `text:s`, tabs or line-break markup is rejected
+until those elements are supported. XLSX inline strings use `xml:space` when
+needed. Public cell text is immutable, and generated packages must pass the
+same size and compression checks as imported packages before publication.
+
+The model is intentionally independent of Rukbat. A future adapter should
+map only representable values and explicitly reject Rukbat formatting,
+comments, named ranges and metadata until those are implemented here. It
+must not silently discard them.
+
+## Standards
+
+- [ECMA-376, Office Open XML](https://ecma-international.org/publications-and-standards/standards/ecma-376/) — SpreadsheetML and Open Packaging Conventions.
+- [Microsoft Open XML SpreadsheetML structure](https://learn.microsoft.com/en-us/office/open-xml/spreadsheet/structure-of-a-spreadsheetml-document) — workbook, worksheet, relationship and cell packaging examples.
+- [OASIS OpenDocument 1.3 Part 2: Packages](https://docs.oasis-open.org/office/OpenDocument/v1.3/OpenDocument-v1.3-part2-packages.html) — manifest and uncompressed first `mimetype` entry.
+- [OASIS OpenDocument 1.3 Part 3: Schema](https://docs.oasis-open.org/office/OpenDocument/v1.3/OpenDocument-v1.3-part3-schema.html) — spreadsheet tables, value types and repeated cells.
+- [OASIS OpenDocument 1.3 Part 4: OpenFormula](https://docs.oasis-open.org/office/OpenDocument/v1.3/OpenDocument-v1.3-part4-formula.html) — ODS formula syntax.

data/lib/lesath/ods.rb

@@ -0,0 +1,169 @@
+# frozen_string_literal: true
+
+module Lesath
+  module ODS
+    OFFICE = "urn:oasis:names:tc:opendocument:xmlns:office:1.0"
+    TABLE = "urn:oasis:names:tc:opendocument:xmlns:table:1.0"
+    TEXT = "urn:oasis:names:tc:opendocument:xmlns:text:1.0"
+    OF = "urn:oasis:names:tc:opendocument:xmlns:of:1.2"
+    MANIFEST = "urn:oasis:names:tc:opendocument:xmlns:manifest:1.0"
+    MIME = "application/vnd.oasis.opendocument.spreadsheet"
+    module_function
+
+    def read(path)
+      parts = Package.read(path)
+      raise UnsupportedFeature, "unsupported ODS package parts" unless parts.keys.sort == ["META-INF/manifest.xml", "content.xml", "mimetype"].sort
+      raise InvalidPackage, "not an ODS spreadsheet" unless parts["mimetype"] == MIME
+      check_manifest(parts.fetch("META-INF/manifest.xml"))
+      root = Package.xml(parts.fetch("content.xml"))
+      Package.check(root, OFFICE, "document-content", attributes: [[OFFICE, "version"]], children: [[OFFICE, "body"]])
+      raise UnsupportedFeature, "unsupported ODS version" unless root.attributes["office:version"] == "1.3"
+      body = root.elements.to_a
+      raise InvalidPackage, "missing ODS body" unless body.length == 1
+      Package.check(body.first, OFFICE, "body", children: [[OFFICE, "spreadsheet"]])
+      spreadsheet = body.first.elements.to_a
+      raise InvalidPackage, "missing ODS spreadsheet" unless spreadsheet.length == 1
+      Package.check(spreadsheet.first, OFFICE, "spreadsheet", children: [[TABLE, "table"]])
+      book = Workbook.new(source_format: :ods)
+      spreadsheet.first.elements.each { |table| parse_table(table, book) }
+      raise InvalidPackage, "ODS has no sheets" if book.sheet_names.empty?
+      book
+    end
+
+    def write(book, path)
+      raise Error, "workbook has no sheets" if book.sheet_names.empty?
+      raise UnsupportedFeature, "cannot translate xlsx formulas to ODS" if book.source_format == :xlsx && book.sheet_names.any? { |name| book.each_cell(name).any? { |_r, _c, cell| cell.formula } }
+      parts = {
+        "mimetype" => MIME,
+        "META-INF/manifest.xml" => manifest_xml,
+        "content.xml" => content_xml(book)
+      }
+      Package.write(parts, path, first_stored: "mimetype")
+    end
+
+    def check_manifest(bytes)
+      root = Package.xml(bytes)
+      Package.check(root, MANIFEST, "manifest", attributes: [[MANIFEST, "version"]], children: [[MANIFEST, "file-entry"]])
+      entries = root.elements.to_a.to_h do |entry|
+        Package.check(entry, MANIFEST, "file-entry", attributes: [[MANIFEST, "full-path"], [MANIFEST, "media-type"]])
+        [entry.attributes["manifest:full-path"], entry.attributes["manifest:media-type"]]
+      end
+      raise InvalidPackage, "duplicate ODS manifest entry" if entries.length != root.elements.to_a.length
+      raise UnsupportedFeature, "unsupported ODS manifest" unless entries == {"/" => MIME, "content.xml" => "text/xml"}
+    end
+
+    def parse_table(element, book)
+      Package.check(element, TABLE, "table", attributes: [[TABLE, "name"]], children: [[TABLE, "table-row"]])
+      name = element.attributes["table:name"]
+      raise InvalidPackage, "missing sheet name" unless name
+      book.add_sheet(name)
+      row_number = 1
+      element.elements.each do |row|
+        Package.check(row, TABLE, "table-row", attributes: [[TABLE, "number-rows-repeated"]], children: [[TABLE, "table-cell"]])
+        repeat = count(row.attributes["table:number-rows-repeated"])
+        raise InvalidPackage, "row out of range" if row_number + repeat - 1 > Workbook::MAX_ROWS
+        column_number = 1
+        row.elements.each do |cell|
+          Package.check(cell, TABLE, "table-cell", attributes: [[TABLE, "number-columns-repeated"], [TABLE, "formula"], [OFFICE, "value-type"], [OFFICE, "value"], [OFFICE, "boolean-value"], [OFFICE, "string-value"]], children: [[TEXT, "p"]])
+          columns = count(cell.attributes["table:number-columns-repeated"])
+          raise InvalidPackage, "column out of range" if column_number + columns - 1 > Workbook::MAX_COLUMNS
+          formula = cell.attributes["table:formula"]
+          raise UnsupportedFeature, "unsupported ODS formula syntax" if formula && !formula.start_with?("of:=")
+          raise InvalidPackage, "OpenFormula namespace is not bound" if formula && cell.namespace("of") != OF
+          value = parse_value(cell)
+          raise UnsupportedFeature, "ODS formula requires a cached value" if formula && value.nil?
+          populated = !value.nil? || formula
+          raise UnsupportedFeature, "repeated populated rows are not supported" if repeat > 1 && populated
+          raise UnsupportedFeature, "repeated populated cells are not supported" if columns > 1 && populated
+          book.set(name, row_number, column_number, value, formula:) if populated
+          column_number += columns
+        end
+        row_number += repeat
+      end
+    end
+
+    def parse_value(cell)
+      paragraphs = cell.elements.to_a
+      paragraphs.each { |paragraph| Package.check(paragraph, TEXT, "p", text: true) }
+      raise UnsupportedFeature, "multiline or rich text is not supported" if paragraphs.length > 1 || paragraphs.any? { |p| !p.elements.to_a.empty? }
+      type = cell.attributes["office:value-type"]
+      values = %w[value boolean-value string-value].select { |key| cell.attributes["office:#{key}"] }
+      allowed = {nil => [], "string" => ["string-value"], "float" => ["value"], "boolean" => ["boolean-value"]}[type]
+      raise UnsupportedFeature, "unsupported ODS value type: #{type}" unless allowed
+      raise UnsupportedFeature, "conflicting ODS value attributes" unless (values - allowed).empty?
+      case type
+      when nil
+        raise InvalidPackage, "text without a value type" unless paragraphs.empty?
+        nil
+      when "string"
+        text = cell.attributes["office:string-value"] || paragraphs.first&.text.to_s
+        raise UnsupportedFeature, "ODS string display text is required" if paragraphs.empty?
+        safe_text!(text)
+        raise InvalidPackage, "string cache differs from display text" if paragraphs.any? && paragraphs.first.text.to_s != text
+        text
+      when "float"
+        raise UnsupportedFeature, "formatted numeric display text" unless paragraphs.empty?
+        XLSX.number(cell.attributes["office:value"])
+      when "boolean"
+        raise UnsupportedFeature, "formatted boolean display text" unless paragraphs.empty?
+        {"true" => true, "false" => false}.fetch(cell.attributes["office:boolean-value"]) { raise InvalidPackage, "invalid ODS boolean" }
+      end
+    end
+
+    def count(value)
+      return 1 unless value
+      raise InvalidPackage, "invalid repeat count" unless value.length <= 7 && value.match?(/\A[1-9]\d*\z/)
+      Integer(value, 10)
+    end
+
+    def manifest_xml
+      root = REXML::Element.new("manifest:manifest")
+      root.add_attributes("xmlns:manifest" => MANIFEST, "manifest:version" => "1.3")
+      root.add_element("manifest:file-entry").add_attributes("manifest:full-path" => "/", "manifest:media-type" => MIME)
+      root.add_element("manifest:file-entry").add_attributes("manifest:full-path" => "content.xml", "manifest:media-type" => "text/xml")
+      Package.render(root)
+    end
+
+    def content_xml(book)
+      root = REXML::Element.new("office:document-content")
+      root.add_attributes("xmlns:office" => OFFICE, "xmlns:table" => TABLE, "xmlns:text" => TEXT, "xmlns:of" => OF, "office:version" => "1.3")
+      spreadsheet = root.add_element("office:body").add_element("office:spreadsheet")
+      book.sheet_names.each do |name|
+        table = spreadsheet.add_element("table:table", {"table:name" => name})
+        previous_row = 0
+        book.each_cell(name).group_by(&:first).each do |row, cells|
+          gap = row - previous_row - 1
+          table.add_element("table:table-row", {"table:number-rows-repeated" => gap.to_s}) if gap.positive?
+          row_node = table.add_element("table:table-row")
+          previous_column = 0
+          cells.each do |_row, column, cell|
+            raise UnsupportedFeature, "ODS formula must start with of:=" if cell.formula && !cell.formula.start_with?("of:=")
+            gap = column - previous_column - 1
+            row_node.add_element("table:table-cell", {"table:number-columns-repeated" => gap.to_s}) if gap.positive?
+            node = row_node.add_element("table:table-cell")
+            node.add_attribute("table:formula", cell.formula) if cell.formula
+            case cell.value
+            when String
+              safe_text!(cell.value)
+              node.add_attributes("office:value-type" => "string", "office:string-value" => cell.value)
+              node.add_element("text:p").text = cell.value
+            when TrueClass, FalseClass then node.add_attributes("office:value-type" => "boolean", "office:boolean-value" => cell.value.to_s)
+            when Numeric then node.add_attributes("office:value-type" => "float", "office:value" => cell.value.to_s)
+            when NilClass
+              raise UnsupportedFeature, "ODS formula requires a cached value" if cell.formula
+            end
+            previous_column = column
+          end
+          previous_row = row
+        end
+      end
+      Package.render(root)
+    end
+
+    def safe_text!(text)
+      if text.match?(/\A | \z| {2}|[\t\r\n]/)
+        raise UnsupportedFeature, "ODS string whitespace needs text:s, tab, or line-break support"
+      end
+    end
+  end
+end

data/lib/lesath/package.rb

@@ -0,0 +1,120 @@
+# frozen_string_literal: true
+
+require "tempfile"
+
+module Lesath
+  module Package
+    MAX_PART = 20 * 1024 * 1024
+    MAX_TOTAL = 50 * 1024 * 1024
+    MAX_ENTRIES = 256
+
+    def self.read(path)
+      Zip::File.open(path) do |zip|
+        raise InvalidPackage, "too many ZIP entries" if zip.entries.length > MAX_ENTRIES
+
+        parts = {}
+        total = 0
+        zip.entries.each do |entry|
+          name = entry.name
+          raise InvalidPackage, "unsafe ZIP path" if name.start_with?("/") || name.include?("\\") || name.split("/").include?("..") || name.include?("\0")
+          raise InvalidPackage, "duplicate ZIP part: #{name}" if parts.key?(name)
+          raise InvalidPackage, "encrypted ZIP entry" if (entry.gp_flags & 1) != 0
+          raise InvalidPackage, "ZIP part too large" if entry.size > MAX_PART || total + entry.size > MAX_TOTAL
+          raise InvalidPackage, "suspicious ZIP compression" if entry.compressed_size.positive? && entry.size > entry.compressed_size * 1_000
+
+          bytes = entry.get_input_stream { |input| input.read(MAX_PART + 1) }
+          raise InvalidPackage, "ZIP part too large" if bytes.bytesize > MAX_PART
+          total += bytes.bytesize
+          raise InvalidPackage, "ZIP package too large" if total > MAX_TOTAL
+          parts[name] = bytes
+        end
+        parts
+      end
+    rescue Zip::Error, SystemCallError => error
+      raise InvalidPackage, "cannot read package: #{error.message}"
+    end
+
+    def self.write(parts, path, first_stored: nil)
+      raise Error, "target already exists: #{path}" if File.exist?(path)
+
+      target = File.expand_path(path)
+      Tempfile.create([".lesath-", ".tmp"], File.dirname(target)) do |file|
+        file.close
+        Zip::OutputStream.open(file.path) do |zip|
+          parts.each do |name, bytes|
+            zip.put_next_entry(name, nil, nil, first_stored == name ? Zip::Entry::STORED : Zip::Entry::DEFLATED)
+            zip.write(bytes)
+          end
+        end
+        read(file.path) # An output must satisfy the same ZIP limits as an input.
+        if Gem.win_platform?
+          created = completed = false
+          begin
+            File.open(target, File::WRONLY | File::CREAT | File::EXCL) do |output|
+              created = true
+              IO.copy_stream(file.path, output)
+              output.flush
+              output.fsync
+            end
+            completed = true
+          ensure
+            File.unlink(target) if created && !completed && File.file?(target)
+          end
+        else
+          File.link(file.path, target)
+        end
+      end
+      path
+    rescue Errno::EEXIST
+      raise Error, "target already exists: #{path}"
+    end
+
+    def self.xml(bytes)
+      raise InvalidPackage, "XML DTD is not supported" if bytes.match?(/<!\s*(?:DOCTYPE|ENTITY)/i)
+      document = REXML::Document.new(bytes)
+      raise InvalidPackage, "empty XML part" unless document.root
+      document.children.each do |child|
+        next if child.is_a?(REXML::XMLDecl) || child.equal?(document.root)
+        next if child.is_a?(REXML::Text) && child.value.strip.empty?
+
+        raise UnsupportedFeature, "unsupported XML prolog content"
+      end
+
+      document.root
+    rescue REXML::ParseException => error
+      raise InvalidPackage, "invalid XML: #{error.message}"
+    end
+
+    def self.check(element, namespace, name, attributes: [], children: [], text: false)
+      raise UnsupportedFeature, "unexpected XML element: #{element.expanded_name}" unless element.namespace == namespace && element.name == name
+
+      element.attributes.each_attribute do |attribute|
+        next if attribute.expanded_name == "xmlns" || attribute.expanded_name.start_with?("xmlns:")
+        namespace = attribute.expanded_name == "xml:space" ? "http://www.w3.org/XML/1998/namespace" : attribute.namespace
+        raise UnsupportedFeature, "unsupported attribute: #{attribute.expanded_name}" unless attributes.include?([namespace, attribute.name])
+      end
+      element.elements.each do |child|
+        raise UnsupportedFeature, "unsupported XML element: #{child.expanded_name}" unless children.include?([child.namespace, child.name])
+      end
+      text_nodes = element.children.select { |child| child.is_a?(REXML::Text) }
+      if text_nodes.any? { |child| child.is_a?(REXML::CData) } || (text && text_nodes.length > 1)
+        raise UnsupportedFeature, "CDATA or split XML text is not supported"
+      end
+      element.children.each do |child|
+        if child.is_a?(REXML::Text)
+          raise UnsupportedFeature, "unexpected XML text" if !text && !child.value.strip.empty?
+        elsif !child.is_a?(REXML::Element)
+          raise UnsupportedFeature, "unsupported XML content"
+        end
+      end
+      element
+    end
+
+    def self.render(root)
+      document = REXML::Document.new
+      document << REXML::XMLDecl.new("1.0", "UTF-8")
+      document.add_element(root)
+      document.to_s
+    end
+  end
+end

data/lib/lesath/version.rb

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

data/lib/lesath/workbook.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+module Lesath
+  class Error < StandardError; end
+  class UnsupportedFeature < Error; end
+  class InvalidPackage < Error; end
+
+  Cell = Data.define(:value, :formula)
+
+  class Workbook
+    MAX_ROWS = 1_048_576
+    MAX_COLUMNS = 16_384
+    MAX_CELLS = 100_000
+    MAX_SHEETS = 200
+
+    attr_reader :source_format
+
+    def initialize(source_format: nil)
+      @source_format = source_format
+      @sheets = {}
+    end
+
+    def sheet_names = @sheets.keys.freeze
+
+    def add_sheet(name)
+      name = xml_text(name.to_s)
+      raise Error, "invalid sheet name" if name.empty? || name.length > 31 || name.match?(/[\[\]:*?\\\/]/) || name.start_with?("'") || name.end_with?("'")
+      raise Error, "duplicate sheet name: #{name}" if @sheets.keys.any? { |key| key.casecmp?(name) }
+      raise Error, "too many sheets" if @sheets.length >= MAX_SHEETS
+
+      @sheets[name.freeze] = {}
+      self
+    end
+
+    def cell(sheet, row, column)
+      @sheets.fetch(sheet) { raise Error, "unknown sheet: #{sheet}" }[[row, column]]
+    end
+
+    def set(sheet, row, column, value = nil, formula: nil)
+      cells = @sheets.fetch(sheet) { raise Error, "unknown sheet: #{sheet}" }
+      raise Error, "cell coordinates out of range" unless row.is_a?(Integer) && row.between?(1, MAX_ROWS) && column.is_a?(Integer) && column.between?(1, MAX_COLUMNS)
+      raise Error, "unsupported cell value" unless value.nil? || value.is_a?(String) || value == true || value == false || value.is_a?(Integer) || (value.is_a?(Float) && value.finite?)
+      raise Error, "integer exceeds spreadsheet precision" if value.is_a?(Integer) && value.abs > 999_999_999_999_999
+      raise Error, "invalid formula" if formula && (!formula.is_a?(String) || formula.empty?)
+      value = xml_text(value) if value.is_a?(String)
+      formula = xml_text(formula) if formula
+      raise Error, "cell text exceeds 32767 UTF-16 units" if value.is_a?(String) && value.encode("UTF-16LE").bytesize / 2 > 32_767
+      raise Error, "too many cells" if !cells.key?([row, column]) && cell_count >= MAX_CELLS
+
+      value.nil? && formula.nil? ? cells.delete([row, column]) : cells[[row, column]] = Cell.new(value:, formula:)
+      self
+    end
+
+    def each_cell(sheet, &block)
+      return enum_for(__method__, sheet) unless block
+
+      @sheets.fetch(sheet) { raise Error, "unknown sheet: #{sheet}" }.sort.each do |(row, column), cell|
+        block.call(row, column, cell)
+      end
+      self
+    end
+
+    def cell_count = @sheets.values.sum(&:size)
+
+    private
+
+    def xml_text(value)
+      text = value.encode(Encoding::UTF_8)
+      raise Error, "invalid XML text" unless text.valid_encoding? && !text.match?(/[\u0000-\u0008\u000B\u000C\u000E-\u001F]/)
+      text.freeze
+    rescue EncodingError
+      raise Error, "invalid XML text"
+    end
+  end
+end

data/lib/lesath/xlsx.rb

@@ -0,0 +1,240 @@
+# frozen_string_literal: true
+
+module Lesath
+  module XLSX
+    MAIN = "http://schemas.openxmlformats.org/spreadsheetml/2006/main"
+    DOC_REL = "http://schemas.openxmlformats.org/officeDocument/2006/relationships"
+    PKG_REL = "http://schemas.openxmlformats.org/package/2006/relationships"
+    TYPES = "http://schemas.openxmlformats.org/package/2006/content-types"
+    WORKBOOK_REL = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/officeDocument"
+    SHEET_REL = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/worksheet"
+    module_function
+
+    def read(path)
+      parts = Package.read(path)
+      root_rels(parts.fetch("_rels/.rels") { raise InvalidPackage, "missing root relationships" })
+      relationships = workbook_rels(parts.fetch("xl/_rels/workbook.xml.rels") { raise InvalidPackage, "missing workbook relationships" })
+      workbook_xml = parts.fetch("xl/workbook.xml") { raise InvalidPackage, "missing workbook" }
+      names = workbook_sheets(workbook_xml)
+      expected = ["[Content_Types].xml", "_rels/.rels", "xl/workbook.xml", "xl/_rels/workbook.xml.rels"]
+      book = Workbook.new(source_format: :xlsx)
+      names.each do |name, id|
+        target = relationships.delete(id) { raise InvalidPackage, "sheet relationship missing: #{id}" }
+        expected << target
+        book.add_sheet(name)
+        parse_sheet(parts.fetch(target) { raise InvalidPackage, "sheet part missing: #{target}" }, book, name)
+      end
+      raise UnsupportedFeature, "unused workbook relationship" unless relationships.empty?
+      raise UnsupportedFeature, "unsupported package parts: #{(parts.keys - expected).join(', ')}" unless (parts.keys - expected).empty?
+      content_types(parts.fetch("[Content_Types].xml"), expected)
+      book
+    end
+
+    def write(book, path)
+      raise Error, "workbook has no sheets" if book.sheet_names.empty?
+      raise UnsupportedFeature, "cannot translate ODS formulas to xlsx" if book.source_format == :ods && book.sheet_names.any? { |name| book.each_cell(name).any? { |_r, _c, cell| cell.formula } }
+
+      parts = {}
+      parts["[Content_Types].xml"] = types_xml(book.sheet_names.length)
+      parts["_rels/.rels"] = relationships_xml([["rId1", WORKBOOK_REL, "xl/workbook.xml"]])
+      parts["xl/workbook.xml"] = workbook_xml(book.sheet_names)
+      parts["xl/_rels/workbook.xml.rels"] = relationships_xml(book.sheet_names.each_index.map { |index| ["rId#{index + 1}", SHEET_REL, "worksheets/sheet#{index + 1}.xml"] })
+      book.sheet_names.each_with_index { |name, index| parts["xl/worksheets/sheet#{index + 1}.xml"] = sheet_xml(book, name) }
+      Package.write(parts, path)
+    end
+
+    def root_rels(bytes)
+      root = Package.xml(bytes)
+      Package.check(root, PKG_REL, "Relationships", children: [[PKG_REL, "Relationship"]])
+      rels = root.elements.to_a
+      raise InvalidPackage, "invalid root relationships" unless rels.length == 1
+      rel = Package.check(rels.first, PKG_REL, "Relationship", attributes: [["", "Id"], ["", "Type"], ["", "Target"]])
+      raise UnsupportedFeature, "unsupported root relationship" unless rel.attributes["Type"] == WORKBOOK_REL && rel.attributes["Target"] == "xl/workbook.xml"
+    end
+
+    def workbook_rels(bytes)
+      root = Package.xml(bytes)
+      Package.check(root, PKG_REL, "Relationships", children: [[PKG_REL, "Relationship"]])
+      relationships = root.elements.to_a.to_h do |rel|
+        Package.check(rel, PKG_REL, "Relationship", attributes: [["", "Id"], ["", "Type"], ["", "Target"]])
+        raise UnsupportedFeature, "unsupported workbook relationship" unless rel.attributes["Type"] == SHEET_REL
+        target = rel.attributes["Target"]
+        raise UnsupportedFeature, "unsafe worksheet relationship" unless target&.match?(/\Aworksheets\/sheet\d+\.xml\z/)
+        [rel.attributes["Id"], "xl/#{target}"]
+      end
+      raise InvalidPackage, "duplicate workbook relationship" if relationships.length != root.elements.to_a.length
+      relationships
+    end
+
+    def workbook_sheets(bytes)
+      root = Package.xml(bytes)
+      Package.check(root, MAIN, "workbook", children: [[MAIN, "sheets"], [MAIN, "calcPr"]])
+      sheets = root.elements.to_a.select { |element| element.name == "sheets" }
+      raise InvalidPackage, "missing sheets" unless sheets.length == 1
+      root.elements.to_a.select { |element| element.name == "calcPr" }.each do |element|
+        Package.check(element, MAIN, "calcPr", attributes: [["", "fullCalcOnLoad"]])
+      end
+      Package.check(sheets.first, MAIN, "sheets", children: [[MAIN, "sheet"]])
+      names = sheets.first.elements.to_a.map do |sheet|
+        Package.check(sheet, MAIN, "sheet", attributes: [["", "name"], ["", "sheetId"], [DOC_REL, "id"]])
+        [sheet.attributes["name"], sheet.attributes["r:id"]]
+      end
+      raise InvalidPackage, "workbook has no sheets" if names.empty? || names.any? { |name, id| !name || !id }
+      names
+    end
+
+    def content_types(bytes, expected)
+      root = Package.xml(bytes)
+      Package.check(root, TYPES, "Types", children: [[TYPES, "Default"], [TYPES, "Override"]])
+      overrides = root.elements.to_a.filter_map do |element|
+        if element.name == "Default"
+          Package.check(element, TYPES, "Default", attributes: [["", "Extension"], ["", "ContentType"]])
+          raise UnsupportedFeature, "unsupported content type" unless element.attributes["Extension"] == "rels" && element.attributes["ContentType"] == "application/vnd.openxmlformats-package.relationships+xml"
+          nil
+        else
+          Package.check(element, TYPES, "Override", attributes: [["", "PartName"], ["", "ContentType"]])
+          part = element.attributes["PartName"].to_s.delete_prefix("/")
+          expected_type = part == "xl/workbook.xml" ? "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet.main+xml" : "application/vnd.openxmlformats-officedocument.spreadsheetml.worksheet+xml"
+          raise UnsupportedFeature, "unsupported part content type" unless element.attributes["ContentType"] == expected_type
+          part
+        end
+      end
+      raise UnsupportedFeature, "content types do not match workbook parts" unless overrides.sort == (expected - ["[Content_Types].xml", "_rels/.rels", "xl/_rels/workbook.xml.rels"]).sort
+    end
+
+    def parse_sheet(bytes, book, name)
+      root = Package.xml(bytes)
+      Package.check(root, MAIN, "worksheet", children: [[MAIN, "sheetData"]])
+      data = root.elements.to_a
+      raise InvalidPackage, "missing sheet data" unless data.length == 1
+      Package.check(data.first, MAIN, "sheetData", children: [[MAIN, "row"]])
+      data.first.elements.each do |row|
+        Package.check(row, MAIN, "row", attributes: [["", "r"]], children: [[MAIN, "c"]])
+        row.elements.each { |cell| parse_cell(cell, book, name) }
+      end
+    end
+
+    def parse_cell(element, book, name)
+      Package.check(element, MAIN, "c", attributes: [["", "r"], ["", "t"], ["", "s"]], children: [[MAIN, "f"], [MAIN, "v"], [MAIN, "is"]])
+      raise InvalidPackage, "duplicate cell child" if element.elements.to_a.map(&:name).tally.values.any? { |count| count > 1 }
+      raise UnsupportedFeature, "cell style is not supported" if element.attributes["s"] && element.attributes["s"] != "0"
+      reference = element.attributes["r"]
+      raise InvalidPackage, "invalid cell reference" unless reference&.match?(/\A[A-Z]+[1-9]\d*\z/)
+      letters, row = reference.match(/\A([A-Z]+)(\d+)\z/).captures
+      column = letters.bytes.reduce(0) { |value, byte| value * 26 + byte - 64 }
+      row = row.to_i
+      raise InvalidPackage, "cell outside row" unless element.parent.attributes["r"].to_i == row
+      raise InvalidPackage, "duplicate cell: #{reference}" if book.cell(name, row, column)
+      formula = element.elements["f"]
+      value = element.elements["v"]
+      inline = element.elements["is"]
+      Package.check(formula, MAIN, "f", text: true) if formula
+      Package.check(value, MAIN, "v", text: true) if value
+      if inline
+        Package.check(inline, MAIN, "is", children: [[MAIN, "t"]])
+        raise UnsupportedFeature, "rich text is not supported" unless inline.elements.to_a.length == 1
+        Package.check(inline.elements[1], MAIN, "t", attributes: [["http://www.w3.org/XML/1998/namespace", "space"]], text: true)
+        if whitespace_sensitive?(inline.elements[1].text.to_s) && inline.elements[1].attributes["xml:space"] != "preserve"
+          raise UnsupportedFeature, "inline string needs xml:space=preserve"
+        end
+      end
+      raise InvalidPackage, "conflicting cell values" if inline && value
+      type = element.attributes["t"] || "n"
+      parsed = case type
+      when "inlineStr" then inline&.elements&.[]("t")&.text.to_s
+      when "str" then value&.text.to_s
+      when "b" then {"1" => true, "0" => false}.fetch(value&.text) { raise InvalidPackage, "invalid boolean" }
+      when "n" then value ? number(value.text) : nil
+      else raise UnsupportedFeature, "unsupported cell type: #{type}"
+      end
+      raise InvalidPackage, "missing inline string" if type == "inlineStr" && !inline
+      raise InvalidPackage, "unexpected inline string" if type != "inlineStr" && inline
+      raise UnsupportedFeature, "inline formula is not supported" if formula && inline
+      raise InvalidPackage, "empty formula" if formula && formula.text.to_s.empty?
+      raise UnsupportedFeature, "formula requires a cached value" if formula && !value
+      raise UnsupportedFeature, "formula requires a cached value" if formula && parsed.nil?
+      book.set(name, row, column, parsed, formula: formula && "=#{formula.text}")
+    end
+
+    def number(text)
+      raise InvalidPackage, "invalid number" unless text&.match?(/\A[+-]?(?:\d+\.?\d*|\.\d+)(?:[eE][+-]?\d+)?\z/)
+      value = text.match?(/\A[+-]?\d+\z/) ? Integer(text, 10) : Float(text)
+      raise InvalidPackage, "non-finite number" unless value.finite?
+      value
+    end
+
+    def relationships_xml(entries)
+      root = REXML::Element.new("Relationships")
+      root.add_attribute("xmlns", PKG_REL)
+      entries.each do |id, type, target|
+        rel = root.add_element("Relationship")
+        rel.add_attributes("Id" => id, "Type" => type, "Target" => target)
+      end
+      Package.render(root)
+    end
+
+    def types_xml(count)
+      root = REXML::Element.new("Types")
+      root.add_attribute("xmlns", TYPES)
+      root.add_element("Default").add_attributes("Extension" => "rels", "ContentType" => "application/vnd.openxmlformats-package.relationships+xml")
+      root.add_element("Override").add_attributes("PartName" => "/xl/workbook.xml", "ContentType" => "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet.main+xml")
+      count.times do |index|
+        root.add_element("Override").add_attributes("PartName" => "/xl/worksheets/sheet#{index + 1}.xml", "ContentType" => "application/vnd.openxmlformats-officedocument.spreadsheetml.worksheet+xml")
+      end
+      Package.render(root)
+    end
+
+    def workbook_xml(names)
+      root = REXML::Element.new("workbook")
+      root.add_attributes("xmlns" => MAIN, "xmlns:r" => DOC_REL)
+      sheets = root.add_element("sheets")
+      names.each_with_index { |name, index| sheets.add_element("sheet").add_attributes("name" => name, "sheetId" => (index + 1).to_s, "r:id" => "rId#{index + 1}") }
+      root.add_element("calcPr").add_attribute("fullCalcOnLoad", "1")
+      Package.render(root)
+    end
+
+    def sheet_xml(book, name)
+      root = REXML::Element.new("worksheet")
+      root.add_attribute("xmlns", MAIN)
+      data = root.add_element("sheetData")
+      previous = nil
+      book.each_cell(name) do |row, column, cell|
+        raise UnsupportedFeature, "xlsx formula must start with =" if cell.formula && !cell.formula.start_with?("=")
+        current = row == previous ? data.elements.to_a.last : data.add_element("row", {"r" => row.to_s})
+        previous = row
+        node = current.add_element("c", {"r" => reference(row, column)})
+        node.add_element("f").text = cell.formula.delete_prefix("=") if cell.formula
+        case cell.value
+        when String
+          if cell.formula
+            node.add_attribute("t", "str")
+            node.add_element("v").text = cell.value
+          else
+            node.add_attribute("t", "inlineStr")
+            text = node.add_element("is").add_element("t")
+            text.add_attribute("xml:space", "preserve") if whitespace_sensitive?(cell.value)
+            text.text = cell.value
+          end
+        when TrueClass, FalseClass
+          node.add_attribute("t", "b")
+          node.add_element("v").text = cell.value ? "1" : "0"
+        when Numeric then node.add_element("v").text = cell.value.to_s
+        end
+      end
+      Package.render(root)
+    end
+
+    def reference(row, column)
+      letters = +""
+      while column.positive?
+        column, remainder = (column - 1).divmod(26)
+        letters.prepend((65 + remainder).chr)
+      end
+      "#{letters}#{row}"
+    end
+
+    def whitespace_sensitive?(text)
+      text.match?(/\A\s|\s\z|[ \t]{2}|[\r\n\t]/)
+    end
+  end
+end

data/lib/lesath.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require "rexml/document"
+require "zip"
+require_relative "lesath/version"
+require_relative "lesath/workbook"
+require_relative "lesath/package"
+require_relative "lesath/xlsx"
+require_relative "lesath/ods"
+
+module Lesath
+  def self.read(path, format: nil)
+    format ||= File.extname(path).downcase.delete_prefix(".").to_sym
+    codec(format).read(path)
+  end
+
+  def self.write(workbook, path, format: nil)
+    format ||= File.extname(path).downcase.delete_prefix(".").to_sym
+    codec(format).write(workbook, path)
+  end
+
+  def self.codec(format)
+    {xlsx: XLSX, ods: ODS}.fetch(format) { raise ArgumentError, "format must be :xlsx or :ods" }
+  end
+  private_class_method :codec
+end

metadata

@@ -0,0 +1,83 @@
+--- !ruby/object:Gem::Specification
+name: lesath
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Yudai Takada
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rexml
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.3'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.3'
+- !ruby/object:Gem::Dependency
+  name: rubyzip
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+description: Reads and writes a documented, lossless subset of xlsx and ODS workbooks.
+email:
+- t.yudai92@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- LICENSE.txt
+- README.md
+- docs/adr/001-lossless-subset.md
+- lib/lesath.rb
+- lib/lesath/ods.rb
+- lib/lesath/package.rb
+- lib/lesath/version.rb
+- lib/lesath/workbook.rb
+- lib/lesath/xlsx.rb
+homepage: https://github.com/noxdea/lesath
+licenses:
+- MIT
+metadata:
+  allowed_push_host: https://rubygems.org
+  homepage_uri: https://github.com/noxdea/lesath
+  source_code_uri: https://github.com/noxdea/lesath/tree/main
+  changelog_uri: https://github.com/noxdea/lesath/blob/main/CHANGELOG.md
+  rubygems_mfa_required: 'true'
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.2.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 4.0.16
+specification_version: 4
+summary: Strict xlsx and ODS spreadsheet interchange
+test_files: []