uniword 1.0.0

data/lib/uniword/wordprocessingml/numbering_level.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+require 'lutaml/model'
+
+module Uniword
+  module Wordprocessingml
+    # Represents a single level in a numbering definition
+    # Each level defines format, alignment, indentation, and start value
+    class NumberingLevel < Lutaml::Model::Serializable
+      attribute :level, :integer, default: -> { 0 }
+      attribute :format, :string, default: -> { 'decimal' }
+      attribute :text, :string
+      attribute :start, :integer, default: -> { 1 }
+      attribute :alignment, :string, default: -> { 'left' }
+      attribute :left_indent, :integer, default: -> { 0 }
+      attribute :hanging_indent, :integer, default: -> { 0 }
+      attribute :font_name, :string
+      attribute :font_charset, :string
+
+      # Valid numbering formats
+      FORMATS = %w[
+        decimal
+        upperRoman
+        lowerRoman
+        upperLetter
+        lowerLetter
+        ordinal
+        cardinalText
+        ordinalText
+        hex
+        chicago
+        bullet
+      ].freeze
+
+      # Valid alignment values
+      ALIGNMENTS = %w[left right center both].freeze
+
+      def initialize(attrs = {})
+        super
+        validate_format
+        validate_alignment
+      end
+
+      # Set this level as a bullet with the given character
+      def bullet!(character, font_name: 'Symbol')
+        self.format = 'bullet'
+        self.text = character
+        self.font_name = font_name
+      end
+
+      # Check if this is a bullet level
+      def bullet?
+        format == 'bullet'
+      end
+
+      # Get the numbering text template
+      # Example: "%1." for level 0, "%1.%2." for level 1, etc.
+      def numbering_text
+        return text if bullet?
+
+        @text || default_numbering_text
+      end
+
+      private
+
+      def default_numbering_text
+        level_ref = "%#{level + 1}"
+        case format
+        when 'decimal', 'upperRoman', 'lowerRoman', 'upperLetter', 'lowerLetter'
+          "#{level_ref}."
+        else
+          level_ref
+        end
+      end
+
+      def validate_format
+        return unless format && !FORMATS.include?(format)
+
+        raise ArgumentError, "Invalid format: #{format}. Must be one of: #{FORMATS.join(', ')}"
+      end
+
+      def validate_alignment
+        return unless alignment && !ALIGNMENTS.include?(alignment)
+
+        raise ArgumentError,
+              "Invalid alignment: #{alignment}. Must be one of: #{ALIGNMENTS.join(', ')}"
+      end
+    end
+  end
+end

data/lib/uniword/wordprocessingml/object.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require 'lutaml/model'
+
+module Uniword
+  module Wordprocessingml
+    # Embedded object
+    #
+    # Generated from OOXML schema: wordprocessingml.yml
+    # Element: <w:object>
+    class Object < Lutaml::Model::Serializable
+      attribute :dxaOrig, :integer
+      attribute :dyaOrig, :integer
+
+      xml do
+        element 'object'
+        namespace Uniword::Ooxml::Namespaces::WordProcessingML
+
+        map_attribute 'dxaOrig', to: :dxaOrig
+        map_attribute 'dyaOrig', to: :dyaOrig
+      end
+    end
+  end
+end

data/lib/uniword/wordprocessingml/outline.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require 'lutaml/model'
+
+module Uniword
+  module Wordprocessingml
+    # Outline text effect
+    #
+    # Generated from OOXML schema: wordprocessingml.yml
+    # Element: <w:outline>
+    class Outline < Lutaml::Model::Serializable
+      include Uniword::Properties::BooleanElement
+
+      attribute :val, :string, default: nil
+      include Uniword::Properties::BooleanValSetter
+
+      xml do
+        element 'outline'
+        namespace Uniword::Ooxml::Namespaces::WordProcessingML
+        map_attribute 'val', to: :val, render_nil: false, render_default: false
+      end
+    end
+  end
+end

