uniword 1.0.0

data/lib/uniword/transformation/paragraph_transformation_rule.rb

@@ -0,0 +1,166 @@
+# frozen_string_literal: true
+
+module Uniword
+  module Transformation
+    # Transformation rule for Paragraph elements.
+    #
+    # Responsibility: Transform Paragraph objects between DOCX and MHTML formats.
+    # Single Responsibility - handles only Paragraph transformations.
+    #
+    # Transformations handle format-specific property conversions:
+    # - DOCX → MHTML: Convert OOXML properties to CSS-compatible properties
+    # - MHTML → DOCX: Convert CSS properties to OOXML properties
+    #
+    # @example Transform DOCX paragraph to MHTML
+    #   rule = ParagraphTransformationRule.new(source_format: :docx, target_format: :mhtml)
+    #   mhtml_para = rule.transform(docx_para)
+    class ParagraphTransformationRule < TransformationRule
+      # Check if this rule matches the transformation request
+      #
+      # @param element_type [Class] The element class
+      # @param source_format [Symbol] Source format
+      # @param target_format [Symbol] Target format
+      # @return [Boolean] true if matches
+      def matches?(element_type:, source_format:, target_format:)
+        element_type == Paragraph &&
+          source_format == @source_format &&
+          target_format == @target_format
+      end
+
+      # Transform a paragraph from source format to target format
+      #
+      # Creates new Paragraph with adapted properties and transformed runs.
+      #
+      # @param source_para [Paragraph] Source paragraph
+      # @return [Paragraph] Transformed paragraph
+      # @raise [ArgumentError] if source_para is not a Paragraph
+      def transform(source_para)
+        validate_element_type(source_para, Paragraph)
+
+        target_para = Paragraph.new
+
+        # Transform properties based on format direction
+        transform_properties(source_para, target_para)
+
+        # Transform runs (delegate to RunTransformationRule)
+        transform_runs(source_para, target_para)
+
+        target_para
+      end
+
+      private
+
+      # Transform paragraph properties
+      #
+      # @param source [Paragraph] Source paragraph
+      # @param target [Paragraph] Target paragraph
+      def transform_properties(source, target)
+        return unless source.properties
+
+        if @source_format == :docx && @target_format == :mhtml
+          transform_properties_docx_to_mhtml(source.properties, target)
+        elsif @source_format == :mhtml && @target_format == :docx
+          transform_properties_mhtml_to_docx(source.properties, target)
+        else
+          # Same format - direct copy
+          copy_properties(source.properties, target)
+        end
+      end
+
+      # Transform DOCX paragraph properties to MHTML format
+      #
+      # @param source_props [Wordprocessingml::ParagraphProperties] Source properties
+      # @param target_para [Paragraph] Target paragraph
+      def transform_properties_docx_to_mhtml(source_props, target_para)
+        target_props = Wordprocessingml::ParagraphProperties.new
+
+        # Direct mappings (format-agnostic)
+        target_props.alignment = source_props.alignment
+        target_props.spacing_before = source_props.spacing_before
+        target_props.spacing_after = source_props.spacing_after
+        target_props.line_spacing = source_props.line_spacing
+        target_props.line_rule = source_props.line_rule
+        target_props.indent_left = source_props.indent_left
+        target_props.indent_right = source_props.indent_right
+        target_props.indent_first_line = source_props.indent_first_line
+
+        # DOCX-specific properties to preserve
+        target_props.style = source_props.style
+        target_props.num_id = source_props.num_id
+        target_props.ilvl = source_props.ilvl
+        target_props.keep_next = source_props.keep_next
+        target_props.keep_lines = source_props.keep_lines
+        target_props.page_break_before = source_props.page_break_before
+        target_props.outline_level = source_props.outline_level
+
+        target_para.properties = target_props
+      end
+
+      # Transform MHTML paragraph properties to DOCX format
+      #
+      # @param source_props [Wordprocessingml::ParagraphProperties] Source properties
+      # @param target_para [Paragraph] Target paragraph
+      def transform_properties_mhtml_to_docx(source_props, target_para)
+        # Same transformation as docx_to_mhtml since both use same model
+        # In future, could handle CSS-specific transformations here
+        transform_properties_docx_to_mhtml(source_props, target_para)
+      end
+
+      # Copy properties directly (same format)
+      #
+      # @param source_props [Wordprocessingml::ParagraphProperties] Source properties
+      # @param target_para [Paragraph] Target paragraph
+      def copy_properties(source_props, target_para)
+        target_para.properties = Wordprocessingml::ParagraphProperties.new(
+          alignment: source_props.alignment,
+          spacing_before: source_props.spacing_before,
+          spacing_after: source_props.spacing_after,
+          line_spacing: source_props.line_spacing,
+          line_rule: source_props.line_rule,
+          indent_left: source_props.indent_left,
+          indent_right: source_props.indent_right,
+          indent_first_line: source_props.indent_first_line,
+          style: source_props.style,
+          num_id: source_props.num_id,
+          ilvl: source_props.ilvl,
+          keep_next: source_props.keep_next,
+          keep_lines: source_props.keep_lines,
+          page_break_before: source_props.page_break_before,
+          outline_level: source_props.outline_level
+        )
+      end
+
+      # Transform runs from source to target paragraph
+      #
+      # @param source [Paragraph] Source paragraph
+      # @param target [Paragraph] Target paragraph
+      def transform_runs(source, target)
+        run_rule = RunTransformationRule.new(
+          source_format: @source_format,
+          target_format: @target_format
+        )
+
+        source.runs.each do |source_run|
+          # Handle different run types (Run, Image, Hyperlink)
+          transformed = if source_run.is_a?(Image)
+                          image_rule = ImageTransformationRule.new(
+                            source_format: @source_format,
+                            target_format: @target_format
+                          )
+                          image_rule.transform(source_run)
+                        elsif source_run.is_a?(Hyperlink)
+                          link_rule = HyperlinkTransformationRule.new(
+                            source_format: @source_format,
+                            target_format: @target_format
+                          )
+                          link_rule.transform(source_run)
+                        else
+                          run_rule.transform(source_run)
+                        end
+
+          target.runs << transformed
+        end
+      end
+    end
+  end
+end

