msfl_visitors 1.1.0.dev2 → 1.1.0.dev3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 45becd6e90f826ce123e6f4c5ee389e37c4f3337
-  data.tar.gz: 87baa18d96cba72ef39deecf22447ecb7a7c30f3
+  metadata.gz: 8ec3bfda1d028fdcd4c4fb02eaf3e6a26c792e4b
+  data.tar.gz: f1e1324598941df2d59dc3da9b80ef2f0a4e3710
 SHA512:
-  metadata.gz: cf1b9343cdf9a64ad46c916b36c37d5eb06c8cb43cb224329194722ad7af915e5e0069ce126004c68c4e46cdcd3e437dd0bcaf100986e5855ffe74a874a083dd
-  data.tar.gz: c034ae9ca6db09fdc7ebc67387a61903e08de3cc8b84e1de735bd0607ac20a3b2688a029203bbd2ce16202ef48b05d51b4be0332e114f6b00c34e11045a0aa49
+  metadata.gz: 8f910b468fefd6e905119c76e9fd7e9939490b37789ba76f9d1cc5a32d42d30a565f44aa32c0c72e8cd149ac10e4b564972f66536d9a59ba95aeca592744d408
+  data.tar.gz: 9e621c0a5175d457c0dc0c63324ac229719442d01c9008a043ced18a41767c37597a5c14da68f710ed0cdf811c0820c07c17178a793b7820c2afc5a2ae67f0d3

data/lib/msfl_visitors/visitor.rb

@@ -12,19 +12,30 @@ module MSFLVisitors
     end
 
     def visit(node)
-      case node
-        when Nodes::Partial
-          in_aggregation_mode do
-            clauses.concat get_visitor.visit(node)
-            ""
-          end
-        else
-          get_visitor.visit(node)
+      if mode == :es_term
+        get_visitor.visit(node)
+      else
+        case node
+          when Nodes::Partial
+            in_aggregation_mode do
+              clauses.concat get_visitor.visit(node)
+              ""
+            end
+          else
+            get_visitor.visit(node)
+        end
       end
     end
 
     def get_visitor
-      (mode == :term ? TermFilterVisitor : AggregationsVisitor).new(self)
+      case mode
+        when :term
+          TermFilterVisitor.new(self)
+        when :es_term
+          ESTermFilterVisitor.new(self)
+        else
+          AggregationsVisitor.new(self)
+      end
     end
 
     def in_aggregation_mode
@@ -202,6 +213,72 @@ module MSFLVisitors
 
       attr_reader :visitor
     end
+
+    class ESTermFilterVisitor
+      def initialize(visitor)
+        @visitor = visitor
+      end
+
+      RANGE_OPERATORS = {
+          Nodes::GreaterThan            => :gt,
+          Nodes::GreaterThanEqual       => :gte,
+          Nodes::LessThan               => :lt,
+          Nodes::LessThanEqual          => :lte,
+      }
+
+      def visit(node)
+        case node
+          when Nodes::Partial
+            { given: Hash[[node.left.accept(visitor), node.right.accept(visitor)]] }
+
+          when Nodes::Equal
+            { term: { node.left.accept(visitor) => node.right.accept(visitor) } }
+          # [{ clause:  }]
+          when Nodes::Field
+            node.value.to_sym
+          when Nodes::Date, Nodes::Time
+            node.value.iso8601
+          when  Nodes::Word,
+              Nodes::Number,
+              Nodes::Boolean,
+              Nodes::Dataset
+            node.value
+          when  Nodes::GreaterThan,
+              Nodes::GreaterThanEqual,
+              Nodes::LessThan,
+              Nodes::LessThanEqual
+            { range: { node.left.accept(visitor) => { RANGE_OPERATORS[node.class] =>  node.right.accept(visitor) } } }
+          when Nodes::Given
+            [:filter, node.contents.first.accept(visitor)]
+          when Nodes::ExplicitFilter
+            [:filter, node.contents.map { |n| n.accept(visitor) }.reduce({}) { |hsh, x| hsh.merge!(x); hsh } ]
+          when Nodes::NamedValue
+            [:aggs, {node.name.accept(visitor).to_sym => Hash[[node.value.accept(visitor)]]}]
+          when Nodes::Containment
+            { terms: {node.left.accept(visitor).to_sym => node.right.accept(visitor)} }
+          when Nodes::Set
+            node.contents.map { |n| n.accept(visitor) }
+          when Nodes::Filter
+            if node.contents.count == 1
+              node.contents.first.accept visitor
+            else
+              { and: node.contents.map { |n| n.accept(visitor) } }
+            end
+          when Nodes::And
+            { and: node.set.accept(visitor) }
+
+          when Nodes::Foreign
+            { has_child: Hash[[[:type, node.left.accept(visitor)], node.right.accept(visitor)]] }
+
+          else
+            fail ArgumentError, "ES TermFilter Visitor cannot visit: #{node.class.name}"
+        end
+      end
+
+      private
+
+      attr_reader :visitor
+    end
   end
 end
 

