midi-nibbler 0.2.3 → 0.2.4

data/lib/nibbler/session.rb

@@ -1,5 +1,5 @@
 module Nibbler
- 
+
   # A parser session
   #
   # Holds on to data that is not relevant to the parser between calls. For instance,
@@ -12,26 +12,28 @@ module Nibbler
     attr_reader :messages,
                 :processed,
                 :rejected
-    
-    def_delegators :@parser, :buffer            
+
+    def_delegators :@parser, :buffer
     def_delegator :clear_buffer, :buffer, :clear
     def_delegator :clear_processed, :processed, :clear
     def_delegator :clear_rejected, :rejected, :clear
     def_delegator :clear_messages, :messages, :clear
 
     # @param [Hash] options
+    # @option options [Symbol] :message_lib The name of a message library module eg MIDIMessage or Midilib
     # @option options [Boolean] :timestamps Whether to report timestamps
     def initialize(options = {})
       @timestamps = options[:timestamps] || false
       @callbacks, @processed, @rejected, @messages = [], [], [], []
-      @parser = Parser.new(options)    
+      @library = MessageLibrary.adapter(options[:message_lib])
+      @parser = Parser.new(@library)
     end
-    
+
     # @return [Array<Object>]
     def all_messages
       @messages | @fragmented_messages
     end
-    
+
     # The buffer as a single hex string
     # @return [String]
     def buffer_s
@@ -48,13 +50,13 @@ module Nibbler
     def clear_messages
       @messages.clear
     end
-    
+
     # Convert messages to hashes with timestamps
     def use_timestamps
       if !@timestamps
         @messages = @messages.map do |message|
-          { 
-            :messages => message, 
+          {
+            :messages => message,
             :timestamp => nil
           }
         end
@@ -71,19 +73,19 @@ module Nibbler
       options = args.last.kind_of?(Hash) ? args.pop : {}
       timestamp = options[:timestamp]
 
-      use_timestamps if !timestamp.nil? 
+      use_timestamps if !timestamp.nil?
 
       result = process(args)
-      log(result, timestamp)  
-    end    
-    
+      log(result, timestamp)
+    end
+
     private
 
     # Process the input
     # @param [Array<Object>] input
     # @return [Hash]
     def process(input)
-      queue = HexProcessor.process(input)
+      queue = DataProcessor.process(input)
       @parser.process(queue)
     end
 
@@ -96,16 +98,16 @@ module Nibbler
       @rejected += parser_report[:rejected]
       get_output(num)
     end
-        
+
     # @param [Array<Object>] messages The MIDI messages to log
-    # @return [Fixnum] The number of MIDI messages logged
+    # @return [Integer] The number of MIDI messages logged
     def log_message(messages, options = {})
       if @timestamps
         messages_for_log = messages.count == 1 ? messages.first : messages
-        @messages << { 
-          :messages => messages_for_log, 
-          :timestamp => options[:timestamp] 
-        }     
+        @messages << {
+          :messages => messages_for_log,
+          :timestamp => options[:timestamp]
+        }
       else
         @messages += messages
       end
@@ -122,13 +124,13 @@ module Nibbler
     # 1 message: the message
     # >1 message: an array of messages
     #
-    # @param [Fixnum] num The number of new messages to report
-    # @return [Array<Object>, Hash] 
+    # @param [Integer] num The number of new messages to report
+    # @return [Array<Object>, Hash]
     def get_output(num)
       messages = @messages.last(num)
-      messages.count < 2 ? messages.first : messages 
+      messages.count < 2 ? messages.first : messages
     end
-    
+
   end
-  
+
 end

data/lib/nibbler/type_conversion.rb

@@ -1,40 +1,76 @@
 module Nibbler
- 
+
   # A helper for converting between different types of nibbles and bytes
   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<Fixnum>]
+    # @return [Array<Integer>]
     def hex_chars_to_numeric_bytes(nibbles)
       nibbles = nibbles.dup
       # get rid of last nibble if there's an odd number
       # it will be processed later anyway
       nibbles.slice!(nibbles.length-2, 1) if nibbles.length.odd?
       bytes = []
-      while !(nibs = nibbles.slice!(0,2)).empty?
+      until (nibs = nibbles.slice!(0,2)).empty?
         byte = (nibs[0].hex << 4) + nibs[1].hex
         bytes << byte
       end
       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>]
     def hex_str_to_hex_chars(string)
-      string.split(//)    
+      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>]
+    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>]
+    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 [String] string
+    # @return [Array<String>]
+    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
-    # @param [Fixnum] num
+
+    # Converts a numeric byte to an array of hex nibble strings eg 0x90 => ["9", "0"]
+    # @param [Integer] num
     # @return [Array<String>]
     def numeric_byte_to_hex_chars(num)
