класс Module

# File activesupport/lib/active_support/core_ext/module/aliasing.rb, line 67
  def alias_attribute(new_name, old_name)
    module_eval "      def #{new_name}; self.#{old_name}; end          # def subject; self.title; end
      def #{new_name}?; self.#{old_name}?; end        # def subject?; self.title?; end
      def #{new_name}=(v); self.#{old_name} = v; end  # def subject=(v); self.title = v; end
", __FILE__, __LINE__ + 1
  end

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

class Content < ActiveRecord::Base
  # has a title attribute
end

class Email < Content
  alias_attribute :subject, :title
end

e = Email.find(1)
e.title    # => "Superstars"
e.subject  # => "Superstars"
e.subject? # => true
e.subject = "Megastars"
e.title    # => "Megastars"

# File activesupport/lib/active_support/core_ext/module/aliasing.rb, line 26
def alias_method_chain(target, feature)
  ActiveSupport::Deprecation.warn("alias_method_chain is deprecated. Please, use Module#prepend instead. From module, you can access the original method using super.")

  # Strip out punctuation on predicates, bang or writer methods since
  # e.g. target?_without_feature is not a valid method name.
  aliased_target, punctuation = target.to_s.sub(/([?!=])$/, ''), $1
  yield(aliased_target, punctuation) if block_given?

  with_method = "#{aliased_target}_with_#{feature}#{punctuation}"
  without_method = "#{aliased_target}_without_#{feature}#{punctuation}"

  alias_method without_method, target
  alias_method target, with_method

  case
  when public_method_defined?(without_method)
    public target
  when protected_method_defined?(without_method)
    protected target
  when private_method_defined?(without_method)
    private target
  end
end

ПРИМЕЧАНИЕ: Этот метод устарел. Пожалуйста, используйте Module#prepend , который поставляется с Ruby 2.0 или новее.

Он обобщает распространённый шаблон:

alias_method :foo_without_feature, :foo
alias_method :foo, :foo_with_feature

С помощью него вы просто делаете:

alias_method_chain :foo, :feature

И оба псевдонима создаются для вас.

Методы запроса и с восклицательным знаком (foo?, foo!) сохраняют ту же пунктуацию:

alias_method_chain :foo?, :feature

эквивалентно

alias_method :foo_without_feature?, :foo?
alias_method :foo?, :foo_with_feature?

поэтому вы можете безопасно использовать цепочки foo, foo?, foo! и/или foo= с той же функцией.

# File activesupport/lib/active_support/core_ext/module/anonymous.rb, line 25
def anonymous?
  name.nil?
end

Модуль может иметь или не иметь имя.

module M; end
M.name # => "M"

m = Module.new
m.name # => nil

anonymous? метод возвращает true, если модуль не имеет имени, и false в противном случае:

Module.new.anonymous? # => true

module M; end
M.anonymous?          # => false

Модуль получает имя, когда он впервые присваивается константе. Либо с помощью ключевого слова module или class, либо путём явного присваивания:

m = Module.new # creates an anonymous module
m.anonymous?   # => true
M = m          # m gets a name here as a side-effect
m.name         # => "M"
m.anonymous?   # => false

# File activesupport/lib/active_support/core_ext/module/attr_internal.rb, line 14
def attr_internal_accessor(*attrs)
  attr_internal_reader(*attrs)
  attr_internal_writer(*attrs)
end

Объявляет чтение и запись атрибута, основанные на внутреннем имени переменной экземпляра.

# File activesupport/lib/active_support/core_ext/module/attr_internal.rb, line 3
def attr_internal_reader(*attrs)
  attrs.each {|attr_name| attr_internal_define(attr_name, :reader)}
end

Объявляет чтение атрибута, основанное на внутреннем имени переменной экземпляра.

# File activesupport/lib/active_support/core_ext/module/attr_internal.rb, line 8
def attr_internal_writer(*attrs)
  attrs.each {|attr_name| attr_internal_define(attr_name, :writer)}
end

