cdc-concurrent 0.0.0 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a8f1b6796df6daf32144dc7df7206777863c4d693997e3b83e500d0c360ff699
-  data.tar.gz: eabe19f74600193950154f4921203123b78bd1c2db8a2ca576bf74c83ab1eb5b
+  metadata.gz: cbc0a0ebe15a9254e91b40caa48db7f7f26e4b01933be88e5fd148ea8c3371d0
+  data.tar.gz: 38888cc8ade72e4611e352fa534a25876cbc71d6ef74c2f725b5bb3ef1c4c069
 SHA512:
-  metadata.gz: eabccfa38225330187c12f4c681c68f973126e60910c00402cc274a400e776753e46b1a5605692b363f8d064971cb26253ab72d305b69d9e2106e49733c964d7
-  data.tar.gz: 2210868f800f9ae0cddf5cf24bf6104be5dfd9f74d2b74694f66571cdd87031ba714ba2b12356c4401b71e4dcad901187848ad1f8a8746f7e0b2f236122dec9c
+  metadata.gz: c3315531e5f0cbe43f86461acabf835ec5f187d65dace206d1640a213b42702a0ee8e1088421f1e2f05e076ce9dfcdd7625f309f837b613c5f13dfc459b07152
+  data.tar.gz: 351566c71b92c033c2c35b2639653eabf6e75d3bacee667f643dde9af47bffaf7dbeee4f802eb8e237bd5e9a5bc7957d43269b323fc9c17b89bedda1ecc7dd8b

data/CHANGELOG.md

@@ -1,5 +1,24 @@
-## [Unreleased]
+## [0.1.0] - 2026-06-04
 
-## [0.1.0] - 2026-05-31
+  Initial release of `cdc-concurrent`.
 
-- Initial release
+  ### Added
+
+  - Async-backed I/O-concurrent runtime adapter for `cdc-core`.
+  - `CDC::Concurrent::Runtime` for processing single events, batches, and transaction envelopes.
+  - `CDC::Concurrent::ProcessorPool` for concurrent `ChangeEvent` processing.
+  - `CDC::Concurrent::TransactionPool` for transaction envelope processing.
+  - `CDC::Concurrent::Router` for routing supported CDC work items.
+  - `concurrent_safe!` processor declaration.
+  - Timeout handling with `CDC::Concurrent::TimeoutError`.
+  - Shutdown and unsupported work item errors.
+  - Result normalization to `CDC::Core::ProcessorResult`.
+  - Unit, integration, behavior, and performance test groups.
+  - RBS signatures.
+  - README positioning `cdc-concurrent` as the I/O-bound sibling of `cdc-parallel`.
+
+  ### Notes
+
+  - Requires Ruby 3.4+.
+  - Designed for I/O-bound processors that cooperate with Ruby's Fiber scheduler.
+  - CPU-bound CDC processing should use `cdc-parallel`.

data/lib/cdc/concurrent/configuration.rb

@@ -3,7 +3,9 @@
 module CDC
   module Concurrent
     # Immutable configuration for concurrent runtimes.
-    Configuration = Data.define(:concurrency, :timeout, :preserve_order) do
+    class Configuration
+      attr_reader :concurrency, :timeout, :preserve_order
+
       # @param concurrency [Integer] maximum concurrent tasks.
       # @param timeout [Float, nil] optional timeout.
       # @param preserve_order [Boolean] whether batch results preserve input order.
@@ -11,7 +13,9 @@ module CDC
         raise ArgumentError, "concurrency must be an Integer" unless concurrency.is_a?(Integer)
         raise ArgumentError, "concurrency must be greater than zero" unless concurrency.positive?
 
-        super
+        @concurrency = concurrency
+        @timeout = timeout
+        @preserve_order = preserve_order
         freeze
       end
     end

data/lib/cdc/concurrent/processor_extensions.rb

@@ -20,7 +20,7 @@ module CDC
 
       # @return [Boolean] whether this processor instance is concurrent-safe.
       def concurrent_safe?
-        self.class.respond_to?(:concurrent_safe?) && self.class.concurrent_safe?
+        self.class.instance_variable_get(:@concurrent_safe) == true
       end
     end
 

