micromidi 0.1.2 → 0.1.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: aebc5e4f8bffb84656b7b662122cdae4c136c8e3
-  data.tar.gz: 9b6a8f43960f1a94785cbd4d5dfe1b7754bb7b5f
+  metadata.gz: f2f1df337f1568e1e5b327664ee14734eae8095a
+  data.tar.gz: 45fa44750f71f646414883b7103ccadf9162c7d6
 SHA512:
-  metadata.gz: be3f0f5d0872e7db2f60b30495df785c099aa56ecb890ff677ba0cdf53ad6ff99aea9a55492756d7f3a9d6d40922f3eb6b0baf8bb50120925a4ad9656b497ba0
-  data.tar.gz: 950635b62998a768e13614efb3c02e472b0da4439ed27ba3c8a576999b376f3f92e075db07a9abd9dac3206032a94b913168122752a29625499aa3b0848fcdb0
+  metadata.gz: 9afb9c4ef330f7cb29b9baf02d37371055487f27f6833f46d99dc46c81161fe0dba982f27572f00422b8dfa20566d6901fbd34069df83ac65399c9e9e38e3a8d
+  data.tar.gz: fa2eb27bdb3162c12a8fac1f6ba72edba97e5e1e6891a43df5c7ca20afe8f006b64ebb41239e544d15bc6495c5fafb9f0e896060b6ab7015c3ebfdc206899e25

data/lib/micromidi.rb

@@ -1,5 +1,5 @@
 #
-# micromidi
+# MicroMIDI
 #
 # A Ruby DSL for MIDI
 #
@@ -14,46 +14,9 @@ require "midi-fx"
 require "midi-message"
 require "unimidi"
 
-module MicroMIDI
-  
-  VERSION = "0.1.2"
-  
-  module Instructions
-  end
-  
-  def self.new(*a, &block)
-    message(*a, &block)
-  end
-  
-  def self.message(*args, &block)
-    ins, outs = *process_devices(args)
-    MicroMIDI::Context.new(ins, outs, &block)
-  end
-  class << self
-    alias_method :using, :message
-  end
-  
-  module IO
-    
-    def self.new(*args, &block)
-      MicroMIDI.message(*args, &block)
-    end
-    
-  end
-  
-  private
-  
-  def self.process_devices(args)
-    ins = args.find_all { |d| d.respond_to?(:type) && d.type == :input && d.respond_to?(:gets) }
-    outs = args.find_all { |d| d.respond_to?(:puts) }
-    [ins, outs]    
-  end  
-  
-end
-MIDI = MicroMIDI
-
 # modules
 require "micromidi/instructions/composite"
+require "micromidi/module_methods"
 
 # classes
 require "micromidi/context"
@@ -67,3 +30,11 @@ require "micromidi/instructions/sysex"
 
 # extension
 require "micromidi/instructions/shorthand"
+
+module MicroMIDI
+  
+  VERSION = "0.1.3"
+
+end
+MIDI = MicroMIDI
+

data/lib/micromidi/context.rb

@@ -25,37 +25,50 @@ module MicroMIDI
       edit(&block) unless block.nil?
     end
     
-    # open a block for editing/live coding in this Context
+    # Open a block for editing/live coding in this Context
     def edit(&block)
-      self.instance_eval(&block)
+      instance_eval(&block)
     end
     
+    # Repeat the last instruction in the history
     def repeat
-      self.send(@state.last_command[:method], *@state.last_command[:args]) unless @state.last_command.nil?
+      send(@state.last_command[:method], *@state.last_command[:args]) unless @state.last_command.nil?
     end
     
