ZMediumToMarkdown 3.5.2 → 3.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 396aabb00395a5451c046ad36eca450186120dd1f836242c2bc0d40885126ee3
-  data.tar.gz: f10a39b453030fcf5286b1df32ed482b948c49c4152d6dd17e7a5871f9b5ed45
+  metadata.gz: 7c9120282aaa35d8568b605ae3af2c24d874c60604198168e603d38457d1ae2b
+  data.tar.gz: fe051875aa9f1970da37bd858aa937b2f529d26af82baef3e1ccec71385a09f4
 SHA512:
-  metadata.gz: 70a93c6be7b9c0e62966dc8cc1217ad95d458468833a26d2b61329eee2b0b9626d33e232490a02bab76f83f8923d5144906c41e394e4aa049b3634c37cc7382d
-  data.tar.gz: a67492a79d7857fff707c0e2aa313332db8a92a58c8e1c61941096194301910d60578051bf150f3ddbd7e04144eac9cd28c1c8a6ee2b0cdbf7e1069b967b24dd
+  metadata.gz: 160d52fafbcbe3fdfe1c0653934fc4bffa99c76b173bec42108cc47df670cdd37a4c7e0444ccd84ee1185945ffa9ec50372004a812761edb7e23b40dec6a88b3
+  data.tar.gz: 9476fe987ff76ad6e9002dfc142241546654ca7a64771c9d69d296e8938de31bf5dac505ce737d3f7e6299d83c58fb1f5bfa62c49c0e043892476cc4255eea1c

data/lib/Models/Paragraph.rb

@@ -18,6 +18,16 @@ class Paragraph
 
     class Markup
         attr_accessor :type, :start, :end, :href, :anchorType, :userId, :linkMetadata
+
+        # Semantic identity fields used for `==` / `eql?` / `hash`. `start` and
+        # `end` are interval coordinates (handled by Rangeable as the [lo, hi]
+        # pair) rather than identity. `linkMetadata` is currently unused
+        # downstream so it is excluded too. This identity is what lets
+        # Rangeable merge two Markups that describe the same logical span
+        # (e.g. two STRONG runs that overlap) into a single coalesced
+        # interval.
+        SEMANTIC_KEYS = [:type, :href, :anchorType, :userId].freeze
+
         def initialize(json)
             @type = json['type']
             @start = json['start']
@@ -27,6 +37,16 @@ class Paragraph
             @userId = json['userId']
             @linkMetadata = json['linkMetadata']
         end
+
+        def ==(other)
+            return false unless other.is_a?(Markup)
+            SEMANTIC_KEYS.all? { |k| public_send(k) == other.public_send(k) }
+        end
+        alias_method :eql?, :==
+
+        def hash
+            SEMANTIC_KEYS.map { |k| public_send(k) }.hash
+        end
     end
 
     class MetaData

data/lib/Parsers/MarkupStyleRender.rb

@@ -1,5 +1,6 @@
 require 'Models/Paragraph'
 require 'Helper'
+require 'rangeable'
 
 # Renders a Paragraph's text + Markup list into final markdown.
 #
@@ -111,7 +112,7 @@ class MarkupStyleRender
     end
 
     def buildTag(markup)
-        case markup.type
+        tag = case markup.type
         when "EM"     then TagChar.new(2, markup.start, markup.end, "_",  "_")
         when "CODE"   then TagChar.new(0, markup.start, markup.end, "`",  "`")
         when "STRONG" then TagChar.new(2, markup.start, markup.end, "**", "**")
@@ -119,8 +120,12 @@ class MarkupStyleRender
         when "A"      then buildAnchorTag(markup)
         else
             Helper.makeWarningText("Undefined Markup Type: #{markup.type}.")
-            nil
+            return nil
         end
+        # Stash the originating Markup on the tag so walkCharsWithTags can
+        # use it as the Rangeable element key (see #walkCharsWithTags).
+        tag&.instance_variable_set(:@_markup, markup)
+        tag
     end
 
     def buildAnchorTag(markup)
@@ -148,18 +153,42 @@ class MarkupStyleRender
         end
     end
 
+    # Walks every char index and dispatches into the open/close hooks. We
+    # build two index-keyed Hashes (`opens_at`, `closes_at`) up front so the
+    # hot path is O(1) per char instead of the previous O(m) `tags.select`
+    # scan; combined with the linear walk over chars that turns total cost
+    # from O(L · m) into O(L + m). Same-position tags inside each bucket
+    # keep their pre-sorted order from the caller.
+    #
+    # ESCAPE tags bypass Rangeable entirely. ESCAPE ranges are single-char
+    # synthetic markups injected by Paragraph#initialize and they MUST stay
+    # disjoint — feeding them through Rangeable would coalesce two ESCAPEs
+    # at adjacent positions into a single span, double-emitting the
+    # backslash. Non-ESCAPE markups go through Rangeable so identical-type
+    # overlapping spans (e.g. two STRONGs that share a few chars) get
+    # merged into a single tag pair.
     def walkCharsWithTags(tags)
