Variables, Constants and Scope

# frozen_string_literal: true

# A bare name is a method call until the parser has seen an assignment to it.
def title = 'from the method'

puts title # the method

on_loan = false
title = 'from the local' if on_loan # never assigned, but the parser saw it
p title # the local variable, which is nil

title = 'now assigned'
puts title
puts self.title # rubocop:disable Style/RedundantSelf
p local_variables

from the method
nil
now assigned
from the method
[:on_loan, :title]

# frozen_string_literal: true

limit = 14

# def, class and module open a new scope: nothing outside is visible inside.
def days_allowed
  limit
rescue NameError => e
  e.message
end
puts days_allowed

# A block is a closure: it sees, and can change, the surrounding locals.
renewals = 0
3.times { renewals += 1 }
p renewals

# define_method takes a block, so it can capture a local from the class body.
class Reader
  max_books = 3
  define_method(:max_books) { max_books }
end
puts Reader.new.max_books
puts limit

undefined local variable or method 'limit' for main
3
3
14

# frozen_string_literal: true

# if, unless, while, case and begin do not open a scope.
if ARGV.empty?
  mode = :interactive
  prompt = '> '
end
p mode, prompt

while (attempt ||= 0) < 2
  attempt += 1
  last_try = attempt
end
p last_try

# The modifier condition runs first, so the parser has not yet seen the assignment.
begin
  p copies if (copies = 3).positive? # rubocop:disable Lint/UselessAssignment
rescue NameError => e
  puts e.message
end

# A name with no assignment seen yet is a method call; ||= makes it a local.
count ||= 10
p count

# Struct.new and Data.define blocks do not open a constant scope.
Point = Struct.new(:x, :y) do
  ORIGIN_X = 0 # rubocop:disable Lint/ConstantDefinitionInBlock
end
p Point.const_defined?(:ORIGIN_X, false)
p Object.const_defined?(:ORIGIN_X)

:interactive
"> "
2
undefined local variable or method 'copies' for main
10
false
true

# frozen_string_literal: true

# Variables first assigned inside a block disappear when it ends.
[1, 2].each { |n| puts n * 2 }
p defined?(n)

# for does not open a scope, so its variable leaks.
for i in 1..3 do end # rubocop:disable Style/For
p i

# A block-local variable (after the semicolon) shadows an outer one on purpose.
total = 100
[1, 2, 3].each do |n; total|
  total = n * 10
  puts total
end
p total

# A plain block parameter with the same name also shadows the outer variable.
name = :outer
[:inner].each { |name| puts name }
p name

# Implicit parameters: it (3.4) and _1 to _9 (2.7).
tens = [1, 2, 3].map { it * 10 }
sums = [[1, 2], [3, 4]].map { _1 + _2 }
p tens, sums

2
4
nil
3
10
20
30
100
inner
:outer
[10, 20, 30]
[3, 7]

# frozen_string_literal: true

prefix = '978'

# Class.new, Module.new and Data.define take blocks, so they can close over locals
# (the "flat scope" technique). A def inside would open a new scope and lose them.
Catalogued = Class.new do
  define_method(:catalogue_prefix) { prefix }

  def broken_prefix
    prefix
  rescue NameError => e
    e.message.lines.first.chomp
  end
end

item = Catalogued.new
p item.catalogue_prefix
p item.broken_prefix

prefix = '979' # the closure shares the variable, it does not copy it
p item.catalogue_prefix

# A lambda keeps its variables alive after the defining scope has ended.
def counter
  count = 0
  -> { count += 1 }
end

next_id = counter
next_id.call
p next_id.call
p next_id.binding.local_variables

"978"
"undefined local variable or method 'prefix' for an instance of Catalogued"
"979"
2
[:count]

# frozen_string_literal: true

# Binding exposes the locals of a scope as data.
def describe_scope(isbn)
  _copies = 2
  binding.local_variables.to_h { |name| [name, binding.local_variable_get(name)] }
end
p describe_scope('9780596516178')