-    def method_missing(m, *a, &b)
-      delegated = false
-      outp = nil
-      options = a.last.kind_of?(Hash) ? a.last : {}
-      do_output = options[:output] || true
-      [@instructions[:sysex], @instructions[:message], @instructions[:process]].each do |dsl|
-        if dsl.respond_to?(m)
-          msg = dsl.send(m, *a, &b)
-          outp = @state.auto_output && do_output ? @instructions[:output].output(msg) : msg
-          delegated = true
+    # Delegates a command to one of the instruction classes
+    def method_missing(method, *args, &block)
+      results = delegate(method, args, &block)
+      if results.empty?
+        super
+      else
+        messages = results.map do |result|
+          @state.record(method, args, block, result[:message])
+          @instructions[:output].output(result[:message]) if output?(result[:instruction_type])
+          result[:message]
         end
+        messages.compact.first
       end
-      unless delegated
-        [@instructions[:input], @instructions[:output], @instructions[:sticky]].each do |dsl| 
-          if dsl.respond_to?(m)
-            outp = dsl.send(m, *a, &b)
-            delegated = true
-          end
+    end
+
+    private
+
+    # Should a message that resulted from the given instruction type be outputted?
+    def output?(instruction_type)
+      @state.auto_output && [:sysex, :message, :process].include?(instruction_type)
+    end
+
+    # Delegate a command 
+    def delegate(method, args, &block)
+      results = @instructions.map do |key, instruction|
+        if instruction.respond_to?(method)
+          message = instruction.send(method, *args, &block)
+          {
+            :instruction_type => key,
+            :message => message
+          }
         end
       end
-      @state.record(m, a, b, outp)
-      delegated ? outp : super
+      results.compact
     end
         
   end

data/lib/micromidi/instructions/composite.rb

@@ -5,31 +5,24 @@ module MicroMIDI
     module Composite
       
       #
-      # plays a note or notes, for a certain duration.
+      # Plays a note or notes, for a certain duration.
       #
-      # the first argument must be a note name (String), MIDIMessage::NoteOn object, or array of either
+      # The first argument must be a note name (String), MIDIMessage::NoteOn object, or array of either
       # the last argument must be a Numeric (representing the duration)
       #
-      # additional arguments should be note names or MIDIMessage::NoteOn objects and will 
-      # be played as a chord with the first argument
+      # Additional arguments should be note names or MIDIMessage::NoteOn objects and will 
+      # be played as a chord with the first argument.
       #
       def play(*args)
-        raise "last argument must be a Numeric duration" unless args.last.kind_of?(Numeric)
+        raise "Last argument must be a Numeric duration" unless args.last.kind_of?(Numeric)
         
         duration = args.pop
         note_or_notes = [args].flatten
-        
-        msgs = note_or_notes.map do |n|
-          case n
-            when Numeric, String then note(n)
-            when MIDIMessage then n 
-          end
-        end
-        
+        messages = as_note_messages(note_or_notes)
         sleep(duration)
-        msgs.each { |msg| note_off(msg.note, :channel => msg.channel, :velocity => msg.velocity) }
+        send_note_offs(messages)
         
-        msgs.size > 1 ? msgs : msgs.first
+        messages.count > 1 ? messages : messages.first
       end
       
       # sends a note off message for every note on every channel
@@ -42,6 +35,23 @@ module MicroMIDI
         true
       end
       alias_method :quiet!, :all_off
+
+      private
+
+      def send_note_offs(messages)
+        messages.each do |message| 
+          note_off(message.note, :channel => message.channel, :velocity => message.velocity)
+        end
+      end
+
+      def as_note_messages(note_or_notes)
+        note_or_notes.map do |note|
+          case note
+            when Numeric, String then note(note)
+            when MIDIMessage then note 
+          end
+        end
+      end
       
     end
 

data/lib/micromidi/instructions/input.rb

@@ -3,18 +3,21 @@ module MicroMIDI
   module Instructions
     
     class Input
-
-      include MIDIMessage
-      
+   
       def initialize(state)
         @state = state
       end
 
       # bind an event that will be called every time a message is received
