smartdown 0.0.1

data/lib/smartdown/parser/directory_input.rb

@@ -0,0 +1,61 @@
+require 'pathname'
+
+module Smartdown
+  module Parser
+    class DirectoryInput
+      def initialize(coversheet_path)
+        @coversheet_path = Pathname.new(coversheet_path.to_s)
+      end
+
+      def coversheet
+        InputFile.new(@coversheet_path)
+      end
+
+      def questions
+        read_dir("questions")
+      end
+
+      def outcomes
+        read_dir("outcomes")
+      end
+
+      def scenarios
+        read_dir("scenarios")
+      end
+
+      def filenames_hash
+        {
+          coversheet: coversheet.to_s,
+          questions: questions.map(&:to_s),
+          outcomes: outcomes.map(&:to_s),
+          scenarios: scenarios.map(&:to_s)
+        }
+      end
+
+    private
+      def read_dir(dir)
+        Dir[@coversheet_path.dirname + dir + "*.txt"].map do |filename|
+          InputFile.new(filename)
+        end
+      end
+    end
+
+    class InputFile
+      def initialize(path)
+        @path = Pathname.new(path.to_s)
+      end
+
+      def name
+        @path.basename.to_s.split(".").first
+      end
+
+      def read
+        File.read(@path)
+      end
+
+      def to_s
+        @path.to_s
+      end
+    end
+  end
+end

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

@@ -0,0 +1,17 @@
+require 'smartdown/parser/base'
+
+module Smartdown
+  module Parser
+    module Element
+      class FrontMatter < Base
+        rule(:front_matter_line) {
+          identifier.as(:name) >> str(":") >> ws >> whitespace_terminated_string.as(:value) >> line_ending
+        }
+        rule(:front_matter) {
+          front_matter_line.repeat(1).as(:front_matter)
+        }
+        root(:front_matter)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,14 @@
+require 'smartdown/parser/base'
+
+module Smartdown
+  module Parser
+    module Element
+      class MarkdownHeading < Base
+        rule(:markdown_heading) {
+          str('# ') >> (whitespace_terminated_string).as(:h1) >> optional_space >> line_ending
+        }
+        root(:markdown_heading)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,19 @@
+require 'smartdown/parser/base'
+
+module Smartdown
+  module Parser
+    module Element
+      class MarkdownParagraph < Base
+        rule(:markdown_line) {
+          optional_space >> whitespace_terminated_string >> optional_space
+        }
+
+        rule(:markdown_paragraph) {
+          (markdown_line >> line_ending).repeat(1).as(:p)
+        }
+
+        root(:markdown_paragraph)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,24 @@
+require 'smartdown/parser/base'
+
+module Smartdown
+  module Parser
+    module Element
+      class MultipleChoiceQuestion < Base
+        rule(:option_definition_line) {
+          bullet >>
+            optional_space >>
+            identifier.as(:value) >>
+            str(":") >>
+            optional_space >>
+            whitespace_terminated_string.as(:label) >>
+            optional_space
+        }
+
+        rule(:multiple_choice_question) {
+          (option_definition_line >> line_ending).repeat(1).as(:multiple_choice)
+        }
+        root(:multiple_choice_question)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,15 @@
+require 'smartdown/parser/base'
+
+module Smartdown
+  module Parser
+    module Element
+      class StartButton < Base
+        rule(:start_button) {
+          str('[start: ') >> question_identifier.as(:start_button) >> str(']') >> line_ending
+        }
+
+        root(:start_button)
+      end
+    end
+  end
+end

data/lib/smartdown/parser/flow_interpreter.rb