-      [((num & 0xF0) >> 4), (num & 0x0F)].map { |n| n.to_s(16) }      
+      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>]
+    def numeric_byte_to_numeric_nibbles(num)
+      [((num & 0xF0) >> 4), (num & 0x0F)]
     end
 
   end
-  
+
 end

data/test/data_processor_test.rb

@@ -0,0 +1,146 @@
+require "helper"
+
+class Nibbler::DataProcessorTest < Minitest::Test
+
+  context "DataProcessor" do
+
+    setup do
+      @processor = Nibbler::DataProcessor
+    end
+
+    context "#process" do
+
+      context "string" do
+
+        setup do
+          @str = "904050"
+          @nibbles = @processor.send(:process, @str)
+        end
+
+        should "not alter input" do
+          assert_equal("904050", @str)
+        end
+
+        should "return correct nibbles" do
+          assert_equal(["9", "0", "4", "0", "5", "0"], @nibbles)
+        end
+
+      end
+
+      context "numeric" do
+
+        setup do
+          @num = 0x90
+          @nibbles = @processor.send(:process, @num)
+        end
+
+        should "not alter input" do
+          assert_equal(0x90, @num)
+        end
+
+        should "return correct nibbles" do
+          assert_equal(["9", "0"], @nibbles)
+        end
+
+      end
+
+      context "mixed types" do
+
+        setup do
+          @array = [0x90, "90", "9"]
+        end
+
+        context "normal" do
+
+          setup do
+            @nibbles = @processor.send(:process, @array)
+          end
+
+          should "not alter input" do
+            assert_equal([0x90, "90", "9"], @array)
+          end
+
+          should "return correct nibbles" do
+            assert_equal(["9", "0", "9", "0", "9"], @nibbles)
+          end
+
+        end
+
+        context "splatted" do
+
+          setup do
+            @nibbles = @processor.send(:process, *@array)
+          end
+
+          should "not alter input" do
+            assert_equal([0x90, "90", "9"], @array)
+          end
+
+          should "return correct nibbles" do
+            assert_equal(["9", "0", "9", "0", "9"], @nibbles)
+          end
+
+        end
+
+      end
+
+    end
+
+    context "#filter_numeric" do
+
+      context "filtered" do
+
+        setup do
+          @num = 560
+          @result = @processor.send(:filter_numeric, @num)
+        end
+
+        should "not alter input" do
+          assert_equal(560, @num)
+        end
+
+        should "return nil" do
+          assert_nil @result
+        end
+
+      end
+
+      context "passing" do
+
+        setup do
+          @num = 50
+          @result = @processor.send(:filter_numeric, @num)
+        end
+
+        should "not alter input" do
+          assert_equal(50, @num)
+        end
+
+        should "return number" do
+          assert_equal(50, @result)
+        end
+
+      end
+
+    end
+
+    context "#filter_string" do
+
+      setup do
+        @input = "(0xAdjskla#(#"
+        @result = @processor.send(:filter_string, @input)
+      end
+
+      should "not alter input" do
+        assert_equal("(0xAdjskla#(#", @input)
+      end
+
+      should "return valid chars" do
+        assert_equal("0ADA", @result)
+      end
+
+    end
+
+  end
+
+end

data/test/functional_buffer_test.rb

@@ -0,0 +1,64 @@
+require "helper"
+
+class Nibbler::FunctionalBufferTest < Minitest::Test
+
+  context "Parser::Buffer" do
+
+    setup do
+      @nibbler = Nibbler.new
+    end
+
+    should "have processed string nibble" do
+      @nibbler.parse("9")
+      assert_equal(["9"], @nibbler.buffer)
+    end
+
+    should "have processed numeric byte" do
+      @nibbler.parse(0x90)
+      assert_equal(["9", "0"], @nibbler.buffer)
+    end
+
+    should "have processed string byte" do
+      @nibbler.parse("90")
+      assert_equal(["9", "0"], @nibbler.buffer)
+    end
+
+    should "have processed array" do
+      @nibbler.parse([0x90])
+      assert_equal(["9", "0"], @nibbler.buffer)
+    end
+
+    should "have processed numeric bytes" do
+      @nibbler.parse(0x90, 0x40)
+      assert_equal(["9", "0", "4", "0"], @nibbler.buffer)
+    end
+
+    should "have processed string bytes" do
+      @nibbler.parse("90", "40")
+      assert_equal(["9", "0", "4", "0"], @nibbler.buffer)
+    end
+
+    should "have processed two-byte string" do
+      @nibbler.parse("9040")
+      assert_equal(["9", "0", "4", "0"], @nibbler.buffer)
+    end
+
+    should "have processed mixed bytes" do
+      @nibbler.parse("90", 0x40)
+      assert_equal(["9", "0", "4", "0"], @nibbler.buffer)
+    end
+
+    should "have processed mixed nibble and byte" do
+      @nibbler.parse("9", 0x40)
+      assert_equal(["9", "4", "0"], @nibbler.buffer)
+    end
+
+    should "have processed separate data" do
+      @nibbler.parse("9")
+      @nibbler.parse(0x40)
+      assert_equal(["9", "4", "0"], @nibbler.buffer)
+    end
+
+  end
+
+end

