Add a new #filter alias for #select

* In Enumerable, Enumerator::Lazy, Array, Hash and Set
  [Feature #13784] [ruby-core:82285]
* Share specs for the various #select#select! methods and
  reuse them for #filter/#filter!.
* Add corresponding filter tests for select tests.
* Update NEWS.

[Fix GH-1824]

From: Alexander Patrick <adp90@case.edu>

git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@62575 b2dd03c8-39d4-4d8f-98ff-823fe69b080e

5 files changed, 106 insertions, 3 deletions

diff --git a/test/ruby/test_array.rb b/test/ruby/test_array.rb
index 955121c0f0..39bf635079 100644
--- a/test/ruby/test_array.rb
+++ b/test/ruby/test_array.rb
@@ -170,6 +170,7 @@ class TestArray < Test::Unit::TestCase
   def test_find_all_0
     assert_respond_to([], :find_all)
     assert_respond_to([], :select)       # Alias
+    assert_respond_to([], :filter)       # Alias
     assert_equal([], [].find_all{ |obj| obj == "foo"})
 
     x = ["foo", "bar", "baz", "baz", 1, 2, 3, 3, 4]
@@ -2301,6 +2302,25 @@ class TestArray < Test::Unit::TestCase
     assert_equal(@cls[4, 5], a)
   end
 
+  def test_filter
+    assert_equal([0, 2], [0, 1, 2, 3].filter {|x| x % 2 == 0 })
+  end
+
+  # alias for select!
+  def test_filter!
+    a = @cls[ 1, 2, 3, 4, 5 ]
+    assert_equal(nil, a.filter! { true })
+    assert_equal(@cls[1, 2, 3, 4, 5], a)
+
+    a = @cls[ 1, 2, 3, 4, 5 ]
+    assert_equal(a, a.filter! { false })
+    assert_equal(@cls[], a)
+
+    a = @cls[ 1, 2, 3, 4, 5 ]
+    assert_equal(a, a.filter! { |i| i > 3 })
+    assert_equal(@cls[4, 5], a)
+  end
+
   def test_delete2
     a = [0] * 1024 + [1] + [0] * 1024
     a.delete(0)
diff --git a/test/ruby/test_enumerator.rb b/test/ruby/test_enumerator.rb
index 235dfbfc9b..86cab539ab 100644
--- a/test/ruby/test_enumerator.rb
+++ b/test/ruby/test_enumerator.rb
@@ -505,7 +505,7 @@ class TestEnumerator < Test::Unit::TestCase
   def test_size_for_enum_created_from_array
     arr = %w[hello world]
     %i[each each_with_index reverse_each sort_by! sort_by map map!
-      keep_if reject! reject select! select delete_if].each do |method|
+      keep_if reject! reject select! select filter! filter delete_if].each do |method|
       assert_equal arr.size, arr.send(method).size
     end
   end
@@ -522,7 +522,7 @@ class TestEnumerator < Test::Unit::TestCase
 
   def test_size_for_enum_created_from_hash
     h = {a: 1, b: 2, c: 3}
-    methods = %i[delete_if reject reject! select select! keep_if each each_key each_pair]
+    methods = %i[delete_if reject reject! select select! filter filter! keep_if each each_key each_pair]
     enums = methods.map {|method| h.send(method)}
     s = enums.group_by(&:size)
     assert_equal([3], s.keys, ->{s.reject!{|k| k==3}.inspect})
@@ -532,7 +532,7 @@ class TestEnumerator < Test::Unit::TestCase
   end
 
   def test_size_for_enum_created_from_env
-    %i[each_pair reject! delete_if select select! keep_if].each do |method|
+    %i[each_pair reject! delete_if select select! filter filter! keep_if].each do |method|
       assert_equal ENV.size, ENV.send(method).size
     end
   end
diff --git a/test/ruby/test_env.rb b/test/ruby/test_env.rb
index ffed94efa6..699f7db084 100644
--- a/test/ruby/test_env.rb
+++ b/test/ruby/test_env.rb
@@ -222,6 +222,18 @@ class TestEnv < Test::Unit::TestCase
     assert_nil(ENV.select! {|k, v| IGNORE_CASE ? k.upcase != "TEST" : k != "test" })
   end
 
