midi-message 0.4.7 → 0.4.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 6e0111fbc4f13b3de102dff3ebbdc0b2ccda001c
-  data.tar.gz: 77408d5b1a726b00d7c4032530c8c361fd31e8dc
+  metadata.gz: a74063f4fe5e1a622a69fc4c775763f20046defb
+  data.tar.gz: 19638072ab7f93b748d5a435263947ece626f9ea
 SHA512:
-  metadata.gz: 1fafe7abcdaf8e90df0bcaeeb49d680266ba453dbf21c28aae68a5dd1d97fd962b9e59077bab2fbafc15872563c674a965dae51a666190235d37b5722b3b8c0c
-  data.tar.gz: 575a16f20a645fbd7cf6304716ab35120d8718fdecca41bea197c09fc55202e225ef48a9930a6aa226cca7c6bc635e22fb49b90cff54651af0ed759e2913dfdd
+  metadata.gz: f85ede4091a84b04f9f292298205cdd7e8fa7e12c24f27e078de4076ede187f94aad464cec41640dfb7aeaf45b2d010a753a4248441143b1157ea93ff5be0a37
+  data.tar.gz: 5f031bf9d385a268d2c3355f787918bf8f1ebdc65321df5a25b7dfc67bc8d5a000f23851e899310f4ee644c9c8f5d161915ffaf74a4845bd87ad0d3630cc4787

data/README.md

