rast 0.1.0.pre

data/lib/rast/rules/rule.rb

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+# Represents a logical rule object.
+class Rule
+  # /**
+  #  * TODO: Validation of the output_clause_src parameter.
+  #  *
+  #  * Instantiate a rule with the given clause. <br/>
+  #  * <br/>
+  #  * <b>Parameter Example:</b><br/>
+  #  * Visible:Proposed|Approved<br/>
+  #  * <br/>
+  #  * Peace:Friendly|Indifferent\<br/>
+  #  * ~War:Angry\<br/>
+  #  * ~Neutral:Play safe
+  #  */
+  def initialize(rules: {})
+    raise 'Must not have empty rules' if rules.empty?
+
+    @outcome_clause_hash = {}
+    # should have array of the rule pairs
+    # rules = pActRuleSrc.split("~");
+    duplicates = []
+
+    rules.each do |outcome, clause|
+      if duplicates.include?(outcome)
+        raise "#{outcome} matched multiple clauses"
+      end
+
+      duplicates << outcome
+      clause = remove_spaces(string: clause, separator: '\(')
+      clause = remove_spaces(string: clause, separator: '\)')
+      clause = remove_spaces(string: clause, separator: '&')
+      clause = remove_spaces(string: clause, separator: '\|')
+      clause = remove_spaces(string: clause, separator: '!')
+      @outcome_clause_hash[outcome.to_s] = clause.strip
+    end
+  end
+
+  def size
+    @outcome_clause_hash.size
+  end
+
+  # /**
+  #  * Removes the leading and trailing spaces of rule tokens.
+  #  *
+  #  * @param string rule clause.
+  #  * @param separator rule clause token.
+  #  */
+  def remove_spaces(string: '', separator: '')
+    string.gsub(Regexp.new("\\s*#{separator} \\s*"), separator)
+  end
+
+  # /**
+  #  * @return the actionList
+  #  */
+  def outcomes
+    @outcome_clause_hash.keys
+  end
+
+  # /**
+  #  * @param action action which rule we want to retrieve.
+  #  * @return the actionToRuleClauses
+  #  */
+  def clause(outcome: '')
+    @outcome_clause_hash[outcome]
+  end
+
+  # /**
+  #  * Get rule result give a fixed list of scenario tokens. Used for fixed
+  #  * list.
+  #  *
+  #  * @param scenario of interest.
+  #  * @return the actionToRuleClauses
+  #  */
+  def rule_outcome(scenario: [])
+    scenario_string = scenario.to_s
+    anded_scenario = scenario_string[1..-2].gsub(/,\s/, '&')
+
+    @outcome_clause_hash.each do |key, clause|
+      or_list_clause = clause.split('\|').map(&:strip)
+      return key if or_list_clause.include?(anded_scenario)
+    end
+  end
+
+  # /**
+  #  * @see {@link Object#toString()}
+  #  * @return String representation of this instance.
+  #  */
+  def to_s
+    @outcome_clause_hash.to_s
+  end
+end

data/lib/rast/rules/rule_evaluator.rb