+  def test_filter_bang
+    h1 = {}
+    ENV.each_pair {|k, v| h1[k] = v }
+    ENV["test"] = "foo"
+    ENV.filter! {|k, v| IGNORE_CASE ? k.upcase != "TEST" : k != "test" }
+    h2 = {}
+    ENV.each_pair {|k, v| h2[k] = v }
+    assert_equal(h1, h2)
+
+    assert_nil(ENV.filter! {|k, v| IGNORE_CASE ? k.upcase != "TEST" : k != "test" })
+  end
+
   def test_keep_if
     h1 = {}
     ENV.each_pair {|k, v| h1[k] = v }
@@ -254,6 +266,21 @@ class TestEnv < Test::Unit::TestCase
     end
   end
 
+  def test_filter
+    ENV["test"] = "foo"
+    h = ENV.filter {|k| IGNORE_CASE ? k.upcase == "TEST" : k == "test" }
+    assert_equal(1, h.size)
+    k = h.keys.first
+    v = h.values.first
+    if IGNORE_CASE
+      assert_equal("TEST", k.upcase)
+      assert_equal("FOO", v.upcase)
+    else
+      assert_equal("test", k)
+      assert_equal("foo", v)
+    end
+  end
+
   def test_clear
     ENV.clear
     assert_equal(0, ENV.size)
diff --git a/test/ruby/test_hash.rb b/test/ruby/test_hash.rb
index 55e46584b4..088178defa 100644
--- a/test/ruby/test_hash.rb
+++ b/test/ruby/test_hash.rb
@@ -1017,6 +1017,44 @@ class TestHash < Test::Unit::TestCase
     assert_equal({}, {}.slice)
   end
 
+  def test_filter
+    assert_equal({3=>4,5=>6}, @cls[1=>2,3=>4,5=>6].filter {|k, v| k + v >= 7 })
+
+    base = @cls[ 1 => 'one', '2' => false, true => 'true', 'cat' => 99 ]
+    h1   = @cls[ '2' => false, 'cat' => 99 ]
+    h2   = @cls[ 1 => 'one', true => 'true' ]
+    h3   = @cls[ 1 => 'one', true => 'true', 'cat' => 99 ]
+
+    h = base.dup
+    assert_equal(h, h.filter { true })
+    assert_equal(@cls[], h.filter { false })
+
+    h = base.dup
+    assert_equal(h1, h.filter {|k,v| k.instance_of?(String) })
+
+    assert_equal(h2, h.filter {|k,v| v.instance_of?(String) })
+
+    assert_equal(h3, h.filter {|k,v| v })
+    assert_equal(base, h)
+
+    h.instance_variable_set(:@foo, :foo)
+    h.default = 42
+    h.taint
+    h = h.filter {true}
+    assert_instance_of(Hash, h)
+    assert_not_predicate(h, :tainted?)
+    assert_nil(h.default)
+    assert_not_send([h, :instance_variable_defined?, :@foo])
+  end
+
+  def test_filter!
+    h = @cls[1=>2,3=>4,5=>6]
+    assert_equal(h, h.filter! {|k, v| k + v >= 7 })
+    assert_equal({3=>4,5=>6}, h)
+    h = @cls[1=>2,3=>4,5=>6]
+    assert_equal(nil, h.filter!{true})
+  end
+
   def test_clear2
     assert_equal({}, @cls[1=>2,3=>4,5=>6].clear)
     h = @cls[1=>2,3=>4,5=>6]
diff --git a/test/test_set.rb b/test/test_set.rb
index 4c6730d141..b20920e63e 100644
--- a/test/test_set.rb
+++ b/test/test_set.rb
@@ -545,6 +545,24 @@ class TC_Set < Test::Unit::TestCase
     assert_equal(Set.new(1..10), set)
   end
 
+  def test_filter!
+    set = Set.new(1..10)
+    ret = set.filter! { |i| i <= 10 }
+    assert_equal(nil, ret)
+    assert_equal(Set.new(1..10), set)
+
+    set = Set.new(1..10)
+    ret = set.filter! { |i| i % 3 != 0 }
+    assert_same(set, ret)
+    assert_equal(Set[1,2,4,5,7,8,10], set)
+
+    set = Set.new(1..10)
+    enum = set.filter!
+    assert_equal(set.size, enum.size)
+    assert_equal(nil, enum.each { |i| i <= 10 })
+    assert_equal(Set.new(1..10), set)
+  end
+
   def test_merge
     set = Set[1,2,3]