класс Module

В первой форме возвращает массив имён всех констант, доступных в точке вызова. Этот список включает имена всех модулей и классов, определённых в глобальной области видимости.

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

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

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

Вторая форма вызывает метод экземпляра constants.

Возвращает список Modules, вложенных в точке вызова.

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

Создаёт новый анонимный модуль. Если передан блок, ему передаётся объект модуля, а блок выполняется в контексте этого модуля, как и при вызове 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"

Присвойте модуль константе (имя должно начинаться с заглавной буквы), если хотите использовать его как обычный модуль.

Возвращает массив всех модулей, используемых в текущей области видимости. Порядок модулей в результирующем массиве не определён.

module A
  refine Object do
  end
end

module B
  refine Object do
  end
end

using A
using B
p Module.used_modules

возвращает:

[B, A]

Возвращает массив всех модулей, используемых в текущей области видимости. Порядок модулей в результирующем массиве не определён.

module A
  refine Object do
  end
end

module B
  refine Object do
  end
end

using A
using B
p Module.used_refinements

возвращает:

[#<refinement:Object@B>, #<refinement:Object@A>]

Возвращает, является ли self подклассом other, или nil, если эти классы не связаны:

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

Возвращает true, если mod является подклассом other или совпадает с other. Возвращает nil, если эти классы не связаны. (Рассматривайте связь в терминах определения класса: «class A < B» подразумевает «A < B».)

Сравнивает self и other.

Возвращает:

• -1, если self включает other, если или self является подклассом other.

• 0, если self и other совпадают.

• 1, если other включает self или если other является подклассом self.

• 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

Равенство — на уровне Object метод == возвращает true только в том случае, если obj и other являются одним и тем же объектом. Обычно этот метод переопределяется в классах-потомках, чтобы задать значение, специфичное для класса.

В отличие от ==, метод equal? никогда не следует переопределять в подклассах, поскольку он используется для определения идентичности объектов (то есть a.equal?(b) тогда и только тогда, когда a является тем же объектом, что и b):

obj = "a"
other = obj.dup

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

Метод eql? возвращает true, если obj и other относятся к одному и тому же ключу хеша. Метод используется в Hash для проверки равенства элементов. Для любой пары объектов, для которой eql? возвращает true, значения hash обоих объектов должны быть равны. Поэтому любой подкласс, переопределяющий eql?, должен также соответствующим образом переопределить hash.

Для объектов класса Object метод eql? является синонимом ==. Подклассы обычно следуют этой традиции и создают псевдоним eql? для переопределенного ими метода ==, однако бывают исключения. Например, типы Numeric выполняют преобразование типов при сравнении с помощью ==, но не с помощью eql?, поэтому:

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

Проверка на равенство в выражениях case — возвращает true, если obj является экземпляром mod или одного из его потомков. Для модулей этот метод имеет ограниченное применение, но его можно использовать в операторах case для классификации объектов по классу.

Возвращает true, если mod является предком other. Возвращает false, если mod совпадает с other или является потомком other. Возвращает nil, если эти классы не связаны. (Рассматривайте связь в терминах определения класса: «class A < B» подразумевает «B > A».)

Возвращает true, если mod является предком other или эти модули совпадают. Возвращает nil, если эти модули не связаны. (Рассматривайте связь в терминах определения класса: «class A < B» подразумевает «B > A».)

Создает новую копию метода 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

Возвращает список модулей, включенных в mod или добавленных перед ним (включая сам mod).

module Mod
  include Math
  include Comparable
  prepend Enumerable
end

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

Первая форма эквивалентна attr_reader. Вторая форма эквивалентна attr_accessor(name), но считается устаревшей. Последняя форма эквивалентна attr_reader(name), но также считается устаревшей. Возвращает массив имен определенных методов в виде символов.

Определяет именованный атрибут для этого модуля, где имя — symbol.id2name, создавая переменную экземпляра (@name) и соответствующий метод доступа для ее чтения. Также создает метод с именем name= для установки значения атрибута. Аргументы типа String преобразуются в символы. Возвращает массив имен определенных методов в виде символов.

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

Создает переменные экземпляра и соответствующие методы, возвращающие значение каждой переменной экземпляра. Эквивалентно последовательному вызову «attr:name» для каждого имени. Аргументы типа String преобразуются в символы. Возвращает массив имен определенных методов в виде символов.

Создает метод доступа, позволяющий присваивать значение атрибуту symbol.id2name. Аргументы типа String преобразуются в символы. Возвращает массив имен определенных методов в виде символов.

Регистрирует filename для загрузки (с помощью Kernel::require) при первом обращении к const (который может быть String или символом) в пространстве имен mod.

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

Если const в mod определен как autoload, имя загружаемого файла заменяется на filename. Если const определен, но не как autoload, метод ничего не делает.

Файлы, которые в данный момент загружаются, нельзя регистрировать для автозагрузки.

Возвращает filename для загрузки, если name зарегистрировано как autoload в пространстве имен mod или одного из его предков.

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

Если inherit имеет значение false, поиск проверяет автозагрузки только у получателя:

class A
  autoload :CONST, "const.rb"
end

class B < A
end

B.autoload?(:CONST)          #=> "const.rb", found in A (ancestor)
B.autoload?(:CONST, false)   #=> nil, not found in B itself

Возвращает true, если данная переменная класса определена в obj. Аргументы типа String преобразуются в символы.

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

Возвращает значение указанной переменной класса (или вызывает исключение NameError). Для обычных переменных класса необходимо включить в имя переменной часть @@. Аргументы типа String преобразуются в символы.

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

Устанавливает для переменной класса с именем symbol заданный объект. Если имя переменной класса передано в виде строки, эта строка преобразуется в символ.

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

Возвращает массив имен переменных класса в mod. В него входят имена переменных класса из всех включенных модулей, если только параметр inherit не установлен в false.

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]

