safe_memoize 1.0.0 → 1.2.0

data/lib/safe_memoize/class_methods.rb

@@ -25,6 +25,19 @@ module SafeMemoize
     # @param key [Proc, nil] class-level custom cache key generator. Receives the same
     #   arguments as the method and should return a single comparable value. Instance-level
     #   keys set via {PublicCustomKeyMethods#memoize_with_custom_key} take priority.
+    # @param store [Stores::Base, nil] custom cache store adapter. Must be a
+    #   {Stores::Base} subclass instance. The store is shared across all instances of the
+    #   class. When +nil+, the default per-instance in-process hash is used.
+    #   Cannot be combined with +max_size:+ or +shared:+.
+    # @param fiber_local [Boolean] when +true+, results are stored in
+    #   +Fiber[:__safe_memoize__]+ rather than instance variables. Each fiber gets its
+    #   own isolated cache that is automatically discarded when the fiber terminates. No
+    #   mutex is acquired. Cannot be combined with +shared:+ or +store:+.
+    # @param ractor_safe [Boolean] when +true+, the class-level shared cache is owned by
+    #   a supervisor +Ractor+ rather than a +Mutex+-protected ivar, making it accessible
+    #   from worker Ractors. Requires +shared: true+. Cached values are deep-frozen via
+    #   +Ractor.make_shareable+. Incompatible with +if:+, +unless:+, +max_size:+,
+    #   +ttl_refresh:+, +key:+, and +store:+.
     # @return [void]
     # @raise [ArgumentError] if the method does not exist, or option values are invalid
     #
@@ -38,7 +51,11 @@ module SafeMemoize
     #
     # @example Conditional — only cache successful responses
     #   memoize :fetch, if: ->(v) { v[:status] == 200 }
-    def memoize(method_name, ttl: nil, max_size: nil, ttl_refresh: false, if: nil, unless: nil, shared: false, key: nil)
+    #
+    # @example With a custom store
+    #   STORE = SafeMemoize::Stores::Memory.new
+    #   memoize :fetch, store: STORE, ttl: 300
+    def memoize(method_name, ttl: nil, max_size: nil, ttl_refresh: false, if: nil, unless: nil, shared: false, key: nil, store: nil, fiber_local: false, ractor_safe: false)
       method_name = method_name.to_sym
 
       unless method_defined?(method_name) || private_method_defined?(method_name) || protected_method_defined?(method_name)
@@ -85,6 +102,46 @@ module SafeMemoize
       raise ArgumentError, ":unless must be callable" if cond_unless && !cond_unless.respond_to?(:call)
       raise ArgumentError, ":key must be callable" if key && !key.respond_to?(:call)
 
+      if store
+        raise ArgumentError, "store: must be a SafeMemoize::Stores::Base instance (got #{store.class})" unless store.is_a?(SafeMemoize::Stores::Base)
+        raise ArgumentError, "max_size: is not supported with store: — use the store adapter's own eviction" if max_size
+        raise ArgumentError, "shared: and store: cannot be combined" if shared
+      end
+
+      if fiber_local
+        raise ArgumentError, "fiber_local: and shared: cannot be combined" if shared
+        raise ArgumentError, "fiber_local: and store: cannot be combined" if store
+      end
+
+      if ractor_safe
+        raise ArgumentError, "ractor_safe: requires shared: true" unless shared
+        raise ArgumentError, "ractor_safe: is incompatible with if:/unless:" if cond_if || cond_unless
+        raise ArgumentError, "ractor_safe: is incompatible with max_size:" if max_size
+        raise ArgumentError, "ractor_safe: is incompatible with ttl_refresh:" if ttl_refresh
+        raise ArgumentError, "ractor_safe: is incompatible with key:" if key
+        raise ArgumentError, "ractor_safe: is incompatible with store:" if store
+      end
+
+      # Resolve effective store: per-method store: wins; then class-level
+      # safe_memoize_store; then global default_store. max_size: and shared:
+      # are incompatible with external stores — fall back silently.
+      effective_store = store
+      if effective_store.nil? && !max_size && !shared
+        class_store = safe_memoize_store
+        if class_store
+          effective_store = class_store
+        else
+          global_default = SafeMemoize.configuration.default_store
+          if global_default
+            unless global_default.is_a?(SafeMemoize::Stores::Base)
+              raise ArgumentError,
+                "SafeMemoize.configuration.default_store must be a Stores::Base instance (got #{global_default.class})"
+            end
+            effective_store = global_default
+          end
+        end
+      end
+
       __safe_memo_class_key_generators__[method_name] = key if key
 
       # Normalize to a single "should cache?" predicate
