patchmaster 0.0.6 → 1.0.0

data/bin/patchmaster

@@ -1,6 +1,6 @@
 #!/usr/bin/env ruby
 #
-# usage: patchmaster [-n] [-d] [pm_file]
+# usage: patchmaster [-n] [-i] [-w] [-p port] [-t] [-d] [pm_file]
 #
 # Starts PatchMaster and optionally loads pm_file.
 #
@@ -8,24 +8,60 @@
 # being able to connect to the MIDI instruments specified in pm_file are
 # ignored, and no MIDI data is sent/received. That is useful if you want to
 # run PatchMaster without actually talking to any MIDI instruments.
+#
+# To run PatchMaster from within an IRB session use -i. See the
+# documentation for details on the commands that are available.
+#
+# To run PatchMaster using a Web browser GUI use -w and point your browser
+# at http://localhost:4567. To change the port, use -p.
+#
+# To run PatchMaster without a GUI use -t. All output will go to the
+# console. The app will run until interrupted. (If you do this, you might
+# want to create a trigger that calls `panic', because you won't be able to
+# use the computer keyboard to do that.)
+#
+# The =-d= flag turns on debug mode. The app becomes slightly more verbose
+# and logs everything to `/tmp/pm_debug.txt'.
+
 
 require 'optparse'
 
 use_midi = true
-use_gui = true
+gui = :curses
+port = nil
 OptionParser.new do |opts|
   opts.banner = "usage: patchmaster [options] [pm_file]"
   opts.on("-d", "--debug", "Turn on debug mode") { $DEBUG = true }
   opts.on("-n", "--no-midi", "Turn off MIDI processing") { use_midi = false }
-  opts.on("-t", "--text", "--nw", "--no-window", "No windows") { use_gui = false }
+  opts.on("-i", "--irb", "Use an IRB console") { gui = :irb }
+  opts.on("-w", "--web", "Use a Web browser GUI") { gui = :web }
+  opts.on("-p", "--port PORT", "Web browser GUI port number") { |opt| port = opt.to_i }
+  opts.on("-t", "--text", "--nw", "--no-window", "No windows") { gui = :text }
+  opts.on_tail("-h", "-?", "--help", "Show this message") do
+    puts opts
+    exit 0
+  end
 end.parse!(ARGV)
 
 # Must require patchmaster here, after handling options, because Singleton
 # initialize code checks $DEBUG.
 require 'patchmaster'
 
-app = use_gui ? PM::Main.instance : PM::PatchMaster.instance
-app.no_gui! if !use_gui
-app.no_midi! if !use_midi
-app.load(ARGV[0]) if ARGV[0]
-app.run
+pm = PM::PatchMaster.instance
+pm.use_midi = use_midi
+pm.load(ARGV[0]) if ARGV[0]
+case gui
+when :curses
+  require 'patchmaster/curses/main'
+  pm.gui = PM::Main.instance
+  pm.run
+when :irb
+  require 'patchmaster/irb'
+  start_patchmaster_irb
+when :web
+  require 'patchmaster/web/sinatra_app'
+  app = PM::SinatraApp.instance
+  app.port = port if port
+  pm.gui = app
+  pm.run
+end

data/lib/patchmaster.rb

@@ -9,4 +9,3 @@ require 'patchmaster/instrument'
 require 'patchmaster/patchmaster'
 require 'patchmaster/trigger'
 require 'patchmaster/dsl'
-require 'patchmaster/app/main'

data/lib/patchmaster/connection.rb

@@ -89,6 +89,7 @@ class Connection
     str << "; pc #@pc_prog" if pc?
     str << "; xpose #@xpose" if @xpose
     str << "; zone #{note_num_to_name(@zone.begin)}..#{note_num_to_name(@zone.end)}" if @zone
+    str
   end
 end
 

data/lib/patchmaster/{app → curses}/list_window.rb

@@ -1,4 +1,4 @@
-require 'patchmaster/app/pm_window'
+require 'patchmaster/curses/pm_window'
 
 module PM
 class ListWindow < PmWindow

data/lib/patchmaster/{app → curses}/main.rb

@@ -1,6 +1,6 @@
 require 'curses'
 require 'singleton'
-%w(list patch info trigger prompt).each { |w| require "patchmaster/app/#{w}_window" }
+%w(list patch info trigger prompt).each { |w| require "patchmaster/curses/#{w}_window" }
 
 module PM
 
@@ -20,10 +20,6 @@ class Main
     @message_bindings = {}
   end
 
-  def no_midi!
-    @pm.no_midi!
-  end
-
   def run
     @pm.start
     begin

data/lib/patchmaster/{app → curses}/patch_window.rb

@@ -1,4 +1,4 @@
-require 'patchmaster/app/pm_window'
+require 'patchmaster/curses/pm_window'
 
 module PM
 class PatchWindow < PmWindow

data/lib/patchmaster/dsl.rb

@@ -7,18 +7,23 @@ class DSL
 
   include PM
 
-  def initialize(no_midi=false)
-    @no_midi = no_midi
+  def initialize
     @pm = PatchMaster.instance
