msfl_visitors 0.1.0.rc3 → 0.3.0.dev

data/spec/visitors/chewy_term_filter_spec.rb

@@ -4,27 +4,147 @@ describe MSFLVisitors::Visitor do
 
   let(:node) { fail ArgumentError, "You must define the node variable in each scope." }
 
-  let(:collector) { MSFLVisitors::Collectors::Chewy::TermFilter.new  }
-
-  let(:renderer) { MSFLVisitors::Renderers::Chewy::TermFilter.new }
-
-  let(:visitor) { described_class.new collector, renderer }
+  let(:visitor) { described_class.new }
 
   let(:left) { MSFLVisitors::Nodes::Field.new "lhs" }
 
   let(:right) { MSFLVisitors::Nodes::Word.new "rhs" }
 
-  subject(:result) { collector }
-
-  before(:each) { node.accept visitor }
+  subject(:result) { node.accept visitor }
 
   context "when visiting" do
 
+    describe "an unsupported node" do
+
+      class UnsupportedNode
+
+        def accept(visitor)
+          visitor.visit self
+        end
+      end
+
+      let(:node) { UnsupportedNode.new }
+
+      context "when using the TermFilter visitor" do
+
+        it "raises an ArgumentError" do
+          expect { subject }.to raise_error ArgumentError
+        end
+      end
+
+      context "when using the Aggregations visitor" do
+
+        before { visitor.mode = :aggregations }
+
+        it "raises an ArgumentError" do
+          expect { subject }.to raise_error ArgumentError
+        end
+      end
+
+    end
+
+    # chewy looks like
+    # Index::Type.filter { match_all }.aggregations({toyotas: {terms: {make: 'Toyota'}, aggregations: { filter: { range: { avg_age: { gt: 10 }}} }}})
+    describe "a Partial node" do
+
+      let(:node)                    { MSFLVisitors::Nodes::Partial.new given_node, named_value }
+
+        let(:given_node)              { MSFLVisitors::Nodes::Given.new [given_equal_node] }
+
+          let(:given_equal_node)        { MSFLVisitors::Nodes::Equal.new given_field_node, given_value_node }
+
+          let(:given_field_node)          { MSFLVisitors::Nodes::Field.new :make }
+
+            let(:given_value_node)        { MSFLVisitors::Nodes::Word.new "Toyota" }
+
+
+      let(:named_value)    { MSFLVisitors::Nodes::NamedValue.new MSFLVisitors::Nodes::Word.new("partial"), explicit_filter_node }
+
+        let(:explicit_filter_node)    { MSFLVisitors::Nodes::ExplicitFilter.new [greater_than_node] }
+
+            let(:greater_than_node)              { MSFLVisitors::Nodes::GreaterThan.new field_node, value_node }
+
+              let(:field_node)              { MSFLVisitors::Nodes::Field.new :age }
+
+              let(:value_node)              { MSFLVisitors::Nodes::Number.new 10 }
+
+
+      subject { visitor.visit_tree node }
+
+      it "results in the appropriate aggregation clause" do
+        exp = [{
+                   clause: {
+                       given: {
+                           filter: {
+                               term: { make: "Toyota" }
+                           },
+                           aggs: {
+                               partial: {
+                                   filter: { range: { age: { gt: 10 }}}
+                               }
+                           }
+                       }
+                   },
+                   method_to_execute: :aggregations
+               }]
+        visitor.mode = :aggregations
+        expect(subject).to eq exp
+      end
+    end
+
+    describe "a Given node" do
+
+      let(:node)                    { MSFLVisitors::Nodes::Given.new [given_equal_node] }
+
+        let(:given_equal_node)        { MSFLVisitors::Nodes::Equal.new given_field_node, given_value_node }
+
+          let(:given_field_node)        { MSFLVisitors::Nodes::Field.new :make }
+
+          let(:given_value_node)        { MSFLVisitors::Nodes::Word.new "Toyota" }
+
+
+      it "results in: [:filter, { term: { make: \"Toyota\" } }]" do
+        visitor.mode = :aggregations
+        expect(subject).to eq([:filter, { term: { make: "Toyota" } }])
+      end
+    end
+
+    describe "a Foreign node" do
+
+      let(:node) { MSFLVisitors::Nodes::Foreign.new dataset_node, filter_node }
+
+      let(:dataset_node) { MSFLVisitors::Nodes::Dataset.new "person" }
+
+      let(:filter_node) { MSFLVisitors::Nodes::ExplicitFilter.new [equal_node] }
+
+      let(:equal_node) { MSFLVisitors::Nodes::Equal.new left, right }
+
+      let(:left) { MSFLVisitors::Nodes::Field.new :age }
+
+      let(:right) { MSFLVisitors::Nodes::Number.new 25 }
+
+      context "when using the TermFilter visitor" do
+
+        it "results in: 'has_child( :person ).filter { age == 25 }" do
+          expect(subject).to eq "has_child( :person ).filter { age == 25 }"
+        end
+      end
+
+      context "when using the Aggregations visitor" do
+
+        before { visitor.mode = :aggregations }
+
+        it "results in: { has_child: { type: \"person\", filter: { term: { age: 25 } } } }" do
+          expect(subject).to eq({ has_child: { type: "person", filter: { term: { age: 25 } } } })
+        end
+      end
+    end
+
     describe "a Containment node" do
 
       let(:node) { MSFLVisitors::Nodes::Containment.new field, values }
 