@@ -0,0 +1,50 @@
+require 'smartdown/model/flow'
+require 'smartdown/parser/node_interpreter'
+
+module Smartdown
+  module Parser
+    class ParseError < StandardError
+      attr_reader :filename, :parse_error
+
+      def initialize(filename, parse_error)
+        @filename = filename
+        @parse_error = parse_error
+      end
+
+      def to_s(full = true)
+        "Parse error in '#{filename}':\n\n" + @parse_error.cause.ascii_tree
+      end
+    end
+
+    class FlowInterpreter
+      attr_reader :flow_input
+
+      def initialize(flow_input)
+        @flow_input = flow_input
+      end
+
+      def interpret
+        Smartdown::Model::Flow.new(coversheet.name, [coversheet] + questions + outcomes)
+      end
+
+    private
+      def coversheet
+        interpret_node(flow_input.coversheet)
+      end
+
+      def questions
+        flow_input.questions.map { |i| interpret_node(i) }
+      end
+
+      def outcomes
+        flow_input.outcomes.map { |i| interpret_node(i) }
+      end
+
+      def interpret_node(input_data)
+        Smartdown::Parser::NodeInterpreter.new(input_data.name, input_data.read).interpret
+      rescue Parslet::ParseFailed => error
+        raise ParseError.new(input_data.to_s, error)
+      end
+    end
+  end
+end

data/lib/smartdown/parser/node_interpreter.rb

@@ -0,0 +1,29 @@
+require 'pathname'
+require 'smartdown/model/flow'
+require 'smartdown/model/node'
+require 'smartdown/parser/node_parser'
+require 'smartdown/parser/node_transform'
+
+module Smartdown
+  module Parser
+    class NodeInterpreter
+      attr_reader :name, :source
+
+      def initialize(name, source, options = {})
+        @name = name
+        @source = source
+        @parser = options.fetch(:parser, Smartdown::Parser::NodeParser.new)
+        @transform = options.fetch(:transform, Smartdown::Parser::NodeTransform.new)
+      end
+
+      def interpret
+        transform.apply(parser.parse(source),
+          node_name: name
+        )
+      end
+
+    private
+      attr_reader :parser, :transform
+    end
+  end
+end

data/lib/smartdown/parser/node_parser.rb

@@ -0,0 +1,37 @@
+require 'smartdown/parser/base'
+require 'smartdown/parser/rules'
+require 'smartdown/parser/element/front_matter'
+require 'smartdown/parser/element/start_button'
+require 'smartdown/parser/element/multiple_choice_question'
+require 'smartdown/parser/element/markdown_heading'
+require 'smartdown/parser/element/markdown_paragraph'
+
+module Smartdown
+  module Parser
+    class NodeParser < Base
+      rule(:markdown_block) {
+        Element::MarkdownHeading.new |
+          Element::MultipleChoiceQuestion.new |
+          Rules.new |
+          Element::StartButton.new |
+          Element::MarkdownParagraph.new
+      }
+
+      rule(:markdown_blocks) {
+        markdown_block >> (newline.repeat(1) >> markdown_block).repeat
+      }
+
+      rule(:body) {
+        markdown_blocks.as(:body)
+      }
+
+      rule(:flow) {
+        Element::FrontMatter.new >> newline.repeat(1) >> body |
+          Element::FrontMatter.new |
+          ws >> body
+      }
+
+      root(:flow)
+    end
+  end
+end

data/lib/smartdown/parser/node_transform.rb

