midi-nibbler 0.2.3 → 0.2.4

data/test/type_conversion_test.rb

@@ -2,28 +2,127 @@ require "helper"
 
 class Nibbler::TypeConversionTest < Minitest::Test
 
-  def test_hex_chars_to_numeric_bytes
-    nibbles = ["4", "5", "9", "3"]
-    bytes = Nibbler::TypeConversion.hex_chars_to_numeric_bytes(nibbles)
+  context "TypeConversion" do
 
-    assert_equal(["4", "5", "9", "3"], nibbles)
-    assert_equal([0x45, 0x93], bytes)
-  end
+    context ".hex_chars_to_numeric_bytes" do
 
-  def test_hex_str_to_hex_chars
-    str = "904050"
-    nibbles = Nibbler::TypeConversion.send(:hex_str_to_hex_chars, str)
+      setup do
+        @nibbles = ["4", "5", "9", "3"]
+        @bytes = Nibbler::TypeConversion.hex_chars_to_numeric_bytes(@nibbles)
+      end
 
-    assert_equal("904050", str)
-    assert_equal(["9", "0", "4", "0", "5", "0"], nibbles)
-  end
+      should "not have side effects" do
+        assert_equal(["4", "5", "9", "3"], @nibbles)
+      end
+
+      should "return correct bytes" do
+        assert_equal([0x45, 0x93], @bytes)
+      end
+
+    end
+
+    context ".hex_str_to_hex_chars" do
+
+      setup do
+        @str = "904050"
+        @nibbles = Nibbler::TypeConversion.send(:hex_str_to_hex_chars, @str)
+      end
+
+      should "not have side effects" do
+        assert_equal("904050", @str)
+      end
+
+      should "return correct chars" do
+        assert_equal(["9", "0", "4", "0", "5", "0"], @nibbles)
+      end
+
+    end
+
+    context ".hex_str_to_numeric_bytes" do
+
+      setup do
+        @str = "904050"
+        @bytes = Nibbler::TypeConversion.send(:hex_str_to_numeric_bytes, @str)
+      end
+
+      should "not have side effects" do
+        assert_equal("904050", @str)
+      end
+
+      should "return correct bytes" do
+        assert_equal([0x90, 0x40, 0x50], @bytes)
+      end
+
+    end
+
+    context ".numeric_bytes_to_numeric_nibbles" do
+
+      setup do
+        @bytes = [0x90, 0x40, 0x50]
+        @nibbles = Nibbler::TypeConversion.send(:numeric_bytes_to_numeric_nibbles, @bytes)
+      end
+
+      should "not have side effects" do
+        assert_equal([0x90, 0x40, 0x50], @bytes)
+      end
+
+      should "return correct nibbles" do
+        assert_equal([0x9, 0x0, 0x4, 0x0, 0x5, 0x0], @nibbles)
+      end
+
+    end
+
+    context ".hex_str_to_numeric_nibbles" do
+
+      setup do
+        @str = "904050"
+        @nibbles = Nibbler::TypeConversion.send(:hex_str_to_numeric_nibbles, @str)
+      end
+
+      should "not have side effects" do
+        assert_equal("904050", @str)
+      end
+
+      should "return correct nibbles" do
+        assert_equal([0x9, 0x0, 0x4, 0x0, 0x5, 0x0], @nibbles)
+      end
+
+    end
+
+    context ".numeric_byte_to_numeric_nibbles" do
+
+      setup do
+        @num = 0x90
+        @nibbles = Nibbler::TypeConversion.send(:numeric_byte_to_numeric_nibbles, @num)
+      end
+
+      should "not have side effects" do
+        assert_equal(0x90, @num)
+      end
+
+      should "return correct nibbles" do
+        assert_equal([0x9, 0x0], @nibbles)
+      end
+
+    end
+
+    context ".numeric_byte_to_hex_chars" do
+
+      setup do
+        @num = 0x90
+        @nibbles = Nibbler::TypeConversion.send(:numeric_byte_to_hex_chars, @num)
+      end
+
+      should "not have side effects" do
+        assert_equal(0x90, @num)
+      end
+
+      should "return correct chars" do
+        assert_equal(["9", "0"], @nibbles)
+      end
 
