uniword 1.0.0

data/lib/uniword/theme/theme_loader.rb

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+module Uniword
+  module Themes
+    # Orchestrates theme loading from .thmx files
+    #
+    # Coordinates between ThemePackageReader and ThemeXmlParser
+    # to load themes and their variants from .thmx packages.
+    #
+    # @example Load a theme
+    #   loader = ThemeLoader.new
+    #   theme = loader.load('Atlas.thmx')
+    #   puts theme.name
+    #   puts theme.variants.keys
+    #
+    # @example Load with specific variant
+    #   theme = loader.load_with_variant('Atlas.thmx', 'variant2')
+    #   puts theme.name
+    class ThemeLoader
+      # Load theme from .thmx file
+      #
+      # @param path [String] Path to .thmx file
+      # @return [Theme] Loaded theme with variants and media
+      # @raise [ArgumentError] if file is invalid
+      def load(path)
+        # Extract package
+        reader = ThemePackageReader.new
+        extracted = reader.extract(path)
+
+        # Parse base theme
+        parser = ThemeXmlParser.new
+        theme = parser.parse(extracted[:base])
+
+        # Store source file reference
+        theme.source_file = path
+
+        # Store media files
+        theme.media_files = extracted[:media] || {}
+
+        # Load variants
+        theme.variants = load_variants(extracted[:variants])
+
+        theme
+      end
+
+      # Load theme with specific variant applied
+      #
+      # @param path [String] Path to .thmx file
+      # @param variant_id [String, Integer] Variant identifier
+      #   Can be 'variant1', 'variant2', etc. or numeric 1, 2, etc.
+      # @return [Theme] Theme with variant applied
+      # @raise [ArgumentError] if variant not found
+      def load_with_variant(path, variant_id)
+        # Normalize variant ID
+        variant_key = normalize_variant_id(variant_id)
+
+        # Load base theme
+        base_theme = load(path)
+
+        # Get variant
+        variant = base_theme.variants[variant_key]
+        unless variant
+          raise ArgumentError,
+                "Variant '#{variant_id}' not found. " \
+                "Available variants: #{base_theme.variants.keys.join(', ')}"
+        end
+
+        # Apply variant to base theme
+        variant.apply_to(base_theme)
+      end
+
+      private
+
+      # Load all variants from extracted theme package
+      #
+      # @param variant_xmls [Hash] variant_id => theme XML content
+      # @return [Hash] variant_id => ThemeVariant
+      def load_variants(variant_xmls)
+        variants = {}
+
+        variant_xmls.each do |variant_id, theme_xml|
+          variant = ThemeVariant.new(variant_id, theme_xml: theme_xml)
+          variants[variant_id] = variant
+        end
+
+        variants
+      end
+
+      # Normalize variant ID to standard format
+      #
+      # Converts numeric IDs to variant{N} format
+      #
+      # @param variant_id [String, Integer] Variant identifier
+      # @return [String] Normalized variant ID
+      def normalize_variant_id(variant_id)
+        case variant_id
+        when Integer
+          "variant#{variant_id}"
+        when /^\d+$/
+          "variant#{variant_id}"
+        else
+          variant_id.to_s
+        end
+      end
+    end
+  end
+end

