Dynamic Dispatch and Method Definition

# frozen_string_literal: true

require "shelf"

# A reservation desk with one public, one protected and one private method.
class Desk
  def open? = true

  def priority(other) = other.score <=> score

  protected

  def score = 10

  private

  def key_box = "keys"

  def respond(name) = "responding to #{name}"
end

desk = Desk.new
name = :open?

desk.send(:open?) # => true
desk.public_send(name) # => true
desk.send(:key_box) # => "keys"
desk.__send__(:key_box) # => "keys"
desk.send(:respond, :bell) # => "responding to bell"

def message_of
  yield
rescue StandardError => e
  e.message
end

# public_send honours visibility; send does not.
%i[key_box score nope].each { |hidden| puts(message_of { desk.public_send(hidden) }) }
message_of { desk.key_box } # => "private method 'key_box' called for an instance of Desk"
desk.priority(Desk.new) # => 0

# Operators and setters are methods too, so they can be sent.
operator = :+
1.send(operator, 2) # => 3
Shelf::Config.new.send(:loan_days=, 21) # => 21

# A class that defines its own `send` hides Object#send, but __send__ stays reachable.
class Postman
  def send(*) = "letter sent"
end

Postman.new.send(:anything) # => "letter sent"
Postman.new.__send__(:class) # => Postman

# Bare send with no arguments is an ArgumentError.
message_of { desk.send } # => "no method name given"

private method 'key_box' called for an instance of Desk
protected method 'score' called for an instance of Desk
undefined method 'nope' for an instance of Desk

# frozen_string_literal: true

require "shelf"

module Shelf
  # Runs a command typed by a user, but only if it is on the allow-list.
  class Commands
    ALLOWED = %i[count first to_a].freeze

    def initialize(catalog)
      @catalog = catalog
    end

    def run(name)
      command = name.to_sym
      raise ArgumentError, "unknown command: #{name}" unless ALLOWED.include?(command)

      @catalog.public_send(command)
    end
  end
end

isbn = Shelf::Isbn.new(digits: "978-0-306-40615-7")
book = Shelf::Book.new(isbn:, title: "Dune", author: Shelf::Author.new(name: "Frank Herbert"))
catalog = Shelf::Catalog.new(store: Shelf::Store::Memory.new).add(book)
commands = Shelf::Commands.new(catalog)

commands.run("count") # => 1
commands.run(:first).title # => "Dune"

def message_of
  yield
rescue StandardError => e
  "#{e.class}: #{e.message}"
end

message_of { commands.run("freeze") } # => "ArgumentError: unknown command: freeze"
message_of { commands.run("instance_variable_get") } # => "ArgumentError: unknown command: instance_variable_get"

# Without the allow-list, public_send still reaches every public method, not just the ones you had in mind.
untrusted = "freeze"
catalog.public_send(untrusted).frozen? # => true
message_of { catalog.instance_variable_set(:@store, nil) }[/\AFrozenError/] # => "FrozenError"
catalog.add(book).count # => 2

# frozen_string_literal: true

require "shelf"

isbn = Shelf::Isbn.new(digits: "978-0-306-40615-7")
book = Shelf::Book.new(isbn:, title: "Dune", author: Shelf::Author.new(name: "Frank Herbert"))
catalog = Shelf::Catalog.new(store: Shelf::Store::Memory.new).add(book)

# respond_to? asks "would this call be accepted from outside?"
catalog.respond_to?(:add) # => true
catalog.respond_to?(:map) # => true
catalog.respond_to?(:remove) # => false
catalog.respond_to?(:puts) # => false
catalog.respond_to?(:puts, true) # => true

# Strings work as well as Symbols; anything else is a TypeError.
catalog.respond_to?("add") # => true

# Method objects capture a method together with its receiver.
adder = catalog.method(:add)
adder.owner # => Shelf::Catalog
adder.receiver.equal?(catalog) # => true
adder.arity # => 1
adder.parameters # => [[:req, :book]]
adder.name # => :add
adder.source_location&.last # => 13
adder.call(book).equal?(catalog) # => true

