jekyll-l10n 1.0.5

data/lib/jekyll-l10n/extraction/config_loader.rb

@@ -0,0 +1,114 @@
+# frozen_string_literal: true
+
+require_relative "../utils/page_locales_config"
+
+module Jekyll
+  module L10n
+    # Loads and validates extraction configuration for files during build.
+    #
+    # ExtractionConfigLoader finds extraction configuration for generated HTML
+    # files by matching them against Jekyll site pages. It validates whether
+    # extraction is enabled and configured for a file, loads page-specific
+    # settings, and identifies files to skip (localized page variants).
+    #
+    # Key responsibilities:
+    # * Match generated HTML files to Jekyll site pages
+    # * Validate that extraction is enabled for a file
+    # * Load page-specific extraction configuration
+    # * Identify localized page variants to skip
+    # * Extract CSS selectors for element exclusion
+    #
+    # @example
+    #   loader = ExtractionConfigLoader.new(site, '_site')
+    #   if loader.valid_for_extraction?(file_path)
+    #     config = loader.load_page_config(file_path)
+    #   end
+    class ExtractionConfigLoader
+      # Initialize a new ExtractionConfigLoader.
+      #
+      # @param site [Jekyll::Site] Jekyll site object
+      # @param dest [String] Destination build directory
+      def initialize(site, dest)
+        @site = site
+        @dest = dest
+      end
+
+      # Check if a file is valid for extraction.
+      #
+      # Matches the file to a Jekyll page and verifies extraction is enabled
+      # for that page in the configuration.
+      #
+      # @param file_path [String] Path to file to check
+      # @return [Boolean] True if file matches a page with extraction enabled
+      def valid_for_extraction?(file_path)
+        page_config = find_page_config_for_file(file_path)
+        return false unless page_config
+
+        config = PageLocalesConfig.new(page_config)
+        config.enabled? && config.extract_on_build?
+      end
+
+      # Load extraction configuration for a file.
+      #
+      # Finds the Jekyll page matching this file and returns its localization
+      # configuration wrapped in PageLocalesConfig.
+      #
+      # @param file_path [String] Path to file
+      # @return [PageLocalesConfig] Localization configuration for the page
+      def load_page_config(file_path)
+        page_config = find_page_config_for_file(file_path)
+        PageLocalesConfig.new(page_config)
+      end
+
+      # Find page configuration for a file.
+      #
+      # Matches a generated file path to a Jekyll page with extraction enabled.
+      # Returns the page's front matter data, or nil if no match found.
+      #
+      # @param file_path [String] Path to generated file
+      # @return [Hash, nil] Page front matter data if found, nil otherwise
+      def find_page_config_for_file(file_path)
+        @site.pages.each do |page|
+          next unless page.data["with_locales"] == true
+
+          page_output = page.output_ext ? page.destination("") : page.destination("/")
+          next unless file_path.end_with?(page_output.sub(%r!/$!, "/index.html"))
+
+          return page.data
+        end
+
+        nil
+      end
+
+      # Check if a file is a localized page variant that should be skipped.
+      #
+      # Localized pages are generated copies in locale subdirectories that
+      # shouldn't be re-extracted (extraction happens on original pages only).
+      #
+      # @param file_path [String] Path to file to check
+      # @return [Boolean] True if file is in a locale subdirectory
+      def skip_localized_page?(file_path)
+        relative_path = file_path.sub(@dest, "")
+
+        all_locales = @site.pages.map do |p|
+          p.data.dig("with_locales_data", "locales") || []
+        end
+        all_locales.flatten!
+        all_locales.uniq!
+        all_locales.any? { |locale| relative_path.start_with?("/#{locale}/") }
+      end
+
+      # Extract CSS selectors for element exclusion from configuration.
+      #
+      # Returns CSS selectors of elements to exclude from extraction (e.g.,
+      # script, style, code blocks). Defaults to sensible defaults if not configured.
+      #
+      # @param config [Hash] Page front matter data
+      # @return [Array<String>] CSS selectors for excluded elements
+      def extract_exclude_selectors(config)
+        config.data.dig("with_locales_data", "extraction", "exclude_selectors") ||
+          ["script", "style", "code.language-plaintext", "pre code"]
+      end
+    end
+  end
+end

