uniword 1.0.0

data/lib/uniword/warnings/warning_collector.rb

@@ -0,0 +1,229 @@
+# frozen_string_literal: true
+
+module Uniword
+  module Warnings
+    # Collects warnings during document processing.
+    #
+    # Responsibility: Track unsupported elements and features.
+    # Single Responsibility: Only collects warnings.
+    #
+    # This class is used during deserialization to track all unsupported
+    # elements and attributes encountered, allowing users to understand
+    # what features may be lost in round-trip operations.
+    #
+    # External configuration: config/warning_rules.yml
+    #
+    # @example Use during deserialization
+    #   collector = WarningCollector.new
+    #   collector.record_unsupported('chart', context: 'In paragraph 5')
+    #   report = collector.report
+    #   puts report.summary
+    class WarningCollector
+      # @return [Array<Warning>] Collected warnings
+      attr_reader :warnings
+
+      # @return [Hash<String, Integer>] Element occurrence counts
+      attr_reader :element_counts
+
+      # Initialize a new warning collector.
+      #
+      # @param config_file [String] Path to configuration file
+      #
+      # @example Create with default config
+      #   collector = WarningCollector.new
+      #
+      # @example Create with custom config
+      #   collector = WarningCollector.new(
+      #     config_file: 'custom_warnings.yml'
+      #   )
+      def initialize(config_file: nil)
+        @config = load_config(config_file)
+        @warnings = []
+        @element_counts = Hash.new(0)
+      end
+
+      # Record an unsupported element.
+      #
+      # @param element_tag [String] Element tag name
+      # @param context [String] Context where element was found
+      # @param location [String] Location in document (optional)
+      # @return [void]
+      #
+      # @example Record unsupported element
+      #   collector.record_unsupported(
+      #     'chart',
+      #     context: 'While parsing paragraph',
+      #     location: '/document/body/p[5]'
+      #   )
+      def record_unsupported(element_tag, context:, location: nil)
+        return unless enabled?
+        return if max_warnings_reached?
+
+        @element_counts[element_tag] += 1
+
+        warning = Warning.new(
+          type: :unsupported_element,
+          severity: determine_severity(element_tag),
+          element: element_tag,
+          message: "Unsupported element: #{element_tag}",
+          context: context,
+          location: location,
+          suggestion: get_suggestion(element_tag)
+        )
+
+        @warnings << warning
+        log_warning(warning) if should_log?
+      end
+
+      # Record an unsupported attribute.
+      #
+      # @param element_tag [String] Element tag name
+      # @param attribute_name [String] Attribute name
+      # @param context [String] Context where attribute was found
+      # @return [void]
+      #
+      # @example Record unsupported attribute
+      #   collector.record_unsupported_attribute(
+      #     'w:p',
+      #     'customAttr',
+      #     context: 'In paragraph properties'
+      #   )
+      def record_unsupported_attribute(element_tag, attribute_name, context:)
+        return unless enabled?
+        return if max_warnings_reached?
+
+        warning = Warning.new(
+          type: :unsupported_attribute,
+          severity: :info,
+          element: element_tag,
+          attribute: attribute_name,
+          message: "Unsupported attribute: #{element_tag}/@#{attribute_name}",
+          context: context
+        )
+
+        @warnings << warning
+        log_warning(warning) if should_log?
+      end
+
+      # Generate warning report.
+      #
+      # @return [WarningReport] Aggregated warning report
+      #
+      # @example Get report
+      #   report = collector.report
+      #   puts "Total warnings: #{report.total_count}"
+      def report
+        WarningReport.new(
+          warnings: @warnings,
+          element_counts: @element_counts,
+          config: @config
+        )
+      end
+
+      # Check if warnings were collected.
+      #
+      # @return [Boolean] true if warnings exist
+      def any?
+        @warnings.any?
+      end
+
+      # Clear all collected warnings.
+      #
+      # @return [void]
+      def clear
+        @warnings.clear
+        @element_counts.clear
+      end
+
+      private
+
+      def load_config(config_file)
+        if config_file
+          Configuration::ConfigurationLoader.load_file(config_file)
+        else
+          # Try to load default config
+          default_path = File.join(
+            Configuration::ConfigurationLoader::CONFIG_DIR,
+            'warning_rules.yml'
+          )
+
+          if File.exist?(default_path)
+            Configuration::ConfigurationLoader.load('warning_rules')
+          else
+            # Use empty config with defaults
+            default_config
+          end
+        end
+      rescue Configuration::ConfigurationError
+        # If config fails to load, use defaults
+        default_config
+      end
+
+      def default_config
+        {
+          warning_system: {
+            enabled: true,
+            log_warnings: false,
+            log_level: :warn,
+            critical_elements: [],
+            warning_elements: [],
+            element_suggestions: {},
+            reporting: {
+              max_warnings: 100
+            }
+          }
+        }
+      end
+
+      def warning_config
+        @config[:warning_system] || {}
+      end
+
+      def enabled?
+        warning_config[:enabled] != false
+      end
+
+      def should_log?
+        warning_config[:log_warnings] == true
+      end
+
+      def max_warnings_reached?
+        max = warning_config.dig(:reporting, :max_warnings) || 100
+        @warnings.count >= max
+      end
+
+      def determine_severity(element_tag)
+        critical = warning_config[:critical_elements] || []
+        warning_els = warning_config[:warning_elements] || []
+
+        if critical.include?(element_tag)
+          :error
+        elsif warning_els.include?(element_tag)
+          :warning
+        else
+          :info
+        end
+      end
+
+      def get_suggestion(element_tag)
+        suggestions = warning_config[:element_suggestions] || {}
+        suggestions[element_tag] ||
+          suggestions[element_tag.to_sym] ||
+          'This element is not yet supported. Data may be lost in round-trip.'
+      end
+
+      def log_warning(warning)
+        level = warning_config[:log_level] || :warn
+        message = "[WARNING] #{warning}"
+
+        # Use Uniword logger if available
+        if defined?(Uniword::Logger)
+          Uniword::Logger.send(level, message)
+        elsif %i[warn error].include?(level)
+          # Fall back to standard output
+          puts message
+        end
+      end
+    end
+  end
+end

