smartdown 0.0.1

data/spec/parser/element/multiple_choice_question_spec.rb

@@ -0,0 +1,31 @@
+require 'smartdown/parser/element/start_button'
+require 'smartdown/parser/node_parser'
+require 'smartdown/parser/node_interpreter'
+
+describe Smartdown::Parser::Element::MultipleChoiceQuestion do
+  subject(:parser) { described_class.new }
+  let(:source) {
+    [
+      "* yes: Yes",
+      "* no: No"
+    ].join("\n")
+  }
+
+  it "parses" do
+    should parse(source).as(
+      multiple_choice: [
+        {value: "yes", label: "Yes"},
+        {value: "no", label: "No"}
+      ]
+    )
+  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::MultipleChoice.new(node_name, {"yes"=>"Yes", "no"=>"No"})) }
+  end
+end

data/spec/parser/element/start_button_parser_spec.rb

@@ -0,0 +1,30 @@
+require 'smartdown/parser/element/start_button'
+require 'smartdown/parser/node_parser'
+require 'smartdown/parser/node_interpreter'
+
+describe Smartdown::Parser::Element::StartButton do
+  subject(:parser) { described_class.new }
+
+  it "parses a start indicator with a question identifier" do
+    should parse("[start: first_question?]").as({start_button: "first_question?"})
+    should parse("[start: first_question?]\n").as({start_button: "first_question?"})
+  end
+
+  it "requires a question identifier" do
+    should_not parse("[start]")
+  end
+
+  it "does not allow spaces in question identifier" do
+    should_not parse("[start: first question]")
+  end
+
+  describe "transformed" do
+    let(:node_name) { "my_node" }
+    let(:source) { "[start: first_question?]\n" }
+    subject(:transformed) {
+      Smartdown::Parser::NodeInterpreter.new(node_name, source, parser: parser).interpret
+    }
+
+    it { should eq(Smartdown::Model::Element::StartButton.new("first_question?")) }
+  end
+end

data/spec/parser/integration/cover_sheet_spec.rb

@@ -0,0 +1,30 @@
+require 'smartdown/parser/node_interpreter'
+require 'smartdown/model/element/start_button'
+
+describe "interpreting a cover sheet containing a start button" do
+  let(:source) { <<-SOURCE
+meta_description: My coversheet
+
+# Cover sheet
+
+This is the cover sheet
+
+[start: first_question?]
+SOURCE
+}
+  let(:interpreter) { Smartdown::Parser::NodeInterpreter.new("my_node", source) }
+  subject(:node) { interpreter.interpret }
+
+  it "has front_matter" do
+    expect(node.front_matter.meta_description).to eq("My coversheet")
+  end
+
+  let(:start_button_element) do
+    Smartdown::Model::Element::StartButton.new("first_question?")
+  end
+
+  it "has start button element" do
+    expect(node.elements).to include(start_button_element)
+  end
+
+end

data/spec/parser/node_parser_spec.rb

@@ -0,0 +1,133 @@
+require 'smartdown/parser/node_parser'
+require 'smartdown/parser/node_interpreter'
+
+describe Smartdown::Parser::NodeParser do
+  subject(:parser) { described_class.new }
+
+  describe "body only" do
+    let(:source) {
+<<SOURCE
+# This is my title
+
+This is a paragraph of text with stuff
+that flows along
+
+Another paragraph of text
+SOURCE
+     }
+
+    it {
+      should parse(source).as({
+        body: [
+          {h1: "This is my title"},
+          {p: "This is a paragraph of text with stuff\nthat flows along\n"},
+          {p: "Another paragraph of text\n"}
+        ]
+      })
+    }
+
+    it "parses markdown blocks separated by multiple newlines" do
+      expect(parser).to parse("a\n\n\nb\n")
+    end
+  end
+
+  describe "front matter and body" do
+    let(:source) {
+<<SOURCE
+name: My node
+
+# This is my title
+
+A paragraph
+SOURCE
+     }
+
+    it do
+      should parse(source).as({
+        front_matter: [
+          {name: "name", value: "My node"}
+        ],
+        body: [
+          {h1: "This is my title"},
+          {p: "A paragraph\n"}
+        ]
+      })
+    end
+  end
+
+  describe "body with multiple choice options" do
+    let(:source) {
+<<SOURCE
+# This is my title
+
+* yes: Yes
+* no: No
+SOURCE
+     }
+
+    it do
+      should parse(source).as({
+        body: [
+          {h1: "This is my title"},
+          {multiple_choice: [
+            {value: "yes", label: "Yes"},
+            {value: "no", label: "No"}
+          ]}
+        ]
+      })
+    end
+  end
+
+  describe "body and next_node rules" do
+    let(:source) {
+<<SOURCE
+# This is my title
+
+* yes: Yes
+* no: No
+
+# Next node rules
+
+* pred1? => outcome
+SOURCE
+     }
+
+    it {
+      should parse(source).as({
+        body: [
+          {h1: "This is my title"},
+          {multiple_choice: [
+            {value: "yes", label: "Yes"},
+            {value: "no", label: "No"}
+          ]},
+          {h1: "Next node rules"},
+          {next_node_rules: [{rule: {predicate: {named_predicate: "pred1?"}, outcome: "outcome"}}]}
+        ]
+      })
+    }
+
+    describe "transformed" do
+      let(:node_name) { "my_node" }
+      subject(:transformed) {
+        Smartdown::Parser::NodeInterpreter.new(node_name, source, parser: parser).interpret
+      }
+
+      let(:expected_elements) {
+        [
+          Smartdown::Model::Element::MarkdownHeading.new("This is my title"),
+          Smartdown::Model::Element::MultipleChoice.new(node_name, "yes"=>"Yes", "no"=>"No"),
+          Smartdown::Model::Element::MarkdownHeading.new("Next node rules"),
+          Smartdown::Model::NextNodeRules.new([
+            Smartdown::Model::Rule.new(Smartdown::Model::Predicate::Named.new("pred1?"), "outcome")
+          ])
+        ]
+      }
+
+      let(:expected_node_model) {
+        Smartdown::Model::Node.new(node_name, expected_elements)
+      }
+
+      it { should eq(expected_node_model) }
+    end
+  end
+end

