midi-message 0.4.8 → 0.4.9

data/lib/midi-message/parser.rb

@@ -1,46 +1,89 @@
 module MIDIMessage
 
-  # Very simple parsing
-  # for more advanced parsing check out {nibbler}[http://github.com/arirusso/nibbler]
+  # Simple message parsing
+  # For more advanced parsing check out {nibbler}[http://github.com/arirusso/nibbler]
   class Parser
 
+    MESSAGE_TYPE = [
+      NoteOff,
+      NoteOn,
+      PolyphonicAftertouch,
+      ControlChange,
+      ProgramChange,
+      ChannelAftertouch,
+      PitchBend,
+      SystemMessage
+    ].freeze
+
+    SYSTEM_MESSAGE_TYPE = [
+      SystemExclusive,
+      SystemCommon,
+      SystemRealtime
+    ].freeze
+
+    # Can take either a hex string eg Parser.new("904040")
+    # or bytes eg Parser.new(0x90, 0x40, 0x40)
+    # or an array of bytes eg Parser.new([0x90, 0x40, 0x40])
+    # @param [Array<Fixnum>, *Fixnum, String] args
+    # @return [MIDIMessage]
+    def self.parse(*args)
+      parser = new(*args)
+      parser.parse
+    end
+
     # Can take either a hex string eg Parser.new("904040")
     # or bytes eg Parser.new(0x90, 0x40, 0x40)
     # or an array of bytes eg Parser.new([0x90, 0x40, 0x40])
+    # @param [Array<Fixnum>, *Fixnum, String] args
+    # @return [MIDIMessage]
     def initialize(*args)
       @data = case args.first
               when Array then args.first
-              when Numeric then args 
+              when Numeric then args
               when String then TypeConversion.hex_string_to_numeric_byte_array(args.first)
               end
     end
 
     # Parse the data and return a message
+    # @return [MIDIMessage]
     def parse
-      first_nibble = ((@data.first & 0xF0) >> 4)
-      second_nibble = (@data.first & 0x0F)
-      case first_nibble
-      when 0x8 then NoteOff.new(second_nibble, @data[1], @data[2])
-      when 0x9 then NoteOn.new(second_nibble, @data[1], @data[2])
-      when 0xA then PolyphonicAftertouch.new(second_nibble, @data[1], @data[2])
-      when 0xB then ControlChange.new(second_nibble, @data[1], @data[2])
-      when 0xC then ProgramChange.new(second_nibble, @data[1])
-      when 0xD then ChannelAftertouch.new(second_nibble, @data[1])
-      when 0xE then PitchBend.new(second_nibble, @data[1], @data[2])
-      when 0xF then case second_nibble
-        when 0x0 then SystemExclusive.new(*@data)
-        when 0x1..0x6 then SystemCommon.new(second_nibble, @data[1], @data[2])
-        when 0x8..0xF then SystemRealtime.new(second_nibble)
-        else nil
-        end
-      else nil
+      nibbles = get_nibbles
+      klass = MESSAGE_TYPE.find { |type| type::STATUS == nibbles[0] }
+      if klass == SystemMessage
+        build_system_message(nibbles[1])
+      else
+        klass.new(nibbles[1], *@data.drop(1))
       end
-    end   
+    end
+
+    private
+
+    def get_nibbles
+      [
+        ((@data.first & 0xF0) >> 4),
+        (@data.first & 0x0F)
+      ]
+    end
+
+    def build_system_message(id)
+      klass = SYSTEM_MESSAGE_TYPE.find do |type|
+        id == type::ID ||
+          (type::ID.kind_of?(Range) && type::ID.include?(id))
+      end
+      if klass == SystemExclusive
+        SystemExclusive.new(*@data)
+      else
+        klass.new(id, *@data.drop(1))
+      end
+    end
 
   end
 
+  # Shortcut to Parser.parse
+  # @param [Array<Fixnum>, *Fixnum, String] args
+  # @return [MIDIMessage]
   def self.parse(*args)
-    Parser.new(*args).parse
+    Parser.parse(*args)
   end
 
 end

data/lib/midi-message/system_exclusive.rb

@@ -4,7 +4,7 @@ module MIDIMessage
   module SystemExclusive
 
     include MIDIMessage # this enables ..kind_of?(MIDIMessage)
-    
+
     def self.included(base)
       base.send(:include, InstanceMethods)
     end
