On Monday, July 30, 2012 9:28:04 PM UTC-4, Matthew Kerwin wrote:
>
>
> For what it's worth, I kind of like this solution, but I get the
> feeling there's something not quite right about it.
Same here, but it's probably just b/c its unusual --its not something you
can really do in any other language but Ruby, that I know of. Granted it is
not perfectly ideal in that modules don't "inherit" exactly in the same way
classed, but that turns out not to be much of an issue in this case. The
whole notion of this was a sort of inverted factory, so the forward facing
API looks normal, e.g. `Main.new`, but versioning still occurs under the
hood.
> An alternative
> could be to strategically name source files, and `require` the
> appropriate one; in that case each version-specific file could
> redefine the relevant part of Main. E.g.
>
> # File: main.rb
> class Main
> def initialize version
> require "./main-v#{version}.rb"
> end
> # universal code
> end
>
> # File main-v0.rb
> class Main
> # version-specific code
> end
>
> It splits things up into maintainable files quite nicely, and also has
> less parsing (for what that's worth.) However it wouldn't work if you
> need two different versions of Main in the one program.
>
Yep. Exactly why that approach does work in my case.
> Alternatively you could create a factory, which is essentially what
> you've done, but might be a bit more recognisable to, or better
> understood by, maintainers. E.g.
>
> class Main
> # ... universal code
> end
> class MainV0 < Main
> # ... version-specific code
> end
> module MainFactory
> def self.create version
> const_get("MainV#{version}").new
> end
> end
>
> It's mostly a fluff change to what you've already got, but it means
> each object has the version-specific API as their class rather than a
> mixed-in module (i.e. no real difference as far as I'm aware), and
> it's clear that the MainFactory is a factory and that each of the
> MainVx classes are what it instantiates, whereas a partially
> implemented Main class with some strange magic in its #initialize
> method might be a bit less clear.
>
Yes, that's the traditional factory approach. I actually would not want to
use "MainFactory", as don't want it to be explicit. But it occurs to me
that I could have redefined `Main.new` as a factory method and done it that
way. And the more I think about it the more that seems like a better
approach. It would work well for Main as well as other classes within it.
-- You received this message because you are subscribed to the Google Groups
ruby-talk-google group. To post to this group, send email to
[email protected]. To unsubscribe from this group, send email
to [email protected]. For more options, visit this
group at https://groups.google.com/d/forum/ruby-talk-google?hl=en
