rast 0.15.1 → 0.18.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c182ee63c3f1cb18ff294cd27be2dca33553cc9f15295ee50848274fdf0a6b90
-  data.tar.gz: 69de9f82cbc4dd45c5c8ac8a275a2eb586fe5cd531ec3ef52638b70c035e7ebd
+  metadata.gz: 77e02b108231f3d36dd5e490e9a0ab9cf1334ebb53ae6ffce93cbec2c124423b
+  data.tar.gz: a738c7603f64ec75eff5a13c87fa472d147c1262efb0340d2b500d76fa590826
 SHA512:
-  metadata.gz: ee7e4c7fd412ef942a78be18fddaac3b58718724f2ad89f83f728781a347913202d80abe81c99d1b43bbe06030d7de8cfbd735a3a87f9f3ebe0b39b19bd5bf1b
-  data.tar.gz: 4cd8885dab731bf4a4c3bed1d2402099545a0bc53b97a26207f99e4190f8508bdc1c2ae2b687bd51f441d29438d313335aa384e470aee298a4a433b411bfa7d3
+  metadata.gz: 88fc71ee6789773bd21b743c9e8bafbabc07654fbc2494f65e7b855930f32f686222ffe0ada7ecafeab1a828b9f45f8a9d94debf5ca7c87603edfbf39e10e4b3
+  data.tar.gz: '01409ef86dc48e884d0a4afd8cfa6113c054a4bd70aa19e8d5ab34d0fac5f50119f4e26924634dea6c8e710ba131fc1cfaf79ae07a884a40a48e8e6be2a84346'

data/CHANGELOG.md

@@ -1,5 +1,17 @@
 # Change log
 
+- 0.18.0 - [feature] xspec to skip a test
+         - [feature] Added include rule to isolate scenarios.
+         - [feature] Asterisk can be used as token character.
+         - [bug] Duplicate outcome wasn't detected when there's default config.
+         - [enhancement] Early return for 'and' and 'or' operators.
+
+- 0.17.0 - Allow default outcome for unmatched scenarios.
+- 0.16.0 - Allow isolation of scenarios via include clause.
+- 0.15.4 - Fix bug on logic checker for not operation.
+- 0.15.3 - Fix use of boolean as key to the config.
+         - Fix allow factory to be called inside both execute and prepare block.
+- 0.15.2 - Fix handling of nil token, and big integers.
 - 0.15.1 - Fix converters when variable is multi typed.
 - 0.14.0 - Introduced an else config as substitute for pair.
 - 0.13.0 - Make pair in config optional for boolean result.

data/Getting-Started.md