Объявляет запись атрибута, основанную на внутреннем имени переменной экземпляра.

# File activesupport/lib/active_support/core_ext/module/delegation.rb, line 153
def delegate(*methods, to: nil, prefix: nil, allow_nil: nil)
  unless to
    raise ArgumentError, 'Delegation needs a target. Supply an options hash with a :to key as the last argument (e.g. delegate :hello, to: :greeter).'
  end

  if prefix == true && to =~ /^[^a-z_]/
    raise ArgumentError, 'Can only automatically set the delegation prefix when delegating to a method.'
  end

  method_prefix =        if prefix
      "#{prefix == true ? to : prefix}_"
    else
      ''
    end

  location = caller_locations(1, 1).first
  file, line = location.path, location.lineno

  to = to.to_s
  to = "self.#{to}" if DELEGATION_RESERVED_METHOD_NAMES.include?(to)

  methods.each do |method|
    # Attribute writer methods only accept one argument. Makes sure []=
    # methods still accept two arguments.
    definition = (method =~ /[^\]]=$/) ? 'arg' : '*args, &block'

    # The following generated method calls the target exactly once, storing
    # the returned value in a dummy variable.
    #
    # Reason is twofold: On one hand doing less calls is in general better.
    # On the other hand it could be that the target has side-effects,
    # whereas conceptually, from the user point of view, the delegator should
    # be doing one call.
    if allow_nil
      method_def = [
        "def #{method_prefix}#{method}(#{definition})",
        "_ = #{to}",
        "if !_.nil? || nil.respond_to?(:#{method})",
        "  _.#{method}(#{definition})",
        "end",
      "end"
      ].join ';'
    else
      exception = %Q(raise DelegationError, "#{self}##{method_prefix}#{method} delegated to #{to}.#{method}, but #{to} is nil: \#{self.inspect}")

      method_def = [
        "def #{method_prefix}#{method}(#{definition})",
        " _ = #{to}",
        "  _.#{method}(#{definition})",
        "rescue NoMethodError => e",
        "  if _.nil? && e.name == :#{method}",
        "    #{exception}",
        "  else",
        "    raise",
        "  end",
        "end"
      ].join ';'
    end

    module_eval(method_def, file, line)
  end
end

Предоставляет delegate класс-метод для лёгкого экспонирования публичных методов содержащихся объектов как своих собственных.

Параметры

• :to - Указывает целевой объект

• :prefix - Добавляет префикс к новому методу с именем целевого объекта или настраиваемым префиксом

• :allow_nil - Если установлено в true, предотвращает выброс NoMethodError

Макрокоманда принимает одно или несколько имён методов (указанных как символы или строки) и имя целевого объекта через опцию :to (также символ или строка).

Делегирование особенно полезно с ассоциациями Active Record:

class Greeter < ActiveRecord::Base
  def hello
    'hello'
  end

  def goodbye
    'goodbye'
  end
end

class Foo < ActiveRecord::Base
  belongs_to :greeter
  delegate :hello, to: :greeter
end

Foo.new.hello   # => "hello"
Foo.new.goodbye # => NoMethodError: undefined method `goodbye' for #<Foo:0x1af30c>

Разрешено несколько делегирований одному и тому же целевому объекту:

class Foo < ActiveRecord::Base
  belongs_to :greeter
  delegate :hello, :goodbye, to: :greeter
end

Foo.new.goodbye # => "goodbye"

Методы могут быть делегированы переменным экземпляра, класса или константам, предоставив их как символы:

class Foo
  CONSTANT_ARRAY = [0,1,2,3]
  @@class_array  = [4,5,6,7]

  def initialize
    @instance_array = [8,9,10,11]
  end
  delegate :sum, to: :CONSTANT_ARRAY
  delegate :min, to: :@@class_array
  delegate :max, to: :@instance_array
end

Foo.new.sum # => 6
Foo.new.min # => 4
Foo.new.max # => 11

Также можно делегировать метод классу, используя :class:

