msfl 0.0.1.pre.rc7 → 0.0.1.pre.rc8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 83c63367edc19c703d2f4cf7ec91cb9108845eb8
-  data.tar.gz: af422af9657995730826dc70f26bfcf3cf0ede87
+  metadata.gz: f158def0dd3c1a90afd52ac221d85b95e68f940b
+  data.tar.gz: 218ac6a18e360fb3710f6528739001ab2454305f
 SHA512:
-  metadata.gz: 98a0f847408159abe70615382c7979adb88e8f3ae19b7cca99653d771d874a42b08d334616e107e98aa82aba31f2894eaf9ee70d8eda3aad5e6de6fa9ac1e34e
-  data.tar.gz: 81963210e26b6d44c305056661368dc79cc9805193f607a78306db4080afa92849fb63df6b83bb6eeeecfa2e57c471fb956b71f4958caf8c134b49e9b36163ae
+  metadata.gz: e1a4bdaec608a350ca1aa02861ab1978c8f534fa6a54575740e9bd898f2070271902835eef85454025df7e0139ad4ad0307ab65ee2c791ca2a988ed177debfc8
+  data.tar.gz: 4e6b90ab7c4dc28cdee6eb83dc106b18958e1df6a123e18cf8342b826b48ab2a9d342430b0cb7494083bb6684aa1f81df99589850e26dd215095f6c4ce28f142

data/lib/msfl/parsers/json.rb

@@ -12,6 +12,7 @@ module MSFL
         json_to_parse = '{}' if json_to_parse.nil? || json_to_parse == "" || json_to_parse == "null"
         obj = ::JSON.parse(json_to_parse)
         obj = arrays_to_sets obj
+        obj = convert_keys_to_symbols obj
         obj
       end
 
@@ -24,7 +25,7 @@ module MSFL
         if obj.respond_to? :each
           if obj.is_a?(::Hash)
             result = {}
-            obj.each { |key, val| result[key.to_sym] = arrays_to_sets val }
+            obj.each { |key, val| result["#{key}".to_sym] = arrays_to_sets val }
           elsif obj.is_a?(Types::Set)
             result = Types::Set.new obj.map { |value| arrays_to_sets value }
           end
@@ -32,6 +33,29 @@ module MSFL
         result ||= obj
         result
       end
+
+      # Deeply converts all hash keys to symbols
+      #
+      # @param obj [Object] the object on which to deeply convert hash keys to symbols
+      # @return [Object] the object with its hash keys deeply converted to symbols
+      def self.convert_keys_to_symbols(obj)
+        result = obj
+        if obj.is_a? Hash
+          result = Hash.new
+          obj.each do |k, v|
+            value = convert_keys_to_symbols v
+            result["#{k}".to_sym] = value
+          end
+        elsif obj.is_a? Types::Set
+          result = Types::Set.new
+          obj.each do |v|
+            result << convert_keys_to_symbols(v)
+          end
+        elsif obj.is_a? Array # Generally this will not be the case as the expectation is that arrays_to_sets has already run
+          result = convert_keys_to_symbols(arrays_to_sets(obj))
+        end
+        result
+      end
     end
   end
 end

data/msfl.gemspec

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

data/spec/msfl/parsers/json_spec.rb

@@ -154,4 +154,133 @@ describe "MSFL::Parsers::JSON" do
       end
     end
   end
+
+  describe ".convert_keys_to_symbols" do
+
+    subject(:mut) { MSFL::Parsers::JSON.convert_keys_to_symbols arg }
+
+    let(:arg) { Object.new }
+
+    [55, "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
+
+    context "when the argument is a Hash" do
+
+      let(:arg) { a_hash }
+
+      [44, "fooz", :bar].each do |key|
+
+        let(:a_hash) { { key => "some value" } }
+
+        let(:expected) { { "#{key}".to_sym => "some value" } }
+
+        it "coerces the keys to symbols" do
+          expect(mut).to eq expected
+        end
+      end
+
+      context "when the hash's values include at least one Hash" do
+
+        let(:a_hash) { { "cat" => { "sally" => "some value" }, 1337 => "peter", "bob" => 111 } }
+
+        let(:expected) { { cat: { sally: "some value" }, :"1337" => "peter", bob: 111 } }
+
+        it "recursively coerces the keys to symbols" do
+          expect(mut).to eq expected
+        end
+      end
+
+      context "when the hash's values include at least one Array" do
+
+        let(:a_hash) { { "inner_array" => array_in_arg, abc: 123, 123 => :abc } }
+
+        let(:expected) do
+          { inner_array: MSFL::Types::Set.new([ MSFL::Types::Set.new([ 4, :b, { sad: "bear" } ]), "baz" ]),
+            abc: 123,
+            :"123" => :abc }
+        end
+
+        let(:array_in_arg) { [ [4, :b, { "sad" => "bear"} ], "baz"] }
+
+        it "recursively coerces hash keys to symbols" do
+          expect(mut).to eq expected
+        end
+      end
+
+      context "when the hash's values include at least on MSFL::Types::Set" do
+
+        let(:a_hash) { { "inner_set" => set_in_arg, abc: 123, 123 => :abc } }
+
+        let(:expected) do
+          { inner_set: MSFL::Types::Set.new([ MSFL::Types::Set.new([ 4, :b, { sad: "bear" } ]), "baz" ]),
+            abc: 123,
+            :"123" => :abc }
+        end
+
+        let(:set_in_arg) { MSFL::Types::Set.new([ MSFL::Types::Set.new([4, :b, { "sad" => "bear"} ]), "baz"]) }
+
+        it "recursively coerces hash keys to symbols" do
+          expect(mut).to eq expected
+        end
+      end
+    end
+
+    context "when the argument is an Array" do
+
+      let(:arg) { an_array }
+
+      let(:an_array) { [:foo, "bar", nil, 99, "bar"] }
+
+      it "coerces Arrays into MSFL::Types::Set objects" do
+        expect(mut).to be_a MSFL::Types::Set
+      end
+
+      context "when the array's values are unique scalars" do
+
+        let(:an_array) { [:foo, "bar", nil, 99] }
+
+        it "is unchanged" do
+          expect(mut).to eq(MSFL::Types::Set.new an_array)
+        end
+      end
+
+      context "when the array includes at least one Hash" do
+
+        let(:an_array) { ["bar", hash_in_array, 84] }
+
+        let(:hash_in_array) { { "cat" => 1221, dog: "fur", "lol" => [ ], 1337 => 1337, "noob" => [ MSFL::Types::Set.new([123]), { 123 => 456, "onetwo" => 34 } ] } }
+
+        let(:expected) do
+          MSFL::Types::Set.new(
+              [
+                  "bar",
+                  {
+                      cat: 1221,
+                      dog: "fur",
+                      lol: MSFL::Types::Set.new([]),
+                      :"1337" => 1337,
+                      noob: MSFL::Types::Set.new(
+                                                [
+                                                    MSFL::Types::Set.new([123]),
+                                                    { :"123" => 456, onetwo: 34 }
+                                                ])
+                  },
+                  84
+              ])
+        end
+
+        it "recursively coerces hash keys to symbols" do
+          expect(mut).to eq expected
+        end
+      end
+    end
+  end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: msfl
 version: !ruby/object:Gem::Version
-  version: 0.0.1.pre.rc7
+  version: 0.0.1.pre.rc8
 platform: ruby
 authors:
 - Courtland Caldwell