data/lib/uniword/warnings/warning_report.rb

@@ -0,0 +1,159 @@
+# frozen_string_literal: true
+
+require 'json'
+
+module Uniword
+  module Warnings
+    # Aggregated warning report.
+    #
+    # Responsibility: Aggregate and report warnings.
+    # Single Responsibility: Only manages warning reporting.
+    #
+    # A warning report includes:
+    # - Collection of all warnings
+    # - Element occurrence counts
+    # - Grouping by severity
+    # - Summary statistics
+    #
+    # @example Create a report
+    #   report = WarningReport.new(
+    #     warnings: warnings,
+    #     element_counts: { 'chart' => 5, 'smartArt' => 2 }
+    #   )
+    #   puts report.summary
+    class WarningReport
+      # @return [Array<Warning>] All warnings
+      attr_reader :warnings
+
+      # @return [Hash<String, Integer>] Element occurrence counts
+      attr_reader :element_counts
+
+      # Initialize a new warning report.
+      #
+      # @param warnings [Array<Warning>] Warnings to include
+      # @param element_counts [Hash<String, Integer>] Element counts
+      # @param config [Hash] Configuration
+      #
+      # @example Create a report
+      #   report = WarningReport.new(
+      #     warnings: [warning1, warning2],
+      #     element_counts: { 'chart' => 3 }
+      #   )
+      def initialize(warnings:, element_counts:, config: {})
+        @warnings = warnings
+        @element_counts = element_counts
+        @config = config
+      end
+
+      # Check if report has any warnings.
+      #
+      # @return [Boolean] true if warnings exist
+      def any?
+        @warnings.any?
+      end
+
+      # Get error-level warnings.
+      #
+      # @return [Array<Warning>] Error warnings
+      def errors
+        @warnings.select(&:error?)
+      end
+
+      # Get warning-level warnings.
+      #
+      # @return [Array<Warning>] Warning-level warnings
+      def warnings_only
+        @warnings.select(&:warning?)
+      end
+
+      # Get info-level warnings.
+      #
+      # @return [Array<Warning>] Info warnings
+      def infos
+        @warnings.select(&:info?)
+      end
+
+      # Get count of error warnings.
+      #
+      # @return [Integer] Error count
+      def error_count
+        errors.count
+      end
+
+      # Get count of warning-level warnings.
+      #
+      # @return [Integer] Warning count
+      def warning_count
+        warnings_only.count
+      end
+
+      # Get count of info warnings.
+      #
+      # @return [Integer] Info count
+      def info_count
+        infos.count
+      end
+
+      # Get total warning count.
+      #
+      # @return [Integer] Total count
+      def total_count
+        @warnings.count
+      end
+
+      # Generate summary text.
+      #
+      # @return [String] Summary text
+      def summary
+        return 'No warnings' unless any?
+
+        lines = []
+        lines << "Found #{total_count} warning(s):"
+        lines << "  Errors: #{error_count}"
+        lines << "  Warnings: #{warning_count}"
+        lines << "  Info: #{info_count}"
+
+        if @element_counts.any?
+          lines << ''
+          lines << 'Unsupported elements encountered:'
+
+          @element_counts.sort_by { |_, count| -count }.each do |element, count|
+            lines << "  #{element}: #{count} occurrence(s)"
+          end
+        end
+
+        lines.join("\n")
+      end
+
+      # Export to JSON string.
+      #
+      # @return [String] JSON representation
+      def to_json(*_args)
+        JSON.pretty_generate(to_h)
+      end
+
+      # Convert to hash representation.
+      #
+      # @return [Hash] Hash representation
+      def to_h
+        {
+          total: total_count,
+          by_severity: {
+            errors: error_count,
+            warnings: warning_count,
+            infos: info_count
+          },
+          element_counts: @element_counts,
+          warnings: @warnings.map(&:to_h)
+        }
+      end
+
+      # Convert to string for display.
+      #
+      # @return [String] String representation
+      def to_s
+        summary
+      end
+    end
+  end
+end

