From: Intransition <transfire@...>
Date: 2012-12-10T03:19:27+09:00
Subject: Help me improve Hash#rekey

------=_Part_93_24450722.1355077165409
Content-Type: multipart/alternative; 
	boundary="----=_Part_94_2156403.1355077165409"

------=_Part_94_2156403.1355077165409
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 7bit

The note `TODO: Improve Hash#rekey code!!!` has been in my docs for too 
long. I could use other's insights and thought others might enjoy the 
challenge. So here's the code:

  require 'facets/na'

  class Hash

    # Rekey a hash:
    #
    #   rekey()
    #   rekey(from_key => to_key, ...)
    #   rekey{|from_key| to_key}
    #   rekey{|from_key, value| to_key}
    #
    # If a key map is given, then the first key is changed to the second 
key.
    #
    #   foo = { :a=>1, :b=>2 }
    #   foo.rekey(:a=>'a')       #=> { 'a'=>1, :b=>2 }
    #   foo.rekey(:b=>:x)        #=> { :a =>1, :x=>2 }
    #   foo.rekey('foo'=>'bar')  #=> { :a =>1, :b=>2 }
    #
    # If a block is given, converts all keys in the Hash accroding to the
    # given block procedure. If the block returns +NA+ for a given key,
    # then that key will be left intact.
    #
    #   foo = { :name=>'Gavin', :wife=>:Lisa }
    #   foo.rekey{ |k| k.to_s }  #=>  { "name"=>"Gavin", "wife"=>:Lisa }
    #   foo                      #=>  { :name =>"Gavin", :wife=>:Lisa }
    #
    # If no key map or block is given, then all keys are converted
    # to Symbols.
    #
    # Note that if both a +key_map+ and a block are given, the +key_map+ is 
    # applied first then the block.
    #
    # CREDIT: Trans, Gavin Kistner

    def rekey(key_map=nil, &block)
      if !(key_map or block)
        block = lambda{|k| k.to_sym}
      end

      key_map ||= {} 

      hash = dup.replace({})  # to keep default_proc

      (keys - key_map.keys).each do |key|
        hash[key] = self[key]
      end

      key_map.each do |from, to|
        hash[to] = self[from] if key?(from)
      end

      if block
        hash2 = dup.replace({})
        case block.arity
        when 2  # TODO: is this condition needed?
          hash.each do |k, v|
            nk = block.call(k,v)
            nk = (NA == nk ? k : nk)
            hash2[nk] = v
          end
        else
          hash.each do |k, v|
            nk = block.call(k)
            nk = (NA == nk ? k : nk)
            hash2[nk] = v
          end
        end
      else
        hash2 = hash
      end

      hash2
    end

    # Synonym for Hash#rekey, but modifies the receiver in place (and 
returns it).
    #
    #   foo = { :name=>'Gavin', :wife=>:Lisa }
    #   foo.rekey!{ |k| k.to_s }  #=>  { "name"=>"Gavin", "wife"=>:Lisa }
    #   foo                       #=>  { "name"=>"Gavin", "wife"=>:Lisa }
    #
    # CREDIT: Trans, Gavin Kistner

    def rekey!(key_map=nil, &block)
      replace(rekey(key_map, &block))
    end

  end

Not the use of `facets/na`. That is defined as:

    class << NA = ArgumentError.new
      def inspect ; 'N/A' ; end
      def method_missing(*); self; end
    end

