msfl 1.1.1 → 1.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 8b2132d5eaec0ac5b4a2055174d6f40685580f40
-  data.tar.gz: 0ff98ee3c34b4225a43c8e9433b0c08b87e2521f
+  metadata.gz: e60cd25d855a736231fddc1f1d893df5a1b45296
+  data.tar.gz: cd75be374c724735b63103dcd8c9f5d2b021d480
 SHA512:
-  metadata.gz: cdacb790d452b5343363f7b8e420f4a37aabd3e5e16f2005031545f79389c06f528c42601ef8f537350a993cfce5b1af745b5607142c041af50df784930091ba
-  data.tar.gz: 5c429cf64452914f271a8ad7513627e009c1d8ea33c1a5f9768277df9f2c660f62c02615a4823bb434fed98c1c9478383e8337495646b8f93579390cc54f8fd0
+  metadata.gz: 888ff6048f6f675f75f1f518ef928ce66d1d0fe40f651d6597738050b0845064392533d0f0c28bfebf7cc2ce1495df0d27f3014414bbbe1e133063d42202052d
+  data.tar.gz: 6c0e6b5f896bb6061abcfdd9e572cc0c90d804bee82127d09f6ace0b7278403288c48fa63ca0374408cbefcbc9dd31639ded8297df9a68f51d75bb4995449471

data/lib/msfl/converters/operator.rb

@@ -3,6 +3,58 @@ module MSFL
     class Operator
       include MSFL::Validators::Definitions::HashKey
 
+      # Order is respected by run_conversions
+      # in otherwords run_conversions executes conversions in the order they occur
+      # in CONVERSIONS, not in the order in which they are passed into the method
+      #
+      # conversion order is context-free
+      CONVERSIONS = [
+          :implicit_between_to_explicit_recursively,
+          :between_to_gte_lte_recursively,
+          :implicit_and_to_explict_recursively
+      ]
+
+      # Runs conversions on an object
+      # It respects the order of CONVERSIONS, not the order of elements in conversions_to_run
+      #
+      # @param obj [Object] the object to run the conversions on
+      # @param conversions_to_run [Array<Symbol>] an array of the conversions that should be run, duplicates are ignored
+      # @return [Object] the object with the conversions applied
+      def run_conversions(obj, conversions_to_run = nil)
+        conversions_to_run ||= CONVERSIONS
+        unless all_conversions?(conversions_to_run)
+          raise ArgumentError, "#run_conversions second argument is optional, if specified it must be an Array of Symbols"
+        end
+
+        CONVERSIONS.each do |conv|
+          # In the order that items are in CONVERSIONS run all of the conversions_to_run
+          obj = send(conv, obj) if conversions_to_run.include?(conv)
+        end
+      end
+
+
+
+      # { year: { start: 2001, end: 2005 } }
+      #  => { year: { between: { start: 2001, end: 2015 } } }
+      def implicit_between_to_explicit_recursively(obj)
+        if obj.is_a? Hash
+          # if the hash has two keys :start and :end, nest it inside a between and recurse on the values
+          if obj.has_key?(:start) && obj.has_key?(:end)
+            result = { between: { start: implicit_between_to_explicit_recursively(obj[:start]), end: implicit_between_to_explicit_recursively(obj[:end]) } }
+          else
+            result = Hash.new
+            obj.each do |k, v|
+              result[k] = implicit_between_to_explicit_recursively(v)
+            end
+          end
+        elsif obj.is_a? Types::Set
+          result = recurse_through_set :implicit_between_to_explicit_recursively, obj
+        elsif obj.is_a? Array
+          raise ArgumentError, "#implicit_between_to_explicit_recursively requires that it does not contain any Arrays - its argument should preprocessed by .arrays_to_sets and .convert_keys_to_symbols"
+        end
+        result ||= obj
+      end
+
       # Recursively converts all between operators to equivalent anded gte / lte
       # it currently creates the converted operators into the implied AND format
       #
@@ -21,10 +73,7 @@ module MSFL
             end
           end
         elsif obj.is_a? Types::Set
-          result = Types::Set.new
-          obj.each do |v|
-            result << between_to_gte_lte_recursively(v)
-          end
+          result = recurse_through_set :between_to_gte_lte_recursively, obj
         elsif obj.is_a? Array
           raise ArgumentError, "#between_to_gte_lte requires that it does not contain any Arrays - its argument should preprocessed by .arrays_to_sets and .convert_keys_to_symbols"
         end
@@ -62,13 +111,8 @@ module MSFL
               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
+                result = Hash.new
+                result[first_key] = recurse_through_set :implicit_and_to_explicit_recursively, obj[first_key]
               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
@@ -110,7 +154,6 @@ module MSFL
         # 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
@@ -122,7 +165,6 @@ module MSFL
           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
@@ -135,12 +177,28 @@ module MSFL
       end
 
       def i_to_e_set(set, parent_key = nil)
+        recurse_through_set :implicit_and_to_explicit_recursively, set
+      end
+
+      def recurse_through_set(method, set)
         result = MSFL::Types::Set.new
         set.each do |v|
-          result << implicit_and_to_explicit_recursively(v)
+          result << send(method, v)
         end
         result
       end
+
+      # Returns true if the argument is an Array of Symbols, otherwise false
+      #
+      # @param obj [Obj] the object to check
+      # @return [Bool] true if the argument is an Array of Symbols
+      def all_conversions?(obj)
+        return false unless obj.is_a?(Array)
+        obj.each do |v|
+          return false unless v.is_a?(Symbol)
+        end
+        true
+      end
     end
   end
 end

data/msfl.gemspec

@@ -1,6 +1,6 @@
 Gem::Specification.new do |s|
   s.name        = 'msfl'
-  s.version     = '1.1.1'
+  s.version     = '1.1.2'
   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

@@ -2,6 +2,208 @@ require 'spec_helper'
 
 describe "MSFL::Converters::Operator" do
 
+  describe "#run_conversions" do
+
+    subject { test_instance.run_conversions obj, conversions_to_run }
+
+    let(:klass) do
+      class OpTestConverter < MSFL::Converters::Operator
+      end
+      OpTestConverter
+    end
+
+    let(:test_instance) { klass.new }
+
+    let(:obj) { Object.new }
+
+    let(:conversions_to_run) { nil }
+
+    context "when the conversions_to_run argument is nil" do
+
+      let(:test_instance) do
+        t_i = klass.new
+
+        allow(t_i).to receive(:implicit_between_to_explicit_recursively)
+        expect(t_i).to receive(:implicit_between_to_explicit_recursively).once
+
+        allow(t_i).to receive(:between_to_gte_lte_recursively)
+        expect(t_i).to receive(:between_to_gte_lte_recursively).once
+
+        allow(t_i).to receive(:implicit_and_to_explict_recursively)
+        expect(t_i).to receive(:implicit_and_to_explict_recursively).once
+        t_i
+      end
+
+      it "runs all conversions in CONVERSIONS" do
+        subject
+      end
+    end
+
+    context "when conversions_to_run is an array of symbols" do
+
+      let(:conversions_to_run) { [:implicit_and_to_explict_recursively, :between_to_gte_lte_recursively]}
+
+      it "runs all elements in CONVERSIONS that are in conversions_to_run" do
+        allow(test_instance).to receive :implicit_and_to_explict_recursively
+        expect(test_instance).to receive(:implicit_and_to_explict_recursively)
+
+        allow(test_instance).to receive :between_to_gte_lte_recursively
+        expect(test_instance).to receive(:between_to_gte_lte_recursively)
+
+        allow(test_instance).to receive :implicit_between_to_explicit_recursively
+        expect(test_instance).to receive(:implicit_between_to_explicit_recursively).never
+
+        subject
+      end
+
+      it "runs the indicated conversions exactly once" do
+
+        allow(test_instance).to receive :implicit_and_to_explict_recursively
+        expect(test_instance).to receive(:implicit_and_to_explict_recursively).once
+
+        allow(test_instance).to receive :between_to_gte_lte_recursively
+        expect(test_instance).to receive(:between_to_gte_lte_recursively).once
+
+        subject
+      end
+
+      it "runs the indicated conversions in the order they appear in CONVERSIONS" do
+
+        allow(test_instance).to receive :between_to_gte_lte_recursively
+        expect(test_instance).to receive(:between_to_gte_lte_recursively).ordered
+
+        allow(test_instance).to receive :implicit_and_to_explict_recursively
+        expect(test_instance).to receive(:implicit_and_to_explict_recursively).ordered
+
+        subject
+      end
+    end
+
+
+    context "when conversions_to_run is not nil and not an array of symbols" do
+
+      let(:conversions_to_run) { "foo" }
+
+      it "raises an ArgumentError" do
+        expect { subject }.to raise_error ArgumentError
+      end
+    end
+  end
+
+  describe "#implicit_between_to_explicit_recursively" do
+
+    subject { test_instance.implicit_between_to_explicit_recursively arg }
+
+    let(:test_instance) { MSFL::Converters::Operator.new }
+
+    let(:arg) { raise ArgumentError, "You are expected to define the arg variable" }
+
+    let(:expected) { raise ArgumentError, "You are expected to define the expected value" }
+
+    context "when there is not an implicit BETWEEN" do
+
+      ["foo", { foo: "bar" }, 123, 56.12, :aaaah].each do |arg|
+
+        context "when the argument is #{arg}" do
+
+          let(:arg) { arg }
+
+          it "is the argument unchanged" do
+            expect(subject).to eq arg
+          end
+        end
+      end
+    end
+
+    context "when there is an implicit BETWEEN" do
+
+      context "when the implicit BETWEEN is at the highest possible level of the filter" do
+
+        let(:arg) { { year: { start: 2001, end: 2005 } } }
+
+        let(:expected) { { year: { between: { start: 2001, end: 2005 } } } }
+
+        it "is an explicit BETWEEN" do
+          expect(subject).to eq expected
+        end
+      end
+
+      context "when the implicit BETWEEN is inside of a MSFL::Types::Set" do
+
+        let(:arg) do
+          { and:
+                MSFL::Types::Set.new([
+                                         { make: "Honda"},
+                                         { year: { start: 2001, end: 2005 } }
+                                 ])
+          }
+        end
+
+        let(:expected) do
+          { and: MSFL::Types::Set.new([
+                                          { make: "Honda" },
+                                          { year: { between: { start: 2001, end: 2005 } } }
+                                      ])}
+        end
+
+        it "recursively converts the implicit BETWEEN to an explicit BETWEEN" do
+          expect(subject).to eq expected
+        end
+      end
+
+      # This can't actually happen in the current MSFL syntax (at least I don't think it can)
+      context "when the implicit BETWEEN is inside of another Hash" do
+
+        let(:arg) do
+          { foo: { bar: { start: "2015-01-01", end: "2015-03-01" } } }
+        end
+
+        let(:expected) do
+          { foo: { bar: { between: { start: "2015-01-01", end: "2015-03-01" } } } }
+        end
+
+        it "recursively converts the implicit BETWEEN to an explicit BETWEEN" do
+          expect(subject).to eq expected
+        end
+      end
+
+      context "when there are multiple implicit BETWEENs that are deeply nested" do
+
+        let(:deep_nest) do
+          {
+              cat: 1221,
+              dog: "fur",
+              lol: MSFL::Types::Set.new([ { hat: { start: 1, end: 5 } } ]),
+              :"1337" => 1337.1337,
+              noob: MSFL::Types::Set.new([
+                                             MSFL::Types::Set.new([123]),
+                                             { :"123" => 456, onetwo: { start: 3, end: 4 } } ]) }
+        end
+
+        let(:arg) { deep_nest }
+
+        let(:expected) do
+          {
+              cat: 1221,
+              dog: "fur",
+              lol: MSFL::Types::Set.new([
+                                            { hat: { between: { start: 1, end: 5 } } }
+                                        ]),
+              :"1337" => 1337.1337,
+              noob: MSFL::Types::Set.new([
+                                             MSFL::Types::Set.new([123]),
+                                             { :"123" => 456, onetwo: { between: { start: 3, end: 4 } } }
+                                         ])
+          }
+        end
+
+        it "recursively converts the implicit BETWEENs to an explicit BETWEENs" do
+          expect(subject).to eq expected
+        end
+      end
+    end
+  end
+
   describe "#implicit_and_to_explicit" do
 
     subject(:mut) { test_instance.implicit_and_to_explicit_recursively arg }

metadata

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