added support to fetch nested values in many formats

Author: thadeu

lib/recollect/utility.rb

@@ -2,6 +2,31 @@
 
 module Recollect
   module Utility
+    module Keys
+      extend self
+
+      DELIMITER_REGEX = /\[|\]|\./
+
+      def to_ary(key)
+        return [] if key.empty?
+
+        key.to_s.split(DELIMITER_REGEX).reject(&:empty?)
+      end
+      alias [] to_ary
+
+      def to_dig(key)
+        enforce_level = ->(level) do
+          if level.is_a?(Integer) || level.match?(/^\d$/)
+            level.to_i
+          else
+            level.to_sym
+          end
+        end
+
+        Keys[key].map(&enforce_level)
+      end
+    end
+
     # ### Utility::TryFetchOrBlank
     # `fetch value into hash, like Lodash.get`
     #
@@ -18,19 +43,21 @@ module Utility
     # ````
     # hash = { a: 1, b: { c: 2 }, d: [{ e: 3 }] }
     # Utility::TryFetchOrBlank.(hash, 'd.0.e')
-    # ````
-    TryFetchOrBlank = lambda do |data, *keys|
-      keys.reduce(data) do |memo, key|
-        symbolized_keys = key.to_s.split('.').map do |k|
-          if k.is_a?(Numeric) || k.match?(/\d/)
-            k.to_i
-          else
-            k.to_sym
-          end
-        end
 
-        memo.dig(*symbolized_keys)
+    # hash = { a: 1, b: { c: 2 }, d: [{ e: 3 }] }
+    # Utility::TryFetchOrBlank.(hash, 'd[0]e')
+
+    # hash = { a: 1, b: { c: 2 }, d: [{ e: 3 }] }
+    # Utility::TryFetchOrBlank.(hash, 'd.[0].e')
+    # ````
+    TryFetchOrBlank = ->(data, *keys) do
+      reducer = ->(memo, key) do
+        memo.dig(*Keys.to_dig(key))
+      rescue StandardError
+        nil
       end
+
+      keys.reduce(data, &reducer)
     end
   end
 end

spec/lib/recollect/utility_spec.rb

@@ -31,15 +31,44 @@
   end
 
   context 'Array' do
-    it 'check array levels' do
-      hash = { a: 1, b: { c: 2 }, d: ['1'] }
-      expect(described_class.call(hash, 'd.0')).to eq('1')
+    subject(:result) { described_class.call(hash, iteratee) }
+
+    context 'iteratee one level' do
+      let(:hash) { { a: 1, b: { c: 2 }, d: ['1'] } }
+      let(:iteratee) { 'd.0' }
+
+      it { expect(result).to eq('1') }
+    end
+
+    context 'iteratee one level' do
+      let(:hash) { { a: 1, b: { c: 2 }, d: [{ e: 3 }] } }
+      let(:iteratee) { 'd.0.e' }
+
+      it { expect(result).to eq(3) }
     end
 
-    it 'check array + hash levels' do
-      hash = { a: 1, b: { c: 2 }, d: [{ e: 3 }] }
+    context 'iteratee nested levels on the complex hash' do
+      let(:hash) do
+        {
+          a: 1,
+          b: { c: 2 },
+          d: [
+            {
+              e: [
+                { e1: 1 },
+                { e2: 2 },
+                { e3: 3 }
+              ]
+            }
+          ]
+        }
+      end
 
-      expect(described_class[hash, 'd.0.e']).to eq(3)
+      it { expect(described_class[hash, 'd.0.e.2.e3']).to eq(3) }
+      it { expect(described_class[hash, 'd.0.e.[2].e3']).to eq(3) }
+      it { expect(described_class[hash, 'd.0.e[2].e3']).to eq(3) }
+      it { expect(described_class[hash, 'd[0]e.2.e3']).to eq(3) }
+      it { expect(described_class[hash, 'd.[0].e[1]e2']).to eq(2) }
     end
   end
 end