markbridge 0.4.2 → 0.4.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: fa422d5e0a05eee7f32524e42823d02a552111132025fd9ede1fc5045a79412e
-  data.tar.gz: cc7af6319a7c9dde74a764dc9edaab186ef2cca92bc6fabd842a147216adaec0
+  metadata.gz: 356955e6ba849a6acb08902465ed0d45c710020183d75eca66d3904b93995f3c
+  data.tar.gz: 4c1bf20ea2c024478cdfa6bbea5ceade531de96085a2cc911499a0c8d31d78ad
 SHA512:
-  metadata.gz: 2eb57814326cf0fbaf2e356290d962a0a9e8bf2b9c38aa4e41ad7526d9494574162fc5384473b15c833b4e34bd7f322bf464098337bf9d535662f615590c19e4
-  data.tar.gz: d4fc22c47cc54ab91a0d29b140bf69317c5c10aae3358758b0036b213f96ddca9318d723016854819a8a80dcf03ea5f66180eaccc8df2d550d06ab69b8f25a87
+  metadata.gz: 0fbb3282126a07f194e4c833bc2694b91a64b877144e6ea0317ff2f62785a28dd144a969cc5d4a3fc1eda3306fa1416496cc478b6fe51ffe4862dba9f468a288
+  data.tar.gz: 0624ec779e99b904de91eb2d519b65ee7c123d2b8e8d51c659b4ce5005afc521bd2290e07517a7f9aaf5ea9e19998354b31e7a6818e27fe55dceb02da22cad41

data/lib/markbridge/parsers/bbcode/handler_registry.rb

@@ -32,8 +32,13 @@ module Markbridge
         def register(tag_names, handler)
           element_class = handler.element_class
           Array(tag_names).each { |tag_name| @handlers[tag_name.to_s.downcase] = handler }
-          @element_handlers[element_class] = handler
+          # The conditional write goes first. Both writes are independent and
+          # keyed by element_class, so the order makes no difference to a
+          # successful register. On a frozen registry it decides which
+          # collection raises, and only a write that can be skipped lets a
+          # spec reach the one behind it.
           @auto_closeable_elements << element_class if handler.auto_closeable?
+          @element_handlers[element_class] = handler
           self
         end
 

data/lib/markbridge/parsers/html/parser.rb

@@ -70,9 +70,21 @@ module Markbridge
           # a <pre> keep their semantics.
           @preserve_depth = initial_preserve_depth(doc)
 
+          # Whitespace collapsing follows the browser rule (CSS Text
+          # §4.1.1): a collapsible space is dropped at the start of a
+          # line, at the end of a line, and right after another
+          # collapsible space — wherever the inline boundaries fall, so
+          # `<b>a </b> b` keeps one space and `<p><b>x </b></p>` none.
+          # A line starts at the parse root and on every block-level tag
+          # boundary. @space_tail is the element whose last child is a
+          # collapsible Text ending in a space (the candidate for the
+          # end-of-line trim), or nil.
+          @line_start = true
+          @space_tail = nil
+
           # Process all nodes
           children.each { |node| process_node(node, document) }
-          trim_trailing_whitespace(document)
+          end_line
 
           document
         end
@@ -117,17 +129,27 @@ module Markbridge
 
           if @preserve_depth.positive?
             parent << AST::Text.new(text)
+            # Preserved whitespace is content: it neither starts a line
+            # nor collapses against a space that follows it.
+            @line_start = false
+            @space_tail = nil
             return
           end
 
-          text = text.gsub(WHITESPACE_RUN, " ") if text.match?(COLLAPSIBLE_WHITESPACE)
-          # Drop leading whitespace at the start of an element's content,
-          # matching the browser rule that whitespace at the beginning of a
-          # block (or before any inline content) is collapsed away.
-          text = text.lstrip if parent.children.empty?
+          text = collapse_whitespace(text)
+          text = text.lstrip if @line_start || @space_tail
           return if text.empty?
 
           parent << AST::Text.new(text)
+          @line_start = false
+          @space_tail = (parent if text.end_with?(" "))
+        end
+
+        # Collapse runs of whitespace to a single space.
+        # @param text [String]
+        # @return [String]
+        def collapse_whitespace(text)
+          text.match?(COLLAPSIBLE_WHITESPACE) ? text.gsub(WHITESPACE_RUN, " ") : text
         end
 
         # Process an element node
