uniword 1.0.0

data/lib/uniword/resource/cache_version.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require 'json'
+
+module Uniword
+  module Resource
+    # MODEL for cache version tracking
+    # Has state (cache reference) and behavior (check staleness, update)
+    #
+    # Does NOT extend Lutaml::Model::Serializable.
+    class CacheVersion
+      attr_reader :cache
+
+      def initialize(cache)
+        @cache = cache
+      end
+
+      # Get cached Word version
+      def cached_version
+        return nil unless File.exist?(cache.paths.version_file)
+
+        JSON.parse(File.read(cache.paths.version_file))['word_version']
+      rescue JSON::ParserError
+        nil
+      end
+
+      # Update cached version
+      def update(word_version)
+        cache.paths.ensure_directories_exist!
+        File.write(cache.paths.version_file, JSON.generate(word_version: word_version))
+      end
+
+      # Check if cache is stale (Word was updated)
+      def stale?(current_word_version)
+        cached_version != current_word_version
+      end
+
+      # Check if cache exists
+      def exists?
+        File.exist?(cache.paths.version_file)
+      end
+
+      # Delete version file
+      def delete
+        FileUtils.rm_f(cache.paths.version_file)
+      end
+    end
+  end
+end

data/lib/uniword/resource/color_transformer.rb

