Ruby object model

Chhorn Chamnap
Yoolk Mango
4 Aug 2010

 Basic Ruby
 Methods
 Classes
 Method-Access Rules
 What’s in an Object?
 Classes in Depth
 What Happens When You Call a Method?
 Module
 Constants
 Self
 Scope
 Singleton Method

 Local variables
 start with a lowercase letter or an underscore
Eg: x, string, __abc__, start_value, and firstName
 Ruby convention is to use underscores with multiple
words (first_name)
 can't start with an uppercase letter
 Instance variables
 storing information for individual objects
 always start with a single at-sign(@)
 can start with an uppercase letter

 Class variables
 store information per class hierarchy
 follow the same rules as instance variables
 start with two at-signs: @@running_total
 Global variables
 recognizable by their leading dollar sign ($)
 $:, $1, and $/, $stdin and $LOAD_PATH

 predefined, reserved terms associated with
specific programming tasks and contexts.
 def,
 class,
 if, and
 __FILE__

 Ruby interprets it as one of three things:
 A local variable
 A keyword
 A method call
 Here’s how Ruby decides:
1. If the identifier is a keyword, it’s a keyword.
2. If there’s an equal sign (=) to the right of the
identifier, it’s a local variable.
3. Otherwise, assumed to be a method call.

 When you load a file, Ruby looks for it in each of its
load path.
 The last directory is the current directory.
 load is a method.
 Load file from relative directories
 load "../extras.rb"
 load "/home/users/dblack/book/code/loadee.rb"
 A call to load always loads the file you ask for.
 Good to examine the effect of changes immediately.

 Doesn’t reload files if already loaded.
 require "loadee"
 require "/home/users/code/loadee"

 Follow the same rules and conventions as
local variables
 except, can end with ?, !, or =
 Methods are expressions that provide a value.
 In some contexts, you can’t tell, just by
looking at an expression.

 Ruby sees all data structures and values as
objects.
 x = "100".to_i(9)
 Methods can take arguments.
 Parentheses are usually optional.
 Many programmers use parentheses in most or all
method calls, just to be safe.

 Have to supply the correct number of
arguments.

 A method that allows any number of
arguments.

def multi_args(*x)
puts "I can take zero or more arguments!"
end

multi_args(1,2,4)
multi_args(1,2)

def default_args(a,b,c=1)
puts "Values of variables: ",a,b,c
end

default_args(3,2)

 Ruby tries to assign values to as many variables
as possible.
 The sponge parameters get the lowest priority.

 Required ones get priority, whether they
occur at the left or at the right of the list.
 All the optional ones have to occur in the
middle.

def broken_args(x,*y,z=1)
syntax error
end

 Classes define clusters of behavior or
functionality.
 Classes can respond to messages, just like
objects.
 Objects can change, acquiring methods and
behaviors that were not defined in their class.

 In Ruby, classes are objects.
 The new method is a constructor.
 Classes are named with constants.

 Ruby executed the code within the class just
as it would execute any other code.

 It’s possible to reopen a class and make
additions or changes.

 These methods defined inside a class.
 Used by all instances of the class.
 They don’t belong only to one object.

 Enables individual objects to remember state.
 Always start with @.
 Visible only to the object to which they
belong.
 Initialized in one method definition is the
same as in other method definitions.

 Define a special method called initialize.

 Ruby allows you to define methods that end
with an equal sign (=).
def price=(amount) ticket.price=(63.00)
@price = amount ticket.price = 63.00
end

 The attributes are implemented as reader
and/or writer methods.

 Ruby supports only single inheritance.
 Classes can import modules as mixins.
 The class Object is almost at the top of the
inheritance chart.

• Private methods can’t be called with an explicit receiver.

class Baker class Baker
def bake_cake def bake_cake
pour_flour pour_flour
add_egg add_egg
end end
def pour_flour private
end def pour_flour
def add_egg end
end def add_egg
private: pour_flour, end
:add_egg end
end

 It’s OK to use an explicit receiver for private
setter methods.

 The top-level method is stored as a private
instance method of the Object class.

 Every object is “born” with certain innate
abilities.
 object_id
 respond_to?
 send
 methods
 instance_variables

 Not uncommon to define a method called
send.
 Then, use __send__ instead.
 public_send, a safe version of send method.
 send can call an object’s private methods
public_send can’t.

 Every class is an instance of a class called
Class.
 You can also create a class the same way you
create most other objects.
my_class = Class.new
instance_of_my_class = my_class.new

 The class Class is an instance of itself.
 Object is a class, Object is an object.
 And Class is a class. And Object is a class, and
Class is an object.
 Which came first?
 Ruby has to do some of this chicken-or-egg stuff
