uniword 1.0.0

data/lib/uniword/wordprocessingml/table_cell_properties.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+require 'lutaml/model'
+
+module Uniword
+  module Wordprocessingml
+    # Table cell properties
+    #
+    # Generated from OOXML schema: wordprocessingml.yml
+    # Element: <w:tcPr>
+    class TableCellProperties < Lutaml::Model::Serializable
+      # Pattern 0: ATTRIBUTES FIRST
+      attribute :cell_width, Uniword::Properties::CellWidth
+      attribute :width, :integer # Convenience attribute for width
+      attribute :borders, TableCellBorders
+      attribute :shading, Uniword::Properties::Shading
+      attribute :vertical_align, Uniword::Properties::CellVerticalAlign
+      attribute :grid_span, ValInt
+      attribute :v_merge, ValInt
+      attribute :tc_mar, TableCellMargin
+      attribute :cnf_style, CnfStyle
+      attribute :no_wrap, NoWrap
+      attribute :text_direction, TextDirection
+
+      xml do
+        element 'tcPr'
+        namespace Uniword::Ooxml::Namespaces::WordProcessingML
+        mixed_content
+
+        map_element 'tcW', to: :cell_width, render_nil: false
+        map_element 'tcBorders', to: :borders, render_nil: false
+        map_element 'shd', to: :shading, render_nil: false
+        map_element 'vAlign', to: :vertical_align, render_nil: false
+        map_element 'gridSpan', to: :grid_span, render_nil: false
+        map_element 'vMerge', to: :v_merge, render_nil: false
+        map_element 'tcMar', to: :tc_mar, render_nil: false
+        map_element 'cnfStyle', to: :cnf_style, render_nil: false
+        map_element 'noWrap', to: :no_wrap, render_nil: false
+        map_element 'textDirection', to: :text_direction,
+                                     render_nil: false
+      end
+
+      # Set vertical merge
+      #
+      # @param value [String, Integer] Vertical merge value
+      # @return [self] For method chaining
+      def vertical_merge=(value)
+        self.v_merge = ValInt.new(value: value.to_i)
+        self
+      end
+
+      # Get vertical merge
+      #
+      # @return [String, nil] Vertical merge value
+      def vertical_merge
+        v_merge&.value
+      end
+    end
+  end
+end

data/lib/uniword/wordprocessingml/table_grid.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require 'lutaml/model'
+
+module Uniword
+  module Wordprocessingml
+    # Table grid column definitions
+    #
+    # Generated from OOXML schema: wordprocessingml.yml
+    # Element: <w:tblGrid>
+    class TableGrid < Lutaml::Model::Serializable
+      attribute :columns, GridCol, collection: true, initialize_empty: true
+
+      xml do
+        element 'tblGrid'
+        namespace Uniword::Ooxml::Namespaces::WordProcessingML
+        mixed_content
+
+        map_element 'gridCol', to: :columns, render_nil: false
+      end
+    end
+  end
+end

data/lib/uniword/wordprocessingml/table_properties.rb

