Module: Upkeep::Rails::Replay

Defined in:
lib/upkeep/rails/replay.rb

Defined Under Namespace

Classes: RackSession

Class Method Summary collapse

Class Method Details

.collect_response_body(body) ⇒ Object 



189
190
191
192
193
 
# File 'lib/upkeep/rails/replay.rb', line 189

def collect_response_body(body)
  body.each.to_a.join
ensure
  body.close if body.respond_to?(:close)
end

.constantize(name) ⇒ Object 



185
186
187
 
# File 'lib/upkeep/rails/replay.rb', line 185

def constantize(name)
  name.to_s.split("::").reduce(Object) { |namespace, constant_name| namespace.const_get(constant_name) }
end

.inferred_local_name(partial) ⇒ Object 



181
182
183
 
# File 'lib/upkeep/rails/replay.rb', line 181

def inferred_local_name(partial)
  File.basename(partial.to_s).sub(/\A_/, "").to_sym
end

.partial_path(template) ⇒ Object 



177
178
179
 
# File 'lib/upkeep/rails/replay.rb', line 177

def partial_path(template)
  template.to_s.sub(%r{(^|/)_([^/]+)\z}, "\\1\\2")
end

.rack_env(env) ⇒ Object 



103
104
105
106
107
108
 
# File 'lib/upkeep/rails/replay.rb', line 103

def rack_env(env)
  env = env.each_with_object({}) { |(key, value), copy| copy[key.to_s] = revive_env_value(value) }
  env["rack.input"] = StringIO.new
  env["rack.errors"] ||= StringIO.new
  env
end

.render(recipe) ⇒ Object 



22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
 
# File 'lib/upkeep/rails/replay.rb', line 22

def render(recipe)
  replay = recipe.replay

  case replay
  when ::Upkeep::Replay::ControllerPage
    render_controller_page(replay)
  when ::Upkeep::Replay::Template
    render_template(replay)
  when ::Upkeep::Replay::Fragment
    render_fragment(replay)
  when ::Upkeep::Replay::Collection
    render_collection(replay)
  when ::Upkeep::Replay::CollectionMember
    render_collection_member(replay)
  else
    raise "unknown Rails replay recipe type: #{replay.class.name}"
  end
end

.render_collection(replay) ⇒ Object 



67
68
69
70
71
72
73
74
75
76
77
78
79
80
 
# File 'lib/upkeep/rails/replay.rb', line 67

def render_collection(replay)
  template_context = replay_template_context
  options = revive_hash(replay.options, template: template_context)
  collection = revive_value(replay.collection, template: template_context)

  if replay.derived_partial?
    renderer_for(replay).render(collection)
  else
    renderer_for(replay).render(options.merge(
      partial: replay.partial,
      collection: collection
    ))
  end
end

.render_collection_member(replay) ⇒ Object 



82
83
84
85
86
87
88
89
90
91
92
93
 
# File 'lib/upkeep/rails/replay.rb', line 82

def render_collection_member(replay)
  template_context = replay_template_context
  options = revive_hash(replay.options, template: template_context)
  record = revive_value(replay.record, template: template_context)
  locals = options.fetch(:locals, {})
  local_name = (options[:as] || inferred_local_name(replay.partial)).to_sym

  renderer_for(replay).render(
    partial: replay.partial,
    locals: locals.merge(local_name => record)
  )
end

.render_controller_page(replay) ⇒ Object 



41
42
43
44
45
46
47
 
# File 'lib/upkeep/rails/replay.rb', line 41

def render_controller_page(replay)
  controller = constantize(replay.controller_class)
  _status, _headers, body = ControllerRuntime.suppress do
    controller.action(replay.action).call(rack_env(replay.env))
  end
  collect_response_body(body)
end

.render_fragment(replay) ⇒ Object 



58
59
60
61
62
63
64
65
 
# File 'lib/upkeep/rails/replay.rb', line 58

def render_fragment(replay)
  template_context = replay_template_context
  renderer_for(replay).render(
    partial: partial_path(replay.template),
    locals: revive_hash(replay.locals, template: template_context),
    assigns: revive_hash(replay.assigns, template: template_context)
  )
