openc3 7.4.1 → 7.5.1

data/lib/openc3/packets/parsers/state_parser.rb

@@ -26,7 +26,7 @@ module OpenC3
     # @param warnings [Array<String>] Array of string warnings which will be
     #   appended with any warnings found when parsing the limits
     def self.parse(parser, packet, cmd_or_tlm, item, warnings)
-      raise parser.error("Items with LIMITS can't define STATE") if item.limits.values
+      raise parser.error("Items with LIMITS can't define STATE") if item.limits_values
       raise parser.error("Items with UNITS can't define STATE") if item.units
 
       parser = StateParser.new(parser)

data/lib/openc3/packets/structure_item.rb

@@ -143,7 +143,8 @@ module OpenC3
       raise ArgumentError, "name must be a String but is a #{name.class}" unless String === name
       raise ArgumentError, "name must contain at least one character" if name.empty?
 
-      @name = name.upcase.clone.freeze
+      # Dedup since many packets share the same item names
+      @name = -name.upcase
       verify_overall() if @structure_item_constructed
     end
 
@@ -151,7 +152,7 @@ module OpenC3
       raise ArgumentError, "key must be a String but is a #{key.class}" unless String === key
       raise ArgumentError, "key must contain at least one character" if key.empty?
 
-      @key = key
+      @key = -key
     end
 
     def endianness=(endianness)

data/lib/openc3/script/api_shared.rb

@@ -37,7 +37,7 @@ module OpenC3
     # @param args [String|Array<String>] See the description for calling style
     # @param type [Symbol] Telemetry type, :RAW, :CONVERTED (default), :FORMATTED
     def check(*args, type: :CONVERTED, scope: $openc3_scope, token: $openc3_token)
-      _check(*args, scope: scope) { |tgt, pkt, item| tlm(tgt, pkt, item, type: type, scope: scope, token: token) }
+      _check(*args, type: type, scope: scope, token: token) { |tgt, pkt, item| tlm(tgt, pkt, item, type: type, scope: scope, token: token) }
     end
 
     def check_raw(*args, scope: $openc3_scope, token: $openc3_token)
@@ -525,12 +525,12 @@ module OpenC3
     # Implementation of the various check commands. It yields back to the
     # caller to allow the return of the value through various telemetry calls.
     # This method should not be called directly by application code.
-    def _check(*args, scope: $openc3_scope, token: $openc3_token)
+    def _check(*args, type: :CONVERTED, scope: $openc3_scope, token: $openc3_token)
       target_name, packet_name, item_name, comparison_to_eval = _check_process_args(args, 'check')
 
       value = yield(target_name, packet_name, item_name)
       if comparison_to_eval
-        _check_eval(target_name, packet_name, item_name, comparison_to_eval, value)
+        _check_comparison(target_name, packet_name, item_name, type, comparison_to_eval, value, scope: scope, token: token)
       else
         puts "CHECK: #{_upcase(target_name, packet_name, item_name)} == #{value.nil? ? 'nil' : value.inspect}"
       end
@@ -596,6 +596,8 @@ module OpenC3
                      quiet: false,
                      scope: $openc3_scope, token: $openc3_token)
       type = (check ? 'CHECK' : 'WAIT')
+      # LATEST would compare the RECEIVED_COUNT of whichever packet was received most recently
+      raise "LATEST is not supported by wait_packet, specify a packet name" if packet_name.to_s.upcase == 'LATEST'
       initial_count = tlm(target_name, packet_name, 'RECEIVED_COUNT', scope: scope, token: token)
       # If the packet has not been received the initial_count could be nil
       initial_count = 0 unless initial_count
@@ -733,28 +735,16 @@ module OpenC3
       return [target_name, packet_name, item_name, comparison_to_eval, timeout, polling_rate]
     end
 
-    def _openc3_script_wait_implementation(target_name, packet_name, item_name, value_type, timeout, polling_rate, exp_to_eval, scope: $openc3_scope, token: $openc3_token, &block)
+    # Waits for the comparison to be true or the timeout to expire.
+    # The comparison is a callable which takes the telemetry value and returns true or false.
+    # A block passed by the user takes precedence over the comparison.
+    def _openc3_script_wait_implementation(target_name, packet_name, item_name, value_type, timeout, polling_rate, comparison, scope: $openc3_scope, token: $openc3_token, &block)
+      condition = block || comparison
       end_time = Time.now.sys + timeout
