uniword 1.0.0

data/lib/uniword/batch/document_processor.rb

@@ -0,0 +1,339 @@
+# frozen_string_literal: true
+
+# All classes autoloaded via lib/uniword.rb and lib/uniword/batch.rb
+# ProcessingStage, BatchResult, Configuration::ConfigurationLoader, DocumentFactory
+
+module Uniword
+  module Batch
+    # Orchestrates batch document processing through configurable pipeline stages.
+    #
+    # Responsibility: Load pipeline configuration and coordinate stage execution.
+    # Single Responsibility - only orchestrates processing, delegates work to stages.
+    #
+    # Follows Open/Closed Principle - new stages can be added via configuration
+    # without modifying this class.
+    #
+    # @example Process batch of documents
+    #   processor = DocumentProcessor.new(pipeline_config: 'config/pipeline.yml')
+    #   results = processor.process_batch(
+    #     input_dir: 'documents/input/',
+    #     output_dir: 'documents/output/'
+    #   )
+    #   puts results.summary_text
+    #
+    # @example Process with custom stages
+    #   processor = DocumentProcessor.new
+    #   processor.add_stage(CustomStage.new(enabled: true))
+    #   results = processor.process_file('document.docx', 'output.docx')
+    class DocumentProcessor
+      attr_reader :stages, :config
+
+      # Stage class registry
+      # Maps stage names to their class implementations
+      STAGE_CLASSES = {
+        normalize_styles: 'NormalizeStylesStage',
+        update_metadata: 'UpdateMetadataStage',
+        validate_links: 'ValidateLinksStage',
+        quality_check: 'QualityCheckStage',
+        convert_format: 'ConvertFormatStage',
+        compress_images: 'CompressImagesStage'
+      }.freeze
+
+      # Initialize document processor
+      #
+      # @param pipeline_config [String, nil] Path to pipeline configuration file
+      # @param config [Hash, nil] Direct configuration hash (overrides pipeline_config)
+      # @param parallel [Boolean] Enable parallel processing
+      # @param max_workers [Integer] Maximum number of parallel workers
+      def initialize(pipeline_config: nil, config: nil, parallel: false, max_workers: 4)
+        @config = load_configuration(pipeline_config, config)
+        @parallel = parallel || @config.dig(:pipeline, :parallel, :enabled) || false
+        @max_workers = max_workers || @config.dig(:pipeline, :parallel, :max_workers) || 4
+        @stages = load_stages
+        @custom_stages = []
+      end
+
+      # Process a batch of documents from input directory
+      #
+      # @param input_dir [String] Input directory path
+      # @param output_dir [String] Output directory path
+      # @param pattern [String] File pattern to match (default: '*.{docx,doc}')
+      # @return [BatchResult] Processing results
+      def process_batch(input_dir:, output_dir:, pattern: '*.{docx,doc}')
+        validate_directories!(input_dir, output_dir)
+
+        # Create output directory if it doesn't exist
+        FileUtils.mkdir_p(output_dir)
+
+        # Find all matching files
+        files = Dir.glob(File.join(input_dir, pattern))
+
+        result = BatchResult.new
+
+        if @parallel && files.size > 1
+          process_parallel(files, input_dir, output_dir, result)
+        else
+          process_sequential(files, input_dir, output_dir, result)
+        end
+
+        result.complete!
+      end
+
+      # Process a single document file
+      #
+      # @param input_path [String] Input file path
+      # @param output_path [String] Output file path
+      # @return [BatchResult] Processing result
+      def process_file(input_path, output_path)
+        result = BatchResult.new
+        start_time = Time.now
+
+        begin
+          # Load document
+          document = DocumentFactory.from_file(input_path)
+
+          # Create context
+          context = {
+            input_path: input_path,
+            output_path: output_path,
+            filename: File.basename(input_path)
+          }
+
+          # Execute pipeline
+          executed_stages = []
+          all_stages = @stages + @custom_stages
+
+          all_stages.each do |stage|
+            next unless stage.enabled?
+
+            stage.process(document, context)
+            executed_stages << stage.name
+          end
+
+          # Save output
+          output_dir = File.dirname(output_path)
+          FileUtils.mkdir_p(output_dir)
+          document.save(output_path)
+
+          duration = Time.now - start_time
+          result.add_success(
+            file: input_path,
+            duration: duration,
+            stages: executed_stages
+          )
+        rescue StandardError => e
+          handle_error(e, input_path, result)
+        end
+
+        result.complete!
+      end
+
+      # Add a custom processing stage
+      #
+      # @param stage [ProcessingStage] Stage to add
+      # @return [self]
+      def add_stage(stage)
+        unless stage.is_a?(ProcessingStage)
+          raise ArgumentError,
+                'Stage must inherit from ProcessingStage'
+        end
+
+        @custom_stages << stage
+        self
+      end
+
+      # Get list of enabled stage names
+      #
+      # @return [Array<String>] Names of enabled stages
+      def enabled_stages
+        all_stages = @stages + @custom_stages
+        all_stages.select(&:enabled?).map(&:name)
+      end
+
+      # Get list of disabled stage names
+      #
+      # @return [Array<String>] Names of disabled stages
+      def disabled_stages
+        all_stages = @stages + @custom_stages
+        all_stages.reject(&:enabled?).map(&:name)
+      end
+
+      private
+
+      # Load configuration from file or use provided config
+      #
+      # @param pipeline_config [String, nil] Path to pipeline file
+      # @param config [Hash, nil] Direct configuration
+      # @return [Hash] Loaded configuration
+      def load_configuration(pipeline_config, config)
+        if config
+          config
+        elsif pipeline_config
+          Configuration::ConfigurationLoader.load_file(pipeline_config)
+        else
+          Configuration::ConfigurationLoader.load('pipeline')
+        end
+      rescue Configuration::ConfigurationError => e
+        # Use default configuration if file not found
+        warn "Warning: Could not load pipeline configuration: #{e.message}"
+        warn 'Using default configuration'
+        default_configuration
+      end
+
+      # Default configuration
+      #
+      # @return [Hash] Default pipeline configuration
+      def default_configuration
+        {
+          pipeline: {
+            default: {
+              stages: []
+            },
+            parallel: {
+              enabled: false,
+              max_workers: 4
+            },
+            error_handling: {
+              continue_on_error: true,
+              log_errors: true
+            }
+          }
+        }
+      end
+
+      # Load and instantiate all configured stages
+      #
+      # @return [Array<ProcessingStage>] Array of stage instances
+      def load_stages
+        stages_config = @config.dig(:pipeline, :default, :stages) || []
+
+        stages_config.map do |stage_config|
+          stage_name = stage_config[:name]&.to_sym
+          class_name = STAGE_CLASSES[stage_name]
+
+          next unless class_name
+
+          instantiate_stage(class_name, stage_config[:options] || {})
+        end.compact
+      end
+
+      # Instantiate a stage class with configuration
+      #
+      # @param class_name [String] Name of the stage class
+      # @param options [Hash] Stage options
+      # @return [ProcessingStage, nil] Stage instance or nil if class not found
+      def instantiate_stage(class_name, options)
+        # Stage classes are autoloaded via lib/uniword/batch.rb
+        stage_class = Batch.const_get(class_name)
+        stage_class.new(options)
+      rescue NameError => e
+        warn "Warning: Stage class not found: #{class_name} (#{e.message})"
+        nil
+      end
+
+      # Process files sequentially
+      #
+      # @param files [Array<String>] List of file paths
+      # @param input_dir [String] Input directory
+      # @param output_dir [String] Output directory
+      # @param result [BatchResult] Result tracker
+      def process_sequential(files, input_dir, output_dir, result)
+        files.each do |input_path|
+          relative_path = input_path.sub(input_dir, '').sub(%r{^/}, '')
+          output_path = File.join(output_dir, relative_path)
+
+          process_single_file(input_path, output_path, result)
+        end
+      end
+
+      # Process files in parallel
+      #
+      # @param files [Array<String>] List of file paths
+      # @param input_dir [String] Input directory
+      # @param output_dir [String] Output directory
+      # @param result [BatchResult] Result tracker
+      def process_parallel(files, input_dir, output_dir, result)
+        # NOTE: Actual parallel implementation would require thread-safe operations
+        # For now, fall back to sequential processing
+        warn 'Warning: Parallel processing not yet implemented, using sequential'
+        process_sequential(files, input_dir, output_dir, result)
+      end
+
+      # Process a single file and update result
+      #
+      # @param input_path [String] Input file path
+      # @param output_path [String] Output file path
+      # @param result [BatchResult] Result tracker
+      def process_single_file(input_path, output_path, result)
+        start_time = Time.now
+
+        begin
+          # Load document
+          document = DocumentFactory.from_file(input_path)
+
+          # Create context
+          context = {
+            input_path: input_path,
+            output_path: output_path,
+            filename: File.basename(input_path)
+          }
+
+          # Execute pipeline
+          executed_stages = []
+          all_stages = @stages + @custom_stages
+
+          all_stages.each do |stage|
+            next unless stage.enabled?
+
+            document = stage.process(document, context)
+            executed_stages << stage.name
+          end
+
+          # Save output
+          output_dir = File.dirname(output_path)
+          FileUtils.mkdir_p(output_dir)
+          document.save(output_path)
+
+          duration = Time.now - start_time
+          result.add_success(
+            file: input_path,
+            duration: duration,
+            stages: executed_stages
+          )
+        rescue StandardError => e
+          handle_error(e, input_path, result)
+        end
+      end
+
+      # Handle processing error
+      #
+      # @param error [Exception] The error that occurred
+      # @param file_path [String] File being processed
+      # @param result [BatchResult] Result tracker
+      def handle_error(error, file_path, result)
+        continue_on_error = @config.dig(:pipeline, :error_handling, :continue_on_error)
+        log_errors = @config.dig(:pipeline, :error_handling, :log_errors)
+
+        result.add_failure(file: file_path, error: error)
+
+        if log_errors
+          warn "Error processing #{file_path}: #{error.message}"
+          warn error.backtrace.first(5).join("\n") if ENV['UNIWORD_VERBOSE']
+        end
+
+        raise error unless continue_on_error
+      end
+
+      # Validate directories exist
+      #
+      # @param input_dir [String] Input directory
+      # @param output_dir [String] Output directory
+      # @raise [ArgumentError] if input directory doesn't exist
+      def validate_directories!(input_dir, _output_dir)
+        return if Dir.exist?(input_dir)
+
+        raise ArgumentError, "Input directory does not exist: #{input_dir}"
+      end
+    end
+  end
+end

