msfl_visitors 1.3.0.dev.f → 1.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: ec528af7457f8551d7febd5d497337a2b805ac8b
-  data.tar.gz: 5e3de6c175ad703eb72b351c30cb3e7a025d9c82
+  metadata.gz: ff27f36c62e1d5dc9848c0779ee2a997fa390479
+  data.tar.gz: e8fcbac337f97ad9d34366c1e32804a8b51c44e3
 SHA512:
-  metadata.gz: a78faedefd14402aba98cbdcd9e4c8ff976c43fc80aa5a9370cf17d6cc1d3ddc0350e47e4d4c3ced60669253fc7840ff0fe54ece4d6a46641f8a55b1449667c8
-  data.tar.gz: c05b7c376734ef110bb67a02f16c2e4bc167da846e07a30b00c6197900655b85da0c3adf6b671384f3b55da9e8ca19ff8bda38ff6c53599c021752344be4d89c
+  metadata.gz: c3b37837e8ce9c138a42db0196c42aef3905d367bdc1d310184543578ea2626e824b97de9f1b523b744d478beaee5dbf07512811bd509e5807c4c67bcf86dce6
+  data.tar.gz: 466355a1f210564a0ad16c52f513d6f3f0853e1999e02b284bb9715d99710386e86f81a6224ab2f7e56dfefad3fd051d583e343ee568eb1fbbe11c65efd12b36

data/Gemfile

@@ -1,6 +1,3 @@
-source 'https://rubygems.org'
-gem 'simplecov', :require => false, :group => :test           # MIT https://github.com/colszowka/simplecov/blob/master/MIT-LICENSE
-gem 'yard'                                                    # MIT https://github.com/lsegal/yard/blob/master/LICENSE + Ruby license for one file from the Ruby source lib/parser/ruby/legacy/ruby_lex.rb
-gem 'rspec'                                                   # MIT https://github.com/rspec/rspec/blob/master/License.txt
-gem 'byebug'
-gem 'msfl', "~> 1.2", ">=1.2.2"
+source "https://rubygems.org"
+
+gemspec

data/Gemfile.lock

@@ -1,6 +1,13 @@
+PATH
+  remote: .
+  specs:
+    msfl_visitors (1.3.0)
+      msfl (~> 1.2, >= 1.2.1)
+
 GEM
   remote: https://rubygems.org/
   specs:
+    builder (3.2.3)
     byebug (4.0.5)
       columnize (= 0.9.0)
     columnize (0.9.0)
@@ -9,6 +16,7 @@ GEM
     json (1.8.2)
     msfl (1.2.2)
       json (~> 1.7)
+    rake (10.4.2)
     rspec (3.2.0)
       rspec-core (~> 3.2.0)
       rspec-expectations (~> 3.2.0)
@@ -22,6 +30,9 @@ GEM
       diff-lcs (>= 1.2.0, < 2.0)
       rspec-support (~> 3.2.0)
     rspec-support (3.2.2)
+    rspec_junit_formatter (0.2.3)
+      builder (< 4)
+      rspec-core (>= 2, < 4, != 2.12.0)
     simplecov (0.10.0)
       docile (~> 1.1.0)
       json (~> 1.8)
@@ -33,8 +44,10 @@ PLATFORMS
   ruby
 
 DEPENDENCIES
-  byebug
-  msfl (~> 1.2, >= 1.2.2)
-  rspec
-  simplecov
-  yard
+  byebug (~> 4.0)
+  msfl_visitors!
+  rake (~> 10.3)
+  rspec (~> 3.2)
+  rspec_junit_formatter (~> 0.2)
+  simplecov (~> 0.10)
+  yard (~> 0.8)

data/circle.yml

@@ -6,4 +6,9 @@ machine:
   # Version of ruby to use
   ruby:
     version:
-      2.1.3
+      2.1.9
+
+test:
+  override:
+    - mkdir -p $CIRCLE_TEST_REPORTS/rspec
+    - bundle exec rspec --format RspecJunitFormatter --out $CIRCLE_TEST_REPORTS/rspec/rspec.xml spec --format progress

