smartdown 0.3.0 → 0.4.0

data/lib/smartdown/engine/conditional_resolver.rb

@@ -1,12 +1,6 @@
-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)
@@ -14,10 +8,8 @@ module Smartdown
       end
 
     private
-      attr_accessor :predicate_evaluator
-
       def evaluate(conditional, state)
-        if predicate_evaluator.evaluate(conditional.predicate, state)
+        if conditional.predicate.evaluate(state)
           conditional.true_case
         else
           conditional.false_case

data/lib/smartdown/engine/interpolator.rb

@@ -39,7 +39,18 @@ module Smartdown
 
       private
         def interpolate(text, state)
-          text.to_s.gsub(/%{([^}]+)}/) { |_| state.get($1) }
+          text.to_s.gsub(/%{([^}]+)}/) do |_|
+            resolve_term($1, state)
+          end
+        end
+
+        def resolve_term(interpolation, state)
+          begin
+              parsed = Smartdown::Parser::Predicates.new.parse(interpolation)
+              Smartdown::Parser::NodeTransform.new.apply(parsed, {}).evaluate(state)
+            rescue Parslet::ParseFailed
+              state.get(interpolation)
+            end
         end
       end
 

data/lib/smartdown/engine/state.rb

@@ -22,12 +22,7 @@ module Smartdown
       end
 
       def get(key)
-        value = fetch(key)
-        if value.respond_to?(:call)
-          evaluate(value)
-        else
-          value
-        end
+        fetch(key)
       end
 
       def put(name, value)
@@ -54,10 +49,6 @@ module Smartdown
           raise UndefinedValue, "variable '#{key}' not defined", caller
         end
       end
-
-      def evaluate(callable)
-        @cached[callable] ||= callable.call(self)
-      end
     end
   end
 end

data/lib/smartdown/engine/transition.rb

@@ -1,4 +1,3 @@
-require 'smartdown/engine/predicate_evaluator'
 require 'smartdown/engine/errors'
 
 module Smartdown
@@ -10,7 +9,6 @@ module Smartdown
         @state = state
         @node = node
         @inputs = input_array
-        @predicate_evaluator = options[:predicate_evaluator] || PredicateEvaluator.new
       end
 
       def next_node
@@ -27,8 +25,6 @@ module Smartdown
       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
@@ -60,11 +56,11 @@ module Smartdown
         rules.each do |rule|
           case rule
           when Smartdown::Model::Rule
-            if predicate_evaluator.evaluate(rule.predicate, state_with_inputs)
+            if rule.predicate.evaluate(state_with_inputs)
               throw(:match, rule)
             end
           when Smartdown::Model::NestedRule
-            if predicate_evaluator.evaluate(rule.predicate, state_with_inputs)
+            if rule.predicate.evaluate(state_with_inputs)
               throw_first_matching_rule_in(rule.children)
             end
           else

data/lib/smartdown/engine.rb

@@ -1,6 +1,7 @@
 require 'smartdown/engine/transition'
 require 'smartdown/engine/state'
 require 'smartdown/engine/node_presenter'
+require 'smartdown/model/predicate/otherwise'
 
 module Smartdown
   class Engine
@@ -20,9 +21,7 @@ module Smartdown
     end
 
     def default_predicates
-      {
-        otherwise: ->(_) { true }
-      }.merge(@initial_state)
+      {}.merge(@initial_state)
     end
 
     def process(responses, test_start_state = nil)

data/lib/smartdown/model/predicate/combined.rb

@@ -1,7 +1,15 @@
 module Smartdown
   module Model
     module Predicate
-      Combined = Struct.new(:predicates)
+      Combined = Struct.new(:predicates) do
+        def evaluate(state)
+          predicates.map { |predicate| predicate.evaluate(state) }.all?
+        end
+
+        def humanize
+          "(#{predicates.map { |p| p.humanize }.join(' AND ')})"
+        end
+      end
     end
   end
 end

data/lib/smartdown/model/predicate/comparison/base.rb

@@ -2,7 +2,10 @@ module Smartdown
   module Model
     module Predicate
       module Comparison
-        Base = Struct.new(:varname, :value)
+        Base = Struct.new(:varname, :value) do
+          def evaluate(state)
+          end
+        end
       end
     end
   end

data/lib/smartdown/model/predicate/comparison/greater.rb

@@ -6,13 +6,18 @@ module Smartdown
     module Predicate
       module Comparison
         class Greater < Base
-          def evaluate(variable)
+          def evaluate(state)
+            variable = state.get(varname)
             if /(\d{4})-(\d{1,2})-(\d{1,2})/.match(value)
               Date.parse(variable) > Date.parse(value)
             else
               variable > value
             end
           end