+    init
   end
 
-  def load(file)
-    contents = IO.read(file)
+  # Initialize state used for reading.
+  def init
     @inputs = {}
     @outputs = {}
     @triggers = []
     @filters = []
     @songs = {}                 # key = name, value = song
+  end
+
+  def load(file)
+    contents = IO.read(file)
+    init
     instance_eval(contents)
     read_triggers(contents)
     read_filters(contents)
@@ -27,22 +32,22 @@ class DSL
   def input(port_num, sym, name=nil)
     raise "input: two inputs can not have the same symbol (:#{sym})" if @inputs[sym]
 
-    input = InputInstrument.new(sym, name, port_num, @no_midi)
+    input = InputInstrument.new(sym, name, port_num, @pm.use_midi?)
     @inputs[sym] = input
     @pm.inputs << input
   rescue => ex
-    raise "input: error creating input instrument \"#{name}\" on input port #{port_num}: #{ex}"
+    raise "input: error creating input instrument \"#{name || sym}\" on input port #{port_num}: #{ex}"
   end
-  alias_method :in, :input
+  alias_method :inp, :input
 
   def output(port_num, sym, name=nil)
     raise "output: two outputs can not have the same symbol (:#{sym})" if @outputs[sym]
 
-    output = OutputInstrument.new(sym, name, port_num, @no_midi)
+    output = OutputInstrument.new(sym, name, port_num, @pm.use_midi?)
     @outputs[sym] = output
     @pm.outputs << output
   rescue => ex
-    raise "output: error creating output instrument \"#{name}\" on output port #{port_num}: #{ex}"
+    raise "output: error creating output instrument \"#{name || sym}\" on output port #{port_num}: #{ex}"
   end
   alias_method :out, :output
 
@@ -51,8 +56,8 @@ class DSL
   end
 
   def message_key(name, key_or_sym)
-    if !@pm.no_gui              # TODO get rid of double negative
-      PM::Main.instance.bind_message(name, key_or_sym)
+    if @pm.gui
+      @pm.gui.bind_message(name, key_or_sym)
     end
   end
 
@@ -84,9 +89,15 @@ class DSL
     @patch.stop_bytes = bytes
   end
 
-  def connection(in_sym, in_chan, out_sym, out_chan)
+  # in_chan can be skipped, so "connection :foo, :bar, 1" is the same as
+  # "connection :foo, nil, :bar, 1".
+  def connection(in_sym, in_chan, out_sym, out_chan=nil)
     input = @inputs[in_sym]
-    in_chan = nil if in_chan == :all || in_chan == :any
+    if in_chan.kind_of? Symbol
+      out_chan = out_sym
+      out_sym = in_chan
+      in_chan = nil
+    end
     raise "can't find input instrument #{in_sym}" unless input
     output = @outputs[out_sym]
     raise "can't find outputput instrument #{out_sym}" unless output
@@ -266,7 +277,7 @@ class DSL
         end
       end
     end
-    containers.each { |thing| thing.text.strip! }
+    containers.each { |thing| thing.text.strip! if thing.text }
   end
 
 end

data/lib/patchmaster/filter.rb

@@ -16,7 +16,7 @@ class Filter
   end
 
   def to_s
-    @text.gsub(/\n\s*/, "; ")
+    (@text || '# no block text found').gsub(/\n\s*/, "; ")
   end
 
 end

data/lib/patchmaster/instrument.rb

@@ -22,8 +22,8 @@ class InputInstrument < Instrument
   attr_reader :listener
 
   # If +port+ is nil (the normal case), creates either a real or a mock port
-  def initialize(sym, name, port_num, no_midi=false)
-    super(sym, name, port_num, input_port(port_num, no_midi))
+  def initialize(sym, name, port_num, use_midi=true)
+    super(sym, name, port_num, input_port(port_num, use_midi))
     @connections = []
     @triggers = []
   end
@@ -61,11 +61,11 @@ class InputInstrument < Instrument
 
   private
 
-  def input_port(port_num, no_midi=false)
-    if no_midi
-      MockInputPort.new(port_num)
-    else
+  def input_port(port_num, use_midi=true)
+    if use_midi
       UniMIDI::Input.all[port_num].open
+    else
+      MockInputPort.new(port_num)
     end
   end
 
@@ -73,8 +73,8 @@ end
 
 class OutputInstrument < Instrument
 
-  def initialize(sym, name, port_num, no_midi=false)
-    super(sym, name, port_num, output_port(port_num, no_midi))
+  def initialize(sym, name, port_num, use_midi=true)
+    super(sym, name, port_num, output_port(port_num, use_midi))
   end
 
   def midi_out(bytes)
@@ -83,11 +83,11 @@ class OutputInstrument < Instrument
 
   private
 
-  def output_port(port_num, no_midi)
-    if no_midi
-      MockOutputPort.new(port_num)
-    else
+  def output_port(port_num, use_midi)
+    if use_midi
       UniMIDI::Output.all[port_num].open
+    else
+      MockOutputPort.new(port_num)
     end
   end
 end

data/lib/patchmaster/irb.rb