data/lib/msfl_visitors.rb

@@ -15,17 +15,5 @@ module MSFLVisitors
       ast       = parser.parse nmsfl
       visitor.visit_tree ast
     end
-
-    def get_arel(dataset, msfl, visitor = MSFLVisitors::Visitor.new)
-      visitor.mode = :arel
-      unless dataset.is_a? MSFL::Datasets::Base
-        raise ArgumentError, "The first argument to MSFLVisitors.get_arel must be a descendant of MSFL::Datasets::Base."
-      end
-      parser    = MSFLVisitors::Parsers::MSFLParser.new dataset
-      converter = MSFL::Converters::Operator.new
-      nmsfl     = converter.run_conversions msfl
-      ast       = parser.parse nmsfl
-      visitor.visit_tree ast, arel_table: dataset.arel_table
-    end
   end
 end

data/lib/msfl_visitors/nodes.rb

@@ -22,6 +22,7 @@ require_relative 'nodes/less_than_equal'
 require_relative 'nodes/match'
 require_relative 'nodes/named_value'
 require_relative 'nodes/number'
+require_relative 'nodes/or'
 require_relative 'nodes/partial'
 require_relative 'nodes/query_string'
 require_relative 'nodes/range_value'

data/lib/msfl_visitors/nodes/or.rb

@@ -0,0 +1,22 @@
+require_relative 'iterator'
+require_relative 'value'
+module MSFLVisitors
+  module Nodes
+    class Or < Iterator
+
+      def initialize(set)
+        super
+        unless valid_set_children?
+          fail ArgumentError, "Members of child Set node of Or node must be expressions, not values, only containment Set nodes have values as children."
+        end
+      end
+
+      private
+      def valid_set_children?
+        set.each do |child|
+          return false if child.is_a?(Value)
+        end
+      end
+    end
+  end
+end

data/lib/msfl_visitors/parsers/msfl_parser.rb

@@ -4,6 +4,7 @@ module MSFLVisitors
     class MSFLParser
       OPERATORS_TO_NODE_CLASS = {
           and:        Nodes::And,
+          or:         Nodes::Or,
           gt:         Nodes::GreaterThan,
           gte:        Nodes::GreaterThanEqual,
           eq:         Nodes::Equal,
@@ -25,10 +26,10 @@ module MSFLVisitors
             MSFLVisitors::Nodes::Number.new obj
 
           when Hash
-            parse_Hash obj, lhs
+            parse_hash obj, lhs
 
           when MSFL::Types::Set
-            parse_Set obj, lhs
+            parse_set obj, lhs
 
           when Symbol, String, NilClass
             MSFLVisitors::Nodes::Word.new obj.to_s
@@ -47,7 +48,7 @@ module MSFLVisitors
 
       attr_accessor :dataset
 
-      def parse_Hash(obj, lhs = false)
+      def parse_hash(obj, lhs = false)
         nodes = Array.new
         obj.each do |k, v|
           nodes << hash_dispatch(k, v, lhs)
@@ -61,7 +62,7 @@ module MSFLVisitors
         end
       end
 
-      def parse_Set(obj, lhs = false)
+      def parse_set(obj, lhs = false)
         nodes = MSFL::Types::Set.new([])
         obj.each do |item|
           nodes << parse(item)

data/lib/msfl_visitors/visitor.rb

@@ -19,15 +19,11 @@ module MSFLVisitors
     def composable_expr_for(regex_as_literal_string)
       regex_as_literal_string[3..-4]
     end
-
-    def coerce_value_to_unquoted(value)
-      return value[1..-2] if value[0] == "\""
-    end
   end
 
   class Visitor
 
-    attr_accessor :clauses, :current_clause, :arel_table
+    attr_accessor :clauses, :current_clause
     attr_writer :mode
 
     def initialize
@@ -39,8 +35,6 @@ module MSFLVisitors
     def visit(node)
       if mode == :es_term
         get_visitor.visit(node)
-      elsif mode == :arel
-        get_visitor.visit(node)
       else
         case node
           when Nodes::Partial
@@ -60,8 +54,6 @@ module MSFLVisitors
           TermFilterVisitor.new(self)
         when :es_term
           ESTermFilterVisitor.new(self)
-        when :arel
-          ArelFilterVisitor.new(self, arel_table)
         else
           AggregationsVisitor.new(self)
       end
@@ -74,11 +66,8 @@ module MSFLVisitors
       result
     end
 
-    def visit_tree(root, arel_table: nil)
-      return [{clause: root.accept(self)}].concat(clauses).reject { |c| c[:clause] == "" } unless mode == :arel
-      raise ArgumentError unless arel_table
-      @arel_table = arel_table.name
-      "#{root.accept(self)}"
+    def visit_tree(root)
+      [{clause: root.accept(self)}].concat(clauses).reject { |c| c[:clause] == "" }
     end
 
     private
@@ -102,7 +91,10 @@ module MSFLVisitors
           Nodes::Match                  => '=~',
       }
 
