qcmd 0.1.7 → 0.1.8

data/lib/qcmd/parser.rb

@@ -1,94 +1,25 @@
+# require 'sxp'
+require 'vendor/sexpistol/sexpistol'
+
 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
-
-      # A helper method to take care of the repetitive stuff for us
-      def is_match?( string, pattern)
-        match = string.match(pattern)
-        return false unless match
-        # Make sure that the matched pattern consumes the entire token
-        match[0].length == string.length
-      end
-
-      # Detect a symbol
-      def is_symbol?( string )
-        # Anything other than parentheses, single or double quote and commas
-        return is_match?( string, /[^\"\'\,\(\)]+/ )
-      end
-
-      # Detect an integer literal
-      def is_integer_literal?( string )
-        # Any number of numerals optionally preceded by a plus or minus sign
-        return is_match?( string, /[\-\+]?[0-9]+/ )
-      end
-
-      def is_float_literal?( string )
-        # Any number of numerals optionally preceded by a plus or minus sign
-        return is_match?( string, /[\-\+]?[0-9]+(\.[0-9]*)?/ )
-      end
-
-      # Detect a string literal
-      def is_string_literal?( string )
-        # Any characters except double quotes
-        # (except if preceded by a backslash), surrounded by quotes
-        return is_match?( string, /"([^"\\]|\\.)*"/)
+      def parser
+        @parser ||= Sexpistol.new
       end
 
-      def convert_tokens( token_array )
-        converted_tokens = []
-        token_array.each do |t|
-          converted_tokens << t.to_i and next if( is_integer_literal?(t) )
-          converted_tokens << t.to_f and next if( is_float_literal?(t) )
-          converted_tokens << t.to_s and next if( is_symbol?(t) )
-          converted_tokens << eval(t) and next if( is_string_literal?(t) )
-          # If we haven't recognized the token by now we need to raise
-          # an exception as there are no more rules left to check against!
-          raise Exception, "Unrecognized token: #{t}"
+      def parse(string)
+        # make sure string is wrapped in parens to make the parser happy
+        begin
+          parser.parse_string "#{ string }"
+        rescue => ex
+          puts "parser FAILED WITH EXCEPTION: #{ ex.message }"
+          raise
         end
-        return converted_tokens
       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)
-        token_array = convert_tokens(token_array)
-        return token_array
+      def generate(sexp)
+        parser.to_sexp(sexp)
       end
     end
   end

data/lib/qcmd/plaintext.rb

@@ -75,10 +75,6 @@ module Qcmd
       }
     end
 