# local_variable_set on a name the parser has not seen lives only in the binding.
scope = binding
scope.local_variable_set(:late, 1)
p scope.local_variable_get(:late)
p scope.local_variable_defined?(:late)
p defined?(late)
p scope.eval('late')

{isbn: "9780596516178", _copies: 2}
1
true
nil
1

# frozen_string_literal: true

# Setters need an explicit receiver: a bare assignment creates a local variable.
class Counter
  attr_accessor :count

  def initialize = @count = 0

  def wrong
    count = 5
    [count, @count]
  end

  def right
    self.count = 5
    [count, @count]
  end
end

counter = Counter.new
p counter.wrong
p counter.right

[5, 0]
[5, 5]

# frozen_string_literal: true

# A library whose subclass defines the same class variable.
class Library
end

# A branch of the library.
class Branch < Library
  @@seats = 10 # rubocop:disable Style/ClassVars

  def self.seats = @@seats
end

# Reopening the superclass and defining the same name overtakes the subclass.
class Library
  @@seats = 99 # rubocop:disable Style/ClassVars
end

begin
  Branch.seats
rescue RuntimeError => e
  puts "#{e.class}: #{e.message}"
end

RuntimeError: class variable @@seats of Branch is overtaken by Library

# frozen_string_literal: true

# Class variables cannot be used at the top level (RuntimeError since 3.0).
begin
  @@shelf_count = 1 # rubocop:disable Style/ClassVars
rescue RuntimeError => e
  puts "#{e.class}: #{e.message}"
end

RuntimeError: class variable access from toplevel

# frozen_string_literal: true

require 'English'

# $! and $@ are set while an exception is handled and reset afterwards.
begin
  raise ArgumentError, 'bad ISBN'
rescue ArgumentError
  p $ERROR_INFO
  p $ERROR_POSITION == $ERROR_INFO.backtrace
end
p $ERROR_INFO

# The match globals belong to the current method frame and thread.
# Style/PerlBackrefs prefers Regexp.last_match; the globals are shown on purpose.
# rubocop:disable Style/PerlBackrefs
if 'ISBN 9780596516178' =~ /(\d{3})(\d+)/
  p $LAST_MATCH_INFO[0], $LAST_MATCH_INFO.pre_match
  p $PREMATCH, $POSTMATCH, $LAST_PAREN_MATCH
  p $1, $2
end

def match_in_another_frame = 'X-1' =~ /(\d)/

match_in_another_frame
p $1
# rubocop:enable Style/PerlBackrefs

p $PROGRAM_NAME == $0 # rubocop:disable Style/SpecialGlobalVars
p $PID == Process.pid
p __FILE__ == $PROGRAM_NAME
p $LOAD_PATH.equal?($:) # rubocop:disable Style/SpecialGlobalVars
p $ARGV.equal?(ARGV)

begin
  eval('$PID = 1', binding, __FILE__, __LINE__)
rescue NameError => e
  puts "#{e.class}: #{e.message}"
end

#<ArgumentError: bad ISBN>
true
nil
"9780596516178"
"ISBN "
"ISBN "
""
"0596516178"
"978"
"0596516178"
"978"
true
true
true
true
true
NameError: $PID is a read-only variable

# frozen_string_literal: true

# Warnings go through Kernel#warn; $VERBOSE = nil silences them all.
def old_api
  warn 'old_api is deprecated', uplevel: 1
end

old_api
$VERBOSE = nil
old_api
warn 'also silent'
$VERBOSE = false
warn 'silent no longer'

verbose_levels.rb:8: warning: old_api is deprecated
silent no longer

# frozen_string_literal: true

# The old separator globals still work, but setting them is deprecated.
$, = ','
$; = ' '
p 'a b'.split
puts [1, 2].join

deprecated_separators.rb:4: warning: non-nil '$,' is deprecated
deprecated_separators.rb:5: warning: non-nil '$;' is deprecated
deprecated_separators.rb:6: warning: $; is set to non-nil value
["a", "b"]
deprecated_separators.rb:7: warning: $, is set to non-nil value
1,2