@@ -94,6 +151,120 @@ module SafeMemoize
         ->(result) { !cond_unless.call(result) }
       end
 
+      if effective_store
+        miss = SafeMemoize::Stores::Base::MISS
+
+        mod = Module.new do
+          define_method(method_name) do |*args, **kwargs, &block|
+            return super(*args, **kwargs, &block) if block
+
+            cache_key = compute_cache_key(method_name, args, kwargs)
+            cached = effective_store.read(cache_key)
+
+            unless cached.equal?(miss)
+              effective_store.write(cache_key, cached, expires_in: ttl) if ttl_refresh
+              record_cache_hit(method_name, args, kwargs)
+              call_memo_hooks(:on_hit, cache_key, {value: cached, expires_at: nil, cached_at: nil})
+              return cached
+            end
+
+            start_time = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+            value = Adapters::OpenTelemetry.trace(
+              SafeMemoize.configuration.opentelemetry_tracer, method_name, self.class.name
+            ) { super(*args, **kwargs) }
+            elapsed_time = Process.clock_gettime(Process::CLOCK_MONOTONIC) - start_time
+
+            now = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+            if !condition || condition.call(value)
+              effective_store.write(cache_key, value, expires_in: ttl)
+              call_memo_hooks(:on_store, cache_key, {value: value, expires_at: nil, cached_at: now})
+            end
+
+            record_cache_miss(method_name, args, kwargs, elapsed_time)
+            call_memo_hooks(:on_miss, cache_key, {value: value, expires_at: nil, cached_at: now})
+
+            value
+          end
+
+          send(visibility, method_name)
+        end
+
+        prepend mod
+
+        return
+      end
+
+      if fiber_local
+        mod = Module.new do
+          define_method(method_name) do |*args, **kwargs, &block|
+            return super(*args, **kwargs, &block) if block
+
+            cache_key = compute_cache_key(method_name, args, kwargs)
+            fiber_cache = fiber_memo_cache!
+            record = fiber_cache[cache_key]
+
+            if memo_record_live?(record)
+              if max_size
+                lru = fiber_memo_lru![method_name] ||= {}
+                lru.delete(cache_key)
+                lru[cache_key] = true
+              end
+              record[:expires_at] = memo_expires_at(ttl) if ttl_refresh
+              record_cache_hit(method_name, args, kwargs)
+              call_memo_hooks(:on_hit, cache_key, record)
+              memo_record_value(record)
+            else
+              call_memo_hooks(:on_expire, cache_key, record) if record
+
+              start_time = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+              value = Adapters::OpenTelemetry.trace(
+                SafeMemoize.configuration.opentelemetry_tracer, method_name, self.class.name
+              ) { super(*args, **kwargs) }
+              elapsed_time = Process.clock_gettime(Process::CLOCK_MONOTONIC) - start_time
+
+              new_record = memo_record(value, expires_at: memo_expires_at(ttl))
+
+              if !condition || condition.call(value)
+                if max_size
+                  lru = fiber_memo_lru![method_name] ||= {}
+                  if lru.size >= max_size
+                    evict_key = lru.keys.first
+                    lru.delete(evict_key)
+                    evicted = fiber_cache.delete(evict_key)
+                    call_memo_hooks(:on_evict, evict_key, evicted) if evicted
+                  end
+                end
+                fiber_cache[cache_key] = new_record
+                if max_size
+                  lru = fiber_memo_lru![method_name] ||= {}
+                  lru.delete(cache_key)
+                  lru[cache_key] = true
+                end
+                call_memo_hooks(:on_store, cache_key, new_record)
+              end
+
+              record_cache_miss(method_name, args, kwargs, elapsed_time)
+              call_memo_hooks(:on_miss, cache_key, new_record)
+
+              value
+            end
+          end
+
+          send(visibility, method_name)
+        end
+
+        prepend mod
+
+        return
+      end
+
+      if ractor_safe
+        extend(RactorSharedMethods) unless is_a?(RactorSharedMethods)
+        supervisor = __safe_memo_ractor_supervisor__
+        __memoize_ractor_safe__(method_name, ttl, visibility, supervisor)
+        return
+      end
+
       if shared
         klass = self
         shared_mutex = klass.send(:__safe_memo_shared_mutex__)