class Foo
  def self.hello
    "world"
  end

  delegate :hello, to: :class
end

Foo.new.hello # => "world"

Делегирования могут быть опционально снабжены префиксом с помощью опции :prefix . Если значение равно true, методы делегирования снабжаются префиксом с именем делегируемого объекта.

Person = Struct.new(:name, :address)

class Invoice < Struct.new(:client)
  delegate :name, :address, to: :client, prefix: true
end

john_doe = Person.new('John Doe', 'Vimmersvej 13')
invoice = Invoice.new(john_doe)
invoice.client_name    # => "John Doe"
invoice.client_address # => "Vimmersvej 13"

Также можно указать настраиваемый префикс.

class Invoice < Struct.new(:client)
  delegate :name, :address, to: :client, prefix: :customer
end

invoice = Invoice.new(john_doe)
invoice.customer_name    # => 'John Doe'
invoice.customer_address # => 'Vimmersvej 13'

Если целевой объект nil и не отвечает на делегированный метод, вызывается NoMethodError, как и в случае с любым другим значением. Иногда, однако, имеет смысл быть устойчивым к этой ситуации, и в этом цель опции :allow_nil: Если целевой объект не nil, или он есть и отвечает на метод, всё работает как обычно. Но если он nil и не отвечает на делегированный метод, возвращается nil.

class User < ActiveRecord::Base
  has_one :profile
  delegate :age, to: :profile
end

User.new.age # raises NoMethodError: undefined method `age'

Но если отсутствие профиля ещё приемлемо и не должно быть ошибкой:

class User < ActiveRecord::Base
  has_one :profile
  delegate :age, to: :profile, allow_nil: true
end

User.new.age # nil

Обратите внимание, что если целевой объект не nil, вызов осуществляется независимо от опции :allow_nil, и поэтому исключение всё ещё вызывается, если указанный объект не отвечает на метод:

class Foo
  def initialize(bar)
    @bar = bar
  end

  delegate :name, to: :@bar, allow_nil: true
end

Foo.new("Bar").name # raises NoMethodError: undefined method `name'

Целевой метод должен быть публичным, в противном случае будет вызвано NoMethodError.

# File activesupport/lib/active_support/core_ext/module/deprecation.rb, line 20
def deprecate(*method_names)
  ActiveSupport::Deprecation.deprecate_methods(self, *method_names)
end

deprecate :foo
deprecate bar: 'message'
deprecate :foo, :bar, baz: 'warning!', qux: 'gone!'

Вы также можете использовать экземпляр настраиваемого утилита для отслеживания устаревших методов:

deprecate :foo, deprecator: MyLib::Deprecator.new
deprecate :foo, bar: "warning!", deprecator: MyLib::Deprecator.new

Настраиваемые утилиты должны отвечать на метод deprecation_warning(deprecated_method_name, message, caller_backtrace) , где вы можете реализовать своё поведение предупреждения.

class MyLib::Deprecator
  def deprecation_warning(deprecated_method_name, message, caller_backtrace = nil)
    message = "#{deprecated_method_name} is deprecated and will be removed from MyLibrary | #{message}"
    Kernel.warn message
  end
end

# File activesupport/lib/active_support/core_ext/module/attribute_accessors.rb, line 207
def mattr_accessor(*syms, &blk)
  mattr_reader(*syms, &blk)
  mattr_writer(*syms)
end

Определяет чтение и запись как для класса, так и для экземпляров атрибутов класса.

module HairColors
  mattr_accessor :hair_colors
end

class Person
  include HairColors
end

HairColors.hair_colors = [:brown, :black, :blonde, :red]
HairColors.hair_colors # => [:brown, :black, :blonde, :red]
Person.new.hair_colors # => [:brown, :black, :blonde, :red]

Если подкласс изменяет значение, это также изменяет значение родительского класса. Аналогично, если родительский класс изменяет значение, это также изменяет значение подклассов.

class Male < Person
end

