berkeley_library-tind 0.4.0

data/lib/berkeley_library/util/ods/xml/table/table.rb

@@ -0,0 +1,193 @@
+require 'berkeley_library/util/ods/xml/element_node'
+require 'berkeley_library/util/ods/xml/loext/table_protection'
+require 'berkeley_library/util/ods/xml/style/column_style'
+require 'berkeley_library/util/ods/xml/table/table_column'
+require 'berkeley_library/util/ods/xml/table/table_row'
+
+module BerkeleyLibrary
+  module Util
+    module ODS
+      module XML
+        module Table
+          class Table < XML::ElementNode
+            # ------------------------------------------------------------
+            # Constants
+
+            MIN_COLUMNS = 1024
+            MIN_ROWS = 1_048_576
+
+            # ------------------------------------------------------------
+            # Accessors
+
+            attr_reader :table_name
+
+            attr_reader :table_style
+
+            # @return [XML::Office::AutomaticStyles] the document styles
+            attr_reader :styles
+
+            # ------------------------------------------------------------
+            # Initializers
+
+            # Initializes a new table
+            #
+            # @param name [String] the table name
+            # @param style [XML::Style::TableStyle] the table style, if other than default
+            # @param styles [XML::Office::AutomaticStyles] the document styles
+            # @param protected [Boolean] whether the table is protected
+            def initialize(table_name, table_style = nil, styles:, protected: true)
+              super(:table, 'table', doc: styles.doc)
+
+              @table_name = table_name
+              @table_style = table_style || styles.default_style(:table)
+              @styles = styles
+
+              set_attribute('name', self.table_name)
+              set_attribute('style-name', self.table_style.style_name)
+
+              protect! if protected
+            end
+
+            # ------------------------------------------------------------
+            # Accessors and utility methods
+
+            def column_count
+              @column_count ||= 0
+            end
+
+            def row_count
+              @row_count ||= 0
+            end
+
+            def get_value_at(row_index, column_index)
+              (row = rows[row_index]) && row.get_value_at(column_index)
+            end
+
+            def add_column(header, width = nil, protected: false)
+              add_column_with_styles(
+                header,
+                column_style: styles.find_or_create_column_style(width),
+                default_cell_style: styles.find_or_create_cell_style(protected)
+              )
+            end
+
+            def add_column_with_styles(header, column_style:, default_cell_style: nil, header_cell_style: nil)
+              cell_style = default_cell_style || styles.find_or_create_cell_style
+              add_or_repeat_column(column_style, cell_style).tap do
+                header_row = rows[0] || add_row
+                header_row.set_value_at(column_count, header, header_cell_style)
+                self.column_count += 1
+              end
+            end
+
+            def add_empty_columns(number_repeated, width = nil, protected: false)
+              column_style = styles.find_or_create_column_style(width)
+              default_cell_style = styles.find_or_create_cell_style(protected)
+
+              TableColumn.new(column_style, default_cell_style, number_repeated, table: self).tap do |col|
+                columns << col
+                self.column_count += number_repeated
+              end
+            end
+
+            # Adds a new row with the specified height.
+            # @param height [String] the row height. Defaults to {XML::Style::RowStyle::DEFAULT_HEIGHT}.
+            # @param number_repeated [Integer] the number of identical rows to repeat
+            # @return [TableRow] the new row
+            def add_row(height = nil, number_repeated = 1)
+              row_style = styles.find_or_create_row_style(height)
+              TableRow.new(row_style, number_repeated, table: self).tap do |row|
+                rows << row
+                self.row_count += number_repeated
+              end
+            end
+
+            # ------------------------------------------------------------
+            # Public XML::ElementNode overrides
+
+            def add_child(child)
+              return child.tap { |column| columns << column } if child.is_a?(TableColumn)
+              return child.tap { |row| rows << row } if child.is_a?(TableRow)
+
+              child.tap { |c| other_children << c }
+            end
+
+            # ------------------------------------------------------------
+            # Protected methods
+
+            protected
+
+            # ----------------------------------------
+            # Protected XML::ElementNode overrides
+
+            def children
+              [other_children, columns, rows].flatten
+            end
+
+            def create_element
+              ensure_empty_columns!
+              ensure_empty_rows!
+
+              super
+            end
+
+            # ------------------------------------------------------------
+            # Private methods
+
+            private
+
+            # ------------------------------
+            # Private writers
+
+            attr_writer :column_count
+
+            attr_writer :row_count
+
+            # ------------------------------
+            # Private readers
+
+            def columns
+              @columns ||= []
+            end
+
+            def rows
+              @rows ||= []
+            end
+
+            def other_children
+              @other_children ||= []
+            end
+
+            # ------------------------------
+            # Private utility methods
+
+            def protect!
+              set_attribute('protected', 'true')
+              add_child(LOExt::TableProtection.new(doc: doc))
+            end
+
+            def add_or_repeat_column(column_style, default_cell_style)
+              if (last_column = columns.last).nil? || !last_column.has_styles?(column_style, default_cell_style)
+                TableColumn.new(column_style, default_cell_style, table: self).tap { |c| columns << c }
+              else
+                last_column.tap(&:increment_repeats!)
+              end
+            end
+
+            # TODO: do we really need to use the LibreOffice default width/height?
+
+            def ensure_empty_columns!
+              empty_required = MIN_COLUMNS - column_count
+              add_empty_columns(empty_required, '0.889in') if empty_required > 0
+            end
+
+            def ensure_empty_rows!
+              empty_required = MIN_ROWS - row_count
+              add_row('0.178in', empty_required) if empty_required > 0
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/berkeley_library/util/ods/xml/table/table_cell.rb

