Class: Brut::FrontEnd::RequestContext

Inherits:
Object
  • Object
show all
Defined in:
lib/brut/front_end/request_context.rb

Overview

Container for request-specific information that serves as the source of what can be automaticall passed to various methods by Brut.

The intention for this class is to provide access to the 80% of stuff needed by most requests, to alleviate the need to have to dig into ‘env` or the Rack request. This also allows arbitrary information to be inserted and made available later.

Several methods of Brut objects take keyword arguments in their initializer or a particular method. The names of those keyword arguments correspond to values that are contained by this class. Thus, if you are creating, say, a Page subclass, and create an initializer for it that accepts the ‘clock:` keyword argument, the managed instance of Clock will be passed into it when Brut creates an instance of the class.

Class Method Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(env:, session:, flash:, xhr:, body:, host:) ⇒ RequestContext

Create a new RequestContext based on some of the information provided by Rack

Parameters:

  • env (Hash) —

    the Rack ‘env` object, as available to any middleware

  • session (Brut::FrontEnd::Session) —

    the current session, noting that this is the Brut (or your app) session class and not the Rack session.

  • flash (Brut::FrontEnd::Flash) —

    the current flash

  • xhr (true|false) —

    true if this is an XHR request.

  • body (Object) —

    the ‘request.body` as provided by Rack

  • host (URI) —

    URI the ‘request.host` and `request.scheme`, and `request.port` as provided by Rack



32
33
34
35
36
37
38
39
40
41
42
43
 
# File 'lib/brut/front_end/request_context.rb', line 32

def initialize(env:,session:,flash:,xhr:,body:,host:)
  @hash = {
    env:,
    session:,
    flash:,
    xhr:,
    body:,
    host:,
    csrf_token: Rack::Protection::AuthenticityToken.token(env["rack.session"]),
    clock: Clock.new(session.timezone),
  }
end

Class Method Details

.current ⇒ Object 



12
13
14
 
# File 'lib/brut/front_end/request_context.rb', line 12

def self.current
  Thread.current.thread_variable_get(:request_context)
end

.inject(klass, request_params: nil) ⇒ Object

Create an instance of klass injected with the request context.



17
18
19
20
21
22
23
 
# File 'lib/brut/front_end/request_context.rb', line 17

def self.inject(klass, request_params: nil)
  self.current.then { |request_context|
    request_context.as_constructor_args(klass,request_params:)
  }.then { |constructor_args|
    klass.new(**constructor_args) 
  }
end

Instance Method Details

#[](key) ⇒ Object

Access a given value, returning ‘nil` if it’s not mapped or is ‘nil`

Parameters:

  • key (String|Symbol) —

    the value to get

Returns:

  • (Object) —

    the mapped value



76
77
78
 
# File 'lib/brut/front_end/request_context.rb', line 76

def [](key)
  @hash[key.to_sym]
end

#[]=(key, value) ⇒ Object

Set an arbitrary value that can be injected later

Parameters:

  • key (String|Symbol) —

    the name of the value. This is converted to a symbol.

  • value (Object) —

    the value to map. Should not be nil.



49
50
51
52
 
# File 'lib/brut/front_end/request_context.rb', line 49

def []=(key,value)
  key = key.to_sym
  @hash[key] = value
end

#as_constructor_args(klass, request_params:, route: nil, form: nil) ⇒ Hash

Based on ‘klass`’ constructor, returns a Hash that maps all keywords it requires to the values stored in this ‘RequestContext`. It is assumed that `request_params:` contains the query parameters so they can be injected. The Brut::FrontEnd::Routing::Route can also be injected to pass in.

Examples:

class SomeClass
  def initialize(flash:,clock:,date:)
    # ...
  end
end

hash = request_context.as_constructor_args(
  SomeClass,
  request_params: { date: "2024-11-11" }
)

# hash contains:
# {
#   flash: «Flash used to create the RequestContext»,
#   clock: «Clock used to create the RequestContext»,
#   date: "2024-11-11",
# }

object = SomeClass.new(**hash)

Parameters:

  • klass (Class) —

    a class that is to be instantiated entirely by the contents of this ‘RequestContext`.

  • request_params (Hash) —

    Query string parameters provided by Rack.

  • route (Brut::FrontEnd::Routing::Route) (defaults to: nil) —

    the route that triggered the request.

  • form (Brut::FrontEnd::Form) (defaults to: nil) —

    the form, if available