@@ -232,6 +403,32 @@ module SafeMemoize
       prepend mod
     end
 
+    # Returns the class-level default cache store, or +nil+ if not set.
+    #
+    # Set this to any {Stores::Base} instance to route every +memoize+ call on
+    # this class through that store, without needing to pass +store:+ to each
+    # individual +memoize+ call.  A per-method +store:+ option still takes
+    # precedence, and the global {SafeMemoize::Configuration#default_store} is
+    # the final fallback.
+    #
+    # @return [Stores::Base, nil]
+    def safe_memoize_store
+      @__safe_memoize_store__
+    end
+
+    # Sets the class-level default cache store.
+    #
+    # @param store [Stores::Base, nil] a store instance, or +nil+ to clear
+    # @return [Stores::Base, nil]
+    # @raise [ArgumentError] if +store+ is not a {Stores::Base} instance (and not +nil+)
+    def safe_memoize_store=(store)
+      if store && !store.is_a?(SafeMemoize::Stores::Base)
+        raise ArgumentError,
+          "safe_memoize_store= must be a SafeMemoize::Stores::Base instance (got #{store.class})"
+      end
+      @__safe_memoize_store__ = store
+    end
+
     # Memoizes every eligible public instance method defined directly on the class.
     #
     # Accepts all options that {#memoize} accepts, plus +:except:+ and +:only:+.
@@ -406,5 +603,67 @@ module SafeMemoize
 
       :public
     end
+
+    # Builds and prepends the ractor_safe memoize wrapper in its own method so
+    # the Proc only closes over the four Ractor-shareable locals (method_name,
+    # ttl, visibility, supervisor) rather than the full memoize binding, which
+    # contains non-shareable objects like SafeMemoize.configuration.
+    #
+    # The Proc is created inside module_eval so its self is the anonymous
+    # module (a shareable object), then frozen via Ractor.make_shareable before
+    # being passed to define_method. Without that step, ANY define_method Proc
+    # is considered non-shareable by Ruby 3.x even when it captures nothing.
+    def __memoize_ractor_safe__(method_name, ttl, visibility, supervisor)
+      mod = Module.new
+      wrapper = mod.module_eval do
+        Ractor.make_shareable(
+          proc do |*args, **kwargs, &block|
+            return super(*args, **kwargs, &block) if block
+
+            cache_key = Ractor.make_shareable([method_name, deep_freeze_copy(args), deep_freeze_copy(kwargs)])
+
+            tag = Thread.current.object_id
+            supervisor.send(Ractor.make_shareable([Ractor.current, tag, :fetch, cache_key]))
+            response = Ractor.receive_if { |m| m.is_a?(Array) && m[0] == tag }[1]
+
+            if response[:hit]
+              record_cache_hit(method_name, args, kwargs)
+              call_memo_hooks(:on_hit, cache_key, response[:record])
+              return response[:record][:value]
+            end
+
+            start_time = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+            value = super(*args, **kwargs)
+            elapsed_time = Process.clock_gettime(Process::CLOCK_MONOTONIC) - start_time
+
+            begin
+              shareable_value = Ractor.make_shareable(value)
+            rescue => e
+              raise ArgumentError, "ractor_safe: memoized values must be Ractor-shareable (#{e.message})"
+            end
+
+            now = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+            record = Ractor.make_shareable({
+              value: shareable_value,
+              expires_at: ttl ? now + ttl : nil,
+              cached_at: now
+            })
+
+            supervisor.send(Ractor.make_shareable([Ractor.current, tag, :store, cache_key, record]))
+            stored = Ractor.receive_if { |m| m.is_a?(Array) && m[0] == tag }[1]
+            stored_record = stored[:stored]
+
+            record_cache_miss(method_name, args, kwargs, elapsed_time)
+            call_memo_hooks(:on_store, cache_key, stored_record)
+            call_memo_hooks(:on_miss, cache_key, stored_record)
+
+            stored_record[:value]
+          end
+        )
+      end
+      mod.define_method(method_name, wrapper)
+      mod.send(visibility, method_name)
+      prepend mod
+    end
   end
 end

