smartdown 0.10.0 → 0.11.0

data/README.md

@@ -224,6 +224,42 @@ date_variable_name >= '14/07/2014'
 date_variable_name < '14/07/2014'
 ```
 
+### Logical connectives
+
+There are operators that can be used to combine predicates, or invert
+their value. Namely NOT, OR and AND.
+
+eg.
+
+```
+variable_name is 'string' OR NOT variable name is 'date'
+```
+
+`OR` connectives join a sequence of predicates and will return true if
+any of them evaluate to true, otherwise false.
+
+`AND` connectives join a sequence of predicates and will return true if
+all of them evaluate to true, otherwise false.
+
+`NOT` connectives will invert the return value of a predicate. ie turn
+true to false and vice versa. They have high precedence so bind to a single
+predicate in chain eg in:
+
+```
+NOT variable_name is 'lovely name' OR variable_name is 'special name'
+```
+
+The implied parentheses around the experssion are:
+
+```
+(NOT variable_name is 'lovely name') OR variable_name is 'special name'
+```
+
+For more information on Logical Connectives see:
+
+http://en.wikipedia.org/wiki/Logical_connective
+
+
 ## Processing model
 
 Each response to a question is assigned to a variable which corresponds to the
@@ -292,6 +328,20 @@ Text if pred1, pred2, pred3 are false
 $ENDIF
 ```
 
+It is also possible to nest if statements: like so.
+
+```markdown
+
+$IF pred1?
+
+$IF pred2?
+
+Text if both true
+
+$ENDIF
+
+$ENDIF
+```
 
 ## Interpolation
 

data/lib/smartdown/api/node.rb

@@ -50,11 +50,7 @@ module Smartdown
       end
 
       def build_govspeak(elements)
-        markdown_elements = elements.select do |element|
-          markdown_element?(element)
-        end
-        govspeak = markdown_elements.map(&:content).join("\n")
-        GovspeakPresenter.new(govspeak).html unless govspeak.empty?
+        elements.select { |element| markdown_element?(element) }.map(&:content).join("\n")
       end
     end
   end

data/lib/smartdown/api/outcome.rb

@@ -3,8 +3,7 @@ module Smartdown
     class Outcome < Node
 
       def next_steps
-        next_step_element = elements.find{|element| element.is_a? Smartdown::Model::Element::NextSteps}
-        GovspeakPresenter.new(next_step_element.content).html if next_step_element
+        elements.find{|element| element.is_a? Smartdown::Model::Element::NextSteps}.content
       end
 
     end

data/lib/smartdown/api/question.rb

@@ -48,11 +48,7 @@ module Smartdown
       end
 
       def build_govspeak(elements)
-        markdown_elements = elements.select do |element|
-          markdown_element?(element)
-        end
-        govspeak = markdown_elements.map(&:content).join("\n")
-        GovspeakPresenter.new(govspeak).html unless govspeak.empty?
+        elements.select { |element| markdown_element?(element) }.markdown_elements.map(&:content).join("\n")
       end
     end
   end

data/lib/smartdown/model/predicate/{combined.rb → and_operation.rb}

@@ -1,7 +1,7 @@
 module Smartdown
   module Model
     module Predicate
-      Combined = Struct.new(:predicates) do
+      AndOperation = Struct.new(:predicates) do
         def evaluate(state)
           predicates.map { |predicate| predicate.evaluate(state) }.all?
         end

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

@@ -0,0 +1,15 @@
+module Smartdown
+  module Model
+    module Predicate
+      NotOperation = Struct.new(:predicate) do
+        def evaluate(state)
+          !predicate.evaluate(state)
+        end
+
+        def humanize
+          "NOT #{predicate.humanize}"
+        end
+      end
+    end
+  end
+end

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

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

data/lib/smartdown/parser/base.rb

@@ -4,13 +4,14 @@ module Smartdown
   module Parser
     class Base < Parslet::Parser
       rule(:eof) { any.absent? }
-      rule(:ws_char) { match('\s') }
+      rule(:ws_char) { space_char | str("\t") }
       rule(:space_char) { str(" ") }
       rule(:non_ws_char) { match('\S') }
