micromidi 0.1.3 → 0.1.4

data/lib/micromidi/instructions/sysex.rb

@@ -1,39 +1,60 @@
 module MicroMIDI
 
   module Instructions
-    
+
     class SysEx
 
-      include MIDIMessage
-      
+      # @param [State] state
       def initialize(state)
         @state = state
       end
-      
-      # create a sysex command
+
+      # Create a sysex command message
+      # @param [Fixnum] address
+      # @param [Array<Fixnum>] data
+      # @param [Hash] options
+      # @option options [MIDIMessage::SystemExclusive::Node] :node (also :sysex_node)
+      # @return [MIDIMessage::SystemExclusive::Command]
       def sysex_command(address, data, options = {})
-        options[:sysex_node] ||= options[:node]
-        props = @state.message_properties(options, :sysex_node)
-        SystemExclusive::Command.new(address, data, :node => props[:sysex_node])
+        properties = sysex_properties(options)
+        MIDIMessage::SystemExclusive::Command.new(address, data, :node => properties[:sysex_node])
       end
       alias_method :command, :sysex_command
-      
-      # create a sysex request
+
+      # Create a sysex request message
+      # @param [Fixnum] address
+      # @param [Fixnum] size
+      # @param [Hash] options
+      # @option options [MIDIMessage::SystemExclusive::Node] :node (also :sysex_node)
+      # @return [MIDIMessage::SystemExclusive::Request]
       def sysex_request(address, size, options = {})
-        options[:sysex_node] ||= options[:node]
-        props = @state.message_properties(options, :sysex_node)
-        SystemExclusive::Request.new(address, size, :node => props[:sysex_node])        
+        properties = sysex_properties(options)
+        MIDIMessage::SystemExclusive::Request.new(address, size, :node => properties[:sysex_node])
       end
       alias_method :request, :sysex_request
-      
-      # create an indeterminate sysex message
+
+      # Create a generic sysex message
+      # @param [Array<Fixnum>] data
+      # @param [Hash] options
+      # @option options [MIDIMessage::SystemExclusive::Node] :node (also :sysex_node)
+      # @return [MIDIMessage::SystemExclusive::Message]
       def sysex_message(data, options = {})
-        options[:sysex_node] ||= options[:node]
-        props = @state.message_properties(options, :sysex_node)
-        SystemExclusive::Message.new(data, :node => props[:sysex_node])
+        properties = sysex_properties(options)
+        MIDIMessage::SystemExclusive::Message.new(data, :node => properties[:sysex_node])
       end
       alias_method :sysex, :sysex_message
 
+      private
+
+      # Get the message properties given the options hash
+      # @param [Hash] options
+      # @return [Hash]
+      def sysex_properties(options)
+        sysex_options = options.dup
+        sysex_options[:sysex_node] ||= options.delete(:node)
+        @state.message_properties(sysex_options, :sysex_node)
+      end
+
     end
 
   end

data/lib/micromidi/module_methods.rb

@@ -1,34 +1,32 @@
 module MicroMIDI
 