data/lib/uniword/wordprocessingml/p_pr_default.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require 'lutaml/model'
+
+module Uniword
+  module Wordprocessingml
+    # Default paragraph properties container
+    #
+    # Generated from OOXML schema: wordprocessingml.yml
+    # Element: <w:pPrDefault>
+    class PPrDefault < Lutaml::Model::Serializable
+      attribute :pPr, ParagraphProperties
+
+      xml do
+        element 'pPrDefault'
+        namespace Uniword::Ooxml::Namespaces::WordProcessingML
+        mixed_content
+
+        map_element 'pPr', to: :pPr, render_nil: false
+      end
+    end
+  end
+end

data/lib/uniword/wordprocessingml/page_margins.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require 'lutaml/model'
+
+module Uniword
+  module Wordprocessingml
+    # Page margin settings
+    #
+    # Generated from OOXML schema: wordprocessingml.yml
+    # Element: <w:pgMar>
+    class PageMargins < Lutaml::Model::Serializable
+      attribute :top, :integer
+      attribute :bottom, :integer
+      attribute :left, :integer
+      attribute :right, :integer
+      attribute :header, :integer
+      attribute :footer, :integer
+      attribute :gutter, :integer
+
+      xml do
+        element 'pgMar'
+        namespace Uniword::Ooxml::Namespaces::WordProcessingML
+
+        map_attribute 'top', to: :top
+        map_attribute 'bottom', to: :bottom
+        map_attribute 'left', to: :left
+        map_attribute 'right', to: :right
+        map_attribute 'header', to: :header
+        map_attribute 'footer', to: :footer
+        map_attribute 'gutter', to: :gutter
+      end
+    end
+  end
+end

data/lib/uniword/wordprocessingml/page_numbering.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require 'lutaml/model'
+
+module Uniword
+  module Wordprocessingml
+    # Page numbering format
+    #
+    # Generated from OOXML schema: wordprocessingml.yml
+    # Element: <w:pgNumType>
+    class PageNumbering < Lutaml::Model::Serializable
+      attribute :format, :string
+      attribute :start, :integer
+
+      xml do
+        element 'pgNumType'
+        namespace Uniword::Ooxml::Namespaces::WordProcessingML
+
+        map_attribute 'format', to: :format
+        map_attribute 'start', to: :start
+      end
+    end
+  end
+end

data/lib/uniword/wordprocessingml/page_size.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require 'lutaml/model'
+
+module Uniword
+  module Wordprocessingml
+    # Page dimensions
+    #
+    # Generated from OOXML schema: wordprocessingml.yml
+    # Element: <w:pgSz>
+    class PageSize < Lutaml::Model::Serializable
+      attribute :width, :integer
+      attribute :height, :integer
+      attribute :orientation, :string
+
+      xml do
+        element 'pgSz'
+        namespace Uniword::Ooxml::Namespaces::WordProcessingML
+
+        map_attribute 'w', to: :width
+        map_attribute 'h', to: :height
+        map_attribute 'orient', to: :orientation
+      end
+    end
+  end
+end

data/lib/uniword/wordprocessingml/paragraph.rb

