cml 1.4.2 → 1.5.0

data/spec/logic_spec.rb

@@ -0,0 +1,207 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe "CML logic" do
+  describe "properties" do
+    describe "with no logic" do
+      before :each do
+        @cml = File.read( File.dirname(__FILE__) + "/fixtures/logic_none.cml" )
+        @p = Parser.new( @cml )
+      end
+      
+      it "is not nested" do
+        @p.logic_tree.max_depth.should == 1
+        @p.has_nested_logic?.should be_false
+      end
+      
+      it "is not grouped" do
+        @p.has_grouped_logic?.should be_false
+      end
+    end
+    
+    describe "without nested logic" do
+      before :each do
+        @cml = File.read( File.dirname(__FILE__) + "/fixtures/logic_not_nested.cml" )
+        @p = Parser.new( @cml )
+      end
+      
+      it "is not nested" do
+        @p.logic_tree.max_depth.should == 2
+        @p.has_nested_logic?.should be_false
+      end
+      
+      it "is grouped" do
+        @p.has_grouped_logic?.should be_true
+      end
+    end
+    
+    describe "with nested logic" do
+      before :each do
+        @cml = File.read( File.dirname(__FILE__) + "/fixtures/logic_nested.cml" )
+        @p = Parser.new( @cml )
+      end
+      
+      it "is nested" do
+        @p.logic_tree.max_depth.should == 4
+        @p.has_nested_logic?.should be_true
+      end
+      
+      it "is not grouped" do
+        @p.has_grouped_logic?.should be_false
+      end
+    end
+    
+    describe "with circular logic safety" do
+      before :each do
+        @cml = File.read( File.dirname(__FILE__) + "/fixtures/logic_circular.cml" )
+        @p = Parser.new( @cml )
+      end
+      
+      it "is nested" do
+        @p.logic_tree.max_depth.should == 10
+        @p.has_nested_logic?.should be_true
+      end
+      
+      it "is not grouped" do
+        @p.has_grouped_logic?.should be_false
+      end
+    end
+    
+    describe "with broken logic safety" do
+      before :each do
+        @cml = File.read( File.dirname(__FILE__) + "/fixtures/logic_broken.cml" )
+        @p = Parser.new( @cml )
+      end
+      
+      it "is not nested" do
+        @p.logic_tree.max_depth.should == 1
+        @p.has_nested_logic?.should be_false
+      end
+      
+      it "is not grouped" do
+        @p.has_grouped_logic?.should be_false
+      end
+    end
+    
+    describe "with grouped logic" do
+      before :each do
+        @cml = File.read( File.dirname(__FILE__) + "/fixtures/logic_grouped.cml" )
+        @p = Parser.new( @cml )
+      end
+      
+      it "is nested" do
+        @p.logic_tree.max_depth.should == 4
+        @p.has_nested_logic?.should be_true
+      end
+      
+      it "is grouped" do
+        @p.has_grouped_logic?.should be_true
+      end
+    end
+  end
+  
+  describe "parsing" do
+    
+    describe "maps tokens and their combinators" do
+      
+      it "without boolean logic" do
+        parsed = CML::TagLogic.parse_expression("omg:[crispy]")
+        parsed.should == [
+          ["", "omg:[crispy]"]]
+      end
+      
+      it "with grouping and 'and' precedence logic" do
+        parsed = CML::TagLogic.parse_expression("omg:[crispy]||(w_t_f:[rtfm]++f_t_w:[rtfm])||!w_t_f:rtfm")
+        parsed.should == [
+          ["", "omg:[crispy]"],
+          ["||", [
+            ["", [
+              ["", "w_t_f:[rtfm]"], ["++", "f_t_w:[rtfm]"]]]]],
+          ["||", "!w_t_f:rtfm"]]
+      end
+      
+      it "with grouping logic between 'or'" do
+        parsed = CML::TagLogic.parse_expression("omg:[crispy]||(w_t_f:[rtfm]||f_t_w:[rtfm])||!w_t_f:rtfm")
+        parsed.should == [
+          ["", "omg:[crispy]"],
+          ["||", [
+            ["", "w_t_f:[rtfm]"], ["||", "f_t_w:[rtfm]"]]],
+          ["||", "!w_t_f:rtfm"]]
+      end
+      
+      it "with grouping logic between 'and'" do
+        pending "Will work with proper combinator support"
+        parsed = CML::TagLogic.parse_expression("omg:[crispy]||w_t_f:[rtfm]++(f_t_w:[rtfm]||!w_t_f:rtfm)")
+        parsed.should == [
+          ["", "omg:[crispy]"],
+          ["++", [
+            ["", "w_t_f:[rtfm]"], 
+            ["||", [
+              ["", "f_t_w:[rtfm]"],
+              ["||", "!w_t_f:rtfm"]]]
+            ]
+          ]
+        ]
+      end
+      
+      it "with 'and' precedence logic" do
+        parsed = CML::TagLogic.parse_expression("omg:[crispy]||w_t_f:[rtfm]++f_t_w:[rtfm]||!w_t_f:rtfm")
+        parsed.should == [
+          ["", "omg:[crispy]"],
+          ["||", [
+            ["", "w_t_f:[rtfm]"], ["++", "f_t_w:[rtfm]"]]],
+          ["||", "!w_t_f:rtfm"]]
+      end
+      
+    end
+    
+    describe "resolves combinators" do
+      
+      def test_rez(exp)
+        parsed = CML::TagLogic.parse_expression(exp)
+        combinators = []
+        parsed.each_with_index do |p,i| 
+          if Array===p[1]
+            p[1].each_with_index do |pp,ii| 
+              combinators << CML::TagLogic.resolve_combinator(p[1], ii)
+            end
+          else
+            combinators << CML::TagLogic.resolve_combinator(parsed, i)
+          end
+        end
+        combinators
+      end
+      
+      it "without boolean logic" do
+        combinators = test_rez("omg:[crispy]")
+        combinators.should == ["||"]
+      end
+      
+      it "for an 'and' phrase" do
+        combinators = test_rez("omg:[crispy]++!w_t_f:rtfm")
+        combinators.should == ["&&", "&&"]
+      end
+      
+      it "for an 'or' phrase" do
+        combinators = test_rez("omg:[crispy]||!w_t_f:rtfm")
+        combinators.should == ["||", "||"]
+      end
+      
+      it "with grouping logic between 'or'" do
+        combinators = test_rez("omg:[crispy]||(w_t_f:[rtfm]||f_t_w:[rtfm])||!w_t_f:rtfm")
+        combinators.should == ["||", "||", "||", "||"]
+      end
+      
+      it "with grouping logic between 'and'" do
+        pending "A tough nut to crack :'( "
+        combinators = test_rez("omg:[crispy]||w_t_f:[rtfm]++(f_t_w:[rtfm]||!w_t_f:rtfm)")
+        combinators.should == ["||", "&&", "&&", "||"]
+      end
+      
+      it "with 'and' precedence logic" do
+        combinators = test_rez("omg:[crispy]||w_t_f:[rtfm]++f_t_w:[rtfm]||!w_t_f:rtfm")
+        combinators.should == ["||", "&&", "&&", "||"]
+      end
+    
+    end
+  end
+end

