smartdown 0.0.3 → 0.0.4

data/README.md

@@ -49,36 +49,52 @@ flow:
 
 Each file has three parts: front-matter, a model definition, rules/logic. Only the model definition is required.
 
-* **front-matter** defines metadata in the form `property: value`
-* the **model definition** is a markdown-like block which defines a flow, question or outcome.
-* **rules/logic** defines 'next node' transition rules or other logic/predicate definitions
+* **front-matter** defines metadata in the form `property: value`. Note: this
+  does not support full YAML syntax.
+* the **model definition* is a markdown-like block which defines a flow,
+  question or outcome.
+* **rules/logic** defines 'next node' transition rules or other
+  logic/predicate definitions
 
 ## Cover sheet node
 
-The cover sheet starts the flow off, its filename should match the flow name, e.g. 'check-uk-visa.txt'.
+The cover sheet starts the flow off, its filename should match the flow name,
+e.g. 'check-uk-visa.txt'.
 
-It has initial 'front matter' which defines metadata for the flow, including
-the first question. It then defines the copy for the cover sheet in markdown
-format. The h1 title is compulsory and used as the title for the smart answer.
+It has initial 'front matter' which defines metadata for the flow. It then
+defines the copy for the cover sheet in markdown format. The h1 title is
+compulsory and used as the title for the smart answer.
+
+A start button determines which question node is presented first.
 
 ```
 meta_description: You may need a visa to come to the UK to visit, study or work.
 satisfies_need: 100982
-start_with: what_passport_do_you_have
 
 # Check if you need a UK visa
 
 You may need a visa to come to the UK to visit, study or work.
+
+[start_button: what_passport_do_you_have]
 ```
 
 ## Question nodes
 
-A question model definition has optional front matter, followed by a title and
-question type.
+Question nodes follow the same standard structure outlined above.
+
+Smartdown currently allows multiple questions to be defined per node, but this
+feature is in development and the behaviour may change.
 
-The next sections define the various question types
+The next sections define the various question types available.
 
-### Radio buttons
+Note that at present only the 'choice' question type has been implemented.
+Unimplemented question types are marked with **(tbd)** in the heading. For
+these question types, consider this documentation to be a proposal of how they
+might work.
+
+### "Choice" questions (aka. radio buttons)
+
+A choice question allows the user to select a single option from a list of choices.
 
 ```markdown
 ## Will you pass through UK Border Control?
@@ -106,7 +122,7 @@ Use front matter to exclude/include countries
 
 ```markdown
 ---
-passport_country: 
+passport_country:
   exclude_countries: country1, country2
   include_countries: {country3: "Country 3", country4: "Country 4"}
 ---
