midi-parser 0.4.0 → 0.5.0

data/README.md

@@ -1,5 +1,8 @@
 # MIDI Parser
 
+[![Ruby Version](https://img.shields.io/badge/ruby-2.7+-red.svg)](https://www.ruby-lang.org/)
+[![License](https://img.shields.io/badge/license-LGPL--3.0--or--later-blue.svg)](https://www.gnu.org/licenses/lgpl-3.0.html)
+
 **Ruby Parser for Raw MIDI Messages**
 
 This library is part of a suite of Ruby libraries for MIDI:
@@ -92,7 +95,7 @@ Use running status:
 
 ```ruby
 midi_parser.parse(0x40, 64)
-  => #<MIDIMEvents::NoteOn:0x98c9818 ...>
+  => #<MIDIEvents::NoteOn:0x98c9818 ...>
 ```
 
 Add an incomplete message:
@@ -116,10 +119,11 @@ MIDI Parser generates [midi-events](http://github.com/javier-sy/midi-events) obj
 
 ## Documentation
 
-* (**TO DO**) [rdoc](http://rubydoc.info/github/javier-sy/midi-parser) 
+* [rdoc](http://rubydoc.info/github/javier-sy/midi-parser) 
 
 ## Differences between [MIDI Parser](https://github.com/javier-sy/midi-parser) and [Nibbler](https://github.com/arirusso/nibbler)
 [MIDI Parser](https://github.com/javier-sy/midi-parser) is mostly a clone of [Nibbler](https://github.com/arirusso/nibbler) with some modifications:
+
 * Removed logging attributes (messages, rejected, processed) to reduce parsing overhead 
 * Updated dependencies versions
 * Source updated to Ruby 2.7 code conventions (method keyword parameters instead of options = {}, hash keys as 'key:' instead of ':key =>', etc.)
@@ -128,8 +132,6 @@ MIDI Parser generates [midi-events](http://github.com/javier-sy/midi-events) obj
 * Renamed module to MIDIParser instead of Nibbler
 * Renamed gem to midi-parser instead of nibbler
 * Minor docs fixing 
-* TODO: update tests to use rspec instead of rake
-* TODO: migrate to (or confirm it's working ok on) Ruby 3.0 or Ruby 3.1
 
 ## Then, why does exist this library if it is mostly a clone of another library?
 
@@ -163,16 +165,6 @@ I've decided to publish my own renamed version of the modified dependencies beca
 
 All in all I have decided to publish a suite of libraries optimized for MusaDSL use case that also can be used by other people in their projects.
 
-| Function | Library | Based on Ari Russo's| Difference |
-| --- | --- | --- | --- |
-| MIDI Events representation | [MIDI Events](https://github.com/javier-sy/midi-events) | [MIDI Message](https://github.com/arirusso/midi-message) | removed parsing, small improvements |
-| MIDI Data parsing | [MIDI Parser](https://github.com/javier-sy/midi-parser) | [Nibbler](https://github.com/arirusso/nibbler) | removed process history information, minor optimizations |
-| MIDI communication with Instruments and Control Surfaces | [MIDI Communications](https://github.com/javier-sy/midi-communications) | [unimidi](https://github.com/arirusso/unimidi) | use of [MIDI Communications MacOS Layer](https://github.com/javier-sy/midi-communications-macos, removed process history information, removed buffering, removed command line script)
-| Low level MIDI interface to MacOS | [MIDI Communications MacOS Layer](https://github.com/javier-sy/midi-communications-macos) | [ffi-coremidi](https://github.com/arirusso/ffi-coremidi) | removed buffering and process history information, locking behaviour when waiting midi events, improved midi devices name detection, minor optimizations |
-| Low level MIDI interface to Linux | **TO DO** | | |
-| Low level MIDI interface to JRuby | **TO DO** | | |
-| Low level MIDI interface to Windows | **TO DO** | | |
-
 ## Author
 
 * [Javier Sánchez Yeste](https://github.com/javier-sy)
@@ -183,6 +175,6 @@ Thanks to [Ari Russo](http://github.com/arirusso) for his ruby library [Nibbler]
 
 ## License
 
-[MIDI Parser](https://github.com/javier-sy/midi-parser) Copyright (c) 2021 [Javier Sánchez Yeste](https://yeste.studio), licensed under LGPL 3.0 License
+[MIDI Parser](https://github.com/javier-sy/midi-parser) Copyright (c) 2021-2025 [Javier Sánchez Yeste](https://yeste.studio), licensed under LGPL 3.0 License
 
 [Nibbler](https://github.com/arirusso/nibbler) Copyright (c) 2011-2015 [Ari Russo](http://arirusso.com), licensed under Apache License 2.0 (see the file LICENSE.nibbler)

data/examples/usage.rb

@@ -2,7 +2,7 @@
 $:.unshift(File.join('..', 'lib'))
 
 #
-# Walk through different ways to use Nibbler
+# Walk through different ways to use MIDI Parser
 #
 
 require 'midi-parser'
@@ -46,26 +46,4 @@ pp 'See progress'
 
 pp midi_parser.buffer # should give you an array of bits
 
-pp midi_parser.buffer_s # should give you an array of bytestrs
-
-pp 'Pass in a timestamp'
-
-# note:
-# once you pass in a timestamp for the first time, midi-parser.messages will then return
-# an array of message/timestamp hashes
-# if there was no timestamp for a particular message it will be nil
-#
-
-pp midi_parser.parse('904040', timestamp: Time.now.to_i)
-
-pp 'Add callbacks'
-
-# you can list any properties of the message to check against.
-# if they are all true, the callback will fire
-#
-# if you wish to use "or" or any more advanced matching I would just process the message after it"s
-# returned
-#
-midi_parser.when({ class: MIDIMessage::NoteOn }) { |msg| puts 'bark' }
-pp midi_parser.parse('904040')
-pp midi_parser.parse('804040')
+pp midi_parser.buffer_s # should give you a hex string

data/lib/midi-parser/data_processor.rb

@@ -1,28 +1,53 @@
 module MIDIParser
-  # Accepts various types of input and returns an array of hex digit chars
+  # Normalizes various input formats into hex nibble strings for parsing.
   #
-  # Ideally this would output Integer objects. However, given that Ruby numerics 0x0 and 0x00 result in the same
-  # object (0 Integer), this would limit the parser to only working with bytes instead of both nibbles and bytes.
+  # DataProcessor accepts bytes, hex strings, nibbles, and arrays, converting
+  # them into a consistent format (uppercase hex character strings) that can
+  # be processed by the {Parser}.
   #
-  # For example, if the input were "5" then the processor would return an ambiguous 0x5
+  # This module handles the complexity of accepting multiple input formats,
+  # allowing users to mix and match formats in a single parse call.
   #
+  # @note This outputs String objects rather than Integers because Ruby's
+  #   0x0 and 0x00 are the same Integer, which would make nibbles and bytes
+  #   ambiguous.
+  #
+  # @example Processing bytes
+  #   MIDIParser::DataProcessor.process([0x90, 0x40, 0x40])
+  #   # => ["9", "0", "4", "0", "4", "0"]
+  #
+  # @example Processing hex string
+  #   MIDIParser::DataProcessor.process(["904040"])
+  #   # => ["9", "0", "4", "0", "4", "0"]
+  #
+  # @example Processing mixed input
+  #   MIDIParser::DataProcessor.process(["9", "0", 0x40, 64])
+  #   # => ["9", "0", "4", "0", "4", "0"]
+  #
+  # @api private
   module DataProcessor
     extend self
 
-    # Accepts various types of input and returns an array of hex digit chars
-    # Invalid input is disregarded
+    # Converts various input formats to an array of hex nibble strings.
+    #
+    # Invalid input (non-hex characters, out-of-range bytes) is filtered out.
     #
-    # @param [*String, *Integer] args
-    # @return [Array<String>] An array of hex string nibbles eg "6", "a"
+    # @param args [Array<String, Integer, Array>] input data in various formats
+    # @return [Array<String>] array of uppercase hex nibble strings (e.g., ["9", "0", "4", "0"])
+    #
+    # @example
+    #   DataProcessor.process([0x90, "40", 0x40])
+    #   # => ["9", "0", "4", "0", "4", "0"]
     def process(*args)
       args.map { |arg| convert(arg) }.flatten.compact.map(&:upcase)
     end
 
     private
 
-    # Convert a single value to hex chars
-    # @param [Array<Integer>, Array<String>, Integer, String] value
-    # @return [Array<String>]
+    # Converts a single value to hex character strings.
+    #
+    # @param value [Array, String, Integer] value to convert
+    # @return [Array<String>, nil] hex character strings, or nil if invalid
     def convert(value)
       case value
       when Array then value.map { |arr| process(*arr) }.reduce(:+)
@@ -31,17 +56,18 @@ module MIDIParser
       end
     end
 
-    # Limit the given number to bytes usable in MIDI ie values (0..240)
-    # returns nil if the byte is outside of that range
-    # @param [Integer] num
-    # @return [Integer, nil]
+    # Filters numeric values to valid MIDI byte range.
+    #
+    # @param num [Integer] byte value to filter
+    # @return [Integer, nil] the value if valid (0x00-0xFF), nil otherwise
     def filter_numeric(num)
       num if (0x00..0xFF).include?(num)
     end
 
-    # Only return valid hex string characters
-    # @param [String] string
-    # @return [String]
+    # Filters a string to only valid hex characters.
+    #
+    # @param string [String] input string
+    # @return [String] string with only hex characters (0-9, A-F)
     def filter_string(string)
       string.gsub(/[^0-9a-fA-F]/, '').upcase
     end

data/lib/midi-parser/message_builder.rb

@@ -1,5 +1,13 @@
 module MIDIParser
+  # Factory for building MIDI message objects from parsed data.
+  #
+  # MessageBuilder maps MIDI status bytes to the appropriate MIDIEvents
+  # message classes and handles the construction of message objects.
+  #
+  # @api private
   class MessageBuilder
+    # Channel message type mappings.
+    # Maps status nibble to message class and expected nibble count.
     CHANNEL_MESSAGE = [
       {
         status: 0x8,
@@ -38,6 +46,8 @@ module MIDIParser
       }
     ].freeze
 
+    # System message type mappings.
+    # Maps status nibble to message class and expected nibble count.
     SYSTEM_MESSAGE = [
       {
         status: 0x1..0x6,
@@ -51,27 +61,52 @@ module MIDIParser
       }
     ].freeze
 
-    attr_reader :num_nibbles, :name, :clazz
+    # @return [Integer] number of nibbles expected for this message type
+    attr_reader :num_nibbles
 
+    # @return [String, nil] optional name for the message type
+    attr_reader :name
+
+    # @return [Class] the MIDIEvents class to instantiate
+    attr_reader :clazz
+
+    # Builds a System Exclusive message from raw data.
+    #
+    # @param message_data [Array<Integer>] SysEx message bytes
+    # @return [MIDIEvents::SystemExclusive] the constructed message
     def self.build_system_exclusive(*message_data)
       MIDIEvents::SystemExclusive.new(*message_data)
     end
 
+    # Creates a MessageBuilder for a system message type.
+    #
+    # @param status [Integer] the second status nibble (0x1-0xF)
+    # @return [MessageBuilder] configured builder for the message type
     def self.for_system_message(status)
       type = SYSTEM_MESSAGE.find { |type| type[:status].cover?(status) }
       new(type[:nibbles], type[:class])
     end
 
+    # Creates a MessageBuilder for a channel message type.
+    #
+    # @param status [Integer] the first status nibble (0x8-0xE)
+    # @return [MessageBuilder] configured builder for the message type
     def self.for_channel_message(status)
       type = CHANNEL_MESSAGE.find { |type| type[:status] == status }
       new(type[:nibbles], type[:class])
     end
 
+    # @param num_nibbles [Integer] expected nibble count for this message type
+    # @param clazz [Class] MIDIEvents class to instantiate
     def initialize(num_nibbles, clazz)
       @num_nibbles = num_nibbles
       @clazz = clazz
     end
 
+    # Builds a MIDI message from the given data.
+    #
+    # @param message_data [Array<Integer>] message data bytes
+    # @return [MIDIEvents::ChannelMessage, MIDIEvents::SystemMessage] the constructed message
     def build(*message_data)
       @clazz.new(*message_data)
     end

data/lib/midi-parser/parser.rb

@@ -1,15 +1,32 @@
 module MIDIParser
+  # Low-level MIDI message parser.
+  #
+  # Parser handles the actual parsing logic, converting hex nibbles into
+  # MIDI message objects. It maintains an internal buffer and supports
+  # MIDI running status.
+  #
+  # This class is typically not used directly. Use {Session} instead for
+  # a higher-level interface.
+  #
+  # @api private
   class Parser
+    # @return [Array<String>] the current buffer of hex nibble strings
     attr_reader :buffer
 
+    # Creates a new parser with empty buffer and running status.
     def initialize
       @running_status = RunningStatus.new
       @buffer = []
     end
 
-    # Process the given nibbles and add them to the buffer
-    # @param [Array<String, Integer>] nibbles
-    # @return [Array<MIDIEvent>]
+    # Processes hex nibbles and returns any complete MIDI messages.
+    #
+    # Nibbles are accumulated in the buffer. When enough data is present
+    # to form a complete MIDI message, it is parsed and returned.
+    #
+    # @param nibbles [Array<String>] hex nibble strings (e.g., ["9", "0", "4", "0"])
+    # @return [Array<MIDIEvents::ChannelMessage, MIDIEvents::SystemMessage>]
+    #   array of parsed messages
     def process(nibbles)
       messages = []
       pointer = 0
@@ -33,9 +50,10 @@ module MIDIParser
       messages
     end
 
-    # If possible, convert the given fragment to a MIDI message
-    # @param [Array<String>] fragment A fragment of data eg ["9", "0", "4", "0", "5", "0"]
-    # @return [Hash, nil]
+    # Attempts to convert a fragment of nibbles to a MIDI message.
+    #
+    # @param fragment [Array<String>] hex nibble strings (e.g., ["9", "0", "4", "0"])
+    # @return [Hash, nil] hash with :message and :processed keys, or nil if incomplete
     def nibbles_to_message(fragment)
       if fragment.length >= 2
         # convert the part of the fragment to start with to a numeric
@@ -76,15 +94,15 @@ module MIDIParser
       @buffer[pointer, (@buffer.length - pointer)]
     end
 
-    # If the given fragment has at least the given number of nibbles, use it to build a hash that can be used
-    # to build a MIDI message
+    # Attempts to build a MIDI message from a fragment with enough nibbles.
     #
-    # @param [Integer] num_nibbles
-    # @param [Array<String>] fragment
-    # @param [Hash] options
-    # @option options [String] :status_nibble_2
-    # @option options [Boolean] :recursive
-    # @return [Hash, nil]
+    # @param fragment [Array<String>] hex nibble strings
+    # @param message_builder [MessageBuilder] builder for the message type
+    # @param options [Hash] additional options
+    # @option options [String] :status_nibble_2 cached status nibble for running status
+    # @option options [Boolean] :recursive whether to try shorter lengths
+    # @option options [Integer] :offset nibble offset adjustment
+    # @return [Hash, nil] hash with :message and :processed keys, or nil
     def lookahead(fragment, message_builder, options = {})
       offset = options.fetch(:offset, 0)
       num_nibbles = message_builder.num_nibbles + offset
@@ -127,6 +145,12 @@ module MIDIParser
       end
     end
 
+    # Manages MIDI running status state.
+    #
+    # Running status is a MIDI optimization where the status byte can be omitted
+    # if it's the same as the previous message.
+    #
+    # @api private
     class RunningStatus
       extend Forwardable
 
@@ -136,16 +160,24 @@ module MIDIParser
 
       def_delegators :@state, :[]
 
+      # Clears the running status state.
+      # @return [nil]
       def cancel
         @state = nil
       end
 
-      # Is there an active cached running status?
-      # @return [Boolean]
+      # Checks if running status is available.
+      # @return [Boolean] true if a previous status is cached
       def possible?
         !@state.nil?
       end
 
+      # Stores the running status state.
+      #
+      # @param offset [Integer] nibble offset for running status
+      # @param message_builder [MessageBuilder] builder for message type
+      # @param status_nibble_2 [String] second status nibble
+      # @return [Hash] the stored state
       def set(offset, message_builder, status_nibble_2)
         @state = {
           message_builder: message_builder,

data/lib/midi-parser/session.rb

@@ -1,35 +1,110 @@
 module MIDIParser
-  # A parser session
+  # A parser session that maintains state between parse calls.
   #
-  # Holds on to data that is not relevant to the parser between calls. For instance,
-  # past messages, rejected bytes
+  # Session is the main interface for parsing MIDI data. It wraps the {Parser}
+  # and provides a convenient API for parsing various input formats and
+  # accessing the internal buffer.
   #
+  # The session maintains a buffer of unparsed nibbles between calls, allowing
+  # for incremental parsing of MIDI data as it arrives.
+  #
+  # @example Basic parsing
+  #   session = MIDIParser::Session.new
+  #   messages = session.parse(0x90, 0x40, 0x40)
+  #   # => [#<MIDIEvents::NoteOn ...>]
+  #
+  # @example Incremental parsing
+  #   session = MIDIParser::Session.new
+  #   session.parse("90")  # => []
+  #   session.parse("40")  # => []
+  #   session.buffer       # => ["9", "0", "4", "0"]
+  #   session.parse("40")  # => [#<MIDIEvents::NoteOn ...>]
+  #
+  # @example Mixed input types
+  #   session = MIDIParser::Session.new
+  #   session.parse("9", "0", 0x40, 64)
+  #   # => [#<MIDIEvents::NoteOn ...>]
+  #
+  # @see MIDIParser.new Convenience constructor
+  # @see Parser The underlying parser
+  #
+  # @api public
   class Session
+    # Creates a new parser session.
+    #
+    # @example
+    #   session = MIDIParser::Session.new
     def initialize
       @parser = Parser.new
     end
 
-    # The buffer
-    # @return [Array<Object>]
+    # Returns the current buffer contents as an array of hex nibble strings.
+    #
+    # The buffer contains unparsed MIDI data waiting for more bytes
+    # to complete a message.
+    #
+    # @return [Array<String>] array of hex nibble strings (e.g., ["9", "0", "4", "0"])
+    #
+    # @example
+    #   session = MIDIParser::Session.new
+    #   session.parse("90", "40")
+    #   session.buffer  # => ["9", "0", "4", "0"]
     def buffer
       @parser.buffer
     end
 
-    # The buffer as a single hex string
-    # @return [String]
+    # Returns the current buffer contents as a single hex string.
+    #
+    # @return [String] concatenated hex string of buffer contents
+    #
+    # @example
+    #   session = MIDIParser::Session.new
+    #   session.parse("90", "40")
+    #   session.buffer_s  # => "9040"
     def buffer_s
       @parser.buffer.join
     end
     alias buffer_hex buffer_s
 
-    # Clear the parser buffer
+    # Clears the parser buffer, discarding any unparsed data.
+    #
+    # @return [Array] empty array
+    #
+    # @example
+    #   session = MIDIParser::Session.new
+    #   session.parse("90", "40")
+    #   session.clear_buffer
+    #   session.buffer  # => []
     def clear_buffer
       @parser.buffer.clear
     end
 
-    # Parse some input
-    # @param [*Object] args
-    # @return [Array<MIDIEvent>]
+    # Parses MIDI data and returns any complete messages.
+    #
+    # Accepts various input formats: bytes (Integer), hex strings (String),
+    # nibbles, or arrays. Input is accumulated in an internal buffer until
+    # complete MIDI messages can be formed.
+    #
+    # @param args [Array<Integer, String>] MIDI data in various formats:
+    #   - Bytes as integers (e.g., 0x90, 0x40, 0x40)
+    #   - Hex strings (e.g., "904040" or "90", "40", "40")
+    #   - Nibbles as strings (e.g., "9", "0", "4", "0")
+    #   - Mixed formats
+    #
+    # @return [Array<MIDIEvents::ChannelMessage, MIDIEvents::SystemMessage>]
+    #   array of parsed MIDI message objects (empty if no complete messages)
+    #
+    # @example Parse bytes
+    #   session.parse(0x90, 0x40, 0x40)
+    #   # => [#<MIDIEvents::NoteOn @channel=0, @note=64, @velocity=64>]
+    #
+    # @example Parse hex string
+    #   session.parse("904040")
+    #   # => [#<MIDIEvents::NoteOn ...>]
+    #
+    # @example Parse multiple messages
+    #   session.parse("90404080404000")
+    #   # => [#<MIDIEvents::NoteOn ...>, #<MIDIEvents::NoteOff ...>]
     def parse(*args)
       queue = DataProcessor.process(args)
       @parser.process(queue)

data/lib/midi-parser/type_conversion.rb

@@ -1,12 +1,29 @@
 module MIDIParser
-  # A helper for converting between different types of nibbles and bytes
+  # Utility module for converting between hex strings, nibbles, and bytes.
+  #
+  # TypeConversion provides methods to transform MIDI data between different
+  # representations: hex character strings, numeric nibbles, and numeric bytes.
+  #
+  # @example Converting hex string to bytes
+  #   TypeConversion.hex_str_to_numeric_bytes("904040")
+  #   # => [0x90, 0x40, 0x40]
+  #
+  # @example Converting bytes to nibbles
+  #   TypeConversion.numeric_byte_to_numeric_nibbles(0x90)
+  #   # => [0x9, 0x0]
+  #
+  # @api private
   module TypeConversion
     extend self
 
-    # Converts an array of hex nibble strings to numeric bytes
-    # eg ["9", "0", "5", "0", "4", "0"] => [0x90, 0x50, 0x40]
-    # @param [Array<String>] nibbles
-    # @return [Array<Integer>]
+    # Converts hex nibble strings to numeric bytes.
+    #
+    # @param nibbles [Array<String>] hex character strings (e.g., ["9", "0", "4", "0"])
+    # @return [Array<Integer>] numeric bytes (e.g., [0x90, 0x40])
+    #
+    # @example
+    #   hex_chars_to_numeric_bytes(["9", "0", "4", "0", "4", "0"])
+    #   # => [0x90, 0x40, 0x40]
     def hex_chars_to_numeric_bytes(nibbles)
       nibbles = nibbles.dup
       # get rid of last nibble if there's an odd number
@@ -20,51 +37,77 @@ module MIDIParser
       bytes
     end
 
-    # Converts a string of hex digits to string nibbles
-    # eg "905040" => ["9", "0", "5", "0", "4", "0"]
-    # @param [String] string
-    # @return [Array<String>]
+    # Splits a hex string into individual character strings.
+    #
+    # @param string [String] hex digit string (e.g., "904040")
+    # @return [Array<String>] individual hex characters (e.g., ["9", "0", "4", "0", "4", "0"])
+    #
+    # @example
+    #   hex_str_to_hex_chars("904040")
+    #   # => ["9", "0", "4", "0", "4", "0"]
     def hex_str_to_hex_chars(string)
       string.split(//)
     end
 
-    # Converts a string of hex digits to numeric nibbles
-    # eg "905040" => [0x9, 0x0, 0x5, 0x0, 0x4, 0x0]
-    # @param [String] string
-    # @return [Array<String>]
+    # Converts a hex string to numeric nibbles.
+    #
+    # @param string [String] hex digit string (e.g., "904040")
+    # @return [Array<Integer>] numeric nibbles (e.g., [0x9, 0x0, 0x4, 0x0, 0x4, 0x0])
+    #
+    # @example
+    #   hex_str_to_numeric_nibbles("904040")
+    #   # => [9, 0, 4, 0, 4, 0]
     def hex_str_to_numeric_nibbles(string)
       bytes = hex_str_to_numeric_bytes(string)
       numeric_bytes_to_numeric_nibbles(bytes)
     end
 
-    # Converts a string of hex digits to numeric bytes
-    # eg "905040" => [0x90, 0x50, 0x40]
-    # @param [String] string
-    # @return [Array<String>]
+    # Converts a hex string to numeric bytes.
+    #
+    # @param string [String] hex digit string (e.g., "904040")
+    # @return [Array<Integer>] numeric bytes (e.g., [0x90, 0x40, 0x40])
+    #
+    # @example
+    #   hex_str_to_numeric_bytes("904040")
+    #   # => [144, 64, 64]
     def hex_str_to_numeric_bytes(string)
       chars = hex_str_to_hex_chars(string)
       hex_chars_to_numeric_bytes(chars)
     end
 
-    # Converts an array bytes to an array of nibbles
-    # eg [0x90, 0x50, 0x40] => [0x9, 0x0, 0x5, 0x0, 0x4, 0x0]
-    # @param [Array<Integer>] bytes
-    # @return [Array<String>]
+    # Converts numeric bytes to numeric nibbles.
+    #
+    # @param bytes [Array<Integer>] byte values (e.g., [0x90, 0x40])
+    # @return [Array<Integer>] nibble values (e.g., [0x9, 0x0, 0x4, 0x0])
+    #
+    # @example
+    #   numeric_bytes_to_numeric_nibbles([0x90, 0x40, 0x40])
+    #   # => [9, 0, 4, 0, 4, 0]
     def numeric_bytes_to_numeric_nibbles(bytes)
       bytes.map { |byte| numeric_byte_to_numeric_nibbles(byte) }.flatten
     end
 
-    # Converts a numeric byte to an array of hex nibble strings eg 0x90 => ["9", "0"]
-    # @param [Integer] num
-    # @return [Array<String>]
+    # Converts a numeric byte to hex character strings.
+    #
+    # @param num [Integer] byte value (e.g., 0x90)
+    # @return [Array<String>] hex characters (e.g., ["9", "0"])
+    #
+    # @example
+    #   numeric_byte_to_hex_chars(0x90)
+    #   # => ["9", "0"]
     def numeric_byte_to_hex_chars(num)
       nibbles = numeric_byte_to_numeric_nibbles(num)
       nibbles.map { |n| n.to_s(16) }
     end
 
-    # Converts a numeric byte to an array of numeric nibbles eg 0x90 => [0x9, 0x0]
-    # @param [Integer] num
-    # @return [Array<String>]
+    # Converts a numeric byte to numeric nibbles.
+    #
+    # @param num [Integer] byte value (e.g., 0x90)
+    # @return [Array<Integer>] nibble values (e.g., [0x9, 0x0])
+    #
+    # @example
+    #   numeric_byte_to_numeric_nibbles(0x90)
+    #   # => [9, 0]
     def numeric_byte_to_numeric_nibbles(num)
       [((num & 0xF0) >> 4), (num & 0x0F)]
     end

data/lib/midi-parser/version.rb

@@ -0,0 +1,3 @@
+module MIDIParser
+  VERSION = '0.5.0'.freeze
+end