
class Point
end

p = Point.new

p.class       # => Point
p.is_a? Point # => true

class Point
  def initialize(x,y)
    @x, @y = x, y
  end
end

p = Point.new(0,0)

# Niepoprawny kod!
class Point
  @x = 0   # Utworzenie zmiennej egzemplarza  @x i przypisanie jej domylnej wartoci. le!
  @y = 0   # Utworzenie zmiennej egzemplarza  @y i przypisanie jej domylnej wartoci. le!
  def initialize(x,y)
    @x, @y = x, y   # Inicjalizacja utworzonych wczeniej zmiennych @x i @y.
  end
end

class Point
  def initialize(x,y)
    @x, @y = x, y
  end
  def to_s        # Zwraca acuch reprezentujcy ten punkt.
    "(#@x,#@y)"   # Interpolacja zmiennych egzemplarza do acucha.
  end
end

p = new Point(1,2)   # Utworzenie nowego obiektu klasy Point.
puts p               # Drukuje (1,2).

class Point
  def initialize(x,y)
    @x, @y = x, y
  end
  def x           # Metoda dostpu do (czyli getter) zmiennej @x.
    @x
  end
  def y           # Metoda dostpu do zmiennej @y.
    @y
  end
end

p = Point.new(1,2)
q = Point.new(p.x*2, p.y*3)

class MutablePoint
  def initialize(x,y); @x, @y = x, y; end
  def x; @x; end       # Metoda dostpu do zmiennej @x.
  def y; @y; end       # Metoda dostpu do zmiennej @y.
  def x=(value)        # Metoda ustawiajca warto zmiennej @x.
    @x = value
  end
  def y=(value)        # Metoda ustawiajca warto zmiennej @y.
    @y = value
  end
end

p = Point.new(1,1)
p.x = 0
p.y = 0

class Point
  attr_accessor :x, :y # Definicja metod dostpowych dla zmiennych egzemplarza.
end

class Point
  attr_reader :x, :y   # Definicja metod sprawdzajcych dla zmiennych egzemplarza.
end

attr_reader "x", "y"

attr :x        # Definicja prostej metody pobierajcej x dla @x.
attr :y, true  # Definicja metody sprawdzajcej i ustawiajcej dla @y.

class Point
  attr_reader :x, :y   # Definicja metod dostpowych.
  def initialize(x,y)
    @x,@y = x, y
  end
  def +(other)         # Definicja operatora + wykonujcego dodawanie wektorowe.
    Point.new(@x + other.x, @y + other.y)
  end
  def -@               # Definicja jednoargumentowego operatora - negujcego obie wsprzdne.
    Point.new(-@x, -@y)
  end
  def *(scalar)        # Definicja operatora * wykonujcego mnoenie skalarne.
    Point.new(@x*scalar, @y*scalar)
  end
end

NoMethodError: undefined method `x' for 3:Fixnum
        from ./point.rb:37:in `+'

def +(other)
  raise TypeError, "Wymagany argument klasy Point" unless other.is_a? Point
  Point.new(@x + other.x, @y + other.y)
end

def +(other)
  raise TypeError, "Wymagany argument typu Point" unless
    other.respond_to? :x and other.respond_to? :y
  Point.new(@x + other.x, @y + other.y)
end

def +(other)         # Zakadasz, e other wyglda jak Point.
  Point.new(@x + other.x, @y + other.y)
rescue               # Jeli co powyej pjdzie le,
  raise TypeError,   # zgaszasz wasny wyjtek.
    "Dodawanie punktw, z ktrych jeden nie kwacze jak punkt!"
end

# Jeli obiekt klasy Point zostanie przekazany do metody * klasy Integer, metoda ta
# zostanie wywoana na rzecz tego obiektu Point, a nastpnie nastpi prba pomnoenia elementw tablicy.
# Zamiast konwertowa typy, zmieniasz kolejno operandw, dziki czemu
# wywoywana jest metoda * zdefiniowana powyej.
def coerce(other)
  [self, other]