Проверяет, есть ли у 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 и его предки:

Math.const_defined?(:String)   #=> true, found in Object

В каждом из проверяемых классов или модулей, если константа отсутствует, но для нее задана автозагрузка, true возвращается напрямую, без автозагрузки:

module Admin
  autoload :User, 'admin/user'
end
Admin.const_defined?(:User)   #=> true

Если константа не найдена, обратный вызов const_missing не вызывается, а метод возвращает false.

Если inherit имеет значение false, поиск проверяет константы только у получателя:

IO.const_defined?(:SYNC)          #=> true, found in File::Constants (ancestor)
IO.const_defined?(:SYNC, false)   #=> false, not found in IO itself

В этом случае действует та же логика автозагрузки.

Если аргумент не является допустимым именем константы, возникает исключение NameError с сообщением «wrong constant name name»:

Hash.const_defined? 'foobar'   #=> NameError: wrong constant name foobar

Ищет в mod константу с указанным именем. Если задан inherit, поиск также выполняется среди предков (а также в Object, если mod является Module).

Если определение найдено, возвращается значение константы; в противном случае возникает исключение NameError.

Math.const_get(:PI)   #=> 3.14159265358979

Если указано имя класса с пространством имен, этот метод рекурсивно ищет имена констант. Например:

module Foo; class Bar; end end
Object.const_get 'Foo::Bar'

Флаг inherit учитывается при каждом поиске. Например:

module Foo
  class Bar
    VAL = 10
  end

  class Baz < Bar; end
end

Object.const_get 'Foo::Baz::VAL'         # => 10
Object.const_get 'Foo::Baz::VAL', false  # => NameError

Если аргумент не является допустимым именем константы, возникает исключение NameError с предупреждением «wrong constant name».

Object.const_get 'foobar' #=> NameError: wrong constant name foobar

Вызывается при обращении к неопределенной константе в mod. Методу передается символ, соответствующий неопределенной константе, и он возвращает значение, которое будет использоваться для этой константы. Например:

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

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

Как показывает приведенный выше пример, метод const_missing не обязан создавать отсутствующую константу в mod, хотя часто это является побочным эффектом. При вызове вызывающая сторона получает возвращаемое значение метода. Если константа также определена, последующие обращения не вызовут const_missing, а обычно вернут значение, хранящееся в константе. В противном случае const_missing будет вызван снова.

