uniword 1.0.0

data/lib/uniword/ooxml/types/variant_types.rb

@@ -0,0 +1,308 @@
+# frozen_string_literal: true
+
+require 'lutaml/model'
+
+module Uniword
+  module Ooxml
+    module Types
+      # Variant Types (vt: namespace) for OLE property values
+      #
+      # Used in docProps/custom.xml and docProps/app.xml for typed values.
+      # XSD: shared-documentPropertiesVariantTypes.xsd
+      # Namespace: http://schemas.openxmlformats.org/officeDocument/2006/docPropsVTypes
+      module VariantTypes
+        VT_NS = Uniword::Ooxml::Namespaces::VariantTypes
+
+        # Base class for simple variant type values (text content only)
+        class VTValue < Lutaml::Model::Serializable
+          attribute :value, :string
+
+          xml do
+            namespace VT_NS
+            map_content to: :value
+          end
+        end
+
+        # vt:lpwstr - Wide string (Unicode), most common type
+        class VtLpwstr < VTValue
+          xml do
+            element 'lpwstr'
+            namespace VT_NS
+            map_content to: :value
+          end
+        end
+
+        # vt:lpstr - ANSI string
+        class VtLpstr < VTValue
+          xml do
+            element 'lpstr'
+            namespace VT_NS
+            map_content to: :value
+          end
+        end
+
+        # vt:bstr - Basic string
+        class VtBstr < VTValue
+          xml do
+            element 'bstr'
+            namespace VT_NS
+            map_content to: :value
+          end
+        end
+
+        # vt:i1 - 1-byte signed integer
+        class VtI1 < VTValue
+          xml do
+            element 'i1'
+            namespace VT_NS
+            map_content to: :value
+          end
+        end
+
+        # vt:i2 - 2-byte signed integer
+        class VtI2 < VTValue
+          xml do
+            element 'i2'
+            namespace VT_NS
+            map_content to: :value
+          end
+        end
+
+        # vt:i4 - 4-byte signed integer
+        class VtI4 < VTValue
+          xml do
+            element 'i4'
+            namespace VT_NS
+            map_content to: :value
+          end
+        end
+
+        # vt:i8 - 8-byte signed integer
+        class VtI8 < VTValue
+          xml do
+            element 'i8'
+            namespace VT_NS
+            map_content to: :value
+          end
+        end
+
+        # vt:int - Integer
+        class VtInt < VTValue
+          xml do
+            element 'int'
+            namespace VT_NS
+            map_content to: :value
+          end
+        end
+
+        # vt:ui1 - 1-byte unsigned integer
+        class VtUi1 < VTValue
+          xml do
+            element 'ui1'
+            namespace VT_NS
+            map_content to: :value
+          end
+        end
+
+        # vt:ui2 - 2-byte unsigned integer
+        class VtUi2 < VTValue
+          xml do
+            element 'ui2'
+            namespace VT_NS
+            map_content to: :value
+          end
+        end
+
+        # vt:ui4 - 4-byte unsigned integer
+        class VtUi4 < VTValue
+          xml do
+            element 'ui4'
+            namespace VT_NS
+            map_content to: :value
+          end
+        end
+
+        # vt:ui8 - 8-byte unsigned integer
+        class VtUi8 < VTValue
+          xml do
+            element 'ui8'
+            namespace VT_NS
+            map_content to: :value
+          end
+        end
+
+        # vt:uint - Unsigned integer
+        class VtUint < VTValue
+          xml do
+            element 'uint'
+            namespace VT_NS
+            map_content to: :value
+          end
+        end
+
+        # vt:r4 - 4-byte real
+        class VtR4 < VTValue
+          xml do
+            element 'r4'
+            namespace VT_NS
+            map_content to: :value
+          end
+        end
+
+        # vt:r8 - 8-byte real
+        class VtR8 < VTValue
+          xml do
+            element 'r8'
+            namespace VT_NS
+            map_content to: :value
+          end
+        end
+
+        # vt:decimal - Decimal
+        class VtDecimal < VTValue
+          xml do
+            element 'decimal'
+            namespace VT_NS
+            map_content to: :value
+          end
+        end
+
+        # vt:bool - Boolean (text is "0" or "1")
+        class VtBool < VTValue
+          xml do
+            element 'bool'
+            namespace VT_NS
+            map_content to: :value
+          end
+        end
+
+        # vt:date - Date/time
+        class VtDate < VTValue
+          xml do
+            element 'date'
+            namespace VT_NS
+            map_content to: :value
+          end
+        end
+
+        # vt:filetime - File timestamp
+        class VtFiletime < VTValue
+          xml do
+            element 'filetime'
+            namespace VT_NS
+            map_content to: :value
+          end
+        end
+
+        # vt:cy - Currency
+        class VtCy < VTValue
+          xml do
+            element 'cy'
+            namespace VT_NS
+            map_content to: :value
+          end
+        end
+
+        # vt:error - Error status code
+        class VtError < VTValue
+          xml do
+            element 'error'
+            namespace VT_NS
+            map_content to: :value
+          end
+        end
+
+        # vt:clsid - Class ID (GUID)
+        class VtClsid < VTValue
+          xml do
+            element 'clsid'
+            namespace VT_NS
+            map_content to: :value
+          end
+        end
+
+        # vt:empty - Empty value (no content)
+        class VtEmpty < Lutaml::Model::Serializable
+          xml do
+            element 'empty'
+            namespace VT_NS
+          end
+        end
+
+        # vt:null - Null value (no content)
+        class VtNull < Lutaml::Model::Serializable
+          xml do
+            element 'null'
+            namespace VT_NS
+          end
+        end
+
+        # vt:variant - Container for recursive variant
+        class VtVariant < Lutaml::Model::Serializable
+          attribute :lpwstr, VtLpwstr
+          attribute :lpstr, VtLpstr
+          attribute :i4, VtI4
+
+          xml do
+            element 'variant'
+            namespace VT_NS
+
+            map_element 'lpwstr', to: :lpwstr, render_nil: false
+            map_element 'lpstr', to: :lpstr, render_nil: false
+            map_element 'i4', to: :i4, render_nil: false
+          end
+
+          def text_value
+            lpwstr&.value || lpstr&.value || i4&.value
+          end
+        end
+
+        # vt:vector - Typed array of values
+        class VtVector < Lutaml::Model::Serializable
+          attribute :base_type, :string
+          attribute :size, :string
+          attribute :lpwstr_values, VtLpwstr, collection: true
+          attribute :lpstr_values, VtLpstr, collection: true
+          attribute :i4_values, VtI4, collection: true
+          attribute :variant_values, VtVariant, collection: true
+
+          xml do
+            element 'vector'
+            namespace VT_NS
+
+            map_attribute 'baseType', to: :base_type
+            map_attribute 'size', to: :size
+            map_element 'lpwstr', to: :lpwstr_values, render_nil: false
+            map_element 'lpstr', to: :lpstr_values, render_nil: false
+            map_element 'i4', to: :i4_values, render_nil: false
+            map_element 'variant', to: :variant_values, render_nil: false
+          end
+
+          def values
+            lpwstr_values.to_a.map(&:value) +
+              lpstr_values.to_a.map(&:value) +
+              i4_values.to_a.map(&:value)
+          end
+        end
+
+        # vt:array - Typed array with bounds
+        class VtArray < Lutaml::Model::Serializable
+          attribute :base_type, :string
+          attribute :size, :string
+          attribute :l_bound, :string
+          attribute :u_bound, :string
+
+          xml do
+            element 'array'
+            namespace VT_NS
+
+            map_attribute 'baseType', to: :base_type
+            map_attribute 'size', to: :size
+            map_attribute 'lBound', to: :l_bound
+            map_attribute 'uBound', to: :u_bound
+          end
+        end
+      end
+    end
+  end
+end