@@ -15,9 +15,6 @@ module MIDIMessage
       attr_accessor :node
       attr_reader :address, :checksum
 
-      StartByte = 0xF0
-      EndByte = 0xF7
-
       # an array of message parts.  multiple byte parts will be represented as an array of bytes
       def to_a(options = {})
         omit = options[:omit] || []
@@ -56,20 +53,20 @@ module MIDIMessage
       alias_method :to_bytestr, :to_hex_s
 
       def name
-        "System Exclusive"
+        SystemExclusive::DISPLAY_NAME
       end
       alias_method :verbose_name, :name
 
       def start_byte
-        self.class::StartByte
+        SystemExclusive::DELIMITER[:start]
       end
 
       def end_byte
-        self.class::EndByte
+        SystemExclusive::DELIMITER[:finish]
       end
 
       def type_byte
-        self.class::TypeByte
+        self.class::TYPE
       end
 
       # alternate method from
@@ -183,25 +180,41 @@ module MIDIMessage
 
     end
 
-    # Convert raw MIDI data to SysEx message objects
-    def self.new(*bytes)
+    module Builder
 
-      start_status = bytes.shift
-      end_status = bytes.pop
+      extend self
 
-      if start_status == 0xF0 && end_status == 0xF7
+      # Convert raw MIDI data to a SysEx message object
+      def build(*bytes)
+        if is_sysex?(bytes)
 
-        type_byte = bytes[3]
+          # if the 4th byte isn't status, we will just make this a Message object
+          #   -- this may need some tweaking
+          message_class = get_message_class(bytes)
 
-        # if the 4th byte isn't status, we will just make this a Message object -- this may need some tweaking
-        if type_byte == 0x11
-          msg_class = Request
-        elsif type_byte == 0x12
-          msg_class = Command
-        else
-          return Message.new(bytes)
+          if message_class.nil?
+            Message.new(bytes)
+          else
+            build_typed_message(message_class, bytes)
+          end
         end
 
+      end
+
+      private
+
+      def get_message_class(bytes)
+        [Request, Command].find { |klass| klass::TYPE == bytes[3] }
+      end
+
+      def is_sysex?(bytes)
+        bytes.shift == SystemExclusive::DELIMITER[:start] &&
+          bytes.pop == SystemExclusive::DELIMITER[:finish]
+      end
+
+      # Build a SysEx message object of the given type using the given bytes
+      def build_typed_message(message_class, bytes)
+        bytes = bytes.dup
         fixed_length_message_part = bytes.slice!(0,7)
 
         manufacturer_id = fixed_length_message_part[0]
@@ -213,8 +226,15 @@ module MIDIMessage
         value = bytes
 
         node = Node.new(manufacturer_id, :model_id => model_id, :device_id => device_id)
-        msg_class.new(address, value, :checksum => checksum, :node => node)
+        message_class.new(address, value, :checksum => checksum, :node => node)
       end
+
+    end
+
+    # Convert raw MIDI data to a SysEx message object
+    # Shortcut to Builder.build
+    def self.new(*bytes)
+      Builder.build(*bytes)
     end
 
   end

data/lib/midi-message/system_message.rb

@@ -3,6 +3,8 @@ module MIDIMessage
   # Common MIDI system message behavior
   module SystemMessage
 
+    STATUS = 0xF
+
     def self.included(base)
       base.send(:include, Message)
     end
@@ -13,7 +15,7 @@ module MIDIMessage
     # @param [Fixnum] byte The byte to strip of a redundant 0xF
     # @return [Fixnum] The remaining nibble
     def strip_redundant_nibble(byte)
-      byte > 0xF ? (byte & 0x0F) : byte
+      byte > STATUS ? (byte & 0x0F) : byte
     end
 
   end

data/test/constant_test.rb

@@ -1,6 +1,6 @@
 require "helper"
 
-class ConstantTest < Minitest::Test
+class MIDIMessage::ConstantTest < Minitest::Test
 
   context "Constant" do
 
@@ -33,6 +33,30 @@ class ConstantTest < Minitest::Test
 
     end
 
+    context "Name" do
+
+      context ".underscore" do
+
+        should "convert string" do
+          @result = MIDIMessage::Constant::Name.underscore("Control Change")
+          refute_nil @result
+          assert_equal "control_change", @result
+        end
+
+      end
+
+      context ".match?" do
+
+        should "match string" do
+          assert MIDIMessage::Constant::Name.match?("Control Change", :control_change)
+          assert MIDIMessage::Constant::Name.match?("Note", :note)
+          assert MIDIMessage::Constant::Name.match?("System Common", :system_common)
+        end
+
+      end
+
+    end
+
     context "Group" do
 
       context "#find" do
