jekyll-l10n 2.0.0 → 3.0.0

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

@@ -4,7 +4,6 @@ require 'fileutils'
 require_relative '../po_file/manager'
 require_relative '../po_file/fuzzy_matcher'
 require_relative '../utils/page_locales_config'
-require_relative '../utils/site_config_accessor'
 
 module Jekyll
   module L10n
@@ -35,8 +34,6 @@ module Jekyll
       # @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
 
       # Merge page-specific PO files into compendia for all locales.
@@ -49,8 +46,11 @@ module Jekyll
       # @param config [PageLocalesConfig] Localization configuration with locales list
       # @return [void]
       def merge_compendia(po_manager, config)
+        # Fuzzy scores depend only on the two English strings, and every
+        # locale compares the same new strings, so they are scored once per run.
+        @fuzzy_scores = {}
         config.locales.each do |locale|
-          process_locale(locale, po_manager, config)
+          process_locale(locale, po_manager)
         end
       end
 
@@ -58,9 +58,8 @@ module Jekyll
 
       # Process a single locale: merge existing compendium with new page translations
       # Skips writing when translations are unchanged to avoid unnecessary file rewrites
-      def process_locale(locale, po_manager, config)
-        compendium_path = File.join(@site.source, config.locales_dir, "#{locale}.po")
-        existing_compendium = load_existing_compendium(compendium_path)
+      def process_locale(locale, po_manager)
+        existing_compendium = load_existing_compendium(po_manager.compendium_path(locale))
         merged = po_manager.merge_po_files(locale)
 
         combined = build_combined_hash(existing_compendium)
@@ -70,7 +69,7 @@ module Jekyll
           combined_entries = format_compendium_entries(combined)
           po_manager.save_compendium(locale, combined_entries)
         end
-        cleanup_locale_directory(locale, config)
+        cleanup_locale_directory(po_manager.locale_dir(locale))
       end
 
       # Check if compendium content is unchanged (same msgids and msgstrs)
@@ -146,7 +145,7 @@ module Jekyll
       end
 
       def resolve_new_entry(combined, msgid, entry, fuzzy_candidates, matched_old_msgids)
-        match = PoFuzzyMatcher.find_match(msgid, fuzzy_candidates)
+        match = PoFuzzyMatcher.find_match(msgid, fuzzy_candidates, scores: @fuzzy_scores)
         if match
           combined[msgid] = create_fuzzy_entry(entry, match)
           matched_old_msgids << match[:msgid]
@@ -195,8 +194,7 @@ module Jekyll
 
       # IMPORTANT: Remove locale-specific directory after compendium merge
       # This cleans up page-specific PO files that have been merged into the compendium
-      def cleanup_locale_directory(locale, config)
-        locale_dir = File.join(@site.source, config.locales_dir, locale)
+      def cleanup_locale_directory(locale_dir)
         FileUtils.rm_rf(locale_dir) if File.directory?(locale_dir)
       end
 

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

@@ -1,9 +1,10 @@
 # frozen_string_literal: true
 
+require_relative '../constants'
+require_relative '../instrumentation'
 require_relative '../po_file/manager'
 require_relative '../utils/page_locales_config'
 require_relative '../utils/po_entry_converter'
-require_relative '../utils/site_config_accessor'
 require_relative '../utils/logger_formatter'
 require_relative '../translation/libre_translator'
 
@@ -33,18 +34,19 @@ module Jekyll
       # @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
 
       # Translate compendia for all configured locales.
       #
       # Checks if LibreTranslate is enabled. If so, for each configured locale,
       # loads the compendium PO file, identifies untranslated entries, sends them
-      # to LibreTranslate API, and saves the updated file.
+      # to LibreTranslate API, and saves the updated file. Locales are
+      # translated at once; their requests share libretranslate_concurrency.
       #
       # @param config [PageLocalesConfig] Localization configuration
       # @return [void]