data/lib/uniword/ooxml/types.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+module Uniword
+  module Ooxml
+    # Type classes for OOXML elements with namespace declarations
+    #
+    # This module contains Type::Value classes that declare their namespaces
+    # following the lutaml-model pattern. Types provide namespace information
+    # that propagates to serialization automatically.
+    #
+    # @see https://github.com/lutaml/lutaml-model/blob/main/TODO.value-namespace.md
+    module Types
+      # Dublin Core Types (dc: namespace)
+      autoload :DcTitleType, "#{__dir__}/types/dc_title_type"
+      autoload :DcSubjectType, "#{__dir__}/types/dc_subject_type"
+      autoload :DcCreatorType, "#{__dir__}/types/dc_creator_type"
+      autoload :DcDescriptionType, "#{__dir__}/types/cp_description_type" # File is cp_*, class is Dc*
+
+      # Core Properties Types (cp: namespace)
+      autoload :CpKeywordsType, "#{__dir__}/types/cp_keywords_type"
+      autoload :CpDescriptionType, "#{__dir__}/types/cp_description_type"
+      autoload :CpLastModifiedByType, "#{__dir__}/types/cp_last_modified_by_type"
+      autoload :CpRevisionType, "#{__dir__}/types/cp_revision_type"
+
+      # Dublin Core Terms Types (dcterms: namespace)
+      autoload :DctermsW3cdtfType, "#{__dir__}/types/dcterms_w3cdtf_type"
+      autoload :DctermsCreatedType, "#{__dir__}/types/dcterms_created_type"
+      autoload :DctermsModifiedType, "#{__dir__}/types/dcterms_modified_type"
+
+      # XML namespace types (xml: namespace) - use built-in :xml_space type via Lutaml::Xml::W3c::XmlSpaceType
+
+      # Markup Compatibility types (mc: namespace)
+      autoload :McIgnorable, "#{__dir__}/types/mc_ignorable_type"
+
+      # OOXML boolean type (for 1/0 boolean encoding)
+      autoload :OoxmlBoolean, "#{__dir__}/types/ooxml_boolean"
+
+      # OOXML boolean type for optional attributes (nil-omitting)
+      # Serializes true -> "1", false/nil -> omitted
+      autoload :OoxmlBooleanOptional, "#{__dir__}/types/ooxml_boolean_optional"
+
+      # Variant Types (vt: namespace) for OLE property values
+      autoload :VariantTypes, "#{__dir__}/types/variant_types"
+
+      # Convenience aliases for commonly used variant types
+      def self.vt_class_for(element_name)
+        {
+          'lpwstr' => VariantTypes::VtLpwstr,
+          'lpstr' => VariantTypes::VtLpstr,
+          'bstr' => VariantTypes::VtBstr,
+          'i1' => VariantTypes::VtI1,
+          'i2' => VariantTypes::VtI2,
+          'i4' => VariantTypes::VtI4,
+          'i8' => VariantTypes::VtI8,
+          'int' => VariantTypes::VtInt,
+          'ui1' => VariantTypes::VtUi1,
+          'ui2' => VariantTypes::VtUi2,
+          'ui4' => VariantTypes::VtUi4,
+          'ui8' => VariantTypes::VtUi8,
+          'uint' => VariantTypes::VtUint,
+          'r4' => VariantTypes::VtR4,
+          'r8' => VariantTypes::VtR8,
+          'decimal' => VariantTypes::VtDecimal,
+          'bool' => VariantTypes::VtBool,
+          'date' => VariantTypes::VtDate,
+          'filetime' => VariantTypes::VtFiletime,
+          'cy' => VariantTypes::VtCy,
+          'error' => VariantTypes::VtError,
+          'clsid' => VariantTypes::VtClsid,
+          'empty' => VariantTypes::VtEmpty,
+          'null' => VariantTypes::VtNull
+        }[element_name]
+      end
+    end
+  end
+end

