midi 0.0.7

data/lib/micromidi/instructions/output.rb

@@ -0,0 +1,28 @@
+#!/usr/bin/env ruby
+#
+module MicroMIDI
+
+  module Instructions
+    
+    class Output
+      
+      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
+      end
+      
+      # toggle mode where messages are automatically outputted
+      def auto_output(mode = nil)
+        mode.nil? ? @state.toggle_auto_output : @state.auto_output = mode
+      end
+
+    end
+
+  end
+
+end

data/lib/micromidi/instructions/process.rb

@@ -0,0 +1,57 @@
+#!/usr/bin/env ruby
+#
+module MicroMIDI
+
+  module Instructions
+    
+    class Process
+
+      include MIDIMessage
+      include MIDIMessage::Process
+      
+      def initialize(state)
+        @state = state
+      end
+      
+      def transpose(message, property, factor, options = {})
+        Transpose.process(message, property, factor, options)
+      end
+      
+      def limit(message, property, range, options = {})
+        Limit.process(message, property, range, options)
+      end
+      
+      def filter(message, property, bandwidth, options = {})
+        Filter.process(message, property, bandwidth, options)
+      end
+      
+      def high_pass_filter(message, property, min, options = {})
+        HighPassFilter.process(message, property, min, options)
+      end
+      alias_method :only_above, :high_pass_filter
+      alias_method :except_below, :high_pass_filter
+
+      def low_pass_filter(message, property, max, options = {})
+        LowPassFilter.process(message, property, max, options)
+      end
+      alias_method :only_below, :low_pass_filter
+      alias_method :except_above, :low_pass_filter
+      
+      def band_pass_filter(message, property, bandwidth, options = {})
+        BandPassFilter.process(message, property, bandwidth, options)
+      end
+      alias_method :only_in, :band_pass_filter
+      alias_method :only, :band_pass_filter
+      
+      def notch_filter(message, property, bandwidth, options = {})
+        NotchFilter.process(message, property, bandwidth, options)
+      end
+      alias_method :band_reject_filter, :notch_filter
+      alias_method :except_in, :notch_filter
+      alias_method :except, :notch_filter
+      
+    end
+
+  end
+
+end

data/lib/micromidi/instructions/shorthand.rb

@@ -0,0 +1,79 @@
+#!/usr/bin/env ruby
+#
+
+module MicroMIDI
+  
+  alias l loop
+ 
+  class << self
+    alias_method :m, :message
+  end
+  
+  class Context
+    alias_method :r, :repeat
+  end
+  
+  module Instructions    
+        
+    module Composite
+      alias_method :p, :play
+      alias_method :q!, :all_off
+      alias_method :x, :all_off
+    end
+        
+    class Input
+      alias_method :j, :join
+      alias_method :rc, :receive
+      alias_method :rcu, :receive_unless
+      alias_method :t, :thru
+      alias_method :te, :thru_except
+      alias_method :tu, :thru_unless
+      alias_method :w, :wait_for_input      
+    end
+    
+    class Message
+      alias_method :c, :control_change
+      alias_method :cc, :control_change
+      alias_method :n, :note
+      alias_method :no, :note_off
+      alias_method :o, :off
+      alias_method :pc, :program_change
+    end
+    
+    class Output
+      alias_method :out, :output
+    end
+    
+    class Process
+      alias_method :bp, :band_pass_filter
+      alias_method :bpf, :band_pass_filter
+      alias_method :br, :notch_filter
+      alias_method :f, :filter
+      alias_method :hp, :high_pass_filter
+      alias_method :hpf, :high_pass_filter
+      alias_method :l, :limit
+      alias_method :lp, :low_pass_filter
+      alias_method :lpf, :low_pass_filter
+      alias_method :mbf, :filter
+      alias_method :nf, :notch_filter
+      alias_method :tp, :transpose      
+    end
+        
+    class Sticky
+      alias_method :ch, :channel
+      alias_method :ss, :super_sticky
+      alias_method :v, :velocity
+    end
+    
+    class SysEx
+      alias_method :sc, :sysex_command
+      alias_method :sr, :sysex_request
+      alias_method :sx, :sysex_message
+    end
+
+  end
+end
+
+def M(*a, &block)
+  MIDI.message(*a, &block)  
+end

data/lib/micromidi/instructions/sticky.rb

@@ -0,0 +1,59 @@
+#!/usr/bin/env ruby
+#
+module MicroMIDI
+
+  module Instructions
+    
+    class Sticky
+      
+      def initialize(state)
+        @state = state
+      end
+
+      # sets the sticky channel for the current block
+      def channel(val = nil)
+        val.nil? ? @state.channel : @state.channel = val
+      end
+      
+      # sets the octave for the current block
+      def octave(val = nil)
+        val.nil? ? @state.octave : @state.octave = val
+      end
+      
+      # sets the sysex node for the current block
+      def sysex_node(*args)
+        options = args.last.kind_of?(Hash) ? args.last : {}
+        args.empty? ? @state.sysex_node : @state.sysex_node = MIDIMessage::SystemExclusive::Node.new(args.first, options)
+      end
+      alias_method :node, :sysex_node
+
+      # sets the sticky velocity for the current block
+      def velocity(val = nil)
+        val.nil? ? @state.velocity : @state.velocity = val
+      end
+      
+      #
+      # toggles super_sticky mode, a mode where any explicit values used to create MIDI messages
+      # automatically become sticky -- whereas normally the explicit value would only be used for 
+      # the current message.
+      #
+      # e.g.
+      #
+      # note "C4", :channel => 5
+      #
+      # will have the exact same effect as
+      # 
+      # channel 5
+      # note "C4"
+      #
+      # while in super sticky mode
+      #
+      def super_sticky
+        @state.toggle_super_sticky
+      end
+      
+    end
+
+  end
+
+end

data/lib/micromidi/instructions/sysex.rb

@@ -0,0 +1,43 @@
+#!/usr/bin/env ruby
+#
+module MicroMIDI
+
+  module Instructions
+    
+    class SysEx
+
+      include MIDIMessage
+      
+      def initialize(state)
+        @state = state
+      end
+      
+      # create a sysex 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])
+      end
+      alias_method :command, :sysex_command
+      
+      # create a sysex 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])        
+      end
+      alias_method :request, :sysex_request
+      
+      # create an indeterminate sysex 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])
+      end
+      alias_method :sysex, :sysex_message
+
+    end
+
+  end
+
+end

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/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
+