uniword 1.0.0

data/lib/uniword/styleset.rb

@@ -0,0 +1,166 @@
+# frozen_string_literal: true
+
+module Uniword
+  # Represents a StyleSet containing a collection of style definitions
+  #
+  # StyleSets are named collections of paragraph, character, table, and
+  # numbering styles that provide consistent formatting for Word documents.
+  # They work in conjunction with themes to create professionally styled documents.
+  #
+  # @example Load StyleSet from .dotx file
+  #   styleset = Uniword::StyleSet.from_dotx('Distinctive.dotx')
+  #   puts styleset.name
+  #   puts "Styles: #{styleset.styles.count}"
+  #
+  # @example Apply StyleSet to document
+  #   doc = Uniword::Wordprocessingml::DocumentRoot.new
+  #   styleset.apply_to(doc)
+  class StyleSet < Lutaml::Model::Serializable
+    # YAML serialization (for bundled stylesets)
+    yaml do
+      map 'name', to: :name
+      map 'source_file', to: :source_file
+      map 'styles', to: :styles
+    end
+
+    # StyleSet name
+    attribute :name, :string, default: -> { 'Custom StyleSet' }
+
+    # Collection of Style objects
+    attribute :styles, Uniword::Wordprocessingml::Style, collection: true, initialize_empty: true
+
+    # Source .dotx file path (for reference)
+    attribute :source_file, :string
+
+    # Initialize StyleSet
+    #
+    # @param attributes [Hash] StyleSet attributes
+    def initialize(attributes = {})
+      super
+      @styles ||= []
+      @source_file ||= nil
+    end
+
+    # Get the number of styles
+    #
+    # @return [Integer] Number of styles
+    def count
+      styles.size
+    end
+
+    # Check if StyleSet is valid
+    #
+    # @return [Boolean] true if valid
+    def valid?
+      !name.nil? && !name.empty? && styles.is_a?(Array)
+    end
+
+    # Get styles by type
+    #
+    # @param type [String, Symbol] Style type (:paragraph, :character, :table, :numbering)
+    # @return [Array<Style>] Styles of the specified type
+    def styles_by_type(type)
+      type_str = type.to_s
+      styles.select { |s| s.type == type_str }
+    end
+
+    # Get paragraph styles
+    #
+    # @return [Array<Style>] Paragraph styles
+    def paragraph_styles
+      styles_by_type('paragraph')
+    end
+
+    # Get character styles
+    #
+    # @return [Array<Style>] Character styles
+    def character_styles
+      styles_by_type('character')
+    end
+
+    # Get table styles
+    #
+    # @return [Array<Style>] Table styles
+    def table_styles
+      styles_by_type('table')
+    end
+
+    # Provide detailed inspection for debugging
+    #
+    # @return [String] A readable representation of the StyleSet
+    def inspect
+      "#<Uniword::StyleSet name=#{name.inspect} " \
+        "styles=#{styles.count} " \
+        "source=#{source_file.inspect}>"
+    end
+
+    # Load StyleSet from .dotx file
+    #
+    # @param path [String] Path to .dotx file
+    # @return [StyleSet] Loaded StyleSet
+    #
+    # @example Load StyleSet
+    #   styleset = StyleSet.from_dotx('Distinctive.dotx')
+    def self.from_dotx(path)
+      Stylesets::Package.from_file(path).styleset
+    end
+
+    # Load bundled StyleSet by name
+    #
+    # @param name [String] StyleSet name (e.g., 'distinctive', 'basic')
+    # @return [StyleSet] Loaded StyleSet
+    #
+    # @example Load bundled StyleSet
+    #   styleset = StyleSet.load('distinctive')
+    def self.load(name)
+      Stylesets::YamlStyleSetLoader.load_bundled(name)
+    end
+
+    # List all available bundled StyleSets
+    #
+    # @return [Array<String>] StyleSet names
+    #
+    # @example List StyleSets
+    #   stylesets = StyleSet.available_stylesets
+    #   # => ["distinctive", "basic", ...]
+    def self.available_stylesets
+      Stylesets::YamlStyleSetLoader.available_stylesets
+    end
+
+    # Apply this StyleSet to a document
+    #
+    # Merges all styles from this StyleSet into the document's
+    # styles configuration.
+    #
+    # @param document [Document] Target document
+    # @param strategy [Symbol] Conflict resolution strategy
+    #   - :keep_existing (default) - Keep existing styles
+    #   - :replace - Replace existing with StyleSet styles
+    #   - :rename - Keep both, rename imported styles
+    # @return [void]
+    def apply_to(document, strategy: :keep_existing)
+      return unless document.respond_to?(:styles_configuration)
+
+      styles.each do |style|
+        case strategy
+        when :replace
+          document.styles_configuration.add_style(style.dup, allow_overwrite: true)
+        when :keep_existing
+          unless document.styles_configuration.style_exists?(style.id)
+            document.styles_configuration.add_style(style.dup)
+          end
+        when :rename
+          if document.styles_configuration.style_exists?(style.id)
+            new_style = style.dup
+            new_style.id = "#{style.id}_styleset"
+            document.styles_configuration.add_style(new_style)
+          else
+            document.styles_configuration.add_style(style.dup)
+          end
+        else
+          raise ArgumentError, "Invalid strategy: #{strategy}"
+        end
+      end
+    end
+  end
+end