end

# Definicja metody [] pozwalajcej na traktowanie obiektw klasy Point jako tablic jednowymiarowych
# lub tablic asocjacyjnych z kluczami :x i :y.
def [](index)
  case index
  when 0, -2: @x         # Indeks 0 (lub -2) odpowiada wsprzdnej X.
  when 1, -1: @y         # Indeks 1 (lub -1) odpowiada wsprzdnej Y.
  when :x, "x": @x       # Klucze tablicy asocjacyjnej jako symbol lub acuch dla wsprzdnej X.
  when :y, "y": @y       # Klucze tablicy asocjacyjnej jako symbol lub acuch dla wsprzdnej Y.
  else nil               # Tablice jednowymiarowe i asocjacyjne zwracaj warto nil dla nieprawidowych indeksw.
  end
end

# Niniejszy iterator przekazuje wsprzdn X do odpowiedniego bloku, nastpnie
# przekazuje wsprzdn Y i zwraca warto. Pozwala na przeliczenie punktu,
# jakby by tablic zawierajc dwa elementy. Ta metoda each jest wymagana
# przez modu Enumerable.
def each
  yield @x
  yield @y
end

p = Point.new(1,2)
p.each {|x| print x }   # Drukuje 12.

include Enumerable

# Czy punkt P oznacza pocztek ukadu wsprzdnych?
p.all? {|x| x == 0 } # Prawda, jeli zwraca true dla wszystkich elementw.

def ==(o)               # Czy self == o?
  if o.is_a? Point      # Jeli o jest obiektem klasy Point,
    @x==o.x && @y==o.y  # porwnywane s pola.
  else                  # Jeli o nie jest obiektem klasy Point,
    false               # to zgodnie z definicj self != o.
  end
end

def ==(o)                  # Czy self == o?
  @x == o.x && @y == o.y   # Zaoenie, e o udostpnia odpowiednie metody x i y.
rescue                     # Jeli zaoenie okae si nieprawdziwe,
  false                    # self != o.
end

class Point
  alias eql? ==
end

def eql?(o)
  if o.instance_of? Point
    @x.eql?(o.x) && @y.eql?(o.y)
  else
    false
  end
end

def hash
  @x.hash + @y.hash
end

def hash
  code = 17
  code = 37*code + @x.hash
  code = 37*code + @y.hash
  # Dodaj wiersz tego typu dla kadej znaczcej zmiennej egzemplarza.
  code  # Zwrot powstaego kodu.
end

include Comparable   # Domieszanie metod z moduu Comparable.
# Definicja porzdku punktw na podstawie ich odlegoci od pocztku ukadu wsprzdnych.
# Ta metoda jest wymagana przez modu Comparable.
def <=>(other)
  return nil unless other.instance_of? Point
  @x**2 + @y**2 <=> other.x**2 + other.y**2
end

p,q = Point.new(1,0), Point.new(0,1)
p == q        # => false: p nie jest rwny q.
p < q         # => false: p nie jest mniejszy od q.
p > q         # => false: p nie jest wikszy od q.

attr_accessor :x, :y

def add!(p)          # Dodaje p do self i zwraca zmodyfikowany obiekt self.
  @x += p.x
  @y += p.y
  self
end

def add(p)           # Niemodyfikujca wersja metody add!
  q = self.dup       # Utworzenie kopii obiektu self.
  q.add!(p)          # Wywoanie metody modyfikujcej na rzecz powstaej kopii.
end

Struct.new("Point", :x, :y)  # Tworzy now klas Struct::Point.
Point = Struct.new(:x, :y)   # Tworzy now klas, przypisuje do Point.

C = Class.new   # Nowa klasa bez ciaa przypisana do staej.
c = C.new       # Utworzenie egzemplarza tej klasy.
c.class.to_s    # => "C": nazwa staej staje si nazw klasy.

p = Point.new(1,2)   # => #<struct Point x=1, y=2>
p.x                  # => 1
p.y                  # => 2
p.x = 3              # => 3
p.x                  # => 3