@@ -0,0 +1,139 @@
+# Getting Started
+
+
+
+## Tutorials
+
+
+
+### Writing a simple test.
+
+Suppose we want to create a class that checks if a number is a positive number or not.
+
+#### Step 1: Defining how to exercise the system under test.
+
+Start by creating a spec file inside your `spec` folder, let's call it `positive_spec.rb`
+
+- spec
+    - positive_spec.rb
+
+
+`positive_spec.rb` would look like this:
+
+```
+require 'rast'
+
+rast Positive do
+  spec 'Is Positive Example' do
+    execute { |number| subject.positive?(number) }
+  end
+end
+```
+
+- On line: 1, the library is required:
+
+```
+require 'rast'
+```
+
+- On line: 3, invoke the DSL:
+
+```
+rast Positive do
+```
+`Positive` is the fully qualified name of the class or the module to be tested.
+
+- On line: 4, define the first spec:
+
+```
+  spec 'Is Positive Example' do
+```
+
+`'Is Positive Example'` is a descriptive identifier for the test. It can be the name of the method like `#positive?`.
+
+- On line: 5, define the `execute` block..
+
+```
+execute { |number| subject.positive?(number) }
+```
+
+There is a lot going on here.<br>
+- Inside the block, we define how our subject will be invoked. The `positive?` method is invoked on the `subject`
+accepting a parameter.
+- Block parameter `number` will contain the test scenario we want to execute. More on this later. Just know that whichever values are passed here, the `subject` has to be able to handle it correctly.
+- `subject` is an instance of the module or class that we defined on line: 3.
+- And lastly, `execute` block expects a return value that will be verified when the spec is run.
+
+#### Step 2: Defining outcomes and the variables that affects the test.
+
+For the sake of simplicity, we will define the variables and outcomes in a separate yaml file, mainly because the next
+steps are purely configurations. Using yaml is completely optional.
+
+Create a folder `rast` in the same level as the spec file:
+
+- spec
+    - rast
+
+Create a yaml file with the same name as the spec, but with `.yml` extension.
+
+`spec/rast/positive_spec.yml` would contain:
+
+```
+specs:
+  Is Positive Exaple:
+    variables: {number: [-1, 0, 1]}
+    outcomes: {true: 1}
+```
+
+- On line: 1 is the root configuration element `specs` that will contain one or more specs.
+- On line: 2 `Is Positive Example` is the spec identifier, this must match what we've defined on `positive_spec.rb:4`
+- On line: 3, The variables that affect the SUT are defined, in this case there is only one variable called `number`,
+which has 3 different possibilities `-1`, `0`, and `1`.
+- On line: 4, This is where outcome to rule mapping is defined.
+
+### The implementation file
+
+positive.rb will have:
+
+```
+class Positive
+  def positive?(number)
+    number > 0
+  end
+end
+```
+
+## How To's
+
+### Use token subscript when there's a variable token clash.
+
+In cases where multiple variables, `left` and `right`, has the same set of tokens `false` and `true`:
+
+```
+    variables:
+      left: [false, true]
+      right: [false, true]
+```
+
+We need a way to uniquely identify the tokens in the `outcomes` configuration. We can do so by using a subscript in the format: `token[n]`
+For Example:
+
+```
+outcomes: {true: 'true[0] & true[1]'}
+```
+
+The subscript `0` would refer to the `true` token in the `left` variable and subscript `1` would refer to the `true` 
+token in the `right` variable.  
+
+
+## References
+
+### Outcomes
+
+
+## Current Limitations.
+
+
+
+
+

data/examples/logic_checker.rb

@@ -20,4 +20,12 @@ class LogicChecker
   def or(argument1, argument2)
     argument1 || argument2
   end
+
+  # Perform logical XOR operation on two arguments.
+  #
+  # @param argument1 first argument of Boolean type.
+  # @param argument2 second argument of Boolean type.
+  def xor(argument1, argument2)
+    argument1 && !argument2 || !argument1 && argument2
+  end
 end

data/examples/lohika.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+# LogicChecker ported from Java
+#
+# @author Royce Remulla
+#
+class Lohika
+  # Perform logical AND operation on two arguments.
+  #
+  # @param argument1 first argument of Boolean type.
+  # @param argument2 second argument of Boolean type.
+  def at(argument1, argument2)
+    return :oo if argument1 == 'oo' && argument2 == 'oo'
+
+    :hindi
+  end
+
+  # Perform logical OR operation on two arguments.
+  #
+  # @param argument1 first argument of Boolean type.
+  # @param argument2 second argument of Boolean type.
+  def o(argument1, argument2)
+    return :oo if argument1 == 'oo' || argument2 == 'oo'
+
+    :hindi
+  end
+end

data/examples/positive.rb

@@ -3,8 +3,6 @@
 # Example single number answer
 class Positive
   def positive?(number)
-    raise "Invalid parameter: #{number}" unless number.is_a?(Integer) || number.is_a?(Float)
-
     number > 0
   end
 end

data/examples/positive2.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+# Example single number answer
+class Positive2
+  def positive?(number)
+    raise 'Invalid' unless number.is_a? Numeric
+
+    number > 0
+  end
+end

data/examples/quiz_module.rb

@@ -16,21 +16,6 @@ module QuizModule
     Regexp::IGNORECASE
   )
 