@@ -0,0 +1,83 @@
+require 'parslet/transform'
+require 'smartdown/model/node'
+require 'smartdown/model/front_matter'
+require 'smartdown/model/rule'
+require 'smartdown/model/nested_rule'
+require 'smartdown/model/next_node_rules'
+require 'smartdown/model/element/multiple_choice'
+require 'smartdown/model/element/start_button'
+require 'smartdown/model/element/markdown_heading'
+require 'smartdown/model/element/markdown_paragraph'
+require 'smartdown/model/predicate/equality'
+require 'smartdown/model/predicate/set_membership'
+require 'smartdown/model/predicate/named'
+
+module Smartdown
+  module Parser
+    class NodeTransform < Parslet::Transform
+      rule(body: subtree(:body)) {
+        Smartdown::Model::Node.new(
+          node_name, body, Smartdown::Model::FrontMatter.new({})
+        )
+      }
+
+      rule(h1: simple(:content)) {
+        Smartdown::Model::Element::MarkdownHeading.new(content)
+      }
+
+      rule(p: simple(:content)) {
+        Smartdown::Model::Element::MarkdownParagraph.new(content)
+      }
+
+      rule(:start_button => simple(:start_node)) {
+        Smartdown::Model::Element::StartButton.new(start_node)
+      }
+
+      rule(:front_matter => subtree(:attrs), body: subtree(:body)) {
+        Smartdown::Model::Node.new(
+          node_name, body, Smartdown::Model::FrontMatter.new(Hash[attrs])
+        )
+      }
+      rule(:front_matter => subtree(:attrs)) {
+        [Smartdown::Model::FrontMatter.new(Hash[attrs])]
+      }
+      rule(:name => simple(:name), :value => simple(:value)) {
+        [name.to_s, value.to_s]
+      }
+
+      rule(:value => simple(:value), :label => simple(:label)) {
+        [value.to_s, label.to_s]
+      }
+
+      rule(:multiple_choice => subtree(:choices)) {
+        Smartdown::Model::Element::MultipleChoice.new(
+          node_name, Hash[choices]
+        )
+      }
+
+      rule(:equality_predicate => { varname: simple(:varname), expected_value: simple(:expected_value) }) {
+        Smartdown::Model::Predicate::Equality.new(varname, expected_value)
+      }
+
+      rule(:set_value => simple(:value)) { value }
+      rule(:set_membership_predicate => { varname: simple(:varname), values: subtree(:values) }) {
+        Smartdown::Model::Predicate::SetMembership.new(varname, values)
+      }
+
+      rule(:named_predicate => simple(:name) ) {
+        Smartdown::Model::Predicate::Named.new(name)
+      }
+
+      rule(:rule => {predicate: subtree(:predicate), outcome: simple(:outcome_name) } ) {
+        Smartdown::Model::Rule.new(predicate, outcome_name)
+      }
+      rule(:nested_rule => {predicate: subtree(:predicate), child_rules: subtree(:child_rules) } ) {
+        Smartdown::Model::NestedRule.new(predicate, child_rules)
+      }
+      rule(:next_node_rules => subtree(:rules)) {
+        Smartdown::Model::NextNodeRules.new(rules)
+      }
+    end
+  end
+end
+

data/lib/smartdown/parser/predicates.rb

@@ -0,0 +1,36 @@
+require 'smartdown/parser/base'
+
+module Smartdown
+  module Parser
+    class Predicates < Base
+      rule(:equality_predicate) {
+        identifier.as(:varname) >> some_space >>
+          str('is') >> some_space >>
+          str("'") >> match("[^']").repeat.as(:expected_value) >> str("'")
+      }
+
+      rule(:set_value) {
+        match('[^\s}]').repeat(1).as(:set_value)
+      }
+
+      rule(:set_values) {
+        (set_value >> some_space).repeat >> set_value
+      }
+
+      rule(:set_membership_predicate) {
+        identifier.as(:varname) >> some_space >>
+          str('in') >> some_space >>
+          str("{") >> optional_space >> set_values.maybe.as(:values) >> optional_space >> str("}")
+      }
+
+      rule(:named_predicate) {
+        question_identifier.as(:named_predicate)
+      }
+      rule(:predicates) {
+        equality_predicate.as(:equality_predicate) | set_membership_predicate.as(:set_membership_predicate) | named_predicate
+      }
+
+      root(:predicates)
+    end
+  end
+end

data/lib/smartdown/parser/rules.rb

@@ -0,0 +1,51 @@
+require 'smartdown/parser/base'
+require 'smartdown/parser/predicates'
+
+module Smartdown
+  module Parser
+    class Rules < Base
+      def indent(depth)
+        str(' ').repeat(depth).capture(:indent)
+      end
+
+      def conditional_line(depth)
+        indent(depth) >> bullet >> optional_space >> Smartdown::Parser::Predicates.new.as(:predicate) >> optional_space >> line_ending
+      end
+
+      def children
+        dynamic do |s,c|
+          current_indent = c.captures[:indent].size
+          condition_with_children_or_rule(current_indent + 1).repeat(1)
+        end.as(:child_rules)
+      end
+
+      def condition_with_children(depth)
+        conditional_line(depth) >> children
+      end
+
+      def rule(depth)
+        (
+          indent(depth) >> bullet >> optional_space >>
+          Smartdown::Parser::Predicates.new.as(:predicate) >> optional_space >>
+          str("=>") >> optional_space >>
+          question_identifier.as(:outcome) >>
+          optional_space >> line_ending
+        ).as(:rule)
+      end
+
+      def condition_with_children_or_rule(depth)
+        condition_with_children(depth).as(:nested_rule) | rule(depth)
+      end
+
+      rule(:one_top_level_rule) {
+        condition_with_children_or_rule(0)
+      }
+
+      rule(:rules) {
+        one_top_level_rule.repeat(1).as(:next_node_rules)
+      }
+
+      root(:rules)
+    end
+  end
+end

