uniword 1.0.0

data/lib/uniword/themes/theme.rb

@@ -0,0 +1,159 @@
+# frozen_string_literal: true
+
+module Uniword
+  module Themes
+    # Friendly Color Scheme - simplified color model
+    #
+    # Represents colors as simple hex values, abstracting away OOXML complexity.
+    #
+    # @example
+    #   scheme = ColorScheme.new(
+    #     name: 'Atlas',
+    #     colors: {
+    #       accent1: 'F81B02',
+    #       dk1: '000000',
+    #       lt1: 'FFFFFF'
+    #     }
+    #   )
+    class ColorScheme < Lutaml::Model::Serializable
+      attribute :name, :string
+      attribute :colors, :hash
+
+      yaml do
+        map 'name', to: :name
+        map 'colors', to: :colors
+      end
+
+      # Key name aliases (maps snake_case to camelCase)
+      KEY_ALIASES = {
+        fol_hlink: 'folHlink'
+      }.freeze
+
+      # Convenience accessor for colors hash
+      # Handles both snake_case (:fol_hlink) and camelCase ('folHlink') keys
+      #
+      # @param key [Symbol, String] Color key (:dk1, :lt1, :accent1, etc.)
+      # @return [String, nil] Hex color value or nil
+      def [](key)
+        key_str = key.to_s
+        # Try exact match first
+        result = colors&.[](key.to_sym) || colors&.[](key_str)
+        return result if result
+
+        # Try alias mapping
+        if (aliased = KEY_ALIASES[key.to_sym])
+          colors&.[](aliased.to_sym) || colors&.[](aliased)
+        end
+      end
+
+      # Convenience setter for colors hash
+      #
+      # @param key [Symbol] Color key
+      # @param value [String] Hex color value
+      def []=(key, value)
+        self.colors ||= {}
+        colors[key.to_sym] = value
+      end
+    end
+
+    # Friendly Font Scheme - simplified font model
+    #
+    # Represents fonts as simple typeface names, abstracting away OOXML complexity.
+    #
+    # @example
+    #   scheme = FontScheme.new(
+    #     name: 'Atlas',
+    #     major_font: 'Calibri Light',
+    #     minor_font: 'Calibri'
+    #   )
+    class FontScheme < Lutaml::Model::Serializable
+      attribute :name, :string
+      attribute :major_font, :string
+      attribute :minor_font, :string
+      attribute :major_east_asian, :string
+      attribute :major_complex_script, :string
+      attribute :minor_east_asian, :string
+      attribute :minor_complex_script, :string
+
+      yaml do
+        map 'name', to: :name
+        map 'major_font', to: :major_font
+        map 'minor_font', to: :minor_font
+        map 'major_east_asian', to: :major_east_asian
+        map 'major_complex_script', to: :major_complex_script
+        map 'minor_east_asian', to: :minor_east_asian
+        map 'minor_complex_script', to: :minor_complex_script
+      end
+    end
+
+    # Friendly Theme Model - implementation-independent, human-editable
+    #
+    # This model provides a simplified, human-friendly YAML schema for themes.
+    # It is intentionally independent of OOXML structure, making it easy to
+    # author and edit by hand.
+    #
+    # For Word document generation, convert to Drawingml::Theme using
+    # ThemeTransformation.to_word_theme(friendly_theme).
+    #
+    # @example Load from YAML
+    #   theme = Theme.from_yaml(File.read('atlas.yml'))
+    #
+    # @example Convert to Word Theme
+    #   transformation = ThemeTransformation.new
+    #   word_theme = transformation.to_word(theme)
+    #
+    # @example Create from Word Theme
+    #   friendly = transformation.from_word(word_theme)
+    class Theme < Lutaml::Model::Serializable
+      attribute :name, :string
+      attribute :source, :string
+      attribute :imported_at, :date_time
+      attribute :color_scheme, ColorScheme
+      attribute :font_scheme, FontScheme
+      attribute :variants, :hash
+
+      yaml do
+        map 'name', to: :name
+        map 'source', to: :source
+        map 'imported_at', to: :imported_at
+        map 'color_scheme', to: :color_scheme
+        map 'font_scheme', to: :font_scheme
+        map 'variants', to: :variants
+      end
+
+      # Load a bundled theme by name
+      #
+      # @param name [String] Theme name (e.g., 'atlas', 'badge')
+      # @return [Theme] Loaded theme
+      # @raise [ArgumentError] if theme not found
+      def self.load(name)
+        path = File.join(__dir__, '../../../data/themes', "#{name}.yml")
+        unless File.exist?(path)
+          raise ArgumentError,
+                "Theme '#{name}' not found. Available: #{available_themes.join(', ')}"
+        end
+
+        from_yaml(File.read(path))
+      end
+
+      # List all available bundled themes
+      #
+      # @return [Array<String>] Theme names
+      def self.available_themes
+        theme_dir = File.join(__dir__, '../../../data/themes')
+        return [] unless Dir.exist?(theme_dir)
+
+        Dir.glob(File.join(theme_dir, '*.yml'))
+           .map { |p| File.basename(p, '.yml') }
+           .sort
+      end
+
+      # Convert to Word Theme for document generation
+      #
+      # @return [Drawingml::Theme] Word/OOXML theme
+      def to_word_theme
+        ThemeTransformation.new.to_word(self)
+      end
+    end
+  end
+end

