active_orm 4.0.3 → 5.0.0

data/lib/active_orm/redis/geo.rb

@@ -1,27 +1,31 @@
-class ActiveOrm::Redis::Geo < ActiveOrm::Redis
+# frozen_string_literal: true
 
-  def self.create
-    # TODO
-  end
+class ActiveOrm::Redis::Geo < ActiveOrm::Redis::Base
+  class << self
 
-  def self.hash
-    # TODO
-  end
+    def create
+      # TODO
+    end
 
-  def self.position
-    # TODO
-  end
+    def hash
+      # TODO
+    end
 
-  def self.distance
-    # TODO
-  end
+    def position
+      # TODO
+    end
 
-  def self.radius
-    # TODO
-  end
+    def distance
+      # TODO
+    end
 
-  def self.radius_member
-    # TODO
-  end
+    def radius
+      # TODO
+    end
 
+    def radius_member
+      # TODO
+    end
+
+  end
 end

data/lib/active_orm/redis/hash.rb

@@ -1,75 +1,79 @@
-class ActiveOrm::Redis::Hash < ActiveOrm::Redis
+# frozen_string_literal: true
 
-  def self.find(key, field)
-    value = client.hget(normalize_key(key), field)
-    value = metamorph(value) if evaluate?
-    value
-  end
+class ActiveOrm::Redis::Hash < ActiveOrm::Redis::Base
+  class << self
 
-  def self.find_each(key, *args)
-    value = client.hmget(normalize_key(key), args)
-    value = metamorph(value) if evaluate?
-    value
-  end
+    def find(key, field)
+      value = client.hget(normalize_key(key), field)
+      value = metamorph(value) if evaluate?
+      value
+    end
 
-  def self.all(key)
-    value = client.hgetall(normalize_key(key))
-    value = metamorph(value) if evaluate?
-    value
-  end
+    def find_each(key, *args)
+      value = client.hmget(normalize_key(key), args)
+      value = metamorph(value) if evaluate?
+      value
+    end
 
-  def self.keys(key)
-    value = client.hkeys(normalize_key(key))
-    value = metamorph(value) if evaluate?
-    value
-  end
+    def all(key)
+      value = client.hgetall(normalize_key(key))
+      value = metamorph(value) if evaluate?
+      value
+    end
 
-  def self.values(key)
-    value = client.hvals(normalize_key(key))
-    value = metamorph(value) if evaluate?
-    value
-  end
+    def keys(key)
+      value = client.hkeys(normalize_key(key))
+      value = metamorph(value) if evaluate?
+      value
+    end
 
-  def self.value_length(key, field)
-    client.hstrlen(normalize_key(key), field)
-  end
+    def values(key)
+      value = client.hvals(normalize_key(key))
+      value = metamorph(value) if evaluate?
+      value
+    end
 
-  def self.count(key)
-    client.hlen(normalize_key(key))
-  end
+    def value_length(key, field)
+      client.hstrlen(normalize_key(key), field)
+    end
 
-  def self.exists?(key, field)
-    client.hexists(normalize_key(key), field)
-  end
+    def count(key)
+      client.hlen(normalize_key(key))
+    end
 
-  def self.create(key, field, value)
-    client.hset(normalize_key(key), field, value)
-  end
+    def exists?(key, field)
+      client.hexists(normalize_key(key), field)
+    end
 
-  def self.create!(key, field, value)
-    client.hsetnx(normalize_key(key), field, value)
-  end
+    def create(key, field, value)
+      client.hset(normalize_key(key), field, value)
+    end
 
-  def self.create_each(key, *args)
-    client.hmset(normalize_key(key), args)
-  end
+    def create!(key, field, value)
+      client.hsetnx(normalize_key(key), field, value)
+    end
+
+    def create_each(key, *args)
+      client.hmset(normalize_key(key), args)
+    end
 
-  def self.increment(key, field, value)
-    normalized_key = normalize_key(key)
+    def increment(key, field, value)
+      normalized_key = normalize_key(key)
 
-    if value.is_a?(Float)
-      client.hincrbyfloat(normalized_key, field, value)
-    else
-      client.hincrby(normalized_key, field, value)
+      if value.is_a?(Float)
+        client.hincrbyfloat(normalized_key, field, value)
+      else
+        client.hincrby(normalized_key, field, value)
+      end
     end
-  end
 
-  def self.destroy(key, *args)
-    client.hdel(normalize_key(key), args)
-  end
+    def destroy(key, *args)
+      client.hdel(normalize_key(key), args)
+    end
 
