Re: how to check if some object is included in some module?

Yup, regexp would be another possible way to do it.

But still, let me bring an example.

m =3D MyModule::AnotherModule::MyClass

if m.descendant?(MyModule)
  # do something
else
  # do something else
end

let's say that it's possible that m would be of type
MyModule::AnotherModule::MyClass,
MyModule::CompletelyAnotherModule::AnotherClass,
AnotherModule::YetAnotherClass.

Yes, it would make sense that if i knew which are all of the possible
types then i could do something like this instead:
if m.kind_of?(MyModule::AnotherModule::MyClass) || m.kind_of?
(MyModule::CompletelyAnotherModule::AnotherClass)
  # do something
else
  # do something else
end

but the problem is that i don't know all the possible types it might
be and it is decided at runtime. I just know that every object, which
is in module (for this example) MyModule should be handled in one way
and all objects which are not within MyModule namespace at all -
another way. So how would you recommend me to handle this kind of case
if you're saying that i should not do it? I still don't see any (much)
better solution than provided by me so far.

Jarmo Pertman
-----
IT does really matter - http://www.itreallymatters.net

On Aug 2, 3:30=A0pm, Brian Candler <[e-mail]> wrote:
> =3D> #<MyModule::AnotherModule::MyClass:0xb7436be4>>> o.class.name
>
> =3D> "MyModule::AnotherModule::MyClass">> puts "Yippee" if o.class.name =
=3D~ /\bMyModule\b/
>
> Yippee
> =3D> nil>> puts "Yippee" if o.class.name =3D~ /\bAnotherModule\b/
>
> Yippee
> =3D> nil
>
> > So, both of you think that this solution would be best to do something
> > like this? Or you're saying that i should not do something like this
> > at all?
>
> Modules are just namespaces. It seems odd to ask an object what
> namespace its class is in. As I've shown above, you can do this - but
> why would you want to?
>
> The only time I've wanted to do anything close to this is dynamic
> constant resolution:
>
> module X
> =A0 class Foo
> =A0 =A0 N=3D1
> =A0 =A0 def show_n
> =A0 =A0 =A0 puts self.class::N
> =A0 =A0 end
> =A0 end
> =A0 class Bar < Foo
> =A0 =A0 N=3D2
> =A0 end
> end
> X::Foo.new.show_n =A0 # 1
> X::Bar.new.show_n =A0 # 2
>
> But even then, neither Foo nor Bar cares whether it is inside module X.
> You can remove the module X wrapper completely, changing X::Foo.new to
> Foo.new, and it will work just the same.
>
> Equally, if it *did* make a difference whether you were inside module X
> or module Y (perhaps because there were different constants or classes
> available), then you'd have to write your code differently within those
> modules anyway.
>
> module X
> =A0 N=3D1
> =A0 class Foo
> =A0 =A0 def yo; puts N; end
> =A0 end
> end
> module Y
> =A0 M=3D2
> =A0 class Bar
> =A0 =A0 def yo; puts M; end
> =A0 end
> end
> --
> Posted viahttp://www.ruby-forum.com/.