11155
September 17, 2013, 7:59pm
1
I am using this plugin and trying to extend it:
module SubdomainRoutes
class HostNotSupplied < StandardError
end
module RewriteSubdomainOptions
include SplitHost
def subdomain_procs
ActionController::Routing::Routes.subdomain_procs
end
def rewrite_subdomain_options(options, host, port = nil, protocol = nil)
if subdomains = options[:subdomains]
old_subdomain, domain = split_host(host)
options_subdomain = options.has_key?(:subdomain) ? options[:subdomain].to_param.to_s.downcase : nil
new_subdomain = options_subdomain || old_subdomain
begin
case subdomains
when Array
unless subdomains.include? new_subdomain
show original
The plugin heavily modifies some the Rails routing (Rails 2.3.x in this
case, but that's not important)
It usually follows this pattern:
module SubdomainRoutes
module UrlWriter
def self.included(base)
base.alias_method_chain :rewrite, :subdomains
end
def native_plugin_method
...a bunch of code
end
def rewrite_with_subdomains
...code
end
end
end
ActionController::UrlWriter.send :include, SubdomainRoutes::UrlWriter
In my own classes I am attempting to override some of these methods. So
i do this:
module CustomRouting
def native_plugin_method
#successfully invoked
...a bunch of code
super #will call method from SubdomainRoutes::UrlWriter
end
def rewrite_with_subdomains
#method is never invoked
...code
super
end
end
ActionController::UrlWriter.send :include, CustomRouting
The method created with alias_method_chain is never affected! My code
successfully overrides 'native_plugin_method', but it seems to do
nothing with rewrite_with_subdomains, even though everything is
identical.
Is there something about aliased methods that does not resolve in the
same way as standard methods?
aliasing pretty much creates a copy of a method - later attempts to redefine the original method don’t affect the copy. For example
class Example
def foo
puts “foo”
end
alias_method :bar, :foo
def foo
puts “new foo”
end
end
Example.new.foo() #=> “new foo”
Example.new.bar() #=> “foo”
You’ll have to do your own alias method chaining when you include your module (in newer versions of rails alias_method_chain has falled out of favour)
Fred
11155
September 18, 2013, 2:27pm
3
Frederick Cheung wrote in post #1121711:
aliasing pretty much creates a copy of a method - later attempts to
redefine the original method don't affect the copy. For example
class Example
def foo
puts "foo"
end
alias_method :bar, :foo
def foo
puts "new foo"
end
end
Example.new.foo() #=> "new foo"
Example.new.bar() #=> "foo"
You'll have to do your own alias method chaining when you include your
module (in newer versions of rails alias_method_chain has falled out of
favour)
Fred
That's exactly what it was! I had to re-alias the method names.
So the original plugin used alias_method_chain to alias :rewrite,
:rewrite_with_subdomain
I had to restructure my module like this:
module CustomRouting
def included(base)
base.send :alias_method, :rewrite, :rewrite_with_subdomains
end
def native_plugin_method
#successfully invoked
...a bunch of code
super #will call method from SubdomainRoutes::UrlWriter
end
def rewrite_with_subdomains
#method is never invoked
...code
super
end
end
And now my overloaded method is correctly invoked, and the 'super' call
works properly and invokes the previous alias.
This was really complicated. phew
