msfl 0.0.1.pre.rc8 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: f158def0dd3c1a90afd52ac221d85b95e68f940b
-  data.tar.gz: 218ac6a18e360fb3710f6528739001ab2454305f
+  metadata.gz: 563d3ef0c03cf0f730fce20bca483a0821114b07
+  data.tar.gz: 55d9c65bd08ff2112be042f643cb5db0e02ffbc0
 SHA512:
-  metadata.gz: e1a4bdaec608a350ca1aa02861ab1978c8f534fa6a54575740e9bd898f2070271902835eef85454025df7e0139ad4ad0307ab65ee2c791ca2a988ed177debfc8
-  data.tar.gz: 4e6b90ab7c4dc28cdee6eb83dc106b18958e1df6a123e18cf8342b826b48ab2a9d342430b0cb7494083bb6684aa1f81df99589850e26dd215095f6c4ce28f142
+  metadata.gz: d9c693af109604a14129e16660d56ef5430b7039a4ada968a1d66c78cdf5be537154d7d7fcd87b577d626619ce81260aa715fa19a790d8a1636f4827946d0d25
+  data.tar.gz: ca8a5143b80148cd2f37527c87400ce72abb527833299645af6ed592c9d861a73167f3adb094f19b8780bb05fddb280622d74218a2bf3869b21aa90aff39d2d2

data/lib/msfl/parsers/json.rb

@@ -13,6 +13,7 @@ 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
 
@@ -56,6 +57,34 @@ 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/msfl.gemspec

@@ -1,7 +1,7 @@
 Gem::Specification.new do |s|
   s.name        = 'msfl'
-  s.version     = '0.0.1-rc8'
-  s.date        = '2015-03-26'
+  s.version     = '1.0.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."
   s.authors     = ["Courtland Caldwell"]

data/spec/msfl/parsers/json_spec.rb

@@ -36,6 +36,129 @@ 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,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: msfl
 version: !ruby/object:Gem::Version
-  version: 0.0.1.pre.rc8
+  version: 1.0.0
 platform: ruby
 authors:
 - Courtland Caldwell
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-03-26 00:00:00.000000000 Z
+date: 2015-04-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: json
@@ -148,9 +148,9 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - '>'
+  - - '>='
     - !ruby/object:Gem::Version
-      version: 1.3.1
+      version: '0'
 requirements: []
 rubyforge_project: 
 rubygems_version: 2.4.2