-      rule(:newline) { str("\r\n") | str("\n\r") | str("\n") | str("\r") }
+      rule(:carriage_return) { str("\r\n") | str("\n\r") | str("\n") | str("\r") }
+      rule(:newline) { optional_space >> carriage_return }
       rule(:line_ending) { eof | newline }
 
-      rule(:optional_space) { space_char.repeat }
+      rule(:optional_space) { ws_char.repeat }
       rule(:some_space) { space_char.repeat(1) }
       rule(:ws) { ws_char.repeat }
       rule(:non_ws) { non_ws.repeat }

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

@@ -6,34 +6,45 @@ module Smartdown
   module Parser
     module Element
       class Conditional < Base
+
+        rule(:dollar_if)     { str("$IF ") }
+        rule(:dollar_else)   { str("$ELSE") }
+        rule(:dollar_elseif) { str("$ELSEIF ") }
+        rule(:dollar_endif)  { str("$ENDIF") }
+
         rule(:markdown_block_inside_conditional) {
-          str("$").absent? >> NodeParser.new.markdown_block
+          dollar_keywords = [dollar_if, dollar_else, dollar_elseif, dollar_endif]
+          dollar_keywords.map(&:absent?).reduce(:>>) >> NodeParser.new.markdown_block
+        }
+
+        rule(:conditional_body_block) {
+          markdown_block_inside_conditional | conditional_clause
         }
 