-  def quiz?(front = nil, back = nil)
-    initialized = [true, false].include? @quiz
-    @quiz = quiz_choice?(back) || quiz_fill_blank?(front) unless initialized
-    @quiz
-  end
-
-  def quiz_choice?(back = nil)
-    initialized = [true, false].include? @choice
-    unless initialized
-      @choice = quiz_single_choice?(back) || quiz_multi_choice?(back)
-    end
-
-    @choice
-  end
-
   def quiz_multi_choice?(back)
     if back.is_a?(Array) && back.any?
       back.each { |element| return false unless element[RE_QUIZ_OPTION_M] }
@@ -46,33 +31,4 @@ module QuizModule
     end
     false
   end
-
-  def quiz_single_choice?(back)
-    if back.is_a?(Array) && back.any?
-      back.each { |element| return false unless element[RE_QUIZ_OPTION_S] }
-
-      # Find at least 1 selected answer
-      selected = back.filter do |element|
-        true if element[RE_SELECTED]
-      end
-      return false unless selected.size == 1
-
-      @quiz = true
-      @front_only = true
-      return true
-    end
-    false
-  end
-
-  def quiz_fill_blank?(front)
-    return true if (front.size == 1) && front.first[/_____/]
-
-    false
-  end
-
-  private
-
-  def choices_with_header(back)
-
-  end
 end

data/lib/rast/converters/str_converter.rb

@@ -3,6 +3,6 @@
 # Converts string into number
 class StrConverter
   def convert(string)
-    string
+    string unless string == 'nil'
   end
 end

data/lib/rast/parameter_generator.rb

@@ -6,8 +6,6 @@ require 'rast/rules/rule'
 require 'rast/rules/rule_evaluator'
 require 'rast/rules/rule_validator'
 
-require 'rast/converters/default_converter'
-
 # Generates the test parameters.
 class ParameterGenerator
   # Allow access so yaml-less can build the config via dsl.
@@ -24,7 +22,11 @@ class ParameterGenerator
     spec_config = @specs_config[spec_id]
 
     spec_config[:description] = spec_id
+
+    # Keep, for backwards compatibility
     spec_config['rules'] ||= spec_config['outcomes']
+    spec_config['default'] ||= spec_config['else']
+
     spec = instantiate_spec(spec_config)
 
     list = []
@@ -43,13 +45,25 @@ class ParameterGenerator
   private
 
   def valid_case?(scenario, spec)
-    return true if spec.exclude_clause.nil?
+    return true if spec.exclude_clause.nil? && spec.include_clause.nil?
 
-    exclude_clause = Rule.sanitize(clause: spec.exclude_clause)
     rule_evaluator = RuleEvaluator.new(converters: spec.converters)
-    rule_evaluator.parse(expression: exclude_clause)
 
-    rule_evaluator.evaluate(scenario: scenario, rule_token_convert: spec.token_converter) == "false"
+    include_result = true
+    unless spec.exclude_clause.nil?
+      exclude_clause = Rule.sanitize(clause: spec.exclude_clause)
+      rule_evaluator.parse(expression: exclude_clause)
+      evaluate_result = rule_evaluator.evaluate(scenario: scenario, rule_token_convert: spec.token_converter)
+      include_result = evaluate_result == 'false'
+    end
+
+    return include_result if spec.include_clause.nil? || !include_result
+
+    include_clause = Rule.sanitize(clause: spec.include_clause)
+    rule_evaluator.parse(expression: include_clause)
+    include_result = rule_evaluator.evaluate(scenario: scenario, rule_token_convert: spec.token_converter) == "true"
+
+    include_result
   end
 
   # add all fixtures to the list.
@@ -57,7 +71,10 @@ class ParameterGenerator
     validator = RuleValidator.new
 
     scenarios.each do |scenario|
-      next unless valid_case?(scenario, spec)
+      good = valid_case?(scenario, spec)
+      # p "#{good} #{scenario}"
+
+      next unless good
 
       list << build_param(validator, scenario, spec)
     end