-  def self.scan(key, cursor, opts = {})
-    client.hdel(normalize_key(key), cursor, opts)
-  end
+    def scan(key, cursor, opts = {})
+      client.hdel(normalize_key(key), cursor, opts)
+    end
 
+  end
 end

data/lib/active_orm/redis/hyper_log_log.rb

@@ -1,15 +1,19 @@
-class ActiveOrm::Redis::HyperLogLog < ActiveOrm::Redis
+# frozen_string_literal: true
 
-  def self.create(key, member)
-    client.pfadd(normalize_key(key), member)
-  end
+class ActiveOrm::Redis::HyperLogLog < ActiveOrm::Redis::Base
+  class << self
 
-  def self.count(*args)
-    client.pfcount(args)
-  end
+    def create(key, member)
+      client.pfadd(normalize_key(key), member)
+    end
 
-  def self.merge(key, *keys)
-    client.pfmerge(normalize_key(key), keys)
-  end
+    def count(*args)
+      client.pfcount(args)
+    end
 
+    def merge(key, *keys)
+      client.pfmerge(normalize_key(key), keys)
+    end
+
+  end
 end

data/lib/active_orm/redis/key.rb

@@ -1,91 +1,95 @@
-class ActiveOrm::Redis::Key < ActiveOrm::Redis
+# frozen_string_literal: true
 
-  def self.exists?(key)
-    client.exists(normalize_key(key))
-  end
+class ActiveOrm::Redis::Key < ActiveOrm::Redis::Base
+  class << self
 
-  def self.type?(key)
-    client.type(normalize_key(key))
-  end
+    def exists?(key)
+      client.exists(normalize_key(key))
+    end
 
-  def self.ttl?(key, format = :seconds)
-    normalized_key = normalize_key(key)
+    def type?(key)
+      client.type(normalize_key(key))
+    end
 
-    seconds?(format) ? client.ttl(normalized_key) : client.pttl(normalized_key)
-  end
+    def ttl?(key, format = :seconds)
+      normalized_key = normalize_key(key)
 
-  def self.sort(key, opts = {})
-    client.sort(normalize_key(key), opts)
-  end
+      seconds?(format) ? client.ttl(normalized_key) : client.pttl(normalized_key)
+    end
 
-  def self.sample
-    client.randomkey
-  end
+    def sort(key, opts = {})
+      client.sort(normalize_key(key), opts)
+    end
 
-  def self.rename(key, value)
-    client.rename(normalize_key(key), value.to_s)
-  end
+    def sample
+      client.randomkey
+    end
 
-  def self.rename!(key, value)
-    client.renamenx(normalize_key(key), value.to_s)
-  end
+    def rename(key, value)
+      client.rename(normalize_key(key), value.to_s)
+    end
 
-  def self.destroy(key)
-    client.del(normalize_key(key))
-  end
+    def rename!(key, value)
+      client.renamenx(normalize_key(key), value.to_s)
+    end
 
-  def self.persist(key)
-    client.persist(normalize_key(key))
-  end
+    def destroy(key)
+      client.del(normalize_key(key))
+    end
+
+    def persist(key)
+      client.persist(normalize_key(key))
+    end
 
-  def self.expire(key, seconds, format = :seconds)
-    normalized_key = normalize_key(key)
+    def expire(key, seconds, format = :seconds)
+      normalized_key = normalize_key(key)
 
-    if seconds?(format)
-      client.expire(normalized_key, seconds)
-    else
-      client.pexpire(normalized_key, seconds)
+      if seconds?(format)
+        client.expire(normalized_key, seconds)
+      else
+        client.pexpire(normalized_key, seconds)
+      end
     end
-  end
 
-  def self.expire_at(key, seconds, format = :seconds)
-    normalized_key = normalize_key(key)
+    def expire_at(key, seconds, format = :seconds)
+      normalized_key = normalize_key(key)
 
-    if seconds?(format)
-      client.expireat(normalized_key, seconds)
-    else
-      client.pexpireat(normalized_key, seconds)
+      if seconds?(format)
+        client.expireat(normalized_key, seconds)
+      else
+        client.pexpireat(normalized_key, seconds)
+      end
     end
-  end
 
-  def self.dump(key)
-    client.dump(normalize_key(key))
-  end
+    def dump(key)
+      client.dump(normalize_key(key))
+    end
 
-  def self.match(pattern = '*')
-    value = client.keys(normalize_key(pattern))
-    value = nil if value.empty?
-    value
-  end
+    def match(pattern = '*')
+      value = client.keys(normalize_key(pattern))
+      value = nil if value.empty?
+      value
+    end
 
