patchmaster 0.0.0 → 0.0.1

data/lib/patchmaster/dsl.rb

@@ -14,27 +14,39 @@ class DSL
 
   def load(file)
     contents = IO.read(file)
+    @triggers = []
     @filters = []
+    @songs = {}                 # key = name, value = song
     instance_eval(contents)
+    read_triggers(contents)
     read_filters(contents)
   end
 
   def input(port_num, sym, name=nil)
-    @pm.inputs[sym] = InputDevice.new(name || sym.to_s, port_num, @no_midi)
+    @pm.inputs[sym] = InputInstrument.new(name || sym.to_s, port_num, @no_midi)
   rescue => ex
-    raise "error creating input device \"#{name}\" on input port #{port_num}: #{ex}"
+    raise "input: error creating input instrument \"#{name}\" on input port #{port_num}: #{ex}"
   end
   alias_method :in, :input
 
   def output(port_num, sym, name=nil)
-    @pm.outputs[sym] = OutputDevice.new(name || sym.to_s, port_num, @no_midi)
+    @pm.outputs[sym] = OutputInstrument.new(name || sym.to_s, port_num, @no_midi)
   rescue => ex
-    raise "error creating output device \"#{name}\" on output port #{port_num}: #{ex}"
+    raise "output: error creating output instrument \"#{name}\" on output port #{port_num}: #{ex}"
   end
   alias_method :out, :output
 
+  def trigger(instrument_sym, bytes, &block)
+    instrument = @pm.inputs[instrument_sym]
+    raise "trigger: error finding instrument #{instrument_sym}" unless instrument
+    t = Trigger.new(bytes, block)
+    instrument.triggers << t
+    @triggers << t
+  end
+
   def song(name)
     @song = Song.new(name)      # ctor saves into @pm.all_songs
+    @songs[name] = @song
     yield @song if block_given?
   end
 
@@ -50,6 +62,7 @@ class DSL
 
   def connection(in_sym, in_chan, out_sym, out_chan)
     input = @pm.inputs[in_sym]
+    in_chan = nil if in_chan == :all || in_chan == :any
     raise "can't find input instrument #{in_sym}" unless input
     output = @pm.outputs[out_sym]
     raise "can't find outputput instrument #{out_sym}" unless output
@@ -95,7 +108,7 @@ class DSL
     sl = SongList.new(name)
     @pm.song_lists << sl
     song_names.each do |sn|
-      song = @pm.all_songs.find(sn)
+      song = @songs[sn]
       raise "song \"#{sn}\" not found (song list \"#{name}\")" unless song
       sl << song
     end
@@ -106,18 +119,29 @@ class DSL
   def save(file)
     File.open(file, 'w') { |f|
       save_instruments(f)
+      save_triggers(f)
       save_songs(f)
       save_song_lists(f)
     }
   end
 
   def save_instruments(f)
-    @pm.inputs.each { |sym, instr|
+    @pm.inputs.each do |sym, instr|
       f.puts "input #{instr.port_num}, :#{sym}, #{quoted(instr.name)}"
-    }
-    @pm.outputs.each { |sym, instr|
+    end
+    @pm.outputs.each do |sym, instr|
       f.puts "output #{instr.port_num}, :#{sym}, #{quoted(instr.name)}"
-    }
+    end
+    f.puts
+  end
+
+  def save_triggers(f)
+    @pm.inputs.each do |sym, instrument|
+      instrument.triggers.each do |trigger|
+        str = "trigger :#{sym}, #{trigger.bytes.inspect} #{trigger.text}"
+        f.puts str
+      end
+    end
     f.puts
   end
 
@@ -138,11 +162,11 @@ class DSL
   end
 
   def save_connection(f, conn)
-    in_sym = @pm.inputs.patch(conn.input)
+    in_sym = @pm.inputs.key(conn.input)
     in_chan = conn.input_chan ? conn.input_chan + 1 : 'nil'
-    out_sym = @pm.outputs.patch(conn.output)
+    out_sym = @pm.outputs.key(conn.output)
     out_chan = conn.output_chan + 1
-    f.puts "    conn :#{in_sym}, #{in_chan}, #{out_sym}, #{out_chan} do"
+    f.puts "    conn :#{in_sym}, #{in_chan}, :#{out_sym}, #{out_chan} do"
     f.puts "      prog_chg #{conn.pc_prog}" if conn.pc?
     f.puts "      zone #{conn.note_num_to_name(conn.zone.begin)}, #{conn.note_num_to_name(conn.zone.end)}" if conn.zone
     f.puts "      xpose #{conn.xpose}" if conn.xpose
@@ -185,42 +209,51 @@ class DSL
     end
   end
 
