If you are

1. A limited guide to intermediate and
advanced Ruby
- Vysakh Sreenivasan (vysakh0)

2. Variables store only
references to objects.

4. So, use dup or clone

5. scan & match

6. match returns the first match.
scan returns all matches

7. (g - global)
gsub and sub

8. >> "hello".sub('l', '*')
=> "he*lo"
>> "hello".gsub('l', '*')
=> "he**o"

9. (when working in irb or pry)
semicolon ;

10. [82] pry(main)> a = [1, 2, 3]
=> [1, 2, 3]
[83] pry(main)> a = [1, 2, 3] ;
[84] pry(main)>
Does not print output of the statement

11. Spaceship operator
<=>

12. a <=> b :=
if a < b then return -1
if a = b then return 0
if a > b then return 1
if a and b are not comparable then return
nil

13. [1,3,2] <=> [2,2,2]
- Ruby will start comparing each element of
both array from left hand side.
- 1 of left array is smaller than 2 of right
array.
- Hence left array is smaller than right array.
Output will be -1.

14. case subsumption operator or case
equality operator
===

15. - "If I have a drawer labelled a would it
make sense to put b in that drawer?"
- The main usage for the === operator is in
case expressions
a === b

16. case a
when b
end
# Here b === a check is made in when
# not b == a

17. Diff between a == b and a === b
- (a == b) and (b == a) is always the same
- (a === b) and (b === a) is not always the
same
Integer === 2 #true
2 === Integer #false

18. splat

19. Accept variable length arguments

20. Unwrap from array and pass as args

21. Coerce values into array
coerced = *"Hello World"
p coerced
# => ["Hello World"]
coerced = *nil
p coerced
# => []
coerced = *(1..3)
p coerced
# => [1, 2, 3]

22. Deconstruct array
data = [1, 2, 3, 4]
first, *rest = data
puts "#{first}, #{rest}"
# => 1, [2, 3, 4]
*list, last = data
puts "#{list}, #{last}"
# => [1, 2, 3], 4
first, *center, last = data
puts "#{first}, #{center}, #{last}"
# => 1, [2, 3], 4

23. Double Splat
Similar to splat but for hashes in arg list

24. def double_splat(**hash)
p hash
end
double_splat()
# => {}
double_splat(a: 1)
# => {:a => 1}
double_splat(a: 1, b: 2)
# => {:a => 1, :b => 2}

25. def foo (args)
return args
end
h1 = { b: 2 }
h2 = { c: 3 }
foo(a: 1, **h1) # => {:a=>1, :b=>2}
foo(a: 1, **h1, **h2) # => {:a=>1, :b=>2, :c=>3}
foo(a: 1, h1) # Syntax Error: syntax error, unexpected ')', expecting =>
foo(h1, h2) # ArgumentError: wrong number of arguments (2 for 1)

26. We just used double splat to capture all
keyword arguments

27. def join_array(arr, elements: , by_char: ‘,’)
arr.take(elements).join(by_char)
end
a = [20, 30, 10, 40]
# optional if there is default set in parameters, in this case it is by_char
p join_array(a, elements: 3)
p join_array(a, elements: 2, by_char: ‘-’)
# order not important
p join_array(a, by_char: ‘-’, elements: 3)

28. Damn! lambda is not rhyming! :/
blocks, procs and lambdas

29. Just passing around a chunk of code

30. def parrot(&what_human_said)
puts “Hey, I’m gonna say what you said”
what_human_said.call
puts “Thank you. Have a nice day”
end
parrot do
puts “I’m not Siri”
puts “I’m green, eeee”
end

31. &what_human_said
makes passed block changed to proc

32. Sorta like a magic :)
Ruby also lets us do it implicitly

33. def parrot
puts “Hey, I’m gonna say what you said”
yield
puts “Thank you. Have a nice day”
end
parrot do
puts “I’m not Siri”
puts “I’m green, eeee”
end

34. yield
- is not a method but a type.
- yield executes the block.
- faster than previous eg.

35. block_given? method of ruby

36. But, what is proc?
- an object
- with blocks of code
- bound to a set of local variables

38. lambda is just like proc but strict and nice
- lambda checks parameters passed to it
- lambda is not like that adamant child that
forces you out of the movie just because
he didn’t like it.

41. Symbol#to_proc

42. odd = proc { |x| x.odd? }
=> #<Proc:0xb8c1c6d8>
odd.call(2)
=> false
odd.call(3)
=> true

43. odd = :odd?.to_proc
=> #<Proc:0xb8c1c6d8>
odd.call(2)
=> false
odd.call(3)
=> true