-  def self.migrate(key, options)
-    client.migrate(normalize_key(key), options)
-  end
+    def migrate(key, options)
+      client.migrate(normalize_key(key), options)
+    end
 
-  def self.move(key, destination)
-    client.move(normalize_key(key), destination)
-  end
+    def move(key, destination)
+      client.move(normalize_key(key), destination)
+    end
 
-  def self.object(*args)
-    client.object(args)
-  end
+    def object(*args)
+      client.object(args)
+    end
 
-  def self.restore(key, milliseconds, value)
-    client.restore(normalize_key(key), milliseconds, value)
-  end
+    def restore(key, milliseconds, value)
+      client.restore(normalize_key(key), milliseconds, value)
+    end
 
-  def self.scan(cursor, opts = {})
-    client.scan(cursor, opts)
-  end
+    def scan(cursor, opts = {})
+      client.scan(cursor, opts)
+    end
 
+  end
 end

data/lib/active_orm/redis/list.rb

@@ -1,125 +1,129 @@
-class ActiveOrm::Redis::List < ActiveOrm::Redis
+# frozen_string_literal: true
+
+class ActiveOrm::Redis::List < ActiveOrm::Redis::Base
+  class << self
+
+    def find(key, position = 1)
+      value = client.lindex(normalize_key(key), (position - 1))
+      value = metamorph(value) if evaluate?
+      value
+    end
+
+    def first(key, limit = 1)
+      value = client.lrange(normalize_key(key), 0, -1)
+      value = (limit == 1 ? value.first : value.first(limit))
+      value = metamorph(value) if evaluate?
+      value
+    end
+
+    def last(key, limit = 1)
+      value = client.lrange(normalize_key(key), 0, -1)
+      value = (limit == 1 ? value.last : value.last(limit))
+      value = metamorph(value) if evaluate?
+      value
+    end
+
+    def between(key, start = 1, finish = 0)
+      value = client.lrange(normalize_key(key), (start - 1), (finish - 1))
+      metatransform(value)
+    end
+
+    def all(key)
+      value = client.lrange(normalize_key(key), 0, -1)
+      metatransform(value)
+    end
+
+    def count(key)
+      client.llen(normalize_key(key))
+    end
+
+    def create(key, value, order = :prepend)
+      normalized_key = normalize_key(key)
+
+      append?(order) ? client.rpush(normalized_key, value) : client.lpush(normalized_key, value)
+    end
+
+    def create!(key, value, order = :prepend)
+      normalized_key = normalize_key(key)
+
+      append?(order) ? client.rpushx(normalized_key, value) : client.lpushx(normalized_key, value)
+    end
+
+    def create_limit(key, value, limit, order = :prepend)
+      normalized_key = normalize_key(key)
+
+      append?(order) ? client.rpush(normalized_key, value) : client.lpush(normalized_key, value)
+      client.ltrim(normalized_key, 0, (limit - 1))
+    end
+
+    def create_limit!(key, value, limit, order = :prepend)
+      normalized_key = normalize_key(key)
+
+      append?(order) ? client.rpushx(normalized_key, value) : client.lpushx(normalized_key, value)
+      client.ltrim(normalized_key, 0, (limit - 1))
+    end
+
+    def create_before(key, pivot, value)
+      client.linsert(normalize_key(key), :before, pivot, value)
+    end
+
+    def create_after(key, pivot, value)
+      client.linsert(normalize_key(key), :after, pivot, value)
+    end
+
+    def update(key, index, value)
+      client.lset(normalize_key(key), index, value)
+    end
+
+    def move(key, desination)
+      value = client.rpoplpush(normalize_key(key), normalize_key(desination))
+      value = metamorph(value) if evaluate?
+      value
+    end
+
+    def move_blocking(key, desination)
+      value = brpoplpush(normalize_key(key), normalize_key(desination))
+      value = metamorph(value) if evaluate?
+      value
+    end
+
+    def destroy(key, count, value)
+      client.lrem(normalize_key(key), count, value)
+    end
+
+    def destroy_first(key, limit = 1)
+      client.ltrim(normalize_key(key), limit, -1)
+    end
+
+    def destroy_last(key, limit = 1)
+      client.ltrim(normalize_key(key), 0, -(limit + 1))
+    end
+
+    def destroy_except(key, start, finish)
+      client.ltrim(normalize_key(key), (start - 1), (finish - 1))
+    end
+
+    def destroy_all(key)
+      client.ltrim(normalize_key(key), -1, 0)
+    end
+
+    def pop(key, order = :prepend)
+      value = append?(order) ? client.rpop(key) : client.lpop(key)
+      value = metamorph(value) if evaluate?
+      value
+    end
+
+    def pop_blocking(keys, opts = {})
+      timeout = opts[:timeout] || 0
+      value = if append?(opts[:order] || :prepend)
+                client.brpop(keys, timeout)
+              else
+                client.blpop(keys, timeout)
+              end
 
