This is the final version of this talk, given at RubyConf 2013 Many of us approach regular expressions with a certain fear and trepidation, using them only when absolutely necessary. We can get by when we need to use them, but we hesitate to dive any deeper into their cryptic world. Ruby has so much more to offer us. This talk showcases the incredible power of Ruby and the Onigmo regex library Ruby runs on. It takes you on a journey beneath the surface, exploring the beauty, elegance, and power of regular expressions. You will discover the flexible, dynamic, and eloquent ways to harness this beauty and power in your own code.

1. Beneath the Surface
Regular Expressions in Ruby
@nellshamrell
Photo By Mr. Christopher Thomas
Creative Commons Attribution-ShareALike 2.0 Generic License

2. ^4[0-9]{12}(?:[0-9]{3})?$
Source: regular-expressions.info

3. We fear what we
do not understand

5. Regular
Expressions
+
Ruby
Photo By Shayan
Creative Commons Attribution-ShareALike 2.0 Generic License

6. Regex Matching in Ruby
Ruby
Methods
Onigmo

7. Onigmo

8. Oniguruma
Fork
Onigmo

9. Onigmo
Reads
Regex

10. Onigmo
Reads
Regex
Parses
Into
Abstract
Syntax
Tree

11. Onigmo
Series of
Instructions
Reads
Regex
Parses
Into
Compiles
Into
Abstract
Syntax
Tree

12. Finite State Machines
Photo By Felipe Skroski
Creative Commons Attribution Generic 2.0

13. A Finite State Machine
Shows How
Something Works

14. Annie the Dog

15. In the
House
Out of
House
Annie the Dog

16. Door
In the
House
Out of
House
Annie the Dog

17. Door
In the
House
Door
Out of
House
Annie the Dog

18. Finite
State
Machine

19. Finite
State
Machine

20. Finite
State
Machine

21. Multiple States

22. /force/

23. re = /force/
string = “Use the force”
re.match(string)

24. “Use the force”
f
o
r
Path
Doesn’t
Match
/force/
c
e

25. “Use the force”
f
o
r
Still
Doesn’t
Match
/force/
c
e

26. “Use the force”
f
o
(Fast Forward)
r
Path
Matches!
/force/
c
e

27. “Use the force”
f
o
r
/force/
c
e

28. “Use the force”
f
o
r
/force/
c
e

29. “Use the force”
f
o
r
/force/
c
e

30. “Use the force”
f
o
r
/force/
c
e

31. “Use the force”
f
o
r
c
We Have
A Match!
/force/
e

32. re = /force/
string = “Use the force”
re.match(string)
=> #<MatchData “force”>

33. Alternation
Photo By Shayan
Creative Commons Attribution Generic 2.0

34. Pipe
/Y(olk|oda)/

35. re = /Y(olk|oda)/
string = “Yoda”
re.match(string)

36. “Yoda”
o
Y
o
l
k
d
a
/Y(olk|oda)/

37. Which To
Choose?
“Yoda”
o
Y
o
l
k
d
a
/Y(olk|oda)/

38. Saves To
Backtrack
Stack
“Yoda”
o
Y
o
l
k
d
a
/Y(olk|oda)/

39. Uh Oh,
No Match
“Yoda”
o
Y
o
l
k
d
a
/Y(olk|oda)/

40. Backtracks
To Here
“Yoda”
o
Y
o
l
k
d
a
/Y(olk|oda)/

41. “Yoda”
o
Y
o
l
k
d
a
/Y(olk|oda)/

42. “Yoda”
o
Y
o
l
k
d
a
/Y(olk|oda)/

43. “Yoda”
o
Y
o
l
k
d
a
We Have
A Match!
/Y(olk|oda)/

44. re = /Y(olk|oda)/
string = “Yoda”
re.match(string)
=> #<MatchData “Yoda”>

45. Quantifiers
Photo By Fancy Horse
Creative Commons Attribution Generic 2.0

46. Plus
Quantifier
/No+/

47. re = /No+/
string = “Noooo”
re.match(string)