data/spec/logic_tree_graph_spec.rb

@@ -0,0 +1,465 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe "CML logic tree graph" do
+
+  it "generates for a simple only-if selector" do
+    @p = Parser.new(<<-HTML)
+      <cml:text label="OMG" />
+      <cml:checkboxes label="w t f" only-if="omg">
+        <cml:checkbox label="lol" />
+        <cml:checkbox label="rtfm" />
+      </cml:checkboxes>
+    HTML
+
+    graph = @p.logic_tree.graph
+    graph.should == {
+      "omg"=>{:outbound_count=>1, :outbound_names=>["w_t_f"]},
+      "w_t_f"=>{:inbound_count=>1, :inbound_names=>["omg"], :inbound_matches=>{"||" => [{"omg"=>[{:match_key => nil, :is_not=>true}]}]}}
+    }
+  end
+
+  it "generates for an only-if 'not' selector" do
+    @p = Parser.new(<<-HTML)
+      <cml:text label="OMG" />
+      <cml:checkboxes label="w t f" only-if="!omg">
+        <cml:checkbox label="lol" />
+        <cml:checkbox label="rtfm" />
+      </cml:checkboxes>
+    HTML
+
+    graph = @p.logic_tree.graph
+    graph.should == {
+      "omg"=>{:outbound_count=>1, :outbound_names=>["w_t_f"]},
+      "w_t_f"=>{:inbound_count=>1, :inbound_names=>["omg"], :inbound_matches=>{"||" => [{"omg"=>[{:match_key => nil, :is_not=>false}]}]}}
+    }
+  end
+
+  it "generates for an only-if 'unchecked' selector for checkboxes" do
+    @p = Parser.new(<<-HTML)
+      <cml:checkboxes label="w t f">
+        <cml:checkbox label="lol" />
+        <cml:checkbox label="rtfm" />
+      </cml:checkboxes>
+      <cml:text label="OMG" only-if="w_t_f:unchecked" />
+    HTML
+
+    graph = @p.logic_tree.graph
+    graph.should == {
+      "w_t_f"=>{:outbound_count=>1, :outbound_names=>["omg"]},
+      "omg"=>{:inbound_count=>1, :inbound_names=>["w_t_f"], :inbound_matches=>{"||" => [{"w_t_f"=>[{:match_key => 'lol', :is_not=>true}, {:match_key => 'rtfm', :is_not=>true}]}]}}
+    }
+  end
+
+  it "generates for an only-if 'unchecked' selector for one checkbox" do
+    @p = Parser.new(<<-HTML)
+      <cml:checkbox label="w t f">
+      <cml:text label="OMG" only-if="w_t_f:unchecked" />
+    HTML
+
+    graph = @p.logic_tree.graph
+    graph.should == {
+      "w_t_f"=>{:outbound_count=>1, :outbound_names=>["omg"]},
+      "omg"=>{:inbound_count=>1, :inbound_names=>["w_t_f"], :inbound_matches=>{"||" => [{"w_t_f"=>[{:match_key => "true", :is_not=>true}]}]}}
+    }
+  end
+
+  it "generates for complex only-if 'and' selectors" do
+    @p = Parser.new(<<-HTML)
+      <cml:text label="OMG" />
+      <cml:checkboxes label="w t f" only-if="omg">
+        <cml:checkbox label="lol" />
+        <cml:checkbox label="rtfm" />
+      </cml:checkboxes>
+      <cml:radios label="bacon" only-if="omg:[crispy]++w_t_f:[lol]">
+        <cml:radio label="tasty" />
+        <cml:radio label="too meaty" />
+      </cml:radios>
+    HTML
+
+    graph = @p.logic_tree.graph
+    graph.should == {
+      "omg"=>{:outbound_names=>["bacon", "w_t_f"], :outbound_count=>2},
+      "w_t_f"=>{:inbound_count=>1, :inbound_names=>["omg"], :inbound_matches=>{
+        "||"=>[{
+          "omg"=>[{:is_not=>true, :match_key=>nil}]}]}, :outbound_names=>["bacon"], :outbound_count=>1},
+      "bacon"=>{:inbound_count=>2, :inbound_names=>["omg", "w_t_f"], :inbound_matches=>{
+        "||" => [{
+          "&&" => [
+            {"omg"=>[{:is_not=>false, :match_key=>"crispy"}]},
+            {"w_t_f"=>[{:is_not=>false, :match_key=>"lol"}]}
+          ]
+        }]
+      }}
+    }
+  end
+
+  it "generates for complex only-if 'or' selectors" do
+    @p = Parser.new(<<-HTML)
+      <cml:text label="OMG" />
+      <cml:checkboxes label="w t f" only-if="omg">
+        <cml:checkbox label="lol" />
+        <cml:checkbox label="rtfm" />
+      </cml:checkboxes>
+      <cml:radios label="bacon" only-if="omg:[crispy]||!w_t_f:[lol]">
+        <cml:radio label="tasty" />
+        <cml:radio label="too meaty" />
+      </cml:radios>
+    HTML
+
+    graph = @p.logic_tree.graph
+    expected = {
+      "omg"=>{:outbound_names=>["bacon", "w_t_f"], :outbound_count=>2},
+      "w_t_f"=>{:inbound_count=>1, :inbound_names=>["omg"], :inbound_matches=>{"||" => [{"omg"=>[{:is_not=>true, :match_key => nil}]}]},
+        :outbound_count=>1, :outbound_names=>["bacon"]},
+      "bacon"=>{:inbound_count=>2, :inbound_names=>["omg", "w_t_f"], :inbound_matches=>{
+        "||" => [
+          {"omg"=>[{:is_not=>false, :match_key => "crispy"}]},
+          {"w_t_f"=>[{:is_not=>true, :match_key => "lol"}]}
+        ]
+      }}
+    }
+    graph.should == expected
+  end
+
+  it "generates with 'and' precedence" do
+    @p = Parser.new(<<-HTML)
+      <cml:text label="OMG" />
+      <cml:checkboxes label="w t f" only-if="omg">
+        <cml:checkbox label="lol" />
+        <cml:checkbox label="rtfm" />
+      </cml:checkboxes>
+      <cml:checkboxes label="f t w" only-if="omg">
+        <cml:checkbox label="lmao" />
+        <cml:checkbox label="rtfm" />
+      </cml:checkboxes>
+      <cml:radios label="bacon" only-if="omg:[crispy]||w_t_f:[rtfm]++f_t_w:[rtfm]">
+        <cml:radio label="tasty" />
+        <cml:radio label="too meaty" />
+      </cml:radios>
+    HTML
+
+    graph = @p.logic_tree.graph
+    graph.should == {
+      "omg"=>{:outbound_count=>3, :outbound_names=>["bacon", "f_t_w", "w_t_f"]},
+      "w_t_f"=>{:inbound_count=>1, :inbound_names=>["omg"], :inbound_matches=>{"||" => [{"omg"=>[{:match_key => nil, :is_not=>true}]}]},
+        :outbound_count=>1, :outbound_names=>["bacon"]},
+      "f_t_w"=>{:inbound_count=>1, :inbound_names=>["omg"], :inbound_matches=>{"||" => [{"omg"=>[{:match_key => nil, :is_not=>true}]}]},
+        :outbound_count=>1, :outbound_names=>["bacon"]},
+      "bacon"=>{:inbound_count=>3, :inbound_names=>["omg", "w_t_f", "f_t_w"],
+        :inbound_matches=>{
+          "||" => [
+            {"omg"=>[{:match_key => "crispy", :is_not=>false}]},
+            {"&&"=>[
+              {"w_t_f"=>[{:match_key => "rtfm", :is_not=>false}]},
+              {"f_t_w"=>[{:match_key => 'rtfm', :is_not=>false}]}
+            ]}
+          ]
+        }
+      }
+    }
+    @p.logic_tree.nodes.collect {|k,v|
+      v.tag.errors && v.tag.errors.each {|err|
+        err.should =~ /^Tag logic is not accurate when only-if contains a group/ }}
+  end
+
+  it "lists complex nested only-if 'or' selectors" do
+    @p = Parser.new(<<-HTML)
+      <cml:text label="OMG" />
+      <cml:checkboxes label="w t f" only-if="omg">
+        <cml:checkbox label="lol" />
+        <cml:checkbox label="rtfm" />
+      </cml:checkboxes>
+      <cml:checkboxes label="f t w" only-if="omg">
+        <cml:checkbox label="lmao" />
+        <cml:checkbox label="rtfm" />
+      </cml:checkboxes>
+      <cml:radios label="bacon" only-if="omg:[crispy]||(w_t_f:[rtfm]++f_t_w:[rtfm]||f_t_w:[lmao])">
+        <cml:radio label="tasty" />
+        <cml:radio label="too meaty" />
+      </cml:radios>
+    HTML
+
+    graph = @p.logic_tree.graph
+    graph.should == {
+      "omg"=>{:outbound_count=>3, :outbound_names=>["bacon", "f_t_w", "w_t_f"]},
+      "w_t_f"=>{:inbound_count=>1, :inbound_names=>["omg"], :inbound_matches=>{"||" => [{"omg"=>[{:match_key => nil, :is_not=>true}]}]},
+        :outbound_count=>1, :outbound_names=>["bacon"]},
+      "f_t_w"=>{:inbound_count=>1, :inbound_names=>["omg"], :inbound_matches=>{"||" => [{"omg"=>[{:match_key => nil, :is_not=>true}]}]},
+        :outbound_count=>1, :outbound_names=>["bacon"]},
+      "bacon"=>{:inbound_count=>3, :inbound_names=>["omg", "w_t_f", "f_t_w"],
+        :inbound_matches=>{
+          "||" => [
+            {"omg"=>[{:match_key => "crispy", :is_not=>false}]},
+            {"||"=> [
+              {"&&"=>[
+                {"w_t_f"=>[{:match_key => "rtfm", :is_not=>false}]},
+                {"f_t_w"=>[{:match_key => 'rtfm', :is_not=>false}]}
+              ]},
+              {"f_t_w"=>[{:match_key => "lmao", :is_not=>false}]}
+            ]}
+          ]
+        }
+      }
+    }
+    @p.logic_tree.nodes.collect {|k,v|
+      v.tag.errors && v.tag.errors.each {|err|
+        err.should =~ /^Tag logic is not accurate when only-if contains a group/ }}
+  end
+
+  it "lists complex nested only-if 'and' selectors" do
+    @p = Parser.new(<<-HTML)
+      <cml:text label="OMG" />
+      <cml:checkboxes label="w t f" only-if="omg">
+        <cml:checkbox label="lol" />
+        <cml:checkbox label="rtfm" />
+      </cml:checkboxes>
+      <cml:checkboxes label="f t w" only-if="omg">
+        <cml:checkbox label="lmao" />
+        <cml:checkbox label="rtfm" />
+      </cml:checkboxes>
+      <cml:radios label="bacon" only-if="omg:[crispy]++(w_t_f:[rtfm]++f_t_w:[rtfm]||f_t_w:[lmao])">
+        <cml:radio label="tasty" />
+        <cml:radio label="too meaty" />
+      </cml:radios>
+    HTML
+
+    graph = @p.logic_tree.graph
+    graph.should == {
+      "omg"=>{:outbound_count=>3, :outbound_names=>["bacon", "f_t_w", "w_t_f"]},
+      "w_t_f"=>{:inbound_count=>1, :inbound_names=>["omg"], :inbound_matches=>{"||" => [{"omg"=>[{:match_key => nil, :is_not=>true}]}]},
+        :outbound_count=>1, :outbound_names=>["bacon"]},
+      "f_t_w"=>{:inbound_count=>1, :inbound_names=>["omg"], :inbound_matches=>{"||" => [{"omg"=>[{:match_key => nil, :is_not=>true}]}]},
+        :outbound_count=>1, :outbound_names=>["bacon"]},
+      "bacon"=>{:inbound_count=>3, :inbound_names=>["omg", "w_t_f", "f_t_w"],
+        :inbound_matches=>{
+          "&&" => [
+            {"omg"=>[{:match_key => "crispy", :is_not=>false}]},
+            {"||"=> [
+              {"&&"=>[
+                {"w_t_f"=>[{:match_key => "rtfm", :is_not=>false}]},
+                {"f_t_w"=>[{:match_key => 'rtfm', :is_not=>false}]}
+              ]},
+              {"f_t_w"=>[{:match_key => "lmao", :is_not=>false}]}
+            ]}
+          ]
+        }
+      }
+    }
+    @p.logic_tree.nodes.collect {|k,v|
+      v.tag.errors && v.tag.errors.each {|err|
+        err.should =~ /^Tag logic is not accurate when only-if contains a group/ }}
+  end
+
+  it "is aware of only-if group" do
+    @p = Parser.new(<<-HTML)
+      <cml:text label="OMG" />
+      <cml:group only-if="omg">
+        <cml:checkboxes label="w t f">
+          <cml:checkbox label="lol" />
+          <cml:checkbox label="rtfm" />
+        </cml:checkboxes>
+        <cml:radios label="bacon">
+          <cml:radio label="tasty" />
+          <cml:radio label="too meaty" />
+        </cml:radios>
+      </cml:group>
+    HTML
+
+    graph = @p.logic_tree.graph
+    graph.should == {
+      "omg"=>{:outbound_count=>2, :outbound_names=>["bacon", "w_t_f"]},
+      "w_t_f"=>{:inbound_count=>1, :inbound_names=>["omg"], :inbound_matches=>{"||" => [{"omg"=>[{:match_key=>nil, :is_not=>true}]}]}},
+      "bacon"=>{:inbound_count=>1, :inbound_names=>["omg"], :inbound_matches=>{"||" => [{"omg"=>[{:match_key=>nil, :is_not=>true}]}]}}
+    }
+  end
+
+  it "is aware of nested only-if group" do
+    @p = Parser.new(<<-HTML)
+      <cml:text label="OMG" />
+      <cml:group only-if="omg">
+        <cml:checkboxes label="w t f">
+          <cml:checkbox label="lol" />
+          <cml:checkbox label="rtfm" />
+        </cml:checkboxes>
+        <cml:group only-if="!w_t_f:[rtfm]">
+          <cml:radios label="bacon">
+            <cml:radio label="tasty" />
+            <cml:radio label="too meaty" />
+          </cml:radios>
+        </cml:group>
+      </cml:group>
+    HTML
+
+    graph = @p.logic_tree.graph
+    graph.should == {
+      "omg"=>{:outbound_count=>2, :outbound_names=>["bacon", "w_t_f"]},
+      "w_t_f"=>{:inbound_count=>1, :inbound_names=>["omg"], :inbound_matches=>{"||" => [{"omg"=>[{:match_key=>nil, :is_not=>true}]}]},
+        :outbound_count=>1, :outbound_names=>["bacon"]},
+      "bacon"=>{:inbound_count=>2, :inbound_names=>["omg", "w_t_f"], :inbound_matches=>{
+        "||" => [
+          {"omg"=>[{:match_key=>nil, :is_not=>true}]},
+          {"w_t_f"=>[{:match_key=>"rtfm", :is_not=>true}]}
+        ]
+      }}
+    }
+  end
+
+  it "handles inter-dependent logic" do
+    @p = Parser.new(<<-HTML)
+      <cml:group only-if="details_unavailable:unchecked">
+
+        <cml:radios name="local" label="Is this a 'Local' or 'National' deal?" validates="required" gold="true">
+        <cml:radio value="local" label="LOCAL: The business or activity is only local" duplicate="true"></cml:radio>
+        <cml:radio value="local" label="LOCAL: The product is specific to a city or region (e.g. a local magazine or a product with shipping restrictions)" duplicate="true"></cml:radio>
+          <cml:radio value="local" label="LOCAL: This travel or hotel deal appeals to people in a particular city only (e.g. a ONE-NIGHT stay in a hotel room or bed and breakfast at a non-tourist destination)" duplicate="true"></cml:radio>
+        <cml:radio value="national" label="NATIONAL: This deal appeals to anyone in the country, and has NO regional shipping restrictions" duplicate="true"></cml:radio>
+          <cml:radio value="national" label="NATIONAL: This travel or hotel deal appeals to anyone in the country (e.g. A MULTI-NIGHT stay in a tourist destination such as Las Vegas, Miami, or another country.)" duplicate="true"></cml:radio>
+      </cml:radios>
+
+        <cml:group only-if="local:[0]||local:[1]||local:[2]">
+
+      <cml:radios name="location" label="Does the consumer have to leave their home?"  validates="required" gold="true">
+        <cml:radio value="location_important" label="YES: There is one (or few) specific locations."></cml:radio>
+        <cml:radio value="location_unimportant" label="NO: This deal is redeemed from home or delivered to the home" duplicate="true"></cml:radio>
+      </cml:radios>
+
+      <cml:taxonomy label="Please select the best LOCAL deal category or categories (you may select more than one if multiple are great fits):" validates="required" multi-select="true" instructions="Any category that you have selected will appear here.  Click the blue 'x' to unselect a category." strict="true" aggregation="cagg_0.4" name="local_category"  log-search="true"></cml:taxonomy>
+
+      </cml:group>
+
+      <cml:group only-if="local:[3]||local:[4]">
+
+          <cml:taxonomy label="Please select the best NATIONAL deal category or categories (you may select more than one if multiple are great fits):" multi-select="true" name="national_category" validates="required" strict="true" gold="true" aggregation="cagg_0.4"  log-search="true"></cml:taxonomy>
+        </cml:group>
+      </cml:group>
+      <hr />
+
+      <cml:checkbox label="Click here if the details of the deal are unavailable." default="false" name="details_unavailable" instructions="Do NOT check this box simply because a deal is expired." gold="true"></cml:checkbox>
+
+    HTML
+
+    graph = @p.logic_tree.graph
+    graph.should == {
+      "local"=>{
+        :inbound_count=>1, :inbound_names=>["details_unavailable"], :inbound_matches=>{
+          "||" => [
+            {"details_unavailable"=>[{:match_key=>"true", :is_not=>true}]}
+          ]},
+        :outbound_count=>3, :outbound_names => %w[local_category location national_category]},
+      "location"=>{
+        :inbound_count=>2, :inbound_names=>["details_unavailable", "local"], :inbound_matches=>{
+          "||" => [
+            {"details_unavailable"=>[{:match_key=>"true", :is_not=>true}]},
+            {"local"=>[{:match_key=>"local", :is_not=>false}]}
+          ]
+        }
+      },
+      "details_unavailable"=>{
+        :outbound_count=>4, :outbound_names=> %w[local local_category location national_category]},
+      "national_category"=>{:inbound_count=>2, :inbound_names=>["details_unavailable", "local"], :inbound_matches=>{
+        "||" => [
+          {"details_unavailable"=>[{:match_key=>"true", :is_not=>true}]},
+          {"local"=>[{:match_key=>"national", :is_not=>false}]}
+        ]
+      }},
+      "local_category"=>{:inbound_count=>2, :inbound_names=>["details_unavailable", "local"], :inbound_matches=>{
+        "||" => [
+          {"details_unavailable"=>[{:match_key=>"true", :is_not=>true}]},
+          {"local"=>[{:match_key=>"local", :is_not=>false}]}
+        ]
+      }}
+    }
+  end
+
+  it "lists a simple only-if selector with indexed match" do
+    @p = Parser.new(<<-HTML)
+      <cml:checkboxes label="w t f">
+        <cml:checkbox label="lol" />
+        <cml:checkbox label="rtfm" />
+      </cml:checkboxes>
+      <cml:text label="OMG" only-if="w_t_f:[1]" />
+    HTML
+
+    graph = @p.logic_tree.graph
+    graph.should == {
+      "w_t_f"=>{:outbound_count=>1, :outbound_names=>["omg"]},
+      "omg"=>{:inbound_count=>1, :inbound_names=>["w_t_f"], :inbound_matches=>{
+        "||" => [
+          {"w_t_f"=>[{:match_key=>"rtfm", :is_not=>false}]}
+        ]
+      }}
+    }
+  end
+
+  it "gracefully skips logic containing Liquid variables" do
+    @p = Parser.new(<<-HTML)
+      <div class="user_input">
+        {% for engine in unique_engines %}
+        <div id="{{ _unit_id }}_input_engine_{{ forloop.index }}">
+          {% case forloop.index %}
+          {% when 1 %}
+          <cml:ratings gold="true" label="User Satisfaction of Engine 1" name="rating_engine_1" validates="required">
+            <cml:rating label="Can't Tell / Invalid Search" value="N/A"></cml:rating>
+            <cml:rating label="Bad" value="1"></cml:rating>
+            <cml:rating label="OK" value="2"></cml:rating>
+            <cml:rating label="Perfect" value="3"></cml:rating>
+          </cml:ratings>
+          <cml:checkboxes label="Please specify reason(s) for your rating" name="reasons_engine_1" only-if="rating_engine_{{ forloop.index }}:[1]||rating_engine_{{ forloop.index }}:[2]" strict="true" gold="true">
+            <cml:checkbox label="I expected result(s) but none were returned"></cml:checkbox>
+             <cml:checkbox label="There are duplicate listings in the results"></cml:checkbox>
+            <cml:checkbox label="The ranking of the listings is incorrect"></cml:checkbox>
+          </cml:checkboxes>
+          <cml:textarea label="Comments" name="comments_engine_1" only-if="rating_engine_{{ forloop.index }}:[1]||rating_engine_{{ forloop.index }}:[2]"></cml:textarea>
+          {% when 2 %}
+          <cml:ratings gold="true" label="User Satisfaction of Engine 2" name="rating_engine_2" validates="required">
+            <cml:rating label="Can't Tell / Invalid Search" value="N/A"></cml:rating>
+            <cml:rating label="Bad" value="1"></cml:rating>
+            <cml:rating label="OK" value="2"></cml:rating>
+            <cml:rating label="Perfect" value="3"></cml:rating>
+            <cml:checkbox label="Other (specify in comments below)" value="Other"></cml:checkbox>
+          </cml:ratings>
+          <cml:checkboxes label="Please specify reason(s) for your rating" name="reasons_engine_2" only-if="rating_engine_{{ forloop.index }}:[1]||rating_engine_{{ forloop.index }}:[2]" strict="true" gold="true">
+            <cml:checkbox label="I expected result(s) but none were returned"></cml:checkbox>
+             <cml:checkbox label="There are duplicate listings in the results"></cml:checkbox>
+            <cml:checkbox label="The ranking of the listings is incorrect"></cml:checkbox>
+          </cml:checkboxes>
+          <cml:textarea label="Comments" name="comments_engine_2" only-if="rating_engine_{{ forloop.index }}:[1]||rating_engine_{{ forloop.index }}:[2]"></cml:textarea>
+          {% when 3 %}
+          <cml:ratings gold="true" label="User Satisfaction of Engine 3" name="rating_engine_3" validates="required">
+            <cml:rating label="Can't Tell / Invalid Search" value="N/A"></cml:rating>
+            <cml:rating label="Bad" value="1"></cml:rating>
+            <cml:rating label="OK" value="2"></cml:rating>
+            <cml:rating label="Perfect" value="3"></cml:rating>
+          </cml:ratings>
+          <cml:checkboxes label="Please specify reason(s) for your rating" name="reasons_engine_3" only-if="rating_engine_{{ forloop.index }}:[1]||rating_engine_{{ forloop.index }}:[2]" strict="true" gold="true">
+            <cml:checkbox label="I expected result(s) but none were returned"></cml:checkbox>
+             <cml:checkbox label="There are duplicate listings in the results"></cml:checkbox>
+            <cml:checkbox label="The ranking of the listings is incorrect"></cml:checkbox>
+          </cml:checkboxes>
+          <cml:textarea label="Comments" name="comments_engine_3" only-if="rating_engine_{{ forloop.index }}:[1]||rating_engine_{{ forloop.index }}:[2]"></cml:textarea>
+          {% when 4 %}
+          <cml:ratings gold="true" label="User Satisfaction of Engine 4" name="rating_engine_4" validates="required">
+            <cml:rating label="Can't Tell / Invalid Search" value="N/A"></cml:rating>
+            <cml:rating label="Bad" value="1"></cml:rating>
+            <cml:rating label="OK" value="2"></cml:rating>
+            <cml:rating label="Perfect" value="3"></cml:rating>
+          </cml:ratings>
+          <cml:checkboxes label="Please specify reason(s) for your rating" name="reasons_engine_4" only-if="rating_engine_{{ forloop.index }}:[1]||rating_engine_{{ forloop.index }}:[2]" strict="true" gold="true">
+            <cml:checkbox label="I expected result(s) but none were returned"></cml:checkbox>
+             <cml:checkbox label="There are duplicate listings in the results"></cml:checkbox>
+            <cml:checkbox label="The ranking of the listings is incorrect"></cml:checkbox>
+          </cml:checkboxes>
+          <cml:textarea label="Comments" name="comments_engine_4" only-if="rating_engine_{{ forloop.index }}:[1]||rating_engine_{{ forloop.index }}:[2]"></cml:textarea>
+          {% endcase %}
+        </div>
+        {% endfor %}
+      </div>
+    HTML
+
+    @p.logic_tree.graph.each {|k,v| v.should == {} }
+    @p.logic_tree.nodes.collect {|k,v|
+      v.tag.errors && v.tag.errors.each {|err|
+        err.should =~ /^The logic tree cannot be constructed when only-if contains a Liquid tag/ }}
+  end
+
+end