smartdown 0.0.1

data/spec/engine/state_spec.rb

@@ -0,0 +1,106 @@
+require 'smartdown/engine/state'
+
+describe Smartdown::Engine::State do
+  subject {
+    described_class.new(current_node: :start_state)
+  }
+
+  it "raises if current_node not given to constructor" do
+    expect { described_class.new() }.to raise_error(ArgumentError)
+  end
+
+  it "initializes path and responses" do
+    expect(subject.get(:responses)).to eq []
+    expect(subject.get(:path)).to eq []
+  end
+
+  describe "#get" do
+    it "raises if a value is undefined" do
+      expect { subject.get(:a) }.to raise_error(Smartdown::Engine::UndefinedValue)
+    end
+
+    it "by string or symbol" do
+      expect(subject.get(:current_node)).to eq(:start_state)
+      expect(subject.get("current_node")).to eq(:start_state)
+    end
+  end
+
+  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"]))
+    end
+  end
+
+  describe "#put" do
+    it "returns a copy of state and leaves orignal unchanged" do
+      new_state = subject.put(:a, 1)
+      expect { subject.get(:a) }.to raise_error
+      expect(new_state.get(:a)).to eq 1
+    end
+
+    it "by string or symbol" do
+      s2 = subject.put(:b, 1)
+      expect(s2.get(:b)).to eq(1)
+      expect(s2.get("b")).to eq(1)
+      s3 = subject.put("b", 2)
+      expect(s3.get(:b)).to eq(2)
+      expect(s3.get("b")).to eq(2)
+    end
+  end
+
+  context "lambda values" do
+    let(:predicate) { double("predicate", call: true) }
+    subject(:state) {
+      described_class.new(current_node: :start_state, predicate?: predicate)
+    }
+
+    describe "#get" do
+      it "evaluates lambda with state" do
+        expect(predicate).to receive(:call).with(state).and_return(true)
+        expect(state.get(:predicate?)).to eq(true)
+      end
+
+      it "caches the result of evaluating the lambda" do
+        expect(predicate).to receive(:call).once
+        state.get(:predicate?)
+        state.get(:predicate?)
+      end
+    end
+
+    describe "#==" do
+      let(:l1) { ->(state) { true } }
+      let(:l2) { ->(state) { true } }
+
+      let(:state_with_l1a) { described_class.new(current_node: "red", pred: l1)}
+      let(:state_with_l1b) { described_class.new(current_node: "red", pred: l1)}
+      let(:state_with_l2) { described_class.new(current_node: "red", pred: l2)}
+
+      it "is equal if identical lambdas" do
+        expect(state_with_l1a).to eq(state_with_l1b)
+      end
+
+      it "is not equal if different lambdas" do
+        expect(state_with_l1a).not_to eq(state_with_l2)
+      end
+    end
+  end
+
+  describe "#==" do
+    let(:s1) { described_class.new(current_node: "red") }
+    let(:s2) { described_class.new(current_node: "red") }
+    let(:s3) { described_class.new(current_node: "green") }
+    let(:s4) { described_class.new(current_node: "red", a: 1) }
+
+    it "is true if two states have the same keys and values" do
+      expect(s1).to eq(s2)
+    end
+
+    it "is false if two states have the same keys with different values" do
+      expect(s1).not_to eq(s3)
+    end
+
+    it "is false if one state is a subset of the other" do
+      expect(s1).not_to eq(s4)
+    end
+  end
+end

data/spec/engine/transition_spec.rb