data/lib/jekyll-l10n/extraction/dom_attribute_extractor.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+require_relative "../utils/xpath_reference_generator"
+require_relative "../utils/text_validator"
+
+module Jekyll
+  module L10n
+    # Extracts HTML attribute values from elements for translation.
+    #
+    # DomAttributeExtractor identifies and extracts values from configurable HTML
+    # attributes (title, alt, aria-label, placeholder, aria-description) on DOM
+    # elements. It validates extracted values and generates file location references
+    # that include the attribute name for precise debugging and reference.
+    #
+    # Key responsibilities:
+    # * Extract attribute values from DOM elements
+    # * Filter extractable attributes by whitelist
+    # * Validate attribute values (minimum length, non-numeric)
+    # * Generate attribute-specific file location references
+    # * Return entries ready for PO file format
+    #
+    # @example
+    #   entries = DomAttributeExtractor.extract(node, 'docs/index.html', '_site',
+    #                                           ['title', 'alt', 'aria-label'])
+    #   # Returns array of extraction entries for all valid attribute values
+    module DomAttributeExtractor
+      extend self
+
+      # Extract attribute values from an HTML element.
+      #
+      # Returns empty array if element is not an element node. For element nodes,
+      # identifies all specified translatable attributes with non-empty values and
+      # returns extraction entries for each, including attribute name in the reference.
+      #
+      # @param node [Nokogiri::XML::Element] DOM element to extract from
+      # @param file_path [String] Source file path (for file location reference)
+      # @param dest [String] Destination directory (for file location reference)
+      # @param translatable_attrs [Array<String>] Attribute names to extract
+      #   (e.g., ['title', 'alt', 'aria-label', 'placeholder', 'aria-description'])
+      # @return [Array<Hash>] Array of extraction entries, each containing:
+      #   - :msgid [String] The attribute value to translate
+      #   - :msgstr [String] Empty string (to be filled by translator)
+      #   - :reference [String] File location reference including attribute name
+      def extract(node, file_path, dest, translatable_attrs)
+        return [] unless node.element?
+
+        attrs = extract_node_attributes(node, translatable_attrs)
+        attrs.map do |attr_text, attr_name|
+          reference = XPathReferenceGenerator.generate(node, file_path, dest, attr_name)
+          { :msgid => attr_text, :msgstr => "", :reference => reference }
+        end
+      end
+
+      def extract_node_attributes(node, translatable_attrs)
+        attrs = {}
+
+        translatable_attrs.each do |attr_name|
+          value = node[attr_name]
+          next if value.nil? || value.empty?
+
+          value = value.strip
+          attrs[value] = attr_name if TextValidator.valid?(value)
+        end
+
+        attrs
+      end
+    end
+  end
+end