+      # @raise [LibreTranslator::TranslationError] If a locale failed, once
+      #   every locale has finished; the locales that finished are saved
       def translate_compendia(config)
         po_manager = PoFileManager.new(@site, config.locales_dir)
         translate_compendia_for_locale(po_manager, config)
@@ -59,15 +61,29 @@ module Jekyll
         log_translation_start(config)
         translator = LibreTranslator.new(config)
 
-        config.locales.each do |locale|
-          process_single_locale(locale, config, translator, po_manager)
+        threads = config.locales.map do |locale|
+          Instrumentation.traced_thread do
+            Thread.current.report_on_exception = false
+            process_single_locale(locale, translator, po_manager)
+          end
         end
+        join_locales(threads)
 
         log_translation_complete(config)
       end
 
-      def process_single_locale(locale, config, translator, po_manager)
-        compendium_path = File.join(@site.source, config.locales_dir, "#{locale}.po")
+      def join_locales(threads)
+        first_error = nil
+        threads.each do |thread|
+          thread.join
+        rescue StandardError => e
+          first_error ||= e
+        end
+        raise first_error if first_error
+      end
+
+      def process_single_locale(locale, translator, po_manager)
+        compendium_path = po_manager.compendium_path(locale)
         LoggerFormatter.debug_if_enabled('CompendiumTranslator',
                                          "Processing compendium file: #{compendium_path}")
         return unless File.exist?(compendium_path)
@@ -119,17 +135,17 @@ module Jekyll
 
       def log_translation_start(config)
         locales = config.locales.join(', ')
-        Jekyll.logger.info 'Localization',
+        Jekyll.logger.info Constants::LOG_PREFIX,
                            "Starting LibreTranslate translation for locales: #{locales}"
       end
 
       def log_translation_complete(config)
         locales = config.locales.join(', ')
-        Jekyll.logger.info 'Localization',
+        Jekyll.logger.info Constants::LOG_PREFIX,
                            "LibreTranslate translation complete for locales: #{locales}"
       end
 
-      private :translate_compendia_for_locale, :process_single_locale,
+      private :translate_compendia_for_locale, :join_locales, :process_single_locale,
               :log_compendia_enabled_check, :log_compendium_stats,
               :log_translation_complete_for_locale, :log_compendium_saved,
               :count_empty_entries, :log_translation_start, :log_translation_complete

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

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require_relative '../configuration'
 require_relative '../utils/page_locales_config'
 require_relative '../utils/locale_url_formatter'
 require_relative '../utils/site_config_accessor'
@@ -51,7 +52,7 @@ module Jekyll
       # @return [Hash, nil] The page data, or nil when no localized page matches
       def find_page_config_for_file(file_path)
         @site.pages.each do |page|
-          next unless page.data['with_locales'] == true
+          next unless Configuration.localizable?(page)
 
           page_output = page.output_ext ? page.destination('') : page.destination('/')
           next unless file_path.end_with?(page_output.sub(%r{/$}, '/index.html'))
@@ -77,10 +78,9 @@ module Jekyll
 
       # @param config [PageLocalesConfig] The page's settings
       # @return [Array<String>] CSS selectors of elements to leave out of
-      #   extraction, from `extraction.exclude_selectors` or the defaults below
+      #   extraction (see PageLocalesConfig#exclude_selectors)
       def extract_exclude_selectors(config)
-        config.data.dig('with_locales_data', 'extraction', 'exclude_selectors') ||
-          ['script', 'style', 'code.language-plaintext', 'pre code']
+        config.exclude_selectors
       end
     end
   end

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