data/lib/uniword/themes/theme_importer.rb

@@ -0,0 +1,138 @@
+# frozen_string_literal: true
+
+require 'yaml'
+require 'fileutils'
+
+module Uniword
+  module Themes
+    # Imports .thmx theme files and converts them to YAML format
+    #
+    # Provides functionality to convert Office theme packages to
+    # human-readable YAML files that can be bundled with the gem.
+    #
+    # @example Import single theme
+    #   importer = ThemeImporter.new
+    #   importer.import('Atlas.thmx', 'data/themes/atlas.yml')
+    #
+    # @example Import all themes from directory
+    #   importer = ThemeImporter.new
+    #   importer.import_all('themes/', 'data/themes/')
+    class ThemeImporter
+      # Import .thmx file to YAML
+      #
+      # @param thmx_path [String] Path to .thmx file
+      # @param output_path [String] Output YAML path
+      # @return [void]
+      def import(thmx_path, output_path)
+        # Load theme using existing ThemeLoader
+        loader = Themes::ThemeLoader.new
+        theme = loader.load(thmx_path)
+
+        # Convert to YAML-friendly hash
+        theme_data = serialize_theme(theme, thmx_path)
+
+        # Ensure output directory exists
+        FileUtils.mkdir_p(File.dirname(output_path))
+
+        # Write YAML file
+        File.write(output_path, YAML.dump(theme_data))
+      end
+
+      # Import all themes from directory
+      #
+      # @param source_dir [String] Directory with .thmx files
+      # @param output_dir [String] Output directory for YAML files
+      # @return [Integer] Number of themes imported
+      def import_all(source_dir, output_dir)
+        count = 0
+
+        Dir.glob(File.join(source_dir, '*.thmx')).each do |thmx_file|
+          theme_name = theme_name_from_file(thmx_file)
+          output_file = File.join(output_dir, "#{theme_name}.yml")
+
+          puts "Importing #{File.basename(thmx_file)} -> #{File.basename(output_file)}"
+          import(thmx_file, output_file)
+          count += 1
+        end
+
+        count
+      end
+
+      private
+
+      # Serialize theme to hash for YAML export
+      #
+      # @param theme [Theme] Theme to serialize
+      # @param source_file [String] Original .thmx file path
+      # @return [Hash] YAML-ready hash
+      def serialize_theme(theme, source_file)
+        {
+          'name' => theme.name,
+          'source' => File.basename(source_file),
+          'imported_at' => Time.now.utc.iso8601,
+          'color_scheme' => serialize_color_scheme(theme.color_scheme),
+          'font_scheme' => serialize_font_scheme(theme.font_scheme),
+          'variants' => serialize_variants(theme.variants)
+        }
+      end
+
+      # Serialize color scheme to hash
+      #
+      # @param color_scheme [ColorScheme] Color scheme to serialize
+      # @return [Hash] YAML-ready hash
+      def serialize_color_scheme(color_scheme)
+        {
+          'name' => color_scheme.name,
+          'colors' => color_scheme.colors.transform_keys(&:to_s).sort.to_h
+        }
+      end
+
+      # Serialize font scheme to hash
+      #
+      # @param font_scheme [FontScheme] Font scheme to serialize
+      # @return [Hash] YAML-ready hash
+      def serialize_font_scheme(font_scheme)
+        {
+          'name' => font_scheme.name,
+          'major_font' => font_scheme.major_font,
+          'minor_font' => font_scheme.minor_font,
+          'major_east_asian' => font_scheme.major_east_asian,
+          'major_complex_script' => font_scheme.major_complex_script,
+          'minor_east_asian' => font_scheme.minor_east_asian,
+          'minor_complex_script' => font_scheme.minor_complex_script
+        }
+      end
+
+      # Serialize variants to hash
+      #
+      # @param variants [Hash] Hash of variant_id => ThemeVariant
+      # @return [Hash] YAML-ready hash
+      def serialize_variants(variants)
+        result = {}
+
+        variants.each do |variant_id, variant|
+          # Parse variant theme if not already parsed
+          variant.parse_theme
+
+          result[variant_id] = {
+            'color_scheme' => serialize_color_scheme(variant.theme.color_scheme),
+            'font_scheme' => serialize_font_scheme(variant.theme.font_scheme)
+          }
+        end
+
+        result
+      end
+
+      # Convert file path to theme name for YAML file
+      #
+      # @param path [String] Path to .thmx file
+      # @return [String] Theme name for YAML file
+      def theme_name_from_file(path)
+        File.basename(path, '.thmx')
+            .downcase
+            .gsub(/[^a-z0-9]+/, '_')
+            .gsub(/^_|_$/, '')
+      end
+    end
+  end
+end

