smartdown 0.3.0 → 0.4.0

data/spec/fixtures/acceptance/animal-example-simple/animal-example-simple.txt

@@ -0,0 +1,25 @@
+meta_description: Animals eh?
+satisfies_need: 100982
+status: draft
+
+# A simple example of smartdown
+
+Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod
+tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam,
+quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo
+consequat.
+
+Duis aute irure dolor in reprehenderit in voluptate velit esse
+cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non
+proident, sunt in culpa qui officia deserunt mollit anim id est laborum.
+
+## Before you start, you will need
+
+* To know the kind of feline you have
+* Any animal training certification documents
+
+[start: question_1]
+
+## Devolved body
+
+Which is really just body content after the start button

data/spec/fixtures/acceptance/animal-example-simple/outcomes/outcome_safe_pet.txt

@@ -0,0 +1,69 @@
+# You picked a safe pet
+
+Good call.
+
+# Markdown/Govspeak examples
+
+## H2 example
+
+With answers, that are smart. Down with that?
+
+Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod
+tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam,
+quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo
+
+### H3 example
+
+consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse
+cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non
+proident, sunt in culpa qui officia deserunt mollit anim id est laborum.
+
+## List
+
+* one
+* two
+* three
+
+## List 2
+
+- A
+- B
+- C
+
+## List 3
+
++ Up
++ Down
++ Left
++ Right
+
+^This is an information callout.^
+
+%This is a warning callout - use it when there’s a risk of getting a fine or going to prison.%
+
+$E
+**Example**
+Your income for the last tax year was £30,000. You think your income will drop to £20,000 this tax year. Enter £22,500 into the calculator.
+$E
+
+{::highlight-answer}
+The VAT rate is *20%*
+{:/highlight-answer}
+
+
+$C
+**Student Finance England**
+Telephone: 0845 300 5090
+Minicom: 0845 604 4434
+[Find out about call charges](http://www.gov.uk/call-charges)
+$C
+
+$A
+Hercules House
+Hercules Road
+London SE1 7DU
+$A
+
+$D
+[Download the 'Example application form' (PDF, 35KB)](http://example.com/ "Example form")
+$D

data/spec/fixtures/acceptance/animal-example-simple/outcomes/outcome_tigers_are_fine.txt

@@ -0,0 +1,9 @@
+# Tigers are fine
+
+You haven't trained with tigers, but you'll be alright, probably.
+
+[next_steps]
+###You bought a tiger? Seriously?
+
+[Your nearest hospital](https://gov.uk/hospital)
+[end_next_steps]

data/spec/fixtures/acceptance/animal-example-simple/outcomes/outcome_trained_with_lions.txt

@@ -0,0 +1,3 @@
+# You've trained with lions
+
+You'll be alright, I think.

data/spec/fixtures/acceptance/animal-example-simple/outcomes/outcome_untrained_with_lions.txt

@@ -0,0 +1,3 @@
+# You're not trained with lions
+
+Nice to know you.

data/spec/fixtures/acceptance/animal-example-simple/questions/question_1.txt

@@ -0,0 +1,13 @@
+# Amazing page title
+
+# What type of feline do you have?
+
+Check the serial number by the tail.
+
+[choice: question_1]
+* lion: Lion
+* tiger: Tiger
+* cat: Cat
+
+* question_1 in {lion tiger} => question_2
+* otherwise => outcome_safe_pet

data/spec/fixtures/acceptance/animal-example-simple/questions/question_2.txt

@@ -0,0 +1,10 @@
+# Are you trained for lions?
+
+[choice: trained_for_lions]
+* yes: Yes
+* no: No
+
+* question_1 is 'lion'
+  * trained_for_lions is 'yes' => outcome_trained_with_lions
+  * otherwise => outcome_untrained_with_lions
+* otherwise => outcome_tigers_are_fine

data/spec/model/predicates/combined_spec.rb

@@ -0,0 +1,47 @@
+require 'smartdown/model/predicate/combined'
+require 'smartdown/model/predicate/combined'
+require 'smartdown/model/predicate/named'
+require 'smartdown/engine/state'
+
+describe Smartdown::Model::Predicate::Combined do
+  let(:predicate_1) { Smartdown::Model::Predicate::Named.new("my_pred?") }
+  let(:predicate_2) { Smartdown::Model::Predicate::Named.new("my_other_pred?") }
+  subject(:predicate) { described_class.new([predicate_1, 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(predicate.evaluate(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(predicate.evaluate(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(predicate.evaluate(state)).to eq(false)
+      end
+    end
+  end
+
+  describe "#humanize" do
+    it { expect(predicate.humanize).to eq("(my_pred? AND my_other_pred?)") }
+  end
+end

data/spec/model/predicates/comparison_spec.rb

@@ -0,0 +1,162 @@
+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 "comparison predicates" do
+  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 { predicate.evaluate(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(predicate.evaluate(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(predicate.evaluate(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(predicate.evaluate(state)).to eq(results[predicate_key])
+          end
+        end
+      end
+    end
+
+    describe "#humanize" do
+      let(:results) { {
+        :greater => "my_var > 5",
+        :greater_or_equal => "my_var >= 5",
+        :less => "my_var < 5",
+        :less_or_equal => "my_var <= 5"
+      } }
+
+      it "has the right human representation" do
+        predicates.each do |predicate_key, predicate|
+          expect(predicate.humanize).to eq(results[predicate_key])
+        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 { predicate.evaluate(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(predicate.evaluate(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(predicate.evaluate(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(predicate.evaluate(state)).to eq(results[predicate_key])
+          end
+        end
+      end
+    end
+  end
+end

data/spec/model/predicates/equality_spec.rb

@@ -0,0 +1,36 @@
+require 'smartdown/model/predicate/equality'
+require 'smartdown/engine/state'
+
+describe Smartdown::Model::Predicate::Equality do
+  subject(:predicate) { described_class.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 { predicate.evaluate(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(predicate.evaluate(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(predicate.evaluate(state)).to eq(false)
+      end
+    end
+  end
+
+  describe "#humanize" do
+    it { expect(predicate.humanize).to eq("my_var == 'some value'") }
+  end
+end

data/spec/model/predicates/function_spec.rb

@@ -0,0 +1,85 @@
+require 'smartdown/model/predicate/function'
+require 'smartdown/engine/state'
+
+describe Smartdown::Model::Predicate::Function do
+  let(:function_name) { "my_function" }
+  subject(:predicate) { described_class.new(function_name, []) }
+
+  describe "#evaluate" do
+    context "state missing expected function definition" do
+      let(:state) { Smartdown::Engine::State.new(current_node: "n") }
+
+      it "raises an UndefinedValue error" do
+        expect { predicate.evaluate(state) }.to raise_error(Smartdown::Engine::UndefinedValue)
+      end
+    end
+
+    context "with no arguments" do
+      let(:function_return) { "hello" }
+      let(:my_function) { ->() { "hello" } }
+      let(:state) { Smartdown::Engine::State.new(current_node: "n", function_name => my_function) }
+
+      it "gets the return value of the function" do
+        expect(predicate.evaluate(state)).to eq(function_return)
+      end
+    end
+
+    context "with arguments" do
+      let(:my_function) { ->(x) { x * 100 } }
+      subject(:predicate) { described_class.new(function_name, ["number"]) }
+      let(:state) { Smartdown::Engine::State.new(current_node: "n", "number" => 3, function_name => my_function) }
+
+      it "gets the return value of the function" do
+        expect(predicate.evaluate(state)).to eq(300)
+      end
+    end
+
+    context "with many arguments" do
+      let(:function_return) { "hello" }
+      let(:my_function) { ->(name, age) { "Hi #{name}, you were #{age-20}, 20 years ago" } }
+      subject(:predicate) { described_class.new(function_name, ["name", "age"]) }
+      let(:state) { Smartdown::Engine::State.new(current_node: "n", "name" => "David", "age" => 30, function_name => my_function) }
+
+      it "gets the return value of the function" do
+        expect(predicate.evaluate(state)).to eq("Hi David, you were 10, 20 years ago")
+      end
+    end
+
+    context "with nested functions" do
+      # nesting looks like: function_1(function_2(5))
+      let(:function_1) { ->(x) { x - 1 } }
+      let(:function_2) { ->(x) { x * 100 } }
+      subject(:predicate) {
+        described_class.new("function_1", [
+          described_class.new("function_2", ['number'])
+        ])
+      }
+
+      let(:state) { Smartdown::Engine::State.new(
+        current_node: "n",
+        "function_1" => function_1,
+        "function_2" => function_2,
+        "number" => 5
+      ) }
+
+      it "gets the return value of the function" do
+        expect(predicate.evaluate(state)).to eq(499)
+      end
+    end
+  end
+
+  describe "#humanize" do
+    context "with no arguments" do
+      subject(:predicate) { described_class.new(function_name, []) }
+
+      it { expect(predicate.humanize).to eq("my_function()") }
+    end
+
+    context "with some arguments" do
+      let(:function_name) { "my_function" }
+      subject(:predicate) { described_class.new(function_name, ['foo', 'bar']) }
+
+      it { expect(predicate.humanize).to eq("my_function(foo bar)") }
+    end
+  end
+end

data/spec/model/predicates/named_spec.rb

@@ -0,0 +1,41 @@
+require 'smartdown/model/predicate/named'
+require 'smartdown/engine/state'
+
+describe Smartdown::Model::Predicate::Named do
+  let(:predicate_name) { "my_pred?" }
+  subject(:predicate) { described_class.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 { predicate.evaluate(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(predicate.evaluate(state)).to eq(true)
+      end
+    end
+  end
+
+  describe "#humanize" do
+    context "predicate name without question mark" do
+      subject(:predicate) { described_class.new("my_pred") }
+
+      it { expect(predicate.humanize).to eq("my_pred?") }
+    end
+
+    context "predicate name with question mark" do
+      subject(:predicate) { described_class.new("my_pred?") }
+
+      it { expect(predicate.humanize).to eq("my_pred?") }
+    end
+  end
+end

data/spec/model/predicates/set_membership_spec.rb

@@ -0,0 +1,39 @@
+require 'smartdown/model/predicate/set_membership'
+require 'smartdown/engine/state'
+
+describe Smartdown::Model::Predicate::SetMembership do
+  let(:expected_values) { ["v1", "v2", "v3"] }
+  let(:varname) { "my_var" }
+  subject(:predicate) { described_class.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 { predicate.evaluate(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(predicate.evaluate(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(predicate.evaluate(state)).to eq(false)
+      end
+    end
+  end
+
+  describe "#humanize" do
+    it { expect(predicate.humanize).to eq("my_var in [v1, v2, v3]") }
+  end
+end