@@ -0,0 +1,129 @@
+# frozen_string_literal: true
+
+require_relative '../constants'
+require_relative '../errors'
+require_relative '../po_file/path_builder'
+require_relative '../po_file/reader'
+require_relative '../utils/msgstr_validator'
+
+module Jekyll
+  module L10n
+    # Counts how much of each locale's compendium is translated.
+    #
+    # Each entry counts once, as translated, fuzzy, untranslated, or invalid
+    # (a msgstr whose markup MsgstrValidator rejects, so pages use the
+    # fallback). Extractor warns about each invalid entry, prints the counts
+    # with the extraction summary, and fails the build when a locale is below
+    # `translation.min_coverage`.
+    #
+    # Only entries whose msgid this build extracted count: a compendium also
+    # keeps entries for text the site no longer has. The counts come from the
+    # compendium files as they are after extraction, so with
+    # `update_compendium: false` they leave out strings no compendium holds
+    # yet.
+    #
+    # @example
+    #   report = CoverageReport.new(site, SiteConfigAccessor.site_config(site, all_locales: true),
+    #                               extracted_msgids)
+    #   report.warn_invalid
+    #   report.log
+    #   report.enforce!(90)  # raises Errors::CoverageError below 90%
+    class CoverageReport
+      # Entry counts for one locale.
+      Counts = Struct.new(:locale, :translated, :fuzzy, :untranslated, :invalid) do
+        # @return [Integer] Entries in the compendium
+        def total
+          translated + fuzzy + untranslated + invalid
+        end
+
+        # @return [Float] Translated entries as a percentage; 100 when the
+        #   compendium is empty
+        def percent
+          total.zero? ? 100.0 : translated * 100.0 / total
+        end
+
+        # @return [String] e.g. "fr: 92.5% translated (1200 of 1297; 40 fuzzy, 50 untranslated, 7 invalid)"
+        def to_s
+          "#{locale}: #{percent.round(1)}% translated (#{translated} of #{total}; " \
+            "#{fuzzy} fuzzy, #{untranslated} untranslated, #{invalid} invalid)"
+        end
+      end
+
+      # @param site [Jekyll::Site]
+      # @param config [PageLocalesConfig] The site config, for locales and locales_dir
+      # @param msgids [Set<String>] The msgids this build extracted
+      def initialize(site, config, msgids)
+        @site = site
+        @config = config
+        @msgids = msgids
+        @invalid = Hash.new { |hash, locale| hash[locale] = [] }
+      end
+
+      # @return [Array<Counts>] One entry per locale that has a compendium
+      def counts
+        @counts ||= @config.locales.filter_map do |locale|
+          path = PoPathBuilder.build(@site.source, @config.locales_dir, locale, nil)
+          count(locale, PoFileReader.parse_for_merge(path)) if File.exist?(path)
+        end
+      end
+
+      # Warn about each entry whose msgstr markup does not match its msgid.
+      #
+      # @return [void]
+      def warn_invalid
+        counts.each do |locale_counts|
+          @invalid[locale_counts.locale].each do |msgid|
+            Jekyll.logger.warn Constants::LOG_PREFIX,
+                               "#{locale_counts.locale}: msgstr markup does not match its msgid, " \
+                               "so pages show the fallback: #{msgid[0..Constants::LOG_TRUNCATE_LONG]}"
+          end
+        end
+      end
+
+      # Print one line per locale.
+      #
+      # @return [void]
+      def log
+        return if counts.empty?
+
+        Jekyll.logger.info Constants::LOG_PREFIX, 'Translation coverage:'
+        counts.each { |locale_counts| Jekyll.logger.info Constants::LOG_PREFIX, "  #{locale_counts}" }
+      end
+
+      # @param minimum [Integer, nil] Required percentage, or nil for none
+      # @return [void]
+      # @raise [Errors::CoverageError] When any locale is below the minimum
+      def enforce!(minimum)
+        return if minimum.nil?
+
+        below = counts.select { |locale_counts| locale_counts.percent < minimum }
+        return if below.empty?
+
+        raise Errors::CoverageError,
+              "Translation coverage is below translation.min_coverage (#{minimum}%): #{below.join('; ')}"
+      end
+
+      private
+
+      def count(locale, entries)
+        tally = Hash.new(0)
+        entries.each do |msgid, entry|
+          next unless @msgids.include?(msgid)
+
+          entry_state = state(msgid, entry)
+          tally[entry_state] += 1
+          @invalid[locale] << msgid if entry_state == :invalid
+        end
+        Counts.new(locale, tally[:translated], tally[:fuzzy], tally[:untranslated], tally[:invalid])
+      end
+
+      def state(msgid, entry)
+        if entry[:fuzzy] then :fuzzy
+        elsif entry[:msgstr].to_s.empty? then :untranslated
+        elsif MsgstrValidator.valid?(msgid, entry[:msgstr]) then :translated
+        else :invalid
+        end
+      end
+    end
+  end
+end

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