data/lib/uniword/warnings.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Uniword
+  module Warnings
+    autoload :Warning, "#{__dir__}/warnings/warning"
+    autoload :WarningCollector, "#{__dir__}/warnings/warning_collector"
+    autoload :WarningReport, "#{__dir__}/warnings/warning_report"
+  end
+end

data/lib/uniword/word2010_ext/wrap.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require 'lutaml/model'
+
+module Uniword
+  module Word2010Ext
+    # Word 2010 extensibility wrap element
+    # Used inside VML shapes for Word 2010 specific wrapping
+    #
+    # Element: <w10:wrap>
+    # Namespace: urn:schemas-microsoft-com:office:word
+    class Wrap < Lutaml::Model::Serializable
+      attribute :anchorx, :string
+      attribute :anchory, :string
+
+      xml do
+        element 'wrap'
+        namespace Uniword::Ooxml::Namespaces::Word2010Ext
+        mixed_content
+
+        map_attribute 'anchorx', to: :anchorx, render_nil: false
+        map_attribute 'anchory', to: :anchory, render_nil: false
+      end
+    end
+  end
+end

data/lib/uniword/word2010_ext.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+# Word2010Ext namespace module
+# Namespace: urn:schemas-microsoft-com:office:word
+# Prefix: w10:
+# Word 2010 extensibility elements used in VML
+
+require 'lutaml/model'
+
+module Uniword
+  module Word2010Ext
+    autoload :Wrap, 'uniword/word2010_ext/wrap'
+  end
+end

data/lib/uniword/word_implementation.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module Uniword
+  # Abstract base class for Word implementation queries
+  #
+  # This is a MODEL (not just a service). It has:
+  # - State: platform, version, installation status
+  # - Behavior: query paths, list resources
+  #
+  # Does NOT extend Lutaml::Model::Serializable because it doesn't need serialization.
+  class WordImplementation
+    # Factory - delegates to platform-specific implementation
+    def self.detect
+      WordImplementationFactory.create
+    end
+
+    # Abstract methods - raise if not overridden
+    def installed?
+      raise NotImplementedError
+    end
+
+    def version
+      raise NotImplementedError
+    end
+
+    # Path accessors - return nil if not applicable
+    def themes_path; end
+    def stylesets_path; end
+    def color_schemes_path; end
+    def font_schemes_path; end
+    def cache_path; end
+
+    # Resource enumeration - return empty array by default
+    def available_themes
+      return [] unless themes_path && File.directory?(themes_path)
+
+      Dir.glob(File.join(themes_path, '*.thmx')).map { |f| File.basename(f, '.thmx') }
+    end
+
+    def available_stylesets
+      return [] unless stylesets_path && File.directory?(stylesets_path)
+
+      Dir.glob(File.join(stylesets_path, '*.dotx')).map { |f| File.basename(f, '.dotx') }
+    end
+
+    def available_color_schemes
+      return [] unless color_schemes_path && File.directory?(color_schemes_path)
+
+      Dir.glob(File.join(color_schemes_path, '*.xml')).map { |f| File.basename(f, '.xml') }
+    end
+
+    def available_font_schemes
+      return [] unless font_schemes_path && File.directory?(font_schemes_path)
+
+      Dir.glob(File.join(font_schemes_path, '*.xml')).map { |f| File.basename(f, '.xml') }
+    end
+  end
+end

