msfl_visitors 0.0.4 → 0.1.0.dev

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: bfe406385ca7f2a298e5734eab80bb39919117d0
-  data.tar.gz: a64c2b8e45a0a324aee12760b845bcdb2c75f3ab
+  metadata.gz: 7c087841af641cd54315d9e01ede56327e432e50
+  data.tar.gz: 62b019613fe964774360e3cfde4ce61603c20686
 SHA512:
-  metadata.gz: 091cd53361857fec191d593e95c8ba099306409d277c40add3362cbacebf6f0a4d68bd5e6ab2550b3f239948b5008717da1366ab6334036b4ac18a1b80500431
-  data.tar.gz: 59430f4f34128a5c388a057d5820c8dce8bf0f052d7c671921e63a1b1e3a69a8dcebf07ff7564721189616c2f4a99582a4232fa82892c4c16758ae91e90e5edb
+  metadata.gz: b0deb50dbdb4057b19c49daa95d151bfff4a8885451d5ad588b8b704247e0e5ccded964ad7d5e1cd9336a7d0d5c836d77b8cd464b8c98d7a5b8e039c15a5dd61
+  data.tar.gz: a79e6d2c395b9e1b573e5a6207504fb59fcffbdf491e2b0081aba6d70d75f492a1e01314f9f0473983407a28e99aef1e7c436d418fb93eca2f9e9fdd575dd2d5

data/lib/msfl_visitors/ast.rb

@@ -3,13 +3,18 @@ module MSFLVisitors
 
     attr_accessor :root
 
-    def initialize(msfl)
-      self.root = MSFLVisitors::Parsers::MSFLParser.new.parse msfl
+    def initialize(obj, parser = MSFLVisitors::Parsers::MSFLParser.new)
+      self.root = parser.parse obj
     end
 
     # Use this method to walk the AST with a particular visitor
     def accept(visitor)
       root.accept visitor
     end
+
+    def ==(other)
+      self.class == other.class &&
+          root == other.root
+    end
   end
 end

data/lib/msfl_visitors/nodes/and.rb

@@ -1,12 +1,23 @@
-require_relative 'binary'
+require_relative 'iterator'
 module MSFLVisitors
   module Nodes
-    class And < Binary
+    class And < Iterator
 
       def accept(visitor)
-        MSFLVisitors::Nodes::Grouping::Grouping.new(left).accept visitor
-        visitor.visit self
-        MSFLVisitors::Nodes::Grouping::Grouping.new(right).accept visitor
+        nodes = Array.new
+        if items.count > 1
+          items.each do |item|
+            nodes << MSFLVisitors::Nodes::Grouping::Grouping.new(item)
+            nodes << BinaryAnd.new
+          end
+          nodes.pop
+        elsif items.count == 1
+          nodes << items.first
+        end
+
+        nodes.each do |node|
+          node.accept visitor
+        end
       end
     end
   end

data/lib/msfl_visitors/nodes/binary_and.rb

@@ -0,0 +1,7 @@
+require_relative 'constant_value'
+module MSFLVisitors
+  module Nodes
+    class BinaryAnd < ConstantValue
+    end
+  end
+end

data/lib/msfl_visitors/nodes/containment.rb

@@ -0,0 +1,7 @@
+require_relative 'binary'
+module MSFLVisitors
+  module Nodes
+    class Containment < Binary
+    end
+  end
+end

data/lib/msfl_visitors/nodes/field.rb

@@ -0,0 +1,7 @@
+require_relative 'value'
+module MSFLVisitors
+  module Nodes
+    class Field < Value
+    end
+  end
+end

data/lib/msfl_visitors/nodes/filter.rb

@@ -1,23 +1,7 @@
-require_relative 'base'
+require_relative 'set/set'
 module MSFLVisitors
   module Nodes
-    class Filter < Base
-
-      attr_accessor :contents
-
-      def accept(visitor)
-        contents.accept visitor
-      end
-
-      # @param nodes [Array<MSFL::Nodes::Base>] the nodes that the filter surrounds
-      def initialize(nodes)
-        self.contents = nodes
-      end
-
-      def ==(other)
-        self.class == other.class &&
-            contents == other.contents
-      end
+    class Filter < Set::Set
     end
   end
 end

data/lib/msfl_visitors/nodes/iterator.rb