-      let(:values) { MSFLVisitors::Nodes::Set::Set.new(MSFL::Types::Set.new([item_one, item_two, item_three])) }
+      let(:values) { MSFLVisitors::Nodes::Set.new(MSFL::Types::Set.new([item_one, item_two, item_three])) }
 
       let(:item_one) { MSFLVisitors::Nodes::Word.new "item_one" }
 
@@ -34,14 +154,26 @@ describe MSFLVisitors::Visitor do
 
       let(:field)  { left }
 
-      it "results in: 'lhs == [ \"item_one\", \"item_two\", \"item_three\" ]'" do
-        expect(subject).to eq "lhs == [ \"item_one\", \"item_two\", \"item_three\" ]"
+      context "when using the TermFilter visitor" do
+
+        it "results in: 'lhs == [ \"item_one\", \"item_two\", \"item_three\" ]'" do
+          expect(subject).to eq "lhs == [ \"item_one\" , \"item_two\" , \"item_three\" ]"
+        end
+      end
+
+      context "when using the Aggregations visitor" do
+
+        before { visitor.mode = :aggregations }
+
+        it "results in: { terms: { lhs: [\"item_one\", \"item_two\", \"item_three\"] } }" do
+          expect(subject).to eq({ terms: { lhs: ["item_one", "item_two", "item_three"] } })
+        end
       end
     end
 
     describe "a Set node" do
 
-      let(:node) { MSFLVisitors::Nodes::Set::Set.new values }
+      let(:node) { MSFLVisitors::Nodes::Set.new values }
 
       let(:values) { MSFL::Types::Set.new([item_one, item_two]) }
 
@@ -49,8 +181,20 @@ describe MSFLVisitors::Visitor do
 
       let(:item_two) { MSFLVisitors::Nodes::Word.new "item_two" }
 
-      it "results in: '[ \"item_one\", \"item_two\" ]'" do
-        expect(result).to eq "[ \"item_one\", \"item_two\" ]"
+      context "when using the TermFilter visitor" do
+
+        it "results in: '[ \"item_one\" , \"item_two\" ]'" do
+          expect(result).to eq "[ \"item_one\" , \"item_two\" ]"
+        end
+      end
+
+      context "when using the Aggregations visitor" do
+
+        before { visitor.mode = :aggregations }
+
+        it "results in: [\"item_one\", \"item_two\"]" do
+          expect(result).to eq ["item_one", "item_two"]
+        end
       end
     end
 
@@ -58,8 +202,20 @@ describe MSFLVisitors::Visitor do
 
       let(:node) { MSFLVisitors::Nodes::Equal.new left, right }
 
