uniword 1.0.0

data/lib/uniword/template/variable_resolver.rb

@@ -0,0 +1,195 @@
+# frozen_string_literal: true
+
+module Uniword
+  module Template
+    # Resolves variable expressions to values from data context.
+    #
+    # Handles nested property access (e.g., "chapter.number") and
+    # conditional evaluation. Works with both Hash and object data sources.
+    #
+    # Responsibility: Variable resolution only
+    # Single Responsibility Principle: Does NOT parse, render, or validate
+    #
+    # @example Resolve simple variable
+    #   resolver = VariableResolver.new(title: "My Document")
+    #   resolver.resolve("title") # => "My Document"
+    #
+    # @example Resolve nested property
+    #   data = { chapter: { number: "5.1" } }
+    #   resolver = VariableResolver.new(data)
+    #   resolver.resolve("chapter.number") # => "5.1"
+    #
+    # @example Resolve from object
+    #   class Chapter
+    #     attr_reader :number
+    #     def initialize(num)
+    #       @number = num
+    #     end
+    #   end
+    #   resolver = VariableResolver.new(Chapter.new("5.1"))
+    #   resolver.resolve("number") # => "5.1"
+    class VariableResolver
+      # Initialize resolver with data context
+      #
+      # @param data [Hash, Object] Data source for variable resolution
+      # @param context [Hash] Additional context variables
+      def initialize(data, context = {})
+        @data = data
+        @context = context
+      end
+
+      # Resolve variable expression to value
+      #
+      # Supports dot notation for nested properties:
+      # - "title" => @data[:title] or @data.title
+      # - "chapter.number" => @data[:chapter][:number] or @data.chapter.number
+      #
+      # @param expression [String] Variable expression (e.g., "title", "chapter.number")
+      # @return [Object] Resolved value or nil if not found
+      def resolve(expression)
+        return nil if expression.nil? || expression.empty?
+
+        parts = expression.to_s.split('.')
+
+        # Start with root data
+        value = @data
+
+        # Navigate through each part
+        parts.each do |part|
+          break if value.nil?
+
+          value = navigate_property(value, part)
+        end
+
+        value
+      end
+
+      # Evaluate conditional expression
+      #
+      # Supports:
+      # - Simple truthiness: "has_annexes"
+      # - Comparisons: "count > 5", "status == 'active'"
+      #
+      # @param condition [String] Condition expression
+      # @return [Boolean] Evaluation result
+      def evaluate(condition)
+        return false if condition.nil? || condition.empty?
+
+        # Simple variable existence/truthiness check
+        if condition.match?(/^\w+(\.\w+)*$/)
+          value = resolve(condition)
+          return !!value
+        end
+
+        # Comparison operators - order matters, check >= and <= before > and <
+        match = condition.match(/(.+?)\s*(>=|<=|==|!=|>|<)\s*(.+)/)
+        if match
+          left_expr = match[1].strip
+          operator = match[2]
+          right_expr = match[3].strip
+
+          left = resolve(left_expr)
+          right = parse_literal(right_expr)
+
+          evaluate_comparison(left, operator, right)
+        else
+          false
+        end
+      end
+
+      private
+
+      # Navigate to a property on an object
+      #
+      # @param object [Object] Object to navigate
+      # @param property [String] Property name
+      # @return [Object] Property value or nil
+      def navigate_property(object, property)
+        # For hashes, use key access
+        if object.is_a?(Hash)
+          object[property.to_sym] || object[property]
+        # For objects with methods, call the method
+        elsif object.respond_to?(property.to_sym)
+          object.send(property.to_sym)
+        end
+      end
+
+      # Parse literal value from string
+      #
+      # @param value [String] Literal value string
+      # @return [Object] Parsed value (number, string, etc.)
+      def parse_literal(value)
+        # Remove quotes if present
+        match = value.match(/^["'](.*)["']$/)
+        if match
+          match[1]
+        elsif value.match?(/^\d+$/)
+          value.to_i
+        elsif value.match?(/^\d+\.\d+$/)
+          value.to_f
+        elsif value == 'true'
+          true
+        elsif value == 'false'
+          false
+        elsif value == 'nil'
+          nil
+        else
+          # Try to resolve as variable
+          resolve(value) || value
+        end
+      end
+
+      # Evaluate comparison between two values
+      #
+      # @param left [Object] Left operand
+      # @param operator [String] Comparison operator
+      # @param right [Object] Right operand
+      # @return [Boolean] Comparison result
+      def evaluate_comparison(left, operator, right)
+        case operator
+        when '=='
+          left == right
+        when '!='
+          left != right
+        when '>'
+          compare_numerically(left, right, :>)
+        when '<'
+          compare_numerically(left, right, :<)
+        when '>='
+          compare_numerically(left, right, :>=)
+        when '<='
+          compare_numerically(left, right, :<=)
+        else
+          false
+        end
+      end
+
+      # Compare values numerically
+      #
+      # @param left [Object] Left operand
+      # @param right [Object] Right operand
+      # @param operator [Symbol] Comparison operator
+      # @return [Boolean] Comparison result
+      def compare_numerically(left, right, operator)
+        left_num = to_number(left)
+        right_num = to_number(right)
+
+        return false if left_num.nil? || right_num.nil?
+
+        left_num.send(operator, right_num)
+      end
+
+      # Convert value to number
+      #
+      # @param value [Object] Value to convert
+      # @return [Numeric, nil] Numeric value or nil
+      def to_number(value)
+        return value if value.is_a?(Numeric)
+        return value.to_i if value.respond_to?(:to_i) && value.to_s.match?(/^\d+$/)
+        return value.to_f if value.respond_to?(:to_f) && value.to_s.match?(/^\d+\.\d+$/)
+
+        nil
+      end
+    end
+  end
+end

data/lib/uniword/template.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Uniword
+  module Template
+    autoload :Template, "#{__dir__}/template/template"
+    autoload :VariableResolver, "#{__dir__}/template/variable_resolver"
+    autoload :TemplateParser, "#{__dir__}/template/template_parser"
+    autoload :TemplateRenderer, "#{__dir__}/template/template_renderer"
+    autoload :TemplateValidator, "#{__dir__}/template/template_validator"
+    autoload :TemplateContext, "#{__dir__}/template/template_context"
+    autoload :TemplateMarker, "#{__dir__}/template/template_marker"
+    autoload :Helpers, "#{__dir__}/template/helpers"
+  end
+end

data/lib/uniword/text_box.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+require 'lutaml/model'
+
+module Uniword
+  # Represents a text box (floating text container)
+  # Can be positioned absolutely or relatively
+  class TextBox < Lutaml::Model::Serializable
+    attribute :paragraphs, Wordprocessingml::Paragraph, collection: true, initialize_empty: true
+
+    # Position (in twips from page origin)
+    attribute :x, :integer
+    attribute :y, :integer
+
+    # Size (in twips)
+    attribute :width, :integer
+    attribute :height, :integer
+
+    # Wrapping style
+    attribute :wrapping, :string, default: -> { 'square' }
+
+    # Border
+    attribute :border_style, :string
+    attribute :border_width, :integer
+    attribute :border_color, :string
+
+    # Fill
+    attribute :fill_color, :string
+
+    # Anchor type (page or paragraph)
+    attribute :anchor_type, :string, default: -> { 'page' }
+
+    # Valid wrapping styles
+    WRAPPING_STYLES = %w[none square tight through topAndBottom].freeze
+
+    def initialize(**attributes)
+      super
+      validate_wrapping
+    end
+
+    # Check if text box is empty
+    def empty?
+      paragraphs.empty?
+    end
+
+    private
+
+    def validate_wrapping
+      return unless wrapping && !WRAPPING_STYLES.include?(wrapping)
+
+      raise ArgumentError,
+            "Invalid wrapping: #{wrapping}. Must be one of: #{WRAPPING_STYLES.join(', ')}"
+    end
+  end
+end

data/lib/uniword/text_frame.rb

@@ -0,0 +1,168 @@
+# frozen_string_literal: true
+
+require 'lutaml/model'
+
+module Uniword
+  # Represents a text frame for positioned text
+  #
+  # Text frames allow precise positioning of paragraphs on the page,
+  # commonly used for sidebars, pull quotes, and floating text boxes.
+  #
+  # @example Absolute positioned frame
+  #   frame = TextFrame.new(
+  #     width: 4000,
+  #     height: 1000,
+  #     x: 1000,
+  #     y: 3000,
+  #     h_anchor: 'margin',
+  #     v_anchor: 'margin'
+  #   )
+  #
+  # @example Aligned frame
+  #   frame = TextFrame.new(
+  #     width: 4000,
+  #     h_alignment: 'right',
+  #     v_alignment: 'top',
+  #     h_anchor: 'page',
+  #     v_anchor: 'page'
+  #   )
+  #
+  # @attr [Integer] width Frame width in twips
+  # @attr [Integer] height Frame height in twips
+  # @attr [String] h_rule Width rule (auto, atLeast, exact)
+  # @attr [String] w_rule Height rule (auto, atLeast, exact)
+  # @attr [Integer] x Horizontal position in twips
+  # @attr [Integer] y Vertical position in twips
+  # @attr [String] h_anchor Horizontal anchor point
+  # @attr [String] v_anchor Vertical anchor point
+  # @attr [String] h_alignment Horizontal alignment
+  # @attr [String] v_alignment Vertical alignment
+  # @attr [String] wrap Text wrapping style
+  # @attr [Boolean] lock_anchor Lock anchor position
+  class TextFrame < Lutaml::Model::Serializable
+    # Anchor types
+    ANCHOR_TYPES = %w[margin page text column character].freeze
+
+    # Alignment options
+    H_ALIGNMENTS = %w[left center right inside outside].freeze
+    V_ALIGNMENTS = %w[top center bottom inside outside].freeze
+
+    # Size rules
+    SIZE_RULES = %w[auto atLeast exact].freeze
+
+    # Wrap types
+    WRAP_TYPES = %w[around none through tight].freeze
+
+    attribute :width, :integer
+    attribute :height, :integer
+    attribute :h_rule, :string, default: -> { 'auto' }
+    attribute :w_rule, :string, default: -> { 'auto' }
+    attribute :x, :integer
+    attribute :y, :integer
+    attribute :h_anchor, :string, default: -> { 'text' }
+    attribute :v_anchor, :string, default: -> { 'text' }
+    attribute :h_alignment, :string
+    attribute :v_alignment, :string
+    attribute :wrap, :string, default: -> { 'around' }
+    attribute :lock_anchor, :boolean, default: -> { false }
+
+    def initialize(**attributes)
+      super
+      validate_anchors
+      validate_alignments
+      validate_rules
+      validate_wrap
+    end
+
+    # Create absolutely positioned frame
+    #
+    # @param width [Integer] Frame width
+    # @param height [Integer] Frame height
+    # @param x [Integer] Horizontal position
+    # @param y [Integer] Vertical position
+    # @param options [Hash] Additional options
+    # @return [TextFrame] New instance
+    def self.absolute(width:, height:, x:, y:, **)
+      new(
+        width: width,
+        height: height,
+        x: x,
+        y: y,
+        h_rule: 'exact',
+        w_rule: 'exact',
+        **
+      )
+    end
+
+    # Create aligned frame
+    #
+    # @param width [Integer] Frame width
+    # @param h_alignment [String] Horizontal alignment
+    # @param v_alignment [String] Vertical alignment
+    # @param options [Hash] Additional options
+    # @return [TextFrame] New instance
+    def self.aligned(width:, h_alignment:, v_alignment:, **)
+      new(
+        width: width,
+        h_alignment: h_alignment,
+        v_alignment: v_alignment,
+        h_rule: 'exact',
+        **
+      )
+    end
+
+    # Check if frame uses absolute positioning
+    #
+    # @return [Boolean] true if has x,y coordinates
+    def absolute_position?
+      !x.nil? && !y.nil?
+    end
+
+    # Check if frame uses alignment positioning
+    #
+    # @return [Boolean] true if has alignments
+    def aligned_position?
+      !h_alignment.nil? || !v_alignment.nil?
+    end
+
+    private
+
+    def validate_anchors
+      if h_anchor && !ANCHOR_TYPES.include?(h_anchor)
+        raise ArgumentError,
+              "Invalid h_anchor: #{h_anchor}. Must be one of: #{ANCHOR_TYPES.join(', ')}"
+      end
+      return unless v_anchor && !ANCHOR_TYPES.include?(v_anchor)
+
+      raise ArgumentError,
+            "Invalid v_anchor: #{v_anchor}. Must be one of: #{ANCHOR_TYPES.join(', ')}"
+    end
+
+    def validate_alignments
+      if h_alignment && !H_ALIGNMENTS.include?(h_alignment)
+        raise ArgumentError,
+              "Invalid h_alignment: #{h_alignment}. Must be one of: #{H_ALIGNMENTS.join(', ')}"
+      end
+      return unless v_alignment && !V_ALIGNMENTS.include?(v_alignment)
+
+      raise ArgumentError,
+            "Invalid v_alignment: #{v_alignment}. Must be one of: #{V_ALIGNMENTS.join(', ')}"
+    end
+
+    def validate_rules
+      if h_rule && !SIZE_RULES.include?(h_rule)
+        raise ArgumentError,
+              "Invalid h_rule: #{h_rule}. Must be one of: #{SIZE_RULES.join(', ')}"
+      end
+      return unless w_rule && !SIZE_RULES.include?(w_rule)
+
+      raise ArgumentError, "Invalid w_rule: #{w_rule}. Must be one of: #{SIZE_RULES.join(', ')}"
+    end
+
+    def validate_wrap
+      return unless wrap && !WRAP_TYPES.include?(wrap)
+
+      raise ArgumentError, "Invalid wrap: #{wrap}. Must be one of: #{WRAP_TYPES.join(', ')}"
+    end
+  end
+end

data/lib/uniword/theme/media_file.rb

@@ -0,0 +1,128 @@
+# frozen_string_literal: true
+
+module Uniword
+  module Themes
+    # Value object representing a media file (image, etc.) from a theme package
+    #
+    # Responsibility: Hold immutable media file data with proper metadata
+    #
+    # This class follows the Value Object pattern:
+    # - Immutable (frozen after initialization)
+    # - Value-based equality
+    # - Self-validating
+    #
+    # @example Create media file from theme
+    #   media = MediaFile.new(
+    #     filename: 'image1.jpeg',
+    #     content: binary_data,
+    #     content_type: 'image/jpeg'
+    #   )
+    class MediaFile
+      # Media filename (e.g., 'image1.jpeg')
+      attr_reader :filename
+
+      # Binary content data
+      attr_reader :content
+
+      # MIME content type (e.g., 'image/jpeg', 'image/png')
+      attr_reader :content_type
+
+      # Original path in theme package (e.g., 'theme/media/image1.jpeg')
+      attr_reader :source_path
+
+      # Create a new MediaFile
+      #
+      # @param attributes [Hash] Media file attributes
+      # @option attributes [String] :filename Required filename
+      # @option attributes [String] :content Required binary content
+      # @option attributes [String] :content_type Optional MIME type (auto-detected if not provided)
+      # @option attributes [String] :source_path Optional original path
+      # @raise [ArgumentError] if required attributes missing
+      def initialize(attributes = {})
+        @filename = attributes[:filename]
+        @content = attributes[:content]
+        @content_type = attributes[:content_type] || detect_content_type(@filename)
+        @source_path = attributes[:source_path]
+
+        validate!
+        freeze # Immutable
+      end
+
+      # Get file size in bytes
+      #
+      # @return [Integer] Size of content in bytes
+      def size
+        content&.bytesize || 0
+      end
+
+      # Check if this is an image file
+      #
+      # @return [Boolean] true if image
+      def image?
+        content_type&.start_with?('image/')
+      end
+
+      # Get file extension
+      #
+      # @return [String, nil] File extension without dot
+      def extension
+        return nil unless filename
+
+        File.extname(filename)[1..]
+      end
+
+      # Value-based equality
+      #
+      # @param other [Object] Object to compare
+      # @return [Boolean] true if equal
+      def ==(other)
+        return false unless other.is_a?(self.class)
+
+        filename == other.filename &&
+          content == other.content &&
+          content_type == other.content_type
+      end
+
+      alias eql? ==
+
+      # Hash code for value-based hashing
+      #
+      # @return [Integer] hash code
+      def hash
+        [filename, content, content_type].hash
+      end
+
+      # Validate required attributes
+      #
+      # @return [void]
+      # @raise [ArgumentError] if invalid
+      def validate!
+        raise ArgumentError, 'filename is required' if filename.nil? || filename.empty?
+        raise ArgumentError, 'content is required' if content.nil?
+        raise ArgumentError, 'filename must be a string' unless filename.is_a?(String)
+      end
+
+      private
+
+      # Detect content type from filename extension
+      #
+      # @param filename [String] The filename
+      # @return [String] MIME content type
+      def detect_content_type(filename)
+        return 'application/octet-stream' unless filename
+
+        ext = File.extname(filename).downcase
+
+        case ext
+        when '.jpeg', '.jpg' then 'image/jpeg'
+        when '.png' then 'image/png'
+        when '.gif' then 'image/gif'
+        when '.bmp' then 'image/bmp'
+        when '.tiff', '.tif' then 'image/tiff'
+        when '.svg' then 'image/svg+xml'
+        else 'application/octet-stream'
+        end
+      end
+    end
+  end
+end

data/lib/uniword/theme/theme_applicator.rb

@@ -0,0 +1,141 @@
+# frozen_string_literal: true
+
+module Uniword
+  module Themes
+    # Applies themes to documents by setting theme data and updating styles
+    #
+    # When a theme is applied to a document:
+    # 1. The theme XML is stored for serialization to word/theme/theme1.xml
+    # 2. Document defaults get theme font references (minorAscii, etc.)
+    # 3. Heading styles get major font and theme color references
+    # 4. Hyperlink styles get theme color references
+    class ThemeApplicator
+      # Apply theme to document
+      #
+      # @param theme [Drawingml::Theme] Theme to apply
+      # @param document [Wordprocessingml::DocumentRoot] Target document
+      # @return [void]
+      def apply(theme, document)
+        word_theme = normalize_theme(theme)
+        document.theme = word_theme.dup
+        update_doc_defaults(document, word_theme)
+        update_builtin_styles(document, word_theme)
+      end
+
+      private
+
+      # Ensure theme is a Drawingml::Theme (convert from friendly if needed)
+      def normalize_theme(theme)
+        if theme.is_a?(Uniword::Drawingml::Theme)
+          theme
+        elsif theme.is_a?(Uniword::Themes::Theme)
+          Uniword::Themes::ThemeTransformation.new.to_word(theme)
+        else
+          raise ArgumentError, "Expected Drawingml::Theme or Themes::Theme, got #{theme.class}"
+        end
+      end
+
+      # Update document defaults to reference theme fonts
+      def update_doc_defaults(document, theme)
+        return unless theme.font_scheme
+
+        styles_config = document.styles_configuration
+
+        doc_defaults = styles_config.doc_defaults
+        if doc_defaults.nil?
+          doc_defaults = Uniword::Wordprocessingml::DocDefaults.new
+          styles_config.doc_defaults = doc_defaults
+        end
+
+        rpr_default = doc_defaults.rPrDefault
+        if rpr_default.nil?
+          rpr_default = Uniword::Wordprocessingml::RPrDefault.new
+          doc_defaults.rPrDefault = rpr_default
+        end
+
+        rpr = rpr_default.rPr
+        if rpr.nil?
+          rpr = Uniword::Wordprocessingml::RunProperties.new
+          rpr_default.rPr = rpr
+        end
+
+        # Set theme font references on doc defaults (body text = minor font)
+        rpr.fonts = build_minor_font_reference(theme)
+        rpr
+      end
+
+      # Update built-in heading and hyperlink styles to reference theme
+      def update_builtin_styles(document, theme)
+        styles_config = document.styles_configuration
+        return unless styles_config
+
+        update_heading_styles(styles_config, theme)
+        update_hyperlink_style(styles_config, theme)
+      end
+
+      # Update heading styles (Heading1-9) with theme font/color references
+      def update_heading_styles(styles_config, theme)
+        heading_color = theme.color(:dk1)
+        (1..9).each do |level|
+          style = styles_config.style_by_id("Heading#{level}")
+          next unless style
+
+          rpr = style.rPr
+          next unless rpr
+
+          # Set major font reference for headings
+          rpr.fonts = build_major_font_reference(theme)
+
+          # Set theme color reference for heading text
+          next unless heading_color
+
+          rpr.color = Uniword::Properties::ColorValue.new(
+            value: heading_color,
+            theme_color: 'text1'
+          )
+        end
+      end
+
+      # Update hyperlink style with theme color reference
+      def update_hyperlink_style(styles_config, theme)
+        style = styles_config.style_by_id('Hyperlink')
+        return unless style
+
+        rpr = style.rPr
+        return unless rpr
+
+        hlink_color = theme.color(:hlink)
+        return unless hlink_color
+
+        rpr.color = Uniword::Properties::ColorValue.new(
+          value: hlink_color,
+          theme_color: 'hyperlink'
+        )
+      end
+
+      # Build RunFonts referencing the theme's minor (body) font
+      def build_minor_font_reference(theme)
+        return nil unless theme.font_scheme
+
+        Uniword::Properties::RunFonts.new(
+          ascii_theme: 'minorAscii',
+          h_ansi_theme: 'minorHAnsi',
+          east_asia_theme: 'minorEastAsia',
+          cs_theme: 'minorBidi'
+        )
+      end
+
+      # Build RunFonts referencing the theme's major (heading) font
+      def build_major_font_reference(theme)
+        return nil unless theme.font_scheme
+
+        Uniword::Properties::RunFonts.new(
+          ascii_theme: 'majorAscii',
+          h_ansi_theme: 'majorHAnsi',
+          east_asia_theme: 'majorEastAsia',
+          cs_theme: 'majorBidi'
+        )
+      end
+    end
+  end
+end