@@ -0,0 +1,18 @@
+require_relative 'base'
+module MSFLVisitors
+  module Nodes
+    class Iterator < Base
+
+      attr_accessor :items
+
+      def initialize(nodes)
+        self.items = nodes
+      end
+
+      def ==(other)
+        self.class == other.class &&
+            items == other.items
+      end
+    end
+  end
+end

data/lib/msfl_visitors/nodes/set/close.rb

@@ -0,0 +1,9 @@
+require_relative '../constant_value'
+module MSFLVisitors
+  module Nodes
+    module Set
+      class Close < ConstantValue
+      end
+    end
+  end
+end

data/lib/msfl_visitors/nodes/set/delimiter.rb

@@ -0,0 +1,9 @@
+require_relative '../constant_value'
+module MSFLVisitors
+  module Nodes
+    module Set
+      class Delimiter < ConstantValue
+      end
+    end
+  end
+end

data/lib/msfl_visitors/nodes/set/open.rb

@@ -0,0 +1,9 @@
+require_relative '../constant_value'
+module MSFLVisitors
+  module Nodes
+    module Set
+      class Open < ConstantValue
+      end
+    end
+  end
+end

data/lib/msfl_visitors/nodes/set/set.rb

@@ -0,0 +1,39 @@
+require_relative '../base'
+module MSFLVisitors
+  module Nodes
+    module Set
+      class Set < Base
+
+        attr_accessor :contents
+
+        def accept(visitor)
+          nodes = Array.new
+          nodes << Open.new
+          if contents.count > 0
+            contents.each do |item|
+              nodes << item
+              nodes << Delimiter.new
+            end
+            # Remove the last (and therefore extra) delimiter
+            nodes.pop
+          end
+          nodes << Close.new
+
+          nodes.each do |node|
+            node.accept visitor
+          end
+        end
+
+        # @param nodes [Array<MSFL::Nodes::Base>] the nodes that the filter surrounds
+        def initialize(nodes)
+          self.contents = Array(nodes)
+        end
+
+        def ==(other)
+          self.class == other.class &&
+              contents == other.contents
+        end
+      end
+    end
+  end
+end

data/lib/msfl_visitors/nodes.rb

@@ -2,13 +2,17 @@
 require_relative 'nodes/and'
 require_relative 'nodes/base'
 require_relative 'nodes/binary'
+require_relative 'nodes/binary_and'
 require_relative 'nodes/boolean'
 require_relative 'nodes/comparison'
 require_relative 'nodes/constant_value'
+require_relative 'nodes/containment'
 require_relative 'nodes/date'
 require_relative 'nodes/date_time'
 require_relative 'nodes/equal'
+require_relative 'nodes/field'
 require_relative 'nodes/filter'
+require_relative 'nodes/iterator'
 require_relative 'nodes/greater_than'
 require_relative 'nodes/greater_than_equal'
 require_relative 'nodes/grouping/close'
@@ -18,6 +22,10 @@ require_relative 'nodes/less_than'
 require_relative 'nodes/less_than_equal'
 require_relative 'nodes/number'
 require_relative 'nodes/range_value'
+require_relative 'nodes/set/close'
+require_relative 'nodes/set/delimiter'
+require_relative 'nodes/set/set'
+require_relative 'nodes/set/open'
 require_relative 'nodes/time'
 require_relative 'nodes/value'
 require_relative 'nodes/word'

data/lib/msfl_visitors/parsers/msfl_parser.rb

@@ -4,8 +4,13 @@ module MSFLVisitors
     class MSFLParser
       include MSFL::Validators::Definitions::HashKey
 
+      OPERATORS_TO_NODE_CLASS = {
+          gt:         Nodes::GreaterThan,
+          gte:        Nodes::GreaterThanEqual,
+          in:         Nodes::Containment,
+      }
+
       def parse(obj, lhs = false)
-        # send("parse_#{obj.class.to_s.gsub('::', '_')}", obj, lhs)
         case obj
 
           when Float, Fixnum
@@ -35,11 +40,21 @@ module MSFLVisitors
         obj.each do |k, v|
           nodes << hash_dispatch(k, v, lhs)
         end
-        MSFLVisitors::Nodes::Filter.new nodes
+        # If there's exactly one node in nodes and it's a filter node we don't want to wrap it in yet
+        # another filter node, so we just return the filter node
+        if nodes.count == 1 && nodes.first.is_a?(MSFLVisitors::Nodes::Filter)
+          nodes.first
+        else
+          MSFLVisitors::Nodes::Filter.new nodes
+        end
       end
 
       def parse_Set(obj, lhs = false)