data/lib/uniword/themes/theme_transformation.rb

@@ -0,0 +1,202 @@
+# frozen_string_literal: true
+
+module Uniword
+  module Themes
+    # Transforms between FriendlyTheme and WordTheme models.
+    #
+    # This transformation is bidirectional:
+    # - to_word: Themes::Theme → Drawingml::Theme (for document generation)
+    # - from_word: Drawingml::Theme → Themes::Theme (for extraction/editing)
+    #
+    # Architecture:
+    # - Stateless transformation (no instance state)
+    # - Follows Transformation pattern from lutaml-model
+    # - Separates concerns: models own serialization, this class owns conversion
+    #
+    # @example Convert friendly theme to Word theme
+    #   transformation = ThemeTransformation.new
+    #   word_theme = transformation.to_word(friendly_theme)
+    #
+    # @example Extract friendly theme from Word theme
+    #   friendly = transformation.from_word(word_theme)
+    #
+    # @example Full roundtrip
+    #   word_theme = transformation.to_word(friendly)
+    #   extracted = transformation.from_word(word_theme)
+    #   friendly.to_yaml == extracted.to_yaml  # => true (semantically)
+    class ThemeTransformation
+      # Standard color keys in a theme
+      COLOR_KEYS = %i[dk1 lt1 dk2 lt2 accent1 accent2 accent3 accent4 accent5 accent6 hlink
+                      fol_hlink].freeze
+
+      # Transform friendly theme to Word theme
+      #
+      # @param friendly_theme [Themes::Theme] The friendly theme
+      # @return [Drawingml::Theme] The Word theme (OOXML model)
+      def to_word(friendly_theme)
+        Drawingml::Theme.new(
+          name: friendly_theme.name,
+          theme_elements: build_theme_elements(friendly_theme)
+        )
+      end
+
+      # Transform Word theme to friendly theme
+      #
+      # @param word_theme [Drawingml::Theme] The Word theme (OOXML model)
+      # @return [Themes::Theme] The friendly theme
+      def from_word(word_theme)
+        Theme.new(
+          name: word_theme.name,
+          color_scheme: extract_color_scheme(word_theme),
+          font_scheme: extract_font_scheme(word_theme)
+        )
+      end
+
+      private
+
+      # Build OOXML ThemeElements from friendly theme
+      #
+      # @param friendly [Themes::Theme] Friendly theme
+      # @return [Drawingml::ThemeElements] OOXML theme elements
+      def build_theme_elements(friendly)
+        return nil unless friendly
+
+        Drawingml::ThemeElements.new(
+          clr_scheme: build_color_scheme(friendly.color_scheme),
+          font_scheme: build_font_scheme(friendly.font_scheme)
+        )
+      end
+
+      # Build OOXML ColorScheme from friendly color scheme
+      #
+      # @param friendly_colors [Themes::ColorScheme, nil] Friendly color scheme
+      # @return [Drawingml::ColorScheme, nil] OOXML color scheme
+      def build_color_scheme(friendly_colors)
+        return nil unless friendly_colors
+
+        Drawingml::ColorScheme.new(
+          name: friendly_colors.name,
+          dk1: build_color_reference(friendly_colors[:dk1], Drawingml::Dk1Color),
+          lt1: build_color_reference(friendly_colors[:lt1], Drawingml::Lt1Color),
+          dk2: build_color_reference(friendly_colors[:dk2], Drawingml::Dk2Color),
+          lt2: build_color_reference(friendly_colors[:lt2], Drawingml::Lt2Color),
+          accent1: build_color_reference(friendly_colors[:accent1], Drawingml::Accent1Color),
+          accent2: build_color_reference(friendly_colors[:accent2], Drawingml::Accent2Color),
+          accent3: build_color_reference(friendly_colors[:accent3], Drawingml::Accent3Color),
+          accent4: build_color_reference(friendly_colors[:accent4], Drawingml::Accent4Color),
+          accent5: build_color_reference(friendly_colors[:accent5], Drawingml::Accent5Color),
+          accent6: build_color_reference(friendly_colors[:accent6], Drawingml::Accent6Color),
+          hlink: build_color_reference(friendly_colors[:hlink], Drawingml::HlinkColor),
+          fol_hlink: build_color_reference(friendly_colors[:fol_hlink], Drawingml::FolHlinkColor)
+        )
+      end
+
+      # Build OOXML color reference from hex value
+      #
+      # Creates the appropriate color type (Dk1Color, Lt1Color, etc.)
+      # with srgb_clr attribute set
+      #
+      # @param hex [String, nil] Hex color value (e.g., "F81B02")
+      # @param color_class [Class] The specific color class (Dk1Color, Lt1Color, etc.)
+      # @return [Object, nil] Color reference object
+      def build_color_reference(hex, color_class)
+        return nil unless hex
+
+        # Create the color type and use the rgb= helper from ThemeColorBase
+        color_class.new.tap { |c| c.rgb = hex }
+      end
+
+      # Build OOXML FontScheme from friendly font scheme
+      #
+      # @param friendly_fonts [Themes::FontScheme, nil] Friendly font scheme
+      # @return [Drawingml::FontScheme, nil] OOXML font scheme
+      def build_font_scheme(friendly_fonts)
+        return nil unless friendly_fonts
+
+        Drawingml::FontScheme.new(
+          name: friendly_fonts.name,
+          major_font_obj: build_major_font(friendly_fonts),
+          minor_font_obj: build_minor_font(friendly_fonts)
+        )
+      end
+
+      # Build OOXML MajorFont from friendly font scheme
+      #
+      # @param friendly [Themes::FontScheme] Friendly font scheme
+      # @return [Drawingml::MajorFont] OOXML major font
+      def build_major_font(friendly)
+        Drawingml::MajorFont.new(
+          latin: Drawingml::LatinFont.new(typeface: friendly.major_font || ''),
+          ea: Drawingml::EaFont.new(typeface: friendly.major_east_asian || ''),
+          cs: Drawingml::CsFont.new(typeface: friendly.major_complex_script || '')
+        )
+      end
+
+      # Build OOXML MinorFont from friendly font scheme
+      #
+      # @param friendly [Themes::FontScheme] Friendly font scheme
+      # @return [Drawingml::MinorFont] OOXML minor font
+      def build_minor_font(friendly)
+        Drawingml::MinorFont.new(
+          latin: Drawingml::LatinFont.new(typeface: friendly.minor_font || ''),
+          ea: Drawingml::EaFont.new(typeface: friendly.minor_east_asian || ''),
+          cs: Drawingml::CsFont.new(typeface: friendly.minor_complex_script || '')
+        )
+      end
+
+      # Extract friendly color scheme from Word theme
+      #
+      # @param word_theme [Drawingml::Theme] Word theme
+      # @return [Themes::ColorScheme, nil] Friendly color scheme
+      def extract_color_scheme(word_theme)
+        word_colors = word_theme.theme_elements&.clr_scheme
+        return nil unless word_colors
+
+        colors = {}
+        COLOR_KEYS.each do |key|
+          if (color_ref = word_colors.send(key))
+            colors[key] = extract_hex_color(color_ref)
+          end
+        end
+
+        ColorScheme.new(
+          name: word_colors.name,
+          colors: colors
+        )
+      end
+
+      # Extract hex color from OOXML color reference
+      #
+      # @param color_ref [Object] OOXML color reference (Dk1Color, etc.)
+      # @return [String, nil] Hex color value
+      def extract_hex_color(color_ref)
+        return nil unless color_ref.is_a?(Drawingml::ThemeColorBase)
+
+        if color_ref.srgb_clr
+          color_ref.srgb_clr.val
+        elsif color_ref.sys_clr
+          color_ref.sys_clr.val
+        end
+      end
+
+      # Extract friendly font scheme from Word theme
+      #
+      # @param word_theme [Drawingml::Theme] Word theme
+      # @return [Themes::FontScheme, nil] Friendly font scheme
+      def extract_font_scheme(word_theme)
+        word_fonts = word_theme.theme_elements&.font_scheme
+        return nil unless word_fonts
+
+        FontScheme.new(
+          name: word_fonts.name,
+          major_font: word_fonts.major_font_obj&.latin&.typeface,
+          minor_font: word_fonts.minor_font_obj&.latin&.typeface,
+          major_east_asian: word_fonts.major_font_obj&.ea&.typeface,
+          major_complex_script: word_fonts.major_font_obj&.cs&.typeface,
+          minor_east_asian: word_fonts.minor_font_obj&.ea&.typeface,
+          minor_complex_script: word_fonts.minor_font_obj&.cs&.typeface
+        )
+      end
+    end
+  end
+end

data/lib/uniword/themes.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Uniword
+  module Themes
+    # Friendly Theme Model (human-editable)
+    autoload :Theme, "#{__dir__}/themes/theme"
+    autoload :ColorScheme, "#{__dir__}/themes/theme"
+    autoload :FontScheme, "#{__dir__}/themes/theme"
+
+    # Theme loading from .thmx files
+    autoload :ThemeLoader, "#{__dir__}/theme/theme_loader"
+    autoload :ThemePackageReader, "#{__dir__}/theme/theme_package_reader"
+    autoload :ThemeImporter, "#{__dir__}/themes/theme_importer"
+    autoload :ThemeVariant, "#{__dir__}/theme/theme_variant"
+    autoload :MediaFile, "#{__dir__}/theme/media_file"
+
+    # Theme application to documents
+    autoload :ThemeApplicator, "#{__dir__}/theme/theme_applicator"
+
+    # Transformation between Friendly Theme and Word Theme
+    autoload :ThemeTransformation, "#{__dir__}/themes/theme_transformation"
+  end
+end