Module: Redisize

Defined in:
lib/redisize.rb,
lib/redisize/version.rb,
lib/redisize/log/rails.rb,
lib/redisize/cache/rails.rb,
lib/redisize/adapter/inline.rb,
lib/redisize/adapter/resque.rb,
lib/redisize/adapter/sidekiq.rb,
lib/redisize/orm/active_record.rb,
lib/redisize/support/enumerable.rb

Defined Under Namespace

Modules: Adapter, Cache, ClassMethods, Log, ORM, Support

Constant Summary collapse

ADAPTERS = 
{
   sidekiq: :Sidekiq, # req: Sidekiq::LimitFetch
   resque: :Resque,
   inline: :TrueClass
}
ORMS = 
{
   ActiveRecord: 'active_record'
}
SUPPORTS = 
{
   Enumerable: 'enumerable'
}
LOGS = 
{
   Rails: 'rails'
}
CACHES = 
{
   Rails: 'rails'
}
VERSION = 
"0.2.0"

Class Attribute Summary collapse

Class Method Summary collapse

Instance Method Summary collapse

Class Attribute Details

.adapter ⇒ Object 



111
112
113
114
115
116
 
# File 'lib/redisize.rb', line 111

def adapter
   @adapter ||=
      ADAPTERS.reduce(nil) do |res, (kind, prc)|
         res || Object.constants.include?(prc) && acquire_adapter(kind) || nil
      end
end

Class Method Details

.acquire_adapter(kind) ⇒ Object 



106
107
108
109
 
# File 'lib/redisize.rb', line 106

def acquire_adapter kind
   require("redisize/adapter/#{kind}")
   Redisize::Adapter.const_get(kind.capitalize)
end

.adapter_kind=(value) ⇒ Object 



102
103
104
 
# File 'lib/redisize.rb', line 102

def adapter_kind= value
   self.adapter = acquire_adapter(ADAPTERS[value] && value || :inline)
end

.assign_reverse_key(key, host_key) ⇒ Object 



126
127
128
129
130
131
132
133
134
135
 
# File 'lib/redisize.rb', line 126

def assign_reverse_key key, host_key
   # binding.pry
   if value = redisize_cache_read(key)
      redisize_cache_write(key, value | [ host_key ], expires_in: 1.day)
      redisize_log_debug("Updated key #{key.inspect} with value #{host_key.inspect}")
   else
      redisize_cache_write(key, [ host_key ], expires_in: 1.day)
      redisize_log_debug("Created key #{key.inspect} with value #{host_key.inspect}")
   end
end

.deredisize_instance_metas(key) ⇒ Object 



225
226
227
228
229
230
231
 
# File 'lib/redisize.rb', line 225

def deredisize_instance_metas key
   metakey = rekey(key)

   # binding.pry
   drop_key(metakey)
   redisize_cache_delete(key)
end

.deredisize_json_metas(key) ⇒ Object 



246
247
248
249
 
# File 'lib/redisize.rb', line 246

def deredisize_json_metas key
   # binding.pry
   drop_key(key)
end

.deredisize_model_metas(model_name) ⇒ Object 



241
242
243
244
 
# File 'lib/redisize.rb', line 241

def deredisize_model_metas model_name
   # binding.pry
   drop_key(["meta", model_name])
end

.drop_key(key) ⇒ Object 



137
138
139
140
141
142
143
144
145
146
147
148
149
 
# File 'lib/redisize.rb', line 137