@@ -3,8 +3,6 @@
 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
@@ -27,7 +25,7 @@ module Jekyll
     #   entry = DomTextExtractor.extract(node, 'docs/index.html', '_site')
     #   # Returns hash with :msgid, :msgstr, :reference if valid text found
     module DomTextExtractor
-      extend self
+      module_function
 
       # Extract text content from an HTML element.
       #
@@ -56,34 +54,7 @@ module Jekyll
       end
 
       def extract_block_text(node)
-        return nil if only_contains_block_elements?(node)
-        return nil if HtmlTextUtils.layout_block_children?(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) }
+        HtmlTextUtils.block_text(node)
       end
     end
   end

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

@@ -1,9 +1,13 @@
 # frozen_string_literal: true
 
+require 'set'
+require_relative '../configuration'
+require_relative '../constants'
 require_relative 'config_loader'
 require_relative 'result_saver'
 require_relative 'logger'
 require_relative 'html_string_extractor'
+require_relative 'coverage_report'
 require_relative '../utils/file_operations'
 require_relative '../utils/site_config_accessor'
 require_relative '../utils/error_handler'
@@ -20,7 +24,10 @@ module Jekyll
     # 3. Merges those files into one compendium per locale (unless
     #    `update_compendium` is false). The merge deletes the page files.
     # 4. Machine-translates the compendia when LibreTranslate is on.
-    # 5. Prints a summary unless `logging.show_statistics` is false.
+    # 5. Prints a summary and each locale's translation coverage unless
+    #    `logging.show_statistics` is false.
+    # 6. Fails the build when a locale's coverage is below
+    #    `translation.min_coverage`.
     #
     # It always processes the whole site. Incremental mode does not affect it.
     #
@@ -43,19 +50,22 @@ module Jekyll
         @dest = SiteConfigAccessor.dest(@site)
         @config_loader = ExtractionConfigLoader.new(@site, @dest)
         @result_saver = ExtractionResultSaver.new(@site)
+        @extracted_msgids = Set.new
       end
 
       # Runs all the steps in the class description.
       #
       # @return [Hash<Symbol, Integer>] Counts under :files_processed,
       #   :strings_extracted, and :po_files_created (files created or updated)
+      # @raise [Errors::CoverageError] When a locale is below `translation.min_coverage`
       def extract_site
-        Jekyll.logger.info 'Localization', 'Extracting translatable strings...'
+        Jekyll.logger.info Constants::LOG_PREFIX, 'Extracting translatable strings...'
         start_time = Time.now
         stats = process_all_html_files
         @result_saver.finalize_compendia
         translate_all_compendia
         ExtractionLogger.log_summary(stats, Time.now - start_time) if show_statistics?
+        check_coverage
         stats
       end
 
@@ -84,20 +94,6 @@ module Jekyll
         end
       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
@@ -108,32 +104,56 @@ module Jekyll
         html = FileOperations.read_utf8(file_path)
         exclude_selectors = @config_loader.extract_exclude_selectors(config)
 