-
+        nodes = MSFL::Types::Set.new([])
+        obj.each do |item|
+          nodes << parse(item)
+        end
+        MSFLVisitors::Nodes::Set::Set.new nodes
       end
 
       def hash_dispatch(key, value, lhs = false)
@@ -47,7 +62,7 @@ module MSFLVisitors
           # Detect the node type, forward the lhs if it was passed in (essentially when the operator is a binary op)
           args = [lhs, parse(value)] if lhs
           args ||= [parse(value)]
-          Object.const_get("MSFLVisitors::Nodes::#{key.to_s.capitalize}").new(*args)
+          OPERATORS_TO_NODE_CLASS[key].new(*args)
         else
           # the key is a field
           # there are three possible scenarios when they key is a field
@@ -61,7 +76,7 @@ module MSFLVisitors
           #     { model: { in: ["Corolla", "Civic", "Mustang"] } }
           #
           # 2 & 3 are just hashes and can be parsed using the same method
-          lhs = MSFLVisitors::Nodes::Word.new key
+          lhs = MSFLVisitors::Nodes::Field.new key
 
           # the node type generated by parsing value can use the lhs node when appropriate and otherwise ignore it
           # although I can't think of a situation when it would ignore it.

data/lib/msfl_visitors/renderers/chewy/term_filter.rb

