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 Oniguruma 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. Photo By Mr. Christopher Thomas
Creative Commons Attribution-ShareALike 2.0 Generic License
Beneath the
Surface
Embracing the True Power of
Regular Expressions in Ruby
@nellshamrell

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
Onigmo
Fork

9. Onigmo
Reads
Regex

10. Onigmo
Reads
Regex
Abstract
Syntax
Tree
Parses
Into

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

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. In the
House
Out of
House
Annie the Dog
Door

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

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. f o r c e
/force/
“Use the force”
Path
Doesn’t
Match

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

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

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

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

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

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

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

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

33. Alternation
Photo By Shayan
Creative Commons Attribution Generic 2.0

34. /Y(olk|oda)/
Pipe

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

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

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

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

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

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

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

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

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

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

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

46. /No+/
Plus
Quantifier

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

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

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

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

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

52. Greedy quantifiers match
as much as possible

53. Greedy quantifiers use
maximum effort for
maximum return

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

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

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

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. /No+?/
Makes
Quantifier
Lazy

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

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

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

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

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

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

68. Greedy quantifiers are
greedy but reasonable

69. /.*moon/
Star
Quantifier

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

87. . m o o n
“That’s no moon”
. 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. N o
o
“Noooo”
/No+w+/
w
w

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

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

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

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

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

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

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

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

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

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

103. Possessive Quantifers

104. Possessive quantifiers
do not backtrack

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

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

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

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

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

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

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

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

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

114. Possessive quantifiers
fail faster by
controlling backtracking

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

118. snake_case to CamelCase

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

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

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

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

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

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

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

126. / /^
Anchors
Match To
Beginning Of
String

127. / / w^
Matches Any
Word
Character

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

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

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

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

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

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

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

135. Problem:
Matches Letters
AND Underscores
w^/ /

136. / /[a-z]^
Matches
Only
Lowercase
Letters

137. / /[a-z]^[^a-z]
Matches
everything
BUT
lowercase
letters

138. / /[a-z]^[^a-z]?
Makes
Character
Class
Optional

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

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

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

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

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

144. / /[a-z]^[^a-z]?

145. Pipe For
Alternation
| [a-z]/ /[a-z]^[^a-z]?

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

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

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

149. Remove underscores
snake_case to CamelCase

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

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

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

153. Matches
An
Underscore
/ /_

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

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

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

157. Combine results of two methods
snake_case to CamelCase

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

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

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

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

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

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

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

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

166. Develop regular expressions
in small pieces

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

169. Move beyond the fear

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