@@ -0,0 +1,82 @@
+require 'patchmaster'
+require 'irb'
+require 'tempfile'
+
+$dsl = nil
+
+# For bin/patchmaster. Does nothing
+def run
+end
+
+def dsl
+  unless $dsl
+    $dsl = PM::DSL.new
+    $dsl.song("IRB Song")
+    $dsl.patch("IRB Patch")
+  end
+  $dsl
+end
+
+def patch
+  dsl.instance_variable_get(:@patch)
+end
+
+def clear
+  patch.stop
+  patch.connections = []
+  patch.start
+end
+
+def pm_help
+  puts <<EOS
+input  num, :sym[, name]                          define an input instrument
+output num, :sym[, name]                          define an output instrument
+conn :in_sym, [chan|nil], :out_sym, [chan|nil]    create a connection
+xpose num                                         set transpose for conn
+zone zone_def                                     set zone for conn
+clear                                             remove all connections
+panic                                             panic
+panic!                                            panic plus note-offs
+EOS
+end
+
+def panic!
+  PM::PatchMaster.instance.panic(true)
+end
+
+def method_missing(sym, *args)
+  pm = PM::PatchMaster.instance
+  if dsl.respond_to?(sym)
+    patch.stop
+    dsl.send(sym, *args)
+    if sym == :input || sym == :inp
+      pm.inputs.last.start
+    end
+    patch.start
+  elsif pm.respond_to?(sym)
+    pm.send(sym, *args)
+  else
+    super
+  end
+end
+
+def start_patchmaster_irb
+  f = Tempfile.new('patchmaster')
+  f.write <<EOS
+  IRB.conf[:PROMPT][:CUSTOM] = {
+    :PROMPT_I=>"PatchMaster:%03n:%i> ",
+    :PROMPT_N=>"PatchMaster:%03n:%i> ",
+    :PROMPT_S=>"PatchMaster:%03n:%i%l ",
+    :PROMPT_C=>"PatchMaster:%03n:%i* ",
+    :RETURN=>"=> %s\n"
+  }
+  IRB.conf[:PROMPT_MODE] = :CUSTOM
+
+  puts 'PatchMaster loaded'
+  puts 'Type "pm_help" for help'
+EOS
+  f.close
+  ENV['IRBRC'] = f.path
+  IRB.start
+  f.unlink
+end

data/lib/patchmaster/patchmaster.rb

@@ -22,7 +22,9 @@ class PatchMaster < SimpleDelegator
 
   attr_reader :inputs, :outputs, :all_songs, :song_lists
   attr_reader :messages
-  attr_reader :no_midi, :no_gui
+  attr_accessor :use_midi
+  alias_method :use_midi?, :use_midi
+  attr_accessor :gui
 
   # A Cursor to which we delegate incoming position methods (#song_list,
   # #song, #patch, #next_song, #prev_patch, etc.)
@@ -31,8 +33,8 @@ class PatchMaster < SimpleDelegator
   def initialize
     @cursor = Cursor.new(self)
     super(@cursor)
-    @no_midi = false
-    @no_gui = false
+    @use_midi = true
+    @gui = nil
 
     if $DEBUG
       @debug_file = File.open(DEBUG_FILE, 'a')
@@ -41,10 +43,6 @@ class PatchMaster < SimpleDelegator
     init_data
   end
 
-  def no_midi!
-    @no_midi = true
-  end
-
   def no_gui!
     @no_gui = true
   end
@@ -57,7 +55,8 @@ class PatchMaster < SimpleDelegator
 
     @cursor.mark
     init_data
-    DSL.new(@no_midi).load(file)
+    DSL.new.load(file)
+    @loaded_file = file
     @cursor.restore
 
     if restart
@@ -70,7 +69,8 @@ class PatchMaster < SimpleDelegator
   end
 
   def save(file)
-    DSL.new(@no_midi).save(file)
+    DSL.new.save(file)
+    @loaded_file = file
   rescue => ex
     raise("error saving #{file}: #{ex}" + caller.join("\n"))
   end
@@ -102,16 +102,20 @@ class PatchMaster < SimpleDelegator
     @running = false
   end
 
-  # Run PatchMaster without the GUI. Don't use this when using PM::Main.
-  #
-  # Call #start, wait for inputs' MIDIEye listener threads to finish, then
-  # call #stop. Note that normally nothing stops those threads, so this is
-  # used as a way to make sure the script doesn't quit until killed by
-  # something like SIGINT.
+  # Run PatchMaster without the GUI. Don't use this when using PM::Main. If
+  # there is a GUI then forward this request to it. Otherwise, call #start,
+  # wait for inputs' MIDIEye listener threads to finish, then call #stop.
+  # Note that normally nothing stops those threads, so this is used as a way
+  # to make sure the script doesn't quit until killed by something like
+  # SIGINT.
   def run
-    start(true)
-    @inputs.each { |input| input.listener.join }
-    stop
+    if @gui
+      @gui.run
+    else
+      start(true)
+      @inputs.each { |input| input.listener.join }
+      stop
+    end
   end
 
   def running?