msfl 1.1.0 → 1.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 51e5ed15234f2119cf9a96d709f7cb15505f6e75
-  data.tar.gz: b31ccaeae664a0d09c359322875a892d55808e71
+  metadata.gz: 8b2132d5eaec0ac5b4a2055174d6f40685580f40
+  data.tar.gz: 0ff98ee3c34b4225a43c8e9433b0c08b87e2521f
 SHA512:
-  metadata.gz: 6b8cdc31ca60efdbb600107dfd98c10580eac574c3677c2a24b34fdbf7933de5c488d719340a3a8d048c9b4be520b06ad456df80f7413c803f8cae607f24c391
-  data.tar.gz: 1a41e178d9b1230eeb16503b4411bc85a6daebc8260df764aea726c7880ee1fb11f608e316654bbfc64a433b46ee4e1675dfb2d15b114cd97d903f1a13258ab9
+  metadata.gz: cdacb790d452b5343363f7b8e420f4a37aabd3e5e16f2005031545f79389c06f528c42601ef8f537350a993cfce5b1af745b5607142c041af50df784930091ba
+  data.tar.gz: 5c429cf64452914f271a8ad7513627e009c1d8ea33c1a5f9768277df9f2c660f62c02615a4823bb434fed98c1c9478383e8337495646b8f93579390cc54f8fd0

data/lib/msfl/converters/operator.rb

@@ -49,22 +49,28 @@ module MSFL
       def implicit_and_to_explicit_recursively(obj, parent_key = nil)
         if obj.is_a? Hash
           first_key = obj.keys.first
-          if hash_key_operators.include?(first_key)
-            # the first key an operator
-            raise ArgumentError, "#implicit_and_to_explicit requires that all or none of a hash's keys be operators" unless all_operators?(obj.keys)
-            # all keys are operators
-            raise ArgumentError, "#implicit_and_to_explicit requires that parent_key be specified when converting operators" if parent_key.nil?
-            # parent key is non nil
-            and_array = []
-            obj.each do |k, v|
-              and_array << { parent_key => { k => implicit_and_to_explicit_recursively(v, k) } }
-            end
+          if binary_operators.include?(first_key)
+            result = i_to_e_bin_op obj, parent_key
+          elsif logical_operators.include?(first_key)
+            result = i_to_e_log_op obj, parent_key
           else
             # the first key is not an operator
             # if there is only one key just assign the result of calling this method recursively on the value to the result for the key
             if obj.keys.count == 1
               if obj[first_key].is_a?(Hash)
                 result = implicit_and_to_explicit_recursively obj[first_key], first_key
+              elsif obj[first_key].is_a? MSFL::Types::Set
+                # This situation occurs when there are nested logical operators
+                # obj is a hash, with one key that is not a binary operator which has a value that is a MSFL::Types::Set
+                result = { }
+                and_array = MSFL::Types::Set.new
+                obj[first_key].each do |v|
+                  # byebug
+                  and_array << implicit_and_to_explicit_recursively(v)
+                end
+                result[first_key] = and_array
+              elsif obj[first_key].is_a? Array
+                raise ArgumentError, "#implicit_and_to_explicit requires that it does not contain any Arrays - its argument should preprocessed by .arrays_to_sets and .convert_keys_to_symbols"
               end
             else
               raise ArgumentError, "#implicit_and_to_explicit requires that all or none of a hash's keys be operators" if any_operators?(obj.keys)
@@ -77,14 +83,11 @@ module MSFL
                   and_array << { k => v }
                 end
               end
+              result = { and: MSFL::Types::Set.new(and_array) }
             end
           end
-          result ||= { and: MSFL::Types::Set.new(and_array) }
         elsif obj.is_a? MSFL::Types::Set
-          result = Types::Set.new
-          obj.each do |v|
-            result << implicit_and_to_explicit_recursively(v)
-          end
+          result = i_to_e_set obj, parent_key
         elsif obj.is_a? Array
           raise ArgumentError, "#implicit_and_to_explicit requires that it does not contain any Arrays - its argument should preprocessed by .arrays_to_sets and .convert_keys_to_symbols"
         end
@@ -92,23 +95,51 @@ module MSFL
       end
 
     private
-      # Use this method for converting implicit and hashes to explicit ones when the keys are operators
-      def implicit_to_explicit_for_ops(hash)
-        and_array = []
-        field = hash.keys.first
-        if hash[field].is_a? Hash
-          hash[field].each do |k, v|
-            and_array << { field => { k => v } }
+      # Recursively handle a hash containing keys that are all logical operators
+      def i_to_e_log_op(hash, parent_key = nil)
+        raise ArgumentError, "#implicit_and_to_explicit requires that all or none of a hash's keys be logical operators" unless all_logical_operators?(hash.keys)
+        result = {}
+        hash.each do |key, value|
+          result[key] = implicit_and_to_explicit_recursively value
+        end
+        result
+      end
+
+      # Recursively handle a hash containing keys that are all binary operators
+      def i_to_e_bin_op(hash, parent_key = nil)
+        # the first key an operator
+        raise ArgumentError, "#implicit_and_to_explicit requires that all or none of a hash's keys be operators" unless all_operators?(hash.keys)
+        # all keys are operators
+
+        first_key = hash.keys.first
+        if hash.keys.count == 1
+          # There's only one key so there cannot be an implied AND at this level
+          if parent_key && (! binary_operators.include?(parent_key)) # this needs more testing - I'm not entirely sure if I should check for this esoteric case of immediately nested explicit ANDs inside of an implied AND
+            # The parent_key argument was provided which means that the caller expects the result to be a hash of at least two levels
+            # where the first level has a key of the parent_key with a value of a hash
+            # first_key is passed in the recursive call
+            { parent_key => { first_key => implicit_and_to_explicit_recursively(hash[first_key], first_key)}}
+          else
+            { first_key => implicit_and_to_explicit_recursively(hash[first_key]) }
           end