p[:x] = 4             # => 4: to samo, co p.x =.
p[:x]                 # => 4: to samo, co p.x.
p[1]                  # => 2: to samo, co p.y.
p.each {|c| print c}  # Drukuje "42".
p.each_pair {|n,c| print n,c }   # Drukuje "x4y2".

q = Point.new(4,2)
q == p        # => true
h = {q => 1}  # Utworzenie tablicy asocjacyjnej przy uyciu q jako klucza.
h[p]          # => 1: pobranie wartoci przy uyciu klucza q.
q.to_s        # => "#<struct Point x=4, y=2>"

Point = Struct.new(:x, :y)   # Utworzenie nowej klasy i przypisanie jej do nazwy Point.
class Point                  # Otwarcie klasy Point w celu dodania nowych metod.
  def add!(other)            # Definicja metody add!.
    self.x += other.x
    self.y += other.y
    self
  end
  include Comparable         # Dodanie moduu do klasy.
  def <=>(other)             # Definicja operatora <=>.
    return nil unless other.instance_of? Point
    self.x**2 + self.y**2 <=> other.x**2 + other.y**2
  end
end

Point = Struct.new(:x, :y)  # Definicja modyfikowalnej klasy.
class Point                 # Otwarcie klasy.
  undef x=,y=,[]=           # Usunicie definicji metod modyfikujcych.
end

total = Point.sum(p1, p2, p3)  # p1, p2 i p3 to obiekty klasy Point.

class Point
  attr_reader :x, :y     # Definicja metod dostpowych do zmiennych egzemplarza.
  def Point.sum(*points) # Zwrot sumy dowolnej liczby punktw.
    x = y = 0
    points.each {|p| x += p.x; y += p.y }
    Point.new(x,y)
  end
  # ... reszta klasy pominita...
end

def self.sum(*points)  # Zwraca sum dowolnej liczby punktw.
  x = y = 0
  points.each {|p| x += p.x; y += p.y }
  Point.new(x,y)
end

# Otwarcie obiektu klasy Point, aby doda do niego metody.
class << Point      # Skadnia pozwalajca dodawa metody do pojedynczych obiektw.
  def sum(*points)  # Metoda klasowa Point.sum.
    x = y = 0
    points.each {|p| x += p.x; y += p.y }
    Point.new(x,y)
  end
  # Tutaj mog znajdowa si definicje innych metod klasowych.
end

class Point
  # Metody egzemplarza.
  class << self
    # Metody klasowe.
  end
end

class Point
  def initialize(x,y)  # Inicjalizacja metody.
    @x,@y = x, y
  end
  ORIGIN = Point.new(0,0)
  UNIT_X = Point.new(1,0)
  UNIT_Y = Point.new(0,1)
  # Pozostaa cz definicji klasy.
end

Point::UNIT_X + Point::UNIT_Y   # => (1,1)

Point::NEGATIVE_UNIT_X = Point.new(-1,0)

class Point
  # Inicjacja zmiennych klasowych w definicji klasy.
  @@n = 0              # Ile zostao utworzonych punktw.
  @@totalX = 0         # Suma wszystkich wsprzdnych X.
  @@totalY = 0         # Suma wszystkich wsprzdnych Y.
  def initialize(x,y)  # Metoda initialize.
    @x,@y = x, y       # Ustawienie wartoci pocztkowych dla zmiennych egzemplarza.
    # Uycie zmiennych klasowych w tej metodzie egzemplarza do zbierania danych.
    @@n += 1           # ledzenie liczby utworzonych punktw.
    @@totalX += x      # Dodanie wsprzdnych do sum cakowitych.
    @@totalY += y
  end
  # Metoda klasowa raportujca o zebranych danych.
  def self.report
    # Uycie zmiennych klasowych w metodzie klasowej.
    puts "Liczba utworzonych punktw: #@@n"
    puts "rednia wsprzdna X: #{@@totalX.to_f/@@n}"
    puts "Srednia wsprzdna Y: #{@@totalY.to_f/@@n}"
  end
