Issue #4085 has been updated by trans (Thomas Sawyer). =begin This is why refinements as decorators break Christmas present principle. Rudolph is a library to light everything in red. Our developer, elf1, knows better then to monkey patch: # lib/rudolph.rb require 'ansi' module Rudolph class RedString < String def to_s super.ansi(:red) end end def self.light!(string) RedString.new(string.to_s) end end Now we all know on Christmas Santa likes a lot of blinky bling, so elf2 decides to go all out. # lib/christmas/refinements require 'ansi' module Christmas module Refinements refine String do def to_s super.ansi(:blink) end end end end Awesome. Now he just needs to setup Santa to spread good cheer and use Rudolph to ensure a well lit way. require 'christmas/refinements' using Christmas::Refinements module Christmas class Santa def spread_cheer! puts "Merry Christmas!" end def on_rudolph! puts Rudolph.light!("The Way!") end end end But uh oh! Why is rudolph blinky? He can't be blinky b/c he must clearly guide the way! Okay so that is a really silly example. But imagine a more serious scenario using the same pattern, i.e. a 3rd party library has subclassed some base class. You of course have no idea that the developer even used said base class --his library is a black box, as it should be. For your app you decide to refine said base class. You also want to use the 3rd party library, but lo, it appears to be broken! =end ---------------------------------------- Feature #4085: Refinements and nested methods https://bugs.ruby-lang.org/issues/4085#change-34305 Author: shugo (Shugo Maeda) Status: Assigned Priority: Normal Assignee: matz (Yukihiro Matsumoto) Category: core Target version: 2.0.0 =begin As I said at RubyConf 2010, I'd like to propose a new features called "Refinements." Refinements are similar to Classboxes. However, Refinements doesn't support local rebinding as mentioned later. In this sense, Refinements might be more similar to selector namespaces, but I'm not sure because I have never seen any implementation of selector namespaces. In Refinements, a Ruby module is used as a namespace (or classbox) for class extensions. Such class extensions are called refinements. For example, the following module refines Fixnum. module MathN refine Fixnum do def /(other) quo(other) end end end Module#refine(klass) takes one argument, which is a class to be extended. Module#refine also takes a block, where additional or overriding methods of klass can be defined. In this example, MathN refines Fixnum so that 1 / 2 returns a rational number (1/2) instead of an integer 0. This refinement can be enabled by the method using. class Foo using MathN def foo p 1 / 2 end end f = Foo.new f.foo #=> (1/2) p 1 / 2 In this example, the refinement in MathN is enabled in the definition of Foo. The effective scope of the refinement is the innermost class, module, or method where using is called; however the refinement is not enabled before the call of using. If there is no such class, module, or method, then the effective scope is the file where using is called. Note that refinements are pseudo-lexically scoped. For example, foo.baz prints not "FooExt#bar" but "Foo#bar" in the following code: class Foo def bar puts "Foo#bar" end def baz bar end end module FooExt refine Foo do def bar puts "FooExt#bar" end end end module Quux using FooExt foo = Foo.new foo.bar # => FooExt#bar foo.baz # => Foo#bar end Refinements are also enabled in reopened definitions of classes using refinements and definitions of their subclasses, so they are *pseudo*-lexically scoped. class Foo using MathN end class Foo # MathN is enabled in a reopened definition. p 1 / 2 #=> (1/2) end class Bar < Foo # MathN is enabled in a subclass definition. p 1 / 2 #=> (1/2) end If a module or class is using refinements, they are enabled in module_eval, class_eval, and instance_eval if the receiver is the class or module, or an instance of the class. module A using MathN end class B using MathN end MathN.module_eval do p 1 / 2 #=> (1/2) end A.module_eval do p 1 / 2 #=> (1/2) end B.class_eval do p 1 / 2 #=> (1/2) end B.new.instance_eval do p 1 / 2 #=> (1/2) end Besides refinements, I'd like to propose new behavior of nested methods. Currently, the scope of a nested method is not closed in the outer method. def foo def bar puts "bar" end bar end foo #=> bar bar #=> bar In Ruby, there are no functions, but only methods. So there are no right places where nested methods are defined. However, if refinements are introduced, a refinement enabled only in the outer method would be the right place. For example, the above code is almost equivalent to the following code: def foo klass = self.class m = Module.new { refine klass do def bar puts "bar" end end } using m bar end foo #=> bar bar #=> NoMethodError The attached patch is based on SVN trunk r29837. =end -- http://bugs.ruby-lang.org/