data/lib/uniword/transformation/run_transformation_rule.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+module Uniword
+  module Transformation
+    # Transformation rule for Run elements.
+    #
+    # Responsibility: Transform Run objects between DOCX and MHTML formats.
+    # Single Responsibility - handles only Run transformations.
+    #
+    # Transformations preserve text content and formatting properties.
+    # Format-specific properties are adapted as needed.
+    #
+    # @example Transform DOCX run to MHTML
+    #   rule = RunTransformationRule.new(source_format: :docx, target_format: :mhtml)
+    #   mhtml_run = rule.transform(docx_run)
+    class RunTransformationRule < TransformationRule
+      # Check if this rule matches the transformation request
+      #
+      # @param element_type [Class] The element class
+      # @param source_format [Symbol] Source format
+      # @param target_format [Symbol] Target format
+      # @return [Boolean] true if matches
+      def matches?(element_type:, source_format:, target_format:)
+        element_type == Run &&
+          source_format == @source_format &&
+          target_format == @target_format
+      end
+
+      # Transform a run from source format to target format
+      #
+      # Creates new Run with same text and adapted properties.
+      #
+      # @param source_run [Run] Source run
+      # @return [Run] Transformed run
+      # @raise [ArgumentError] if source_run is not a Run
+      def transform(source_run)
+        validate_element_type(source_run, Run)
+
+        # Create new run with same text
+        target_run = Run.new(text: source_run.text)
+
+        # Transform properties if they exist
+        transform_properties(source_run, target_run) if source_run.properties
+
+        target_run
+      end
+
+      private
+
+      # Transform run properties
+      #
+      # @param source [Run] Source run
+      # @param target [Run] Target run
+      def transform_properties(source, target)
+        source_props = source.properties
+
+        # Create new properties object
+        target.properties = Wordprocessingml::RunProperties.new(
+          bold: source_props.bold,
+          italic: source_props.italic,
+          underline: source_props.underline,
+          strike: source_props.strike,
+          double_strike: source_props.double_strike,
+          size: source_props.size,
+          font: source_props.font,
+          color: source_props.color,
+          highlight: source_props.highlight,
+          vertical_align: source_props.vertical_align,
+          small_caps: source_props.small_caps,
+          all_caps: source_props.all_caps,
+          style: source_props.style
+        )
+      end
+    end
+  end
+end

data/lib/uniword/transformation/table_transformation_rule.rb