-        extractor = HtmlStringExtractor.new(config.translatable_attributes, exclude_selectors)
+        extractor = HtmlStringExtractor.new(config.translatable_attributes, exclude_selectors,
+                                            baseurl: @site.config['baseurl'] || '')
         extractor.extract(html, @dest, file_path)
       end
 
-      # Machine translation uses the settings of the first localized page that
-      # turns LibreTranslate on, including that page's `locales`.
+      # Machine translation is a site-wide step: it reads the `jekyll_l10n`
+      # settings and covers every locale the site uses.
+      #
+      # @return [PageLocalesConfig, nil] The site config, or nil when
+      #   LibreTranslate is off
       def find_libretranslate_config
         return nil unless @site.respond_to?(:pages)
 
-        @site.pages.each do |page|
-          next unless page.data['with_locales'] == true
+        config = SiteConfigAccessor.site_config(@site, all_locales: true)
+        config if config.libretranslate_enabled?
+      end
 
-          config = @config_loader.load_page_config(page.destination(''))
-          return config if config.libretranslate_enabled?
-        end
+      private
+
+      # per-page body called from the html_files loop in process_all_html_files
+      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?
 
-        nil
+        @extracted_msgids.merge(entries.map { |entry| entry[:msgid] })
+
+        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
 
-      private
+      # Runs after machine translation, so its entries count, and outside
+      # ErrorHandler, so a CoverageError fails the build.
+      def check_coverage
+        config = SiteConfigAccessor.site_config(@site, all_locales: true)
+        report = CoverageReport.new(@site, config, @extracted_msgids)
+        report.warn_invalid
+        report.log if config.show_statistics?
+        report.enforce!(config.min_coverage)
+      end
 
       # The summary covers the whole site, so read the site-wide setting, not a
       # page's.
       def show_statistics?
-        site_data = SiteConfigAccessor.extract_locales_data(@site)
-        PageLocalesConfig.new('with_locales_data' => site_data).show_statistics?
+        SiteConfigAccessor.site_config(@site).show_statistics?
       end
 
       def construct_page_path(file_path)

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

@@ -1,8 +1,12 @@
 # frozen_string_literal: true
 
+require_relative '../constants'
 require_relative 'dom_text_extractor'
 require_relative 'dom_attribute_extractor'
 require_relative 'logger'
+require_relative '../utils/baseurl_normalizer'
+require_relative '../utils/html_elements'
+require_relative '../utils/html_parser'
 
 module Jekyll
   module L10n
@@ -27,7 +31,7 @@ module Jekyll
     #   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
+      attr_reader :translatable_attrs, :exclude_selectors, :baseurl
 
       # Initialize a new HtmlStringExtractor.
       #
@@ -35,9 +39,12 @@ module Jekyll
       #   (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)
+      # @param baseurl [String] (keyword) Site baseurl, kept out of msgids
+      #   (see {BaseurlNormalizer})
+      def initialize(translatable_attrs, exclude_selectors, baseurl: '')
         @translatable_attrs = translatable_attrs
         @exclude_selectors = exclude_selectors
+        @baseurl = baseurl
       end
 
       # Extract translatable strings from HTML.
@@ -57,7 +64,8 @@ module Jekyll
       def extract(html, dest, file_path)
         entries = []
 
-        doc = Nokogiri::HTML(html)
+        doc = HtmlParser.parse_document(html)
+        BaseurlNormalizer.strip(doc, @baseurl)
         walk_dom(doc.root, file_path, entries, dest)
 
         entries.uniq { |e| e[:msgid] }
@@ -65,17 +73,23 @@ module Jekyll
 
       private
 
-      def walk_dom(node, file_path, entries, dest)
+      # Below a content element that has a msgid, inline text is translated only
+      # as part of that msgid, so it gets none of its own (covered). A nested
+      # content element is looked up by its own msgid, so it is extracted again
+      # and decides coverage for its own descendants.
+      def walk_dom(node, file_path, entries, dest, covered: false)
         return if node.nil? || should_exclude_element?(node)
 
