[ruby-core:55671] [CommonRuby - Feature #8571][Assigned] Refinement inheritance by Module#include

[ruby-core:55671] [CommonRuby - Feature #8571][Assigned] Refinement inheritance by Module#include

[shugo (Shugo Maeda)]

Issue #8571 has been reported by shugo (Shugo Maeda).

----------------------------------------
Feature #8571: Refinement inheritance by Module#include
https://bugs.ruby-lang.org/issues/8571

Author: shugo (Shugo Maeda)
Status: Assigned
Priority: Normal
Assignee: matz (Yukihiro Matsumoto)
Category: 
Target version: 


Currently, refinements are not inherited by Module#include.
How about to make using to activate refinements in the ancestors of the specified module?

For example,

  module A
    refine X do ... end
    refine Y do ... end
  end
  module B
    refine Z do ... end
  end
  module C
    include A
    include B
  end

  using C
  # Refinements in A and B are activated here.

In this code,

  using C

is equivalent to

  C.ancestors.reverse_each { |m| using m }

This feature enables you to distribute refinements into different modules, and then package the refinements into one module.

Please note that Module#include does't activate refinements in the argument module.

For example,

  module C
    include A
    include B

    # Refinements in A and B are not activated here.
  end

I've implemented this feature, and have attached the patch.



-- 
http://bugs.ruby-lang.org/

[ruby-core:55721] [CommonRuby - Feature #8571] Refinement inheritance by Module#include

[matz (Yukihiro Matsumoto)]

Issue #8571 has been updated by matz (Yukihiro Matsumoto).

Assignee changed from matz (Yukihiro Matsumoto) to shugo (Shugo Maeda)

Agreed. It also conforms the original design.

Matz.

----------------------------------------
Feature #8571: Refinement inheritance by Module#include
https://bugs.ruby-lang.org/issues/8571#change-40215

Author: shugo (Shugo Maeda)
Status: Assigned
Priority: Normal
Assignee: shugo (Shugo Maeda)
Category: 
Target version: 


Currently, refinements are not inherited by Module#include.
How about to make using to activate refinements in the ancestors of the specified module?

For example,

  module A
    refine X do ... end
    refine Y do ... end
  end
  module B
    refine Z do ... end
  end
  module C
    include A
    include B
  end

  using C
  # Refinements in A and B are activated here.

In this code,

  using C

is equivalent to

  C.ancestors.reverse_each { |m| using m }

This feature enables you to distribute refinements into different modules, and then package the refinements into one module.

Please note that Module#include does't activate refinements in the argument module.

For example,

  module C
    include A
    include B

    # Refinements in A and B are not activated here.
  end

I've implemented this feature, and have attached the patch.



-- 
http://bugs.ruby-lang.org/

[ruby-core:55725] [CommonRuby - Feature #8571][Closed] Refinement inheritance by Module#include

[shugo (Shugo Maeda)]

Issue #8571 has been updated by shugo (Shugo Maeda).

Status changed from Assigned to Closed

matz (Yukihiro Matsumoto) wrote:
> Agreed. It also conforms the original design.

I've committed in r41719.  Thanks.

----------------------------------------
Feature #8571: Refinement inheritance by Module#include
https://bugs.ruby-lang.org/issues/8571#change-40220

Author: shugo (Shugo Maeda)
Status: Closed
Priority: Normal
Assignee: shugo (Shugo Maeda)
Category: 
Target version: 


Currently, refinements are not inherited by Module#include.
How about to make using to activate refinements in the ancestors of the specified module?

For example,

  module A
    refine X do ... end
    refine Y do ... end
  end
  module B
    refine Z do ... end
  end
  module C
    include A
    include B
  end

  using C
  # Refinements in A and B are activated here.

In this code,

  using C

is equivalent to

  C.ancestors.reverse_each { |m| using m }

This feature enables you to distribute refinements into different modules, and then package the refinements into one module.

Please note that Module#include does't activate refinements in the argument module.

For example,

  module C
    include A
    include B

    # Refinements in A and B are not activated here.
  end

I've implemented this feature, and have attached the patch.



-- 
http://bugs.ruby-lang.org/