@@ -3,7 +3,6 @@ module MSFLVisitors
     module Chewy
       class TermFilter
         BINARY_OPERATORS = {
-          Nodes::And              => ' & ',
           Nodes::GreaterThan      => ' > ',
           Nodes::LessThan         => ' < ',
           Nodes::GreaterThanEqual => ' >= ',
@@ -14,24 +13,39 @@ module MSFLVisitors
         def render(node)
           case node
 
-          when Nodes::Comparison, Nodes::And
+          when Nodes::Comparison
             BINARY_OPERATORS[node.class]
 
+          when Nodes::BinaryAnd
+            ' & '
+
           when Nodes::Date, Nodes::Time
             node.value.iso8601
 
           when Nodes::Boolean, Nodes::Number
             node.value
 
-          when Nodes::Word
+          when Nodes::Field
             node.value.to_s
 
+          when Nodes::Word
+            %("#{node.value.to_s}")
+
           when Nodes::Grouping::Close
             ' )'
 
           when Nodes::Grouping::Open
             '( '
 
+          when Nodes::Set::Close
+            ' ]'
+
+          when Nodes::Set::Delimiter
+            ', '
+
+          when Nodes::Set::Open
+            '[ '
+
           else
             fail ArgumentError.new("Unrecognized node type: #{node.class}")
           end

data/msfl_visitors.gemspec

@@ -1,7 +1,7 @@
 Gem::Specification.new do |s|
   s.name        = 'msfl_visitors'
-  s.version     = '0.0.4'
-  s.date        = '2015-05-01'
+  s.version     = '0.1.0.dev'
+  s.date        = '2015-05-06'
   s.summary     = "Convert MSFL to other forms"
   s.description = "Visitor pattern approach to converting MSFL to other forms."
   s.authors     = ["Courtland Caldwell"]

data/spec/ast_spec.rb

@@ -0,0 +1,78 @@
+require 'spec_helper'
+
+describe MSFLVisitors::AST do
+
+  let(:msfl) { { make: "Honda" } }
+
+  describe "#initialize" do
+
+    let(:parser) do
+      p = double('Fake Parser')
+      expect(p).to receive(:parse).with(msfl).once
+      p
+    end
+
+    subject { described_class.new msfl, parser }
+
+    it "eagerly parses the first argument" do
+      subject
+    end
+
+    context "when a parser is specified" do
+
+      it "uses the specified parser" do
+        subject
+      end
+    end
+  end
+
+  describe "#accept" do
+
+    let(:parser) { double('Fake Parser', parse: root) }
+
+    let(:root) do
+      r = double('Fake Root Node')
+      expect(r).to receive(:accept).with(visitor).once
+      r
+    end
+
+    let(:visitor) { double('Fake Visitor') }
+
+    subject { described_class.new(msfl, parser).accept visitor }
+
+    it "delegates to the root node" do
+      subject
+    end
+  end
+
+  describe "#==" do
+
+    subject { left == right }
+
+    let(:left) { described_class.new(msfl) }
+
+    let(:right) { described_class.new(msfl) }
+
+    context "when the two ASTs are the same class" do
+
+      context "when the two ASTs have equal root nodes" do
+
+        it { is_expected.to be true }
+      end
+
+      context "when the two ASTs do not have equal root nodes" do
+
+        let(:right) { described_class.new({ value: 1000 }) }
+
+        it { is_expected.to be false }
+      end
+    end
+
+    context "when the two ASTs are not the same class" do
+
+      let(:right) { double('Fake AST') }
+
+      it { is_expected.to be false }
+    end
+  end
+end

data/spec/nodes/iterator_spec.rb

@@ -0,0 +1,39 @@
+require 'spec_helper'
+
+describe MSFLVisitors::Nodes::Iterator do
+
+  describe "#==" do
+
+    let(:one) { MSFLVisitors::Nodes::Number.new(1) }
+
+    let(:two) { MSFLVisitors::Nodes::Number.new(2) }
+
+    let(:left) { MSFLVisitors::Nodes::Iterator.new [one, two] }
+
+    let(:right) { MSFLVisitors::Nodes::Iterator.new [one, two] }
+
+    subject { left == right }
+
+    context "when lhs and rhs are the same class" do
+
+      context "when lhs#items is equal to rhs#items" do
+
+        it { is_expected.to be true }
+      end
+
+      context "when lhs#items is not equal to rhs#items" do
+
+        let(:right) {  MSFLVisitors::Nodes::Iterator.new [one] }
+
+        it { is_expected.to be false }
+      end
+    end
+
+    context "when lhs is a different class than rhs" do
+
+      let(:right) { Object.new }
+
+      it { is_expected.to be false }
+    end
+  end
+end

data/spec/parsers/msfl_parser_spec.rb

@@ -0,0 +1,70 @@
+# This is a working file until I split these up
+require 'spec_helper'
+
+describe MSFLVisitors::Parsers::MSFLParser do
+
+  let(:expected_node) { ->(comp_node) { MSFLVisitors::Nodes::Filter.new [ comp_node ] } }
+
+  let(:left) { MSFLVisitors::Nodes::Field.new :value }
+
+  let(:right) { MSFLVisitors::Nodes::Number.new 1000 }
+
+  describe "parsing a trivial filter" do
+
+    subject { described_class.new.parse msfl }
+
+    let(:msfl) { { value: 1000 } }
+
+    it "is the expected node" do
+      expect(subject).to eq expected_node.call(MSFLVisitors::Nodes::Equal.new(left, right))
+    end
+  end
+
+  describe "#parse" do
+
+    context "when parsing a filter" do
+
+      subject { -> (filter) { described_class.new.parse filter } }
+
+      let(:implicit_equality_filter) { { value: 1000 } }
+
+      let(:explicit_gte_filter) { { value: { gte: 1000 } } }
+
+      let(:containment_filter) { { value: { in: containment_values } } }
+
+      let(:containment_values) { MSFL::Types::Set.new [50, 250, 20000] }
+
+      it "handles implicit equality comparisons" do
+        expect(subject.call(implicit_equality_filter)).to eq expected_node.call(MSFLVisitors::Nodes::Equal.new(left, right))
+      end
+
+      it "handles explicit comparisons" do
+        comparison_node = MSFLVisitors::Nodes::GreaterThanEqual.new left, right
+        expect(subject.call(explicit_gte_filter)).to eq expected_node.call(comparison_node)
+      end
+
+      # { value: { in: [50, 250, 20000] } }
+      #
+      #  => Nodes::Containment.new(Nodes::Field.new(:value),
+      #                            Nodes::Set::Set.new([
+      #                               Nodes::Number.new(50),
+      #                               Nodes::Number.new(250),
+      #                               Nodes::Number.new(20000)]))
+      it "handles containments" do
+        contained_nodes = containment_values.map { |value| MSFLVisitors::Nodes::Number.new(value) }
+        set_node = MSFLVisitors::Nodes::Set::Set.new(contained_nodes)
+        containment_node = MSFLVisitors::Nodes::Containment.new left, set_node
+        expect(subject.call(containment_filter)).to eq expected_node.call(containment_node)
+      end
+
+      context "when the filter contains an unsupported type" do
+
+        let(:bad_filter) { { foo: Object.new } }
+
+        it "raises an ArgumentError" do
+          expect { subject.call(bad_filter) }.to raise_error ArgumentError
+        end
+      end
+    end
+  end
+end

data/spec/renderers/chewy/term_filter_spec.rb

@@ -0,0 +1,24 @@
+require 'spec_helper'
+
+describe MSFLVisitors::Renderers::Chewy::TermFilter do
+
+  let(:node) { fail ArgumentError, "You must define the node variable in each scope." }
+
+  let(:collector) { String.new }
+
+  let(:renderer) { MSFLVisitors::Renderers::Chewy::TermFilter.new }
+
+  describe "#render" do
+
+    let(:node) { double('Unsupported Type') }
+
+    subject { renderer.render node }
+
+    context "when attempting to render an unsupported type" do
+
+      it "raises an ArgumentError" do
+        expect { subject }.to raise_error ArgumentError
+      end
+    end
+  end
+end

data/spec/visitors/chewy_term_filter_spec.rb

@@ -10,20 +10,37 @@ describe MSFLVisitors::Visitor do
 
   let(:visitor) { described_class.new collector, renderer }
 
-  let(:left) { MSFLVisitors::Nodes::Word.new "lhs" }
+  let(:left) { MSFLVisitors::Nodes::Field.new "lhs" }
 
   let(:right) { MSFLVisitors::Nodes::Word.new "rhs" }
 
-  subject(:result) { node.accept visitor }
+  subject(:result) { collector }
+
+  before(:each) { node.accept visitor }
 
   context "when visiting" do
 
+    describe "a Set node" do
+
+      let(:node) { MSFLVisitors::Nodes::Set::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: 'left == right'" do
-        expect(result).to eq "lhs == rhs"
+        expect(result).to eq "lhs == \"rhs\""
       end
     end
 
@@ -32,7 +49,7 @@ describe MSFLVisitors::Visitor do
       let(:node) { MSFLVisitors::Nodes::GreaterThan.new left, right }
 
       it "returns: 'left > right'" do
-        expect(result).to eq "lhs > rhs"
+        expect(result).to eq "lhs > \"rhs\""
       end
     end
 
@@ -41,7 +58,7 @@ describe MSFLVisitors::Visitor do
       let(:node) { MSFLVisitors::Nodes::GreaterThanEqual.new left, right }
 
       it "returns: 'left >= right'" do
-        expect(result).to eq "lhs >= rhs"
+        expect(result).to eq "lhs >= \"rhs\""
       end
     end
 
@@ -50,7 +67,7 @@ describe MSFLVisitors::Visitor do
       let(:node) { MSFLVisitors::Nodes::LessThan.new left, right }
 
       it "returns: 'left < right'" do
-        expect(result).to eq "lhs < rhs"
+        expect(result).to eq 'lhs < "rhs"'
       end
     end
 
@@ -59,16 +76,63 @@ describe MSFLVisitors::Visitor do
       let(:node) { MSFLVisitors::Nodes::LessThanEqual.new left, right }
 
       it "returns: 'left <= right'" do
-        expect(result).to eq "lhs <= rhs"
+        expect(result).to eq 'lhs <= "rhs"'
       end
     end
 
     describe "an And node" do
 
-      let(:node) { MSFLVisitors::Nodes::And.new left, right }
+      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) }
 