@@ -0,0 +1,352 @@
+# frozen_string_literal: true
+
+require 'lutaml/model'
+
+module Uniword
+  module Wordprocessingml
+    # Table formatting properties
+    #
+    # Represents w:tblPr element containing table-level formatting.
+    # Used in StyleSets and table elements.
+    class TableProperties < Lutaml::Model::Serializable
+      # Pattern 0: ATTRIBUTES FIRST, then XML mappings
+
+      # Style reference
+      attribute :style, TableStyle
+
+      # Table width (wrapper class)
+      attribute :table_width, Uniword::Properties::TableWidth
+
+      # Table alignment (wrapper class for w:jc element)
+      attribute :alignment, Uniword::Properties::TableJustification
+
+      # Table indentation
+      attribute :indent, :integer # In twips
+
+      # Cell spacing
+      attribute :cell_spacing, :integer # In twips
+
+      # Table layout
+      attribute :layout, :string # autofit, fixed
+
+      # Borders flag
+      attribute :borders, :boolean, default: -> { false }
+
+      # Allow break flag
+      attribute :allow_break, :boolean, default: -> { true }
+
+      # Individual border properties (stored as flat attributes)
+      attribute :border_top_style, :string
+      attribute :border_top_size, :integer
+      attribute :border_top_color, :string
+
+      attribute :border_bottom_style, :string
+      attribute :border_bottom_size, :integer
+      attribute :border_bottom_color, :string
+
+      attribute :border_left_style, :string
+      attribute :border_left_size, :integer
+      attribute :border_left_color, :string
+
+      attribute :border_right_style, :string
+      attribute :border_right_size, :integer
+      attribute :border_right_color, :string
+
+      attribute :border_inside_h_style, :string
+      attribute :border_inside_h_size, :integer
+      attribute :border_inside_h_color, :string
+
+      attribute :border_inside_v_style, :string
+      attribute :border_inside_v_size, :integer
+      attribute :border_inside_v_color, :string
+
+      # Table shading (wrapper class with themeFill support)
+      attribute :shading, Uniword::Properties::Shading
+
+      # Table cell margins (wrapper class)
+      attribute :table_cell_margin, Uniword::Properties::TableCellMargin
+
+      # Table indent (wrapper class)
+      attribute :table_indent, Uniword::Properties::TableIndent
+
+      # Table look - conditional formatting flags (wrapper class)
+      attribute :table_look, Uniword::Properties::TableLook
+
+      # Table borders
+      attribute :table_borders, TableBorders
+
+      # XML mappings come AFTER attributes
+      xml do
+        element 'tblPr'
+        namespace Uniword::Ooxml::Namespaces::WordProcessingML
+        mixed_content
+
+        # High-priority mappings (Phase 4 Session 1-2)
+        map_element 'tblW', to: :table_width, render_nil: false
+        map_element 'shd', to: :shading, render_nil: false
+        map_element 'tblCellMar', to: :table_cell_margin, render_nil: false
+        map_element 'tblLook', to: :table_look, render_nil: false
+
+        # Table indentation - critical for table styles
+        map_element 'tblInd', to: :table_indent, render_nil: false
+        # Table cell spacing
+        map_element 'tblCellSpacing', to: :cell_spacing, render_nil: false
+        # Table alignment
+        map_element 'jc', to: :alignment, render_nil: false
+        # Table layout
+        map_element 'tblLayout', to: :layout, render_nil: false
+        # Table style reference
+        map_element 'tblStyle', to: :style, render_nil: false
+
+        # Table borders
+        map_element 'tblBorders', to: :table_borders, render_nil: false
+      end
+
+      # Initialize with defaults and handle convenience attributes
+      def initialize(attrs = {})
+        # Extract border attributes and convert to flat attributes
+        border_attrs = {}
+        %i[top bottom left right inside_h inside_v].each do |side|
+          key = "#{side}_border"
+          if attrs.key?(key) || attrs.key?(key.to_sym)
+            border_attrs[side] = attrs.delete(key) || attrs.delete(key.to_sym)
+          end
+        end
+
+        # Extract other convenience attributes
+        cell_padding_value = attrs.delete(:cell_padding) || attrs.delete('cell_padding')
+        cell_spacing_value = attrs.delete(:cell_spacing) || attrs.delete('cell_spacing')
+
+        # Handle width: parameter (creates table_width wrapper)
+        width_value = attrs.delete(:width) || attrs.delete('width')
+        # Handle alignment: parameter (creates jc element wrapper)
+        alignment_value = attrs.delete(:alignment) || attrs.delete('alignment')
+
+        super
+
+        @borders ||= false
+        @allow_break = true if @allow_break.nil?
+
+        # Set borders from extracted attributes
+        border_attrs.each do |side, value|
+          send("#{side}_border=", value)
+        end
+
+        # Set cell padding if provided
+        self.cell_padding = cell_padding_value if cell_padding_value
+
+        # Set cell spacing if provided
+        self.cell_spacing = cell_spacing_value if cell_spacing_value
+
+        # Set width if provided (creates TableWidth wrapper)
+        if width_value
+          self.table_width = Properties::TableWidth.new
+          table_width.w = width_value.to_i
+          table_width.type ||= 'dxa'
+        end
+
+        # Set alignment if provided (creates TableJustification wrapper)
+        return unless alignment_value
+
+        self.alignment = Properties::TableJustification.new
+        alignment.value = alignment_value
+      end
+
+      # Get table width
+      #
+      # @return [Integer, nil] Table width value
+      def width
+        table_width&.value
+      end
+
+      # Set table width
+      #
+      # @param value [Integer] Width value
+      # @return [self] For method chaining
+      def width=(value)
+        self.table_width ||= Properties::TableWidth.new
+        table_width.value = value
+        self
+      end
+
+      # Get cell padding (alias for table_cell_margin)
+      #
+      # @return [Integer, nil] Cell padding value
+      def cell_padding
+        # Return the padding value if all sides are the same
+        return nil unless table_cell_margin
+
+        margins = [table_cell_margin.top, table_cell_margin.left,
+                   table_cell_margin.bottom, table_cell_margin.right].compact
+        margins.first if margins.uniq.size == 1
+      end
+
+      # Set cell padding
+      #
+      # @param value [Integer, TableCellMargin, Hash] Cell margin settings
+      # @return [self] For method chaining
+      def cell_padding=(value)
+        case value
+        when Integer
+          self.table_cell_margin ||= Properties::TableCellMargin.new
+          table_cell_margin.top = value
+          table_cell_margin.left = value
+          table_cell_margin.bottom = value
+          table_cell_margin.right = value
+        when Properties::TableCellMargin
+          self.table_cell_margin = value
+        when Hash
+          self.table_cell_margin ||= Properties::TableCellMargin.new
+          table_cell_margin.top = value[:top] || value[:all]
+          table_cell_margin.left = value[:left] || value[:all]
+          table_cell_margin.bottom = value[:bottom] || value[:all]
+          table_cell_margin.right = value[:right] || value[:all]
+        else
+          self.table_cell_margin = value
+        end
+        self
+      end
+
+      # Get top border
+      #
+      # @return [BorderInfo, nil] Top border properties
+      def top_border
+        border_to_object(:top)
+      end
+
+      # Set top border
+      #
+      # @param value [TableBorder, Hash] Border configuration
+      # @return [self] For method chaining
+      def top_border=(value)
+        set_border(:top, value)
+        self
+      end
+
+      # Get bottom border
+      #
+      # @return [BorderInfo, nil] Bottom border properties
+      def bottom_border
+        border_to_object(:bottom)
+      end
+
+      # Set bottom border
+      #
+      # @param value [TableBorder, Hash] Border configuration
+      # @return [self] For method chaining
+      def bottom_border=(value)
+        set_border(:bottom, value)
+        self
+      end
+
+      # Get left border
+      #
+      # @return [BorderInfo, nil] Left border properties
+      def left_border
+        border_to_object(:left)
+      end
+
+      # Set left border
+      #
+      # @param value [TableBorder, Hash] Border configuration
+      # @return [self] For method chaining
+      def left_border=(value)
+        set_border(:left, value)
+        self
+      end
+
+      # Get right border
+      #
+      # @return [BorderInfo, nil] Right border properties
+      def right_border
+        border_to_object(:right)
+      end
+
+      # Set right border
+      #
+      # @param value [TableBorder, Hash] Border configuration
+      # @return [self] For method chaining
+      def right_border=(value)
+        set_border(:right, value)
+        self
+      end
+
+      # Get inside horizontal border
+      #
+      # @return [BorderInfo, nil] Inside horizontal border properties
+      def inside_h_border
+        border_to_object(:inside_h)
+      end
+
+      # Set inside horizontal border
+      #
+      # @param value [TableBorder, Hash] Border configuration
+      # @return [self] For method chaining
+      def inside_h_border=(value)
+        set_border(:inside_h, value)
+        self
+      end
+
+      # Get inside vertical border
+      #
+      # @return [BorderInfo, nil] Inside vertical border properties
+      def inside_v_border
+        border_to_object(:inside_v)
+      end
+
+      # Set inside vertical border
+      #
+      # @param value [TableBorder, Hash] Border configuration
+      # @return [self] For method chaining
+      def inside_v_border=(value)
+        set_border(:inside_v, value)
+        self
+      end
+
+      private
+
+      # Simple struct for border info with accessor methods
+      BorderInfo = Struct.new(:style, :size, :color)
+
+      # Convert border attributes to BorderInfo object
+      #
+      # @param side [Symbol] Border side (:top, :bottom, :left, :right, :inside_h, :inside_v)
+      # @return [BorderInfo, nil] Border properties object
+      def border_to_object(side)
+        style = send("border_#{side}_style")
+        return nil unless style
+
+        BorderInfo.new(
+          style: style,
+          size: send("border_#{side}_size"),
+          color: send("border_#{side}_color")
+        )
+      end
+
+      # Set border attributes from TableBorder or Hash
+      #
+      # @param side [Symbol] Border side
+      # @param value [TableBorder, Hash] Border configuration
+      def set_border(side, value)
+        case value
+        when Uniword::TableBorder
+          send("border_#{side}_style=", value.style)
+          send("border_#{side}_size=", value.width)
+          send("border_#{side}_color=", value.color)
+        when Hash
+          send("border_#{side}_style=", value[:style])
+          send("border_#{side}_size=", value[:size])
+          send("border_#{side}_color=", value[:color])
+        end
+      end
+
+      # Convert border attributes to hash (deprecated, use border_to_object)
+      #
+      # @param side [Symbol] Border side (:top, :bottom, :left, :right, :inside_h, :inside_v)
+      # @return [Hash, nil] Border properties hash
+      def border_to_hash(side)
+        border_to_object(side)&.to_h
+      end
+    end
+  end
+end