Returns:

  • (Hash) —

    can be splatted to keyword arguments and passed to the constructor of ‘klass`

Raises:

  • (ArgumentError) —

    if the constructor has any non-keyword arguments, or if any required keyword argument is not present in this ‘RequestContext`.



120
121
122
 
# File 'lib/brut/front_end/request_context.rb', line 120

def as_constructor_args(klass, request_params:, route:nil, form: nil)
  args_for_method(method: klass.instance_method(:initialize), request_params:, form: , route:)
end

#as_method_args(object, method_name, request_params:, form:, route: nil) ⇒ Hash

Based on ‘object`’ method, returns a Hash that maps all keywords it requires to the values stored in this ‘RequestContext`. It is assumed that `request_params:` contains the query parameters so they can be injected. It is also assumed that `form:` is the Form that is provided as part of the request. The Brut::FrontEnd::Routing::Route can also be injected to pass in.

Examples:

class SomeClass
  def doit(flash:,clock:,date:)
    # ...
  end
end

object = SomeClass.new

hash = request_context.as_method_args(
  object,
  :doit,
  request_params: { date: "2024-11-11" }
)

# hash contains:
# {
#   flash: «Flash used to create the RequestContext»,
#   clock: «Clock used to create the RequestContext»,
#   date: "2024-11-11",
# }

result = object.doit(**hash)

Parameters:

  • object (Class) —

    an object whose method is to be called that requires some of the contents of this ‘RequestContext`.

  • method_name (Symbol) —

    name of the method that will be called.

  • request_params (Hash) —

    Query string parameters provided by Rack. Note that any parameter whose value is the empty string will be coerced to ‘nil`.

  • route (Brut::FrontEnd::Routing::Route) (defaults to: nil) —

    the route that triggered the request.

  • form (Brut::FrontEnd::Form) —

    the form that was submitted with this request. May be ‘nil`.

Returns:

  • (Hash) —

    can be splatted to keyword arguments and passed to the constructor of ‘klass`

Raises:

  • (ArgumentError) —

    if the method has any non-keyword arguments, or if any required keyword argument is not present in this ‘RequestContext`.



162
163
164
 
# File 'lib/brut/front_end/request_context.rb', line 162

def as_method_args(object, method_name, request_params:,form:,route:nil)
  args_for_method(method: object.method(method_name), request_params:, form:,route:)
end

#fetch(key) ⇒ Object

Access the given value, raising an exception if it has not been set or if it’s nil.

Parameters:

  • key (String|Symbol) —

    the value to fetch.

Returns:

  • (Object) —

    the mapped value

Raises:

  • (ArgumentError) —

    if ‘key` was never mapped or maps to `nil`.



60
61
62
63
64
65
66
67
68
69
70
71
 
# File 'lib/brut/front_end/request_context.rb', line 60

def fetch(key)
  if self.key?(key)
    value = self[key]
    if value
      return value
    else
      raise ArgumentError,"No key '#{key}' in #{self.class}"
    end
  else
    raise ArgumentError,"Key '#{key}' is nil in #{self.class}"
  end
end

#key?(key) ⇒ true|false

Check if a given value has been mapped.

Parameters:

  • key (String|Symbol) —

    the value to check

Returns:

  • (true|false) —

    if the value is mapped. Note that if ‘nil` was injected, this method returns `true`.



83
84
85
 
# File 'lib/brut/front_end/request_context.rb', line 83

def key?(key)
  @hash.key?(key.to_sym)
end