smartdown 0.3.0 → 0.4.0

data/spec/parser/predicates_spec.rb

@@ -47,39 +47,56 @@ describe Smartdown::Parser::Predicates do
   describe "named predicate" do
     subject(:parser) { described_class.new }
 
-    it { should parse("my_pred").as(named_predicate: "my_pred") }
     it { should parse("my_pred?").as(named_predicate: "my_pred?") }
+    it { should_not parse("my_pred") }
     it { should_not parse("my pred") }
 
     describe "transformed" do
       let(:node_name) { "my_node" }
-      let(:source) { "my_pred" }
+      let(:source) { "my_pred?" }
       subject(:transformed) {
         Smartdown::Parser::NodeInterpreter.new(node_name, source, parser: parser).interpret
       }
 
-      it { should eq(Smartdown::Model::Predicate::Named.new("my_pred")) }
+      it { should eq(Smartdown::Model::Predicate::Named.new("my_pred?")) }
+    end
+  end
+
+  describe "otherwise predicate" do
+    subject(:parser) { described_class.new }
+
+    it { should parse("otherwise").as(otherwise_predicate: "otherwise") }
+    it { should_not parse("other") }
+
+    describe "transformed" do
+      let(:node_name) { "my_node" }
+      let(:source) { "otherwise" }
+      subject(:transformed) {
+        Smartdown::Parser::NodeInterpreter.new(node_name, source, parser: parser).interpret
+      }
+
+      it { should eq(Smartdown::Model::Predicate::Otherwise.new) }
     end
   end
 
   describe "predicate AND predicate" do
     subject(:parser) { described_class.new }
 
