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

Ruby object model

More Related Content

Viewers also liked

Similar to Ruby object model

More from Chamnap Chhorn

Recently uploaded

Ruby object model