-      def receive(*a, &block)
-        options = a.last.kind_of?(Hash) ? a.pop : {}
-        match = a.empty? ? nil : { :class => msg_classes(a) }
-        listener(match, options) { |event| yield(event[:message], event[:timestamp]) }
+      def receive(*args, &block)
+        message_options = args.dup
+        options = message_options.last.kind_of?(Hash) ? message_options.pop : {}
+        unless message_options.empty?
+          match = { :class => message_classes(message_options) }
+        end
+        listener(match, options) do |event| 
+          yield(event[:message], event[:timestamp])
+        end
       end
       alias_method :gets, :receive
       alias_method :handle, :receive
@@ -22,10 +25,13 @@ module MicroMIDI
       alias_method :listen_for, :receive
       alias_method :when_receive, :receive
 
-      def receive_unless(*a, &block)
-        options = a.last.kind_of?(Hash) ? a.pop : {}
-        match = { :class => msg_classes(a) }
-        listener(nil, options) { |event| yield(event[:message], event[:timestamp]) unless match.include?(event[:message].class) }
+      def receive_unless(*args, &block)
+        message_options = args.dup
+        options = message_options.last.kind_of?(Hash) ? message_options.pop : {}
+        match = message_classes(message_options)
+        listener(nil, options) do |event| 
+          yield(event[:message], event[:timestamp]) unless match.include?(event[:message].class)
+        end
       end
       alias_method :handle_unless, :receive_unless
       alias_method :listen_unless, :receive_unless
@@ -38,22 +44,22 @@ module MicroMIDI
       end
 
       # send input messages thru to the outputs if it has a specific class
-      def thru_if(*a)
-        a.last.kind_of?(Hash) ? a.last[:thru] = true : a.push({ :thru => true })
-        receive(*a) { |message, timestamp| output(message) }
+      def thru_if(*args)
+        receive_options = thru_options(args)
+        receive(*receive_options) { |message, timestamp| output(message) }
       end
 
       # send input messages thru to the outputs unless of a specific class
-      def thru_unless(*a)
-        a.last.kind_of?(Hash) ? a.last[:thru] = true : a.push({ :thru => true })
-        receive_unless(*a) { |message, timestamp| output(message) }
+      def thru_unless(*args)
+        receive_options = thru_options(args)
+        receive_unless(*receive_options) { |message, timestamp| output(message) }
       end
       
       # like <em>thru_unless</em> except a block can be passed that will be called when
       # notes specified as the <em>unless</em> arrive
-      def thru_except(*a, &block)
-        thru_unless(*a)
-        receive(*a, &block)        
+      def thru_except(*args, &block)
+        thru_unless(*args)
+        receive(*args, &block)        
       end
             
       # wait for input on the last input passed in
@@ -69,38 +75,56 @@ module MicroMIDI
 
       protected
 
-      def listener(match = {}, options = {}, &block)
+      def listener(match, options = {}, &block)
         inputs = options[:from] || @state.inputs
-        thru = options[:thru] || false
+        do_thru = options.fetch(:thru, false)
+        should_start = options.fetch(:start, true)
         match ||= {}
-        inputs.each do |input|
-          listener = MIDIEye::Listener.new(input)
-          listener.listen_for(match, &block)
-          if thru
-            @state.thru_listeners.each { |l| l.stop }
-            @state.thru_listeners.clear
-            @state.thru_listeners << listener
-          else 
-            @state.listeners << listener
-          end 
-          listener.start(:background => true) unless !options[:start].nil? && !options[:start]
+
+        listeners = inputs.map { |input| initialize_listener(input, match, do_thru, &block) }
+        if should_start
+          listeners.each { |listener| listener.start(:background => true) }
         end
       end
 
       private
 
-      def msg_classes(list)
+      def initialize_listener(input, match, do_thru, &block)
+        listener = MIDIEye::Listener.new(input)
+        listener.listen_for(match, &block)
+        if do_thru
+          @state.thru_listeners.each(&:stop)
+          @state.thru_listeners.clear
+          @state.thru_listeners << listener
+        else 
+          @state.listeners << listener
+        end 
+        listener
+      end
+
+      # The options for using thru
+      def thru_options(args)
+        receive_options = args.dup
+        if receive_options.last.kind_of?(Hash)
+          receive_options.last[:thru] = true
+        else
+          receive_options << { :thru => true }
+        end
+        receive_options
+      end
+
+      def message_classes(list)
         list.map do |type|
           case type