@@ -109,7 +126,8 @@ class ParameterGenerator
     spec = RastSpec.new(
       description: spec_config[:description],
       variables: spec_config['variables'],
-      rule: Rule.new(rules: spec_config['rules'])
+      rule: Rule.new(rules: spec_config['rules']),
+      default_outcome: spec_config['default'] || spec_config['else']
     )
 
     pair_config = calculate_pair(spec_config)
@@ -119,6 +137,10 @@ class ParameterGenerator
       spec.init_exclusion(spec_config['exclude'])
     end
 
+    unless spec_config['include'].nil?
+      spec.init_inclusion(spec_config['include'])
+    end
+
     converters_config = spec_config['converters']
     converters = if converters_config.nil?
                    # when no converters defined, we detect if type is consistent, otherwise assume it's string.
@@ -130,14 +152,6 @@ class ParameterGenerator
                        default_converter
                      end
                    end
-                 elsif converters_config.first.class == String
-                   # when converters defined, determined by the converter name as String.
-                   spec_config['converters'].map do |converter|
-                     Object.const_get(converter).new
-                   end
-                 else
-                   # converters defined, probably programmatically when yaml-less, just return it.
-                   converters_config
                  end
 
     spec.init_converters(converters: converters)
@@ -157,7 +171,7 @@ class ParameterGenerator
         return { outcomes.first => outcomes.first == 'true' ? 'false' : 'true' }
       end
 
-      return { outcomes.first => spec_config['else'] } if spec_config['else']
+      return { outcomes.first => spec_config['default'] } if spec_config['default']
     end
 
     {}

data/lib/rast/rast_spec.rb

@@ -7,17 +7,20 @@ class RastSpec
   # token_converter is the mapping of a variable token to a converter
   # converters is a list of converters used via positional tokens.
   attr_reader :variables, :pair, :pair_reversed, :rule, :description,
-              :exclude_clause, :token_converter, :converters
+              :exclude_clause, :include_clause, :token_converter, :converters,
+              :default_outcome
 
   attr_accessor :exclude
 
-  def initialize(description: '', variables: [][], rule: nil)
+  def initialize(description: '', variables: [][], rule: nil, default_outcome: '')
     @description = description
     @variables = variables
     @pair = {}
     @pair_reversed = {}
     @rule = rule
     @exclude_clause = nil
+    @include_clause = nil
+    @default_outcome = default_outcome
   end
 
   def init_pair(pair_config: {})
@@ -47,13 +50,8 @@ class RastSpec
     self
   end
 
-  def to_s
-    "Class: #{self.class}
-Description: #{@description}
-Variables: #{@variables}
-Rules: #{@rules}
-Pair: #{@pair}
-Converters: #{@converters}
-    "
+  def init_inclusion(include_clause)
+    @include_clause = include_clause
+    self
   end
 end

data/lib/rast/rules/logic_helper.rb

@@ -8,29 +8,29 @@ module LogicHelper
   #  * @author Royce
   #  */
 
-  TRUE = '|true'
-  FALSE = '|false'
+  TRUE = '*true'
+  FALSE = '*false'
 
   # /**
   #  * @param scenario list of scenario tokens.
   #  * @param left_subscript left index.
   #  * @param right_subscript right index.
-  #  * @param left left token.
-  #  * @param right right token.
+  #  * @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 || FALSE == right
+    if FALSE == left && left_subscript == -1 || FALSE == right && right_subscript == -1
       FALSE
-    elsif TRUE == left && TRUE == right
+    elsif TRUE == left && left_subscript == -1 && TRUE == right && right_subscript == -1
       TRUE
-    elsif TRUE == left
+    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
+    elsif TRUE == right && right_subscript == -1
       if left_subscript < 0
         scenario.include?(left).to_s
       else
@@ -43,6 +43,8 @@ module LogicHelper
         object: left
       )
 