data/spec/parser/predicates_spec.rb

@@ -0,0 +1,65 @@
+require 'smartdown/parser/predicates'
+require 'smartdown/parser/node_interpreter'
+
+describe Smartdown::Parser::Predicates do
+
+  describe "equality predicate" do
+    subject(:parser) { described_class.new }
+    let(:source) { "varname is 'expected_value'" }
+
+    it { should parse(source).as(equality_predicate: {varname: "varname", expected_value: "expected_value"}) }
+    it { should_not parse("v is value") }
+    it { should_not parse("v is 'a thing's thing'") }
+    it { should_not parse("v is 'a thing\\'s thing'") }
+    it { should_not parse(%q{v is "a thing"}) }
+
+    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::Equality.new("varname", "expected_value")) }
+    end
+  end
+
+  describe "set membership predicate" do
+    subject(:parser) { described_class.new }
+    let(:source) { "varname in {a b c}" }
+
+    it { should parse(source).as(set_membership_predicate: {varname: "varname", values: [{set_value: "a"}, {set_value: "b"}, {set_value: "c"}]}) }
+    it { should parse('v in {}').as(set_membership_predicate: {varname: "v", values: nil}) }
+    it { should parse('v in { }').as(set_membership_predicate: {varname: "v", values: nil}) }
+    it { should parse('v   in   { }').as(set_membership_predicate: {varname: "v", values: nil}) }
+    it { should_not parse('vin {}') }
+    it { should_not parse("v in {\n}") }
+
+    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::SetMembership.new("varname", ["a", "b", "c"])) }
+    end
+  end
+
+  describe "named predicate" do
+    subject(:parser) { described_class.new }
+
+    it { should parse("my_pred").as(named_predicate: "my_pred") }
+    it { should parse("my_pred?").as(named_predicate: "my_pred?") }
+    it { should_not parse("my pred") }
+
+    describe "transformed" do
+      let(:node_name) { "my_node" }
+      let(:source) { "my_pred" }
+      subject(:transformed) {
+        Smartdown::Parser::NodeInterpreter.new(node_name, source, parser: parser).interpret
+      }
+
+      it { should eq(Smartdown::Model::Predicate::Named.new("my_pred")) }
+    end
+  end
+end
+

data/spec/parser/rules_spec.rb