+
+          def humanize
+            "#{varname} > #{value}"
+          end
         end
       end
     end

data/lib/smartdown/model/predicate/comparison/greater_or_equal.rb

@@ -6,13 +6,18 @@ module Smartdown
     module Predicate
       module Comparison
         class GreaterOrEqual < Base
-          def evaluate(variable)
+          def evaluate(state)
+            variable = state.get(varname)
             if /(\d{4})-(\d{1,2})-(\d{1,2})/.match(value)
               Date.parse(variable) >= Date.parse(value)
             else
               variable >= value
             end
           end
+
+          def humanize
+            "#{varname} >= #{value}"
+          end
         end
       end
     end

data/lib/smartdown/model/predicate/comparison/less.rb

@@ -6,13 +6,18 @@ module Smartdown
     module Predicate
       module Comparison
         class Less < Base
-          def evaluate(variable)
+          def evaluate(state)
+            variable = state.get(varname)
             if /(\d{4})-(\d{1,2})-(\d{1,2})/.match(value)
               Date.parse(variable) < Date.parse(value)
             else
               variable < value
             end
           end
+
+          def humanize
+            "#{varname} < #{value}"
+          end
         end
       end
     end

data/lib/smartdown/model/predicate/comparison/less_or_equal.rb

@@ -6,13 +6,18 @@ module Smartdown
     module Predicate
       module Comparison
         class LessOrEqual < Base
-          def evaluate(variable)
+          def evaluate(state)
+            variable = state.get(varname)
             if /(\d{4})-(\d{1,2})-(\d{1,2})/.match(value)
               Date.parse(variable) <= Date.parse(value)
             else
               variable <= value
             end
           end
+
+          def humanize
+            "#{varname} <= #{value}"
+          end
         end
       end
     end

data/lib/smartdown/model/predicate/equality.rb

@@ -1,7 +1,15 @@
 module Smartdown
   module Model
     module Predicate
-      Equality = Struct.new(:varname, :expected_value)
+      Equality = Struct.new(:varname, :expected_value) do
+        def evaluate(state)
+          state.get(varname) == expected_value
+        end
+
+        def humanize
+          "#{varname} == '#{expected_value}'"
+        end
+      end
     end
   end
 end

data/lib/smartdown/model/predicate/function.rb

@@ -0,0 +1,28 @@
+module Smartdown
+  module Model
+    module Predicate
+      Function = Struct.new(:name, :arguments) do
+        def evaluate(state)
+          state.get(name).call(*evaluate_arguments(state))
+        end
+
+        def humanize
+          "#{name}(#{arguments.join(' ')})"
+        end
+
+      private
+
+        def evaluate_arguments(state)
+          # Should have an evaluatable "variable" object that matches identifier
+          arguments.map do |argument|
+            if argument.respond_to?(:evaluate)
+              argument.evaluate(state)
+            else
+              state.get(argument)
+            end
+         end
+        end
+      end
+    end
+  end
+end

data/lib/smartdown/model/predicate/named.rb

@@ -1,7 +1,15 @@
 module Smartdown
   module Model
     module Predicate
-      Named = Struct.new(:name)
+      Named = Struct.new(:name) do
+        def evaluate(state)
+          !!state.get(name)
+        end
+
+        def humanize
+          "#{name.to_s.chomp('?')}?"
+        end
+      end
     end
   end
 end

data/lib/smartdown/model/predicate/otherwise.rb

@@ -0,0 +1,15 @@
+module Smartdown
+  module Model
+    module Predicate
+      class Otherwise
+        def evaluate(state)
+            true
+        end
+
+        def ==(o)
+          o.class == self.class
+        end
+      end
+    end
+  end
+end

data/lib/smartdown/model/predicate/set_membership.rb

@@ -1,7 +1,15 @@
 module Smartdown
   module Model
     module Predicate
-      SetMembership = Struct.new(:varname, :values)
+      SetMembership = Struct.new(:varname, :values) do
+        def evaluate(state)
+          values.include?(state.get(varname))
+        end
+
+        def humanize
+          "#{varname} in [#{values.join(", ")}]"
+        end
+      end
     end
   end
 end

data/lib/smartdown/parser/node_transform.rb

@@ -16,6 +16,7 @@ require 'smartdown/model/predicate/equality'
 require 'smartdown/model/predicate/set_membership'
 require 'smartdown/model/predicate/named'
 require 'smartdown/model/predicate/combined'