in order to get the class and object system up and
running.

 Classes are objects.
 Instances of classes are objects, too.
 A class object has its own methods, its own
state, its own identity.

 When you call a method, Ruby does two
things:
 It finds the method (method lookup).
 It executes the method. (find self).

 “one step to the right, then up.”

 How objects call their methods?
 From their class
 From the superclass and earlier ancestors of their
class
 From their own store of singleton methods
 Instances of Class can call methods that are
defined as instance methods in their class.
 Class defines an instance method called new.
Ticket.new

 The class Class has two new methods as:
 a class method; Class.new
 an instance method; Ticket.new
 Instances of Class have access to the instance
methods defined in Module.
class Ticket
attr_reader :venue, :date
attr_accessor :price

 Modules are bundles of methods and
constants.
 Modules don’t have instances.
 Consists of the functionality to be added to a
class or an object.
 Modules encourage modular design.
 Modules are the more basic structure, and
classes are just a specialization.

 Modules get mixed in to classes, using the
include method, referred to as mix-ins.
 The instances of the class have the ability to
call the instance methods defined in the
module.
 A class can mix in more than one module.

 To resolve a message into a method:
 Its class
 Modules mixed into its class
 The class’s superclass
 Modules mixed into the superclass
 Likewise, up to Object (and its mix-in Kernel) and
BasicObject

 Define a method twice inside the same class,
the second definition takes precedence.
class D
def hello
puts “hello”
end
end

class D
def hello
puts “hello world”
end
end

 If the object’s method-lookup path includes
more than two same methods, the first one is
the “winner”.

 A class mixes in two or more modules.
 The modules are searched in reverse order of
inclusion

class C
include M
include N
include M
end

 Re-including a module doesn’t do anything.
 N is still considered the most recently
included module.

 Use the super keyword to jump up to the
next-highest definition, in the method-
lookup path.

 The way super handles arguments:
 Called with no argument list – super
 Called with an empty argument list – super()
 Called with specific arguments – super(a,b,c)

 The Kernel module provides an instance method called
method_missing.

 Nested module/class chains are used to
create namespaces for classes, modules, and
methods.
module Tools
class Hammer
end
End

h = Tools::Hammer.new

 Begin with an uppercase letter.
eg: A, String, FirstName, and STDIN
 (FirstName) or (FIRST_NAME) is usual.
 Can be referred to from inside the instance or
class methods.

 You get a warning if you reassign to the
constant.

 To modify a constant, use a variable instead.

 not redefining a constant,
 good for reloading program files

 Constants have a kind
of global visibility or
reachability.
 Bears a close
resemblance to
searching a filesystem.

 Like /, the :: means “start from the top level.”

 At every moment, only one object is playing
the role of self.
 Self is the default object or current object.
 To know which object is self, you need to
know what context you’re in.

 But what is self when you haven’t yet entered
any definition block?
 The answer is that Ruby provides you with a start-
up self at the top level.
ruby -e 'puts self'

 main is a special term that the default self
object.
 The keyword (class, module, or def) marks a
switch to a new self.

 In a class or module definition, self is the class
or module object.

 In a method definition, self is the object that
called it.

 When a singleton method is executed, self is
the object that owns the method.

 If the receiver of the message is self, you can
omit the receiver and the dot.

 If both a method and a variable of a given
name exist (talk), the variable takes
precedence.
 To force Ruby to see as a method name, you’d
have to use self.talk or talk().
 To call a setter method, have to supply
object-dot-notation.
self.first_name = “dara”
first_name = “dara”

 Every instance variable belongs to self.

 Scope refers to the reach or visibility of
variables and constants.
 Three types of variables: global, local, and
class variables.

 Global scope is scope that covers the entire
program.
 Global scope is enjoyed by global variables.

 Local scope is a basic layer of every Ruby
program.
 Every time you cross into a class, module, or
def keyword, you start a new local scope.
 The top level has its own local scope.
 Every class or module definition block has its own
local scope.
 Every method definition has its own local scope.

 Provides a storage mechanism shared
between a class and its instances.
 Visible only to a class and its instances.

 They’re class-hierarchy variables.

 Let’s say we’ve created our Ticket class.
 Ticket isn’t only a class.
 Ticket is also an object in its own right.

 defined directly on the class object Ticket.
 referred to as a class method of the class.

 Where do singleton methods live?
 The singleton class
 Every object has two classes:
 The class of which it’s an instance
 Its singleton class

 Singleton classes are anonymous.
 The << object notation means the anonymous,
singleton class of object.

 The Well-Grounded Rubyist, David A. Black
 Metaprogramming Ruby, Paolo Perrotta

Ruby object model

More Related Content

Viewers also liked (19)

Similar to Ruby object model (20)

More from Chamnap Chhorn (7)

Recently uploaded (20)

Ruby object model