rast 0.18.0 → 0.19.0

data/lib/rast/rules/logic_helper.rb

@@ -11,113 +11,38 @@ module LogicHelper
   TRUE = '*true'
   FALSE = '*false'
 
-  # /**
-  #  * @param scenario list of scenario tokens.
-  #  * @param left_subscript left index.
-  #  * @param right_subscript right index.
-  #  * @param left left token, no subscript.
-  #  * @param right right token, no subscript.
-  #  */
-  def perform_logical_and(scenario: [], left_subscript: -1, right_subscript: -1,
-                          left: nil, right: nil)
-    if FALSE == left && left_subscript == -1 || FALSE == right && right_subscript == -1
-      FALSE
-    elsif TRUE == left && left_subscript == -1 && TRUE == right && right_subscript == -1
-      TRUE
-    elsif TRUE == left && left_subscript == -1
-      if right_subscript < 0
-        scenario.include?(right).to_s
-      else
-        (scenario[right_subscript] == right).to_s
-      end
-    elsif TRUE == right && right_subscript == -1
-      if left_subscript < 0
-        scenario.include?(left).to_s
-      else
-        (scenario[left_subscript] == left).to_s
-      end
-    else
-      left_eval = pevaluate(
-        scenario: scenario,
-        subscript: left_subscript,
-        object: left
-      )
+  OPPOSITE = {
+    TRUE => FALSE,
+    FALSE => TRUE
+  }.freeze
 
-      return 'false' unless left_eval
-
-      right_eval = pevaluate(
-        scenario: scenario,
-        subscript: right_subscript,
-        object: right
-      )
-
-      (left_eval && right_eval).to_s
-    end
-  end
+  LOGIC_PRIMARY_RESULT = {
+    and: FALSE,
+    or: TRUE
+  }.freeze
 
   # /**
-  #  * @param scenario list of scenario tokens.
-  #  * @param left_subscript left index.
-  #  * @param right_subscript right index.
-  #  * @param left left token.
-  #  * @param right right token.
+  #  * @scenario list of scenario tokens.
+  #  * @left left left token object.
+  #  * @right right right token object.
+  #  * @operation :and or :or.
   #  */
-  def perform_logical_or(scenario: [], left_subscript: -1, right_subscript: -1,
-                         left: nil, right: nil)
-    if TRUE == left && left_subscript == -1 || TRUE == right && right_subscript == -1
-      TRUE
-    elsif FALSE == left && left_subscript == -1 && FALSE == right && right_subscript == -1
-      FALSE
-    elsif FALSE == left && left_subscript == -1
-      if right_subscript < 0
-        scenario.include?(right).to_s
-      else
-        (scenario[right_subscript] == right).to_s
-      end
-    elsif FALSE == right && right_subscript == -1
-      if left_subscript < 0
-        scenario.include?(left).to_s
-      else
-        (scenario[left_subscript] == left).to_s
-      end
-    else
-      left_eval = pevaluate(
-        scenario: scenario,
-        subscript: left_subscript,
-        object: left
-      )
+  def perform_logical(scenario: [], left: {}, right: {}, operation: :nil)
+    evaluated = send(:both_internal?, left, right, operation)
+    return evaluated if evaluated
 
-      return 'true' if left_eval
+    default = operation == :and ? TRUE : FALSE
+    return present?(scenario, right).to_s if internal_match?(default, left)
 
-      right_eval = pevaluate(
-        scenario: scenario,
-        subscript: right_subscript,
-        object: right
-      )
-
-      (left_eval || right_eval).to_s
-    end
-  end
+    return present?(scenario, left).to_s if internal_match?(default, right)
 
-  # /**
-  #  * Helper method to evaluate left or right token.
-  #  *
-  #  * @param scenario list of scenario tokens.
-  #  * @param subscript scenario token subscript.
-  #  * @param object left or right token.
-  #  */
-  def pevaluate(scenario: [], subscript: -1, object: nil)
-    if subscript < 0
-      scenario.include?(object)
-    else
-      scenario[subscript] == object
-    end
+    send("evaluate_#{operation}", scenario, left, right).to_s
   end
 
   # /**
   #  * Check if the token is opening bracket.
   #  *
-  #  * @param token Input <code>String</code> token
+  #  * @token Input <code>String</code> token
   #  * @return <code>boolean</code> output
   #  */
   def open_bracket?(token: '')