-
+      ITERATOR_OPERATORS = {
+          Nodes::And  => "&",
+          Nodes::Or   => "|"
+      }
 
       def visit(node)
         case node
@@ -144,11 +136,11 @@ module MSFLVisitors
               node.contents.map { |n| "( " + n.accept(visitor) + " )" }.join(" & ")
             end
 
-          when Nodes::And
+          when Nodes::Iterator
             if node.set.contents.count == 1
               node.set.contents.first.accept(visitor)
             else
-              node.set.contents.map { |n| "( " + n.accept(visitor) + " )" }.join(" & ")
+              node.set.contents.map { |n| "( " + n.accept(visitor) + " )" }.join(" #{ITERATOR_OPERATORS[node.class]} ")
             end
 
           when Nodes::Foreign
@@ -182,6 +174,11 @@ module MSFLVisitors
           Nodes::QueryString            => :query_string,
       }
 
+      ITERATOR_OPERATORS = {
+          Nodes::And => :and,
+          Nodes::Or => :or,
+      }
+
       def visit(node)
         case node
           when Nodes::Partial
@@ -240,8 +237,8 @@ module MSFLVisitors
             else
               { and: node.contents.map { |n| n.accept(visitor) } }
             end
-          when Nodes::And
-            { and: node.set.accept(visitor) }
+          when Nodes::Iterator
+            { ITERATOR_OPERATORS[node.class] => node.set.accept(visitor) }
 
           when Nodes::Foreign
             { foreign: Hash[[[:type, node.left.accept(visitor)], [:filter, node.right.accept(visitor)]]] }
@@ -256,87 +253,6 @@ module MSFLVisitors
       attr_reader :visitor
     end
 