data/msfl_visitors.gemspec

@@ -1,6 +1,6 @@
 Gem::Specification.new do |s|
   s.name        = 'msfl_visitors'
-  s.version     = '1.1.0.dev2'
+  s.version     = '1.1.0.dev3'
   s.date        = '2015-05-28'
   s.summary     = "Convert MSFL to other forms"
   s.description = "Visitor pattern approach to converting MSFL to other forms."

data/spec/msfl_visitors/visitors/es_term_filter_spec.rb

@@ -0,0 +1,434 @@
+require 'spec_helper'
+
+describe MSFLVisitors::Visitor do
+
+  let(:node) { fail ArgumentError, "You must define the node variable in each scope." }
+
+  let(:visitor) { described_class.new }
+
+  let(:left) { MSFLVisitors::Nodes::Field.new "lhs" }
+
+  let(:right) { MSFLVisitors::Nodes::Word.new "rhs" }
+
+  subject(:result) { node.accept visitor }
+
+  context "when using the ESTermFilter visitor" do
+
+    before { visitor.mode = :es_term }
+
+    context "when visiting" do
+
+      describe "an unsupported node" do
+
+        class UnsupportedNode
+
+          def accept(visitor)
+            visitor.visit self
+          end
+        end
+
+        let(:node) { UnsupportedNode.new }
+
+          it "raises an ArgumentError" do
+            expect { subject }.to raise_error ArgumentError
+          end
+      end
+
+      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 clause" do
+          exp = [{
+                     clause: {
+                         given: {
+                             filter: {
+                                 term: { make: "Toyota" }
+                             },
+                             aggs: {
+                                 partial: {
+                                     filter: { range: { age: { gt: 10 }}}
+                                 }
+                             }
+                         }
+                     }
+                 }]
+          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
+          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 }
+
+        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
+
+      describe "a Containment node" do
+
+        let(:node) { MSFLVisitors::Nodes::Containment.new field, values }
+
+        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" }
+
+        let(:item_two) { MSFLVisitors::Nodes::Word.new "item_two" }
+
+        let(:item_three) { MSFLVisitors::Nodes::Word.new "item_three" }
+
+        let(:field)  { left }
+
+        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
+
+      describe "a Set node" do
+
+        let(:node) { MSFLVisitors::Nodes::Set.new values }
+
+        let(:values) { MSFL::Types::Set.new([item_one, item_two]) }
+
+        let(:item_one) { MSFLVisitors::Nodes::Word.new "item_one" }
+
+        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"]
+        end
+      end
+
+      describe "an Equal node" do
+
+        let(:node) { MSFLVisitors::Nodes::Equal.new left, right }
+
+        it "results in: { term: { lhs: \"rhs\" } }" do
+          expect(result).to eq({ term: { lhs: "rhs" } })
+        end
+      end
+
+      describe "a GreaterThan node" do
+
+        let(:node) { MSFLVisitors::Nodes::GreaterThan.new left, right }
+
+        let(:right) { MSFLVisitors::Nodes::Number.new 1000 }
+
+        it "results in: { range: { lhs: { gt: 1000 } } }" do
+          expect(result).to eq({ range: { lhs: { gt: 1000 } } })
+        end
+      end
+
+      describe "a GreaterThanEqual node" do
+
+        let(:node) { MSFLVisitors::Nodes::GreaterThanEqual.new left, right }
+
+        let(:right) { MSFLVisitors::Nodes::Number.new 10.52 }
+
+        it "results in: { range: { lhs: { gte: 10.52 } } }" do
+          expect(result).to eq({ range: { lhs: { gte: 10.52 } } })
+        end
+      end
+
+      describe "a LessThan node" do
+
+        let(:node) { MSFLVisitors::Nodes::LessThan.new left, right }
+
+        let(:right) { MSFLVisitors::Nodes::Number.new 133.7 }
+
+        it "returns: { range: { lhs: { lt: 133.7 } } }" do
+          expect(result).to eq({ range: { lhs: { lt: 133.7 } } })
+        end
+      end
+
+      describe "a LessThanEqual node" do
+
+        let(:node) { MSFLVisitors::Nodes::LessThanEqual.new left, right }
+
+        let(:right) { MSFLVisitors::Nodes::Date.new Date.today }
+
+        it "returns: { range: { lhs: { lte: \"#{Date.today}\" } } }" do
+          expect(result).to eq({ range: { lhs: { lte: "#{Date.today}" } } })
+        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
+
+        it "returns: { range: { value: { gte: 1000 } } }" do
+          expect(result).to eq({ range: { value: { gte: 1000 } } })
+        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
+
+          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
+
+      describe "an And node" do
+
+        let(:first_field) { MSFLVisitors::Nodes::Field.new "first_field" }
+
+        let(:first_value) { MSFLVisitors::Nodes::Word.new "first_word" }
+
+        let(:first) { MSFLVisitors::Nodes::Equal.new(first_field, first_value) }
+
+        let(:second_field) { MSFLVisitors::Nodes::Field.new "second_field" }
+
+        let(:second_value) { MSFLVisitors::Nodes::Word.new "second_word" }
+
+        let(:second) { MSFLVisitors::Nodes::Equal.new(second_field, second_value) }
+
+        let(:third_field) { MSFLVisitors::Nodes::Field.new "third_field" }
+
+        let(:third_value) { MSFLVisitors::Nodes::Word.new "third_word" }
+
+        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(:set_node) { MSFLVisitors::Nodes::Set.new [] }
+
+          it "returns: { and: [] }" do
+            expect(result).to eq({ and: [] })
+          end
+        end
+
+        context "when the node has one item" do
+
+          let(:set_node) { MSFLVisitors::Nodes::Set.new [first] }
+
+          it "returns: { and: [{ term: { first_field: \"first_word\" }] }" do
+            expect(result).to eq({ and: [{ term: { first_field: "first_word" } }] })
+          end
+        end
+
+        context "when the node has two items" do
+
+          let(:set_node) { MSFLVisitors::Nodes::Set.new [first, second] }
+
+          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
+
+        context "when the node has three items" do
+
+          let(:set_node) { MSFLVisitors::Nodes::Set.new [first, second, third] }
+
+          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
+
+        context "when one of the node's items is a containment node" do
+
+          let(:node) do
+            MSFLVisitors::Nodes::And.new(
+                MSFLVisitors::Nodes::Set.new(
+                    [
+                        MSFLVisitors::Nodes::Filter.new(
+                            [
+                                MSFLVisitors::Nodes::Containment.new(
+                                    MSFLVisitors::Nodes::Field.new(:make),
+                                    MSFLVisitors::Nodes::Set.new(
+                                        [
+                                            MSFLVisitors::Nodes::Word.new("Honda"),
+                                            MSFLVisitors::Nodes::Word.new("Chevy"),
+                                            MSFLVisitors::Nodes::Word.new("Volvo")
+                                        ]
+                                    )
+                                )
+                            ]
+                        ),
+                        MSFLVisitors::Nodes::Filter.new(
+                            [
+                                MSFLVisitors::Nodes::GreaterThanEqual.new(
+                                    MSFLVisitors::Nodes::Field.new(:value),
+                                    MSFLVisitors::Nodes::Number.new(1000)
+                                )
+                            ]
+                        )
+                    ]
+                )
+            )
+          end
+          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
+
+      describe "value nodes" do
+        describe "a Boolean node" do
+
+          let(:node) { MSFLVisitors::Nodes::Boolean.new value }
+
+          subject(:result) { node.accept visitor }
+
+          context "with a value of true" do
+
+            let(:value) { true }
+
+            it "returns: true" do
+              expect(result).to eq true
+            end
+          end
+
+          context "with a value of false" do
+
+            let(:value) { false }
+
+            it "returns: false" do
+              expect(result).to eq false
+            end
+          end
+        end
+
+        describe "a Word node" do
+
+          let(:word) { "node_content" }
+
+          let(:node) { MSFLVisitors::Nodes::Word.new word }
+
+          it "returns: the literal string" do
+            expect(result).to eq "#{word}"
+          end
+        end
+      end
+
+      describe "range value nodes" do
+
+        subject(:result) { node.accept visitor }
+
+        describe "a Date node" do
+
+          let(:today) { Date.today }
+
+          let(:node) { MSFLVisitors::Nodes::Date.new today }
+
+          it "returns: the date using iso8601 formatting" do
+            expect(result).to eq "#{today.iso8601}"
+          end
+        end
+
+        describe "a Time node" do
+
+          let(:now) { Time.now }
+
+          let(:node) { MSFLVisitors::Nodes::Time.new now }
+
+          it "returns: the date using iso8601 formatting" do
+            expect(result).to eq "#{now.iso8601}"
+          end
+        end
+
+        describe "a DateTime node" do
+
+          let(:now) { DateTime.now }
+
+          let(:node) { MSFLVisitors::Nodes::DateTime.new now }
+
+          it "returns: the date and time using iso8601 formatting" do
+            expect(result).to eq "#{now.iso8601}"
+          end
+        end
+
+        describe "a Number node" do
+
+          let(:number) { 123 }
+
+          let(:node) { MSFLVisitors::Nodes::Number.new number }
+
+          it "returns: 123" do
+            expect(result).to eq number
+          end
+
+          context "when the number is a float" do
+
+            let(:number) { 123.456 }
+
+            it "returns: the number with the same precision" do
+              expect(result).to eq number
+            end
+          end
+        end
+      end
+    end
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: msfl_visitors
 version: !ruby/object:Gem::Version
-  version: 1.1.0.dev2
+  version: 1.1.0.dev3
 platform: ruby
 authors:
 - Courtland Caldwell
@@ -154,6 +154,7 @@ files:
 - spec/msfl_visitors/parsers/msfl_parser_spec.rb
 - spec/msfl_visitors/visitor_spec.rb
 - spec/msfl_visitors/visitors/chewy_term_filter_spec.rb
+- spec/msfl_visitors/visitors/es_term_filter_spec.rb
 - spec/msfl_visitors_spec.rb
 - spec/spec_helper.rb
 homepage: https://github.com/Referly/msfl_visitors
@@ -186,6 +187,7 @@ test_files:
 - spec/msfl_visitors/parsers/msfl_parser_spec.rb
 - spec/msfl_visitors/visitor_spec.rb
 - spec/msfl_visitors/visitors/chewy_term_filter_spec.rb
+- spec/msfl_visitors/visitors/es_term_filter_spec.rb
 - spec/msfl_visitors_spec.rb
 - spec/spec_helper.rb
 has_rdoc: