micromidi 0.0.7

data/lib/micromidi/state.rb

@@ -0,0 +1,79 @@
+#!/usr/bin/env ruby
+#
+module MicroMIDI
+
+  class State
+    
+    Default = {
+      :channel => 0,
+      :octave => 2,
+      :velocity => 100
+    }
+    
+    attr_accessor :auto_output,
+                  :channel,
+                  :last_note,
+                  :octave,
+                  :sysex_node,
+                  :super_sticky, 
+                  :velocity
+    
+    attr_reader :inputs,
+                :last_command,
+                :listeners,
+                :outputs,
+                :output_cache, 
+                :start_time,
+                :thru_listeners
+        
+    def initialize(ins, outs, options = {})
+      @auto_output = true
+      @last_command = nil
+      @last_note = nil    
+      @listeners = []
+      @thru_listeners = []
+      @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 }
+    end
+    
+    def toggle_super_sticky
+      @super_sticky = !@super_sticky
+    end
+    
+    def toggle_auto_output
+      @auto_output = !@auto_output
+    end
+
+    def message_properties(opts, *props)
+      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)
+      end
+      output
+    end
+    
+    private
+    
+    def now
+      ((Time.now.to_f - @start_time) * 1000)
+    end
+
+  end
+
+end

data/lib/micromidi.rb

@@ -0,0 +1,67 @@
+#!/usr/bin/env ruby
+#
+# micromidi
+# A Ruby DSL for MIDI
+#
+# (c)2011 Ari Russo 
+# licensed under the Apache 2.0 License
+#
+
+# libs
+require 'midi-eye'
+require 'midi-message'
+require 'unimidi'
+
+module MicroMIDI
+  
+  VERSION = "0.0.7"
+  
+  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)
+      MicroMIDI.message(*args)
+    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'
+
+# classes
+require 'micromidi/context'
+require 'micromidi/state'
+require 'micromidi/instructions/process'
+require 'micromidi/instructions/input'
+require 'micromidi/instructions/message'
+require 'micromidi/instructions/output'
+require 'micromidi/instructions/sticky'
+require 'micromidi/instructions/sysex'
+
+# re-open
+require 'micromidi/instructions/shorthand'

data/lib/midi.rb

@@ -0,0 +1,15 @@
+#!/usr/bin/env ruby
+#
+# micromidi
+# A Ruby DSL for MIDI
+#
+# (c)2011 Ari Russo 
+# licensed under the Apache 2.0 License
+#
+
+# the purpose of this file is just to allow both 
+# <em>require "micromidi"</em>
+# and 
+# <em>require "midi"</em>
+
+require 'micromidi'

data/test/helper.rb

@@ -0,0 +1,32 @@
+#!/usr/bin/env ruby
+
+dir = File.dirname(File.expand_path(__FILE__))
+$LOAD_PATH.unshift dir + '/../lib'
+
+require 'test/unit'
+require 'midi'
+
+module TestHelper
+  
+  def self.select_devices
+    $test_device ||= {}
+    { :input => UniMIDI::Input.all, :output => UniMIDI::Output.all }.each do |type, devs|
+      puts ""
+      puts "select an #{type.to_s}..."
+      while $test_device[type].nil?
+        devs.each do |device|
+          puts device.pretty_name
+        end
+        selection = $stdin.gets.chomp
+        if selection != ""
+          selection = selection.to_i
+          $test_device[type] = devs.find { |d| d.id == selection }
+          puts "selected #{selection} for #{type.to_s}" unless $test_device[type]
+        end
+      end
+    end
+  end 
+     
+end
+
+TestHelper.select_devices

data/test/test_composite.rb