data/lib/jekyll-l10n/extraction/dom_text_extractor.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+require_relative "../utils/text_normalizer"
+require_relative "../utils/xpath_reference_generator"
+require_relative "../utils/html_text_utils"
+require_relative "../utils/html_elements"
+require_relative "../utils/text_validator"
+
+module Jekyll
+  module L10n
+    # Extracts text content from HTML elements for translation.
+    #
+    # DomTextExtractor identifies content-bearing HTML elements (paragraphs, headings,
+    # list items, etc.) and extracts their text content while preserving inline HTML
+    # tags. It validates extracted text and generates file location references for
+    # debugging. Text is extracted from elements that contain text nodes or inline
+    # elements, but not from elements containing only block-level children.
+    #
+    # Key responsibilities:
+    # * Identify extractable content elements (p, h1-h6, li, blockquote, etc.)
+    # * Extract text while preserving inline HTML structure
+    # * Skip elements containing only block-level children
+    # * Validate extracted text (minimum length, non-numeric)
+    # * Generate file location references for extracted strings
+    #
+    # @example
+    #   entry = DomTextExtractor.extract(node, 'docs/index.html', '_site')
+    #   # Returns hash with :msgid, :msgstr, :reference if valid text found
+    module DomTextExtractor
+      extend self
+
+      # Extract text content from an HTML element.
+      #
+      # Returns nil if element is not extractable (not a content element) or if
+      # extracted text fails validation (too short, numeric-only, etc.). For valid
+      # text, returns hash with msgid, empty msgstr, and file location reference for
+      # debugging.
+      #
+      # @param node [Nokogiri::XML::Element] DOM element to extract from
+      # @param file_path [String] Source file path (for file location reference)
+      # @param dest [String] Destination directory (for file location reference)
+      # @return [Hash, nil] Hash with :msgid, :msgstr, :reference if valid text found,
+      #   nil if element is not extractable or text fails validation
+      def extract(node, file_path, dest)
+        return nil unless extractable?(node)
+
+        text = extract_block_text(node)
+        return nil if text.nil?
+
+        reference = XPathReferenceGenerator.generate(node, file_path, dest)
+        { :msgid => text, :msgstr => "", :reference => reference }
+      end
+
+      def extractable?(node)
+        node.element? && HtmlTextUtils::CONTENT_ELEMENTS.include?(node.name)
+      end
+
+      def extract_block_text(node)
+        return nil if only_contains_block_elements?(node)
+
+        text = HtmlTextUtils.extract_with_inline_tags(node)
+        TextValidator.valid?(text) ? text : nil
+      end
+
+      def only_contains_block_elements?(node)
+        node.children.each do |child|
+          return false if non_empty_text?(child)
+          return false if non_block_element?(child)
+        end
+
+        block_element_children?(node)
+      end
+
+      private
+
+      def non_empty_text?(child)
+        child.text? && !child.content.strip.empty?
+      end
+
+      def non_block_element?(child)
+        child.element? && !HtmlTextUtils::ALL_BLOCK_ELEMENTS.include?(child.name)
+      end
+
+      def block_element_children?(node)
+        node.children.any? { |c| c.element? && HtmlTextUtils::ALL_BLOCK_ELEMENTS.include?(c.name) }
+      end
+    end
+  end
+end

data/lib/jekyll-l10n/extraction/extractor.rb