@@ -0,0 +1,46 @@
+require 'berkeley_library/util/ods/xml/table/repeatable'
+require 'berkeley_library/util/ods/xml/text/p'
+
+module BerkeleyLibrary
+  module Util
+    module ODS
+      module XML
+        module Table
+          class TableCell < Repeatable
+            attr_reader :value
+            attr_reader :cell_style
+
+            def initialize(value = nil, cell_style = nil, number_repeated = 1, table:)
+              super('table-cell', 'number-columns-repeated', number_repeated, table: table)
+
+              @value = value
+              @cell_style = cell_style
+
+              set_default_attributes!
+              add_default_children!
+            end
+
+            class << self
+              def repeat_empty(number_repeated, cell_style = nil, table:)
+                TableCell.new(nil, cell_style, number_repeated, table: table)
+              end
+            end
+
+            private
+
+            def set_default_attributes!
+              set_attribute('style-name', cell_style.style_name) if cell_style
+              set_attribute(:office, 'value-type', 'string') if value
+              set_attribute(:calcext, 'value-type', 'string') if value
+            end
+
+            def add_default_children!
+              children << XML::Text::P.new(value, doc: doc) if value
+            end
+
+          end
+        end
+      end
+    end
+  end
+end

data/lib/berkeley_library/util/ods/xml/table/table_column.rb

@@ -0,0 +1,43 @@
+require 'berkeley_library/util/ods/xml/element_node'
+require 'berkeley_library/util/ods/xml/table/repeatable'
+
+module BerkeleyLibrary
+  module Util
+    module ODS
+      module XML
+        module Table
+          class TableColumn < Repeatable
+
+            attr_reader :column_style
+            attr_reader :default_cell_style
+
+            # Initializes a new column
+            #
+            # @param column_style [XML::Style::ColumnStyle] the column style
+            # @param default_cell_style [XML::Style::CellStyle] the default cell style for this column
+            def initialize(column_style, default_cell_style, number_repeated = 1, table:)
+              super('table-column', 'number-columns-repeated', number_repeated, table: table)
+              @column_style = column_style
+              @default_cell_style = default_cell_style
+
+              set_default_attributes!
+            end
+
+            # rubocop:disable Naming/PredicateName
+            def has_styles?(column_style, default_cell_style)
+              self.column_style == column_style && self.default_cell_style == default_cell_style
+            end
+            # rubocop:enable Naming/PredicateName
+
+            private
+
+            def set_default_attributes!
+              set_attribute('style-name', column_style.style_name)
+              set_attribute('default-cell-style-name', default_cell_style.style_name)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/berkeley_library/util/ods/xml/table/table_row.rb