data/lib/uniword/word_implementation_factory.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Uniword
+  # Separate factory class - follows Single Responsibility Principle
+  class WordImplementationFactory
+    def self.create
+      case RbConfig::CONFIG['host_os']
+      when /darwin/ then MacOSWordImplementation.new
+      when /mswin|mingw|cygwin/ then WindowsWordImplementation.new
+      when /linux/ then LinuxWordImplementation.new
+      else NullWordImplementation.new
+      end
+    end
+  end
+end

data/lib/uniword/word_implementation_linux.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Uniword
+  class LinuxWordImplementation < WordImplementation
+    # NOTE: There is no Microsoft Word for Linux
+    # Linux users must manually copy theme files from another system
+
+    def installed?
+      false # No native Word on Linux
+    end
+
+    def version
+      nil
+    end
+
+    def themes_path
+      # User-configured path for manually copied themes
+      ENV['UNIWORD_THEMES_PATH'] || File.expand_path('~/.local/share/uniword/themes/source')
+    end
+
+    def stylesets_path
+      ENV['UNIWORD_STYLESETS_PATH'] || File.expand_path('~/.local/share/uniword/stylesets/source')
+    end
+
+    def color_schemes_path
+      ENV['UNIWORD_COLOR_SCHEMES_PATH'] || File.expand_path('~/.local/share/uniword/color_schemes/source')
+    end
+
+    def font_schemes_path
+      ENV['UNIWORD_FONT_SCHEMES_PATH'] || File.expand_path('~/.local/share/uniword/font_schemes/source')
+    end
+
+    def cache_path
+      # XDG cache directory
+      if ENV['XDG_CACHE_HOME']
+        File.join(ENV['XDG_CACHE_HOME'], 'uniword')
+      else
+        File.expand_path('~/.cache/uniword')
+      end
+    end
+  end
+end

data/lib/uniword/word_implementation_macos.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module Uniword
+  class MacOSWordImplementation < WordImplementation
+    WORD_APP_PATH = '/Applications/Microsoft Word.app'
+    RESOURCES_PATH = '/Applications/Microsoft Word.app/Contents/Resources'
+
+    def installed?
+      File.directory?(WORD_APP_PATH)
+    end
+
+    def version
+      return nil unless installed?
+
+      plist = File.join(WORD_APP_PATH, 'Contents', 'Info.plist')
+      return nil unless File.exist?(plist)
+
+      `defaults read "#{WORD_APP_PATH}/Contents" CFBundleShortVersionString 2>/dev/null`.strip.presence
+    end
+
+    def themes_path
+      File.join(RESOURCES_PATH, 'Office Themes') if installed?
+    end
+
+    def stylesets_path
+      File.join(RESOURCES_PATH, 'QuickStyles') if installed?
+    end
+
+    def color_schemes_path
+      File.join(RESOURCES_PATH, 'Office Themes', 'Theme Colors') if installed?
+    end
+
+    def font_schemes_path
+      File.join(RESOURCES_PATH, 'Office Themes', 'Theme Fonts') if installed?
+    end
+
+    def cache_path
+      File.expand_path('~/.uniword')
+    end
+  end
+end

data/lib/uniword/word_implementation_null.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Uniword
+  # Null Object Pattern - returns safe defaults for unknown platforms
+  class NullWordImplementation < WordImplementation
+    def installed?
+      false
+    end
+
+    def version
+      nil
+    end
+
+    def themes_path
+      nil
+    end
+
+    def stylesets_path
+      nil
+    end
+
+    def color_schemes_path
+      nil
+    end
+
+    def font_schemes_path
+      nil
+    end
+
+    def cache_path
+      File.expand_path('~/.uniword')
+    end
+  end
+end