-      it "results in: 'left == right'" do
-        expect(result).to eq "lhs == \"rhs\""
+      context "when the current visitor is Chewy::TermFilter" do
+
+        it "results in: 'left == right'" do
+          expect(result).to eq "lhs == \"rhs\""
+        end
+      end
+
+      context "when the current visitor is Chewy::Aggregations" do
+
+        before { visitor.mode = :aggregations }
+
+        it "results in: { term: { lhs: \"rhs\" } }" do
+          expect(result).to eq({ term: { lhs: "rhs" } })
+        end
       end
     end
 
@@ -67,8 +223,22 @@ describe MSFLVisitors::Visitor do
 
       let(:node) { MSFLVisitors::Nodes::GreaterThan.new left, right }
 
-      it "returns: 'left > right'" do
-        expect(result).to eq "lhs > \"rhs\""
+      let(:right) { MSFLVisitors::Nodes::Number.new 1000 }
+
+      context "when using the TermFilter visitor" do
+
+        it "returns: 'left > 1000'" do
+          expect(result).to eq "lhs > 1000"
+        end
+      end
+
+      context "when using the Aggregations visitor" do
+
+        before { visitor.mode = :aggregations }
+
+        it "results in: { range: { lhs: { gt: 1000 } } }" do
+          expect(result).to eq({ range: { lhs: { gt: 1000 } } })
+        end
       end
     end
 
@@ -76,8 +246,22 @@ describe MSFLVisitors::Visitor do
 
       let(:node) { MSFLVisitors::Nodes::GreaterThanEqual.new left, right }
 
-      it "returns: 'left >= right'" do
-        expect(result).to eq "lhs >= \"rhs\""
+      let(:right) { MSFLVisitors::Nodes::Number.new 10.52 }
+
+      context "when using the TermFilter visitor" do
+
+        it "returns: 'left >= 10.52'" do
+          expect(result).to eq "lhs >= 10.52"
+        end
+      end
+
+      context "when using the Aggregations visitor" do
+
+        before { visitor.mode = :aggregations }
+
+        it "results in: { range: { lhs: { gte: 10.52 } } }" do
+          expect(result).to eq({ range: { lhs: { gte: 10.52 } } })
+        end
       end
     end
 
@@ -85,8 +269,22 @@ describe MSFLVisitors::Visitor do
 
       let(:node) { MSFLVisitors::Nodes::LessThan.new left, right }
 
-      it "returns: 'left < right'" do
-        expect(result).to eq 'lhs < "rhs"'
+      let(:right) { MSFLVisitors::Nodes::Number.new 133.7 }
+
+      context "when using the TermFilter visitor" do
+
+        it "returns: 'left < 133.7'" do
+          expect(result).to eq 'lhs < 133.7'
+        end
+      end
+
+      context "when using the Aggregations visitor" do
+
+        before { visitor.mode = :aggregations }
+
+        it "returns: { range: { lhs: { lt: 133.7 } } }" do
+          expect(result).to eq({ range: { lhs: { lt: 133.7 } } })
+        end
       end
     end
 
@@ -94,8 +292,82 @@ describe MSFLVisitors::Visitor do
 
       let(:node) { MSFLVisitors::Nodes::LessThanEqual.new left, right }
 