-      if exp_to_eval and !exp_to_eval.is_printable?
-        raise "ERROR: Invalid comparison to non-ascii value"
-      end
       while true
         work_start = Time.now.sys
         value = tlm(target_name, packet_name, item_name, type: value_type, scope: scope, token: token)
-        if not block.nil?
-          if block.call(value)
-            return true, value
-          end
-        else
-          begin
-            if eval(exp_to_eval)
-              return true, value
-            end
-          # NoMethodError is raised when the tlm() returns nil and we try to eval the expression
-          # In this case we just continue and see if eventually we get a good value from tlm()
-          rescue NoMethodError
-          end
-        end
+        return true, value if condition and condition.call(value)
         break if Time.now.sys >= end_time
 
         delta = Time.now.sys - work_start
@@ -766,58 +756,62 @@ module OpenC3
 
         if canceled
           value = tlm(target_name, packet_name, item_name, type: value_type, scope: scope, token: token)
-          if not block.nil?
-            if block.call(value)
-              return true, value
-            else
-              return false, value
-            end
+          if condition and condition.call(value)
+            return true, value
           else
-            begin
-              if eval(exp_to_eval)
-                return true, value
-              else
-                return false, value
-              end
-            # NoMethodError is raised when the tlm() returns nil and we try to eval the expression
-            rescue NoMethodError
-              return false, value
-            end
+            return false, value
           end
         end
       end
 
       return false, value
-    rescue NameError => e
-      if e.message =~ /uninitialized constant OpenC3::ApiShared::(\w+)/
-        new_error = NameError.new("Uninitialized constant #{$1}. Did you mean '#{$1}' as a string?")
-        new_error.set_backtrace(e.backtrace)
-        raise new_error
-      else
-        raise e
-      end
+    end
+
+    # Builds a callable which compares a telemetry value against the given comparison string,
+    # e.g. "> 1". Returns nil if there is no comparison, e.g. a block based wait_check().
+    # Raises if the comparison is invalid, e.g. an unsupported operator or unparsable operand.
+    def _comparison_implementation(target_name, packet_name, item_name, value_type, comparison_to_eval, scope: $openc3_scope, token: $openc3_token)
+      return nil unless comparison_to_eval
+
+      operator, operand = extract_comparison(comparison_to_eval, value_type) { get_item(target_name, packet_name, item_name, scope: scope, token: token) }
+      return nil unless operator
+      lambda { |value| compare_values(value, operator, operand) }
     end
 
     # Wait for a converted telemetry item to pass a comparison
     def _openc3_script_wait_implementation_comparison(target_name, packet_name, item_name, value_type, comparison_to_eval, timeout, polling_rate = DEFAULT_TLM_POLLING_RATE, scope: $openc3_scope, token: $openc3_token, &block)
-      if comparison_to_eval
-        exp_to_eval = "value " + comparison_to_eval
-      else
-        exp_to_eval = nil
+      # The comparison text is logged whether or not it is parsed so it is always validated
+      if comparison_to_eval and !comparison_to_eval.is_printable?
+        raise "ERROR: Invalid comparison to non-ascii value"
       end
-      _openc3_script_wait_implementation(target_name, packet_name, item_name, value_type, timeout, polling_rate, exp_to_eval, scope: scope, token: token, &block)
+      # A user supplied block is the condition so the comparison text is never parsed
+      comparison = block ? nil : _comparison_implementation(target_name, packet_name, item_name, value_type, comparison_to_eval, scope: scope, token: token)
+      _openc3_script_wait_implementation(target_name, packet_name, item_name, value_type, timeout, polling_rate, comparison, scope: scope, token: token, &block)
     end
 
     def _openc3_script_wait_implementation_tolerance(target_name, packet_name, item_name, value_type, expected_value, tolerance, timeout, polling_rate = DEFAULT_TLM_POLLING_RATE, scope: $openc3_scope, token: $openc3_token, &block)