end

class Point
  # Inicjacja klasowych zmiennych egzemplarza w samej definicji klasy.
  @n = 0              # Ile zostao utworzonych punktw.
  @totalX = 0         # Suma wsprzdnych X.
  @totalY = 0         # Suma wsprzdnych Y.
  def initialize(x,y) # Metoda initialize.
    @x,@y = x, y      # Ustawienie pocztkowych wartoci zmiennych egzemplarza.
  end
  def self.new(x,y)   # Metoda klasowa tworzca obiekty klasy Point.
    # Klasowe zmienne egzemplarza do przechowywania danych.
    @n += 1           # ledzenie liczby utworzonych obiektw klasy Point.
    @totalX += x      # Dodanie wsprzdnych do sum cakowitych.
    @totalY += y
    super             # Wywoanie prawdziwej definicji new w celu utworzenia punktu.
                      # Wicej na temat sowa kluczowego super znajduje si dalej w tym rozdziale.
  end
  # Metoda klasowa raportujca zebrane dane.
  def self.report
    # Uycie klasowych metod egzemplarza w metodzie klasowej.
    puts "Liczba utworzonych punktw: #@n"
    puts "rednia wsprzdna X: #{@totalX.to_f/@n}"
    puts "rednia wsprzdna Y: #{@totalY.to_f/@n}"
  end
end

class << self
  attr_accessor :n, :totalX, :totalY
end

class Point
  # Metody publiczne.
  # Poniej znajduj si metody chronione.
  protected
  # Metody chronione.
  # Ponisze metody s prywatne.
  private
  # Metody prywatne.
end

class Widget
  def x                       # Metoda dostpu do @x.
    @x
  end
  protected :x                # Deklaracja chronienia.
  def utility_method          # Definicja metody.
    nil
  end
  private :utility_method     # Deklaracja prywatnoci.
end

private_class_method :new

w = Widget.new                      # Utworzenie widgetu.
w.send :utility_method              # Wywoanie prywatnej metody!
w.instance_eval { utility_method }  # Inny sposb wywoania tej metody.
w.instance_eval { @x }              # Odczyt zmiennej egzemplarza w.

class Point3D < Point    # Definicja klasy Point3D jako podklasy klasy Point.
end

class Point3D < Struct.new("Point3D", :x, :y, :z)
  # Nadklasa przekazaa metody ==, to_s itd.
  # Tutaj mona doda kolejne metody specyficzne dla punktw 3D.
end

p2 = Point.new(1,2)
p3 = Point3D.new(1,2)
print p2.to_s, p2.class   # Drukuje "(1,2)Point".
print p3.to_s, p3.class   # Drukuje "(1,2)Point3D".

o = Object.new
puts o.to_s      # Drukuje co w rodzaju "#<Object:0xb7f7fce4>".

# Powitanie ze wiatem.
class WorldGreeter
  def greet                      # Wywietlenie powitania.
    puts "#{greeting} #{who}"
  end
  def greeting                   # Wybr powitania.
    "Witaj"
  end
  def who                        # Kogo powita.
    "wiecie"
  end
end
# Powitanie ze wiatem po hiszpasku.
class SpanishWorldGreeter < WorldGreeter
  def greeting                   # Przesonicie przywitania.
    "Hola"
  end
end
# Wywoujemy metod zdefiniowan w klasie WorldGreeter, ktra wywouje przesonit
# wersj powitania w klasie SpanishWorldGreeter oraz drukuje Hola wiecie.
SpanishWorldGreeter.new.greet

# Ta klasa jest abstrakcyjna. Nie definiuje metod greeting ani who.
# Nie jest wymagana adna specjalna skadnia   kada klasa wywoujca metody
# majce by zaimplementowane w podklasie jest abstrakcyjna.
class AbstractGreeter
  def greet
    puts "#{greeting} #{who}"
  end
