msfl_visitors 0.1.0.rc0 → 0.1.0.rc1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: ea4ecf6626a9a55c1c9498d10d8e64fd382e046a
-  data.tar.gz: 848033290c03302400ab3311c216a3cf69c47fee
+  metadata.gz: 2156e94f555e526308eabb17c416c12883081b18
+  data.tar.gz: 210369d1ba7954ad0132d189e8c0976845ca294a
 SHA512:
-  metadata.gz: 2483e48b85610b202bc5d2cf1d755608eea89d0629417e1bf148f088a8f25e7924ae8129c69ce428ba9c223c5c161e8798c8208e73c66c25cebc10fe6bfb6c94
-  data.tar.gz: d68a784620b91a8b1f9bb8009ed849eacee1621ed4dc0711a2ef9fc5c59c41f40c1e1554bd44e36c089835fffc39bf5be6ab048f2a340e60b836b808041844b1
+  metadata.gz: 88dbf7a0b57600f139098d0a334f25d3b3404b9ebf8299d6fb97cda1e6c15db510f34fb62c0f4b2f098bb349dd1071b7ecef6e9b1ab9c2d71ffe71e3e729740f
+  data.tar.gz: 11c609cbf7a04bd5a4fd2248e49b956384af7d758399d2ad1a3c9601fd192b9ef8062715625ff2064c1149be82a9de40fefbd1279ee031bc86aa396630f74279

data/lib/msfl_visitors/parsers/msfl_parser.rb

@@ -2,12 +2,17 @@ require 'msfl'
 module MSFLVisitors
   module Parsers
     class MSFLParser
-      include MSFL::Validators::Definitions::HashKey
+      # include MSFL::Validators::Definitions::HashKey
 
       OPERATORS_TO_NODE_CLASS = {
+          and:        Nodes::And,
           gt:         Nodes::GreaterThan,
           gte:        Nodes::GreaterThanEqual,
+          eq:         Nodes::Equal,
+          lt:         Nodes::LessThan,
+          lte:        Nodes::LessThanEqual,
           in:         Nodes::Containment,
+
       }
 
       def parse(obj, lhs = false)
@@ -58,7 +63,7 @@ module MSFLVisitors
       end
 
       def hash_dispatch(key, value, lhs = false)
-        if hash_key_operators.include? key
+        if OPERATORS_TO_NODE_CLASS.include? key
           # 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)]

data/msfl_visitors.gemspec

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

data/spec/parsers/msfl_parser_spec.rb

@@ -3,17 +3,19 @@ require 'spec_helper'
 
 describe MSFLVisitors::Parsers::MSFLParser do
 
-  let(:expected_node) { ->(comp_node) { MSFLVisitors::Nodes::Filter.new [ comp_node ] } }
+  let(:expected_node) { ->(wrapped_node) { MSFLVisitors::Nodes::Filter.new [ wrapped_node ] } }
 
   let(:left) { MSFLVisitors::Nodes::Field.new :value }
 
-  let(:right) { MSFLVisitors::Nodes::Number.new 1000 }
+  let(:right) { MSFLVisitors::Nodes::Number.new one_thousand }
+
+  let(:one_thousand) { 1000 }
 
   describe "parsing a trivial filter" do
 
     subject { described_class.new.parse msfl }
 
-    let(:msfl) { { value: 1000 } }
+    let(:msfl) { { value: one_thousand } }
 
     it "is the expected node" do
       expect(subject).to eq expected_node.call(MSFLVisitors::Nodes::Equal.new(left, right))
@@ -24,45 +26,116 @@ describe MSFLVisitors::Parsers::MSFLParser do
 
     context "when parsing a filter" do
 