-          when :aftertouch, :pressure, :aft then [ChannelAftertouch, PolyphonicAftertouch]
-          when :channel_aftertouch, :channel_pressure, :ca, :cp then ChannelAftertouch
-          when :control_change, :cc, :c then ControlChange
-          when :note, :n then [NoteOn, NoteOff]
-          when :note_on, :nn then NoteOn
-          when :note_off, :no, :off then NoteOff
-          when :pitch_bend, :pb then PitchBend
-          when :polyphonic_aftertouch, :poly_aftertouch, :poly_pressure, :polyphonic_pressure, :pa, :pp then PolyphonicAftertouch
-          when :program_change, :pc, :p then ProgramChange
+          when :aftertouch, :pressure, :aft then [MIDIMessage::ChannelAftertouch, MIDIMessage::PolyphonicAftertouch]
+          when :channel_aftertouch, :channel_pressure, :ca, :cp then MIDIMessage::ChannelAftertouch
+          when :control_change, :cc, :c then MIDIMessage::ControlChange
+          when :note, :n then [MIDIMessage::NoteOn, MIDIMessage::NoteOff]
+          when :note_on, :nn then MIDIMessage::NoteOn
+          when :note_off, :no, :off then MIDIMessage::NoteOff
+          when :pitch_bend, :pb then MIDIMessage::PitchBend
+          when :polyphonic_aftertouch, :poly_aftertouch, :poly_pressure, :polyphonic_pressure, :pa, :pp then MIDIMessage::PolyphonicAftertouch
+          when :program_change, :pc, :p then MIDIMessage::ProgramChange
           end
         end.flatten.compact
       end

data/lib/micromidi/instructions/message.rb

@@ -3,41 +3,33 @@ module MicroMIDI
   module Instructions
     
     class Message
-
-      include MIDIMessage
       
       def initialize(state)
         @state = state
       end
       
       # create a control change message
-      def control_change(id, value, opts = {})
-        props = @state.message_properties(opts, :channel)
-        id.kind_of?(Numeric) ? ControlChange.new(props[:channel], id, value) : ControlChange[id].new(props[:channel], value)
+      def control_change(id, value, options = {})
+        properties = @state.message_properties(options, :channel)
+        if id.kind_of?(Numeric)
+          MIDIMessage::ControlChange.new(properties[:channel], id, value)
+        else
+          MIDIMessage::ControlChange[id].new(properties[:channel], value)
+        end
       end
 
       # create a note message
-      def note(id, opts = {})
-        props = @state.message_properties(opts, :channel, :velocity)
-        note = if id.kind_of?(Numeric) 
-          NoteOn.new(props[:channel], id, props[:velocity])
-        elsif id.kind_of?(String) || id.kind_of?(Symbol)
-          note_string = parse_note_name(id)
-          NoteOn[note_string].new(props[:channel], props[:velocity])
-        end
+      def note(id, options = {})
+        properties = @state.message_properties(options, :channel, :velocity)
+        note = note_message(MIDIMessage::NoteOn, id, properties)
         @state.last_note = note
         note
       end
 
       # create a note off message
-      def note_off(id, opts = {})
-        props = @state.message_properties(opts, :channel, :velocity)
-        if id.kind_of?(Numeric) 
-          NoteOff.new(props[:channel], id, props[:velocity])
-        elsif id.kind_of?(String) || id.kind_of?(Symbol)
-          note_string = parse_note_name(id)
-          NoteOff[parse_note_name(id)].new(props[:channel], props[:velocity])
-        end
+      def note_off(id, options = {})
+        properties = @state.message_properties(options, :channel, :velocity)
+        note_message(MIDIMessage::NoteOff, id, properties)
       end
 
       # create a MIDI message from a byte string, array of bytes, or list of bytes