-  def test_numeric_byte_to_hex_chars
-    num = 0x90
-    nibbles = Nibbler::TypeConversion.send(:numeric_byte_to_hex_chars, num)
+    end
 
-    assert_equal(0x90, num)
-    assert_equal(["9", "0"], nibbles)
   end
 
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: midi-nibbler
 version: !ruby/object:Gem::Version
-  version: 0.2.3
+  version: 0.2.4
 platform: ruby
 authors:
 - Ari Russo
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-01-31 00:00:00.000000000 Z
+date: 2017-05-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: midilib
@@ -140,24 +140,27 @@ files:
 - LICENSE
 - README.md
 - lib/nibbler.rb
-- lib/nibbler/hex_processor.rb
+- lib/nibbler/data_processor.rb
+- lib/nibbler/message_builder.rb
+- lib/nibbler/message_library.rb
 - lib/nibbler/midi-message.rb
 - lib/nibbler/midilib.rb
 - lib/nibbler/parser.rb
 - lib/nibbler/session.rb
 - lib/nibbler/type_conversion.rb
+- test/data_processor_test.rb
+- test/functional_buffer_test.rb
+- test/functional_rejected_test.rb
 - test/helper.rb
-- test/hex_processor_test.rb
+- test/message_library_test.rb
 - test/midi_message_test.rb
 - test/midilib_test.rb
-- test/parser_buffer_test.rb
-- test/parser_rejected_test.rb
 - test/parser_test.rb
 - test/session_test.rb
 - test/type_conversion_test.rb
 homepage: http://github.com/arirusso/nibbler
 licenses:
-- Apache 2.0
+- Apache-2.0
 metadata: {}
 post_install_message: 
 rdoc_options: []
@@ -175,7 +178,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: 1.3.6
 requirements: []
 rubyforge_project: nibbler
-rubygems_version: 2.2.2
+rubygems_version: 2.6.8
 signing_key: 
 specification_version: 4
 summary: Parse MIDI Messages

data/test/hex_processor_test.rb

@@ -1,56 +0,0 @@
-require "helper"
-
-class Nibbler::HexProcessorTest < Minitest::Test
-
-  def test_to_nibbles_array_mixed
-    processor = Nibbler::HexProcessor
-    array = [0x90, "90", "9"]
-    nibbles = processor.send(:process, array)
-    assert_equal([0x90, "90", "9"], array)
-    assert_equal(["9", "0", "9", "0", "9"], nibbles)
-  end
-
-  def test_to_nibbles_mixed
-    processor = Nibbler::HexProcessor
-    array = [0x90, "90", "9"]
-    nibbles = processor.send(:process, *array)
-    assert_equal([0x90, "90", "9"], array)
-    assert_equal(["9", "0", "9", "0", "9"], nibbles)
-  end
-
-  def test_to_nibbles_numeric
-    processor = Nibbler::HexProcessor
-    num = 0x90
-    nibbles = processor.send(:process, num)
-    assert_equal(0x90, num)
-    assert_equal(["9", "0"], nibbles)
-  end
-
-  def test_to_nibbles_string
-    processor = Nibbler::HexProcessor
-    str = "904050"
-    nibbles = processor.send(:process, str)
-    assert_equal("904050", str)
-    assert_equal(["9", "0", "4", "0", "5", "0"], nibbles)
-  end
-
-  def test_processor_numeric
-    processor = Nibbler::HexProcessor
-    badnum = 560
-    output = processor.send(:filter_numeric, badnum)
-    assert_equal(560, badnum)
-    assert_equal(nil, output)
-    goodnum = 50
-    output = processor.send(:filter_numeric, goodnum)
-    assert_equal(50, goodnum)
-    assert_equal(50, output)
-  end
-
-  def test_processor_string
-    processor = Nibbler::HexProcessor
-    str = "(0xAdjskla#(#"
-    outp = processor.send(:filter_string, str)
-    assert_equal("0ADA", outp)
-  end
-
-end

data/test/parser_buffer_test.rb