data/lib/uniword/ooxml.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+# OOXML (Office Open XML) Support Module
+#
+# This module contains all OOXML-related classes and namespaces for
+# working with Microsoft Office document formats.
+#
+# NOTE: The Namespaces module can now be autoloaded - it constant access is at runtime
+module Uniword
+  module Ooxml
+    # Core OOXML packages
+    autoload :DocxPackage, "#{__dir__}/ooxml/docx_package"
+    autoload :DotxPackage, "#{__dir__}/ooxml/dotx_package"
+    autoload :ThmxPackage, "#{__dir__}/ooxml/thmx_package"
+    autoload :MhtmlPackage, "#{__dir__}/ooxml/mhtml_package"
+    autoload :StylesetPackage, "#{__dir__}/ooxml/styleset_package"
+    autoload :ThemePackage, "#{__dir__}/ooxml/theme_package"
+
+    # OOXML properties
+    autoload :AppProperties, "#{__dir__}/ooxml/app_properties"
+    autoload :CoreProperties, "#{__dir__}/ooxml/core_properties"
+    autoload :CustomProperties, "#{__dir__}/ooxml/custom_properties"
+
+    # OOXML shared schemas
+    autoload :AdditionalCharacteristics, "#{__dir__}/ooxml/additional_characteristics"
+    autoload :SchemaLibrary, "#{__dir__}/ooxml/schema_library"
+
+    # OOXML infrastructure
+    autoload :Types, "#{__dir__}/ooxml/types"
+    autoload :PackageFile, "#{__dir__}/ooxml/package_file"
+    autoload :ContentTypes, "#{__dir__}/content_types"
+
+    # OOXML namespaces - autoload for runtime access
+    autoload :Namespaces, "#{__dir__}/ooxml/namespaces"
+
+    # OOXML relationships
+    autoload :Relationships, "#{__dir__}/ooxml/relationships"
+    autoload :Schema, "#{__dir__}/ooxml/schema"
+  end
+end

