class Warden::SessionSerializer

Experimental RBS support (using type sampling data from the type_fusion project). 

# sig/warden/session_serializer.rbs

class Warden::SessionSerializer
  def key_for: (Symbol scope) -> untyped
end

def delete(scope, user=nil) 

def delete(scope, user=nil)
  session.delete(key_for(scope))
end

def deserialize(key) 

def deserialize(key)
  key
end

def fetch(scope) 

def fetch(scope)
  key = session[key_for(scope)]
  return nil unless key
  method_name = "#{scope}_deserialize"
  user = respond_to?(method_name) ? send(method_name, key) : deserialize(key)
  delete(scope) unless user
  user
end

def initialize(env) 

def initialize(env)
  @env = env
end

def key_for(scope)

Experimental RBS support (using type sampling data from the type_fusion project). 

def key_for: (Symbol scope) -> untyped

This signature was generated using 1 sample from 1 application. 

def key_for(scope)
  "warden.user.#{scope}.key"
end

def serialize(user) 

def serialize(user)
  user
end

def session

We can't cache this result because the session can be lazy loaded 
def session
  env["rack.session"] || {}
end

def store(user, scope) 

def store(user, scope)
  return unless user
  method_name = "#{scope}_serialize"
  specialized = respond_to?(method_name)
  session[key_for(scope)] = specialized ? send(method_name, user) : serialize(user)
end

def stored?(scope) 

def stored?(scope)
  !!session[key_for(scope)]
end