# Method#to_proc lets a method stand in for a block.
%w[978-0-306-40615-7 9780306406157].map(&Shelf::Isbn.method(:new))
# => [#<data Shelf::Isbn digits="9780306406157">, #<data Shelf::Isbn digits="9780306406157">]

# Unbound methods are detached from a receiver and can be rebound to compatible ones.
size = Array.instance_method(:size)
size.bind_call([1, 2, 3]) # => 3
size.owner # => Array

# public_method refuses non-public methods; method does not.
catalog.public_method(:add).call(book).class # => Shelf::Catalog
catalog.method(:puts).owner # => Kernel

# A dispatch table maps names to callables instead of calling send on user input.
shelf = Shelf::Catalog.new(store: Shelf::Store::Memory.new).add(book)
handlers = { count: shelf.method(:count), first: shelf.method(:first) }
handlers.fetch(:count).call # => 1
handlers.fetch(:first).call.title # => "Dune"

# frozen_string_literal: true

require "shelf"

module Shelf
  # A loan with one generated predicate per state and a few other generated methods.
  class TrackedLoan < Loan
    # One predicate per state: available?, lent?, overdue? and returned?.
    STATES.each do |name|
      define_method(:"#{name}?") { state == name }
    end

    # The block closes over a local variable that a plain def could never see.
    renewals = 0
    define_method(:renew) do |days = 7, reason: "none", &log|
      renewals += 1
      log&.call("renewed #{days} days (#{reason}), total #{renewals}")
      days
    end

    # Generated methods can be made private like any other.
    define_method(:audit_trail) { "#{book.title}: #{state}" }
    private :audit_trail

    # A Method or UnboundMethod can be reused under a second name.
    define_method(:status, instance_method(:describe))

    # A generated method can call super, but only with explicit arguments.
    define_method(:describe) { "[tracked] #{super()}" }
  end
end

isbn = Shelf::Isbn.new(digits: "978-0-306-40615-7")
book = Shelf::Book.new(isbn:, title: "Dune", author: Shelf::Author.new(name: "Frank Herbert"))
loan = Shelf::TrackedLoan.new(book, state: :lent)

loan.lent? # => true
loan.available? # => false
Shelf::TrackedLoan.public_instance_methods(false).sort
# => [:available?, :describe, :lent?, :overdue?, :renew, :returned?, :status]

# Parameters behave like those of a lambda: arity is checked, defaults and keywords work.
loan.renew # => 7
loan.renew(14, reason: "holiday") { |entry| puts entry } # => 14
Shelf::TrackedLoan.instance_method(:renew).parameters
# => [[:opt, :days], [:key, :reason], [:block, :log]]
Shelf::TrackedLoan.instance_method(:renew).arity # => -1

# Visibility: audit_trail is private, so only an implicit receiver reaches it.
Shelf::TrackedLoan.private_instance_methods(false) # => [:audit_trail]
loan.send(:audit_trail) # => "Dune: lent"

# status is the original describe; describe was redefined to wrap it.
loan.status # => "Dune is lent"
loan.describe # => "[tracked] Dune is lent"

# define_method returns the name as a Symbol, and accepts a String name too.
Shelf::TrackedLoan.define_method("extra") { :extra } # => :extra
loan.extra # => :extra

def message_of
  yield
rescue StandardError => e
  "#{e.class}: #{e.message}"
end

message_of { loan.audit_trail } # => "NoMethodError: private method 'audit_trail' called for an instance of Shelf::TrackedLoan"
message_of { loan.lent?(1) } # => "ArgumentError: wrong number of arguments (given 1, expected 0)"

# Bare super is not allowed inside define_method.
class LazyLoan < Shelf::Loan
  define_method(:describe) { super }
end