end
# Konkretna podklasa.
class WorldGreeter < AbstractGreeter
  def greeting; "Witaj"; end
  def who; "wiecie"; end
end
WorldGreeter.new.greet  # Wywietla Witaj wiecie.

class Point3D < Point
  def initialize(x,y,z)
    # Przekazanie dwch pierwszych argumentw do metody initialize w nadklasie.
    super(x,y)
    # Trzeci argument pozostanie w podklasie.
    @z = z;
  end
end

class Point3D < Point
  def initialize(x,y,z)
    super(x,y)
    @z = z;
  end
  def to_s
    "(#@x, #@y, #@z)"  # Czy zmienne @x i @y s dziedziczone?
  end
end

Point3D.new(1,2,3).to_s  # => "(1, 2, 3)".

class A
  @@value = 1                   # Zmienna klasowa.
  def A.value; @@value; end     # Metoda dostpu do tej zmiennej klasowej.
end
print A.value                   # Wywietlenie wartoci zmiennej klasy A.
class B < A; @@value = 2; end   # Podklasa zmienia warto wspdzielonej zmiennej klasowej.
print A.value                   # Nadklasa widzi zmienion warto.
class C < A; @@value = 3; end   # Inna klasa znowu zmienia wspdzielon zmienn.
print B.value                   # Pierwsza podklasa widzi warto z drugiej podklasy.

ORIGIN = Point3D.new(0,0,0)

def new(*args)
  o = self.allocate   # Utworzenie nowego obiektu tej klasy.
  o.initialize(*args) # Wywoanie metody initialize tego obiektu z argumentami.
  o                   # Zwrcenie nowego obiektu i zignorowanie wartoci zwrotnej metody initialize.
end

class Point
  # Inicjuje obiekt klasy Point dwoma lub trzema wsprzdnymi.
  def initialize(x, y, z=nil)
    @x,@y,@z = x, y, z
  end
end

class Point
  # Definiowanie i inicjacja metod jak zwykle...
  def initialize(x,y)  # Przyjmuje wsprzdne kartezjaskie.
    @x,@y = x,y
  end
  # Metoda fabryczna new jest prywatna.
  private_class_method :new
  def Point.cartesian(x,y)  # Metoda fabryczna dla wsprzdnych kartezjaskich.
    new(x,y)  # Metod new mona nadal wywoywa w innych metodach klasowych.
  end
  def Point.polar(r, theta) # Metoda fabryczna dla wsprzdnych biegunowych.
    new(r*Math.cos(theta), r*Math.sin(theta))
  end
end

class Point                 # Punkt w przestrzeni n.
  def initialize(*coords)   # Przyjmuje dowoln liczb wsprzdnych.
    @coords = coords        # Zapisuje wsprzdne w tablicy.
  end
  def initialize_copy(orig) # Jeli obiekt ten bdzie kopiowany,
    @coords = @coords.dup   # zostanie utworzona take kopia tablicy wsprzdnych.
  end
end

class Season
  NAMES = %w{ Spring Summer Autumn Winter }  # Tablica pr roku.
  INSTANCES = []                             # Tablica obiektw klasy Season.
  def initialize(n)  # Stan pory roku jest  tylko jej
    @n = n           # indeksem w tablicach NAMES i INSTANCES.
  end
  def to_s           # Zwrcenie nazwy pory roku.
    NAMES[@n]
  end
  # Tworzy egzemplarze tej klasy reprezentujce pory roku
  # oraz definiuje stae odwoujce si do tych egzemplarzy.
  # Musi to zosta zrobione po zdefiniowaniu metody initialize.
  NAMES.each_with_index do |name,index|
    instance = new(index)         # Utworzenie nowego egzemplarza.
    INSTANCES[index] = instance   # Zapisanie go w tablicy egzemplarzy.
    const_set name, instance      # Definicja staej odwoujcej si do niego.
  end
  # Kiedy zostay utworzone wszystkie egzemplarze, ktre bd kiedykolwiek potrzebne,
  # trzeba zablokowa tworzenie kolejnych egzemplarzy.
  private_class_method :new,:allocate  # Uczynienie metod fabrycznych prywatnymi.
  private :dup, :clone                 # Uczynienie kopiowania metod czynnoci prywatn.