@@ -0,0 +1,273 @@
+# frozen_string_literal: true
+
+require_relative 'operator'
+require_relative 'logic_helper'
+require 'rast/converters/int_converter'
+require 'rast/converters/bool_converter'
+require 'rast/converters/str_converter'
+
+# Evaluates the rules.
+class RuleEvaluator
+  include LogicHelper
+
+  NOT = Operator.new(name: 'not', symbol: '!', precedence: 100)
+  AND = Operator.new(name: 'and', symbol: '&', precedence: 2)
+  OR = Operator.new(name: 'or', symbol: '|', precedence: 1)
+
+  OPERATORS = [NOT, AND, OR].freeze
+  OPERATORS_CONCAT = OPERATORS.map(&:to_s).join
+
+  # the "false" part of the "false[1]"
+  RE_TOKEN_BODY = /^.+(?=\[)/.freeze
+  RE_TOKENS = /([!|)(&])|([a-zA-Z\s0-9]+\[\d\])/.freeze
+
+  def self.operator_from_symbol(symbol: nil)
+    OPERATORS.find { |operator| operator.symbol == symbol }
+  end
+
+  DEFAULT_CONVERT_HASH = {
+    Integer => IntConverter.new,
+    TrueClass => BoolConverter.new,
+    FalseClass => BoolConverter.new,
+    String => StrConverter.new
+  }.freeze
+
+  # /** @param pConverterList list of rule token converters. */
+  def initialize(converters: [])
+    @converters = converters
+
+    @stack_operations = []
+    @stack_rpn = []
+    @stack_answer = []
+  end
+
+  # /**
+  #  * Parses the math expression (complicated formula) and stores the result.
+  #  *
+  #  * @param pExpression <code>String</code> input expression (logical
+  #  *            expression formula)
+  #  * @since 0.3.0
+  #  */
+  def parse(expression: '')
+    # /* cleaning stacks */
+    @stack_operations.clear
+    @stack_rpn.clear
+
+    # /* splitting input string into tokens */
+    tokens = expression.split(RE_TOKENS).reject(&:empty?)
+
+    # /* loop for handling each token - shunting-yard algorithm */
+    tokens.each { |token| shunt_internal(token: token.strip) }
+
+    @stack_rpn << @stack_operations.pop while @stack_operations.any?
+    @stack_rpn.reverse!
+  end
+
+  # /**
+  #  * Evaluates once parsed math expression with "var" variable included.
+  #  *
+  #  * @param scenario List of values to evaluate against the rule expression.
+  #  * @param rule_token_convert mapping of rule tokens to converter.
+  #  * @return <code>String</code> representation of the result
+  #  */
+  def evaluate(scenario: [], rule_token_convert: {})
+    # /* check if is there something to evaluate */
+    if @stack_rpn.empty?
+      true
+    elsif @stack_rpn.size == 1
+      evaluate_one_rpn(scenario: scenario)
+    else
+      evaluate_multi_rpn(
+        scenario: scenario,
+        rule_token_convert: rule_token_convert
+      )
+    end
+  end
+
+  # /**
+  #  * @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&.strip
+    if TRUE != value && FALSE != value
+      subscript = extract_subscript(token: value.to_s)
+      value_str = value.to_s.strip
+      if subscript > -1
+        converter = @converters[subscript]
+        value = converter.convert(value_str[/^.+(?=\[)/])
+      else
+        value = if rule_token_convert.nil? ||
+                   rule_token_convert[value_str].nil?
+                  default_converter.convert(value_str)
+                else
+                  rule_token_convert[value_str].convert(value_str)
+                end
+      end
+    end
+    retval << subscript
+    retval << value
+    retval
+  end
+
+  # /** @param token token. */
+  def shunt_internal(token: '')
+    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
+    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
+    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: '')
+    subscript = token[/\[(\d+)\]$/, 1]
+    subscript.nil? ? -1 : subscript.to_i
+  end
+
+  # /**
+  #  * @param scenario List of values to evaluate against the rule expression.
+  #  * @param rule_token_convert token to converter map.
+  #  */
+  def evaluate_multi_rpn(scenario: [], rule_token_convert: {})
+    # /* clean answer stack */
+    @stack_answer.clear
+
+    # /* get the clone of the RPN stack for further evaluating */
+    stack_rpn_clone = Marshal.load(Marshal.dump(@stack_rpn))
+
+    # /* evaluating the RPN expression */
+
+    # binding.pry
+
+    while stack_rpn_clone.any?
+      token = stack_rpn_clone.pop.strip
+      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
+      else
+        @stack_answer << token
+      end
+    end
+
+    raise 'Some operator is missing' if @stack_answer.size > 1
+
+    @stack_answer.pop[1..]
+  end
+
+  # /**
+  #  * @param scenario List of values to evaluate against the rule expression.
+  #  * @param rule_token_convert token to converter map.
+  #  * @param operator OR/AND.
+  #  */
+  def evaluate_multi(scenario: [], rule_token_convert: {}, operator: nil)
+    default_converter = DEFAULT_CONVERT_HASH[scenario.first.class]
+
+    # binding.pry
+
+    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
+    )
+
+    answer = send(
+      "perform_logical_#{operator.name}",
+      scenario: scenario,
+      left_subscript: left_arr[0],
+      right_subscript: right_arr[0],
+      left: left_arr[1],
+      right: right_arr[1]
+    )
+
+    @stack_answer << if answer[0] == '|'
+                       answer
+                     else
+                       "|#{answer}"
+                     end
+  end
+
+  # /**
+  #  * @param scenario List of values to evaluate against the rule expression.
+  #  */
+  def evaluate_multi_not(scenario: [])
+    left = @stack_answer.pop.strip
+
+    # binding.pry
+
+    answer = if LogicHelper::TRUE == left
+               LogicHelper::FALSE
+             elsif LogicHelper::FALSE == left
+               LogicHelper::TRUE
+             else
+               subscript = extract_subscript(token: left)
+               if subscript.negative?
+                 (!scenario.include?(left)).to_s
+               else
+                 default_converter = DEFAULT_CONVERT_HASH[scenario.first.class]
+                 converted = default_converter.convert(left[RE_TOKEN_BODY])
+                 (scenario[subscript] == converted).to_s
+               end
+             end
+
+    @stack_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)
+    if subscript > -1
+      default_converter = DEFAULT_CONVERT_HASH[scenario.first.class]
+      scenario[subscript] == default_converter.convert(single[RE_TOKEN_BODY])
+    else
+      scenario.include? single
+    end
+  end
+
+  def operator?(token: '')
+    !token.nil? && OPERATORS.map(&:symbol).include?(token)
+  end
+
+  def precedence(symbol_char: '')
+    RuleEvaluator.operator_from_symbol(symbol: symbol_char).precedence
+  end
+end