# frozen_string_literal: true

p RUBY_VERSION, RUBY_ENGINE
p ARGV
p ENV.fetch('SHELF_ENV', 'development')
p TOPLEVEL_BINDING.local_variable_defined?(:titles)
p DATA.class
titles = DATA.each_line(chomp: true).to_a
p titles
p TOPLEVEL_BINDING.local_variable_get(:titles)

__END__
Dune
Emma

"4.0.7"
"ruby"
[]
"development"
true
File
["Dune", "Emma"]
["Dune", "Emma"]

# frozen_string_literal: true

# Per-thread and per-fiber state, instead of a plain global.
Thread.current[:request_id] = 'r-1' # fiber-local, despite the name
Thread.current.thread_variable_set(:user, 'ana') # thread-local

Fiber.new do
  p Thread.current[:request_id]
  p Thread.current.thread_variable_get(:user)
end.resume

Thread.new do
  p Thread.current[:request_id]
  p Thread.current.thread_variable_get(:user)
end.join
p Thread.current[:request_id]

nil
"ana"
nil
nil
"r-1"

# frozen_string_literal: true

# Lending rules for the shelf catalogue.
module Policy
  MAX_LOANS = 5
  MAX_LOANS = 7
end
p Policy::MAX_LOANS

# Lending rules, reopened.
module Policy
  p constants.sort
  p const_get(:MAX_LOANS)
  p const_defined?(:LOST_FEE)
  p const_source_location(:MAX_LOANS)
end

Policy.const_set(:LOST_FEE, 20)
p Policy::LOST_FEE
p Policy.constants.sort
p Policy.send(:remove_const, :LOST_FEE)
p Policy.const_defined?(:LOST_FEE)

begin
  Policy::LOST_FEE
rescue NameError => e
  puts e.message
  p e.name, e.receiver
end

begin
  Policy.const_get(:lost_fee)
rescue NameError => e
  puts e.message
end

constants_api.rb:6: warning: already initialized constant Policy::MAX_LOANS
constants_api.rb:5: warning: previous definition of MAX_LOANS was here
7
[:MAX_LOANS]
7
false
["constants_api.rb", 6]
20
[:LOST_FEE, :MAX_LOANS]
20
false
uninitialized constant Policy::LOST_FEE
:LOST_FEE
Policy
wrong constant name lost_fee

# frozen_string_literal: true

source = <<~RUBY
  def configure
    DEFAULT_DAYS = 14
  end
RUBY

begin
  eval(source, binding, 'config.rb', 1) # rubocop:disable Security/Eval
rescue SyntaxError => e
  puts e.message
end

# Constants are fine in a class body, and const_set works inside a method.
class Config
  def self.setup = const_set(:DEFAULT_DAYS, 14)
end
p Config.setup
p Config::DEFAULT_DAYS

config.rb:2: syntax error found
  1 | def configure
> 2 |   DEFAULT_DAYS = 14
    |   ^~~~~~~~~~~~~~~~~ dynamic constant assignment
  3 | end
14
14

# frozen_string_literal: true

# A class whose constants are defined from outside.
class Desk
end

# A block keeps the lexical scope of where it was written (top level).
# rubocop:disable Lint/ConstantDefinitionInBlock
Desk.class_eval do
  FROM_BLOCK = 1
end
# rubocop:enable Lint/ConstantDefinitionInBlock

# A string is compiled with the receiver as the lexical scope.
Desk.class_eval('FROM_STRING = 2', __FILE__, __LINE__)

p Object.const_defined?(:FROM_BLOCK)
p Desk.const_defined?(:FROM_BLOCK, false)
p Desk.constants

true
false
[:FROM_STRING]

# frozen_string_literal: true

# Lending states and rules; a constant name does not make its value immutable.
module Rules
  STATES = %i[available lent overdue returned] # rubocop:disable Style/MutableConstant
  FEES = { late: [1, 2], lost: [20] }.freeze
  NAMES = %w[Dune Emma].map(&:freeze).freeze
  CALENDAR = Ractor.make_shareable({ open: %w[mon tue], closed: %w[sun] })
