qcmd 0.1.0

data/lib/qcmd/commands.rb

@@ -0,0 +1,103 @@
+module Qcmd
+  module Commands
+    # Commands that expect reponses
+    MACHINE_RESPONSE = %w(workspaces)
+
+    WORKSPACE_RESPONSE = %w(
+      cueLists selectedCues runningCues runningOrPausedCues connect thump
+    )
+
+    # commands that always expect a response
+    CUE_RESPONSE = %w(
+      uniqueID hasFileTargets hasCueTargets allowsEditingDuration isLoaded
+      isRunning isPaused isBroken preWaitElapsed actionElapsed
+      postWaitElapsed percentPreWaitElapsed percentActionElapsed
+      percentPostWaitElapsed type
+      basics children
+    )
+
+    # commands that expect a response if given without args
+    NO_ARG_CUE_RESPONSE = %w(
+      number name notes cueTargetNumber cueTargetId preWait duration
+      postWait continueMode flagged armed colorName
+    )
+
+    class << self
+      def machine_response_matcher
+        @machine_response_matcher ||= %r[(#{MACHINE_RESPONSE.join('|')})]
+      end
+      def machine_response_match command
+        !!(machine_response_matcher =~ command)
+      end
+
+      def workspace_response_matcher
+        @workspace_response_matcher ||= %r[(#{WORKSPACE_RESPONSE.join('|')})]
+      end
+      def workspace_response_match command
+        !!(workspace_response_matcher =~ command)
+      end
+
+      def cue_response_matcher
+        @cue_response_matcher ||= %r[(#{CUE_RESPONSE.join('|') })]
+      end
+      def cue_response_match command
+        !!(cue_response_matcher =~ command)
+      end
+
+      def cue_no_arg_response_matcher
+        @cue_no_arg_response_matcher ||= %r[(#{NO_ARG_CUE_RESPONSE.join('|') })]
+      end
+      def cue_no_arg_response_match command
+        !!(cue_no_arg_response_matcher =~ command)
+      end
+
+      def expects_reply? osc_message
+        address = osc_message.address
+
+        Qcmd.debug "(check #{address} for reply expectation in connection state #{Qcmd.context.connection_state})"
+
+        # debugger
+
+        case Qcmd.context.connection_state
+        when :none
+          # shouldn't be dealing with OSC messages when unconnected to
+          # machine or workspace
+          response = false
+        when :machine
+          # could be workspace or machine command
+          response = machine_response_match(address) ||
+                     workspace_response_match(address)
+        when :workspace
+          if is_cue_command?(address)
+            Qcmd.debug "- (checking cue command)"
+            if osc_message.has_arguments?
+              Qcmd.debug "- (with arguments)"
+              response = cue_response_match address
+            else
+              Qcmd.debug "- (without arguments)"
+              response = cue_no_arg_response_match(address) ||
+                         cue_response_match(address)
+            end
+          else
+            Qcmd.debug "- (checking workspace command)"
+            response = workspace_response_match(address) ||
+                       machine_response_match(address)
+          end
+        end
+
+        response.tap {|value|
+          msg = value ? "EXPECT REPLY" : "do not expect reply"
+          Qcmd.debug "- (#{ msg })"
+        }
+      end
+
+      def is_cue_command? address
+        /cue/ =~ address && !(/Lists/ =~ address || /Cues/ =~ address)
+      end
+
+      def is_workspace_command? address
+        /workspace/ =~ address && !(%r[cue/] =~ address || %r[cue_id/] =~ address)
+      end
+    end
+  end
+end

data/lib/qcmd/context.rb

@@ -0,0 +1,37 @@
+module Qcmd
+  class Context
+    attr_accessor :machine, :workspace, :workspace_connected
+
+    def reset
+      disconnect_machine
+      disconnect_workspace
+    end
+
+    def disconnect_machine
+      self.machine = nil
+    end
+
+    def disconnect_workspace
+      self.workspace = nil
+      self.workspace_connected = false
+    end
+
+    def machine_connected?
+      !machine.nil?
+    end
+
+    def workspace_connected?
+      !!workspace_connected
+    end
+
+    def connection_state
+      if !machine_connected?
+        :none
+      elsif !workspace_connected?
+        :machine
+      else
+        :workspace
+      end
+    end
+  end
+end

data/lib/qcmd/core_ext/array.rb

@@ -0,0 +1,6 @@
+# borrowed from ActiveSupport
+class Array
+  def extract_options!
+    last.is_a?(Hash) ? pop : {}
+  end
+end

data/lib/qcmd/core_ext/osc/message.rb

@@ -0,0 +1,7 @@
+module OSC
+  class Message
+    def has_arguments?
+      to_a.size > 0
+    end
+  end
+end

data/lib/qcmd/handler.rb

@@ -0,0 +1,80 @@
+module Qcmd
+  class Handler
+    include Qcmd::Plaintext
+
+    def handle reply
+      Qcmd.debug "(handling #{ reply })"
+
+      case reply.address
+      when %r[/workspaces]
+        Qcmd.context.machine.workspaces = reply.data.map {|ws| Qcmd::QLab::Workspace.new(ws)}
+
+        print centered_text(" Workspaces ", '-')
+        print
+        Qcmd.context.machine.workspaces.each_with_index do |ws, n|
+          print "#{ n + 1 }. #{ ws.name }"
+        end
+
+        print
+        print wrapped_text('Type `use "WORKSPACE_NAME" PASSCODE` to load a workspace. ' +
+                           'Only enter a passcode if your workspace uses one')
+        print
+
+      when %r[/workspace/[^/]+/connect]
+        # connecting to a workspace
+        if reply.data == 'badpass'
+          print 'failed to connect to workspace'
+          Qcmd.context.disconnect_workspace
+        elsif reply.data == 'ok'
+          print 'connected to workspace'
+          Qcmd.context.workspace_connected = true
+        end
+
+      when %r[/cueLists]
+        Qcmd.debug "(received cueLists)"
+
+        # load global cue list
+        Qcmd.context.workspace.cues = cues = reply.data.map {|cue_list|
+          cue_list['cues'].map {|cue| Qcmd::QLab::Cue.new(cue)}
+        }.compact.flatten
+
+        print "loaded #{pluralize cues.size, 'cue'}"
+
+      when %r[/(selectedCues|runningCues|runningOrPausedCues)]
+        cues = reply.data.map {|cue|
+          cues = [Qcmd::QLab::Cue.new(cue)]
+
+          if cue['cues']
+            cues << cue['cues'].map {|cue| Qcmd::QLab::Cue.new(cue)}
+          end
+
+          cues
+        }.compact.flatten
+
+        title = case reply.address
+                when /selectedCues/;        "Selected Cues"
+                when /runningCues/;         "Running Cues"
+                when /runningOrPausedCues/; "Running or Paused Cues"
+                end
+
+        print
+        print centered_text(" #{title} ", '-')
+        table(['Number', 'Id', 'Name', 'Type'], cues.map {|cue|
+          [cue.number, cue.id, cue.name, cue.type]
+        })
+        print
+
+      when %r[/(cue|cue_id)/[^/]+/[a-zA-Z]+]
+        # properties, just print reply data
+        result = reply.data
+        if result.is_a?(String) || result.is_a?(Numeric)
+          print result
+        else
+          print result.inspect
+        end
+      else
+        Qcmd.debug "(unrecognized message from QLab, cannot handle #{ reply.address })"
+      end
+    end
+  end
+end

data/lib/qcmd/input_completer.rb

@@ -0,0 +1,67 @@
+require 'readline'
+
+module Qcmd
+  module InputCompleter
+    ReservedWords = %w[
+      connect exit workspace workspaces disconnect
+    ]
+
+    ReservedWorkspaceWords = %w[
+      cueLists selectedCues runningCues runningOrPausedCues thump
+    ]
+
+    ReservedCueWords = %w[
+      cue stop pause resume load preview reset panic loadAt uniqueID
+      hasFileTargets hasCueTargets allowsEditingDuration isLoaded isRunning
+      isPaused isBroken preWaitElapsed actionElapsed postWaitElapsed
+      percentPreWaitElapsed percentActionElapsed percentPostWaitElapsed
+      type number name notes cueTargetNumber cueTargetId preWait duration
+      postWait continueMode flagged armed colorName basics children
+    ]
+
+    CompletionProc = Proc.new {|input|
+      # puts "input: #{ input }"
+
+      matcher  = /^#{Regexp.escape(input)}/
+      commands = ReservedWords.grep(matcher)
+
+      if Qcmd.connected? && Qcmd.context
+        # have selected a machine
+        if Qcmd.context.workspace_connected?
+          # have selected a workspace
+          cue_numbers = Qcmd.context.workspace.cues.map(&:number)
+          commands    = commands +
+                        cue_numbers.grep(matcher) +
+                        ReservedCueWords.grep(matcher) +
+                        ReservedWorkspaceWords.grep(matcher)
+        else
+          # haven't selected a workspace yet
+          names           = Qcmd.context.machine.workspace_names
+          quoted_names    = names.map {|wn| %["#{wn}"]}
+          workspace_names = (names + quoted_names).grep(matcher)
+          workspace_names = workspace_names.map {|wsn|
+            if / / =~ wsn && /"/ !~ wsn
+              # if workspace name has a space and is not already quoted
+              %["#{ wsn }"]
+            else
+              wsn
+            end
+          }
+          commands = commands + workspace_names
+        end
+      else
+        # haven't selected a machine yet
+        commands = commands + Qcmd::Network.names.grep(matcher)
+      end
+
+      commands
+    }
+  end
+end
+
+if Readline.respond_to?("basic_word_break_characters=")
+  Readline.basic_word_break_characters= " \t\n`><=;|&{("
+end
+Readline.completion_append_character = nil
+Readline.completion_case_fold = true
+Readline.completion_proc = Qcmd::InputCompleter::CompletionProc

data/lib/qcmd/machine.rb

@@ -0,0 +1,27 @@
+module Qcmd
+  class Machine < Struct.new(:name, :address, :port)
+    def client_arguments
+      [address, port]
+    end
+
+    def client_string
+      "#{ address }:#{ port }"
+    end
+
+    def workspaces= val
+      @workspaces = val
+    end
+
+    def workspaces
+      @workspaces || []
+    end
+
+    def workspace_names
+      @workspaces.map(&:name) || []
+    end
+
+    def find_workspace name
+      @workspaces.find {|ws| ws.name == name}
+    end
+  end
+end

data/lib/qcmd/network.rb

@@ -0,0 +1,70 @@
+require 'dnssd'
+
+module Qcmd
+  class Network
+    BROWSE_TIMEOUT = 2
+
+    class << self
+      attr_accessor :machines, :browse_thread
+
+      def browse
+        self.machines = []
+        self.browse_thread = Thread.start do
+          DNSSD.browse! '_qlab._udp' do |b|
+            DNSSD.resolve b.name, b.type, b.domain do |r|
+              self.machines << Qcmd::Machine.new(b.name, r.target, r.port)
+            end
+          end
+        end
+
+        naps = 0
+        changed = false
+        previous = 0
+
+        # sleep for 3 seconds
+        while naps < BROWSE_TIMEOUT
+          sleep 1
+          naps += 1
+
+          if machines.size != previous
+            Qcmd.print
+            Qcmd.print "Found #{ machines.size } QLab machine#{ machines.size == 1 ? '' : 's'}"
+            Qcmd.print
+            previous = machines.size
+          end
+        end
+
+        Thread.kill(browse_thread) if browse_thread.alive?
+      end
+
+      def display
+        longest = machines.map {|m| m.name.size}.max
+
+        machines.each_with_index do |machine, n|
+          if Qcmd.debug?
+            Qcmd.print "#{ n + 1 }. %-#{ longest + 2 }s %s" % [machine.name, machine.client_string]
+          else
+            Qcmd.print "#{ n + 1 }. %-#{ longest + 2 }s" % [machine.name]
+          end
+        end
+
+        Qcmd.print
+        Qcmd.print 'type `connect MACHINE` to connect to a machine'
+        Qcmd.print
+      end
+
+      def browse_and_display
+        browse
+        display
+      end
+
+      def find machine_name
+        machines.find {|m| m.name == machine_name}
+      end
+
+      def names
+        machines.map(&:name)
+      end
+    end
+  end
+end

data/lib/qcmd/parser.rb

@@ -0,0 +1,48 @@
+module Qcmd
+  module Parser
+    class << self
+      # adapted from https://gist.github.com/612311
+      # by Aaron Gough
+      def extract_string_literals( string )
+        string_literal_pattern = /"([^"\\]|\\.)*"/
+        string_replacement_token = "___+++STRING_LITERAL+++___"
+        # Find and extract all the string literals
+        string_literals = []
+        string.gsub(string_literal_pattern) {|x| string_literals << x}
+        # Replace all the string literals with our special placeholder token
+        string = string.gsub(string_literal_pattern, string_replacement_token)
+        # Return the modified string and the array of string literals
+        return [string, string_literals]
+      end
+
+      def tokenize_string( string )
+        string = string.gsub("(", " ( ")
+        string = string.gsub(")", " ) ")
+        token_array = string.split(" ")
+        return token_array
+      end
+
+      def restore_string_literals( token_array, string_literals )
+        return token_array.map do |x|
+          if(x == '___+++STRING_LITERAL+++___')
+            # Since we've detected that a string literal needs to be
+            # replaced we will grab the first available string from the
+            # string_literals array
+            string_literals.shift
+          else
+            # This is not a string literal so we need to just return the
+            # token as it is
+            x
+          end
+        end
+      end
+
+      def parse( string )
+        string, string_literals = extract_string_literals(string)
+        token_array = tokenize_string(string)
+        token_array = restore_string_literals(token_array, string_literals)
+        return token_array
+      end
+    end
+  end
+end