logical operator symbols

[rarensu]

conditionals could support more normal-looking logical operator symbols, like

• == instead of .
• var!= as a shorthand for !var==

matching on "not empty" should feel more explicit. examples:

• var!=null
• var (no symbols)

someday, arithmetic like > or substring like in.

[rarensu]

import { getFieldValue } from './fieldUtils';

export const evaluateCondition = (condition, fields) => {
  // Add early return for null/empty conditions
  if (!condition) return false;

  const evaluateExpression = (expr) => {
    // Enhanced tokenizer to handle comparison operators and field references
    const tokens = expr.match(
      /(\|\||&&|==|!=|<=|>=|<|>|\(|\)|!|\^|\$[a-zA-Z0-9_]+|"[^"]*"|'[^']*'|[^\s\|\&\(\)!=<>]+)/g
    );
    
    if (!tokens) return false;

    const valuesStack = [];
    const operatorsStack = [];
    
    // Precedence table (higher number = higher precedence)
    const precedence = { 
      "||": 1, 
      "^": 2,
      "&&": 3, 
      "==": 4,
      "!=": 4,
      "<": 4,
      ">": 4,
      "<=": 4,
      ">=": 4,
      "!": 5 
    };

    // Check if a token is a comparison operator
    const isComparisonOperator = (op) => {
      return ["==", "!=", "<", ">", "<=", ">="].includes(op);
    };

    // Parse a value token
    const parseValue = (token) => {
      // Field reference (starts with $)
      if (token.startsWith('$')) {
        const fieldName = token.substring(1);
        const value = getFieldValue(fields, fieldName);
        
        // Handle objects with value property (like Select components)
        if (typeof value === 'object' && value?.value !== undefined) {
          return value.value;
        }
        return value;
      }
      
      // String literal (quoted)
      if ((token.startsWith('"') && token.endsWith('"')) ||
          (token.startsWith("'") && token.endsWith("'"))) {
        return token.slice(1, -1);
      }
      
      // Number literal
      if (!isNaN(token) && token !== '') {
        return parseFloat(token);
      }
      
      // Boolean literal
      if (token === 'true') return true;
      if (token === 'false') return false;
      
      // Null literal
      if (token === 'null') return null;
      
      // Default to string
      return token;
    };

    const applyOperator = () => {
      const operator = operatorsStack.pop();
      
      if (operator === "!") {
        const operand = valuesStack.pop();
        valuesStack.push(!operand);
      } else if (isComparisonOperator(operator)) {
        const right = valuesStack.pop();
        const left = valuesStack.pop();
        
        switch (operator) {
          case "==":
            valuesStack.push(left == right);
            break;
          case "!=":
            valuesStack.push(left != right);
            break;
          case "<":
            valuesStack.push(left < right);
            break;
          case ">":
            valuesStack.push(left > right);
            break;
          case "<=":
            valuesStack.push(left <= right);
            break;
          case ">=":
            valuesStack.push(left >= right);
            break;
        }
      } else {
        const right = valuesStack.pop();
        const left = valuesStack.pop();
        
        switch (operator) {
          case "&&":
            valuesStack.push(left && right);
            break;
          case "||":
            valuesStack.push(left || right);
            break;
          case "^":
            valuesStack.push(!!(left ^ right)); // XOR
            break;
        }
      }
    };

    let i = 0;
    while (i < tokens.length) {
      const token = tokens[i];
      
      if (precedence[token] !== undefined) {
        // Handle unary ! operator
        if (token === "!" && (i === 0 || tokens[i-1] === "(" || precedence[tokens[i-1]])) {
          operatorsStack.push(token);
        } else {
          // Binary operator
          while (
            operatorsStack.length &&
            operatorsStack[operatorsStack.length - 1] !== "(" &&
            precedence[operatorsStack[operatorsStack.length - 1]] >= precedence[token]
          ) {
            applyOperator();
          }
          operatorsStack.push(token);
        }
      } else if (token === "(") {
        operatorsStack.push(token);
      } else if (token === ")") {
        while (operatorsStack.length && operatorsStack[operatorsStack.length - 1] !== "(") {
          applyOperator();
        }
        operatorsStack.pop(); // Remove "("
      } else {
        // It's a value token
        valuesStack.push(parseValue(token));
      }
      
      i++;
    }

    // Apply remaining operators
    while (operatorsStack.length) {
      applyOperator();
    }
    
    return valuesStack[0];
  };

  return evaluateExpression(condition.trim());
};

[rarensu]

// Mock getFieldValue implementation for testing
const getFieldValue = (fields, fieldName) => fields[fieldName];

// Old syntax examples (for reference)
// "status.active" -> New: "$status == active"
// "count.5" -> New: "$count == 5"

// Example usage and tests
const testExamples = () => {
  // Mock fields for testing
  const fields = {
    status: 'active',
    count: 5,
    enabled: true,
    user: { value: 'admin' }, // Object with value property
    category: null
  };  

  // New syntax examples
  const tests = [
    ['$status == "active"', true],
    ['$status != "inactive"', true],
    ['$count > 3', true],
    ['$count <= 5', true],
    ['$enabled == true', true],
    ['$user == "admin"', true], // Handles object.value automatically
    ['$category == null', true],
    ['$status == "active" && $count > 3', true],
    ['$status == "active" || $count < 3', true],
    ['!($status == "inactive")', true],
    ['($count > 3) && ($enabled == true)', true],
    ['$count == 5 ^ $enabled == false', true], // XOR
  ];
  
  tests.forEach(([condition, expected]) => {
    try {
      const result = evaluateCondition(condition, fields);
      const pass = result === expected ? '✓' : '✗';
      console.log(`${pass} "${condition}" => ${result}`);
    } catch (error) {
      console.log(`✗ "${condition}" => Error: ${error.message}`);
    }
  });
};

console.log('Test Results:');
console.log('-------------');
testExamples();

[rarensu]

@pennings-tamu
how do you feel about
'condition': '$name == literal'