can_messenger 1.4.0 → 2.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d6460da6eaff67f984db1e7f63466b8350140b244c4e7beaea56595a95e7da92
-  data.tar.gz: 7f06c6f54c0e6fc7ea49aff994ad7ad076c7d3a5f98cb50554793751f8941372
+  metadata.gz: b79b0febdca3de5f068c142413eef6f959461518e3928cd9beed52b14ee8ceef
+  data.tar.gz: aca5cf8fde09f75b6f0d7a81ab1bca9e6a59fc2d3d811a72321eb6b9d6b88ba9
 SHA512:
-  metadata.gz: b1b3bdb759e1ed223c0e08d43c7fdcbf556123c007ecad5dce1b2b4b9b8ac35af289b64a15d16c46939a6ee9028d52b5015f35f4576b14637406884e9e881270
-  data.tar.gz: 1de19b416ecf4733f074c7c704a966313a86c6f16d9a631f7ff14a5b3ebf9b923dfe24930948bbb910554a376e168f49ea1a6c5c8abd324902efbdc9ed65366d
+  metadata.gz: 864bd3e56da612dee5e02bd6e575eff32adab311c3090e2a874704ee7fb6f84895146294a83362be40faef5477e3951c69203f6ecd4ad094a79067d4a5928d1e
+  data.tar.gz: c1bc154e2b42b3373aadd0e27572d66221d3859fb5272f0594fc5d1adb1a4e1382de1e04e02e7e2171bf28b6f2a1cfc33500b4c4af0f0acd3edf35ea3b87c1f4

data/CHANGELOG.md