data/lib/uniword/wordprocessingml/table_row.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+require 'lutaml/model'
+
+module Uniword
+  module Wordprocessingml
+    # Table row
+    #
+    # Generated from OOXML schema: wordprocessingml.yml
+    # Element: <w:tr>
+    class TableRow < Lutaml::Model::Serializable
+      attribute :properties, TableRowProperties
+      attribute :cells, TableCell, collection: true, initialize_empty: true
+
+      # Revision tracking attributes
+      attribute :rsid_r, :string
+      attribute :rsid_r_pr, :string
+      attribute :rsid_tr, :string
+
+      # W14 namespace attributes
+      attribute :para_id, W14ParaId
+      attribute :text_id, W14TextId
+
+      # Header flag for table rows (not serialized, runtime only)
+      attr_accessor :header
+
+      # Predicate for header flag
+      def header?
+        !!@header
+      end
+
+      xml do
+        element 'tr'
+        namespace Uniword::Ooxml::Namespaces::WordProcessingML
+        mixed_content
+
+        map_attribute 'rsidR', to: :rsid_r, render_nil: false
+        map_attribute 'rsidRPr', to: :rsid_r_pr, render_nil: false
+        map_attribute 'rsidTr', to: :rsid_tr, render_nil: false
+        map_attribute 'paraId', to: :para_id, render_nil: false
+        map_attribute 'textId', to: :text_id, render_nil: false
+
+        map_element 'trPr', to: :properties, render_nil: false
+        map_element 'tc', to: :cells, render_nil: false
+      end
+
+      # Get cell count
+      #
+      # @return [Integer] Number of cells in row
+      def cell_count
+        cells.count
+      end
+
+      # Get row height
+      #
+      # @return [Integer, nil] Row height
+      def height
+        properties&.height
+      end
+
+      # Set row height
+      #
+      # @param value [Integer] Height value
+      # @return [Integer] The height value
+      def height=(value)
+        self.properties ||= TableRowProperties.new
+        properties.height = value
+      end
+
+      # Accept a visitor (Visitor pattern)
+      #
+      # @param visitor [BaseVisitor] The visitor to accept
+      # @return [void]
+      def accept(visitor)
+        visitor.visit_table_row(self)
+      end
+    end
+  end
+end