-      exp_to_eval = "((#{expected_value} - #{tolerance})..(#{expected_value} + #{tolerance})).include? value"
-      _openc3_script_wait_implementation(target_name, packet_name, item_name, value_type, timeout, polling_rate, exp_to_eval, scope: scope, token: token, &block)
+      comparison = lambda do |value|
+        begin
+          value >= (expected_value - tolerance) and value <= (expected_value + tolerance)
+        rescue ArgumentError, NoMethodError, TypeError
+          false
+        end
+      end
+      _openc3_script_wait_implementation(target_name, packet_name, item_name, value_type, timeout, polling_rate, comparison, scope: scope, token: token, &block)
     end
 
     def _openc3_script_wait_implementation_array_tolerance(array_size, target_name, packet_name, item_name, value_type, expected_value, tolerance, timeout, polling_rate = DEFAULT_TLM_POLLING_RATE, scope: $openc3_scope, token: $openc3_token, &block)
-      statements = []
-      array_size.times { |i| statements << "(((#{expected_value[i]} - #{tolerance[i]})..(#{expected_value[i]} + #{tolerance[i]})).include? value[#{i}])" }
-      exp_to_eval = statements.join(" && ")
-      _openc3_script_wait_implementation(target_name, packet_name, item_name, value_type, timeout, polling_rate, exp_to_eval, scope: scope, token: token, &block)
+      comparison = lambda do |values|
+        begin
+          next false unless values.is_a?(Array) and values.length == array_size
+          array_size.times.all? do |i|
+            values[i] >= (expected_value[i] - tolerance[i]) and values[i] <= (expected_value[i] + tolerance[i])
+          end
+        rescue ArgumentError, NoMethodError, TypeError
+          false
+        end
+      end
+      _openc3_script_wait_implementation(target_name, packet_name, item_name, value_type, timeout, polling_rate, comparison, scope: scope, token: token, &block)
     end
 
     # Wait on an expression to be true.
@@ -859,17 +853,15 @@ module OpenC3
       end
     end
 
-    def _check_eval(target_name, packet_name, item_name, comparison_to_eval, value)
-      string = "value " + comparison_to_eval
+    def _check_comparison(target_name, packet_name, item_name, value_type, comparison_to_eval, value, scope: $openc3_scope, token: $openc3_token)
       check_str = "CHECK: #{_upcase(target_name, packet_name, item_name)} #{comparison_to_eval}"
       # Show user the check against a quoted string
-      # Note: We have to preserve the original 'value' variable because we're going to eval against it
       value_str = value.is_a?(String) ? "'#{value}'" : value
       value_str = 'nil' if value.nil? # Show user nil value as 'nil'
       with_value = "with value == #{value_str}"
 
-      eval_is_valid = _check_eval_validity(value, comparison_to_eval)
-      unless eval_is_valid
+      operator, operand = extract_comparison(comparison_to_eval, value_type) { get_item(target_name, packet_name, item_name, scope: scope, token: token) }
+      unless _valid_comparison?(value, operator, operand)
         message = "Invalid comparison for types"
         if $disconnect
           puts "ERROR: #{message}"
@@ -878,7 +870,7 @@ module OpenC3
         end
       end
 
-      if eval_is_valid && eval(string)
+      if compare_values(value, operator, operand)
         puts "#{check_str} success #{with_value}"
       else
         message = "#{check_str} failed #{with_value}"
@@ -888,35 +880,19 @@ module OpenC3
           raise CheckError, message
         end
       end
-    rescue NameError => e
-      if e.message =~ /uninitialized constant OpenC3::ApiShared::(\w+)/
-        new_error = NameError.new("Uninitialized constant #{$1}. Did you mean '#{$1}' as a string?")
-        new_error.set_backtrace(e.backtrace)
-        raise new_error
-      else
-        raise e
-      end
     end
 
-    def _check_eval_validity(value, comparison)
-      return true if comparison.nil? || comparison.empty?
-
-      begin
-        operator, operand = extract_operator_and_operand_from_comparison(comparison)
-      rescue RuntimeError => e
-        if e.message.include?("Unable to parse operand")
-          # If we can't parse the operand, let the eval happen anyway
-          # It will raise an appropriate error (like NameError for undefined constants)
-          return true
-        end
-        raise # Re-raise invalid operator errors
-      rescue JSON::ParserError
-        return true
-      end
+    # Returns whether the value and operand can be meaningfully compared with the operator.
+    # Note this is only used by check() because wait() polls until the value changes.
+    def _valid_comparison?(value, operator, operand)
+      return true if operator.nil?
 
       if [">=", "<=", ">", "<"].include?(operator)
-        return false if value.nil? || operand.nil? || value.is_a?(Array) || operand.is_a?(Array)
+        return false if value.nil? or operand.nil?
+        return false if value.is_a?(Array) or operand.is_a?(Array)
+        return false if value.is_a?(String) != operand.is_a?(String)
       end
