This document summarizes a presentation about saying goodbye to procedural programming and introducing the Trailblazer framework. Key points include: - Trailblazer extends the basic MVC pattern with new abstractions like operations and steps to encapsulate business logic in a declarative way. - Operations can be tested independently by passing parameters and validating outputs. Failure handling is also supported. - The framework provides dependency injection so business logic can access objects like the current user without direct coupling. - Common patterns like validation and authorization can be abstracted into reusable steps. - While more complex initially, the document argues Trailblazer results in cleaner, more modular code compared to nested conditional logic in traditional controllers and services

1. SAY GOODBYE TO
PROCEDURAL*
PROGRAMMING
ANOTHER USELESS PRESENTATION
BROUGHT TO YOU BY @APOTONICK

2. SAY GOODBYE TO
PROCEDURAL*
PROGRAMMING
* AS WE KNOW IT.

4. <wrong>

5. REVEAL.JS
AND HOW TO MASTER IT, PART I OF VIII

6. [ ] DIAGRAMS
[ ] 6 MEMES
[ ] 2 BULLET POINT LISTS
[ ] QUOTE FROM SOMEONE
[ ] MORE DIAGRAMS
[ ] TRUCKLOADS OF CODE (you wanted it)

7. [ ] DIAGRAMS
[ ] 6 MEMES
[x ] 2 BULLET POINT LISTS
[ ] QUOTE FROM SOMEONE
[ ] MORE DIAGRAMS
[ ] TRUCKLOADS OF CODE (you wanted it)

12. class Post < ActiveRecord::Base
validates :body, presence:true
validates :author, presence:true
after_save :notify_moderators!, if: :create?
end

13.
class PostsController < ApplicationController
def create
return unless can?(current_user, Post, :new)
post = Post.new(author: current_user)
if post.update_attributes(
params.require(:post).permit(:title)
)
post.save
notify_current_user!
else
render :new
end
end
end

24. Let's not talk
about persistence!
Let's not talk
about business logic!
Let's not talk
about views!

26. I SAID: RAILS VIEWS!

29. Notes:
let's come back to the problems in our example it's
hard to understand what we are trying to do and:

30. HOW DO I
TEST THAT?

31. class Post < ActiveRecord::Base
validates :body, presence:true
validates :author, presence:true
after_save :notify_moderators!, if: :create?
end
describe Post do
it "validates and notifies moderators" do
post = Post.create( valid_params )
expect(post).to be_persisted
end
end

32. class Post < ActiveRecord::Base
validates :body, presence:true
validates :author, presence:true
after_save :notify_moderators!, if: :create?
end
describe Post do
it "validates and notifies moderators" do
post = Post.create( valid_params )
expect(post).to be_persisted
end
end

33. it do
controller = Controller.new
controller.create( valid_params )
expect(Post.last).to be_persisted
end

35. describe BlogPostsController do
it "creates BlogPost model" do
post :create, blog_post: valid_params
expect(response).to be_ok
expect(BlogPost.last).to be_persisted
end
end

37. ...THINKING...

38. ...THINKING...

42. [...] It extends the basic MVC pattern
with new abstractions.

43. NO!

48. class MyService
def self.call(args)
# do something here
end
end
MyService.( valid_params )

49. Notes: we don't need any domain logic, that's very
user specific and shouldn't be dictated by "my
framework"

50. class MyService
def call(params)
return unless can?(current_user, Post, :new)
post = Post.new(author: current_user)
post.update_attributes(
params.require(:post).permit(:title)
)
if post.save
notify_current_user!
end
end
end

52. [ ] DIAGRAMS
[x] 6 MEMES
[x ] 2 BULLET POINT LISTS
[ ] QUOTE FROM SOMEONE
[ ] MORE DIAGRAMS
[ ] TRUCKLOADS OF CODE (you wanted it)

53. class MyService
def call(params)
return unless can?(current_user, Post, :new)
post = Post.new(author: current_user)
post.update_attributes(
params.require(:post).permit(:title)
)
if post.save
notify_current_user!
end
end
end

54. TEST
it do
service = MyService.new
service.call( valid_params )
expect(Post.last).to be_persisted
end

55. HAPPY!

56. ...THINKING...

57. SERVICE OBJECTS, REVISITED
[x] Encapsulation
[x] Testing
[ ] What to return?
[ ] Validations extracted?
[ ] Extendable
class MyService
def call(params)
end
end

58. Is the problem the
procedural* code design?

63. AND THAT'S TRB.
THANK YOU!

64. QUESTIONS?

65. OK, I GOT
A QUESTION
THEN:

66. DO YOU WANT
SOME CODE?

67. DO YOU WANT
SOME CODE?

68. NO?

69. class Create < Trailblazer::Operation
#
#
#
end

70. class BlogPost::Create < Trailblazer::Operation
#
#
#
end

71. class Create < Trailblazer::Operation
#
#
#
end

72. class Create < Trailblazer::Operation
def process(params)
# sam's code here
end
end

