rubinius · Jan 10, 2016 · Jan 10, 2016 · Jan 11, 2016
Showing with 144 additions and 0 deletions.

+9 −0 kernel/common/array.rb

+9 −0 kernel/common/hash.rb

+13 −0 kernel/common/struct.rb

+38 −0 spec/ruby/core/array/dig_spec.rb

+38 −0 spec/ruby/core/hash/dig_spec.rb

+37 −0 spec/ruby/core/struct/dig_spec.rb
diff --git a/kernel/common/array.rb b/kernel/common/array.rb
@@ -583,6 +583,15 @@ def delete_if
     self
   end
 
+  def dig(*sequence)
+    item = self[sequence.shift]
+    return item if sequence.empty? || item.nil?
+
+    raise TypeError, "#{item.class} does not have #dig method" unless item.respond_to?(:dig)
+
+    item.dig(*sequence)
+  end
+
   def each_index
     return to_enum(:each_index) { size } unless block_given?
 

diff --git a/kernel/common/hash.rb b/kernel/common/hash.rb
@@ -322,6 +322,15 @@ def delete(key)
     return yield(key) if block_given?
   end
 
+  def dig(*sequence)
+    item = self[sequence.shift]
+    return item if sequence.empty? || item.nil?
+
+    raise TypeError, "#{item.class} does not have #dig method" unless item.respond_to?(:dig)
+
+    item.dig(*sequence)
+  end
+
   def each_item
     return unless @state
 

diff --git a/kernel/common/struct.rb b/kernel/common/struct.rb
@@ -181,6 +181,19 @@ def []=(var, obj)
     return instance_variable_set(:"@#{var}", obj)
   end
 
+  def dig(*sequence)
+    item = begin
+             self[sequence.shift]
+            rescue NameError
+              nil
+            end
+    return item if sequence.empty? || item.nil?
+
+    raise TypeError, "#{item.class} does not have #dig method" unless item.respond_to?(:dig)
+
+    item.dig(*sequence)
+  end
+
   def eql?(other)
     return true if equal? other
     return false if self.class != other.class

diff --git a/spec/ruby/core/array/dig_spec.rb b/spec/ruby/core/array/dig_spec.rb
@@ -0,0 +1,38 @@
+require File.expand_path('../../../spec_helper', __FILE__)
+
+describe "Array#dig" do
+  it "returns the nested value specified by the sequence of indexes" do
+    a = [[1, [2, 3]]]
+
+    a.dig(0, 1, 1).should == 3
+  end
+
+  it "returns the nested value specified if the sequence includes a key" do
+    a = [42, new_hash(foo: :bar)]
+
+    a.dig(1, :foo).should == :bar
+  end
+
+  it "raises a TypeError if any intermediate step does not respond to #dig" do
+    a = [1, 2]
+
+    lambda { a.dig(0, 1) }.should raise_error(TypeError)
+  end
+
+  it "returns nil if any intermediate step is nil" do
+    a = [[1, [2, 3]]]
+
+    a.dig(1, 2, 3).should == nil
+  end
+
+  it "calls #dig on any intermediate step with the rest of the sequence as arguments" do
+    o = Object.new
+    a = [1, [2, o]]
+
+    def o.dig(*args)
+      {dug: args}
+    end
+
+    a.dig(1, 1, :bar, :baz).should == {dug: [:bar, :baz]}
+  end
+end
diff --git a/spec/ruby/core/hash/dig_spec.rb b/spec/ruby/core/hash/dig_spec.rb
@@ -0,0 +1,38 @@
+require File.expand_path('../../../spec_helper', __FILE__)
+
+describe "Hash#dig" do
+  it "returns the nested value specified by the sequence of keys" do
+    h = new_hash(foo: new_hash(bar: new_hash(baz: 1)))
+
+    h.dig(:foo, :bar, :baz).should == 1
+  end
+
+  it "returns the nested value specified if the sequence includes an index" do
+    h = new_hash(foo: [1, 2, 3])
+
+    h.dig(:foo, 2).should == 3
+  end
+
+  it "returns nil if any intermediate step is nil" do
+    h = new_hash(foo: new_hash(bar: new_hash(baz: 1)))
+
+    h.dig(:foo, :zot, :xyz).should == nil
+  end
+
+  it "raises a TypeError if any intermediate step does not respond to #dig" do
+    h = new_hash(foo: 1)
+
+    lambda { h.dig(:foo, 3) }.should raise_error(TypeError)
+  end
+
+  it "calls #dig on any intermediate step with the rest of the sequence as arguments" do
+    o = Object.new
+    h = new_hash(foo: o)
+
+    def o.dig(*args)
+      {dug: args}
+    end
+
+    h.dig(:foo, :bar, :baz).should == {dug: [:bar, :baz]}
+  end
+end
diff --git a/spec/ruby/core/struct/dig_spec.rb b/spec/ruby/core/struct/dig_spec.rb
@@ -0,0 +1,37 @@
+require File.expand_path('../../../spec_helper', __FILE__)
+
+describe "Struct#dig" do
+  before(:each) do
+    @klass = Struct.new(:a)
+    @instance = @klass.new(@klass.new(b: [1, 2, 3]))
+  end
+
+  it "returns the nested value specified by the sequence of keys" do
+    @instance.dig(:a, :a).should == {b: [1, 2, 3]}
+  end
+
+  it "returns the nested value specified if the sequence includes an index" do
+    @instance.dig(:a, :a, :b, 0).should == 1
+  end
+
+  it "returns nil if any intermediate step is nil" do
+    @instance.dig(:b, 0).should == nil
+  end
+
+  it "raises a TypeError if any intermediate step does not respond to #dig" do
+    instance = @klass.new(1)
+
+    lambda { instance.dig(:a, 3) }.should raise_error(TypeError)
+  end
+
+  it "calls #dig on any intermediate step with the rest of the sequence as arguments" do
+    obj = Object.new
+    instance = @klass.new(obj)
+
+    def obj.dig(*args)
+      {dug: args}
+    end
+
+    instance.dig(:a, :bar, :baz).should == {dug: [:bar, :baz]}
+  end
+end