mirror of
				https://github.com/ruby/ruby.git
				synced 2022-11-09 12:17:21 -05:00 
			
		
		
		
	hash.c: map_v -> transform_values
* hash.c (rb_hash_transform_values, rb_hash_transform_values_bang): Rename map_v to transform_values. [Feature #12512] [ruby-core:76095] * test/ruby/test_hash.rb: ditto. git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@56099 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
This commit is contained in:
		
							parent
							
								
									a128c0d33f
								
							
						
					
					
						commit
						eaa0a27f61
					
				
					 3 changed files with 33 additions and 25 deletions
				
			
		| 
						 | 
				
			
			@ -1,3 +1,11 @@
 | 
			
		|||
Thu Sep  8 11:29:00 2016  Kenta Murata  <mrkn@mrkn.jp>
 | 
			
		||||
 | 
			
		||||
	* hash.c (rb_hash_transform_values, rb_hash_transform_values_bang):
 | 
			
		||||
	  Rename map_v to transform_values.
 | 
			
		||||
	  [Feature #12512] [ruby-core:76095]
 | 
			
		||||
 | 
			
		||||
	* test/ruby/test_hash.rb: ditto.
 | 
			
		||||
 | 
			
		||||
Thu Sep  8 10:08:35 2016  Kazuki Yamaguchi  <k@rhe.jp>
 | 
			
		||||
 | 
			
		||||
	* {ext,test}/openssl: Import Ruby/OpenSSL 2.0.0.beta.2. The full commit
 | 
			
		||||
| 
						 | 
				
			
			
 | 
			
		|||
							
								
								
									
										38
									
								
								hash.c
									
										
									
									
									
								
							
							
						
						
									
										38
									
								
								hash.c
									
										
									
									
									
								
							| 
						 | 
				
			
			@ -1788,7 +1788,7 @@ rb_hash_each_pair(VALUE hash)
 | 
			
		|||
}
 | 
			
		||||
 | 
			
		||||
static int
 | 
			
		||||
map_v_i(VALUE key, VALUE value, VALUE result)
 | 
			
		||||
transform_values_i(VALUE key, VALUE value, VALUE result)
 | 
			
		||||
{
 | 
			
		||||
    VALUE new_value = rb_yield(value);
 | 
			
		||||
    rb_hash_aset(result, key, new_value);
 | 
			
		||||
| 
						 | 
				
			
			@ -1797,29 +1797,29 @@ map_v_i(VALUE key, VALUE value, VALUE result)
 | 
			
		|||
 | 
			
		||||
/*
 | 
			
		||||
 *  call-seq:
 | 
			
		||||
 *     hsh.map_v {|value| block } -> hsh
 | 
			
		||||
 *     hsh.map_v                  -> an_enumerator
 | 
			
		||||
 *     hsh.transform_values {|value| block } -> hsh
 | 
			
		||||
 *     hsh.transform_values                  -> an_enumerator
 | 
			
		||||
 *
 | 
			
		||||
 *  Return a new with the results of running block once for every value.
 | 
			
		||||
 *  This method does not change the keys.
 | 
			
		||||
 *
 | 
			
		||||
 *     h = { a: 1, b: 2, c: 3 }
 | 
			
		||||
 *     h.map_v {|v| v * v + 1 }  #=> { a: 2, b: 5, c: 10 }
 | 
			
		||||
 *     h.map_v(&:to_s)           #=> { a: "1", b: "2", c: "3" }
 | 
			
		||||
 *     h.map_v.with_index {|v, i| "#{v}.#{i}" }
 | 
			
		||||
 *                               #=> { a: "1.0", b: "2.1", c: "3.2" }
 | 
			
		||||
 *     h.transform_values {|v| v * v + 1 }  #=> { a: 2, b: 5, c: 10 }
 | 
			
		||||
 *     h.transform_values(&:to_s)           #=> { a: "1", b: "2", c: "3" }
 | 
			
		||||
 *     h.transform_values.with_index {|v, i| "#{v}.#{i}" }
 | 
			
		||||
 *                                          #=> { a: "1.0", b: "2.1", c: "3.2" }
 | 
			
		||||
 *
 | 
			
		||||
 *  If no block is given, an enumerator is returned instead.
 | 
			
		||||
 */
 | 
			
		||||
static VALUE
 | 
			
		||||
rb_hash_map_v(VALUE hash)
 | 
			
		||||
rb_hash_transform_values(VALUE hash)
 | 
			
		||||
{
 | 
			
		||||
    VALUE result;
 | 
			
		||||
 | 
			
		||||
    RETURN_SIZED_ENUMERATOR(hash, 0, 0, hash_enum_size);
 | 
			
		||||
    result = rb_hash_new();
 | 
			
		||||
    if (!RHASH_EMPTY_P(hash)) {
 | 
			
		||||
        rb_hash_foreach(hash, map_v_i, result);
 | 
			
		||||
        rb_hash_foreach(hash, transform_values_i, result);
 | 
			
		||||
    }
 | 
			
		||||
 | 
			
		||||
    return result;
 | 
			
		||||
| 
						 | 
				
			
			@ -1827,27 +1827,27 @@ rb_hash_map_v(VALUE hash)
 | 
			
		|||
 | 
			
		||||
/*
 | 
			
		||||
 *  call-seq:
 | 
			
		||||
 *     hsh.map_v! {|value| block } -> hsh
 | 
			
		||||
 *     hsh.map_v!                  -> an_enumerator
 | 
			
		||||
 *     hsh.transform_values! {|value| block } -> hsh
 | 
			
		||||
 *     hsh.transform_values!                  -> an_enumerator
 | 
			
		||||
 *
 | 
			
		||||
 *  Return a new with the results of running block once for every value.
 | 
			
		||||
 *  This method does not change the keys.
 | 
			
		||||
 *
 | 
			
		||||
 *     h = { a: 1, b: 2, c: 3 }
 | 
			
		||||
 *     h.map_v! {|v| v * v + 1 }  #=> { a: 2, b: 5, c: 10 }
 | 
			
		||||
 *     h.map_v!(&:to_s)           #=> { a: "1", b: "2", c: "3" }
 | 
			
		||||
 *     h.map_v!.with_index {|v, i| "#{v}.#{i}" }
 | 
			
		||||
 *                                #=> { a: "1.0", b: "2.1", c: "3.2" }
 | 
			
		||||
 *     h.transform_values! {|v| v * v + 1 }  #=> { a: 2, b: 5, c: 10 }
 | 
			
		||||
 *     h.transform_values!(&:to_s)           #=> { a: "1", b: "2", c: "3" }
 | 
			
		||||
 *     h.transform_values!.with_index {|v, i| "#{v}.#{i}" }
 | 
			
		||||
 *                                           #=> { a: "1.0", b: "2.1", c: "3.2" }
 | 
			
		||||
 *
 | 
			
		||||
 *  If no block is given, an enumerator is returned instead.
 | 
			
		||||
 */
 | 
			
		||||
static VALUE
 | 
			
		||||
rb_hash_map_v_bang(VALUE hash)
 | 
			
		||||
rb_hash_transform_values_bang(VALUE hash)
 | 
			
		||||
{
 | 
			
		||||
    RETURN_SIZED_ENUMERATOR(hash, 0, 0, hash_enum_size);
 | 
			
		||||
    rb_hash_modify_check(hash);
 | 
			
		||||
    if (RHASH(hash)->ntbl)
 | 
			
		||||
        rb_hash_foreach(hash, map_v_i, hash);
 | 
			
		||||
        rb_hash_foreach(hash, transform_values_i, hash);
 | 
			
		||||
    return hash;
 | 
			
		||||
}
 | 
			
		||||
 | 
			
		||||
| 
						 | 
				
			
			@ -4398,8 +4398,8 @@ Init_Hash(void)
 | 
			
		|||
    rb_define_method(rb_cHash,"each_pair", rb_hash_each_pair, 0);
 | 
			
		||||
    rb_define_method(rb_cHash,"each", rb_hash_each_pair, 0);
 | 
			
		||||
 | 
			
		||||
    rb_define_method(rb_cHash, "map_v", rb_hash_map_v, 0);
 | 
			
		||||
    rb_define_method(rb_cHash, "map_v!", rb_hash_map_v_bang, 0);
 | 
			
		||||
    rb_define_method(rb_cHash, "transform_values", rb_hash_transform_values, 0);
 | 
			
		||||
    rb_define_method(rb_cHash, "transform_values!", rb_hash_transform_values_bang, 0);
 | 
			
		||||
 | 
			
		||||
    rb_define_method(rb_cHash,"keys", rb_hash_keys, 0);
 | 
			
		||||
    rb_define_method(rb_cHash,"values", rb_hash_values, 0);
 | 
			
		||||
| 
						 | 
				
			
			
 | 
			
		|||
| 
						 | 
				
			
			@ -1415,24 +1415,24 @@ class TestHash < Test::Unit::TestCase
 | 
			
		|||
    assert_equal([10, 20, 30], [1, 2, 3].map(&h))
 | 
			
		||||
  end
 | 
			
		||||
 | 
			
		||||
  def test_map_v
 | 
			
		||||
  def test_transform_values
 | 
			
		||||
    x = @cls[a: 1, b: 2, c: 3]
 | 
			
		||||
    y = x.map_v {|v| v ** 2 }
 | 
			
		||||
    y = x.transform_values {|v| v ** 2 }
 | 
			
		||||
    assert_equal([1, 4, 9], y.values_at(:a, :b, :c))
 | 
			
		||||
    assert_not_same(x, y)
 | 
			
		||||
 | 
			
		||||
    y = x.map_v.with_index {|v, i| "#{v}.#{i}" }
 | 
			
		||||
    y = x.transform_values.with_index {|v, i| "#{v}.#{i}" }
 | 
			
		||||
    assert_equal(%w(1.0  2.1  3.2), y.values_at(:a, :b, :c))
 | 
			
		||||
  end
 | 
			
		||||
 | 
			
		||||
  def test_map_v_bang
 | 
			
		||||
  def test_transform_values_bang
 | 
			
		||||
    x = @cls[a: 1, b: 2, c: 3]
 | 
			
		||||
    y = x.map_v! {|v| v ** 2 }
 | 
			
		||||
    y = x.transform_values! {|v| v ** 2 }
 | 
			
		||||
    assert_equal([1, 4, 9], y.values_at(:a, :b, :c))
 | 
			
		||||
    assert_same(x, y)
 | 
			
		||||
 | 
			
		||||
    x = @cls[a: 1, b: 2, c: 3]
 | 
			
		||||
    y = x.map_v!.with_index {|v, i| "#{v}.#{i}" }
 | 
			
		||||
    y = x.transform_values!.with_index {|v, i| "#{v}.#{i}" }
 | 
			
		||||
    assert_equal(%w(1.0  2.1  3.2), y.values_at(:a, :b, :c))
 | 
			
		||||
  end
 | 
			
		||||
 | 
			
		||||
| 
						 | 
				
			
			
 | 
			
		|||
		Loading…
	
	Add table
		Add a link
		
	
		Reference in a new issue