Module

Module

Module은 메서드와 상수의 모음이에요. 모듈 안의 메서드는 인스턴스 메서드일 수도 있고 모듈 메서드일 수도 있어요. 인스턴스 메서드는 모듈이 include될 때 클래스의 메서드로 나타나지만, 모듈 메서드는 그렇게 나타나지 않아요. 반대로 모듈 메서드는 캡슐화하는 객체를 만들지 않고도 호출할 수 있지만, 인스턴스 메서드는 그럴 수 없어요. (Module#module_function 참고.)

module Mod
  include Math
  CONST = 1
  def meth
    # ...
  end
end

Mod.class            #=> Module
Mod.constants        #=> [:CONST, :PI, :E]
Mod.instance_methods #=> [:meth]

출처: Ruby 4.0 API

본문

아래 설명들에서 인자 sym은 심볼을 가리켜요. 따옴표로 감싼 문자열이거나 Symbol(예: :name)이에요.

Public Class Methods

constants → array
constants(inherited) → array

첫 번째 형태는 호출 시점에서 접근 가능한 모든 상수의 이름 배열을 돌려줘요. 전역 스코프에 정의된 모든 모듈·클래스 이름도 포함돼요.

Module.constants.first(4)
# => [:ARGF, :ARGV, :ArgumentError, :Array]

Module.constants.include?(:SEEK_SET)   # => false

class IO
  Module.constants.include?(:SEEK_SET) # => true
end

두 번째 형태는 인스턴스 메서드 constants를 호출해요.

nesting → array

호출 지점에 중첩된 Module 목록을 돌려줘요.

module M1
  module M2
    $a = Module.nesting
  end
end
$a          #=> [M1::M2, M1]
$a[0].name  #=> "M1::M2"

new → mod
new {|mod| block } → mod

새 익명 모듈을 만들어요. 블록이 주어지면 모듈 객체가 넘겨지고, 그 블록은 module_eval처럼 이 모듈의 문맥에서 평가돼요.

fred = Module.new do
  def meth1
    "hello"
  end
  def meth2
    "bye"
  end
end
a = "my string"
a.extend(fred)  #=> "my string"
a.meth1         #=> "hello"
a.meth2         #=> "bye"

일반 모듈처럼 취급하고 싶다면 모듈을 상수(대문자 시작 이름)에 할당하세요.

used_modules → array

현재 스코프에서 사용된 모든 모듈의 배열을 돌려줘요. 배열의 순서는 정의되지 않았어요.

used_refinements → array

현재 스코프에서 사용된 모든 refinement의 배열을 돌려줘요. 순서는 정의되지 않았어요.

Public Instance Methods

self < other → true, false, or nil

self가 other의 서브클래스인지 여부를 돌려줘요. 둘 사이에 관계가 없으면 nil이에요.

Float < Numeric # => true
Numeric < Float # => false
Float < Float   # => false
Float < Hash    # => nil

mod <= other → true, false, or nil

mod가 other의 서브클래스이거나 같으면 true를 돌려줘요. 관계가 없으면 nil. "클래스 정의 관점에서 생각해 보세요. class A < B는 A < B를 뜻해요."

self <=> other → -1, 0, 1, or nil

self와 other를 비교해요. self가 other를 include하거나 other의 서브클래스면 -1, 둘이 같으면 0, other가 self를 include하거나 self의 서브클래스면 1, 그 외엔 nil을 돌려줘요.

# Class Array includes module Enumerable.
  Array <=> Enumerable # => -1
Enumerable <=> Enumerable # =>  0
Enumerable <=> Array      # =>  1
# Class File is a subclass of class IO.
  File <=> IO         # => -1
  File <=> File       # =>  0
    IO <=> File       # =>  1
# Class File has no relationship to class String.
  File <=> String     # => nil

obj == other → true or false
equal?(other) → true or false
eql?(other) → true or false

동등성(Equality) — Object 수준에서 ==는 obj와 other가 같은 객체일 때만 true를 돌려줘요. 보통 서브클래스에서 클래스 고유의 의미를 주도록 재정의해요. ==와 달리 equal?은 객체 정체성(identity)을 판별하므로 서브클래스에서 재정의하면 안 돼요.

obj = "a"
other = obj.dup

obj == other      #=> true
obj.equal? other  #=> false
obj.equal? obj    #=> true

eql?은 obj와 other가 같은 해시 키를 가리킬 때 true를 돌려줘요. Hash가 멤버 동등성을 검사할 때 써요. eql?이 true인 어떤 객체 쌍이든 둘의 hash 값은 같아야 해요. 그래서 eql?를 재정의하면 hash도 적절히 재정의해야 해요. Object 클래스의 객체에서 eql?은 ==과 동의어예요. Numeric 같은 예외도 있는데, ==에서는 타입 변환을 하지만 eql?에서는 하지 않아요.

1 == 1.0    #=> true
1.eql? 1.0  #=> false

mod === obj → true or false

Case Equality — obj가 mod의 인스턴스이거나 mod의 하위(descendant) 인스턴스면 true를 돌려줘요. case 문에서 객체를 클래스별로 분류할 때 쓸 수 있어요.

mod > other → true, false, or nil

mod가 other의 조상(ancestor)이면 true, 같거나 하위면 false, 관계 없으면 nil.

mod >= other → true, false, or nil

mod가 other의 조상이거나 두 모듈이 같으면 true, 관계 없으면 nil.

alias_method(new_name, old_name) → symbol

old_name 메서드의 새 복사본 new_name을 만들어요. 재정의되는 메서드에 대한 접근을 유지할 때 쓸 수 있어요.

module Mod
  alias_method :orig_exit, :exit #=> :orig_exit
  def exit(code=0)
    puts "Exiting with code #{code}"
    orig_exit(code)
  end
end
include Mod
exit(99)
# Exiting with code 99

ancestors → array

mod에 include/prepend된 모듈 목록(mod 자신 포함)을 돌려줘요.

module Mod
  include Math
  include Comparable
  prepend Enumerable
end

Mod.ancestors        #=> [Enumerable, Mod, Comparable, Math]

attr(name, ...) → array
attr(name, true) → array
attr(name, false) → array

첫 형태는 attr_reader와 같아요. 두 번째 형태는 attr_accessor(name)과 같지만 deprecated예요. 마지막 형태는 attr_reader(name)과 같지만 deprecated예요. 정의된 메서드 이름들을 심볼 배열로 돌려줘요.

attr_accessor(symbol, ...) → array
attr_accessor(string, ...) → array

이 모듈에 이름이 붙은 속성을 정의해요. 인스턴스 변수(@name)와 그것을 읽는 접근 메서드를 만들고, 값을 세팅하는 name= 메서드도 만들어요. String 인자는 심볼로 변환돼요. 정의된 메서드 이름 배열을 돌려줘요.

module Mod
  attr_accessor(:one, :two) #=> [:one, :one=, :two, :two=]
end
Mod.instance_methods.sort  #=> [:one, :one=, :two, :two=]

attr_reader(symbol, ...) → array
attr(symbol, ...) → array
attr_reader(string, ...) → array
attr(string, ...) → array

각 인스턴스 변수의 값을 돌려주는 인스턴스 변수와 대응 메서드를 만들어요. 각 이름에 대해 attr :name을 호출하는 것과 같아요. String 인자는 심볼로 변환돼요.

attr_writer(symbol, ...) → array
attr_writer(string, ...) → array

symbol.id2name이라는 속성에 값을 할당하게 해주는 접근 메서드를 만들어요. String 인자는 심볼로 변환돼요.

autoload(const, filename) → nil

mod의 네임스페이스에서 const(문자열 또는 심볼)를 처음 접근할 때 filename을 로드하도록(내부적으로 Kernel::require 사용) 등록해요.

module A
end
A.autoload(:B, "b")
A::B.doit  # autoloads "b"

const가 autoload로 정의돼 있으면 로드할 파일 이름이 filename으로 교체돼요. autoload가 아닌 상수로 정의돼 있으면 아무것도 하지 않아요. 현재 로드 중인 파일은 autoload로 등록하면 안 돼요.

autoload?(name, inherit=true) → String or nil

name이 mod 또는 그 조상의 네임스페이스에 autoload로 등록돼 있으면 로드할 파일 이름을 돌려줘요.

module A
end
A.autoload(:B, "b")
A.autoload?(:B)  #=> "b"

inherit가 false면 리시버 자신의 autoload만 검사해요.

class_eval(string [, filename [, lineno]]) → obj
class_eval {|mod| block } → obj

mod의 문맥에서 문자열 또는 블록을 평가해요. 블록이 주어질 때는 상수/클래스 변수 조회에 영향이 없어요. 클래스에 메서드를 추가할 때 쓸 수 있어요. module_eval은 인자를 평가한 결과를 돌려줘요. 선택적 filename과 lineno는 오류 메시지의 텍스트를 설정해요.

class Thing
end
a = %q{def hello() "Hello there!" end}
Thing.module_eval(a)
puts Thing.new.hello()
Thing.module_eval("invalid code", "dummy", 123)
# Hello there!
# dummy:123:in `module_eval': undefined local variable
#     or method `code' for Thing:Class

module_eval의 별칭이에요.

class_exec(arg...) {|var...| block } → obj

주어진 블록을 클래스/모듈의 문맥에서 평가해요. 블록에서 정의한 메서드는 리시버에 속해요. 메서드에 넘긴 인자는 블록에 전달돼요. 블록이 인스턴스 변수에 접근해야 할 때 유용해요.

class Thing
end
Thing.class_exec{
  def hello() "Hello there!" end
}
puts Thing.new.hello()
# Hello there!

module_exec의 별칭이에요.

class_variable_defined?(symbol) → true or false
class_variable_defined?(string) → true or false

obj에 주어진 클래스 변수가 정의돼 있으면 true를 돌려줘요. String 인자는 심볼로 변환돼요.

class Fred
  @@foo = 99
end
Fred.class_variable_defined?(:@@foo)  #=> true
Fred.class_variable_defined?(:@@bar)  #=> false

class_variable_get(symbol) → obj
class_variable_get(string) → obj

주어진 클래스 변수의 값을 돌려줘요(없으면 NameError). 일반 클래스 변수는 이름에 @@ 부분을 포함해야 해요. String 인자는 심볼로 변환돼요.

class Fred
  @@foo = 99
end
Fred.class_variable_get(:@@foo)  #=> 99

class_variable_set(symbol, obj) → obj
class_variable_set(string, obj) → obj

symbol이름의 클래스 변수를 주어진 객체로 설정해요. 문자열로 넘기면 심볼로 변환돼요.

class Fred
  @@foo = 99
  def foo
    @@foo
  end
end
Fred.class_variable_set(:@@foo, 101)  #=> 101
Fred.new.foo                          #=> 101

class_variables(inherit=true) → array

mod의 클래스 변수 이름 배열을 돌려줘요. inherit가 false가 아니면 include된 모듈의 클래스 변수 이름도 포함돼요.

class One
  @@var1 = 1
end
class Two < One
  @@var2 = 2
end
One.class_variables        #=> [:@@var1]
Two.class_variables        #=> [:@@var2, :@@var1]
Two.class_variables(false) #=> [:@@var2]

const_defined?(sym, inherit=true) → true or false
const_defined?(str, inherit=true) → true or false

mod나 그 조상이 주어진 이름의 상수를 갖고 있는지 말해줘요.

Float.const_defined?(:EPSILON)    #=> true, found in Float itself
Float.const_defined?("String")    #=> true, found in Object (ancestor)
BasicObject.const_defined?(:Hash) #=> false

mod가 Module이면 추가로 Object와 그 조상도 검사해요. 각 검사 대상에서 상수가 없는데 autoload가 있으면 실제로 autoload하지 않고 바로 true를 돌려줘요. 상수를 못 찾으면 const_missing 콜백은 호출되지 않고 false를 돌려줘요. inherit가 false면 리시버 자신의 상수만 검사해요. 유효하지 않은 상수 이름이면 NameError(메시지 "wrong constant name name")가 나요.

const_get(sym, inherit=true) → obj
const_get(str, inherit=true) → obj

mod에서 주어진 이름의 상수를 찾아요. inherit가 설정돼 있으면 조상도(그리고 mod가 Module이면 Object도) 검색해요. 정의를 찾으면 그 상수 값을, 아니면 NameError를 돌려줘요. 네임스페이스가 붙은 클래스 이름이 주어지면 재귀적으로 상수 이름을 찾아요. 유효하지 않은 상수 이름이면 경고와 함께 NameError가 나요.

const_missing(sym) → obj

mod에서 정의되지 않은 상수를 참조할 때 호출돼요. 정의되지 않은 상수의 심볼이 전달되고, 그 상수에 사용할 값을 돌려줘요.

def Foo.const_missing(name)
  name # return the constant name as Symbol
end

Foo::UNDEFINED_CONST  #=> :UNDEFINED_CONST -- symbol returned

const_missing은 꼭 상수를 만들어야 하는 건 아니에요(그래도 종종 부작용으로 만들죠). 트리거되면 호출자는 그 반환값을 받아요. 상수가 이미 정의돼 있으면 이후 조회는 const_missing을 거치지 않고 상수에 저장된 값을 돌려줘요. 아니면 또 호출돼요. 자동 로드(autoload)를 구현하는 데도 쓸 수 있어요.

const_set(sym, obj) → obj
const_set(str, obj) → obj

이름 붙은 상수를 주어진 객체로 설정하고 그 객체를 돌려줘요. 이전에 없던 이름이라면 새 상수를 만들어요. 유효하지 않은 상수 이름이면 경고와 함께 NameError가 나요.

Math.const_set("HIGH_SCHOOL_PI", 22.0/7.0) #=> 3.14285714285714
Math::HIGH_SCHOOL_PI - Math::PI             #=> 0.00126448926734968

const_source_location(sym, inherit=true) → [String, Integer]
const_source_location(str, inherit=true) → [String, Integer]

지정된 상수의 정의가 들어 있는 Ruby 소스 파일명과 줄 번호를 돌려줘요. 못 찾으면 nil, C 코드에 정의돼 있어 위치를 추출할 수 없으면 빈 배열을 돌려줘요. inherit는 mod.ancestors에서 찾을지를 지정해요(기본 true).

constants(inherit=true) → array

mod에서 접근 가능한 상수 이름 배열을 돌려줘요. inherit가 false가 아니면 include된 모듈의 상수 이름도 포함돼요. 순서는 보장되지 않아요. Module#const_defined?도 참고하세요.

define_method(symbol, method) → symbol
define_method(symbol) { block } → symbol

리시버에 인스턴스 메서드를 정의해요. method 파라미터는 Proc, Method, UnboundMethod 객체일 수 있어요. 블록이 지정되면 그 블록이 메서드 본문으로 쓰여요. 블록이나 method 파라미터에 파라미터가 있으면 그게 메서드 파라미터가 돼요. 이 블록은 instance_eval로 평가돼요.

class A
  def fred
    puts "In Fred"
  end
  def create_method(name, &block)
    self.class.define_method(name, &block)
  end
  define_method(:wilma) { puts "Charge it!" }
  define_method(:flint) {|name| puts "I'm #{name}!"}
end
class B < A
  define_method(:barney, instance_method(:fred))
end
a = B.new
a.barney
a.wilma
a.flint('Dino')
a.create_method(:betty) { p self }
a.betty
# In Fred
# Charge it!
# I'm Dino!
# #<B:0x401b39e8>

deprecate_constant(symbol, ...) → mod

기존 상수 목록을 deprecated로 만들어요. 참조하면 경고가 나요.

module HTTP
  NotFound = Exception.new
  NOT_FOUND = NotFound # previous version of the library used this name
  deprecate_constant :NOT_FOUND
end

HTTP::NOT_FOUND
# warning: constant HTTP::NOT_FOUND is deprecated

freeze → mod

mod에 대한 추가 수정을 막아요. self를 돌려줘요.

include(module, ...) → self

각 파라미터에 대해 역순으로 Module.append_features를 호출해요.

include?(module) → true or false

module이 mod 또는 mod의 조상 중 하나에 include/prepend돼 있으면 true를 돌려줘요.

included_modules → array

mod 또는 mod의 조상에 include/prepend된 모듈 목록을 돌려줘요.

instance_method(symbol) → unbound_method

mod의 주어진 인스턴스 메서드를 나타내는 UnboundMethod를 돌려줘요.

instance_methods(include_super=true) → array

리시버의 public·protected 인스턴스 메서드 이름 배열을 돌려줘요. 모듈이면 public·protected 메서드, 클래스면 인스턴스(싱글턴이 아닌) 메서드예요. 선택 파라미터가 false면 조상의 메서드는 제외돼요. 현재 클래스에서의 메서드 가시성 변경과 별칭도 이 메서드에선 현재 클래스의 메서드로 간주돼요.

method_defined?(symbol, inherit=true) → true or false
method_defined?(string, inherit=true) → true or false

이름 붙은 메서드가 mod에 정의돼 있으면 true를 돌려줘요. inherit가 설정돼 있으면 mod의 조상도 검색해요. public·protected 메서드가 매치돼요. String 인자는 심볼로 변환돼요.

module_eval(string [, filename [, lineno]]) → obj
module_eval {|mod| block } → obj

mod의 문맥에서 문자열 또는 블록을 평가해요. class_eval로도 부를 수 있어요. (설명은 위 class_eval과 동일.)

module_exec(arg...) {|var...| block } → obj

주어진 블록을 클래스/모듈의 문맥에서 평가해요. class_exec로도 부를 수 있어요. (설명은 위 class_exec과 동일.)

name → string or nil

모듈 mod의 이름을 돌려줘요. 익명 모듈이면 nil.

prepend(module, ...) → self

각 파라미터에 대해 역순으로 Module.prepend_features를 호출해요.

private_class_method(symbol, ...) → mod
private_class_method(string, ...) → mod
private_class_method(array) → mod

기존 클래스 메서드를 private으로 만들어요. 기본 생성자 new를 숨길 때 자주 쓰여요. String 인자는 심볼로 변환되고, Symbol/String 배열도 받아요.

private_constant(symbol, ...) → mod

기존 상수 목록을 private으로 만들어요.

private_instance_methods(include_super=true) → array

mod에 정의된 private 인스턴스 메서드 목록을 돌려줘요. 선택 파라미터가 false면 조상의 메서드는 제외돼요.

private_method_defined?(symbol, inherit=true) → true or false
private_method_defined?(string, inherit=true) → true or false

이름 붙은 private 메서드가 mod에 정의돼 있으면 true를 돌려줘요. inherit가 설정돼 있으면 조상도 검색해요. String 인자는 심볼로 변환돼요.

protected_instance_methods(include_super=true) → array

mod에 정의된 protected 인스턴스 메서드 목록을 돌려줘요. false면 조상 메서드 제외.

protected_method_defined?(symbol, inherit=true) → true or false
protected_method_defined?(string, inherit=true) → true or false

이름 붙은 protected 메서드가 mod에 정의돼 있으면 true를 돌려줘요. inherit가 설정돼 있으면 조상도 검색해요.

public_class_method(symbol, ...) → mod
public_class_method(string, ...) → mod
public_class_method(array) → mod

기존 클래스 메서드 목록을 public으로 만들어요.

public_constant(symbol, ...) → mod

기존 상수 목록을 public으로 만들어요.

public_instance_method(symbol) → unbound_method

instance_method와 비슷하지만 public 메서드만 검색해요.

public_instance_methods(include_super=true) → array

mod에 정의된 public 인스턴스 메서드 목록을 돌려줘요. false면 조상 메서드 제외.

public_method_defined?(symbol, inherit=true) → true or false
public_method_defined?(string, inherit=true) → true or false

이름 붙은 public 메서드가 mod에 정의돼 있으면 true를 돌려줘요. inherit가 설정돼 있으면 조상도 검색해요.

refinements → array

리시버 안에 정의된 Refinement 배열을 돌려줘요.

remove_class_variable(sym) → obj

리시버에서 이름 붙은 클래스 변수를 제거하고 그 값을 돌려줘요.

remove_method(symbol) → self
remove_method(string) → self

현재 클래스에서 symbol로 식별되는 메서드를 제거해요. String 인자는 심볼로 변환돼요. undef_method와 달리 슈퍼클래스나 include된 모듈에 같은 이름의 메서드가 있으면 여전히 찾을 수 있어요.

set_temporary_name(string) → self
set_temporary_name(nil) → self

모듈의 임시 이름을 설정해요. 이 이름은 모듈의 인트로스펙션과 관련 값들(인스턴스, 상수, 메서드)에 반영돼요. 이름은 nil이거나 유효한 상수 경로가 아닌 비어있지 않은 문자열이어야 해요(영구 이름과 혼동 방지). 동적으로 생성된 클래스/모듈을 상수에 할당하지 않고 구분할 때 유용해요. 상수에 할당해 영구 이름을 주면 임시 이름은 버려져요. nil을 주면 모듈은 다시 익명이 돼요.

singleton_class? → true or false

mod가 싱글턴 클래스면 true, 일반 클래스/모듈이면 false.

class C
end
C.singleton_class?                  #=> false
C.singleton_class.singleton_class?  #=> true

to_s → string

이 모듈/클래스를 나타내는 문자열을 돌려줘요. 기본 클래스·모듈이면 이름이에요. 싱글턴이면 붙어 있는 대상의 정보도 보여줘요. inspect로도 부를 수 있어요.

undef_method(symbol) → self
undef_method(string) → self

현재 클래스가 이름 붙은 메서드 호출에 응답하지 않도록 해요. remove_method가 특정 클래스에서 메서드를 지우는 것과는 대조적이에요. undef_method는 슈퍼클래스나 include된 모듈까지 찾지 못하게 완전히 막아요. String 인자는 심볼로 변환돼요.

undefined_instance_methods → array

mod에 정의된 미정의(undefined) 인스턴스 메서드 목록을 돌려줘요. 조상의 미정의 메서드는 포함되지 않아요.

콜백 메서드 (Private Instance)

append_features(mod) → mod

이 모듈이 다른 모듈에 include될 때 Ruby가 이 모듈의 append_features를 호출하며 받는 모듈을 mod로 전달해요. 기본 구현은 이 모듈이 이미 mod나 그 조상에 추가되지 않았다면 상수·메서드·모듈 변수를 mod에 추가해요. Module#include도 참고하세요.

const_added(const_name)

리시버에 상수가 할당될 때마다 콜백으로 호출돼요. class 키워드로 클래스를 정의하면 const_added는 inherited보다 먼저 실행돼요.

extend_object(obj) → obj

이 모듈의 상수와 메서드를(싱글턴 메서드로) 추가해 지정된 객체를 확장해요. Object#extend가 사용하는 콜백 메서드예요.

extended(othermod)

included와 같은 역할이지만 확장(extend)된 모듈용이에요.

included(othermod)

리시버가 다른 모듈/클래스에 include될 때마다 호출되는 콜백이에요. 모듈이 include될 때 무언가 수행하려면 Module.append_features보다 이걸 쓰는 게 좋아요.

method_added(method_name)

리시버에 인스턴스 메서드가 추가될 때마다 콜백으로 호출돼요.

method_removed(method_name)

리시버에서 인스턴스 메서드가 제거될 때마다 콜백으로 호출돼요.

method_undefined(method_name)

리시버에서 인스턴스 메서드가 미정의(undef)될 때마다 콜백으로 호출돼요.

module_function → nil
module_function(method_name) → method_name
module_function(method_name, method_name, ...) → array

이름 붙은 메서드들에 대한 모듈 함수를 만들어요. 이 함수들은 모듈을 리시버로 해서 호출할 수 있고, 그 모듈을 믹스인한 클래스의 인스턴스 메서드로도 사용할 수 있어요. 모듈 함수는 원본의 복사본이라 독립적으로 바뀔 수 있어요. 인스턴스 메서드 버전은 private으로 만들어져요. 인자 없이 쓰면 이후 정의되는 메서드들이 모듈 함수가 돼요.

module Mod
  def one
    "This is one"
  end
  module_function :one
end
class Cls
  include Mod
  def call_one
    one
  end
end
Mod.one     #=> "This is one"
c = Cls.new
c.call_one  #=> "This is one"

prepend_features(mod) → mod

이 모듈이 다른 모듈에 prepend될 때 Ruby가 이 모듈의 prepend_features를 호출하며 받는 모듈을 mod로 전달해요. 기본 구현은 이 모듈이 이미 추가되지 않았다면 상수·메서드·모듈 변수를 mod에 겹쳐(overlay) 추가해요. Module#prepend도 참고하세요.

prepended(othermod)

included와 같은 역할이지만 prepend된 모듈용이에요.

private → nil
private(method_name) → method_name
private(method_name, method_name, ...) → array
private(array) → array

인자 없이 쓰면 이후 정의되는 메서드들의 기본 가시성을 private으로 설정해요. 인자와 함께 쓰면 이름 붙은 메서드를 private으로 설정해요.

protected → nil
protected(method_name) → method_name
protected(method_name, method_name, ...) → array
protected(array) → array

섹션 또는 메서드 이름 목록의 가시성을 protected로 설정해요. Ruby의 protected 메서드는 Java 같은 언어와 달라요. Java에서 protected는 서브클래스 접근을 위해 쓰지만, Ruby에선 서브클래스가 이미 부모의 모든 메서드(private 포함)에 접근할 수 있어요. protected로 표시하면 같은 클래스의 서로 다른 객체들이 그 메서드를 호출할 수 있어요. == 같은 비교 메서드에서, 다른 클래스의 객체에는 public으로 노출하지 않고 같은 클래스 객체 간 비교를 노출하고 싶을 때 유용해요. protected 메서드는 인라인 캐시를 못 써서 다른 메서드보다 느려요.

class Account
  # Mark balance as protected, so that we can compare between accounts
  # without making it public.
  attr_reader :balance
  protected :balance

  def initialize(balance)
    @balance = balance
  end

  def >(other)
    # The invocation to `other.balance` is allowed because `other` is a
    # different object of the same class (Account).
    balance > other.balance
  end
end

account1 = Account.new(100)
account2 = Account.new(50)

account1 > account2  # => true (works)
account1.balance     # => NoMethodError (fails because balance is not public)

public → nil
public(method_name) → method_name
public(method_name, method_name, ...) → array
public(array) → array

인자 없이 쓰면 이후 정의되는 메서드들의 기본 가시성을 public으로 설정해요. 인자와 함께 쓰면 이름 붙은 메서드를 public으로 설정해요.

refine(mod) { block } → module

리시버에서 mod를 refine해요. refine된 메서드가 정의되는 모듈을 돌려줘요.

remove_const(sym) → obj

주어진 상수의 정의를 제거하고 그 상수의 이전 값을 돌려줘요. 그 상수가 모듈을 가리켰다면 그 모듈의 이름은 바뀌지 않고 혼동을 일으킬 수 있어요.

ruby2_keywords(method_name, ...) → nil

이름 붙은 메서드들에 대해, 키워드를 일반 인자 스플랫(*args)을 통해 전달되도록 표시해요. 이 메서드는 인자 스플랫(*args)은 받지만 명시적 키워드나 키워드 스플랫은 받지 않는 메서드에만 호출해야 해요. Ruby 3.0 이전 버전과의 호환성용으로만, 키워드를 다른 메서드에 위임하는 메서드에만 사용해야 해요. 언젠가 제거될 수 있으니, 호출 전에 respond_to?(:ruby2_keywords, true)로 확인하는 게 좋아요.

using(module) → self

module의 클래스 refinement를 현재 클래스/모듈 정의로 가져와요.