data/lib/uniword/stylesets/package.rb

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+module Uniword
+  module Stylesets
+    # Represents a .dotx StyleSet package (ZIP with word/styles.xml)
+    #
+    # Follows MODEL-DRIVEN architecture using lutaml-model for XML
+    # deserialization. No manual parsing.
+    #
+    # @example Load StyleSet from .dotx
+    #   package = Package.from_file('Distinctive.dotx')
+    #   styleset = package.styleset
+    #   puts styleset.name
+    class Package < Lutaml::Model::Serializable
+      # Pattern 0: ATTRIBUTES FIRST
+
+      # word/styles.xml content (lutaml-model deserialization)
+      attribute :styles_configuration, Uniword::Wordprocessingml::StylesConfiguration
+
+      # Source .dotx file path (for reference)
+      attribute :source_path, :string
+
+      # Initialize Package
+      #
+      # @param attributes [Hash] Package attributes
+      def initialize(attributes = {})
+        super
+        @styles_configuration ||= Uniword::Wordprocessingml::StylesConfiguration.new
+      end
+
+      # Load Package from .dotx file
+      #
+      # @param path [String] Path to .dotx file
+      # @return [Package] Loaded package
+      # @raise [ArgumentError] if file invalid
+      # @raise [Uniword::CorruptedFileError] if ZIP corrupt
+      #
+      # @example
+      #   pkg = Package.from_file('Distinctive.dotx')
+      def self.from_file(path)
+        # Validate file exists
+        raise Uniword::FileNotFoundError, path unless File.exist?(path)
+
+        # Extract ZIP
+        extracted = extract_zip(path)
+
+        # Deserialize styles.xml using lutaml-model (MODEL-DRIVEN!)
+        styles_xml = extracted['word/styles.xml']
+        raise Uniword::CorruptedFileError.new(path, 'styles.xml missing') unless styles_xml
+
+        styles_config = Uniword::Wordprocessingml::StylesConfiguration.from_xml(styles_xml)
+
+        # Create Package instance
+        new(
+          styles_configuration: styles_config,
+          source_path: path
+        )
+      end
+
+      # Convert to StyleSet model
+      #
+      # @return [StyleSet] StyleSet with styles from package
+      def styleset
+        StyleSet.new(
+          name: extract_name,
+          styles: styles_configuration.styles,
+          source_file: source_path
+        )
+      end
+
+      private
+
+      # Extract ZIP contents
+      #
+      # @param path [String] ZIP file path
+      # @return [Hash] Extracted files {path => content}
+      def self.extract_zip(path)
+        require 'zip'
+
+        contents = {}
+        Zip::File.open(path) do |zip|
+          zip.each do |entry|
+            next if entry.directory?
+
+            contents[entry.name] = entry.get_input_stream.read
+          end
+        end
+        contents
+      rescue Zip::Error => e
+        raise Uniword::CorruptedFileError.new(path, "Failed to extract: #{e.message}")
+      end
+
+      # Extract StyleSet name from source path
+      #
+      # @return [String] StyleSet name
+      def extract_name
+        return 'Custom StyleSet' unless source_path
+
+        # Get filename without extension
+        filename = File.basename(source_path, '.*')
+
+        # Convert to title case (e.g., 'distinctive' -> 'Distinctive')
+        filename.split(/[-_]/).map(&:capitalize).join(' ')
+      end
+    end
+  end
+end