def drop_key key
   # binding.pry
   if value = redisize_cache_read(key)
      if key.first == "meta"
         size = value.size

         value.each { |rkey| drop_key(rkey) }
      end

      redisize_log_debug("Removed key #{key.inspect}#{size && " with #{size} subkeys"}")
      redisize_cache_delete(key)
   end
end

.enqueue(method, *args) ⇒ Object 



118
119
120
 
# File 'lib/redisize.rb', line 118

def enqueue method, *args
   adapter.enqueue(method.to_s, *args)
end

.filtered_for(attrs, klass) ⇒ Object 



122
123
124
 
# File 'lib/redisize.rb', line 122

def filtered_for attrs, klass
   filtered = attrs.select {|attr| klass.attribute_types.keys.include?(attr) }
end

.included(kls) ⇒ Object

system method



49
50
51
52
53
54
55
56
57
 
# File 'lib/redisize.rb', line 49

def included kls
   kls.extend(Redisize::ClassMethods)

   # init orm, log, cache, and support classes
   init_orm_for(kls)
   init_log_for(kls)
   init_cache_for(kls)
   init_support_for(kls)
end

.init_cache_for(kls) ⇒ Object 



90
91
92
93
94
95
96
97
98
99
100
 
# File 'lib/redisize.rb', line 90

def init_cache_for kls
   cache = Object.constants.reduce(nil) { |res, anc| res || CACHES.keys.find {|re| /#{re}/ =~ anc.to_s } }

   if cache
      require("redisize/cache/#{CACHES[cache]}")
      Redisize.include(Redisize::Cache.const_get(cache))
      Redisize.extend(Redisize::Cache.const_get(cache))
      Enumerable.include(Redisize::Cache.const_get(cache))
      kls.extend(Redisize::Cache.const_get(cache))
   end
end

.init_log_for(kls) ⇒ Object 



79
80
81
82
83
84
85
86
87
88
 
# File 'lib/redisize.rb', line 79

def init_log_for kls
   log = Object.constants.reduce(nil) { |res, anc| res || LOGS.keys.find {|re| /#{re}/ =~ anc.to_s } }

   if log
      require("redisize/log/#{LOGS[log]}")
      Redisize.include(Redisize::Log.const_get(log))
      Redisize.extend(Redisize::Log.const_get(log))
      kls.extend(Redisize::Log.const_get(log))
   end
end

.init_orm_for(kls) ⇒ Object 



59
60
61
62
63
64
65
66
 
# File 'lib/redisize.rb', line 59

def init_orm_for kls
   orm = kls.ancestors.reduce(nil) { |res, anc| res || ORMS.keys.find {|re| /#{re}/ =~ anc.to_s } }

   if orm
      require("redisize/orm/#{ORMS[orm]}")
      kls.include(Redisize::ORM.const_get(orm))
   end
end

.init_support_for(kls) ⇒ Object 



68
69
70
71
72
73
74
75
76
77
 
# File 'lib/redisize.rb', line 68

def init_support_for kls
   sup = Object.constants.reduce(nil) { |res, anc| res || SUPPORTS.keys.find {|re| /#{re}/ =~ anc.to_s } }

   if sup
      require("redisize/support/#{SUPPORTS[sup]}")
      cls = sup.to_s.constantize
      cls.include(Redisize::Support.const_get(sup))
      cls.include(Redisize::ClassMethods)
   end
end

.key_name_for(model_name, attrs, type = "meta") ⇒ Object 



155
156
157
158
 
# File 'lib/redisize.rb', line 155

def key_name_for model_name, attrs, type = "meta"
   primary_key = model_name.constantize.primary_key || attrs.keys.first
   [type, model_name, primary_key, attrs[primary_key].to_s]
end

.parse_instance_attrs(model_name, attrs, key) ⇒ Object 



170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
 
# File 'lib/redisize.rb', line 170

def parse_instance_attrs model_name, attrs, key
   model = model_name.constantize
   children =
      attrs.map do |x, value|
         (value.is_a?(Array) || value.is_a?(Hash)) && x || nil
      end.compact

   children.each do |many|
      name = /^_(?<_name>.*)/ =~ many && _name || many.to_s

      instance = nil
      if klass = model.reflections[name]&.klass || many.singularize.camelize.constantize rescue nil
         attres_in = attrs[many]
         attres = attres_in.is_a?(Hash) && [attres_in] || attres_in
         attres.each do |attrs|
            if attrs[klass.primary_key]
               assign_reverse_key(key_name_for(klass.name, attrs), key)
            else
               assign_reverse_key(["meta", klass.name], key)
            end
            parse_instance_attrs(klass.name, attrs, key)
         end

         assign_reverse_key(["meta", klass.name], key)
      end
   end
end

.parse_sql_key(key) ⇒ Object 



160
161
162
163
164
165
166
167
168
 
# File 'lib/redisize.rb', line 160

def parse_sql_key key
   key[-1].split(/\s(join|from)\s/i)[1..-1].map do |part|
      part.strip.split(/[\s\"]/).reject {|x| x.blank? }.first
   end.uniq.map do |table|
      table.singularize.camelize.constantize rescue nil
   end.compact.each do |klass|
      assign_reverse_key(["meta", klass.name], key)
   end
end

.redisize_array_metas(key, attres) ⇒ Object

redisize_array_metas updates all the meta keys for the result array value



210
211
212
213
214
215
216
217
218
219
220
221
222
223
 
# File 'lib/redisize.rb', line 210

def redisize_array_metas key, attres
   model_name = key[1]
   primary_key = key[2]

   # binding.pry
   attres.map do |attrs|
      metakey = ["meta", model_name, primary_key, attrs[primary_key]]

      parse_instance_attrs(model_name, attrs, key)
      assign_reverse_key(metakey, key)
   end

   parse_sql_key(key)
end

.redisize_json_metas(key, attrs) ⇒ Object 



251
252
253
254
255
256
257
 
# File 'lib/redisize.rb', line 251

def redisize_json_metas key, attrs
   metakey = key_name_for(key[1], attrs)

   # binding.pry
   parse_instance_attrs(key[1], attrs, key)
   assign_reverse_key(metakey, key)
end

.redisize_model_metas(metakey, model_name, attrs, key) ⇒ Object

internal methods for enqueued proceeds



200
201
202
203
204
205
206
 
# File 'lib/redisize.rb', line 200

def redisize_model_metas metakey, model_name, attrs, key
   # binding.pry
   drop_key(metakey)
   drop_key(metakey[0..1])
   parse_instance_attrs(model_name, attrs, key)
   assign_reverse_key(metakey, key)
end

.rekey(key, type = "meta") ⇒ Object 



151
152
153
 
# File 'lib/redisize.rb', line 151

def rekey key, type = "meta"
   [type.to_s] + key[1..-1]
end

.reredisize_instance_metas(key) ⇒ Object 



233
234
235
236
237
238
239
 
# File 'lib/redisize.rb', line 233

def reredisize_instance_metas key
   metakey = rekey(key)
   # binding.pry

   drop_key(metakey)
   assign_reverse_key(metakey, key)
end

Instance Method Details

#deredisize_instance ⇒ Object

self -> model instance



300
301
302
303
304
305
306
 
# File 'lib/redisize.rb', line 300

def deredisize_instance
   attrs = self.as_json
   key = Redisize.key_name_for(self.class.polymorphic_base_name, attrs, "instance")

   # binding.pry
   Redisize.enqueue(:deredisize_instance_metas, key)
end

#deredisize_json(scheme, &block) ⇒ Object

self -> model instance



276
277
278
279
280
281
282
 
# File 'lib/redisize.rb', line 276

def deredisize_json scheme, &block
   primary_key = self.class.primary_key
   key = ["json", self.class.polymorphic_base_name, primary_key, self[primary_key], scheme]

   # binding.pry
   Redisize.enqueue(:deredisize_json_metas, key)
end

#deredisize_model ⇒ Object

self -> model instance



285
286
287
 
# File 'lib/redisize.rb', line 285

def deredisize_model
   Redisize.enqueue(:deredisize_model_metas, self.class.polymorphic_base_name)
end

#redisize_json(scheme, &block) ⇒ Object

self -> model instance



261
262
263
264
265
266
267
268
269
270
271
272
273
 
# File 'lib/redisize.rb', line 261

def redisize_json scheme, &block
   primary_key = self.class.primary_key
   key = ["json", self.class.polymorphic_base_name, primary_key, self[primary_key].to_s, scheme]

   # binding.pry
   redisize_cache_fetch(key, expires_in: 1.week) do
      value = block.call

      Redisize.enqueue(:redisize_json_metas, key, value)

      value
   end
end

#reredisize_instance ⇒ Object

self -> model instance



290
291
292
293
294
295
296
297
 
# File 'lib/redisize.rb', line 290

def reredisize_instance
   attrs = self.as_json
   key = Redisize.key_name_for(self.class.polymorphic_base_name, attrs, "instance")

   # binding.pry
   redisize_cache_write(key, self, expires_in: 1000.years)
   Redisize.enqueue(:reredisize_instance_metas, key)
end