jekyll-l10n 1.3.15 → 1.4.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4dfd489e89732a8083e339c87e7ac32f3ceff7723be4a963303649eff9e397f9
-  data.tar.gz: aa3f4cdc2756e7923307e9fa9f26ad37ee06709c9ce7a47cb3a20a35fbb304dd
+  metadata.gz: 1c8edcdac30ed6d89b587d914f1b8038ffd3b10a95a0e15cc43965dd915e39f2
+  data.tar.gz: 513218e1e01c3814a2f7130f60a6b35463d0836659ee13d85ae3d7c9a0aaf6c5
 SHA512:
-  metadata.gz: ec106808864ebc0bdf6e278e4dcdbd29d4a56e58b8474cfa706738dd4065b71b65f844815061a86b6335dd64b26ca5c669bb4bdcc4447d4b5a2ce7c16b6b80d5
-  data.tar.gz: e5e4a5a0af33c57cb526c2a9de8ecd84845d60b4eddd44f39d417e3f7bab6e1bf39a2da09a54566b919216e3cc4a058de09762038b695287827625f6eda7dd04
+  metadata.gz: 24586cc374d7ad819cbda298c98d9dc70438b60bc7afafcc6d695190bb62dc6294ddfd4bb02fb4f04c57c3231cea3fe12047dc9bdf3eb0de5390c6e4fb7a0970
+  data.tar.gz: f5f5bb5755c8354794fd81090c74c0519f06fb15c216cc1b9ba748e5837dcef7b7a05c324d5f67feef8c544884e17a936d492c76132ac26cb7f0d6f0bafa22e6

data/lib/jekyll-l10n/po_file/writer.rb

@@ -189,7 +189,7 @@ module Jekyll
       end
 
       def self.escape_backslashes(value)
-        value.gsub('\\', '\\\\')
+        value.gsub('\\') { '\\\\' }
       end
 
       def self.escape_quotes_and_get_delimiter(escaped)

data/lib/jekyll-l10n/translation/block_text_extractor.rb

@@ -19,7 +19,6 @@ module Jekyll
     # * Remove nested block elements from text
     # * Remove empty icon tags (external link markers)
     # * Normalize and validate extracted text
-    # * Decode HTML entities
     #
     # @example
     #   text = BlockTextExtractor.extract(paragraph_node)
@@ -31,7 +30,8 @@ module Jekyll
       #
       # Returns nil if element is not extractable or if extracted text fails
       # validation. Clones the node, removes nested block elements and empty
-      # icon tags, normalizes whitespace, decodes HTML entities, and validates.
+      # icon tags, normalizes whitespace, and validates. HTML entities are
+      # preserved verbatim to match the keys produced by the extraction pipeline.
       #
       # @param node [Nokogiri::XML::Element] DOM element to extract from
       # @return [String, nil] Normalized text from element, or nil if not valid
@@ -39,11 +39,11 @@ module Jekyll
         return nil unless extractable?(node)
 
         clone = node.dup
+        HtmlTextUtils.remove_code_blocks(clone)
         HtmlTextUtils.remove_block_elements(clone)
         HtmlTextUtils.remove_empty_icon_tags(clone)
 
         text = TextNormalizer.normalize(clone.inner_html).strip
-        text = HtmlTextUtils.decode_html_entities(text)
 
         TextValidator.valid?(text) ? text : nil
       end

data/lib/jekyll-l10n/translation/html_translator.rb

@@ -108,7 +108,7 @@ module Jekyll
         normalized_text = TextNormalizer.normalize(text)
         translated = TranslationResolver.resolve(node, normalized_text, translations)
 