lazy = LazyLoan.new(book)
message_of { lazy.describe }[/implicit argument passing of super/] # => "implicit argument passing of super"

renewed 14 days (holiday), total 2

# frozen_string_literal: true

require "shelf"

isbn = Shelf::Isbn.new(digits: "978-0-306-40615-7")
book = Shelf::Book.new(isbn:, title: "Dune", author: Shelf::Author.new(name: "Frank Herbert"))
loan = Shelf::Loan.new(book, state: :lent)
other = Shelf::Loan.new(book)

# define_singleton_method adds a method to one object only (its singleton class).
loan.define_singleton_method(:late_fee) { |days_late, rate: 10| days_late * rate } # => :late_fee
loan.late_fee(3) # => 30
loan.late_fee(3, rate: 25) # => 75
loan.singleton_methods # => [:late_fee]
other.respond_to?(:late_fee) # => false
loan.singleton_method(:late_fee).arity # => -2

# It is equivalent to define_method on the singleton class.
other.singleton_class.define_method(:note) { "see #{book.title}" } # => :note
other.note # => "see Dune"
other.singleton_methods # => [:note]

# extend adds a whole module to one object, which is how small DSLs are bolted onto plain objects.
module Reminders
  def remind = "#{book.title} is #{state}"
end

other.extend(Reminders).equal?(other) # => true
other.remind # => "Dune is available"
other.singleton_class.include?(Reminders) # => true
other.is_a?(Reminders) # => true
loan.is_a?(Reminders) # => false
Shelf::Loan.include?(Reminders) # => false

# frozen_string_literal: true

require "shelf"

isbn = Shelf::Isbn.new(digits: "978-0-306-40615-7")
book = Shelf::Book.new(isbn:, title: "Dune", author: Shelf::Author.new(name: "Frank Herbert"))
loan = Shelf::Loan.new(book, state: :lent)

# Reading and writing instance variables by name breaks encapsulation on purpose.
loan.instance_variables # => [:@book, :@state]
loan.instance_variable_get(:@state) # => :lent
loan.instance_variable_set(:@state, :overdue) # => :overdue
loan.state # => :overdue
loan.instance_variable_defined?(:@state) # => true
loan.instance_variable_defined?(:@fine) # => false
loan.instance_variable_get(:@fine) # => nil

# The generic serialiser this makes possible: a hash of every instance variable.
loan.instance_variables.to_h { |name| [name.to_s.delete_prefix("@").to_sym, loan.instance_variable_get(name)] }
# => {book: #<data Shelf::Book isbn=#<data Shelf::Isbn digits="9780306406157">, title="Dune", author=#<data Shelf::Author name="Frank Herbert">>, state: :overdue}

# remove_instance_variable removes it and returns the old value.
loan.instance_variable_set(:@fine, 5) # => 5
loan.remove_instance_variable(:@fine) # => 5
loan.instance_variables # => [:@book, :@state]

def message_of
  yield
rescue StandardError => e
  "#{e.class}: #{e.message}"
end

# The name must look like an instance variable.
message_of { loan.instance_variable_get("state") } # => "NameError: 'state' is not allowed as an instance variable name"
message_of { loan.instance_variable_get(:"@a b") } # => "NameError: '@a b' is not allowed as an instance variable name"
message_of { loan.remove_instance_variable(:@nothing) } # => "NameError: instance variable @nothing not defined"