data/lib/safe_memoize/configuration.rb

@@ -42,6 +42,12 @@ module SafeMemoize
     #   When set, {Adapters::OpenTelemetry} wraps each cache-miss computation in a span.
     attr_accessor :opentelemetry_tracer
 
+    # @return [Stores::Base, nil] Default cache store applied to every {ClassMethods#memoize}
+    #   call that does not specify its own +store:+. +nil+ uses the built-in per-instance
+    #   hash cache. Methods using +max_size:+ or +shared:+ are incompatible with an external
+    #   store and will silently continue using the per-instance hash even when this is set.
+    attr_accessor :default_store
+
     # @api private
     def initialize
       @default_ttl = nil
@@ -51,6 +57,7 @@ module SafeMemoize
       @active_support_notifications = false
       @statsd_client = nil
       @opentelemetry_tracer = nil
+      @default_store = nil
     end
   end
 end

data/lib/safe_memoize/fiber_local_methods.rb

@@ -0,0 +1,108 @@
+# frozen_string_literal: true
+
+module SafeMemoize
+  # Public and private helpers for fiber-local memoization.
+  #
+  # When a method is memoized with +fiber_local: true+, its cached values are
+  # stored in +Fiber[:__safe_memoize__]+ rather than instance variables, giving
+  # each fiber an isolated cache that is automatically discarded when the fiber
+  # terminates. No mutex is required because fibers are cooperative: only one
+  # fiber runs at a time within a thread.
+  module FiberLocalMethods
+    FIBER_STORE_KEY = :__safe_memoize__
+
+    # Returns +true+ if the given call is currently cached in the current fiber.
+    #
+    # @note In Ruby, +Fiber.new+ inherits the parent fiber's local storage. SafeMemoize
+    #   detects inherited stores via an +:__owner__+ sentinel and creates a fresh
+    #   isolated store for each fiber on first write.
+    #
+    # @param method_name [Symbol, String]
+    # @param args [Array]
+    # @param kwargs [Hash]
+    # @return [Boolean]
+    def fiber_local_memoized?(method_name, *args, **kwargs, &block)
+      return false if block
+
+      method_name = method_name.to_sym
+      cache_key = compute_cache_key(method_name, args, kwargs)
+      record = fiber_memo_cache_or_nil&.[](cache_key)
+      memo_record_live?(record)
+    end
+
+    # Removes one or all fiber-local cached entries for a method in the current fiber.
+    #
+    # @param method_name [Symbol, String]
+    # @param args [Array]
+    # @param kwargs [Hash]
+    # @return [void]
+    def reset_fiber_memo(method_name, *args, **kwargs)
+      method_name = method_name.to_sym
+      cache = fiber_memo_cache_or_nil
+      return unless cache
+
+      if args.empty? && kwargs.empty?
+        cache.delete_if { |key, _| key[0] == method_name }
+        fiber_memo_lru_or_nil&.delete(method_name)
+      else
+        cache_key = compute_cache_key(method_name, args, kwargs)
+        cache.delete(cache_key)
+        fiber_memo_lru_or_nil&.[](method_name)&.delete(cache_key)
+      end
+    end
+
+    # Clears all fiber-local cached entries for this instance in the current fiber.
+    #
+    # @return [void]
+    def reset_all_fiber_memos
+      store = Fiber[FIBER_STORE_KEY]
+      return unless store&.[](:__owner__) == Fiber.current.object_id
+
+      store.delete(object_id)
+    end
+
+    private
+
+    # Returns the per-fiber top-level store hash, creating a fresh one for
+    # this fiber if the current store was inherited from a parent fiber.
+    def fiber_root_store!
+      store = Fiber[FIBER_STORE_KEY]
+      unless store&.[](:__owner__) == Fiber.current.object_id
+        store = {__owner__: Fiber.current.object_id}
+        Fiber[FIBER_STORE_KEY] = store
+      end
+      store
+    end
+
+    def fiber_memo_store!
+      fiber_root_store![object_id] ||= {cache: {}, lru: {}}
+    end
+
+    def fiber_memo_cache!
+      fiber_memo_store![:cache]
+    end
+
+    def fiber_memo_lru!
+      fiber_memo_store![:lru]
+    end
+
+    def fiber_root_store_or_nil
+      store = Fiber[FIBER_STORE_KEY]
+      return nil unless store&.[](:__owner__) == Fiber.current.object_id
+
+      store
+    end
+
+    def fiber_memo_store_or_nil
+      fiber_root_store_or_nil&.[](object_id)
+    end
+
+    def fiber_memo_cache_or_nil
+      fiber_memo_store_or_nil&.[](:cache)
+    end
+
+    def fiber_memo_lru_or_nil
+      fiber_memo_store_or_nil&.[](:lru)
+    end
+  end
+end