@@ -46,37 +38,37 @@ module MicroMIDI
       end
 
       # create a program change message
-      def program_change(program, opts = {})
-        props = @state.message_properties(opts, :channel)
-        MIDIMessage::ProgramChange.new(props[:channel], program)
+      def program_change(program, options = {})
+        properties = @state.message_properties(options, :channel)
+        MIDIMessage::ProgramChange.new(properties[:channel], program)
       end
 
       # create a note-off message from the last note-on message
       def off
-        o = @state.last_note.to_note_off unless @state.last_note.nil?
+        note_off = @state.last_note.to_note_off unless @state.last_note.nil?
         @state.last_note = nil
-        o
+        note_off
       end
       
       # create a channel pressure message
-      def channel_aftertouch(value, opts = {})
-        props = @state.message_properties(opts, :channel)
-        MIDIMessage::ChannelAftertouch.new(props[:channel], value)
+      def channel_aftertouch(value, options = {})
+        properties = @state.message_properties(options, :channel)
+        MIDIMessage::ChannelAftertouch.new(properties[:channel], value)
       end
       alias_method :channel_pressure, :channel_aftertouch
       
       # create a poly pressure message
-      def polyphonic_aftertouch(note, value, opts = {})
-        props = @state.message_properties(opts, :channel)
-        MIDIMessage::PolyphonicAftertouch.new(props[:channel], note, value)
+      def polyphonic_aftertouch(note, value, options = {})
+        properties = @state.message_properties(options, :channel)
+        MIDIMessage::PolyphonicAftertouch.new(properties[:channel], note, value)
       end
       alias_method :poly_aftertouch, :polyphonic_aftertouch
       alias_method :polyphonic_pressure, :polyphonic_aftertouch
       alias_method :poly_pressure, :polyphonic_aftertouch
       
-      def pitch_bend(low, high, opts = {})
-        props = @state.message_properties(opts, :channel)
-        MIDIMessage::PitchBend.new(props[:channel], low, high)
+      def pitch_bend(low, high, options = {})
+        properties = @state.message_properties(options, :channel)
+        MIDIMessage::PitchBend.new(properties[:channel], low, high)
       end
       alias_method :bend, :pitch_bend
       alias_method :pitchbend, :pitch_bend
@@ -84,11 +76,23 @@ module MicroMIDI
       protected
       
       def parse_note_name(name)
-        name = name.to_s #ensure that name is a string
-        string_opts = { :octave => name.scan(/-?\d\z/).first }
+        name = name.to_s
+        octave = name.scan(/-?\d\z/).first
+        string_options = { :octave => octave }
         note = name.split(/-?\d\z/).first
-        string_props = @state.message_properties(string_opts, :octave)
-        "#{note}#{string_props[:octave].to_s}"
+        string_properties = @state.message_properties(string_options, :octave)
+        "#{note}#{string_properties[:octave].to_s}"
+      end
+
+      private
+
+      def note_message(klass, id, properties)
+        if id.kind_of?(Numeric) 
+          klass.new(properties[:channel], id, properties[:velocity])
+        elsif id.kind_of?(String) || id.kind_of?(Symbol)
+          note_name = parse_note_name(id)
+          klass[note_name].new(properties[:channel], properties[:velocity])
+        end
       end
 
     end

data/lib/micromidi/instructions/output.rb

@@ -4,19 +4,32 @@ module MicroMIDI
     
     class Output
       
+      extend Forwardable
+
+      def_delegators :@state, :toggle_auto_output
+      alias_method :auto_output, :toggle_auto_output
+
+      # @param [State] state
       def initialize(state)
         @state = state
       end
 