data/lib/uniword/theme/theme_package_reader.rb

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+module Uniword
+  module Themes
+    # Reads and extracts .thmx theme package files
+    #
+    # .thmx files are ZIP archives containing PowerPoint theme definitions
+    # with optional variant packages. The actual Word theme is nested at
+    # theme/theme/theme1.xml (not theme/theme1.xml as initially expected).
+    #
+    # @example Extract a theme package
+    #   reader = ThemePackageReader.new
+    #   files = reader.extract('Atlas.thmx')
+    #   base_theme_xml = files[:base]
+    #   variant_themes = files[:variants]
+    class ThemePackageReader
+      # Extract theme files from .thmx package
+      #
+      # @param path [String] Path to .thmx file
+      # @return [Hash] Extracted theme data
+      #   - :base => Base theme XML content (from theme/theme/theme1.xml)
+      #   - :variants => Hash of variant_id => variant theme XML content
+      #   - :variant_manager => Variant manager XML (if present)
+      #   - :media => Hash of filename => MediaFile objects
+      # @raise [ArgumentError] if file is invalid or missing required theme
+      def extract(path)
+        extractor = Infrastructure::ZipExtractor.new
+        content = extractor.extract(path)
+
+        # Extract base theme from corrected path
+        base_theme_xml = content['theme/theme/theme1.xml']
+        unless base_theme_xml
+          raise ArgumentError,
+                'Invalid theme package: missing theme/theme/theme1.xml'
+        end
+
+        # Extract variants
+        variants = extract_variants(content)
+
+        # Extract variant manager if present
+        variant_manager_xml = content['themeVariants/themeVariantManager.xml']
+
+        # Extract media files
+        media = extract_media_files(content)
+
+        {
+          base: base_theme_xml,
+          variants: variants,
+          variant_manager: variant_manager_xml,
+          media: media
+        }
+      end
+
+      private
+
+      # Extract variant themes from package
+      #
+      # @param content [Hash] All extracted files from .thmx
+      # @return [Hash] variant_id => theme XML content
+      def extract_variants(content)
+        variants = {}
+
+        content.each_key do |file_path|
+          # Match pattern: themeVariants/variant{N}/theme/theme/theme1.xml
+          next unless file_path =~ %r{^themeVariants/variant(\d+)/theme/theme/theme1\.xml$}
+
+          variant_id = "variant#{Regexp.last_match(1)}"
+          variants[variant_id] = content[file_path]
+        end
+
+        variants
+      end
+
+      # Extract media files from package
+      #
+      # Extracts images and other media from theme/media/ directory
+      # Returns MediaFile objects for proper encapsulation
+      #
+      # @param content [Hash] All extracted files from .thmx
+      # @return [Hash] filename => MediaFile object
+      def extract_media_files(content)
+        media = {}
+
+        content.each_key do |file_path|
+          # Match pattern: theme/media/{filename}
+          next unless file_path =~ %r{^theme/media/(.+)$}
+
+          filename = Regexp.last_match(1)
+
+          # Create MediaFile value object
+          media[filename] = MediaFile.new(
+            filename: filename,
+            content: content[file_path],
+            source_path: file_path
+          )
+        end
+
+        media
+      end
+    end
+  end
+end