# Frozen objects refuse the write, and Data instances are frozen from birth.
message_of { book.instance_variable_set(:@title, "Emma") }[/\AFrozenError: can't modify frozen Shelf::Book/]
# => "FrozenError: can't modify frozen Shelf::Book"

# frozen_string_literal: true

require "shelf"

# Aliases and generated methods know both names.
module Shelf
  # The same method under two names, with the old definition wrapped.
  class Audited < Loan
    alias original_describe describe

    define_method(:describe) { "audit: #{original_describe}" }

    %i[lent overdue].each do |state|
      define_method(:"mark_#{state}") do
        @state = state
        [__method__, __callee__, state]
      end
    end

    alias mark_late mark_overdue
  end
end

isbn = Shelf::Isbn.new(digits: "978-0-306-40615-7")
book = Shelf::Book.new(isbn:, title: "Dune", author: Shelf::Author.new(name: "Frank Herbert"))
loan = Shelf::Audited.new(book)
loan.describe # => "audit: Dune is on the shelf"
loan.mark_lent # => [:mark_lent, :mark_lent, :lent]
loan.mark_late # => [:mark_overdue, :mark_late, :overdue]
Shelf::Audited.instance_method(:mark_late).name # => :mark_late
Shelf::Audited.instance_method(:mark_late).original_name # => :mark_overdue

# remove_method deletes this class's entry, so lookup falls through to the superclass.
Shelf::Audited.send(:remove_method, :describe)
loan.describe # => "Dune is overdue"

# undef_method forbids the name, even though a superclass defines it.
Shelf::Audited.send(:undef_method, :describe)
Shelf::Audited.undefined_instance_methods # => [:describe]
Shelf::Audited.method_defined?(:describe) # => false
Shelf::Loan.method_defined?(:describe) # => true

begin
  loan.describe
rescue NoMethodError => e
  e.message.sub(/ for an instance.*/, "") # => "undefined method 'describe'"
end

# frozen_string_literal: true

require "shelf"

module Shelf
  # A class-level macro that generates a reader and a writer, with their documentation.
  module Attributes
    # Declares a readable and writable attribute.
    #
    # @!macro [attach] attribute
    #   @!method $1
    #     Returns the +$1+ attribute, or its default.
    #     @return [Object]
    #   @!method $1=(value)
    #     Sets the +$1+ attribute.
    #     @param value [Object]
    #     @return [Object]
    # @param name [Symbol] the attribute name
    # @param default [Object] returned while nothing has been set
    # @return [Symbol] the attribute name
    def attribute(name, default: nil)
      variable = :"@#{name}"
      define_method(name) do
        instance_variable_defined?(variable) ? instance_variable_get(variable) : default
      end
      define_method(:"#{name}=") { |value| instance_variable_set(variable, value) }
      (@attributes ||= []) << name
      name
    end

    # @return [Array<Symbol>] the attribute names declared on this class
    def attributes = (@attributes || []).dup
  end

  # A library member who can borrow books.
  class Member
    extend Attributes

    attribute :name
    attribute :max_loans, default: 3

    def to_h = self.class.attributes.to_h { [it, public_send(it)] }
  end
end

member = Shelf::Member.new
member.name = "Ico"
member.to_h # => {name: "Ico", max_loans: 3}
member.max_loans = 5 # => 5
member.to_h # => {name: "Ico", max_loans: 5}
Shelf::Member.attributes # => [:name, :max_loans]
Shelf::Member.instance_methods(false).sort # => [:max_loans, :max_loans=, :name, :name=, :to_h]
Shelf::Member.instance_method(:max_loans=).parameters # => [[:req, :value]]
Shelf::Member.instance_method(:name).source_location.last # => 23
Shelf::Member.attribute(:email) # => :email

# frozen_string_literal: true

require "shelf"

# An anonymous class has no name until it is assigned to a constant.
adapter = Class.new(Shelf::Store::Memory) do
  def all = super.sort_by(&:title)
end
adapter.name # => nil
adapter.superclass # => Shelf::Store::Memory
adapter.new.all # => []

Shelf::Store.const_set(:Sorted, adapter)
adapter.name # => "Shelf::Store::Sorted"
adapter.to_s # => "Shelf::Store::Sorted"

# The block runs with self set to the new class, so def defines instance methods
# and a local variable of the enclosing scope is visible (a closure).
prefix = "shelf"
tagged = Class.new do
  define_method(:tag) { "#{prefix}-tag" }
  def plain = "no access to locals here"
end
tagged.new.tag # => "shelf-tag"
tagged.instance_methods(false).sort # => [:plain, :tag]

# The inherited hook runs before the block.
class Registry
  def self.inherited(subclass)
    super
    (@subclasses ||= []) << subclass.instance_methods(false)
  end

  def self.seen = @subclasses
end

Class.new(Registry) { def hello = :hi }
Registry.seen # => [[]]
Registry.subclasses.size # => 1
Registry.subclasses.first.instance_methods(false) # => [:hello]

# set_temporary_name (Ruby 3.3) gives an anonymous module a readable name for inspect.
mixin = Module.new
mixin.set_temporary_name("fake<Namespace>") # => fake<Namespace>
mixin.name # => "fake<Namespace>"

def message_of
  yield
rescue StandardError => e
  "#{e.class}: #{e.message}"
end

message_of { mixin.new } # => "NoMethodError: undefined method 'new' for module fake<Namespace>"
message_of { mixin.set_temporary_name("Real::Name") }[/must not be a constant path/] # => "must not be a constant path"
message_of { Class.new(Class) } # => "TypeError: can't make subclass of Class"
message_of { Class.new(adapter.new) }[/superclass must be an instance/] # => "superclass must be an instance"

# Module.new builds a mixin whose methods are generated from data.
statuses = Module.new do
  Shelf::Loan::STATES.each do |state|
    define_method(:"#{state}?") { self.state == state }
  end
end

loan_class = Class.new(Shelf::Loan) { include statuses }
isbn = Shelf::Isbn.new(digits: "978-0-306-40615-7")
book = Shelf::Book.new(isbn:, title: "Dune", author: Shelf::Author.new(name: "Frank Herbert"))
loan = loan_class.new(book, state: :overdue)
loan.overdue? # => true
loan.lent? # => false
loan_class.include?(statuses) # => true
loan_class.ancestors.first(3).map(&:class) # => [Class, Module, Class]

# Data.define and Struct.new also return anonymous classes.
Data.define(:title).name # => nil
Struct.new(:title).superclass # => Struct

# Subclass bookkeeping that needs no hook.
Registry.subclasses.size # => 1
Shelf::Loan.subclasses.size # => 1
loan.singleton_class.attached_object.equal?(loan) # => true

# frozen_string_literal: true

# A constant assigned inside a block belongs to the scope where the block was written,
# not to the class being built.
adapter = Class.new do
  LIMIT = 3 # rubocop:disable Lint/ConstantDefinitionInBlock
  def limit = LIMIT
end

adapter.new.limit # => 3
adapter.constants # => []
Object.const_defined?(:LIMIT, false) # => true

# const_set puts the constant on the class itself.
bounded = Class.new do
  const_set(:MAX, 5)
  def max = self.class::MAX
end

bounded.constants # => [:MAX]
bounded.new.max # => 5
Object.const_defined?(:MAX, false) # => false

# frozen_string_literal: true

require "forwardable"
require "shelf"

module Shelf
  # An abstract base whose concrete classes are produced by Repository[Model].
  class Repository
    # Repository[Book] returns a subclass bound to Book. The result is memoised per model.
    def self.[](model)
      @bound ||= {}
      @bound[model] ||= Class.new(self) do
        define_singleton_method(:model) { model }
      end
    end

    # The abstract part: an unbound repository has no model.
    def self.model = raise(NotImplementedError, "bind a model first: #{name}[Model]")

    def initialize(store: Shelf.config.store)
      @store = store
    end

    def all = @store.all.grep(self.class.model)
  end

  BookRepository = Repository[Book]
  AuthorRepository = Repository[Author]

  # Class-to-instance delegation: Renewals.renew(...) is Renewals.new.renew(...).
  class Renewals
    def self.delegate_to_instance(*names)
      names.each do |name|
        define_singleton_method(name) { |*args, **kwargs, &block| new.public_send(name, *args, **kwargs, &block) }
      end
    end

    delegate_to_instance :renew

    def renew(loan, days: 14) = "#{loan.book.title} renewed for #{days} days"
    alias call renew
  end

  # Forwardable generates the delegating methods for you.
  class Desk
    extend Forwardable

    def_delegators :@catalog, :count, :first
    def_delegator :@catalog, :add, :shelve

    def initialize(catalog) = @catalog = catalog
  end
end

def message_of
  yield
rescue StandardError, ScriptError => e
  "#{e.class}: #{e.message}"
end

Shelf::BookRepository.model # => Shelf::Book
Shelf::BookRepository.name # => "Shelf::BookRepository"
Shelf::Repository[Shelf::Book].equal?(Shelf::BookRepository) # => true
Shelf::BookRepository.superclass.equal?(Shelf::Repository) # => true
message_of { Shelf::Repository.model } # => "NotImplementedError: bind a model first: Shelf::Repository[Model]"

# NotImplementedError is a ScriptError, so a plain rescue does not catch it.
NotImplementedError.ancestors.take(3) # => [NotImplementedError, ScriptError, Exception]
NotImplementedError.ancestors.include?(StandardError) # => false

isbn = Shelf::Isbn.new(digits: "978-0-306-40615-7")
book = Shelf::Book.new(isbn:, title: "Dune", author: Shelf::Author.new(name: "Frank Herbert"))
store = Shelf::Store::Memory.new.add(book).add(book.author)
Shelf::BookRepository.new(store:).all.map(&:title) # => ["Dune"]
Shelf::AuthorRepository.new(store:).all.map(&:name) # => ["Frank Herbert"]

loan = Shelf::Loan.new(book, state: :lent)
Shelf::Renewals.renew(loan) # => "Dune renewed for 14 days"
Shelf::Renewals.renew(loan, days: 7) # => "Dune renewed for 7 days"
Shelf::Renewals.new.call(loan, days: 21) # => "Dune renewed for 21 days"
Shelf::Renewals.instance_method(:call).eql?(Shelf::Renewals.instance_method(:renew)) # => true
Shelf::Renewals.instance_method(:call).name # => :call
Shelf::Renewals.instance_method(:call).original_name # => :renew

# Method objects of delegating methods know where they were defined.
desk = Shelf::Desk.new(Shelf::Catalog.new(store: Shelf::Store::Memory.new))
desk.shelve(book).class # => Shelf::Catalog
desk.count # => 1
desk.first.title # => "Dune"
Shelf::Desk.instance_methods(false).sort # => [:count, :first, :shelve]

# then yields the receiver; with `it` the block needs no parameter list (Ruby 3.4).
Shelf::BookRepository.new(store:).all.then { it.map(&:title).join(", ") } # => "Dune"

# frozen_string_literal: true

require "shelf"

# The named parameters below are the point of the comparison, so RuboCop's advice to use
# anonymous forwarding is switched off for the three classes that show them.
module Shelf
  # The object being wrapped: positional, keyword and block arguments.
  class Receipt
    def line(book, prefix: "", &decorate)
      text = "#{prefix}#{book.title}"
      decorate ? decorate.call(text) : text
    end

    def total = 0
  end

  # rubocop:disable Style/ArgumentsForwarding, Naming/BlockForwarding

  # Forwards only *args: keyword arguments arrive as a positional Hash.
  class NaiveForwarder
    def initialize(target) = @target = target

    def method_missing(name, *args, &block)
      return super unless @target.respond_to?(name)

      @target.public_send(name, *args, &block)
    end

    def respond_to_missing?(name, include_private = false) = @target.respond_to?(name, include_private) || super
  end

  # The full signature: positional, keyword and block arguments all travel.
  class Forwarder
    def initialize(target) = @target = target

    def method_missing(name, *args, **kwargs, &block)
      return super unless @target.respond_to?(name)

      @target.public_send(name, *args, **kwargs, &block)
    end

    def respond_to_missing?(name, include_private = false) = @target.respond_to?(name, include_private) || super
  end

  # rubocop:enable Style/ArgumentsForwarding, Naming/BlockForwarding

  # The ... parameter (with a leading argument since Ruby 3.0) says the same without names.
  class EllipsisForwarder
    def initialize(target) = @target = target

    def method_missing(name, ...)
      return super unless @target.respond_to?(name)

      @target.public_send(name, ...)
    end

    def respond_to_missing?(name, include_private = false) = @target.respond_to?(name, include_private) || super
  end

  # rubocop:disable Style/ArgumentsForwarding, Naming/BlockForwarding

  # ruby2_keywords flags the trailing Hash so that splatting it passes keywords again.
  class FlaggedForwarder
    def initialize(target) = @target = target

    ruby2_keywords def method_missing(name, *args, &block)
      return super unless @target.respond_to?(name)

      @target.public_send(name, *args, &block)
    end

    def respond_to_missing?(name, include_private = false) = @target.respond_to?(name, include_private) || super
  end

  # rubocop:enable Style/ArgumentsForwarding, Naming/BlockForwarding
end

isbn = Shelf::Isbn.new(digits: "978-0-306-40615-7")
book = Shelf::Book.new(isbn:, title: "Dune", author: Shelf::Author.new(name: "Frank Herbert"))
receipt = Shelf::Receipt.new

forwarders = [Shelf::NaiveForwarder, Shelf::Forwarder, Shelf::EllipsisForwarder, Shelf::FlaggedForwarder]
forwarders.each do |klass|
  result = begin
    klass.new(receipt).line(book, prefix: "> ", &:upcase)
  rescue ArgumentError => e
    "ArgumentError: #{e.message}"
  end
  puts "#{klass.name.split('::').last}: #{result}"
end

forwarder = Shelf::Forwarder.new(receipt)
forwarder.total # => 0
forwarder.respond_to?(:line) # => true
forwarder.respond_to?(:refund) # => false

# respond_to_missing? also makes method() work; the Method object reports the ghost.
forwarder.method(:line).arity # => -1
forwarder.method(:line).call(book) # => "Dune"
forwarder.method(:line).inspect # => "#<Method: Shelf::Forwarder#line(*)>"

def message_of
  yield
rescue NameError => e
  "#{e.class}: #{e.message}"
end

# super turns an unknown name back into the usual error, with name, receiver and arguments intact.
message_of { forwarder.refund(1) } # => "NoMethodError: undefined method 'refund' for an instance of Shelf::Forwarder"
message_of { forwarder.instance_eval { refund } }.sub(/ for an instance.*/, "")
# => "NameError: undefined local variable or method 'refund'"

NaiveForwarder: ArgumentError: wrong number of arguments (given 2, expected 1)
Forwarder: > DUNE
EllipsisForwarder: > DUNE
FlaggedForwarder: > DUNE

# frozen_string_literal: true

require "shelf"

module Shelf
  # A bag of settings with ghost readers and writers that become real methods after first use.
  class Options
    def initialize(**values) = @values = values

    def method_missing(name, *)
      key = name.to_s.delete_suffix("=").to_sym
      return super unless @values.key?(key) || name.end_with?("=")

      define_accessors(key)
      public_send(name, *)
    end

    def respond_to_missing?(name, include_private = false)
      @values.key?(name.to_s.delete_suffix("=").to_sym) || super
    end

    private

    def define_accessors(key)
      define_singleton_method(key) { @values[key] }
      define_singleton_method(:"#{key}=") { |value| @values[key] = value }
    end
  end

  # Answers every message, which is exactly the problem.
  class Greedy
    def method_missing(name, *) = "ghost #{name}"

    def respond_to_missing?(*) = true
  end

  # Handles only the names it owns and leaves the rest to super.
  class Polite
    def method_missing(name, *)
      return super unless name.start_with?("get_")

      "ghost #{name}"
    end

    def respond_to_missing?(name, include_private = false) = name.start_with?("get_") || super
  end
end

options = Shelf::Options.new(loan_days: 14)
options.singleton_methods # => []
options.loan_days # => 14
options.singleton_methods # => [:loan_days=, :loan_days]
options.loan_days = 21 # => 21
options.loan_days # => 21
options.respond_to?(:loan_days) # => true
options.respond_to?(:fine) # => false

def message_of
  yield
rescue StandardError, SystemStackError => e
  "#{e.class}: #{e.message}"
end

message_of { Shelf::Options.new.fine } # => "NoMethodError: undefined method 'fine' for an instance of Shelf::Options"

# Implicit conversions probe the object with respond_to? and to_ary, to_str, to_proc, ...
greedy = Shelf::Greedy.new
message_of { puts greedy }
# => "TypeError: can't convert Shelf::Greedy to Array (Shelf::Greedy#to_ary gives String)"
message_of { [greedy].flatten }
# => "TypeError: can't convert Shelf::Greedy to Array (Shelf::Greedy#to_ary gives String)"
message_of { Array(greedy) }
# => "TypeError: can't convert Shelf::Greedy to Array (Shelf::Greedy#to_ary gives String)"

polite = Shelf::Polite.new
polite.get_title # => "ghost get_title"
[polite].flatten.size # => 1
polite.respond_to?(:to_ary) # => false

# A method_missing that calls another missing method calls itself until the stack runs out.
class Runaway
  def method_missing(name, *) = helper_for(name)

  def respond_to_missing?(*) = false
end

message_of { Runaway.new.anything } # => "SystemStackError: stack level too deep"

# frozen_string_literal: true

require "benchmark"
require "shelf"

# Three ways to answer loan.lent?, all with the same result.
class DefLoan < Shelf::Loan
  def lent? = state == :lent
end

class DefineLoan < Shelf::Loan
  Shelf::Loan::STATES.each { |name| define_method(:"#{name}?") { state == name } }
end

class GhostLoan < Shelf::Loan
  def method_missing(name, *args, &)
    status = name.to_s.delete_suffix("?").to_sym
    return super unless name.end_with?("?") && Shelf::Loan::STATES.include?(status)

    state == status
  end

  def respond_to_missing?(name, include_private = false)
    (name.end_with?("?") && Shelf::Loan::STATES.include?(name.to_s.delete_suffix("?").to_sym)) || super
  end
end

isbn = Shelf::Isbn.new(digits: "978-0-306-40615-7")
book = Shelf::Book.new(isbn:, title: "Dune", author: Shelf::Author.new(name: "Frank Herbert"))
loans = [DefLoan, DefineLoan, GhostLoan].map { |klass| klass.new(book, state: :lent) }
loans.map(&:lent?) # => [true, true, true]

runs = 1_000_000
Benchmark.bmbm do |bench|
  loans.each { |loan| bench.report(loan.class.name) { runs.times { loan.lent? } } }
end

Rehearsal ----------------------------------------------
DefLoan      0.028839   0.000007   0.028846 (  0.028853)
DefineLoan   0.031347   0.000030   0.031377 (  0.031397)
GhostLoan    0.179977   0.001163   0.181140 (  0.181933)
------------------------------------- total: 0.241363sec

Source: https://github.com/ruby/benchmark[Benchmark (bundled gem)], https://docs.ruby-lang.org/en/4.0/Module.html#method-i-define_method[Module#define_method] and https://docs.ruby-lang.org/en/4.0/BasicObject.html#method-i-method_missing[BasicObject#method_missing]

                 user     system      total        real
DefLoan      0.029703   0.000457   0.030160 (  0.030977)
DefineLoan   0.032377   0.000343   0.032720 (  0.033476)
GhostLoan    0.210576   0.004055   0.214631 (  0.221432)