-      it "returns: 'left <= right'" do
-        expect(result).to eq 'lhs <= "rhs"'
+      let(:right) { MSFLVisitors::Nodes::Date.new Date.today }
+
+      context "when using the TermFilter visitor" do
+
+        it "returns: 'left <= \"#{Date.today}\"'" do
+          expect(result).to eq "lhs <= \"#{Date.today}\""
+        end
+      end
+
+      context "when using the Aggregations visitor" do
+
+        before { visitor.mode = :aggregations }
+
+        it "returns: { range: { lhs: { lte: \"#{Date.today}\" } } }" do
+          expect(result).to eq({ range: { lhs: { lte: "#{Date.today}" } } })
+        end
+      end
+    end
+
+    describe "a Filter node" do
+
+      let(:node) { MSFLVisitors::Nodes::Filter.new filtered_nodes }
+
+      let(:filtered_nodes) do
+        [
+            MSFLVisitors::Nodes::GreaterThanEqual.new(
+                MSFLVisitors::Nodes::Field.new(:value),
+                MSFLVisitors::Nodes::Number.new(1000))
+        ]
+      end
+
+      context "when using the TermFilter visitor" do
+
+        it "returns: value >= 1000" do
+          expect(result).to eq "value >= 1000"
+        end
+      end
+
+      context "when using the Aggregations visitor" do
+
+        before { visitor.mode = :aggregations }
+
+        it "returns: { range: { value: { gte: 1000 } } }" do
+          expect(result).to eq({ range: { value: { gte: 1000 } } })
+        end
+      end
+
+      context "when the filter has multiple children" do
+
+        let(:filtered_nodes) do
+          [
+              MSFLVisitors::Nodes::Equal.new(
+                  MSFLVisitors::Nodes::Field.new(:make),
+                  MSFLVisitors::Nodes::Word.new("Chevy")
+              ),
+              MSFLVisitors::Nodes::GreaterThanEqual.new(
+                  MSFLVisitors::Nodes::Field.new(:value),
+                  MSFLVisitors::Nodes::Number.new(1000))
+          ]
+        end
+
+        context "when using the TermFilter visitor" do
+
+          it "returns: ( make == \"Chevy\" ) & ( value >= 1000 )" do
+            expect(result).to eq "( make == \"Chevy\" ) & ( value >= 1000 )"
+          end
+        end
+
+        context "when using the Aggregations visitor" do
+
+          before { visitor.mode = :aggregations }
+
+          it "returns: { and: [{ term: { make: \"Chevy\" } },{ range: { value: { gte: 1000 } } }] }" do
+            expect(result).to eq({ and: [{ term: { make: "Chevy" } },{ range: { value: { gte: 1000 } } }] })
+          end
+        end
       end
     end
 
@@ -119,38 +391,89 @@ describe MSFLVisitors::Visitor do
 
       let(:third) { MSFLVisitors::Nodes::Equal.new(third_field, third_value) }
 
+      let(:node) { MSFLVisitors::Nodes::And.new(set_node) }
+
       context "when the And node has zero items" do
-        let(:node) { MSFLVisitors::Nodes::And.new([]) }
 
-        it "is empty" do
-          expect(result).to be_empty
+        let(:set_node) { MSFLVisitors::Nodes::Set.new [] }
+
+        context "when using the TermFilter visitor" do
+
+          it "is empty" do
+            expect(result).to be_empty
+          end
+        end
+
+        context "when using the Aggregations visitor" do
+
+          before { visitor.mode = :aggregations }
+
+          it "returns: { and: [] }" do
+            expect(result).to eq({ and: [] })
+          end
         end
       end
 
       context "when the node has one item" do
 
-        let(:node) { MSFLVisitors::Nodes::And.new([first])}
+        let(:set_node) { MSFLVisitors::Nodes::Set.new [first] }
+
+        context "when using the TermFilter visitor" do
 
-        it "returns: the item without adding parentheses" do
-          expect(result).to eq 'first_field == "first_word"'
+          it "returns: the item without adding parentheses" do
+            expect(result).to eq 'first_field == "first_word"'
+          end
+        end
+
+        context "when using the Aggregations visitor" do
+
+          before { visitor.mode = :aggregations }
+
+          it "returns: { and: [{ term: { first_field: \"first_word\" }] }" do
+            expect(result).to eq({ and: [{ term: { first_field: "first_word" } }] })
+          end
         end
       end
 
       context "when the node has two items" do
 
-        let(:node) { MSFLVisitors::Nodes::And.new([first, second]) }
+        let(:set_node) { MSFLVisitors::Nodes::Set.new [first, second] }
+
+        context "when using the TermFilter visitor" do
 
