msfl 1.0.0 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 563d3ef0c03cf0f730fce20bca483a0821114b07
-  data.tar.gz: 55d9c65bd08ff2112be042f643cb5db0e02ffbc0
+  metadata.gz: 51e5ed15234f2119cf9a96d709f7cb15505f6e75
+  data.tar.gz: b31ccaeae664a0d09c359322875a892d55808e71
 SHA512:
-  metadata.gz: d9c693af109604a14129e16660d56ef5430b7039a4ada968a1d66c78cdf5be537154d7d7fcd87b577d626619ce81260aa715fa19a790d8a1636f4827946d0d25
-  data.tar.gz: ca8a5143b80148cd2f37527c87400ce72abb527833299645af6ed592c9d861a73167f3adb094f19b8780bb05fddb280622d74218a2bf3869b21aa90aff39d2d2
+  metadata.gz: 6b8cdc31ca60efdbb600107dfd98c10580eac574c3677c2a24b34fdbf7933de5c488d719340a3a8d048c9b4be520b06ad456df80f7413c803f8cae607f24c391
+  data.tar.gz: 1a41e178d9b1230eeb16503b4411bc85a6daebc8260df764aea726c7880ee1fb11f608e316654bbfc64a433b46ee4e1675dfb2d15b114cd97d903f1a13258ab9

data/lib/msfl.rb

@@ -4,6 +4,7 @@ require_relative 'msfl/validators'
 require_relative 'msfl/configuration'
 require_relative 'msfl/datasets'
 require_relative 'msfl/sinatra'
+require_relative 'msfl/converters'
 
 module MSFL
   class << self

data/lib/msfl/converters.rb

@@ -0,0 +1 @@
+require_relative 'converters/operator'

data/lib/msfl/converters/operator.rb

@@ -0,0 +1,115 @@
+module MSFL
+  module Converters
+    class Operator
+      include MSFL::Validators::Definitions::HashKey
+
+      # Recursively converts all between operators to equivalent anded gte / lte
+      # it currently creates the converted operators into the implied AND format
+      #
+      # @param obj [Object] the object to recurse through to convert all betweens to gte / ltes
+      # @return [Object] the object with betweens converted to anded gte / ltes
+      def between_to_gte_lte_recursively(obj)
+        result = obj
+        if obj.is_a? Hash
+          obj.each do |k, v|
+            if v.is_a?(Hash) && v.has_key?(:between) && v[:between].has_key?(:start) && v[:between].has_key?(:end)
+              lower_bound = between_to_gte_lte_recursively v[:between][:start]
+              upper_bound = between_to_gte_lte_recursively v[:between][:end]
+              result[k] = { gte: lower_bound, lte: upper_bound  }
+            else
+              result[k] = between_to_gte_lte_recursively v
+            end
+          end
+        elsif obj.is_a? Types::Set
+          result = Types::Set.new
+          obj.each do |v|
+            result << between_to_gte_lte_recursively(v)
+          end
+        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
+        result
+      end
+
+      # Convert a Hash containing an implict and into an explicit and
+      #
+      # TYPE 1 ---
+      #     { make: "chevy", year: 2010 }
+      #      =>    { and: [ { make: "chevy" }, { year: 2010 }] }
+      # TYPE 2 ---
+      #     { year: { gte: 2010, lte: 2012 } }
+      #      => { and: [ { year: { gte: 2010 } }, { year: { lte: 2012 } } ] }
+      #
+      # TYPE 3 ---
+      #     { make: "chevy", year: { gte: 2010, lte: 2012 } }
+      #      => { and: [ { make: "chevy" }, { and: [ { year: { gte: 2010 } }, { year: { lte: 2012 } } ] } ] }
+      #
+      # @param obj [Object] the Hash that is an implicit and
+      # @return [Hash] the resulting explicit hash
+      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
+          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
+              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)
+              # none of the keys are operators
+              and_array = []
+              obj.each do |k, v|
+                if v.is_a? Hash
+                  and_array << implicit_and_to_explicit_recursively(v, k)
+                else
+                  and_array << { k => v }
+                end
+              end
+            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
+        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
+        result ||= obj
+      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 } }
+          end
+        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) }
+      end
+    end
+  end
+end

data/lib/msfl/parsers/json.rb

@@ -13,7 +13,6 @@ module MSFL
         obj = ::JSON.parse(json_to_parse)
         obj = arrays_to_sets obj
         obj = convert_keys_to_symbols obj