@@ -0,0 +1,136 @@
+require 'berkeley_library/util/arrays'
+require 'berkeley_library/util/ods/xml/element_node'
+require 'berkeley_library/util/ods/xml/table/repeatable'
+require 'berkeley_library/util/ods/xml/table/table_cell'
+
+module BerkeleyLibrary
+  module Util
+    module ODS
+      module XML
+        module Table
+          class TableRow < Repeatable
+
+            # ------------------------------------------------------------
+            # Accessors
+
+            attr_reader :row_style
+            attr_reader :default_cell_style
+
+            # ------------------------------------------------------------
+            # Initializer
+
+            # @param table [Table] the table
+            # @param default_cell_style [Style::CellStyle] the default cell style
+            def initialize(row_style, number_repeated = 1, table:, default_cell_style: nil)
+              super('table-row', 'number-rows-repeated', number_repeated, table: table)
+              @row_style = row_style
+              @default_cell_style = default_cell_style
+
+              set_default_attributes!
+            end
+
+            # ------------------------------------------------------------
+            # Public utility methods
+
+            def set_value_at(column_index, value = nil, cell_style = nil)
+              explicit_cells[column_index] = TableCell.new(value, cell_style || default_cell_style, table: table)
+            end
+
+            def get_value_at(column_index)
+              (cell = explicit_cells[column_index]) && cell.value
+            end
+
+            # ------------------------------------------------------------
+            # Public XML::ElementNode overrides
+
+            def add_child(child)
+              return add_table_cell(child) if child.is_a?(TableCell)
+
+              child.tap { |c| other_children << c }
+            end
+
+            # ------------------------------------------------------------
+            # Protected methods
+
+            protected
+
+            # ----------------------------------------
+            # Protected utility methods
+
+            def add_table_cell(cell)
+              return cell.tap { |c| explicit_cells << c } if explicit_cell_count < table.column_count
+
+              raise ArgumentError, "Can't add cell at column index #{explicit_cell_count} to table with only #{table.column_count} columns"
+            end
+
+            # ----------------------------------------
+            # Protected XML::ElementNode overrides
+
+            def children
+              [].tap do |cc|
+                each_cell { |c| cc << c }
+                cc.concat(other_children)
+              end
+            end
+
+            # ------------------------------------------------------------
+            # Private methods
+
+            private
+
+            def column_count_actual
+              [table.column_count, Table::MIN_COLUMNS].max
+            end
+
+            def explicit_cells
+              @explicit_cells ||= []
+            end
+
+            def set_default_attributes!
+              set_attribute('style-name', row_style.style_name)
+            end
+
+            def other_children
+              @other_children ||= []
+            end
+
+            def explicit_cell_count
+              explicit_cells.size
+            end
+
+            def each_cell(columns_yielded = 0, remaining = explicit_cells, &block)
+              columns_yielded, remaining = yield_while_non_nil(columns_yielded, remaining, &block)
+              columns_yielded, remaining = yield_while_nil(columns_yielded, remaining, &block)
+              each_cell(columns_yielded, remaining, &block) unless remaining.empty?
+            end
+
+            def yield_while_non_nil(columns_yielded, remaining, &block)
+              non_nil_cells = remaining.take_while { |c| !c.nil? }
+              non_nil_cells.each(&block)
+              non_nil_cell_count = non_nil_cells.size
+
+              [columns_yielded + non_nil_cell_count, remaining[non_nil_cell_count..]]
+            end
+
+            def yield_while_nil(columns_yielded, remaining, &block)
+              nil_cell_count = Arrays.count_while(values: remaining, &:nil?)
+              remaining = remaining[nil_cell_count..]
+
+              empty_required = remaining.empty? ? (column_count_actual - columns_yielded) : nil_cell_count
+              yield_repeat_empty(empty_required, &block)
+              columns_yielded += empty_required
+
+              [columns_yielded, remaining]
+            end
+
+            def yield_repeat_empty(num_repeats, &block)
+              empty_cell = TableCell.repeat_empty(num_repeats, default_cell_style, table: table)
+              block.call(empty_cell)
+            end
+
+          end
+        end
+      end
+    end
+  end
+end