@@ -0,0 +1,181 @@
+## [Unreleased]
+
+## [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
+
+- **Breaking:** Require Ruby 4.0.1 or higher.
+- Update CI to run on Ruby 4.0.1.
+- Upgrade RuboCop to support Ruby 4.0 and refresh linting.
+- Minor style cleanups in DBC parsing and message listener block forwarding.
+- Extract SocketCAN logic into a dedicated adapter and add a base adapter interface.
+- Allow injecting a custom adapter into `Messenger` for alternate transports or testing.
+- **Breaking:** Default CAN ID endianness is now native (`:native`) instead of `:big`.
+
+### Fixed
+
+- Close SocketCAN sockets when bind/setsockopt fails to avoid leaks.
+
+## [1.4.0] - 2025-07-25
+
+### Added
+
+- `send_dbc_message` helper for encoding and sending messages defined in DBC files.
+
+### Changed
+
+- `send_can_message` now only accepts raw frame parameters.
+- DBC parsing code split into helper methods for clarity.
+
+### Fixed
+
+- Correct encoding of negative signal values using two's-complement.
+
+## [1.3.0] - 2025-06-27
+
+### Added
+
+- Optional **CAN FD** support for sending and receiving up to 64-byte frames.
+
+### Changed
+
+- Updated APIs to accept a `can_fd:` flag on initialization and message methods.
+
+### Fixed
+
+- (Nothing since last release.)
+
+## [1.2.1] - 2025-06-05
+
+### Changed
+
+- `send_can_message` now raises `ArgumentError` when data length exceeds eight bytes.
+- Updated RBS `initialize` signature to include the `endianness` argument.
+- Fixed formatting in README around extended CAN frames.
+- Clarified spec helper comment.
+
+### Fixed
+
+- Addressed a listener restart bug allowing `start_listening` to be called again.
+
+## [1.2.0] - 2025-02-28
+
+### Added
+
+- **Explicit extended CAN ID support**.
+  - Added an `extended_id: false` parameter to `send_can_message`, which, if set to `true`, sets the Extended Frame Format bit (bit 31) in the CAN ID.
+  - Updated `parse_frame` to detect and report `extended: true` when the EFF bit is set in incoming frames.
+  - Added corresponding tests for sending and receiving extended CAN frames.
+
+### Changed
+
+- _No breaking changes_, but internal refactoring around how CAN IDs are packed and unpacked.
+  - Removed the masking of bit 31 in `unpack_frame_id`, ensuring extended frames are no longer silently treated as standard frames.
+
+### Fixed
+
+- (Nothing since last release.)
+
+## [1.1.0] - 2025-02-10
+
+### Changed
+
+- **Removed dependency on `cansend`**. We now write CAN frames directly via raw sockets.
+- Internal refactoring to support raw-socket–based sending without changing the public API.
+
+### Fixed
+
+## [1.0.3] - 2025-02-09
+
+- Revert release.yml
+
+### Fixed
+
+## [1.0.2] - 2025-02-09
+
+- Bugfix release.yml
+
+## [1.0.1] - 2025-02-09
+
+### Changed
+
+- Updated the README to include an **Important Considerations** section that outlines environment requirements, API changes (keyword arguments and block requirement), threading and socket management notes, and logging behavior.
+- Made minor documentation clarifications and tweaks to help users avoid common pitfalls.
+
+## [1.0.0] - 2025-02-09
+
+### Changed
+
+- **Breaking Change:** Updated the Messenger API to require keyword arguments (e.g., `interface_name:`) for initialization. Existing code using the old API will need to be updated.
+- **Breaking Change:** Updated the send_can_message Method to require keyword arguments (e.g., `id:,data:`) to send messages to the can bus. Existing code using the old API will need to be updated.
+- Refactored `start_listening`.
+- Enhanced error handling throughout the gem with more detailed logging.
+- Updated type signatures (RBS) and documentation to match the new API.
+- Refactored tests to reflect the new API and improved error handling.
+
+## [0.2.3] - 2025-02-01
+
+### Changed
+
+- Updated the internal listening loop in `start_listening` to continue iterating on nil (timeout) responses instead of breaking out, improving reliability.
+- Suppressed log output during tests by injecting a silent logger.
+- Updated the test suite to better handle long-running listening loops and error conditions.
+
+## [0.2.2] - 2024-12-06
+
+### Changed
+
+- Updated README.md to reflect modern debian package install command.
+
+## [0.2.1] - 2024-12-06
+
+### Changed
+
+- Updated `start_listening` RBS signature to include the `filter` parameter, ensuring type definitions match the implementation.
+
+## [0.2.0] - 2024-12-05
+
+### Added
+
+- Filtering support for `start_listening` via a `filter` parameter:
+  - Single CAN ID.
+  - Range of CAN IDs.
+  - Array of CAN IDs.
+
+### Changed
+
+- Refactored `start_listening` to support optional filtering of incoming CAN messages.
+- Documentation updates for `start_listening` in README.
+
+## [0.1.0] - 2024-11-10
+
+- Initial release
+  [Unreleased]: https://github.com/fk1018/can_messenger/compare/v2.1.0...HEAD
+  [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
+  [1.2.0]: https://github.com/fk1018/can_messenger/compare/v1.1.0...v1.2.0
+  [1.1.0]: https://github.com/fk1018/can_messenger/compare/v1.0.3...v1.1.0
+  [1.0.3]: https://github.com/fk1018/can_messenger/compare/v1.0.1...v1.0.3
+  [1.0.1]: https://github.com/fk1018/can_messenger/compare/v1.0.0...v1.0.1
+  [1.0.0]: https://github.com/fk1018/can_messenger/compare/v0.2.3...v1.0.0
+  [0.2.3]: https://github.com/fk1018/can_messenger/compare/v0.2.2...v0.2.3
+  [0.2.2]: https://github.com/fk1018/can_messenger/compare/v0.2.1...v0.2.2
+  [0.2.1]: https://github.com/fk1018/can_messenger/compare/v0.2.0...v0.2.1
+  [0.2.0]: https://github.com/fk1018/can_messenger/compare/v0.1.0...v0.2.0
+  [0.1.0]: https://github.com/fk1018/can_messenger/releases/tag/v0.1.0

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2024 fk1018
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -12,7 +12,8 @@
 
 ## Requirements
 
-- Ruby 3.0 or higher.
+- Ruby 4.0.1 or higher.
+- Docker (optional, for containerized development without installing Ruby locally).
 
 ## Installation
 
@@ -135,17 +136,34 @@ To stop listening, use:
 messenger.stop_listening
 ```
 
+### Adapters
+
+`CanMessenger::Messenger` delegates low-level CAN bus operations to an adapter. By default it uses the
+SocketCAN adapter which communicates with Linux CAN interfaces using raw sockets:
+
+```ruby
+messenger = CanMessenger::Messenger.new(interface_name: "can0")
+```
+
+You can provide a custom adapter via the `adapter:` option:
+
+```ruby
+my_adapter = MyCustomAdapter.new(interface_name: "can0", logger: Logger.new($stdout))
+messenger = CanMessenger::Messenger.new(interface_name: "can0", adapter: my_adapter)
+```
+
+To build your own adapter, subclass `CanMessenger::Adapter::Base` and implement the required methods
+`open_socket`, `build_can_frame`, `receive_message`, and `parse_frame`.
+
 ## Important Considerations
 
 Before using `can_messenger`, please note the following:
 
 - **Environment Requirements:**
-
   - **SocketCAN** must be available on your Linux system.
   - **Permissions:** Working with raw sockets may require elevated privileges or membership in a specific group to open and bind to CAN interfaces without running as root.
 
 - **API Changes (v1.0.0 and later):**
-
   - **Keyword Arguments:** The Messenger API now requires keyword arguments. For example, when initializing the Messenger:
 
     ```ruby
@@ -169,16 +187,14 @@ Before using `can_messenger`, please note the following:
     ```
 
 - **Threading & Socket Management:**
-
   - **Blocking Behavior:** The gem uses blocking socket calls and continuously listens for messages. Manage the listener’s lifecycle appropriately, especially in multi-threaded environments. Always call `stop_listening` to gracefully shut down the listener.
   - **Resource Cleanup:** The socket is automatically closed when the listening loop terminates. Stop the listener to avoid resource leaks.
 
 - **Logging:**
-
   - **Default Logger:** If no logger is provided, logs go to standard output. Provide a custom logger if you want more control.
 
 - **CAN Frame Format Assumptions:**
-  - By default, the gem uses **big-endian** packing for CAN IDs. If you integrate with a system using little-endian, you may need to adjust or specify an endianness in the code.
+  - By default, the gem uses **native endianness** for CAN IDs (little-endian on most x86/ARM systems). **Changed in v2.0.0:** this default was previously `:big`. You can override this by passing `endianness: :big` or `endianness: :little`.
   - The gem expects a standard CAN frame layout (16 bytes total, with the first 4 for the ID, followed by 1 byte for DLC, 3 bytes of padding, and up to 8 bytes of data). **CAN FD** frames (up to 64 bytes) are supported when enabled.
 
 ## Features
@@ -191,7 +207,58 @@ 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 (no local Ruby required)
+
+Build the development image:
+
+```bash
+docker compose build app
+```
+
+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/base.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module CanMessenger
+  module Adapter
+    # Base adapter defines the interface for CAN bus adapters.
+    # Concrete adapters must implement all of the methods defined here.
+    class Base
+      attr_reader :interface_name, :logger, :endianness
+
+      def self.native_endianness
+        native = pack_uint(1, "I")
+        return :little if native == pack_uint(1, "V")
+        return :big if native == pack_uint(1, "N")
+
+        # Fallback for unusual platforms.
+        native.bytes.first == 1 ? :little : :big
+      end
+
+      def self.pack_uint(value, template)
+        [value].pack(template)
+      end
+      private_class_method :pack_uint
+
+      def initialize(interface_name:, logger:, endianness: :native)
+        @interface_name = interface_name
+        @logger = logger
+        normalized_endianness = normalize_endianness(endianness)
+        @endianness = normalized_endianness == :native ? self.class.native_endianness : normalized_endianness
+      end
+
+      # Open a socket for the underlying interface.
+      # @return [Object] adapter-specific socket
+      def open_socket(can_fd: false)
+        raise NotImplementedError, "open_socket must be implemented in subclasses"
+      end
+
+      # Build a frame ready to be written to the socket.
+      def build_can_frame(id:, data:, extended_id: false, can_fd: false)
+        raise NotImplementedError, "build_can_frame must be implemented in subclasses"
+      end
+
+      # Receive and parse a frame from the socket.
+      def receive_message(socket:, can_fd: false)
+        raise NotImplementedError, "receive_message must be implemented in subclasses"
+      end
+
+      # Parse a raw frame string into a message hash.
+      def parse_frame(frame:, can_fd: false)
+        raise NotImplementedError, "parse_frame must be implemented in subclasses"
+      end
+
+      private
+
+      def normalize_endianness(endianness)
+        normalized = endianness.is_a?(String) ? endianness.strip.downcase.to_sym : endianness
+        return normalized if %i[native little big].include?(normalized)
+
+        raise ArgumentError, "endianness must be :native, :little, or :big"
+      end
+    end
+  end
+end

data/lib/can_messenger/adapter/socketcan.rb

@@ -0,0 +1,125 @@
+# frozen_string_literal: true
+
+require "socket"
+require_relative "base"
+
+module CanMessenger
+  module Adapter
+    # Adapter implementation for Linux SocketCAN interfaces.
+    class Socketcan < Base
+      FRAME_SIZE = 16
+      CANFD_FRAME_SIZE = 72
+      MIN_FRAME_SIZE = 8
+      MAX_FD_DATA = 64
+      TIMEOUT = [1, 0].pack("l_2")
+
+      # Creates and configures a CAN socket bound to the interface.
+      def open_socket(can_fd: false)
+        socket = Socket.open(Socket::PF_CAN, Socket::SOCK_RAW, Socket::CAN_RAW)
+        configure_socket(socket, can_fd: can_fd)
+        socket
+      rescue StandardError => e
+        close_socket(socket)
+        logger.error("Error creating CAN socket on interface #{interface_name}: #{e}")
+        nil
+      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
+        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
+        # Set bit 31 for extended frames
+        can_id |= 0x80000000 if extended_id
+
+        # Pack the ID based on endianness
+        id_bytes = endianness == :big ? [can_id].pack("L>") : [can_id].pack("V")
+
+        dlc_and_pad = [data.size, 0, 0, 0].pack("C*")
+
+        payload = if can_fd
+                    data.pack("C*").ljust(MAX_FD_DATA, "\x00")
+                  else
+                    data.pack("C*").ljust(8, "\x00")
+                  end
+
+        id_bytes + dlc_and_pad + payload
+      end
+
+      # Reads a frame from the socket and parses it into a hash.
+      def receive_message(socket:, can_fd: false)
+        frame_size = can_fd ? CANFD_FRAME_SIZE : FRAME_SIZE
+        frame = socket.recv(frame_size)
+        return nil if frame.nil? || frame.size < MIN_FRAME_SIZE
+
+        parse_frame(frame: frame, can_fd: can_fd)
+      rescue IO::WaitReadable
+        nil
+      rescue StandardError => e
+        logger.error("Error receiving CAN message on interface #{interface_name}: #{e}")
+        nil
+      end
+
+      # Parses a raw CAN frame string into a hash with id, data and extended flag.
+      def parse_frame(frame:, can_fd: nil) # rubocop:disable Metrics/MethodLength, Metrics/AbcSize, Metrics/PerceivedComplexity
+        return nil unless frame && frame.size >= MIN_FRAME_SIZE
+
+        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
+
+        data_length = if use_fd
+                        frame[4].ord
+                      else
+                        frame[4].ord & 0x0F
+                      end
+
+        data = if frame.size >= MIN_FRAME_SIZE + data_length
+                 frame[MIN_FRAME_SIZE, data_length].unpack("C*")
+               else
+                 []
+               end
+
+        { id: id, data: data, extended: extended }
+      rescue StandardError => e
+        logger.error("Error parsing CAN frame: #{e}")
+        nil
+      end
+
+      private
+
+      def unpack_frame_id(frame:)
+        if endianness == :big
+          frame[0..3].unpack1("L>")
+        else
+          frame[0..3].unpack1("V")
+        end
+      end
+
+      def configure_socket(socket, can_fd:)
+        socket.bind(Socket.pack_sockaddr_can(interface_name))
+        socket.setsockopt(Socket::SOL_SOCKET, Socket::SO_RCVTIMEO, TIMEOUT)
+        return unless can_fd && Socket.const_defined?(:CAN_RAW_FD_FRAMES)
+
+        socket.setsockopt(Socket.const_defined?(:SOL_CAN_RAW) ? Socket::SOL_CAN_RAW : Socket::CAN_RAW,
+                          Socket::CAN_RAW_FD_FRAMES, 1)
+      end
+
+      def close_socket(socket)
+        return unless socket
+        return if socket.closed?
+
+        socket.close
+      rescue StandardError
+        # Ignore close errors so we can report the original failure.
+      end
+    end
+  end
+end

data/lib/can_messenger/dbc.rb

@@ -85,7 +85,7 @@ module CanMessenger
     # @param [Message] _current The current message being processed (unused but kept for API consistency)
     # @return [Signal, nil] A Signal object if the line matches, nil otherwise
     def parse_signal_line(line, _current) # rubocop:disable Metrics/MethodLength
-      return unless (m = line.match(/^SG_\s+(\w+)\s*:\s*(\d+)\|(\d+)@(\d)([+-])\s*\(([^,]+),([^\)]+)\)/))
+      return unless (m = line.match(/^SG_\s+(\w+)\s*:\s*(\d+)\|(\d+)@(\d)([+-])\s*\(([^,]+),([^)]+)\)/))
 
       sig_name = m[1]
       start_bit = m[2].to_i
@@ -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
 
@@ -506,11 +505,27 @@ module CanMessenger
     # @param [Integer] value The unsigned integer value to potentially convert
     # @return [Integer] The final signed or unsigned value
     def convert_to_signed_if_needed(value)
-      if sign == :signed && value[length - 1] == 1
-        value - (1 << length)
-      else
-        value
+      return value unless sign == :signed && length.positive?
+
+      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

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
-require "socket"
 require "logger"
+require_relative "adapter/socketcan"
 
 module CanMessenger
   # Messenger
@@ -15,25 +15,24 @@ module CanMessenger
   #   messenger.start_listening do |message|
   #     puts "Received: ID=#{message[:id]}, Data=#{message[:data].map { |b| '0x%02X' % b }}"
   #   end
-  class Messenger # rubocop:disable Metrics/ClassLength
-    FRAME_SIZE = 16
-    CANFD_FRAME_SIZE = 72
-    MIN_FRAME_SIZE = 8
-    MAX_FD_DATA = 64
-    TIMEOUT = [1, 0].pack("l_2")
-
+  class Messenger
     # Initializes a new Messenger instance.
     #
     # @param [String] interface_name The CAN interface to use (e.g., 'can0').
     # @param [Logger, nil] logger Optional logger for error handling and debug information.
-    # @param [Symbol] endianness The endianness of the CAN ID (default: :big) can be :big or :little.
+    # @param [Symbol] endianness The endianness of the CAN ID (default: :native) can be :big, :little, or :native.
     # @return [void]
-    def initialize(interface_name:, logger: nil, endianness: :big, can_fd: false)
+    def initialize(interface_name:, logger: nil, endianness: :native, can_fd: false, adapter: Adapter::Socketcan)
       @interface_name = interface_name
       @logger = logger || Logger.new($stdout)
       @listening = true # Control flag for listening loop
-      @endianness    = endianness # :big or :little
+      @endianness    = endianness # :big, :little, or :native
       @can_fd        = can_fd
+      @adapter = if adapter.is_a?(Class)
+                   adapter.new(interface_name: interface_name, logger: @logger, endianness: endianness)
+                 else
+                   adapter
+                 end
     end
 
     # Sends a CAN message by writing directly to a raw CAN socket
@@ -47,7 +46,7 @@ module CanMessenger
       use_fd = can_fd.nil? ? @can_fd : can_fd
 
       with_socket(can_fd: use_fd) do |socket|
-        frame = build_can_frame(id: id, data: data, extended_id: extended_id, can_fd: use_fd)
+        frame = @adapter.build_can_frame(id: id, data: data, extended_id: extended_id, can_fd: use_fd)
         socket.write(frame)
       end
     rescue ArgumentError
@@ -86,7 +85,7 @@ module CanMessenger
     #   - `:id` [Integer] the CAN message ID
     #   - `:data` [Array<Integer>] the message data bytes
     # @return [void]
-    def start_listening(filter: nil, can_fd: nil, dbc: nil, &block)
+    def start_listening(filter: nil, can_fd: nil, dbc: nil, &)
       return @logger.error("No block provided to handle messages.") unless block_given?
 
       @listening = true
@@ -95,7 +94,7 @@ module CanMessenger
 
       with_socket(can_fd: use_fd) do |socket|
         @logger.info("Started listening on #{@interface_name}")
-        process_message(socket, filter, use_fd, dbc, &block) while @listening
+        process_message(socket, filter, use_fd, dbc, &) while @listening
       end
     end
 
@@ -115,7 +114,7 @@ module CanMessenger
     # @yield [socket] An open CAN socket.
     # @return [void]
     def with_socket(can_fd: @can_fd)
-      socket = open_can_socket(can_fd: can_fd)
+      socket = @adapter.open_socket(can_fd: can_fd)
       return @logger.error("Failed to open socket, cannot continue operation.") if socket.nil?
 
       yield socket
@@ -123,57 +122,6 @@ module CanMessenger
       socket&.close
     end
 
-    # Creates and configures a CAN socket bound to @interface_name.
-    #
-    # @return [Socket, nil] The configured CAN socket, or nil if the socket cannot be opened.
-    def open_can_socket(can_fd: @can_fd) # rubocop:disable Metrics/MethodLength
-      socket = Socket.open(Socket::PF_CAN, Socket::SOCK_RAW, Socket::CAN_RAW)
-      socket.bind(Socket.pack_sockaddr_can(@interface_name))
-      socket.setsockopt(Socket::SOL_SOCKET, Socket::SO_RCVTIMEO, TIMEOUT)
-      if can_fd && Socket.const_defined?(:CAN_RAW_FD_FRAMES)
-        socket.setsockopt(Socket.const_defined?(:SOL_CAN_RAW) ? Socket::SOL_CAN_RAW : Socket::CAN_RAW,
-                          Socket::CAN_RAW_FD_FRAMES, 1)
-      end
-      socket
-    rescue StandardError => e
-      @logger.error("Error creating CAN socket on interface #{@interface_name}: #{e}")
-      nil
-    end
-
-    # Builds a raw CAN or CAN FD frame for SocketCAN.
-    #
-    # @param id [Integer] the CAN ID
-    # @param data [Array<Integer>] data bytes (up to 8 for classic, 64 for CAN FD)
-    # @param can_fd [Boolean] whether to build a CAN FD frame
-    # @return [String] the packed CAN frame
-    def build_can_frame(id:, data:, extended_id: false, can_fd: false) # 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
-
-      # If extended_id == true, set bit 31 (CAN_EFF_FLAG)
-      can_id |= 0x80000000 if extended_id
-
-      # Pack the 4‐byte ID (big-endian or little-endian)
-      id_bytes = @endianness == :big ? [can_id].pack("L>") : [can_id].pack("V")
-
-      # 1 byte for DLC/length, then 3 bytes for flags/reserved
-      dlc_and_pad = [data.size, 0, 0, 0].pack("C*")
-
-      payload = if can_fd
-                  data.pack("C*").ljust(MAX_FD_DATA, "\x00")
-                else
-                  data.pack("C*").ljust(8, "\x00")
-                end
-
-      id_bytes + dlc_and_pad + payload
-    end
-
     # Processes a single CAN message from `socket`. Applies filter, yields to block if it matches.
     #
     # @param socket [Socket] The CAN socket.
@@ -181,7 +129,7 @@ module CanMessenger
     # @yield [message] Yields the message if it passes filtering.
     # @return [void]
     def process_message(socket, filter, can_fd, dbc, &block)
-      message = receive_message(socket: socket, can_fd: can_fd)
+      message = @adapter.receive_message(socket: socket, can_fd: can_fd)
       return if message.nil?
       return if filter && !matches_filter?(message_id: message[:id], filter: filter)
 
@@ -195,68 +143,6 @@ module CanMessenger
       @logger.error("Unexpected error in listening loop: #{e.message}")
     end
 
-    # Reads a frame from the socket and parses it into { id:, data: }, or nil if none is received.
-    #
-    # @param socket [Socket]
-    # @return [Hash, nil]
-    def receive_message(socket:, can_fd: false)
-      frame_size = can_fd ? CANFD_FRAME_SIZE : FRAME_SIZE
-      frame = socket.recv(frame_size)
-      return nil if frame.nil? || frame.size < MIN_FRAME_SIZE
-
-      parse_frame(frame: frame, can_fd: can_fd)
-    rescue IO::WaitReadable
-      nil
-    rescue StandardError => e
-      @logger.error("Error receiving CAN message on interface #{@interface_name}: #{e}")
-      nil
-    end
-
-    # Parses a raw CAN frame into { id: Integer, data: Array<Integer> }, or nil on error.
-    #
-    # @param [String] frame
-    # @return [Hash, nil]
-    def parse_frame(frame:, can_fd: nil) # rubocop:disable Metrics/MethodLength, Metrics/AbcSize, Metrics/PerceivedComplexity
-      return nil unless frame && frame.size >= MIN_FRAME_SIZE
-
-      use_fd = can_fd.nil? ? frame.size >= CANFD_FRAME_SIZE : can_fd
-
-      raw_id = unpack_frame_id(frame: frame)
-
-      # Determine if EFF bit is set
-      extended = raw_id.anybits?(0x80000000)
-      # or raw_id.anybits?(0x80000000) if your Ruby version supports `Integer#anybits?`
-
-      # Now mask off everything except the lower 29 bits
-      id = raw_id & 0x1FFFFFFF
-
-      data_length = if use_fd
-                      frame[4].ord
-                    else
-                      frame[4].ord & 0x0F
-                    end
-
-      # Extract data
-      data = if frame.size >= MIN_FRAME_SIZE + data_length
-               frame[MIN_FRAME_SIZE, data_length].unpack("C*")
-             else
-               []
-             end
-
-      { id: id, data: data, extended: extended }
-    rescue StandardError => e
-      @logger.error("Error parsing CAN frame: #{e}")
-      nil
-    end
-
-    def unpack_frame_id(frame:)
-      if @endianness == :big
-        frame[0..3].unpack1("L>")
-      else
-        frame[0..3].unpack1("V")
-      end
-    end
-
     # Checks whether the given message ID matches the specified filter.
     #
     # @param message_id [Integer] The ID of the incoming CAN message.

data/lib/can_messenger/version.rb

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

metadata

@@ -1,14 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: can_messenger
 version: !ruby/object:Gem::Version
-  version: 1.4.0
+  version: 2.1.0
 platform: ruby
 authors:
 - fk1018
-autorequire:
 bindir: exe
 cert_chain: []
-date: 2025-07-29 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies: []
 description: CanMessenger provides an interface to send and receive messages over
   the CAN bus, useful for applications requiring CAN communication in Ruby.
@@ -18,8 +17,12 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- CHANGELOG.md
+- LICENSE.txt
 - README.md
 - lib/can_messenger.rb
+- lib/can_messenger/adapter/base.rb
+- lib/can_messenger/adapter/socketcan.rb
 - lib/can_messenger/dbc.rb
 - lib/can_messenger/messenger.rb
 - lib/can_messenger/version.rb
@@ -32,7 +35,6 @@ metadata:
   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'
-post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -40,15 +42,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 3.0.0
+      version: 4.0.1
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.22
-signing_key:
+rubygems_version: 4.0.3
 specification_version: 4
 summary: A simple Ruby wrapper to read and write CAN bus messages.
 test_files: []