Class: CacheCrispies::Base

Inherits:
Object
  • Object
show all
Defined in:
lib/cache_crispies/base.rb

Overview

The Base class that all serializer classes should inherit from

Class Attribute Summary collapse

Instance Attribute Summary collapse

Class Method Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(model, options = {}) ⇒ Base

Initializes a new instance of CacheCrispies::Base, or really, it should always be a subclass of CacheCrispies::Base.

Parameters:

  • model (Object) —

    typically ActiveRecord::Base, but could be anything

  • options (Hash) (defaults to: {}) —

    any optional custom values you want to be accessible in your subclass.



34
35
36
37
 
# File 'lib/cache_crispies/base.rb', line 34

def initialize(model, options = {})
  @model = model
  @options = options
end

Class Attribute Details

.attributes ⇒ Object (readonly)

Returns the value of attribute attributes.



24
25
26
 
# File 'lib/cache_crispies/base.rb', line 24

def attributes
  @attributes
end

Instance Attribute Details

#model ⇒ Object (readonly)

Returns the value of attribute model.



9
10
11
 
# File 'lib/cache_crispies/base.rb', line 9

def model
  @model
end

#options ⇒ Object (readonly)

Returns the value of attribute options.



9
10
11
 
# File 'lib/cache_crispies/base.rb', line 9

def options
  @options
end

Class Method Details

.cache_key_addons(options = {}) {|options| ... } ⇒ Array<String>

Call with a block returning an array of strings that should be added to the cache key for an instance of this serializer. Typically you’d add in string values to uniquely represent the values you’re passing to the serializer so that they are cached separately. But it could also contain any custom logic about how to construct a cache key. Call without a block to act as a getter and return the value.

passed in here as well so you can refernce it if needed. should return an array of strings to use in the cache key

Examples:

cache based off models provided in options

cache_key_addons { |options| [options[:current_user].id] }

time-based caching

cache_key_addons { |_options| [Date.today.to_s] }

Parameters:

  • options (Hash) (defaults to: {}) —

    the options hash passed to the serializer, will be

Yields:

  • (options) —

    a block that takes options passed to the serializer and

Returns:

  • (Array<String>) 


146
147
148
149
150
151
152
153
154
155
 
# File 'lib/cache_crispies/base.rb', line 146

def self.cache_key_addons(options = {}, &block)
  @cache_key_addons ||= nil

  if block_given?
    @cache_key_addons = block
    nil
  else
    Array(@cache_key_addons&.call(options))
  end
end

.cache_key_base ⇒ String

Return a cache key string for the serializer class to be included in the cache key for the instances. The key includes the name of the class, and a digest of the contents of the main class file.

Returns:

  • (String) —

    a cache key for the class



180
181
182
 
# File 'lib/cache_crispies/base.rb', line 180

def self.cache_key_base
  @cache_key_base ||= "#{self}-#{file_hashes.join(CACHE_KEY_SEPARATOR)}"
end

.collection_key(*key) ⇒ Symbol?

Get or set a JSON key to use as a root key on a collection-type serializable. By deafult it’s the plural version of .key, but it can be overridden in a subclass to be anything. Calling the method with a key will set the key, calling it without any arguments will get the key.

Hash, or nil for no key or nil for no key

Parameters:

  • key (Symbol, nil) —

    a symbol to be used as a key for a JSON-ready

Returns:

  • (Symbol) —

    a symbol to be used as a key for a JSON-ready Hash

  • (Symbol, nil) —

    a symbol to be used as a key for a JSON-ready Hash,



112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
 
# File 'lib/cache_crispies/base.rb', line 112

def self.collection_key(*key)
  @default_collection_key ||= self.key.to_s.pluralize.to_sym

  # method called with no args so act as a getter
  if key.empty?
    if defined? @collection_key
      return @collection_key
    else
      return @default_collection_key
    end
  end

  # method called with args so act as a setter
  @collection_key = key.first&.to_sym
end

.dependency_key(key = nil) ⇒ String