data/lib/uniword/wordprocessingml/table_row_properties.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+require 'lutaml/model'
+
+module Uniword
+  module Wordprocessingml
+    # Table row properties
+    #
+    # Generated from OOXML schema: wordprocessingml.yml
+    # Element: <w:trPr>
+    class TableRowProperties < Lutaml::Model::Serializable
+      # Pattern 0: ATTRIBUTES FIRST, then XML
+      attribute :tr_height, TrHeight
+      attribute :tbl_header, ValInt
+      attribute :cant_split, ValInt
+      attribute :grid_before, GridBefore
+      attribute :grid_after, GridAfter
+      attribute :w_before, WidthBefore
+      attribute :w_after, WidthAfter
+
+      xml do
+        element 'trPr'
+        namespace Uniword::Ooxml::Namespaces::WordProcessingML
+        mixed_content
+
+        map_element 'trHeight', to: :tr_height, render_nil: false
+        map_element 'tblHeader', to: :tbl_header, render_nil: false
+        map_element 'cantSplit', to: :cant_split, render_nil: false
+        map_element 'gridBefore', to: :grid_before, render_nil: false
+        map_element 'gridAfter', to: :grid_after, render_nil: false
+        map_element 'wBefore', to: :w_before, render_nil: false
+        map_element 'wAfter', to: :w_after, render_nil: false
+      end
+
+      def initialize(attrs = {})
+        # Handle table_header: keyword for docx-js API compatibility
+        if attrs.key?(:table_header)
+          val = attrs.delete(:table_header)
+          attrs[:tbl_header] = coerce_to_val_int(val)
+        end
+        super
+      end
+
+      private
+
+      def coerce_to_val_int(val)
+        case val
+        when ValInt then val
+        when true, 1 then ValInt.new(value: 1)
+        when false, 0 then nil
+        when Integer then ValInt.new(value: val)
+        when nil then nil
+        else ValInt.new(value: val.to_i)
+        end
+      end
+    end
+  end
+end