-        obj = convert_between_to_gte_lte obj
         obj
       end
 
@@ -57,34 +56,6 @@ module MSFL
         end
         result
       end
-
-      # Recursively converts all between operators to equivalent anded gte / lte
-      # it currently creates the converted operators in the implied AND format
-      #
-      # @param obj [Object] the object to recurse through to convert all betweens to gte / ltes
-      # @return [Object] the object with betweens converted to anded gte / ltes
-      def self.convert_between_to_gte_lte(obj)
-        result = obj
-        if obj.is_a? Hash
-          obj.each do |k, v|
-            if v.is_a?(Hash) && v.has_key?(:between) && v[:between].has_key?(:start) && v[:between].has_key?(:end)
-              lower_bound = convert_between_to_gte_lte v[:between][:start]
-              upper_bound = convert_between_to_gte_lte v[:between][:end]
-              result[k] = { gte: lower_bound, lte: upper_bound  }
-            else
-              result[k] = convert_between_to_gte_lte v
-            end
-          end
-        elsif obj.is_a? Types::Set
-          result = Types::Set.new
-          obj.each do |v|
-            result << convert_between_to_gte_lte(v)
-          end
-        elsif obj.is_a? Array
-          raise ArgumentError, ".convert_between_to_gte_lte requires its argument to have been preprocessed by .arrays_to_sets and .convert_keys_to_symbols"
-        end
-        result
-      end
     end
   end
 end

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

@@ -30,6 +30,28 @@ module MSFL
               :neg,         # logical negation
           ]
         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
+        # @return [Bool] true if all of the elements of arr are operators
+        def all_operators?(arr)
+          arr.each do |e|
+            return false unless hash_key_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
+        # @return [Bool] true if any of the elements of arr are operators
+        def any_operators?(arr)
+          arr.each do |e|
+            return true if hash_key_operators.include?(e)
+          end
+          false
+        end
       end
     end
   end

data/msfl.gemspec

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