-        rule(:markdown_blocks_inside_conditional) {
-          markdown_block_inside_conditional.repeat(1,1) >> (newline.repeat(1) >> markdown_block_inside_conditional).repeat
+        rule(:blocks_inside_conditional) {
+          conditional_body_block.repeat(1,1) >> (newline.repeat(1) >> conditional_body_block).repeat
         }
 
         rule(:else_clause) {
-          str("$ELSE") >> optional_space >> newline.repeat(2) >>
-            (markdown_blocks_inside_conditional.as(:false_case) >> newline).maybe
+          dollar_else >> optional_space >> newline.repeat(2) >>
+            (blocks_inside_conditional.as(:false_case) >> newline).maybe
         }
 
         rule(:elseif_clause) {
-          str("$ELSEIF ") >> (Predicates.new.as(:predicate) >>
+          dollar_elseif >> (Predicates.new.as(:predicate) >>
           optional_space >> newline.repeat(2) >>
-          (markdown_blocks_inside_conditional.as(:true_case) >> newline).maybe >>
+          (blocks_inside_conditional.as(:true_case) >> newline).maybe >>
           ((elseif_clause | else_clause).maybe)).as(:conditional).repeat(1,1).as(:false_case)
         }
 
         rule(:conditional_clause) {
           (
-            str("$IF ") >>
+            dollar_if >>
               Predicates.new.as(:predicate) >>
               optional_space >> newline.repeat(2) >>
-              (markdown_blocks_inside_conditional.as(:true_case) >> newline).maybe >>
+              (blocks_inside_conditional.as(:true_case) >> newline).maybe >>
               (else_clause | elseif_clause).maybe >>
-              str("$ENDIF") >> optional_space >> line_ending
+              dollar_endif >> optional_space >> line_ending
           ).as(:conditional)
         }
 

data/lib/smartdown/parser/node_transform.rb

@@ -18,7 +18,9 @@ require 'smartdown/model/element/next_steps'
 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/not_operation'
+require 'smartdown/model/predicate/and_operation'
+require 'smartdown/model/predicate/or_operation'
 require 'smartdown/model/predicate/function'
 require 'smartdown/model/predicate/comparison/greater_or_equal'
 require 'smartdown/model/predicate/comparison/greater'
@@ -37,8 +39,33 @@ module Smartdown
         @data_module = data_module || {}
       end
 
-      #TODO: Horrible monkey patching, should try to submit a PR to parselet
-      #to allow modification of bindings?
+      # !!ALERT!! MONKEY PATCHING !!ALERT!!
+      #
+      # This call_on_match method is used for executing all the rule blocks you see
+      # below. The only variables that are in scope for these blocks  are the contents
+      # of bindings - which consists of information about bits of the AST that the rule
+      # matched.
+      #
+      # In the country rule: there is a need for accessing an external variable/method
+      # as the information required to create a country question object is defined in
+      # the data_module - so cannot be inferred purely from the syntax fed to parselet.
+      #
+      # There are 2 options we could have chosen, the first would be to have another
+      # transformation layer. We would create intermediate elements that were lacking
+      # information and then recreate them outside of parselet.
+      #
+      # A far simpler option is to manually modify the set of bindings available to
+      # rule blocks, so we can inject our information from the data_module. Unfortunately
+      # the only way to do this is to Monkey patch the call_on_match method to do the
+      # to injecting. The drawbacks of this are if the method changes its name or function
+      # in a newer parselet version; or possibly accidentally overriding some default
+      # bindings with methods from a data module.
+      #
+      # Ideally we would like a way of injecting information into bindings without this
+      # patch so we have submitted a PR to parselet describing this problem:
+      #
+      # https://github.com/kschiess/parslet/pull/119
+      #
       def call_on_match(bindings, block)
         bindings.merge! data_module
         super(bindings, block)
@@ -169,8 +196,16 @@ module Smartdown
         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(:and_operation => {first_predicate: subtree(:first_predicate), and_predicates: subtree(:and_predicates) }) {
+        Smartdown::Model::Predicate::AndOperation.new([first_predicate]+and_predicates)
+      }
+
+      rule(:or_operation => {first_predicate: subtree(:first_predicate), or_predicates: subtree(:or_predicates) }) {
+        Smartdown::Model::Predicate::OrOperation.new([first_predicate]+or_predicates)
+      }
+
+      rule(:not_operation => {predicate: subtree(:predicate)}) {
+        Smartdown::Model::Predicate::NotOperation.new(predicate)
       }
 
       rule(:function_argument => simple(:argument)) { argument.to_s }

data/lib/smartdown/parser/predicates.rb

@@ -4,9 +4,11 @@ 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("'")
+        (
+          identifier.as(:varname) >> some_space >>
+            str('is') >> some_space >>
+            str("'") >> match("[^']").repeat.as(:expected_value) >> str("'")
+        ).as(:equality_predicate)
       }
 
       rule(:comparison_operator) {
@@ -14,9 +16,9 @@ module Smartdown
       }
 
       rule(:comparison_predicate) {
-        identifier.as(:varname) >> some_space >>
+        (identifier.as(:varname) >> some_space >>
         comparison_operator.as(:operator) >> some_space >>
-        str("'") >> match("[^']").repeat.as(:value) >> str("'")
+        str("'") >> match("[^']").repeat.as(:value) >> str("'")).as(:comparison_predicate)
       }
 
       rule(:set_value) {
@@ -28,9 +30,11 @@ module Smartdown
       }
 
       rule(:set_membership_predicate) {
-        identifier.as(:varname) >> some_space >>
-          str('in') >> some_space >>
-          str("{") >> optional_space >> set_values.maybe.as(:values) >> optional_space >> str("}")
+        (
+          identifier.as(:varname) >> some_space >>
+            str('in') >> some_space >>
+            str("{") >> optional_space >> set_values.maybe.as(:values) >> optional_space >> str("}")
+        ).as(:set_membership_predicate)
       }
 
       rule(:named_predicate) {
@@ -42,18 +46,29 @@ module Smartdown
       }
 
       rule(:predicate) {
-        equality_predicate.as(:equality_predicate) |
-        set_membership_predicate.as(:set_membership_predicate) |
-        comparison_predicate.as(:comparison_predicate) |
-        function_predicate.as(:function_predicate) |
+        equality_predicate |
+        set_membership_predicate |
+        comparison_predicate |
+        function_predicate |
+        not_operation |
         otherwise_predicate |
         named_predicate
       }
 
-      rule (:combined_predicate) {
-        predicate.as(:first_predicate) >>
+      rule (:and_operation) {
+        (predicate.as(:first_predicate) >>
         (some_space >> str('AND') >> some_space >>
-        predicate).repeat(1).as(:and_predicates)
+         predicate).repeat(1).as(:and_predicates)).as(:and_operation)
+      }
+
+      rule (:or_operation) {
+        (predicate.as(:first_predicate) >>
+        (some_space >> str('OR') >> some_space >>
+         predicate).repeat(1).as(:or_predicates)).as(:or_operation)
+      }
+
+      rule (:not_operation) {
+        (str('NOT') >> some_space >> predicate.as(:predicate)).as(:not_operation)
       }
 
       rule(:function_arguments) {
@@ -61,14 +76,15 @@ module Smartdown
       }
 
       rule (:function_predicate) {
-        (identifier >> str('?').maybe).as(:name) >>
+        ((identifier >> str('?').maybe).as(:name) >>
         str('(') >>
         function_arguments.as(:arguments).maybe >>
-        str(')')
+        str(')')).as(:function_predicate)
       }
 
       rule (:predicates) {
-        combined_predicate.as(:combined_predicate) |
+        and_operation |
+        or_operation |
         predicate
       }
 

data/lib/smartdown/version.rb

@@ -1,3 +1,3 @@
 module Smartdown
-  VERSION = "0.10.0"
+  VERSION = "0.11.0"
 end

data/spec/model/predicates/{combined_spec.rb → and_operation_spec.rb}

@@ -1,9 +1,8 @@
-require 'smartdown/model/predicate/combined'
-require 'smartdown/model/predicate/combined'
+require 'smartdown/model/predicate/and_operation'
 require 'smartdown/model/predicate/named'
 require 'smartdown/engine/state'
 
-describe Smartdown::Model::Predicate::Combined do
+describe Smartdown::Model::Predicate::AndOperation do
   let(:predicate_1) { Smartdown::Model::Predicate::Named.new("my_pred?") }
   let(:predicate_2) { Smartdown::Model::Predicate::Named.new("my_other_pred?") }
   subject(:predicate) { described_class.new([predicate_1, predicate_2])}

data/spec/model/predicates/not_operation_spec.rb

@@ -0,0 +1,27 @@
+require 'smartdown/model/predicate/not_operation'
+require 'smartdown/model/predicate/named'
+require 'smartdown/engine/state'
+
+describe Smartdown::Model::Predicate::NotOperation do
+  subject(:negated_predicate) { described_class.new(inner_predicate) }
+  let(:inner_predicate_name) { "my_pred?" }
+  let(:inner_predicate) { Smartdown::Model::Predicate::Named.new inner_predicate_name }
+
+  describe "#evaluate" do
+    context "state has predicate definition" do
+      let(:state) {
+        Smartdown::Engine::State.new("current_node" => "n", "my_pred?" => true )
+      }
+
+      it "returns the negation of the inner predicate" do
+        expect(negated_predicate.evaluate(state)).to eq(false)
+      end
+    end
+  end
+
+  describe "#humanize" do
+    it "prepends the inner predicate's humanize with NOT" do
+      expect(negated_predicate.humanize).to eq("NOT my_pred?")
+    end
+  end
+end

data/spec/model/predicates/or_operation_spec.rb

@@ -0,0 +1,46 @@
+require 'smartdown/model/predicate/or_operation'
+require 'smartdown/model/predicate/named'
+require 'smartdown/engine/state'
+
+describe Smartdown::Model::Predicate::OrOperation do
+  let(:predicate_1) { Smartdown::Model::Predicate::Named.new("my_pred?") }
+  let(:predicate_2) { Smartdown::Model::Predicate::Named.new("my_other_pred?") }
+  subject(:predicate) { described_class.new([predicate_1, predicate_2])}
+
+  describe "#evaluate" do
+
+    context "both states are true" do
+      let(:state) {
+        Smartdown::Engine::State.new("current_node" => "n", "my_pred?" => true, "my_other_pred?" => true )
+      }
+
+      it "evaluates as true" do
+        expect(predicate.evaluate(state)).to eq(true)
+      end
+    end
+
+    context "both states are false" do
+      let(:state) {
+        Smartdown::Engine::State.new("current_node" => "n", "my_pred?" => false, "my_other_pred?" => false )
+      }
+
+      it "evaluates as false" do
+        expect(predicate.evaluate(state)).to eq(false)
+      end
+    end
+
+    context "one of the states is false" do
+      let(:state) {
+        Smartdown::Engine::State.new("current_node" => "n", "my_pred?" => true, "my_other_pred?" => false )
+      }
+
+      it "evaluates as true" do
+        expect(predicate.evaluate(state)).to eq(true)
+      end
+    end
+  end
+
+  describe "#humanize" do
+    it { expect(predicate.humanize).to eq("(my_pred? OR my_other_pred?)") }
+  end
+end

data/spec/parser/base_spec.rb

@@ -6,9 +6,9 @@ describe Smartdown::Parser::Base do
 
   describe "#ws" do
     subject { parser.ws }
-    it { should parse("\n") }
     it { should parse(" ") }
     it { should parse("   ") }
+    it { should parse("  ") }
   end
 
   describe "#eof" do

data/spec/parser/element/conditional_spec.rb

@@ -329,5 +329,69 @@ SOURCE
 
     end
   end
+
+  context "Nested IF statement" do
+    let(:source) { <<-SOURCE
+$IF pred1?
+
+#{first_true_body}
+
+$IF pred2?
+
+#{both_true_body}
+
+$ENDIF
+
+#{first_true_body}
+
+$ENDIF
+SOURCE
+}
+    context "With a body for double true case" do
+      let(:first_true_body) { "Text if first predicates is true" }
+      let(:both_true_body) { "Text if both predicates are true" }
+      it { should parse(source).as(
+           conditional: {
+             predicate: {named_predicate: "pred1?"},
+             true_case: [
+               {p: "#{first_true_body}\n"},
+               {conditional: {
+                 predicate: {named_predicate: "pred2?"},
+                 true_case: [{p: "#{both_true_body}\n"}],
+               }},
+               {p: "#{first_true_body}\n"}
+             ]
+           }
+        )
+      }
+    end
+  end
+
+  context "with custom markdown tags inside" do
+
+    let (:source) { <<-SOURCE
+$IF pred?
+
+#{true_body.chomp}
+
+$ENDIF
+SOURCE
+}
+    let(:true_body) { <<-TAG
+$E
+Bit of content in lovely custom tag
+$E
+TAG
+}
+
+    it { should parse(source).as(
+         conditional: {
+           predicate: {named_predicate: "pred?"},
+            true_case: [
+              {p: "#{true_body}"}
+           ]},
+        )
+      }
+  end
 end
 

data/spec/parser/node_parser_spec.rb

@@ -194,4 +194,23 @@ SOURCE
     }
   end
 