@@ -137,19 +159,21 @@ module Markbridge
           tag_name = node.name
           return if IGNORED_TAGS.include?(tag_name)
 
-          # Drop whitespace that sits between content and the start of a
-          # block-level tag, matching browser behavior where such whitespace
-          # collapses against the block boundary. Applies whether or not a
-          # handler is registered, so unknown tags like <div> or <section>
-          # still collapse the whitespace before them.
-          trim_trailing_whitespace(parent) if @handlers.block_level_tags.include?(tag_name)
+          # A block-level tag ends the line before it and the line inside
+          # it, matching browser behavior where whitespace collapses
+          # against the block boundary. Applies whether or not a handler
+          # is registered, so unknown tags like <div> or <section> still
+          # end lines.
+          block = @handlers.block_level_tags.include?(tag_name)
+          end_line if block
 
           preserving = @handlers.whitespace_preserving_tags.include?(tag_name)
           @preserve_depth += 1 if preserving
 
-          dispatch_element(node, tag_name, parent, preserving)
+          dispatch_element(node, tag_name, parent)
 
           @preserve_depth -= 1 if preserving
+          end_line if block
         end
 
         # Dispatch an element to its handler (or the unknown-tag path) and
@@ -157,18 +181,22 @@ module Markbridge
         # @param node [Nokogiri::XML::Element]
         # @param tag_name [String]
         # @param parent [AST::Element]
-        # @param preserving [Boolean] whether this tag preserves whitespace
-        def dispatch_element(node, tag_name, parent, preserving)
+        def dispatch_element(node, tag_name, parent)
           handler = @handlers[tag_name]
           return handle_unknown_tag(node, parent) unless handler
 
           # Handler returns element if children should be processed, nil otherwise
+          size = parent.children.size
           ast_element = handler.process(element: node, parent:)
 
-          return unless ast_element
-
-          process_children(node, ast_element)
-          trim_trailing_whitespace(ast_element) unless preserving
+          if ast_element
+            process_children(node, ast_element)
+          elsif parent.children.size > size
+            # The handler appended a leaf (image, line break, ...), which
+            # is content on the current line like a word.
+            @line_start = false
+            @space_tail = nil
+          end
         end
 
         # Handle unknown tag by tracking it and ignoring the wrapper
@@ -180,6 +208,16 @@ module Markbridge
           process_children(node, parent)
         end
 
+        # End the current line: the collapsible space that closed it goes,
+        # and the next collapsible space starts a line. @space_tail is
+        # not cleared here: the trim is idempotent, so a stale tail is
+        # harmless until the next text or leaf on the new line resets it,
+        # and @line_start already covers the lstrip.
+        def end_line
+          trim_trailing_whitespace(@space_tail) if @space_tail
+          @line_start = true
+        end
+
         # Number of whitespace-preserving elements enclosing the parse
         # root, the root itself included. Computed once per parse; from
         # there the counter is maintained during descent. Documents and

data/lib/markbridge/renderers/discourse/tags/url_tag.rb

@@ -28,18 +28,25 @@ module Markbridge
 
             if interface.html_mode?
               %(<a href="#{HtmlEscaper.escape(href)}">#{text}</a>)
-            elsif element.bare? || text.empty?
+            elsif element.bare? || blank?(text)
               # Url#bare? judges the AST (so label escaping can't confuse
               # it); the rendered-text check additionally catches labels
-              # that render to nothing (e.g. an empty formatting child).
+              # that render to nothing (e.g. an empty formatting child)
+              # or to whitespace only, which wrap_inline would leave
+              # unlinked.
               href
             else
-              "[#{text}](#{markdown_destination(href)})"
+              interface.wrap_inline(text, "[", "](#{markdown_destination(href)})")
             end
           end
 
           private
 
+          # Unicode-aware, matching the guard in RenderingInterface#wrap_inline.
+          def blank?(text)
+            !text.match?(/[^[:space:]]/)
+          end
+
           # CommonMark link destinations cannot contain whitespace unless
           # wrapped in <> — relevant for relative targets like MediaWiki
           # page names ("Main Page").

data/lib/markbridge/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Markbridge
-  VERSION = "0.4.2"
+  VERSION = "0.4.3"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: markbridge
 version: !ruby/object:Gem::Version
-  version: 0.4.2
+  version: 0.4.3
 platform: ruby
 authors:
 - Discourse Team