+      return 'false' unless left_eval
+
       right_eval = pevaluate(
         scenario: scenario,
         subscript: right_subscript,
@@ -62,21 +64,21 @@ module LogicHelper
   #  */
   def perform_logical_or(scenario: [], left_subscript: -1, right_subscript: -1,
                          left: nil, right: nil)
-    if TRUE == left || TRUE == right
+    if TRUE == left && left_subscript == -1 || TRUE == right && right_subscript == -1
       TRUE
-    elsif FALSE == left && FALSE == right
+    elsif FALSE == left && left_subscript == -1 && FALSE == right && right_subscript == -1
       FALSE
-    elsif FALSE == left
+    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
+    elsif FALSE == right && right_subscript == -1
       if left_subscript < 0
         scenario.include?(left).to_s
       else
-        (scenario[left_subscript]).to_s == left
+        (scenario[left_subscript] == left).to_s
       end
     else
       left_eval = pevaluate(
@@ -85,6 +87,8 @@ module LogicHelper
         object: left
       )
 
+      return 'true' if left_eval
+
       right_eval = pevaluate(
         scenario: scenario,
         subscript: right_subscript,

data/lib/rast/rules/rule.rb

@@ -23,11 +23,11 @@ class Rule
     duplicates = []
 
     rules.each do |outcome, clause|
-      if duplicates.include?(outcome)
-        raise "#{outcome} matched multiple clauses"
-      end
+      # if duplicates.include?(outcome)
+      #   raise "#{outcome} matched multiple clauses"
+      # end
 
-      duplicates << outcome
+      # duplicates << outcome
 
       @outcome_clause_hash[outcome.to_s] = Rule.sanitize(clause: clause)
     end
@@ -35,7 +35,7 @@ class Rule
 
   def self.sanitize(clause: '')
     return clause if clause.is_a?(Array)
-    
+
     cleaner = Rule.remove_spaces(token: clause, separator: '(')
     cleaner = Rule.remove_spaces(token: cleaner, separator: ')')
     cleaner = Rule.remove_spaces(token: cleaner, separator: '&')
@@ -72,29 +72,4 @@ class Rule
   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

@@ -21,7 +21,7 @@ class RuleEvaluator
 
   # the "false" part of the "false[1]"
   RE_TOKEN_BODY = /^.+(?=\[)/.freeze
-  RE_TOKENS = /([!|)(&])|([a-zA-Z\s0-9-]+\[\d\])/.freeze
+  RE_TOKENS = /([!|)(&])|([*a-zA-Z\s0-9-]+\[\d\])/.freeze
 
   def self.operator_from_symbol(symbol: nil)
     OPERATORS.find { |operator| operator.symbol == symbol }
@@ -30,7 +30,7 @@ class RuleEvaluator
   DEFAULT_CONVERT_HASH = {
     Integer => IntConverter.new,
     Float => FloatConverter.new,
-    Fixnum => FloatConverter.new,
+    Fixnum => IntConverter.new,
     Array => DefaultConverter.new,
     TrueClass => BoolConverter.new,
     FalseClass => BoolConverter.new,
@@ -85,10 +85,7 @@ class RuleEvaluator
   #  * @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
+    if @stack_rpn.size == 1
       evaluate_one_rpn(scenario: scenario).to_s
     else
       evaluate_multi_rpn(
@@ -112,18 +109,14 @@ class RuleEvaluator
     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
+      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
+
     retval << subscript
     retval << value
     retval
@@ -161,6 +154,8 @@ class RuleEvaluator
   #  * @param string token to check for subscript.
   #  */
   def extract_subscript(token: '')
+    return -1 if token.is_a? Array
+
     subscript = token[/\[(\d+)\]$/, 1]
     subscript.nil? ? -1 : subscript.to_i
   end
@@ -177,9 +172,6 @@ class RuleEvaluator
     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
       if operator?(token: token)
@@ -211,7 +203,8 @@ class RuleEvaluator
   def evaluate_multi(scenario: [], rule_token_convert: {}, operator: nil)
     default_converter = DEFAULT_CONVERT_HASH[scenario.first.class]
 
-    # binding.pry
+    # Convert 'nil' to nil.
+    formatted_scenario = scenario.map { |token| token == 'nil' ? nil: token }
 
     left_arr = next_value(
       rule_token_convert: rule_token_convert,
@@ -225,17 +218,17 @@ class RuleEvaluator
 
     answer = send(
       "perform_logical_#{operator.name}",
-      scenario: scenario,
+      scenario: formatted_scenario,
       left_subscript: left_arr[0],
       right_subscript: right_arr[0],
       left: left_arr[1],
       right: right_arr[1]
     )
 
-    @stack_answer << if answer[0] == '|'
+    @stack_answer << if answer[0] == '*'
                        answer
                      else
-                       "|#{answer}"
+                       "*#{answer}"
                      end
   end
 
@@ -243,29 +236,28 @@ class RuleEvaluator
   #  * @param scenario List of values to evaluate against the rule expression.
   #  */
   def evaluate_multi_not(scenario: [])
-    left = @stack_answer.pop.strip
-
-    # binding.pry
+    latest = @stack_answer.pop.strip
 
-    answer = if LogicHelper::TRUE == left
+    answer = if LogicHelper::TRUE == latest
                LogicHelper::FALSE
-             elsif LogicHelper::FALSE == left
+             elsif LogicHelper::FALSE == latest
                LogicHelper::TRUE
              else
-               subscript = extract_subscript(token: left)
+               subscript = extract_subscript(token: latest)
+               converter = DEFAULT_CONVERT_HASH[scenario.first.class]
                if subscript < 0
-                 (!scenario.include?(left)).to_s
+                 converted = converter.convert(latest)
+                 (!scenario.include?(converted)).to_s
                else
-                 default_converter = DEFAULT_CONVERT_HASH[scenario.first.class]
-                 converted = default_converter.convert(left[RE_TOKEN_BODY])
-                 (scenario[subscript] == converted).to_s
+                 converted = converter.convert(latest[RE_TOKEN_BODY])
+                 (scenario[subscript] != converted).to_s
                end
              end
 
-    @stack_answer << if answer[0] == '|'
+    @stack_answer << if answer[0] == '*'
                        answer
                      else
-                       "|#{answer}"
+                       "*#{answer}"
                      end
   end
 

data/lib/rast/rules/rule_validator.rb

@@ -26,8 +26,6 @@ class RuleValidator
   private
 
   def validate_multi(scenario: [], spec: nil, rule_result: [])
-    # binding.pry
-
     matched_outputs = []
     match_count = 0
 
@@ -37,26 +35,20 @@ class RuleValidator
       match_count += 1
       matched_outputs << spec.rule.outcomes[i]
     end
-    Rast.assert("Scenario must fall into a unique rule output/clause:
-     #{scenario} , matched: #{matched_outputs}") { match_count == 1 }
 
-    matched_outputs.first
+    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
+
+    matched_outputs.first || spec.default_outcome
   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)
+    if expected == 'true'
+      outcome
     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

@@ -8,10 +8,10 @@ class SpecDSL
   include FactoryGirl::Syntax::Methods
 
   attr_accessor :subject, :rspec_methods, :execute_block,
-                :prepare_block, :transients, :outcomes, :fixtures
+                :prepare_block, :transients, :outcomes, :fixtures, :spec_id
 
   # # yaml-less
-  attr_writer :variables, :exclude, :converters, :rules, :pair
+  attr_writer :variables, :exclude, :include, :converters, :rules, :pair, :default_outcome
 
   # @subject the sut instance
   # @name the sut name to be displayed with -fd
@@ -29,23 +29,6 @@ class SpecDSL
     instance_eval(&block)
   end
 
-  def respond_to_missing?(*several_variants)
-    super(several_variants)
-  end
-
-  def method_missing(method_name_symbol, *args, &block)
-    # p "method_missing: #{method_name_symbol}"
-    return super if method_name_symbol == :to_ary
-
-    @rspec_methods << {
-      name: method_name_symbol,
-      args: args.first,
-      block: block
-    }
-
-    self
-  end
-
   # yaml-less start
   def variables(vars)
     @variables = vars
@@ -55,16 +38,18 @@ class SpecDSL
     @exclude = clause
   end
 
-  def converters(&block)
-    @converters = instance_eval(&block)
-  end
-
   def rules(rules)
-    @rules = rules
+    @rules = {}
+
+    rules.each do |key, value|
+      calc_key = key
+      calc_key = key == :true if key == :true || key == :false
+      @rules[calc_key] = value
+    end
   end
 
-  def pair(pair)
-    @pair = pair
+  def outcomes(outcomes)
+    rules(outcomes)
   end
 
   # yaml-less end
@@ -91,9 +76,17 @@ class SpecDSL
     end
 
     @fixtures.sort_by! do |fixture|
+
+      if fixture[:expected_outcome].nil?
+        raise 'Broken initialization, check your single rule/else/default configuration'
+      end
+
       fixture[:expected_outcome] + fixture[:scenario].to_s
+      # fixture[:scenario].to_s + fixture[:expected_outcome]
     end
 
+    # @fixtures.reverse!
+
     generate_rspecs
   end
 
@@ -103,8 +96,13 @@ class SpecDSL
     main_scope = self
 
     title = "#{@subject_name}: #{@fixtures.first[:spec].description}"
+
     exclusion = fixtures.first[:spec].exclude_clause
-    title += ", Excluded: '#{exclusion}'" if exclusion
+    exclusion = exclusion.join if exclusion.is_a? Array
+    title += ", EXCLUDE: '#{exclusion}'" if exclusion
+    inclusion = fixtures.first[:spec].include_clause
+    inclusion = inclusion.join if inclusion.is_a? Array
+    title += ", ONLY: '#{inclusion}'" if inclusion
 
     RSpec.describe title do
       main_scope.fixtures.each do |fixture|
@@ -129,6 +127,7 @@ def generate_rspec(scope: nil, scenario: {}, expected: '')
     block_params = scenario.values
 
     @mysubject = scope.subject
+
     class << self
       define_method(:subject) { @mysubject }
     end

data/lib/rast.rb

@@ -8,10 +8,6 @@ require 'rast/spec_dsl'
 class Rast
 # RSpec All scenario test
 #
-# Example:
-#   >> Hola.hi("spanish")
-#   => hola mundo
-#
 # Arguments:
 #   language: (String)
 
@@ -38,6 +34,10 @@ class Rast
     raise message unless yield
   end
 
+  def xspec(id, &block)
+    p "xspec skipped #{id}"
+  end
+
   def spec(id, &block)
     global_spec(
       subject: @subject,

data/lib/template_spec.yml

@@ -5,14 +5,12 @@ specs:
 
     variables:
       param1:
-        - false
-        - true
+        - one
+        - two
 
-    converters:
-      - BoolConverter
+    outcomes:  # required (dictionary)
+      true: true[0]
 
-    rules:
-      'true': 'true[0]'
+    pair: {true: one}  # optional. (dictionary with 1 mapping)
 
-    pair:
-      'true': 'false'
+    default: DEFAULT  # optional (scalar) fall off value, or the else result of the `pair` config.

data/rast.gemspec

@@ -2,7 +2,7 @@
 
 Gem::Specification.new do |spec|
   spec.name          = 'rast'
-  spec.version       = '0.15.1'
+  spec.version       = '0.18.0'
   spec.authors       = ['Royce Remulla']
   spec.email         = ['royce.com@gmail.com']
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rast
 version: !ruby/object:Gem::Version
-  version: 0.15.1
+  version: 0.18.0
 platform: ruby
 authors:
 - Royce Remulla
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2020-05-09 00:00:00.000000000 Z
+date: 2020-05-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: factory_girl
@@ -38,6 +38,7 @@ files:
 - CHANGELOG.md
 - Gemfile
 - Gemfile.lock
+- Getting-Started.md
 - README.md
 - examples/arithmetic_module.rb
 - examples/double_example.rb
@@ -45,8 +46,10 @@ files:
 - examples/factory_example.rb
 - examples/logic_checker.rb
 - examples/logic_four.rb
+- examples/lohika.rb
 - examples/phone.rb
 - examples/positive.rb
+- examples/positive2.rb
 - examples/prime_number.rb
 - examples/quiz_module.rb
 - examples/quoted.rb