@@ -0,0 +1,193 @@
+require 'spec_helper'
+
+describe "MSFL::Converters::Operator" do
+
+  describe "#implicit_and_to_explicit" do
+
+    subject(:mut) { test_instance.implicit_and_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 the implicit AND exists on a Hash whose keys are fields" do
+
+      # TYPE 1 --- { make: "chevy", year: 2010 } => { and: [ { make: "chevy" }, { year: 2010 }] }
+      let(:arg) { { make: "chevy", year: 2010 } }
+
+      let(:expected) { { and: MSFL::Types::Set.new([
+                                                       { make: "chevy" },
+                                                       { year: 2010 }
+                                                   ])}}
+
+      it "converts the implicit AND to an explicit AND" do
+        expect(mut).to eq expected
+      end
+    end
+
+    context "when the implicit AND exists on a Hash whose value is a Hash with multiple operator keys" do
+
+      # TYPE 2 --- { year: { gte: 2010, lte: 2012 } } => { and: [ { year: { gte: 2010 } }, { year: { lte: 2012 } } ] }
+      let(:arg) { { year: { gte: 2010, lte: 2012 } } }
+
+      let(:expected) { { and: MSFL::Types::Set.new([
+                                                       { year: { gte: 2010 } },
+                                                       { year: { lte: 2012 } }
+                                                   ])}}
+
+      it "converts the implicit AND to an explicit AND" do
+        expect(mut).to eq expected
+      end
+    end
+
+    context "when the implicit AND exists on a Hash whose keys are fields" do
+
+      context "when the implicit AND exists on a Hash whose value is a Hash with multiple operator keys" do
+
+        # TYPE 3 --- { make: "chevy", year: { gte: 2010, lte: 2012 } } => { and: [ { make: "chevy" }, { and: [ { year: { gte: 2010 } }, { year: { lte: 2012 } } ] } ] }
+        let(:arg) { { make: "chevy", year: { gte: 2010, lte: 2012 } } }
+
+        let(:expected) do
+          { and: MSFL::Types::Set.new([
+                                          { make: "chevy" },
+                                          { and: MSFL::Types::Set.new([
+                                                                          { year: { gte: 2010 } },
+                                                                          { year: { lte: 2012 } }
+                                                                      ])}
+                                      ])}
+        end
+
+        it "converts both of the implicit ANDs to explicit ANDs" do
+          expect(mut).to eq expected
+        end
+      end
+    end
+  end
+
+  describe "#between_to_gte_lte_recursively" do
+
+    subject(:mut) { test_instance.between_to_gte_lte_recursively arg }
+
+    let(:test_instance) { MSFL::Converters::Operator.new }
+
+    let(:arg) { Object.new }
+
+    let(:deep_nest) 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: 34 } ]) }
+    end
+
+    context "when the argument is a type other than MSFL::Types::Set, Hash, or Array" do
+
+      [55, 60.9, "five", :fourty, nil].each do |item|
+        context "when the argument is a #{item.class}" do
+
+          let(:arg) { item }
+
+          it "is equal to the argument" do
+            expect(mut).to eq arg
+          end
+        end
+      end
+    end
+
+    context "when the argument is a Hash" do
+
+      let(:arg) { { foo: { between: { start: "2015-01-01", end: "2015-04-01" } } } }
+
+      let(:expected) { { foo: { gte: "2015-01-01", lte: "2015-04-01" } } }
+
+      it "converts between clauses into anded gte / lte clauses" do
+        expect(mut).to eq expected
+      end
+
+      context "when the between clause is below the second level" do
+
+        let(:arg) do
+          {
+              and: MSFL::Types::Set.new([
+                                            { foo: { between: { start: -500, end: 12 } } },
+                                            { bar: { dog: "cat" } },
+                                        ])
+          }
+        end
+
+        let(:expected) do
+          {
+              and: MSFL::Types::Set.new([
+                                            { foo: { gte: -500, lte: 12 } },
+                                            { bar: { dog: "cat" } }
+                                        ])
+          }
+        end
+
+        it "recursively converts between clauses into anded gte / lte clauses" do
+          expect(mut).to eq expected
+        end
+      end
+    end
+
+    context "when the argument is a MSFL::Types::Set" do
+
+      let(:arg) { MSFL::Types::Set.new([ { foo: { between: { start: 1, end: 5 } } } ])}
+
+      let(:expected) { MSFL::Types::Set.new([ { foo: { gte: 1, lte: 5 } } ]) }
+
+      it "recursively converts between clauses into anded gte / lte clauses" do
+        expect(mut).to eq expected
+      end
+
+      context "when the between clause is below the second level" do
+
+        let(:arg) { MSFL::Types::Set.new([ { and: MSFL::Types::Set.new([{foo: { between: { start: 1, end: 5 } } }, {bar: 123}]) } ])}
+
+        let(:expected) { MSFL::Types::Set.new([ { and: MSFL::Types::Set.new([{ foo: { gte: 1, lte: 5} }, { bar: 123} ]) }]) }
+
+        it "recursively converts between clauses into anded gte / lte clauses" do
+          expect(mut).to eq expected
+        end
+      end
+    end
+
+    context "when the argument contains an Array" do
+
+      let(:arg) { [ { foo: { between: { start: 1, end: 5 } } } ] }
+
+      it "raises an ArgumentError" do
+        expect { mut }.to raise_error ArgumentError
+      end
+    end
+
+    context "when the argument is deeply nested and contains many types" do
+
+      let(:arg) { MSFL::Types::Set.new([deep_nest]) }
+
+      let(:expected) do
+        MSFL::Types::Set.new([
+                                 {
+                                     cat: 1221,
+                                     dog: "fur",
+                                     lol: MSFL::Types::Set.new(
+                                         [
+                                             { hat: { gte: 1, lte: 5} }
+                                         ]),
+                                     :"1337" => 1337.1337,
+                                     noob: MSFL::Types::Set.new(
+                                         [
+                                             MSFL::Types::Set.new([123]),
+                                             { :"123" => 456, onetwo: 34 }
+                                         ])
+                                 }])
+      end
+
+      it "recursively converts between clauses into anded gte / lte clauses" do
+        expect(mut).to eq expected
+      end
+    end
+  end
+end

data/spec/msfl/parsers/json_spec.rb

@@ -36,129 +36,6 @@ describe "MSFL::Parsers::JSON" do
 
   end
 