end

class Point                  # Punkt w przestrzeni n-wymiarowej.
  def initialize(*coords)    # Przyjmuje dowoln liczb wsprzdnych.
    @coords = coords         # Zapisuje wsprzdne w tablicy.
  end
  def marshal_dump           # Pakuje wsprzdne do acucha i szereguje go.
    @coords.pack("w*")
  end
  def marshal_load(s)        # Odpakowuje wsprzdne z rozszeregowanego acucha
    @coords = s.unpack("w*") # i inicjuje za ich pomoc obiekt.
  end
end

class Season
  # Pozwalasz na szeregowanie obiektw klasy Season, ale nie
  # pozwalasz na tworzenie podczas ich rozszeregowywania nowych egzemplarzy.
  def _dump(limit)         # Metoda szeregujca.
    @n.to_s                # Zwrot indeksu w postaci acucha.
  end
  def self._load(s)        # Metoda rozszeregowujca.
    INSTANCES[Integer(s)]  # Zwrot istniejcego egzemplarza.
  end
end

require 'singleton'           # Modu Singleton nie jest wbudowany.
class PointStats              # Definiowanie klasy.
  include Singleton           # Zadeklarowanie klasy jako singletonowej.
  def initialize              # Normalna metoda initialize.
    @n, @totalX, @totalY = 0, 0.0, 0.0
  end
  def record(point)           # Zapisanie nowego punktu.
    @n += 1
    @totalX += point.x
    @totalY += point.y
  end
  def report                  # Raportowanie statystyk punktw.
    puts "Liczba utworzonych punktw: #@n"
    puts "rednia wsprzdna X: #{@totalX/@n}"
    puts "rednia wsprzdna Y: #{@totalY/@n}"
  end
end

def initialize(x,y)
  @x,@y = x,y
  PointStats.instance.record(self)
end

PointStats.instance.report

def base64_encode
end
def base64_decode
end

module Base64
  def self.encode
  end
  def self.decode
  end
end

module Base64
  def Base64.encode
  end
  def Base64.decode
  end
end

# Wywoania metod moduu Base64.
text = Base64.encode(data)
data = Base64.decode(text)

module Base64
  DIGITS = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' \
           'abcdefghijklmnopqrstuvwxyz' \
           '0123456789+/'
end

module Base64
  DIGITS = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'
  class Encoder
    def encode
    end
  end
  class Decoder
    def decode
    end
  end
  # Funkcja uytkowa do dyspozycji obu klas.
  def Base64.helper
  end
end

class Point
  include Comparable
end

class Point
  include(Comparable)
end

include Enumerable, Comparable

"text".is_a? Comparable         # => true
Enumerable === "text"           # => true w Ruby 1.8, false w 1.9

"text".instance_of? Comparable  # => false

module Iterable       # Klasy, ktre definiuj metod next, mog docza ten modu.
  include Enumerable          # Iteratory s definiowane na podstawie metody each.
  def each                    # Metoda each jest zdefiniowana na podstawie metody next.
    loop { yield self.next }
  end
end

countdown = Object.new       # Stary zwyky obiekt.
def countdown.each           # Iterator each jako metoda singletonowa.
  yield 3
  yield 2
  yield 1
end
countdown.extend(Enumerable) # Teraz obiekt ten posiada wszystkie metody Enumerable.
print countdown.sort         # Drukuje "[1, 2, 3]".

Math.sin(0)    # => 0.0: Math jest przestrzeni nazw.
include Math   # Przestrze nazw Math mona doczy.
sin(0)         # => 0.0: Teraz masz uatwiony dostp do funkcji.