-        return if apply_block_level_translation?(node, normalized_text, translated)
+        return if apply_block_level_translation?(node, normalized_text, translations)
 
         if @debug_logging
           log_translation_debug_info(text, normalized_text, translated,
@@ -147,9 +147,15 @@ module Jekyll
                              "[HtmlTranslator]   Translation: #{translation[0..truncate_length]}..."
         end
 
+        inject_translation_preserving_structure(parent, translation)
+      end
+
+      def inject_translation_preserving_structure(parent, translation)
+        preserved_blocks  = parent.css('pre').map(&:dup)
         preserved_anchors = parent.css('.heading-anchor').map(&:dup)
         parent.children.each(&:remove)
         parent.inner_html = translation
+        preserved_blocks.each  { |b| parent.add_child(b) }
         preserved_anchors.each { |a| parent.add_child(a) } if parent.css('.heading-anchor').empty?
       end
 
@@ -204,18 +210,45 @@ module Jekyll
         @debug_logging && text.include?('attribute')
       end
 
-      def apply_block_level_translation?(node, normalized_text, translated)
-        return false unless translated && node.parent && content_element?(node.parent)
+      def apply_block_level_translation?(node, normalized_text, translations)
+        ancestor = find_content_element_ancestor(node)
+        return false unless ancestor
 
-        return false if TranslationResolver.contains_protected_elements?(node.parent)
+        return false if TranslationResolver.contains_protected_elements?(ancestor)
 
-        block_text = BlockTextExtractor.extract(node.parent)
+        block_text = BlockTextExtractor.extract(ancestor)
         return false unless block_text && block_text != normalized_text
 
-        apply_block_level_translation(node.parent, translated)
+        translation = select_block_translation(node, ancestor, normalized_text, block_text,
+                                               translations)
+        return false unless translation
+
+        apply_block_level_translation(ancestor, translation)
         true
       end
 
+      # When text is directly inside a content element, prefer its direct translation
+      # (the msgstr may itself contain HTML, e.g. a heading with an anchor).
+      # When text is nested inside inline element(s), only apply if the full block
+      # text is an explicit translation key.
+      def select_block_translation(node, ancestor, normalized_text, block_text, translations)
+        if node.parent == ancestor
+          translations[normalized_text] || translations[block_text]
+        else
+          translations[block_text]
+        end
+      end
+
+      def find_content_element_ancestor(node)
+        current = node&.parent
+        while current&.element?
+          return current if content_element?(current)
+
+          current = current.parent
+        end
+        nil
+      end
+
       def log_translation_debug_info(text, normalized_text, translated, translations)
         translation_data = DebugLogger::TranslationData.new(text: text,
                                                             normalized_text: normalized_text,
@@ -225,7 +258,9 @@ module Jekyll
       end
 
       private :log_text_node_debug, :should_skip_translation?, :should_log_text_debug?,
-              :apply_block_level_translation?, :log_translation_debug_info
+              :apply_block_level_translation?, :select_block_translation,
+              :find_content_element_ancestor, :log_translation_debug_info,
+              :inject_translation_preserving_structure
     end
   end
 end

data/lib/jekyll-l10n/utils/html_text_utils.rb

@@ -48,6 +48,22 @@ module Jekyll
             .gsub(''', "'")
       end
 
+      # Remove preformatted code blocks from a node.
+      #
+      # Removes all <pre> elements entirely. With highlighter: none in Jekyll config,
+      # fenced code blocks produce plain <pre><code> as direct children of content
+      # elements — no Rouge wrappers. Removing <pre> before extraction ensures raw
+      # code never appears in PO msgids.
+      #
+      # Must run before remove_block_elements_from_node so that <code> inside <pre>
+      # is gone before the general flattening pass.
+      #
+      # @param node [Nokogiri::XML::Node] Node to process (modified in place)
+      # @return [void]
+      def self.remove_code_blocks(node)
+        node.css('pre').each(&:remove)
+      end
+
       # Remove block-level elements from a cloned node.
       #
       # Replaces block-level element nodes with their children (flattening structure).
@@ -89,18 +105,20 @@ module Jekyll
       # Extract text with inline tags preserved.
       #
       # Extracts text from an element, removes block elements and empty icons,
-      # normalizes whitespace, and decodes HTML entities. Returns plain text
-      # suitable for translation.
+      # and normalizes whitespace. HTML entities (e.g. &lt;, &gt;) are preserved
+      # verbatim so that entity-encoded content inside inline elements (such as
+      # <code>&lt;p&gt;</code>) is written to PO msgids as-is and does not
+      # become a live HTML tag when the msgstr is later injected via inner_html.
       #
       # @param node [Nokogiri::XML::Node] Element to extract from
       # @return [String] Extracted and normalized text
       def self.extract_with_inline_tags(node)
         clone = node.dup
+        remove_code_blocks(clone)
         remove_block_elements_from_node(clone)
         remove_empty_icon_tags(clone)
 
         text = TextNormalizer.normalize(clone.inner_html)
-        text = decode_html_entities(text)
         text&.then { |t| TextNormalizer.normalize(t).strip }
       end
 

data/lib/jekyll-l10n/utils/translation_resolver.rb

@@ -47,7 +47,7 @@ module Jekyll
       # node alone doesn't have a direct translation but the entire block does.
       #
       # Security consideration: Returns nil if the block contains protected elements
-      # (script, style, pre tags) to prevent unsafe translation application.
+      # (script, style) to prevent unsafe translation application.
       #
       # @param node [Nokogiri::XML::Node] Text node being translated
       # @param text [String] Normalized text of the node
@@ -59,13 +59,12 @@ module Jekyll
       #   # Returns nil (protected element present, prevents block translation)
       #   TranslationResolver.try_block_level_translation(node, "text", translations)
       def self.try_block_level_translation(node, text, translations)
-        return nil unless node.parent && content_element?(node.parent)
+        ancestor = find_content_element_ancestor(node)
+        return nil unless ancestor
 
-        # Don't attempt block-level translation if parent contains protected elements
-        # (script, style, pre). These cannot be safely applied at block level.
-        return nil if contains_protected_elements?(node.parent)
+        return nil if contains_protected_elements?(ancestor)
 
-        block_text = BlockTextExtractor.extract(node.parent)
+        block_text = BlockTextExtractor.extract(ancestor)
         return nil unless block_text && block_text != text
 
         translations[block_text]
@@ -78,15 +77,24 @@ module Jekyll
         HtmlElements::CONTENT_ELEMENTS.include?(node.name)
       end
 
+      def self.find_content_element_ancestor(node)
+        current = node&.parent
+        while current&.element?
+          return current if content_element?(current)
+
+          current = current.parent
+        end
+        nil
+      end
+      private_class_method :find_content_element_ancestor
+
       # Check if an element contains protected child elements that block translations.
       #
-      # Protected elements (script, style, pre) cannot have their surrounding text
-      # translated at the block level because:
-      # * script/style: Security and functionality reasons (executable content)
-      # * pre: Multi-line code blocks where translations break formatting
-      #
-      # This is a shared utility used by both HtmlTranslator and TranslationResolver
-      # to ensure consistent protection of sensitive content across the codebase.
+      # Protected elements (script, style) cannot have their surrounding text
+      # translated at the block level for security and functionality reasons.
+      # <pre> is not protected here — HtmlTextUtils.remove_code_blocks strips it
+      # before extraction so code content never reaches PO msgids, and
+      # HtmlTranslator preserves <pre> verbatim across translation injection.
       #
       # @param node [Nokogiri::XML::Node] Element to check
       # @return [Boolean] true if node contains protected elements, false otherwise
@@ -101,13 +109,12 @@ module Jekyll
       #   doc = Nokogiri::HTML('<p><code>inline</code> text</p>')
       #   para = doc.xpath('//p').first
       #   TranslationResolver.contains_protected_elements?(para)
-      #   # => false (code is allowed, only script/style/pre are protected)
+      #   # => false (code is allowed, only script/style are protected)
       def self.contains_protected_elements?(node)
         return false unless node.element?
 
-        # Block block-level translation for script, style (security/functionality),
-        # and pre (multi-line code blocks). These cannot be safely applied at block level.
-        protected_elements = %w[script style pre]
+        # Block block-level translation for script and style (security/functionality).
+        protected_elements = %w[script style]
         node.children.any? { |child| child.element? && protected_elements.include?(child.name) }
       end
     end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: jekyll-l10n
 version: !ruby/object:Gem::Version
-  version: 1.3.15
+  version: 1.4.1
 platform: ruby
 authors:
 - ReleaseBot