smartdown 0.7.1 → 0.8.0

data/README.md

@@ -295,6 +295,15 @@ outcome_the_result
 outcome_the_other_result
 ```
 
+##Code terminology
+
+####Answers vs responses
+
+The words 'answers' and 'responses' are used for various variable names and method names throughout the gem.
+Both are used to describe an answer to a question, but indicate two different formats:
+* ```response``` is used for raw string inputs
+* ```answer``` is used for Model::Answer objects
+
 ## Software design
 
 The initial plan for software design can be seen in this diagram:

data/lib/smartdown/api/flow.rb

@@ -22,7 +22,8 @@ module Smartdown
         state = smartdown_state(started, responses)
         State.new(transform_node(evaluate_node(node_by_name(state.get(:current_node)), state)),
                   previous_question_nodes_for(state),
-                  responses
+                  state.get(:accepted_responses)[1..-1] || [],
+                  state.get(:current_answers)
         )
       end
 
@@ -35,11 +36,11 @@ module Smartdown
       end
 
       def meta_description
-        front_matter.meta_description
+        front_matter.fetch meta_description, nil
       end
 
       def need_id
-        front_matter.satisfies_need
+        front_matter.fetch satisfies_need, nil
       end
 
       def status

data/lib/smartdown/api/node.rb

@@ -26,7 +26,7 @@ module Smartdown
         build_govspeak(elements_before_smartdown)
       end
 
-      def devolved_body
+      def post_body
         elements_after_smartdown = elements.drop_while{|element| !smartdown_element?(element)}
         build_govspeak(elements_after_smartdown)
       end

data/lib/smartdown/api/state.rb

@@ -4,22 +4,23 @@ module Smartdown
   module Api
     class State
 
-      attr_reader :responses, :current_node
+      attr_reader :accepted_responses, :current_node, :current_answers
 
-      def initialize(current_node, previous_questionpage_smartdown_nodes, responses)
+      def initialize(current_node, previous_questionpage_smartdown_nodes, accepted_responses, current_answers)
         @current_node = current_node
         @previous_questionpage_smartdown_nodes = previous_questionpage_smartdown_nodes
-        @responses = responses
+        @accepted_responses = accepted_responses
+        @current_answers = current_answers
       end
 
-      def answers
-        previous_question_pages(responses).map { |previous_question_page|
+      def previous_answers
+        previous_question_pages.map { |previous_question_page|
           previous_question_page.answers
         }.flatten
       end
 
-      def previous_question_pages(responses)
-        @previous_question_pages ||= build_question_pages(responses)
+      def previous_question_pages
+        @previous_question_pages ||= build_question_pages(accepted_responses)
       end
 
       def started?
@@ -31,12 +32,12 @@ module Smartdown
       end
 
       def current_question_number
-        responses.count + 1
+        accepted_responses.count + 1
       end
 
     private
 
-      attr_reader :smartdown_state, :previous_questionpage_smartdown_nodes
+      attr_reader :previous_questionpage_smartdown_nodes
 
       def build_question_pages(responses)
         resp = responses.dup

data/lib/smartdown/engine/state.rb

@@ -8,7 +8,8 @@ module Smartdown
       def initialize(data = {})
         @data = duplicate_and_normalize_hash(data)
         @data["path"] ||= []
-        @data["responses"] ||= []
+        @data["accepted_responses"] ||= []
+        @data["current_answers"] ||= []
         @cached = {}
         raise ArgumentError, "must specify current_node" unless has_key?("current_node")
       end

data/lib/smartdown/engine/transition.rb

@@ -3,12 +3,12 @@ require 'smartdown/engine/errors'
 module Smartdown
   class Engine
     class Transition
-      attr_reader :state, :node, :inputs
+      attr_reader :state, :node, :answers
 
-      def initialize(state, node, input_array, options = {})
+      def initialize(state, node, answers, options = {})
         @state = state
         @node = node
-        @inputs = input_array
+        @answers = answers
       end
 
       def next_node
@@ -18,9 +18,9 @@ module Smartdown
       end
 
       def next_state
-        state_with_inputs
+        state_with_responses
           .put(:path, state.get(:path) + [node.name])
-          .put(:responses, state.get(:responses) + inputs)
+          .put(:accepted_responses, state.get(:accepted_responses) + answers.map(&:to_s))
           .put(:current_node, next_node)
       end
 
@@ -47,11 +47,11 @@ module Smartdown
         rules.each do |rule|
           case rule
           when Smartdown::Model::Rule
-            if rule.predicate.evaluate(state_with_inputs)
+            if rule.predicate.evaluate(state_with_responses)
               throw(:match, rule)
             end
           when Smartdown::Model::NestedRule
-            if rule.predicate.evaluate(state_with_inputs)
+            if rule.predicate.evaluate(state_with_responses)
               throw_first_matching_rule_in(rule.children)
             end
           else
@@ -61,10 +61,10 @@ module Smartdown
         raise Smartdown::Engine::IndeterminateNextNode
       end
 
-      def state_with_inputs
-        result = state.put(node.name, inputs)
+      def state_with_responses
+        result = state.put(node.name, answers.map(&:to_s))
         input_variable_names_from_question.each_with_index do |input_variable_name, index|
-          result = result.put(input_variable_name, inputs[index])
+          result = result.put(input_variable_name, answers[index])
         end
         result
       end

data/lib/smartdown/engine.rb

@@ -25,6 +25,7 @@ module Smartdown
     end
 
     def process(raw_responses, test_start_state = nil)
+      #TODO: change interface to match started, raw_responses like API state...no need for shifting etc...
       state = test_start_state || build_start_state
       unprocessed_responses = raw_responses
       while !unprocessed_responses.empty? do
@@ -38,6 +39,10 @@ module Smartdown
             question.answer_type.new(unprocessed_responses.shift, question)
           end
 
+          unless answers.all?(&:valid?)
+            state = state.put(:current_answers, answers)
+            break
+          end
           transition = Transition.new(state, current_node, answers)
         end
         state = transition.next_state

data/lib/smartdown/model/answer/base.rb

@@ -5,25 +5,46 @@ module Smartdown
         extend Forwardable
         include Comparable
 
-        def_delegators :value, :to_s, :humanize, :to_i, :to_f, :+, :-, :*, :/
+        def_delegators :value, :to_s, :humanize, :to_i, :to_f
 
         def value_type
           ::String
         end
 
+        def -(other)
+          value - parse_other_object(other)
+        end
+
+        def +(other)
+          value + parse_other_object(other)
+        end
+
+        def *(other)
+          value * parse_other_object(other)
+        end
+
+        def /(other)
+          value / parse_other_object(other)
+        end
+
         def <=>(other)
-          value <=> parse_comparison_object(other)
+          value <=> parse_other_object(other)
         end
 
-        attr_reader :question, :value
+        attr_reader :question, :value, :error
 
         def initialize(value, question=nil)
-          @value = parse_value(value)
           @question = question
+          @value = check_value_not_nil(value)
+          @value = parse_value(value) if valid?
+        end
+
+        def valid?
+          @error.nil?
         end
 
       private
-        def parse_comparison_object(comparison_object)
+        def parse_other_object(comparison_object)
           if comparison_object.is_a? Base
             comparison_object.value
           elsif comparison_object.is_a? value_type
@@ -36,6 +57,13 @@ module Smartdown
         def parse_value(value)
           value
         end
+
+        def check_value_not_nil(value)
+          unless value
+            @error = "Please answer this question"
+          end
+          value
+        end
       end
     end
   end

data/lib/smartdown/model/answer/date.rb

@@ -18,7 +18,12 @@ module Smartdown
 
       private
         def parse_value(value)
-          ::Date.parse(value)
+          begin
+            ::Date.parse(value)
+          rescue ArgumentError
+            @error = "Invalid date"
+            return
+          end
         end
       end
     end

data/lib/smartdown/model/answer/money.rb

@@ -14,7 +14,10 @@ module Smartdown
         end
 
         def humanize
-          "£#{'%.2f' % value}"
+          number_string = "£#{'%.2f' % value}".gsub(/(\d)(?=(\d\d\d)+(?!\d))/) do |digit_to_delimit|
+            "#{digit_to_delimit},"
+          end
+          number_string.end_with?(".00") ? number_string[0..-4] : number_string
         end
       end
     end

data/lib/smartdown/model/answer/multiple_choice.rb

@@ -11,6 +11,17 @@ module Smartdown
         def humanize
           question.choices.fetch(value)
         end
+
+        private
+        def parse_value(value)
+          check_value_not_nil(value)
+          if valid?
+            unless question.choices.keys.include? value
+              @error = "Invalid choice"
+            end
+          end
+          value
+        end
       end
     end
   end

data/lib/smartdown/model/answer/salary.rb

@@ -7,23 +7,34 @@ module Smartdown
       class Salary < Base
         attr_reader :period, :amount_per_period
 
+        FORMAT_REGEX = /^£?\W*([\d|,|]+[\.]?[\d]*)[-|\W*per\W*](week|month|year)$/
+
         def value_type
           ::Float
         end
 
         def to_s
-          "#{'%.2f' % amount_per_period} per #{period}"
+          "#{'%.2f' % amount_per_period}-#{period}"
         end
 
         def humanize
           whole, decimal = separate_by_comma(amount_per_period)
-          "£#{whole}.#{decimal} per #{period}"
+          if decimal == "00"
+            "£#{whole} per #{period}"
+          else
+            "£#{whole}.#{decimal} per #{period}"
+          end
         end
 
       private
         def parse_value(value)
-          @amount_per_period, @period = value.split(/-|\W*per\W*/)
-          @amount_per_period = @amount_per_period.to_f
+          matched_value = value.strip.match FORMAT_REGEX
+          unless matched_value
+            @error = "Invalid format"
+            return
+          end
+          @amount_per_period, @period = *matched_value[1..2]
+          @amount_per_period = @amount_per_period.gsub(",","").to_f
           yearly_total
         end
 
@@ -43,7 +54,6 @@ module Smartdown
           left.gsub!(/(\d)(?=(\d\d\d)+(?!\d))/) do |digit_to_delimit|
             "#{digit_to_delimit},"
           end
-          right = "%02d" % right.to_i
           [left, right]
         end
       end

data/lib/smartdown/model/front_matter.rb

@@ -21,8 +21,8 @@ module Smartdown
         @attributes.has_key?(name.to_s)
       end
 
-      def fetch(name)
-        @attributes.fetch(name.to_s)
+      def fetch(name, *args)
+        @attributes.fetch(name.to_s, *args)
       end
 
       def to_hash

data/lib/smartdown/model/node.rb

@@ -12,7 +12,11 @@ module Smartdown
       end
 
       def body
-        markdown_blocks[1..-1].map { |block| as_markdown(block) }.compact.join("\n")
+        markdown_blocks_before_question.map { |block| as_markdown(block) }.compact.join("\n")
+      end
+
+      def post_body
+        markdown_blocks_after_question.map { |block| as_markdown(block) }.compact.join("\n")
       end
 
       def questions
@@ -35,8 +39,18 @@ module Smartdown
 
       private
 
-      def markdown_blocks
-        elements_of_kind(Smartdown::Model::Element::MarkdownHeading, Smartdown::Model::Element::MarkdownParagraph)
+      def markdown_blocks_before_question
+        elements.take_while { |e|
+          e.is_a?(Smartdown::Model::Element::MarkdownHeading) ||
+          e.is_a?(Smartdown::Model::Element::MarkdownParagraph)
+        }[1..-1]
+      end
+
+      def markdown_blocks_after_question
+        elements.reverse.take_while { |e|
+          e.is_a?(Smartdown::Model::Element::MarkdownHeading) ||
+          e.is_a?(Smartdown::Model::Element::MarkdownParagraph)
+        }.reverse
       end
 
       def h1s

data/lib/smartdown/parser/node_transform.rb

@@ -33,15 +33,15 @@ module Smartdown
       }
 
       rule(h1: simple(:content)) {
-        Smartdown::Model::Element::MarkdownHeading.new(content)
+        Smartdown::Model::Element::MarkdownHeading.new(content.to_s)
       }
 
       rule(p: simple(:content)) {
-        Smartdown::Model::Element::MarkdownParagraph.new(content)
+        Smartdown::Model::Element::MarkdownParagraph.new(content.to_s)
       }
 
       rule(:start_button => simple(:start_node)) {
-        Smartdown::Model::Element::StartButton.new(start_node)
+        Smartdown::Model::Element::StartButton.new(start_node.to_s)
       }
 
       rule(:front_matter => subtree(:attrs), body: subtree(:body)) {
@@ -66,7 +66,7 @@ module Smartdown
 
       rule(:multiple_choice => {identifier: simple(:identifier), options: subtree(:choices)}) {
         Smartdown::Model::Element::Question::MultipleChoice.new(
-          identifier, Hash[choices]
+          identifier.to_s, Hash[choices]
         )
       }
 
@@ -115,17 +115,17 @@ module Smartdown
       }
 
       rule(:equality_predicate => { varname: simple(:varname), expected_value: simple(:expected_value) }) {
-        Smartdown::Model::Predicate::Equality.new(varname, expected_value)
+        Smartdown::Model::Predicate::Equality.new(varname.to_s, expected_value.to_s)
       }
 
       rule(:set_value => simple(:value)) { value }
 
       rule(:set_membership_predicate => { varname: simple(:varname), values: subtree(:values) }) {
-        Smartdown::Model::Predicate::SetMembership.new(varname, values)
+        Smartdown::Model::Predicate::SetMembership.new(varname.to_s, values)
       }
 
       rule(:named_predicate => simple(:name) ) {
-        Smartdown::Model::Predicate::Named.new(name)
+        Smartdown::Model::Predicate::Named.new(name.to_s)
       }
 
       rule(:otherwise_predicate => simple(:name) ) {
@@ -136,14 +136,14 @@ module Smartdown
         Smartdown::Model::Predicate::Combined.new([first_predicate]+and_predicates)
       }
 
-      rule(:function_argument => simple(:argument)) { argument }
+      rule(:function_argument => simple(:argument)) { argument.to_s }
 
       rule(:function_predicate => { name: simple(:name), arguments: subtree(:arguments) }) {
-        Smartdown::Model::Predicate::Function.new(name, Array(arguments))
+        Smartdown::Model::Predicate::Function.new(name.to_s, Array(arguments))
       }
 
       rule(:function_predicate => { name: simple(:name) }) {
-        Smartdown::Model::Predicate::Function.new(name, [])
+        Smartdown::Model::Predicate::Function.new(name.to_s, [])
       }
 
       rule(:comparison_predicate => { varname: simple(:varname), 
@@ -152,20 +152,20 @@ module Smartdown
                                      }) { 
         case operator
         when "<="
-          Smartdown::Model::Predicate::Comparison::LessOrEqual.new(varname, value)
+          Smartdown::Model::Predicate::Comparison::LessOrEqual.new(varname.to_s, value.to_s)
         when "<"
-          Smartdown::Model::Predicate::Comparison::Less.new(varname, value)
+          Smartdown::Model::Predicate::Comparison::Less.new(varname.to_s, value.to_s)
         when ">="
-          Smartdown::Model::Predicate::Comparison::GreaterOrEqual.new(varname, value)
+          Smartdown::Model::Predicate::Comparison::GreaterOrEqual.new(varname.to_s, value.to_s)
         when ">"
-          Smartdown::Model::Predicate::Comparison::Greater.new(varname, value)
+          Smartdown::Model::Predicate::Comparison::Greater.new(varname.to_s, value.to_s)
         else
           raise "Comparison operator not recognised"
         end
       }
 
       rule(:rule => {predicate: subtree(:predicate), outcome: simple(:outcome_name) } ) {
-        Smartdown::Model::Rule.new(predicate, outcome_name)
+        Smartdown::Model::Rule.new(predicate, outcome_name.to_s)
       }
       rule(:nested_rule => {predicate: subtree(:predicate), child_rules: subtree(:child_rules) } ) {
         Smartdown::Model::NestedRule.new(predicate, child_rules)

data/lib/smartdown/parser/predicates.rb

@@ -60,7 +60,7 @@ module Smartdown
       }
 
       rule (:function_predicate) {
-        identifier.as(:name) >>
+        (identifier >> str('?').maybe).as(:name) >>
         str('(') >>
         function_arguments.as(:arguments).maybe >>
         str(')')

data/lib/smartdown/version.rb

@@ -1,3 +1,3 @@
 module Smartdown
-  VERSION = "0.7.1"
+  VERSION = "0.8.0"
 end

data/spec/acceptance/flow_spec.rb

@@ -32,6 +32,26 @@ describe Smartdown::Api::Flow do
       expect(tigers_and_cats_scenario.question_groups.first.first.name).to eq("question_1")
       expect(tigers_and_cats_scenario.question_groups.first.first.answer).to eq("cat")
     end
+
+    context "flow state" do
+      context "with no answers given" do
+        specify { expect(flow.state("y",[]).current_answers).to be_empty }
+        specify { expect(flow.state("y",[]).accepted_responses).to eq [] }
+      end
+
+      context "with a valid answer given to the first question" do
+        specify { expect(flow.state("y",["cat"]).current_node.name).to eq "outcome_safe_pet" }
+        specify { expect(flow.state("y",["cat"]).accepted_responses).to eq ["cat"] }
+        specify { expect(flow.state("y",["cat"]).current_answers).to eq [] }
+      end
+
+      context "with an invalid answer given to the first question" do
+        specify { expect(flow.state("y",["lynx"]).current_node.name).to eq "question_1" }
+        specify { expect(flow.state("y",["lynx"]).accepted_responses).to eq [] }
+        specify { expect(flow.state("y",["lynx"]).current_answers.first.error).to eq "Invalid choice" }
+      end
+    end
+
   end
 
   context "flow with two questions per page" do
@@ -60,6 +80,50 @@ describe Smartdown::Api::Flow do
       expect(tigers_and_cats_scenario.question_groups[1][1].name).to eq("trained_for_tigers")
       expect(tigers_and_cats_scenario.question_groups[1][1].answer).to eq("no")
     end
+
+    context "flow state" do
+      context "with no answers given" do
+        specify { expect(flow.state("y",[]).current_answers).to be_empty }
+      end
+
+      context "with a valid answer given to the first question, only first answer to second page" do
+        specify { expect(flow.state("y",["lion", "yes", nil]).current_node.name).to eq "question_2" }
+        specify { expect(flow.state("y",["lion", "yes", nil]).accepted_responses).to eq ["lion"] }
+        specify { expect(flow.state("y",["lion", "yes", nil]).current_answers.count).to eq 2 }
+        specify { expect(flow.state("y",["lion", "yes", nil]).current_answers[0].valid?).to be true }
+        specify { expect(flow.state("y",["lion", "yes", nil]).current_answers[1].error).to eq "Please answer this question" }
+      end
+
+      context "with a valid answer given to the first question, only second answer to second page" do
+        specify { expect(flow.state("y",["lion", nil, "yes"]).current_node.name).to eq "question_2" }
+        specify { expect(flow.state("y",["lion", nil, "yes"]).accepted_responses).to eq ["lion"] }
+        specify { expect(flow.state("y",["lion", nil, "yes"]).current_answers.count).to eq 2 }
+        specify { expect(flow.state("y",["lion", nil, "yes"]).current_answers[1].valid?).to be true }
+        specify { expect(flow.state("y",["lion", nil, "yes"]).current_answers[0].error).to eq "Please answer this question" }
+      end
+
+      context "with a valid answer given to the first question, only first invalid answer to second page" do
+        specify { expect(flow.state("y",["lion", "lynx", nil]).current_node.name).to eq "question_2" }
+        specify { expect(flow.state("y",["lion", "lynx", nil]).accepted_responses).to eq ["lion"] }
+        specify { expect(flow.state("y",["lion", "lynx", nil]).current_answers.count).to eq 2 }
+        specify { expect(flow.state("y",["lion", "lynx", nil]).current_answers[0].error).to eq "Invalid choice" }
+        specify { expect(flow.state("y",["lion", "lynx", nil]).current_answers[1].error).to eq "Please answer this question" }
+      end
+
+      context "with a valid answer given to the first question, empty answers to second page" do
+        specify { expect(flow.state("y",["lion", nil, nil]).current_node.name).to eq "question_2" }
+        specify { expect(flow.state("y",["lion", nil, nil]).accepted_responses).to eq ["lion"] }
+        specify { expect(flow.state("y",["lion", nil, nil]).current_answers.count).to eq 2 }
+        specify { expect(flow.state("y",["lion", nil, nil]).current_answers[0].error).to eq "Please answer this question" }
+        specify { expect(flow.state("y",["lion", nil, nil]).current_answers[1].error).to eq "Please answer this question" }
+      end
+
+      context "with valid answers to both pages" do
+        specify { expect(flow.state("y",["lion", "no", "no"]).current_node.name).to eq "outcome_untrained_with_lions" }
+        specify { expect(flow.state("y",["lion", "no", "no"]).accepted_responses).to eq ["lion", "no", "no"] }
+        specify { expect(flow.state("y",["lion", "no", "no"]).current_answers).to eq [] }
+      end
+    end
   end
 
 end

data/spec/acceptance/parsing_spec.rb

@@ -87,6 +87,12 @@ para 2.
 EXPECTED
       end
 
+      it "has a post body" do
+        expect(question_node.post_body).to eq(<<-EXPECTED)
+Text after the question.
+EXPECTED
+      end
+
       it "has a multiple choice question" do
         expect(question_node.questions).to match([instance_of(Smartdown::Model::Element::Question::MultipleChoice)])
       end

data/spec/api/previous_question_spec.rb

@@ -5,7 +5,11 @@ describe Smartdown::Api::PreviousQuestion do
 
   subject(:previous_question) { Smartdown::Api::PreviousQuestion.new(elements, response)}
   let(:elements) { [ multiple_choice_element ] }
-  let(:multiple_choice_element) { Smartdown::Model::Element::Question::MultipleChoice.new }
+  let(:multiple_choice_element) {
+    Smartdown::Model::Element::Question::MultipleChoice.new("question",
+                                                            {"answer" => "Beautiful answer"}
+    )
+  }
   let(:response) { double(:response) }
   let(:multiple_choice_class) { double(:multiple_choice_class, :new => nil) }
   let(:answer_type) { double(:answer_type) }

data/spec/api/state_spec.rb

@@ -2,7 +2,7 @@ require 'smartdown/api/state'
 
 describe Smartdown::Api::State do
 
-  subject(:state) { Smartdown::Api::State.new(current_node, previous_questionpage_smartdown_nodes, responses)}
+  subject(:state) { Smartdown::Api::State.new(current_node, previous_questionpage_smartdown_nodes, responses, double)}
   let(:current_node) { double(:current_node) }
   let(:previous_questionpage_smartdown_nodes) { [question_page_node_1, question_page_node_2] }
   let(:question_page_node_1) { double(:question_page_node_1, :questions => [double, double]) }
@@ -13,7 +13,7 @@ describe Smartdown::Api::State do
   describe "#previous_question_pages" do
     it "creates question pages with their corresponding responses" do
       stub_const("Smartdown::Api::PreviousQuestionPage", previous_question_page_class)
-      state.previous_question_pages(responses)
+      state.previous_question_pages
       expect(Smartdown::Api::PreviousQuestionPage).to have_received(:new)
                                                   .with(question_page_node_1, ["a", "b"])
       expect(Smartdown::Api::PreviousQuestionPage).to have_received(:new)

data/spec/engine/interpolator_spec.rb

@@ -72,17 +72,6 @@ describe Smartdown::Engine::Interpolator do
     end
   end
 
-  context "a paragraph containing a parslet slice" do
-    let(:elements) { [Smartdown::Model::Element::MarkdownParagraph.new(Parslet::Slice.new(0, 'Hello %{name}'))] }
-
-    it "interpolates without raising an error about gsub missing" do
-      # Note: the parser actually produces parslet 'slices' rather than strings.
-      # A parslet slice behaves like a string but doesn't have all of the methods of string.
-      # This test is to document that fact and catch any regressions.
-      expect(interpolated_node.elements.first.content).to eq("Hello #{example_name}")
-    end
-  end
-
   context "a paragraph containing function call" do
     let(:elements) { [Smartdown::Model::Element::MarkdownParagraph.new('%{double(number)}')] }
     let(:state) {

data/spec/engine/state_spec.rb

@@ -10,8 +10,9 @@ describe Smartdown::Engine::State do
   end
 
   it "initializes path and responses" do
-    expect(subject.get(:responses)).to eq []
+    expect(subject.get(:accepted_responses)).to eq []
     expect(subject.get(:path)).to eq []
+    expect(subject.get(:current_answers)).to eq []
   end
 
   describe "#get" do
@@ -27,7 +28,7 @@ describe Smartdown::Engine::State do
 
   describe "#keys" do
     it "returns a set of all keys in the state" do
-      expect(subject.keys).to eq(Set.new(["current_node", "path", "responses"]))
+      expect(subject.keys).to eq(Set.new(["current_node", "path", "accepted_responses", "current_answers"]))
     end
   end
 

data/spec/engine/transition_spec.rb

@@ -88,7 +88,7 @@ describe Smartdown::Engine::Transition do
     describe "#next_state" do
       it "returns a state including a record of responses, path, and new current_node" do
         expected_state = start_state
-          .put(:responses, [input])
+          .put(:accepted_responses, [input])
           .put(:path, [current_node_name])
           .put(:current_node, outcome_name1)
           .put(current_node.name, input_array)

data/spec/engine_spec.rb

@@ -83,9 +83,30 @@ describe Smartdown::Engine do
             outcome("outcome_imaginary_country")
           end
           rule do
-            set_membership_predicate("what_passport_do_you_have?", ["greek", "british"])
+            set_membership_predicate("what_passport_do_you_have?", ["greek"])
             outcome("outcome_no_visa_needed")
           end
+          rule do
+            set_membership_predicate("what_passport_do_you_have?", ["british"])
+            outcome("second_passport_question")
+          end
+        end
+      end
+
+      node("second_passport_question") do
+        heading("What colour is your passport?")
+        multiple_choice(
+            "what_colour_is_your_passport?",
+            {
+                red: "Red",
+                white: "White",
+                blue: "Blue"
+            }
+        )
+        next_node_rules do
+          rule do
+            outcome("outcome_passport_colour_specified")
+          end
         end
       end
 
@@ -108,6 +129,10 @@ describe Smartdown::Engine do
       node("outcome_with_interpolation") do
         paragraph("The answer is %{interpolated_variable}")
       end
+
+      node("outcome_passport_colour_specified") do
+        paragraph("What a pretty passport")
+      end
     end
   }
 
@@ -165,6 +190,16 @@ describe Smartdown::Engine do
           expect { subject }.to raise_error(Smartdown::Engine::IndeterminateNextNode)
         end
       end
+
+      context "no passport answer entered" do
+        let(:responses) { ["yes", nil] }
+
+        it "raises parsing errors" do
+          expect(subject.get(:current_node)).to eq("passport_question")
+          expect(subject.get("current_answers").count).to eq 1
+          expect(subject.get("current_answers").first.error).to eq "Please answer this question"
+        end
+      end
     end
 
     context "two questions per page" do
@@ -194,6 +229,49 @@ describe Smartdown::Engine do
           expect(subject.get("what_country_are_you_going_to?")).to eq("usa")
         end
       end
+
+      context "no answers given" do
+        let(:responses) { ["yes", nil, nil] }
+        it "raises parsing errors" do
+          expect(subject.get(:current_node)).to eq("passport_question")
+          expect(subject.get("current_answers").count).to eq 2
+          expect(subject.get("current_answers")[0].error).to eq "Please answer this question"
+          expect(subject.get("current_answers")[1].error).to eq "Please answer this question"
+          expect(subject.get("accepted_responses")).to eq ["yes"]
+        end
+      end
+
+      context "only second answer given" do
+        let(:responses) { ["yes", nil, "narnia"] }
+        it "raises parsing errors" do
+          expect(subject.get(:current_node)).to eq("passport_question")
+          expect(subject.get("current_answers").count).to eq 2
+          expect(subject.get("current_answers")[0].error).to eq "Please answer this question"
+          expect(subject.get("current_answers")[1].error).to be nil
+          expect(subject.get("accepted_responses")).to eq ["yes"]
+        end
+      end
+
+      context "only first answer given" do
+        let(:responses) { ["yes", "greek", nil] }
+        it "raises parsing errors" do
+          expect(subject.get(:current_node)).to eq("passport_question")
+          expect(subject.get("current_answers").count).to eq 2
+          expect(subject.get("current_answers")[0].error).to be nil
+          expect(subject.get("current_answers")[1].error).to eq "Please answer this question"
+          expect(subject.get("accepted_responses")).to eq ["yes"]
+        end
+      end
+
+      context "british, going to usa" do
+        let(:responses) { ["yes", "british", "usa", nil] }
+        it "raises parsing errors" do
+          expect(subject.get(:current_node)).to eq("second_passport_question")
+          expect(subject.get("current_answers").count).to eq 1
+          expect(subject.get("current_answers").first.error).to eq "Please answer this question"
+          expect(subject.get("accepted_responses")).to eq ["yes", "british", "usa"]
+        end
+      end
     end
   end
 

data/spec/fixtures/acceptance/one-question/questions/q1.txt

@@ -8,3 +8,5 @@ para 2.
 [choice: q1]
 * yes: Yes
 * no: No
+
+Text after the question.

data/spec/model/answer/base_spec.rb

@@ -20,4 +20,26 @@ describe Smartdown::Model::Answer::Base do
       it { should respond_to(method) }
     end
   end
+
+  describe 'validations' do
+    describe 'valid?' do
+      it 'returns true if there are no errors on the question' do
+        expect(instance).to be_valid
+      end
+
+      it "has no error defined" do
+        expect(instance.error).to be nil
+      end
+
+      context "answer has been given a nil value" do
+        let(:value) { nil }
+        it 'returns false if there are no errors on the question' do
+          expect(instance).not_to be_valid
+        end
+        it "has an error asking for user to input a value" do
+          expect(instance.error).to eq "Please answer this question"
+        end
+      end
+    end
+  end
 end

data/spec/model/answer/date_spec.rb

@@ -14,6 +14,21 @@ describe Smartdown::Model::Answer::Date do
     specify { expect(instance.humanize).to eql "10 January 2000" }
   end
 
+  describe "errors" do
+
+    context "format is incorrect" do
+      let(:date_string) { "tomorrow" }
+      specify { expect(instance.error).to eql "Invalid date" }
+      specify { expect(instance.value).to eql nil }
+    end
+
+    context "answer not filled in" do
+      let(:date_string) { nil }
+      specify { expect(instance.error).to eql "Please answer this question" }
+      specify { expect(instance.value).to eql nil }
+    end
+  end
+
   describe "comparisons" do
     let(:date_string) { "2000-1-10" }
 

data/spec/model/answer/money_spec.rb

@@ -28,5 +28,11 @@ describe Smartdown::Model::Answer::Money do
         expect(instance.humanize).to eql("£523.42")
       end
     end
+    context "no pence" do
+      let(:money_float) { 523.00 }
+      it "rounds down amounts of money correctly" do
+        expect(instance.humanize).to eql("£523")
+      end
+    end
   end
 end

data/spec/model/answer/multiple_choice_spec.rb

@@ -3,7 +3,8 @@ require 'smartdown/model/answer/multiple_choice'
 
 describe Smartdown::Model::Answer::MultipleChoice do
 
-  subject(:answer) { described_class.new("answer", multiple_choice_question) }
+  let(:answer_string) { "answer" }
+  subject(:answer) { described_class.new(answer_string, multiple_choice_question) }
   let(:multiple_choice_question) {
     Smartdown::Model::Element::Question::MultipleChoice.new("question",
                                                             {"answer" => "Beautiful answer"}
@@ -15,4 +16,16 @@ describe Smartdown::Model::Answer::MultipleChoice do
       expect(answer.humanize).to eq "Beautiful answer"
     end
   end
+
+  describe "errors" do
+    context "format is incorrect" do
+      let(:answer_string) { "kasjdf" }
+      specify { expect(answer.error).to eql "Invalid choice" }
+    end
+
+    context "answer not filled in" do
+      let(:answer_string) { nil }
+      specify { expect(answer.error).to eql "Please answer this question" }
+    end
+  end
 end

data/spec/model/answer/salary_spec.rb

@@ -11,18 +11,18 @@ describe Smartdown::Model::Answer::Salary do
   specify { expect(instance.amount_per_period).to eql(500.00) }
 
   it "as a string, it should declare itself in the initial format provided" do
-    expect(instance.to_s).to eql("500.00 per week")
+    expect(instance.to_s).to eql("500.00-week")
   end
 
   describe "#humanize" do
     it "declares itself in the initial format provided" do
-      expect(instance.humanize).to eql("£500.00 per week")
+      expect(instance.humanize).to eql("£500 per week")
     end
 
     context "amounts over 999" do
       let(:salary_string) { "15000-week" }
       it "adds commas" do
-        expect(instance.humanize).to eql("£15,000.00 per week")
+        expect(instance.humanize).to eql("£15,000 per week")
       end
     end
 
@@ -46,6 +46,32 @@ describe Smartdown::Model::Answer::Salary do
         expect(instance.humanize).to eql("£15,000.56 per week")
       end
     end
+
+    context "amounts with commas" do
+      let(:salary_string) { "15,0000-week" }
+      it "correct comma location" do
+        expect(instance.humanize).to eql("£150,000 per week")
+      end
+    end
+  end
+
+  describe "errors" do
+    context "invalid formatting" do
+      let(:salary_string) {"Loads'a'money"}
+
+      it "Has errors" do
+        expect(instance.error).to eql("Invalid format")
+      end
+    end
+
+    context "no input" do
+      let(:salary_string) { nil }
+
+      it "Has errors" do
+        expect(instance.error).to eql("Please answer this question")
+      end
+    end
+
   end
 
   context "declared by week" do

data/spec/model/front_matter_spec.rb

@@ -0,0 +1,35 @@
+require 'smartdown/model/front_matter.rb'
+
+describe Smartdown::Model::FrontMatter do
+
+  subject { described_class.new({ 'key' => :thing }) }
+
+  describe "fetch" do
+    context 'Has the attribute desired' do
+      it { expect(subject.fetch 'key').to eq(:thing) }
+
+      it "doesn't use the default" do
+        expect(subject.fetch 'key', 'default').to eq(:thing)
+      end
+    end
+
+    context 'Does not have the attribute desired' do
+      it 'raises error by default if the attribute is missing' do
+        expect { subject.fetch :hahhad }.to raise_error
+      end
+
+      it 'allows passing a default to return on failure' do
+        expect(subject.fetch :askdjf, 'draft').to eq ('draft')
+      end
+
+      it 'allows passing a nil default to return on failure' do
+        expect(subject.fetch :askdjf, nil).to be_nil
+      end
+
+      it 'raises an error if more than 2 arguments are passed' do
+        expect { subject.fetch :askdjf, 'draft', 'x' }.to raise_error(ArgumentError)
+      end
+    end
+  end
+end
+

data/spec/model/predicates/comparison_spec.rb

@@ -114,7 +114,7 @@ describe "comparison predicates" do
       end
 
       context "state has lower value" do
-        let(:state) { Smartdown::Engine::State.new(current_node: "n", my_var: "2014-1-30") }
+        let(:state) { Smartdown::Engine::State.new(current_node: "n", my_var: Smartdown::Model::Answer::Date.new("2014-1-30")) }
         let(:results) { {
             :greater => false,
             :greater_or_equal => false,
@@ -129,7 +129,7 @@ describe "comparison predicates" do
       end
 
       context "state has identical value" do
-        let(:state) { Smartdown::Engine::State.new(current_node: "n", my_var: "2014-1-31") }
+        let(:state) { Smartdown::Engine::State.new(current_node: "n", my_var: Smartdown::Model::Answer::Date.new("2014-1-31")) }
         let(:results) { {
             :greater => false,
             :greater_or_equal => true,
@@ -144,7 +144,7 @@ describe "comparison predicates" do
       end
 
       context "state has higher value" do
-        let(:state) { Smartdown::Engine::State.new(current_node: "n", my_var: "2014-2-1") }
+        let(:state) { Smartdown::Engine::State.new(current_node: "n", my_var: Smartdown::Model::Answer::Date.new("2014-2-1")) }
         let(:results) { {
             :greater => true,
             :greater_or_equal => true,

data/spec/model/predicates/function_spec.rb

@@ -45,6 +45,17 @@ describe Smartdown::Model::Predicate::Function do
       end
     end
 
+    context "with a ? in the function name" do
+      let(:function_name) { "is_odd?" }
+      let(:my_function) { ->(number) { number.odd? } }
+      subject(:predicate) { described_class.new(function_name, ["number"]) }
+      let(:state) { Smartdown::Engine::State.new(current_node: "n", "number" => 3, function_name => my_function) }
+
+      it "can be called normally" do
+        expect(predicate.evaluate(state)).to eq(true)
+      end
+    end
+
     context "with nested functions" do
       # nesting looks like: function_1(function_2(5))
       let(:function_1) { ->(x) { x - 1 } }

data/spec/parser/predicates_spec.rb

@@ -140,6 +140,21 @@ describe Smartdown::Parser::Predicates do
       end
     end
 
+    context "with ? in name" do
+      let(:source) { "function_name?()" }
+
+      it { should parse(source).as(function_predicate: { name: "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)" }
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: smartdown
 version: !ruby/object:Gem::Version
-  version: 0.7.1
+  version: 0.8.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: &17430720 !ruby/object:Gem::Requirement
+  requirement: &20602040 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -21,10 +21,10 @@ dependencies:
         version: 1.6.1
   type: :runtime
   prerelease: false
-  version_requirements: *17430720
+  version_requirements: *20602040
 - !ruby/object:Gem::Dependency
   name: rspec
-  requirement: &17430000 !ruby/object:Gem::Requirement
+  requirement: &20601400 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -32,10 +32,10 @@ dependencies:
         version: 3.0.0
   type: :development
   prerelease: false
-  version_requirements: *17430000
+  version_requirements: *20601400
 - !ruby/object:Gem::Dependency
   name: rake
-  requirement: &17429460 !ruby/object:Gem::Requirement
+  requirement: &20600760 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -43,10 +43,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *17429460
+  version_requirements: *20600760
 - !ruby/object:Gem::Dependency
   name: gem_publisher
-  requirement: &17428800 !ruby/object:Gem::Requirement
+  requirement: &20600200 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -54,7 +54,7 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *17428800
+  version_requirements: *20600200
 description: 
 email: david.heath@digital.cabinet-office.gov.uk
 executables:
@@ -213,6 +213,7 @@ files:
 - spec/support_specs/model_builder_spec.rb
 - spec/engine_spec.rb
 - spec/model/node_spec.rb
+- spec/model/front_matter_spec.rb
 - spec/model/flow_spec.rb
 - spec/model/answer/money_spec.rb
 - spec/model/answer/multiple_choice_spec.rb
@@ -241,7 +242,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: 3609502559032787740
+      hash: -4304436723939506743
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
@@ -250,7 +251,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: 3609502559032787740
+      hash: -4304436723939506743
 requirements: []
 rubyforge_project: 
 rubygems_version: 1.8.11
@@ -327,6 +328,7 @@ test_files:
 - spec/support_specs/model_builder_spec.rb
 - spec/engine_spec.rb
 - spec/model/node_spec.rb
+- spec/model/front_matter_spec.rb
 - spec/model/flow_spec.rb
 - spec/model/answer/money_spec.rb
 - spec/model/answer/multiple_choice_spec.rb