midi-events 0.6.1 → 0.7.0

data/README.md

@@ -1,5 +1,8 @@
 # MIDI Events
 
+[![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 MIDI Events Objects**
 
 This library is part of a suite of Ruby libraries for MIDI:
@@ -61,6 +64,49 @@ Those expressions all evaluate to the same object:
    @verbose_name="Note On: E4">
 ```
 
+#### Raw Channel Messages
+
+You can also create raw channel messages directly from nibbles and bytes:
+
+```ruby
+MIDIEvents::ChannelMessage.new(0x9, 0x0, 0x40, 0x40)
+```
+
+#### Mutable Properties
+
+Some message properties can be modified after creation:
+
+```ruby
+msg = MIDIEvents::NoteOn["E4"].new(0, 100)
+msg.note += 5  # Transpose up 5 semitones
+```
+
+#### System Realtime Messages
+
+System Realtime messages are used for synchronization:
+
+```ruby
+MIDIEvents::SystemRealtime["Start"].new
+MIDIEvents::SystemRealtime["Stop"].new
+```
+
+#### Building Melodies
+
+You can construct sequences of notes programmatically:
+
+```ruby
+channel = 0
+notes = [36, 40, 43]  # C E G
+octaves = 2
+velocity = 100
+
+melody = []
+
+(0..((octaves-1)*12)).step(12) do |oct|
+  notes.each { |note| melody << MIDIEvents::NoteOn.new(channel, note + oct, velocity) }
+end
+```
+
 #### SysEx Messages
 
 As with any kind of message, you can begin with raw data:
@@ -101,16 +147,15 @@ One way or another, you will wind up with a pair of objects like this:
 
 ## Documentation
 
-* (**TO DO**) [rdoc](http://rubydoc.info/github/javier-sy/midi-events)
+* [rdoc](http://rubydoc.info/github/javier-sy/midi-events)
 
 ## Differences between [MIDI Events](https://github.com/javier-sy/midi-events) library and [MIDI Message](https://github.com/arirusso/midi-message) library
 
 [MIDI Events](https://github.com/javier-sy/midi-events) is mostly a clone of [MIDI Message](https://github.com/arirusso/midi-message) with some modifications:
+
 * Renamed gem to midi-events instead of midi-message
 * Renamed module to MIDIEvents instead of MIDIMessage
 * Removed parsing features (in favour of the more complete parser [MIDI Parser](https://github.com/javier-sy/midi-parser))
-* TODO: update tests to use rspec instead of rake
-* TODO: migrate to (or confirm it's working ok on) Ruby 3.0 and Ruby 3.1
 
 ## Then, why does exist this library if it is mostly a clone of another library?
 
@@ -144,16 +189,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)
@@ -164,7 +199,7 @@ Thanks to [Ari Russo](http://github.com/arirusso) for his ruby library [MIDI Mes
 
 ## License
 
-[MIDI Events](https://github.com/javier-sy/midi-events) Copyright (c) 2021 [Javier Sánchez Yeste](https://yeste.studio), licensed under LGPL 3.0 License
+[MIDI Events](https://github.com/javier-sy/midi-events) Copyright (c) 2021-2025 [Javier Sánchez Yeste](https://yeste.studio), licensed under LGPL 3.0 License
 
 [MIDI Message](https://github.com/arirusso/midi-message) Copyright (c) 2011-2015 [Ari Russo](http://arirusso.com), licensed under Apache License 2.0 (see the file LICENSE.midi-message)
 

data/examples/short_messages.rb

@@ -9,19 +9,12 @@ require "midi-events"
 
 # Here are examples of different ways to construct messages, going from low to high-level
 
-pp MIDIEvents.parse(0x90, 0x40, 0x40)
-
 channel_msg = MIDIEvents::ChannelMessage.new(0x9, 0x0, 0x40, 0x40)
 
 pp channel_msg
 
-# this will return a NoteOn object with the properties of channel_msg
-pp channel_msg.to_type
-
 pp MIDIEvents::ChannelMessage.new(MIDIEvents::Constant::Status["Note On"], 0x0, 0x40, 0x40)
 
-pp MIDIEvents::ChannelMessage.new(MIDIEvents::Constant::Status["Note On"], 0x0, 0x40, 0x40).to_type
-
 pp MIDIEvents::NoteOn.new(0, 64, 64) # or NoteOn.new(0x0, 0x64, 0x64)
 
 # some message properties are mutable

data/lib/midi-events/constant.rb

@@ -1,6 +1,26 @@
 module MIDIEvents
-  # Refer to a MIDI message by its usage
-  # eg *C4* for MIDI note *60* or *Bank Select* for MIDI control change *0*
+  # MIDI constant lookups and mappings
+  #
+  # Provides a flexible system for referring to MIDI messages by their human-readable names
+  # instead of numeric values. For example, "C4" for MIDI note 60, or "Bank Select" for
+  # MIDI control change 0.
+  #
+  # Constants are loaded from a YAML dictionary (midi.yml) and organized into groups
+  # (Notes, Control Changes, Status bytes, etc.).
+  #
+  # @example Looking up note values
+  #   MIDIEvents::Constant.find('Note', 'C4')
+  #   # => #<MIDIEvents::Constant::Map @key="C4", @value=60>
+  #
+  # @example Getting constant value directly
+  #   MIDIEvents::Constant.value('Note', 'E4')
+  #   # => 64
+  #
+  # @example Using constants in message creation
+  #   MIDIEvents::NoteOn["C4"].new(0, 100)
+  #   # Creates a NoteOn message for C4 (MIDI note 60)
+  #
+  # @api public
   module Constant
     # Get a Mapping object for the specified constant
     # @param [Symbol, String] group_name
@@ -20,46 +40,88 @@ module MIDIEvents
       map.value
     end
 
+    # Name manipulation utilities for constant lookups
+    #
+    # Provides methods to normalize and compare constant names in a case-insensitive
+    # manner, supporting both "Control Change" and "control_change" formats.
+    #
+    # @api private
     module Name
       extend self
 
-      # eg "Control Change" -> "control_change"
-      # @param [Symbol, String] string
-      # @return [String]
+      # Convert a name to underscore format
+      #
+      # @example
+      #   MIDIEvents::Constant::Name.underscore("Control Change")
+      #   # => "control_change"
+      #
+      # @param [Symbol, String] string The name to convert
+      # @return [String] The underscored version
       def underscore(string)
         string.to_s.downcase.gsub(/(\ )+/, '_')
       end
 
-      # @param [Symbol, String] key
-      # @param [Symbol, String] other
-      # @return [Boolean]
+      # Check if two names match (case-insensitive, supports underscored or spaced)
+      #
+      # @example
+      #   MIDIEvents::Constant::Name.match?("Control Change", "control_change")
+      #   # => true
+      #
+      # @param [Symbol, String] key First name to compare
+      # @param [Symbol, String] other Second name to compare
+      # @return [Boolean] True if names match
       def match?(key, other)
         match_key = key.to_s.downcase
         [match_key, Name.underscore(match_key)].include?(other.to_s.downcase)
       end
     end
 
-    # MIDI Constant container
+    # Container for a group of related MIDI constants
+    #
+    # Groups organize constants by category (e.g., "Note", "Control Change", "Status").
+    # Each group contains multiple Map objects that pair constant names with their values.
+    #
+    # @example Accessing a constant group
+    #   group = MIDIEvents::Constant::Group['Note']
+    #   group.find('C4')  # => Map object for C4
+    #
+    # @api public
     class Group
-      attr_reader :constants, :key
+      # @return [Array<MIDIEvents::Constant::Map>] The constants in this group
+      attr_reader :constants
 
-      # @param [String] key
-      # @param [Hash] constants
+      # @return [String] The group's key/name
+      attr_reader :key
+
+      # Create a new constant group
+      #
+      # @param [String] key The group identifier
+      # @param [Hash] constants Hash of constant names to values
       def initialize(key, constants)
         @key = key
         @constants = constants.map { |k, v| Constant::Map.new(k, v) }
       end
 
-      # Find a constant by its name
-      # @param [String, Symbol] name
-      # @return [Constant::Map]
+      # Find a constant in this group by its name
+      #
+      # @example
+      #   group = MIDIEvents::Constant::Group['Note']
+      #   group.find('E4')  # => Map for E4 (value 64)
+      #
+      # @param [String, Symbol] name The constant name to find
+      # @return [MIDIEvents::Constant::Map, nil] The matching constant or nil
       def find(name)
         @constants.find { |const| Name.match?(const.key, name) }
       end
 
-      # Find a constant by its value
-      # @param [Object] value
-      # @return [Constant::Map]
+      # Find a constant in this group by its value (reverse lookup)
+      #
+      # @example
+      #   group = MIDIEvents::Constant::Group['Note']
+      #   group.find_by_value(64)  # => Map for E4
+      #
+      # @param [Object] value The numeric value to find
+      # @return [MIDIEvents::Constant::Map, nil] The matching constant or nil
       def find_by_value(value)
         @constants.find { |const| Name.match?(const.value, value) }
       end
@@ -113,28 +175,61 @@ module MIDIEvents
 
     end
 
-    # The mapping of a constant key to its value eg "Note On" => 0x9
+    # A single constant mapping (name to value pair)
+    #
+    # Represents an individual MIDI constant, pairing a human-readable name
+    # with its numeric MIDI value.
+    #
+    # @example
+    #   map = MIDIEvents::Constant::Map.new("C4", 60)
+    #   map.key    # => "C4"
+    #   map.value  # => 60
+    #
+    # @api public
     class Map
-      attr_reader :key, :value
+      # @return [String] The human-readable name of the constant
+      attr_reader :key
+
+      # @return [Object] The numeric MIDI value
+      attr_reader :value
 
-      # @param [String] key
-      # @param [Object] value
+      # Create a new constant mapping
+      #
+      # @param [String] key The constant name (e.g., "C4", "Note On")
+      # @param [Object] value The constant value (e.g., 60, 0x9)
       def initialize(key, value)
         @key = key
         @value = value
       end
     end
 
+    # Helper class for building messages with pre-bound constants
+    #
+    # This class is returned when you call a message class's bracket method
+    # with a constant name (e.g., NoteOn["C4"]). It stores the constant
+    # and message class so that when you call #new, it creates the message
+    # with the constant value already filled in.
+    #
+    # @example
+    #   builder = MIDIEvents::NoteOn["C4"]
+    #   note = builder.new(0, 100)  # channel 0, velocity 100
+    #   # The note value (60 for C4) is automatically filled in
+    #
+    # @api private
     class MessageBuilder
-      # @param [MIDIEvents] klass The message class to build
-      # @param [MIDIEvents::Constant::Map] const The constant to build the message with
+      # Create a new message builder
+      #
+      # @param [Class] klass The message class to build (e.g., NoteOn)
+      # @param [MIDIEvents::Constant::Map] const The constant to build with
       def initialize(klass, const)
         @klass = klass
         @const = const
       end
 
-      # @param [*Object] args
-      # @return [Message]
+      # Create a message instance with the bound constant
+      #
+      # @param [Array] args The remaining arguments for the message constructor
+      # @return [MIDIEvents::Message] The constructed message
       def new(*args)
         args = args.dup
         args.last.is_a?(Hash) ? args.last[:const] = @const : args.push(const: @const)
@@ -142,13 +237,23 @@ module MIDIEvents
       end
     end
 
-    # Shortcuts for dealing with message status
+    # Shortcuts for dealing with MIDI status bytes
+    #
+    # Provides quick lookup of status byte values by their human-readable names
+    # (e.g., "Note On" => 0x9).
+    #
+    # @example
+    #   MIDIEvents::Constant::Status['Note On']  # => 0x9
+    #   MIDIEvents::Constant::Status['Control Change']  # => 0xB
+    #
+    # @api public
     module Status
       extend self
 
-      # The value of the Status constant with the name status_name
-      # @param [String] status_name The key to use to look up a constant value
-      # @return [String] The constant value that was looked up
+      # Find a status byte value by its name
+      #
+      # @param [String, Symbol] status_name The name of the status (e.g., "Note On")
+      # @return [Integer, nil] The status nibble value or nil if not found
       def find(status_name)
         const = Constant.find('Status', status_name)
         const&.value
@@ -156,21 +261,31 @@ module MIDIEvents
       alias [] find
     end
 
-    # Loading constants from the spec file into messages
+    # Internal system for loading constants into message objects
+    #
+    # Handles the automatic population of message metadata (names, verbose names)
+    # based on constant definitions in midi.yml.
+    #
+    # @api private
     module Loader
       extend self
 
-      # Get the index of the constant from the given message's type
-      # @param [Message] message
-      # @return [Fixnum]
+      # Get the property index for a constant in a message
+      #
+      # @param [MIDIEvents::Message] message The message to inspect
+      # @return [Integer] The index of the constant property
       def get_index(message)
         key = message.class.constant_property
         message.class.properties.index(key) || 0
       end
 
-      # Used to populate message metadata with information gathered from midi.yml
-      # @param [Message] message
-      # @return [Hash, nil]
+      # Populate message metadata using constant information from midi.yml
+      #
+      # Looks up the constant for a message and returns metadata including
+      # the constant object, name, and verbose name.
+      #
+      # @param [MIDIEvents::Message] message The message to populate
+      # @return [Hash, nil] Hash with :const, :name, :verbose_name keys, or nil
       def get_info(message)
         const_group_name = message.class.display_name
         group_name_alias = message.class.constant_name
@@ -189,7 +304,12 @@ module MIDIEvents
         end
       end
 
-      # DSL type class methods for loading constants into messages
+      # DSL class methods for message classes to work with constants
+      #
+      # These methods are extended into message classes to provide constant lookup
+      # functionality (e.g., NoteOn["C4"]).
+      #
+      # @api private
       module DSL
         # Find a constant value in this class's group for the passed in key
         # @param [String] name The constant key
@@ -228,9 +348,16 @@ module MIDIEvents
           Constant::Status[display_name]
         end
 
-        # This returns a MessageBuilder for the class, preloaded with the selected const
-        # @param [String, Symbol] const_name The constant key to use to build the message
-        # @return [MIDIEvents::MessageBuilder] A MessageBuilder object for the passed in constant
+        # Find a constant and return a MessageBuilder bound to it
+        #
+        # This enables the bracket syntax: NoteOn["C4"].new(channel, velocity)
+        #
+        # @example
+        #   builder = MIDIEvents::NoteOn["C4"]
+        #   note = builder.new(0, 100)  # Creates NoteOn for C4 on channel 0
+        #
+        # @param [String, Symbol] const_name The constant name to look up
+        # @return [MIDIEvents::Constant::MessageBuilder, nil] Builder or nil if not found
         def find(const_name)
           const = get_constant(const_name.to_s)
           MessageBuilder.new(self, const) unless const.nil?

data/lib/midi-events/context.rb

@@ -1,15 +1,44 @@
 module MIDIEvents
 
-  # A DSL for instantiating message objects
+  # DSL for creating MIDI messages with shared context
+  #
+  # Provides a convenient way to create multiple MIDI messages that share common
+  # parameters (like channel and velocity) without repeating them for each message.
+  #
+  # @example Basic context usage
+  #   MIDIEvents.with(channel: 0, velocity: 100) do
+  #     note_on("C4")   # Creates NoteOn with channel 0, velocity 100
+  #     note_off("C4")  # Creates NoteOff with channel 0, velocity 100
+  #   end
+  #
+  # @example Override context parameters
+  #   MIDIEvents.with(channel: 0, velocity: 100) do
+  #     note_on("C4")                  # Uses context: channel 0, velocity 100
+  #     note_on("E4", velocity: 127)   # Overrides velocity to 127
+  #   end
+  #
+  # @example Control changes in context
+  #   MIDIEvents.with(channel: 0) do
+  #     control_change("Modulation Wheel", 64)
+  #     program_change("Acoustic Grand Piano")
+  #   end
+  #
+  # @api public
   class Context
 
-    attr_accessor :channel, :velocity
+    # @return [Integer, nil] The MIDI channel (0-15) for messages created in this context
+    attr_accessor :channel
 
-    # Open a context with the given options
-    # @param [Hash] options
-    # @param [Proc] block
-    # @option options [Fixnum] :channel
-    # @option options [Fixnum] :velocity
+    # @return [Integer, nil] The velocity (0-127) for note messages created in this context
+    attr_accessor :velocity
+
+    # Create and execute a context with the given parameters
+    #
+    # @param [Hash] options Context parameters
+    # @param [Proc] block The block to execute within this context
+    # @option options [Integer] :channel MIDI channel (0-15)
+    # @option options [Integer] :velocity Note velocity (0-127)
+    # @return [Object] The result of evaluating the block
     def self.with(options = {}, &block)
       new(options, &block).instance_eval(&block)
     end

data/lib/midi-events/type_conversion.rb

@@ -1,15 +1,34 @@
 module MIDIEvents
- 
-  # Helper for converting nibbles and bytes
+
+  # Utilities for converting between different MIDI data representations
+  #
+  # Provides methods to convert between hex strings, nibbles, and numeric byte arrays.
+  # Useful for working with MIDI data in different formats.
+  #
+  # @example Converting hex string to bytes
+  #   MIDIEvents::TypeConversion.hex_string_to_numeric_byte_array("904040")
+  #   # => [0x90, 0x40, 0x40]
+  #
+  # @example Converting bytes to hex string
+  #   MIDIEvents::TypeConversion.numeric_byte_array_to_hex_string([0x90, 0x40, 0x40])
+  #   # => "904040"
+  #
+  # @api public
   module TypeConversion
-    
+
     extend self
 
-    # Convert an array of hex nibbles to an array of numeric bytes
-    # eg ["9", "0", "4", "0"] to [0x90, 0x40]
+    # Convert an array of hex character nibbles to numeric bytes
+    #
+    # Pairs nibbles together to form bytes. If there's an odd number of nibbles,
+    # the second-to-last nibble is removed.
     #
-    # @param [Array<String>] An array of hex nibbles eg ["9", "0", "4", "0"]
-    # @return [Array<Fixnum] An array of numeric bytes eg [0x90, 0x40]
+    # @example
+    #   hex_chars_to_numeric_byte_array(["9", "0", "4", "0"])
+    #   # => [0x90, 0x40]
+    #
+    # @param [Array<String>] nibbles Array of hex character strings (e.g., ["9", "0", "4", "0"])
+    # @return [Array<Integer>] Array of numeric bytes (e.g., [0x90, 0x40])
     def hex_chars_to_numeric_byte_array(nibbles)
       nibbles = nibbles.dup # Don't mess with the input
       # get rid of last nibble if there's an odd number
@@ -23,10 +42,14 @@ module MIDIEvents
       bytes
     end
     
-    # Convert byte string to an array of numeric bytes
-    # eg. "904040" to [0x90, 0x40, 0x40]
-    # @param [String] string A string representing hex digits eg "904040"
-    # @return [Array<Fixnum>] An array of numeric bytes eg [0x90, 0x40, 0x40]
+    # Convert a hex string to an array of numeric bytes
+    #
+    # @example
+    #   hex_string_to_numeric_byte_array("904040")
+    #   # => [0x90, 0x40, 0x40]
+    #
+    # @param [String] string A string of hex digits (e.g., "904040")
+    # @return [Array<Integer>] An array of numeric bytes (e.g., [0x90, 0x40, 0x40])
     def hex_string_to_numeric_byte_array(string)
       string = string.dup
       bytes = []
@@ -36,18 +59,26 @@ module MIDIEvents
       bytes
     end
     
-    # Convert a string of hex digits to an array of nibbles
-    # eg. "904040" to ["9", "0", "4", "0", "4", "0"]
-    # @param [String] string A string representing hex digits eg "904040"
-    # @return [Array<String>] An array of hex nibble chars eg ["9", "0", "4", "0", "4", "0"]
+    # Convert a hex string to an array of character nibbles
+    #
+    # @example
+    #   hex_str_to_hex_chars("904040")
+    #   # => ["9", "0", "4", "0", "4", "0"]
+    #
+    # @param [String] string A string of hex digits (e.g., "904040")
+    # @return [Array<String>] An array of individual hex character nibbles
     def hex_str_to_hex_chars(string)
       string.split(//)    
     end
     
-    # Convert an array of numeric bytes to a string of hex digits
-    # eg. [0x90, 0x40, 0x40] to "904040"
-    # @param [Array<Fixnum>] bytes An array of numeric bytes eg [0x90, 0x40, 0x40]
-    # @return [String] A string representing hex digits eg "904040"
+    # Convert an array of numeric bytes to an uppercase hex string
+    #
+    # @example
+    #   numeric_byte_array_to_hex_string([0x90, 0x40, 0x40])
+    #   # => "904040"
+    #
+    # @param [Array<Integer>] bytes An array of numeric bytes (e.g., [0x90, 0x40, 0x40])
+    # @return [String] An uppercase hex string (e.g., "904040")
     def numeric_byte_array_to_hex_string(bytes)
       string_bytes = bytes.map do |byte| 
         string = byte.to_s(16)
@@ -57,19 +88,27 @@ module MIDIEvents
       string_bytes.join.upcase
     end
     
-    # Convert a numeric byte to hex chars
-    # eg 0x90 to ["9", "0"]
-    # @param [Fixnum] num A numeric byte eg 0x90
-    # @return [Array<String>] An array of hex nibble chars eg ["9", "0"]
+    # Convert a numeric byte to hex character nibbles
+    #
+    # @example
+    #   numeric_byte_to_hex_chars(0x90)
+    #   # => ["9", "0"]
+    #
+    # @param [Integer] num A numeric byte (e.g., 0x90)
+    # @return [Array<String>] An array of two hex character nibbles (e.g., ["9", "0"])
     def numeric_byte_to_hex_chars(num)
       nibbles = numeric_byte_to_nibbles(num)
       nibbles.map { |n| n.to_s(16) }      
     end
 
-    # Convert a numeric byte to nibbles
-    # eg 0x90 to [0x9, 0x0]
-    # @param [Fixnum] num A numeric byte eg 0x90
-    # @return [Array<Fixnum>] An array of nibbles eg [0x9, 0x0]
+    # Split a numeric byte into its high and low nibbles
+    #
+    # @example
+    #   numeric_byte_to_nibbles(0x90)
+    #   # => [0x9, 0x0]
+    #
+    # @param [Integer] num A numeric byte (e.g., 0x90)
+    # @return [Array<Integer>] An array of two nibbles [high, low] (e.g., [0x9, 0x0])
     def numeric_byte_to_nibbles(num)
       [((num & 0xF0) >> 4), (num & 0x0F)]
     end

data/lib/midi-events/version.rb

@@ -1,3 +1,47 @@
+# Ruby MIDI Events library - object-oriented representation of MIDI messages
+#
+# This library provides a comprehensive set of classes and modules for working with MIDI events
+# in Ruby. It offers an intuitive API for creating and manipulating various MIDI message types
+# including channel messages (notes, control changes, program changes), system messages, and
+# system exclusive (SysEx) messages.
+#
+# @example Basic note creation
+#   require 'midi-events'
+#
+#   # Create a middle C note-on message on channel 0 with velocity 64
+#   note = MIDIEvents::NoteOn.new(0, 64, 64)
+#   # => #<MIDIEvents::NoteOn @channel=0, @note=64, @velocity=64>
+#
+# @example Using note names
+#   # Create note using named constant
+#   note = MIDIEvents::NoteOn["E4"].new(0, 100)
+#   # => #<MIDIEvents::NoteOn @channel=0, @note=64, @velocity=100, @name="E4">
+#
+# @example Using context for common parameters
+#   # Set channel and velocity as context
+#   MIDIEvents.with(channel: 0, velocity: 100) do
+#     note_on("E4")  # Creates note-on with channel 0, velocity 100
+#   end
+#
+# @example Working with control changes
+#   # Create modulation wheel control change
+#   cc = MIDIEvents::ControlChange["Modulation Wheel"].new(0, 64)
+#
+# @example System exclusive messages
+#   # Create a SysEx node representing a device
+#   synth = MIDIEvents::SystemExclusive::Node.new(0x41, model_id: 0x42, device_id: 0x10)
+#
+#   # Send a command to the device
+#   command = synth.command([0x40, 0x7F, 0x00], 0x00)
+#
+# @see MIDIEvents::Context For DSL-style message creation
+# @see MIDIEvents::Constant For MIDI constant lookups
+#
+# @author (c)2021 Javier Sánchez Yeste for the modifications, licensed under LGPL 3.0 License
+# @author (c)2011-2015 Ari Russo for original MIDI Message library, licensed under Apache 2.0 License
+#
+# @note This library is part of the MusaDSL ecosystem
+# @note Based on Ari Russo's MIDI Message library with performance optimizations
 module MIDIEvents
-  VERSION = '0.6.1'.freeze
+  VERSION = '0.7.0'.freeze
 end

data/lib/midi-events.rb

@@ -1,10 +1,3 @@
-#
-# Ruby MIDI message objects
-#
-# (c)2021 Javier Sánchez Yeste for the modifications, licensed under LGPL 3.0 License
-# (c)2011-2015 Ari Russo for original MIDI Message library, licensed under Apache 2.0 License
-#
-
 # Libs
 require 'forwardable'
 require 'yaml'