48. “Noooo”
o
N
o
/No+/

49. “Noooo”
o
N
o
/No+/

50. “Noooo”
o
N
o
Return
Match?
Or Keep
Looping?
/No+/

51. “Noooo”
o
N
o
Greedy
Quantifier
/No+/
Keeps
Looping

52. Greedy quantifiers match
as much as possible

53. Greedy quantifiers use
maximum effort for
maximum return

54. “Noooo”
o
N
o
/No+/

55. “Noooo”
o
N
o
/No+/

56. “Noooo”
o
N
o
We Have
A Match!
/No+/

57. re = /No+/
string = “Noooo”
re.match(string)
=> #<MatchData “Noooo”>

58. Lazy Quantifiers

59. Lazy quantifiers match
as little as possible

60. Lazy quantifiers use
minimum effort for
minimum return

61. Makes
Quantifier
Lazy
/No+?/

62. re = /No+?/
string = “Noooo”
re.match(string)

63. “Noooo”
o
N
o
/No+?/

64. “Noooo”
o
N
o
/No+?/

65. “Noooo”
o
N
o
Return
Match?
Or Keep
Looping?
/No+?/

66. “Noooo”
o
N
o
We Have
A Match!
/No+?/

67. re = /No+?/
string = “Noooo”
re.match(string)
=> #<MatchData “No”>

68. Greedy quantifiers are
greedy but reasonable

69. Star
Quantifier
/.*moon/

70. re = /.*moon/
string = “That’s no moon”
re.match(string)

71. “That’s no moon”
.
m
o
o
.
/.*moon/
n

72. “That’s no moon”
.
m
o
o
.
/.*moon/
n

73. “That’s no moon”
.
m
.
o
o
Loops
/.*moon/
n

74. “That’s no moon”
.
m
.
(Fast Forward)
o
o
Which To
Match?
/.*moon/
n

75. “That’s no moon”
.
m
.
o
o
Keeps
Looping
/.*moon/
n

76. “That’s no moon”
.
m
.
o
o
Keeps
Looping
/.*moon/
n

77. “That’s no moon”
.
m
.
o
o
Keeps
Looping
/.*moon/
n

78. “That’s no moon”
.
m
o
No More
Characters?
o
.
/.*moon/
n

79. “That’s no moon”
.
m
.
o
o
n
Backtrack or Fail?
/.*moon/

80. “That’s no moon”
.
m
Backtracks
o
o
.
/.*moon/
n

81. “That’s no moon”
.
m
Backtracks
o
o
.
/.*moon/
n

82. “That’s no moon”
.
m
Backtracks
o
o
.
/.*moon/
n

83. “That’s no moon”
.
Backtracks
m
.
o
o
Huzzah!
/.*moon/
n

84. “That’s no moon”
.
m
o
o
.
/.*moon/
n

85. “That’s no moon”
.
m
o
o
.
/.*moon/
n

86. “That’s no moon”
.
m
o
o
.
/.*moon/
n

87. “That’s no moon”
.
m
o
o
.
n
We Have
A Match!
/.*moon/

88. re = /.*moon/
string = “That’s no moon”
re.match(string)
=> #<MatchData “That’s
no moon”>

89. Backtracking = Slow

90. /No+w+/

91. re = /No+w+/
string = “Noooo”
re.match(string)

92. “Noooo”
o
N
o
w
/No+w+/
w

93. “Noooo”
o
N
o
w
/No+w+/
w

94. “Noooo”
o
Loops
N
o
w
/No+w+/
w

95. “Noooo”
o
Loops
N
o
w
/No+w+/
w

96. “Noooo”
o
Loops
N
o
w
/No+w+/
w

97. “Noooo”
o
N
o
w
/No+w+/
Uh Oh
w

98. “Noooo”
o
N
o
Uh Oh
w
w
Backtrack or Fail?
/No+w+/

99. “Noooo”
Backtracks
N
o
o
w
/No+w+/
w

100. “Noooo”
o
Backtracks
N
o
w
/No+w+/
w