@@ -0,0 +1,197 @@
+# frozen_string_literal: true
+
+require 'lutaml/model'
+
+module Uniword
+  module Wordprocessingml
+    # Paragraph - block-level text element
+    #
+    # Generated from OOXML schema: wordprocessingml.yml
+    # Element: <w:p>
+    class Paragraph < Lutaml::Model::Serializable
+      attribute :properties, ParagraphProperties
+      attribute :runs, Run, collection: true, initialize_empty: true
+      attribute :hyperlinks, Hyperlink, collection: true, initialize_empty: true
+      attribute :bookmark_starts, BookmarkStart, collection: true, initialize_empty: true
+      attribute :bookmark_ends, BookmarkEnd, collection: true, initialize_empty: true
+      attribute :field_chars, FieldChar, collection: true, initialize_empty: true
+      attribute :instr_text, InstrText, collection: true, initialize_empty: true
+      attribute :comment_range_starts, CommentRangeStart, collection: true, initialize_empty: true
+      attribute :comment_range_ends, CommentRangeEnd, collection: true, initialize_empty: true
+      attribute :comment_references, CommentReference, collection: true, initialize_empty: true
+      attribute :alternate_content, AlternateContent, default: nil
+      attribute :sdts, StructuredDocumentTag, collection: true, initialize_empty: true
+      attribute :o_math_paras, Uniword::Math::OMathPara, collection: true, initialize_empty: true
+      attribute :proof_errors, ProofErr, collection: true, initialize_empty: true
+      attribute :simple_fields, SimpleField, collection: true, initialize_empty: true
+
+      # Pattern 0: Revision tracking attributes (rsid)
+      attribute :rsid_r, :string          # Revision ID for paragraph creation
+      attribute :rsid_r_default, :string  # Default revision ID
+      attribute :rsid_p, :string          # Revision ID for properties
+      attribute :rsid_r_pr, :string # Revision ID for run properties
+      # Pattern 0: W14 namespace typed attributes
+      attribute :para_id, W14ParaId          # Paragraph ID (w14:paraId)
+      attribute :text_id, W14TextId          # Text ID (w14:textId)
+
+      # Non-serialized runtime reference to parent document for style inheritance
+      # This allows runs to access styles_configuration for style property resolution
+      attr_accessor :parent_document
+
+      xml do
+        element 'p'
+        namespace Uniword::Ooxml::Namespaces::WordProcessingML
+        mixed_content
+
+        # Revision tracking attributes
+        map_attribute 'rsidR', to: :rsid_r, render_nil: false
+        map_attribute 'rsidRDefault', to: :rsid_r_default, render_nil: false
+        map_attribute 'rsidP', to: :rsid_p, render_nil: false
+        map_attribute 'rsidRPr', to: :rsid_r_pr, render_nil: false
+        # W14 namespace typed attributes - namespace declared on the type class
+        map_attribute 'paraId', to: :para_id, render_nil: false
+        map_attribute 'textId', to: :text_id, render_nil: false
+
+        map_element 'pPr', to: :properties, render_nil: false
+        map_element 'r', to: :runs, render_nil: false
+        map_element 'hyperlink', to: :hyperlinks, render_nil: false
+        map_element 'bookmarkStart', to: :bookmark_starts, render_nil: false
+        map_element 'bookmarkEnd', to: :bookmark_ends, render_nil: false
+        map_element 'fldChar', to: :field_chars, render_nil: false
+        map_element 'instrText', to: :instr_text, render_nil: false
+        map_element 'commentRangeStart', to: :comment_range_starts, render_nil: false
+        map_element 'commentRangeEnd', to: :comment_range_ends, render_nil: false
+        map_element 'commentReference', to: :comment_references, render_nil: false
+        map_element 'AlternateContent', to: :alternate_content, render_nil: false
+        map_element 'sdt', to: :sdts, render_nil: false
+        # oMathPara from MathML namespace - the target class declares its namespace
+        map_element 'oMathPara', to: :o_math_paras,
+                                 render_nil: false
+        # Proofing errors
+        map_element 'proofErr', to: :proof_errors, render_nil: false
+        map_element 'fldSimple', to: :simple_fields, render_nil: false
+      end
+
+      # Set paragraph text (replaces all runs with a single run)
+      #
+      # @param value [String] Text value
+      def text=(value)
+        runs.clear
+        return if value.nil? || value.to_s.empty?
+
+        runs << Run.new(text: value.to_s)
+      end
+
+      # Get paragraph text
+      #
+      # @return [String] Combined text from all runs
+      def text
+        return '' unless runs
+
+        runs.map { |r| run_text(r) }.join
+      end
+
+      # Extract text from a run or SDT element
+      #
+      # @param run_or_sdt [Run, StructuredDocumentTag] Run or SDT element
+      # @return [String] Text content
+      def run_text(run_or_sdt)
+        if run_or_sdt.is_a?(StructuredDocumentTag)
+          extract_sdt_text(run_or_sdt)
+        else
+          run_or_sdt.text.to_s
+        end
+      end
+
+      # Extract text from SDT content
+      #
+      # @param sdt [StructuredDocumentTag] SDT element
+      # @return [String] Text content
+      def extract_sdt_text(sdt)
+        return '' unless sdt.content
+
+        sdt.content.runs.map { |r| r.text.to_s }.join
+      end
+
+      # Check if paragraph is empty
+      #
+      # @return [Boolean] true if no runs or all runs empty
+      def empty?
+        !runs || runs.empty? || runs.all? { |r| run_text(r).empty? }
+      end
+
+      # Get paragraph style (convenience accessor)
+      #
+      # @return [String, nil] Style name
+      def style
+        properties&.style
+      end
+
+      # Get paragraph alignment (convenience accessor)
+      #
+      # @return [String, nil] Alignment value (center, left, right, etc.)
+      def alignment
+        properties&.alignment
+      end
+
+      # Iterate over text runs (convenience alias)
+      #
+      # @yield [Run] Each run in the paragraph
+      def each_text_run(&)
+        runs.each(&)
+      end
+
+      # Remove all content from this paragraph
+      def remove!
+        runs.clear
+      end
+
+      # Numbering ID
+      #
+      # @return [Integer, nil] Numbering ID
+      def num_id
+        properties&.num_id
+      end
+
+      # Numbering level
+      #
+      # @return [Integer, nil] Numbering level (0-based)
+      def ilvl
+        properties&.ilvl
+      end
+
+      # Get numbering properties
+      #
+      # @return [Hash, nil] Hash with :num_id and :level, or nil
+      def numbering
+        return nil unless properties&.num_id
+
+        { num_id: properties.num_id, level: properties.ilvl }
+      end
+
+      # Check if paragraph has numbering
+      #
+      # @return [Boolean] true if paragraph has numbering
+      def numbered?
+        properties&.num_id ? true : false
+      end
+
+      # Accept a visitor (Visitor pattern)
+      #
+      # @param visitor [BaseVisitor] The visitor to accept
+      # @return [void]
+      def accept(visitor)
+        visitor.visit_paragraph(self)
+      end
+
+      # Custom inspect for readable output
+      #
+      # @return [String] Human-readable representation
+      def inspect
+        text_preview = text.to_s
+        text_preview = "#{text_preview[0, 47]}..." if text_preview.length > 50
+        "#<#{self.class} runs=#{runs&.size || 0} text=\"#{text_preview}\">"
+      end
+    end
+  end
+end