+  context "blank line with a tab on it" do
+
+    let(:source) {
+<<SOURCE
+# Lovely title
+	 
+line of content
+SOURCE
+}
+
+    it "doesn't blow up" do
+      should parse(source).as({
+        body: [
+          { h1: "Lovely title" },
+          { p: "line of content\n" },
+        ]
+      })
+    end
+  end
 end

data/spec/parser/predicates_spec.rb

@@ -2,9 +2,9 @@ require 'smartdown/parser/predicates'
 require 'smartdown/parser/node_interpreter'
 
 describe Smartdown::Parser::Predicates do
+  subject(:parser) { described_class.new }
 
   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"}) }
@@ -24,7 +24,6 @@ describe Smartdown::Parser::Predicates do
   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"}]}) }
@@ -45,8 +44,6 @@ describe Smartdown::Parser::Predicates do
   end
 
   describe "named predicate" do
-    subject(:parser) { described_class.new }
-
     it { should parse("my_pred?").as(named_predicate: "my_pred?") }
     it { should_not parse("my_pred") }
     it { should_not parse("my pred") }
@@ -63,8 +60,6 @@ describe Smartdown::Parser::Predicates do
   end
 
   describe "otherwise predicate" do
-    subject(:parser) { described_class.new }
-
     it { should parse("otherwise").as(otherwise_predicate: "otherwise") }
     it { should_not parse("other") }
 