-      subject { -> (filter) { described_class.new.parse filter } }
+      subject { described_class.new.parse(filter) }
+
+      let(:set_of_values) { MSFL::Types::Set.new [50, 250, 20000] }
+
+      let(:set_of_nodes) { set_of_values.map { |value| MSFLVisitors::Nodes::Number.new value } }
+
+      let(:set_node) { MSFLVisitors::Nodes::Set::Set.new set_of_nodes }
+
+      describe "parsing implicit equality" do
+
+        let(:filter) { { value: one_thousand } }
+
+        it "is the expected Equal node" do
+          expect(subject).to eq expected_node.call(MSFLVisitors::Nodes::Equal.new(left, right))
+        end
+      end
+
+      describe "parsing explict comparisons" do
+
+        describe "parsing a gt filter" do
+
+          let(:filter) { { value: { gt: one_thousand } } }
+
+          let(:gt_node) { MSFLVisitors::Nodes::GreaterThan.new left, right }
+
+          it "is the expected GreaterThan node" do
+            expect(subject).to eq expected_node.call(gt_node)
+          end
+        end
+
+        describe "parsing a gte filter" do
+
+          let(:filter) { { value: { gte: one_thousand } } }
+
+          let(:gte_node) { MSFLVisitors::Nodes::GreaterThanEqual.new left, right }
+
+          it "is the expected GreaterThanEqual node" do
+            expect(subject).to eq expected_node.call(gte_node)
+          end
+        end
+
+        describe "parsing a eq filter" do
+
+          let(:filter) { { value: { eq: one_thousand } } }
+
+          let(:eq_node) { MSFLVisitors::Nodes::Equal.new left, right }
+
+          it "is the expected Equal node" do
+            expect(subject).to eq expected_node.call(eq_node)
+          end
+        end
+
+        describe "parsing a lt filter" do
+
+          let(:filter) { { value: { lt: one_thousand } } }
 
-      let(:implicit_equality_filter) { { value: 1000 } }
+          let(:lt_node) { MSFLVisitors::Nodes::LessThan.new left, right }
+
+          it "is the expected LessThan node" do
+            expect(subject).to eq expected_node.call(lt_node)
+          end
+        end
 
-      let(:explicit_gte_filter) { { value: { gte: 1000 } } }
+        describe "parsing a lte filter" do
 
-      let(:containment_filter) { { value: { in: containment_values } } }
+          let(:filter) { { value: { lte: one_thousand } } }
 
-      let(:containment_values) { MSFL::Types::Set.new [50, 250, 20000] }
+          let(:lte_node) { MSFLVisitors::Nodes::LessThanEqual.new left, right }
 
-      it "handles implicit equality comparisons" do
-        expect(subject.call(implicit_equality_filter)).to eq expected_node.call(MSFLVisitors::Nodes::Equal.new(left, right))
+          it "is the expected LessThanEqual node" do
+            expect(subject).to eq expected_node.call(lte_node)
+          end
+        end
       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)
+      describe "parsing containment" do
+
+        let(:filter) { { value: { in: set_of_values } } }
+
+        let(:containment_node) { MSFLVisitors::Nodes::Containment.new left, set_node }
+
+        # { 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 "is the expected Containment node" do
+          expect(subject).to eq expected_node.call(containment_node)
+        end
       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)
+      describe "parsing an and filter" do
+
+        let(:filter) { { and: set_of_values } }
+
+        let(:and_node) { MSFLVisitors::Nodes::And.new set_node }
+
+        it "is the expected And node" do
+          expect(subject).to eq expected_node.call(and_node)
+        end
       end
 
       context "when the filter contains an unsupported type" do
 
-        let(:bad_filter) { { foo: Object.new } }
+        let(:filter) { { foo: Object.new } }
 
         it "raises an ArgumentError" do
-          expect { subject.call(bad_filter) }.to raise_error ArgumentError
+          expect { subject }.to raise_error ArgumentError
         end
       end
     end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: msfl_visitors
 version: !ruby/object:Gem::Version
-  version: 0.1.0.rc0
+  version: 0.1.0.rc1
 platform: ruby
 authors:
 - Courtland Caldwell
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-05-06 00:00:00.000000000 Z
+date: 2015-05-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: msfl