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

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

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

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

On Wed, Mar 13, 2013 at 7:30 AM, Aashish Kiran <span dir=3D"ltr">&lt;<a hre=
f=3D"mailto:lists@ruby-forum.com" target=3D"_blank">lists@ruby-forum.com</a=
>&gt;</span> wrote:<br><div class=3D"gmail_quote"><blockquote class=3D"gmai=
l_quote" style=3D"margin:0 0 0 .8ex;border-left:1px #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 class=3D"HOEnZb"><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>Change `block_given?` to `block`.=
 The block_given? macro is checking if method_missing received a block. Sin=
ce it didn&#39;t the first time you called x.hello, it never will (that sco=
pe 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>=A0 end<=
/div><div>end</div>
<div><br></div><div>x =3D XmlDoc.new</div><div>x.hello =A0 =A0 =A0 =A0 =A0 =
# =3D&gt; &quot;&lt;hello&gt;&lt;/hello&gt;&quot;</div><div>x.hello{&quot;d=
olly&quot;} =A0# =3D&gt; &quot;&lt;hello&gt;dolly&lt;/hello&gt;&quot;</div>=
</div><div><br>
</div><div><br></div><div>-Josh</div>

--e89a8f22bcc3abcac504d7cdf77b--