В следующем примере при обращении к неопределенной константе метод const_missing пытается загрузить файл, путь к которому соответствует имени константы в нижнем регистре (предполагается, что класс Fred находится в файле fred.rb). Если константа определена как побочный эффект загрузки файла, метод возвращает хранящееся в ней значение. Это реализует функцию автозагрузки, аналогичную Kernel#autoload и Module#autoload, хотя между ними есть важные различия.

def Object.const_missing(name)
  @looked_for ||= {}
  str_name = name.to_s
  raise "Constant not found: #{name}" if @looked_for[str_name]
  @looked_for[str_name] = 1
  file = str_name.downcase
  require file
  const_get(name, false)
end

Устанавливает для именованной константы заданный объект и возвращает этот объект. Создает новую константу, если константы с указанным именем ранее не существовало.

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

Если sym или str не является допустимым именем константы, возникает исключение NameError с предупреждением «wrong constant name».

Object.const_set('foobar', 42) #=> NameError: wrong constant name foobar

Возвращает имя файла с исходным кодом Ruby и номер строки, содержащие определение указанной константы. Если именованная константа не найдена, возвращается nil. Если константа найдена, но получить ее расположение в исходном коде невозможно (константа определена в коде на C), возвращается пустой массив.

Параметр inherit задает, следует ли выполнять поиск в mod.ancestors (по умолчанию — true).

# test.rb:
class A         # line 1
  C1 = 1
  C2 = 2
end

module M        # line 6
  C3 = 3
end

class B < A     # line 10
  include M
  C4 = 4
end

class A # continuation of A definition
  C2 = 8 # constant redefinition; warned yet allowed
end

p B.const_source_location('C4')           # => ["test.rb", 12]
p B.const_source_location('C3')           # => ["test.rb", 7]
p B.const_source_location('C1')           # => ["test.rb", 2]

p B.const_source_location('C3', false)    # => nil  -- don't lookup in ancestors

p A.const_source_location('C2')           # => ["test.rb", 16] -- actual (last) definition place

p Object.const_source_location('B')       # => ["test.rb", 10] -- top-level constant could be looked through Object
p Object.const_source_location('A')       # => ["test.rb", 1] -- class reopening is NOT considered new definition

p B.const_source_location('A')            # => ["test.rb", 1]  -- because Object is in ancestors
p M.const_source_location('A')            # => ["test.rb", 1]  -- Object is not ancestor, but additionally checked for modules

p Object.const_source_location('A::C1')   # => ["test.rb", 2]  -- nesting is supported
p Object.const_source_location('String')  # => []  -- constant is defined in C code

Возвращает массив имен констант, доступных в mod. В него входят имена констант из всех включенных модулей (пример приведен в начале раздела), если только параметр inherit не установлен в false.

Реализация не гарантирует порядок, в котором возвращаются константы.

IO.constants.include?(:SYNC)        #=> true
IO.constants(false).include?(:SYNC) #=> false

См. также Module#const_defined?.

Определяет метод экземпляра у получателя. Параметр 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>

Помечает список существующих констант как устаревшие. Попытка обратиться к ним приведет к появлению предупреждения.

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

Запрещает дальнейшие изменения mod.

Этот метод возвращает self.

Вызывает Module.append_features для каждого параметра в обратном порядке.

Возвращает true, если module включён или добавлен в начало списка поиска в mod либо в одном из предков mod.

module A
end
class B
  include A
end
class C < B
end
B.include?(A)   #=> true
C.include?(A)   #=> true
A.include?(A)   #=> false

Возвращает список модулей, включённых или добавленных в начало списка поиска в mod либо в одном из предков mod.

module Sub
end

module Mixin
  prepend Sub
end

module Outer
  include Mixin
end

Mixin.included_modules   #=> [Sub]
Outer.included_modules   #=> [Sub, Mixin]

Возвращает UnboundMethod, представляющий указанный метод экземпляра в mod.