data/test/functional_rejected_test.rb

@@ -0,0 +1,154 @@
+require "helper"
+
+class Nibbler::FunctionalRejectedTest < Minitest::Test
+
+  context "Rejected" do
+
+    setup do
+      @nibbler = Nibbler.new
+    end
+
+    context "leading chars" do
+
+      setup do
+        @message = @nibbler.parse("0", "9", "04", "040")
+      end
+
+      should "return correct message" do
+        assert_equal(::MIDIMessage::NoteOn, @message.class)
+      end
+
+      should "reject extra char" do
+        refute_empty @nibbler.rejected
+        assert_equal("0", @nibbler.rejected.first)
+      end
+
+    end
+
+    context "2 leading chars" do
+
+      setup do
+        @message = @nibbler.parse("1", "0", "9", "04", "040")
+      end
+
+      should "reject two leading chars" do
+        refute_empty @nibbler.rejected
+        assert_equal "1", @nibbler.rejected[0]
+        assert_equal "0", @nibbler.rejected[1]
+      end
+
+    end
+
+    context "leading string" do
+
+      setup do
+        @message = @nibbler.parse("10", "9", "04", "040")
+      end
+
+      should "return correct message" do
+        assert_equal(::MIDIMessage::NoteOn, @message.class)
+      end
+
+      should "reject chars in leading string" do
+        refute_empty @nibbler.rejected
+        assert_equal "1", @nibbler.rejected[0]
+        assert_equal "0", @nibbler.rejected[1]
+      end
+
+    end
+
+    context "long leading string" do
+
+      setup do
+        @message = @nibbler.parse("000001000010", "9", "04", "040")
+      end
+
+      should "return correct message" do
+        assert_equal(::MIDIMessage::NoteOn, @message.class)
+      end
+
+      should "return string" do
+        refute_empty @nibbler.rejected
+        assert_equal("000001000010".split(//), @nibbler.rejected)
+      end
+
+    end
+
+    context "long leading string overlap" do
+
+      setup do
+        @message = @nibbler.parse("000001000010090", "4", "040")
+      end
+
+      should "return correct message" do
+        assert_equal(::MIDIMessage::NoteOn, @message.class)
+      end
+
+      should "return leading string" do
+        refute_empty @nibbler.rejected
+        assert_equal("0000010000100".split(//), @nibbler.rejected)
+      end
+
+    end
+
+    context "leading number" do
+
+      setup do
+        @message = @nibbler.parse(0x30, "9", "04", "040")
+      end
+
+      should "return correct message" do
+        assert_equal(::MIDIMessage::NoteOn, @message.class)
+      end
+
+      should "return leading numbers" do
+        refute_empty @nibbler.rejected
+        assert_equal "3", @nibbler.rejected[0]
+        assert_equal "0", @nibbler.rejected[1]
+      end
+
+    end
+
+    context "2 leading numbers" do
+
+      setup do
+        @message = @nibbler.parse(0x60, 0x30, "9", "04", "040")
+      end
+
+      should "return correct message" do
+        assert_equal(::MIDIMessage::NoteOn, @message.class)
+      end
+
+      should "return leading numbers" do
+        refute_empty @nibbler.rejected
+        assert_equal "6", @nibbler.rejected[0]
+        assert_equal "0", @nibbler.rejected[1]
+        assert_equal "3", @nibbler.rejected[2]
+        assert_equal "0", @nibbler.rejected[3]
+      end
+
+    end
+
+    context "3 leading numbers" do
+
+      setup do
+        @message = @nibbler.parse(0x00, 0x30, "9", "04", "040")
+      end
+
+      should "return correct message" do
+        assert_equal(::MIDIMessage::NoteOn, @message.class)
+      end
+
+      should "return leading numbers" do
+        refute_empty @nibbler.rejected
+        assert_equal "0", @nibbler.rejected[0]
+        assert_equal "0", @nibbler.rejected[1]
+        assert_equal "3", @nibbler.rejected[2]
+        assert_equal "0", @nibbler.rejected[3]
+      end
+
+    end
+
+  end
+
+end