qcmd 0.1.8 → 0.1.9

data/CHANGELOG.md

@@ -0,0 +1,18 @@
+### 0.1.8 -> 0.1.9
+
+* add "alias" command to help
+* add "new" command to create new cues in QLab
+* add "select" command to allow selection of a given cue (by number)
+  * `select 2; go` would select and start the QLab workspace at the given cue
+* allow IPv4 machine addresses
+
+Internals:
+* set default log level to `:info`
+* separate machine connection and workspace loading
+* simplify `send_workspace_command` method, clean up `send_command`
+* add list of cue types for "new" command
+* unify simple reply handling in CLI
+* fix `-c "COMMAND"` command line option
+* various small bug fixes
+
+

data/bin/qcmd

@@ -3,6 +3,8 @@
 require 'qcmd'
 require 'trollop'
 
+# require 'profile'
+
 VERSION_STRING =  "qcmd #{ Qcmd::VERSION } (c) 2012 Figure 53, Baltimore, MD."
 
 opts = Trollop::options do
@@ -15,6 +17,8 @@ opts = Trollop::options do
   opt :command, "Execute a single command and exit", :type => :string
 end
 
+Qcmd.log_level = :info
+
 if opts[:verbose]
   Qcmd.log_level = :debug
 end
@@ -27,21 +31,32 @@ end
 # browse local network and check for qlab + qlab workspaces
 
 Qcmd::History.load
+Qcmd::Network.init
 
 if !opts[:machine_given]
   Qcmd.ascii_qlab
   Qcmd.print
   Qcmd.print Qcmd.centered_text(VERSION_STRING)
-
   Qcmd::Network.browse_and_display opts
 else