class Interpreter
  def do_a() print "there, "; end
  def do_d() print "Hello ";  end
  def do_e() print "!\n";     end
  def do_v() print "Dave";    end
  Dispatcher = {
    "a" => instance_method(:do_a),
    "d" => instance_method(:do_d),
    "e" => instance_method(:do_e),
    "v" => instance_method(:do_v)
  }
  def interpret(string)
    string.each_char {|b| Dispatcher[b].bind(self).call }
  end
end

interpreter = Interpreter.new
interpreter.interpret('dave')

результат:

Hello there, Dave!

Возвращает массив, содержащий имена открытых и защищённых методов экземпляра получателя. Для модуля это открытые и защищённые методы; для класса — методы экземпляра (не singleton-методы). Если необязательный параметр равен false, методы предков не включаются.

module A
  def method1()  end
end
class B
  include A
  def method2()  end
end
class C < B
  def method3()  end
end

A.instance_methods(false)                   #=> [:method1]
B.instance_methods(false)                   #=> [:method2]
B.instance_methods(true).include?(:method1) #=> true
C.instance_methods(false)                   #=> [:method3]
C.instance_methods.include?(:method2)       #=> true

Обратите внимание, что изменения видимости методов в текущем классе, а также псевдонимы, этим методом считаются методами текущего класса:

class C < B
  alias method4 method2
  protected :method2
end
C.instance_methods(false).sort               #=> [:method2, :method3, :method4]

Возвращает true, если метод с указанным именем определён в mod. Если задан параметр inherit, поиск также выполняется среди предков mod. Проверяются открытые и защищённые методы. Аргументы типа String преобразуются в символы.

module A
  def method1()  end
  def protected_method1()  end
  protected :protected_method1
end
class B
  def method2()  end
  def private_method2()  end
  private :private_method2
end
class C < B
  include A
  def method3()  end
end

A.method_defined? :method1              #=> true
C.method_defined? "method1"             #=> true
C.method_defined? "method2"             #=> true
C.method_defined? "method2", true       #=> true
C.method_defined? "method2", false      #=> false
C.method_defined? "method3"             #=> true
C.method_defined? "protected_method1"   #=> true
C.method_defined? "method4"             #=> false
C.method_defined? "private_method2"     #=> false

Выполняет строку или блок в контексте 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

Выполняет переданный блок в контексте класса/модуля. Метод, определённый в блоке, будет принадлежать получателю. Все аргументы, переданные методу, будут переданы блоку. Это можно использовать, если блоку нужен доступ к переменным экземпляра.

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

результат:

Hello there!

Возвращает имя модуля mod. Для анонимных модулей возвращает nil.

Вызывает Module.prepend_features для каждого параметра в обратном порядке.

Делает существующие методы класса закрытыми. Часто используется, чтобы скрыть конструктор по умолчанию new.

Аргументы типа String преобразуются в символы. Также принимается Array символов и/или строк.

class SimpleSingleton  # Not thread safe
  private_class_method :new
  def SimpleSingleton.create(*args, &block)
    @me = new(*args, &block) if ! @me
    @me
  end
end

Делает список существующих констант закрытым.

Возвращает список закрытых методов экземпляра, определённых в mod. Если необязательный параметр равен false, методы предков не включаются.

module Mod
  def method1()  end
  private :method1
  def method2()  end
end
Mod.instance_methods           #=> [:method2]
Mod.private_instance_methods   #=> [:method1]

Возвращает true, если закрытый метод с указанным именем определён в mod. Если задан параметр inherit, поиск также выполняется среди предков mod. Аргументы типа String преобразуются в символы.

module A
  def method1()  end
end
class B
  private
  def method2()  end
end
class C < B
  include A
  def method3()  end
end

A.method_defined? :method1                   #=> true
C.private_method_defined? "method1"          #=> false
C.private_method_defined? "method2"          #=> true
C.private_method_defined? "method2", true    #=> true
C.private_method_defined? "method2", false   #=> false
C.method_defined? "method2"                  #=> false

Возвращает список защищённых методов экземпляра, определённых в mod. Если необязательный параметр равен false, методы предков не включаются.

Возвращает true, если защищённый метод с указанным именем определён в mod. Если задан параметр inherit, поиск также выполняется среди предков mod. Аргументы типа String преобразуются в символы.

module A
  def method1()  end
