used to initialize other objects p String.kind_of? Class # => true p String.kind_of? Object # => true p Object.kind_of? Class # => true p Class.kind_of? Object # => true Classes
a class must be dictated by its public methods • Public methods must be stable to allow other objects to depend on them • Methods are public by default • Apply Information Hiding principle to anything that the public should not see • Use private and protected sections Classes
duck and quacks like a duck, it’s a duck! Rely on the object’s messages instead of the object type class Car attr_accessor :model, :owner def initialize(model, owner) @model = model @owner = owner end def label "this is #{owner.name} #{owner.surname}'s #{model}" end end batman = Person.new('Bruce', 'Wayne') Car.new('Batmobile', batman).label # => this is Bruce Wayne's Batmobile Dynamic Typing
:diesel end end class Car # code omitted def engine :diesel end protected :engine end • Any instance of the class can call protected methods on any other instances of the same class or subclass Methods
:turbo end end class Car # code omitted def engine :diesel end private :engine end • Can ‘only’ be called from within the class or any subclasses • In reality private and protected are not real limitation but ‘suggestions’ instead • Ruby still allows you to use :send method or alter the class at runtime > ferrari = Car.new > ferrari.send(:engine) # => :turbo Methods
ferrari.stubs(:color).returns(:red) ferrari.color #=> :red Stubs are a typical example of Singleton Methods • A Singleton Methods is a method that is defined for only one object instance ferrari = Car.new #=> <Car:0x001a901245> ferrari.color #=> undefined method ‘color’ for <Car:0x001a901245> Singleton Methods
= Car.new def ferrari.color :red end puts ferrari.color #=> :red # Option 2 ferrari = Car.new class << ferrari def color :red end end puts ferrari.color #=> :red Singleton Methods
end my_car = Car.new def my_car.describe_me "I'm #{self}, an instance of #{self.class}" end p my_car.describe_me #=> "I'm #<Car:0x007fc4dd21c6c8>, an instance of Car" class Car; end my_car = Car def my_car.describe_me "I'm #{self}, an instance of #{self.class}" end p my_car.describe_me #=> "I’m Car, an instance of Class" Singleton Methods
Car.describe_me "I'm #{self}, an instance of #{self.class}" end p Car.describe_me #=> "I’m Car, an instance of Class" class Car; end my_car = Car def my_car.describe_me "I'm #{self}, an instance of #{self.class}" end p my_car.describe_me #=> "I’m Car, an instance of Class" Singleton Methods
end my_car = Car.new class << my_car def describe_me "I'm #{self}, an instance of #{self.class}" end end p my_car.describe_me #=> "I'm #<Car:0x007fc4dd21c6c8>, an instance of Car" class Car; end my_car = Car class << my_car def describe_me "I'm #{self}, an instance of #{self.class}" end end p my_car.describe_me #=> "I’m Car, an instance of Class" Singleton Methods
class << Car def describe_me "I'm #{self}, an instance of #{self.class}" end end p Car.describe_me #=> "I’m Car, an instance of Class" class Car; end my_car = Car class << my_car def describe_me "I'm #{self}, an instance of #{self.class}" end end p my_car.describe_me #=> "I’m Car, an instance of Class" Singleton Methods
<< self def describe_me "I'm #{self}, an instance of #{self.class}" end end end p Car.describe_me #=> "I’m Car, an instance of Class" class Car; end class << Car def describe_me "I'm #{self}, an instance of #{self.class}" end end p Car.describe_me #=> "I’m Car, an instance of Class" Singleton Methods
self.describe_me "I'm #{self}, an instance of #{self.class}" end end end p Car.describe_me #=> "I’m Car, an instance of Class" class Car class << self def describe_me "I'm #{self}, an instance of #{self.class}" end end end p Car.describe_me #=> "I’m Car, an instance of Class" Singleton Methods
class << self attr_accessor :default_engine end attr_reader :name, :engine def initialize(name) @name = name @engine = Car.default_engine end end p Car.new(:bmw) #=> #<Car:0x007f995181b770 @name=:bmw, @engine=:petrol> Car.default_engine = :diesel p Car.new(:ferrari) #=> #<Car:0x007f995181b568 @name=:bmw, @engine=:diesel> class Car attr_accessor :engine end bmw = Car.new bmw.engine = :petrol p bmw.engine #=> :petrol Singleton Methods
results class ScanResult attr_reader :start_time, :end_time, :files, :product def initialize(params = {}) # some params initialization end # some code omitted... def total_time end_time - start_time end def detections_found? files.any?{ |f| f.detected? } end end Class Operators class ScannedFile attr_accessor :filename, :detection def initialize(params) @filename = params[:filename] @detection = params[:detection] end def detected? !detection.empty? end def remediated? # code omitted end # other code omitted... end class Product attr_reader :name, :version def initialize(params) @name = params[:name] @version = params[:version] end end
@name = name @songs = [] end def <<(song) @songs << song end def [](index) @songs[index] end end my_playlist = Playlist.new(‘Rock’) my_playlist << Song.new(‘Paranoid’) p my_playlist[0] # => Paranoid Other examples: def +(other); end def -(other); end Beware of the pitfalls… • A + B != B + A (e.g. Array – unless sorted) • A + B == B + A (e.g. Fixnum) Class Operators
@engine = engine @color = :black end def ==(other) return false unless other.instance_of?(self.class) engine == other.engine && color == other.color end def ===(other) puts 'in ===' self == other end end a = Car.new(engine: :diesel) b = Car.new(engine: :diesel) case a when b then puts “actually it matches ‘b’!” when nil then puts ‘it is nil’ else puts ‘it must be something else' end #=> in === #=> actually it matches ‘b’! • The use of === is generally rare to see in Ruby code • Mainly used for case statements Equality
= year @category = category end # code omitted... def hash year.hash ^ category.hash end def eql?(other) return false unless other.instance_of?(self.class) year == other.year && category == other.category end end • E.g. we have to override hash to return XOR of year and category hash values • We have to override eql? tell the Hash object which comparison algorithm to use catalog = {} car_1 = Car.new(engine: :diesel) car_id_1 = CarIdentifier.new(2016, :sport) catalog[car_id_1] = car_1 car_id_2 = CarIdentifier.new(2016, :sport) car_2 = catalog[car_id_2] #=> now it will return car_1 object! p car_id_1.hash #=> 9905875239901056 P car_id_2.hash #=> 9905875239901056 Equality
initialize(params) @engine = params[:engine] end def ==(other) return false unless other.kind_of?(self.class) self.engine == other.engine end end class RacingCar < Car # more specifications here... end Equality car_1 = Car.new(engine: :diesel) p car_1 car_2 = RacingCar.new(engine: :diesel) p car_2 p car_1 == car_2 #=> true p car_2 == car_1 #=> false
a single file module CarParts class Body attr_accessor :color, :model # code omitted... end class Engine attr_accessor :type, :capacity # code omitted... end class Wheel attr_accessor :size, :rim # code omitted... end end engine = CarParts::Engine.new • Or in separate files (recommended) # file: car_parts/body.rb module CarParts class Body attr_accessor :color, :model # code omitted... end end # file: car_parts/engine.rb module CarParts class Engine attr_accessor :type, :capacity # code omitted... end end # file: car_parts/wheel.rb module CarParts class Wheel attr_accessor :size, :rim # code omitted... end end Modules
organized but also help distinguish between homonym classes • Representing completely different entities car.body = CarParts::Body.new document.body = Document::Body.new • Representing same entity with different characteristics if OS.is_windows? Windows::ButtonRenderer else OSX::ButtonRenderer end os = if OS.is_windows? Windows else OSX end os::ButtonRenderer Modules
to somebody end end module Searcheable def search(phrase) # search in content end # maybe other types of search end module Binary def metadata # extract metadata end # other binary stuff end class HtmlFile include Shareable include Searcheable # other html-stuff... end class PdfFile include Shareable include Searcheable include Binary # other pdf stuff... end class ImageFile include Shareable include Binary # other image stuff... end Modules
in content end # maybe other types of search end class HtmlFile extend Searcheable # other html-stuff... end # inherits methods as class methods HtmlFile.search(phrase) Modules
enemies with fire balls end end class Hero attr_reader :name, :energy def initialize(name) @name = name @energy = 100 end # other code omitted... end mario = Hero.new(‘Super Mario’) # Mario eats the magic flower... mario.extends(FlowerPower) mario.fire_ball Modules
a method ⚫ When calling a method we may pass in some parameters and we don’t know what it does ⚫ When using a block we are in control of the flow with the parameters (if any) the block gives us – Although some logic may still be hidden by the block def do_nothing yield if block_given? end do_nothing do puts "Calling a block" end # or this do_nothing { puts "Calling a block" } def greetings_from_block yield("Mr. Block") if block_given? end greetings_from_block do |name| puts "Hello I’m #{name}" end #=> Hello I’m Mr. Block Blocks
@name = name @members = [] @projects = [] end def add_member(member) @members << member end def add_project(project) @projects << project end def each_member @members.each do |member| yield(member) end end # other stuff omitted... end qa_team = Team.new('Ops QA') qa_team.add_member('Mark Dy') qa_team.add_member('Marc LeDeroff' ) qa_team.add_member('Jenniffer SeeGo' ) qa_team.add_project('FPIR') qa_team.add_project('Eraser') qa_team.add_project('GVM') qa_team.each_member do |member| puts "#{member} is an #{qa_team.name} " end #=> Mark Dy is an Ops QA #=> Marc LeDeroff is an Ops QA #=> Jenniffer SeeGo is an Ops QA Blocks
initialize(name) @name = name @members = [] end def add_member(member) @members << member end # define method each to get the power # of Enumerable def each @members.each do |member| yield(member) end end # other stuff omitted... end qa_team = Team.new('Ops QA') qa_team.add_member('Mark Dy') qa_team.add_member('Marc LeDeroff' ) qa_team.add_member('Jenniffer SeeGo' ) p qa_team.count p qa_team.map{ |m| m.upcase } p qa_team.select{ |m| m.match(/^M/) } #=> 3 #=> ["MARK DY", "MARC LEDEROFF", "JENNIFFER SEEGO"] # => ["Mark Dy", "Marc LeDeroff"] Blocks
edit(document_name) with_logging('load') do @doc = Document.load(document_name) end # edit the content of document with_logging('save') { @doc.save } end def with_logging(event) begin @logger.debug("#{event} starting") yield @logger.debug("#{event} completed") rescue @logger.error("#{event} failed") raise end end end Blocks
:engine def initialize(name, params = {}) @name = name @color = params[:color] @engine = params[:engine] yield(self) if block_given? end end car = Car.new('ferrari', { color: 'red', engine: 'turbo' }) p car #=> #<Car:0x007f97d881b0d8 @name="ferrari", @color="red", @engine="turbo"> car = Car.new('ferrari') do |c| c.color = 'red' c.engine = 'turbo' end p car #=> #<Car:0x007f97d881aed0 @name="ferrari", @color="red", @engine="turbo"> Blocks
if block puts "after the block" end run_a_block do puts "a test block that does nothing" end #=> before the block #=> a test block that does nothing #=> after the block Blocks
= name @before_drive_listeners = [] @after_park_listeners = [] end def before_drive(&block) @before_drive_listeners << block end def after_park(&block) @after_park_listeners << block end def drive(destination) @before_drive_listeners.each do |b| b.call end puts "driving towards #{destination}" end def park puts "parking" @after_park_listeners.each do |b| b.call end end end car = Car.new('VW Beetle') car.before_drive { puts 'check tires pressure' } car.before_drive { puts 'set navigator' } car.after_park { puts 'lock car' } car.drive('New York') car.park #=> check tires pressure #=> set navigator #=> driving towards New York #=> parking #=> lock car Blocks
do puts 'check insurance validity' end def initialize(name) @name = name @before_drive_listeners = [DEFAULT_BEFORE_DRIVE] @after_park_listeners = [] end def before_drive(&block) @before_drive_listeners << block end def after_park(&block) @after_park_listeners << block end def drive(destination) @before_drive_listeners.each do |b| b.call end puts "driving towards #{destination}" end def park puts "parking" @after_park_listeners.each do |b| b.call end end end car = Car.new('VW Beetle') car.before_drive { puts 'check tires pressure' } car.before_drive { puts 'set navigator' } car.after_park { puts 'lock car' } car.drive('New York') car.park #=> check insurance validity #=> check tires pressure #=> set navigator #=> driving towards New York #=> parking #=> lock car Blocks
object which is slightly different than the Proc object generated by Proc.new (or &block) • What are the differences between lambda and Proc.new? • Parameters • Proc.new is more forgiving in the number of arguments we pass in • If too few will fill up the remaining arguments with nil • If too many will quietly ignore the arguments in excess • Lambda • Acts like a regular method → it will shout on wrong number of arguments • Behavior • Proc.new runs within the context of the caller (method/code) • Using next, return, break will have direct repercussion into the caller • Lambda runs in an isolated context exactly like a standard method • Using next, return, break will return from the block and no further Blocks
onk
yamanoku
nealle
kizawa2020
ezaki
namiki64
keeg
greenmidori
rfdnxbro
pfn
genda
riyaamemiya
mongodb
jakevdp
akashhashmi
sachag
mfonobong
madoxten
tammyeverts
philnash
soudai
sergeychernyshev
chriscoyier
katarinadahlin
![Ruby Mindset [email protected] Sr. Software Engineer](https://files.speakerdeck.com/presentations/311e6f7f532b404087daa18a5c0f2798/slide_0.jpg){kind=link}