+      # Note 'in' does not need a check here because the parser already requires a list operand
 
       return true
     end

data/lib/openc3/script/extract.rb

@@ -26,6 +26,37 @@ module OpenC3
     # whitespace around them is optional.
     SCANNING_REGULAR_EXPRESSION = %r{ (?:"(?:[^\\"]|\\.)*") | (?:'(?:[^\\']|\\.)*') | (?:\[(?:[^\\\[\]]|\\.|\[(?:[^\\\[\]]|\\.)*\])*\]) | , | [^\s,]+ }x # "
 
+    # Operators supported by check(), wait() and wait_check() comparisons
+    COMPARISON_OPERATORS = ["==", "!=", ">=", "<=", ">", "<", "in"]
+
+    # Single character escape sequences processed inside a double quoted comparison operand.
+    # The numeric (\nnn, \xHH, \uHHHH, \u{...}) forms are handled by unescape_double_quoted().
+    DOUBLE_QUOTE_ESCAPES = {
+      '\\' => "\\", '"' => '"', "'" => "'", '#' => '#', 'n' => "\n", 't' => "\t",
+      'r' => "\r", 'a' => "\a", 'b' => "\b", 'e' => "\e", 'f' => "\f", 'v' => "\v", 's' => ' '
+    }
+
+    # Tokenizes a double quoted operand into escape sequences, interpolation markers and runs
+    # of plain characters. The alternatives are ordered longest first so \u{1F600} is not read
+    # as \u, and the escape alternatives precede the markers so \#{ is a literal '#{'.
+    DOUBLE_QUOTE_TOKEN_REGEX =
+      /\\u\{[\h\s]*\}|\\u\h{4}|\\x\h{1,2}|\\[0-7]{1,3}|\\M-\\C-.|\\M-.|\\C-.|\\c.|\\.|\#[{@$]|[^\\\#]+|\#/m
+
+    # Escape sequences which have a meaning we deliberately do not implement. Dropping the
+    # backslash would silently change the value so they are rejected instead.
+    UNSUPPORTED_ESCAPE_REGEX = /\A\\(?:c|C-|M-)/
+
+    # The Ruby string interpolation markers. Interpolation would be code execution so it is
+    # rejected rather than silently compared against the uninterpolated text.
+    INTERPOLATION_REGEX = /\A\#[{@$]/
+
+    # Limits Ruby enforces on a \u escape. A codepoint is written with at most six hex digits,
+    # the largest character Unicode defines is 0x10FFFF, and the surrogate range is reserved
+    # for UTF-16 pairs so it is not a character on its own.
+    MAX_UNICODE_DIGITS = 6
+    MAX_UNICODE_CODEPOINT = 0x10FFFF
+    UNICODE_SURROGATE_RANGE = (0xD800..0xDFFF)
+
     private
 
     # Pulls all string keyword arguments into the args array. Raises on any symbol keyword arguments.
@@ -164,9 +195,8 @@ module OpenC3
     end
 
     # Splits `check()` comparison expressions, e.g. "== 'foo bar'" becomes ["==", "foo bar"]
-    def extract_operator_and_operand_from_comparison(comparison)
-      valid_operators = ["==", "!=", ">=", "<=", ">", "<", "in"]
-
+    # The optional block resolves an unquoted word, see extract_operand
+    def extract_operator_and_operand_from_comparison(comparison, &resolve_name)
       operator, operand = comparison.split(nil, 2) # Ruby: second split arg is max number of resultant elements
 
       if operand.nil?
@@ -175,29 +205,242 @@ module OpenC3
         return [nil, nil]
       end
 
-      raise "ERROR: Invalid operator: '#{operator}'" unless valid_operators.include?(operator)
+      raise "ERROR: Invalid operator: '#{operator}'" unless COMPARISON_OPERATORS.include?(operator)
 