data/lib/uniword/page_borders.rb

@@ -0,0 +1,117 @@
+# frozen_string_literal: true
+
+require 'lutaml/model'
+
+module Uniword
+  # Represents a single page border side
+  #
+  # @attr [String] style Border style (single, thick, double, etc.)
+  # @attr [String] color Border color (hex)
+  # @attr [Integer] width Border width in eighths of a point
+  # @attr [Integer] space Space from text in points
+  class PageBorderSide < Lutaml::Model::Serializable
+    # Border styles
+    STYLES = %w[
+      single thick double dotted dashed
+      dot_dash triple wave dashSmallGap
+      dashDotStroked threeDEmboss threeDEngrave
+    ].freeze
+
+    attribute :style, :string, default: -> { 'single' }
+    attribute :color, :string, default: -> { 'auto' }
+    attribute :width, :integer, default: -> { 6 }
+    attribute :space, :integer, default: -> { 0 }
+
+    def initialize(**attributes)
+      super
+      validate_style
+    end
+
+    private
+
+    def validate_style
+      return unless style && !STYLES.include?(style)
+
+      raise ArgumentError, "Invalid border style: #{style}. Must be one of: #{STYLES.join(', ')}"
+    end
+  end
+
+  # Represents page borders for a section
+  #
+  # Page borders can be applied to all sides of pages in a section.
+  #
+  # @example Create page borders
+  #   borders = PageBorders.new(
+  #     display: 'allPages',
+  #     offset_from: 'page'
+  #   )
+  #   borders.top = PageBorderSide.new(style: 'double', color: '000000', width: 12)
+  #
+  # @attr [PageBorderSide] top Top border
+  # @attr [PageBorderSide] bottom Bottom border
+  # @attr [PageBorderSide] left Left border
+  # @attr [PageBorderSide] right Right border
+  # @attr [String] display When to display borders (allPages, firstPage, notFirstPage)
+  # @attr [String] offset_from Measurement reference (page, text)
+  class PageBorders < Lutaml::Model::Serializable
+    # Display options
+    DISPLAY_OPTIONS = %w[allPages firstPage notFirstPage].freeze
+
+    # Offset reference options
+    OFFSET_OPTIONS = %w[page text].freeze
+
+    attribute :top, PageBorderSide
+    attribute :bottom, PageBorderSide
+    attribute :left, PageBorderSide
+    attribute :right, PageBorderSide
+    attribute :display, :string, default: -> { 'allPages' }
+    attribute :offset_from, :string, default: -> { 'page' }
+
+    def initialize(**attributes)
+      super
+      validate_display
+      validate_offset_from
+    end
+
+    # Create borders on all sides with same properties
+    #
+    # @param style [String] Border style
+    # @param color [String] Border color
+    # @param width [Integer] Border width
+    # @param options [Hash] Additional options (display, offset_from)
+    # @return [PageBorders] New instance
+    def self.all_sides(style: 'single', color: 'auto', width: 6, **)
+      border_side = PageBorderSide.new(style: style, color: color, width: width)
+      new(
+        top: border_side,
+        bottom: border_side,
+        left: border_side,
+        right: border_side,
+        **
+      )
+    end
+
+    # Check if any border is defined
+    #
+    # @return [Boolean] true if any border exists
+    def any?
+      !top.nil? || !bottom.nil? || !left.nil? || !right.nil?
+    end
+
+    private
+
+    def validate_display
+      return unless display && !DISPLAY_OPTIONS.include?(display)
+
+      raise ArgumentError,
+            "Invalid display: #{display}. Must be one of: #{DISPLAY_OPTIONS.join(', ')}"
+    end
+
+    def validate_offset_from
+      return unless offset_from && !OFFSET_OPTIONS.include?(offset_from)
+
+      raise ArgumentError,
+            "Invalid offset_from: #{offset_from}. Must be one of: #{OFFSET_OPTIONS.join(', ')}"
+    end
+  end
+end

data/lib/uniword/paragraph_border.rb