@@ -0,0 +1,150 @@
+require 'smartdown/engine/transition'
+require 'smartdown/engine/state'
+require 'smartdown/model/rule'
+require 'smartdown/model/nested_rule'
+
+describe Smartdown::Engine::Transition do
+  let(:current_node_name) { "q1" }
+  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(:state_including_input) {
+    start_state.put(current_node.name, input)
+  }
+
+  context "no next node rules" do
+    let(:current_node) {
+      Smartdown::Model::Node.new(current_node_name, [])
+    }
+
+    describe "#next_node" do
+      it "raises IndeterminateNextNode" do
+        expect { transition.next_node }.to raise_error(Smartdown::Engine::IndeterminateNextNode)
+      end
+    end
+  end
+
+  context "next node rules defined with a simple rule" do
+    let(:predicate1) { double("predicate1") }
+    let(:outcome_name1) { "o1" }
+    let(:predicate2) { double("predicate2") }
+    let(:outcome_name2) { "o2" }
+
+    let(:current_node) {
+      Smartdown::Model::Node.new(
+        current_node_name,
+        [
+          Smartdown::Model::NextNodeRules.new(
+            [
+              Smartdown::Model::Rule.new(
+                predicate1, outcome_name1
+              ),
+              Smartdown::Model::Rule.new(
+                predicate2, outcome_name2
+              )
+            ]
+          )
+        ]
+      )
+    }
+
+    describe "#next_node" do
+      it "invokes the predicate evaluator with the predicate and state including the input value" do
+        expect(predicate_evaluator).to receive(:evaluate).with(predicate1, state_including_input).and_return(true)
+
+        transition.next_node
+      end
+
+      it "invokes the predicate evaluator for each rule in turn" do
+        allow(predicate_evaluator).to receive(:evaluate).with(predicate1, state_including_input).and_return(false)
+        expect(predicate_evaluator).to receive(:evaluate).with(predicate2, state_including_input).and_return(true)
+
+        transition.next_node
+      end
+
+      it "returns the name of the next node" do
+        allow(predicate_evaluator).to receive(:evaluate).with(predicate1, state_including_input).and_return(false)
+        allow(predicate_evaluator).to receive(:evaluate).with(predicate2, state_including_input).and_return(true)
+
+        expect(transition.next_node).to eq(outcome_name2)
+      end
+    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])
+          .put(:path, [current_node_name])
+          .put(:current_node, outcome_name1)
+          .put(current_node.name, input)
+
+        expect(transition.next_state).to eq(expected_state)
+      end
+    end
+  end
+
+  context "next node rules defined with nested rule" do
+    let(:predicate1) { double("predicate1") }
+    let(:predicate2) { double("predicate2") }
+    let(:predicate3) { double("predicate3") }
+    let(:outcome_name1) { "o1" }
+    let(:outcome_name2) { "o2" }
+
+    let(:current_node) {
+      Smartdown::Model::Node.new(
+        current_node_name,
+        [
+          Smartdown::Model::NextNodeRules.new(
+            [
+              Smartdown::Model::NestedRule.new(
+                predicate1, [
+                  Smartdown::Model::Rule.new(
+                    predicate2, outcome_name1
+                  ),
+                  Smartdown::Model::Rule.new(
+                    predicate3, outcome_name2
+                  )
+                ]
+              )
+            ]
+          )
+        ]
+      )
+    }
+
+    describe "#next_node" do
+      context "p1 false" do
+        it "invokes the predicate evaluator with each predicate in turn" do
+          expect(predicate_evaluator).to receive(:evaluate).with(predicate1, state_including_input).and_return(false)
+
+          expect { transition.next_node }.to raise_error(Smartdown::Engine::IndeterminateNextNode)
+        end
+      end
+
+      context "p1 and p2 true" do
+        it "invokes the predicate evaluator with each predicate in turn" do
+          allow(predicate_evaluator).to receive(:evaluate).with(predicate1, state_including_input).and_return(true)
+          expect(predicate_evaluator).to receive(:evaluate).with(predicate2, state_including_input).and_return(true)
+
+          expect(transition.next_node).to eq(outcome_name1)
+        end
+      end
+
+      context "p1 true, p2 false, p3 true" do
+        it "invokes the predicate evaluator with each predicate in turn" do
+          allow(predicate_evaluator).to receive(:evaluate).with(predicate1, state_including_input).and_return(true)
+          allow(predicate_evaluator).to receive(:evaluate).with(predicate2, state_including_input).and_return(false)
+          expect(predicate_evaluator).to receive(:evaluate).with(predicate3, state_including_input).and_return(true)
+
+          expect(transition.next_node).to eq(outcome_name2)
+        end
+      end
+    end
+  end
+
+end

data/spec/engine_spec.rb

