asterism 0.2.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: bdb7bf2126361f3b9ae4097467832d950440b9a65c419a92394f230b4d7b0277
-  data.tar.gz: ba8621f58ee2d5fb22f5eeb3b68917cb6ce9f9420d07230d5d69e246b9c53564
+  metadata.gz: f03c6be1c5461da008a067c55b609a009b31b7552810836b7272bcdd35443ba7
+  data.tar.gz: df8c8641c8039408dcb3ca803b7fdcfe0a24e3eef3199da0b1277e980977f936
 SHA512:
-  metadata.gz: cc43c0ab1f0076a148bcd65a648b0220eb8559912b296a7fdbb7b4810f108ab8f66d439e951e3c1a3fe24329ac6fb5a76593214c7571e3f18b55d833a917276d
-  data.tar.gz: 48114f986885d604142a4fb369b1a31f4a7cb6d1dbff95ffc0b0566e97801bbd646278cb498b4c0e1003c8a3b425a526262ffb384557eeb0cdc4a7e450b6bc63
+  metadata.gz: 663fbb3e79d9b824128b541b899028809d899916af70a28fe761581fa2e28285f9841ef78dfafd088c2583f2c9df705328566b1f465ec31886df277c013c90a2
+  data.tar.gz: d447307b7bba1387d35316044c483f974a814ab1b0a4c7f5d32e17e8fc0b954ed2388ee53aaef9bf780bb7ccb98a93669fdf30f0efb7357d007535cae26a33ec

data/README.md

