ZMediumToMarkdown 3.5.1 → 3.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: aad5256e92463eb91197f407050468d928098faf55b90bf97454bbb75544fa41
-  data.tar.gz: 8e05c320fbb2dd468236e69e8c54a9d0b4a403ea10840b49c30d8b650db71b9b
+  metadata.gz: 7c9120282aaa35d8568b605ae3af2c24d874c60604198168e603d38457d1ae2b
+  data.tar.gz: fe051875aa9f1970da37bd858aa937b2f529d26af82baef3e1ccec71385a09f4
 SHA512:
-  metadata.gz: 2a32d5a034f142eece10a2ad997473d9f00223435f5d6b28671d178545f3d17f925698ca3c032a86fa7aaffff23db6fa172cf3ac2ae4efd5f8945b2c3111d85f
-  data.tar.gz: 57a66882f1447c6ddb58da6f68d74b79f3fc7f501eba7d09707ecef879ac791fd1ab80f6f0e69de754085b2f30f8f74f43bdfc4cd25d32eb273a8861516d853a
+  metadata.gz: 160d52fafbcbe3fdfe1c0653934fc4bffa99c76b173bec42108cc47df670cdd37a4c7e0444ccd84ee1185945ffa9ec50372004a812761edb7e23b40dec6a88b3
+  data.tar.gz: 9476fe987ff76ad6e9002dfc142241546654ca7a64771c9d69d296e8938de31bf5dac505ce737d3f7e6299d83c58fb1f5bfa62c49c0e043892476cc4255eea1c

data/lib/CLI.rb

@@ -158,8 +158,7 @@ module CLI
     # other than the default upstream Medium URL — i.e. user pointed it
     # at their own Cloudflare Worker (or another proxy).
     def proxyConfigured?
-        host = ENV['MEDIUM_HOST'].to_s
-        !host.empty? && host != DEFAULT_MEDIUM_HOST
+        !Request.mediumProxyOrigin.nil?
     end
 
     # Only warn when the invocation will actually hit Medium — skip for

data/lib/ImageDownloader.rb

@@ -1,21 +1,74 @@
+require 'net/http'
+require 'uri'
+
 require 'Helper'
+require 'Request'
 
 class ImageDownloader
+    USER_AGENT = 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/142.0.0.0 Safari/537.36'.freeze
+    MAX_REDIRECTS = 5
+
+    # Downloads `url` to disk at `path`. Routes medium.com / miro.medium.com
+    # URLs through MEDIUM_HOST when configured (so requests inherit the
+    # Worker's IP reputation + auth) and attaches `X-Medium-Proxy-Secret`
+    # and the global cookie jar when the destination is the user's proxy.
+    # Other hosts (i.ytimg.com, pbs.twimg.com, etc.) are fetched directly.
     def self.download(path, url)
-        dir = path.split("/")
-        dir.pop()
-        Helper.createDirIfNotExist(dir.join("/"))
-        
-        if File.exist?(path)
-            return true
+        dir = path.split('/')
+        dir.pop
+        Helper.createDirIfNotExist(dir.join('/'))
+
+        return true if File.exist?(path)
+
+        rewritten = Request.mediumProxiedURL(url)
+        uri = URI.parse(rewritten) rescue nil
+        return false if uri.nil? || uri.host.nil?
+
+        response = fetchWithRedirects(uri, MAX_REDIRECTS)
+        return false if response.nil? || response.code.to_i != 200
+
+        body = response.body
+        return false if body.nil? || body.empty?
+
+        File.binwrite(path, body)
+        true
+    rescue StandardError
+        false
+    end
+
+    def self.fetchWithRedirects(uri, limit)
+        return nil if limit <= 0
+
+        https = Net::HTTP.new(uri.host, uri.port)
+        https.use_ssl = (uri.scheme == 'https')
+        https.open_timeout = 10
+        https.read_timeout = 60
+
+        request = Net::HTTP::Get.new(uri)
+        request['User-Agent'] = USER_AGENT
+
+        if Request.proxyURI?(uri)
+            secret = ENV['MEDIUM_HOST_SECRET'].to_s
+            request['X-Medium-Proxy-Secret'] = secret unless secret.empty?
         end
 
-        begin
-            imageResponse = URI.open(url)
-            File.write(path, imageResponse.read)
-            true
-        rescue
-            false
+        cookies = $cookies || {}
+        cookieString = cookies.reject { |_, v| v.nil? }
+                              .map { |k, v| "#{k}=#{v}" }
+                              .join('; ')
+        request['Cookie'] = cookieString unless cookieString.empty?
+
+        response = https.request(request)
+
+        case response.code.to_i
+        when 301, 302, 303, 307, 308
+            location = response['location'].to_s
+            return nil if location.empty?
+            target = URI.parse(URI.join(uri.to_s, location).to_s)
+            target = URI.parse(Request.mediumProxiedURL(target.to_s))
+            fetchWithRedirects(target, limit - 1)
+        else
+            response
         end
     end
-end
+end

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

data/lib/Post.rb

@@ -93,8 +93,7 @@ class Post
       "query" => queryString
     }]
 
-    host = ENV.fetch('MEDIUM_HOST', 'https://medium.com/_/graphql')
-    response = Request.body(Request.URL(host, 'POST', body))
+    response = Request.body(Request.URL(Request.mediumGraphqlEndpoint, 'POST', body))
     return nil if response.nil?
 
     JSON.parse(response)