data/lib/cdc/concurrent/processor_pool.rb

@@ -28,8 +28,9 @@ module CDC
       # @return [Array<CDC::Core::ProcessorResult>]
       def process_many(events)
         raise ShutdownError, "processor pool has been shut down" if @shutdown
-        return [].freeze if events.empty?
+        return empty_results if events.empty?
 
+        # @type var indexed_results: Array[[Integer, CDC::Core::ProcessorResult]]
         indexed_results = []
 
         process_batch(events, indexed_results)
@@ -51,6 +52,12 @@ module CDC
         raise UnsafeProcessorError, "#{processor.class} must declare concurrent_safe!"
       end
 
+      def empty_results
+        # @type var results: Array[CDC::Core::ProcessorResult]
+        results = []
+        results.freeze
+      end
+
       def process_batch(events, indexed_results)
         Async do |task|
           semaphore = Async::Semaphore.new(@configuration.concurrency, parent: task)

data/lib/cdc/concurrent/version.rb

@@ -3,6 +3,6 @@
 module CDC
   module Concurrent
     # Current cdc-concurrent version.
-    VERSION = "0.0.0"
+    VERSION = "0.1.0"
   end
 end

data/sig/cdc/concurrent/configuration.rbs

@@ -1,6 +1,12 @@
 module CDC
   module Concurrent
     # Immutable configuration for concurrent runtimes.
-    Configuration: untyped
+    class Configuration
+      attr_reader concurrency: Integer
+      attr_reader timeout: Float?
+      attr_reader preserve_order: bool
+
+      def initialize: (?concurrency: Integer, ?timeout: Float?, ?preserve_order: bool) -> void
+    end
   end
 end

data/sig/cdc/concurrent/processor_pool.rbs

@@ -29,6 +29,8 @@ module CDC
 
       def validate_processor!: (untyped processor) -> (nil | untyped)
 
+      def empty_results: () -> ::Array[untyped]
+
       def process_batch: (untyped events, untyped indexed_results) -> untyped
 
       def process_one: (untyped event) -> untyped

data/sig/shims/async.rbs

@@ -0,0 +1,20 @@
+module Kernel
+  private
+
+  def Async: () { (Async::Task) -> untyped } -> Async::Task
+end
+
+module Async
+  class Task
+    def with_timeout: (untyped timeout) { () -> untyped } -> untyped
+    def wait: () -> untyped
+  end
+
+  class Semaphore
+    def initialize: (Integer limit, parent: Task) -> void
+    def async: () { (Task) -> untyped } -> Task
+  end
+
+  class TimeoutError < StandardError
+  end
+end

data/sig/shims/cdc_core.rbs

@@ -0,0 +1,31 @@
+module CDC
+  module Core
+    class Processor
+      def self.extend: (Module mod) -> self
+      def self.include: (Module mod) -> self
+
+      def process: (untyped event) -> untyped
+    end
+
+    class ProcessorResult
+      attr_reader status: Symbol
+      attr_reader event: untyped
+      attr_reader error: untyped
+      attr_reader metadata: untyped
+
+      def self.success: (?untyped event, ?metadata: untyped) -> ProcessorResult
+      def self.failure: (untyped error, ?event: untyped, ?metadata: untyped) -> ProcessorResult
+
+      def success?: () -> bool
+      def failure?: () -> bool
+      def skipped?: () -> bool
+    end
+
+    class ChangeEvent
+    end
+
+    class TransactionEnvelope
+      attr_reader events: Array[ChangeEvent]
+    end
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: cdc-concurrent
 version: !ruby/object:Gem::Version
-  version: 0.0.0
+  version: 0.1.0
 platform: ruby
 authors:
 - Ken C. Demanawa
@@ -72,6 +72,8 @@ files:
 - sig/cdc/concurrent/transaction_pool.rbs
 - sig/cdc/concurrent/version.rbs
 - sig/cdc_concurrent.rbs
+- sig/shims/async.rbs
+- sig/shims/cdc_core.rbs
 homepage: https://kanutocd.github.io/cdc-concurrent
 licenses:
 - MIT