-    class ArelFilterVisitor
-      include VisitorHelpers
-
-      attr_accessor :arel_table
-
-      def initialize(visitor, arel_table)
-        @visitor = visitor
-        @arel_table = arel_table
-      end
-
-      BINARY_OPERATORS = {
-          Nodes::Containment            => 'in',
-          Nodes::GreaterThan            => 'gt',
-          Nodes::GreaterThanEqual       => 'gte',
-          Nodes::Equal                  => 'eq',
-          Nodes::LessThan               => 'lt',
-          Nodes::LessThanEqual          => 'lte',
-          Nodes::Match                  => '=~',
-      }
-
-
-
-      def visit(node)
-        case node
-          when  Nodes::Field
-            "#{node.value.to_sym}"
-          when Nodes::Regex
-            regex_escape node.value.to_s
-          when  Nodes::Word
-            "\"#{node.value}\""
-          when Nodes::Date, Nodes::Time
-            "\"#{node.value.iso8601}\""
-          when  Nodes::Number, Nodes::Boolean
-            node.value
-
-          when  Nodes::QueryString
-            %(#{node.left.accept(visitor)} LIKE '%#{coerce_value_to_unquoted node.right.accept(visitor)}%')
-
-          when  Nodes::Match
-            if node.right.is_a? Nodes::Set
-              escaped_str_frags = node.right.contents.map { |right_child| composable_expr_for(MSFLVisitors::Nodes::Regex.new(right_child.value.to_s).accept(visitor).inspect) }
-              escaped_str = "(" + escaped_str_frags.join('|') + ")"
-              "#{node.left.accept(visitor)} #{BINARY_OPERATORS[node.class]} " + %r[.*#{escaped_str}.*].inspect
-            else
-              "#{node.left.accept(visitor)} #{BINARY_OPERATORS[node.class]} " + MSFLVisitors::Nodes::Regex.new(node.right.value.to_s).accept(visitor).inspect
-            end
-          when  Nodes::Containment,
-              Nodes::GreaterThan,
-              Nodes::GreaterThanEqual,
-              Nodes::Equal,
-              Nodes::LessThan,
-              Nodes::LessThanEqual
-            %(#{arel_table}[:#{node.left.accept(visitor)}].#{BINARY_OPERATORS[node.class]}(#{node.right.accept(visitor)}))
-          when  Nodes::Set
-            "[" + node.contents.map { |n| n.accept(visitor) }.join(", ") + "]"
-          when Nodes::Filter
-            node.contents.reduce("") { |res, n|
-              next(n.accept(visitor)) unless res.length > 0
-              res + ".and(#{n.accept(visitor)})"
-            }
-          when Nodes::And
-            node.set.contents.reduce("") { |res, n|
-              next(n.accept(visitor)) unless res.length > 0
-              res + ".and(#{n.accept(visitor)})"
-            }
-          when Nodes::Foreign
-            "#{node.left.accept visitor}.filter { #{node.right.accept visitor} }"
-
-          when Nodes::Dataset
-            "has_child( :#{node.value} )"
-
-          else
-            fail ArgumentError, "ArelFilter cannot visit: #{node.class.name}"
-        end
-      end
-
-      private
-
-      attr_reader :visitor
-    end
-
     # ESTermFilterVisitor is not currently used and so not all node types are implemented
     class ESTermFilterVisitor
       def initialize(visitor)

data/msfl_visitors.gemspec

@@ -1,7 +1,7 @@
 Gem::Specification.new do |s|
   s.name        = 'msfl_visitors'
-  s.version     = '1.3.0.dev.f'
-  s.date        = '2016-09-30'
+  s.version     = '1.3.0'
+  s.date        = '2017-04-06'
   s.summary     = "Convert MSFL to other forms"
   s.description = "Visitor pattern approach to converting MSFL to other forms."
   s.authors     = ["Courtland Caldwell"]
@@ -16,5 +16,6 @@ Gem::Specification.new do |s|
   s.add_development_dependency "yard", "~> 0.8"
   s.add_development_dependency "rspec", "~> 3.2"
   s.add_development_dependency "byebug", "~> 4.0"
+  s.add_development_dependency "rspec_junit_formatter", "~> 0.2" # MIT https://github.com/sj26/rspec_junit_formatter/blob/master/LICENSE
   s.license     = "MIT"
 end

data/spec/msfl_visitors/nodes/or_spec.rb

@@ -0,0 +1,21 @@
+require 'spec_helper'
+
+describe MSFLVisitors::Nodes::Or do
+
+  context "when creating an instance of #{described_class}" do
+
+    subject { described_class.new node }
+
+    context "when passed as Set node as the argument to the constructor" do
+
+      let(:node) { MSFLVisitors::Nodes::Set.new [MSFLVisitors::Nodes::Number.new(1)] }
+
+      context "when the Set contains any nodes which inherit from Value" do
+
+        it "raises an ArgumentError" do
+          expect { subject }.to raise_error ArgumentError
+        end
+      end
+    end
+  end
+end

data/spec/msfl_visitors/visitors/chewy_term_filter_spec.rb

@@ -731,6 +731,181 @@ describe MSFLVisitors::Visitor do
       end
     end
 
+    describe "an Or 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::Or.new set_node }
+
+      context "when the Or node has zero items" do
+
+        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({ or: [] })
+          end
+        end
+      end
+
+      context "when the node has one item" do
+
+        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"'
+          end
+        end
+
+        context "when using the Aggregations visitor" do
+
+          before { visitor.mode = :aggregations }
+
+          it "returns: { or: [{ agg_field_name: :first_field, operator: :eq, test_value: \"first_word\" }]}" do
+            expect(result).to eq({ or: [{ agg_field_name: :first_field, operator: :eq, test_value: "first_word" }]})
+          end
+        end
+      end
+
+      context "when the node has two items" do
+
+        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" )'
+          end
+        end
+
+        context "when using the Aggregations visitor" do
+
+          before { visitor.mode = :aggregations }
+
+          it "returns: {
+              or: [{ agg_field_name: :first_field, operator: :eq, test_value: \"first_word\" },
+                    { agg_field_name: :second_field, operator: :eq, test_value: \"second_word\" }
+              ]}" do
+            expect(result).to eq({
+                                     or: [{ agg_field_name: :first_field, operator: :eq, test_value: "first_word" },
+                                           { agg_field_name: :second_field, operator: :eq, test_value: "second_word" }
+                                     ]})
+          end
+        end
+      end
+
+      context "when the node has three items" do
+
+        let(:set_node) { MSFLVisitors::Nodes::Set.new [first, second, third] }
+
+        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: {
+              or: [{ agg_field_name: :first_field, operator: :eq, test_value: \"first_word\" },
+                    { agg_field_name: :second_field, operator: :eq, test_value: \"second_word\"},
+                    {agg_field_name: :third_field, operator: :eq, test_value: \"third_word\"}
+              ]}" do
+            expect(result).to eq({
+                                     or: [{ agg_field_name: :first_field, operator: :eq, test_value: "first_word" },
+                                           { agg_field_name: :second_field, operator: :eq, test_value: "second_word"},
+                                           {agg_field_name: :third_field, operator: :eq, test_value: "third_word"}
+                                     ]})
+          end
+        end
+      end
+
+      context "when one of the node's items is a containment node" do
+
+        let(:node) do
+          MSFLVisitors::Nodes::Or.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
+
+        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: { or: [{ agg_field_name: :make, operator: :in, test_value: [\"Honda\", \"Chevy\", \"Volvo\"] }, { agg_field_name: :value, operator: :gte, test_value: 1000 } }] }" do
+            expected = { or: [
+                { agg_field_name: :make, operator: :in, test_value: ["Honda", "Chevy", "Volvo"] },
+                { agg_field_name: :value, operator: :gte, test_value: 1000}
+            ]}
+            expect(result).to eq expected
+          end
+        end
+      end
+    end
+
     describe "value nodes" do
       describe "a Boolean node" do
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: msfl_visitors
 version: !ruby/object:Gem::Version
-  version: 1.3.0.dev.f
+  version: 1.3.0
 platform: ruby
 authors:
 - Courtland Caldwell
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-09-30 00:00:00.000000000 Z
+date: 2017-04-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: msfl
@@ -100,6 +100,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '4.0'
+- !ruby/object:Gem::Dependency
+  name: rspec_junit_formatter
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.2'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.2'
 description: Visitor pattern approach to converting MSFL to other forms.
 email: courtland@mattermark.com
 executables: []
@@ -138,6 +152,7 @@ files:
 - lib/msfl_visitors/nodes/match.rb
 - lib/msfl_visitors/nodes/named_value.rb
 - lib/msfl_visitors/nodes/number.rb
+- lib/msfl_visitors/nodes/or.rb
 - lib/msfl_visitors/nodes/partial.rb
 - lib/msfl_visitors/nodes/query_string.rb
 - lib/msfl_visitors/nodes/range_value.rb
@@ -152,9 +167,9 @@ files:
 - simplecov_custom_profiles.rb
 - spec/msfl_visitors/nodes/and_spec.rb
 - spec/msfl_visitors/nodes/iterator_spec.rb
+- spec/msfl_visitors/nodes/or_spec.rb
 - spec/msfl_visitors/parsers/msfl_parser_spec.rb
 - spec/msfl_visitors/visitor_spec.rb
-- spec/msfl_visitors/visitors/arel_filter_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
@@ -174,9 +189,9 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">"
+  - - ">="
     - !ruby/object:Gem::Version
-      version: 1.3.1
+      version: '0'
 requirements: []
 rubyforge_project: 
 rubygems_version: 2.4.3
@@ -186,11 +201,10 @@ summary: Convert MSFL to other forms
 test_files:
 - spec/msfl_visitors/nodes/and_spec.rb
 - spec/msfl_visitors/nodes/iterator_spec.rb
+- spec/msfl_visitors/nodes/or_spec.rb
 - spec/msfl_visitors/parsers/msfl_parser_spec.rb
 - spec/msfl_visitors/visitor_spec.rb
-- spec/msfl_visitors/visitors/arel_filter_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: 

data/spec/msfl_visitors/visitors/arel_filter_spec.rb

@@ -1,451 +0,0 @@
-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 ArelFilter visitor" do
-
-    before {
-      visitor.mode = :arel
-      visitor.arel_table = :cars
-    }
-
-    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: 'cars[:lhs].in(["item_one", "item_two", "item_three"])') do
-          expect(subject).to eq(%(cars[:lhs].in(["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: 'cars[:lhs].eq("rhs")') do
-          expect(result).to eq(%(cars[:lhs].eq("rhs")))
-        end
-      end
-
-      #
-      # Models::Investor.arel_table.project(Arel.sql('*')).where(send MSFLVisitors.get_arel(MSFL::Datasets::Investor.new, { linkedin_id: { gt: 200 } })).to_a
-      #
-      describe "a GreaterThan node" do
-
-        let(:node) { MSFLVisitors::Nodes::GreaterThan.new left, right }
-
-        let(:right) { MSFLVisitors::Nodes::Number.new 1000 }
-
-        it %(results in: 'cars[:lhs].gt(1000)') do
-          expect(result).to eq(%(cars[: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: 'cars[:lhs].gte(10.52)') do
-          expect(result).to eq(%(cars[: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: 'cars[:lhs].lt(133.7)') do
-          expect(result).to eq(%(cars[: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: 'cars[:lhs].lte(#{Date.today})') do
-          expect(result).to eq(%(cars[:lhs].lte("#{Date.today}")))
-        end
-      end
-
-      describe "a QueryString node" do
-
-        let(:node) { MSFLVisitors::Nodes::QueryString.new left, right }
-
-        let(:right) { MSFLVisitors::Nodes::Word.new "happy" }
-
-        it %(returns: "lhs LIKE '%happy%'") do
-          expect(result).to eq(%(lhs LIKE '%happy%'))
-        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: 'cars[:value].gte(1000)') do
-          expect(result).to eq(%(cars[: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: 'cars[:make].eq("Chevy").and(cars[:value].gte(1000))') do
-            expect(result).to eq(%(cars[:make].eq("Chevy").and(cars[: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: '') do
-            expect(result).to eq('')
-          end
-        end
-
-        context "when the node has one item" do
-
-          let(:set_node) { MSFLVisitors::Nodes::Set.new [first] }
-
-          it %(returns: 'cars[:first_field].eq("first_word")') do
-            expect(result).to eq(%(cars[:first_field].eq("first_word")))
-          end
-        end
-
-        context "when the node has two items" do
-
-          let(:set_node) { MSFLVisitors::Nodes::Set.new [first, second] }
-
-          it %(returns: 'cars[:first_field].eq("first_word").and(cars[:second_field].eq("second_word"))') do
-            expect(result).to eq(%(cars[:first_field].eq("first_word").and(cars[:second_field].eq("second_word"))))
-          end
-        end
-
-        context "when the node has three items" do
-
-          let(:set_node) { MSFLVisitors::Nodes::Set.new [first, second, third] }
-
-          it %(returns: 'cars[:first_field].eq("first_word").and(cars[:second_field].eq("second_word")).and(cars[:third_field].eq("third_word"))') do
-            expect(result).to eq(%(cars[:first_field].eq("first_word").and(cars[:second_field].eq("second_word")).and(cars[:third_field].eq("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: 'cars[:make].in(["Honda", "Chevy", "Volvo"]).and(cars[:value].gte(1000))') do
-            expected = %(cars[:make].in(["Honda", "Chevy", "Volvo"]).and(cars[: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