101. “Noooo”
o
Backtracks
N
o
w
/No+w+/
w

102. “Noooo”
o
N
o
w
Match FAILS
/No+w+/
w

103. Possessive Quantifers

104. Possessive quantifiers
do not backtrack

105. Makes
Quantifier
Possessive
/No++w+/

106. “Noooo”
o
N
o
w
/No++w+/
w

107. “Noooo”
o
N
o
w
/No++w+/
w

108. “Noooo”
o
Loops
N
o
w
/No++w+/
w

109. “Noooo”
o
Loops
N
o
w
/No++w+/
w

110. “Noooo”
o
Loops
N
o
w
/No++w+/
w

111. “Noooo”
o
N
o
w
/No++w+/
w

112. “Noooo”
o
Loops
N
o
Uh Oh
w
w
Backtrack or Fail?
/No++w+/

113. “Noooo”
o
N
o
w
Match FAILS
/No++w+/
w

114. Possessive quantifiers
fail faster by
controlling backtracking

115. Use possessive quantifers
with caution

117. Tying It All Together
Photo By Keith Ramos
Creative Commons Attribution 2.0 Generic

119. snake_case to CamelCase

120. snake_case to CamelCase
Find first letter of string and
capitalize it

121. snake_case to CamelCase
Find first letter of string and
capitalize it
Find any character that follows
an underscore and capitalize it

122. snake_case to CamelCase
Find first letter of string and
capitalize it
Find any character that follows an
underscore and capitalize it
Remove underscores

123. snake_case to CamelCase
Find first letter of string and
capitalize it

124. case_converter_spec.rb
before(:each) do
@case_converter = CaseConverter.new
end
it ʺ″capitalizes the first letterʺ″ do
result = @case_converter
.upcase_chars(ʺ″methodʺ″)
result.should == ʺ″Methodʺ″
end

125. case_converter_spec.rb
before(:each) do
@case_converter = CaseConverter.new
end
it ʺ″capitalizes the first letterʺ″ do
result = @case_converter
.upcase_chars(ʺ″methodʺ″)
result.should == ʺ″Methodʺ″
end

126. case_converter_spec.rb
before(:each) do
@case_converter = CaseConverter.new
end
it ʺ″capitalizes the first letterʺ″ do
result = @case_converter
.upcase_chars(ʺ″methodʺ″)
result.should == ʺ″Methodʺ″
end

127. Anchors
Match To
Beginning Of
String
/ A /

128. Matches Any
Word
Character
/ Aw/

129. case_converter.rb
def upcase_chars(string)
re = / A w/
string.gsub(re){|char| char.upcase}
end

130. case_converter.rb
def upcase_chars(string)
re = / A w/
string.gsub(re){|char| char.upcase}
end

131. case_converter.rb
def upcase_chars(string)
re = / A w/
string.gsub(re){|char| char.upcase}
end
Spec Passes!

132. case_converter_spec.rb
it ʺ″capitalizes the first letterʺ″ do
result = @case_converter
.upcase_chars(ʺ″_methodʺ″)
result.should == ʺ″_Methodʺ″
end

133. case_converter_spec.rb
it ʺ″capitalizes the first letterʺ″ do
result = @case_converter
.upcase_chars(ʺ″_methodʺ″)
result.should == ʺ″_Methodʺ″
end

134. case_converter_spec.rb
it ʺ″capitalizes the first letterʺ″ do
result = @case_converter
.upcase_chars(ʺ″_methodʺ″)
result.should == ʺ″_Methodʺ″
end
Spec Fails!

135. Spec Failure:
Expected: ʺ″_Methodʺ″
Got: ʺ″_methodʺ″

136. Problem:
Matches Letters
AND Underscores
/ Aw/

137. Matches
Only
Lowercase
Letters
/ A[a-z]/

138. Matches an
underscore
/ A _ [a-z]/

139. Makes
underscore
optional
/ A _ ?[a-z] /

140. case_converter.rb
def upcase_chars(string)
re = / A _? [a-z] /
string.gsub(re){|char| char.upcase}
end

