rulezilla 0.1.4

data/lib/rulezilla/rule_builder/gherkin_to_condition_rule.rb

@@ -0,0 +1,63 @@
+module Rulezilla
+  class RuleBuilder
+    class DefaultCondition; end
+
+    class GherkinToConditionRule
+      include Rulezilla::DSL
+
+      define :'this is a "field"' do
+        condition { name =~ /^this is\s?a?n? \"(.*)\"$/i }
+
+        result do
+          field = name.scan(/^this is\s?a?n? \"(.*)\"$/i).flatten.first
+          "#{field}?"
+        end
+      end
+
+      define :'the "field" is "value"' do
+        condition { name =~ /^the \"(.*)\" is \"(.*)\"$/i }
+
+        result do
+          field, value = name.scan(/^the \"(.*)\" is \"(.*)\"$/i).flatten
+          field = field.gsub(/\s/, '_').downcase
+
+          "#{field} == #{ConditionValueEvaluateRule.apply(value: value)}"
+        end
+      end
+
+      define :'the "field" is in: {table}' do
+        condition { name =~ /^the \"(.*)\" is in:$/i }
+
+        result do
+          field = name.scan(/^the \"(.*)\" is in:$/i).flatten.first
+          field = field.gsub(/\s/, '_').downcase
+
+          values = rows.map{ |row| "#{ConditionValueEvaluateRule.apply(value: row['cells'].first)}" }.join(', ')
+
+          "[#{values}].include?(#{field})"
+        end
+      end
+
+      define :'none of the above' do
+        condition { name == 'none of the above' }
+        result(DefaultCondition)
+      end
+
+      default { raise "Condition steps is not recognised: #{name}" }
+    end
+
+
+
+    class ConditionValueEvaluateRule
+      include Rulezilla::DSL
+
+      define :blank do
+        condition { value == 'blank'}
+        result("''")
+      end
+
+      default { "\"#{value}\"" }
+    end
+  end
+
+end

data/lib/rulezilla/rule_builder/gherkin_to_result_rule.rb

@@ -0,0 +1,49 @@
+module Rulezilla
+  class RuleBuilder
+    class GherkinToResultRule
+      include Rulezilla::DSL
+
+      group :keyword_is do
+        condition { name =~ /^the #{step_keyword} is/i }
+
+        define :value_is do
+          condition { name =~ /^the #{step_keyword} is \"(.*)\"$/i }
+          result    { "\"#{name.scan(/^the #{step_keyword} is \"(.*)\"$/i).flatten.first}\"" }
+        end
+
+        define :duration_is do
+          condition { name =~ /^the #{step_keyword} is \"(\d+)\" (days?|hours?|minutes?|seconds?)$/i }
+          result do
+            quantity, unit = name.scan(/^the #{step_keyword} is \"(\d+)\" (days?|hours?|minutes?|seconds?)$/i).flatten
+
+            multiplier = case unit
+            when /day/
+              86400
+            when /hour/
+              3600
+            when /minute/
+              60
+            when /second/
+              1
+            end
+
+            quantity.to_i * multiplier
+          end
+        end
+      end
+
+      define :start_with_this_is_a do
+        condition { name =~ /^this is an? #{step_keyword}$/i }
+        result("true")
+      end
+
+      define :start_with_this_is_not_a do
+        condition { name =~ /^this is not an? #{step_keyword}$/i }
+        result("false")
+      end
+
+      default { raise "Unrecognisable step: #{name}" }
+
+    end
+  end
+end

data/lib/rulezilla/tree.rb

@@ -0,0 +1,76 @@
+module Rulezilla
+  class Tree
+    attr_reader :current_node, :root_node
+
+    def initialize(node)
+      @root_node      = node
+      @root_node.name = :root
+      @current_node   = node
+    end
+
+    def go_up
+      @current_node = is_root? ? @root_node : @current_node.parent
+    end
+
+    def find_all(record, node=@root_node)
+      array = []
+      if node.applies?(record)
+        node.children.each do |child_node|
+          array += find_all(record, child_node)
+        end
+
+        return node.has_result? ? array + [node] : array
+      end
+      return array
+    end
+
+    def trace(record, node=@root_node)
+      if node.applies?(record)
+        node.children.each do |child_node|
+          array = trace(record, child_node)
+          return [node] + array unless array.empty?
+        end
+        return node.has_result? ? [node] : []
+      end
+      return []
+    end
+
+    def all_results(record, node=@root_node, results=[])
+      if node.has_result?
+        results << node.result(record) rescue NoMethodError
+      end
+
+      node.children.each do |child_node|
+        all_results(record, child_node, results)
+      end
+
+      return results
+    end
+
+    def create_and_move_to_child(name=nil)
+      node = Node.new
+      node.name = name
+      @current_node.add_child(node)
+      @current_node = node
+      node
+    end
+
+    def clone_and_append_children(children, node=@current_node)
+      children.each do |child_node|
+        child_node = child_node.dup
+        node.add_child(child_node)
+
+        if child_node.has_children?
+          children_nodes = child_node.children
+          child_node.children = []
+          clone_and_append_children(children_nodes, child_node)
+        end
+      end
+    end
+
+    private
+    def is_root?
+      @current_node == @root_node
+    end
+  end
+end

data/lib/rulezilla/version.rb

@@ -0,0 +1,3 @@
+module Rulezilla
+  VERSION = '0.1.4'
+end

data/rulezilla.gemspec

@@ -0,0 +1,18 @@
+$:.push File.expand_path("../lib", __FILE__)
+require 'rulezilla/version'
+
+Gem::Specification.new do |gem|
+  gem.authors       = ['Peter Wu']
+  gem.email         = ['peter.wu@simplybusiness.com']
+  gem.description   = %q{Rules DSL}
+  gem.summary       = %q{Rules DSL}
+  gem.homepage      = %q{https://github.com/simplybusiness/rulezilla}
+
+  gem.files         = `git ls-files`.split($\)
+  gem.name          = 'rulezilla'
+  gem.require_paths = ['lib']
+  gem.version       = Rulezilla::VERSION
+  gem.license       = 'MIT'
+
+  gem.add_runtime_dependency('gherkin')
+end

data/spec/features/default_support_methods.feature

@@ -0,0 +1,21 @@
+Feature: Default Support methods
+
+Scenario Outline: does_not?
+  Given the rule is:
+    """
+      define :not_sleep do
+        condition { does_not?(go_to_bed) }
+        result('Tired')
+      end
+
+      default('Refreshing')
+    """
+  When the record has attribute "go_to_bed" and returns "<value>"
+  Then the result is "<result>"
+
+  Examples:
+    | value | result     |
+    | true  | Refreshing |
+    | false | Tired      |
+    |       | Refreshing |
+    | nil   | Refreshing |

data/spec/features/gherkin_dsl_framework.feature

@@ -0,0 +1,90 @@
+Feature: Rulezilla Gherkin DSL
+
+  Scenario: Condition: something is something
+    Given the gherkin is:
+      """
+        Feature: Awesomeness Rule
+
+        Scenario: Robocop
+          When the "target" is "Robocop"
+          Then the awesomeness is "very awesome"
+      """
+    When the record has attribute "target" and returns "Robocop"
+    Then the result is "very awesome"
+
+
+  Scenario: Multiple Condition: something is something
+    Given the gherkin is:
+      """
+        Feature: Winner Rule
+
+        Scenario: Robocop vs Ironman
+          When the "target" is "Robocop"
+          And the "opponent" is "Ironman"
+          Then the winner is "Ironman"
+      """
+    When the record has attribute "target" and returns "Robocop"
+    And the record has attribute "opponent" and returns "Ironman"
+    Then the result is "Ironman"
+
+
+  Scenario: Default
+    Given the gherkin is:
+      """
+        Feature: Winner Rule
+
+        Scenario: Default
+          When none of the above
+          Then the winner is "Ironman"
+      """
+    Then the result is "Ironman"
+
+
+  Scenario: 'The :keyword is :value', Keyword mismatch
+    Given the incorrect gherkin is:
+      """
+        Feature: Winner Rule
+
+        Scenario: Default
+          When none of the above
+          Then the loser is "Hello kitty"
+      """
+    Then it raises exception "Unrecognisable step: the loser is 'Hello kitty'"
+
+
+  Scenario: True value
+    Given the gherkin is:
+      """
+        Feature: Dummy Rule
+
+        Scenario: Dummy
+          When the "name" is "007"
+          Then this is a dummy
+      """
+    When the record has attribute "name" and returns "007"
+    Then the result is "true"
+
+
+  Scenario: False value
+    Given the gherkin is:
+      """
+        Feature: Dummy Rule
+
+        Scenario: Not Dummy
+          When the "name" is "Tom"
+          Then this is not a dummy
+      """
+    When the record has attribute "name" and returns "Tom"
+    Then the result is "false"
+
+
+  Scenario: 'This is( not) a :keyword', Keyword mismatch
+    Given the incorrect gherkin is:
+      """
+        Feature: Winner Rule
+
+        Scenario: Not Dummy
+          When the "name" is "Tom"
+          Then this is not a cat
+      """
+    Then it raises exception "Unrecognisable step: this is not a 'cat'"

data/spec/features/gherkin_rules/animal_rule.feature

@@ -0,0 +1,16 @@
+@rule_steps
+Feature: Animal Rule
+
+  Scenario: entity is a cat
+    When this is a "cat"
+    Then this is an animal
+
+  Scenario: telephone number is dog or bird
+    When the "entity" is in:
+      | dog  |
+      | bird |
+    Then this is an animal
+
+  Scenario: default
+    When none of the above
+    Then this is not an animal

data/spec/features/gherkin_rules/duration_rule.feature

@@ -0,0 +1,14 @@
+@rule_steps
+Feature: Duration Rule
+
+  Scenario: Maths class
+    When the "name of the class" is "Maths"
+    Then the duration is "1" minute
+
+  Scenario: Science class
+    When the "name of the class" is "Science"
+    Then the duration is "10" hours
+
+  Scenario: PE
+    When the "name of the class" is "PE"
+    Then the duration is "2" days

data/spec/features/rulezilla_dsl_framwork.feature

@@ -0,0 +1,299 @@
+Feature: Rulezilla DSL
+
+Scenario: To get all outcome from a rule
+  Given the rule is:
+    """
+      group :group_1 do
+        condition { false }
+
+        group :group_1_1 do
+          condition { true }
+
+          define :rule_1_1_1 do
+            condition { false }
+            result('A')
+          end
+
+          default('B')
+        end
+
+        define :rule_1_1 do
+          condition { true }
+          result('C')
+        end
+
+        define :rule_1_2 do
+          condition { true }
+          result('D')
+        end
+      end
+
+      define :rule_2 do
+        condition { false }
+        result('E')
+      end
+
+      default('F')
+    """
+  Then all the outcomes are "A, B, C, D, E, F"
+
+Scenario: Rule is evaluated from top to bottom order
+  Given the rule is:
+    """
+      define :rule_1 do
+        condition { true }
+        result('Yes')
+      end
+
+      define :rule_2 do
+        condition { true }
+        result('May be')
+      end
+    """
+  Then the result is "Yes"
+
+
+Scenario: Nesting in Rule DSL
+  Given the rule is:
+    """
+      group :group_1 do
+        condition { true }
+
+        define :good do
+          condition { true }
+          result('Good')
+        end
+      end
+    """
+  Then the result is "Good"
+
+
+Scenario: If nothing is matched in a group, it will fall to default value of the group
+  Given the rule is:
+    """
+      group :group_1 do
+        condition { true }
+
+        define :good do
+          condition { false }
+          result('Good')
+        end
+
+        default('It is alright')
+      end
+    """
+  Then the result is "It is alright"
+
+
+Scenario: If nothing is matched, and no default is define in the group, it will fall to the next default
+  Given the rule is:
+    """
+      group :group_1 do
+        condition { true }
+
+        define :good do
+          condition { false }
+          result('Good')
+        end
+      end
+
+      default('Everything is awesome')
+    """
+  Then the result is "Everything is awesome"
+
+
+Scenario: If nothing is matched, it will continue to evaluate the next group
+  Given the rule is:
+    """
+      group :group_1 do
+        condition { true }
+
+        define :good do
+          condition { false }
+          result('Good')
+        end
+      end
+
+      group :group_2 do
+        condition { true }
+
+        define :bad do
+          condition { true }
+          result('Bad')
+        end
+      end
+    """
+  Then the result is "Bad"
+
+
+Scenario Outline: It evaluate the rule against a record
+  Given the rule is:
+    """
+      define :fruit do
+        condition { fruit }
+        result('This is good!')
+      end
+
+      define :fruit do
+        condition { !fruit }
+        result('Oh, too bad')
+      end
+    """
+  When the record has attribute "fruit" and returns "<value>"
+  Then the result is "<result>"
+
+  Examples:
+    | value | result        |
+    | true  | This is good! |
+    | false | Oh, too bad   |
+
+
+Scenario: To get all matching outcomes from a rule
+  Given the rule is:
+    """
+      group :group_1 do
+        condition { true }
+
+        group :group_1_1 do
+          condition { true }
+
+          define :rule_1_1_1 do
+            condition { false }
+            result('A')
+          end
+
+          default('B')
+        end
+
+        define :rule_1_1 do
+          condition { true }
+          result('C')
+        end
+
+        define :rule_1_2 do
+          condition { true }
+          result('D')
+        end
+      end
+
+      define :rule_2 do
+        condition { false }
+        result('E')
+      end
+
+      default('F')
+    """
+  Then all the matching outcomes are "B, C, D, F"
+
+
+Scenario: Support Module
+  Given the rule class name is "FruitRule"
+  And the support module called "FruitRuleSupport" has definition:
+    """
+      def is_fruit?
+        fruit == true
+      end
+    """
+  And the rule is:
+    """
+      define :fruit do
+        condition { is_fruit? }
+        result('This is good!')
+      end
+
+      define :fruit do
+        condition { !is_fruit? }
+        result('Oh, too bad')
+      end
+    """
+  When the record has attribute "fruit" and returns "true"
+  Then the result is "This is good!"
+
+
+Scenario Outline: Validate the presence of attributes
+  Given the rule is:
+    """
+      validate_attributes_presence :apple, :orange
+
+      default(true)
+    """
+  When the record has attribute "<attributes>"
+  Then "<does or does not>" raise the exception "<exception>"
+
+  Examples:
+    | attributes    | does or does not | exception                 |
+    | apple         | does             | Missing orange attributes |
+    | orange        | does             | Missing apple attributes  |
+    | apple, orange | does not         |                           |
+
+
+Scenario: Rule return nil if no rule is defined Given the rule is:
+  Given the rule is:
+    """
+    """
+  Then the result is "nil"
+
+Scenario Outline: Trace the path to the result
+  Given the rule is:
+    """
+      group :group_1 do
+        condition { group_1_condition }
+
+        group :group_2 do
+          condition { group_2_condition }
+
+          define :rule_1 do
+            condition { false }
+            result('A')
+          end
+
+          define :rule_2 do
+            condition { rule_2_condition }
+            result('B')
+          end
+
+          default('C')
+        end
+
+        default('D')
+      end
+
+      define :rule_3 do
+        condition { rule_3_condition }
+        result('E')
+      end
+
+      default('F')
+    """
+  When the record has attribute "group_1_condition" and returns "<group_1_condition>"
+  And the record has attribute "group_2_condition" and returns "<group_2_condition>"
+  And the record has attribute "rule_2_condition" and returns "<rule_2_condition>"
+  And the record has attribute "rule_3_condition" and returns "<rule_3_condition>"
+  Then the trace is "<trace>"
+
+  Examples:
+    | group_1_condition | group_2_condition | rule_2_condition | rule_3_condition | trace                                |
+    | true              | true              | true             | true             | root -> group_1 -> group_2 -> rule_2 |
+    | true              | false             | true             | true             | root -> group_1                      |
+    | false             | true              | true             | true             | root -> rule_3                       |
+    | false             | true              | true             | false            | root                                 |
+
+Scenario: Include rule
+  Given there is a rule called "CommonRule":
+    """
+      define :a do
+        condition { true }
+        result { 'A' }
+      end
+
+      define :b do
+        condition { false }
+        result { 'B' }
+      end
+    """
+  And our rule is:
+    """
+      include_rule CommonRule
+    """
+  Then all the outcomes are "A, B"
+  And the result is "A"