data/lib/uniword/theme/theme_variant.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+module Uniword
+  module Themes
+    # Represents a theme variant
+    #
+    # Theme variants provide visual style variations of a base theme.
+    # In .thmx files, variants are numbered (variant1, variant2, etc.)
+    # and each contains a complete theme definition that can override
+    # the base theme's colors, fonts, or effects.
+    #
+    # @example Create and apply a variant
+    #   variant = ThemeVariant.new('variant2')
+    #   variant.theme_xml = variant_theme_xml_content
+    #   themed = variant.apply_to(base_theme)
+    class ThemeVariant
+      # @return [String] Variant identifier (e.g., 'variant1', 'variant2')
+      attr_accessor :id
+
+      # @return [String, nil] Variant GUID from theme package
+      attr_accessor :guid
+
+      # @return [String, nil] Raw theme XML for this variant
+      attr_accessor :theme_xml
+
+      # @return [Theme, nil] Parsed theme for this variant
+      attr_accessor :theme
+
+      # Initialize a theme variant
+      #
+      # @param id [String] Variant identifier
+      # @param theme_xml [String, nil] Optional variant theme XML
+      def initialize(id, theme_xml: nil)
+        @id = id
+        @theme_xml = theme_xml
+        @theme = nil
+        @guid = nil
+      end
+
+      # Parse the variant theme XML
+      #
+      # @return [Theme] Parsed variant theme
+      def parse_theme
+        return @theme if @theme
+        return nil unless @theme_xml
+
+        parser = ThemeXmlParser.new
+        @theme = parser.parse(@theme_xml)
+      end
+
+      # Apply this variant to a base theme
+      #
+      # For now, this simply returns the variant's theme since
+      # variants in .thmx files are complete theme definitions.
+      # Future enhancement: merge variant with base theme selectively.
+      #
+      # @param base_theme [Theme] Base theme (unused in current implementation)
+      # @return [Theme] Variant theme (or parsed variant theme)
+      def apply_to(base_theme)
+        # Parse theme if not already parsed
+        parse_theme unless @theme
+
+        # Return the variant theme
+        # In .thmx files, variants are complete themes, not just overrides
+        @theme || base_theme.dup
+      end
+
+      # Get a descriptive name for this variant
+      #
+      # @return [String] Variant name
+      def name
+        # In the future, this could map to display names
+        # For now, just return the ID
+        @id
+      end
+
+      # Provide detailed inspection for debugging
+      #
+      # @return [String] A readable representation of the variant
+      def inspect
+        "#<Uniword::Theme::ThemeVariant id=#{@id.inspect} " \
+          "guid=#{@guid.inspect} " \
+          "theme=#{@theme ? @theme.name : 'not parsed'}>"
+      end
+    end
+  end
+end

data/lib/uniword/theme/theme_xml_parser.rb