-    def joined_wrapped_text line
-      wrapped_text(line).join "\n"
-    end
-
     # turn line into lines of text of columns length
     def wrapped_text *args
       options = {

data/lib/qcmd/qlab.rb

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

data/lib/qcmd/qlab/cue.rb

@@ -50,6 +50,14 @@ module Qcmd
         self.data = options
       end
 
+      def sync
+        Qcmd.debug "[Cue sync] synchronizing cue with id #{ self.id }"
+
+        # reload cue properties from QLab
+        fields = %w(uniqueID number name type colorName flagged armed cues)
+        self.data = Qcmd::CueAction.evaluate("cue_id #{ self.id } valuesForKeys #{ JSON.dump(fields).inspect }")
+      end
+
       def id
         data['uniqueID']
       end
@@ -65,6 +73,18 @@ module Qcmd
       def type
         data['type']
       end
+
+      def cues
+        if data['cues'].nil?
+          []
+        else
+          data['cues'].map {|c| Qcmd::QLab::Cue.new(c)}
+        end
+      end
+
+      def has_cues?
+        cues.size > 0
+      end
     end
   end
 end

data/lib/qcmd/qlab/cue_list.rb

@@ -0,0 +1,83 @@
+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 CueList
+      attr_accessor :data
+
+      def initialize data
+        self.data = data
+      end
+
+      def id
+        data['uniqueID']
+      end
+
+      def name
+        data['listName']
+      end
+
+      def number
+        data['number']
+      end
+
+      def type
+        data['type']
+      end
+
+      def cues
+        if data['cues'].nil?
+          []
+        else
+          data['cues'].map {|c| Qcmd::QLab::Cue.new(c)}
+        end
+      end
+
+      def has_cues?
+        cues.size > 0
+      end
+    end
+  end
+end

data/lib/qcmd/qlab/reply.rb

@@ -2,7 +2,13 @@ module Qcmd
   module QLab
     class Reply < Struct.new(:osc_message)
       def json
-        @json ||= JSON.parse(osc_message.to_a.first)
+        @json ||= begin
+                    Qcmd.debug "[Reply json] parsing osc_message #{ osc_message.to_a.inspect }"
+                    JSON.parse(osc_message.to_a.first)
+                  rescue => ex
+                    Qcmd.debug "[Reply json] json parsing of osc_message failed on message #{ osc_message.to_a.inspect }. #{ ex.message }"
+                    {}
+                  end
       end
 
       def address
@@ -13,12 +19,20 @@ module Qcmd
         @data ||= json['data']
       end
 
-      def is_cue_command?
-        Qcmd::Commands.is_cue_command?(address)
+      def has_data?
+        !data.nil?
+      end
+
+      def status
+        @status ||= json['status']
+      end
+
+      def empty?
+        false
       end
 
       def to_s
-        "<Qcmd::Qlab::Reply address:'#{address}' data:#{data.inspect}>"
+        "<Qcmd::Qlab::Reply address:'#{address}' status:'#{status}' data:#{data.inspect}>"
       end
     end
   end

data/lib/qcmd/qlab/workspace.rb

@@ -6,7 +6,7 @@ module Qcmd
     #   "hasPasscode": number
     #
     class Workspace
-      attr_accessor :data, :passcode, :cue_lists, :cues
+      attr_accessor :data, :passcode, :cue_lists
 
       def initialize options={}
         self.data = options
@@ -23,6 +23,28 @@ module Qcmd
       def id
         data['uniqueID']
       end
+
+      # all cues in this workspace
+      def cues
+        cue_lists.map do |cl|
+          load_cues(cl, [])
+        end.flatten.compact
+      end
+
+      def has_cues?
+        cues.size > 0
+      end
+
+      private
+
+      def load_cues parent_cue, cues
+        parent_cue.cues.each {|child_cue|
+          cues << child_cue
+          load_cues child_cue, cues
+        }
+
+        cues
+      end
     end
   end
 end

data/lib/qcmd/version.rb

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

data/lib/vendor/sexpistol/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2010 Aaron Gough (http://thingsaaronmade.com/)
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/lib/vendor/sexpistol/sexpistol.rb

@@ -0,0 +1,2 @@
+require File.expand_path(File.join(File.dirname(__FILE__), 'sexpistol', 'sexpistol_parser.rb'))
+require File.expand_path(File.join(File.dirname(__FILE__), 'sexpistol', 'sexpistol.rb'))

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

@@ -0,0 +1,76 @@
+# This class contains our logic for parsing
+# S-Expressions. They are turned into a 
+# native Ruby representation like:
+#   [:def, :something [:lambda, [:a], [:do_something]]]
+class Sexpistol
+
+  attr_accessor :ruby_keyword_literals, :scheme_compatability
+
+  # Parse a string containing an S-Expression into a
+  # nested set of Ruby arrays
+  def parse_string(string)
+    tree = SexpistolParser.new(string).parse
+    return convert_ruby_keyword_literals(tree) if(@ruby_keyword_literals)
+    return tree
+  end
+
+  # Convert symbols corresponding to Ruby's keyword literals
+  # into their literal forms
+  def convert_ruby_keyword_literals(expression)
+    return recursive_map(expression) do |x|
+      case x
+        when :'nil' then nil
+        when :'true' then true
+        when :'false' then false
+        else x
+      end
+    end
+  end
+  
+  # Convert nil, true and false into (), #t and #f for compatability
+  # with Scheme
+  def convert_scheme_literals(data)
+    return recursive_map(data) do |x|
+      case x
+        when nil then []
+        when true then :"#t"
+        when false then :"#f"
+        else x
+      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)
+    if( data.is_a?(Array))
+      mapped = data.map do |item|
+        if( item.is_a?(Array))
+          to_sexp(item)
+        else
+          item.to_s
+        end
+      end
+      "(" + mapped.join(" ") + ")"
+    else
+      data.to_s
+    end
+  end
+  
+  private
+  
+    def recursive_map(data, &block)
+      if(data.is_a?(Array))
+        return data.map do |x|
+          if(x.is_a?(Array))
+            recursive_map(x, &block)
+          else
+            block.call(x)
+          end
+        end
+      else
+        block.call(data)
+      end
+    end
+  
+end

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

@@ -0,0 +1,94 @@
+require 'strscan'
+
+class SexpistolParser < StringScanner
+
+  def initialize(string)
+    # step through string counting closing parens, exclude parens in string literals
+    in_string_literal = false
+    escape_char = false
+    paren_count = 0
+    string.bytes.each do |byte|
+      if escape_char
+        escape_char = false
+        next
+      end
+
+      case byte.chr
+      when '\\'
+        escape_char = true
+        next
+      when '('
+        if !in_string_literal
+          paren_count += 1
+        end
+      when ')'
+        if !in_string_literal
+          paren_count -= 1
+        end
+      when '"'
+        in_string_literal = !in_string_literal
+      end
+    end
+
+    if paren_count > 0
+      raise Exception, "Missing closing parentheses"
+    elsif paren_count < 0
+      raise Exception, "Missing opening parentheses"
+    end
+
+    super(string)
+  end
+
+  def parse
+    exp = []
+    while true
+      case fetch_token
+        when '('
+          exp << parse
+        when ')'
+          break
+        when :"'"
+          case fetch_token
+          when '(' then exp << [:quote].concat([parse])
+          else exp << [:quote, @token]
+          end
+        when String, Fixnum, Float, Symbol 
+          exp << @token
+        when nil 
+          break
+      end
+    end
+    exp
+  end
+  
+  def fetch_token
+    skip(/\s+/)
+    return nil if(eos?)
+    
+    @token = 
+    # Match parentheses
+    if scan(/[\(\)]/)      
+      matched
+    # Match a string literal
+    elsif scan(/"([^"\\]|\\.)*"/)
+      eval(matched)
+    # Match a float literal
+    elsif scan(/[\-\+]? [0-9]+ ((e[0-9]+) | (\.[0-9]+(e[0-9]+)?))/x)
+      matched.to_f
+    # Match an integer literal
+    elsif scan(/[\-\+]?[0-9]+/)
+      matched.to_i
+    # Match a comma (for comma quoting)
+    elsif scan(/'/)
+      matched.to_sym
+    # Match a symbol
+    elsif scan(/[^\(\)\s]+/)
+      matched.to_sym
+    # If we've gotten here then we have an invalid token
+    else
+      near = scan %r{.{0,20}}
+      raise "Invalid character at position #{pos} near '#{near}'."
+    end
+  end
+
+end