-  def self.new(*args, &block)
-    message(*args, &block)
+  extend self
+
+  # Shortcut to create a new context
+  # @param [*Object] args
+  # @param [Proc] block
+  # @return [Context]
+  def new(*args, &block)
+    inputs = Device.get_inputs(args)
+    outputs = Device.get_outputs(args)
+    Context.new(inputs, outputs, &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
+    alias_method :message, :new
+    alias_method :using, :new
   end
 
   module IO
 
+    # Shortcut to create a new context
+    # @param [*Object] args
+    # @param [Proc] block
+    # @return [Context]
     def self.new(*args, &block)
-      MicroMIDI.message(*args, &block)
+      MicroMIDI.new(*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

@@ -1,86 +1,129 @@
 module MicroMIDI
 
+  # The DSL state
   class State
-    
+
     DEFAULT = {
       :channel => 0,
       :octave => 2,
       :velocity => 100
     }
-    
+
     attr_accessor :auto_output,
-                  :channel,
-                  :last_note,
-                  :octave,
-                  :sysex_node,
-                  :super_sticky, 
-                  :velocity
-    
+    :channel,
+    :last_note,
+    :octave,
+    :sysex_node,
+    :super_sticky,
+    :velocity
+
     attr_reader :inputs,
-                :last_command,
-                :listeners,
-                :outputs,
-                :output_cache, 
-                :start_time,
-                :thru_listeners
-        
+    :last_command,
+    :listeners,
+    :outputs,
+    :output_cache,
+    :start_time,
+    :thru_listeners
+
+    # @param [Array<UniMIDI::Input>, UniMIDI::Input] inputs
+    # @param [Array<UniMIDI::Output, IO>, IO, UniMIDI::Output] outputs
+    # @param [Hash] options
+    # @option options [Fixnum] :channel
+    # @option options [Fixnum] :octave
+    # @option options [Fixnum] :velocity
     def initialize(inputs, outputs, options = {})
-      @inputs = inputs
-      @outputs = outputs 
+      @inputs = [inputs].flatten
+      @outputs = [outputs].flatten
 
       @channel = options[:channel] || DEFAULT[:channel]
       @velocity = options[:velocity] || DEFAULT[:velocity]
-      @octave = options[:octave] || DEFAULT[:octave]  
+      @octave = options[:octave] || DEFAULT[:octave]
 
       @auto_output = true
       @last_command = nil
-      @last_note = nil    
+      @last_note = nil
       @listeners = []
       @thru_listeners = []
       @output_cache = []
       @start_time = Time.now.to_f
       @super_sticky = false
     end
-    
-    def record(method, args, block, output)
+
+    # Record that a command was used
+    # @param [Symbol, String] method
+    # @param [Array<Object>] args
+    # @param [Proc] block
+    # @param [Object] result
+    def record(method, args, block, result)
       timestamp = now
-      message = { 
-        :message => output, 
-        :timestamp => timestamp 
+      message = {
+        :message => result,
+        :timestamp => timestamp
       }
       @output_cache << message
-      @last_command = { 
-        :method => method, 
-        :args => args, 
-        :block => block, 
-        :timestamp => timestamp 
+      @last_command = {
+        :method => method,
+        :args => args,
+        :block => block,
+        :timestamp => timestamp
       }
     end
-    
+
+    #
+    # Toggles super_sticky mode, a mode where any explicit values used to create MIDI messages
+    # automatically become sticky.  Normally the explicit value would only be used for
+    # the current message.
+    #
+    # For example, while in super sticky mode
+    #
+    # ```ruby
+    # note "C4", :channel => 5
+    # note "C3"
+    # ```
+    #
+    # will have the same results as
+    #
+    # ```ruby
+    # channel 5
+    # note "C4"
+    # note "C3"
+    # ```
+    #
+    # @return [Boolean]
     def toggle_super_sticky
       @super_sticky = !@super_sticky
     end
-    
+
+    # Toggles auto-output mode.  In auto-output mode, any messages that are instantiated are sent to
+    # any available MIDI outputs.
+    # @return [Boolean]
     def toggle_auto_output
       @auto_output = !@auto_output
     end
 
+    # Return message properties with regard to the current state
+    # @param [Hash] options
+    # @param [*Symbol] properties
+    # @return [Hash]
     def message_properties(options, *properties)
-      output = {}
+      result = {}
       properties.each do |property|
-        output[property] = options[property]
-        if !output[property].nil? && (send(property).nil? || @super_sticky)
-          send("#{property.to_s}=", output[property]) 
+        result[property] = options[property]
+        if !result[property].nil? && (send(property).nil? || @super_sticky)
+          send("#{property.to_s}=", result[property])
         end
-        output[property] ||= send(property.to_s)
+        result[property] ||= send(property.to_s)
       end
-      output
+      result
     end
-    
+
     private
-    
+
+    # A timestamp
+    # @return [Float]
     def now
-      (Time.now.to_f - @start_time) * 1000
+      time = Time.now.to_f - @start_time
+      time * 1000
     end
 
   end

data/lib/midi.rb

@@ -2,14 +2,15 @@
 # MicroMIDI
 # A Ruby DSL for MIDI
 #
-# (c)2011-2014 Ari Russo 
-# licensed under the Apache 2.0 License
+# (c)2011-2014 Ari Russo
+# Apache 2.0 License
 #
 
-# The purpose of this file is just to allow both:
+# The purpose of this file is to allow:
 #
-# <em>require "micromidi"</em>
-# and 
 # <em>require "midi"</em>
+# in addition to
+# <em>require "micromidi"</em>
+#
 
 require "micromidi"

data/test/composite_test.rb

@@ -1,78 +1,73 @@
 require "helper"
 
-class CompositeTest < Test::Unit::TestCase
-
-  include MicroMIDI
-  include MIDIMessage
-  include TestHelper
+class CompositeTest < Minitest::Test
 
   def test_play
     m = MicroMIDI.message
     start = Time.now
     msg = m.play "C0", 0.5
-    
+
     finish = Time.now
     dif = finish - start
     assert_equal(true, dif >= 0.5)
-    
-    assert_equal(NoteOn, msg.class)
+
+    assert_equal(MIDIMessage::NoteOn, msg.class)
     assert_equal(12, msg.note)
     assert_equal(0, msg.channel)
     assert_equal(2, m.state.output_cache.size)
-    
+
     off_msg = m.state.output_cache.last[:message]
-    assert_equal(NoteOff, off_msg.class)
+    assert_equal(MIDIMessage::NoteOff, off_msg.class)
     assert_equal(12, off_msg.note)
     assert_equal(0, off_msg.channel)
   end
-  
+
   def test_play_chord
     m = MicroMIDI.message
     start = Time.now
     msgs = m.play "C0", "E1", "G2", 0.5
-    
+
     finish = Time.now
     dif = finish - start
     assert_equal(true, dif >= 0.5)
-    
+
     msg = msgs.first
-    
-    assert_equal(NoteOn, msg.class)
+
+    assert_equal(MIDIMessage::NoteOn, msg.class)
     assert_equal(12, msg.note)
     assert_equal(0, msg.channel)
     assert_equal(6, m.state.output_cache.size)
-    
+
     off_msg = m.state.output_cache.last[:message]
-    assert_equal(NoteOff, off_msg.class)
+    assert_equal(MIDIMessage::NoteOff, off_msg.class)
     assert_equal(43, off_msg.note)
     assert_equal(0, off_msg.channel)
   end
-  
+
   def test_play_chord_array
     m = MicroMIDI.message
     start = Time.now
     msgs = m.play ["C0", "E1", "G2"], 0.5
-    
+
     finish = Time.now
     dif = finish - start
     assert_equal(true, dif >= 0.5)
-    
+
     msg = msgs.first
-    
-    assert_equal(NoteOn, msg.class)
+
+    assert_equal(MIDIMessage::NoteOn, msg.class)
     assert_equal(12, msg.note)
     assert_equal(0, msg.channel)
     assert_equal(6, m.state.output_cache.size)
-    
+
     off_msg = m.state.output_cache.last[:message]
-    assert_equal(NoteOff, off_msg.class)
+    assert_equal(MIDIMessage::NoteOff, off_msg.class)
     assert_equal(43, off_msg.note)
     assert_equal(0, off_msg.channel)
   end
-  
+
   def test_all_off
-    
+
   end
-          
-end
 
+end

data/test/context_test.rb

@@ -1,52 +1,47 @@
 require "helper"
 
-class ContextTest < Test::Unit::TestCase
+class ContextTest < Minitest::Test
 
-  include MicroMIDI
-  include MIDIMessage
-  include TestHelper
-  
   def test_new_with_block
     msg = nil
     MIDI::IO.new do
       msg = note "C0"
     end
-    assert_equal(NoteOn, msg.class)
+    assert_equal(MIDIMessage::NoteOn, msg.class)
     assert_equal(12, msg.note)
-    assert_equal(0, msg.channel)    
+    assert_equal(0, msg.channel)
   end
-  
+
   def test_new_with_no_block
     m = MIDI::IO.new
     msg = m.note "C0"
-    assert_equal(NoteOn, msg.class)
+    assert_equal(MIDIMessage::NoteOn, msg.class)
     assert_equal(12, msg.note)
     assert_equal(0, msg.channel)
   end
-  
+
   def test_edit
     msg = nil
-    m = MIDI::IO.new 
+    m = MIDI::IO.new
     m.edit do
       msg = m.note "C0"
     end
-    assert_equal(NoteOn, msg.class)
+    assert_equal(MIDIMessage::NoteOn, msg.class)
     assert_equal(12, msg.note)
-    assert_equal(0, msg.channel)     
+    assert_equal(0, msg.channel)
   end
 
   def test_repeat
     m = MicroMIDI.message
     msg = m.note "C0"
-    assert_equal(NoteOn, msg.class)
+    assert_equal(MIDIMessage::NoteOn, msg.class)
     assert_equal(12, msg.note)
     assert_equal(0, msg.channel)
-    
+
     r_msg = m.repeat
-    assert_equal(NoteOn, r_msg.class)
+    assert_equal(MIDIMessage::NoteOn, r_msg.class)
     assert_equal(12, r_msg.note)
     assert_equal(0, r_msg.channel)
   end
-          
-end
 
+end