Re: [Bug?] Module/Class definitions cannot take non literal blocks

On Jan 16, 2008 1:23 PM, David A. Black <[e-mail]> wrote:
> Hi --
>
> On Wed, 16 Jan 2008, Robert Dober wrote:
>
> > Hi list
> >
> > I was just about to rewrite pure-traits to be 1.9 compatible just to
> > discover that the following does not work anymore
> >
> > def taint &blk
> >   ...
> >   Module::new &blk
> >   ...
> > end
> >
> > I did not find any workarounds :(
>
> On 1.9.0.0 it seems to work:
>
> >> RUBY_VERSION
> => "1.9.0"
> >> def x(&block); Module.new(&block); end
> => nil
> >> m = x { }
> => #<Module:0x53ebac>
>
> What does it do, or not do, when you do it?
So sorry David, I am really not a good bug reporter, here we go:
As a resume there seem to be two bugs:
Literally passing a block to ClassOrModule::new works as in 1.8
Passing a &blk to ClassOrModule seems to make the methods defined in
the block private *and* their name cannot be seen in
Module#private_instance_methods while it can be perfectly seen in
Class#private_instance_methods *even* when included from a module
where it cannot be seen:
Confusing? I guess so, here come some examples:

puts RUBY_VERSION

def assert condition, text
  puts condition ? "#{text} . . . ok" : "#{text} . . . failed"
end
def make_a_module mod_or_class, &blk
  mod_or_class::new &blk
end

m1 = make_a_module( Module ){ def a; 42 end }
assert m1.instance_methods.include?( :a ), "Block Var: Module Instance
Method name visible"
assert m1.private_instance_methods.include?( :a ), "Block Var: Module
Private Instance Method name visible"

m2 = Module::new { def a; 42 end }
assert m2.instance_methods.include?( :a ), "Literal Block: Module
Instance Method name visible"

c1 = make_a_module( Class ){ def a; 42 end }
assert c1.instance_methods.include?( :a ), "Block Var: Class Instance
Method name visible"
assert c1.new.send(:a) == 42, "Block Var: Private Class Instance
Method callable and correct result"
assert c1.private_instance_methods.include?( :a ), "Block Var: Private
Instance Method visible"
begin
  assert c1.new.a == 42, "Block Var: Class Instance Method callable
and correct result"
rescue NoMethodError => error
  puts "Block Var: Class Instance Method callable . . . Error #{error}"
end

c2 = Class::new{ def a; 42 end }
assert c2.instance_methods.include?( :a ), "Literal Block: Class
Instance Method name visible"
assert c2.new.send(:a) == 42, "Literal Block: Private Class Instance
Method callable and correct result"
assert c2.new.a == 42, "Literal Block: Class Instance Method callable
and correct result"

c1 = Class::new{ include m1 }
assert c1.instance_methods.include?( :a ), "Block Var: Class Included
Instance Method name visible"
assert c1.private_instance_methods.include?( :a ), "Block Var: Class
Included Private Instance Method name visible"
begin
  assert c1.new.a == 42, "Class Included Instance Method callable and
correct result"
rescue NoMethodError => error
  puts "Block Var: Class Included Instance Method callable . . . Error #{error}"
end

1.9.0
Block Var: Module Instance Method name visible . . . failed
Block Var: Module Private Instance Method name visible . . . failed
Literal Block: Module Instance Method name visible . . . ok
Block Var: Class Instance Method name visible . . . failed
Block Var: Private Class Instance Method callable and correct result . . . ok
Block Var: Private Instance Method visible . . . ok
Block Var: Class Instance Method callable . . . Error private method
`a' called for #<#<Class:0xb7d17998>:0xb7d17808>
Literal Block: Class Instance Method name visible . . . ok
Literal Block: Private Class Instance Method callable and correct
result . . . ok
Literal Block: Class Instance Method callable and correct result . . . ok
Block Var: Class Included Instance Method name visible . . . failed
Block Var: Class Included Private Instance Method name visible . . . ok
Block Var: Class Included Instance Method callable . . . Error private
method `a' called for #<#<Class:0xb7d17588>:0xb7d17484>