-      def output(msg)
-        auto_output(msg) if msg === false || msg === true
-        @state.outputs.each { |o| o.puts(msg) } unless msg.nil?
-        msg
+      # Output a message or toggle the auto output mode
+      # @param [MIDIMessage, Boolean] message A MIDI message to output, or a boolean to toggle auto-output mode
+      # @return [BIDIMessage]
+      def output(message)
+        set_auto_output(message) if !!message === message # check for boolean
+        unless message.nil?
+          @state.outputs.each { |output| output.puts(message) }
+        end
+        message
       end
       
-      # toggle mode where messages are automatically outputted
-      def auto_output(mode = nil)
-        mode.nil? ? @state.toggle_auto_output : @state.auto_output = mode
+      # Set mode where messages are automatically outputted
+      # @param [Boolean] is_on Whether to set the auto output mode to ON
+      # @return [Boolean]
+      def set_auto_output(is_on)
+        @state.auto_output = is_on
       end
 
     end

data/lib/micromidi/instructions/shorthand.rb

@@ -2,8 +2,8 @@ module MicroMIDI
   
   alias l loop
  
-  class << self
-    alias_method :m, :message
+  def self.m(*args, &block)
+    send(:message, *args, &block)
   end
   
   class Context

data/lib/micromidi/module_methods.rb

@@ -0,0 +1,34 @@
+module MicroMIDI
+
+  def self.new(*args, &block)
+    message(*args, &block)
+  end
+
+  def self.message(*args, &block)
+    inputs = get_inputs(args)
+    outputs = get_outputs(args)
+    MicroMIDI::Context.new(inputs, outputs, &block)
+  end
+  class << self
+    alias_method :using, :message
+  end
+
+  module IO
+
+    def self.new(*args, &block)
+      MicroMIDI.message(*args, &block)
+    end
+
+  end
+
+  private
+
+  def self.get_inputs(args)
+    args.find_all { |device| device.respond_to?(:type) && device.type == :input && device.respond_to?(:gets) }
+  end
+
+  def self.get_outputs(args)
+    args.find_all { |device| device.respond_to?(:puts) }  
+  end
+
+end

data/lib/micromidi/state.rb

@@ -2,7 +2,7 @@ module MicroMIDI
 
   class State
     