73. Notes: not really extendable

74. class Create < Trailblazer::Operation
def process(params)
return unless can?(current_user, Post, :new)
post = Post.new(author: current_user)
post.update_attributes(
params.require(:post).permit(:title)
)
if post.save
notify_current_user!
end
end
end

75. class Create < Trailblazer::Operation
#
#
#
end
result = Create.()
result.success? #=> true

76. Notes:
Hooray, we have an API for service objects!

77. HOORAY, A
SERVICE
OBJECT
API!

78. class Create < Trailblazer::Operation
#
#
#
#
end

79. class Create < Trailblazer::Operation
step :create_model!
step :validate!
step :save!
step :notify_current_user!
end

82. class Create < Trailblazer::Operation
step :create_model!
step :validate!
step :save!
step :notify_current_user!
end

83. class Create < Trailblazer::Operation
step :create_model!
#
#
#
#
end

84. class Create < Trailblazer::Operation
step :create_model!
def create_model!(options, **)
end
end

85. CREATE MODEL
class Create < Trailblazer::Operation
step :create_model!
def create_model!(options, **)
options["model"] = BlogPost.new
end
end
result = Create.()
result.success? #=> true
result["model"] #=> #<BlogPost id:nil, ..>

86. VALIDATE
class Create < Trailblazer::Operation
step :create_model!
step :validate!
def create_model!(options, **)
# ..
def validate!(options, params:, **)
# validate params
end
end

87. valid_params = { body: "Blogging's fun. #not" }
Create.( valid_params )
class Create < Trailblazer::Operation
# ..
def validate!(options, params:, **)
params #=> { body: "Blogging's fun. #not" }
end
end

88. Notes: sending params into the op

89. class Create < Trailblazer::Operation
# ..
def validate!(options, params:, **)
model = options["model"] # from the create_model! step...
if model.update_attributes(params)
true
else
false
end
end
end

90. class Create < Trailblazer::Operation
# ..
def validate!(options, params:, model:, **)
#
#
if model.update_attributes(params)
true
else
false
end
end
end

94. #class Create < Trailblazer::Operation
# ..
def validate!(options, params:, model:, **)
if model.update_attributes(params)
true
else
false
end
end
#end

95. #class Create < Trailblazer::Operation
# ..
def validate!(options, params:, model:, **)
#
#
#
#
model.update_attributes(params)
end
#end

98. class Create < Trailblazer::Operation
step :create_model!
step :validate!
step :save!
#
#
#
#
#
#
end

99. class Create < Trailblazer::Operation
step :create_model!
step :validate!
step :save!
#def create_model!(options, **)
#def validate!(options, params:, **)
def save!(options, params:, model:, **)
true
end
end

102. class Create < Trailblazer::Operation
step :create_model!
step :validate!
step :save!
step :notify!
#def create_model!(options, **)
#def validate!(options, params:, **)
#def save!(options, params:, model:, **)
def notify!(options, model:, **)
MyMailer.call(model)
end
end

103. HAPPY
TIMES!

104. ... AND WHEN
THINGS
GO WRONG?

106. class Create < Trailblazer::Operation
step :create_model!
step :validate!
step :save!
step :notify!
#def create_model!(options, **)
#def validate!(options, params:, **)
#def save!(options, params:, model:, **)
#def notify!(options, model:, **)
end

107. class Create < Trailblazer::Operation
step :create_model!
step :validate! [XXX]
step :save!
step :notify!
#def create_model!(options, **)
#def validate!(options, params:, **)
#def save!(options, params:, model:, **)
#def notify!(options, model:, **)
end

110. #class Create < Trailblazer::Operation
# ..
def validate!(options, params:, model:, **)
model.update_attributes(params) #=> false
end
#end

114. class Create < Trailblazer::Operation
step :create_model!
step :validate!
step :save!
step :notify!
failure :handle!
#..
end

115. class Create < Trailblazer::Operation
step :create_model!
step :validate!
step :save!
step :notify!
failure :handle!
#..
def handle!(options, **)
options["error"] = "don't cry!"
end
end

116. result = Create.( { title: nil } )
result.success? #=> false
result["error"] = "don't cry!"

117. RAILWAYS
ROCK!

118. BUT ISN'T THAT
SUPER
COMPLEX?

119. DUDE.

121. Notes: do you find this more complex than this?

122. class MyService
def call(params)
return unless can?(current_user, Post, :new)
post = Post.new(author: current_user)
if post.update_attributes(
params.require(:post).permit(:title)
)
unless notify_current_user!
if ...
else
end
end
end

123. class Create < Trailblazer::Operation
step :create_model!
step :validate!
step :save!
step :notify!
failure :handle!
# ..
end

124. def create_model!(options, **)
def validate!( options, params:, **)
def save!( options, params:, model:, **)
def notify!( options, model:, **)

125. result = Create.( { title: nil } )
result.success? #=> false
result["error"] #=> "don't cry!"
result["model"] #=> #<BlogPost title: nil>