-      # Handle string operand: remove surrounding double/single quotes
-      if operand.match?(/^(['"])(.*)\1$/m) # Starts with single or double quote, and ends with matching quote
-        operand = operand[1..-2]
-        return [operator, operand]
+      # split leaves any trailing whitespace on the operand which the anchored matches reject
+      operand = extract_operand(operand.strip, &resolve_name)
+      # 'in' is containment against a list of values in both Ruby and Python.
+      # Enforced here so check(), wait() and wait_check() all reject the same thing.
+      if operator == "in" and !operand.is_a?(Array)
+        raise "ERROR: The 'in' operator requires a list operand: #{operand.inspect}"
+      end
+
+      return [operator, operand]
+    end
+
+    # Converts the operand of a `check()` comparison expression into a Ruby value.
+    # Note this deliberately does not eval the operand so only literal values are supported.
+    # The optional block is called with an unquoted word, including one inside a list, and
+    # returns the value to use or nil if the word is not recognized, e.g. a state name.
+    def extract_operand(operand, &resolve_name)
+      # A quoted operand must be a single complete string literal. Anything trailing the
+      # closing quote, e.g. "== 'a' garbage 'b'", is a syntax error rather than a string.
+      if (match = operand.match(/\A'((?:[^'\\]|\\.)*)'\z/m))
+        # Ruby single quoted strings only escape the backslash and the single quote
+        return match[1].gsub(/\\([\\'])/) { $1 }
+      end
+      if (match = operand.match(/\A"((?:[^"\\]|\\.)*)"\z/m))
+        return unescape_double_quoted(match[1])
       end
+      return nil if operand == "nil"
+      return false if operand == "false"
+      return true if operand == "true"
 
-      # Handle other operand types
-      if operand == "nil"
-        operand = nil
-      elsif operand == "false"
-        operand = false
-      elsif operand == "true"
-        operand = true
+      # Ruby's Float() rejects these but Python's float() accepts them
+      case operand.upcase
+      when 'INFINITY', '+INFINITY', 'INF', '+INF'
+        return Float::INFINITY
+      when '-INFINITY', '-INF'
+        return -Float::INFINITY
+      when 'NAN', '+NAN', '-NAN'
+        return Float::NAN
       else
-        begin
-          operand = JSON.parse(operand)
-        rescue JSON::ParserError
-          raise "ERROR: Unable to parse operand: #{operand}"
+        # Not an infinity or NaN keyword so fall through to the formats below
+      end
+
+      # Arrays are parsed recursively so their elements follow exactly the same rules as a
+      # bare operand. JSON alone would reject ['ON', 'OFF'], [0xA, 0xB] and [true, nil].
+      if operand.start_with?('[') and operand.end_with?(']')
+        return split_operand_list(operand[1..-2]).map { |element| extract_operand(element, &resolve_name) }
+      end
+      # JSON handles decimal numbers and hashes
+      begin
+        return JSON.parse(operand)
+      rescue JSON::ParserError
+        # Fall through to the number formats JSON does not accept
+      end
+      # Number formats JSON does not accept
+      begin
+        # Explicit base prefix: hex (0x), octal (0o) or binary (0b)
+        return Integer(operand) if operand.match?(/\A[+-]?0[xXoObB][0-9a-fA-F_]+\z/)
+        # Integers with underscore separators, e.g. 1_000. A leading zero is deliberately
+        # rejected because it is ambiguous: Ruby reads 010 as octal 8 while Python rejects it.
+        # Write 0o10 for octal 8 or 10 for decimal 10.
+        return Integer(operand, 10) if operand.match?(/\A[+-]?[1-9][0-9_]*\z/)
+        # Floats with underscore separators, e.g. 1_000.5. A leading zero is unambiguous here.
+        return Float(operand) if operand.match?(/\A[+-]?[0-9][0-9_]*(?:\.[0-9_]+(?:[eE][+-]?[0-9_]+)?|[eE][+-]?[0-9_]+)\z/)
+      rescue ArgumentError
+        # Fall through to the error cases
+      end
+
+      # A bare word is almost always a string the user forgot to quote
+      if operand.match?(/\A[A-Za-z_][A-Za-z0-9_]*\z/)
+        value = resolve_name&.call(operand)
+        return value unless value.nil?
+
+        raise NameError, "Unknown state name #{operand}. Did you mean '#{operand}' as a string?"
+      end
+      raise "ERROR: Unable to parse operand: #{operand}"
+    end
+
+    # Processes the escape sequences in the contents of a double quoted operand
+    def unescape_double_quoted(string)
+      # A \xHH or octal escape can produce a byte which is not valid UTF-8 so build the result
+      # in binary. Otherwise preserve the encoding of the comparison the user passed in.
+      # The escape must not itself be escaped, e.g. "C:\\0" is a backslash followed by a zero.
+      binary = string.match?(/(?<!\\)(?:\\\\)*\\(?:x\h|[0-7])/)
+      result = binary ? ''.b : String.new(encoding: string.encoding)
+      string.scan(DOUBLE_QUOTE_TOKEN_REGEX).each do |token|
+        replacement =
+          if token.match?(INTERPOLATION_REGEX)
+            raise "ERROR: String interpolation is not supported in an operand: #{token}. " +
+                  'Interpolate in the script itself or escape it as \#' + token[1] +
+                  ' to compare against the literal text'
+          elsif !token.start_with?('\\')
+            token
+          elsif token.start_with?('\u{')
+            # \u{1F600} or \u{48 49} which is one or more whitespace separated codepoints
+            token[3..-2].split.map { |codepoint| pack_unicode_codepoint(codepoint, token) }.join
+          elsif token.length == 6 and token.start_with?('\u')
+            pack_unicode_codepoint(token[2..-1], token)
+          elsif token.length > 2 and token.start_with?('\x')
+            [token[2..-1].hex].pack('C')
+          elsif token.match?(/\A\\[0-7]/)
+            [token[1..-1].to_i(8) & 0xFF].pack('C')
+          elsif token.match?(UNSUPPORTED_ESCAPE_REGEX)
+            raise "ERROR: Unsupported escape sequence in operand: #{token}"
+          elsif token == '\u' or token == '\x'
+            raise "ERROR: Invalid escape sequence in operand: #{token}"
+          else
+            # Ruby drops the backslash of an escape which has no special meaning, e.g. "\q"
+            DOUBLE_QUOTE_ESCAPES.fetch(token[1], token[1])
+          end
+        result << (binary ? replacement.b : replacement)
+      end
+      return result
+    end
+
+    # Packs a single codepoint of a \u escape into a UTF-8 character. Ruby rejects a codepoint
+    # which is too long, above the largest Unicode character or in the UTF-16 surrogate range,
+    # so those raise here rather than silently packing into an invalid UTF-8 string.
+    def pack_unicode_codepoint(codepoint, token)
+      value = codepoint.hex
+      if codepoint.length > MAX_UNICODE_DIGITS or value > MAX_UNICODE_CODEPOINT or
+         UNICODE_SURROGATE_RANGE.include?(value)
+        raise "ERROR: Invalid Unicode codepoint in operand: #{token}"
+      end
+      return [value].pack('U')
+    end
+
+    # Splits the contents of a bracketed operand list on the top level commas.
+    # Quotes and nesting are tracked so "['a,b', [1, 2]]" is two elements, not four.
+    def split_operand_list(text)
+      elements = []
+      current = String.new(encoding: text.encoding)
+      depth = 0
+      quote = nil
+      escaped = false
+      text.each_char do |char|
+        if escaped
+          escaped = false
+        elsif quote
+          if char == '\\'
+            escaped = true
+          elsif char == quote
+            quote = nil
+          end
+        elsif char == "'" or char == '"'
+          quote = char
+        elsif char == '[' or char == '{'
+          depth += 1
+        elsif char == ']' or char == '}'
+          depth -= 1
+          raise "ERROR: Unable to parse operand: [#{text}]" if depth < 0
+        elsif char == ',' and depth == 0
+          elements << current.strip
+          current = String.new(encoding: text.encoding)
+          next
         end
+        current << char
       end
-      return [operator, operand]
+      raise "ERROR: Unable to parse operand: [#{text}]" if depth != 0 or quote
+
+      elements << current.strip
+      # A single empty element is an empty list, e.g. []
+      return [] if elements.length == 1 and elements[0].empty?
+      # A trailing comma is allowed, e.g. [1,], matching both Ruby and Python list literals
+      elements.pop if elements[-1].empty?
+      raise "ERROR: Unable to parse operand: [#{text}]" if elements.empty? or elements.any?(&:empty?)
+
+      return elements
+    end
+
+    # Splits a comparison like extract_operator_and_operand_from_comparison but matches state names.
+    # State names are stored upper case so a string operand which matches a state name ignoring case
+    # is compared against that state name, e.g. "== 'Connected'" matches the CONNECTED state.
+    # An unquoted state name, e.g. "== Connected" or "in [On, Off]", is also accepted. The block returns
+    # the item hash. It is only called once, when the operand could be a state name, so numeric
+    # comparisons don't make an additional API call. RAW values are never state names so it is never called.
+    def extract_comparison(comparison, value_type, &get_item)
+      item_states = nil
+      looked_up = false
+      states = lambda do
+        unless looked_up
+          looked_up = true
+          item_states = get_item.call['states'] unless value_type.to_s.upcase == 'RAW'
+        end
+        item_states
+      end
+      operator, operand = extract_operator_and_operand_from_comparison(comparison) do |name|
+        name.upcase if states.call&.key?(name.upcase)
+      end
+      return [operator, operand] unless operand_contains_string?(operand)
+
+      return [operator, states.call ? upcase_state_names(operand, states.call) : operand]
+    end
+
+    # Returns whether the operand is or contains a string, i.e. could be a state name
+    def operand_contains_string?(operand)
+      return true if operand.is_a?(String)
+      return operand.any? { |element| operand_contains_string?(element) } if operand.is_a?(Array)
+      return false
+    end
+
+    # State names are stored upper case so any string in the operand which matches
+    # a state name ignoring case is replaced with that state name
+    def upcase_state_names(operand, states)
+      if operand.is_a?(String)
+        return states.key?(operand.upcase) ? operand.upcase : operand
+      end
+      return operand.map { |element| upcase_state_names(element, states) } if operand.is_a?(Array)
+      return operand
+    end
+
+    # Compares a telemetry value against an operand using the given operator.
+    # Returns false rather than raising if the two values can not be compared.
+    def compare_values(value, operator, operand)
+      case operator
+      when "=="
+        value == operand
+      when "!="
+        value != operand
+      when ">"
+        value > operand
+      when ">="
+        value >= operand
+      when "<"
+        value < operand
+      when "<="
+        value <= operand
+      when "in"
+        # 'in' is containment against a list of values, matching Python
+        operand.is_a?(Array) && operand.include?(value)
+      else
+        raise "ERROR: Invalid operator: '#{operator}'"
+      end
+    rescue ArgumentError, NoMethodError, TypeError
+      # Comparing incompatible types, e.g. nil > 1, is simply not a match
+      false
     end
   end
 end

data/lib/openc3/script/plugins.rb

@@ -19,6 +19,7 @@ module OpenC3
       response_body = nil
       begin
         endpoint = "/openc3-api/plugins?scope=#{scope}"
+        endpoint += "&exclude_default=true" unless default
         uri = URI.parse($api_server.generate_url + endpoint)
         auth = $api_server.generate_auth
 
@@ -30,19 +31,11 @@ module OpenC3
           http.request(request) do |response|
             response_body = response.body
             response.value() # Raises an HTTP error if the response is not 2xx (success)
-            plugins = JSON.parse(response.body, allow_nan: true, create_additions: true)
-            if default
-              return plugins
-            else
-              return plugins.select do |plugin|
-                !plugin.include?('openc3-cosmos-tool-') and !plugin.include?('openc3-tool-base') and
-                !plugin.include?('openc3-cosmos-enterprise-tool-') and !plugin.include?('openc3-enterprise-tool-base')
-              end
-            end
+            return JSON.parse(response.body, allow_nan: true, create_additions: true)
           end
         end
       rescue => e
-        raise "get_plugin_list failed due to #{e.formatted}\nURI:#{uri}\nResponse:\n#{response_body}"
+        raise "plugin_list failed due to #{e.formatted}\nURI:#{uri}\nResponse:\n#{response_body}"
       end
     end
 
@@ -65,7 +58,7 @@ module OpenC3
           end
         end
       rescue => e
-        raise "get_plugin failed due to #{e.formatted}\nURI:#{uri}\nResponse:\n#{response_body}"
+        raise "plugin_get failed due to #{e.formatted}\nURI:#{uri}\nResponse:\n#{response_body}"
       end
     end
 

data/lib/openc3/script/script.rb

@@ -313,7 +313,7 @@ module OpenC3
           return disconnect if disconnect
           # The only commands allowed through in disconnect mode are read-only
           # Thus we allow the get, list, tlm and limits_enabled and subscribe methods
-          if method_name =~ /\w*_get$|^get_\w*|\w*_list$|^list_\w*|^tlm|^limits_enabled$|^subscribe$/
+          if method_name =~ /\w*_get$|^get_\w*|\w*_list$|^list_\w*|^tlm|^limits_enabled\??$|^subscribe$/
             return @json_drb.method_missing(method_name, *method_params, **kw_params)
           else
             return nil