-    Default = {
+    DEFAULT = {
       :channel => 0,
       :octave => 2,
       :velocity => 100
@@ -24,7 +24,14 @@ module MicroMIDI
                 :start_time,
                 :thru_listeners
         
-    def initialize(ins, outs, options = {})
+    def initialize(inputs, outputs, options = {})
+      @inputs = inputs
+      @outputs = outputs 
+
+      @channel = options[:channel] || DEFAULT[:channel]
+      @velocity = options[:velocity] || DEFAULT[:velocity]
+      @octave = options[:octave] || DEFAULT[:octave]  
+
       @auto_output = true
       @last_command = nil
       @last_note = nil    
@@ -33,19 +40,21 @@ module MicroMIDI
       @output_cache = []
       @start_time = Time.now.to_f
       @super_sticky = false
-
-      @channel = options[:channel] || Default[:channel]
-      @velocity = options[:velocity] || Default[:velocity]
-      @octave = options[:octave] || Default[:octave]  
-      
-      @inputs = ins
-      @outputs = outs  
     end
     
-    def record(m, a, b, outp)
-      ts = now
-      @output_cache << { :message => outp, :timestamp => ts }
-      @last_command = { :method => m, :args => a, :block => b, :timestamp => ts }
+    def record(method, args, block, output)
+      timestamp = now
+      message = { 
+        :message => output, 
+        :timestamp => timestamp 
+      }
+      @output_cache << message
+      @last_command = { 
+        :method => method, 
+        :args => args, 
+        :block => block, 
+        :timestamp => timestamp 
+      }
     end
     
     def toggle_super_sticky
@@ -56,12 +65,14 @@ module MicroMIDI
       @auto_output = !@auto_output
     end
 
-    def message_properties(opts, *props)
+    def message_properties(options, *properties)
       output = {}
-      props.each do |prop|
-        output[prop] = opts[prop]
-        self.send("#{prop.to_s}=", output[prop]) if !output[prop].nil? && (self.send(prop).nil? || @super_sticky)
-        output[prop] ||= self.send(prop.to_s)
+      properties.each do |property|
+        output[property] = options[property]
+        if !output[property].nil? && (send(property).nil? || @super_sticky)
+          send("#{property.to_s}=", output[property]) 
+        end
+        output[property] ||= send(property.to_s)
       end
       output
     end
@@ -69,7 +80,7 @@ module MicroMIDI
     private
     
     def now
-      ((Time.now.to_f - @start_time) * 1000)
+      (Time.now.to_f - @start_time) * 1000
     end
 
   end

data/lib/midi.rb

@@ -1,8 +1,8 @@
 #
-# micromidi
+# MicroMIDI
 # A Ruby DSL for MIDI
 #
-# (c)2011 Ari Russo 
+# (c)2011-2014 Ari Russo 
 # licensed under the Apache 2.0 License
 #
 

data/test/input_test.rb

@@ -2,10 +2,6 @@ require "helper"
 
 class InputTest < Test::Unit::TestCase
 
-  include MicroMIDI
-  include MIDIMessage
-  include TestHelper
-
   def test_thru_listeners
     m = MicroMIDI.message($test_device[:input].open)
     m.thru

data/test/sysex_test.rb

@@ -2,56 +2,54 @@ require "helper"
 
 class SysexTest < Test::Unit::TestCase
 
-  include MicroMIDI
   include MIDIMessage
-  include TestHelper
   
   def test_command
     m = MicroMIDI.message
     m.sysex_node 0x41, :model_id => 0x42, :device_id => 0x10
-    msg = m.sysex_command [0x40, 0x7F, 0x00], 0x00
-    assert_equal(SystemExclusive::Command, msg.class)
-    assert_equal([0x40, 0x7F, 0x00], msg.address)
-    assert_equal(0, msg.data)
-    assert_equal([0xF0, 0x41, 0x10, 0x42, 0x12, 0x40, 0x7F, 0x00, 0x00, 0x41, 0xF7], msg.to_bytes)
+    message = m.sysex_command [0x40, 0x7F, 0x00], 0x00
+    assert_equal(SystemExclusive::Command, message.class)
+    assert_equal([0x40, 0x7F, 0x00], message.address)
+    assert_equal(0, message.data)
+    assert_equal([0xF0, 0x41, 0x10, 0x42, 0x12, 0x40, 0x7F, 0x00, 0x00, 0x41, 0xF7], message.to_bytes)
   end
   
   def test_request
     m = MicroMIDI.message
     m.sysex_node 0x41, :model_id => 0x42, :device_id => 0x10
-    msg = m.sysex_request [0x40, 0x7F, 0x00], 0x02
-    assert_equal(SystemExclusive::Request, msg.class)
-    assert_equal([0x40, 0x7F, 0x00], msg.address)
-    assert_equal([0x0, 0x0, 0x02], msg.size)
-    assert_equal([0xF0, 0x41, 0x10, 0x42, 0x11, 0x40, 0x7F, 0x00, 0x0, 0x0, 0x02, 0x3F, 0xF7], msg.to_bytes)   
+    message = m.sysex_request [0x40, 0x7F, 0x00], 0x02
+    assert_equal(SystemExclusive::Request, message.class)
+    assert_equal([0x40, 0x7F, 0x00], message.address)
+    assert_equal([0x0, 0x0, 0x02], message.size)
+    assert_equal([0xF0, 0x41, 0x10, 0x42, 0x11, 0x40, 0x7F, 0x00, 0x0, 0x0, 0x02, 0x3F, 0xF7], message.to_bytes)   
   end
 
   def test_message
     m = MicroMIDI.message  
-    msg = m.sysex_message [0x42, 0x11, 0x40, 0x7F, 0x00, 0x0, 0x0, 0x02]
-    assert_equal(SystemExclusive::Message, msg.class)
-    assert_equal([0x42, 0x11, 0x40, 0x7F, 0x00, 0x0, 0x0, 0x02], msg.data)
-    assert_equal([0xF0,  0x42, 0x11, 0x40, 0x7F, 0x00, 0x0, 0x0, 0x02, 0xF7], msg.to_bytes)   
+    message = m.sysex_message [0x42, 0x11, 0x40, 0x7F, 0x00, 0x0, 0x0, 0x02]
+    assert_equal(SystemExclusive::Message, message.class)
+    assert_equal([0x42, 0x11, 0x40, 0x7F, 0x00, 0x0, 0x0, 0x02], message.data)
+    assert_equal([0xF0,  0x42, 0x11, 0x40, 0x7F, 0x00, 0x0, 0x0, 0x02, 0xF7], message.to_bytes)   
   end
 
   def test_message_with_node
     m = MicroMIDI.message  
     m.sysex_node 0x41, :model_id => 0x42, :device_id => 0x10
-    msg = m.sysex_message [0x42, 0x11, 0x40, 0x7F, 0x00, 0x0, 0x0, 0x02]
-    assert_equal(SystemExclusive::Message, msg.class)
-    assert_equal([0x42, 0x11, 0x40, 0x7F, 0x00, 0x0, 0x0, 0x02], msg.data)
-    assert_equal([0xF0, 0x41, 0x10, 0x42, 0x42, 0x11, 0x40, 0x7F, 0x00, 0x0, 0x0, 0x02, 0xF7], msg.to_bytes)   
+    message = m.sysex_message [0x42, 0x11, 0x40, 0x7F, 0x00, 0x0, 0x0, 0x02]
+    assert_equal(SystemExclusive::Message, message.class)
+    assert_equal([0x42, 0x11, 0x40, 0x7F, 0x00, 0x0, 0x0, 0x02], message.data)
+    assert_equal([0xF0, 0x41, 0x10, 0x42, 0x42, 0x11, 0x40, 0x7F, 0x00, 0x0, 0x0, 0x02, 0xF7], message.to_bytes)   
   end
     
   def test_no_model_id
     m = MicroMIDI.message
     m.sysex_node 0x41, :device_id => 0x10
-    msg = m.sysex_command [0x40, 0x7F, 0x00], 0x00
-    assert_equal(SystemExclusive::Command, msg.class)
-    assert_equal([0x41, 0x10], msg.node.to_a)
-    assert_equal([0x40, 0x7F, 0x00], msg.address)
-    assert_equal(0, msg.data)
-    assert_equal([0xF0, 0x41, 0x10, 0x12, 0x40, 0x7F, 0x00, 0x00, 0x41, 0xF7], msg.to_bytes)
+    message = m.sysex_command [0x40, 0x7F, 0x00], 0x00
+    assert_equal(SystemExclusive::Command, message.class)
+    assert_equal([0x41, 0x10], message.node.to_a)
+    assert_equal([0x40, 0x7F, 0x00], message.address)
+    assert_equal(0, message.data)
+    assert_equal([0xF0, 0x41, 0x10, 0x12, 0x40, 0x7F, 0x00, 0x00, 0x41, 0xF7], message.to_bytes)
   end
       
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: micromidi
 version: !ruby/object:Gem::Version
-  version: 0.1.2
+  version: 0.1.3
 platform: ruby
 authors:
 - Ari Russo
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-09-05 00:00:00.000000000 Z
+date: 2014-09-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: midi-eye
@@ -103,6 +103,7 @@ files:
 - lib/micromidi/instructions/shorthand.rb
 - lib/micromidi/instructions/sticky.rb
 - lib/micromidi/instructions/sysex.rb
+- lib/micromidi/module_methods.rb
 - lib/micromidi/state.rb
 - lib/midi.rb
 - test/composite_test.rb