rulezilla 0.1.4 → 0.4.1

data/lib/rulezilla/rule_builder/gherkin_to_result_rule.rb

@@ -1,49 +0,0 @@
-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/rule_builder.rb

@@ -1,101 +0,0 @@
-require 'gherkin/parser/parser'
-require 'gherkin/formatter/json_formatter'
-require 'stringio'
-require 'json'
-require 'rulezilla/rule_builder/gherkin_to_result_rule'
-require 'rulezilla/rule_builder/gherkin_to_condition_rule'
-
-module Rulezilla
-  class RuleBuilder
-
-    def self.from_file(name, file)
-      new(name, IO.read(file))
-    end
-
-    attr_reader :name, :content
-
-    def initialize(name, content)
-      @name    = name
-      @content = content
-    end
-
-    def build
-      klass_definition = rules.map do |rule|
-        rule = RuleDefinition.new(rule, step_keyword)
-
-        condition_definition = rule.conditions.empty? ? "" : "condition { #{rule.conditions} }"
-
-        """
-          define \"#{rule.name}\" do
-            #{condition_definition}
-            result(#{rule.result})
-          end
-        """
-      end.join("\n")
-
-      klass = Rulezilla.const_set(name, Class.new)
-
-      klass.class_eval('include Rulezilla::DSL')
-      klass.class_eval(klass_definition)
-
-      klass
-    end
-
-
-    private
-
-    def step_keyword
-      gherkin_json.first['name'].gsub(/\s?rule/i, '')
-    end
-
-    def rules
-      gherkin_json.first['elements']
-    end
-
-    def gherkin_json
-      @gherkin_json ||= begin
-        io        = StringIO.new
-        formatter = Gherkin::Formatter::JSONFormatter.new(io)
-        parser    = Gherkin::Parser::Parser.new(formatter)
-
-        parser.parse(content, content, 0)
-        formatter.done
-
-        JSON.parse(io.string)
-      end
-    end
-
-
-    class RuleDefinition
-      def initialize(gherkin_json, step_keyword)
-        @gherkin_json = gherkin_json
-        @step_keyword = step_keyword
-      end
-
-      def name
-        @gherkin_json['name']
-      end
-
-      def conditions
-        condition_steps = steps.reject{|step| step['keyword'].strip.downcase == 'then'}
-        conditions = condition_steps.map do |step|
-          ::Rulezilla::RuleBuilder::GherkinToConditionRule.apply(record(step))
-        end.reject{|condition| condition == Rulezilla::RuleBuilder::DefaultCondition}.join(' && ')
-      end
-
-      def result
-        ::Rulezilla::RuleBuilder::GherkinToResultRule.apply record(steps.detect{|step| step['keyword'].strip.downcase == 'then'})
-      end
-
-      private
-
-      def steps
-        @steps ||= @gherkin_json['steps']
-      end
-
-      def record(step)
-        step.merge(step_keyword: @step_keyword)
-      end
-    end
-  end
-end

data/spec/features/gherkin_dsl_framework.feature

@@ -1,90 +0,0 @@
-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

@@ -1,16 +0,0 @@
-@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

@@ -1,14 +0,0 @@
-@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/step_definitions/rule_steps.rb

@@ -1,64 +0,0 @@
-steps_for :rule_steps do
-
-  step 'this is a "cat"' do
-    @records = [{cat?: true}]
-  end
-
-  step 'the :field is :value' do |field, value|
-    record ||= {}
-    field = field.gsub(/\s/,'_').downcase
-
-    value = case value
-    when 'blank'
-      ""
-    when /^less than \d+ digits$/i
-      value.scan(/^less than \d+ digits$/i).flatten.first.to_i.times.map{Random.rand(10)}.join
-    else
-      value
-    end
-
-    record[field] = value
-    @records = [record]
-  end
-
-  step 'the :field is in:' do |field, values|
-    @records = []
-    field = field.gsub(/\s/,'_').downcase
-    values.raw.flatten.each do |telephone_number|
-     @records << { field => telephone_number }
-   end
-  end
-
-  step 'this is an animal' do
-    @records.each do |record|
-      expect(Rulezilla::AnimalRule.apply(record)).to eq true
-    end
-  end
-
-  step 'this is not an animal' do
-    @records.each do |record|
-      expect(Rulezilla::AnimalRule.apply(record)).to eq false
-    end
-  end
-
-  step 'none of the above' do
-    @records = [{telephone_number: '09827364755'}]
-  end
-
-  step 'the duration is :day days' do |day|
-    send 'the duration is :second seconds', day.to_i * 86400
-  end
-
-  step 'the duration is :hour hours' do |hour|
-    send 'the duration is :second seconds', hour.to_i * 3600
-  end
-
-  step 'the duration is :minute minute' do |minute|
-    send 'the duration is :second seconds', minute.to_i * 60
-  end
-
-  step 'the duration is :second seconds' do |second|
-    expect(Rulezilla::DurationRule.apply(@records.first)).to eq second.to_i
-  end
-
-end