qcmd 0.1.7 → 0.1.8

data/lib/qcmd/commands.rb

@@ -7,138 +7,143 @@ module Qcmd
     # *_RESPONSE lists are commands that expect responses
     #
 
-    NO_MACHINE_RESPONSE = %w(connect)
-
-    MACHINE_RESPONSE = %w(workspaces)
-
-    WORKSPACE_RESPONSE = %w(
-      cueLists selectedCues runningCues runningOrPausedCues thump
+    MACHINE = %w(
+      alwaysReply
+      connect
+      workingDirectory
+      workspaces
     )
 
-    WORKSPACE_NO_RESPONSE = %w(
-      go stop pause resume reset panic
+    WORKSPACE = %w(
+      cueLists
+      go
+      hardStop
+      new
+      panic
+      pause
+      reset
+      resume
+      runningCues
+      runningOrPausedCues
+      select
+      selectedCues
+      stop
+      thump
+      toggleFullScreen
+      updates
     )
 
-    ALL_WORKSPACE_COMMANDS = [WORKSPACE_RESPONSE + WORKSPACE_NO_RESPONSE]
-
     # commands that take no args and do not respond
-    CUE_NO_RESPONSE = %w(
-      start stop pause resume load preview reset panic
-    )
-
-    # commands that take args but do not respond
-    CUE_ARG_NO_RESPONSE = %w(
+    CUE = %w(
+      actionElapsed
+      allowsEditingDuration
+      armed
+      children
+      colorName
+      continueMode
+      cueTargetId
+      cueTargetNumber
+      defaultName
+      displayName
+      duration
+      fileTarget
+      flagged
+      hardStop
+      hasCueTargets
+      hasFileTargets
+      isBroken
+      isLoaded
+      isPaused
+      isRunning
+      listName
+      load
       loadAt
+      name
+      notes
+      number
+      panic
+      pause
+      percentActionElapsed
+      percentPostWaitElapsed
+      percentPreWaitElapsed
+      postWait
+      postWaitElapsed
+      preWait
+      preWaitElapsed
+      preview
+      reset
+      resume
+      sliderLevel
+      sliderLevels
+      start
+      stop
+      togglePause
+      type
+      uniqueID
+      valuesForKeys
     )
 
-    # commands that always expect a response
-    CUE_RESPONSE = %w(
-      uniqueID hasFileTargets hasCueTargets allowsEditingDuration isLoaded
-      isRunning isPaused isBroken preWaitElapsed actionElapsed
-      postWaitElapsed percentPreWaitElapsed percentActionElapsed
-      percentPostWaitElapsed type sliderLevels
-      basics children
+    GROUP_CUE = %w(
+      playbackPositionId
     )
 
-    # commands that take args but expect a response if given without args
-    NO_ARG_CUE_RESPONSE = %w(
-      number name notes cueTargetNumber cueTargetId preWait duration
-      postWait continueMode flagged armed colorName
+    AUDIO_CUE = %w(
+      doFade
+      doPitchShift
+      endTime
+      infiniteLoop
+      level
+      patch
+      playCount
+      rate
       sliderLevel
+      sliderLevels
+      startTime
     )
 
-    # all cue commands that take arguments
-    CUE_ARG = CUE_ARG_NO_RESPONSE + NO_ARG_CUE_RESPONSE
-
-    ALL_CUE_COMMANDS = CUE_NO_RESPONSE +
-                       CUE_ARG_NO_RESPONSE +
-                       CUE_RESPONSE +
-                       NO_ARG_CUE_RESPONSE
-
-    class << self
-      def no_machine_response_matcher
-        @no_machine_response_matcher ||= %r[(#{NO_MACHINE_RESPONSE.join('|')})]
-      end
-      def no_machine_response_match command
-        !!(no_machine_response_matcher =~ command)
-      end
-
-      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 = no_machine_response_match(address)
-        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
+    FADE_CUE = %w(
+      level
+      sliderLevel
+      sliderLevels
+    )
 
-        response.tap {|value|
-          msg = value ? "EXPECT REPLY" : "do not expect reply"
-          Qcmd.debug "- (#{ msg })"
-        }
-      end
+    MIC_CUE = %w(
+      level
+      sliderLevel
+      sliderLevels
+    )
 
-      def is_cue_command? address
-        /cue/ =~ address && !(/Lists/ =~ address || /Cues/ =~ address)
-      end
+    VIDEO_CUE = %w(
+      cueSize
+      doEffect
+      doFade
+      doPitchShift
+      effect
+      effectSet
+      endTime
+      fullScreen
+      infiniteLoop
+      layer
+      level
+      opacity
+      patch
+      playCount
+      preserveAspectRatio
+      quaternion
+      rate
+      scaleX
+      scaleY
+      sliderLevel
+      sliderLevels
+      startTime
+      surfaceID
+      surfaceList
+      surfaceSize
+      translationX
+      translationY
+    )
 
-      def is_workspace_command? address
-        /workspace/ =~ address && !(%r[cue/] =~ address || %r[cue_id/] =~ address)
-      end
-    end
+    ALL_CUES = (CUE + GROUP_CUE + AUDIO_CUE + FADE_CUE + MIC_CUE + VIDEO_CUE).uniq.sort
 
     module Help
       class << self
@@ -147,43 +152,49 @@ module Qcmd
           Qcmd.print %[
 #{Qcmd.centered_text(' Available Commands ', '-')}
 
+
 exit
 
-  close qcmd
+  Close qcmd.
 
 
-connect MACHINE_NAME
+connect MACHINE_ID
 
-  connect to the machine with name MACHINE_NAME
+  Connect to the machine with id MACHINE_ID. This can either be the name of the
+  machine shown in the listing or its number on the list. Once a machine is
+  connected its name will appear above the prompt.
 
 
 disconnect
 
-  disconnect from the current machine and workspace
+  Disconnect from the current machine and workspace.
+
+
+..
+
+  Disconnect cue if one is connected. If not, disconnect the current workspace.
+  If one is not connected, disconnect from the machine.
 
 
 use WORKSPACE_NAME [PASSCODE]
 
-  connect to the workspace with name WORKSPACE_NAME using passcode PASSCODE. A
-  passcode is only required if the workspace has one enabled.
+  Connect to the workspace with name WORKSPACE_NAME given as a double quoted
+  string using passcode PASSCODE. A passcode is only required if the workspace
+  has one enabled. Once a workspace is connected its name will appear above the
+  prompt.
 
 
 workspaces
 
-  show a list of the available workspaces for the currently connected machine.
+  Show a list of the available workspaces for the currently connected machine.
 
 
 workspace COMMAND [VALUE]
 
-  pass the given COMMAND to the connected workspace. The following commands will
-  act on a workspace but will not return a value:
+  Pass the given COMMAND to the connected workspace. The following commands will
+  act on a workspace:
 
-    #{Qcmd.wrapped_text(Qcmd::Commands::WORKSPACE_NO_RESPONSE.sort.join(', '), :indent => '    ').join("\n")}
-
-  And these commands will not act on a workspace, but will return a value
-  (usually a list of cues):
-
-    #{Qcmd.wrapped_text((Qcmd::Commands::WORKSPACE_RESPONSE - ['connect']).sort.join(', '), :indent => '    ').join("\n")}
+    #{Qcmd.wrapped_text(Qcmd::Commands::WORKSPACE.sort.join(', '), :indent => '    ').join("\n")}
 
   * Pro Tip: once you are connected to a workspace, you can just use COMMAND
   and leave off "workspace" to quickly send the given COMMAND to the connected
@@ -192,27 +203,72 @@ workspace COMMAND [VALUE]
 
 cue NUMBER COMMAND [VALUE [ANOTHER_VALUE ...]]
 
-  send a command to the cue with the given NUMBER.
+  or
+
+cue_id ID COMMAND [VALUE [ANOTHER_VALUE ...]]
+
+  Send a command to the cue with the given NUMBER or ID depending on the way
+  you are addressing the cue.
 
-  NUMBER can be a string or a number, depending on the command.
+  NUMBER can be a double quoted string or a number, depending on the command.
 
   COMMAND can be one of:
 
-    #{Qcmd.wrapped_text(Qcmd::Commands::ALL_CUE_COMMANDS.sort.join(', '), :indent => '    ').join("\n")}
+    #{Qcmd.wrapped_text(Qcmd::Commands::CUE.sort.join(', '), :indent => '    ').join("\n")}
+
+  Specific types of cues may have different cues available. Here's the commands
+  available for different types of cues:
+
+  Group Cue:
+
+    #{Qcmd.wrapped_text(Qcmd::Commands::GROUP_CUE.sort.join(', '), :indent => '    ').join("\n")}
+
+  Audio Cue:
+
+    #{Qcmd.wrapped_text(Qcmd::Commands::AUDIO_CUE.sort.join(', '), :indent => '    ').join("\n")}
+
+  Fade Cue:
+
+    #{Qcmd.wrapped_text(Qcmd::Commands::FADE_CUE.sort.join(', '), :indent => '    ').join("\n")}
+
+  Mic Cue:
+
+    #{Qcmd.wrapped_text(Qcmd::Commands::MIC_CUE.sort.join(', '), :indent => '    ').join("\n")}
+
+  Video Cue:
+
+    #{Qcmd.wrapped_text(Qcmd::Commands::VIDEO_CUE.sort.join(', '), :indent => '    ').join("\n")}
+
+  Once a command has been sent to an existing cue, subsequent cue commands will
+  be sent to the same cue with needing to repeat the leading "cue NUMBER". Once
+  a cue is connected its name will appear above the prompt.
+
+
+alias COMMAND ACTION
+
+  Create a new command to use in qcmd! COMMAND should be a single word,
+  starting with made of one or more letters, numbers, underscores, and/or
+  hyphens. ACTION should be a legit qcmd program surrounded by parentheses,
+  which is anything you can type into qcmd. If you want your command to accept
+  arguments, use $1, $2, ...  $n in place of the argument.
+
+  For example:
+
+    > alias cue-rename (cue $1 name "Hello $2")
+
+  Would create a new command, "cue-rename", that you could use to rename a cue:
 
-  Of those commands, only some accept a VALUE. The following commands, if given
-  a value, will update the cue:
+    > cue-rename 10 World
 
-    #{Qcmd.wrapped_text(Qcmd::Commands::CUE_ARG.sort.join(', '), :indent => '    ').join("\n")}
+  to rename cue number 10 to "Hello World".
 
-  Some cues are Read-Only and will return information about a cue:
+  We've included a few custom commands so you can see how it works. Aliases are
+  stored in ~/.qcmd/settings.json and can be edited from there.
 
-    #{Qcmd.wrapped_text(Qcmd::Commands::CUE_RESPONSE.sort.join(', '), :indent => '    ').join("\n")}
 
-  Finally, some commands act on a cue, but don't take a VALUE and don't
-  respond:
+aliases
 
-    #{Qcmd.wrapped_text(Qcmd::Commands::CUE_NO_RESPONSE.sort.join(', '), :indent => '    ').join("\n")}
+  See all the aliases.
 
 ]
         end

data/lib/qcmd/configuration.rb

@@ -0,0 +1,83 @@
+require 'fileutils'
+
+module Qcmd
+  class Configuration
+    class << self
+      def qcmd_directory
+        ".qcmd"
+      end
+
+      def home_directory
+        @home_directory ||= begin
+                              full_path = File.join(File.expand_path('~'), qcmd_directory)
+                              begin
+                                if !File.exists?(full_path)
+                                  FileUtils.mkdir_p(full_path)
+                                end
+                                full_path
+                              rescue => ex
+                                puts "Failed to create qcmd's home directory at #{ full_path }"
+                                puts ex.message
+
+                                exit 1
+                              end
+                            end
+      end
+
+      def open_file_for_appending(fname)
+         f = File.new(fname, 'a')
+         f.sync = true
+         f
+      end
+
+      def config
+        @config ||= begin
+                      if !File.exists?(config_file)
+                        File.open(config_file, 'w') {|f|
+                          default = JSON.pretty_generate({'aliases' => Qcmd::Aliases.defaults})
+                          Qcmd.debug "[Configuration config] writing defaults: #{ default }"
+                          f.write default
+                        }
+                      end
+
+                      JSON.load(File.open(config_file))
+                    end
+      end
+
+      def update key, value
+        config[key] = value
+        save
+      end
+
+      def save
+        File.open(config_file, 'w') {|conf_file|
+          conf_file.write(JSON.pretty_generate(config))
+        }
+      end
+
+      # not really config file things, but related to config & settings storage
+
+      def history
+        @history ||= open_file_for_appending(history_file)
+      end
+
+      def log
+        @log ||= open_file_for_appending(log_file)
+      end
+
+      # and the actual files
+
+      def config_file
+        File.join(home_directory, "settings.json")
+      end
+
+      def history_file
+        File.join(home_directory, "history.log")
+      end
+
+      def log_file
+        File.join(home_directory, "debug.log")
+      end
+    end
+  end
+end