end

.render_template(replay) ⇒ Object 



49
50
51
52
53
54
55
56
 
# File 'lib/upkeep/rails/replay.rb', line 49

def render_template(replay)
  template_context = replay_template_context
  renderer_for(replay).render(
    template: replay.template,
    locals: revive_hash(replay.locals, template: template_context),
    assigns: revive_hash(replay.assigns, template: template_context)
  )
end

.renderer_for(replay) ⇒ Object 



95
96
97
98
99
100
101
 
# File 'lib/upkeep/rails/replay.rb', line 95

def renderer_for(replay)
  if replay.controller_class
    constantize(replay.controller_class).renderer
  else
    ::ActionController::Base.renderer
  end
end

.replay_session_snapshot?(value) ⇒ Boolean

Returns:

  • (Boolean) 


165
166
167
168
169
170
 
# File 'lib/upkeep/rails/replay.rb', line 165

def replay_session_snapshot?(value)
  return false unless value.is_a?(Hash)

  type = value["__upkeep_replay_type"] || value[:__upkeep_replay_type]
  type == "rack_session"
end

.replay_template_context ⇒ Object 



148
149
150
 
# File 'lib/upkeep/rails/replay.rb', line 148

def replay_template_context
  ::ActionView::Base.empty
end

.revive_env_value(value) ⇒ Object 



152
153
154
155
156
157
158
159
160
161
162
163
 
# File 'lib/upkeep/rails/replay.rb', line 152

def revive_env_value(value)
  return revive_replay_session(value) if replay_session_snapshot?(value)

  case value
  when Hash
    value.transform_values { |nested_value| revive_env_value(nested_value) }
  when Array
    value.map { |nested_value| revive_env_value(nested_value) }
  else
    value
  end
end

.revive_form_builder(snapshot, template:) ⇒ Object 



139
140
141
142
143
144
145
146
 
# File 'lib/upkeep/rails/replay.rb', line 139

def revive_form_builder(snapshot, template:)
  constantize(snapshot.builder_class).new(
    snapshot.object_name,
    revive_value(snapshot.object, template: template),
    template,
    revive_hash(snapshot.options, template: template)
  )
end

.revive_hash(values, template: replay_template_context) ⇒ Object 



110
111
112
113
114
115
116
 
# File 'lib/upkeep/rails/replay.rb', line 110

def revive_hash(values, template: replay_template_context)
  values = values.entries if values.is_a?(::Upkeep::Replay::HashValue)

  values.each_with_object({}) do |(key, value), revived|
    revived[key.to_sym] = revive_value(value, template: template)
  end
end

.revive_replay_session(snapshot) ⇒ Object 



172
173
174
175
 
# File 'lib/upkeep/rails/replay.rb', line 172

def revive_replay_session(snapshot)
  values = snapshot["values"] || snapshot[:values] || {}
  RackSession.new(revive_env_value(values))
end

.revive_value(snapshot, template: replay_template_context) ⇒ Object 



118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
 
# File 'lib/upkeep/rails/replay.rb', line 118

def revive_value(snapshot, template: replay_template_context)
  snapshot = ::Upkeep::Replay.value(snapshot)

  case snapshot
  when ::Upkeep::Replay::ActiveRecordValue
    constantize(snapshot.model).find(snapshot.id)
  when ::Upkeep::Replay::ActiveRecordRelationValue
    constantize(snapshot.model).find_by_sql(snapshot.sql)
  when ::Upkeep::Replay::ArrayValue
    snapshot.items.map { |item| revive_value(item, template: template) }
  when ::Upkeep::Replay::HashValue
    revive_hash(snapshot.entries, template: template)
  when ::Upkeep::Replay::LiteralValue
    snapshot.value
  when ::Upkeep::Replay::RailsFormBuilderValue
    revive_form_builder(snapshot, template: template)
  else
    raise "unsupported Rails replay value type: #{snapshot.class.name}"
  end
end