/usr/lib/site_ruby/1.8
/usr/lib/site_ruby/1.8/i386-linux
/usr/lib/site_ruby
/usr/lib/ruby/1.8
/usr/lib/ruby/1.8/i386-linux
.

/usr/local/lib/ruby/gems/1.9/gems/rake-0.7.3/lib
/usr/local/lib/ruby/gems/1.9/gems/rake-0.7.3/bin
/usr/local/lib/ruby/site_ruby/1.9
/usr/local/lib/ruby/site_ruby/1.9/i686-linux
/usr/local/lib/ruby/site_ruby
/usr/local/lib/ruby/vendor_ruby/1.9
/usr/local/lib/ruby/vendor_ruby/1.9/i686-linux
/usr/local/lib/ruby/vendor_ruby
/usr/local/lib/ruby/1.9
/usr/local/lib/ruby/1.9/i686-linux
.

# Usuwa biecy katalog ze cieki wczytywania.
$:.pop if $:.last == '.'
# Dodaje katalog instalacyjny biecego programu na
# pocztku cieki wczytywania jako alternatywa uycia require_relative.
$LOAD_PATH.unshift File.expand_path($PROGRAM_NAME)
# Dodaje warto zmiennej rodowiskowej na kocu cieki.
$LOAD_PATH << ENV['MY_LIBRARY_DIRECTORY']

$Util = Util   # Zapisanie referencji do tego moduu w zmiennej globalnej.

if Module.nesting.size > 0       # Jeli zostalimy zaadowani do moduu opakowujcego,
  $wrapper = Module.nesting[0]   # przekazujemy ten modu z powrotem do kodu adujcego.
end

# Docza 'socket', jeli i gdy staa TCPSocket zostanie uyta po raz pierwszy.
autoload :TCPSocket, "socket"

class << Point
  def class_method1      # Metoda egzemplarza klasy eigenclass.
  end                    # Jest to take metoda klasowa obiektu klasy Point.
  def class_method2
  end
end

class Point
  # Metody egzemplarza.
  class << self
    # Metody klasowe jako metody egzemplarza klasy eigenclass.
  end
end

class Point            # Utworzenie lub otwarcie klasy Point.
class Point3D < Point  # Utworzenie podklasy klasy Point.
class << Point         # Otwarcie klasy eigenclass obiektu klasowego Point.

eigenclass = class << o; self; end

class Object
  def eigenclass
    class << self; self; end
  end
end

message = "witaj"
message.world

NoMethodError: undefined method 'world' for "witaj":String

class C
end

c = C.new

def Integer.parse(text)
  text.to_i
end

n = Fixnum.parse("1")

module Kernel
  # Stae zdefiniowane w module Kernel.
  A = B = C = D = E = F = "zdefiniowane w module Kernel"
end
# Stae globalne zdefiniowane w klasie Object.
A = B = C = D = E = "zdefiniowane na najwyszym poziomie"
class Super
  # Stae zdefiniowane w nadklasie.
  A = B = C = D = "zdefiniowane w nadklasie"
end
module Included
  # Stae zdefiniowane w doczonym module.
  A = B = C = "zdefiniowane w doczonym module"
end
module Enclosing
  # Stae zdefiniowane w module nadrzdnym.
  A = B = "zdefiniowane w module nadrzdnym"
  class Local < Super
    include Included
    # Staa zdefiniowana lokalnie.
    A = "zdefiniowana lokalnie"
    # Lista przeszukiwanych moduw w kolejnoci przeszukiwania.
    # [Enclosing::Local, Enclosing, Included, Super, Object, Kernel]
    search = (Module.nesting + self.ancestors + Object.ancestors).uniq
    puts A  # Drukuje zdefiniowane lokalnie
    puts B  # Drukuje zdefiniowane w module nadrzdnym
    puts C  # Drukuje zdefiniowane w doczonym module
    puts D  # Drukuje zdefiniowane w nadklasie
    puts E  # Drukuje zdefiniowane na najwyszym poziomie
    puts F  # Drukuje zdefiniowane w module Kernel
  end
end