@@ -133,4 +58,60 @@ module LogicHelper
   def close_bracket?(token: '')
     token == ')'
   end
+
+  private
+
+  # @left hash containing token and subscript
+  # @right hash containing token and subscript
+  # @operation symbol either :and or :or
+  def both_internal?(left, right, operation)
+    default = LOGIC_PRIMARY_RESULT[operation]
+    if internal_match?(default, left) || internal_match?(default, right)
+      return default
+    end
+
+    opposite = OPPOSITE[default]
+    if internal_match?(opposite, left) && internal_match?(opposite, right)
+      return opposite
+    end
+
+    false
+  end
+
+  def evaluate_and(scenario, left, right)
+    left_eval = present?(scenario, left)
+
+    return false unless left_eval
+
+    right_eval = present?(scenario, right)
+    left_eval && right_eval
+  end
+
+  def evaluate_or(scenario, left, right)
+    left_eval = present?(scenario, left)
+
+    return true if left_eval
+
+    right_eval = present?(scenario, right)
+    left_eval || right_eval
+  end
+
+  # /**
+  #  * Helper method to evaluate left or right token.
+  #  *
+  #  * @param scenario list of scenario tokens.
+  #  * @param subscript scenario token subscript.
+  #  * @param object left or right token.
+  #  */
+  def present?(scenario, token)
+    if token[:subscript] < 0
+      scenario.include?(token[:value])
+    else
+      scenario[token[:subscript]] == token[:value]
+    end
+  end
+
+  def internal_match?(internal, token)
+    token[:value] == internal && token[:subscript] == -1
+  end
 end

data/lib/rast/rules/rule_evaluator.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require 'rast/rules/operator'
+require 'rast/rules/token_util'
 require 'rast/rules/logic_helper'
 require 'rast/converters/int_converter'
 require 'rast/converters/float_converter'
@@ -8,7 +9,7 @@ require 'rast/converters/default_converter'
 require 'rast/converters/bool_converter'
 require 'rast/converters/str_converter'
 
-# Evaluates the rules.
+# Evaluates the rules. "Internal refers to the `*true` or `*false` results."
 class RuleEvaluator
   include LogicHelper
 
@@ -99,27 +100,30 @@ class RuleEvaluator
   #  * @param rule_token_convert token to converter map.
   #  * @param default_converter default converter to use.
   #  */
