PC-24: Improve formula validation with dentaku

Author: PivtoranisV

app/models/item.rb

@@ -8,7 +8,7 @@ class Item < ApplicationRecord
   validate :fixed_parameters_values_must_be_numeric
   validate :pricing_options_values_must_be_numeric
   validates :calculation_formula, presence: true, if: :requires_calculation_formula?
-  validate :calculation_formula_must_be_valid, if: :requires_calculation_formula?
+  validates_with ItemFormulaSyntaxValidator
 
   def self.ransackable_attributes(_auth_object = nil)
     %w[category_id created_at id is_disabled name updated_at]
@@ -73,48 +73,4 @@ def numeric?(val)
   def requires_calculation_formula?
     is_fixed || is_open || is_selectable_options
   end
-
-  def calculation_formula_must_be_valid
-    return if calculation_formula.blank?
-
-    check_all_formula_parameters_present
-    check_allowed_parameters
-    check_parentheses_balanced
-  end
-
-  def check_all_formula_parameters_present
-    missing_parameters = formula_parameters.reject do |param|
-      calculation_formula.match?(/\b#{Regexp.escape(param)}\b/)
-    end
-
-    return unless missing_parameters.any?
-
-    errors.add(:calculation_formula, "is missing parameters: #{missing_parameters.join(', ')}")
-  end
-
-  def check_allowed_parameters
-    operators = %w[+ - * / % ( )]
-
-    invalid_parameters = calculation_formula.split(' ').reject do |param|
-      param.match?(/\A\d+(\.\d+)?\z/) || # Matches numbers
-        operators.include?(param) || # Matches operators
-        formula_parameters.include?(param) # Matches formula parameters
-    end
-
-    return unless invalid_parameters.any?
-
-    errors.add(:calculation_formula, "contains invalid parameters: #{invalid_parameters.join(', ')}")
-  end
-
-  def check_parentheses_balanced
-    parentheses = []
-    calculation_formula.each_char do |char|
-      parentheses.push(char) if char == '('
-      parentheses.pop if char == ')' && parentheses.any?
-    end
-
-    return unless parentheses.any? || calculation_formula.count('(') != calculation_formula.count(')')
-
-    errors.add(:calculation_formula, 'has unbalanced parentheses')
-  end
 end

app/validators/item_formula_syntax_validator.rb

@@ -0,0 +1,72 @@
+class ItemFormulaSyntaxValidator < ActiveModel::Validator
+  def validate(record)
+    return if record.calculation_formula.blank?
+    return unless requires_calculation_formula?(record)
+
+    check_all_formula_parameters_present(record)
+    check_allowed_parameters(record)
+    check_operator_placement(record)
+    validate_formula_syntax(record)
+  end
+
+  private
+
+  def requires_calculation_formula?(record)
+    record.is_fixed || record.is_open || record.is_selectable_options
+  end
+
+  def check_all_formula_parameters_present(record)
+    missing_parameters = record.formula_parameters.reject do |param|
+      record.calculation_formula.match?(/\b#{Regexp.escape(param)}\b/)
+    end
+
+    return if missing_parameters.empty?
+
+    record.errors.add(:calculation_formula, "is missing parameters: #{missing_parameters.join(', ')}")
+  end
+
+  def check_allowed_parameters(record)
+    operators = %w[+ - * / % ( )]
+
+    invalid_parameters = record.calculation_formula.split(' ').reject do |param|
+      param.match?(/\A\d+(\.\d+)?\z/) ||
+        operators.include?(param) ||
+        record.formula_parameters.include?(param)
+    end
+
+    return if invalid_parameters.empty?
+
+    record.errors.add(:calculation_formula, "contains invalid parameters: #{invalid_parameters.join(', ')}")
+  end
+
+  def check_operator_placement(record)
+    if record.calculation_formula.match?(%r{\A\s*[+\-*/%]})
+      record.errors.add(:calculation_formula, "cannot start with a mathematical operator")
+    end
+    return unless record.calculation_formula.match?(%r{[+\-*/%]\s*\z})
+
+    record.errors.add(:calculation_formula, "cannot end with a mathematical operator")
+  end
+
+  def validate_formula_syntax(record)
+    calculator = Dentaku::Calculator.new
+    calculator.dependencies(record.calculation_formula)
+  rescue Dentaku::ParseError => e
+    handle_parse_error(record, e)
+  rescue StandardError => e
+    record.errors.add(:calculation_formula, "could not validate formula: #{e.message}")
+  end
+
+  def handle_parse_error(record, error)
+    case error.message
+    when /Undefined function/
+      record.errors.add(:calculation_formula, "references an undefined function. Please review formula structure.")
+    when /too few operands/
+      record.errors.add(:calculation_formula, "has missing operands. Ensure the correct number of arguments.")
+    when /has too many/
+      record.errors.add(:calculation_formula, "has extra operands. Ensure the correct number of arguments.")
+    else
+      record.errors.add(:calculation_formula, "has a syntax error: #{error.message}")
+    end
+  end
+end