-  describe ".convert_between_to_gte_lte" do
-
-    subject(:mut) { MSFL::Parsers::JSON.convert_between_to_gte_lte arg }
-
-    let(:arg) { Object.new }
-
-    let(:deep_nest) 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: 34 } ]) }
-    end
-
-    context "when the argument is a type other than MSFL::Types::Set, Hash, or Array" do
-
-      [55, 60.9, "five", :fourty, nil].each do |item|
-        context "when the argument is a #{item.class}" do
-
-          let(:arg) { item }
-
-          it "is equal to the argument" do
-            expect(mut).to eq arg
-          end
-        end
-      end
-    end
-
-    context "when the argument is a Hash" do
-
-      let(:arg) { { foo: { between: { start: "2015-01-01", end: "2015-04-01" } } } }
-
-      let(:expected) { { foo: { gte: "2015-01-01", lte: "2015-04-01" } } }
-
-      it "converts between clauses into anded gte / lte clauses" do
-        expect(mut).to eq expected
-      end
-
-      context "when the between clause is below the second level" do
-
-        let(:arg) do
-          {
-              and: MSFL::Types::Set.new([
-                { foo: { between: { start: -500, end: 12 } } },
-                { bar: { dog: "cat" } },
-              ])
-          }
-        end
-
-        let(:expected) do
-          {
-              and: MSFL::Types::Set.new([
-                                            { foo: { gte: -500, lte: 12 } },
-                                            { bar: { dog: "cat" } }
-                                        ])
-          }
-        end
-
-        it "recursively converts between clauses into anded gte / lte clauses" do
-          expect(mut).to eq expected
-        end
-      end
-    end
-
-    context "when the argument is a MSFL::Types::Set" do
-
-      let(:arg) { MSFL::Types::Set.new([ { foo: { between: { start: 1, end: 5 } } } ])}
-
-      let(:expected) { MSFL::Types::Set.new([ { foo: { gte: 1, lte: 5 } } ]) }
-
-      it "recursively converts between clauses into anded gte / lte clauses" do
-        expect(mut).to eq expected
-      end
-
-      context "when the between clause is below the second level" do
-
-        let(:arg) { MSFL::Types::Set.new([ { and: MSFL::Types::Set.new([{foo: { between: { start: 1, end: 5 } } }, {bar: 123}]) } ])}
-
-        let(:expected) { MSFL::Types::Set.new([ { and: MSFL::Types::Set.new([{ foo: { gte: 1, lte: 5} }, { bar: 123} ]) }]) }
-
-        it "recursively converts between clauses into anded gte / lte clauses" do
-          expect(mut).to eq expected
-        end
-      end
-    end
-
-    context "when the argument contains an Array" do
-
-      let(:arg) { [ { foo: { between: { start: 1, end: 5 } } } ] }
-
-      it "raises an ArgumentError" do
-        expect { mut }.to raise_error ArgumentError
-      end
-    end
-
-    context "when the argument is deeply nested and contains many types" do
-
-      let(:arg) { MSFL::Types::Set.new([deep_nest]) }
-
-      let(:expected) do
-        MSFL::Types::Set.new([
-            {
-                cat: 1221,
-                dog: "fur",
-                lol: MSFL::Types::Set.new(
-                    [
-                        { hat: { gte: 1, lte: 5} }
-                    ]),
-                :"1337" => 1337.1337,
-                noob: MSFL::Types::Set.new(
-                    [
-                        MSFL::Types::Set.new([123]),
-                        { :"123" => 456, onetwo: 34 }
-                    ])
-            }])
-      end
-
-      it "recursively converts between clauses into anded gte / lte clauses" do
-        expect(mut).to eq expected
-      end
-    end
-  end
-
   describe ".arrays_to_sets" do
 
     subject(:mut) { MSFL::Parsers::JSON.arrays_to_sets arg }

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: msfl
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 1.1.0
 platform: ruby
 authors:
 - Courtland Caldwell
@@ -110,6 +110,8 @@ files:
 - circle.yml
 - lib/msfl.rb
 - lib/msfl/configuration.rb
+- lib/msfl/converters.rb
+- lib/msfl/converters/operator.rb
 - lib/msfl/datasets.rb
 - lib/msfl/datasets/base.rb
 - lib/msfl/datasets/car.rb
@@ -125,6 +127,7 @@ files:
 - lib/msfl/validators/semantic.rb
 - msfl.gemspec
 - simplecov_custom_profiles.rb
+- spec/msfl/converters/operator_spec.rb
 - spec/msfl/datasets/base_spec.rb
 - spec/msfl/parsers/json_spec.rb
 - spec/msfl/shared_examples.rb
@@ -158,6 +161,7 @@ signing_key:
 specification_version: 4
 summary: MSFL in Ruby
 test_files:
+- spec/msfl/converters/operator_spec.rb
 - spec/msfl/datasets/base_spec.rb
 - spec/msfl/parsers/json_spec.rb
 - spec/msfl/shared_examples.rb