patchmaster 0.0.0

data/lib/patchmaster/filter.rb

@@ -0,0 +1,23 @@
+module PM
+
+# Filters are blocks of code executed by a Connection to modify incoming
+# MIDI bytes. Since we want to save them to files, we store the text
+# representation as well.
+class Filter
+
+  attr_accessor :block, :text
+
+  def initialize(block, text=nil)
+    @block, @text = block, text
+  end
+
+  def call(conn, bytes)
+    @block.call(conn, bytes)
+  end
+
+  def to_s
+    @text.gsub("\n", "; ")
+  end
+
+end
+end

data/lib/patchmaster/io.rb

@@ -0,0 +1,87 @@
+# Ports are UniMIDI inputs or outputs.
+module PM
+
+class MIDIDevice
+
+  attr_reader :name, :port_num, :port
+
+  def initialize(name, port_num, port)
+    @name, @port_num, @port = name, port_num, port
+  end
+
+end
+
+# When a connection is started, it adds itself to this InputDevice's
+# +@connections+. When it ends, it removes itself.
+class InputDevice < MIDIDevice
+
+  attr_accessor :connections
+
+  # 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 = []
+  end
+
+  def add_connection(conn)
+    @connections << conn
+  end
+
+  def remove_connection(conn)
+    @connections.delete(conn)
+  end
+
+  # Poll for more MIDI input and process it.
+  def gets_data
+    @port.gets_data.each { |bytes| midi_in(bytes) }
+  end
+
+  # Passes MIDI bytes on to each output connection
+  def midi_in(bytes)
+    @connections.each { |conn| conn.midi_in(bytes) }
+  end
+
+  private
+
+  def input_port(port_num, no_midi=false)
+    if no_midi
+      MockInputPort.new
+    else
+      UniMIDI::Input.all[port_num].open
+    end
+  end
+
+end
+
+class OutputDevice < MIDIDevice
+
+  def initialize(name, port_num, no_midi=false)
+    super(name, port_num, output_port(port_num, no_midi))
+  end
+
+  def midi_out(bytes)
+    @port.puts bytes
+  end
+
+  private
+
+  def output_port(port_num, no_midi)
+    if no_midi
+      MockOutputPort.new
+    else
+      UniMIDI::Output.all[port_num].open
+    end
+  end
+end
+
+class MockInputPort
+  def gets_data
+    []
+  end
+end
+
+class MockOutputPort
+  def puts(data)
+  end
+end
+end

data/lib/patchmaster/list.rb

@@ -0,0 +1,121 @@
+module PM
+
+# A list (Array) of things with a cursor. +@curr+ is an integer index into
+# an array of data.
+class List
+
+  include Enumerable
+
+  # If +enter_sym+ or +exit_sym+ are defined, they will be sent to a data
+  # element when it becomes the current element or stops being the current
+  # element.
+  def initialize
+    @data = []
+    @curr = nil
+  end
+
+  # Adding data does not modify the cursor.
+  def <<(data)
+    @data << data
+  end
+
+  # Inserts +data+ before +before_this+. If +before_this+ is not in our
+  # list, +data+ is inserted at the beginning of the list.
+  def insert_before(before_this, data)
+    idx = @data.index(before_this) || 0
+    @data[idx, 0] = data
+  end
+
+  # Inserts +data+ after +after_this+. If +after_this+ is not in our list,
+  # +data+ is inserted at the end of the list.
+  def insert_after(after_this, data)
+    idx = @data.index(after_this) || @data.length-1
+    @data[idx + 1, 0] = data
+  end
+
+  def size
+    @data.size
+  end
+  alias_method :length, :size
+
+  def first?
+    @curr == 0
+  end
+
+  def first
+    if !@data.empty? && @curr != 0
+      @curr = 0
+    end
+    curr
+  end
+
+  def next
+    if @curr == nil || @curr >= @data.length - 1
+      @curr = nil
+    else
+      @curr += 1
+    end
+    curr
+  end
+
+  def curr
+    @curr ? @data[@curr] : nil
+  end
+
+  # This does not change what is stored at the current location. Rather,
+  # it moves this list's cursor to point to +data+ and returns +data+.
+  def curr=(data)
+    if curr != data
+      @curr = @data.index(data)
+    end
+    data
+  end
+
+  # Returns the +n+th data element. This method is not normally used to
+  # access data because it does not change the cursor. It is used to peek
+  # into the list's data array, for example during testing.
+  def [](n)
+    @data[n]
+  end
+
+  def prev
+    if @curr == nil || @curr == 0
+      @curr = nil
+    else
+      @curr -= 1
+    end
+    curr
+  end
+
+  def last
+    if !@data.empty? && !last?
+      @curr = @data.length - 1
+    end
+    curr
+  end
+
+  def last?
+    @curr == nil || @curr == @data.length - 1
+  end
+
+  def remove(data)
+    return unless @data.include?(data)
+    @data[@data.index(data), 1] = []
+    if @data.empty?
+      @curr = nil
+    elsif @curr >= @data.length
+      @curr = @data.length - 1
+    end
+  end
+
+  def each
+    @data.each { |data| yield data }
+  end
+
+  # For debugging
+  def to_s
+    "List(#{@data.empty? ? 'empty' : @data[0].class.name}), size #{size}, curr index #{@curr}"
+  end
+
+end
+end