data/lib/smartdown/version.rb

@@ -0,0 +1,3 @@
+module Smartdown
+  VERSION = "0.0.1"
+end

data/lib/smartdown.rb

@@ -0,0 +1,9 @@
+require 'smartdown/parser/flow_interpreter'
+require 'smartdown/parser/directory_input'
+
+module Smartdown
+  def self.parse(coversheet_file)
+    input = Smartdown::Parser::DirectoryInput.new(coversheet_file)
+    Smartdown::Parser::FlowInterpreter.new(input).interpret
+  end
+end

data/spec/acceptance/parsing_spec.rb

@@ -0,0 +1,109 @@
+require 'smartdown.rb'
+
+describe "Smartdown.parse" do
+
+  def fixture(name)
+    File.dirname(__FILE__) + "/../fixtures/acceptance/#{name}/#{name}.txt"
+  end
+
+  context "flow with only a cover-sheet" do
+    subject(:flow) { Smartdown.parse(fixture("cover-sheet")) }
+
+    it "builds a Flow model" do
+      expect(flow).to be_a(Smartdown::Model::Flow)
+    end
+
+    it "derives the name from the filename" do
+      expect(flow.name).to eq("cover-sheet")
+    end
+
+    it "has a single coversheet node" do
+      expect(flow.nodes).to match([instance_of(Smartdown::Model::Node)])
+    end
+
+    describe "#coversheet" do
+      subject(:coversheet) { flow.coversheet }
+
+      it "returns the coversheet node" do
+        expect(flow.coversheet).to be_a(Smartdown::Model::Node)
+      end
+
+      it "has front matter" do
+        expect(coversheet.front_matter).to be_a(Smartdown::Model::FrontMatter)
+      end
+
+      describe "front matter" do
+        it "has satisfies_need" do
+          expect(coversheet.front_matter.satisfies_need).to eq("1234")
+        end
+
+        it "has meta_description" do
+          expect(coversheet.front_matter.meta_description).to eq("Blah blah")
+        end
+      end
+
+      it "has a title extracted from the first markdown H1" do
+        expect(coversheet.title).to eq("My coversheet")
+      end
+
+      it "has a body" do
+        expect(coversheet.body).to eq(<<-EXPECTED)
+This is the body markdown.
+
+It has many paragraphs
+of text.
+
+* it
+* can
+* have
+* lists
+EXPECTED
+      end
+    end
+  end
+
+  context "flow with a cover-sheet and a question" do
+    subject(:flow) { Smartdown.parse(fixture("one-question")) }
+
+    it "has two nodes" do
+      expect(flow.nodes.size).to eq(2)
+      expect(flow.nodes[0]).to eq(flow.coversheet)
+      expect(flow.nodes[1]).to be_a(Smartdown::Model::Node)
+    end
+
+    describe "the question node" do
+      subject(:question_node) { flow.nodes[1] }
+
+      it "has a title" do
+        expect(question_node.title).to eq("Question one")
+      end
+
+      it "has two body paras" do
+        expect(question_node.body).to eq(<<-EXPECTED)
+Body text line 1.
+
+Body text
+para 2.
+EXPECTED
+      end
+
+      it "has a multiple choice question" do
+        expect(question_node.questions).to match([instance_of(Smartdown::Model::Element::MultipleChoice)])
+      end
+    end
+  end
+
+  context "flow coversheet, question and outcome" do
+    subject(:flow) { Smartdown.parse(fixture("question-and-outcome")) }
+
+    it "has three nodes" do
+      expect(flow.nodes.size).to eq(3)
+    end
+
+    it "has node names" do
+      expect(flow.nodes.map(&:name)).to eq(["question-and-outcome", "q1", "o1"])
+    end
+  end
+end
+
+

