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 



168
169
170
171
172
 
# File 'lib/upkeep/rails/replay.rb', line 168

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

.constantize(name) ⇒ Object 



164
165
166
 
# File 'lib/upkeep/rails/replay.rb', line 164

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

.inferred_local_name(partial) ⇒ Object 



160
161
162
 
# File 'lib/upkeep/rails/replay.rb', line 160

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

.partial_path(template) ⇒ Object 



156
157
158
 
# File 'lib/upkeep/rails/replay.rb', line 156

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

.rack_env(env) ⇒ Object 



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

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 



63
64
65
66
67
68
69
70
71
72
73
74
75
 
# File 'lib/upkeep/rails/replay.rb', line 63

def render_collection(replay)
  options = revive_hash(replay.options)
  collection = revive_value(replay.collection)

  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 



77
78
79
80
81
82
83
84
85
86
87
 
# File 'lib/upkeep/rails/replay.rb', line 77

def render_collection_member(replay)
  options = revive_hash(replay.options)
  record = revive_value(replay.record)
  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 



56
57
58
59
60
61
 
# File 'lib/upkeep/rails/replay.rb', line 56

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

.render_template(replay) ⇒ Object 



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

def render_template(replay)
  renderer_for(replay).render(
    template: replay.template,
    locals: revive_hash(replay.locals)
  )
end

.renderer_for(replay) ⇒ Object 



89
90
91
92
93
94
95
 
# File 'lib/upkeep/rails/replay.rb', line 89

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) 


144
145
146
147
148
149
 
# File 'lib/upkeep/rails/replay.rb', line 144

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

.revive_env_value(value) ⇒ Object 



131
132
133
134
135
136
137
138
139
140
141
142
 
# File 'lib/upkeep/rails/replay.rb', line 131

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_hash(values) ⇒ Object 



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

def revive_hash(values)
  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)
  end
end

.revive_replay_session(snapshot) ⇒ Object 



151
152
153
154
 
# File 'lib/upkeep/rails/replay.rb', line 151

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

.revive_value(snapshot) ⇒ Object 



112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
 
# File 'lib/upkeep/rails/replay.rb', line 112

def revive_value(snapshot)
  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) }
  when ::Upkeep::Replay::HashValue
    revive_hash(snapshot.entries)
  when ::Upkeep::Replay::LiteralValue
    snapshot.value
  else
    raise "unsupported Rails replay value type: #{snapshot.class.name}"
  end
end