data/lib/patchmaster/list_container.rb

@@ -0,0 +1,36 @@
+module PM
+
+# A ListContainer responds to messages that manipulate the cursors for one
+# or more List objects.
+module ListContainer
+
+  def method_missing(sym, *args)
+    case sym.to_s
+    when /^curr_(\w+)=$/
+      name = $1
+      ivar_sym = "@#{pluralize(name)}".to_sym
+      raise "no such ivar #{ivar_sym} in #{self.class}" unless instance_variable_defined?(ivar_sym)
+      instance_variable_get(ivar_sym).send(:curr=, args[0])
+    when /^(first|next|prev|curr|last)_(\w+)(\?)?$/
+      method, ivar, qmark = $1, $2, $3
+      ivar_sym = "@#{pluralize(ivar)}".to_sym
+      raise "no such ivar #{ivar_sym} in #{self.class}" unless instance_variable_defined?(ivar_sym)
+      instance_variable_get(ivar_sym).send("#{method}#{qmark}".to_sym)
+    else
+      super
+    end
+  end
+
+  def pluralize(str)
+    case str
+    when /s$/, /ch$/
+      "#{str}es"
+    when /y$/
+      "#{str[0..-2]}ies}"
+    else
+      "#{str}s"
+    end
+  end
+
+end
+end

data/lib/patchmaster/patch.rb

@@ -0,0 +1,48 @@
+module PM
+
+class Patch
+
+  attr_accessor :name, :connections, :start_bytes
+
+  def initialize(name, start_bytes=nil)
+    @name = name
+    @connections = []
+    @start_bytes = start_bytes
+    @running = false
+  end
+
+  def <<(conn)
+    @connections << conn
+  end
+
+  def inputs
+    @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.
+  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
+    end
+  end
+
+  def running?
+    @running
+  end
+
+  def stop
+    if @running
+      @running = false
+      @connections.map(&:stop)
+    end
+  end
+end
+
+end # PM

data/lib/patchmaster/patchmaster.rb

@@ -0,0 +1,168 @@
+require 'singleton'
+require 'patchmaster/sorted_song_list'
+
+module PM
+
+# Global behavior: master list of songs, list of song lists, stuff like
+# that.
+#
+# Typical use:
+#
+#   PatchMaster.instance.load("my_pm_dsl_file")
+#   PatchMaster.instance.start
+#   # ...when you're done
+#   PatchMaster.instance.stop
+class PatchMaster
+
+  include Singleton
+
+  attr_reader :inputs, :outputs, :all_songs, :song_lists, :no_midi
+  attr_reader :curr_song_list, :curr_song, :curr_patch
+
+  def initialize
+    init_data
+    @no_midi = false
+    @curr_song_list = @curr_song = @curr_patch = nil
+  end
+
+  def no_midi!
+    @no_midi = true
+  end
+
+  def load(file)
+    stop
+    init_data
+    DSL.new(@no_midi).load(file)
+  rescue => ex
+    raise("error loading #{file}: #{ex}\n" + caller.join("\n"))
+  end
+
+  def save(file)
+    DSL.new(@no_midi).save(file)
+    message("saved #{file}")
+  rescue => ex
+    raise("error saving #{file}: #{ex}")
+  end
+
+  def init_data
+    @curr_song_list = @curr_song = @curr_patch = nil
+    @inputs = {}
+    @outputs = {}
+    @song_lists = List.new
+    @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
+  end
+
+  def stop
+    @curr_patch.stop if @curr_patch
+    @curr_song_list = @curr_song = @curr_patch = nil
+  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
+  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
+    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
+    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
+  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
+    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
+  end
+
+end
+end