-      it "returns: '( left ) & ( right )'" do
-        expect(result).to eq "( lhs ) & ( rhs )"
+      context "when the And node has zero items" do
+        let(:node) { MSFLVisitors::Nodes::And.new([]) }
+
+        it "is empty" do
+          expect(result).to be_empty
+        end
+      end
+
+      context "when the node has one item" do
+
+        let(:node) { MSFLVisitors::Nodes::And.new([first])}
+
+        it "returns: the item without adding parentheses" do
+          expect(result).to eq 'first_field == "first_word"'
+        end
+      end
+
+      context "when the node has two items" do
+
+        let(:node) { MSFLVisitors::Nodes::And.new([first, second]) }
+
+        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 the node has three items" do
+
+        let(:node) { MSFLVisitors::Nodes::And.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" )'
+        end
       end
     end
 
@@ -106,8 +170,8 @@ describe MSFLVisitors::Visitor do
 
         let(:node) { MSFLVisitors::Nodes::Word.new word }
 
-        it "is a literal string" do
-          expect(result).to eq word
+        it "is a double quoted literal string" do
+          expect(result).to eq "\"#{word}\""
         end
       end
     end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: msfl_visitors
 version: !ruby/object:Gem::Version
-  version: 0.0.4
+  version: 0.1.0.dev
 platform: ruby
 authors:
 - Courtland Caldwell
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-05-01 00:00:00.000000000 Z
+date: 2015-05-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: msfl
@@ -119,22 +119,30 @@ files:
 - lib/msfl_visitors/nodes/and.rb
 - lib/msfl_visitors/nodes/base.rb
 - lib/msfl_visitors/nodes/binary.rb
+- lib/msfl_visitors/nodes/binary_and.rb
 - lib/msfl_visitors/nodes/boolean.rb
 - lib/msfl_visitors/nodes/comparison.rb
 - lib/msfl_visitors/nodes/constant_value.rb
+- lib/msfl_visitors/nodes/containment.rb
 - lib/msfl_visitors/nodes/date.rb
 - lib/msfl_visitors/nodes/date_time.rb
 - lib/msfl_visitors/nodes/equal.rb
+- lib/msfl_visitors/nodes/field.rb
 - lib/msfl_visitors/nodes/filter.rb
 - lib/msfl_visitors/nodes/greater_than.rb
 - lib/msfl_visitors/nodes/greater_than_equal.rb
 - lib/msfl_visitors/nodes/grouping/close.rb
 - lib/msfl_visitors/nodes/grouping/grouping.rb
 - lib/msfl_visitors/nodes/grouping/open.rb
+- lib/msfl_visitors/nodes/iterator.rb
 - lib/msfl_visitors/nodes/less_than.rb
 - lib/msfl_visitors/nodes/less_than_equal.rb
 - lib/msfl_visitors/nodes/number.rb
 - lib/msfl_visitors/nodes/range_value.rb
+- lib/msfl_visitors/nodes/set/close.rb
+- lib/msfl_visitors/nodes/set/delimiter.rb
+- lib/msfl_visitors/nodes/set/open.rb
+- lib/msfl_visitors/nodes/set/set.rb
 - lib/msfl_visitors/nodes/time.rb
 - lib/msfl_visitors/nodes/value.rb
 - lib/msfl_visitors/nodes/word.rb
@@ -143,7 +151,10 @@ files:
 - lib/msfl_visitors/visitor.rb
 - msfl_visitors.gemspec
 - simplecov_custom_profiles.rb
-- spec/parsers/parse_msfl_spec.rb
+- spec/ast_spec.rb
+- spec/nodes/iterator_spec.rb
+- spec/parsers/msfl_parser_spec.rb
+- spec/renderers/chewy/term_filter_spec.rb
 - spec/spec_helper.rb
 - spec/visitors/chewy_term_filter_spec.rb
 homepage: https://github.com/Referly/msfl_visitors
@@ -161,9 +172,9 @@ required_ruby_version: !ruby/object:Gem::Requirement
       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.2.2
@@ -171,7 +182,10 @@ signing_key:
 specification_version: 4
 summary: Convert MSFL to other forms
 test_files:
-- spec/parsers/parse_msfl_spec.rb
+- spec/ast_spec.rb
+- spec/nodes/iterator_spec.rb
+- spec/parsers/msfl_parser_spec.rb
+- spec/renderers/chewy/term_filter_spec.rb
 - spec/spec_helper.rb
 - spec/visitors/chewy_term_filter_spec.rb
 has_rdoc: 

data/spec/parsers/parse_msfl_spec.rb

@@ -1,22 +0,0 @@
-# This is a working file until I split these up
-require 'spec_helper'
-
-describe MSFLVisitors::Parsers::MSFLParser do
-
-   describe "parsing a trivial filter" do
-
-     subject { described_class.new.parse msfl }
-
-     let(:msfl) { { make: "Ferrari" } }
-
-     let(:expected) { MSFLVisitors::Nodes::Filter.new [ MSFLVisitors::Nodes::Equal.new(left, right) ] }
-
-     let(:left) { MSFLVisitors::Nodes::Word.new :make }
-
-     let(:right) { MSFLVisitors::Nodes::Word.new "Ferrari" }
-
-     it "is the expected AST" do
-       expect(subject).to eq expected
-     end
-   end
-end