Module: Familia::DataType::Serialization

Included in:
Familia::DataType
Defined in:
lib/familia/data_type/serialization.rb

Instance Method Summary collapse

Instance Method Details

#deserialize_value(val) ⇒ Object?

Note:

If no class option is specified, the original value is returned unchanged.

Deserializes a single value from the database.

NOTE: Currently only the DataType class uses this method. Horreum fields are a newer addition and don’t support the full range of deserialization options that DataType supports. It uses serialize_value for serialization since everything becomes a string in Valkey.

Parameters:

  • val (String, nil) —

    The value to deserialize.

Returns:

  • (Object, nil) —

    The deserialized object, the default value if val is nil, or nil if deserialization fails.



119
120
121
122
123
124
125
 
# File 'lib/familia/data_type/serialization.rb', line 119

def deserialize_value(val)
  return @opts[:default] if val.nil?
  return val unless @opts[:class]

  ret = deserialize_values val
  ret&.first # return the object or nil
end

#deserialize_values(*values) ⇒ Array<Object>

Deserializes multiple values from Redis, removing nil values.

Parameters:

  • values (Array<String>) —

    The values to deserialize.

Returns:

  • (Array<Object>) —

    Deserialized objects, with nil values removed.

See Also:



59
60
61
62
63
64
65
 
# File 'lib/familia/data_type/serialization.rb', line 59

def deserialize_values(*values)
  # Avoid using compact! here. Using compact! as the last expression in the
  # method can unintentionally return nil if no changes are made, which is
  # not desirable. Instead, use compact to ensure the method returns the
  # expected value.
  deserialize_values_with_nil(*values).compact
end

#deserialize_values_with_nil(*values) ⇒ Array<Object, nil>

Note:

This method attempts to deserialize each value using the specified class’s load method. If deserialization fails for a value, it’s replaced with nil.

Deserializes multiple values from Redis, preserving nil values.

Parameters:

  • values (Array<String>) —

    The values to deserialize.

Returns:

  • (Array<Object, nil>) —

    Deserialized objects, including nil values.

Raises:

  • (Familia::Problem) —

    If the specified class doesn’t respond to the load method.



79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
 
# File 'lib/familia/data_type/serialization.rb', line 79

def deserialize_values_with_nil(*values)
  Familia.ld "deserialize_values: (#{@opts}) #{values}"
  return [] if values.empty?
  return values.flatten unless @opts[:class]

  unless @opts[:class].respond_to?(load_method)
    raise Familia::Problem, "No such method: #{@opts[:class]}##{load_method}"
  end

  values.collect! do |obj|
    next if obj.nil?

    val = @opts[:class].send load_method, obj
    Familia.ld "[#{self.class}#deserialize_values] nil returned for #{@opts[:class]}##{name}" if val.nil?

    val
  rescue StandardError => e
    Familia.info val
    Familia.info "Parse error for #{dbkey} (#{load_method}): #{e.message}"
    Familia.info e.backtrace
    nil
  end

  values
end

#serialize_value(val, strict_values: true) ⇒ String?

Note:

When a class option is specified, it uses that class’s serialization method. Otherwise, it relies on Familia.distinguisher for serialization.

Serializes a value for storage in Redis.

Examples:

With a class option

serialize_value(User.new(name: "Cloe"), strict_values: false) #=> '{"name":"Cloe"}'

Without a class option

serialize_value(123) #=> "123"
serialize_value("hello") #=> "hello"

Parameters:

  • val (Object) —

    The value to be serialized.

  • strict_values (Boolean) (defaults to: true) —

    Whether to enforce strict value serialization (default: true).

Returns:

  • (String, nil) —

    The serialized representation of the value, or nil if serialization fails.

Raises:



27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
 
# File 'lib/familia/data_type/serialization.rb', line 27

def serialize_value(val, strict_values: true)
  prepared = nil

  Familia.trace :TOREDIS, dbclient, "#{val}<#{val.class}|#{opts[:class]}>", caller(1..1) if Familia.debug?

  if opts[:class]
    prepared = Familia.distinguisher(opts[:class], strict_values: strict_values)
    Familia.ld "  from opts[class] <#{opts[:class]}>: #{prepared || '<nil>'}"
  end

  if prepared.nil?
    # Enforce strict values when no class option is specified
    prepared = Familia.distinguisher(val, strict_values: true)
    Familia.ld "  from <#{val.class}> => <#{prepared.class}>"
  end

  if Familia.debug?
    Familia.trace :TOREDIS, dbclient, "#{val}<#{val.class}|#{opts[:class]}> => #{prepared}<#{prepared.class}>",
                  caller(1..1)
  end

  Familia.warn "[#{self.class}#serialize_value] nil returned for #{opts[:class]}##{name}" if prepared.nil?
  prepared
end