@@ -160,6 +176,17 @@ Asks for salary which can be expressed as either a weekly or monthly money amoun
 * [ ] no: No
 ```
 
+## Next steps
+
+Markdown to be displayed as part of an outcome to direct the users to other information of potential interest to them.
+
+```markdown
+[next_steps]
+* Any kind of markdown
+[A link](https://gov.uk/somewhere)
+[end_next_steps]
+```
+
 ## Next node rules
 
 Logical rules for transitioning to the next node are defined in 'Next node' section. This is declared using a markdown h1 'Next node'.
@@ -177,32 +204,90 @@ defines a conditional transition
 ```
 # Next node
 
-* predicate1
-  * predicate2 => outcome1
-  * predicate3 => outcome2
+* reddish?
+  * yellowish? => orange
+  * blueish? => purple
 ```
 
 defines nested rules.
 
+In the example above the node `orange` would be selected if both `reddish?` and `yellowish?` were true.
+
 ## Predicates
 
+As well as 'named' predicates which might be defined by a plugin or other
+mechanism, there's also a basic expression language for predicates.
+
+The currently supported operations are:
+
 ```
 variable_name is 'string'
 variable_name in {this that the-other}
 ```
 
-### Date comparison predicates
+### Date comparison predicates (tbd)
 
 ```
 date_variable_name >= '14/07/2014'
 date_variable_name < '14/07/2014'
 ```
 
-## Conditional blocks in outcomes (tbd)
-
 ## Processing model
 
-Each response to a question is assigned to a variable which corresponds to the question name (as determined by the filename).
+Each response to a question is assigned to a variable which corresponds to the
+question name (as determined by the filename).
+
+## Conditional blocks in outcomes
+
+The syntax is:
+
+```markdown
+
+$IF pred?
+
+Text if true
+
+more text if you like
+
+$ENDIF
+```
+
+You can also have an else clause:
+
+```markdown
+
+$IF pred?
+
+Text if true
+
+$ELSE
+
+Text if false
+
+$ENDIF
+```
+
+It's required to have a blank line between each if statement and the next paragraph of text, in other words this would be **invalid**:
+
+```markdown
+
+$IF pred?
+Text if true
+$ENDIF
+```
+
+## Interpolation
+
+It's possible to interpolate values from calculations, responses to questions, plugins etc.
+
+Interpolations are currently supported into headings and paragraphs using the following syntax:
+
+```markdown
+
+# State pension age calculation for %{name}
+
+Your state pension age is %{state_pension_age}.
+```
 
 ## Named predicates (tbd)
 

data/lib/smartdown/engine/conditional_resolver.rb

@@ -0,0 +1,38 @@
+require 'smartdown/engine/predicate_evaluator'
+
+module Smartdown
+  class Engine
+    class ConditionalResolver
+      def initialize(predicate_evaluator = nil)
+        @predicate_evaluator = predicate_evaluator || PredicateEvaluator.new
+      end
+
+      def call(node, state)
+        node.dup.tap do |new_node|
+          new_node.elements = resolve_conditionals(node.elements, state)
+        end
+      end
+
+    private
+      attr_accessor :predicate_evaluator
+
+      def evaluate(conditional, state)
+        if predicate_evaluator.evaluate(conditional.predicate, state)
+          conditional.true_case
+        else
+          conditional.false_case
+        end
+      end
+
+      def resolve_conditionals(elements, state)
+        elements.map do |element|
+          if element.is_a?(Smartdown::Model::Element::Conditional)
+            evaluate(element, state)
+          else
+            element
+          end
+        end.flatten
+      end
+    end
+  end
+end

data/lib/smartdown/engine/interpolator.rb

@@ -0,0 +1,55 @@
+module Smartdown
+  class Engine
+    class Interpolator
+      def call(node, state)
+        node.dup.tap do |new_node|
+          new_node.elements = interpolate_elements(node.elements, state)
+        end
+      end
+
+    private
+      def interpolator_for(element)
+        INTERPOLATOR_CONFIG.fetch(element.class, DEFAULT_INTERPOLATOR).new(element)
+      end
+
+      def interpolate_elements(elements, state)
+        elements.map do |element|
+          interpolator_for(element).call(state)
+        end
+      end
+
+      class NullElementInterpolator
+        attr_reader :element
+
+        def initialize(element)
+          @element = element
+        end
+
+        def call(state)
+          element
+        end
+      end
+
+      class ElementContentInterpolator < NullElementInterpolator
+        def call(state)
+          element.dup.tap do |e|
+            e.content = interpolate(e.content, state)
+          end
+        end
+
+      private
+        def interpolate(text, state)
+          text.to_s.gsub(/%{([^}]+)}/) { |_| state.get($1) }
+        end
+      end
+
+      INTERPOLATOR_CONFIG = {
+        Smartdown::Model::Element::MarkdownParagraph => ElementContentInterpolator,
+        Smartdown::Model::Element::MarkdownHeading => ElementContentInterpolator
+      }
+
+      DEFAULT_INTERPOLATOR = NullElementInterpolator
+
+    end
+  end
+end

data/lib/smartdown/engine/node_presenter.rb

@@ -1,38 +1,19 @@
-require 'smartdown/engine/predicate_evaluator'
+require 'smartdown/engine/conditional_resolver'
+require 'smartdown/engine/interpolator'
 
 module Smartdown
   class Engine
     class NodePresenter
-      def initialize(predicate_evaluator = nil)
-        @predicate_evaluator = predicate_evaluator || PredicateEvaluator.new
-      end
+      PRESENTERS = [
+        Smartdown::Engine::ConditionalResolver.new,
+        Smartdown::Engine::Interpolator.new
+      ]
 
-      def present(node, state)
-        node.dup.tap do |new_node|
-          new_node.elements = resolve_conditionals(node.elements, state)
+      def present(unpresented_node, state)
+        PRESENTERS.inject(unpresented_node) do |node, presenter_class|
+          presenter_class.call(node, state)
         end
       end
-
-    private
-      attr_accessor :predicate_evaluator
-
-      def evaluate(conditional, state)
-        if predicate_evaluator.evaluate(conditional.predicate, state)
-          conditional.true_case
-        else
-          conditional.false_case
-        end
-      end
-
-      def resolve_conditionals(elements, state)
-        elements.map do |element|
-          if element.is_a?(Smartdown::Model::Element::Conditional)
-            evaluate(element, state)
-          else
-            element
-          end
-        end.flatten
-      end
     end
   end
 end

data/lib/smartdown/engine/state.rb

@@ -51,7 +51,7 @@ module Smartdown
         if has_key?(key)
           @data.fetch(key.to_s)
         else
-          raise UndefinedValue
+          raise UndefinedValue, "variable '#{key}' not defined", caller
         end
       end
 

data/lib/smartdown/engine/transition.rb

@@ -14,23 +14,45 @@ module Smartdown
       end
 
       def next_node
-        first_matching_rule(next_node_rules.rules).outcome
+        next_node_from_next_node_rules ||
+          next_node_from_start_button ||
+          raise(Smartdown::Engine::IndeterminateNextNode, "No next node rules defined for '#{node.name}'", caller)
       end
 
       def next_state
         state_with_input
           .put(:path, state.get(:path) + [node.name])
           .put(:responses, state.get(:responses) + [input])
-          .put(node.name, input)
+          .put(input_variable_name, input)
           .put(:current_node, next_node)
       end
 
     private
       attr_reader :predicate_evaluator
 
+      def next_node_from_next_node_rules
+        next_node_rules && first_matching_rule(next_node_rules.rules).outcome
+      end
+
+      def next_node_from_start_button
+        start_button && start_button.start_node
+      end
+
+      def input_variable_name
+        input_variable_name_from_question || node.name
+      end
+
+      def input_variable_name_from_question
+        question = node.elements.find { |e| e.is_a?(Smartdown::Model::Element::MultipleChoice) }
+        question && question.name
+      end
+
       def next_node_rules
-        node.elements.find { |e| e.is_a?(Smartdown::Model::NextNodeRules) } or \
-          raise Smartdown::Engine::IndeterminateNextNode, "No next node rules defined for '#{node.name}'"
+        node.elements.find { |e| e.is_a?(Smartdown::Model::NextNodeRules) }
+      end
+
+      def start_button
+        node.elements.find { |e| e.is_a?(Smartdown::Model::Element::StartButton) }
       end
 
       def first_matching_rule(rules)

data/lib/smartdown/model/element/next_steps.rb

@@ -0,0 +1,7 @@
+module Smartdown
+  module Model
+    module Element
+      NextSteps = Struct.new(:content)
+    end
+  end
+end

data/lib/smartdown/parser/element/next_steps.rb

@@ -0,0 +1,33 @@
+require 'smartdown/parser/base'
+
+module Smartdown
+  module Parser
+    module Element
+      class NextSteps < Base
+
+        rule(:markdown) { (str("[end_next_steps]").absnt? >> any).repeat.as(:content) }
+
+        rule(:next_steps_tag) {
+          str("[next_steps]") >>
+          optional_space >>
+          line_ending
+        }
+
+        rule(:next_steps_end_tag) {
+          str("[end_next_steps]") >>
+          optional_space >>
+          line_ending
+        }
+
+        rule(:next_steps) {
+          (
+            next_steps_tag >>
+            markdown >>
+            next_steps_end_tag
+          ).as(:next_steps)
+        }
+        root(:next_steps)
+      end
+    end
+  end
+end

data/lib/smartdown/parser/node_parser.rb

@@ -6,17 +6,19 @@ require 'smartdown/parser/element/multiple_choice_question'
 require 'smartdown/parser/element/markdown_heading'
 require 'smartdown/parser/element/markdown_paragraph'
 require 'smartdown/parser/element/conditional'
+require 'smartdown/parser/element/next_steps'
 
 module Smartdown
   module Parser
     class NodeParser < Base
       rule(:markdown_block) {
         Element::Conditional.new |
-          Element::MarkdownHeading.new |
-          Element::MultipleChoiceQuestion.new |
-          Rules.new |
-          Element::StartButton.new |
-          Element::MarkdownParagraph.new
+        Element::MarkdownHeading.new |
+        Element::MultipleChoiceQuestion.new |
+        Rules.new |
+        Element::StartButton.new |
+        Element::NextSteps.new |
+        Element::MarkdownParagraph.new
       }
 
       rule(:markdown_blocks) {
@@ -29,8 +31,8 @@ module Smartdown
 
       rule(:flow) {
         Element::FrontMatter.new >> newline.repeat(1) >> body |
-          Element::FrontMatter.new |
-          ws >> body
+        Element::FrontMatter.new |
+        ws >> body
       }
 
       root(:flow)

data/lib/smartdown/parser/node_transform.rb

@@ -9,6 +9,7 @@ require 'smartdown/model/element/start_button'
 require 'smartdown/model/element/markdown_heading'
 require 'smartdown/model/element/markdown_paragraph'
 require 'smartdown/model/element/conditional'
+require 'smartdown/model/element/next_steps'
 require 'smartdown/model/predicate/equality'
 require 'smartdown/model/predicate/set_membership'
 require 'smartdown/model/predicate/named'
@@ -50,12 +51,20 @@ module Smartdown
         [value.to_s, label.to_s]
       }
 
+      rule(:url => simple(:url), :label => simple(:label)) {
+        [url.to_s, label.to_s]
+      }
+
       rule(:multiple_choice => {identifier: simple(:identifier), options: subtree(:choices)}) {
         Smartdown::Model::Element::MultipleChoice.new(
           identifier, Hash[choices]
         )
       }
 
+      rule(:next_steps => { content: simple(:content) }) {
+        Smartdown::Model::Element::NextSteps.new(content.to_s)
+      }
+
       # Conditional with no content in true-case
       rule(:conditional => {:predicate => subtree(:predicate)}) {
         Smartdown::Model::Element::Conditional.new(predicate)

data/lib/smartdown/version.rb

@@ -1,3 +1,3 @@
 module Smartdown
-  VERSION = "0.0.3"
+  VERSION = "0.0.4"
 end

data/spec/engine/{node_presenter_spec.rb → conditional_resolver_spec.rb}

@@ -1,8 +1,8 @@
-require 'smartdown/engine/node_presenter'
+require 'smartdown/engine/conditional_resolver'
 require 'smartdown/engine/state'
 
-describe Smartdown::Engine::NodePresenter do
-  subject(:node_presenter) { described_class.new }
+describe Smartdown::Engine::ConditionalResolver do
+  subject(:conditional_resolver) { described_class.new }
 
   context "a node with a conditional" do
     let(:node) {
@@ -34,7 +34,7 @@ describe Smartdown::Engine::NodePresenter do
       }
 
       it "should resolve the conditional and preserve the 'True case' paragraph block" do
-        expect(node_presenter.present(node, state)).to eq(expected_node_after_presentation)
+        expect(conditional_resolver.call(node, state)).to eq(expected_node_after_presentation)
       end
     end
 
@@ -53,7 +53,7 @@ describe Smartdown::Engine::NodePresenter do
       }
 
       it "should resolve the conditional and preserve the 'False case' paragraph block" do
-        expect(node_presenter.present(node, state)).to eq(expected_node_after_presentation)
+        expect(conditional_resolver.call(node, state)).to eq(expected_node_after_presentation)
       end
     end
   end

data/spec/engine/interpolator_spec.rb

@@ -0,0 +1,81 @@
+require 'smartdown/engine/interpolator'
+require 'smartdown/engine/state'
+require 'parslet'
+
+describe Smartdown::Engine::Interpolator do
+  subject(:interpolator) { described_class.new }
+
+  let(:example_name) { "Neil" }
+
+  let(:state) {
+    Smartdown::Engine::State.new(
+      current_node: node.name,
+      name: example_name
+    )
+  }
+
+  let(:interpolated_node) { interpolator.call(node, state) }
+
+  let(:node) {
+    Smartdown::Model::Node.new("example", elements)
+  }
+
+  context "a node with no elements" do
+    let(:elements) { [] }
+
+    it "returns the node unchanged" do
+      expect(interpolator.call(node, state)).to eq(node)
+    end
+  end
+
+  context "a node with elements with no interpolations" do
+    let(:node) {
+      model_builder.node("example") do
+        heading("a heading")
+        paragraph("some_stuff")
+        conditional do
+          named_predicate "pred?"
+          true_case do
+            paragraph("True case")
+          end
+          false_case do
+            paragraph("False case")
+          end
+        end
+        multiple_choice({})
+        next_node_rules
+      end
+    }
+
+    it "returns the node unchanged" do
+      expect(interpolated_node).to eq(node)
+    end
+  end
+
+  context "a node with a paragraph containing an interpolation" do
+    let(:elements) { [Smartdown::Model::Element::MarkdownParagraph.new('Hello %{name}')] }
+
+    it "interpolates the name into the paragraph content" do
+      expect(interpolated_node.elements.first.content).to eq("Hello #{example_name}")
+    end
+  end
+
+  context "a node with a heading containing an interpolation" do
+    let(:elements) { [Smartdown::Model::Element::MarkdownHeading.new('Hello %{name}')] }
+
+    it "interpolates the name into the paragraph content" do
+      expect(interpolated_node.elements.first.content).to eq("Hello #{example_name}")
+    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
+end

data/spec/engine/transition_spec.rb

@@ -8,7 +8,7 @@ describe Smartdown::Engine::Transition do
   let(:start_state) { Smartdown::Engine::State.new(current_node: current_node_name) }
   let(:input) { "yes" }
   subject(:transition) { described_class.new(start_state, current_node, input, predicate_evaluator: predicate_evaluator) }
-  let(:predicate_evaluator) { instance_double("Smartdown::Engine::PredicateEvaluator") }
+  let(:predicate_evaluator) { instance_double("Smartdown::Engine::PredicateEvaluator", evaluate: true) }
   let(:state_including_input) {
     start_state.put(current_node.name, input)
   }
@@ -25,6 +25,20 @@ describe Smartdown::Engine::Transition do
     end
   end
 
+  context "no next node rules, but start button" do
+    let(:current_node) {
+      Smartdown::Model::Node.new(current_node_name, [
+        Smartdown::Model::Element::StartButton.new("first_question")
+      ])
+    }
+
+    describe "#next_node" do
+      it "take the next node from the start button" do
+        expect(transition.next_node).to eq("first_question")
+      end
+    end
+  end
+
   context "next node rules defined with a simple rule" do
     let(:predicate1) { double("predicate1") }
     let(:outcome_name1) { "o1" }
@@ -72,10 +86,6 @@ describe Smartdown::Engine::Transition do
     end
 
     describe "#next_state" do
-      before(:each) do
-        allow(predicate_evaluator).to receive(:evaluate).and_return(true)
-      end
-
       it "returns a state including a record of responses, path, and new current_node" do
         expected_state = start_state
           .put(:responses, [input])
@@ -147,4 +157,27 @@ describe Smartdown::Engine::Transition do
     end
   end
 
+  context "next node rules and a named question" do
+    let(:question_name) { "my_question" }
+
+    let(:current_node) {
+      Smartdown::Model::Node.new(
+        current_node_name,
+        [
+          Smartdown::Model::Element::MultipleChoice.new(question_name, {"a" => "Apple"}),
+          Smartdown::Model::NextNodeRules.new(
+            [Smartdown::Model::Rule.new(double("predicate1"), "o1")]
+          )
+        ]
+      )
+    }
+
+    describe "#next_state" do
+      it "assigns the input value to a variable matching the question name" do
+        expect(transition.next_state.get(question_name)).to eq(input)
+      end
+    end
+
+  end
+
 end

data/spec/engine_spec.rb

@@ -7,12 +7,6 @@ describe Smartdown::Engine do
         heading("Check uk visa")
         paragraph("This is the paragraph")
         start_button("what_passport_do_you_have?")
-        next_node_rules do
-          rule do
-            named_predicate("otherwise")
-            outcome("what_passport_do_you_have?")
-          end
-        end
       end
 
       node("what_passport_do_you_have?") do
@@ -41,6 +35,10 @@ describe Smartdown::Engine do
           end
         end
       end
+
+      node("outcome_with_interpolation") do
+        paragraph("The answer is %{interpolated_variable}")
+      end
     end
   }
 
@@ -92,20 +90,40 @@ describe Smartdown::Engine do
   end
 
   describe "#evaluate_node" do
-    let(:current_state) {
-      start_state
-        .put(:current_node, "outcome_no_visa_needed")
-        .put(:pred?, true)
-    }
-
-    let(:expected_node_after_conditional_resolution) {
-      model_builder.node("outcome_no_visa_needed") do
-        paragraph("True case")
+    context "conditional resolution" do
+      let(:current_state) {
+        start_state
+          .put(:current_node, "outcome_no_visa_needed")
+          .put(:pred?, true)
+      }
+
+      let(:expected_node_after_conditional_resolution) {
+        model_builder.node("outcome_no_visa_needed") do
+          paragraph("True case")
+        end
+      }
+
+      it "evaluates the current node of the given state, resolving any conditionals" do
+        expect(engine.evaluate_node(current_state)).to eq(expected_node_after_conditional_resolution)
       end
-    }
+    end
+
+    context "interpolation" do
+      let(:current_state) {
+        start_state
+          .put(:current_node, "outcome_with_interpolation")
+          .put(:interpolated_variable, "42")
+      }
 
-    it "evaluates the current node of the given state, resolving any conditionals" do
-      expect(engine.evaluate_node(current_state)).to eq(expected_node_after_conditional_resolution)
+      let(:expected_node_after_conditional_resolution) {
+        model_builder.node("outcome_with_interpolation") do
+          paragraph("The answer is 42")
+        end
+      }
+
+      it "evaluates the current node of the given state, resolving any conditionals" do
+        expect(engine.evaluate_node(current_state)).to eq(expected_node_after_conditional_resolution)
+      end
     end
   end
 

data/spec/parser/element/next_steps_spec.rb

@@ -0,0 +1,33 @@
+require 'smartdown/parser/element/next_steps'
+require 'smartdown/parser/node_parser'
+require 'smartdown/parser/node_interpreter'
+
+describe Smartdown::Parser::Element::NextSteps do
+  subject(:parser) { described_class.new }
+
+  let(:source) {
+    [
+      "[next_steps]",
+      "some markdown",
+      "some more markdown",
+      "[end_next_steps]"
+    ].join("\n")
+  }
+
+  it "parses" do
+    should parse(source).as(
+      next_steps: {
+        content: "some markdown\nsome more markdown\n"
+      }
+    )
+  end
+
+  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::Element::NextSteps.new("some markdown\nsome more markdown\n")) }
+  end
+end

data/spec/support/model_builder.rb

@@ -52,6 +52,13 @@ class ModelBuilder
     @elements.last
   end
 
+  def next_steps(urls)
+    @elements ||= []
+    urls_with_string_keys = ::Hash[urls.map {|k,v| [k.to_s, v]}]
+    @elements << Smartdown::Model::Element::NextSteps.new(urls_with_string_keys)
+    @elements.last
+  end
+
   def next_node_rules(&block)
     @rules = []
     instance_eval(&block) if block_given?

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: smartdown
 version: !ruby/object:Gem::Version
-  version: 0.0.3
+  version: 0.0.4
   prerelease: 
 platform: ruby
 authors:
@@ -96,12 +96,15 @@ files:
 - lib/smartdown/parser/element/start_button.rb
 - lib/smartdown/parser/element/front_matter.rb
 - lib/smartdown/parser/element/multiple_choice_question.rb
+- lib/smartdown/parser/element/next_steps.rb
 - lib/smartdown/parser/element/markdown_heading.rb
 - lib/smartdown/parser/flow_interpreter.rb
 - lib/smartdown/version.rb
 - lib/smartdown/engine/node_presenter.rb
 - lib/smartdown/engine/state.rb
+- 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
@@ -113,6 +116,7 @@ files:
 - lib/smartdown/model/element/conditional.rb
 - lib/smartdown/model/element/markdown_paragraph.rb
 - lib/smartdown/model/element/start_button.rb
+- lib/smartdown/model/element/next_steps.rb
 - lib/smartdown/model/element/markdown_heading.rb
 - lib/smartdown/model/element/multiple_choice.rb
 - lib/smartdown/model/next_node_rules.rb
@@ -128,6 +132,7 @@ files:
 - spec/parser/base_spec.rb
 - spec/parser/rules_spec.rb
 - spec/parser/predicates_spec.rb
+- spec/parser/element/next_steps_spec.rb
 - spec/parser/element/multiple_choice_question_spec.rb
 - spec/parser/element/conditional_spec.rb
 - spec/parser/element/start_button_parser_spec.rb
@@ -138,9 +143,10 @@ files:
 - spec/support/model_builder.rb
 - spec/spec_helper.rb
 - spec/engine/state_spec.rb
-- spec/engine/node_presenter_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
 - spec/fixtures/directory_input/outcomes/o1.txt
 - spec/fixtures/directory_input/questions/q1.txt
@@ -171,7 +177,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: 1408391630094207002
+      hash: 3856298649637769047
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
@@ -180,7 +186,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: 1408391630094207002
+      hash: 3856298649637769047
 requirements: []
 rubyforge_project: 
 rubygems_version: 1.8.23
@@ -195,6 +201,7 @@ test_files:
 - spec/parser/base_spec.rb
 - spec/parser/rules_spec.rb
 - spec/parser/predicates_spec.rb
+- spec/parser/element/next_steps_spec.rb
 - spec/parser/element/multiple_choice_question_spec.rb
 - spec/parser/element/conditional_spec.rb
 - spec/parser/element/start_button_parser_spec.rb
@@ -205,9 +212,10 @@ test_files:
 - spec/support/model_builder.rb
 - spec/spec_helper.rb
 - spec/engine/state_spec.rb
-- spec/engine/node_presenter_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
 - spec/fixtures/directory_input/outcomes/o1.txt
 - spec/fixtures/directory_input/questions/q1.txt