msfl_visitors 1.2.3 → 1.3.0.dev.f

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: e4f7b46f12ec1e288ad1b62e983c0585a6194b5c
-  data.tar.gz: 01bf0621c30d745039618cd6f8ce71927fe13e1d
+  metadata.gz: ec528af7457f8551d7febd5d497337a2b805ac8b
+  data.tar.gz: 5e3de6c175ad703eb72b351c30cb3e7a025d9c82
 SHA512:
-  metadata.gz: 1be1ea7b20669e7205edf8dd164ba9799cc67995c5dff2b41706b2259a2f62ec8af4b75ad3e612fdeaf8782797ca2c43df1ceb7e207c80787b41cfd4452ccf6e
-  data.tar.gz: 5a5c14a0c70f0bb6e6273e3450f46216bd183766ba1539d0690fb3a52b2a3ccb1a825c8d3b83984f64f4faac7b769545579533d5b55c30422abe35dde1e522e7
+  metadata.gz: a78faedefd14402aba98cbdcd9e4c8ff976c43fc80aa5a9370cf17d6cc1d3ddc0350e47e4d4c3ced60669253fc7840ff0fe54ece4d6a46641f8a55b1449667c8
+  data.tar.gz: c05b7c376734ef110bb67a02f16c2e4bc167da846e07a30b00c6197900655b85da0c3adf6b671384f3b55da9e8ca19ff8bda38ff6c53599c021752344be4d89c

data/lib/msfl_visitors/visitor.rb

@@ -19,11 +19,15 @@ 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
+    attr_accessor :clauses, :current_clause, :arel_table
     attr_writer :mode
 
     def initialize
@@ -35,6 +39,8 @@ 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
@@ -54,6 +60,8 @@ module MSFLVisitors
           TermFilterVisitor.new(self)
         when :es_term
           ESTermFilterVisitor.new(self)
+        when :arel
+          ArelFilterVisitor.new(self, arel_table)
         else
           AggregationsVisitor.new(self)
       end
@@ -66,8 +74,11 @@ module MSFLVisitors
       result
     end
 
-    def visit_tree(root)
-      [{clause: root.accept(self)}].concat(clauses).reject { |c| c[:clause] == "" }
+    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)}"
     end
 
     private
@@ -245,6 +256,87 @@ 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/lib/msfl_visitors.rb

@@ -15,5 +15,17 @@ 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/msfl_visitors.gemspec

@@ -1,7 +1,7 @@
 Gem::Specification.new do |s|
   s.name        = 'msfl_visitors'
-  s.version     = '1.2.3'
-  s.date        = '2015-07-09'
+  s.version     = '1.3.0.dev.f'
+  s.date        = '2016-09-30'
   s.summary     = "Convert MSFL to other forms"
   s.description = "Visitor pattern approach to converting MSFL to other forms."
   s.authors     = ["Courtland Caldwell"]

data/spec/msfl_visitors/visitors/arel_filter_spec.rb

@@ -0,0 +1,451 @@
+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

metadata

@@ -1,103 +1,103 @@
 --- !ruby/object:Gem::Specification
 name: msfl_visitors
 version: !ruby/object:Gem::Version
-  version: 1.2.3
+  version: 1.3.0.dev.f
 platform: ruby
 authors:
 - Courtland Caldwell
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-07-09 00:00:00.000000000 Z
+date: 2016-09-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: msfl
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '1.2'
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: 1.2.1
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '1.2'
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: 1.2.1
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '10.3'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '10.3'
 - !ruby/object:Gem::Dependency
   name: simplecov
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '0.10'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '0.10'
 - !ruby/object:Gem::Dependency
   name: yard
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '0.8'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '0.8'
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '3.2'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '3.2'
 - !ruby/object:Gem::Dependency
   name: byebug
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '4.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '4.0'
 description: Visitor pattern approach to converting MSFL to other forms.
@@ -106,7 +106,7 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- .gitignore
+- ".gitignore"
 - Gemfile
 - Gemfile.lock
 - LICENSE
@@ -154,6 +154,7 @@ files:
 - spec/msfl_visitors/nodes/iterator_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
@@ -168,17 +169,17 @@ require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
-  - - '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - '>='
+  - - ">"
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.3.1
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.2
+rubygems_version: 2.4.3
 signing_key: 
 specification_version: 4
 summary: Convert MSFL to other forms
@@ -187,6 +188,7 @@ test_files:
 - spec/msfl_visitors/nodes/iterator_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