data/lib/uniword/wordprocessingml/paragraph_borders.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+require 'lutaml/model'
+
+module Uniword
+  module Wordprocessingml
+    # Paragraph borders
+    #
+    # Generated from OOXML schema: wordprocessingml.yml
+    # Element: <w:pBdr>
+    class ParagraphBorders < Lutaml::Model::Serializable
+      attribute :top, Border
+      attribute :bottom, Border
+      attribute :left, Border
+      attribute :right, Border
+      attribute :between, Border
+      attribute :bar, Border
+
+      xml do
+        element 'pBdr'
+        namespace Uniword::Ooxml::Namespaces::WordProcessingML
+        mixed_content
+
+        map_element 'top', to: :top, render_nil: false
+        map_element 'bottom', to: :bottom, render_nil: false
+        map_element 'left', to: :left, render_nil: false
+        map_element 'right', to: :right, render_nil: false
+        map_element 'between', to: :between, render_nil: false
+        map_element 'bar', to: :bar, render_nil: false
+      end
+
+      # Create a box-style border (all four sides with same style)
+      #
+      # @param style [String] Border style
+      # @param color [String] Border color (hex)
+      # @param size [Integer] Border size
+      # @param space [Integer] Border space
+      # @return [ParagraphBorders] New borders object with box styling
+      def self.box(style:, color:, size: 6, space: 1)
+        border = Border.new(val: style, color: color, sz: size, space: space)
+        new(top: border, bottom: border, left: border, right: border)
+      end
+
+      # Check if this is a box-style border (all four sides present with same style)
+      #
+      # @return [Boolean] true if box-style
+      def box?
+        return false unless top && bottom && left && right
+        return false unless top.val == bottom.val && top.val == left.val && top.val == right.val
+        unless top.color == bottom.color && top.color == left.color && top.color == right.color
+          return false
+        end
+
+        true
+      end
+    end
+  end
+end