end
class B
  protected
  def method2()  end
end
class C < B
  include A
  def method3()  end
end

A.method_defined? :method1                    #=> true
C.protected_method_defined? "method1"         #=> false
C.protected_method_defined? "method2"         #=> true
C.protected_method_defined? "method2", true   #=> true
C.protected_method_defined? "method2", false  #=> false
C.method_defined? "method2"                   #=> true

Делает список существующих методов класса открытым.

Аргументы типа String преобразуются в символы. Также принимается Array символов и/или строк.

Делает список существующих констант открытым.

Подобно instance_method, выполняет поиск только среди открытых методов.

Возвращает список открытых методов экземпляра, определённых в mod. Если необязательный параметр равен false, методы предков не включаются.

Возвращает true, если открытый метод с указанным именем определён в mod. Если задан параметр inherit, поиск также выполняется среди предков mod. Аргументы типа String преобразуются в символы.

module A
  def method1()  end
end
class B
  protected
  def method2()  end
end
class C < B
  include A
  def method3()  end
end

A.method_defined? :method1                 #=> true
C.public_method_defined? "method1"         #=> true
C.public_method_defined? "method1", true   #=> true
C.public_method_defined? "method1", false  #=> true
C.public_method_defined? "method2"         #=> false
C.method_defined? "method2"                #=> true

Возвращает массив Refinement, определённых внутри получателя.

module A
  refine Integer do
  end

  refine String do
  end
end

p A.refinements

результат:

[#<refinement:Integer@A>, #<refinement:String@A>]

Удаляет именованную переменную класса из получателя и возвращает её значение.

class Example
  @@var = 99
  puts remove_class_variable(:@@var)
  p(defined? @@var)
end

результат:

99
nil

Удаляет метод, указанный в symbol, из текущего класса. Пример см. в описании Module#undef_method. Аргументы типа String преобразуются в символы.

Задаёт модулю временное имя. Это имя отображается при интроспекции модуля и связанных с ним значений, например экземпляров, констант и методов.

Имя должно быть nil или непустой строкой, которая не является допустимым путём константы (чтобы не путать постоянные и временные имена).

Этот метод может быть полезен для различения динамически созданных классов и модулей без присваивания их константам.

Если модулю присвоено постоянное имя посредством присваивания константе, временное имя отбрасывается. Нельзя назначить временное имя модулю, у которого уже есть постоянное имя.

Если указанное имя — nil, модуль снова становится анонимным.

Пример:

m = Module.new # => #<Module:0x0000000102c68f38>
m.name #=> nil

m.set_temporary_name("fake_name") # => fake_name
m.name #=> "fake_name"

m.set_temporary_name(nil) # => #<Module:0x0000000102c68f38>
m.name #=> nil

c = Class.new
c.set_temporary_name("MyClass(with description)") # => MyClass(with description)

c.new # => #<MyClass(with description):0x0....>

c::M = m
c::M.name #=> "MyClass(with description)::M"

# Assigning to a constant replaces the name with a permanent one
C = c

C.name #=> "C"
C::M.name #=> "C::M"
c.new # => #<C:0x0....>

Возвращает true, если mod является singleton-классом, или false, если это обычный класс или модуль.

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

Возвращает строку, представляющую этот модуль или класс. Для обычных классов и модулей это имя. Для singleton-объектов также отображается информация об объекте, к которому они относятся.

Запрещает текущему классу отвечать на вызовы метода с указанным именем. В отличие от этого метода, remove_method удаляет метод из конкретного класса; Ruby продолжит поиск возможного получателя в суперклассах и подключённых модулях. Аргументы типа String преобразуются в символы.

class Parent
  def hello
    puts "In parent"
  end
end
class Child < Parent
  def hello
    puts "In child"
  end
end

c = Child.new
c.hello

class Child
  remove_method :hello  # remove from child, still in parent
end
c.hello

class Child
  undef_method :hello   # prevent any calls to 'hello'
end
c.hello

результат:

In child
In parent
prog.rb:23: undefined method 'hello' for #<Child:0x401b3bb4> (NoMethodError)

Возвращает список неопределённых методов экземпляра, определённых в mod. Неопределённые методы предков не включаются.

Когда этот модуль включается в другой модуль, Ruby вызывает append_features в этом модуле, передавая ему принимающий модуль в mod. Реализация Ruby по умолчанию добавляет константы, методы и переменные модуля этого модуля в mod, если этот модуль ещё не был добавлен в mod или один из его предков. См. также Module#include.

Вызывается как обратный вызов каждый раз, когда получателю присваивается константа

module Chatty
  def self.const_added(const_name)
    super
    puts "Added #{const_name.inspect}"
  end
  FOO = 1
end

результат:

Added :FOO

Если определить класс с помощью ключевого слова class, const_added выполняется до inherited:

module M
  def self.const_added(const_name)
    super
    p :const_added
  end

  parent = Class.new do
    def self.inherited(subclass)
      super
      p :inherited
    end
  end

  class Child < parent
  end
end

результат:

:const_added
:inherited

Расширяет указанный объект, добавляя константы и методы этого модуля (они добавляются как одиночные методы). Это метод обратного вызова, используемый методом Object#extend.

module Picky
  def Picky.extend_object(o)
    if String === o
      puts "Can't add Picky to a String"
    else
      puts "Picky added to #{o.class}"
      super
    end
  end
end
(s = Array.new).extend Picky  # Call Object.extend
(s = "quick brown fox").extend Picky

результат:

Picky added to Array
Can't add Picky to a String

Аналог included, но для расширенных модулей.

module A
  def self.extended(mod)
    puts "#{self} extended in #{mod}"
  end
end
module Enumerable
  extend A
end
 # => prints "A extended in Enumerable"

Обратный вызов, вызываемый каждый раз, когда получатель включается в другой модуль или класс. Если ваш код должен выполнять действие при включении модуля в другой модуль, следует использовать этот метод вместо Module.append_features.

module A
  def A.included(mod)
    puts "#{self} included in #{mod}"
  end
end
module Enumerable
  include A
end
 # => prints "A included in Enumerable"

Вызывается как обратный вызов каждый раз, когда в получатель добавляется метод экземпляра.

module Chatty
  def self.method_added(method_name)
    puts "Adding #{method_name.inspect}"
  end
  def self.some_class_method() end
  def some_instance_method() end
end

результат:

Adding :some_instance_method

Вызывается как обратный вызов каждый раз, когда из получателя удаляется метод экземпляра.

module Chatty
  def self.method_removed(method_name)
    puts "Removing #{method_name.inspect}"
  end
  def self.some_class_method() end
  def some_instance_method() end
  class << self
    remove_method :some_class_method
  end
  remove_method :some_instance_method
end

результат:

Removing :some_instance_method

Вызывается как обратный вызов каждый раз, когда метод экземпляра становится неопределённым в получателе.

module Chatty
  def self.method_undefined(method_name)
    puts "Undefining #{method_name.inspect}"
  end
  def self.some_class_method() end
  def some_instance_method() end
  class << self
    undef_method :some_class_method
  end
  undef_method :some_instance_method
end

результат:

Undefining :some_instance_method

Создаёт функции модуля для указанных методов. Эти функции можно вызывать, указав модуль в качестве получателя; кроме того, они становятся доступны как методы экземпляра для классов, включающих этот модуль. Функции модуля являются копиями исходных методов, поэтому их можно изменять независимо. Версии методов экземпляра становятся приватными. Если аргументы не указаны, все последующие определяемые методы становятся функциями модуля. Аргументы String преобразуются в символы. Если передан один аргумент, он возвращается. Если аргументы не переданы, возвращается nil. Если передано несколько аргументов, они возвращаются в виде массива.

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"
module Mod
  def one
    "This is the new one"
  end
end
Mod.one     #=> "This is one"
c.call_one  #=> "This is the new one"

Когда этот модуль добавляется в начало другого, Ruby вызывает prepend_features в этом модуле, передавая ему принимающий модуль в mod. Реализация Ruby по умолчанию накладывает константы, методы и переменные модуля этого модуля на mod, если этот модуль ещё не был добавлен в mod или один из его предков. См. также Module#prepend.

Аналог included, но для модулей, добавленных в начало.

module A
  def self.prepended(mod)
    puts "#{self} prepended to #{mod}"
  end
end
module Enumerable
  prepend A
end
 # => prints "A prepended to Enumerable"

Без аргументов устанавливает приватную видимость по умолчанию для всех последующих определяемых методов. С аргументами задаёт приватную видимость для указанных методов. Аргументы String преобразуются в символы. Также принимается Array символов и/или строк. Если передан один аргумент, он возвращается. Если аргументы не переданы, возвращается nil. Если передано несколько аргументов, они возвращаются в виде массива.

module Mod
  def a()  end
  def b()  end
  private
  def c()  end
  private :a
end
Mod.private_instance_methods   #=> [:a, :c]

Обратите внимание: чтобы отобразить приватный метод в RDoc, используйте :doc:.

Задаёт защищённую видимость для раздела или списка имён методов. Не принимает аргументов, набор имён методов (символов или строк) либо массив имён методов. Возвращает полученные аргументы.

Важное отличие от protected в других языках

Защищённые методы в Ruby отличаются от методов в других языках, таких как Java, где методы помечаются как защищённые, чтобы предоставить доступ подклассам. В Ruby подклассы уже имеют доступ ко всем методам, определённым в родительском классе, даже к приватным.

Объявление метода защищённым позволяет разным объектам одного класса вызывать его.

Один из вариантов использования — методы сравнения, например ==, если нужно предоставить метод для сравнения объектов одного класса, не делая его общедоступным для объектов других классов.

Особенности производительности

Защищённые методы работают медленнее других, поскольку не могут использовать встроенный кэш.

Пример

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)