-  Qcmd::Network.browse
+  if Qcmd::Network::IPV4_MATCHER =~ opts[:machine]
+    Qcmd.debug "[bin/qcmd] given machine name matches IP address pattern"
+  elsif opts[:machine] == 'localhost'
+    opts[:machine] = '127.0.0.1'
+  else
+    Qcmd.debug "[bin/qcmd] browsing network #{ opts[:machine] }"
+    Qcmd::Network.browse
+  end
 end
 
 if opts[:command_given] && !(opts[:machine_given] && opts[:workspace_given])
   Qcmd.print_wrapped("if you give a command, you must also give a
                       machine name and a workspace name to connect to")
+elsif opts[:command_given] && opts[:machine_given] && opts[:workspace_given]
+  opts[:command_mode] = true
 end
 
-
+# Profiler__::start_profile
 Qcmd::CLI.launch opts
+# Profiler__::stop_profile
+# Profiler__::print_profile($stderr)

data/lib/qcmd.rb

@@ -33,10 +33,23 @@ module Qcmd
   class << self
     include Qcmd::Plaintext
 
-    attr_accessor :log_level
     attr_accessor :debug_mode
     attr_accessor :context
 
+    LEVELS = %w(debug info warning error none)
+
+    def log_level
+      @log_level ||= :info
+    end
+
+    def log_level=(value)
+      if LEVELS.include?(value.to_s)
+        @log_level = value
+      else
+        raise "Invalid log_level value: #{ value.to_s }"
+      end
+    end
+
     def verbose!
       self.log_level = :debug
     end
@@ -73,7 +86,11 @@ module Qcmd
 
       Qcmd::Configuration.log.puts "[%s] %s" % [Time.now.strftime('%T'), message]
 
-      log(message) if log_level == :debug
+      log(:debug, message)
+    end
+
+    def log_level_acheived? level
+      LEVELS.index(level.to_s) >= LEVELS.index(log_level.to_s)
     end
 
     def connected?

data/lib/qcmd/action.rb

@@ -87,7 +87,7 @@ module Qcmd
     end
 
     def osc_arguments
-      code[1..-1]
+      stringify code[1..-1]
     end
 
     # the raw command
@@ -100,6 +100,7 @@ module Qcmd
     def send_message
       responses = []
 
+      Qcmd.debug "[Action send_message] send #{ osc_message.encode }"
       Qcmd.context.qlab.send(osc_message) do |response|
         # puts "response to: #{ osc_message.inspect }"
         # puts response.inspect
@@ -120,6 +121,20 @@ module Qcmd
         responses
       end
     end
+
+    def stringify args
+      if args.nil?
+        nil
+      else
+        args.map {|arg|
+          if arg.is_a?(Symbol)
+            arg.to_s
+          else
+            arg
+          end
+        }
+      end
+    end
   end
 
   class CueAction < Action
@@ -133,18 +148,7 @@ module Qcmd
     end
 
     def osc_arguments
-      args = code[3..-1]
-      if args.nil?
-        nil
-      else
-        args.map {|arg|
-          if arg.is_a?(Symbol)
-            arg.to_s
-          else
-            arg
-          end
-        }
-      end
+      stringify code[3..-1]
     end
 
     # cue specific fields

data/lib/qcmd/cli.rb

@@ -23,22 +23,25 @@ module Qcmd
           connect_to_machine_by_name(options[:machine])
         end
 
+        load_workspaces
+
         if options[:workspace_given]
-          Qcmd.debug "[CLI initialize] autoconnecting to workspace #{ options[:machine] }"
+          Qcmd.debug "[CLI initialize] autoconnecting to workspace #{ options[:workspace] }"
 
           Qcmd.while_quiet do
             connect_to_workspace_by_name(options[:workspace], options[:workspace_passcode])
           end
 
           if options[:command_given]
-            handle_input options[:command]
-            print %[sent command "#{ options[:command] }"]
-            exit 0
+            handle_input Qcmd::Parser.parse(options[:command])
+            return
           end
         elsif Qcmd.context.machine.workspaces.size == 1 &&
               !Qcmd.context.machine.workspaces.first.passcode? &&
               !Qcmd.context.workspace_connected?
-          connect_to_workspace_by_index(0, nil)
+          if !connect_default_workspace
+            Handler.print_workspace_list
+          end
         end
       end
 
@@ -79,7 +82,7 @@ module Qcmd
         if arg.is_a?(Array)
           replace_args(arg, original_expression)
         elsif (arg.is_a?(Symbol) || arg.is_a?(String)) && alias_arg_matcher =~ arg.to_s
-          while alias_arg_matcher  =~ arg.to_s
+          while alias_arg_matcher =~ arg.to_s
             arg_idx = $1.to_i
             arg_val = original_expression[arg_idx]
 
@@ -141,7 +144,7 @@ module Qcmd
       ["#{clock} #{prefix.join(' ')}", "> "]
     end
 
-    def connect machine
+    def connect_machine machine
       if machine.nil?
         print "A valid machine is needed to connect!"
         return
@@ -157,18 +160,10 @@ module Qcmd
       # tell QLab to always reply to messages
       response = Qcmd::Action.evaluate('/alwaysReply 1')
       if response.nil? || response.empty?
-        print %[Failed to connect to QLab machine "#{ machine.name }"]
+        log(:error, %[Failed to connect to QLab machine "#{ machine.name }"])
       elsif response.status == 'ok'
         print %[Connected to machine "#{ machine.name }"]
       end
-
-      machine.workspaces = Qcmd::Action.evaluate('workspaces').map {|ws| QLab::Workspace.new(ws)}
-
-      if Qcmd.context.machine.workspaces.size == 1 && !Qcmd.context.machine.workspaces.first.passcode?
-        connect_to_workspace_by_index(0, nil)
-      else
-        Handler.print_workspace_list
-      end
     end
 
     def disconnected_machine_warning
@@ -183,20 +178,29 @@ module Qcmd
     end
 
     def connect_to_machine_by_name machine_name
-      if machine = Qcmd::Network.find(machine_name)
-        print "Connecting to machine: #{machine_name}"
-        connect machine
+      machine = nil
+
+      # machine name can be found or IPv4 address is given
+      if Qcmd::Network.find(machine_name)
+        machine = Qcmd::Network.find(machine_name)
+      elsif Qcmd::Network::IPV4_MATCHER  =~ machine_name
+        machine = Qcmd::Machine.new(machine_name, machine_name, 53000)
+      end
+
+      if machine.nil?
+        log(:warning, 'Sorry, that machine could not be found')
       else
-        print 'Sorry, that machine could not be found'
+        print "Connecting to machine: #{machine_name}"
+        connect_machine machine
       end
     end
 
     def connect_to_machine_by_index machine_idx
       if machine = Qcmd::Network.find_by_index(machine_idx)
         print "Connecting to machine: #{machine.name}"
-        connect machine
+        connect_machine machine
       else
-        print 'Sorry, that machine could not be found'
+        log(:warning, 'Sorry, that machine could not be found')
       end
     end
 
@@ -208,7 +212,7 @@ module Qcmd
           print "That workspace isn't on the list."
         end
       else
-        print %[You can't connect to a workspace until you've connected to a machine. ]
+        log(:warning, %[You can't connect to a workspace until you've connected to a machine. ])
         disconnected_machine_warning
       end
     end
@@ -218,16 +222,15 @@ module Qcmd
         if workspace = Qcmd.context.machine.find_workspace(workspace_name)
           workspace.passcode = passcode
           print "Connecting to workspace: #{workspace_name}"
-
           use_workspace workspace
         else
-          print "That workspace doesn't seem to exist, try one of the following:"
+          log(:warning, "That workspace doesn't seem to exist, try one of the following:")
           Qcmd.context.machine.workspaces.each do |ws|
-            print %[  "#{ ws.name }"]
+            log(:warning, %[  "#{ ws.name }"])
           end
         end
       else
-        print %[You can't connect to a workspace until you've connected to a machine. ]
+        log(:warning, %[You can't connect to a workspace until you've connected to a machine. ])
         disconnected_machine_warning
       end
     end
@@ -248,7 +251,7 @@ module Qcmd
       reply = Qcmd::Action.evaluate(ws_action_string)
 
       if reply == 'badpass'
-        print 'Failed to connect to workspace, bad passcode or no passcode given.'
+        log(:error, 'Failed to connect to workspace, bad passcode or no passcode given.')
         Qcmd.context.disconnect_workspace
       elsif reply == 'ok'
         print %[Connected to "#{Qcmd.context.workspace.name}"]
@@ -284,7 +287,7 @@ module Qcmd
         begin
           if /;/ =~ cli_input
             cli_input.split(';').each do |sub_input|
-              handle_input Qcmd::Parser.parse(sub_input)
+              handle_input Qcmd::Parser.parse(sub_input.strip)
             end
           else
             handle_input Qcmd::Parser.parse(cli_input)
@@ -300,6 +303,8 @@ module Qcmd
     def handle_input args
       command = args[0].to_s
 
+      Qcmd.debug "[CLI handle_input] command: #{ command }; args: #{ args.inspect }"
+
       case command
       when 'exit', 'quit', 'q'
         print 'exiting...'
@@ -318,6 +323,12 @@ module Qcmd
           connect_to_machine_by_name machine_ident
         end
 
+        load_workspaces
+
+        if !connect_default_workspace
+          Handler.print_workspace_list
+        end
+
       when 'disconnect'
         disconnect_what = args[1]
 
@@ -382,18 +393,12 @@ module Qcmd
           print_wrapped("no workspace command given. available workspace commands
                          are: #{Qcmd::InputCompleter::ReservedWorkspaceWords.join(', ')}")
         else
-          send_workspace_command(workspace_command, *args)
+          reply = send_workspace_command(workspace_command, *args)
+          handle_simple_reply reply
         end
 
       when 'help'
-        help_command = args.shift
-
-        if help_command.nil?
-          # print help according to current context
-          Qcmd::Commands::Help.print_all_commands
-        else
-          # print command specific help
-        end
+        Qcmd::Commands::Help.print_all_commands
 
       when 'cues'
         if !Qcmd.context.workspace_connected?
@@ -441,33 +446,9 @@ module Qcmd
         cue_action = Qcmd::CueAction.new(args)
 
         reply = cue_action.evaluate
+        handle_simple_reply reply
 
-        if reply.is_a?(QLab::Reply)
-          if !reply.status.nil?
-            print reply.status
-          end
-        else
-          render_data reply
-        end
-
-        # fixate on cue
-        if Qcmd.context.workspace.has_cues?
-          _cue = Qcmd.context.workspace.cues.find {|cue|
-            case cue_action.id_field
-            when :cue
-              cue.number.to_s == cue_action.identifier.to_s
-            when :cue_id
-              cue.id.to_s == cue_action.identifier.to_s
-            end
-          }
-
-          if _cue
-            Qcmd.context.cue = _cue
-            Qcmd.context.cue_connected = true
-
-            Qcmd.context.cue.sync
-          end
-        end
+        fixate_on_cue(cue_action)
 
       when 'aliases'
         print centered_text(" Available Custom Commands ", '-')
@@ -483,6 +464,38 @@ module Qcmd
         new_alias = add_alias(args[1].to_s, args[2])
         print %[Added alias for "#{ args[1] }": #{ new_alias }]
 
+      when 'new'
+        # create new cue
+
+        if !(args.size == 2 && QLab::Cue::TYPES.include?(args.last.to_s))
+          log(:warning, "That cue type can't be created, try one of the following:")
+          log(:warning, joined_wrapped(QLab::Cue::TYPES.join(", ")))
+        else
+          reply = send_workspace_command(command, *args)
+          handle_simple_reply reply
+        end
+
+      when 'select'
+
+        if args.size == 2
+          reply = send_workspace_command "#{ args[0] }/#{ args[1] }"
+
+          if reply.respond_to?(:status) && reply.status == 'ok'
+            # cue exists, get name and fixate
+            cue_action = Qcmd::CueAction.new([:cue, args[1], :name])
+            reply = cue_action.evaluate
+            if reply.is_a?(QLab::Reply)
+              # something went wrong
+              handle_simple_reply reply
+            else
+              print "Selected #{args[1]} - #{reply}"
+              fixate_on_cue(cue_action)
+            end
+          end
+        else
+          log(:warning, "The select command should be in the form `select CUE_NUMBER`.")
+        end
+
       else
         if aliases[command]
           Qcmd.debug "[CLI handle_input] using alias #{ command }"
@@ -509,7 +522,6 @@ module Qcmd
             handle_input(new_expression)
           end
 
-
         elsif Qcmd.context.cue_connected? && Qcmd::InputCompleter::ReservedCueWords.include?(command)
           # prepend the given command with a cue address
           if Qcmd.context.cue.number.nil? || Qcmd.context.cue.number.size == 0
@@ -523,31 +535,18 @@ module Qcmd
           cue_action = Qcmd::CueAction.new(args)
 
           reply = cue_action.evaluate
+          handle_simple_reply reply
 
-          if reply.is_a?(QLab::Reply)
-            if !reply.status.nil?
-              print reply.status
-            end
-          else
-            render_data reply
-          end
-
-          # send_workspace_command(command, *args)
         elsif Qcmd.context.workspace_connected? && Qcmd::InputCompleter::ReservedWorkspaceWords.include?(command)
-          send_workspace_command(command, *args)
+          reply = send_workspace_command(command, *args)
+          handle_simple_reply reply
 
         else
           # failure modes?
           if %r[/] =~ command
             # might be legit OSC command, try sending
             reply = Qcmd::Action.evaluate(args)
-            if reply.is_a?(QLab::Reply)
-              if !reply.status.nil?
-                print reply.status
-              end
-            else
-              render_data reply
-            end
+            handle_simple_reply reply
           else
             if Qcmd.context.cue_connected?
               # cue is connected, but command isn't a valid cue command
@@ -557,7 +556,9 @@ module Qcmd
               # workspace is connected, but command isn't a valid workspace command
               print_wrapped("Unrecognized command: '#{ command }'. Try one of these workspace commands: #{ Qcmd::InputCompleter::ReservedWorkspaceWords.join(', ') }")
             elsif Qcmd.context.machine_connected?
-              send_command(command, *args)
+              # send a command directly to a machine
+              reply = Qcmd::Action.evaluate(args)
+              handle_simple_reply reply
             else
               print 'you must connect to a machine before sending commands'
             end
@@ -588,6 +589,16 @@ module Qcmd
     ### communication actions
     private
 
+    def handle_simple_reply reply
+      if reply.is_a?(QLab::Reply)
+        if !reply.status.nil?
+          print reply.status
+        end
+      else
+        render_data reply
+      end
+    end
+
     def render_data data
       if data.is_a?(Array) || data.is_a?(Hash)
         begin
@@ -601,42 +612,51 @@ module Qcmd
       end
     end
 
+    def fixate_on_cue cue_action
+      # fixate on cue
+      if Qcmd.context.workspace.has_cues?
+        _cue = Qcmd.context.workspace.cues.find {|cue|
+          case cue_action.id_field
+          when :cue
+            cue.number.to_s == cue_action.identifier.to_s
+          when :cue_id
+            cue.id.to_s == cue_action.identifier.to_s
+          end
+        }
 
-    def send_command command, *args
-      options = args.extract_options!
+        if _cue
+          Qcmd.context.cue = _cue
+          Qcmd.context.cue_connected = true
 
-      Qcmd.debug "[CLI send_command] building command from command, args, options: #{ command.inspect }, #{ args.inspect }, #{ options.inspect }"
+          Qcmd.context.cue.sync
+        end
+      end
+    end
 
-      # make sure command is valid OSC Address
-      if %r[^/] =~ command
-        address = command
+    def send_workspace_command _command, *args
+      if !Qcmd.context.workspace.nil?
+        args[0] = "workspace/#{ Qcmd.context.workspace.id }/#{ _command }"
+        Qcmd::Action.evaluate(args)
       else
-        address = "/#{ command }"
+        log(:warning, "A workspace needs to be connected before a workspace command can be sent.")
       end
+    end
 
-      osc_message = OSC::Message.new address, *args
+    ## QLab commands
 
-      Qcmd.debug "[CLI send_command] sending osc message #{ osc_message.address } #{osc_message.has_arguments? ? 'with' : 'without'} args"
+    def load_workspaces
+      Qcmd.context.machine.workspaces = Qcmd::Action.evaluate('workspaces').map {|ws| QLab::Workspace.new(ws)}
+    end
 
-      if block_given?
-        # use given response handler, pass it response as a QLab Reply
-        Qcmd.context.qlab.send osc_message do |response|
-          Qcmd.debug "[CLI send_command] converting OSC::Message to QLab::Reply"
-          yield QLab::Reply.new(response)
-        end
+    def connect_default_workspace
+      if Qcmd.context.machine.workspaces.size == 1 && !Qcmd.context.machine.workspaces.first.passcode?
+        connect_to_workspace_by_index(0, nil)
+        true
       else
-        # rely on default response handler
-        Qcmd.context.qlab.send(osc_message)
+        false
       end
     end
 
-    def send_workspace_command _command, *args
-      command = "workspace/#{ Qcmd.context.workspace.id }/#{ _command }"
-      send_command(command, *args)
-    end
-
-    ## QLab commands
-
     def load_cues
       cues = Qcmd::Action.evaluate('/cueLists')
       Qcmd.context.workspace.cue_lists = cues.map {|cue_list| Qcmd::QLab::CueList.new(cue_list)}

data/lib/qcmd/handler.rb

@@ -61,7 +61,7 @@ module Qcmd
         end
 
         Qcmd.print
-        Qcmd.print_wrapped('Type `use "WORKSPACE_NAME" PASSCODE` to load a workspace. Passcode is required if workspace is [PROTECTED].')
+        Qcmd.print_wrapped('Type `use "WORKSPACE NAME" PASSCODE` to load a workspace. Passcode is required if workspace is [PROTECTED].')
         Qcmd.print
       end
     end

data/lib/qcmd/network.rb

@@ -4,14 +4,17 @@ module Qcmd
   # Browse the LAN and find open and running QLab instances.
   class Network
     BROWSE_TIMEOUT = 2
+    IPV4_MATCHER = /\b(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\b/
 
     class << self
       attr_accessor :machines, :browse_thread
 
+      def init
+        self.machines ||= []
+      end
+
       # browse can be used alone to populate the machines list
       def browse
-        self.machines = []
-
         self.browse_thread = Thread.start do
           DNSSD.browse! '_qlab._tcp.' do |b|
             DNSSD.resolve b.name, b.type, b.domain do |r|
@@ -41,7 +44,7 @@ module Qcmd
         end
 
         Qcmd.print
-        Qcmd.print 'Type `connect MACHINE` to connect to a machine'
+        Qcmd.print 'Type `connect "MACHINE NAME"` or `connect IP_ADDRESS` to connect to a machine'
         Qcmd.print
       end
 

data/lib/qcmd/plaintext.rb

@@ -1,16 +1,18 @@
 module Qcmd
   module Plaintext
-    def log message=nil
-      if message
-        puts message
-      else
-        puts
+    def log level, message=nil
+      if Qcmd.log_level_acheived?(level)
+        if message
+          puts message
+        else
+          puts
+        end
       end
     end
 
     # display output unless absolutely silent
     def print message=nil
-      log(message) unless Qcmd.silent?
+      log(:info, message) unless Qcmd.silent?
     end
 
     def set_columns value
@@ -86,6 +88,10 @@ module Qcmd
       word_wrap(line, options)
     end
 
+    def joined_wrapped *args
+      wrapped_text(*args).join("\n")
+    end
+
     def print_wrapped line
       print wrapped_text(line)
     end

data/lib/qcmd/qlab/cue.rb

@@ -44,6 +44,10 @@ module Qcmd
     #    \"armed\":true}]
 
     class Cue
+      TYPES = %w(audio mic video camera fade osc midi midi file timecode group
+                 start stop pause load reset devamp goto target arm disarm wait
+                 memo script cuelist)
+
       attr_accessor :data
 
       def initialize options={}

data/lib/qcmd/version.rb

@@ -1,3 +1,3 @@
 module Qcmd
-  VERSION = "0.1.8"
+  VERSION = "0.1.9"
 end

data/lib/vendor/sexpistol/sexpistol/sexpistol.rb

@@ -1,5 +1,5 @@
 # This class contains our logic for parsing
-# S-Expressions. They are turned into a 
+# S-Expressions. They are turned into a
 # native Ruby representation like:
 #   [:def, :something [:lambda, [:a], [:do_something]]]
 class Sexpistol
@@ -26,7 +26,7 @@ class Sexpistol
       end
     end
   end
-  
+
   # Convert nil, true and false into (), #t and #f for compatability
   # with Scheme
   def convert_scheme_literals(data)
@@ -39,7 +39,7 @@ class Sexpistol
       end
      end
   end
-  
+
   # Convert a set of nested arrays back into an S-Expression
   def to_sexp(data)
     data = convert_scheme_literals(data) if(@scheme_compatability)
@@ -47,6 +47,9 @@ class Sexpistol
       mapped = data.map do |item|
         if( item.is_a?(Array))
           to_sexp(item)
+        elsif item.is_a?(String)
+          # preserve string literal double quoting
+          item.inspect
         else
           item.to_s
         end
@@ -56,9 +59,9 @@ class Sexpistol
       data.to_s
     end
   end
-  
+
   private
-  
+
     def recursive_map(data, &block)
       if(data.is_a?(Array))
         return data.map do |x|
@@ -72,5 +75,5 @@ class Sexpistol
         block.call(data)
       end
     end
-  
-end
+
+end

data/spec/unit/parser_spec.rb

@@ -32,6 +32,11 @@ describe Qcmd::Parser do
     tokens.should eql([:cue, 10, :name, [:cue, 3, :name]])
   end
 
+  it "should parse nested commands with string literals" do
+    tokens = Qcmd::Parser.parse 'alias cue-rename (cue $1 name "Hello World")'
+    tokens.should eql([:alias, :'cue-rename', [:cue, :'$1', :name, 'Hello World']])
+  end
+
   it "should parse alias commands" do
     tokens = Qcmd::Parser.parse 'alias copy-name (cue 10 name (cue 3 name))'
     tokens.should eql([:alias, :'copy-name', [:cue, 10, :name, [:cue, 3, :name]]])
@@ -56,4 +61,24 @@ describe Qcmd::Parser do
     tokens = Qcmd::Parser.parse %[cue 1 name "this is (not good)"]
     tokens.should eql([:cue, 1, :name, 'this is (not good)'])
   end
+
+  ## Generating
+
+  describe "generating expressions" do
+    it "should leave string literals intact" do
+      expression = Qcmd::Parser.generate([:cue, :'$1', :name, 'Hello World'])
+      expression.should eql('(cue $1 name "Hello World")')
+    end
+
+    it "should handle nesting" do
+      expression = Qcmd::Parser.generate([:cue, :'$1', :name, [:cue, :'$2', :name]])
+      expression.should eql('(cue $1 name (cue $2 name))')
+    end
+
+    it "should handle escaped double quotes" do
+      expression = Qcmd::Parser.generate([:go, 'word word', 10, -12.3, 'life "is good" yeah'])
+      expression.should eql('(go "word word" 10 -12.3 "life \"is good\" yeah")')
+
+    end
+  end
 end

data/spec/unit/qcmd_spec.rb

@@ -3,14 +3,14 @@ require 'qcmd'
 describe Qcmd do
   # tests go here
   it "should log debug messages when in verbose mode" do
-    Qcmd.should_receive(:log).with('hello')
+    Qcmd.should_receive(:log).with(:debug, 'hello')
     Qcmd.verbose!
     Qcmd.log_level.should eql(:debug)
     Qcmd.debug 'hello'
   end
 
   it 'should not log debug messages when not in verbose mode' do
-    Qcmd.should_not_receive(:log)
+    Kernel.should_not_receive(:puts)
     Qcmd.quiet!
     Qcmd.log_level.should eql(:warning)
     Qcmd.debug 'hello'
@@ -21,7 +21,7 @@ describe Qcmd do
     Qcmd.log_level.should eql(:debug)
 
     Qcmd.while_quiet do
-      Qcmd.should_not_receive(:log)
+      Kernel.should_not_receive(:puts)
       Qcmd.log_level.should eql(:warning)
       Qcmd.debug 'hello'
     end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: qcmd
 version: !ruby/object:Gem::Version
-  version: 0.1.8
+  version: 0.1.9
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-04-20 00:00:00.000000000 Z
+date: 2013-04-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: dnssd
@@ -132,6 +132,7 @@ extensions: []
 extra_rdoc_files: []
 files:
 - .gitignore
+- CHANGELOG.md
 - Gemfile
 - LICENSE.txt
 - README.md