+require 'smartdown/model/predicate/function'
 require 'smartdown/model/predicate/comparison/greater_or_equal'
 require 'smartdown/model/predicate/comparison/greater'
 require 'smartdown/model/predicate/comparison/less_or_equal'
@@ -120,11 +121,24 @@ module Smartdown
         Smartdown::Model::Predicate::Named.new(name)
       }
 
+      rule(:otherwise_predicate => simple(:name) ) {
+        Smartdown::Model::Predicate::Otherwise.new
+      }
 
       rule(:combined_predicate => {first_predicate: subtree(:first_predicate), and_predicates: subtree(:and_predicates) }) {
         Smartdown::Model::Predicate::Combined.new([first_predicate]+and_predicates)
       }
 
+      rule(:function_argument => simple(:argument)) { argument }
+
+      rule(:function_predicate => { name: simple(:name), arguments: subtree(:arguments) }) {
+        Smartdown::Model::Predicate::Function.new(name, Array(arguments))
+      }
+
+      rule(:function_predicate => { name: simple(:name) }) {
+        Smartdown::Model::Predicate::Function.new(name, [])
+      }
+
       rule(:comparison_predicate => { varname: simple(:varname), 
                                        value: simple(:value),
                                        operator: simple(:operator)

data/lib/smartdown/parser/predicates.rb

@@ -34,13 +34,18 @@ module Smartdown
       }
 
       rule(:named_predicate) {
-        question_identifier.as(:named_predicate)
+        (identifier >> str('?')).as(:named_predicate)
+      }
+
+      rule(:otherwise_predicate) {
+        str('otherwise').as(:otherwise_predicate)
       }
 
       rule(:predicate) {
         equality_predicate.as(:equality_predicate) |
         set_membership_predicate.as(:set_membership_predicate) |
         comparison_predicate.as(:comparison_predicate) |
+        otherwise_predicate |
         named_predicate
       }
 
@@ -50,8 +55,20 @@ module Smartdown
         predicate).repeat(1).as(:and_predicates)
       }
 
+      rule(:function_arguments) {
+        identifier.as(:function_argument) >> (some_space >> identifier.as(:function_argument)).repeat
+      }
+
+      rule (:function_predicate) {
+        identifier.as(:name) >>
+        str('(') >>
+        function_arguments.as(:arguments).maybe >>
+        str(')')
+      }
+
       rule (:predicates) {
         combined_predicate.as(:combined_predicate) |
+        function_predicate.as(:function_predicate) |
         predicate
       }
 

data/lib/smartdown/version.rb

@@ -1,3 +1,3 @@
 module Smartdown
-  VERSION = "0.3.0"
+  VERSION = "0.4.0"
 end

data/spec/acceptance/parsing_spec.rb

@@ -104,6 +104,14 @@ EXPECTED
       expect(flow.nodes.map(&:name)).to eq(["question-and-outcome", "q1", "o1"])
     end
   end
+
+  context "full flow example" do
+    subject(:flow) { Smartdown.parse(fixture("animal-example-simple")) }
+
+    it "parses" do
+      expect(flow.instance_of? Smartdown::Model::Flow).to eq(true)
+    end
+  end
 end
 
 

data/spec/engine/interpolator_spec.rb

@@ -78,4 +78,18 @@ describe Smartdown::Engine::Interpolator do
       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) {
+      Smartdown::Engine::State.new(
+        current_node: node.name,
+        number: 10,
+        double: ->(number) { number * 2 }
+      )
+    }
+    it "interpolates the result of the function call" do
+      expect(interpolated_node.elements.first.content).to eq("20")
+    end
+  end
 end

data/spec/engine/state_spec.rb

@@ -48,43 +48,6 @@ describe Smartdown::Engine::State do
     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") }

data/spec/engine/transition_spec.rb

@@ -8,8 +8,7 @@ describe Smartdown::Engine::Transition do
   let(:start_state) { Smartdown::Engine::State.new(current_node: current_node_name) }
   let(:input) { "yes" }
   let(:input_array) { [input] }
-  subject(:transition) { described_class.new(start_state, current_node, input_array, predicate_evaluator: predicate_evaluator) }
-  let(:predicate_evaluator) { instance_double("Smartdown::Engine::PredicateEvaluator", evaluate: true) }
+  subject(:transition) { described_class.new(start_state, current_node, input_array) }
   let(:state_including_input) {
     start_state.put(current_node.name, input_array)
   }
@@ -65,22 +64,22 @@ describe Smartdown::Engine::Transition do
     }
 
     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)