@@ -68,11 +92,65 @@ class ConstantTest < Minitest::Test
 
     end
 
+    context "MessageBuilder" do
+
+      context "#new" do
+
+        context "note on" do
+
+          setup do
+            @group = MIDIMessage::Constant::Group.find(:note)
+            @map = @group.find("C3")
+            @builder = MIDIMessage::Constant::MessageBuilder.new(MIDIMessage::NoteOn, @map)
+          end
+
+          should "build correct note" do
+            @note = @builder.new
+            refute_nil @note
+            assert_equal "C3", @note.name
+          end
+
+        end
+
+        context "cc" do
+
+          setup do
+            @group = MIDIMessage::Constant::Group.find(:control_change)
+            @map = @group.find("Modulation Wheel")
+            @builder = MIDIMessage::Constant::MessageBuilder.new(MIDIMessage::ControlChange, @map)
+          end
+
+          should "build correct cc" do
+            @cc = @builder.new
+            refute_nil @cc
+            assert_equal "Modulation Wheel", @cc.name
+          end
+
+        end
+
+      end
+
+    end
+
+    context "Status" do
+
+      context ".find" do
+
+        should "find status" do
+          assert_equal 0x8, MIDIMessage::Constant::Status.find("Note Off")
+          assert_equal 0x9, MIDIMessage::Constant::Status.find("Note On")
+          assert_equal 0xB, MIDIMessage::Constant::Status["Control Change"]
+        end
+
+      end
+
+    end
+
     context "Loader" do
 
       context "DSL" do
 
-        context "#[]" do
+        context ".find" do
 
           context "note on" do
 
@@ -108,7 +186,7 @@ class ConstantTest < Minitest::Test
           context "cc" do
 
             setup do
-              @message = MIDIMessage::ControlChange["Modulation Wheel"].new(2, 0x20)
+              @message = MIDIMessage::ControlChange.find("Modulation Wheel").new(2, 0x20)
             end
 
             should "create message object" do

data/test/context_test.rb

@@ -1,129 +1,133 @@
 require "helper"
 
-class ContextTest < Minitest::Test
+class MIDIMessage::ContextTest < Minitest::Test
 
   context "Context" do
 
-    context "note off" do
+    context ".with" do
 
-      setup do
-        @message = MIDIMessage.with(:channel => 0, :velocity => 64) do
-          note_off(55)
+      context "note off" do
+
+        setup do
+          @message = MIDIMessage.with(:channel => 0, :velocity => 64) do
+            note_off(55)
+          end
+        end
+
+        should "create message object" do
+          assert_equal(0, @message.channel)
+          assert_equal(55, @message.note)
+          assert_equal(64, @message.velocity)
+          assert_equal([128, 55, 64], @message.to_a)
+          assert_equal("803740", @message.to_bytestr)
         end
-      end
 
-      should "create message object" do
-        assert_equal(0, @message.channel)
-        assert_equal(55, @message.note)
-        assert_equal(64, @message.velocity)
-        assert_equal([128, 55, 64], @message.to_a)
-        assert_equal("803740", @message.to_bytestr)
       end
 
-    end
+      context "note on" do
 
-    context "note on" do
+        setup do
+          @message = MIDIMessage.with(:channel => 0, :velocity => 64) do
+            note_on(55)
+          end
+        end
 
-      setup do
-        @message = MIDIMessage.with(:channel => 0, :velocity => 64) do
-          note_on(55)
+        should "create message object" do
+          assert_equal(0, @message.channel)
+          assert_equal(55, @message.note)
+          assert_equal(64, @message.velocity)
+          assert_equal([144, 55, 64], @message.to_a)
+          assert_equal("903740", @message.to_bytestr)
         end
-      end
 
-      should "create message object" do
-        assert_equal(0, @message.channel)
-        assert_equal(55, @message.note)
-        assert_equal(64, @message.velocity)
-        assert_equal([144, 55, 64], @message.to_a)
-        assert_equal("903740", @message.to_bytestr)
       end
 
-    end
+      context "cc" do
 
-    context "cc" do
+        setup do
+          @message = MIDIMessage::Context.with(:channel => 2) do
+            control_change(0x20, 0x30)
+          end
+        end
 