126. TEST
it "fails with empty title" do
result = Create.( { title: nil } )
expect(result).to be_success
expect(result["error"]).to eq("don't cry!")
expect(result["model"]).to be_persisted
end

127. rspec-trailblazer
minitest-trailblazer

130. Notes:
validations still in model

131. class PostsController < ApplicationController
def create
return unless can?(current_user, Post, :new)
post = Post.new(author: current_user)
if post.update_attributes(
params.require(:post).permit(:title))
notify_current_user!
else
render :new
end
end
end

132. class PostsController < ApplicationController
def create
return unless can?(current_user, Post, :new)
#
#
#
result = BlogPost::Create.( params )
if result.failure?
render :new
end
end
end

133. AUTHORIZATION
def create
return unless can?(current_user, Post, :new)
# ..

134. class Create < Trailblazer::Operation
step :authorize!
#step :create_model!
#step :validate!
#step :save!
#step :notify!
#failure :handle!
# ..
end

135. class Create < Trailblazer::Operation
step :authorize!
# ..
def authorize!(options, current_user:, **)
CouldCould.can?(current_user, Post, :new)
end
end

136. CURRENT WHAT?

137. def authorize!(options, current_user:, **)
CouldCould.can?(
current_user, # wtf?
Post, :new
)
end

138. class PostsController < ApplicationController
def create
return unless can?(current_user, Post, :new)
result = BlogPost::Create.( params )
#
#
#
if result.failure?
render :new
end
end
end

139. class PostsController < ApplicationController
def create
return unless can?(current_user, Post, :new)
result = BlogPost::Create.(
params,
"current_user" => current_user
)
if result.failure?
render :new
end
end
end

140. class PostsController < ApplicationController
def create
#return unless can?(current_user, Post, :new)
#
result = BlogPost::Create.(
params,
"current_user" => current_user
)
if result.failure?
render :new
end
end
end

141. class PostsController < ApplicationController
def create
result = BlogPost::Create.(
params,
"current_user" => current_user
)
if result.failure?
render :new
end
end
end

142. class PostsController < ApplicationController
def create
run BlogPost::Create, "current_user" => current_user do
return
end
render :new
end
end

143. class PostsController < ApplicationController
def create
run BlogPost::Create do
return
end
render :new
end
end

144. class PostsController < ApplicationController
def create
run BlogPost::Create do |result|
return redirect_to blog_post_path(result["model"].id)
end
render :new
end
end

145. class PostsController < ApplicationController
def create
run BlogPost::Create do |result|
return redirect_to blog_post_path(result["model"
end
render :new
end
end

146. DEPENDENCY INJECTION
it "works with current_user" do
result = Create.(
valid_params,
"current_user" => User.find(1) )
# ..
end

149. class Create < Trailblazer::Operation
step :authorize!
# ..
def authorize!(options, current_user:, **)
CouldCould.can?(current_user, Post, :new)
end
end

150. class Create < Trailblazer::Operation
step MyAuth
# ..
class MyAuth
def self.call(options, current_user:, **)
CouldCould.can?(current_user, Post, :new)
end
end
end

151. class Create < Trailblazer::Operation
step MyAuthCallableSittingSomewhere
# ..
#class MyAuth
# def self.call(options, current_user:, **)
# CouldCould.can?(current_user, Post, :new)
# end
#end
end

152. DYI SUCKS

153. class Create < Trailblazer::Operation
step Policy::CanCan( Post, :new )
# step :model!
# ..
end

156. VALIDATIONS:
A STORY OF MANKIND

158. class Post < ActiveRecord::Base
validates :title, presence:true
validates :body, presence:true
#after_save :notify_moderators!, if: :create?
end

159. module BlogPost
module Contract
class Create::Create < Reform::Form
property :title
property :body
validates :title, presence:true
validates :body, presence:true
end
end
end

160. class Create < Trailblazer::Operation
step Policy::CanCan( Post, :new )
step :model!
step :validate!
step :notify!
# ..
def model!(options, **)
def validate!(options, **)
# ..
end

161. class Create < Trailblazer::Operation
step Policy::CanCan( Post, :new )
step :model!
step Contract::Build( constant: Contract::Create )
step Contract::Validate()
step Contract::Persist()
step :notify!
# ..
def model!(options, **)
# ..
end

166. BPMN

172. class Create < Trailblazer::Operation
step :create_model!
step :validate!
step :save!
step :notify!
failure :handle!
# ..
end

174. result = Create.(
params,
"current_user" => ..
)

175. SAY GOODBYE TO
PROCEDURAL*
PROGRAMMING
* AS WE KNOW IT.

176. Trailblazer is awesome!
-- Someone

177. [ ] DIAGRAMS
[x] 6 MEMES
[xX] 2 BULLET POINT LISTS
[x] QUOTE FROM SOMEONE
[x] MORE DIAGRAMS
[ ] TRUCKLOADS OF CODE (you wanted it)

178. @APOTONICK
❤