-        it "returns: '( first_field == \"first_word\" ) & ( second_field == \"second_word\" )'" do
-          expect(result).to eq '( first_field == "first_word" ) & ( second_field == "second_word" )'
+          it "returns: '( first_field == \"first_word\" ) & ( second_field == \"second_word\" )'" do
+            expect(result).to eq '( first_field == "first_word" ) & ( second_field == "second_word" )'
+          end
+        end
+
+        context "when using the Aggregations visitor" do
+
+          before { visitor.mode = :aggregations }
+
+          it "returns: { and: [{ term: { first_field: \"first_word\" } },{ term: { second_field: \"second_word\" } }] }" do
+            expect(result).to eq({ and: [{ term: { first_field: "first_word" }}, { term: { second_field: "second_word" } }] })
+          end
         end
       end
 
       context "when the node has three items" do
 
-        let(:node) { MSFLVisitors::Nodes::And.new([first, second, third]) }
+        let(:set_node) { MSFLVisitors::Nodes::Set.new [first, second, third] }
 
-        it "returns: '( first_field == \"first_word\" ) & ( second_field == \"second_word\" ) & ( third_field == \"third_word\" )'" do
-          expect(result).to eq '( first_field == "first_word" ) & ( second_field == "second_word" ) & ( third_field == "third_word" )'
+        context "when using the TermFilter visitor" do
+
+          it "returns: '( first_field == \"first_word\" ) & ( second_field == \"second_word\" ) & ( third_field == \"third_word\" )'" do
+            expect(result).to eq '( first_field == "first_word" ) & ( second_field == "second_word" ) & ( third_field == "third_word" )'
+          end
+        end
+
+        context "when using the Aggregations visitor" do
+
+          before { visitor.mode = :aggregations }
+
+          it "returns: { and: [{ term: { first_field: \"first_word\" } },{ term: { second_field: \"second_word\" } },{ term: { third_field: \"third_word\" } }] }" do
+            expect(result).to eq({ and: [{ term: { first_field: "first_word" } },{ term: { second_field: "second_word" } },{ term: { third_field: "third_word" } }] })
+          end
         end
       end
 