@@ -0,0 +1,244 @@
+require 'smartdown/parser/rules'
+require 'smartdown/parser/node_interpreter'
+
+describe Smartdown::Parser::Rules do
+  subject(:parser) { described_class.new }
+  let(:node_name) { "my_node" }
+
+  describe "simple rule" do
+    let(:source) { "* my_pred? => outcome" }
+
+    it { should parse(source).as({next_node_rules: [{rule: {predicate: {named_predicate: "my_pred?"}, outcome: "outcome"}}]}) }
+    it { should parse("* p? => q?").as({next_node_rules: [{rule: {predicate: {named_predicate: "p?"}, outcome: "q?"}}]}) }
+
+    describe "transformed" do
+      subject(:transformed) {
+        Smartdown::Parser::NodeInterpreter.new(node_name, source, parser: parser).interpret
+      }
+
+      it { should eq(
+        Smartdown::Model::NextNodeRules.new(
+          [
+            Smartdown::Model::Rule.new(
+              Smartdown::Model::Predicate::Named.new("my_pred?"),
+              "outcome"
+            )
+          ]
+        )
+      ) }
+    end
+  end
+
+  describe "nested rules" do
+    describe "one inner rule" do
+      let(:child_rule) { "* pred2? => outcome"}
+      let(:source) {
+        [
+          "* pred1?",
+          "  " + child_rule
+        ].join("\n")
+      }
+      let(:parsed_child_rule) { parser.one_top_level_rule.parse(child_rule) }
+
+      it { should parse(source).as(next_node_rules: [{nested_rule: {predicate: {named_predicate: "pred1?"}, child_rules: [parsed_child_rule]}}]) }
+
+      describe "transformed" do
+        subject(:transformed) {
+          Smartdown::Parser::NodeInterpreter.new(node_name, source, parser: parser).interpret
+        }
+
+        it {
+          should eq(
+            Smartdown::Model::NextNodeRules.new(
+              [
+                Smartdown::Model::NestedRule.new(
+                  Smartdown::Model::Predicate::Named.new("pred1?"),
+                  [
+                    Smartdown::Model::Rule.new(
+                      Smartdown::Model::Predicate::Named.new("pred2?"),
+                      "outcome"
+                    )
+                  ]
+                )
+              ]
+            )
+          )
+        }
+      end
+    end
+
+    describe "two inner rules" do
+      let(:source) {
+        [
+          "* pred1?",
+          "  * pred2? => outcome1",
+          "  * pred3? => outcome2"
+        ].join("\n")
+      }
+      let(:parsed_child1) { parser.one_top_level_rule.parse("* pred2? => outcome1") }
+      let(:parsed_child2) { parser.one_top_level_rule.parse("* pred3? => outcome2") }
+
+      it {
+        should parse(source).as(
+          next_node_rules: [
+            {
+              nested_rule: {
+                predicate: { named_predicate: "pred1?" },
+                child_rules: [parsed_child1, parsed_child2]
+              }
+            }
+          ]
+        )
+      }
+
+      describe "transformed" do
+        subject(:transformed) {
+          Smartdown::Parser::NodeInterpreter.new(node_name, source, parser: parser).interpret
+        }
+
+        it {
+          should eq(
+            Smartdown::Model::NextNodeRules.new(
+              [
+                Smartdown::Model::NestedRule.new(
+                  Smartdown::Model::Predicate::Named.new("pred1?"),
+                  [
+                    Smartdown::Model::Rule.new(
+                      Smartdown::Model::Predicate::Named.new("pred2?"),
+                      "outcome1"
+                    ),
+                    Smartdown::Model::Rule.new(
+                      Smartdown::Model::Predicate::Named.new("pred3?"),
+                      "outcome2"
+                    )
+                  ]
+                )
+              ]
+            )
+          )
+        }
+      end
+    end
+
+    describe "combination of nested and non-nested rules" do
+      let(:child_rule) { "* pred2? => outcome"}
+      let(:source) {
+        [
+          "* pred1?",
+          "  * pred2? => outcome1_2",
+          "* pred3? => outcome3"
+        ].join("\n")
+      }
+      let(:parsed_child_1) { parser.one_top_level_rule.parse("* pred2? => outcome1_2") }
+      let(:parsed_child_2) { parser.one_top_level_rule.parse("* pred3? => outcome3") }
+
+      it {
+        should parse(source).as(
+          next_node_rules: [
+            {
+              nested_rule: {
+                predicate: { named_predicate: "pred1?" },
+                child_rules: [parsed_child_1]
+              }
+            },
+            parsed_child_2
+          ]
+        )
+      }
+
+      describe "transformed" do
+        subject(:transformed) {
+          Smartdown::Parser::NodeInterpreter.new(node_name, source, parser: parser).interpret
+        }
+
+        it {
+          should eq(
+            Smartdown::Model::NextNodeRules.new(
+              [
+                Smartdown::Model::NestedRule.new(
+                  Smartdown::Model::Predicate::Named.new("pred1?"),
+                  [
+                    Smartdown::Model::Rule.new(
+                      Smartdown::Model::Predicate::Named.new("pred2?"),
+                      "outcome1_2"
+                    )
+                  ]
+                ),
+                Smartdown::Model::Rule.new(
+                  Smartdown::Model::Predicate::Named.new("pred3?"),
+                  "outcome3"
+                )
+              ]
+            )
+          )
+        }
+      end
+    end
+
+    describe "nested rule in a nested rule" do
+      let(:child_rule) { "* pred2? => outcome"}
+      let(:source) {
+        [
+          "* pred1?",
+          "  * pred2?",
+          "    " + child_rule
+        ].join("\n")
+      }
+      let(:parsed_child_rule) { parser.one_top_level_rule.parse(child_rule) }
+
+      it {
+        should parse(source, trace: true).as(
+          next_node_rules: [
+            {
+              nested_rule: {
+                predicate: {named_predicate: "pred1?"},
+                child_rules: [
+                  nested_rule: {
+                    predicate: {named_predicate: "pred2?"},
+                    child_rules: [parsed_child_rule]
+                  }
+                ]
+              }
+            }
+          ]
+        )
+      }
+
+      describe "transformed" do
+        subject(:transformed) {
+          Smartdown::Parser::NodeInterpreter.new(node_name, source, parser: parser).interpret
+        }
+
+        it {
+          should eq(
+            Smartdown::Model::NextNodeRules.new(
+              [
+                Smartdown::Model::NestedRule.new(
+                  Smartdown::Model::Predicate::Named.new("pred1?"),
+                  [
+                    Smartdown::Model::NestedRule.new(
+                      Smartdown::Model::Predicate::Named.new("pred2?"),
+                      [
+                        Smartdown::Model::Rule.new(
+                          Smartdown::Model::Predicate::Named.new("pred2?"),
+                          "outcome"
+                        )
+                      ]
+                    )
+                  ]
+                )
+              ]
+            )
+          )
+        }
+      end
+    end
+
+    describe "missing inner rule" do
+      let(:source) { "* pred1?" }
+
+      it { should_not parse(source) }
+    end
+  end
+end
+

