I’ve been using a factory pattern for a set of packaging classes
–classes that generate different package formats (eg. Debian, RPM,
etc.), but it’s not quite the right fit b/c it leads to repetition of
the staging step. Yuk! So I think a better fit is to have one class
(Packager) that calls on external modules (or classes) for each
different format. But, unfortuately there are quite a few attributes
needed by each from the Packager, and it’s just doesn’t seem right to
pass that many variables. So it seems like it would be better to just
include the needed module into the Packager class as needed. But here
again I can’t un-include a format module once done with it in order to
use another format. So I’m right back to using a factory pattern.
Then I had this idea. and I’m wondering what others think of it.
First we need this little extension from Facets:
class Object
# Like super but skips to a specific ancestor module or class.
#
# class A
# def x ; 1 ; end
# end
#
# class B < A
# def x ; 2 ; end
# end
#
# class C < B
# def x ; superior(A) ; end
# end
#
# C.new.x #=> 1
#
def superior(klass=self.class.superclass, *args, &blk)
unless self.class.ancestors.include?(klass)
raise ArgumentError
end
called = /\`([^\']+)\'/.match(caller(1).first)[1].to_sym
klass.instance_method(called).bind(self).call(*args,&blk)
end
end
Then:
module Debian
def pack ; “Debian package”; end
end
I’ve been using a factory pattern for a set of packaging classes
–classes that generate different package formats (eg. Debian, RPM,
etc.), but it’s not quite the right fit b/c it leads to repetition of
the staging step. Yuk! So I think a better fit is to have one class
(Packager) that calls on external modules (or classes) for each
different format. But, unfortuately there are quite a few attributes
needed by each from the Packager, and it’s just doesn’t seem right to
pass that many variables. (…)
Tom, couldn’t you pass the packager itself to the external modules and
let them query the attributes they need?
Tom, couldn’t you pass the packager itself to the external modules and
let them query the attributes they need?
Yes. That would work too. And that might be the best way to do it.
Though it still means writing code to do the attribute transfer, but
that can be automated fairly easily.
I’m still curious about this “multi-module” idea in general though.
Seems like it could be an alternative to code injection too.
I’m still curious about this “multi-module” idea in general though.
Seems like it could be an alternative to code injection too.
T.
why not:
harp:~ > cat a.rb
module DEB
A, B, C = %w( D E B )
def self.pack_step_one() p A end
def self.pack_step_two() p B end
def self.pack_step_three() p C end
def self.pack_step_four(arg) p arg end
end
module RPM
A, B, C = %w( R P M )
def self.pack_step_one() p A end
def self.pack_step_two() p B end
def self.pack_step_three() p C end
def self.pack_step_four(arg) p arg end
end
class Packager
def initialize type
@type = type
end
def pack arg
@type.instance_eval{
pack_step_one
pack_step_two
pack_step_three
pack_step_four arg
}
end
end
packager = Packager.new DEB
packager.pack 42
harp:~ > ruby a.rb
"D"
"E"
"B"
42
??
btw. for these kinds of setups: modules with state (singletons) i’ve
been
using prototypes lately:
harp:~ > cat a.rb
require 'prototype'
DEB = prototype{
@a, @b, @c = %w( D E B )
def pack_step_one() p @a end
def pack_step_two() p @b end
def pack_step_three() p @c end
def pack_step_four(arg) p arg end
}
RPM = prototype{
@a, @b, @c = %w( D E B )
def pack_step_one() p @a end
def pack_step_two() p @b end
def pack_step_three() p @c end
def pack_step_four(arg) p arg end
}
class Packager
attr 'type'
def initialize type
@type = type
end
def pack arg
@type.instance_eval{
pack_step_one
pack_step_two
pack_step_three
pack_step_four arg
}
end
end
packager = Packager.new DEB
packager.pack 42
harp:~ > ruby -r rubygems a.rb
"D"
"E"
"B"
42
i guess i’m failing to see what multi-module inclusion givs you that
delegation
plus argument passing (into the delegate module not the other way
around)
doesn’t?
Only becuase there are a lot of arguments to pass.
btw. for these kinds of setups: modules with state (singletons) i’ve been
using prototypes lately:
Right on. I do like the prototype stuff. Just don’t have the time to
invest init at them moment though.
[snip cool example use of prototype]
i guess i’m failing to see what multi-module inclusion givs you that delegation
plus argument passing (into the delegate module not the other way around)
doesn’t?
The advantage is access to the internal state --no passing of
attributes required. Esspecailly true when you have alot of
attributes/arguments involved. Simple example:
require 'facet/kernel/as'
module DEB
A, B, C = %w( D E B )
def pack_step_one() p A+a end
def pack_step_two() p B+b end
def pack_step_three() p C+c end
end
module RPM
A, B, C = %w( R P M )
def pack_step_one() p A+a+b+c end
def pack_step_two() p B+b+c+a end
def pack_step_three() p C+c+a+b end
end
class Packager
include DEB, RPM
attr :a,:b,:c
def initialize
@a,@b,@c = %w{ 1 2 3 }
end
def pack type
as(type).pack_step_one
as(type).pack_step_two
as(type).pack_step_three
end
end
packager = Packager.new
packager.pack DEB, 42
harp:~ > ruby a.rb
"D123"
"E231"
"B312"
42
Note #as works like #superior from my last example but uses magic-dot
notation to allow any method to be called. (It would be nice if it took
a block but I’ll have to work on that).
Only becuase there are a lot of arguments to pass.
hash? array?
module DEB
def pack_step_three() p C+c+a+b end
as(type).pack_step_two
"B312"
42
Note #as works like #superior from my last example but uses magic-dot
notation to allow any method to be called. (It would be nice if it took a
block but I’ll have to work on that).
hmm. how bout this:
harp:~ > cat a.rb
class Object
def including m, &b
(class << (d=dup); self; end).module_eval{ include m }
d.instance_eval &b
end
end
module DEB
A, B, C = %w( D E B )
def pack_step_one() p A+a end
def pack_step_two() p B+b end
def pack_step_three() p C+c end
end
module RPM
A, B, C = %w( R P M )
def pack_step_one() p A+a+b+c end
def pack_step_two() p B+b+c+a end
def pack_step_three() p C+c+a+b end
end
class Packager
[:a,:b,:c].each{|a| attr a}
def initialize
@a,@b,@c = %w{ 1 2 3 }
end
def pack type, *a
including(type){
pack_step_one
pack_step_two
pack_step_three
}
end
end
packager = Packager.new
packager.pack DEB, 42
harp:~ > ruby a.rb
"D1"
"E2"
"B3"
sure the performance will suck though ;-(
fun stuff…
i like your ‘as’ method.
-a
This forum is not affiliated to the Ruby language, Ruby on Rails framework, nor any Ruby applications discussed here.