data/lib/berkeley_library/util/ods/xml/text/p.rb

@@ -0,0 +1,118 @@
+require 'berkeley_library/util/ods/xml/element_node'
+
+module BerkeleyLibrary
+  module Util
+    module ODS
+      module XML
+        module Text
+          class P < XML::ElementNode
+
+            # ------------------------------------------------------------
+            # Constant
+
+            ESCAPABLE = ["\t", "\n", ' '].freeze
+
+            # ------------------------------------------------------------
+            # Accessors
+
+            attr_reader :text
+
+            # ------------------------------------------------------------
+            # Initializer
+
+            def initialize(text, doc:)
+              super(:text, 'p', doc: doc)
+
+              @text = text
+              add_default_children!
+            end
+
+            # ------------------------------------------------------------
+            # Private methods
+
+            private
+
+            def add_default_children!
+              each_child_element_or_string { |c| children << c }
+            end
+
+            def each_child_element_or_string(last_char = nil, text_remaining = text, &block)
+              last_char, text_remaining = yield_while_escaped(last_char, text_remaining, &block)
+              last_char, text_remaining = yield_while_unescaped(last_char, text_remaining, &block)
+              each_child_element_or_string(last_char, text_remaining, &block) unless text_remaining.empty?
+            end
+
+            def yield_while_unescaped(last_char, text_remaining, &block)
+              unescaped, last_char = take_while_unescaped(last_char, text_remaining)
+              unless unescaped.empty?
+                block.call(unescaped)
+                text_remaining = text_remaining[unescaped.size..]
+              end
+
+              [last_char, text_remaining]
+            end
+
+            def yield_while_escaped(last_char, text_remaining, &block)
+              escaped_char_count = 0
+              text_remaining.each_char do |c|
+                break unless escape?(c, last_char)
+
+                # TODO: collapse contiguous spaces with attribute 'text:c'
+                #   https://docs.oasis-open.org/office/v1.2/os/OpenDocument-v1.2-os-part1.html#attribute-text_c
+                block.call(escape_element_for(c))
+                escaped_char_count += 1
+                last_char = c
+              end
+              text_remaining = text_remaining[escaped_char_count..] unless escaped_char_count == 0
+
+              [last_char, text_remaining]
+            end
+
+            def take_while_unescaped(last_char, text_remaining)
+              unescaped = text_remaining.each_char.with_object('') do |c, result|
+                break result if escape?(c, last_char)
+
+                result << c
+                last_char = c
+              end
+              [unescaped, last_char]
+            end
+
+            def escape?(c, last_char)
+              ESCAPABLE.include?(c) && (last_char == ' ' || c != ' ')
+            end
+
+            def escape_element_for(c)
+              raise ArgumentError, "Not an escapable character: #{c}" unless ESCAPABLE.include?(c)
+
+              return S.new(doc: doc) if c == ' '
+              return Tab.new(doc: doc) if c == "\t"
+              return LineBreak.new(doc: doc) if c == "\n"
+            end
+          end
+
+          # ------------------------------------------------------------
+          # Helper classes
+
+          class S < XML::ElementNode
+            def initialize(doc:)
+              super(:text, 's', doc: doc)
+            end
+          end
+
+          class Tab < XML::ElementNode
+            def initialize(doc:)
+              super(:text, 'tab', doc: doc)
+            end
+          end
+
+          class LineBreak < XML::ElementNode
+            def initialize(doc:)
+              super(:text, 'line-break', doc: doc)
+            end
+          end
+        end
+      end
+    end
+  end
+end