From: "rosenfeld (Rodrigo Rosenfeld Rosas)" <rr.rosas@...>
Date: 2013-02-23T02:18:45+09:00
Subject: [ruby-core:52712] [ruby-trunk - Feature #7914] Case for local class methods


Issue #7914 has been updated by rosenfeld (Rodrigo Rosenfeld Rosas).


Maybe you could ask for some special method/keyword to know if the class is the same as the declared one (instead of some inheriting class):

  def special_name
    local_class? ? 'unique:Y' : super
  end

Or instead of "local_class" you could ask if it has been called as a "super" method:

  def special_name
    called_by_super? ? super : 'unique:Y'
  end

----------------------------------------
Feature #7914: Case for local class methods
https://bugs.ruby-lang.org/issues/7914#change-36799

Author: trans (Thomas Sawyer)
Status: Open
Priority: Normal
Assignee: 
Category: core
Target version: 2.1.0


=begin
Here is a use case for local class methods.

Say we wish to give certain classes and all subclasses a special name.

  class X
    def self.special_name
      "special:#{name}"
    end
  end
  class Y < X; end
  class Z < Y; end

  Z.special_name  #=> "special:Z"

But what if Y has a unique special name?

  class Y < X
    def special_name
      'unique:Y'
    end
  end

Problem that arises:

    Z.special_name  #=> "unique:Y"  # wrong!

Currently, to solve this would require creating an additional method, e.g. `unique_name` and redefine `special_name` to first look for unique_name then fallback to default special name if non-found. It works, but adds additional complexity to API.

Nicer solution would be local class methods.

    class Y < X
      def special_name
        'unique:Y'
      end
      local :special_name
    end

    Y.special_name  #=> "unique:Y"
    Z.special_name  #=> "special:Z"

The idea being that local class methods are skipped in super/lookup chain.

This idea is not without precedence. Module class methods can be thought of as being local. So this idea has other side of the notion, that modules could have class methods that are not skipped over in the super/lookup chain. In that case we would need a term that means opposite of local, so I'll use `nonlocal`:

    module M
      def self.q; "q"; end
      nonlocal :q
    end

    class X
      include M
    end

    X.q  #=> "q"

=end



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