+        rangeable_tags, escape_tags = tags.partition { |t| !escape_tag?(t) }
+        merged_tags = mergeTagsViaRangeable(rangeable_tags)
+        final_tags = (merged_tags + escape_tags).sort_by(&:startIndex)
+
+        opens_at = Hash.new { |h, k| h[k] = [] }
+        closes_at = Hash.new { |h, k| h[k] = [] }
+        final_tags.each do |t|
+            opens_at[t.startIndex] << t
+            closes_at[t.endIndex] << t
+        end
+
         response = []
         stack = []
-
         chars.each do |index, char|
             if newline?(char)
                 emitNewline(char, stack, response)
             end
 
-            openStartingTags(tags, index, stack, response)
+            openStartingTags(opens_at[index], stack, response) if opens_at.key?(index)
             emitChar(char, stack, response) unless newline?(char)
-            closeEndingTags(tags, index, stack, response)
+            closeEndingTags(closes_at[index], stack, response) if closes_at.key?(index)
         end
 
         # Flush any tags still open at end-of-paragraph.
@@ -167,6 +196,45 @@ class MarkupStyleRender
         response
     end
 
+    # Build a Rangeable from the non-ESCAPE TagChars, then read the merged
+    # ranges back out as fresh TagChar instances (one per coalesced span,
+    # rather than one per original markup). Each TagChar carries enough
+    # info (sort priority, start/end strings) to drive emission, so we
+    # reuse a representative original TagChar per Markup as the prototype.
+    def mergeTagsViaRangeable(rangeable_tags)
+        return [] if rangeable_tags.empty?
+
+        rangeable = Rangeable.new
+        proto_by_markup = {}
+
+        rangeable_tags.each do |tag|
+            markup = tag.instance_variable_get(:@_markup)
+            proto_by_markup[markup] ||= tag
+            # TagChar stored endIndex as `end - 1` (last covered slot); restore
+            # the half-open `end` for Rangeable's closed-interval insert.
+            rangeable.insert(markup, start: tag.startIndex, end: tag.endIndex)
+        end
+
+        merged = []
+        rangeable.each do |markup, ranges|
+            proto = proto_by_markup[markup]
+            startCharsStr = proto.startChars.chars.join
+            endCharsStr = proto.endChars.chars.join
+            ranges.each do |lo, hi|
+                # TagChar.new takes the half-open `end`; it stores `end - 1`.
+                merged << TagChar.new(proto.sort, lo, hi + 1, startCharsStr, endCharsStr)
+            end
+        end
+        merged
+    end
+
+    # ESCAPE markups are emitted as TagChar with startChars == "\\" and
+    # empty endChars; identifying them by start-string is simpler than
+    # threading a type tag through the TagChar struct.
+    def escape_tag?(tag)
+        tag.startChars.chars.join == "\\"
+    end
+
     def newline?(char)
         char.chars.join == "\n"
     end
@@ -180,8 +248,8 @@ class MarkupStyleRender
         stack.each { |tag| response.push(tag.startChars) }
     end
 
-    def openStartingTags(tags, index, stack, response)
-        startTags = tags.select { |t| t.startIndex == index }.sort_by(&:sort)
+    def openStartingTags(startTags, stack, response)
+        startTags = startTags.sort_by(&:sort)
         suppressEmit = false
         startTags.each do |tag|
             response.append(tag.startChars) unless suppressEmit
@@ -211,10 +279,13 @@ class MarkupStyleRender
     # supposed to end here (overlapping markups), close it anyway and
     # re-open it after the legitimate closes — keeping each individual
     # tag pair properly nested in the output.
-    def closeEndingTags(tags, index, stack, response)
-        endTags = tags.select { |t| t.endIndex == index }
+    def closeEndingTags(endTags, stack, response)
         return if endTags.empty?
 
+        # Caller passes the pre-built bucket; clone so we can mutate locally
+        # (find_index + delete_at) without trashing the cached array.
+        endTags = endTags.dup
+
         mismatchTags = []
         until endTags.empty?
             stackTag = stack.pop

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: ZMediumToMarkdown
 version: !ruby/object:Gem::Version
-  version: 3.5.2
+  version: 3.6.0
 platform: ruby
 authors:
 - ZhgChgLi
 bindir: bin
 cert_chain: []
-date: 2026-05-06 00:00:00.000000000 Z
+date: 2026-05-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: nokogiri
@@ -91,6 +91,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '0.15'
+- !ruby/object:Gem::Dependency
+  name: rangeable
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
 description: ZMediumToMarkdown converts Medium posts into clean, portable Markdown.
   It can download a single post or every post from a Medium username, preserving headings,
   lists, blockquotes, code blocks, images, links, and common embeds such as GitHub