-  def next_value(rule_token_convert: {}, default_converter: nil)
-    subscript = -1
-    retval = []
-    value = @stack_answer.pop
-
-    return [-1, value] if value.is_a? Array
-
-    if TRUE != value && FALSE != value
-      subscript = extract_subscript(token: value.to_s)
-      value_str = value.to_s.strip
-      value = if subscript > -1
-                value_token = value_str[/^.+(?=\[)/]
-                rule_token_convert[value_token].convert(value_token)
-              else
-                rule_token_convert[value_str].convert(value_str)
-              end
-    end
+  def next_value(rule_token_convert: {})
+    token = @stack_answer.pop
+    default = {
+      subscript: -1,
+      value: token
+    }
+
+    return default if token.is_a?(Array) || [TRUE, FALSE].include?(token)
+
+    next_value_default(rule_token_convert, token)
+  end
+
+  # private
+  def next_value_default(rule_token_convert, token)
+    token_cleaned = token.to_s.strip
+    subscript = TokenUtil.extract_subscript(token: token_cleaned)
+    token_body = subscript > -1 ? token_cleaned[/^.+(?=\[)/] : token_cleaned
+
+    raise "Config Error: Outcome clause token: '#{token}' not found in variables" if rule_token_convert[token_body].nil?
 
-    retval << subscript
-    retval << value
-    retval
+    {
+      value: rule_token_convert[token_body].convert(token_body),
+      subscript: subscript
+    }
   end
 
   # /** @param token token. */
@@ -127,39 +131,34 @@ class RuleEvaluator
     if open_bracket?(token: token)
       @stack_operations << token
     elsif close_bracket?(token: token)
-      while @stack_operations.any? &&
-            !open_bracket?(token: @stack_operations.last.strip)
-        @stack_rpn << @stack_operations.pop
-      end
-      @stack_operations.pop
+      shunt_close
     elsif operator?(token: token)
-      while !@stack_operations.empty? &&
-            operator?(token: @stack_operations.last.strip) &&
-            precedence(symbol_char: token[0]) <=
-            precedence(symbol_char: @stack_operations.last.strip[0])
-        @stack_rpn << @stack_operations.pop
-      end
-      @stack_operations << token
+      shunt_operator(token)
     else
       @stack_rpn << token
     end
   end
 
-  private
-
-  # /**
-  #  * Returns value of 'n' if rule token ends with '[n]'. where 'n' is the
-  #  * variable group index.
-  #  *
-  #  * @param string token to check for subscript.
-  #  */
-  def extract_subscript(token: '')
-    return -1 if token.is_a? Array
+  def shunt_operator(token)
+    while !@stack_operations.empty? &&
+          operator?(token: @stack_operations.last.strip) &&
+          precedence(symbol_char: token[0]) <=
+          precedence(symbol_char: @stack_operations.last.strip[0])
+      @stack_rpn << @stack_operations.pop
+    end
+    @stack_operations << token
+  end
 
-    subscript = token[/\[(\d+)\]$/, 1]
-    subscript.nil? ? -1 : subscript.to_i
+  def shunt_close
+    while @stack_operations.any? &&
+          !open_bracket?(token: @stack_operations.last.strip)
+      @stack_rpn << @stack_operations.pop
+    end
+    @stack_operations.pop
   end
 
+  private
+
   # /**
   #  * @param scenario List of values to evaluate against the rule expression.
   #  * @param rule_token_convert token to converter map.
@@ -170,29 +169,36 @@ class RuleEvaluator
 
     # /* get the clone of the RPN stack for further evaluating */
     stack_rpn_clone = Marshal.load(Marshal.dump(@stack_rpn))
+    evaluate_stack_rpn(stack_rpn_clone, scenario, rule_token_convert)
+
+    raise 'Some operator is missing' if @stack_answer.size > 1
 
-    # /* evaluating the RPN expression */
-    while stack_rpn_clone.any?
-      token = stack_rpn_clone.pop
+    last = @stack_answer.pop
+    last[1..last.size]
+  end
+
+  # evaluating the RPN expression
+  def evaluate_stack_rpn(stack_rpn, scenario, rule_token_convert)
+    while stack_rpn.any?
+      token = stack_rpn.pop
       if operator?(token: token)
-        if NOT.symbol == token
-          evaluate_multi_not(scenario: scenario)
-        else
-          evaluate_multi(
-            scenario: scenario,
-            rule_token_convert: rule_token_convert,
-            operator: RuleEvaluator.operator_from_symbol(symbol: token[0])
-          )
-        end
+        evaluate_operator(scenario, rule_token_convert, token)
       else
         @stack_answer << token
       end
     end
+  end
 
-    raise 'Some operator is missing' if @stack_answer.size > 1
-
-    last = @stack_answer.pop
-    last[1..last.size]
+  def evaluate_operator(scenario, rule_token_convert, token)
+    if NOT.symbol == token
+      evaluate_multi_not(scenario: scenario)
+    else
+      evaluate_multi(
+        scenario: scenario,
+        rule_token_convert: rule_token_convert,
+        operator: RuleEvaluator.operator_from_symbol(symbol: token[0])
+      )
+    end
   end
 
   # /**
@@ -201,35 +207,21 @@ class RuleEvaluator
   #  * @param operator OR/AND.
   #  */
   def evaluate_multi(scenario: [], rule_token_convert: {}, operator: nil)
-    default_converter = DEFAULT_CONVERT_HASH[scenario.first.class]
-
     # Convert 'nil' to nil.
-    formatted_scenario = scenario.map { |token| token == 'nil' ? nil: token }
+    formatted_scenario = scenario.map { |token| token == 'nil' ? nil : token }
 
-    left_arr = next_value(
-      rule_token_convert: rule_token_convert,
-      default_converter: default_converter
-    )
-
-    right_arr = next_value(
-      rule_token_convert: rule_token_convert,
-      default_converter: default_converter
-    )
+    left = next_value(rule_token_convert: rule_token_convert)
+    right = next_value(rule_token_convert: rule_token_convert)
 
     answer = send(
-      "perform_logical_#{operator.name}",
+      :perform_logical,
       scenario: formatted_scenario,
-      left_subscript: left_arr[0],
-      right_subscript: right_arr[0],
-      left: left_arr[1],
-      right: right_arr[1]
+      left: left,
+      right: right,
+      operation: operator.name.to_sym
     )
 
-    @stack_answer << if answer[0] == '*'
-                       answer
-                     else
-                       "*#{answer}"
-                     end
+    @stack_answer << format_internal_result(answer)
   end
 
   # /**
@@ -243,28 +235,38 @@ class RuleEvaluator
              elsif LogicHelper::FALSE == latest
                LogicHelper::TRUE
              else
-               subscript = extract_subscript(token: latest)
-               converter = DEFAULT_CONVERT_HASH[scenario.first.class]
-               if subscript < 0
-                 converted = converter.convert(latest)
-                 (!scenario.include?(converted)).to_s
-               else
-                 converted = converter.convert(latest[RE_TOKEN_BODY])
-                 (scenario[subscript] != converted).to_s
-               end
+               evaluate_non_internal(scenario, latest)
              end
 
-    @stack_answer << if answer[0] == '*'
-                       answer
-                     else
-                       "*#{answer}"
-                     end
+    @stack_answer << format_internal_result(answer)
+  end
+
+  def evaluate_non_internal(scenario, latest)
+    subscript = TokenUtil.extract_subscript(token: latest)
+    converter = DEFAULT_CONVERT_HASH[scenario.first.class]
+    if subscript < 0
+      converted = converter.convert(latest)
+      (!scenario.include?(converted)).to_s
+    else
+      converted = converter.convert(latest[RE_TOKEN_BODY])
+      (scenario[subscript] != converted).to_s
+    end
+  end
+
+  # returns true if answer starts with *, *true if answer is true, same goes for
+  # false.
+  def format_internal_result(answer)
+    if answer[0] == '*'
+      answer
+    else
+      "*#{answer}"
+    end
   end
 
   # /** @param scenario to evaluate against the rule expression. */
   def evaluate_one_rpn(scenario: [])
     single = @stack_rpn.last
-    subscript = extract_subscript(token: single)
+    subscript = TokenUtil.extract_subscript(token: single)
     default_converter = DEFAULT_CONVERT_HASH[scenario.first.class]
     if subscript > -1
       scenario[subscript] == default_converter.convert(single[RE_TOKEN_BODY])

data/lib/rast/rules/rule_validator.rb

@@ -11,8 +11,13 @@ class RuleValidator
     )
 
     spec = fixture[:spec]
-    rule = spec.rule
+    validate_results(scenario, rule_result, spec)
+  end
+
+  private
 
+  def validate_results(scenario, rule_result, spec)
+    rule = spec.rule
     single_result = rule.size == 1
     if single_result
       next_result = rule_result.first
@@ -23,8 +28,6 @@ class RuleValidator
     end
   end
 
-  private
-
   def validate_multi(scenario: [], spec: nil, rule_result: [])
     matched_outputs = []
     match_count = 0
@@ -36,14 +39,18 @@ class RuleValidator
       matched_outputs << spec.rule.outcomes[i]
     end
 
-    Rast.assert("#{spec.description} #{scenario} must fall into a unique rule outcome/clause, matched: #{matched_outputs}") do
-      match_count == 1 || match_count == 0 && !spec.default_outcome.nil?
-    end
+    verify_results(spec, scenario, matched_outputs, match_count)
 
     matched_outputs.first || spec.default_outcome
   end
 
-  #
+  def verify_results(spec, scenario, matched_outputs, match_count)
+    Rast.assert("#{spec.description} #{scenario} must fall into a unique rule" \
+      " outcome/clause, matched: #{matched_outputs}") do
+      match_count == 1 || match_count.zero? && !spec.default_outcome.nil?
+    end
+  end
+
   def binary_outcome(outcome: '', spec: nil, expected: false)
     if expected == 'true'
       outcome

data/lib/rast/rules/token_util.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+#
+module TokenUtil
+  # /**
+  #  * Returns value of 'n' if rule token ends with '[n]'. where 'n' is the
+  #  * variable group index.
+  #  *
+  #  * @param string token to check for subscript.
+  #  */
+  def self.extract_subscript(token: '')
+    return -1 if token.is_a? Array
+
+    subscript = token[/\[(\d+)\]$/, 1]
+    subscript.nil? ? -1 : subscript.to_i
+  end
+end