-      setup do
-        @message = MIDIMessage.with(:channel => 2) do
-          control_change(0x20, 0x30)
+        should "create message object" do
+          assert_equal(@message.channel, 2)
+          assert_equal(0x20, @message.index)
+          assert_equal(0x30, @message.value)
+          assert_equal([0xB2, 0x20, 0x30], @message.to_a)
+          assert_equal("B22030", @message.to_bytestr)
         end
-      end
 
-      should "create message object" do
-        assert_equal(@message.channel, 2)
-        assert_equal(0x20, @message.index)
-        assert_equal(0x30, @message.value)
-        assert_equal([0xB2, 0x20, 0x30], @message.to_a)
-        assert_equal("B22030", @message.to_bytestr)
       end
 
-    end
+      context "polyphonic aftertouch" do
 
-    context "polyphonic aftertouch" do
+        setup do
+          @message = MIDIMessage::Context.with(:channel => 1) do
+            polyphonic_aftertouch(0x40, 0x40)
+          end
+        end
 
-      setup do
-        @message = MIDIMessage.with(:channel => 1) do
-          polyphonic_aftertouch(0x40, 0x40)
+        should "create message object" do
+          assert_equal(1, @message.channel)
+          assert_equal(0x40, @message.note)
+          assert_equal(0x40, @message.value)
+          assert_equal([0xA1, 0x40, 0x40], @message.to_a)
+          assert_equal("A14040", @message.to_bytestr)
         end
-      end
 
-      should "create message object" do
-        assert_equal(1, @message.channel)
-        assert_equal(0x40, @message.note)
-        assert_equal(0x40, @message.value)
-        assert_equal([0xA1, 0x40, 0x40], @message.to_a)
-        assert_equal("A14040", @message.to_bytestr)
       end
 
-    end
+      context "program change" do
 
-    context "program change" do
+        setup do
+          @message = MIDIMessage.with(:channel => 3) do
+            program_change(0x40)
+          end
+        end
 
-      setup do
-        @message = MIDIMessage.with(:channel => 3) do
-          program_change(0x40)
+        should "create message object" do
+          assert_equal(3, @message.channel)
+          assert_equal(0x40, @message.program)
+          assert_equal([0xC3, 0x40], @message.to_a)
+          assert_equal("C340", @message.to_bytestr)
         end
-      end
 
-      should "create message object" do
-        assert_equal(3, @message.channel)
-        assert_equal(0x40, @message.program)
-        assert_equal([0xC3, 0x40], @message.to_a)
-        assert_equal("C340", @message.to_bytestr)
       end
 
-    end
+      context "channel aftertouch" do
 
-    context "channel aftertouch" do
+        setup do
+          @message = MIDIMessage.with(:channel => 3) do
+            channel_aftertouch(0x50)
+          end
+        end
 
-      setup do
-        @message = MIDIMessage.with(:channel => 3) do
-          channel_aftertouch(0x50)
+        should "create message object" do
+          assert_equal(3, @message.channel)
+          assert_equal(0x50, @message.value)
+          assert_equal([0xD3, 0x50], @message.to_a)
+          assert_equal("D350", @message.to_bytestr)
         end
-      end
 
-      should "create message object" do
-        assert_equal(3, @message.channel)
-        assert_equal(0x50, @message.value)
-        assert_equal([0xD3, 0x50], @message.to_a)
-        assert_equal("D350", @message.to_bytestr)
       end
 
-    end
+      context "pitch bend" do
 
-    context "pitch bend" do
+        setup do
+          @message = MIDIMessage.with(:channel => 0) do
+            pitch_bend(0x50, 0xA0)
+          end
+        end
 
-      setup do
-        @message = MIDIMessage.with(:channel => 0) do
-          pitch_bend(0x50, 0xA0)
+        should "create message object" do
+          assert_equal(0, @message.channel)
+          assert_equal(0x50, @message.low)
+          assert_equal(0xA0, @message.high)
+          assert_equal([0xE0, 0x50, 0xA0], @message.to_a)
+          assert_equal("E050A0", @message.to_bytestr)
         end
-      end
 
-      should "create message object" do
-        assert_equal(0, @message.channel)
-        assert_equal(0x50, @message.low)
-        assert_equal(0xA0, @message.high)
-        assert_equal([0xE0, 0x50, 0xA0], @message.to_a)
-        assert_equal("E050A0", @message.to_bytestr)
       end
 
     end