data/lib/safe_memoize/hooks_methods.rb

@@ -31,7 +31,8 @@ module SafeMemoize
       hooks.each do |hook|
         hook.call(cache_key, record)
       rescue => error
-        handler = SafeMemoize.configuration.on_hook_error
+        # SafeMemoize.configuration is not accessible from non-main Ractors
+        handler = (Ractor.current == Ractor.main) ? SafeMemoize.configuration.on_hook_error : nil
         if handler
           handler.call(error, hook_type, cache_key)
         else
@@ -39,6 +40,10 @@ module SafeMemoize
         end
       end
 
+      # ActiveSupport::Notifications and StatsD integration require main-Ractor
+      # configuration access; skip them from worker Ractors.
+      return if Ractor.current != Ractor.main
+
       safe_memo_notify(hook_type, cache_key) if SafeMemoize.configuration.active_support_notifications
 
       if (client = SafeMemoize.configuration.statsd_client)

data/lib/safe_memoize/instance_methods.rb

@@ -13,5 +13,6 @@ module SafeMemoize
     include CustomKeyMethods
     include PublicCustomKeyMethods
     include LruMethods
+    include FiberLocalMethods
   end
 end

data/lib/safe_memoize/ractor_shared_methods.rb

@@ -0,0 +1,146 @@
+# frozen_string_literal: true
+
+module SafeMemoize
+  # Class-level methods for Ractor-safe shared caching.
+  #
+  # Mixed into a class (via ClassMethods) when any method is memoized with
+  # +shared: true, ractor_safe: true+. The class owns a supervisor +Ractor+ that
+  # holds the mutable cache hash. All cache reads and writes are serialized through
+  # the supervisor's message loop, removing the need for a +Mutex+ (which is not
+  # Ractor-shareable).
+  #
+  # Constraints for +ractor_safe: true+ memoization:
+  # - Cached return values are made Ractor-shareable via +Ractor.make_shareable+
+  #   (deep-frozen in place). Ensure return values can be frozen.
+  # - +if:+, +unless:+, +max_size:+, +ttl_refresh:+, +key:+, and +store:+ are
+  #   incompatible and raise +ArgumentError+ at +memoize+ time.
+  # - When calling a ractor-safe memoized method from the main Ractor with multiple
+  #   threads, responses are matched by thread identity so concurrent callers do not
+  #   consume each other's replies.
+  module RactorSharedMethods
+    # Clears one or all entries from the Ractor-safe shared cache.
+    #
+    # @param method_name [Symbol, String]
+    # @param args [Array] positional args identifying a specific entry; omit to clear all
+    # @param kwargs [Hash]
+    # @return [void]
+    def reset_ractor_memo(method_name, *args, **kwargs)
+      method_name = method_name.to_sym
+      sup = @__safe_memo_ractor_supervisor__
+      return unless sup
+
+      if args.empty? && kwargs.empty?
+        __ractor_cache_send__(sup, :delete_all, method_name)
+      else
+        key = Ractor.make_shareable([method_name, args.freeze, kwargs.freeze])
+        __ractor_cache_send__(sup, :delete_one, key)
+      end
+    end
+
+    # Clears the entire Ractor-safe shared cache for this class.
+    # @return [void]
+    def reset_all_ractor_memos
+      sup = @__safe_memo_ractor_supervisor__
+      return unless sup
+
+      __ractor_cache_send__(sup, :clear)
+    end
+
+    # Returns +true+ if a live entry exists in the Ractor-safe shared cache.
+    #
+    # @param method_name [Symbol, String]
+    # @param args [Array]
+    # @param kwargs [Hash]
+    # @return [Boolean]
+    def ractor_memoized?(method_name, *args, **kwargs)
+      method_name = method_name.to_sym
+      sup = @__safe_memo_ractor_supervisor__
+      return false unless sup
+
+      key = Ractor.make_shareable([method_name, args.freeze, kwargs.freeze])
+      __ractor_cache_send__(sup, :memoized, key)
+    end
+
+    # Returns the number of live entries in the Ractor-safe shared cache.
+    #
+    # @param method_name [Symbol, String, nil] when given, counts only entries for
+    #   that method; when +nil+, counts all.
+    # @return [Integer]
+    def ractor_memo_count(method_name = nil)
+      sup = @__safe_memo_ractor_supervisor__
+      return 0 unless sup
+
+      __ractor_cache_send__(sup, :count, method_name&.to_sym)
+    end
+
+    private
+
+    # Sends a message to the supervisor and blocks until the tagged response arrives.
+    # Uses Thread.current.object_id as a per-call tag so concurrent threads in the
+    # main Ractor do not steal each other's replies.
+    def __ractor_cache_send__(supervisor, op, *args)
+      tag = Thread.current.object_id
+      msg = Ractor.make_shareable([Ractor.current, tag, op, *args])
+      supervisor.send(msg)
+      Ractor.receive_if { |m| m.is_a?(Array) && m[0] == tag }[1]
+    end
+
+    # Creates the supervisor Ractor that owns this class's Ractor-safe shared cache.
+    # Must be called from the main Ractor at class-definition time.
+    def __safe_memo_ractor_supervisor__
+      # :nocov:
+      @__safe_memo_ractor_supervisor__ ||= Ractor.new do
+        cache = {}
+
+        loop do
+          caller_ractor, tag, op, *args = Ractor.receive
+          now = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+
+          result = case op
+          when :fetch
+            key = args[0]
+            record = cache[key]
+            live = record && (record[:expires_at].nil? || record[:expires_at] > now)
+            live ? {hit: true, record: record} : {hit: false, record: nil}
+
+          when :store
+            key, new_record = args
+            existing = cache[key]
+            live = existing && (existing[:expires_at].nil? || existing[:expires_at] > now)
+            cache[key] = new_record unless live
+            {stored: live ? existing : new_record}
+
+          when :delete_all
+            method_name = args[0]
+            cache.delete_if { |k, _| k[0] == method_name }
+            :ok
+
+          when :delete_one
+            cache.delete(args[0])
+            :ok
+
+          when :clear
+            cache.clear
+            :ok
+
+          when :memoized
+            key = args[0]
+            record = cache[key]
+            !!(record && (record[:expires_at].nil? || record[:expires_at] > now))
+
+          when :count
+            method_name = args[0]
+            cache.count do |k, r|
+              next false if r[:expires_at] && r[:expires_at] <= now
+              method_name.nil? || k[0] == method_name
+            end
+          end
+
+          response = Ractor.make_shareable([tag, result])
+          caller_ractor.send(response)
+        end
+      end
+      # :nocov:
+    end
+  end
+end