data/lib/Request.rb

@@ -288,31 +288,47 @@ class Request
     end
 
     # If the user has configured a Cloudflare Worker proxy via MEDIUM_HOST,
-    # rewrite *any* https://medium.com/<path> URL to <worker-origin>/<path>
-    # so non-GraphQL hits (iframe metadata at /media/<id>, OG-image fallback
-    # to /<user>/<post>, etc.) also benefit from the proxy. GraphQL callers
-    # already hand us the proxy URL directly via ENV['MEDIUM_HOST'], so they
-    # short-circuit the rewrite.
+    # rewrite any https://medium.com/<path> OR https://miro.medium.com/<path>
+    # URL to <worker-origin>/<path> so non-GraphQL hits (iframe metadata at
+    # /media/<id>, OG-image fallback to /<user>/<post>, miro image downloads,
+    # etc.) all benefit from the proxy. GraphQL callers already hand us the
+    # proxy URL directly via mediumGraphqlEndpoint, so they short-circuit.
     def self.mediumProxiedURL(url)
-        return url unless url.is_a?(String) && url.start_with?('https://medium.com/')
+        return url unless url.is_a?(String)
         origin = mediumProxyOrigin
         return url if origin.nil?
-        url.sub(%r{\Ahttps://medium\.com}, origin)
+        if url.start_with?('https://medium.com/')
+            url.sub(%r{\Ahttps://medium\.com}, origin)
+        elsif url.start_with?('https://miro.medium.com/')
+            url.sub(%r{\Ahttps://miro\.medium\.com}, origin)
+        else
+            url
+        end
     end
 
     # Extract the `<scheme>://<host>[:port]` of MEDIUM_HOST, or nil if no
-    # proxy is configured (or it still points at medium.com itself).
+    # proxy is configured (or it still points at upstream medium.com).
+    # Accepts MEDIUM_HOST in any form — bare root, with /_/graphql suffix,
+    # or any other path — only the origin matters here.
     def self.mediumProxyOrigin
         host = ENV['MEDIUM_HOST'].to_s
         return nil if host.empty?
         uri = URI.parse(host)
-        return nil if uri.host.nil? || uri.host == 'medium.com'
+        return nil if uri.host.nil? || uri.host == 'medium.com' || uri.host == 'miro.medium.com'
         port = (uri.port && uri.port != uri.default_port) ? ":#{uri.port}" : ''
         "#{uri.scheme}://#{uri.host}#{port}"
     rescue URI::InvalidURIError
         nil
     end
 
+    # GraphQL endpoint the gem should POST to. When MEDIUM_HOST configures a
+    # proxy, it's <proxy-origin>/_/graphql regardless of whether the user set
+    # MEDIUM_HOST to the bare root or already with the /_/graphql suffix.
+    def self.mediumGraphqlEndpoint
+        origin = mediumProxyOrigin
+        origin.nil? ? 'https://medium.com/_/graphql' : "#{origin}/_/graphql"
+    end
+
     # Resolve the host the gem should use for miro.medium.com image fetches.
     # Single-Worker setups: the same MEDIUM_HOST proxy handles both medium.com
     # and miro.medium.com via path dispatch, so we always derive miro from
@@ -322,17 +338,16 @@ class Request
     end
 
     # True iff `uri` is hosted by the configured Worker proxy — i.e. its
-    # host matches MEDIUM_HOST and MEDIUM_HOST is set to something other
-    # than upstream medium.com. Used to gate the MEDIUM_HOST_SECRET auth
-    # header so the secret only leaves the process when heading to the
+    # host matches MEDIUM_HOST's origin. Used to gate the MEDIUM_HOST_SECRET
+    # auth header so the secret only leaves the process when heading to the
     # user's own proxy.
     def self.proxyURI?(uri)
         return false if uri.nil? || uri.host.nil?
-        envValue = ENV['MEDIUM_HOST'].to_s
-        return false if envValue.empty?
-        parsed = URI.parse(envValue) rescue nil
+        origin = mediumProxyOrigin
+        return false if origin.nil?
+        parsed = URI.parse(origin) rescue nil
         return false if parsed.nil? || parsed.host.nil?
-        parsed.host != 'medium.com' && parsed.host == uri.host
+        parsed.host == uri.host
     end
 
     # Cloudflare tags blocked responses via either the cf-mitigated header

data/lib/User.rb

@@ -22,8 +22,7 @@ class User
       }
     ]
 
-    host = ENV.fetch('MEDIUM_HOST', 'https://medium.com/_/graphql')
-    body = Request.body(Request.URL(host, "POST", query))
+    body = Request.body(Request.URL(Request.mediumGraphqlEndpoint, "POST", query))
     return nil if body.nil?
 
     json = JSON.parse(body)
@@ -44,8 +43,7 @@ class User
       }
     ]
 
-    host = ENV.fetch('MEDIUM_HOST', 'https://medium.com/_/graphql')
-    body = Request.body(Request.URL(host, "POST", query))
+    body = Request.body(Request.URL(Request.mediumGraphqlEndpoint, "POST", query))
     return { "nextID" => nil, "postURLs" => [] } if body.nil?
 
     json = JSON.parse(body)

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: ZMediumToMarkdown
 version: !ruby/object:Gem::Version
-  version: 3.5.1
+  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