-  # Extremely simple filter text reader. Relies on indentation to detect end
-  # of filter block.
+  def read_triggers(contents)
+    read_block_text('trigger', @triggers, contents)
+  end
+
   def read_filters(contents)
-    i = 0
-    in_filter = false
-    filter_indentation = nil
-    filter_end_token = nil
+    read_block_text('filter', @filters, contents)
+  end
+
+  # Extremely simple block text reader. Relies on indentation to detect end
+  # of code block.
+  def read_block_text(name, containers, contents)
+    i = -1
+    in_block = false
+    block_indentation = nil
+    block_end_token = nil
     contents.each_line do |line|
-      if line =~ /^(\s*)filter\s*(.*)/
-        filter_indentation, text = $1, $2
-        @filters[i].text = text + "\n"
-        in_filter = true
-        filter_end_token = case text
+      if line =~ /^(\s*)#{name}\s*.*?(({|do|->\s*{|lambda\s*{)(.*))/
+        block_indentation, text = $1, $2
+        i += 1
+        containers[i].text = text + "\n"
+        in_block = true
+        block_end_token = case text
                              when /^{/
                                "}"
                              when /^do\b/
                                "end"
-                             when /^lambda\s*({|do)/
-                               $1 == "{" ? "}" : "end"
+                             when /^(->|lambda)\s*({|do)/
+                               $2 == "{" ? "}" : "end"
                              else
                                "}|end" # regex
                              end
-      elsif in_filter
+      elsif in_block
         line =~ /^(\s*)(.*)/
         indentation, text = $1, $2
-        if indentation.length <= filter_indentation.length
-          if text =~ /^#{filter_end_token}/
-            @filters[i].text << line
+        if indentation.length <= block_indentation.length
+          if text =~ /^#{block_end_token}/
+            containers[i].text << line
           end
-          i += 1
-          in_filter = false
+          in_block = false
         else
-          @filters[i].text << line
+          containers[i].text << line
         end
       end
     end
+    containers.each { |thing| thing.text.strip! }
   end
 
 end

data/lib/patchmaster/filter.rb

@@ -16,7 +16,7 @@ class Filter
   end
 
   def to_s
-    @text.gsub("\n", "; ")
+    @text.gsub(/\n\s*/, "; ")
   end
 
 end

data/lib/patchmaster/{io.rb → instrument.rb}

@@ -1,9 +1,11 @@
+require 'midi-eye'
+
 # Ports are UniMIDI inputs or outputs.
 module PM
 
-class MIDIDevice
+class Instrument
 
-  attr_reader :name, :port_num, :port
+  attr_reader :name, :port_num, :port, :listener
 
   def initialize(name, port_num, port)
     @name, @port_num, @port = name, port_num, port
@@ -11,16 +13,17 @@ class MIDIDevice
 
 end
 
-# When a connection is started, it adds itself to this InputDevice's
+# When a connection is started, it adds itself to this InputInstrument's
 # +@connections+. When it ends, it removes itself.
-class InputDevice < MIDIDevice
+class InputInstrument < Instrument
 
-  attr_accessor :connections
+  attr_accessor :connections, :triggers
 
   # If +port+ is nil (the normal case), creates either a real or a mock port
   def initialize(name, port_num, no_midi=false)
     super(name, port_num, input_port(port_num, no_midi))
     @connections = []
+    @triggers = []
   end
 
   def add_connection(conn)
@@ -32,12 +35,22 @@ class InputDevice < MIDIDevice
   end
 
   # Poll for more MIDI input and process it.
-  def gets_data
-    @port.gets_data.each { |bytes| midi_in(bytes) }
+  def start
+    PatchMaster.instance.debug("instrument #{name} start")
+    @port.clear_buffer
+    @listener = MIDIEye::Listener.new(@port).listen_for { |event| midi_in(event[:message].to_bytes) }
+    @listener.run(:background => true)
+  end
+
+  def stop
+    PatchMaster.instance.debug("instrument #{name} stop")
+    @port.clear_buffer
+    @listener.close
   end
 
-  # Passes MIDI bytes on to each output connection
+  # Passes MIDI bytes on to triggers and to each output connection.
   def midi_in(bytes)
+    @triggers.each { |trigger| trigger.signal(bytes) }
     @connections.each { |conn| conn.midi_in(bytes) }
   end
 
@@ -53,7 +66,7 @@ class InputDevice < MIDIDevice
 
 end
 
-class OutputDevice < MIDIDevice
+class OutputInstrument < Instrument
 
   def initialize(name, port_num, no_midi=false)
     super(name, port_num, output_port(port_num, no_midi))
@@ -75,8 +88,8 @@ class OutputDevice < MIDIDevice
 end
 
 class MockInputPort
-  def gets_data
-    []
+  def gets
+    [{:data => [], :timestamp => 0}]
   end
 end
 

data/lib/patchmaster/patch.rb

@@ -2,12 +2,11 @@ module PM
 
 class Patch
 
-  attr_accessor :name, :connections, :start_bytes
+  attr_accessor :name, :connections, :start_bytes, :stop_bytes
 
-  def initialize(name, start_bytes=nil)
-    @name = name
+  def initialize(name, start_bytes=nil, stop_bytes=nil)
+    @name, @start_bytes, @stop_bytes = name, start_bytes, stop_bytes
     @connections = []
-    @start_bytes = start_bytes
     @running = false
   end
 
@@ -19,17 +18,11 @@ class Patch
     @connections.map(&:input).uniq
   end
 
-  # Send start_bytes to each connection, then spawn a new thread that
-  # receives input and passes it on to each connection.
+  # Send start_bytes to each connection.
   def start
-    input_devices = inputs()
-    @connections.each { |conn| conn.start(@start_bytes) }
-    @running = true
-    Thread.new do
-      loop do
-        break unless @running
-        input_devices.map(&:gets_data)
-      end
+    unless @running
+      @connections.each { |conn| conn.start(@start_bytes) }
+      @running = true
     end
   end
 
@@ -37,12 +30,12 @@ class Patch
     @running
   end
 
+  # Send stop_bytes to each connection, then call #stop on each connection.
   def stop
     if @running
       @running = false
-      @connections.map(&:stop)
+      @connections.each { |conn| conn.stop(@stop_bytes) }
     end
   end
 end
-
-end # PM
+end

data/lib/patchmaster/patchmaster.rb

@@ -1,5 +1,7 @@
 require 'singleton'
+require 'delegate'
 require 'patchmaster/sorted_song_list'
+require 'patchmaster/cursor'
 
 module PM
 
@@ -12,157 +14,139 @@ module PM
 #   PatchMaster.instance.start
 #   # ...when you're done
 #   PatchMaster.instance.stop
-class PatchMaster
+class PatchMaster < SimpleDelegator
+
+  DEBUG_FILE = '/tmp/pm_debug.txt'
 
   include Singleton
 
   attr_reader :inputs, :outputs, :all_songs, :song_lists, :no_midi
-  attr_reader :curr_song_list, :curr_song, :curr_patch
+
+  # A Cursor to which we delegate incoming position methods (#song_list,
+  # #song, #patch, #next_song, #prev_patch, etc.)
+  attr_reader :cursor
 
   def initialize
-    init_data
+    @cursor = Cursor.new(self)
+    super(@cursor)
+
+    if $DEBUG
+      @debug_file = File.open(DEBUG_FILE, 'a')
+    end
     @no_midi = false
-    @curr_song_list = @curr_song = @curr_patch = nil
+
+    init_data
   end
 
   def no_midi!
     @no_midi = true
   end
 
+  # Loads +file+. Does its best to restore the current song list, song, and
+  # patch after loading.
   def load(file)
+    restart = running?
     stop
+
+    @cursor.mark
     init_data
     DSL.new(@no_midi).load(file)
+    @loaded_file = file
+    @cursor.restore
+
+    if restart
+      start(false)
+    elsif @cursor.patch
+      @cursor.patch.start
+    end
   rescue => ex
     raise("error loading #{file}: #{ex}\n" + caller.join("\n"))
   end
 
   def save(file)
     DSL.new(@no_midi).save(file)
-    message("saved #{file}")
+    @loaded_file = file
   rescue => ex
-    raise("error saving #{file}: #{ex}")
+    raise("error saving #{file}: #{ex}" + caller.join("\n"))
   end
 
+  # Initializes the cursor and all data.
   def init_data
-    @curr_song_list = @curr_song = @curr_patch = nil
+    @cursor.clear
     @inputs = {}
     @outputs = {}
-    @song_lists = List.new
+    @song_lists = []
     @all_songs = SortedSongList.new('All Songs')
     @song_lists << @all_songs
   end
 
-  def start
-    @curr_song_list = @song_lists.first # sets cursor in @song_lists
-    @curr_song = @curr_song_list.first_song
-    if @curr_song
-      @curr_patch = @curr_song.first_patch
-      @curr_patch.start
-    else
-      @curr_patch = nil
-    end
+  # If +init_cursor+ is +true+ (the default), initializes current song list,
+  # song, and patch.
+  def start(init_cursor = true)
+    @cursor.init if init_cursor
+    @cursor.patch.start if @cursor.patch
+    @running = true
+    @inputs.values.map(&:start)
   end
 
   def stop
-    @curr_patch.stop if @curr_patch
-    @curr_song_list = @curr_song = @curr_patch = nil
+    @cursor.patch.stop if @cursor.patch
+    @inputs.values.map(&:stop)
+    @running = false
   end
 
-  def next_song
-    return unless @curr_song_list
-    return if @curr_song_list.last_song?
-
-    @curr_patch.stop if @curr_patch
-    @curr_song = @curr_song_list.next_song
-    @curr_patch = @curr_song.first_patch
-    @curr_patch.start
+  def running?
+    @running
   end
 
-  def prev_song
-    return unless @curr_song_list
-    return if @curr_song_list.first_song?
-
-    @curr_patch.stop if @curr_patch
-    @curr_song = @curr_song_list.prev_song
-    @curr_patch = @curr_song.first_patch
-    @curr_patch.start
-  end
-
-  def next_patch
-    return unless @curr_song
-    if @curr_song.last_patch?
-      next_song
-    elsif @curr_patch
-      @curr_patch.stop
-      @curr_patch = @curr_song.next_patch
-      @curr_patch.start
+  # Sends the +CM_ALL_NOTES_OFF+ controller message to all output
+  # instruments on all 16 MIDI channels. If +individual_notes+ is +true+
+  # send individual +NOTE_OFF+ messages to all notes as well.
+  def panic(individual_notes=false)
+    debug("panic(#{individual_notes})")
+    @outputs.values.each do |out|
+      MIDI_CHANNELS.times do |chan|
+        out.midi_out([CONTROLLER + chan, CM_ALL_NOTES_OFF, 0])
+        if individual_notes
+          128.times { |note| out.midi_out([NOTE_OFF + chan, note, 0]) }
+        end
+      end
     end
   end
 
-  def prev_patch
-    return unless @curr_song
-    if @curr_song.first_patch?
-      prev_song
-    elsif @curr_patch
-      @curr_patch.stop
-      @curr_patch = @curr_song.prev_patch
-      @curr_patch.start
+  # Opens the most recently loaded/saved file name in an editor. After
+  # editing, the file is re-loaded.
+  def edit
+    editor_command = find_editor
+    unless editor_command
+      message("Can not find $VISUAL, $EDITOR, vim, or vi on your path")
+      return
     end
-  end
-
-  def goto_song(name_regex)
-    new_song_list = new_song = new_patch = nil
-    new_song = @curr_song_list.find(name_regex) if @curr_song_list
-    new_song = @all_songs.find(name_regex) unless new_song
-    new_patch = new_song ? new_song.first_patch : nil
-
-    if (new_song && new_song != @curr_song) || # moved to new song
-        (new_song == @curr_song && @curr_patch != new_patch) # same song but not at same first patch
-
-      @curr_patch.stop if @curr_patch
 
-      if @curr_song_list.songs.include?(new_song)
-        new_song_list = @curr_song_list
-      else
-        # Not found in current song list. Switch to all_songs list.
-        new_song_list = @all_songs
-      end
-      new_song_list.curr_song = new_song # move to that song in selected song list
-
-      @curr_song_list = new_song_list
-      @curr_song = new_song
-      @curr_patch = new_patch
-      @curr_patch.start
-    end
+    cmd = "#{editor_command} #{@loaded_file}"
+    debug(cmd)
+    system(cmd)
+    load(@loaded_file)
   end
 
-  def goto_song_list(name_regex)
-    name_regex = Regexp.new(name_regex.to_s, true) # make case-insensitive
-    new_song_list = @song_lists.detect { |song_list| song_list.name =~ name_regex }
-    return unless new_song_list
-
-    @curr_song_list = new_song_list
-    @song_lists.curr = new_song_list # set cursor
-
-    new_song = @curr_song_list.first_song
-    new_patch = new_song ? new_song.first_patch : nil
-
-    if new_patch != @curr_patch
-      @curr_patch.stop if @curr_patch
-      new_patch.start if new_patch
+  # Return the first legit command from $VISUAL, $EDITOR, vim, vi, and
+  # notepad.exe.
+  def find_editor
+    @editor ||= [ENV['VISUAL'], ENV['EDITOR'], 'vim', 'vi', 'notepad.exe'].compact.detect do |cmd|
+      system('which', cmd) || File.exist?(cmd)
     end
-    @curr_song = new_song
-    @curr_patch = new_patch
   end
 
-  def panic
-    @outputs.values.each do |out|
-      MIDI_CHANNELS.times do |chan|
-        out.midi_out([CONTROLLER + chan, CM_ALL_NOTES_OFF, 0])
-      end
-    end
+  # Output +str+ to @debug_file or $stderr.
+  def debug(str)
+    return unless $DEBUG
+    f = @debug_file || $stderr
+    f.puts str
+    f.flush
   end
 
+  def close_debug_file
+    @debug_file.close if @debug_file
+  end
 end
 end