@@ -1,66 +0,0 @@
-require "helper"
-
-class Nibbler::BufferTest < Minitest::Test
-
-  def test_buffer_nibble_str
-    nibbler = Nibbler.new
-    nibbler.parse("9")
-    assert_equal(["9"], nibbler.buffer)
-  end
-
-  def test_buffer_single_byte
-    nibbler = Nibbler.new
-    nibbler.parse(0x90)
-    assert_equal(["9", "0"], nibbler.buffer)
-  end
-
-  def test_buffer_single_byte_str
-    nibbler = Nibbler.new
-    nibbler.parse("90")
-    assert_equal(["9", "0"], nibbler.buffer)
-  end
-
-  def test_buffer_single_byte_in_array
-    nibbler = Nibbler.new
-    nibbler.parse([0x90])
-    assert_equal(["9", "0"], nibbler.buffer)
-  end
-
-  def test_buffer_two_bytes
-    nibbler = Nibbler.new
-    nibbler.parse(0x90, 0x40)
-    assert_equal(["9", "0", "4", "0"], nibbler.buffer)
-  end
-
-  def test_buffer_two_bytes_str
-    nibbler = Nibbler.new
-    nibbler.parse("90", "40")
-    assert_equal(["9", "0", "4", "0"], nibbler.buffer)
-  end
-
-  def test_buffer_two_bytes_single_str
-    nibbler = Nibbler.new
-    nibbler.parse("9040")
-    assert_equal(["9", "0", "4", "0"], nibbler.buffer)
-  end
-
-  def test_buffer_two_bytes_mixed
-    nibbler = Nibbler.new
-    nibbler.parse("90", 0x40)
-    assert_equal(["9", "0", "4", "0"], nibbler.buffer)
-  end
-
-  def test_buffer_nibble_and_byte_mixed
-    nibbler = Nibbler.new
-    nibbler.parse("9", 0x40)
-    assert_equal(["9", "4", "0"], nibbler.buffer)
-  end
-
-  def test_buffer_stepped
-    nibbler = Nibbler.new
-    nibbler.parse("9")
-    nibbler.parse(0x40)
-    assert_equal(["9", "4", "0"], nibbler.buffer)
-  end
-
-end

data/test/parser_rejected_test.rb

@@ -1,60 +0,0 @@
-require "helper"
-
-class Nibbler::ParserRejectedTest < Minitest::Test
-
-  def test_leading_chars
-    nibbler = Nibbler.new
-    msg = nibbler.parse("0", "9", "04", "040")
-    assert_equal(::MIDIMessage::NoteOn, msg.class)
-    assert_equal(["0"], nibbler.rejected)
-  end
-
-  def test_2_leading_chars
-    nibbler = Nibbler.new
-    msg = nibbler.parse("1", "0", "9", "04", "040")
-    assert_equal(["1", "0"], nibbler.rejected)
-  end
-
-  def test_leading_string
-    nibbler = Nibbler.new
-    msg = nibbler.parse("10", "9", "04", "040")
-    assert_equal(::MIDIMessage::NoteOn, msg.class)
-    assert_equal(["1", "0"], nibbler.rejected)
-  end
-
-  def test_long_leading_string
-    nibbler = Nibbler.new
-    msg = nibbler.parse("000001000010", "9", "04", "040")
-    assert_equal(::MIDIMessage::NoteOn, msg.class)
-    assert_equal("000001000010".split(//), nibbler.rejected)
-  end
-
-  def test_long_leading_string_overlap
-    nibbler = Nibbler.new
-    msg = nibbler.parse("000001000010090", "4", "040")
-    assert_equal(::MIDIMessage::NoteOn, msg.class)
-    assert_equal("0000010000100".split(//), nibbler.rejected)
-  end
-
-  def test_leading_number
-    nibbler = Nibbler.new
-    msg = nibbler.parse(0x30, "9", "04", "040")
-    assert_equal(::MIDIMessage::NoteOn, msg.class)
-    assert_equal(["3", "0"], nibbler.rejected)
-  end
-
-  def test_2_leading_numbers
-    nibbler = Nibbler.new
-    msg = nibbler.parse(0x60, 0x30, "9", "04", "040")
-    assert_equal(::MIDIMessage::NoteOn, msg.class)
-    assert_equal(["6", "0", "3", "0"], nibbler.rejected)
-  end
-
-  def test_3_leading_numbers
-    nibbler = Nibbler.new
-    msg = nibbler.parse(0x00, 0x30, "9", "04", "040")
-    assert_equal(::MIDIMessage::NoteOn, msg.class)
-    assert_equal(["0", "0", "3", "0"], nibbler.rejected)
-  end
-
-end