end

Rules::STATES << :lost
p Rules::STATES

Rules::FEES[:late] << 3 # the hash is frozen, the array inside it is not
p Rules::FEES
begin
  Rules::FEES[:extra] = []
rescue FrozenError => e
  puts e.message
end

begin
  Rules::NAMES << 'Ulysses'
rescue FrozenError => e
  puts e.message
end

begin
  Rules::CALENDAR[:open] << 'wed'
rescue FrozenError => e
  puts e.message
end

p Rules::CALENDAR.frozen?, Rules::CALENDAR[:open].frozen?
p Ractor.shareable?(Rules::FEES), Ractor.shareable?(Rules::CALENDAR)

editable = Rules::CALENDAR.dup # shallow copy: unfrozen hash, same frozen arrays
editable[:holiday] = %w[dec25]
p editable.frozen?, editable[:open].frozen?

[:available, :lent, :overdue, :returned, :lost]
{late: [1, 2, 3], lost: [20]}
can't modify frozen Hash: {late: [1, 2, 3], lost: [20]}
can't modify frozen Array: ["Dune", "Emma"]
can't modify frozen Array: ["mon", "tue"]
true
true
false
true
false
true

# frozen_string_literal: true

# shareable_constant_value: literal

# Fees in cents; with the directive, literal values are deeply frozen.
module Fees
  LATE = { per_day: [10, 25], cap: 500 }
  CODES = %w[L M]
end

p Fees::LATE.frozen?, Fees::LATE[:per_day].frozen?
p Ractor.shareable?(Fees::CODES)

begin
  Fees::CODES << 'X'
rescue FrozenError => e
  puts e.message
end

# const_set is not affected by the directive.
Fees.const_set(:LIST, [])
p Fees::LIST.frozen?

true
true
true
can't modify frozen Array: ["L", "M"]
false

# frozen_string_literal: true

# shareable_constant_value: literal

# A value built at load time is not a literal, so it must already be shareable.
reader = Struct.new(:name).new('Ana')
begin
  CURRENT_READER = reader
rescue Ractor::IsolationError => e
  puts "#{e.class}: #{e.message}"
end

Ractor::IsolationError: cannot assign unshareable object to CURRENT_READER

# frozen_string_literal: true

DAYS = 'top level'

# A kind of lendable item.
class Media
  KIND = 'media'
  DAYS = 'media'
end

# Lexical scope is searched before ancestors.
module Lending
  KIND = 'lending'
  p Module.nesting

  # A book that can be lent.
  class Book < Media
    p Module.nesting

    # Lending::KIND is found lexically, before Media::KIND.
    def kind = KIND

    # Not in Lending, so Media::DAYS is found through the ancestors.
    def days = DAYS

    # Nothing nearer, so Object (through the ancestors) provides it.
    def comparable = Comparable
  end
end

# The compact form: Lending is not in Module.nesting, so its constants are not visible.
# rubocop:disable Style/ClassAndModuleChildren
class Lending::Dvd < Media
  p Module.nesting

  # Media::KIND, not Lending::KIND.
  def kind = KIND
end
# rubocop:enable Style/ClassAndModuleChildren

p Lending::Book.new.kind
p Lending::Book.new.days
p Lending::Book.new.comparable
p Lending::Dvd.new.kind

[Lending]
[Lending::Book, Lending]
[Lending::Dvd]
"lending"
"media"
Comparable
"media"

# frozen_string_literal: true

# Constants come from the lexical scope, then the ancestors, including mixins.
module Greeting
  WORD = 'hello'
end

# A class that mixes the module in and defines one constant of its own.
class Desk
  include Greeting

  OWN = 'own'

  def word = WORD

  class << self
    # Desk is in the lexical scope of the singleton class body.
    def own_word = OWN

    # Greeting is only an ancestor of Desk, and lexical lookup ignores ancestors.
    def mixin_word = WORD
  end
end