@@ -0,0 +1,36 @@
+#!/usr/bin/env ruby
+
+require 'helper'
+
+class CompositeTest < Test::Unit::TestCase
+
+  include MicroMIDI
+  include MIDIMessage
+  include TestHelper
+
+  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(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(12, off_msg.note)
+    assert_equal(0, off_msg.channel)
+  end
+  
+  def test_all_off
+    
+  end
+          
+end
+

data/test/test_context.rb

@@ -0,0 +1,33 @@
+#!/usr/bin/env ruby
+
+require 'helper'
+
+class ContextTest < Test::Unit::TestCase
+
+  include MicroMIDI
+  include MIDIMessage
+  include TestHelper
+  
+  def test_no_block
+    m = MIDI::IO.new
+    msg = m.note "C0"
+    assert_equal(NoteOn, msg.class)
+    assert_equal(12, msg.note)
+    assert_equal(0, msg.channel)
+  end
+
+  def test_repeat
+    m = MicroMIDI.message
+    msg = m.note "C0"
+    assert_equal(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(12, r_msg.note)
+    assert_equal(0, r_msg.channel)
+  end
+          
+end
+

data/test/test_effect.rb

@@ -0,0 +1,135 @@
+#!/usr/bin/env ruby
+
+require 'helper'
+
+class EffectTest < Test::Unit::TestCase
+
+  include MicroMIDI
+  include TestHelper
+
+  def test_high_pass_note_reject
+    m = MicroMIDI.message
+    msg = m.note "C0"
+    outp = m.hpf msg, :note, 20   
+    assert_equal(12, msg.note)
+    assert_equal(nil, outp)
+  end
+
+  def test_high_pass_note_accept
+    m = MicroMIDI.message
+    msg = m.note "C4"
+    outp = m.hpf msg, :note, 20
+    assert_equal(60, msg.note)
+    assert_equal(msg, outp)
+  end
+
+  def test_low_pass_note_reject
+    m = MicroMIDI.message
+    msg = m.note "C4"
+    outp = m.lpf msg, :note, 50
+    assert_equal(60, msg.note)
+    assert_equal(nil, outp)
+  end
+
+  def test_low_pass_note_accept
+    m = MicroMIDI.message
+    msg = m.note "C4"
+    outp = m.lp msg, :note, 100
+    assert_equal(60, msg.note)
+    assert_equal(msg, outp)
+  end
+
+  def test_band_pass_note_reject
+    m = MicroMIDI.message
+    msg = m.note "C4"
+    outp = m.bpf msg, :note, (20..50)
+    assert_equal(60, msg.note)
+    assert_equal(nil, outp)
+  end
+
+  def test_band_pass_note_accept
+    m = MicroMIDI.message
+    msg = m.note "C4"
+    outp = m.bp msg, :note, (20..100)
+    assert_equal(60, msg.note)
+    assert_equal(msg, outp)
+  end
+  
+  def test_notch_note_reject
+    m = MicroMIDI.message
+    msg = m.note "C4"
+    outp = m.nf msg, :note, (20..70)
+    assert_equal(60, msg.note)
+    assert_equal(nil, outp)
+  end
+
+  def test_notch_note_accept
+    m = MicroMIDI.message
+    msg = m.note "C4"
+    outp = m.nf msg, :note, (20..50)
+    assert_equal(60, msg.note)
+    assert_equal(msg, outp)
+  end
+  
+  def test_multiband_note_reject
+    m = MicroMIDI.message
+    msg = m.note "C4"
+    outp = m.f msg, :note, [(20..30), (40..50)]
+    assert_equal(60, msg.note)
+    assert_equal(nil, outp)
+  end
+
+  def test_multiband_note_accept
+    m = MicroMIDI.message
+    msg = m.note "C4"
+    outp = m.mbf msg, :note, [(20..30), (50..70)]
+    assert_equal(60, msg.note)
+    assert_equal(msg, outp)
+  end
+  
+  def test_multinotch_note_reject
+    m = MicroMIDI.message
+    msg = m.note "C4"
+    outp = m.mbf msg, :note, [(20..30), (55..65)], :reject => true
+    assert_equal(60, msg.note)
+    assert_equal(nil, outp)
+  end
+
+  def test_multinotch_note_accept
+    m = MicroMIDI.message
+    msg = m.note "C4"
+    outp = m.mbf msg, :note, [(20..30), (40..50)], :reject => true   
+    assert_equal(60, msg.note)
+    assert_equal(msg, outp)
+  end
+  
+  def test_limit_low
+    m = MicroMIDI.message
+    msg = m.note "C0"
+    outp = m.limit msg, :note, (20..50)
+    assert_equal(20, msg.note)
+  end
+
+  def test_limit_high
+    m = MicroMIDI.message
+    msg = m.note "C6"
+    outp = m.limit msg, :note, (20..50)
+    assert_equal(50, msg.note)
+  end
+  
+  def test_transpose_note_up
+    m = MicroMIDI.message
+    msg = m.note "C4"
+    outp = m.transpose msg, :note, 5
+    assert_equal(65, msg.note)
+  end
+
+  def test_transpose_velocity_down
+    m = MicroMIDI.message
+    msg = m.note "C4", :velocity => 82
+    outp = m.transpose msg, :velocity, -10
+    assert_equal(72, msg.velocity)
+  end
+  
+end
+

data/test/test_input.rb

@@ -0,0 +1,23 @@
+#!/usr/bin/env ruby
+
+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
+    assert_equal(0, m.state.listeners.size)
+    assert_equal(1, m.state.thru_listeners.size)
+    assert_equal(MIDIEye::Listener, m.state.thru_listeners.first.class)    
+  end
+
+  def test_thru_unless
+  end
+            
+end
+

data/test/test_message.rb

@@ -0,0 +1,123 @@
+#!/usr/bin/env ruby
+
+require 'helper'
+
+class MessageTest < Test::Unit::TestCase
+
+  include MicroMIDI
+  include MIDIMessage
+  include TestHelper
+  
+  def test_cc
+    m = MicroMIDI.message
+    msg = m.cc 16, 12
+    assert_equal(ControlChange, msg.class)
+    assert_equal(16, msg.index)
+    assert_equal(12, msg.value)
+  end
+
+  def test_channel_aftertouch
+    m = MicroMIDI::IO.new
+    msg = m.channel_aftertouch 2, :channel => 1
+    assert_equal(ChannelAftertouch, msg.class)
+    assert_equal(1, msg.channel)
+    assert_equal(2, msg.value)
+  end
+
+  def test_poly_aftertouch
+    m = MicroMIDI::IO.new
+    msg = m.poly_aftertouch 64, 2, :channel => 1
+    assert_equal(PolyphonicAftertouch, msg.class)
+    assert_equal(1, msg.channel)
+    assert_equal(64, msg.note)
+    assert_equal(2, msg.value)
+  end
+  
+  def test_pitch_bend
+    m = MicroMIDI::IO.new
+    msg = m.pitch_bend 64, 2, :channel => 1
+    assert_equal(PitchBend, msg.class)
+    assert_equal(1, msg.channel)
+    assert_equal(64, msg.low)
+    assert_equal(2, msg.high)    
+  end
+      
+  def test_note_off
+    m = MicroMIDI.message
+    msg = m.note_off 13, :channel => 9, :velocity => 80
+    assert_equal(NoteOff, msg.class)
+    assert_equal(13, msg.note)
+    assert_equal(9, msg.channel)
+    assert_equal(80, msg.velocity)    
+  end
+
+  def test_note_on_string
+    m = MicroMIDI.message
+    msg = m.note "C0", :velocity => 94
+    assert_equal(NoteOn, msg.class)
+    assert_equal(12, msg.note)
+    assert_equal(94, msg.velocity)
+  end
+
+  def test_note_on_string_no_octave
+    m = MicroMIDI.message
+    msg = m.note "C", :velocity => 94
+    assert_equal(NoteOn, msg.class)
+    assert_equal(36, msg.note)
+    assert_equal(94, msg.velocity)
+  end
+  
+  def test_note_on_int
+    m = MicroMIDI.message
+    msg = m.note 12, :channel => 3
+    assert_equal(NoteOn, msg.class)
+    assert_equal(12, msg.note)
+    assert_equal(3, msg.channel)
+  end
+
+  def test_note_on_symbol
+    m = MicroMIDI.message
+    msg = m.note :C0
+    assert_equal(NoteOn, msg.class)
+    assert_equal(12, msg.note)
+    assert_equal(100, msg.velocity)    
+  end
+    
+  def test_note_on_symbol_no_octave
+    m = MicroMIDI.message
+    msg = m.note :C
+    assert_equal(NoteOn, msg.class)
+    assert_equal(36, msg.note)
+    assert_equal(100, msg.velocity)    
+  end
+  
+  def test_parse
+    m = MicroMIDI.message
+    msg = m.parse "906040"
+    assert_equal(NoteOn, msg.class)
+    assert_equal(96, msg.note)
+    assert_equal(0, msg.channel)    
+    assert_equal(64, msg.velocity)
+  end
+  
+  def test_program_change
+    m = MicroMIDI.message
+    msg = m.program_change 15
+    assert_equal(ProgramChange, msg.class)
+    assert_equal(15, msg.program)    
+  end
+  
+  def test_off
+    m = MicroMIDI.message
+    msg = m.note "C0", :channel => 3
+    assert_equal(NoteOn, msg.class)
+    assert_equal(12, msg.note)
+    assert_equal(3, msg.channel)
+    off_msg = m.off    
+    assert_equal(NoteOff, off_msg.class)
+    assert_equal(12, off_msg.note)
+    assert_equal(3, off_msg.channel)
+  end
+    
+end
+

data/test/test_output.rb

@@ -0,0 +1,21 @@
+#!/usr/bin/env ruby
+
+require 'helper'
+
+class OutputTest < Test::Unit::TestCase
+
+  include MicroMIDI
+  include MIDIMessage
+  include TestHelper
+
+  def test_auto_output
+    m = MicroMIDI.message($test_device[:output].open)
+    assert_equal(true, m.state.auto_output)
+    m.output false
+    assert_equal(false, m.state.auto_output)
+    m.output true
+    assert_equal(true, m.state.auto_output)
+  end
+            
+end
+

data/test/test_state.rb

@@ -0,0 +1,32 @@
+#!/usr/bin/env ruby
+
+require 'helper'
+
+class StateTest < Test::Unit::TestCase
+
+  include MicroMIDI
+  include MIDIMessage
+  include TestHelper
+
+  def test_output_cache
+    m = MicroMIDI.message
+    cache = m.state.output_cache
+    
+    m.note "C0"    
+    assert_equal(1, cache.size)
+    
+    m.note "C3"
+    assert_equal(2, cache.size)    
+  end
+  
+  def test_start_time
+    t1 = Time.now.to_f
+    m = MicroMIDI.message
+    t2 = Time.now.to_f
+    t = m.state.start_time
+    assert_equal(true, t1 < t)
+    assert_equal(true, t < t2)
+  end
+          
+end
+