Get or set a cache key that can be changed whenever an outside dependency of any kind changes in any way that could change the output of your serializer. For instance, if a mixin is changed. Or maybe an object you’re serializing has changed it’s #to_json method. This key should be changed accordingly, to bust the cache so that you’re not serving stale data.

Returns:

  • (String) —

    a version string in any form



165
166
167
168
169
170
171
172
173
 
# File 'lib/cache_crispies/base.rb', line 165

def self.dependency_key(key = nil)
  @dependency_key ||= nil

  # method called with no args so act as a getter
  return @dependency_key unless key

  # method called with args so act as a setter
  @dependency_key = key.to_s
end

.do_caching(value = nil) ⇒ Boolean Also known as: do_caching?

Get or set whether or not this serializer class should allow caching of results. It returns false by default, but can be overridden in child classes. Calling the method with an argument will set the value, calling it without any arguments will get the value.

Parameters:

  • value (Boolean) (defaults to: nil) —

    true to enable caching, false to disable

Returns:

  • (Boolean) 


53
54
55
56
57
58
59
60
61
 
# File 'lib/cache_crispies/base.rb', line 53

def self.do_caching(value = nil)
  @do_caching ||= false

  # method called with no args so act as a getter
  return @do_caching if value.nil?

  # method called with args so act as a setter
  @do_caching = !!value
end

.engine(value = nil) ⇒ Object

Get or set root path of Rails application or engine. It uses Rails by default, but can be overriden with your Rails Engine class. Calling the method with an argument will set the value, calling it without any arguments will get the value.



71
72
73
74
75
76
77
78
79
80
 
# File 'lib/cache_crispies/base.rb', line 71

def self.engine(value = nil)
  @engine ||= superclass.try(:engine)
  @engine ||= Rails

  # method called with no args so act as a getter
  return @engine if value.nil?

  # method called with args so act as a setter
  @engine = value
end

.file_hashes ⇒ Array<String>

Return an array of cache key string for this serializer and all nested and deeply nested serializers. The purpose of grabbing all this data is to be able to construct a cache key that will be busted if any of the nested serializers, no matter how deep, change at all.

Returns:

  • (Array<String>) —

    an array of uniq, sorted serializer file hashes



190
191
192
193
194
 
# File 'lib/cache_crispies/base.rb', line 190

def self.file_hashes
  @file_hashes ||= (
    [file_hash] + nested_serializers.flat_map(&:file_hashes)
  ).uniq.sort
end

.inherited(other) ⇒ void

This method returns an undefined value.

Define class-level instance variables and their default values when the class is inherited by another class. This is not meant to be called directly. It is called internally by Ruby.

Parameters:

  • other (Class) —

    the inheriting child class



17
18
19
20
21
 
# File 'lib/cache_crispies/base.rb', line 17

def self.inherited(other)
  other.instance_variable_set(:@attributes, [])
  other.instance_variable_set(:@nesting, [])
  other.instance_variable_set(:@conditions, [])
end

.key(*key) ⇒ Symbol?

Get or set a JSON key to use as a root key on a non-collection serializable. By default it’s the name of the class without the “Serializer” part. But it can be overridden in a subclass to be anything. Calling the method with a key will set the key, calling it without any arguments will get the key.

Hash, or nil for no key or nil for no key

Parameters:

  • key (Symbol, nil) —

    a symbol to be used as a key for a JSON-ready

Returns:

  • (Symbol, nil) —

    a symbol to be used as a key for a JSON-ready Hash,



92
93
94
95
96
97
98
99
100
 
# File 'lib/cache_crispies/base.rb', line 92

def self.key(*key)
  @default_key ||= to_s.demodulize.chomp('Serializer').underscore.to_sym

  # method called with no args so act as a getter
  return defined?(@key) ? @key : @default_key if key.empty?

  # method called with args so act as a setter
  @key = key.first&.to_sym
end

Instance Method Details

#as_json ⇒ Hash

Renders the serializer instance to a JSON-ready Hash

Returns:

  • (Hash) —

    a JSON-ready hash



42
43
44
 
# File 'lib/cache_crispies/base.rb', line 42

def as_json
  HashBuilder.new(self).call
end