data/lib/uniword/stylesets/styleset_importer.rb

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+require 'fileutils'
+
+module Uniword
+  module Stylesets
+    # Imports .dotx StyleSet files and converts them to YAML format
+    #
+    # Leverages lutaml-model's from_xml and to_yaml serialization for
+    # simple, reliable conversion from .dotx to YAML format.
+    #
+    # @example Import single StyleSet
+    #   importer = StyleSetImporter.new
+    #   importer.import('Distinctive.dotx', 'data/stylesets/distinctive.yml')
+    #
+    # @example Import all StyleSets from directory
+    #   importer = StyleSetImporter.new
+    #   importer.import_all('stylesets/', 'data/stylesets/')
+    class StyleSetImporter
+      # Import .dotx file to YAML
+      #
+      # @param dotx_path [String] Path to .dotx file
+      # @param output_path [String] Output YAML path
+      # @return [void]
+      def import(dotx_path, output_path)
+        # Extract .dotx package
+        reader = StyleSetPackageReader.new
+        files = reader.extract(dotx_path)
+
+        # Parse styles.xml using lutaml-model
+        styles_config = ::Uniword::Wordprocessingml::StylesConfiguration.from_xml(
+          files[:styles],
+          encoding: 'UTF-8'
+        )
+
+        # Create StyleSet model
+        styleset = ::Uniword::StyleSet.new(
+          name: extract_name_from_path(dotx_path),
+          styles: styles_config.styles,
+          source_file: File.basename(dotx_path)
+        )
+
+        # Ensure output directory exists
+        FileUtils.mkdir_p(File.dirname(output_path))
+
+        # Serialize to YAML using lutaml-model
+        File.write(output_path, styleset.to_yaml)
+      end
+
+      # Import all StyleSets from directory
+      #
+      # @param source_dir [String] Directory with .dotx files
+      # @param output_dir [String] Output directory for YAML files
+      # @return [Integer] Number of StyleSets imported
+      def import_all(source_dir, output_dir)
+        count = 0
+
+        Dir.glob(File.join(source_dir, '*.dotx')).each do |dotx_file|
+          styleset_name = styleset_name_from_file(dotx_file)
+          output_file = File.join(output_dir, "#{styleset_name}.yml")
+
+          puts "Importing #{File.basename(dotx_file)} -> #{File.basename(output_file)}"
+          import(dotx_file, output_file)
+          count += 1
+        end
+
+        count
+      end
+
+      private
+
+      # Extract StyleSet name from file path
+      #
+      # @param path [String] Path to .dotx file
+      # @return [String] StyleSet name (e.g., 'Distinctive')
+      def extract_name_from_path(path)
+        # Get filename without extension
+        filename = File.basename(path, '.*')
+
+        # Convert to title case (e.g., 'distinctive' -> 'Distinctive')
+        filename.split(/[-_]/).map(&:capitalize).join(' ')
+      end
+
+      # Convert file path to StyleSet name for YAML filename
+      #
+      # @param path [String] Path to .dotx file
+      # @return [String] StyleSet name for YAML file (e.g., 'distinctive')
+      def styleset_name_from_file(path)
+        File.basename(path, '.dotx')
+            .downcase
+            .gsub(/[^a-z0-9]+/, '_')
+            .gsub(/^_|_$/, '')
+      end
+    end
+  end
+end

data/lib/uniword/stylesets/yaml_styleset_loader.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module Uniword
+  module Stylesets
+    # Loads StyleSets from YAML files
+    #
+    # Leverages lutaml-model's from_yaml deserialization for simple,
+    # reliable loading of YAML StyleSet files.
+    #
+    # @example Load from YAML file
+    #   loader = YamlStyleSetLoader.new
+    #   styleset = loader.load('custom_styleset.yml')
+    #
+    # @example Load bundled StyleSet
+    #   styleset = YamlStyleSetLoader.load_bundled('distinctive')
+    class YamlStyleSetLoader
+      # Load StyleSet from YAML file
+      #
+      # @param path [String] Path to YAML file
+      # @return [StyleSet] Loaded StyleSet
+      def load(path)
+        # Use lutaml-model deserialization
+        ::Uniword::StyleSet.from_yaml(File.read(path))
+      end
+
+      # List all available bundled StyleSets
+      #
+      # @return [Array<String>] StyleSet names
+      def self.available_stylesets
+        styleset_dir = File.join(__dir__, '../../../data/stylesets')
+        return [] unless Dir.exist?(styleset_dir)
+
+        Dir.glob(File.join(styleset_dir, '*.yml')).map do |path|
+          File.basename(path, '.yml')
+        end.sort
+      end
+
+      # Load bundled StyleSet by name
+      #
+      # @param name [String] StyleSet name (e.g., 'distinctive', 'basic')
+      # @return [StyleSet] Loaded StyleSet
+      # @raise [ArgumentError] if StyleSet not found
+      def self.load_bundled(name)
+        styleset_dir = File.join(__dir__, '../../../data/stylesets')
+        path = File.join(styleset_dir, "#{name}.yml")
+
+        unless File.exist?(path)
+          available = available_stylesets
+          raise ArgumentError,
+                "StyleSet '#{name}' not found. " \
+                "Available StyleSets: #{available.join(', ')}"
+        end
+
+        new.load(path)
+      end
+    end
+  end
+end