@@ -0,0 +1,239 @@
+# frozen_string_literal: true
+
+require 'nokogiri'
+
+module Uniword
+  module Themes
+    # Parses theme XML files into Theme models
+    #
+    # Handles parsing of theme1.xml files from .thmx packages,
+    # extracting color schemes, font schemes, and format schemes.
+    #
+    # @example Parse a theme XML file
+    #   parser = ThemeXmlParser.new
+    #   theme = parser.parse(theme_xml_content)
+    #   puts theme.name
+    #   puts theme.color_scheme.colors[:accent1]
+    class ThemeXmlParser
+      # DrawingML namespace used in theme XML
+      THEME_NS = {
+        'a' => 'http://schemas.openxmlformats.org/drawingml/2006/main'
+      }.freeze
+
+      # Parse theme1.xml into Theme model
+      #
+      # @param xml [String] Theme XML content
+      # @return [Theme] Parsed theme
+      # @raise [ArgumentError] if XML is invalid or missing theme element
+      def parse(xml)
+        doc = Nokogiri::XML(xml)
+        theme_node = doc.at_xpath('//a:theme', THEME_NS)
+
+        raise ArgumentError, 'Invalid theme XML: missing theme element' unless theme_node
+
+        theme = ::Uniword::Drawingml::Theme.new
+        theme.name = theme_node['name'] || 'Untitled Theme'
+
+        # Create theme_elements if not exists
+        theme.theme_elements ||= ::Uniword::Drawingml::ThemeElements.new
+
+        # Parse color scheme
+        color_scheme_node = doc.at_xpath('//a:themeElements/a:clrScheme', THEME_NS)
+        if color_scheme_node
+          scheme = parse_color_scheme(color_scheme_node)
+          theme.theme_elements.clr_scheme = scheme
+        end
+
+        # Parse font scheme
+        font_scheme_node = doc.at_xpath('//a:themeElements/a:fontScheme', THEME_NS)
+        if font_scheme_node
+          scheme = parse_font_scheme(font_scheme_node)
+          theme.theme_elements.font_scheme = scheme
+        end
+
+        theme
+      end
+
+      private
+
+      # Parse color scheme from XML
+      #
+      # @param node [Nokogiri::XML::Element] Color scheme node
+      # @return [ColorScheme] Parsed color scheme
+      def parse_color_scheme(node)
+        scheme = ColorScheme.new
+        scheme.name = node['name'] || 'Color Scheme'
+
+        # Parse each of the 12 standard theme colors
+        ColorScheme::THEME_COLORS.each do |color_name|
+          color_node = node.at_xpath("a:#{color_name}", THEME_NS)
+          next unless color_node
+
+          # Extract color information
+          color_obj = extract_color_object(color_node, color_name)
+
+          # Set the color using the appropriate attribute
+          attr_name = color_name == 'folHlink' ? :fol_hlink : color_name.to_sym
+          scheme.instance_variable_set("@#{attr_name}", color_obj)
+        end
+
+        # Sync hash interface
+        scheme.sync_colors_hash
+
+        scheme
+      end
+
+      # Extract color object with proper class
+      def extract_color_object(node, color_name)
+        # Determine the color class
+        color_class = case color_name
+                      when 'dk1' then Uniword::Dk1Color
+                      when 'lt1' then Uniword::Lt1Color
+                      when 'dk2' then Uniword::Dk2Color
+                      when 'lt2' then Uniword::Lt2Color
+                      when 'accent1' then Uniword::Accent1Color
+                      when 'accent2' then Uniword::Accent2Color
+                      when 'accent3' then Uniword::Accent3Color
+                      when 'accent4' then Uniword::Accent4Color
+                      when 'accent5' then Uniword::Accent5Color
+                      when 'accent6' then Uniword::Accent6Color
+                      when 'hlink' then Uniword::HlinkColor
+                      when 'folHlink' then Uniword::FolHlinkColor
+                      else Uniword::Dk1Color
+                      end
+
+        # Check for srgbClr first
+        srgb_node = node.at_xpath('.//a:srgbClr', THEME_NS)
+        if srgb_node
+          color_obj = color_class.new
+          color_obj.srgb_clr = Uniword::SrgbColor.new(val: srgb_node['val'])
+          color_obj.sys_clr = nil # Explicitly clear sys_clr
+          return color_obj
+        end
+
+        # Check for sysClr
+        sys_node = node.at_xpath('.//a:sysClr', THEME_NS)
+        if sys_node
+          color_obj = color_class.new
+          color_obj.sys_clr = Uniword::SysColor.new(
+            val: sys_node['val'],
+            last_clr: sys_node['lastClr']
+          )
+          color_obj.srgb_clr = nil # Explicitly clear srgb_clr
+          return color_obj
+        end
+
+        # Default - create with srgbClr
+        color_class.new
+      end
+
+      # Extract color value from color node
+      #
+      # Handles multiple color representation types:
+      # - srgbClr: RGB color (most common)
+      # - sysClr: System color with last known value
+      # - schemeClr: Reference to another theme color
+      # - prstClr: Preset color name
+      #
+      # @param node [Nokogiri::XML::Element] Color node
+      # @return [String, nil] RGB hex value (6 characters, no #)
+      def extract_color_value(node)
+        # Try sRGB color first (direct RGB value)
+        srgb_node = node.at_xpath('.//a:srgbClr', THEME_NS)
+        return srgb_node['val'] if srgb_node
+
+        # Try system color (use last known color value)
+        sys_node = node.at_xpath('.//a:sysClr', THEME_NS)
+        return sys_node['lastClr'] if sys_node
+
+        # Try preset color (named color)
+        prst_node = node.at_xpath('.//a:prstClr', THEME_NS)
+        return convert_preset_color(prst_node['val']) if prst_node
+
+        # Scheme color references would need color resolution
+        # For now, return nil and let default colors be used
+        nil
+      end
+
+      # Convert preset color name to RGB hex
+      #
+      # @param color_name [String] Preset color name
+      # @return [String] RGB hex value
+      def convert_preset_color(color_name)
+        # Common preset colors - expand as needed
+        preset_colors = {
+          'black' => '000000',
+          'white' => 'FFFFFF',
+          'red' => 'FF0000',
+          'green' => '00FF00',
+          'blue' => '0000FF',
+          'yellow' => 'FFFF00',
+          'magenta' => 'FF00FF',
+          'cyan' => '00FFFF'
+        }
+
+        preset_colors[color_name.downcase] || '000000'
+      end
+
+      # Parse font scheme from XML
+      #
+      # @param node [Nokogiri::XML::Element] Font scheme node
+      # @return [FontScheme] Parsed font scheme
+      def parse_font_scheme(node)
+        scheme = FontScheme.new
+        scheme.name = node['name'] || 'Font Scheme'
+
+        # Parse major font
+        major_font_node = node.at_xpath('a:majorFont', THEME_NS)
+        scheme.major_font_obj = parse_font_container(major_font_node, :major) if major_font_node
+
+        # Parse minor font
+        minor_font_node = node.at_xpath('a:minorFont', THEME_NS)
+        scheme.minor_font_obj = parse_font_container(minor_font_node, :minor) if minor_font_node
+
+        scheme
+      end
+
+      # Parse major or minor font container
+      def parse_font_container(node, type)
+        container = type == :major ? Uniword::MajorFont.new : Uniword::MinorFont.new
+
+        # Parse latin font
+        latin_node = node.at_xpath('a:latin', THEME_NS)
+        if latin_node
+          container.latin = Uniword::LatinFont.new(
+            typeface: latin_node['typeface'] || '',
+            panose: latin_node['panose']
+          )
+        end
+
+        # Parse ea font
+        ea_node = node.at_xpath('a:ea', THEME_NS)
+        if ea_node
+          container.ea = Uniword::EaFont.new(
+            typeface: ea_node['typeface'] || ''
+          )
+        end
+
+        # Parse cs font
+        cs_node = node.at_xpath('a:cs', THEME_NS)
+        if cs_node
+          container.cs = Uniword::CsFont.new(
+            typeface: cs_node['typeface'] || ''
+          )
+        end
+
+        # Parse script-specific fonts
+        font_nodes = node.xpath('a:font', THEME_NS)
+        container.fonts = font_nodes.map do |font_node|
+          Uniword::ScriptFont.new(
+            script: font_node['script'] || '',
+            typeface: font_node['typeface'] || ''
+          )
+        end
+
+        container
+      end
+    end
+  end
+end