-        process_text_content(node, file_path, entries, dest)
+        block = node.element? && HtmlElements::CONTENT_ELEMENTS.include?(node.name)
+        entry = process_text_content(node, file_path, entries, dest) if block || !covered
         process_attributes(node, file_path, entries, dest)
-        process_children(node, file_path, entries, dest)
+        process_children(node, file_path, entries, dest, covered: block ? !entry.nil? : covered)
       end
 
       def process_text_content(node, file_path, entries, dest)
         entry = DomTextExtractor.extract(node, file_path, dest)
         entries << entry if entry
+        entry
       end
 
       def process_attributes(node, file_path, entries, dest)
@@ -83,8 +97,8 @@ module Jekyll
         entries.concat(attr_entries)
       end
 
-      def process_children(node, file_path, entries, dest)
-        node.children.each { |child| walk_dom(child, file_path, entries, dest) }
+      def process_children(node, file_path, entries, dest, covered: false)
+        node.children.each { |child| walk_dom(child, file_path, entries, dest, covered: covered) }
       end
 
       def should_exclude_element?(node)
@@ -92,10 +106,10 @@ module Jekyll
 
         @exclude_selectors.any? { |selector| node.matches?(selector) }
       rescue Nokogiri::CSS::SyntaxError => e
-        Jekyll.logger.warn 'Localization', "CSS selector syntax error: #{e.message}"
+        Jekyll.logger.warn Constants::LOG_PREFIX, "CSS selector syntax error: #{e.message}"
         false
       rescue StandardError => e
-        Jekyll.logger.warn 'Localization', "Selector matching error (continuing): #{e.message}"
+        Jekyll.logger.warn Constants::LOG_PREFIX, "Selector matching error (continuing): #{e.message}"
         false
       end
     end

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

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require_relative '../constants'
 require_relative '../utils/error_handler'
 
 module Jekyll
@@ -39,11 +40,11 @@ module Jekyll
       # @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"
+        Jekyll.logger.info Constants::LOG_PREFIX, 'Extraction complete:'
+        Jekyll.logger.info Constants::LOG_PREFIX, "  Files processed: #{stats[:files_processed]}"
+        Jekyll.logger.info Constants::LOG_PREFIX, "  Strings extracted: #{stats[:strings_extracted]}"
+        Jekyll.logger.info Constants::LOG_PREFIX, "  PO files created/updated: #{stats[:po_files_created]}"
+        Jekyll.logger.info Constants::LOG_PREFIX, "  Time: #{elapsed.round(2)}s"
       end
     end
   end

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

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require_relative '../configuration'
 require_relative '../po_file/manager'
 require_relative '../utils/page_locales_config'
 require_relative '../utils/site_config_accessor'
@@ -33,8 +34,7 @@ module Jekyll
       # @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 })
+        @site_config = SiteConfigAccessor.site_config(@site)
       end
 
       # Save extraction results to PO files.
@@ -105,17 +105,12 @@ module Jekyll
         po_files_created
       end
 
-      # Build a PageLocalesConfig whose locale list is the union of site-wide
-      # defaults and every page-level front-matter locale override.
-      #
-      # All other site-wide settings (locales_dir, extraction, translation,
-      # logging, etc.) are preserved unchanged; only the locale list is widened.
+      # The site config with every locale any page uses, not only the
+      # site-wide list (see SiteConfigAccessor.all_configured_locales).
       #
       # @return [PageLocalesConfig]
       def merge_config
-        all_locales = SiteConfigAccessor.all_configured_locales(@site)
-        merged_data = (@site_config.data['with_locales_data'] || {}).merge('locales' => all_locales)
-        PageLocalesConfig.new({ 'with_locales_data' => merged_data })
+        SiteConfigAccessor.site_config(@site, all_locales: true)
       end
 
       private :save_po_files