-  def self.find(key, position = 1)
-    value = client.lindex(normalize_key(key), (position - 1))
-    value = metamorph(value) if evaluate?
-    value
-  end
-
-  def self.first(key, limit = 1)
-    value = client.lrange(normalize_key(key), 0, -1)
-    value = (limit == 1 ? value.first : value.first(limit))
-    value = metamorph(value) if evaluate?
-    value
-  end
-
-  def self.last(key, limit = 1)
-    value = client.lrange(normalize_key(key), 0, -1)
-    value = (limit == 1 ? value.last : value.last(limit))
-    value = metamorph(value) if evaluate?
-    value
-  end
-
-  def self.between(key, start = 1, finish = 0)
-    value = client.lrange(normalize_key(key), (start - 1), (finish - 1))
-    metatransform(value)
-  end
-
-  def self.all(key)
-    value = client.lrange(normalize_key(key), 0, -1)
-    metatransform(value)
-  end
-
-  def self.count(key)
-    client.llen(normalize_key(key))
-  end
-
-  def self.create(key, value, order = :prepend)
-    normalized_key = normalize_key(key)
+      value = metamorph(value) if evaluate?
+      value
+    end
 
-    append?(order) ? client.rpush(normalized_key, value) : client.lpush(normalized_key, value)
   end
-
-  def self.create!(key, value, order = :prepend)
-    normalized_key = normalize_key(key)
-
-    append?(order) ? client.rpushx(normalized_key, value) : client.lpushx(normalized_key, value)
-  end
-
-  def self.create_limit(key, value, limit, order = :prepend)
-    normalized_key = normalize_key(key)
-
-    append?(order) ? client.rpush(normalized_key, value) : client.lpush(normalized_key, value)
-    client.ltrim(normalized_key, 0, (limit - 1))
-  end
-
-  def self.create_limit!(key, value, limit, order = :prepend)
-    normalized_key = normalize_key(key)
-
-    append?(order) ? client.rpushx(normalized_key, value) : client.lpushx(normalized_key, value)
-    client.ltrim(normalized_key, 0, (limit - 1))
-  end
-
-  def self.create_before(key, pivot, value)
-    client.linsert(normalize_key(key), :before, pivot, value)
-  end
-
-  def self.create_after(key, pivot, value)
-    client.linsert(normalize_key(key), :after, pivot, value)
-  end
-
-  def self.update(key, index, value)
-    client.lset(normalize_key(key), index, value)
-  end
-
-  def self.move(key, desination)
-    value = client.rpoplpush(normalize_key(key), normalize_key(desination))
-    value = metamorph(value) if evaluate?
-    value
-  end
-
-  def self.move_blocking(key, desination)
-    value = brpoplpush(normalize_key(key), normalize_key(desination))
-    value = metamorph(value) if evaluate?
-    value
-  end
-
-  def self.destroy(key, count, value)
-    client.lrem(normalize_key(key), count, value)
-  end
-
-  def self.destroy_first(key, limit = 1)
-    client.ltrim(normalize_key(key), limit, -1)
-  end
-
-  def self.destroy_last(key, limit = 1)
-    client.ltrim(normalize_key(key), 0, -(limit + 1))
-  end
-
-  def self.destroy_except(key, start, finish)
-    client.ltrim(normalize_key(key), (start - 1), (finish - 1))
-  end
-
-  def self.destroy_all(key)
-    client.ltrim(normalize_key(key), -1, 0)
-  end
-
-  def self.pop(key, order = :prepend)
-    value = append?(order) ? client.rpop(key) : client.lpop(key)
-    value = metamorph(value) if evaluate?
-    value
-  end
-
-  def self.pop_blocking(keys, opts = {})
-    timeout = opts[:timeout] || 0
-    value = if append?(opts[:order] || :prepend)
-              client.brpop(keys, timeout)
-            else
-              client.blpop(keys, timeout)
-            end
-
-    value = metamorph(value) if evaluate?
-    value
-  end
-
 end