p Desk.new.word, Desk.own_word, Desk::WORD
begin
  Desk.mixin_word
rescue NameError => e
  puts e.message
end
p Desk.const_defined?(:WORD, false)
p Desk.constants.sort

"hello"
"own"
"hello"
uninitialized constant #<Class:Desk>::WORD
false
[:OWN, :WORD]

# frozen_string_literal: true

DAYS = 'top level'

# A kind of lendable item.
class Media
  KIND = 'media'
end

# Items that can be lent.
module Lending
  # A book that can be lent.
  class Book < Media
  end
end

p Lending::Book::KIND # scoped lookup: Book, then its ancestors
p ::DAYS              # an explicit top-level constant
p Lending.const_get(:DAYS)
begin
  Lending.const_get(:DAYS, false) # inherit = false: only Lending itself
rescue NameError => e
  puts e.message
end

begin
  Lending::Book::String # scoped lookup does not fall back to Object
rescue NameError => e
  puts e.message
end
p Lending::Book.const_get(:String) # const_get does
p Lending::Book.const_get('Media::KIND')

"media"
"top level"
"top level"
uninitialized constant Lending::DAYS
uninitialized constant Lending::Book::String
String
"media"

# frozen_string_literal: true

# Item kinds known to the catalogue.
module Kinds
  BOOK = :book
  LEGACY_MAGAZINE = :magazine
  INTERNAL_CODES = %w[b m].freeze

  private_constant :INTERNAL_CODES
  deprecate_constant :LEGACY_MAGAZINE

  # Inside the module the private constant is an ordinary name.
  def self.codes = INTERNAL_CODES
end

p Kinds.codes
p Kinds::LEGACY_MAGAZINE

begin
  Kinds::INTERNAL_CODES
rescue NameError => e
  puts e.message
end
p Kinds.constants
p Kinds.const_defined?(:INTERNAL_CODES)
p Kinds.const_get(:INTERNAL_CODES) # const_get ignores private_constant

["b", "m"]
private_deprecated_constants.rb:17: warning: constant Kinds::LEGACY_MAGAZINE is deprecated
:magazine
private constant Kinds::INTERNAL_CODES referenced
[:BOOK, :LEGACY_MAGAZINE]
true
["b", "m"]

# frozen_string_literal: true

# A module that hides one constant and also defines const_missing.
module Vault
  SECRET = 'demo'
  private_constant :SECRET

  def self.const_missing(name)
    "const_missing called for #{name}"
  end
end

puts Vault::SECRET # the private constant reaches const_missing

const_missing called for SECRET

# frozen_string_literal: true

# Shelf codes resolved on demand: Codes::FICTION gives 'F', Codes::HISTORY gives 'H'.
module Codes
  # Called when a constant is not found anywhere in the lookup path.
  def self.const_missing(name)
    code = name.to_s[0]
    return super if code.nil? || name.to_s.length < 4

    const_set(name, code) # define it so const_missing runs only once
  end
end

p Codes::FICTION
p Codes.constants
begin
  Codes::X
rescue NameError => e
  puts e.message
end

"F"
[:FICTION]
uninitialized constant Codes::X

# frozen_string_literal: true

# Module#const_added (3.2) runs every time a constant is defined.
class Registry
  def self.const_added(name)
    super
    puts "defined #{self}::#{name}"
  end

  LIMIT = 3

  # A nested class is a constant too.
  class Entry; end
end

p Ruby::VERSION == RUBY_VERSION

defined Registry::LIMIT
defined Registry::Entry
true

# frozen_string_literal: true

# An anonymous class gets its name the first time it is assigned to a constant.
branch = Class.new
p branch.name
Annex = branch # rubocop:disable Naming/ConstantName
p branch.name, branch
Other = branch # rubocop:disable Naming/ConstantName
p Other.name # the first constant wins

temp = Module.new.set_temporary_name('fake<shelf>') # 3.3
p temp
Permanent = temp # rubocop:disable Naming/ConstantName
p temp.name

nil
"Annex"
Annex
"Annex"
fake<shelf>
"Permanent"