@@ -158,13 +481,13 @@ describe MSFLVisitors::Visitor do
 
         let(:node) do
           MSFLVisitors::Nodes::And.new(
-              MSFLVisitors::Nodes::Set::Set.new(
+              MSFLVisitors::Nodes::Set.new(
                   [
                       MSFLVisitors::Nodes::Filter.new(
                           [
                               MSFLVisitors::Nodes::Containment.new(
                                   MSFLVisitors::Nodes::Field.new(:make),
-                                  MSFLVisitors::Nodes::Set::Set.new(
+                                  MSFLVisitors::Nodes::Set.new(
                                       [
                                           MSFLVisitors::Nodes::Word.new("Honda"),
                                           MSFLVisitors::Nodes::Word.new("Chevy"),
@@ -187,8 +510,21 @@ describe MSFLVisitors::Visitor do
           )
         end
 
-        it "returns: '( make == [ \"Honda\", \"Chevy\", \"Volvo\" ] ) & ( value >= 1000 )'" do
-          expect(result).to eq '( make == [ "Honda", "Chevy", "Volvo" ] ) & ( value >= 1000 )'
+        context "when using the TermFilter visitor" do
+
+          it "returns: '( make == [ \"Honda\" , \"Chevy\" , \"Volvo\" ] ) & ( value >= 1000 )'" do
+            expect(result).to eq '( make == [ "Honda" , "Chevy" , "Volvo" ] ) & ( value >= 1000 )'
+          end
+        end
+
+        context "when using the Aggregations visitor" do
+
+          before { visitor.mode = :aggregations }
+
+          it "returns: { and: [{ terms: { make: [\"Honda\",\"Chevy\",\"Volvo\"]} }, { range: { value: { gte: 1000 } } }] }" do
+            expected = { and: [{ terms: { make: ["Honda", "Chevy", "Volvo"]} }, { range: { value: { gte: 1000 } } }] }
+            expect(result).to eq expected
+          end
         end
       end
     end
@@ -196,18 +532,28 @@ describe MSFLVisitors::Visitor do
     describe "value nodes" do
       describe "a Boolean node" do
 
-        let(:collector) { Array.new }
-
         let(:node) { MSFLVisitors::Nodes::Boolean.new value }
 
-        subject(:result) { node.accept(visitor).first }
+        subject(:result) { node.accept visitor }
 
         context "with a value of true" do
 
           let(:value) { true }
 
-          it "returns: true" do
-            expect(result).to be true
+          context "when using the TermFilter visitor" do
+
+            it "returns: true" do
+              expect(result).to eq true
+            end
+          end
+
+          context "when using the Aggregations visitor" do
+
+            before { visitor.mode = :aggregations }
+
+            it "returns: true" do
+              expect(result).to eq true
+            end
           end
         end
 
@@ -216,7 +562,16 @@ describe MSFLVisitors::Visitor do
           let(:value) { false }
 
           it "returns: false" do
-            expect(result).to be false
+            expect(result).to eq false
+          end
+
+          context "when using the Aggregations visitor" do
+
+            before { visitor.mode = :aggregations }
+
+            it "returns: false" do
+              expect(result).to eq false
+            end
           end
         end
       end
@@ -230,14 +585,21 @@ describe MSFLVisitors::Visitor do
         it "is a double quoted literal string" do
           expect(result).to eq "\"#{word}\""
         end
+
+        context "when using the Aggregations visitor" do
+
+          before { visitor.mode = :aggregations }
+
+          it "returns: the literal string" do
+            expect(result).to eq "#{word}"
+          end
+        end
       end
     end
 
     describe "range value nodes" do
 
-      let(:collector) { Array.new }
-
-      subject(:result) { node.accept(visitor).first }
+      subject(:result) { node.accept visitor }
 
       describe "a Date node" do
 
@@ -246,7 +608,16 @@ describe MSFLVisitors::Visitor do
         let(:node) { MSFLVisitors::Nodes::Date.new today }
 
         it "returns: the date using iso8601 formatting" do
-          expect(result).to eq today.iso8601
+          expect(result).to eq "\"#{today.iso8601}\""
+        end
+
+        context "when using the Aggregations visitor" do
+
+          before { visitor.mode = :aggregations }
+
+          it "returns: the date using iso8601 formatting" do
+            expect(result).to eq "#{today.iso8601}"
+          end
         end
       end
 
@@ -257,7 +628,16 @@ describe MSFLVisitors::Visitor do
         let(:node) { MSFLVisitors::Nodes::Time.new now }
 
         it "returns: the time using iso8601 formatting" do
-          expect(result).to eq now.iso8601
+          expect(result).to eq "\"#{now.iso8601}\""
+        end
+
+        context "when using the Aggregations visitor" do
+
+          before { visitor.mode = :aggregations }
+
+          it "returns: the date using iso8601 formatting" do
+            expect(result).to eq "#{now.iso8601}"
+          end
         end
       end
 
@@ -268,7 +648,16 @@ describe MSFLVisitors::Visitor do
         let(:node) { MSFLVisitors::Nodes::DateTime.new now }
 
         it "returns: the date and time using iso8601 formatting" do
-          expect(result).to eq now.iso8601
+          expect(result).to eq "\"#{now.iso8601}\""
+        end
+
+        context "when using the Aggregations visitor" do
+
+          before { visitor.mode = :aggregations }
+
+          it "returns: the date and time using iso8601 formatting" do
+            expect(result).to eq "#{now.iso8601}"
+          end
         end
       end
 
@@ -278,10 +667,19 @@ describe MSFLVisitors::Visitor do
 
         let(:node) { MSFLVisitors::Nodes::Number.new number }
 
-        it "returns: the number" do
+        it "returns: 123" do
           expect(result).to eq number
         end
 
+        context "when using the Aggregations visitor" do
+
+          before { visitor.mode = :aggregations }
+
+          it "returns: 123" do
+            expect(result).to eq number
+          end
+        end
+
         context "when the number is a float" do
 
           let(:number) { 123.456 }
@@ -289,6 +687,15 @@ describe MSFLVisitors::Visitor do
           it "returns: the number with the same precision" do
             expect(result).to eq number
           end
+
+          context "when using the Aggregations visitor" do
+
+            before { visitor.mode = :aggregations }
+
+            it "returns: the number with the same precision" do
+              expect(result).to eq number
+            end
+          end
         end
       end
     end