@@ -0,0 +1,113 @@
+# frozen_string_literal: true
+
+require 'lutaml/model'
+
+module Uniword
+  # Represents a single paragraph border side
+  #
+  # @attr [String] style Border style (single, thick, double, etc.)
+  # @attr [String] color Border color (hex)
+  # @attr [Integer] size Border width in eighths of a point
+  # @attr [Integer] space Space from text in points
+  class ParagraphBorderSide < Lutaml::Model::Serializable
+    # Border styles matching OOXML specification
+    STYLES = %w[
+      single thick double dotted dashed
+      dotDash dotDotDash triple
+      thinThickSmallGap thickThinSmallGap
+      thinThickThinSmallGap thinThickMediumGap
+      thickThinMediumGap thinThickThinMediumGap
+      thinThickLargeGap thickThinLargeGap
+      thinThickThinLargeGap wave doubleWave
+      dashSmallGap dashDotStroked threeDEmboss
+      threeDEngrave outset inset
+    ].freeze
+
+    attribute :style, :string, default: -> { 'single' }
+    attribute :color, :string, default: -> { 'auto' }
+    attribute :size, :integer, default: -> { 6 }
+    attribute :space, :integer, default: -> { 1 }
+
+    def initialize(**attributes)
+      super
+      validate_style
+    end
+
+    private
+
+    def validate_style
+      return unless style && !STYLES.include?(style)
+
+      raise ArgumentError, "Invalid border style: #{style}. Must be one of: #{STYLES.join(', ')}"
+    end
+  end
+
+  # Represents paragraph borders
+  #
+  # Paragraph borders can be applied to individual sides or between paragraphs.
+  #
+  # @example Create paragraph with borders
+  #   borders = ParagraphBorders.new
+  #   borders.top = ParagraphBorderSide.new(style: 'single', color: '000000', size: 6)
+  #   borders.bottom = ParagraphBorderSide.new(style: 'double', color: 'FF0000', size: 12)
+  #
+  # @attr [ParagraphBorderSide] top Top border
+  # @attr [ParagraphBorderSide] bottom Bottom border
+  # @attr [ParagraphBorderSide] left Left border
+  # @attr [ParagraphBorderSide] right Right border
+  # @attr [ParagraphBorderSide] between Border between paragraphs
+  class ParagraphBorders < Lutaml::Model::Serializable
+    attribute :top, ParagraphBorderSide
+    attribute :bottom, ParagraphBorderSide
+    attribute :left, ParagraphBorderSide
+    attribute :right, ParagraphBorderSide
+    attribute :between, ParagraphBorderSide
+
+    # Create borders on all sides with same properties
+    #
+    # @param style [String] Border style
+    # @param color [String] Border color
+    # @param size [Integer] Border size
+    # @param space [Integer] Space from text
+    # @return [ParagraphBorders] New instance
+    def self.all_sides(style: 'single', color: 'auto', size: 6, space: 1)
+      border_side = ParagraphBorderSide.new(
+        style: style,
+        color: color,
+        size: size,
+        space: space
+      )
+      new(
+        top: border_side,
+        bottom: border_side,
+        left: border_side,
+        right: border_side
+      )
+    end
+
+    # Create box borders (all sides, no between)
+    #
+    # @param style [String] Border style
+    # @param color [String] Border color
+    # @param size [Integer] Border size
+    # @param space [Integer] Space from text
+    # @return [ParagraphBorders] New instance
+    def self.box(style: 'single', color: 'auto', size: 6, space: 1)
+      all_sides(style: style, color: color, size: size, space: space)
+    end
+
+    # Check if any border is defined
+    #
+    # @return [Boolean] true if any border exists
+    def any?
+      !top.nil? || !bottom.nil? || !left.nil? || !right.nil? || !between.nil?
+    end
+
+    # Check if this creates a complete box
+    #
+    # @return [Boolean] true if all four sides are defined
+    def box?
+      !top.nil? && !bottom.nil? && !left.nil? && !right.nil?
+    end
+  end
+end

data/lib/uniword/picture/fill_rect.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require 'lutaml/model'
+
+module Uniword
+  module Picture
+    # Fill rectangle insets
+    #
+    # Generated from OOXML schema: picture.yml
+    # Element: <pic:fillRect>
+    class FillRect < Lutaml::Model::Serializable
+      attribute :l, :integer
+      attribute :t, :integer
+      attribute :r, :integer
+      attribute :b, :integer
+
+      xml do
+        element 'fillRect'
+        namespace Uniword::Ooxml::Namespaces::Picture
+
+        map_attribute 'l', to: :l
+        map_attribute 't', to: :t
+        map_attribute 'r', to: :r
+        map_attribute 'b', to: :b
+      end
+    end
+  end
+end