data/lib/uniword/wordprocessingml/table_style.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require 'lutaml/model'
+
+module Uniword
+  module Wordprocessingml
+    # Table style reference
+    #
+    # Element: <w:tblStyle>
+    class TableStyle < Lutaml::Model::Serializable
+      attribute :val, :string
+
+      xml do
+        root 'tblStyle'
+        namespace Uniword::Ooxml::Namespaces::WordProcessingML
+        map_attribute 'val', to: :val
+      end
+    end
+  end
+end

data/lib/uniword/wordprocessingml/text.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+require 'lutaml/model'
+require 'nokogiri'
+
+module Uniword
+  module Wordprocessingml
+    # Text content with xml:space attribute support
+    #
+    # Element: <w:t xml:space="preserve">
+    class Text < Lutaml::Model::Serializable
+      attribute :content, :string
+      attribute :xml_space, :string
+
+      xml do
+        element 't'
+        namespace Uniword::Ooxml::Namespaces::WordProcessingML
+
+        map_content to: :content
+        map_attribute 'xml:space', to: :xml_space
+      end
+
+      # Handle type conversion for lutaml-model's attribute system.
+      # When used as an attribute type, lutaml-model calls cast() to convert
+      # incoming values to the proper type.
+      #
+      # @param value [String, Text, nil] The value to cast
+      # @return [Text, nil] The properly typed Text object
+      def self.cast(value)
+        case value
+        when Text
+          value
+        when nil
+          nil
+        else
+          content_str = value.to_s
+          text_obj = new(content: content_str)
+          # Preserve whitespace for XML serialization
+          if content_str.start_with?(' ') || content_str.end_with?(' ') || content_str.include?("\t")
+            text_obj.xml_space = 'preserve'
+          end
+          text_obj
+        end
+      end
+
+      # Get the actual text value
+      def text
+        content
+      end
+
+      # String conversion for compatibility with code expecting plain strings
+      def to_s
+        content.to_s
+      end
+
+      # Allow comparison with strings for test compatibility
+      def ==(other)
+        return super unless other.is_a?(String)
+
+        content == other
+      end
+
+      alias eql? ==
+
+      # Support String#include? for test compatibility
+      def include?(substr)
+        content.to_s.include?(substr)
+      end
+
+      # Set text value
+      def text=(value)
+        self.content = value
+      end
+
+      # Check if space should be preserved
+      def space_preserve?
+        xml_space == 'preserve'
+      end
+    end
+  end
+end

data/lib/uniword/wordprocessingml/text_box_content.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require 'lutaml/model'
+
+module Uniword
+  module Wordprocessingml
+    # Text box content container
+    # Shared by VML and DrawingML text boxes
+    # Contains paragraphs, tables, and structured document tags
+    class TextBoxContent < Lutaml::Model::Serializable
+      # PATTERN 0: Attributes FIRST
+      attribute :paragraphs, Paragraph, collection: true, initialize_empty: true
+      attribute :tables, Table, collection: true, initialize_empty: true
+      attribute :sdts, StructuredDocumentTag, collection: true, initialize_empty: true
+
+      xml do
+        element 'txbxContent'
+        namespace Uniword::Ooxml::Namespaces::WordProcessingML
+        mixed_content
+
+        map_element 'p', to: :paragraphs, render_nil: false
+        map_element 'tbl', to: :tables, render_nil: false
+        map_element 'sdt', to: :sdts, render_nil: false
+      end
+    end
+  end
+end