data/lib/safe_memoize/release_tooling.rb

@@ -46,6 +46,31 @@ module SafeMemoize
       contents.sub(UNRELEASED_HEADING, "#{UNRELEASED_HEADING}\n\n#{release_heading}")
     end
 
+    # Removes milestone sections from ROADMAP.md where every feature row has
+    # "Shipped" status. Non-milestone sections (Versioning policy, Contributing,
+    # etc.) and sections with any non-Shipped row are left untouched.
+    #
+    # Sections are delimited by the +\n\n---\n\n+ horizontal-rule separator that
+    # the ROADMAP uses between headings. A milestone section is any section whose
+    # first non-blank line starts with +## v+.
+    def prune_roadmap(contents)
+      separator = "\n\n---\n\n"
+      sections = contents.split(separator)
+
+      pruned = sections.reject do |section|
+        next false unless section.lstrip.start_with?("## v")
+
+        # Table rows: lines starting with "|"; drop alignment rows (only |, -, :, whitespace)
+        rows = section.lines.select { |l| l.strip.start_with?("|") }
+        rows = rows.reject { |l| l.match?(/\A[\s|:-]+\z/) }
+        data_rows = rows.drop(1) # first row is the header
+
+        data_rows.any? && data_rows.all? { |row| row.strip.end_with?("Shipped |") }
+      end
+
+      pruned.join(separator)
+    end
+
     def extract_release_notes(contents, version)
       normalized_version = normalize_version(version)
       lines = contents.lines