But it is really nothing more than a dummy object used to mean Not 
Applicable. So in the case of #rekey, if the block returns NA then the key 
goes unchanged. Thinking about it again now, it's probably unnecessary, but 
I had wanted a way to say "leave it alone" while also making sure that 
`nil` could still be used as a key (even if that's rare). Feel free to 
remove the NA business, but if you do please explain why you think its not 
needed.

Best solution will get their name put in front of CREDITs for the next 
release of Facets. 


------=_Part_94_2156403.1355077165409
Content-Type: text/html; charset=utf-8
Content-Transfer-Encoding: quoted-printable

<div><div>The note `TODO: Improve Hash#rekey code!!!` has been in my docs f=
or too long. I could use other's insights and thought others might enjoy th=
e challenge. So here's the code:</div><div><br></div></div><div>&nbsp; requ=
ire 'facets/na'</div><div><br></div><div>&nbsp; class Hash</div><div><br></=
div><div>&nbsp; &nbsp; # Rekey a hash:<br></div><div>&nbsp; &nbsp; #</div><=
div>&nbsp; &nbsp; # &nbsp; rekey()</div><div>&nbsp; &nbsp; # &nbsp; rekey(f=
rom_key =3D&gt; to_key, ...)</div><div>&nbsp; &nbsp; # &nbsp; rekey{|from_k=
ey| to_key}</div><div>&nbsp; &nbsp; # &nbsp; rekey{|from_key, value| to_key=
}</div><div>&nbsp; &nbsp; #</div><div>&nbsp; &nbsp; # If a key map is given=
, then the first key is changed to the second key.</div><div>&nbsp; &nbsp; =
#</div><div>&nbsp; &nbsp; # &nbsp; foo =3D { :a=3D&gt;1, :b=3D&gt;2 }</div>=
<div>&nbsp; &nbsp; # &nbsp; foo.rekey(:a=3D&gt;'a') &nbsp; &nbsp; &nbsp; #=
=3D&gt; { 'a'=3D&gt;1, :b=3D&gt;2 }</div><div>&nbsp; &nbsp; # &nbsp; foo.re=
key(:b=3D&gt;:x) &nbsp; &nbsp; &nbsp; &nbsp;#=3D&gt; { :a =3D&gt;1, :x=3D&g=
t;2 }</div><div>&nbsp; &nbsp; # &nbsp; foo.rekey('foo'=3D&gt;'bar') &nbsp;#=
=3D&gt; { :a =3D&gt;1, :b=3D&gt;2 }</div><div>&nbsp; &nbsp; #</div><div>&nb=
sp; &nbsp; # If a block is given, converts all keys in the Hash accroding t=
o the</div><div>&nbsp; &nbsp; # given block procedure. If the block returns=
 +NA+ for a given key,</div><div>&nbsp; &nbsp; # then that key will be left=
 intact.</div><div>&nbsp; &nbsp; #</div><div>&nbsp; &nbsp; # &nbsp; foo =3D=
 { :name=3D&gt;'Gavin', :wife=3D&gt;:Lisa }</div><div>&nbsp; &nbsp; # &nbsp=
; foo.rekey{ |k| k.to_s } &nbsp;#=3D&gt; &nbsp;{ "name"=3D&gt;"Gavin", "wif=
e"=3D&gt;:Lisa }</div><div>&nbsp; &nbsp; # &nbsp; foo &nbsp; &nbsp; &nbsp; =
&nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp;#=3D&gt; &nbsp;{ :na=
me =3D&gt;"Gavin", :wife=3D&gt;:Lisa }</div><div>&nbsp; &nbsp; #</div><div>=
&nbsp; &nbsp; # If no key map or block is given, then all keys are converte=
d</div><div>&nbsp; &nbsp; # to Symbols.</div><div>&nbsp; &nbsp; #</div><div=
>&nbsp; &nbsp; # Note that if both a +key_map+ and a block are given, the +=
key_map+ is&nbsp;</div><div>&nbsp; &nbsp; # applied first then the block.</=
div><div>&nbsp; &nbsp; #</div><div>&nbsp; &nbsp; # CREDIT: Trans, Gavin Kis=
tner</div><div><br></div><div>&nbsp; &nbsp; def rekey(key_map=3Dnil, &amp;b=
lock)</div><div>&nbsp; &nbsp; &nbsp; if !(key_map or block)</div><div>&nbsp=
; &nbsp; &nbsp; &nbsp; block =3D lambda{|k| k.to_sym}</div><div>&nbsp; &nbs=
p; &nbsp; end</div><div><br></div><div>&nbsp; &nbsp; &nbsp; key_map ||=3D {=
}&nbsp;</div><div><br></div><div>&nbsp; &nbsp; &nbsp; hash =3D dup.replace(=
{}) &nbsp;# to keep default_proc</div><div><br></div><div>&nbsp; &nbsp; &nb=
sp; (keys - key_map.keys).each do |key|</div><div>&nbsp; &nbsp; &nbsp; &nbs=
p; hash[key] =3D self[key]</div><div>&nbsp; &nbsp; &nbsp; end</div><div><br=
></div><div>&nbsp; &nbsp; &nbsp; key_map.each do |from, to|</div><div>&nbsp=
; &nbsp; &nbsp; &nbsp; hash[to] =3D self[from] if key?(from)</div><div>&nbs=
p; &nbsp; &nbsp; end</div><div><br></div><div>&nbsp; &nbsp; &nbsp; if block=
</div><div>&nbsp; &nbsp; &nbsp; &nbsp; hash2 =3D dup.replace({})</div><div>=
&nbsp; &nbsp; &nbsp; &nbsp; case block.arity</div><div>&nbsp; &nbsp; &nbsp;=
 &nbsp; when 2 &nbsp;# TODO: is this condition needed?</div><div>&nbsp; &nb=
