can_messenger 2.0.0 → 2.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 15f09405e67a906115972dc84790769875d1dcdb5cbd78a57827ccdf910d7e05
-  data.tar.gz: faa23fc30c89b5a81875ff2664e5f97cac2970cb6161599887a1c02da9b5f36c
+  metadata.gz: 51737c6d0bee83617a3cb2c68b634f63a65ae5b1c711a4720d7a5a37a08a0612
+  data.tar.gz: aebcbd5b0904849633ce3326f60bf9fd28ca47f8c1982601d25161ec383f3a05
 SHA512:
-  metadata.gz: bb33fdda392ca2acaea5357a661b5b9dda245c41db5b000802e4d12886d58b16c49d5238312aa254f062fdc9f46c9f05b9f140f202a0ad73e1ceda9b81d397ca
-  data.tar.gz: 4823263138efc7d61756d473e2e6235487921f7d8e6d8350260dcd80d491bee6927cbf5606671a242576fdb3f3fb5437212f77c008856c3bfa1d2b9a5b5d4924
+  metadata.gz: f6d8a36f95f8afcc859d25bd48b5c49b878b7fd1e2e51245ebe142e83dc3e05bc0e2572233da563ec470b0e0b52b3b59ee55c50c7165dc46b7d13302d2df465c
+  data.tar.gz: 88bca2b12015fa26df773080f8ad540ec30967b486e6a878afe4319c93b743eb758c6dcef9fe302b2af3ee5776e162129a49236368f31ca1343cc30a117096fc

data/CHANGELOG.md

@@ -1,5 +1,31 @@
 ## [Unreleased]
 
+## [2.2.0] - 2026-03-11
+
+### Changed
+
+- Make the Ruby Docker workflow install gems against the checked-in lockfile and self-heal stale bundle cache volumes.
+- Promote the docs site stable snapshot to `2.2.0` and add global RubyGems navigation links.
+
+### Fixed
+
+- Respect DBC-defined extended CAN IDs when sending messages and when decoding received extended frames.
+- Reject invalid outbound CAN IDs instead of silently coercing them to a different wire value.
+
+## [2.1.0] - 2026-02-23
+
+### Changed
+
+- Promote the first stable docs snapshot version to `2.1.0`.
+- Tighten DBC signal bounds validation and report exact out-of-range bit positions.
+
+### Fixed
+
+- Fix DBC big-endian (`@0`) bit mapping for multi-byte signals.
+- Reject unsigned DBC signal values that exceed the field's bit-length range instead of silently wrapping.
+- Align `Messenger` RBS signatures with runtime behavior (`adapter:` support and correct private method surface).
+- Update DBC specs to cover the corrected big-endian behavior and unsigned overflow errors.
+
 ## [2.0.0] - 2026-02-02
 
 ### Changed
@@ -150,6 +176,9 @@
 ## [0.1.0] - 2024-11-10
 
 - Initial release
+  [Unreleased]: https://github.com/fk1018/can_messenger/compare/v2.2.0...HEAD
+  [2.2.0]: https://github.com/fk1018/can_messenger/compare/v2.1.0...v2.2.0
+  [2.1.0]: https://github.com/fk1018/can_messenger/compare/v2.0.0...v2.1.0
   [2.0.0]: https://github.com/fk1018/can_messenger/compare/v1.3.0...v2.0.0
   [1.3.0]: https://github.com/fk1018/can_messenger/compare/v1.2.1...v1.3.0
   [1.2.1]: https://github.com/fk1018/can_messenger/compare/v1.2.0...v1.2.1

data/README.md

@@ -13,6 +13,7 @@
 ## Requirements
 
 - Ruby 4.0.1 or higher.
+- Docker (optional, for containerized development without installing Ruby locally).
 
 ## Installation
 
@@ -34,6 +35,8 @@ Or install it yourself with:
 gem install can_messenger
 ```
 
+RubyGems page: [https://rubygems.org/gems/can_messenger](https://rubygems.org/gems/can_messenger)
+
 ## Usage
 
 ### Initializing the Messenger
@@ -127,6 +130,8 @@ messenger.start_listening(dbc: dbc) do |msg|
 end
 ```
 