44. Both these are equivalent
:odd?.to_proc #==> &:odd?
proc { |x| x.odd? }

45. Also note, these are same
1 + 2
#=> 3
1.send(:+, 2)
#=> 3

46. And so, this works too(equivalence)
:odd?.to_proc
proc { |x| x.send(:odd?) }

47. And hence, these are same :)
[“ruby”, “rails”, “thor”].map do |x|
x.reverse
end
[“ruby”, “rails”, “thor”].map(&:reverse)

48. Proc=== is an alias to Proc.
call

49. mul_of_3 = proc { |num| num % 3 == 0 }
mul_of_3.call(30) #=> true
mul_of_3 === 30 #=> true

50. # And so,
case 30
when mul_of_3
puts “Yayyy”
end
#=> Yayyy

51. Proc curry

52. - A curried proc receives some arguments.
- If a sufficient number of arguments are
supplied, it passes the supplied arguments
to the original proc and returns the result.

53. multiple = proc { |x, y| x * y }
multiple.call(2, 3) #=> 6
# here x = 2, y = 3
curry_multiple = multiple.curry
#=> curried the multiple proc

54. multiple_of_2 = curry_multiple.call(2)
# here x is 2, y is not yet passed
# when y is passed, the proc will
# get executed
multiple_of_2.call(3) #=> 6
# here x is 2, y is 3

55. multiply = proc { |*args| args.reduce(:*) }
multiply_2_nums = multiply.curry(2)
twice= multiply_2_nums.call(2)
twice.call(5) # => 10

56. methods

57. Assert if method exists

58. class Twitter
def tweet; end
end
t = Twitter.new
t.respond_to?(:tweet)
Twitter.method_defined?(:tweet)

59. making method object

60. def sum(a, b)
a + b
end
s = method(:sum)
s.methods # s is an object now :D
s.parameters
s.super_method
s.call(10, 20)

61. unbound method object

62. class Calc
def sum(a, b)
a + b
end
end
s = Calc.instance_method(:sum)
s.call(10, 20) # NoMethodError
s.bind(Calc.new).call(10, 20)

63. def palindrome?
self.reverse == self
end
pal = Object.instance_method :palindrome?
=> #<UnboundMethod: Object#palindrome?>
pal.bind("Madam").call
=> false
pal.bind("madam").call
=> true

64. You can also invoke a method by
s.send(:sum, 10, 20)
eval “s.sum(1, 2)”
# eval is not recommended, never use

65. defining methods
(different way)

66. class Order
define_method :total_for |quantity|
10 * quantity
end
end
Order.new.total_for(20)
#=> 200

67. undefining methods

68. class Order
define_method :total_for |quantity|
10 * quantity
end
undef_method :total_for
#just unlinks but is in memory
end

69. class Order
define_method :total_for |quantity|
10 * quantity
end
remove_method :total_for
#removes it totally
end

70. alias method

71. class Politics
def free_scheme
puts “Yo. Get lots of free stuff.”
end
alias_method :money_time, :free_scheme
end
Politics.new.free_scheme # what you see :P
Politics.new.money_time # what they see :P

72. method_missing
(Do not try this at your home/code)

73. not found is not an option for you
Use it only when method

75. method curry

76. def multiple(x, y)
x * y
end
curry_multiple = method(:multiple).curry
#=> curried the multiple method, got proc
twice = curry_multiple.call(2)
twice.call(3) #=> 6

77. Monkey patch
Open up classes and insert your own methods

78. class A
end
class A
def hello
“yolo”
end
end

79. class String
def palindrome?
self.reverse == self
end
end
# adds a method to the already existing String Class

80. Refinements

81. module Watson
refine String do
def palindrome?
self.reverse == self
end
end
end
“Ruby”.palindrome?
#=> NoMethodError: undefined method `palindrome?' for "Ruby":String
#Not available outside the namespace

82. module Watson
p “RoR”.palindrome?
end
module Sherlock
using Watson
p “RoR”.palindrome?
end

83. Objects

84. inherits from the class “Object”
Every object in Ruby by default

85. class Foo
end
class Foo < Object
end
Both these classes are identical

86. Even class is an object

87. Foo.is_a?(Object)
Foo.new.is_a?(Object)
Both these are Objects

88. Ancestry

90. class Elizabeth1; end
class Victoria < Elizabeth1
end
class Elizabeth2 < Victoria
end

92. Who was Elizabeth1’s
ancestor?

93. May be just another
human?

94. Then who was human’s
ancestor?

95. Some ape, duh!

96. The APE is the BasicObject
In Ruby, human is Object