@@ -0,0 +1,153 @@
+# frozen_string_literal: true
+
+require_relative "config_loader"
+require_relative "result_saver"
+require_relative "logger"
+require_relative "html_string_extractor"
+require_relative "../utils/file_operations"
+require_relative "../utils/site_config_accessor"
+
+module Jekyll
+  module L10n
+    # String Extraction Orchestrator - Finds translatable strings in generated HTML
+    #
+    # The Extractor is the main entry point for the string extraction workflow. It scans all
+    # generated HTML files after Jekyll's build, identifies translatable content (text nodes
+    # and configurable HTML attributes), and creates or updates GNU Gettext PO files with
+    # the extracted strings.
+    #
+    # The extraction workflow:
+    # 1. Scans all HTML files in Jekyll output directory (_site/)
+    # 2. For each HTML file, extracts translatable text and attributes
+    # 3. Normalizes text for consistent matching across builds
+    # 4. Creates or updates page-specific PO files in _locales/ directory
+    # 5. Optionally applies automatic translations via LibreTranslate API
+    #
+    # Key responsibilities:
+    # - Load and validate extraction configuration from pages
+    # - Extract text and attributes from HTML with file location references
+    # - Create and update PO files with extracted strings
+    # - Log extraction statistics and progress
+    # - Coordinate with LibreTranslate for automatic translation
+    #
+    # @example Usage (typically invoked by PostWriteProcessor)
+    #   extractor = Extractor.new(site)
+    #   result = extractor.extract_site
+    #   # => { files_processed: 42, strings_extracted: 237, po_files_created: 3 }
+    #
+    # @see Jekyll::L10n::ExtractionResultSaver for PO file creation and updates
+    # @see Jekyll::L10n::HtmlStringExtractor for text and attribute extraction
+    #
+    class Extractor
+      # @!attribute [r] site
+      #   The Jekyll site object with generated pages
+      #   @return [Jekyll::Site]
+      attr_reader :site
+
+      # Initialize the string extractor
+      #
+      # Sets up configuration and result saving infrastructure for extraction.
+      #
+      # @param site [Jekyll::Site] The Jekyll site object
+      def initialize(site)
+        @site = site
+        @source = SiteConfigAccessor.source(@site)
+        @dest = SiteConfigAccessor.dest(@site)
+        @config_loader = ExtractionConfigLoader.new(@site, @dest)
+        @result_saver = ExtractionResultSaver.new(@site)
+      end
+
+      # Extract all translatable strings from the generated site
+      #
+      # Main entry point for extraction. Scans all HTML files in the build output,
+      # extracts translatable strings and attributes, creates/updates PO files,
+      # and optionally translates strings via LibreTranslate API.
+      #
+      # @return [Hash<Symbol, Integer>] Statistics hash with keys:
+      #   - :files_processed - Number of HTML files processed
+      #   - :strings_extracted - Total strings extracted
+      #   - :po_files_created - Number of PO files created/updated
+      # @example
+      #   result = extractor.extract_site
+      #   puts "Processed #{result[:files_processed]} files"
+      def extract_site
+        Jekyll.logger.info "Localization", "Extracting translatable strings..."
+        start_time = Time.now
+        stats = process_all_html_files
+        translate_all_compendia
+        ExtractionLogger.log_summary(stats, Time.now - start_time)
+        stats
+      end
+
+      def process_all_html_files
+        stats = { :files_processed => 0, :strings_extracted => 0, :po_files_created => 0 }
+        html_files = Dir.glob(File.join(@dest, "**", "*.html"))
+
+        html_files.each do |file_path|
+          next if @config_loader.skip_localized_page?(file_path)
+
+          file_stats = process_file(file_path)
+          stats[:files_processed] += file_stats[:files_processed]
+          stats[:strings_extracted] += file_stats[:strings_extracted]
+          stats[:po_files_created] += file_stats[:po_files_created]
+        end
+
+        stats
+      end
+
+      def translate_all_compendia
+        config = find_libretranslate_config
+        return unless config
+
+        @result_saver.translate_compendia(config)
+      end
+
+      def process_file(file_path)
+        return default_stats unless @config_loader.valid_for_extraction?(file_path)
+
+        config = @config_loader.load_page_config(file_path)
+        entries = extract_strings_from_file(file_path, config)
+        return default_stats if entries.empty?
+
+        page_path = construct_page_path(file_path)
+        @result_saver.save_results(config, entries, page_path)
+      rescue StandardError => e
+        ExtractionLogger.log_error(file_path, e)
+        default_stats
+      end
+
+      def default_stats
+        { :files_processed => 0, :strings_extracted => 0, :po_files_created => 0 }
+      end
+
+      def extract_strings_from_file(file_path, config)
+        return [] unless File.exist?(file_path)
+
+        html = FileOperations.read_utf8(file_path)
+        exclude_selectors = @config_loader.extract_exclude_selectors(config)
+
+        extractor = HtmlStringExtractor.new(config.translatable_attributes, exclude_selectors)
+        extractor.extract(html, @dest, file_path)
+      end
+
+      def find_libretranslate_config
+        return nil unless @site.respond_to?(:pages)
+
+        @site.pages.each do |page|
+          next unless page.data["with_locales"] == true
+
+          config = @config_loader.load_page_config(page.destination(""))
+          return config if config.libretranslate_enabled?
+        end
+
+        nil
+      end
+
+      private
+
+      def construct_page_path(file_path)
+        file_path.sub("#{@dest}/", "")
+      end
+    end
+  end
+end