+      it "evaluates the predicates with state including the input value" do
+        expect(predicate1).to receive(:evaluate).with(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)
+      it "evaluates the predicates for each rule in turn" do
+        allow(predicate1).to receive(:evaluate).with(state_including_input).and_return(false)
+        expect(predicate2).to receive(:evaluate).with(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)
+        allow(predicate1).to receive(:evaluate).with(state_including_input).and_return(false)
+        allow(predicate2).to receive(:evaluate).with(state_including_input).and_return(true)
 
         expect(transition.next_node).to eq(outcome_name2)
       end
@@ -94,6 +93,8 @@ describe Smartdown::Engine::Transition do
           .put(:current_node, outcome_name1)
           .put(current_node.name, input_array)
 
+        allow(predicate1).to receive(:evaluate).with(state_including_input).and_return(true)
+
         expect(transition.next_state).to eq(expected_state)
       end
     end
@@ -130,27 +131,27 @@ describe Smartdown::Engine::Transition do
 
     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)
+        it "evaluates each predicate in turn" do
+          expect(predicate1).to receive(:evaluate).with(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)
+        it "evaluates each predicate in turn" do
+          allow(predicate1).to receive(:evaluate).with(state_including_input).and_return(true)
+          expect(predicate2).to receive(:evaluate).with(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)
+        it "evaluates each predicate in turn" do
+          allow(predicate1).to receive(:evaluate).with(state_including_input).and_return(true)
+          allow(predicate2).to receive(:evaluate).with(state_including_input).and_return(false)
+          expect(predicate3).to receive(:evaluate).with(state_including_input).and_return(true)
 
           expect(transition.next_node).to eq(outcome_name2)
         end
@@ -160,6 +161,7 @@ describe Smartdown::Engine::Transition do
 
   context "next node rules and a named question" do
     let(:question_name) { "my_question" }
+    let(:predicate1) { double("predicate1") }
 
     let(:current_node) {
       Smartdown::Model::Node.new(
@@ -167,7 +169,7 @@ describe Smartdown::Engine::Transition do
         [
           Smartdown::Model::Element::Question::MultipleChoice.new(question_name, {"a" => "Apple"}),
           Smartdown::Model::NextNodeRules.new(
-            [Smartdown::Model::Rule.new(double("predicate1"), "o1")]
+            [Smartdown::Model::Rule.new(predicate1, "o1")]
           )
         ]
       )
@@ -175,6 +177,8 @@ describe Smartdown::Engine::Transition do
 
     describe "#next_state" do
       it "assigns the input value to a variable matching the question name" do
+        allow(predicate1).to receive(:evaluate).and_return(true)
+
         expect(transition.next_state.get(question_name)).to eq(input)
       end
     end

data/spec/engine_spec.rb

@@ -5,12 +5,6 @@ describe Smartdown::Engine do
   subject(:engine) { Smartdown::Engine.new(flow) }
   let(:start_state) {
     engine.build_start_state
-      .put(:eea_passport?, ->(state) {
-        %w{greek british}.include?(state.get(:what_passport_do_you_have?))
-      })
-      .put(:imaginary?, ->(state) {
-        %w{narnia}.include?(state.get(:what_country_are_you_going_to?))
-      })
       .put(:otherwise, true)
   }
 
@@ -34,7 +28,7 @@ describe Smartdown::Engine do
         )
         next_node_rules do
           rule do
-            named_predicate("eea_passport?")
+            set_membership_predicate("what_passport_do_you_have?", ["greek", "british"])
             outcome("outcome_no_visa_needed")
           end
         end
@@ -85,11 +79,11 @@ describe Smartdown::Engine do
         )
         next_node_rules do
           rule do
-            named_predicate("imaginary?")
+            set_membership_predicate("what_country_are_you_going_to?", ["narnia"])
             outcome("outcome_imaginary_country")
           end
           rule do
-            named_predicate("eea_passport?")
+            set_membership_predicate("what_passport_do_you_have?", ["greek", "british"])
             outcome("outcome_no_visa_needed")
           end
         end
@@ -118,16 +112,19 @@ describe Smartdown::Engine do
   }
 
   describe "initial_state" do
+    let(:lambda) {
+      ->(state) { 'a_dynamic_state_object' }
+    }
     let(:initial_state) { {
       key_1: 'a_state_object',
-      key_2: ->(state) { 'a_dynamic_state_object' }
+      key_2: :lambda
     } }
     let(:engine) { Smartdown::Engine.new(flow, initial_state) }
     subject(:state) { engine.process([]) }
 
     it "should have added initial_state to state" do
       expect(subject.get(:key_1)).to eql 'a_state_object'
-      expect(subject.get(:key_2)).to eql 'a_dynamic_state_object'
+      expect(subject.get(:key_2)).to eql :lambda
     end
   end