Чтобы отобразить приватный метод в RDoc, используйте :doc: вместо этого.

Без аргументов устанавливает общедоступную видимость по умолчанию для всех последующих определяемых методов. С аргументами задаёт общедоступную видимость для указанных методов. Аргументы String преобразуются в символы. Также принимается Array символов и/или строк. Если передан один аргумент, он возвращается. Если аргументы не переданы, возвращается nil. Если передано несколько аргументов, они возвращаются в виде массива.

Уточняет mod в получателе.

Возвращает модуль, в котором определены уточнённые методы.

Удаляет определение указанной константы и возвращает её предыдущее значение. Если эта константа ссылалась на модуль, имя модуля не изменится, что может привести к путанице.

Для указанных имён методов помечает метод как передающий ключевые аргументы через обычное распаковывание аргументов. Вызывать этот метод следует только для методов, принимающих распакованный набор аргументов (*args), но не явные ключевые аргументы и не распакованный набор ключевых аргументов. Метод помечается таким образом, что при вызове с ключевыми аргументами последний аргумент-хеш получает специальный флаг. Если он является последним элементом обычного распакованного набора аргументов при вызове другого метода, а этот вызов не содержит явных ключевых аргументов или распакованного набора ключевых аргументов, последний элемент интерпретируется как ключевые аргументы. Иными словами, ключевые аргументы передаются через этот метод другим методам.

Этот метод следует использовать только для методов, передающих ключевые аргументы другому методу, и только для обеспечения обратной совместимости с версиями Ruby до 3.0. Подробности о причинах существования ruby2_keywords, а также о том, когда и как его использовать, см. на странице www.ruby-lang.org/en/news/2019/12/12/separation-of-positional-and-keyword-arguments-in-ruby-3-0/.

Вероятно, в какой-то момент этот метод будет удалён, поскольку он существует только для обеспечения обратной совместимости. Так как в версиях Ruby до 2.7 он отсутствует, перед вызовом проверьте, отвечает ли модуль на этот метод:

module Mod
  def foo(meth, *args, &block)
    send(:"do_#{meth}", *args, &block)
  end
  ruby2_keywords(:foo) if respond_to?(:ruby2_keywords, true)
end

Однако учтите, что если метод ruby2_keywords будет удалён, поведение метода foo, использующего приведённый выше подход, изменится: метод перестанет передавать ключевые аргументы.

Импортирует уточнения классов из module в текущее определение класса или модуля.