data/lib/jekyll-l10n/extraction/html_string_extractor.rb

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+require_relative "dom_text_extractor"
+require_relative "dom_attribute_extractor"
+require_relative "logger"
+
+module Jekyll
+  module L10n
+    # Extracts translatable strings from HTML documents for localization.
+    #
+    # HtmlStringExtractor walks the DOM tree of parsed HTML and extracts text content
+    # from content elements and values from configurable HTML attributes. It deduplicates
+    # entries by msgid and generates file location references for each extraction to aid
+    # in debugging and tracking. Entries are excluded based on CSS selectors.
+    #
+    # Key responsibilities:
+    # * Parse HTML into DOM tree
+    # * Walk DOM recursively to find translatable content
+    # * Extract text from content elements (p, h1-h6, li, etc.)
+    # * Extract attribute values (title, alt, aria-label, etc.)
+    # * Generate file location references for each extracted string
+    # * Skip elements matching exclude selectors
+    # * Deduplicate entries by msgid
+    #
+    # @example
+    #   extractor = HtmlStringExtractor.new(['title', 'alt'], ['script', 'style'])
+    #   entries = extractor.extract(html_content, '_site', 'docs/index.html')
+    #   # Returns array of hash entries with :msgid, :msgstr, :reference keys
+    class HtmlStringExtractor
+      attr_reader :translatable_attrs, :exclude_selectors
+
+      # Initialize a new HtmlStringExtractor.
+      #
+      # @param translatable_attrs [Array<String>] HTML attributes to extract
+      #   (e.g., ['title', 'alt', 'aria-label', 'placeholder', 'aria-description'])
+      # @param exclude_selectors [Array<String>] CSS selectors for elements to skip
+      #   during extraction (e.g., ['script', 'style', '.no-translate'])
+      def initialize(translatable_attrs, exclude_selectors)
+        @translatable_attrs = translatable_attrs
+        @exclude_selectors = exclude_selectors
+      end
+
+      # Extract translatable strings from HTML.
+      #
+      # Walks the DOM tree and extracts text nodes from content elements and values
+      # from specified attributes. Each extraction is assigned a file location reference
+      # for debugging. Entries are deduplicated by msgid (multiple occurrences of same
+      # text yield a single entry).
+      #
+      # @param html [String] HTML content to extract from
+      # @param dest [String] Destination directory path (used in file location reference generation)
+      # @param file_path [String] Path to source file (used in file location reference generation)
+      # @return [Array<Hash>] Array of extraction entries, each containing:
+      #   - :msgid [String] The text or attribute value to translate
+      #   - :msgstr [String] Empty string (to be filled by translator)
+      #   - :reference [String] File location reference for debugging
+      def extract(html, dest, file_path)
+        entries = []
+
+        doc = Nokogiri::HTML(html)
+        walk_dom(doc.root, file_path, entries, dest)
+
+        entries.uniq { |e| e[:msgid] }
+      end
+
+      private
+
+      def walk_dom(node, file_path, entries, dest)
+        return if node.nil? || should_exclude_element?(node)
+
+        process_text_content(node, file_path, entries, dest)
+        process_attributes(node, file_path, entries, dest)
+        process_children(node, file_path, entries, dest)
+      end
+
+      def process_text_content(node, file_path, entries, dest)
+        entry = DomTextExtractor.extract(node, file_path, dest)
+        entries << entry if entry
+      end
+
+      def process_attributes(node, file_path, entries, dest)
+        attr_entries = DomAttributeExtractor.extract(node, file_path, dest, @translatable_attrs)
+        entries.concat(attr_entries)
+      end
+
+      def process_children(node, file_path, entries, dest)
+        node.children.each { |child| walk_dom(child, file_path, entries, dest) }
+      end
+
+      def should_exclude_element?(node)
+        return false unless node.element?
+
+        @exclude_selectors.any? { |selector| node.matches?(selector) }
+      rescue Nokogiri::CSS::SyntaxError => e
+        Jekyll.logger.warn "Localization", "CSS selector syntax error: #{e.message}"
+        false
+      rescue StandardError => e
+        Jekyll.logger.warn "Localization", "Selector matching error (continuing): #{e.message}"
+        false
+      end
+    end
+  end
+end

data/lib/jekyll-l10n/extraction/logger.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module Jekyll
+  module L10n
+    # Logs extraction process errors and summary statistics.
+    #
+    # ExtractionLogger provides centralized logging for the extraction pipeline,
+    # recording errors during extraction and final summary statistics including
+    # file count, string count, PO file creation count, and elapsed time.
+    #
+    # Key responsibilities:
+    # * Log extraction errors with file context
+    # * Log extraction summary statistics
+    # * Format statistics output for user visibility
+    #
+    # @see Jekyll::L10n::Extractor for extraction workflow context
+    # @see Jekyll::L10n::CompendiumTranslator for automated translation logging
+    class ExtractionLogger
+      # Log an extraction error.
+      #
+      # @param file_path [String] Path to file where error occurred
+      # @param error [StandardError] The error that occurred
+      # @return [void]
+      def self.log_error(file_path, error)
+        Jekyll.logger.error "Localization", "Error extracting from #{file_path}: #{error.message}"
+      end
+
+      # Log extraction completion summary.
+      #
+      # Logs final statistics about the extraction process including total files
+      # processed, strings extracted, PO files created/updated, and elapsed time.
+      #
+      # @param stats [Hash] Statistics hash with keys:
+      #   - :files_processed [Integer]
+      #   - :strings_extracted [Integer]
+      #   - :po_files_created [Integer]
+      # @param elapsed [Float] Time elapsed in seconds
+      # @return [void]
+      def self.log_summary(stats, elapsed)
+        Jekyll.logger.info "Localization", "Extraction complete:"
+        Jekyll.logger.info "Localization", "  Files processed: #{stats[:files_processed]}"
+        Jekyll.logger.info "Localization", "  Strings extracted: #{stats[:strings_extracted]}"
+        Jekyll.logger.info "Localization", "  PO files created/updated: #{stats[:po_files_created]}"
+        Jekyll.logger.info "Localization", "  Time: #{elapsed.round(2)}s"
+      end
+    end
+  end
+end

