qcmd 0.1.0

data/lib/qcmd/plaintext.rb

@@ -0,0 +1,116 @@
+module Qcmd
+  module Plaintext
+    def log message=nil
+      if message
+        puts message
+      else
+        puts
+      end
+    end
+
+    # always output
+    def print message=nil
+      log(message)
+    end
+
+    def columns
+      begin
+        `stty size`.split.last.to_i
+      rescue
+        80
+      end
+    end
+
+    def pluralize n, word
+      "#{n} #{n == 1 ? word : word + 's'}"
+    end
+
+    def word_wrap(text, options={})
+      options = {
+        :line_width => columns
+      }.merge options
+
+      text.split("\n").collect do |line|
+        line.length > options[:line_width] ? line.gsub(/(.{1,#{options[:line_width]}})(\s+|$)/, "\\1\n").strip : line
+      end * "\n"
+    end
+
+    def ascii_qlab
+      ['    .::::    .::                .::      ',
+       '  .::    .:: .::                .::      ',
+       '.::       .::.::         .::    .::      ',
+       '.::       .::.::       .::  .:: .:: .::  ',
+       '.::       .::.::      .::   .:: .::   .::',
+       '  .:: .: .:: .::      .::   .:: .::   .::',
+       '    .:: ::   .::::::::  .:: .:::.:: .::  ',
+       '         .:                              '].map {|line|
+        print centered_text(line)
+      }
+    end
+
+    def joined_wrapped_text line
+      wrapped_text(line).join "\n"
+    end
+
+    # turn line into lines of text of columns length
+    def wrapped_text line
+      word_wrap(line, :line_width => columns).split("\n")
+    end
+
+    def right_text line
+      diff = [(columns - line.size), 0].max
+      "%s%s" % [' ' * diff, line]
+    end
+
+    def centered_text line, char=' '
+      if line.size > columns && line.split(' ').all? {|chunk| chunk.size < columns}
+        # wrap the text then center each line, then join
+        return wrapped_text(line).map {|l| centered_text(l, char)}.join("\n")
+      end
+
+      diff = (columns - line.size)
+
+      return line if diff < 0
+
+      lpad = diff / 2
+      rpad = diff - lpad
+
+      "%s%s%s" % [char * lpad, line, char * rpad]
+    end
+
+    def split_text left, right
+      diff = columns - left.size
+      if (diff - right.size) < 0
+        left_lines = wrapped_text(left)
+        diff = columns - left_lines.last.size
+
+        # still?
+        if (diff - right.size) < 0
+          diff = ''
+          right = "\n" + right_text(right)
+        end
+
+        left = left_lines.join "\n"
+      end
+      "%s%#{diff}s" % [left, right]
+    end
+
+    def table headers, rows
+      print
+      columns = headers.map(&:size)
+      rows.each do |row|
+        columns.each_with_index do |col, n|
+          columns[n] = [col, row[n].size].max + 1
+        end
+      end
+
+      row_format = columns.map {|n| "%#{n}s\t"}.join('')
+      print row_format % headers
+      print
+      rows.each do |row|
+        print row_format % row
+      end
+      print
+    end
+  end
+end

data/lib/qcmd/qlab.rb

@@ -0,0 +1,3 @@
+require 'qcmd/qlab/cue'
+require 'qcmd/qlab/reply'
+require 'qcmd/qlab/workspace'

data/lib/qcmd/qlab/cue.rb

@@ -0,0 +1,70 @@
+module Qcmd
+  module QLab
+    #  All return an array of cue dictionaries:
+    #
+    #  [
+    #      {
+    #          "uniqueID": string,
+    #          "number": string
+    #          "name": string
+    #          "type": string
+    #          "colorName": string
+    #          "flagged": number
+    #          "armed": number
+    #      }
+    #  ]
+    #  If the cue is a group, the dictionary will include an array of cue dictionaries for all children in the group:
+    #
+    #  [
+    #      {
+    #          "uniqueID": string,
+    #          "number": string
+    #          "name": string
+    #          "type": string
+    #          "colorName": string
+    #          "flagged": number
+    #          "armed": number
+    #          "cues": [ { }, { }, { } ]
+    #      }
+    #  ]
+    #
+    #  [{\"number\":\"\",
+    #    \"uniqueID\":\"1\",
+    #    \"cues\":[{\"number\":\"1\",
+    #    \"uniqueID\":\"2\",
+    #    \"flagged\":false,
+    #    \"type\":\"Wait\",
+    #    \"colorName\":\"none\",
+    #    \"name\":\"boom\",
+    #    \"armed\":true}],
+    #    \"flagged\":false,
+    #    \"type\":\"Group\",
+    #    \"colorName\":\"none\",
+    #    \"name\":\"Main Cue List\",
+    #    \"armed\":true}]
+
+    class Cue
+      attr_accessor :data
+
+      def initialize options={}
+        self.data = options
+      end
+
+      def id
+        data['uniqueID']
+      end
+
+      def name
+        data['name']
+      end
+
+      def number
+        data['number']
+      end
+
+      def type
+        data['type']
+      end
+    end
+  end
+end

data/lib/qcmd/qlab/reply.rb

@@ -0,0 +1,25 @@
+module Qcmd
+  module QLab
+    class Reply < Struct.new(:osc_message)
+      def json
+        @json ||= JSON.parse(osc_message.to_a.first)
+      end
+
+      def address
+        @address ||= json['address']
+      end
+
+      def data
+        @data ||= json['data']
+      end
+
+      def is_cue_command?
+        Qcmd::Commands.is_cue_command?(address)
+      end
+
+      def to_s
+        "<Qcmd::Qlab::Reply address:'#{address}' data:#{data.inspect}>"
+      end
+    end
+  end
+end

data/lib/qcmd/qlab/workspace.rb

@@ -0,0 +1,28 @@
+module Qcmd
+  module QLab
+    #
+    #   "uniqueID": string,
+    #   "displayName": string
+    #   "hasPasscode": number
+    #
+    class Workspace
+      attr_accessor :data, :passcode, :cue_lists, :cues
+
+      def initialize options={}
+        self.data = options
+      end
+
+      def name
+        data['displayName']
+      end
+
+      def passcode?
+        !!data['hasPasscode']
+      end
+
+      def id
+        data['uniqueID']
+      end
+    end
+  end
+end

data/lib/qcmd/server.rb

@@ -0,0 +1,178 @@
+require 'osc-ruby'
+require 'osc-ruby/em_server'
+require 'ruby-debug'
+
+require 'json'
+
+module Qcmd
+  class TimeoutError < Exception; end
+
+  class Server
+    attr_accessor :receive_channel, :receive_thread, :receive_port, :send_channel, :machine
+
+    def initialize *args
+      options = args.extract_options!
+
+      self.receive_port = options[:receive]
+      connect_to_client
+
+      @handler = Qcmd::Handler.new
+      @sent_messages = []
+      @sent_messages_expecting_reply = []
+      @received_messages = []
+    end
+
+    def connect_to_client
+      self.machine = Qcmd.context.machine
+      self.send_channel = OSC::Client.new machine.address, machine.port
+
+      Qcmd.debug '(setting up listening connection)'
+      listen
+    end
+
+    def generic_responding_proc
+      proc do |osc_message|
+        @received_messages << osc_message
+
+        begin
+          Qcmd.debug "(received message: #{ osc_message.address })"
+          reply_received QLab::Reply.new(osc_message)
+        rescue => ex
+          Qcmd.debug "(ERROR #{ ex.message })"
+        end
+      end
+    end
+
+    # initialize
+    def listen
+      if receive_channel
+        Qcmd.debug "(stopping existing server)"
+        stop
+      end
+
+      self.receive_channel = OSC::EMServer.new(self.receive_port)
+
+      Qcmd.debug "(opening receiving channel: #{ self.receive_channel.inspect })"
+
+      receive_channel.add_method %r{/reply/?(.*)}, &generic_responding_proc
+    end
+
+    def replies_expected?
+      @sent_messages_expecting_reply.size > 0
+    end
+
+    def reply_received reply
+      Qcmd.debug "(receiving #{ reply })"
+
+      # update world state
+      begin
+        @handler.handle reply
+      rescue => ex
+        print "(ERROR: #{ ex.message })"
+      end
+
+      # FIFO
+      @sent_messages_expecting_reply.shift
+
+      Qcmd.debug "(#{ @sent_messages_expecting_reply.size } messages awaiting reply)"
+    end
+
+    def wait_for_replies
+      begin
+        yield
+
+        naps = 0
+        while replies_expected? do
+          if naps > 20
+            # FAILED TO GET RESPONSE
+            raise TimeoutError.new
+          end
+
+          naps += 1
+          sleep 0.1
+        end
+      rescue TimeoutError => ex
+        Qcmd.log "[error: reply timeout]"
+        # clear expecting reply item, assume it will never arrive
+        @sent_messages_expecting_reply.shift
+      end
+    end
+
+    def send_command command, *args
+      options = args.extract_options!
+
+      Qcmd.debug "(building command from command, args, options: #{ command.inspect }, #{ args.inspect }, #{ options.inspect })"
+
+      # make sure command is valid OSC Address
+      if %r[^/] =~ command
+        address = command
+      else
+        address = "/#{ command }"
+      end
+
+      osc_message = OSC::Message.new address, *args
+
+      send_message osc_message
+    end
+
+    def send_message osc_message
+      Qcmd.debug "(sending osc message #{ osc_message.address } #{osc_message.has_arguments? ? 'with' : 'without'} args)"
+
+      @sent_messages << osc_message
+      if Qcmd::Commands.expects_reply?(osc_message)
+        Qcmd.debug "(this command expects a reply)"
+        @sent_messages_expecting_reply << osc_message
+      end
+
+      wait_for_replies do
+        send_channel.send osc_message
+      end
+    end
+
+    def stop
+      Thread.kill(receive_thread) if receive_thread.alive?
+    end
+
+    def run
+      Qcmd.debug '(starting server)'
+      self.receive_thread = Thread.new do
+        Qcmd.debug '(server is up)'
+        receive_channel.run
+      end
+    end
+    alias :start :run
+
+    def send_workspace_command _command, *args
+      command = "workspace/#{ Qcmd.context.workspace.id }/#{ _command }"
+      send_command(command, *args)
+    end
+
+    def send_cue_command number, action, *args
+      command = "cue/#{ number }/#{ action }"
+      send_workspace_command(command, *args)
+    end
+
+    ## QLab commands
+
+    def load_workspaces
+      send_command 'workspaces'
+    end
+
+    def load_cues
+      send_workspace_command 'cueLists'
+    end
+
+    def connect_to_workspace workspace
+      if workspace.passcode?
+        send_command "workspace/#{workspace.id}/connect", workspace.passcode
+      else
+        send_command "workspace/#{workspace.id}/connect"
+      end
+
+      # if it worked, load cues automatically
+      if Qcmd.context.workspace
+        load_cues
+      end
+    end
+  end
+end

data/lib/qcmd/version.rb

@@ -0,0 +1,3 @@
+module Qcmd
+  VERSION = "0.1.0"
+end

data/qcmd.gemspec

@@ -0,0 +1,30 @@
+# -*- encoding: utf-8 -*-
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'qcmd/version'
+
+Gem::Specification.new do |gem|
+  gem.name          = "qcmd"
+  gem.version       = Qcmd::VERSION
+  gem.authors       = ["Adam Bachman"]
+  gem.email         = ["adam.bachman@gmail.com"]
+  gem.description   = %q{A simple interactive QLab 3 command line controller}
+  gem.summary       = %q{QLab 3 console}
+  gem.homepage      = "https://github.com/abachman/qcmd"
+
+  gem.files         = `git ls-files`.split($/)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.require_paths = ["lib"]
+
+  gem.add_runtime_dependency 'dnssd'
+  gem.add_runtime_dependency 'eventmachine'
+  gem.add_runtime_dependency 'json'
+  gem.add_runtime_dependency 'osc-ruby'
+  gem.add_runtime_dependency 'trollop'
+
+  gem.add_development_dependency "rspec"
+  gem.add_development_dependency "cucumber"
+  gem.add_development_dependency "aruba"
+  gem.add_development_dependency 'ruby-debug'
+end