-    it { should parse("my_pred AND my_other_pred").as(
+    it { should parse("my_pred? AND my_other_pred?").as(
       { combined_predicate: {
-        first_predicate: { named_predicate: "my_pred" },
+        first_predicate: { named_predicate: "my_pred?" },
         and_predicates:
           [
-            {named_predicate: "my_other_pred"},
+            {named_predicate: "my_other_pred?"},
           ]
       } }
     ) }
-    it { should parse("my_pred AND my_other_pred AND varname in {a b c}").as(
+    it { should parse("my_pred? AND my_other_pred? AND varname in {a b c}").as(
       { combined_predicate: {
-        first_predicate: { named_predicate: "my_pred" },
+        first_predicate: { named_predicate: "my_pred?" },
         and_predicates:
           [
-            {named_predicate: "my_other_pred"},
+            {named_predicate: "my_other_pred?"},
             {set_membership_predicate:
               {varname: "varname", values: [{set_value: "a"}, {set_value: "b"}, {set_value: "c"}]}
             }
@@ -90,20 +107,85 @@ describe Smartdown::Parser::Predicates do
 
     describe "transformed" do
       let(:node_name) { "my_node" }
-      let(:source) { "my_pred AND my_other_pred" }
+      let(:source) { "my_pred? AND my_other_pred?" }
       subject(:transformed) {
         Smartdown::Parser::NodeInterpreter.new(node_name, source, parser: parser).interpret
       }
 
       it { should eq(Smartdown::Model::Predicate::Combined.new(
         [
-          Smartdown::Model::Predicate::Named.new("my_pred"),
-          Smartdown::Model::Predicate::Named.new("my_other_pred")
+          Smartdown::Model::Predicate::Named.new("my_pred?"),
+          Smartdown::Model::Predicate::Named.new("my_other_pred?")
         ]
       )) }
     end
   end
 
+  describe "function predicate" do
+    subject(:parser) { described_class.new }
+
+    context "no arguments" do
+      let(:source) { "function_name()" }
+
+      it { should parse(source).as(function_predicate: { name: "function_name" }) }
+      it { should_not parse("function_name(") }
+
+      describe "transformed" do
+        let(:node_name) { "my_node" }
+        subject(:transformed) {
+          Smartdown::Parser::NodeInterpreter.new(node_name, source, parser: parser).interpret
+        }
+
+        it { should eq(Smartdown::Model::Predicate::Function.new("function_name", [])) }
+      end
+    end
+
+    context "single argument" do
+      let(:source) { "function_name(arg_1)" }
+
+      it { should parse(source).as(function_predicate: { name: "function_name", arguments: {function_argument: "arg_1"} }) }
+      it { should_not parse("function_name(hello") }
+      it { should_not parse("function name(hello)") }
+      it { should_not parse("function_name(hello) foo") }
+
+      describe "transformed" do
+        let(:node_name) { "my_node" }
+        subject(:transformed) {
+          Smartdown::Parser::NodeInterpreter.new(node_name, source, parser: parser).interpret
+        }
+
+        it { should eq(Smartdown::Model::Predicate::Function.new("function_name", ["arg_1"])) }
+      end
+    end
+
+    context "multiple arguments" do
+      let(:source) { "function_name(arg_1 arg_2 arg_3)" }
+
+      it { should parse(source).as(
+        { function_predicate: {
+          name: "function_name", arguments:
+          [
+            {function_argument: "arg_1"},
+            {function_argument: "arg_2"},
+            {function_argument: "arg_3"}
+          ]
+        } }
+      ) }
+
+      it { should_not parse("function_name(hello, foo") }
+      it { should_not parse("function name(hello, foo, bar) bar") }
+
+      describe "transformed" do
+        let(:node_name) { "my_node" }
+        subject(:transformed) {
+          Smartdown::Parser::NodeInterpreter.new(node_name, source, parser: parser).interpret
+        }
+
+        it { should eq(Smartdown::Model::Predicate::Function.new("function_name", ["arg_1", "arg_2", "arg_3"])) }
+      end
+    end
+  end
+
   describe "comparison predicate" do
     subject(:parser) { described_class.new }
     let(:greater_equal_source) { "varname >= 'value'" }
@@ -122,19 +204,19 @@ describe Smartdown::Parser::Predicates do
       subject(:transformed) {
         Smartdown::Parser::NodeInterpreter.new(node_name, source, parser: parser).interpret
       }
-      context "greater" do
+      context "greater or equal" do
         let(:source) { greater_equal_source }
         it { should eq(Smartdown::Model::Predicate::Comparison::GreaterOrEqual.new("varname", "value")) }
       end
-      context "stricly greater" do
+      context "greater" do
         let(:source) { greater_source }
         it { should eq(Smartdown::Model::Predicate::Comparison::Greater.new("varname", "value")) }
       end
-      context "lower" do
+      context "less than or equal" do
         let(:source) { less_equal_source }
         it { should eq(Smartdown::Model::Predicate::Comparison::LessOrEqual.new("varname", "value")) }
       end
-      context "strictly lower" do
+      context "less than" do
         let(:source) { less_source }
         it { should eq(Smartdown::Model::Predicate::Comparison::Less.new("varname", "value")) }
       end

data/spec/support/model_builder.rb

@@ -120,6 +120,10 @@ class ModelBuilder
     @predicate = Smartdown::Model::Predicate::Named.new(name)
   end
 
+  def set_membership_predicate(varname, values)
+    @predicate = Smartdown::Model::Predicate::SetMembership.new(varname, values)
+  end
+
   def outcome(name)
     @outcome = name
   end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: smartdown
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.4.0
   prerelease: 
 platform: ruby
 authors:
@@ -13,7 +13,7 @@ date: 2014-07-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: parslet
-  requirement: &16437600 !ruby/object:Gem::Requirement
+  requirement: &10821840 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -21,10 +21,10 @@ dependencies:
         version: 1.6.1
   type: :runtime
   prerelease: false
-  version_requirements: *16437600
+  version_requirements: *10821840
 - !ruby/object:Gem::Dependency
   name: rspec
-  requirement: &16435640 !ruby/object:Gem::Requirement
+  requirement: &10820700 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -32,10 +32,10 @@ dependencies:
         version: 3.0.0
   type: :development
   prerelease: false
-  version_requirements: *16435640
+  version_requirements: *10820700
 - !ruby/object:Gem::Dependency
   name: rake
-  requirement: &16837980 !ruby/object:Gem::Requirement
+  requirement: &10818660 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -43,10 +43,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *16837980
+  version_requirements: *10818660
 - !ruby/object:Gem::Dependency
   name: gem_publisher
-  requirement: &16837320 !ruby/object:Gem::Requirement
+  requirement: &10832280 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -54,7 +54,7 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *16837320
+  version_requirements: *10832280
 description: 
 email: david.heath@digital.cabinet-office.gov.uk
 executables:
@@ -100,11 +100,11 @@ files:
 - lib/smartdown/engine/conditional_resolver.rb
 - lib/smartdown/engine/transition.rb
 - lib/smartdown/engine/interpolator.rb
-- lib/smartdown/engine/predicate_evaluator.rb
 - lib/smartdown/engine/errors.rb
 - lib/smartdown/model/flow.rb
 - lib/smartdown/model/predicate/named.rb
 - lib/smartdown/model/predicate/set_membership.rb
+- lib/smartdown/model/predicate/function.rb
 - lib/smartdown/model/predicate/equality.rb
 - lib/smartdown/model/predicate/comparison/less_or_equal.rb
 - lib/smartdown/model/predicate/comparison/greater_or_equal.rb
@@ -112,6 +112,7 @@ files:
 - lib/smartdown/model/predicate/comparison/greater.rb
 - lib/smartdown/model/predicate/comparison/less.rb
 - lib/smartdown/model/predicate/combined.rb
+- lib/smartdown/model/predicate/otherwise.rb
 - lib/smartdown/model/node.rb
 - lib/smartdown/model/front_matter.rb
 - lib/smartdown/model/element/conditional.rb
@@ -149,7 +150,6 @@ files:
 - spec/spec_helper.rb
 - spec/engine/state_spec.rb
 - spec/engine/interpolator_spec.rb
-- spec/engine/predicate_evaluator_spec.rb
 - spec/engine/transition_spec.rb
 - spec/engine/conditional_resolver_spec.rb
 - spec/fixtures/directory_input/scenarios/s1.txt
@@ -159,6 +159,13 @@ files:
 - spec/fixtures/acceptance/question-and-outcome/question-and-outcome.txt
 - spec/fixtures/acceptance/question-and-outcome/outcomes/o1.txt
 - spec/fixtures/acceptance/question-and-outcome/questions/q1.txt
+- spec/fixtures/acceptance/animal-example-simple/outcomes/outcome_untrained_with_lions.txt
+- spec/fixtures/acceptance/animal-example-simple/outcomes/outcome_tigers_are_fine.txt
+- spec/fixtures/acceptance/animal-example-simple/outcomes/outcome_safe_pet.txt
+- spec/fixtures/acceptance/animal-example-simple/outcomes/outcome_trained_with_lions.txt
+- spec/fixtures/acceptance/animal-example-simple/animal-example-simple.txt
+- spec/fixtures/acceptance/animal-example-simple/questions/question_1.txt
+- spec/fixtures/acceptance/animal-example-simple/questions/question_2.txt
 - spec/fixtures/acceptance/cover-sheet/cover-sheet.txt
 - spec/fixtures/acceptance/one-question/one-question.txt
 - spec/fixtures/acceptance/one-question/questions/q1.txt
@@ -167,6 +174,12 @@ files:
 - spec/engine_spec.rb
 - spec/model/node_spec.rb
 - spec/model/flow_spec.rb
+- spec/model/predicates/set_membership_spec.rb
+- spec/model/predicates/combined_spec.rb
+- spec/model/predicates/comparison_spec.rb
+- spec/model/predicates/equality_spec.rb
+- spec/model/predicates/named_spec.rb
+- spec/model/predicates/function_spec.rb
 homepage: https://github.com/alphagov/smartdown
 licenses:
 - MIT
@@ -182,7 +195,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: 306060104431825323
+      hash: -1672361924519016433
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
@@ -191,7 +204,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: 306060104431825323
+      hash: -1672361924519016433
 requirements: []
 rubyforge_project: 
 rubygems_version: 1.8.11
@@ -220,7 +233,6 @@ test_files:
 - spec/spec_helper.rb
 - spec/engine/state_spec.rb
 - spec/engine/interpolator_spec.rb
-- spec/engine/predicate_evaluator_spec.rb
 - spec/engine/transition_spec.rb
 - spec/engine/conditional_resolver_spec.rb
 - spec/fixtures/directory_input/scenarios/s1.txt
@@ -230,6 +242,13 @@ test_files:
 - spec/fixtures/acceptance/question-and-outcome/question-and-outcome.txt
 - spec/fixtures/acceptance/question-and-outcome/outcomes/o1.txt
 - spec/fixtures/acceptance/question-and-outcome/questions/q1.txt
+- spec/fixtures/acceptance/animal-example-simple/outcomes/outcome_untrained_with_lions.txt
+- spec/fixtures/acceptance/animal-example-simple/outcomes/outcome_tigers_are_fine.txt
+- spec/fixtures/acceptance/animal-example-simple/outcomes/outcome_safe_pet.txt
+- spec/fixtures/acceptance/animal-example-simple/outcomes/outcome_trained_with_lions.txt
+- spec/fixtures/acceptance/animal-example-simple/animal-example-simple.txt
+- spec/fixtures/acceptance/animal-example-simple/questions/question_1.txt
+- spec/fixtures/acceptance/animal-example-simple/questions/question_2.txt
 - spec/fixtures/acceptance/cover-sheet/cover-sheet.txt
 - spec/fixtures/acceptance/one-question/one-question.txt
 - spec/fixtures/acceptance/one-question/questions/q1.txt
@@ -238,3 +257,9 @@ test_files:
 - spec/engine_spec.rb
 - spec/model/node_spec.rb
 - spec/model/flow_spec.rb
+- spec/model/predicates/set_membership_spec.rb
+- spec/model/predicates/combined_spec.rb
+- spec/model/predicates/comparison_spec.rb
+- spec/model/predicates/equality_spec.rb
+- spec/model/predicates/named_spec.rb
+- spec/model/predicates/function_spec.rb

data/lib/smartdown/engine/predicate_evaluator.rb

@@ -1,27 +0,0 @@
-module Smartdown
-  class Engine
-    class PredicateEvaluator
-      def evaluate(predicate, state)
-        evaluator_for(predicate).call(state)
-      end
-
-    private
-      def evaluator_for(predicate)
-        case predicate
-        when Smartdown::Model::Predicate::Equality
-          ->(state) { state.get(predicate.varname) == predicate.expected_value }
-        when Smartdown::Model::Predicate::SetMembership
-          ->(state) { predicate.values.include?(state.get(predicate.varname)) }
-        when Smartdown::Model::Predicate::Named
-          ->(state) { state.get(predicate.name) }
-        when Smartdown::Model::Predicate::Comparison::Base
-          ->(state) { predicate.evaluate(state.get(predicate.varname)) }
-        when Smartdown::Model::Predicate::Combined
-          ->(state) { predicate.predicates.map { |p| evaluate(p, state) }.all? }
-        else
-          raise "Unknown predicate type #{predicate.class}"
-        end
-      end
-    end
-  end
-end

data/spec/engine/predicate_evaluator_spec.rb

@@ -1,284 +0,0 @@
-require 'smartdown/engine/predicate_evaluator'
-require 'smartdown/model/predicate/equality'
-require 'smartdown/model/predicate/set_membership'
-require 'smartdown/model/predicate/named'
-require 'smartdown/model/predicate/combined'
-require 'smartdown/model/predicate/comparison/greater_or_equal'
-require 'smartdown/model/predicate/comparison/greater'
-require 'smartdown/model/predicate/comparison/less_or_equal'
-require 'smartdown/model/predicate/comparison/less'
-require 'smartdown/engine/state'
-
-describe Smartdown::Engine::PredicateEvaluator do
-  subject(:evaluator) { described_class.new }
-
-  context "equality predicate" do
-    let(:predicate) { Smartdown::Model::Predicate::Equality.new("my_var", "some value") }
-
-    describe "#evaluate" do
-      context "state missing expected variable" do
-        let(:state) { Smartdown::Engine::State.new(current_node: "n") }
-
-        it "raises an UndefinedValue error" do
-          expect { evaluator.evaluate(predicate, state) }.to raise_error(Smartdown::Engine::UndefinedValue)
-        end
-      end
-
-      context "state has expected variable with same value" do
-        let(:state) { Smartdown::Engine::State.new(current_node: "n", my_var: "some value") }
-
-        it "evaluates to true" do
-          expect(evaluator.evaluate(predicate, state)).to eq(true)
-        end
-      end
-
-      context "state has expected variable with a different value" do
-        let(:state) { Smartdown::Engine::State.new(current_node: "n", my_var: "some other value") }
-
-        it "evaluates to false" do
-          expect(evaluator.evaluate(predicate, state)).to eq(false)
-        end
-      end
-    end
-  end
-
-  context "set membership predicate" do
-    let(:expected_values) { ["v1", "v2", "v3"] }
-    let(:varname) { "my_var" }
-    let(:predicate) { Smartdown::Model::Predicate::SetMembership.new(varname, expected_values) }
-
-    describe "#evaluate" do
-      context "state missing expected variable" do
-        let(:state) { Smartdown::Engine::State.new(current_node: "n") }
-
-        it "raises an UndefinedValue error" do
-          expect { evaluator.evaluate(predicate, state) }.to raise_error(Smartdown::Engine::UndefinedValue)
-        end
-      end
-
-      context "state has expected variable with one of the expected values" do
-        it "evaluates to true" do
-          expected_values.each do |value|
-            state = Smartdown::Engine::State.new(current_node: "n", varname => value)
-            expect(evaluator.evaluate(predicate, state)).to eq(true)
-          end
-        end
-      end
-
-      context "state has expected variable with a value not in the list of expected values" do
-        let(:state) { Smartdown::Engine::State.new(current_node: "n", varname => "some other value") }
-
-        it "evaluates to false" do
-          expect(evaluator.evaluate(predicate, state)).to eq(false)
-        end
-      end
-    end
-  end
-
-  context "named predicate" do
-    let(:predicate_name) { "my_pred?" }
-    let(:predicate) { Smartdown::Model::Predicate::Named.new(predicate_name) }
-
-    describe "#evaluate" do
-      context "state missing predicate definition" do
-        let(:state) { Smartdown::Engine::State.new(current_node: "n") }
-
-        it "raises an UndefinedValue error" do
-          expect { evaluator.evaluate(predicate, state) }.to raise_error(Smartdown::Engine::UndefinedValue)
-        end
-      end
-
-      context "state has predicate definition" do
-        let(:state) {
-          Smartdown::Engine::State.new("current_node" => "n", "my_pred?" => true )
-        }
-
-        it "fetches the predicate value from the state" do
-          expect(evaluator.evaluate(predicate, state)).to eq(true)
-        end
-      end
-    end
-  end
-
-  context "combined predicate" do
-    let(:predicate_name) { "my_pred?" }
-    let(:predicate_name_2) { "my_other_pred?" }
-    let(:predicate) { Smartdown::Model::Predicate::Named.new(predicate_name) }
-    let(:predicate_2) { Smartdown::Model::Predicate::Named.new(predicate_name_2) }
-    let(:combined_predicate) { Smartdown::Model::Predicate::Combined.new([predicate, predicate_2])}
-
-    describe "#evaluate" do
-
-      context "both states are true" do
-        let(:state) {
-          Smartdown::Engine::State.new("current_node" => "n", "my_pred?" => true, "my_other_pred?" => true )
-        }
-
-        it "evaluates as true" do
-          expect(evaluator.evaluate(combined_predicate, state)).to eq(true)
-        end
-      end
-
-      context "both states are false" do
-        let(:state) {
-          Smartdown::Engine::State.new("current_node" => "n", "my_pred?" => false, "my_other_pred?" => false )
-        }
-
-        it "evaluates as false" do
-          expect(evaluator.evaluate(combined_predicate, state)).to eq(false)
-        end
-      end
-
-      context "one of the states is false" do
-        let(:state) {
-          Smartdown::Engine::State.new("current_node" => "n", "my_pred?" => true, "my_other_pred?" => false )
-        }
-
-        it "evaluates as false" do
-          expect(evaluator.evaluate(combined_predicate, state)).to eq(false)
-        end
-      end
-    end
-
-  end
-
-  context "comparison predicates with integers" do
-    let(:greater_predicate) { Smartdown::Model::Predicate::Comparison::Greater.new("my_var", "5") }
-    let(:greater_or_equal_predicate) { Smartdown::Model::Predicate::Comparison::GreaterOrEqual.new("my_var", "5") }
-    let(:less_predicate) { Smartdown::Model::Predicate::Comparison::Less.new("my_var", "5") }
-    let(:less_or_equal_predicate) { Smartdown::Model::Predicate::Comparison::LessOrEqual.new("my_var", "5") }
-    let(:predicates) { {
-      :greater => greater_predicate,
-      :greater_or_equal => greater_or_equal_predicate,
-      :less => less_predicate,
-      :less_or_equal => less_or_equal_predicate
-    } }
-
-    describe "#evaluate" do
-      context "state missing expected variable" do
-        let(:state) { Smartdown::Engine::State.new(current_node: "n") }
-
-        it "raises an UndefinedValue error" do
-          predicates.values.each do |predicate|
-            expect { evaluator.evaluate(predicate, state) }.to raise_error(Smartdown::Engine::UndefinedValue)
-          end
-        end
-      end
-
-      context "state has lower value" do
-        let(:state) { Smartdown::Engine::State.new(current_node: "n", my_var: "4") }
-        let(:results) { {
-          :greater => false,
-          :greater_or_equal => false,
-          :less => true,
-          :less_or_equal => true
-        } }
-        it "evaluates correctly" do
-          predicates.each do |predicate_key, predicate|
-            expect(evaluator.evaluate(predicate, state)).to eq(results[predicate_key])
-          end
-        end
-      end
-
-      context "state has identical value" do
-        let(:state) { Smartdown::Engine::State.new(current_node: "n", my_var: "5") }
-        let(:results) { {
-            :greater => false,
-            :greater_or_equal => true,
-            :less => false,
-            :less_or_equal => true
-        } }
-        it "evaluates correctly" do
-          predicates.each do |predicate_key, predicate|
-            expect(evaluator.evaluate(predicate, state)).to eq(results[predicate_key])
-          end
-        end
-      end
-
-      context "state has higher value" do
-        let(:state) { Smartdown::Engine::State.new(current_node: "n", my_var: "6") }
-        let(:results) { {
-            :greater => true,
-            :greater_or_equal => true,
-            :less => false,
-            :less_or_equal => false
-        } }
-        it "evaluates correctly" do
-          predicates.each do |predicate_key, predicate|
-            expect(evaluator.evaluate(predicate, state)).to eq(results[predicate_key])
-          end
-        end
-      end
-    end
-  end
-
-  context "comparison predicates with dates" do
-    let(:greater_predicate) { Smartdown::Model::Predicate::Comparison::Greater.new("my_var", "2014-1-31") }
-    let(:greater_or_equal_predicate) { Smartdown::Model::Predicate::Comparison::GreaterOrEqual.new("my_var", "2014-1-31") }
-    let(:less_predicate) { Smartdown::Model::Predicate::Comparison::Less.new("my_var", "2014-1-31") }
-    let(:less_or_equal_predicate) { Smartdown::Model::Predicate::Comparison::LessOrEqual.new("my_var", "2014-1-31") }
-    let(:predicates) { {
-        :greater => greater_predicate,
-        :greater_or_equal => greater_or_equal_predicate,
-        :less => less_predicate,
-        :less_or_equal => less_or_equal_predicate
-    } }
-
-    describe "#evaluate" do
-      context "state missing expected variable" do
-        let(:state) { Smartdown::Engine::State.new(current_node: "n") }
-
-        it "raises an UndefinedValue error" do
-          predicates.values.each do |predicate|
-            expect { evaluator.evaluate(predicate, state) }.to raise_error(Smartdown::Engine::UndefinedValue)
-          end
-        end
-      end
-
-      context "state has lower value" do
-        let(:state) { Smartdown::Engine::State.new(current_node: "n", my_var: "2014-1-30") }
-        let(:results) { {
-            :greater => false,
-            :greater_or_equal => false,
-            :less => true,
-            :less_or_equal => true
-        } }
-        it "evaluates correctly" do
-          predicates.each do |predicate_key, predicate|
-            expect(evaluator.evaluate(predicate, state)).to eq(results[predicate_key])
-          end
-        end
-      end
-
-      context "state has identical value" do
-        let(:state) { Smartdown::Engine::State.new(current_node: "n", my_var: "2014-1-31") }
-        let(:results) { {
-            :greater => false,
-            :greater_or_equal => true,
-            :less => false,
-            :less_or_equal => true
-        } }
-        it "evaluates correctly" do
-          predicates.each do |predicate_key, predicate|
-            expect(evaluator.evaluate(predicate, state)).to eq(results[predicate_key])
-          end
-        end
-      end
-
-      context "state has higher value" do
-        let(:state) { Smartdown::Engine::State.new(current_node: "n", my_var: "2014-2-1") }
-        let(:results) { {
-            :greater => true,
-            :greater_or_equal => true,
-            :less => false,
-            :less_or_equal => false
-        } }
-        it "evaluates correctly" do
-          predicates.each do |predicate_key, predicate|
-            expect(evaluator.evaluate(predicate, state)).to eq(results[predicate_key])
-          end
-        end
-      end
-    end
-  end
-end