data/lib/uniword/stylesets.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Uniword
+  module Stylesets
+    autoload :Package, "#{__dir__}/stylesets/package"
+    autoload :YamlStyleSetLoader, "#{__dir__}/stylesets/yaml_styleset_loader"
+    autoload :StyleSetImporter, "#{__dir__}/stylesets/styleset_importer"
+  end
+end

data/lib/uniword/tab_stop.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+require 'lutaml/model'
+
+module Uniword
+  # Represents a tab stop in a paragraph
+  #
+  # Tab stops control where the cursor moves when the Tab key is pressed.
+  # They can have different alignments and leader characters.
+  #
+  # @example Create a tab stop
+  #   tab = TabStop.new(position: 720, alignment: 'left', leader: 'dot')
+  #
+  # @attr [Integer] position Position in twips from left margin
+  # @attr [String] alignment Alignment type (left, center, right, decimal, bar)
+  # @attr [String] leader Leader character (none, dot, hyphen, underscore, heavy)
+  class TabStop < Lutaml::Model::Serializable
+    # Alignment options
+    ALIGNMENTS = %w[left center right decimal bar num].freeze
+
+    # Leader options
+    LEADERS = %w[none dot hyphen underscore heavy middleDot].freeze
+
+    attribute :position, :integer
+    attribute :alignment, :string, default: -> { 'left' }
+    attribute :leader, :string, default: -> { 'none' }
+
+    def initialize(**attributes)
+      super
+      validate_alignment
+      validate_leader
+    end
+
+    # Create a left-aligned tab stop
+    #
+    # @param position [Integer] Position in twips
+    # @param leader [String] Leader character
+    # @return [TabStop] New instance
+    def self.left(position, leader: 'none')
+      new(position: position, alignment: 'left', leader: leader)
+    end
+
+    # Create a center-aligned tab stop
+    #
+    # @param position [Integer] Position in twips
+    # @param leader [String] Leader character
+    # @return [TabStop] New instance
+    def self.center(position, leader: 'none')
+      new(position: position, alignment: 'center', leader: leader)
+    end
+
+    # Create a right-aligned tab stop
+    #
+    # @param position [Integer] Position in twips
+    # @param leader [String] Leader character
+    # @return [TabStop] New instance
+    def self.right(position, leader: 'none')
+      new(position: position, alignment: 'right', leader: leader)
+    end
+
+    # Create a decimal-aligned tab stop (for numbers)
+    #
+    # @param position [Integer] Position in twips
+    # @param leader [String] Leader character
+    # @return [TabStop] New instance
+    def self.decimal(position, leader: 'none')
+      new(position: position, alignment: 'decimal', leader: leader)
+    end
+
+    private
+
+    def validate_alignment
+      return unless alignment && !ALIGNMENTS.include?(alignment)
+
+      raise ArgumentError,
+            "Invalid alignment: #{alignment}. Must be one of: #{ALIGNMENTS.join(', ')}"
+    end
+
+    def validate_leader
+      return unless leader && !LEADERS.include?(leader)
+
+      raise ArgumentError, "Invalid leader: #{leader}. Must be one of: #{LEADERS.join(', ')}"
+    end
+  end
+end

data/lib/uniword/table_border.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+require 'lutaml/model'
+
+module Uniword
+  # Represents a table border configuration
+  # Used for table and cell borders
+  class TableBorder < Lutaml::Model::Serializable
+    attribute :style, :string, default: -> { 'single' }
+    attribute :width, :integer, default: -> { 4 }
+    attribute :color, :string, default: -> { 'auto' }
+    attribute :space, :integer, default: -> { 0 }
+
+    # Valid border styles
+    STYLES = %w[
+      none
+      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
+
+    def initialize(**attributes)
+      super
+      validate_style
+    end
+
+    # Create a simple single border
+    def self.single(width: 4, color: 'auto')
+      new(style: 'single', width: width, color: color)
+    end
+
+    # Create a double border
+    def self.double(width: 6, color: 'auto')
+      new(style: 'double', width: width, color: color)
+    end
+
+    # Create a dashed border
+    def self.dashed(width: 4, color: 'auto')
+      new(style: 'dashed', width: width, color: color)
+    end
+
+    # Create a dotted border
+    def self.dotted(width: 4, color: 'auto')
+      new(style: 'dotted', width: width, color: color)
+    end
+
+    # Create a thick border
+    def self.thick(color: 'auto')
+      new(style: 'thick', width: 8, color: color)
+    end
+
+    # Create no border
+    def self.none
+      new(style: 'none', width: 0, color: 'auto')
+    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
+end