141. case_converter.rb
def upcase_chars(string)
re = / A _? [a-z] /
string.gsub(re){|char| char.upcase}
end
Spec Passes!

142. snake_case to CamelCase
Find any character that follows an
underscore and capitalize it

143. case_converter_spec.rb
it ʺ″capitalizes letters after an underscoreʺ″ do
result = @case_converter
.upcase_chars(ʺ″some_methodʺ″)
result.should == ʺ″Some_Methodʺ″
end

144. case_converter_spec.rb
it ʺ″capitalizes letters after an underscoreʺ″ do
result = @case_converter
.upcase_chars(ʺ″some_methodʺ″)
result.should == ʺ″Some_Methodʺ″
end

145. / A _ ?[a-z] /

146. Pipe For
Alternation
/ A _ ?[a-z]|[a-z] /

147. Look Behind
/ A _ ?[a-z]|(?<=_)[a-z] /

148. case_converter.rb
def upcase_chars(string)
re = / A _ ?[a-z] | (?<=_)[a-z] /
string.gsub(re){|char| char.upcase}
end

149. case_converter.rb
def upcase_chars(string)
re = / A _ ?[a-z] | (?<=_)[a-z] /
string.gsub(re){|char| char.upcase}
end
Spec Passes!

150. snake_case to CamelCase
Remove underscores

151. case_converter_spec.rb
it ʺ″removes underscoresʺ″ do
result = @case_converter
.rmv_underscores(ʺ″some_methodʺ″)
result.should == ʺ″somemethodʺ″
end

152. case_converter_spec.rb
it ʺ″removes underscoresʺ″ do
result = @case_converter
.rmv_underscores(ʺ″some_methodʺ″)
result.should == ʺ″somemethodʺ″
end

153. case_converter_spec.rb
it ʺ″removes underscoresʺ″ do
result = @case_converter
.rmv_underscores(ʺ″some_methodʺ″)
result.should == ʺ″somemethodʺ″
end

154. Matches
An
Underscore
/_ /

155. case_converter.rb
def rmv_underscores(string)
re = / _ /
string.gsub(re, “”)
end

156. case_converter.rb
def rmv_underscores(string)
re = / _ /
string.gsub(re, “”)
end

157. case_converter.rb
def rmv_underscores(string)
re = / _ /
string.gsub(re, “”)
end
Spec Passes!

158. snake_case to CamelCase
Combine results of two methods

159. case_converter_spec.rb
it ʺ″converts snake_case to CamelCaseʺ″ do
result = @case_converter
.snake_to_camel(ʺ″some_methodʺ″)
result.should == ʺ″SomeMethodʺ″
end

160. case_converter_spec.rb
it ʺ″converts snake_case to CamelCaseʺ″ do
result = @case_converter
.snake_to_camel(ʺ″some_methodʺ″)
result.should == ʺ″SomeMethodʺ″
end

161. case_converter_spec.rb
it ʺ″converts snake_case to CamelCaseʺ″ do
result = @case_converter
.snake_to_camel(ʺ″some_methodʺ″)
result.should == ʺ″SomeMethodʺ″
end

162. case_converter.rb
def snake_to_camel(string)
upcase_chars(string)
end

163. case_converter.rb
def snake_to_camel(string)
rmv_underscores( upcase_chars(string)
)
end

164. case_converter.rb
def snake_to_camel(string)
rmv_underscores( upcase_chars(string)
)
end
Spec Passes!

165. Code is available here:
https://github.com/nellshamrell/
snake_to_camel_case

166. Conclusion
Photo By Steve Jurvetson
Creative Commons Attribution Generic 2.0

167. Develop regular expressions
in small pieces

169. If you write code, you can
write regular expressions

170. Move beyond the fear

171. Nell Shamrell
Software Development Engineer
Blue Box
@nellshamrell
Resources: https://gist.github.com/
nellshamrell/6031738
Photo By Leonardo Pallotta
Creative Commons Attribution Generic 2.0