98. Who is this kernel?

99. And there are qualities that got mixed into you
See, you are human, not ape

100. that is mixed into the “Object” class
Kernel is a module

101. Ya, modules are part of
ancestors

103. Singleton methods

105. And how did you define on an object?
But only classes has methods

106. a singleton class(invisible to you) for the object
You are right. Ruby makes
just to hold object specific methods

107. have singleton classes not only objects
You know what, even classes

108. class God
def self.true_me
“:troll_face:”
end
end
God.singleton_class
God.singleton_methods
God.singleton_method(:true_me).call
God.true_me

109. singleton class for the class just to hold
So, ruby makes a
class specific methods ?

110. Foo and Foo.new are objects
Wait, I remember you saying

111. the class to hold the class specific methods
So, actually ruby is making a singleton class for
just like it does for object because class is
also object?

113. invisible to the programmer.
AH! Yes! And The singleton class is typically
But you sorta see in one syntax, which is

114. class God
class << self
def self.true_me
“:troll_face:”
end
end
end

115. class << self is like class Singleton(self)
- You want to add a method just to a specific
object. (note: even class is an object)
- But you can’t write method to a object.
- So, you write method to object’s singleton
class like this.

116. class Human;end
matz = Human.new
class << matz
def write
puts “Writing the epic: Ruby”
end
end
matz.write

117. You can also define
Singleton methods by

118. class RubyLang; end
RubyLang.define_singleton_method(:minaswan) do
puts “Matz is nice and so we are nice”
end
RubyLang.minaswan

119. Ruby OO goodies

120. Yo = Class.new do
def ping
“hodor”
end
end
Yo.new.ping
A = Class.new
# proper class but..
a = Class.new
# an anonymous generic class

121. Struct is like class
with bundled accessor methods

122. Product = Struct.new(:name, :price)
pr = Product.new(“Book”, 20)
pr.name # attr_accessor out of box
pr.price = 10
pr.to_h #=> {:name=>”Book”, :price => 10}
a = *pr #=> [”Book”, 10]
Product = Struct.new(:name, :price) do
def title
“#{name} #{price}”
end
end

123. OpenStruct is like Struct
with more manipulation as if it is a hash

124. require ‘ostruct’
param = { name: “book”, price: 20 }
param_obj = OpenStruct.new(param)
param_obj.delivered = false
param_obj[:discount] = 5
param_obj.delete_field :delivered
param_obj.to_h

125. Delegator
Inherit it, and don’t write constructor as it
is already defined.

126. class CEO
attr_accessor :next_appointment
def fix_appointment(date)
next_appoinment = date
end
end

127. Ceo decides to hire a PA
and delegate some of her work to PA

128. require ‘delegate’
class CEO
attr_accessor :next_appointment
end
class PA < SimpleDelegator
def fix_appointment(date)
next_appoinment = date
end
end

129. elon_musk = CEO.new
elon_musk_pa = PA.new(elon_musk)
elon_musk_pa.fix_appointment(“7/6/2015”)
# you won’t know anything else about the ceo

130. Forwardable

131. require ‘forwardable’
class CEO
attr_accessor :availability, :office_mails
def phone_call
puts “Hi. How are you? How can I help you?”
yield
end
end

132. class PA
extend Forwardable
def_delegators :@ceo, :availability, :phone_call, :office_mails
def initialize(ceo)
@ceo = ceo
end
def check_my_mail(mail)
office_mails.include? (mail)
end
end

133. jack_ma = CEO.new(“Jack Ma”)
jack_ma_pa = PA.new(jack_ma)
jack_ma_pa.phone_call do
puts “Hello, mr.jack ma.”
end
jack_ma_pa.check_my_mail(1234)

134. Also look for other awesome classes
- Queue
- Stack
- Thread
- StringScanner

135. Manipulating variables
dynamically

136. class A
def initialize(foo)
@foo = foo
end
end
a = A.new (“cool”)
a.instance_variable_get “foo”
a.instance_variable_set :@foo, “hotl”
a.instance_variables

137. class A
@@b = 10
end
A.class_variable_get “b”
A.class_variables

138. const_get
class A
PI = 3.14
end
A.const_get “PI” # also there is const_set
#only works with the classes not with objects

139. Eval
The evil }:-D

140. (Ruby will run this string )
eval “puts ‘hello world’ “

141. instance_eval
evaluates string/block of code in the
context of the object

142. class Subject
def initialize(name)
@name
end
end
maths = Subject.new(“Mathematics”)
maths.name #=> ERROR
maths.instance_eval { @name } #=> “Mathematics”