data/spec/acceptance/smartdown_cli_spec.rb

@@ -0,0 +1,16 @@
+describe "bin/smartdown" do
+  subject(:the_executable) { "bin/smartdown" }
+
+  it "is executable" do
+    expect(File.executable?(the_executable)).to eq(true)
+  end
+
+  describe "invocation with no arguments" do
+    subject(:output) { `#{the_executable} 2>&1` }
+
+    it "reports usage" do
+      expect(output).to match(/usage/i)
+      expect($?.exitstatus).to eq(1)
+    end
+  end
+end

data/spec/engine/predicate_evaluator_spec.rb

@@ -0,0 +1,98 @@
+require 'smartdown/engine/predicate_evaluator'
+require 'smartdown/model/predicate/equality'
+require 'smartdown/model/predicate/set_membership'
+require 'smartdown/model/predicate/named'
+require 'smartdown/engine/state'
+
+describe Smartdown::Engine::PredicateEvaluator do
+  subject(:evalutator) { described_class.new }
+
+  context "equality predicate" do
+    let(:predicate) { Smartdown::Model::Predicate::Equality.new("my_var", "some value") }
+
+    describe "#evaluate" do
+      context "state missing expected variable" do
+        let(:state) { Smartdown::Engine::State.new(current_node: "n") }
+
+        it "raises an UndefinedValue error" do
+          expect { evalutator.evaluate(predicate, state) }.to raise_error(Smartdown::Engine::UndefinedValue)
+        end
+      end
+
+      context "state has expected variable with same value" do
+        let(:state) { Smartdown::Engine::State.new(current_node: "n", my_var: "some value") }
+
+        it "evalutes to true" do
+          expect(evalutator.evaluate(predicate, state)).to eq(true)
+        end
+      end
+
+      context "state has expected variable with a different value" do
+        let(:state) { Smartdown::Engine::State.new(current_node: "n", my_var: "some other value") }
+
+        it "evalutes to false" do
+          expect(evalutator.evaluate(predicate, state)).to eq(false)
+        end
+      end
+    end
+  end
+
+  context "set membership predicate" do
+    let(:expected_values) { ["v1", "v2", "v3"] }
+    let(:varname) { "my_var" }
+    let(:predicate) { Smartdown::Model::Predicate::SetMembership.new(varname, expected_values) }
+
+    describe "#evaluate" do
+      context "state missing expected variable" do
+        let(:state) { Smartdown::Engine::State.new(current_node: "n") }
+
+        it "raises an UndefinedValue error" do
+          expect { evalutator.evaluate(predicate, state) }.to raise_error(Smartdown::Engine::UndefinedValue)
+        end
+      end
+
+      context "state has expected variable with one of the expected values" do
+        it "evalutes to true" do
+          expected_values.each do |value|
+            state = Smartdown::Engine::State.new(current_node: "n", varname => value)
+            expect(evalutator.evaluate(predicate, state)).to eq(true)
+          end
+        end
+      end
+
+      context "state has expected variable with a value not in the list of expected values" do
+        let(:state) { Smartdown::Engine::State.new(current_node: "n", varname => "some other value") }
+
+        it "evalutes to false" do
+          expect(evalutator.evaluate(predicate, state)).to eq(false)
+        end
+      end
+    end
+  end
+
+  context "named predicate" do
+    let(:predicate_name) { "my_pred?" }
+    let(:predicate) { Smartdown::Model::Predicate::Named.new(predicate_name) }
+
+    describe "#evaluate" do
+      context "state missing predicate definition" do
+        let(:state) { Smartdown::Engine::State.new(current_node: "n") }
+
+        it "raises an UndefinedValue error" do
+          expect { evalutator.evaluate(predicate, state) }.to raise_error(Smartdown::Engine::UndefinedValue)
+        end
+      end
+
+      context "state has predicate definition" do
+        let(:state) {
+          Smartdown::Engine::State.new("current_node" => "n", "my_pred?" => true )
+        }
+
+        it "fetches the predicate value from the state" do
+          expect(evalutator.evaluate(predicate, state)).to eq(true)
+        end
+      end
+    end
+  end
+
+end