data/lib/jekyll-l10n/extraction/result_saver.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+require_relative "../po_file/manager"
+require_relative "../utils/page_locales_config"
+require_relative "../utils/site_config_accessor"
+require_relative "../utils/logger_formatter"
+require_relative "compendium_translator"
+require_relative "compendium_merger"
+
+module Jekyll
+  module L10n
+    # Saves extraction results to PO files and optionally translates compendia.
+    #
+    # ExtractionResultSaver orchestrates the post-extraction process: writing
+    # page-specific PO files for all configured locales, merging with existing
+    # translations, optionally updating compendia, and triggering automatic
+    # translation via LibreTranslate if enabled.
+    #
+    # Key responsibilities:
+    # * Save page-specific PO files for each locale
+    # * Merge new entries with existing translations
+    # * Update compendium files from page-specific extractions
+    # * Trigger automatic translation of compendia
+    # * Report extraction statistics
+    #
+    # @example
+    #   saver = ExtractionResultSaver.new(site)
+    #   stats = saver.save_results(config, entries, 'docs/index.html')
+    #   saver.translate_compendia(config) if config.libretranslate_enabled?
+    class ExtractionResultSaver
+      # Initialize a new ExtractionResultSaver.
+      #
+      # @param site [Jekyll::Site] Jekyll site object
+      def initialize(site)
+        @site = site
+        with_locales_data = SiteConfigAccessor.extract_locales_data(@site)
+        @site_config = PageLocalesConfig.new({ "with_locales_data" => with_locales_data })
+      end
+
+      # Save extraction results to PO files.
+      #
+      # Saves extracted strings to PO files for each configured locale, merging with
+      # existing translations to preserve manual edits. Optionally merges new entries
+      # into compendium files. Returns statistics about the save operation.
+      #
+      # @param config [PageLocalesConfig] Localization configuration
+      # @param entries [Array<Hash>] Array of extracted entries with :msgid, :msgstr, :reference
+      # @param page_path [String] Page path for file organization (e.g., 'docs/index.html')
+      # @return [Hash] Statistics hash with keys:
+      #   - :files_processed [Integer] Number of pages processed (always 1)
+      #   - :strings_extracted [Integer] Number of extracted strings
+      #   - :po_files_created [Integer] Number of PO files created/updated
+      def save_results(config, entries, page_path)
+        LoggerFormatter.debug_if_enabled("ExtractionResultSaver", "Processing page: #{page_path}")
+
+        po_manager = PoFileManager.new(@site, config.locales_dir)
+        po_files_created = save_po_files(po_manager, config, entries, page_path)
+
+        {
+          :files_processed   => 1,
+          :strings_extracted => entries.length,
+          :po_files_created  => po_files_created,
+        }
+      end
+
+      # Translate compendia using LibreTranslate.
+      #
+      # If LibreTranslate is enabled in config, translates all empty entries in
+      # compendium files for configured locales. Called after extraction and
+      # compendium merging to fill in translations automatically.
+      #
+      # @param config [PageLocalesConfig] Localization configuration with LibreTranslate settings
+      # @return [void]
+      def translate_compendia(config)
+        CompendiumTranslator.new(@site).translate_compendia(config)
+      end
+
+      private
+
+      def save_po_files(po_manager, config, entries, page_path)
+        po_files_created = 0
+
+        config.locales.each do |locale|
+          po_files_created += 1 if po_manager.save_po_file(locale, entries, :page_path => page_path)
+        end
+
+        CompendiumMerger.new(@site).merge_compendia(po_manager, config) if config.update_compendium?
+
+        po_files_created
+      end
+
+      private :save_po_files
+    end
+  end
+end