data/lib/rast/rules/rule_processor.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require_relative 'rule_evaluator'
+
+# undoc
+class RuleProcessor
+  # /**
+  #  * @param scenario current scenario.
+  #  * @param caseFixture current test case fixture.
+  #  */
+  def evaluate(scenario: [], fixture: nil)
+    # if scenario.empty? || fixture.nil?
+    #   raise 'Scenario or fixture cannot be nil.'
+    # end
+
+    fixture[:spec].rule.outcomes.inject([]) do |retval, outcome|
+      process_outcome(
+        scenario: scenario,
+        fixture: fixture,
+        list: retval,
+        outcome: outcome
+      )
+    end
+  end
+
+  private
+
+  def process_outcome(scenario: [], fixture: nil, list: [], outcome: '')
+    spec = fixture[:spec]
+
+    clause = spec.rule.clause(outcome: outcome)
+    rule_evaluator = RuleEvaluator.new(converters: spec.converters)
+
+    rule_evaluator.parse(expression: clause)
+
+    list << rule_evaluator.evaluate(
+      scenario: scenario,
+      rule_token_convert: fixture[:converter_hash]
+    )
+  end
+end

data/lib/rast/rules/rule_validator.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+require 'rast/assert'
+require_relative 'rule_processor'
+
+# Validates rules
+class RuleValidator
+  def validate(scenario: [], fixture: {})
+    rule_result = RuleProcessor.new.evaluate(
+      scenario: scenario,
+      fixture: fixture
+    )
+
+    spec = fixture[:spec]
+    rule = spec.rule
+
+    single_result = rule.size == 1
+    if single_result
+      next_result = rule_result.first
+      outcome = rule.outcomes.first
+      binary_outcome(outcome: outcome, spec: spec, expected: next_result)
+    else
+      validate_multi(scenario: scenario, spec: spec, rule_result: rule_result)
+    end
+  end
+
+  private
+
+  def validate_multi(scenario: [], spec: nil, rule_result: [])
+    # binding.pry
+
+    matched_outputs = []
+    match_count = 0
+
+    rule_result.map { |result| result == 'true' }.each_with_index do |result, i|
+      next unless result
+
+      match_count += 1
+      matched_outputs << spec.rule.outcomes[i]
+    end
+    assert("Scenario must fall into a unique rule output/clause:
+     #{scenario} , matched: #{matched_outputs}") { match_count == 1 }
+
+    matched_outputs.first
+  end
+
+  def binary_outcome(outcome: '', spec: nil, expected: false)
+    is_positive = spec.pair.keys.include?(outcome)
+    if is_positive
+      expected == 'true' ? outcome : opposite(outcome: outcome, spec: spec)
+    else
+      expected == 'true' ? opposite(outcome: outcome, spec: spec) : outcome
+    end
+  end
+
+  def opposite(outcome: '', spec: nil)
+    if spec.pair.keys.include? outcome
+      spec.pair[outcome]
+    else
+      spec.pair_reversed[outcome]
+    end
+  end
+end

data/lib/rast/spec_dsl.rb

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+require_relative 'parameter_generator'
+
+# Main DSL. This is the entry point of the test when running a spec.
+class SpecDSL
+  attr_accessor :subject, :rspec_methods, :execute_block, :prepare_block,
+                :transients, :outcomes, :fixtures
+
+  def initialize(subject: nil, fixtures: [], &block)
+    @subject = subject
+    @fixtures = fixtures
+
+    @transients = []
+    @result = nil
+    @rspec_methods = []
+
+    instance_eval(&block)
+  end
+
+  def result(outcome)
+    @outcome = outcome.to_s
+  end
+
+  def method_missing(method_name_symbol, *args, &block)
+    return super if method_name_symbol == :to_ary
+
+    @rspec_methods << {
+      name: method_name_symbol,
+      args: args.first,
+      block: block
+    }
+
+    self
+  end
+
+  def prepare(&block)
+    @prepare_block = block
+    @transients
+  end
+
+  def execute(&block)
+    @execute_block = block
+
+    @fixtures.sort_by! { |fixture| fixture[:expected_outcome] }
+    generate_rspecs
+  end
+
+  private
+
+  def generate_rspecs
+    spec = @fixtures.first[:spec]
+    main_scope = self
+
+    RSpec.describe "#{@subject.class}: #{spec.description}" do
+      main_scope.fixtures.each do |fixture|
+        generate_rspec(
+          scope: main_scope,
+          scenario: fixture[:scenario],
+          expected: fixture[:expected_outcome]
+        )
+      end
+    end
+  end
+end
+
+def generate_rspec(scope: nil, scenario: {}, expected: '')
+  spec_params = scenario.keys.inject('') do |output, key|
+    output += ', ' unless output == ''
+    output + "#{key}: #{scenario[key]}"
+  end
+
+  it "[#{expected}]=[#{spec_params}]" do
+    block_params = scenario.values
+    scope.prepare_block&.call(*block_params) unless scope.rspec_methods.any?
+
+    while scope.rspec_methods.any?
+      first_meth = scope.rspec_methods.shift
+      second_meth = scope.rspec_methods.shift
+      if first_meth[:name] == :allow && second_meth[:name] == :receive
+        allow(scope.subject)
+          .to receive(second_meth[:args], &second_meth[:block])
+      end
+      scope.rspec_methods.shift
+    end
+
+    actual = scope.execute_block.call(*block_params).to_s
+
+    expect(actual).to eq(expected)
+  end
+end
+
+# DSL Entry Point
+def spec(subject: nil, fixtures: [], &block)
+  SpecDSL.new(subject: subject, fixtures: fixtures, &block)
+end

data/lib/rast/version.rb

@@ -0,0 +1,3 @@
+module Rast
+  VERSION = '0.1.0.pre'.freeze
+end

data/lib/rast.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require 'rspec'
+require_relative 'rast/parameter_generator'
+require_relative 'rast/spec_dsl'
+
+# Main DSL. This is the entry point of the test when running a spec.
+class Rast
+# RSpec All scenario test
+#
+# Example:
+#   >> Hola.hi("spanish")
+#   => hola mundo
+#
+# Arguments:
+#   language: (String)
+
+
+
+  alias global_spec spec
+
+  def initialize(rasted_class, &block)
+    @rasted_class = rasted_class
+    @subject = rasted_class.new
+
+    spec_path = caller[2][/spec.*?\.rb/]
+    yaml_path = spec_path.gsub(/(\w+).rb/, 'rast/\\1.yml')
+
+    @generator = ParameterGenerator.new(yaml_path: yaml_path)
+
+    instance_eval(&block)
+  end
+
+  def spec(id, &block)
+    global_spec(
+      subject: @subject,
+      fixtures: @generator.generate_fixtures(spec_id: id),
+      &block
+    )
+  end
+end
+
+# DSL Entry Point
+def rast(rasted_class, &block)
+  Rast.new(rasted_class, &block)
+end

data/lib/template_spec.yml

@@ -0,0 +1,18 @@
+---
+specs:
+  spec_key:
+    description: Spec Description
+
+    variables:
+      param1:
+        - false
+        - true
+
+    converters:
+      - BoolConverter
+
+    rules:
+      'true': 'true[0]'
+
+    pair:
+      'true': 'false'

data/rast.gemspec

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require_relative 'lib/rast/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'rast'
+  spec.version       = Rast::VERSION
+  spec.authors       = ['Royce Remulla']
+  spec.email         = ['royce.com@gmail.com']
+
+  spec.summary       = 'RSpec AST - All Scenario Testing'
+  spec.description   = 'Extends RSpec functionality by using the catch-all-scenario testing (CAST) principle.'
+  spec.homepage      = 'https://github.com/roycetech/rast'
+  spec.license       = 'MIT'
+  spec.required_ruby_version = Gem::Requirement.new('>= 2.3.0')
+
+  # spec.metadata['allowed_push_host'] = "TODO: Set to 'http://mygemserver.com'"
+  # spec.metadata['homepage_uri'] = spec.homepage
+  # spec.metadata['source_code_uri'] = "TODO: Put your gem's public repo URL here."
+  # spec.metadata['changelog_uri'] = "TODO: Put your gem's CHANGELOG.md URL here."
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files = Dir.chdir(File.expand_path(__dir__)) do
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  end
+  spec.bindir        = 'exe'
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = %w[lib]
+end