@@ -80,10 +75,9 @@ describe Smartdown::Parser::Predicates do
   end
 
   describe "predicate AND predicate" do
-    subject(:parser) { described_class.new }
 
     it { should parse("my_pred() AND my_other_pred?").as(
-      { combined_predicate: {
+      { and_operation: {
         first_predicate: { function_predicate: { name: "my_pred" } },
         and_predicates:
           [
@@ -92,7 +86,7 @@ describe Smartdown::Parser::Predicates do
       } }
     ) }
     it { should parse("my_pred? AND my_other_pred? AND varname in {a b c}").as(
-      { combined_predicate: {
+      { and_operation: {
         first_predicate: { named_predicate: "my_pred?" },
         and_predicates:
           [
@@ -104,6 +98,7 @@ describe Smartdown::Parser::Predicates do
       } }
     ) }
     it { should_not parse("my_pred AND ") }
+    it { should_not parse("my_pred AND my_other_pred OR special_pred") }
 
     describe "transformed" do
       let(:node_name) { "my_node" }
@@ -112,7 +107,7 @@ describe Smartdown::Parser::Predicates do
         Smartdown::Parser::NodeInterpreter.new(node_name, source, parser: parser).interpret
       }
 
-      it { should eq(Smartdown::Model::Predicate::Combined.new(
+      it { should eq(Smartdown::Model::Predicate::AndOperation.new(
         [
           Smartdown::Model::Predicate::Function.new("my_pred", []),
           Smartdown::Model::Predicate::Named.new("my_other_pred?")
@@ -121,8 +116,84 @@ describe Smartdown::Parser::Predicates do
     end
   end
 
+  describe "predicate OR predicate" do
+    it {should parse("my_pred() OR my_other_pred?").as(
+      { or_operation: {
+        first_predicate: { function_predicate: { name: "my_pred" } },
+        or_predicates:
+          [
+            {named_predicate: "my_other_pred?"},
+          ]
+      } }
+    ) }
+    it { should parse("my_pred? OR my_other_pred? OR varname in {a b c}").as(
+      { or_operation: {
+        first_predicate: { named_predicate: "my_pred?" },
+        or_predicates:
+          [
+            {named_predicate: "my_other_pred?"},
+            {set_membership_predicate:
+              {varname: "varname", values: [{set_value: "a"}, {set_value: "b"}, {set_value: "c"}]}
+            }
+          ]
+      } }
+    ) }
+    it { should_not parse("my_pred OR ") }
+    it { should_not parse("my_pred OR my_other_pred AND special_pred") }
+
+    describe "transformed" do
+      let(:node_name) { "my_node" }
+      let(:source) { "my_pred() OR my_other_pred?" }
+      subject(:transformed) {
+        Smartdown::Parser::NodeInterpreter.new(node_name, source, parser: parser).interpret
+      }
+
+      it { should eq(Smartdown::Model::Predicate::OrOperation.new(
+        [
+          Smartdown::Model::Predicate::Function.new("my_pred", []),
+          Smartdown::Model::Predicate::Named.new("my_other_pred?")
+      ]
+      )) }
+    end
+
+  end
+
+  describe "NOT predicate" do
+    it { should parse("NOT my_pred?").as(
+      { not_operation: {
+        predicate: { named_predicate: "my_pred?" }
+        } }
+    ) }
+
+    it { should parse("NOT my_pred? AND my_other_pred?").as (
+      { and_operation:
+        {
+          first_predicate:
+            {
+              not_operation: { predicate: { named_predicate: 'my_pred?' } }
+            },
+          and_predicates:
+            [
+              {  named_predicate: 'my_other_pred?' }
+            ]
+        }
+      }
+    )}
+
+    describe "transformed" do
+      let(:node_name) { "my_node" }
+      let(:source) { "NOT my_pred?" }
+      subject(:transformed) {
+        Smartdown::Parser::NodeInterpreter.new(node_name, source, parser: parser).interpret
+      }
+
+      it { should eq(Smartdown::Model::Predicate::NotOperation.new(
+          Smartdown::Model::Predicate::Named.new("my_pred?"),
+      )) }
+    end
+  end
+
   describe "function predicate" do
-    subject(:parser) { described_class.new }
 
     context "no arguments" do
       let(:source) { "function_name()" }
@@ -202,7 +273,6 @@ describe Smartdown::Parser::Predicates do
   end
 
   describe "comparison predicate" do
-    subject(:parser) { described_class.new }
     let(:greater_equal_source) { "varname >= 'value'" }
     let(:greater_source) { "varname > 'value'" }
     let(:less_equal_source) { "varname <= 'value'" }

data/spec/support/model_builder.rb

@@ -13,7 +13,7 @@ require 'smartdown/model/rule'
 require 'smartdown/model/predicate/named'
 require 'smartdown/model/predicate/equality'
 require 'smartdown/model/predicate/set_membership'
-require 'smartdown/model/predicate/combined'
+require 'smartdown/model/predicate/and_operation'
 require 'smartdown/model/predicate/comparison/greater_or_equal'
 require 'smartdown/model/predicate/comparison/less_or_equal'
 require 'smartdown/model/predicate/comparison/greater'

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: smartdown
 version: !ruby/object:Gem::Version
-  version: 0.10.0
+  version: 0.11.0
   prerelease: 
 platform: ruby
 authors:
@@ -13,7 +13,7 @@ date: 2014-07-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: parslet
-  requirement: &18204100 !ruby/object:Gem::Requirement
+  requirement: &8759180 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -21,10 +21,10 @@ dependencies:
         version: 1.6.1
   type: :runtime
   prerelease: false
-  version_requirements: *18204100
+  version_requirements: *8759180
 - !ruby/object:Gem::Dependency
   name: rspec
-  requirement: &18232520 !ruby/object:Gem::Requirement
+  requirement: &8758660 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -32,10 +32,10 @@ dependencies:
         version: 3.0.0
   type: :development
   prerelease: false
-  version_requirements: *18232520
+  version_requirements: *8758660
 - !ruby/object:Gem::Dependency
   name: rake
-  requirement: &18231800 !ruby/object:Gem::Requirement
+  requirement: &8758220 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -43,10 +43,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *18231800
+  version_requirements: *8758220
 - !ruby/object:Gem::Dependency
   name: gem_publisher
-  requirement: &18230980 !ruby/object:Gem::Requirement
+  requirement: &8757720 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -54,10 +54,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *18230980
+  version_requirements: *8757720
 - !ruby/object:Gem::Dependency
   name: timecop
-  requirement: &18230000 !ruby/object:Gem::Requirement
+  requirement: &8757300 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -65,7 +65,7 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *18230000
+  version_requirements: *8757300
 description: 
 email: david.heath@digital.cabinet-office.gov.uk
 executables:
@@ -127,6 +127,7 @@ files:
 - lib/smartdown/model/flow.rb
 - lib/smartdown/model/predicate/named.rb
 - lib/smartdown/model/predicate/set_membership.rb
+- lib/smartdown/model/predicate/and_operation.rb
 - lib/smartdown/model/predicate/function.rb
 - lib/smartdown/model/predicate/equality.rb
 - lib/smartdown/model/predicate/comparison/less_or_equal.rb
@@ -134,8 +135,9 @@ files:
 - lib/smartdown/model/predicate/comparison/base.rb
 - lib/smartdown/model/predicate/comparison/greater.rb
 - lib/smartdown/model/predicate/comparison/less.rb
-- lib/smartdown/model/predicate/combined.rb
+- lib/smartdown/model/predicate/not_operation.rb
 - lib/smartdown/model/predicate/otherwise.rb
+- lib/smartdown/model/predicate/or_operation.rb
 - lib/smartdown/model/node.rb
 - lib/smartdown/model/front_matter.rb
 - lib/smartdown/model/answer/date.rb
@@ -243,11 +245,13 @@ files:
 - spec/model/answer/salary_spec.rb
 - spec/model/answer/date_spec.rb
 - spec/model/answer/country_spec.rb
+- spec/model/predicates/not_operation_spec.rb
 - spec/model/predicates/set_membership_spec.rb
-- spec/model/predicates/combined_spec.rb
+- spec/model/predicates/or_operation_spec.rb
 - spec/model/predicates/comparison_spec.rb
 - spec/model/predicates/equality_spec.rb
 - spec/model/predicates/named_spec.rb
+- spec/model/predicates/and_operation_spec.rb
 - spec/model/predicates/function_spec.rb
 homepage: https://github.com/alphagov/smartdown
 licenses:
@@ -264,7 +268,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: 508907290184423365
+      hash: -3164786129793908873
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
@@ -273,7 +277,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: 508907290184423365
+      hash: -3164786129793908873
 requirements: []
 rubyforge_project: 
 rubygems_version: 1.8.11
@@ -363,9 +367,11 @@ test_files:
 - spec/model/answer/salary_spec.rb
 - spec/model/answer/date_spec.rb
 - spec/model/answer/country_spec.rb
+- spec/model/predicates/not_operation_spec.rb
 - spec/model/predicates/set_membership_spec.rb
-- spec/model/predicates/combined_spec.rb
+- spec/model/predicates/or_operation_spec.rb
 - spec/model/predicates/comparison_spec.rb
 - spec/model/predicates/equality_spec.rb
 - spec/model/predicates/named_spec.rb
+- spec/model/predicates/and_operation_spec.rb
 - spec/model/predicates/function_spec.rb