@@ -0,0 +1,79 @@
+require 'smartdown/engine'
+
+describe Smartdown::Engine do
+  let(:flow) {
+    build_flow("check-uk-visa") do
+      node("check-uk-visa") 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
+        heading("What passport do you have?")
+        multiple_choice(
+          greek: "Greek",
+          british: "British",
+          usa: "USA"
+        )
+        next_node_rules do
+          rule do
+            named_predicate("eea_passport?")
+            outcome("outcome_no_visa_needed")
+          end
+        end
+      end
+    end
+  }
+
+  subject(:engine) { Smartdown::Engine.new(flow) }
+  let(:start_state) {
+    engine.default_start_state
+      .put(:eea_passport?, ->(state) {
+        %w{greek british}.include?(state.get(:what_passport_do_you_have?))
+      })
+      .put(:otherwise, true)
+  }
+
+  describe "#process" do
+    subject { engine.process(responses, start_state) }
+
+    context "start button response only" do
+      let(:responses) { %w{yes} }
+
+      it "is on what_passport_do_you_have?" do
+        expect(subject.get(:current_node)).to eq("what_passport_do_you_have?")
+      end
+
+      it "has recorded input" do
+        expect(subject.get("check-uk-visa")).to eq("yes")
+      end
+    end
+
+    context "greek passport" do
+      let(:responses) { %w{yes greek} }
+
+      it "is on what_passport_do_you_have?" do
+        expect(subject.get(:current_node)).to eq("outcome_no_visa_needed")
+      end
+
+      it "has recorded input" do
+        expect(subject.get("what_passport_do_you_have?")).to eq("greek")
+      end
+    end
+
+    context "USA passport" do
+      let(:responses) { %w{yes usa} }
+
+      it "raises IndeterminateNextNode error" do
+        expect { subject }.to raise_error(Smartdown::Engine::IndeterminateNextNode)
+      end
+    end
+  end
+end

data/spec/fixtures/acceptance/cover-sheet/cover-sheet.txt

@@ -0,0 +1,14 @@
+satisfies_need: 1234
+meta_description: Blah blah
+
+# My coversheet
+
+This is the body markdown.
+
+It has many paragraphs
+of text.
+
+* it
+* can
+* have
+* lists

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

@@ -0,0 +1,3 @@
+# My coversheet
+
+Blah

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

@@ -0,0 +1,9 @@
+# Question one
+
+Body text line 1.
+
+Body text
+para 2.
+
+* yes: Yes
+* no: No

data/spec/fixtures/acceptance/question-and-outcome/outcomes/o1.txt

@@ -0,0 +1,3 @@
+# Outcome one
+
+body

data/spec/fixtures/acceptance/question-and-outcome/question-and-outcome.txt

@@ -0,0 +1,3 @@
+# My coversheet
+
+Blah

data/spec/fixtures/acceptance/question-and-outcome/questions/q1.txt

@@ -0,0 +1,9 @@
+# Question one
+
+Body text line 1.
+
+Body text
+para 2.
+
+* yes: Yes
+* no: No

data/spec/fixtures/directory_input/cover-sheet.txt

@@ -0,0 +1 @@
+cover sheet

data/spec/fixtures/directory_input/outcomes/o1.txt

@@ -0,0 +1 @@
+outcome one

data/spec/fixtures/directory_input/questions/q1.txt

@@ -0,0 +1 @@
+question one

data/spec/fixtures/directory_input/scenarios/s1.txt

@@ -0,0 +1 @@
+scenario one

data/spec/fixtures/example.sd

@@ -0,0 +1,17 @@
+name: border_control?
+
+# Will you pass through UK Border Control?
+
+You might pass through UK Border Control even if you don't leave the airport -
+eg your bags aren't checked through and you need to collect them before transferring
+to your outbound flight.
+
+* yes: Yes
+* no: No
+
+-----------
+
+# Next node
+
+* border_control is 'yes' => transit
+* border_control is 'no' => outcome_visa

data/spec/model/flow_spec.rb