@@ -23,7 +23,15 @@ each Ruby:
 - mruby / PicoRuby: [picoruby-asterism-zenoh](https://github.com/ruby-asterism/picoruby-asterism-zenoh)
   (over zenoh-pico)
 
-Neither gem is on rubygems.org yet (version 0.2.0 builds from these
+Which zenoh-c features the CRuby binding exposes (configuration and TLS,
+scouting, publishers, queriers, the advanced publisher / subscriber,
+events, key expressions, timestamps) and which zenoh-pico could offer is
+in asterism-zenoh's
+[feature coverage](https://github.com/ruby-asterism/asterism-zenoh/blob/main/docs/feature_coverage.md).
+The ones added in 0.3.0 are CRuby only: the shared layer (`mrblib/`) does
+not use them.
+
+Neither gem is on rubygems.org yet (version 0.3.0 builds from these
 repositories with `rake gem`).
 
 ## Using it
@@ -31,7 +39,7 @@ repositories with `rake gem`).
 CRuby (needs CRuby 3.2+ and a C compiler):
 
 ```
-gem install asterism          # also installs asterism-zenoh (~> 0.2.0) and msgpack
+gem install asterism          # also installs asterism-zenoh (~> 0.3.0) and msgpack
 ruby -e 'require "asterism"'
 ```
 
@@ -44,7 +52,7 @@ build but not yet tested. To install from the repositories instead:
 
 ```
 (cd ../asterism-zenoh && rake gem) && rake gem
-gem install --local ../asterism-zenoh/pkg/asterism-zenoh-0.2.0.gem pkg/asterism-0.2.0.gem
+gem install --local ../asterism-zenoh/pkg/asterism-zenoh-0.3.0.gem pkg/asterism-0.3.0.gem
 ```
 
 From the working trees, without installing:
@@ -115,17 +123,41 @@ Asterism::Zenoh.open("tcp/192.0.2.2:7447") do |s|   # closed when the block ends
   s.liveliness_watch("asterism/**") { |key, alive| puts "#{key} #{alive}" }
   s.run                                               # receive on this thread until Ctrl-C
 end
+
+# asterism-zenoh 0.3.0 (CRuby only)
+Asterism::Zenoh.open("tls/192.0.2.2:7447",
+                     config: { "transport/link/tls/root_ca_certificate" => "ca.pem" }) do |s|
+  pub = s.publisher("home/pc/temp", encoding: "text/plain", priority: :data_high)
+  pub.on_matching { |listening| puts "listened to: #{listening}" }
+  pub.put(21.5)
+  s.delete("home/pc/old")
+  s.subscribe("home/**") { |sm| p [sm.kind, sm.encoding, sm.timestamp&.to_time] }
+  q = s.querier("home/**/status", timeout: 1.0)
+  q.get(errors: true).each { |r| puts r.error? ? "error: #{r.payload}" : r.payload }
+  latched = s.advanced_publisher("home/pc/mode", cache: 1, sample_miss_detection: true)
+  latched.put("eco")                                 # late subscribers with history: get it
+  s.advanced_subscriber("home/**/mode", history: true) { |sm| puts sm.payload }
+  s.on_transport { |ev| puts "#{ev.zid} #{ev.kind}" }
+  s.run
+end
 ```
 
 | Call | Notes |
 |---|---|
-| `Asterism::Zenoh.open(locator = nil, mode:, listen:, interval: 0.002)` | `Session.open` wrapped in a `Connection`. With a block: yields it, closes it after (also on an exception), returns the block's value |
+| `Asterism::Zenoh.open(locator = nil, mode:, listen:, scouting:, timestamping:, config:, config_file:, interval: 0.002)` | `Session.open` wrapped in a `Connection`. With a block: yields it, closes it after (also on an exception), returns the block's value |
 | `Connection.new(session)` | wraps a session opened with the polled API |
-| `s.put(key, payload, attachment: nil)` | a payload that is not a String is sent as `to_s` |
+| `s.put(key, payload, attachment: nil, **opts)` | a payload that is not a String is sent as `to_s`. opts: `encoding:`, `priority:`, `congestion_control:`, `express:`, `reliability:`, `timestamp:`, `allowed_destination:` (asterism-zenoh's `Session#put`) |
+| `s.delete(key, **opts)` | subscribers get a `Sample` of kind `:delete` |
+| `s.publisher(key, **opts)` | a `Publisher`: `put(payload, attachment:, encoding:, timestamp:)`, `delete`, `matching?`, `on_matching { \|listening\| }` (on the receiving thread), `close` |
+| `s.advanced_publisher(key, cache:, sample_miss_detection:, publisher_detection:, **opts)` | the same `Publisher`, keeping the last samples for late subscribers (ROS 2's transient local) |
+| `s.advanced_subscriber(key, depth: 16, history:, recovery:, **opts) { \|sample\| }` | a `Subscription` that also gets the publishers' history; `on_publisher { \|key, alive\| }`, `on_miss { \|miss\| }` |
+| `s.querier(key, timeout: 2.0, **opts)` | a `Querier`: `get(params:, payload:, attachment:, encoding:, errors: false)` like `s.get`, `matching?`, `on_matching`, `close` |
+| `s.on_transport(history: false) { \|ev\| }` / `s.on_link { \|ev\| }` | a `TransportEvent` / `LinkEvent` (`added?` / `removed?`, `zid`, ...) on the receiving thread; returns an `Events` (`close`) |
+| `s.peer_zids`, `router_zids`, `transports`, `links`, `new_timestamp`, `declare_keyexpr(key)` | as in asterism-zenoh |
 | `s.subscribe(key, depth: 16) { \|sample\| }` | the block gets each `Sample` on the receiving thread. Returns a `Subscription` (`close` ends it) |
 | `s.subscribe(key, depth: 16)` | a `Subscription` to take from: `each(timeout: nil)` waits for samples (an Enumerator without a block; Enumerable), `each_pending` gives what is there now as Samples, `pending` / `received` / `dropped` / `closed?` / `close` |
 | `s.queryable(key, depth: 16, complete: false) { \|q\| }` | each query on the receiving thread, finished when the block returns. `q.reply(payload)` answers on the queryable's key (when it has no wildcard), `q.reply(key, payload, attachment:)` as before. Without a block, `each(timeout:)` yields the queries |
-| `s.get(key, timeout: 2.0, params:, payload:, attachment:, target:, consolidation:)` | an Enumerator of `Reply`; each iteration sends the get again. With a block: yields each, returns their number |
+| `s.get(key, timeout: 2.0, params:, payload:, attachment:, target:, consolidation:, errors: false, **opts)` | an Enumerator of `Reply`; each iteration sends the get again. With a block: yields each, returns their number. `errors: true` also yields the error replies (`reply.error?`); opts: `encoding:`, `priority:`, `congestion_control:`, `express:`, `accept_replies:` |
 | `s.liveliness(key)` | a token (`close`) |
 | `s.liveliness_watch(key) { \|key, alive\| }` | on the receiving thread; the tokens alive now come first. Without a block, `each` yields `Liveliness` (`key`, `alive?`) |
 | `s.liveliness_get(key, timeout: 2.0)` | the keys alive now (an Array) |
@@ -134,8 +166,9 @@ end
 | `s.on_error { \|error, where\| }` | what the blocks raise (`StandardError`); without a handler it is printed with `warn`. Receiving goes on |
 | `s.session`, `zid`, `peers`, `poll`, `closed?`, `close` | |
 
-`Sample`, `Reply` (`key`, `payload`, `attachment`; `text` is the payload as
-UTF-8) and `Liveliness` are `Data` values, so they work with pattern
+`Sample`, `Reply` (`key`, `payload`, `attachment`, and since 0.3.0 `kind`,
+`encoding`, `timestamp` and the rest; `text` is the payload as UTF-8; both
+are asterism-zenoh's) and `Liveliness` are `Data` values, so they work with pattern
 matching: `case sample in {key: %r{/temp\z}, payload:}`. Times are seconds
 here (the polled API counts milliseconds).
 

data/lib/asterism/cruby/zenoh.rb

@@ -8,6 +8,9 @@
 #     s.put("home/pc/hello", "hi")
 #     s.get("home/**/status").each { |reply| p reply }
 #     s.subscribe("sensor/temp").each.lazy.map { _1.payload.to_f }.first(3)
+#     pub = s.publisher("home/pc/temp", encoding: "text/plain")
+#     pub.on_matching { |listening| puts "someone listens: #{listening}" }
+#     s.on_transport { |ev| puts "#{ev.zid} #{ev.kind}" }
 #     s.run                              # until Ctrl-C (or s.start / s.stop)
 #   end
 #
@@ -19,28 +22,8 @@ module Asterism
     # Pause between looks while an Enumerator waits for data (seconds).
     ENUM_STEP = 0.002
 
-    # A received sample. payload and attachment are binary Strings (the
-    # attachment nil when there was none); text is the payload as UTF-8.
-    Sample = Data.define(:key, :payload, :attachment) do
-      def text
-        payload.dup.force_encoding(Encoding::UTF_8)
-      end
-
-      def to_s
-        "#{key}: #{payload}"
-      end
-    end
-
-    # A reply to a get: the key it was sent with, payload and attachment.
-    Reply = Data.define(:key, :payload, :attachment) do
-      def text
-        payload.dup.force_encoding(Encoding::UTF_8)
-      end
-
-      def to_s
-        "#{key}: #{payload}"
-      end
-    end
+    # Sample and Reply (the received values, with kind, encoding,
+    # timestamp and the rest) are asterism-zenoh's (asterism/zenoh/values).
 
     # A liveliness change: key of the token, and whether it appeared.
     Liveliness = Data.define(:key, :alive) do
@@ -57,6 +40,20 @@ module Asterism
         args.unshift(@asterism_key) if args.size == 1 && @asterism_key
         super(*args, **kw)
       end
+
+      # reply_del without a key: the queryable's own key, as reply.
+      def reply_del(key = nil, **kw)
+        super(key || @asterism_key, **kw)
+      end
+
+      def reply_err(payload, **kw)
+        super(payload.is_a?(String) ? payload : payload.to_s, **kw)
+      end
+    end
+
+    # A payload as a String (anything else is sent as to_s).
+    def self.bytes(payload)
+      payload.is_a?(String) ? payload : payload.to_s
     end
 
     # The queryable's key when it names one key (no wildcard).
@@ -92,10 +89,10 @@ module Asterism
     # Waits on the calling thread until a sample comes into sub (an
     # Asterism::Zenoh::Subscriber or LivelinessWatch), yielding each.
     # Ends when sub or the session closes, or after timeout seconds.
-    def self.drain(sub, session, timeout)
+    def self.drain(sub, session, timeout, take: :each_pending)
       deadline = timeout && (Process.clock_gettime(Process::CLOCK_MONOTONIC) + timeout)
       loop do
-        got = sub.each_pending
+        got = sub.public_send(take)
         got.each { |e| yield e }
         break if sub.closed? || session.closed?
         break if deadline && Process.clock_gettime(Process::CLOCK_MONOTONIC) >= deadline
@@ -115,11 +112,65 @@ module Asterism
         @runner.add { @session.poll ? 0 : false }
       end
 
-      def put(key, payload, attachment: nil)
-        @session.put(key, payload.is_a?(String) ? payload : payload.to_s, attachment: attachment)
+      # opts: those of Session#put (attachment:, encoding:, priority:,
+      # congestion_control:, express:, reliability:, timestamp:,
+      # allowed_destination:). A payload that is not a String is sent as
+      # to_s.
+      def put(key, payload, **opts)
+        @session.put(key, Zenoh.bytes(payload), **opts)
+        nil
+      end
+
+      # Deletes key (subscribers get a Sample of kind :delete). opts: those
+      # of Session#delete.
+      def delete(key, **opts)
+        @session.delete(key, **opts)
         nil
       end
 
+      # A declared publisher (Connection::Publisher): put / delete,
+      # matching?, on_matching { |listening| }. opts: those of
+      # Session#publisher (encoding:, priority:, ...).
+      def publisher(key, **opts)
+        Publisher.new(self, @session.publisher(key, **opts), key)
+      end
+
+      # An advanced publisher (cache:, sample_miss_detection:,
+      # publisher_detection: and the publisher options): late subscribers
+      # with history get what it kept. Same object as publisher.
+      def advanced_publisher(key, **opts)
+        Publisher.new(self, @session.advanced_publisher(key, **opts), key)
+      end
+
+      # An advanced subscriber (history:, recovery:, subscriber_detection:,
+      # query_timeout_ms:): like subscribe, plus on_publisher and on_miss.
+      def advanced_subscriber(key, depth: 16, **opts, &blk)
+        sub = AdvancedSubscription.new(self, @session.advanced_subscriber(key, depth, **opts), key)
+        sub.handle(&blk) if blk
+        sub
+      end
+
+      # A declared get (Connection::Querier): get { |reply| }, matching?,
+      # on_matching. timeout in seconds; the rest as Session#querier.
+      def querier(key, timeout: 2.0, **opts)
+        Querier.new(self, @session.querier(key, timeout_ms: Zenoh.ms(timeout, 2000), **opts), key)
+      end
+
+      # on_transport(history: false) { |event| }: a TransportEvent (kind
+      # :added / :removed, zid, whatami) on the receiving thread each time a
+      # peer or router connects or goes. Returns an Events (close it).
+      def on_transport(history: false, depth: 16, &blk)
+        raise ArgumentError, "a block is needed" unless blk
+        Events.new(self, @session.transport_events(depth, history: history), "on_transport", blk)
+      end
+
+      # on_link(history: false) { |event| }: a LinkEvent each time a link
+      # opens or closes.
+      def on_link(history: false, depth: 16, &blk)
+        raise ArgumentError, "a block is needed" unless blk
+        Events.new(self, @session.link_events(depth, history: history), "on_link", blk)
+      end
+
       # With a block: every sample is given to it (as a Sample) on the
       # receiving thread; returns the Subscription (close it to stop).
       # Without: a Subscription to take from (each, each_pending).
@@ -141,11 +192,17 @@ module Asterism
       # The replies to a get: yields each Reply until every answer came or
       # timeout (seconds) ran out, and returns their number. Without a
       # block, an Enumerator (each iteration sends the get again).
+      # errors: true also yields the error replies (Reply#error?); opts:
+      # encoding:, priority:, congestion_control:, express:,
+      # accept_replies: (Session#get).
       def get(key, timeout: 2.0, params: nil, payload: nil, attachment: nil, target: :all,
-              consolidation: :none, &blk)
-        args = [key, timeout, params, payload, attachment, target, consolidation]
-        return enum_for(:get_each, *args) unless blk
-        get_each(*args, &blk)
+              consolidation: :none, errors: false, **opts, &blk)
+        start = lambda do
+          @session.get(key, Zenoh.ms(timeout, 2000), params, payload,
+                       attachment: attachment, target: target, consolidation: consolidation, **opts)
+        end
+        return enum_for(:get_each, start, errors) unless blk
+        get_each(start, errors, &blk)
       end
 
       # A liveliness token (close it to withdraw).
@@ -221,6 +278,20 @@ module Asterism
         @session.peers
       end
 
+      # The Zenoh IDs of the peers / routers connected now.
+      def peer_zids = @session.peer_zids
+      def router_zids = @session.router_zids
+
+      # What is connected now: Arrays of Transport / Link.
+      def transports = @session.transports
+      def links = @session.links
+
+      # A new Timestamp from the session's clock (put(timestamp:)).
+      def new_timestamp = @session.new_timestamp
+
+      # A KeyExpr declared on the session (use it as the key afterwards).
+      def declare_keyexpr(key) = @session.declare_keyexpr(key)
+
       # Stops receiving and closes the session (with everything declared on
       # it). Idempotent.
       def close
@@ -235,17 +306,21 @@ module Asterism
 
       private
 
-      def get_each(key, timeout, params, payload, attachment, target, consolidation)
-        g = @session.get(key, Zenoh.ms(timeout, 2000), params, payload,
-                         attachment: attachment, target: target, consolidation: consolidation)
+      # Sends the get (start) and yields each Reply; error replies only
+      # with errors. The done? before taking the replies: once the get is
+      # done, every reply it had is already in the queue.
+      def get_each(start, errors)
+        g = start.call
         n = 0
         loop do
-          got = g.each_reply
+          done = g.done?
+          got = g.each_result
           got.each do |r|
+            next if r.error? && !errors
             n += 1
-            yield Reply.new(r[0], r[1], r[2])
+            yield r
           end
-          break if g.done? && g.pending == 0
+          break if done && g.pending == 0
           sleep(ENUM_STEP) if got.empty?
         end
         n
@@ -272,8 +347,8 @@ module Asterism
           where = "subscribe #{@key}"
           r = @conn.runner
           @task = r.add do
-            got = @subscriber.each_pending
-            got.each { |e| r.guard(where) { blk.call(Sample.new(e[0], e[1], e[2])) } }
+            got = @subscriber.each_sample
+            got.each { |s| r.guard(where) { blk.call(s) } }
             got.size
           end
           self
@@ -285,13 +360,13 @@ module Asterism
         def each(timeout: nil, &blk)
           return enum_for(:each, timeout: timeout) unless blk
           raise ::Asterism::Error, "this subscription has a block; its samples go there" if @task
-          Zenoh.drain(@subscriber, @conn.session, timeout) { |e| blk.call(Sample.new(e[0], e[1], e[2])) }
+          Zenoh.drain(@subscriber, @conn.session, timeout, take: :each_sample) { |s| blk.call(s) }
           self
         end
 
         # The samples there now as Samples (an Array), or yields them.
         def each_pending
-          got = @subscriber.each_pending.map { |e| Sample.new(e[0], e[1], e[2]) }
+          got = @subscriber.each_sample
           return got unless block_given?
           got.each { |s| yield s }
           got.size
@@ -417,6 +492,157 @@ module Asterism
           nil
         end
       end
+
+      # A publisher (or advanced publisher) of a Connection.
+      class Publisher
+        attr_reader :key, :publisher
+
+        def initialize(conn, publisher, key)
+          @conn = conn
+          @publisher = publisher
+          @key = key.to_s
+          @tasks = []
+        end
+
+        # opts: attachment:, encoding:, timestamp:. A payload that is not a
+        # String is sent as to_s.
+        def put(payload, **opts)
+          @publisher.put(Zenoh.bytes(payload), **opts)
+          nil
+        end
+
+        def delete(**opts)
+          @publisher.delete(**opts)
+          nil
+        end
+
+        # True when a subscriber matches the key now.
+        def matching? = @publisher.matching?
+
+        # on_matching { |listening| }: true when the first subscriber
+        # appears, false when the last one goes, on the receiving thread.
+        def on_matching(depth: 16, &blk)
+          raise ArgumentError, "a block is needed" unless blk
+          @tasks << Events.new(@conn, @publisher.matching_listener(depth), "on_matching #{@key}", blk)
+          self
+        end
+
+        def closed? = @publisher.closed?
+
+        def close
+          @tasks.each(&:close)
+          @tasks.clear
+          @publisher.close
+          nil
+        end
+
+        def inspect
+          "#<Asterism::Zenoh::Connection::Publisher #{@key}>"
+        end
+      end
+
+      # A querier of a Connection: the same get, sent again and again.
+      class Querier
+        attr_reader :key, :querier
+
+        def initialize(conn, querier, key)
+          @conn = conn
+          @querier = querier
+          @key = key.to_s
+          @tasks = []
+        end
+
+        # Yields each Reply until every answer came or the querier's time
+        # ran out; returns their number. errors: true also yields the error
+        # replies. Without a block, an Enumerator.
+        def get(params: nil, payload: nil, attachment: nil, encoding: nil, errors: false, &blk)
+          start = -> { @querier.get(params, payload, attachment: attachment, encoding: encoding) }
+          return @conn.send(:enum_for, :get_each, start, errors) unless blk
+          @conn.send(:get_each, start, errors, &blk)
+        end
+
+        def matching? = @querier.matching?
+
+        # on_matching { |answered| }: true when a queryable matches, false
+        # when none does any more.
+        def on_matching(depth: 16, &blk)
+          raise ArgumentError, "a block is needed" unless blk
+          @tasks << Events.new(@conn, @querier.matching_listener(depth), "on_matching #{@key}", blk)
+          self
+        end
+
+        def closed? = @querier.closed?
+
+        def close
+          @tasks.each(&:close)
+          @tasks.clear
+          @querier.close
+          nil
+        end
+      end
+
+      # A subscription with history and recovery (advanced_subscriber).
+      class AdvancedSubscription < Subscription
+        def initialize(conn, subscriber, key)
+          super
+          @extra = []
+        end
+
+        # on_publisher { |key, alive| }: the advanced publishers on the key
+        # that declared publisher_detection, as they come and go (the ones
+        # there now first).
+        def on_publisher(depth: 16, history: true, &blk)
+          raise ArgumentError, "a block is needed" unless blk
+          w = Watch.new(@conn, @subscriber.detect_publishers(depth, history: history), @key)
+          w.handle(&blk)
+          @extra << w
+          self
+        end
+
+        # on_miss { |miss| }: samples that never came (Miss: source_zid,
+        # source_eid, count); needs sample_miss_detection on the publisher.
+        def on_miss(depth: 16, &blk)
+          raise ArgumentError, "a block is needed" unless blk
+          @extra << Events.new(@conn, @subscriber.miss_listener(depth), "on_miss #{@key}", blk)
+          self
+        end
+
+        def close
+          @extra.each(&:close)
+          @extra.clear
+          super
+        end
+
+        def inspect
+          "#<Asterism::Zenoh::Connection::AdvancedSubscription #{@key}#{@task ? ' (block)' : ''}>"
+        end
+      end
+
+      # The values of a listener (MatchingListener or EventListener) given
+      # to a block on the receiving thread. close stops it.
+      class Events
+        attr_reader :listener
+
+        def initialize(conn, listener, where, blk)
+          @conn = conn
+          @listener = listener
+          r = conn.runner
+          @task = r.add do
+            got = @listener.each_pending
+            got.each { |v| r.guard(where) { blk.call(v) } }
+            got.size
+          end
+        end
+
+        def closed? = @listener.closed?
+
+        def close
+          @conn.runner.remove(@task) if @task
+          @task = nil
+          @listener.close
+          nil
+        end
+      end
     end
   end
 end

data/lib/asterism/version.rb

@@ -1,5 +1,5 @@
 module Asterism
   # The gem's version (the CRuby gem asterism; it depends on asterism-zenoh
   # of the same version).
-  VERSION = "0.2.0"
+  VERSION = "0.3.0"
 end

data/mrblib/ros.rb

@@ -58,7 +58,7 @@ module Asterism
     def self.mangle(name)
       s = name.to_s
       return "%" if s.empty? || s == "/"
-      out = ""
+      out = "".dup
       i = 0
       n = s.bytesize
       while i < n
@@ -104,7 +104,7 @@ module Asterism
     # rmw_zenoh hashes the entity's liveliness key the same way (with XXH3);
     # receivers only use the GID to tell publishers apart.
     def self.gid_for(key)
-      out = ""
+      out = "".dup
       lane = 0
       while lane < 4
         h = 0x811c9dc5 ^ (lane * 0x9e3779b9 & 0xffffffff)
@@ -225,7 +225,7 @@ module Asterism
 
     # Asterism::ROS::<Pkg>::<Name>, or nil.
     def self.type_constant(pkg, name)
-      mod_name = ""
+      mod_name = "".dup  # a fresh String: literals may be frozen (Ruby 4)
       pkg.split("_").each do |w|
         mod_name << w.byteslice(0, 1).upcase << w.byteslice(1, w.bytesize - 1) if w.bytesize > 0
       end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: asterism
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.3.0
 platform: ruby
 authors:
 - Katsuhiko Kageyama
@@ -16,14 +16,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.2.0
+        version: 0.3.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.2.0
+        version: 0.3.0
 - !ruby/object:Gem::Dependency
   name: msgpack
   requirement: !ruby/object:Gem::Requirement