sp; &nbsp; &nbsp; &nbsp; hash.each do |k, v|</div><div>&nbsp; &nbsp; &nbsp;=
 &nbsp; &nbsp; &nbsp; nk =3D block.call(k,v)</div><div>&nbsp; &nbsp; &nbsp;=
 &nbsp; &nbsp; &nbsp; nk =3D (NA =3D=3D nk ? k : nk)</div><div>&nbsp; &nbsp=
; &nbsp; &nbsp; &nbsp; &nbsp; hash2[nk] =3D v</div><div>&nbsp; &nbsp; &nbsp=
; &nbsp; &nbsp; end</div><div>&nbsp; &nbsp; &nbsp; &nbsp; else</div><div>&n=
bsp; &nbsp; &nbsp; &nbsp; &nbsp; hash.each do |k, v|</div><div>&nbsp; &nbsp=
; &nbsp; &nbsp; &nbsp; &nbsp; nk =3D block.call(k)</div><div>&nbsp; &nbsp; =
&nbsp; &nbsp; &nbsp; &nbsp; nk =3D (NA =3D=3D nk ? k : nk)</div><div>&nbsp;=
 &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; hash2[nk] =3D v</div><div>&nbsp; &nbsp;=
 &nbsp; &nbsp; &nbsp; end</div><div>&nbsp; &nbsp; &nbsp; &nbsp; end</div><d=
iv>&nbsp; &nbsp; &nbsp; else</div><div>&nbsp; &nbsp; &nbsp; &nbsp; hash2 =
=3D hash</div><div>&nbsp; &nbsp; &nbsp; end</div><div><br></div><div>&nbsp;=
 &nbsp; &nbsp; hash2</div><div>&nbsp; &nbsp; end</div><div><br></div><div>&=
nbsp; &nbsp; # Synonym for Hash#rekey, but modifies the receiver in place (=
and returns it).</div><div>&nbsp; &nbsp; #</div><div>&nbsp; &nbsp; # &nbsp;=
 foo =3D { :name=3D&gt;'Gavin', :wife=3D&gt;:Lisa }</div><div>&nbsp; &nbsp;=
 # &nbsp; foo.rekey!{ |k| k.to_s } &nbsp;#=3D&gt; &nbsp;{ "name"=3D&gt;"Gav=
in", "wife"=3D&gt;:Lisa }</div><div>&nbsp; &nbsp; # &nbsp; foo &nbsp; &nbsp=
; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; #=3D&gt; &=
nbsp;{ "name"=3D&gt;"Gavin", "wife"=3D&gt;:Lisa }</div><div>&nbsp; &nbsp; #=
</div><div>&nbsp; &nbsp; # CREDIT: Trans, Gavin Kistner</div><div><br></div=
><div>&nbsp; &nbsp; def rekey!(key_map=3Dnil, &amp;block)</div><div>&nbsp; =
&nbsp; &nbsp; replace(rekey(key_map, &amp;block))</div><div>&nbsp; &nbsp; e=
nd</div><div><br></div><div>&nbsp; end</div><div><br></div><div>Not the use=
 of `facets/na`. That is defined as:</div><div><br></div><div><div>&nbsp; &=
nbsp; class &lt;&lt; NA =3D ArgumentError.new</div><div>&nbsp; &nbsp; &nbsp=
; def inspect ; 'N/A' ; end</div><div>&nbsp; &nbsp; &nbsp; def method_missi=
ng(*); self; end</div><div>&nbsp; &nbsp; end</div></div><div><br></div><div=
>But it is really nothing more than a dummy object used to mean Not Applica=
ble. So in the case of #rekey, if the block returns NA then the key goes un=
changed. Thinking about it again now, it's probably&nbsp;unnecessary, but I=
 had wanted a way to say "leave it alone" while also making sure that `nil`=
 could still be used as a key (even if that's rare). Feel free to remove th=
e NA business, but if you do please explain why you think its not needed.</=
div><div><br></div><div>Best solution will get their name put in front of C=
REDITs for the next release of Facets.&nbsp;</div><div><br></div>
------=_Part_94_2156403.1355077165409--

------=_Part_93_24450722.1355077165409--