Male.new.hair_colors << :blue
Person.new.hair_colors # => [:brown, :black, :blonde, :red, :blue]

Чтобы отключить метод записи экземпляра, передайте instance_writer: false. Чтобы отключить метод чтения экземпляра, передайте instance_reader: false.

module HairColors
  mattr_accessor :hair_colors, instance_writer: false, instance_reader: false
end

class Person
  include HairColors
end

Person.new.hair_colors = [:brown]  # => NoMethodError
Person.new.hair_colors             # => NoMethodError

Или передайте instance_accessor: false, чтобы отключить оба метода экземпляра.

module HairColors
  mattr_accessor :hair_colors, instance_accessor: false
end

class Person
  include HairColors
end

Person.new.hair_colors = [:brown]  # => NoMethodError
Person.new.hair_colors             # => NoMethodError

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

module HairColors
  mattr_accessor :hair_colors do
    [:brown, :black, :blonde, :red]
  end
end

class Person
  include HairColors
end

Person.class_variable_get("@@hair_colors") # => [:brown, :black, :blonde, :red]

# File activesupport/lib/active_support/core_ext/module/attribute_accessors.rb, line 53
  def mattr_reader(*syms)
    options = syms.extract_options!
    syms.each do |sym|
      raise NameError.new("invalid attribute name: #{sym}") unless sym =~ /\A[_A-Za-z]\w*\z/
      class_eval("        @@#{sym} = nil unless defined? @@#{sym}

        def self.#{sym}
          @@#{sym}
        end
", __FILE__, __LINE__ + 1)

      unless options[:instance_reader] == false || options[:instance_accessor] == false
        class_eval("          def #{sym}
            @@#{sym}
          end
", __FILE__, __LINE__ + 1)
      end
      class_variable_set("@@#{sym}", yield) if block_given?
    end
  end

Определяет атрибут класса и создаёт методы чтения для класса и экземпляров. Базовая переменная класса устанавливается в nil, если она не определена ранее.

module HairColors
  mattr_reader :hair_colors
end

HairColors.hair_colors # => nil
HairColors.class_variable_set("@@hair_colors", [:brown, :black])
HairColors.hair_colors # => [:brown, :black]

Имя атрибута должно быть допустимым именем метода в Ruby.

module Foo
  mattr_reader :"1_Badname"
end
# => NameError: invalid attribute name: 1_Badname

Если вы хотите отключить создание метода чтения экземпляра, передайте instance_reader: false или instance_accessor: false.

module HairColors
  mattr_reader :hair_colors, instance_reader: false
end

class Person
  include HairColors
end

Person.new.hair_colors # => NoMethodError

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

module HairColors
  mattr_reader :hair_colors do
    [:brown, :black, :blonde, :red]
  end
end

class Person
  include HairColors
end

Person.new.hair_colors # => [:brown, :black, :blonde, :red]

# File activesupport/lib/active_support/core_ext/module/attribute_accessors.rb, line 119
  def mattr_writer(*syms)
    options = syms.extract_options!
    syms.each do |sym|
      raise NameError.new("invalid attribute name: #{sym}") unless sym =~ /\A[_A-Za-z]\w*\z/
      class_eval("        @@#{sym} = nil unless defined? @@#{sym}

        def self.#{sym}=(obj)
          @@#{sym} = obj
        end
", __FILE__, __LINE__ + 1)

      unless options[:instance_writer] == false || options[:instance_accessor] == false
        class_eval("          def #{sym}=(obj)
            @@#{sym} = obj
          end
", __FILE__, __LINE__ + 1)
      end
      send("#{sym}=", yield) if block_given?
    end
  end

Определяет атрибут класса и создаёт методы записи для класса и экземпляров для присвоения атрибута.

module HairColors
  mattr_writer :hair_colors
end

class Person
  include HairColors
end

HairColors.hair_colors = [:brown, :black]
Person.class_variable_get("@@hair_colors") # => [:brown, :black]
Person.new.hair_colors = [:blonde, :red]
HairColors.class_variable_get("@@hair_colors") # => [:blonde, :red]

Если вы хотите отключить метод записи экземпляра, передайте instance_writer: false или instance_accessor: false.

module HairColors
  mattr_writer :hair_colors, instance_writer: false
end

class Person
  include HairColors
end

Person.new.hair_colors = [:blonde, :red] # => NoMethodError

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

module HairColors
  mattr_writer :hair_colors do
    [:brown, :black, :blonde, :red]
  end
end

class Person
  include HairColors
end

Person.class_variable_get("@@hair_colors") # => [:brown, :black, :blonde, :red]

# File activesupport/lib/active_support/core_ext/module/introspection.rb, line 32
def parent
  parent_name ? ActiveSupport::Inflector.constantize(parent_name) : Object
end

Возвращает модуль, содержащий данный модуль по его имени.

module M
  module N
  end
end
X = M::N

M::N.parent # => M
X.parent    # => M

Родительским модулем для модулей верхнего уровня и анонимных модулей является Объект.

M.parent          # => Object
Module.new.parent # => Object

# File activesupport/lib/active_support/core_ext/module/introspection.rb, line 7
def parent_name
  if defined?(@parent_name)
    @parent_name
  else
    parent_name = name =~ /::[^:]+\Z/ ? $`.freeze : nil
    @parent_name = parent_name unless frozen?
    parent_name
  end
end

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

M::N.parent_name # => "M"

# File activesupport/lib/active_support/core_ext/module/introspection.rb, line 48
def parents
  parents = []
  if parent_name
    parts = parent_name.split('::')
    until parts.empty?
      parents << ActiveSupport::Inflector.constantize(parts * '::')
      parts.pop
    end
  end
  parents << Object unless parents.include? Object
  parents
end

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

module M
  module N
  end
end
X = M::N

M.parents    # => [Object]
M::N.parents # => [M, Object]
X.parents    # => [M, Object]

# File activesupport/lib/active_support/core_ext/module/remove_method.rb, line 18
def redefine_method(method, &block)
  visibility = method_visibility(method)
  remove_possible_method(method)
  define_method(method, &block)
  send(visibility, method)
end

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

# File activesupport/lib/active_support/core_ext/module/remove_method.rb, line 3
def remove_possible_method(method)
  if method_defined?(method) || private_method_defined?(method)
    undef_method(method)
  end
end

Удаляет именованный метод, если он существует.

# File activesupport/lib/active_support/core_ext/module/remove_method.rb, line 10
def remove_possible_singleton_method(method)
  singleton_class.instance_eval do
    remove_possible_method(method)
  end
end

Удаляет именованный метод-синглтон, если он существует.

# File activesupport/lib/active_support/core_ext/module/attribute_accessors_per_thread.rb, line 136
def thread_mattr_accessor(*syms, &blk)
  thread_mattr_reader(*syms, &blk)
  thread_mattr_writer(*syms, &blk)
end

Определяет аксессоры для атрибутов класса как для класса, так и для экземпляров.

class Account
  thread_mattr_accessor :user
end

Account.user = "DHH"
Account.user     # => "DHH"
Account.new.user # => "DHH"

Если подкласс изменяет значение, значение родительского класса не изменяется. Аналогично, если родительский класс изменяет значение, значение подклассов не изменяется.

class Customer < Account
end

Customer.user = "Rafael"
Customer.user # => "Rafael"
Account.user  # => "DHH"

Чтобы исключить метод записи экземпляра, передайте instance_writer: false. Чтобы исключить метод чтения экземпляра, передайте instance_reader: false.

class Current
  thread_mattr_accessor :user, instance_writer: false, instance_reader: false
end

Current.new.user = "DHH"  # => NoMethodError
Current.new.user          # => NoMethodError

Или передайте instance_accessor: false, чтобы исключить оба метода экземпляра.

class Current
  mattr_accessor :user, instance_accessor: false
end

Current.new.user = "DHH"  # => NoMethodError
Current.new.user          # => NoMethodError