Solutions for deep class paths

[Luke Kanies]

Hi all,

I've currently got a very flat code structure in a large code base
[1], and I'm looking at redoing the layout to make the functional
lines more obvious. This redesign will add an extra constant to
every class path; e.g., where I might have 'Puppet::Type::User' right
now, I'd have 'Puppet::OSAL::Type::User' in the new layout.

If possible, I'd like to avoid having to type full class paths every
time I talk about a class. I've noticed that Ruby behaves very
differently depending on how I define a class; for instance:

class One
class Two
end
end

will allow Two to use unqualified constants from One, but

class One::Two
end

will not. This is fine for shallow class paths, but it gets annoying
when every single class I define has to look like this:

module Puppet
module OSAL
class Type
class User
...
end
end
end
end

I'd *much* prefer to just write:

module Puppet::OSAL::Type::User
end

But if I do that, then I'll always have to specify the full class
path. I have quite a few classes in Puppet, and having to include
the full wrappers for every constant in the class path would get very
painful, and I would have to be very conscious of load order (because
every class in Puppet::OSAL::Type would either have to specify type's
parent class if there is one, or it would have to be loaded after
Puppet::OSAL::Type was loaded).

Are there semi-standard ways of making deep class paths more
convenient to use?

Thanks,
Luke

1 - http://reductivelabs.com/projects/puppet

 

[Gavin Sinclair]

This is fine for shallow class paths, but it gets annoying
when every single class I define has to look like this:

module Puppet
module OSAL
class Type
class User
...
end
end
end
end

I'd *much* prefer to just write:

module Puppet::OSAL::Type::User
end

module Puppet; module OSAL; class Type
class User
...
end
end

That's all I can think of.

Cheers,
Gavin

 

[gwtmp01]

I'd *much* prefer to just write:

module Puppet::OSAL::Type::User
end

But if I do that, then I'll always have to specify the full class
path.

Can you group all the constants in a module? Something like this:

module Puppet

module Constants
Constant1 = 42
Constant2 = Constant1 * 42
end

module OSAL
module Type
end
end

class OSAL::Type::User
include Constants # Now the constants can be used unqualified

puts Constant1
end

class OSAL::Type::User2
include Constants # Now the constants can be used unqualified

puts Constant2
end
end



Gary Wright

 

[Luke Kanies]

module Puppet; module OSAL; class Type
class User
...
end
end

That's all I can think of.

This still requires a bunch of end statements:

module Puppet; module OSAL; class Type
class User
...
end
end; end; end

Not the worst, I guess, but it'd be nice if I could just manipulate
the constant lookup path or something.

 

[Luke Kanies]

Can you group all the constants in a module? Something like this:

module Puppet

module Constants
Constant1 = 42
Constant2 = Constant1 * 42
end

module OSAL
module Type
end
end

class OSAL::Type::User
include Constants # Now the constants can be used unqualified

puts Constant1
end

class OSAL::Type::User2
include Constants # Now the constants can be used unqualified

puts Constant2
end
end

Well, the constants in this case are all of the class constants, not
arbitrary constants like numbers. So, if I did this, I'd have to
stick a constant for each class into that Constants module.

 

[gwtmp01]

Well, the constants in this case are all of the class constants,
not arbitrary constants like numbers. So, if I did this, I'd have
to stick a constant for each class into that Constants module.

If each class has its own collection of constants, why aren't you
putting the definitions right in the class? In your original post it
sounded like you were looking for a way to have several different
classes have 'direct' access to a common collection of constants
(i.e. without the need for explicit scoping).


Gary Wright

 

[Luke Kanies]

If each class has its own collection of constants, why aren't you
putting the definitions right in the class? In your original post
it sounded like you were looking for a way to have several
different classes have 'direct' access to a common collection of
constants (i.e. without the need for explicit scoping).

Well, that's kind of what I want, except that in this case the
constants are those associated with my classes and modules. E.g.,
the constants in question are 'Puppet' (which points to the Puppet
module) and Puppet::OSAL::Type (which points to the Type class in
Puppet::OSAL).

There's probably a better way to talk about this, I suppose. What I
really want is to have access to all of the classes in Puppet without
having to specify quite so long a constant path everywhere and also
without having to have all of my classes wrapped in four or five
module/end statements.