uniword 1.2.5 → 1.4.0

data/lib/uniword/warnings/warning_collector.rb

@@ -1,234 +0,0 @@
-# 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)
-          case level
-          when :debug then Uniword::Logger.debug(message)
-          when :info  then Uniword::Logger.info(message)
-          when :warn  then Uniword::Logger.warn(message)
-          when :error then Uniword::Logger.error(message)
-          end
-        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

@@ -1,159 +0,0 @@
-# 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

@@ -1,9 +0,0 @@
-# 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