@@ -0,0 +1,42 @@
+require 'smartdown/model/flow'
+require 'smartdown/model/node'
+
+describe Smartdown::Model::Flow do
+  let(:flow_name) { "my_name" }
+  let(:nodes) { [] }
+  subject(:flow) { Smartdown::Model::Flow.new(flow_name, nodes) }
+
+  it "has a name" do
+    expect(subject.name).to eq(flow_name)
+  end
+
+  context "no nodes" do
+    it "has no nodes" do
+      expect(flow.nodes).to eq([])
+    end
+  end
+
+  context "one node" do
+    let(:node_name) { "chocolate?" }
+    let(:node) {
+      instance_double("Smartdown::Model::Node", name: node_name)
+    }
+    let(:nodes) { [node] }
+
+    describe "#nodes" do
+      it "returns a list with the node" do
+        expect(flow.nodes).to eq([node])
+      end
+    end
+
+    describe "#node" do
+      it "fetches the named node" do
+        expect(subject.node(node_name)).to eq(node)
+      end
+
+      it "raises if node not found" do
+        expect { subject.node("undefined node") }.to raise_error
+      end
+    end
+  end
+end

data/spec/model/node_spec.rb

@@ -0,0 +1,32 @@
+require 'smartdown/model/node'
+
+describe Smartdown::Model::Node do
+  let(:name) { "my node" }
+  let(:elements) { [] }
+
+  describe "#new" do
+    subject(:node) { described_class.new(name, elements) }
+
+    it "accepts name and list of body blocks" do
+      expect(node.name).to eq(name)
+      expect(node.elements).to eq(elements)
+    end
+
+    context "no front matter" do
+      let(:empty_front_matter) { Smartdown::Model::FrontMatter.new({}) }
+
+      it "defaults to empty" do
+        expect(node.front_matter).to eq(empty_front_matter)
+      end
+    end
+
+    context "front matter" do
+      let(:front_matter) { Smartdown::Model::FrontMatter.new({a: "1"}) }
+      subject(:node) { described_class.new(name, elements, front_matter) }
+
+      it "uses it" do
+        expect(node.front_matter).to eq(front_matter)
+      end
+    end
+  end
+end

data/spec/parser/base_spec.rb

@@ -0,0 +1,49 @@
+require 'smartdown/parser/element/front_matter'
+
+describe Smartdown::Parser::Base do
+
+  subject(:parser) { described_class.new }
+
+  describe "#ws" do
+    subject { parser.ws }
+    it { should parse("\n") }
+    it { should parse(" ") }
+    it { should parse("   ") }
+  end
+
+  describe "#eof" do
+    subject { parser.eof }
+
+    it { should parse("") }
+    it { should_not parse(" ") }
+  end
+
+  describe "#newline" do
+    subject { parser.newline }
+
+    # Only one newline
+    it { should parse("\r") }
+    it { should parse("\r\n") }
+    it { should parse("\n\r") }
+    it { should parse("\n") }
+
+    # Not multiple
+    it { should_not parse("\n\n") }
+  end
+
+  describe "#whitespace_terminated_string" do
+    subject { parser.whitespace_terminated_string }
+
+    it { should parse("a b c") }
+    it { should_not parse(" a") }
+    it { should_not parse("a ") }
+  end
+
+  describe "identifier" do
+    subject { parser.identifier }
+
+    it { should parse("abcdefghijklmnopqrstuvwxyz_ABCDEFGHIJKLMNOPQRSTUVWXYZ-123") }
+    it { should_not parse("abc_ABC-123?") }
+  end
+end
+

data/spec/parser/directory_input_spec.rb

@@ -0,0 +1,56 @@
+require 'smartdown/parser/directory_input'
+
+shared_examples "flow input interface" do
+  it { should respond_to(:coversheet) }
+  it { should respond_to(:questions) }
+  it { should respond_to(:outcomes) }
+  it { should respond_to(:scenarios) }
+end
+
+describe Smartdown::Parser::DirectoryInput do
+  it_should_behave_like "flow input interface"
+
+  let(:coversheet_file) {
+    Pathname.new("../../fixtures/directory_input/cover-sheet.txt").expand_path(__FILE__)
+  }
+
+  subject(:input) { described_class.new(coversheet_file) }
+
+  describe "#coversheet" do
+    subject { input.coversheet }
+
+    it { should be_a(Smartdown::Parser::InputFile) }
+
+    it "has name" do
+      expect(input.coversheet.name).to eq("cover-sheet")
+    end
+
+    it "reads the file contents" do
+      expect(input.coversheet.read).to eq("cover sheet\n")
+    end
+  end
+
+  describe "#questions" do
+    it "returns an InputFile for every file in the questions folder" do
+      expect(input.questions).to match([instance_of(Smartdown::Parser::InputFile)])
+      expect(input.questions.first.name).to eq("q1")
+      expect(input.questions.first.read).to eq("question one\n")
+    end
+  end
+
+  describe "#outcomes" do
+    it "returns an InputFile for every file in the outcomes folder" do
+      expect(input.outcomes).to match([instance_of(Smartdown::Parser::InputFile)])
+      expect(input.outcomes.first.name).to eq("o1")
+      expect(input.outcomes.first.read).to eq("outcome one\n")
+    end
+  end
+
+  describe "#scenarios" do
+    it "returns an InputFile for every file in the scenarios folder" do
+      expect(input.scenarios).to match([instance_of(Smartdown::Parser::InputFile)])
+      expect(input.scenarios.first.name).to eq("s1")
+      expect(input.scenarios.first.read).to eq("scenario one\n")
+    end
+  end
+end