143. # earlier we saw this code
class Human;end
matz = Human.new
class << matz
def write
puts “Writing the epic: Ruby”
end
end
matz.write

144. # Can also be written as
class Human;end
matz = Human.new
matz.instance_eval do
def write
puts “Writing the epic: Ruby”
end
end
matz.write

145. Since class is also an object
we can use instance_eval on it.

146. # we earlier saw this
class RubyLang; end
RubyLang.define_singleton_method(:minaswan) do
puts “Matz is nice and so we are nice”
end
RubyLang.minaswan

147. # Also can be written as
class RubyLang; end
RubyLang.instance_eval do
puts “Matz is nice and so we are nice”
end
RubyLang.minaswan

148. class_eval
evaluates string/block of code in the
context of the class

149. class Person; end
Person.new.name #=> ERROR
Person.class_eval do
attr_accessor :name
def trumpet
puts “Me..me...me… #{name}”
end
end
person = Person.new
person.name = “Narcissis”
person.trumpet

150. Modules
collection of methods and constants

151. module Mod
CONST = 1
def math
# ...
end
end
Mod.class #=> Module
Mod.constants #=> [:CONST]
Mod.instance_methods #=> [:math]

152. that you can use across multiple classes
Modules are about providing methods

153. - extend
- include
- prepend
- using (refinements)
We already saw about ‘using’

154. module Hipster
def flame_wars
puts “Yo, this lang is better, that lang is worse”
end
end
class Programmer
end
me = Programmer.new
me.extend Hipster
me.flame_wars

155. Can you guess where the
module methods were inserted for object?

156. extend just did that for us :)
To the singleton class of the object.

157. module Hipster
def flame_wars
puts “Yo, this lang is better, that lang is worse”
end
end
class HipsterProgrammer
extend Hipster
end
HipsterProgrammer.flame_wars

158. Yes. We inserted module methods to
the singleton class of class by using extend

159. What if we want to just insert
module methods to the class?

160. module Hipster
def flame_wars
puts “Yo, this lang is better, that lang is worse”
end
end
class HipsterProgrammer
include Hipster
end
me = HipsterProgrammer.new
me.flame_wars

161. class HipsterProgrammer
include Hipster
end
HipsterProgrammer.ancestors
# => [HipsterProgrammer, Hipster, …]
# NOTE: You are not inheriting here, but you are changing
# method lookup chain here

162. module Validations
def save
puts "validating model"
end
end
class Model
include Validations
def save
super
puts "saving model"
end
end

163. m = Model.new
m.save
#=> validating model
#=> saving model

164. prepend is just like include
But prepends itself first in the ancestors chain

165. module Friend
def opinion
puts "This would be best for you :) .."
end
end
class NormalPerson
include Friend
def opinion
puts "I think this would be best for me"
end
end

166. NormalPerson.ancestors
#=> [NormalPerson, Friend,...]
# This is the order of method look up
NormalPerson.new.opinion
#=> “I think this would be best for me”

167. - Though “opinion” method exists in both
classes
- it would start from the first of the ancestors
- i.e NormalPerson in our case

168. module Friend
def opinion
puts "This would be best for you :) .."
end
end
class BFF
prepend Friend
def opinion
puts "I think this would be best for me"
end
end

169. BFF.ancestors
#=> [Friend, BFF, ...]
# This is the order of method look up
BFF.new.opinion
#=> “This would be best for you :) ..”

171. double underscore basically indicates
"special/avoid overwrite”
__VALUE__

172. - In foo.rb, __FILE__ would be "foo.rb".
- If foo.rb were in the dir /home/vysakh
then File.dirname(__FILE__) would return
/home/vysakh.
__FILE__

173. if foo.rb were in the dir /home/vysakh then
__dir__ would return /home/vysakh.
__dir__

174. def foo
[__method__, __callee__]
end
alias bar foo
p foo #=> [:foo, :foo]
p bar #=> [:foo, :bar]
__callee__ and __method__

175. class Errand
def send
puts “Buy stuff”
end
def check
puts “checking…”
end
end
Errand.new.__send__(“check”)
use __send__ if the name send clashes with an existing method in obj

176. Also there are
__ENCODING__ (keyword)
__LINE__ (keyword)
__getobj__ (SimpleDelegator)
__setobj__ (SimpleDelegator)

177. Things we missed
- Operators like &&=, ||=, =~
- File operations
- System calls
- Enumerator methods
- threads
- exceptions, backtraces, benchmarking
- and many more, do check it out

178. Keep calm and write
Prose and Poetry using Ruby :)