From: Josh Cheek <josh.cheek@...>
Date: 2013-03-13T22:01:27+09:00
Subject: Re: cannot get blocks working

--047d7b3441c4cb3a8c04d7ce0070
Content-Type: text/plain; charset=ISO-8859-1

On Wed, Mar 13, 2013 at 7:58 AM, Josh Cheek <josh.cheek@gmail.com> wrote:

> On Wed, Mar 13, 2013 at 7:30 AM, Aashish Kiran <lists@ruby-forum.com>wrote:
>
>> Hi,
>> Below is the piece of code. Can anyone help in getting expected output.
>>
>>
>> ------------------------------------------------------------
>>
>> class XmlDoc
>>   def method_missing(name, *args, &block)
>>     self.class.class_eval do
>>       define_method(name) do |*args, &block|
>>         if block_given?
>>           temp = "<#{name}#{temp}>" + block.call + "</#{name}>"
>>         else
>>           "<#{name}></#{name}>"
>>         end
>>       end
>>     end
>>     send(name, *args, &block)
>>   end
>> end
>>
>> x = XmlDoc.new
>>
>>
>> p '1111111111111111111'
>> p x.hello
>> #expected output "<hello></hello>"
>>
>> p x.hello{"dolly"}
>> #expected output   "<hello>dolly</hello>"
>>
>> -----------------------------------------------------------------------
>>
>> Thanks,
>> Aashish
>>
>> --
>> Posted via http://www.ruby-forum.com/.
>>
>>
> Change `block_given?` to `block`. The block_given? macro is checking if
> method_missing received a block. Since it didn't the first time you called
> x.hello, it never will (that scope was enclosed).
>
> Also, you should move the method definition out to a helper method,
> because the methods that this defines will capture the block sent to
> method_missing, which in turn capture their environments. Since they're
> becoming methods, they won't be garbage collected, so you run the risk of
> memory leaks. Moving it to a helper method will prevent capturing of the
> block.
>
> Also, when doing metaprogramming, it's usually best to use __send__
> instead of send (to avoid potential namespace conflicts).
>
> I would probably write it like this (well, at this point in my life, I
> probably wouldn't write anything this dynamic, but whatever)
>
>
> class XmlDoc
>   def self.define_node(name)
>     define_method name do |*args, &block|
>       block ||= lambda { '' }
>       "<#{name}>" + block.call + "</#{name}>"
>     end
>   end
>
>   def method_missing(name, *args, &block)
>     self.class.define_node name
>     __send__ name, *args, &block
>   end
> end
>
> x = XmlDoc.new
> x.hello           # => "<hello></hello>"
> x.hello{"dolly"}  # => "<hello>dolly</hello>"
>
>
> -Josh
>

I guess I would also interpolate the block.call, which would allow nil to
be returned, which would allow you to get rid of the reassignment to the
empty lambda.

    define_method name do |*args, &block|
      "<#{name}>#{block.call if block}</#{name}>"
    end

--047d7b3441c4cb3a8c04d7ce0070
Content-Type: text/html; charset=ISO-8859-1
Content-Transfer-Encoding: quoted-printable

On Wed, Mar 13, 2013 at 7:58 AM, Josh Cheek <span dir=3D"ltr">&lt;<a href=
=3D"mailto:josh.cheek@gmail.com" target=3D"_blank">josh.cheek@gmail.com</a>=
&gt;</span> wrote:<br><div class=3D"gmail_quote"><blockquote class=3D"gmail=
_quote" style=3D"margin:0 0 0 .8ex;border-left:1px #ccc solid;padding-left:=
1ex">
<div class=3D"HOEnZb"><div class=3D"h5">On Wed, Mar 13, 2013 at 7:30 AM, Aa=
shish Kiran <span dir=3D"ltr">&lt;<a href=3D"mailto:lists@ruby-forum.com" t=
arget=3D"_blank">lists@ruby-forum.com</a>&gt;</span> wrote:<br><div class=
=3D"gmail_quote">
<blockquote class=3D"gmail_quote" style=3D"margin:0 0 0 .8ex;border-left:1p=
x #ccc solid;padding-left:1ex">
Hi,<br>
Below is the piece of code. Can anyone help in getting expected output.<br>
<br>
<br>
------------------------------------------------------------<br>
<br>
class XmlDoc<br>
=A0 def method_missing(name, *args, &amp;block)<br>
=A0 =A0 self.class.class_eval do<br>
=A0 =A0 =A0 define_method(name) do |*args, &amp;block|<br>
=A0 =A0 =A0 =A0 if block_given?<br>
=A0 =A0 =A0 =A0 =A0 temp =3D &quot;&lt;#{name}#{temp}&gt;&quot; + block.cal=
l + &quot;&lt;/#{name}&gt;&quot;<br>
=A0 =A0 =A0 =A0 else<br>
=A0 =A0 =A0 =A0 =A0 &quot;&lt;#{name}&gt;&lt;/#{name}&gt;&quot;<br>
=A0 =A0 =A0 =A0 end<br>
=A0 =A0 =A0 end<br>
=A0 =A0 end<br>
=A0 =A0 send(name, *args, &amp;block)<br>
=A0 end<br>
end<br>
<br>
x =3D XmlDoc.new<br>
<br>
<br>
p &#39;1111111111111111111&#39;<br>
p x.hello<br>
#expected output &quot;&lt;hello&gt;&lt;/hello&gt;&quot;<br>
<br>
p x.hello{&quot;dolly&quot;}<br>
#expected output =A0 &quot;&lt;hello&gt;dolly&lt;/hello&gt;&quot;<br>
<br>
-----------------------------------------------------------------------<br>
<br>
Thanks,<br>
Aashish<br>
<span><font color=3D"#888888"><br>
--<br>
Posted via <a href=3D"http://www.ruby-forum.com/" target=3D"_blank">http://=
www.ruby-forum.com/</a>.<br>
<br>
</font></span></blockquote></div><br></div></div><div>Change `block_given?`=
 to `block`. The block_given? macro is checking if method_missing received =
a block. Since it didn&#39;t the first time you called x.hello, it never wi=
ll (that scope was enclosed).</div>

<div><br></div><div>Also, you should move the method definition out to a he=
lper method, because the methods that this defines will capture the block s=
ent to method_missing, which in turn capture their environments. Since they=
&#39;re becoming methods, they won&#39;t be garbage collected, so you run t=
he risk of memory leaks. Moving it to a helper method will prevent capturin=
g of the block.</div>

<div><br></div><div>Also, when doing metaprogramming, it&#39;s usually best=
 to use __send__ instead of send (to avoid potential namespace conflicts).<=
/div><div><br></div><div>I would probably write it like this (well, at this=
 point in my life, I probably wouldn&#39;t write anything this dynamic, but=
 whatever)</div>

<div><br></div><div><br></div><div><div>class XmlDoc</div><div>=A0 def self=
.define_node(name)</div><div>=A0 =A0 define_method name do |*args, &amp;blo=
ck|</div><div>=A0 =A0 =A0 block ||=3D lambda { &#39;&#39; }</div><div>=A0 =
=A0 =A0 &quot;&lt;#{name}&gt;&quot; + block.call + &quot;&lt;/#{name}&gt;&q=
uot;</div>

<div>=A0 =A0 end</div><div>=A0 end</div><div>=A0=A0</div><div>=A0 def metho=
d_missing(name, *args, &amp;block)</div><div>=A0 =A0 self.class.define_node=
 name</div><div>=A0 =A0 __send__ name, *args, &amp;block</div><div class=3D=
"im"><div>=A0 end</div>
<div>end</div>
<div><br></div><div>x =3D XmlDoc.new</div></div><div>x.hello =A0 =A0 =A0 =
=A0 =A0 # =3D&gt; &quot;&lt;hello&gt;&lt;/hello&gt;&quot;</div><div>x.hello=
{&quot;dolly&quot;} =A0# =3D&gt; &quot;&lt;hello&gt;dolly&lt;/hello&gt;&quo=
t;</div></div><span class=3D"HOEnZb"><font color=3D"#888888"><div>
<br>
</div><div><br></div><div>-Josh</div>
</font></span></blockquote></div><br><div>I guess I would also interpolate =
the block.call, which would allow nil to be returned, which would allow you=
 to get rid of the reassignment to the empty lambda.</div><div><br></div>
<div><div>=A0 =A0 define_method name do |*args, &amp;block|</div><div>=A0 =
=A0 =A0 &quot;&lt;#{name}&gt;#{block.call if block}&lt;/#{name}&gt;&quot;</=
div><div>=A0 =A0 end</div></div>

--047d7b3441c4cb3a8c04d7ce0070--