data/lib/uniword/theme_writer.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module Uniword
+  # Writer for saving Theme instances to files.
+  #
+  # Responsibility: Handle theme file writing operations.
+  # Follows Single Responsibility Principle - separated from Theme class.
+  #
+  # @example Save theme to .thmx file
+  #   writer = ThemeWriter.new(theme)
+  #   writer.save('output.thmx')
+  #
+  # @example Save with explicit format
+  #   writer = ThemeWriter.new(theme)
+  #   writer.save('output.thmx', format: :thmx)
+  class ThemeWriter
+    attr_reader :theme
+
+    # Initialize writer with a theme.
+    #
+    # @param theme [Theme] The theme to write
+    def initialize(theme)
+      @theme = theme
+    end
+
+    # Save theme to file.
+    #
+    # @param path [String] Output path
+    # @param format [Symbol] Format to save as (:auto, :thmx)
+    # @return [void]
+    def save(path, format: :auto)
+      format = infer_format(path) if format == :auto
+
+      case format
+      when :thmx
+        Ooxml::ThmxPackage.to_file(theme, path)
+      else
+        raise ArgumentError, "Unsupported format for theme: #{format}"
+      end
+    end
+
+    private
+
+    # Infer format from file extension.
+    #
+    # @param path [String] File path
+    # @return [Symbol] Inferred format
+    def infer_format(path)
+      extension = File.extname(path).downcase
+      case extension
+      when '.thmx'
+        :thmx
+      else
+        raise ArgumentError, "Cannot infer theme format from: #{extension}"
+      end
+    end
+  end
+end