data/lib/uniword/batch/processing_stage.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+module Uniword
+  module Batch
+    # Base class for batch processing pipeline stages.
+    #
+    # Responsibility: Define the interface for processing pipeline stages.
+    # Each stage performs one specific transformation or validation on a document.
+    #
+    # Follows Single Responsibility Principle - one stage does one transformation.
+    # Follows Open/Closed Principle - new stages can be added without modifying this class.
+    #
+    # @example Create a custom processing stage
+    #   class CustomStage < ProcessingStage
+    #     def initialize(options = {})
+    #       super(options)
+    #       @threshold = options[:threshold] || 100
+    #     end
+    #
+    #     def process(document, context = {})
+    #       # Perform transformation
+    #       # Return modified document or original
+    #       document
+    #     end
+    #   end
+    class ProcessingStage
+      attr_reader :options, :enabled
+
+      # Initialize processing stage
+      #
+      # @param options [Hash] Stage configuration options
+      # @option options [Boolean] :enabled Whether stage is enabled (default: true)
+      def initialize(options = {})
+        @options = options || {}
+        @enabled = @options.fetch(:enabled, true)
+      end
+
+      # Check if stage is enabled
+      #
+      # @return [Boolean] true if stage should be executed
+      def enabled?
+        @enabled
+      end
+
+      # Process a document through this stage
+      #
+      # @param document [Document] The document to process
+      # @param context [Hash] Processing context (file paths, metadata, etc.)
+      # @return [Document] The processed document (may be modified or original)
+      # @raise [NotImplementedError] if not implemented by subclass
+      def process(document, context = {})
+        raise NotImplementedError, "#{self.class} must implement #process"
+      end
+
+      # Get stage name (used for identification and logging)
+      #
+      # @return [String] Stage name
+      def name
+        self.class.name.split('::').last
+            .gsub(/Stage$/, '')
+            .gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2')
+            .gsub(/([a-z\d])([A-Z])/, '\1_\2')
+            .downcase
+      end
+
+      # Get stage description (for logging and reporting)
+      #
+      # @return [String] Stage description
+      def description
+        "#{name} stage"
+      end
+
+      protected
+
+      # Log a message during processing
+      #
+      # @param message [String] Message to log
+      # @param level [Symbol] Log level (:info, :warn, :error)
+      def log(message, level: :info)
+        prefix = "[#{name}]"
+        case level
+        when :error
+          warn "ERROR #{prefix} #{message}"
+        when :warn
+          warn "WARN #{prefix} #{message}"
+        else
+          puts "INFO #{prefix} #{message}" if ENV['UNIWORD_VERBOSE']
+        end
+      end
+    end
+  end
+end