data/spec/parser/element/front_matter_spec.rb

@@ -0,0 +1,21 @@
+require 'smartdown/parser/element/front_matter'
+require 'smartdown/parser/node_interpreter'
+
+describe Smartdown::Parser::Element::FrontMatter do
+
+  subject(:parser) { described_class.new }
+
+  it { should parse("a: 1\n").as(front_matter: [{name: "a", value: "1"}]) }
+  it { should parse("a: 1\nb: 2\n").as(front_matter: [{name: "a", value: "1"}, {name: "b", value: "2"}]) }
+
+  describe "transformed" do
+    let(:node_name) { "my_node" }
+    let(:source) { "a: 1\n" }
+    subject(:transformed) {
+      Smartdown::Parser::NodeInterpreter.new(node_name, source, parser: parser).interpret
+    }
+
+    it { should eq([Smartdown::Model::FrontMatter.new("a"=>"1")]) }
+  end
+end
+

data/spec/parser/element/markdown_heading_spec.rb

@@ -0,0 +1,24 @@
+require 'smartdown/parser/element/markdown_heading'
+require 'smartdown/parser/node_interpreter'
+
+describe Smartdown::Parser::Element::MarkdownHeading do
+
+  subject(:parser) { described_class.new }
+  let(:node_name) { "my_node" }
+  let(:heading_content) { "My heading"}
+  let(:source) { "# #{heading_content}" }
+
+  it { should parse(source).as(h1: heading_content) }
+  it { should parse("# heading\n").as(h1: "heading") }
+  it { should parse("# heading   \n").as(h1: "heading") }
+  it { should parse("# heading   ").as(h1: "heading") }
+
+  describe "transformed" do
+    subject(:transformed) {
+      Smartdown::Parser::NodeInterpreter.new(node_name, source, parser: parser).interpret
+    }
+
+    it { should eq(Smartdown::Model::Element::MarkdownHeading.new(heading_content)) }
+  end
+end
+

data/spec/parser/element/markdown_paragraph_spec.rb

@@ -0,0 +1,28 @@
+require 'smartdown/parser/element/markdown_paragraph'
+require 'smartdown/parser/node_interpreter'
+
+describe Smartdown::Parser::Element::MarkdownParagraph do
+
+  subject(:parser) { described_class.new }
+  let(:node_name) { "my_node" }
+
+  it { should parse("My para").as(p: "My para") }
+  it { should parse("My para\n").as(p: "My para\n") }
+  it { should parse(" My para").as(p: " My para") }
+  it { should parse(" My para\nsecond line").as(p: " My para\nsecond line") }
+  it { should parse(" My para\nsecond line\n").as(p: " My para\nsecond line\n") }
+  it { should parse(" My para\nsecond line   \n").as(p: " My para\nsecond line   \n") }
+  it { should_not parse("Para1\n\nPara2") }
+
+  it { should parse("a   b") }
+
+  describe "transformed" do
+    let(:content) { "My para" }
+    subject(:transformed) {
+      Smartdown::Parser::NodeInterpreter.new(node_name, content, parser: parser).interpret
+    }
+
+    it { should eq(Smartdown::Model::Element::MarkdownParagraph.new(content)) }
+  end
+end
+