+If the DBC message definition uses an extended CAN ID, `send_dbc_message` automatically sends it as an extended frame and `start_listening(dbc: ...)` decodes received extended frames back through the same DBC definition.
+
 ### Stopping the Listener
 
 To stop listening, use:
@@ -206,7 +211,60 @@ Before using `can_messenger`, please note the following:
 
 ## Development
 
-After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake test:rspec` to execute the test suite.
+### Docker-first workflow
+
+Build the development image:
+
+```bash
+docker compose build app
+```
+
+The Ruby services automatically run `bundle check || bundle install` inside the container, so an existing bundle cache volume stays usable after dependency changes.
+
+Run RuboCop:
+
+```bash
+docker compose run --rm lint
+```
+
+Run the test suite:
+
+```bash
+docker compose run --rm test
+```
+
+Build the gem:
+
+```bash
+docker compose run --rm build
+```
+
+Install docs dependencies (Docusaurus):
+
+```bash
+docker compose run --rm docs npm ci
+```
+
+Build the docs site:
+
+```bash
+docker compose run --rm docs npm run build
+```
+
+Preview docs locally:
+
+```bash
+docker compose run --rm --service-ports docs npm run start
+```
+
+### Local Ruby workflow
+
+If you already have Ruby installed locally, you can still use:
+
+```bash
+bin/setup
+bundle exec rake test:rspec
+```
 
 ## Contributing
 

data/lib/can_messenger/adapter/socketcan.rb

@@ -2,6 +2,7 @@
 
 require "socket"
 require_relative "base"
+require_relative "../constants"
 
 module CanMessenger
   module Adapter
@@ -11,10 +12,11 @@ module CanMessenger
       CANFD_FRAME_SIZE = 72
       MIN_FRAME_SIZE = 8
       MAX_FD_DATA = 64
+      MAX_STANDARD_ID = 0x7FF
       TIMEOUT = [1, 0].pack("l_2")
 
       # Creates and configures a CAN socket bound to the interface.
-      def open_socket(can_fd: false)
+      def open_socket(can_fd: nil)
         socket = Socket.open(Socket::PF_CAN, Socket::SOCK_RAW, Socket::CAN_RAW)
         configure_socket(socket, can_fd: can_fd)
         socket
@@ -25,17 +27,18 @@ module CanMessenger
       end
 
       # Builds a raw CAN or CAN FD frame for SocketCAN.
-      def build_can_frame(id:, data:, extended_id: false, can_fd: false) # rubocop:disable Metrics/MethodLength, Metrics/AbcSize, Metrics/PerceivedComplexity
+      def build_can_frame(id:, data:, extended_id: false, can_fd: nil) # rubocop:disable Metrics/MethodLength, Metrics/AbcSize, Metrics/PerceivedComplexity
         if can_fd
           raise ArgumentError, "CAN FD data cannot exceed #{MAX_FD_DATA} bytes" if data.size > MAX_FD_DATA
         elsif data.size > 8
           raise ArgumentError, "CAN data cannot exceed 8 bytes"
         end
 
-        # Mask the ID to 29 bits
-        can_id = id & 0x1FFFFFFF
+        validate_can_id!(id, extended_id: extended_id)
+
+        can_id = id
         # Set bit 31 for extended frames
-        can_id |= 0x80000000 if extended_id
+        can_id |= Constants::EXTENDED_ID_FLAG if extended_id
 
         # Pack the ID based on endianness
         id_bytes = endianness == :big ? [can_id].pack("L>") : [can_id].pack("V")
@@ -52,7 +55,7 @@ module CanMessenger
       end
 
       # Reads a frame from the socket and parses it into a hash.
-      def receive_message(socket:, can_fd: false)
+      def receive_message(socket:, can_fd: nil)
         frame_size = can_fd ? CANFD_FRAME_SIZE : FRAME_SIZE
         frame = socket.recv(frame_size)
         return nil if frame.nil? || frame.size < MIN_FRAME_SIZE
@@ -72,8 +75,8 @@ module CanMessenger
         use_fd = can_fd.nil? ? frame.size >= CANFD_FRAME_SIZE : can_fd
 
         raw_id = unpack_frame_id(frame: frame)
-        extended = raw_id.anybits?(0x80000000)
-        id = raw_id & 0x1FFFFFFF
+        extended = raw_id.anybits?(Constants::EXTENDED_ID_FLAG)
+        id = raw_id & Constants::MAX_EXTENDED_ID
 
         data_length = if use_fd
                         frame[4].ord
@@ -120,6 +123,16 @@ module CanMessenger
       rescue StandardError
         # Ignore close errors so we can report the original failure.
       end
+
+      def validate_can_id!(id, extended_id:)
+        raise ArgumentError, "id must be an Integer" unless id.is_a?(Integer)
+        raise ArgumentError, "CAN id cannot be negative" if id.negative?
+
+        max_id = extended_id ? Constants::MAX_EXTENDED_ID : MAX_STANDARD_ID
+        return if id <= max_id
+
+        raise ArgumentError, "#{extended_id ? "Extended" : "Standard"} CAN id cannot exceed 0x#{max_id.to_s(16).upcase}"
+      end
     end
   end
 end

data/lib/can_messenger/constants.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module CanMessenger
+  module Constants
+    CAN_ID_MASK = 0x1FFFFFFF
+    EXTENDED_ID_FLAG = 0x80000000
+    MAX_EXTENDED_ID = 0x1FFFFFFF
+  end
+end

data/lib/can_messenger/dbc.rb

@@ -283,15 +283,15 @@ module CanMessenger
     # @return [void]
     # @raise [ArgumentError] If signal bits exceed message boundaries or start_bit is negative
     def validate_signal_bounds(message_size_bytes)
-      max_bit = start_bit + length - 1
-      max_allowed_bit = (message_size_bytes * 8) - 1
-
       raise ArgumentError, "Signal #{name}: start_bit (#{start_bit}) cannot be negative" if start_bit.negative?
+      raise ArgumentError, "Signal #{name}: length (#{length}) must be positive" if length <= 0
 
-      return unless max_bit > max_allowed_bit
+      max_allowed_bit = max_allowed_bit_for(message_size_bytes)
+      invalid_position = invalid_bit_position(max_allowed_bit)
+      return unless invalid_position
 
       raise ArgumentError,
-            "Signal #{name}: signal bits #{start_bit}..#{max_bit} exceed message size " \
+            "Signal #{name}: bit position #{invalid_position} exceeds message size " \
             "(#{message_size_bytes} bytes = #{max_allowed_bit + 1} bits)"
     end
 
@@ -328,9 +328,15 @@ module CanMessenger
     # @return [void]
     # @raise [ArgumentError] If an unsigned value is negative
     def validate_unsigned_value(raw)
-      return unless sign == :unsigned && raw.negative?
+      return unless sign == :unsigned
+
+      raise ArgumentError, "Unsigned value cannot be negative: #{raw}" if raw.negative?
 
-      raise ArgumentError, "Unsigned value cannot be negative: #{raw}"
+      max_val = (1 << length) - 1
+      return if raw <= max_val
+
+      raise ArgumentError,
+            "Unsigned value #{raw} out of range [0..#{max_val}] for #{length}-bit field"
     end
 
     # Validates signed values to ensure they fit in the signal's bit range.
@@ -396,19 +402,12 @@ module CanMessenger
       if endianness == :little
         start_bit + bit_offset
       else
-        # For big-endian signals, the bit numbering within a byte follows MSB-first
-        # ordering. This means that the most significant bit (MSB) is numbered 7,
-        # and the least significant bit (LSB) is numbered 0. To calculate the absolute
-        # bit position, we first determine the position of the MSB in the starting byte.
-        #
-        # The formula ((start_bit / 8) * 8) calculates the starting byte's base bit
-        # position (aligned to the nearest multiple of 8). Adding (7 - (start_bit % 8))
-        # adjusts this base position to point to the MSB of the starting byte.
-        #
-        # Finally, we subtract the bit offset to account for the signal's length and
-        # position within the message.
-        base = ((start_bit / 8) * 8) + (7 - (start_bit % 8))
-        base - bit_offset
+        # DBC big-endian (`@0`) start_bit is in sawtooth numbering and points at the
+        # signal MSB. Convert to sequential network numbering, move toward the LSB,
+        # then convert back to the little-endian bit index used by byte writes.
+        network_start = sawtooth_to_network_bitnum(start_bit)
+        network_bit = network_start + (length - 1 - bit_offset)
+        sawtooth_to_network_bitnum(network_bit)
       end
     end
 
@@ -511,5 +510,22 @@ module CanMessenger
       msb_set = (value >> (length - 1)).allbits?(1)
       msb_set ? value - (1 << length) : value
     end
+
+    def sawtooth_to_network_bitnum(bitnum)
+      (8 * (bitnum / 8)) + (7 - (bitnum % 8))
+    end
+
+    def invalid_bit_position(max_allowed_bit)
+      length.times do |i|
+        bit_pos = calculate_bit_position(i)
+        return bit_pos if bit_pos.negative? || bit_pos > max_allowed_bit
+      end
+
+      nil
+    end
+
+    def max_allowed_bit_for(message_size_bytes)
+      (message_size_bytes * 8) - 1
+    end
   end
 end

data/lib/can_messenger/messenger.rb

@@ -2,6 +2,7 @@
 
 require "logger"
 require_relative "adapter/socketcan"
+require_relative "constants"
 
 module CanMessenger
   # Messenger
@@ -64,8 +65,8 @@ module CanMessenger
     def send_dbc_message(message_name:, signals:, dbc: @dbc, extended_id: false, can_fd: nil)
       raise ArgumentError, "dbc is required" if dbc.nil?
 
-      encoded = dbc.encode_can(message_name, signals)
-      send_can_message(id: encoded[:id], data: encoded[:data], extended_id: extended_id, can_fd: can_fd)
+      encoded = normalized_dbc_message(dbc.encode_can(message_name, signals), extended_id: extended_id)
+      send_can_message(id: encoded[:id], data: encoded[:data], extended_id: encoded[:extended_id], can_fd: can_fd)
     rescue ArgumentError
       raise
     rescue StandardError => e
@@ -134,7 +135,7 @@ module CanMessenger
       return if filter && !matches_filter?(message_id: message[:id], filter: filter)
 
       if dbc
-        decoded = dbc.decode_can(message[:id], message[:data])
+        decoded = dbc.decode_can(dbc_decode_id(message), message[:data])
         message[:decoded] = decoded if decoded
       end
 
@@ -156,5 +157,27 @@ module CanMessenger
       else true
       end
     end
+
+    def normalize_can_id(id)
+      id & Constants::CAN_ID_MASK
+    end
+
+    def dbc_extended_id?(id)
+      id.anybits?(Constants::EXTENDED_ID_FLAG)
+    end
+
+    def normalized_dbc_message(encoded, extended_id:)
+      {
+        id: normalize_can_id(encoded[:id]),
+        data: encoded[:data],
+        extended_id: extended_id || dbc_extended_id?(encoded[:id])
+      }
+    end
+
+    def dbc_decode_id(message)
+      return message[:id] unless message[:extended]
+
+      message[:id] | Constants::EXTENDED_ID_FLAG
+    end
   end
 end

data/lib/can_messenger/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module CanMessenger
-  VERSION = "2.0.0"
+  VERSION = "2.2.0"
 end

data/lib/can_messenger.rb

@@ -2,6 +2,7 @@
 # frozen_string_literal: true
 
 require_relative "can_messenger/version"
+require_relative "can_messenger/constants"
 require_relative "can_messenger/messenger"
 require_relative "can_messenger/dbc"
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: can_messenger
 version: !ruby/object:Gem::Version
-  version: 2.0.0
+  version: 2.2.0
 platform: ruby
 authors:
 - fk1018
@@ -23,15 +23,16 @@ files:
 - lib/can_messenger.rb
 - lib/can_messenger/adapter/base.rb
 - lib/can_messenger/adapter/socketcan.rb
+- lib/can_messenger/constants.rb
 - lib/can_messenger/dbc.rb
 - lib/can_messenger/messenger.rb
 - lib/can_messenger/version.rb
-homepage: https://github.com/fk1018/can_messenger
+homepage: https://can-messenger.github.io/
 licenses:
 - MIT
 metadata:
   allowed_push_host: https://rubygems.org
-  homepage_uri: https://github.com/fk1018/can_messenger
+  homepage_uri: https://can-messenger.github.io/
   source_code_uri: https://github.com/fk1018/can_messenger
   changelog_uri: https://github.com/fk1018/can_messenger/blob/main/CHANGELOG.md
   rubygems_mfa_required: 'true'