data/lib/uniword/batch/stages/compress_images_stage.rb

@@ -0,0 +1,187 @@
+# frozen_string_literal: true
+
+module Uniword
+  module Batch
+    # Processing stage that compresses images in documents.
+    #
+    # Responsibility: Reduce image file sizes while maintaining quality.
+    # Single Responsibility - only handles image compression.
+    #
+    # @example Use in pipeline
+    #   stage = CompressImagesStage.new(
+    #     max_width: 1920,
+    #     max_height: 1080,
+    #     quality: 85
+    #   )
+    #   document = stage.process(document, context)
+    class CompressImagesStage < ProcessingStage
+      # Initialize compress images stage
+      #
+      # @param options [Hash] Stage options
+      # @option options [Integer] :max_width Maximum image width in pixels
+      # @option options [Integer] :max_height Maximum image height in pixels
+      # @option options [Integer] :quality JPEG quality (0-100)
+      # @option options [Boolean] :preserve_aspect_ratio Maintain aspect ratio
+      # @option options [Boolean] :skip_small_images Skip images below min size
+      # @option options [Integer] :min_size_kb Minimum size to compress (KB)
+      def initialize(options = {})
+        super
+        @max_width = options.fetch(:max_width, 1920)
+        @max_height = options.fetch(:max_height, 1080)
+        @quality = options.fetch(:quality, 85)
+        @preserve_aspect_ratio = options.fetch(:preserve_aspect_ratio, true)
+        @skip_small_images = options.fetch(:skip_small_images, true)
+        @min_size_kb = options.fetch(:min_size_kb, 100)
+      end
+
+      # Process document to compress images
+      #
+      # @param document [Document] Document to process
+      # @param context [Hash] Processing context
+      # @return [Document] Processed document
+      def process(document, context = {})
+        log "Compressing images in #{context[:filename]}"
+
+        images = collect_images(document)
+        compressed_count = 0
+        total_saved = 0
+
+        images.each do |image|
+          next unless should_compress_image?(image)
+
+          saved_bytes = compress_image(image)
+          if saved_bytes.positive?
+            compressed_count += 1
+            total_saved += saved_bytes
+          end
+        end
+
+        if compressed_count.positive?
+          saved_kb = (total_saved / 1024.0).round(2)
+          log "Compressed #{compressed_count} image(s), saved #{saved_kb} KB"
+        else
+          log 'No images needed compression'
+        end
+
+        document
+      end
+
+      # Get stage description
+      #
+      # @return [String] Description
+      def description
+        'Compress document images'
+      end
+
+      private
+
+      # Collect all images from document
+      #
+      # @param document [Document] Document to scan
+      # @return [Array<Image>] Array of images
+      def collect_images(document)
+        images = []
+
+        # Scan paragraphs for images
+        document.paragraphs.each do |paragraph|
+          paragraph.runs.each do |run|
+            images << run if run.is_a?(Uniword::Image)
+          end
+        end
+
+        # Scan tables for images
+        document.tables.each do |table|
+          table.rows.each do |row|
+            row.cells.each do |cell|
+              cell.paragraphs.each do |paragraph|
+                paragraph.runs.each do |run|
+                  images << run if run.is_a?(Uniword::Image)
+                end
+              end
+            end
+          end
+        end
+
+        images
+      end
+
+      # Check if image should be compressed
+      #
+      # @param image [Image] Image to check
+      # @return [Boolean] true if should compress
+      def should_compress_image?(image)
+        return false unless image.is_a?(Uniword::Image)
+        return false if image.image_data.nil?
+
+        # Skip small images if configured
+        if @skip_small_images
+          size_kb = image.image_data.bytesize / 1024.0
+          return false if size_kb < @min_size_kb
+        end
+
+        true
+      end
+
+      # Compress an image
+      #
+      # @param image [Image] Image to compress
+      # @return [Integer] Bytes saved (0 if not compressed)
+      def compress_image(image)
+        original_size = image.image_data.bytesize
+
+        # Get image dimensions
+        width, height = get_image_dimensions(image)
+
+        # Check if resizing is needed
+        needs_resize = width > @max_width || height > @max_height
+
+        if needs_resize
+          new_width, new_height = calculate_new_dimensions(width, height)
+          log "  Resizing image from #{width}x#{height} to #{new_width}x#{new_height}"
+
+          # Placeholder for actual image compression
+          # In real implementation, would use image processing library
+          # For now, just log the action
+          original_size - original_size # Returns 0
+        else
+          0
+        end
+      end
+
+      # Get image dimensions
+      #
+      # @param image [Image] Image object
+      # @return [Array<Integer>] Width and height
+      def get_image_dimensions(image)
+        # Placeholder - would need to parse image data
+        # For now, return dimensions from image properties if available
+        width = image.respond_to?(:width) ? image.width : 800
+        height = image.respond_to?(:height) ? image.height : 600
+        [width || 800, height || 600]
+      end
+
+      # Calculate new dimensions maintaining aspect ratio
+      #
+      # @param width [Integer] Current width
+      # @param height [Integer] Current height
+      # @return [Array<Integer>] New width and height
+      def calculate_new_dimensions(width, height)
+        return [width, height] unless @preserve_aspect_ratio
+
+        # Calculate scaling factor
+        width_scale = @max_width.to_f / width
+        height_scale = @max_height.to_f / height
+        scale = [width_scale, height_scale].min
+
+        # Apply scale if needed
+        if scale < 1.0
+          new_width = (width * scale).round
+          new_height = (height * scale).round
+          [new_width, new_height]
+        else
+          [width, height]
+        end
+      end
+    end
+  end
+end