@@ -0,0 +1,134 @@
+# frozen_string_literal: true
+
+module Uniword
+  module Resource
+    # SERVICE for color transformations
+    # Pure functions - no state, no side effects
+    class ColorTransformer
+      # Shift ranges (in HSL)
+      HUE_SHIFT_RANGE = (-15..15)
+      SATURATION_SHIFT_RANGE = (-10..10)
+      LIGHTNESS_SHIFT_RANGE = (-10..10)
+
+      # Transform a hex color by shifting HSL values
+      #
+      # @param hex_color [String] Hex color code (e.g., "#FF0000" or "FF0000")
+      # @param hue_shift [Integer] Hue shift in degrees (-15..15)
+      # @param saturation_shift [Integer] Saturation shift percent (-10..10)
+      # @param lightness_shift [Integer] Lightness shift percent (-10..10)
+      # @return [String] Transformed hex color
+      def self.shift_color(hex_color, hue_shift:, saturation_shift:, lightness_shift:)
+        return hex_color if hue_shift.zero? && saturation_shift.zero? && lightness_shift.zero?
+
+        rgb = hex_to_rgb(hex_color)
+        hsl = rgb_to_hsl(rgb)
+
+        # Apply shifts with clamping
+        hsl[:h] = (hsl[:h] + hue_shift) % 360
+        hsl[:s] = (hsl[:s] + saturation_shift).clamp(0, 100)
+        hsl[:l] = (hsl[:l] + lightness_shift).clamp(0, 100)
+
+        rgb_to_hex(hsl_to_rgb(hsl))
+      end
+
+      # Transform all colors in a color scheme
+      #
+      # @param color_scheme [Themes::ColorScheme] Color scheme to transform
+      # @param hue_shift [Integer] Hue shift in degrees
+      # @param saturation_shift [Integer] Saturation shift percent
+      # @param lightness_shift [Integer] Lightness shift percent
+      # @return [Themes::ColorScheme] Transformed color scheme
+      def self.transform_color_scheme(color_scheme, hue_shift:, saturation_shift:, lightness_shift:)
+        color_scheme.dup.tap do |scheme|
+          # Transform each color in the scheme
+          scheme.colors&.each_value do |color|
+            next unless color.respond_to?(:val) && color.val&.match?(/^[0-9A-Fa-f]{6}$/)
+
+            color.val = shift_color(
+              color.val,
+              hue_shift:,
+              saturation_shift:,
+              lightness_shift:
+            )
+          end
+        end
+      end
+
+      # Convert hex color to RGB hash
+      #
+      # @param hex [String] Hex color code
+      # @return [Hash] RGB hash with :r, :g, :b keys
+      def self.hex_to_rgb(hex)
+        hex = hex.sub(/^#/, '')
+        { r: hex[0..1].to_i(16), g: hex[2..3].to_i(16), b: hex[4..5].to_i(16) }
+      end
+
+      # Convert RGB hash to hex color
+      #
+      # @param rgb [Hash] RGB hash with :r, :g, :b keys
+      # @return [String] Hex color code with # prefix
+      def self.rgb_to_hex(rgb)
+        format('#%02X%02X%02X', rgb[:r], rgb[:g], rgb[:b])
+      end
+
+      # Convert RGB to HSL
+      #
+      # @param rgb [Hash] RGB hash with :r, :g, :b keys (0-255)
+      # @return [Hash] HSL hash with :h (0-360), :s (0-100), :l (0-100)
+      def self.rgb_to_hsl(rgb)
+        r = rgb[:r] / 255.0
+        g = rgb[:g] / 255.0
+        b = rgb[:b] / 255.0
+        max = [r, g, b].max
+        min = [r, g, b].min
+        l = (max + min) / 2.0
+
+        if max == min
+          h = s = 0
+        else
+          d = max - min
+          s = l > 0.5 ? d / (2 - max - min) : d / (max + min)
+          h = case max
+              when r then (((g - b) / d) + (g < b ? 6 : 0)) * 60
+              when g then (((b - r) / d) + 2) * 60
+              when b then (((r - g) / d) + 4) * 60
+              end
+        end
+
+        { h: h.round, s: (s * 100).round, l: (l * 100).round }
+      end
+
+      # Convert HSL to RGB
+      #
+      # @param hsl [Hash] HSL hash with :h (0-360), :s (0-100), :l (0-100)
+      # @return [Hash] RGB hash with :r, :g, :b keys (0-255)
+      def self.hsl_to_rgb(hsl)
+        h = hsl[:h]
+        s = hsl[:s] / 100.0
+        l = hsl[:l] / 100.0
+
+        if s.zero?
+          r = g = b = l
+        else
+          hue_to_rgb = lambda do |p, q, t|
+            t += 1 if t.negative?
+            t -= 1 if t > 1
+            return p + ((q - p) * 6 * t) if t < 1 / 6.0
+            return q if t < 1 / 2.0
+            return p + ((q - p) * ((2 / 3.0) - t) * 6) if t < 2 / 3.0
+
+            p
+          end
+
+          q = l < 0.5 ? l * (1 + s) : l + s - (l * s)
+          p = (2 * l) - q
+          r = hue_to_rgb.call(p, q, (h / 360.0) + (1 / 3.0))
+          g = hue_to_rgb.call(p, q, h / 360.0)
+          b = hue_to_rgb.call(p, q, (h / 360.0) - (1 / 3.0))
+        end
+
+        { r: (r * 255).round, g: (g * 255).round, b: (b * 255).round }
+      end
+    end
+  end
+end

data/lib/uniword/resource/font_substitutor.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module Uniword
+  module Resource
+    # SERVICE for font substitution
+    # Pure functions - no state, no side effects
+    class FontSubstitutor
+      # Font substitution map (MS fonts -> open-source alternatives)
+      SUBSTITUTIONS = {
+        'Calibri' => 'Carlito',
+        'Calibri Light' => 'Carlito',
+        'Cambria' => 'Caladea',
+        'Cambria Math' => 'Caladea',
+        'Arial' => 'Liberation Sans',
+        'Times New Roman' => 'Liberation Serif',
+        'Courier New' => 'Liberation Mono',
+        'Segoe UI' => 'Source Sans Pro',
+        'Tahoma' => 'Liberation Sans'
+      }.freeze
+
+      # Get substitute font name
+      #
+      # @param font_name [String] Original font name
+      # @return [String] Substituted font name or original if no substitution
+      def self.substitute(font_name)
+        SUBSTITUTIONS[font_name] || font_name
+      end
+
+      # Transform font scheme with substitutions
+      #
+      # @param font_scheme [Drawingml::FontScheme] Font scheme to transform
+      # @return [Drawingml::FontScheme] Transformed font scheme
+      def self.transform_font_scheme(font_scheme)
+        font_scheme.dup.tap do |scheme|
+          # Transform major font
+          if scheme.major_font_obj&.latin
+            scheme.major_font_obj.latin.typeface = substitute(scheme.major_font_obj.latin.typeface)
+          end
+
+          # Transform minor font
+          if scheme.minor_font_obj&.latin
+            scheme.minor_font_obj.latin.typeface = substitute(scheme.minor_font_obj.latin.typeface)
+          end
+        end
+      end
+
+      # Check font availability via Fontist
+      #
+      # @param font_name [String] Font name to check
+      # @return [Boolean] true if font is available or Fontist is not installed
+      def self.check_availability(font_name)
+        return true unless defined?(Fontist)
+
+        Fontist.available?(font_name)
+      rescue StandardError
+        false
+      end
+    end
+  end
+end

data/lib/uniword/resource/importer.rb

@@ -0,0 +1,114 @@
+# frozen_string_literal: true
+
+module Uniword
+  module Resource
+    # MODEL for importing resources from Word or files
+    #
+    # Has state (word/cache references) and behavior (import_one, import_all)
+    # Does NOT extend Lutaml::Model::Serializable
+    class Importer
+      attr_reader :word, :cache
+
+      # Initialize importer with dependencies
+      #
+      # @param word [WordImplementation] Word implementation instance
+      # @param cache [Cache] Cache instance
+      def initialize(word, cache)
+        @word = word
+        @cache = cache
+      end
+
+      # Import a single resource by name
+      #
+      # @param type [Symbol] Resource type (:theme, :styleset, :color_scheme, :font_scheme)
+      # @param name [String] Resource name
+      # @return [Object] The imported resource
+      # @raise [ArgumentError] if Word not installed or resource not found
+      def import_one(type, name)
+        raise ArgumentError, 'Microsoft Word is not installed' unless word.installed?
+
+        resource = load_from_word(type, name)
+        cache.write(type, name, resource.to_yaml)
+        resource
+      end
+
+      # Import all resources of a type
+      #
+      # @param type [Symbol] Resource type
+      # @param force [Boolean] Overwrite existing cache entries
+      # @return [Integer] Number of resources imported
+      def import_all_of_type(type, force: false)
+        raise ArgumentError, 'Microsoft Word is not installed' unless word.installed?
+
+        available = available_resources(type)
+        count = 0
+
+        available.each do |name|
+          next if !force && cache.exists?(type, name)
+
+          begin
+            import_one(type, name)
+            count += 1
+          rescue StandardError => e
+            warn "Failed to import #{type} '#{name}': #{e.message}"
+          end
+        end
+
+        count
+      end
+
+      # Import all resources from Word
+      #
+      # @param force [Boolean] Overwrite existing cache entries
+      # @return [Hash] Count of imported resources by type
+      def import_all(force: false)
+        result = {}
+
+        %i[theme styleset].each do |type|
+          result[type] = import_all_of_type(type, force: force)
+        end
+
+        result
+      end
+
+      private
+
+      # Load resource from Word installation
+      #
+      # @param type [Symbol] Resource type
+      # @param name [String] Resource name
+      # @return [Object] Loaded resource
+      def load_from_word(type, name)
+        case type
+        when :theme
+          path = File.join(word.themes_path, "#{name}.thmx")
+          raise ArgumentError, "Theme not found: #{name}" unless File.exist?(path)
+
+          Uniword::Ooxml::ThmxPackage.from_file(path)&.theme
+        when :styleset
+          path = File.join(word.stylesets_path, "#{name}.dotx")
+          raise ArgumentError, "StyleSet not found: #{name}" unless File.exist?(path)
+
+          Uniword::Ooxml::DotxPackage.from_file(path)&.styles_configuration
+        else
+          raise ArgumentError, "Unsupported resource type: #{type}"
+        end
+      end
+
+      # Get list of available resources from Word
+      #
+      # @param type [Symbol] Resource type
+      # @return [Array<String>] Available resource names
+      def available_resources(type)
+        case type
+        when :theme
+          word.available_themes
+        when :styleset
+          word.available_stylesets
+        else
+          []
+        end
+      end
+    end
+  end
+end

data/lib/uniword/resource/resource_location.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Uniword
+  module Resource
+    # Immutable value object for resource location
+    # Does NOT extend Lutaml::Model::Serializable - this is a value object
+    ResourceLocation = Struct.new(:type, :name, :source, :path) do
+      # Check if location is readable
+      def exists?
+        File.exist?(path)
+      end
+
+      # Read content
+      def read
+        File.read(path) if exists?
+      end
+
+      # Factory from path
+      def self.from_path(type, path)
+        name = File.basename(path, '.*')
+        source = determine_source(path)
+        new(type, name, source, path)
+      end
+
+      def self.determine_source(path)
+        case path
+        when %r{/\.uniword/} then :cached
+        when %r{/data-private/} then :private
+        when %r{/data/} then :bundled
+        else :unknown
+        end
+      end
+    end
+  end
+end

data/lib/uniword/resource/resource_resolver.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+module Uniword
+  module Resource
+    # MODEL for resolving resources from multiple sources
+    # Has state (cache reference) and behavior (resolve, list)
+    #
+    # Does NOT extend Lutaml::Model::Serializable.
+    class ResourceResolver
+      # Resolution order: cached -> bundled
+      RESOLUTION_ORDER = %i[cached bundled].freeze
+
+      attr_reader :cache
+
+      def initialize(cache = nil)
+        @cache = cache || Cache.new
+      end
+
+      # Resolve resource by name
+      # Returns ResourceLocation or nil if not found
+      def resolve(type, name)
+        RESOLUTION_ORDER.each do |source|
+          location = location_for_source(type, name, source)
+          return location if location&.exists?
+        end
+        nil
+      end
+
+      # Check if resource exists in any source
+      def exists?(type, name)
+        resolve(type, name)&.exists? || false
+      end
+
+      # List all available resources from all sources
+      def list_all(type)
+        (list_cached(type) + list_bundled(type)).sort.uniq
+      end
+
+      # List resources from specific source
+      def list(type, source: :all)
+        case source
+        when :cached then list_cached(type)
+        when :bundled then list_bundled(type)
+        else list_all(type)
+        end
+      end
+
+      private
+
+      def location_for_source(type, name, source)
+        case source
+        when :cached
+          path = File.join(cache_directory_for_type(type), "#{name}.yml")
+          ResourceLocation.new(type, name, :cached, path)
+        when :bundled
+          path = File.join(bundled_directory_for_type(type), "#{name}.yml")
+          ResourceLocation.new(type, name, :bundled, path)
+        end
+      end
+
+      def list_cached(type)
+        cache.list(type)
+      end
+
+      def list_bundled(type)
+        dir = bundled_directory_for_type(type)
+        return [] unless File.directory?(dir)
+
+        Dir.glob(File.join(dir, '*.yml')).map { |f| File.basename(f, '.yml') }
+      end
+
+      def cache_directory_for_type(type)
+        case type
+        when :theme then cache.paths.themes
+        when :styleset then cache.paths.stylesets
+        when :color_scheme then cache.paths.color_schemes
+        when :font_scheme then cache.paths.font_schemes
+        else raise ArgumentError, "Unknown resource type: #{type}"
+        end
+      end
+
+      def bundled_directory_for_type(type)
+        case type
+        when :theme then bundled_path('themes')
+        when :styleset then bundled_path('stylesets')
+        when :color_scheme then bundled_path('color_schemes')
+        when :font_scheme then bundled_path('font_schemes')
+        else raise ArgumentError, "Unknown resource type: #{type}"
+        end
+      end
+
+      def bundled_path(subdir)
+        # Use Gem.datadir if available, otherwise fall back to data/ directory
+        data_path = (Gem.datadir('uniword') if defined?(Gem) && Gem.respond_to?(:datadir))
+        data_path ||= File.expand_path('../../../data', __dir__)
+        File.join(data_path, subdir)
+      end
+    end
+  end
+end

data/lib/uniword/resource/theme_processor.rb

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+require 'digest'
+
+module Uniword
+  module Resource
+    # MODEL for processing themes into copyright-free variants
+    # Has state (shift values) and behavior (process)
+    class ThemeProcessor
+      attr_reader :hue_shift, :saturation_shift, :lightness_shift
+
+      # Shift ranges for random generation
+      HUE_SHIFT_RANGE = (-10..10)
+      SATURATION_SHIFT_RANGE = (-5..5)
+      LIGHTNESS_SHIFT_RANGE = (-5..5)
+
+      # Create processor with optional shift values
+      #
+      # @param hue_shift [Integer, nil] Hue shift in degrees (random if nil)
+      # @param saturation_shift [Integer, nil] Saturation shift percent (random if nil)
+      # @param lightness_shift [Integer, nil] Lightness shift percent (random if nil)
+      def initialize(hue_shift: nil, saturation_shift: nil, lightness_shift: nil)
+        @hue_shift = hue_shift || rand(HUE_SHIFT_RANGE)
+        @saturation_shift = saturation_shift || rand(SATURATION_SHIFT_RANGE)
+        @lightness_shift = lightness_shift || rand(LIGHTNESS_SHIFT_RANGE)
+      end
+
+      # Create deterministic processor from seed string
+      #
+      # @param seed [String] Seed string for deterministic shift generation
+      # @return [ThemeProcessor] Processor with deterministic shift values
+      def self.from_seed(seed)
+        hash = Digest::SHA256.hexdigest(seed)
+
+        # Use first 24 hex chars (6 bytes each) for shift values
+        hue_shift = (hash[0, 6].to_i(16) % 21) - 10 # -10..10
+        saturation_shift = (hash[6, 6].to_i(16) % 11) - 5  # -5..5
+        lightness_shift = (hash[12, 6].to_i(16) % 11) - 5  # -5..5
+
+        new(
+          hue_shift: hue_shift,
+          saturation_shift: saturation_shift,
+          lightness_shift: lightness_shift
+        )
+      end
+
+      # Create identity processor (no transformations)
+      #
+      # @return [ThemeProcessor] Processor with zero shifts
+      def self.identity
+        new(hue_shift: 0, saturation_shift: 0, lightness_shift: 0)
+      end
+
+      # Check if this processor is an identity (no-op)
+      #
+      # @return [Boolean] true if all shifts are zero
+      def identity?
+        hue_shift.zero? && saturation_shift.zero? && lightness_shift.zero?
+      end
+
+      # Process a theme into a copyright-free variant
+      #
+      # @param theme [Drawingml::Theme] Theme to process
+      # @return [Drawingml::Theme] Processed theme with shifted colors and substituted fonts
+      def process(theme)
+        theme.dup.tap do |processed|
+          # Transform color scheme
+          if processed.theme_elements&.clr_scheme
+            transform_color_scheme(processed.theme_elements.clr_scheme)
+          end
+
+          # Transform font scheme
+          if processed.theme_elements&.font_scheme
+            FontSubstitutor.transform_font_scheme(processed.theme_elements.font_scheme)
+          end
+
+          # Update name to indicate it's a Uniword variant
+          processed.name = "#{theme.name} (Uniword)"
+        end
+      end
+
+      private
+
+      # Transform color scheme by shifting all colors
+      #
+      # @param color_scheme [Drawingml::ColorScheme] Color scheme to transform
+      def transform_color_scheme(color_scheme)
+        # Get all color attributes that respond to srgb_clr
+        color_attrs = %i[dk1 lt1 dk2 lt2 accent1 accent2 accent3 accent4 accent5 accent6 hlink
+                         fol_hlink]
+
+        color_attrs.each do |attr|
+          color_obj = color_scheme.send(attr)
+          next unless color_obj&.srgb_clr&.val
+
+          original = color_obj.srgb_clr.val
+          color_obj.srgb_clr.val = ColorTransformer.shift_color(
+            original,
+            hue_shift: hue_shift,
+            saturation_shift: saturation_shift,
+            lightness_shift: lightness_shift
+          )
+        end
+      end
+    end
+  end
+end

data/lib/uniword/resource.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Uniword
+  module Resource
+    # SERVICES (stateless pure functions)
+    autoload :ColorTransformer, "#{__dir__}/resource/color_transformer"
+    autoload :FontSubstitutor, "#{__dir__}/resource/font_substitutor"
+
+    # MODELS (have state + behavior)
+    autoload :ThemeProcessor, "#{__dir__}/resource/theme_processor"
+    autoload :Cache, "#{__dir__}/resource/cache"
+    autoload :CacheVersion, "#{__dir__}/resource/cache_version"
+    autoload :ResourceResolver, "#{__dir__}/resource/resource_resolver"
+
+    # VALUE OBJECTS (immutable structs)
+    autoload :CachePaths, "#{__dir__}/resource/cache_paths"
+    autoload :ResourceLocation, "#{__dir__}/resource/resource_location"
+  end
+end