+
+        else
+          raise ArgumentError, "#implicit_and_to_explicit requires that parent_key be specified when converting operators" if parent_key.nil?
+          # parent key is non nil
+          and_array = []
+          hash.each do |k, v|
+            and_array << { parent_key => { k => implicit_and_to_explicit_recursively(v, k) } }
+          end
+          { and: MSFL::Types::Set.new(and_array) }
         end
-        { and: MSFL::Types::Set.new(and_array) }
       end
 
-      # Use this method for converting implicit and hashes to explicit ones when the keys are properties
-      def implicit_to_explicit_for_field(hash)
-        and_array = []
-        hash.each { |key, value| and_array << { key => value } }
-        { and: MSFL::Types::Set.new(and_array) }
+      def i_to_e_set(set, parent_key = nil)
+        result = MSFL::Types::Set.new
+        set.each do |v|
+          result << implicit_and_to_explicit_recursively(v)
+        end
+        result
       end
     end
   end

data/lib/msfl/validators/definitions/hash_key.rb

@@ -13,9 +13,11 @@ module MSFL
 
         # Operators still needing parsing: ellipsis2, tilda
         def hash_key_operators
+          binary_operators.concat(logical_operators)
+        end
+
+        def binary_operators
           [
-              :and,         # logical AND
-              :or,          # logical OR
               :in,          # IN
               :between,     # inclusive range for integers, dates, and date times
               :start,       # a range bound inclusively to the left
@@ -31,6 +33,10 @@ module MSFL
           ]
         end
 
+        def logical_operators
+          [:and, :or]
+        end
+
         # Returns true if all elements of arr are operators, false otherwise
         #
         # @param arr [Array<Symbol>] the Array of Symbols to be checked against the operators list
@@ -42,6 +48,18 @@ module MSFL
           true
         end
 
+
+        # Returns true if all elements of arr are logical operators, false otherwise
+        #
+        # @param arr [Array<Symbol>] and array of symbols to check to see if all elements are logical operators
+        # @return [Bool] it is true if all the elements are logical operators, otherwise false
+        def all_logical_operators?(arr)
+          arr.each do |e|
+            return false unless logical_operators.include?(e)
+          end
+          true
+        end
+
         # Returns true if any of the elements in arr are operators, otherwise false
         #
         # @param arr [Array] the array of elements to check for the presence of operators

data/msfl.gemspec

@@ -1,6 +1,6 @@
 Gem::Specification.new do |s|
   s.name        = 'msfl'
-  s.version     = '1.1.0'
+  s.version     = '1.1.1'
   s.date        = '2015-04-01'
   s.summary     = "MSFL in Ruby"
   s.description = "Serializers, validators, and other tasty goodness for the Mattermark Semantic Filter Language in Ruby."

data/spec/msfl/converters/operator_spec.rb

@@ -12,6 +12,40 @@ describe "MSFL::Converters::Operator" do
 
     let(:expected) { raise ArgumentError, "You are expected to define the expected value" }
 
+    context "when there is not an implicit AND" do
+
+      let(:expected) { arg }
+
+      context "when the arg is a scalar" do
+
+        let(:arg) { 50 }
+
+        it "is the arg unchanged" do
+          expect(mut).to eq expected
+        end
+      end
+
+      context "when the arg is single level" do
+
+        let(:arg) { { gte: 1000 }  }
+
+        it "is the arg unchanged" do
+          expect(mut).to eq expected
+        end
+      end
+
+      context "when the arg is multi level" do
+
+        let(:arg) { { value: { gte: 1000 } } }
+
+        it "is the arg unchanged" do
+          expect(mut).to eq expected
+        end
+      end
+
+
+    end
+
     context "when the implicit AND exists on a Hash whose keys are fields" do
 
       # TYPE 1 --- { make: "chevy", year: 2010 } => { and: [ { make: "chevy" }, { year: 2010 }] }
@@ -64,6 +98,33 @@ describe "MSFL::Converters::Operator" do
         end
       end
     end
+
+    context "when the implicit AND is within a MSFL::Types::Set" do
+
+      let(:arg) do
+        { and: MSFL::Types::Set.new([
+                                       { make: "chevy", year: { gte: 2010, lte: 2012 } },
+                                       { value: { gte: 1000 } }
+                                   ])}
+      end
+
+      let(:expected) do
+        { and: MSFL::Types::Set.new([
+                                       { and: MSFL::Types::Set.new([
+                                                                       { make: "chevy" },
+                                                                       { and: MSFL::Types::Set.new([
+                                                                                                       { year: { gte: 2010 } },
+                                                                                                       { year: { lte: 2012 } }
+                                                                                                   ])}
+                                       ])},
+                                       { value: { gte: 1000 } }
+                                   ])}
+      end
+
+      it "converts all of the implicit ANDs" do
+        expect(mut).to eq expected
+      end
+    end
   end
 
   describe "#between_to_gte_lte_recursively" do

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: msfl
 version: !ruby/object:Gem::Version
-  version: 1.1.0
+  version: 1.1.1
 platform: ruby
 authors:
 - Courtland Caldwell