@@ -115,4 +115,4 @@ Check out [nibbler](http://github.com/arirusso/nibbler) for more advanced parsin
 
 Apache 2.0, See the file LICENSE
 
-Copyright (c) 2011-2015 Ari Russo
+Copyright (c) 2011-2015 [Ari Russo](http://arirusso.com)

data/lib/midi-message/constant.rb

@@ -4,16 +4,31 @@ module MIDIMessage
   # eg *C4* for MIDI note *60* or *Bank Select* for MIDI control change *0*
   module Constant
 
+    # Get a Mapping object for the specified constant
+    # @param [Symbol, String] group_name
+    # @param [String] const_name
+    # @return [MIDIMessage::Constant::Map, nil]
     def self.find(group_name, const_name)
       group = Group[group_name]
       group.find(const_name)
     end
 
+    # Get the value of the specified constant
+    # @param [Symbol, String] group_name
+    # @param [String] const_name
+    # @return [Object]
+    def self.value(group_name, const_name)
+      map = find(group_name, const_name)
+      map.value
+    end
+
     # MIDI Constant container
     class Group
 
-      attr_reader :key, :value
+      attr_reader :constants, :key
 
+      # @param [String] key
+      # @param [Hash] constants
       def initialize(key, constants)
         @key = key
         @constants = constants.map { |k, v| Constant::Map.new(k, v) }
@@ -25,7 +40,6 @@ module MIDIMessage
       def find(name)
         @constants.find { |const| const.key.to_s.downcase == name.to_s.downcase }
       end
-      alias_method :[], :find
 
       # Find a constant by its value
       # @param [Object] value
@@ -34,45 +48,50 @@ module MIDIMessage
         @constants.find { |const| const.value.to_s.downcase == value.to_s.downcase }
       end
 
-      # All constant groups
-      # @return [Array<ConstantGroup>]
-      def self.all
-        ensure_initialized
-        @groups
-      end
+      class << self
 
-      # Find a constant group by its key
-      # @param [String, Symbol] key
-      # @return [ConstantGroup]
-      def self.[](key)
-        ensure_initialized
-        @groups.find { |g| g.key.to_s.downcase == key.to_s.downcase }
-      end
+        # All constant groups
+        # @return [Array<ConstantGroup>]
+        def all
+          ensure_initialized
+          @groups
+        end
 
-      private
+        # Find a constant group by its key
+        # @param [String, Symbol] key
+        # @return [ConstantGroup]
+        def find(key)
+          ensure_initialized
+          @groups.find { |g| g.key.to_s.downcase == key.to_s.downcase }
+        end
+        alias_method :[], :find
 
-      # Lazy initialize
-      # @return [Boolean]
-      def self.ensure_initialized
-        populate_dictionary | populate_groups
-      end
+        private
 
-      # Populate the dictionary of constants
-      # @return [Boolean]
-      def self.populate_dictionary
-        if @dict.nil?
-          @dict = YAML.load_file(File.expand_path('../../midi.yml', __FILE__))
-          true
+        # Lazy initialize
+        # @return [Boolean]
+        def ensure_initialized
+          populate_dictionary | populate_groups
         end
-      end
 
-      # Populate the constant groups using the dictionary
-      # @return [Boolean]
-      def self.populate_groups
-        if @groups.nil? && !@dict.nil?
-          @groups = @dict.map { |k, v| new(k, v) }
-          true
+        # Populate the dictionary of constants
+        # @return [Boolean]
+        def populate_dictionary
+          if @dict.nil?
+            @dict = YAML.load_file(File.expand_path('../../midi.yml', __FILE__))
+            true
+          end
         end
+
+        # Populate the constant groups using the dictionary
+        # @return [Boolean]
+        def populate_groups
+          if @groups.nil? && !@dict.nil?
+            @groups = @dict.map { |k, v| new(k, v) }
+            true
+          end
+        end
+
       end
 
     end

data/lib/midi-message.rb

@@ -25,6 +25,6 @@ require "midi-message/parser"
 
 module MIDIMessage
 
-  VERSION = "0.4.7"
+  VERSION = "0.4.8"
 
 end

data/test/constant_test.rb

@@ -0,0 +1,160 @@
+require "helper"
+
+class ConstantTest < Minitest::Test
+
+  context "Constant" do
+
+    context ".find" do
+
+      setup do
+        @map = MIDIMessage::Constant.find(:note, "C2")
+      end
+
+      should "return constant mapping" do
+        refute_nil @map
+        assert_equal MIDIMessage::Constant::Map, @map.class
+        assert_equal 36, @map.value
+      end
+
+    end
+
+    context ".value" do
+
+      setup do
+        @value = MIDIMessage::Constant.value(:note, "C3")
+      end
+
+      should "return constant value" do
+        refute_nil @value
+        assert_equal 48, @value
+        assert_equal MIDIMessage::NoteOn.new(0, @value, 100).note, @value
+        assert_equal MIDIMessage::NoteOn["C3"].new(0, 100).note, @value
+      end
+
+    end
+
+    context "Group" do
+
+      context "#find" do
+
+        setup do
+          @group = MIDIMessage::Constant::Group.find(:note)
+          @map = @group.find("C3")
+        end
+
+        should "return correct mapping" do
+          refute_nil @map
+          assert_equal MIDIMessage::Constant::Map, @map.class
+          assert_equal 48, @map.value
+        end
+
+      end
+
+      context ".find" do
+
+        setup do
+          @group = MIDIMessage::Constant::Group.find(:note)
+        end
+
+        should "return group object" do
+          refute_nil @group
+          assert_equal MIDIMessage::Constant::Group, @group.class
+          assert_equal "Note", @group.key
+          refute_empty @group.constants
+          assert @group.constants.all? { |c| c.kind_of?(MIDIMessage::Constant::Map) }
+        end
+
+      end
+
+    end
+
+    context "Loader" do
+
+      context "DSL" do
+
+        context "#[]" do
+
+          context "note on" do
+
+            setup do
+              @message = MIDIMessage::NoteOn["c3"].new(0, 100)
+            end
+
+            should "create message object" do
+              assert_equal(MIDIMessage::NoteOn, @message.class)
+              assert_equal("C3", @message.name)
+              assert_equal("C", @message.note_name)
+              assert_equal("Note On: C3", @message.verbose_name)
+              assert_equal([0x90, 0x30, 100], @message.to_a)
+            end
+
+          end
+
+          context "note off" do
+
+            setup do
+              @message = MIDIMessage::NoteOff["C2"].new(0, 100)
+            end
+
+            should "create message object" do
+              assert_equal(MIDIMessage::NoteOff, @message.class)
+              assert_equal("C2", @message.name)
+              assert_equal("Note Off: C2", @message.verbose_name)
+              assert_equal([0x80, 0x24, 100], @message.to_a)
+            end
+
+          end
+
+          context "cc" do
+
+            setup do
+              @message = MIDIMessage::ControlChange["Modulation Wheel"].new(2, 0x20)
+            end
+
+            should "create message object" do
+              assert_equal(MIDIMessage::ControlChange, @message.class)
+              assert_equal(@message.channel, 2)
+              assert_equal(0x01, @message.index)
+              assert_equal(0x20, @message.value)
+              assert_equal([0xB2, 0x01, 0x20], @message.to_a)
+            end
+
+          end
+
+          context "system realtime" do
+
+            setup do
+              @message = MIDIMessage::SystemRealtime["Stop"].new
+            end
+
+            should "create message object" do
+              assert_equal(MIDIMessage::SystemRealtime, @message.class)
+              assert_equal("Stop", @message.name)
+              assert_equal([0xFC], @message.to_a)
+            end
+
+          end
+
+          context "system common" do
+
+            setup do
+              @message = MIDIMessage::SystemCommon["Song Select"].new
+            end
+
+            should "create message object" do
+              assert_equal(MIDIMessage::SystemCommon, @message.class)
+              assert_equal("Song Select", @message.name)
+              assert_equal([0xF3], @message.to_a)
+            end
+
+          end
+
+        end
+
+      end
+
+    end
+
+  end
+
+end

data/test/context_test.rb

@@ -2,81 +2,132 @@ require "helper"
 
 class ContextTest < Minitest::Test
 
-  def test_note_off
-    msg = MIDIMessage.with(:channel => 0, :velocity => 64) do
-      note_off(55)
+  context "Context" do
+
+    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
-    assert_equal(0, msg.channel)
-    assert_equal(55, msg.note)
-    assert_equal(64, msg.velocity)
-    assert_equal([128, 55, 64], msg.to_a)
-    assert_equal("803740", msg.to_bytestr)
-  end
 
-  def test_note_on
-    msg = MIDIMessage.with(:channel => 0, :velocity => 64) do
-      note_on(55)
+    context "note on" do
+
+      setup do
+        @message = MIDIMessage.with(:channel => 0, :velocity => 64) do
+          note_on(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([144, 55, 64], @message.to_a)
+        assert_equal("903740", @message.to_bytestr)
+      end
+
     end
-    assert_equal(0, msg.channel)
-    assert_equal(55, msg.note)
-    assert_equal(64, msg.velocity)
-    assert_equal([144, 55, 64], msg.to_a)
-    assert_equal("903740", msg.to_bytestr)
-  end
 
-  def test_control_change
-    msg = MIDIMessage.with(:channel => 2) do
-      control_change(0x20, 0x30)
+    context "cc" do
+
+      setup do
+        @message = MIDIMessage.with(:channel => 2) do
+          control_change(0x20, 0x30)
+        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
-    assert_equal(msg.channel, 2)
-    assert_equal(0x20, msg.index)
-    assert_equal(0x30, msg.value)
-    assert_equal([0xB2, 0x20, 0x30], msg.to_a)
-    assert_equal("B22030", msg.to_bytestr)
 
-  end
+    context "polyphonic aftertouch" do
+
+      setup do
+        @message = MIDIMessage.with(:channel => 1) do
+          polyphonic_aftertouch(0x40, 0x40)
+        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
 
-  def test_polyphonic_aftertouch
-    msg = MIDIMessage.with(:channel => 1) do
-      polyphonic_aftertouch(0x40, 0x40)
     end
-    assert_equal(1, msg.channel)
-    assert_equal(0x40, msg.note)
-    assert_equal(0x40, msg.value)
-    assert_equal([0xA1, 0x40, 0x40], msg.to_a)
-    assert_equal("A14040", msg.to_bytestr)
-  end
 
-  def test_program_change
-    msg = MIDIMessage.with(:channel => 3) do
-      program_change(0x40)
+    context "program change" do
+
+      setup do
+        @message = MIDIMessage.with(:channel => 3) do
+          program_change(0x40)
+        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
-    assert_equal(3, msg.channel)
-    assert_equal(0x40, msg.program)
-    assert_equal([0xC3, 0x40], msg.to_a)
-    assert_equal("C340", msg.to_bytestr)
 
-  end
+    context "channel aftertouch" do
+
+      setup do
+        @message = MIDIMessage.with(:channel => 3) do
+          channel_aftertouch(0x50)
+        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
 
-  def test_channel_aftertouch
-    msg = MIDIMessage.with(:channel => 3) do
-      channel_aftertouch(0x50)
     end
-    assert_equal(3, msg.channel)
-    assert_equal(0x50, msg.value)
-    assert_equal([0xD3, 0x50], msg.to_a)
-    assert_equal("D350", msg.to_bytestr)
-  end
 
-  def test_pitch_bend
-    msg = MIDIMessage.with(:channel => 0) do
-      pitch_bend(0x50, 0xA0)
+    context "pitch bend" do
+
+      setup do
+        @message = MIDIMessage.with(:channel => 0) do
+          pitch_bend(0x50, 0xA0)
+        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
-    assert_equal(0, msg.channel)
-    assert_equal(0x50, msg.low)
-    assert_equal(0xA0, msg.high)
-    assert_equal([0xE0, 0x50, 0xA0], msg.to_a)
-    assert_equal("E050A0", msg.to_bytestr)
+
   end
 
 end

data/test/helper.rb

@@ -1,6 +1,7 @@
-dir = File.dirname(File.expand_path(__FILE__))
-$LOAD_PATH.unshift dir + "/../lib"
+$:.unshift(File.join("..", "lib"))
 
 require "minitest/autorun"
+require "mocha/test_unit"
+require "shoulda-context"
 
 require "midi-message"

data/test/message_test.rb

@@ -4,6 +4,8 @@ class ShortMessageTest < Minitest::Test
 
   def test_channel_message
     message = MIDIMessage::ChannelMessage.new(0x9, 0x0, 0x40, 0x40)
+    refute_nil message
+    assert message.kind_of?(MIDIMessage)
     assert_equal(0x9, message.status[0])
     assert_equal(0x0, message.status[1])
     assert_equal(0x40, message.data[0])

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: midi-message
 version: !ruby/object:Gem::Version
-  version: 0.4.7
+  version: 0.4.8
 platform: ruby
 authors:
 - Ari Russo
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-04-12 00:00:00.000000000 Z
+date: 2015-05-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: minitest
@@ -111,7 +111,7 @@ files:
 - lib/midi-message/system_message.rb
 - lib/midi-message/type_conversion.rb
 - lib/midi.yml
-- test/constants_test.rb
+- test/constant_test.rb
 - test/context_test.rb
 - test/helper.rb
 - test/message_test.rb

data/test/constants_test.rb

@@ -1,45 +0,0 @@
-require "helper"
-
-class ConstantsTest < Minitest::Test
-
-  def test_note_on
-    msg = MIDIMessage::NoteOn["c3"].new(0, 100)
-    assert_equal(MIDIMessage::NoteOn, msg.class)
-    assert_equal("C3", msg.name)
-    assert_equal("C", msg.note_name)
-    assert_equal("Note On: C3", msg.verbose_name)
-    assert_equal([0x90, 0x30, 100], msg.to_a)
-  end
-
-  def test_note_off
-    msg = MIDIMessage::NoteOff["C2"].new(0, 100)
-    assert_equal(MIDIMessage::NoteOff, msg.class)
-    assert_equal("C2", msg.name)
-    assert_equal("Note Off: C2", msg.verbose_name)
-    assert_equal([0x80, 0x24, 100], msg.to_a)
-  end
-
-  def test_control_change
-    msg = MIDIMessage::ControlChange["Modulation Wheel"].new(2, 0x20)
-    assert_equal(MIDIMessage::ControlChange, msg.class)
-    assert_equal(msg.channel, 2)
-    assert_equal(0x01, msg.index)
-    assert_equal(0x20, msg.value)
-    assert_equal([0xB2, 0x01, 0x20], msg.to_a)
-  end
-
-  def test_system_realtime
-    msg = MIDIMessage::SystemRealtime["Stop"].new
-    assert_equal(MIDIMessage::SystemRealtime, msg.class)
-    assert_equal("Stop", msg.name)
-    assert_equal([0xFC], msg.to_a)
-  end
-
-  def test_system_common
-    msg = MIDIMessage::SystemCommon["Song Select"].new
-    assert_equal(MIDIMessage::SystemCommon, msg.class)
-    assert_equal("Song Select", msg.name)
-    assert_equal([0xF3], msg.to_a)
-  end
-
-end