@@ -0,0 +1,120 @@
+# frozen_string_literal: true
+
+module Uniword
+  module Transformation
+    # Transformation rule for Table elements.
+    #
+    # Responsibility: Transform Table objects between DOCX and MHTML formats.
+    # Single Responsibility - handles only Table transformations.
+    #
+    # Transforms table structure including rows, cells, and all properties.
+    #
+    # @example Transform DOCX table to MHTML
+    #   rule = TableTransformationRule.new(source_format: :docx, target_format: :mhtml)
+    #   mhtml_table = rule.transform(docx_table)
+    class TableTransformationRule < TransformationRule
+      # Check if this rule matches the transformation request
+      #
+      # @param element_type [Class] The element class
+      # @param source_format [Symbol] Source format
+      # @param target_format [Symbol] Target format
+      # @return [Boolean] true if matches
+      def matches?(element_type:, source_format:, target_format:)
+        element_type == Table &&
+          source_format == @source_format &&
+          target_format == @target_format
+      end
+
+      # Transform a table from source format to target format
+      #
+      # Creates new Table with all rows and cells transformed.
+      #
+      # @param source_table [Table] Source table
+      # @return [Table] Transformed table
+      # @raise [ArgumentError] if source_table is not a Table
+      def transform(source_table)
+        validate_element_type(source_table, Table)
+
+        target_table = Table.new
+
+        # Transform table-level properties
+        transform_properties(source_table, target_table)
+
+        # Transform each row
+        source_table.rows.each do |source_row|
+          target_row = transform_row(source_row)
+          target_table.rows << target_row
+        end
+
+        target_table
+      end
+
+      private
+
+      # Transform table properties
+      #
+      # @param source [Table] Source table
+      # @param target [Table] Target table
+      def transform_properties(source, target)
+        return unless source.properties
+
+        target.properties = Properties::TableProperties.new(
+          width: source.properties.width,
+          width_type: source.properties.width_type,
+          alignment: source.properties.alignment,
+          border_style: source.properties.border_style,
+          borders: source.properties.borders
+        )
+      end
+
+      # Transform a table row
+      #
+      # @param source_row [TableRow] Source row
+      # @return [TableRow] Transformed row
+      def transform_row(source_row)
+        target_row = TableRow.new
+        target_row.header = source_row.header
+        target_row.height = source_row.height
+
+        # Transform each cell
+        source_row.cells.each do |source_cell|
+          target_cell = transform_cell(source_cell)
+          target_row.cells << target_cell
+        end
+
+        target_row
+      end
+
+      # Transform a table cell
+      #
+      # @param source_cell [TableCell] Source cell
+      # @return [TableCell] Transformed cell
+      def transform_cell(source_cell)
+        target_cell = TableCell.new
+
+        # Copy cell properties
+        target_cell.properties = TableCellProperties.new if source_cell.properties
+        if target_cell.properties
+          target_cell.properties.width = source_cell.properties&.width
+          target_cell.properties.grid_span = source_cell.properties&.grid_span
+          target_cell.properties.vertical_merge = source_cell.properties&.vertical_merge
+          target_cell.properties.shading = source_cell.properties&.shading
+          target_cell.properties.vertical_align = source_cell.properties&.vertical_align
+        end
+
+        # Transform cell content (paragraphs)
+        para_rule = ParagraphTransformationRule.new(
+          source_format: @source_format,
+          target_format: @target_format
+        )
+
+        source_cell.paragraphs.each do |source_para|
+          target_para = para_rule.transform(source_para)
+          target_cell.paragraphs << target_para
+        end
+
+        target_cell
+      end
+    end
+  end
+end

data/lib/uniword/transformation/transformation_rule.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+module Uniword
+  module Transformation
+    # Base class for transformation rules.
+    #
+    # Responsibility: Define the interface for element transformation rules.
+    # Each rule transforms one element type from source format to target format.
+    #
+    # Follows Single Responsibility Principle - one rule handles one transformation pattern.
+    # Follows Open/Closed Principle - new rules can be added without modifying this class.
+    #
+    # @example Create a custom transformation rule
+    #   class CustomRule < TransformationRule
+    #     def matches?(element_type:, source_format:, target_format:)
+    #       element_type == CustomElement &&
+    #         source_format == :docx &&
+    #         target_format == :mhtml
+    #     end
+    #
+    #     def transform(element)
+    #       # Transform CustomElement from DOCX to MHTML format
+    #       transformed = CustomElement.new
+    #       # Copy and adapt properties
+    #       transformed
+    #     end
+    #   end
+    class TransformationRule
+      attr_reader :source_format, :target_format
+
+      # Initialize transformation rule
+      #
+      # @param source_format [Symbol] Source format (:docx or :mhtml)
+      # @param target_format [Symbol] Target format (:docx or :mhtml)
+      def initialize(source_format:, target_format:)
+        @source_format = source_format
+        @target_format = target_format
+      end
+
+      # Check if this rule matches the transformation request
+      #
+      # @param element_type [Class] The element class to transform
+      # @param source_format [Symbol] Source format
+      # @param target_format [Symbol] Target format
+      # @return [Boolean] true if this rule can handle the transformation
+      def matches?(element_type:, source_format:, target_format:)
+        raise NotImplementedError, "#{self.class} must implement #matches?"
+      end
+
+      # Transform an element from source format to target format
+      #
+      # @param element [Element] The element to transform
+      # @return [Element, Array<Element>] The transformed element(s)
+      def transform(element)
+        raise NotImplementedError, "#{self.class} must implement #transform"
+      end
+
+      protected
+
+      # Helper to validate element type
+      #
+      # @param element [Object] Element to validate
+      # @param expected_type [Class] Expected class
+      # @raise [ArgumentError] if element is wrong type
+      def validate_element_type(element, expected_type)
+        return if element.is_a?(expected_type)
+
+        raise ArgumentError,
+              "Expected #{expected_type}, got #{element.class}"
+      end
+    end
+
+    # Null transformation rule (fallback when no rule matches)
+    #
+    # Returns element unchanged - useful as default behavior
+    class NullTransformationRule < TransformationRule
+      def initialize
+        super(source_format: :any, target_format: :any)
+      end
+
+      def matches?(element_type:, source_format:, target_format:)
+        true # Matches anything (fallback)
+      end
+
+      def transform(element)
+        # No transformation - deep copy element to avoid mutations
+        element.class.new(element.to_h)
+      end
+    end
+  end
+end