data/spec/spec_helper.rb

@@ -0,0 +1,27 @@
+$LOAD_PATH << File.expand_path("../lib", File.dirname(__FILE__))
+
+require 'pathname'
+require 'parslet/rig/rspec'
+require 'support/model_builder'
+
+RSpec.configure do |config|
+  if config.files_to_run.one?
+    config.full_backtrace = false
+    config.default_formatter = 'doc'
+  end
+
+  config.order = :random
+
+  Kernel.srand config.seed
+
+  config.expect_with :rspec do |expectations|
+    expectations.syntax = :expect
+  end
+
+  config.mock_with :rspec do |mocks|
+    mocks.syntax = :expect
+    mocks.verify_partial_doubles = true
+  end
+
+  config.include ModelBuilder::DSL
+end

data/spec/support/model_builder.rb

@@ -0,0 +1,83 @@
+require 'smartdown/model/flow'
+require 'smartdown/model/node'
+require 'smartdown/model/element/markdown_heading'
+require 'smartdown/model/element/markdown_paragraph'
+require 'smartdown/model/element/start_button'
+require 'smartdown/model/element/multiple_choice'
+require 'smartdown/model/next_node_rules'
+require 'smartdown/model/rule'
+require 'smartdown/model/predicate/named'
+require 'smartdown/model/predicate/equality'
+require 'smartdown/model/predicate/set_membership'
+
+class ModelBuilder
+  def flow(name, &block)
+    @nodes = []
+    instance_eval(&block) if block_given?
+    Smartdown::Model::Flow.new(name, @nodes)
+  end
+
+  def node(name, &block)
+    @nodes ||= []
+    @elements = []
+    @front_matter = nil
+    instance_eval(&block) if block_given?
+    @nodes << Smartdown::Model::Node.new(name, @elements, @front_matter)
+    @nodes.last
+  end
+
+  def heading(content)
+    @elements ||= []
+    @elements << Smartdown::Model::Element::MarkdownHeading.new(content)
+    @elements.last
+  end
+
+  def paragraph(content)
+    @elements ||= []
+    @elements << Smartdown::Model::Element::MarkdownParagraph.new(content)
+    @elements.last
+  end
+
+  def start_button(content)
+    @elements ||= []
+    @elements << Smartdown::Model::Element::StartButton.new(content)
+    @elements.last
+  end
+
+  def multiple_choice(options)
+    @elements ||= []
+    options_with_string_keys = ::Hash[options.map {|k,v| [k.to_s, v]}]
+    @elements << Smartdown::Model::Element::MultipleChoice.new(nil, options_with_string_keys)
+    @elements.last
+  end
+
+  def next_node_rules(&block)
+    @rules = []
+    instance_eval(&block) if block_given?
+    @elements << Smartdown::Model::NextNodeRules.new(@rules)
+    @elements.last
+  end
+
+  def rule(predicate = nil, outcome = nil, &block)
+    @predicate = predicate
+    @outcome = outcome
+    @rules ||= []
+    instance_eval(&block) if block_given?
+    @rules << Smartdown::Model::Rule.new(@predicate, @outcome)
+    @rules.last
+  end
+
+  def named_predicate(name)
+    @predicate = Smartdown::Model::Predicate::Named.new(name)
+  end
+
+  def outcome(name)
+    @outcome = name
+  end
+
+  module DSL
+    def build_flow(name, &block)
+      ModelBuilder.new.flow(name, &block)
+    end
+  end
+end