data/lib/uniword/transformation/transformation_rule_registry.rb

@@ -0,0 +1,133 @@
+# frozen_string_literal: true
+
+module Uniword
+  module Transformation
+    # Registry for transformation rules.
+    #
+    # Responsibility: Manage registration and lookup of transformation rules.
+    # Single Responsibility - only handles rule registration and retrieval.
+    #
+    # Follows Open/Closed Principle - new rules can be registered without
+    # modifying this class.
+    #
+    # Follows MECE Principle - each rule is mutually exclusive (handles
+    # specific element types and format combinations), and collectively
+    # exhaustive (fallback to NullTransformationRule ensures coverage).
+    #
+    # @example Register and use rules
+    #   registry = TransformationRuleRegistry.new
+    #   registry.register(ParagraphTransformationRule.new(
+    #     source_format: :docx,
+    #     target_format: :mhtml
+    #   ))
+    #
+    #   rule = registry.find_rule(
+    #     element_type: Paragraph,
+    #     source_format: :docx,
+    #     target_format: :mhtml
+    #   )
+    class TransformationRuleRegistry
+      # Initialize empty registry
+      def initialize
+        @rules = []
+        @null_rule = NullTransformationRule.new
+      end
+
+      # Register a transformation rule
+      #
+      # @param rule [TransformationRule] The rule to register
+      # @return [self] Returns self for method chaining
+      # @raise [ArgumentError] if rule is not a TransformationRule
+      #
+      # @example Register a rule
+      #   registry.register(CustomRule.new(source_format: :docx, target_format: :mhtml))
+      def register(rule)
+        validate_rule(rule)
+        @rules << rule
+        self
+      end
+
+      # Find a rule matching the given criteria
+      #
+      # Returns the first matching rule, or NullTransformationRule if none match.
+      # NullTransformationRule returns element unchanged (deep copy).
+      #
+      # @param element_type [Class] The element class to transform
+      # @param source_format [Symbol] Source format (:docx or :mhtml)
+      # @param target_format [Symbol] Target format (:docx or :mhtml)
+      # @return [TransformationRule] The matching rule or NullTransformationRule
+      #
+      # @example Find a rule
+      #   rule = registry.find_rule(
+      #     element_type: Paragraph,
+      #     source_format: :docx,
+      #     target_format: :mhtml
+      #   )
+      def find_rule(element_type:, source_format:, target_format:)
+        @rules.find do |rule|
+          rule.matches?(
+            element_type: element_type,
+            source_format: source_format,
+            target_format: target_format
+          )
+        end || @null_rule
+      end
+
+      # Get all registered rules
+      #
+      # @return [Array<TransformationRule>] Array of registered rules
+      def rules
+        @rules.dup
+      end
+
+      # Get count of registered rules
+      #
+      # @return [Integer] Number of registered rules
+      def count
+        @rules.count
+      end
+
+      # Check if any rules are registered
+      #
+      # @return [Boolean] true if registry has rules
+      def empty?
+        @rules.empty?
+      end
+
+      # Clear all registered rules
+      #
+      # Useful for testing or reconfiguration
+      #
+      # @return [self] Returns self for method chaining
+      def clear
+        @rules.clear
+        self
+      end
+
+      # Register multiple rules at once
+      #
+      # @param rules [Array<TransformationRule>] Array of rules to register
+      # @return [self] Returns self for method chaining
+      #
+      # @example Batch registration
+      #   registry.register_all([rule1, rule2, rule3])
+      def register_all(rules)
+        rules.each { |rule| register(rule) }
+        self
+      end
+
+      private
+
+      # Validate that object is a TransformationRule
+      #
+      # @param rule [Object] Object to validate
+      # @raise [ArgumentError] if rule is invalid
+      def validate_rule(rule)
+        return if rule.is_a?(TransformationRule)
+
+        raise ArgumentError,
+              "Rule must be a TransformationRule, got #{rule.class}"
+      end
+    end
+  end
+end