active_orm 4.0.3 → 5.0.0

data/lib/active_orm/redis/pub_sub.rb

@@ -1,31 +1,35 @@
-class ActiveOrm::Redis::PubSub < ActiveOrm::Redis
+# frozen_string_literal: true
 
-  def self.publish(channel, message)
-    client.publish(channel, message)
-  end
+class ActiveOrm::Redis::PubSub < ActiveOrm::Redis::Base
+  class << self
 
-  def self.subscribed?
-    client.subscribed?
-  end
+    def publish(channel, message)
+      client.publish(channel, message)
+    end
 
-  def self.subscribe(*channels, &block)
-    client.subscribe(channels, &block)
-  end
+    def subscribed?
+      client.subscribed?
+    end
 
-  def self.unsubscribe(*channels)
-    client.unsubscribe(channels)
-  end
+    def subscribe(*channels, &block)
+      client.subscribe(channels, &block)
+    end
 
-  def self.match_subscribe(*channels, &block)
-    client.psubscribe(channels, &block)
-  end
+    def unsubscribe(*channels)
+      client.unsubscribe(channels)
+    end
 
-  def self.match_unsubscribe(*channels)
-    client.punsubscribe(channels)
-  end
+    def match_subscribe(*channels, &block)
+      client.psubscribe(channels, &block)
+    end
 
-  def self.state(command, *args)
-    client.pubsub(command, args)
-  end
+    def match_unsubscribe(*channels)
+      client.punsubscribe(channels)
+    end
 
+    def state(command, *args)
+      client.pubsub(command, args)
+    end
+
+  end
 end

data/lib/active_orm/redis/script.rb

@@ -1,15 +1,19 @@
-class ActiveOrm::Redis::Script < ActiveOrm::Redis
+# frozen_string_literal: true
 
-  def self.script(command, *args)
-    client.script(command, args)
-  end
+class ActiveOrm::Redis::Script < ActiveOrm::Redis::Base
+  class << self
 
-  def self.eval(*args)
-    client.eval(:eval, args)
-  end
+    def script(command, *args)
+      client.script(command, args)
+    end
 
-  def self.evalsha(*args)
-    client.eval(:evalsha, args)
-  end
+    def eval(*args)
+      client.eval(:eval, args)
+    end
 
+    def evalsha(*args)
+      client.eval(:evalsha, args)
+    end
+
+  end
 end

data/lib/active_orm/redis/set.rb

@@ -1,68 +1,72 @@
-class ActiveOrm::Redis::Set < ActiveOrm::Redis
+# frozen_string_literal: true
 
-  def self.find(key)
-    value = client.smembers(normalize_key(key))
-    metatransform(value)
-  end
+class ActiveOrm::Redis::Set < ActiveOrm::Redis::Base
+  class << self
 
-  def self.combine(*args)
-    value = client.sunion(*args)
-    metatransform(value)
-  end
+    def find(key)
+      value = client.smembers(normalize_key(key))
+      metatransform(value)
+    end
 
-  def self.difference(*args)
-    value = client.sdiff(*args)
-    metatransform(value)
-  end
+    def combine(*args)
+      value = client.sunion(*args)
+      metatransform(value)
+    end
 
-  def self.intersection(key, *args)
-    value = client.sinter(normalize_key(key), *args)
-    metatransform(value)
-  end
+    def difference(*args)
+      value = client.sdiff(*args)
+      metatransform(value)
+    end
 
-  def self.sample(key, value = 1)
-    value = client.srandmember(normalize_key(key), value)
-    metatransform(value)
-  end
+    def intersection(key, *args)
+      value = client.sinter(normalize_key(key), *args)
+      metatransform(value)
+    end
 
-  def self.value?(key, value)
-    client.sismember(normalize_key(key), value)
-  end
+    def sample(key, value = 1)
+      value = client.srandmember(normalize_key(key), value)
+      metatransform(value)
+    end
 
-  def self.count(key)
-    client.scard(normalize_key(key))
-  end
+    def value?(key, value)
+      client.sismember(normalize_key(key), value)
+    end
 
-  def self.create(key, *args)
-    client.sadd(normalize_key(key), args)
-  end
+    def count(key)
+      client.scard(normalize_key(key))
+    end
 
-  def self.create_combination(key, *args)
-    client.sunionstore(normalize_key(key), args)
-  end
+    def create(key, *args)
+      client.sadd(normalize_key(key), args)
+    end
 
-  def self.create_difference(key, *args)
-    client.sdiffstore(normalize_key(key), *args)
-  end
+    def create_combination(key, *args)
+      client.sunionstore(normalize_key(key), args)
+    end
 
-  def self.create_intersection(key, *args)
-    client.sinterstore(normalize_key(key), args)
-  end
+    def create_difference(key, *args)
+      client.sdiffstore(normalize_key(key), *args)
+    end
 
-  def self.move(key, destination, value)
-    client.smove(normalize_key(key), destination.to_s, value)
-  end
+    def create_intersection(key, *args)
+      client.sinterstore(normalize_key(key), args)
+    end
 
-  def self.destroy(key, *args)
-    client.srem(normalize_key(key), *args)
-  end
+    def move(key, destination, value)
+      client.smove(normalize_key(key), destination.to_s, value)
+    end
 
-  def self.destroy_random(key)
-    client.spop(normalize_key(key))
-  end
+    def destroy(key, *args)
+      client.srem(normalize_key(key), *args)
+    end
 
-  def self.scan(key, cursor, opts = {})
-    client.sscan(normalize_key(key), cursor, opts)
-  end
+    def destroy_random(key)
+      client.spop(normalize_key(key))
+    end
 
+    def scan(key, cursor, opts = {})
+      client.sscan(normalize_key(key), cursor, opts)
+    end
+
+  end
 end

data/lib/active_orm/redis/sorted_set.rb

@@ -1,149 +1,153 @@
-class ActiveOrm::Redis::SortedSet < ActiveOrm::Redis
+# frozen_string_literal: true
+
+class ActiveOrm::Redis::SortedSet < ActiveOrm::Redis::Base
+  class << self
+
+    def find(key, position, opts = {})
+      position -= 1
+
+      value = client.zrange(normalize_key(key), position, position, opts)
+      value = value.first
+      value = metamorph(value) if evaluate?
+      value
+    end
+
+    def find_score(key, position, opts = {})
+      value = client.zrangebyscore(normalize_key(key), position, position, opts)
+      value = value.first
+      value = metamorph(value) if evaluate?
+      value
+    end
+
+    def first(key, opts = {})
+      value = client.zrange(normalize_key(key), 0, 0, opts)
+      value = value.first
+      value = metamorph(value) if evaluate?
+      value
+    end
+
+    def first_score(key, opts = {})
+      value = client.zrangebyscore(normalize_key(key), 1, 1, opts)
+      value = value.first
+      value = metamorph(value) if evaluate?
+      value
+    end
+
+    def last(key, opts = {})
+      value = client.zrevrange(normalize_key(key), 0, 0, opts)
+      value = value.first
+      value = metamorph(value) if evaluate?
+      value
+    end
+
+    def last_score(key, opts = {})
+      value = client.zrevrangebyscore(normalize_key(key), 1, 1, opts)
+      value = value.first
+      value = metamorph(value) if evaluate?
+      value
+    end
+
+    def between(key, start, finish, opts = {})
+      value = client.zrange(normalize_key(key), (start - 1), (finish - 1), opts)
+      value = metatransform(value)
+      value
+    end
+
+    def between_reverse(key, start, finish, opts = {})
+      value = client.zrevrange(normalize_key(key), (start - 1), (finish - 1), opts)
+      value = metatransform(value)
+      value
+    end
+
+    def between_scores(key, min, max, opts = {})
+      value = client.zrangebyscore(normalize_key(key), min, max, opts)
+      value = metatransform(value)
+      value
+    end
+
+    def between_scores_reverse(key, min, max, opts = {})
+      value = client.zrevrangebyscore(normalize_key(key), min, max, opts)
+      value = metatransform(value)
+      value
+    end
+
+    def between_lex(key, min, max, opts = {})
+      value = client.zrangebylex(normalize_key(key), min, max, opts)
+      value = metatransform(value)
+      value
+    end
+
+    def between_lex_reverse(key, min, max, opts = {})
+      value = client.zrevrangebylex(normalize_key(key), min, max, opts)
+      value = metatransform(value)
+      value
+    end
+
+    def all(key, opts = {})
+      value = client.zrange(normalize_key(key), '-inf', '+inf', opts)
+      value = metatransform(value)
+      value
+    end
+
+    def position(key, value)
+      value = client.zrank(normalize_key(key), value)
+      value += 1 unless value.nil?
+      value
+    end
+
+    def position_reverse(key, value)
+      value = client.zrevrank(normalize_key(key), value)
+      value += 1 unless value.nil?
+      value
+    end
+
+    def score(key, value)
+      client.zscore(normalize_key(key), value)
+    end
+
+    def count(key)
+      client.zcard(normalize_key(key))
+    end
+
+    def count_between(key, min, max)
+      client.zcount(normalize_key(key), min, max)
+    end
+
+    def create(key, *args)
+      client.zadd(normalize_key(key), args)
+    end
+
+    def create_intersection(key, keys, opts = {})
+      client.zinterstore(normalize_key(key), keys, opts)
+    end
+
+    def create_combination(key, keys, opts = {})
+      client.zunionstore(normalize_key(key), keys, opts)
+    end
+
+    def increment(key, value, count)
+      client.zincrby(normalize_key(key), count, value)
+    end
+
+    def destroy(key, at)
+      client.zrem(normalize_key(key), at)
+    end
+
+    def destroy_between(key, start, finish)
+      client.zremrangebyrank(normalize_key(key), (start - 1), (finish - 1))
+    end
+
+    def destroy_scores(key, min, max)
+      client.zremrangebyscore(normalize_key(key), min, max)
+    end
+
+    def destroy_lex(key, min, max, opts = {})
+      client.zrevrangebylex(normalize_key(key), max, min, opts)
+    end
+
+    def scan(key, cursor, opts = {})
+      client.zscan(normalize_key(key), cursor, opts)
+    end
 
-  def self.find(key, position, opts = {})
-    position -= 1
-
-    value = client.zrange(normalize_key(key), position, position, opts)
-    value = value.first
-    value = metamorph(value) if evaluate?
-    value
-  end
-
-  def self.find_score(key, position, opts = {})
-    value = client.zrangebyscore(normalize_key(key), position, position, opts)
-    value = value.first
-    value = metamorph(value) if evaluate?
-    value
-  end
-
-  def self.first(key, opts = {})
-    value = client.zrange(normalize_key(key), 0, 0, opts)
-    value = value.first
-    value = metamorph(value) if evaluate?
-    value
-  end
-
-  def self.first_score(key, opts = {})
-    value = client.zrangebyscore(normalize_key(key), 1, 1, opts)
-    value = value.first
-    value = metamorph(value) if evaluate?
-    value
-  end
-
-  def self.last(key, opts = {})
-    value = client.zrevrange(normalize_key(key), 0, 0, opts)
-    value = value.first
-    value = metamorph(value) if evaluate?
-    value
-  end
-
-  def self.last_score(key, opts = {})
-    value = client.zrevrangebyscore(normalize_key(key), 1, 1, opts)
-    value = value.first
-    value = metamorph(value) if evaluate?
-    value
-  end
-
-  def self.between(key, start, finish, opts = {})
-    value = client.zrange(normalize_key(key), (start - 1), (finish - 1), opts)
-    value = metatransform(value)
-    value
-  end
-
-  def self.between_reverse(key, start, finish, opts = {})
-    value = client.zrevrange(normalize_key(key), (start - 1), (finish - 1), opts)
-    value = metatransform(value)
-    value
-  end
-
-  def self.between_scores(key, min, max, opts = {})
-    value = client.zrangebyscore(normalize_key(key), min, max, opts)
-    value = metatransform(value)
-    value
-  end
-
-  def self.between_scores_reverse(key, min, max, opts = {})
-    value = client.zrevrangebyscore(normalize_key(key), min, max, opts)
-    value = metatransform(value)
-    value
-  end
-
-  def self.between_lex(key, min, max, opts = {})
-    value = client.zrangebylex(normalize_key(key), min, max, opts)
-    value = metatransform(value)
-    value
-  end
-
-  def self.between_lex_reverse(key, min, max, opts = {})
-    value = client.zrevrangebylex(normalize_key(key), min, max, opts)
-    value = metatransform(value)
-    value
-  end
-
-  def self.all(key, opts = {})
-    value = client.zrange(normalize_key(key), '-inf', '+inf', opts)
-    value = metatransform(value)
-    value
-  end
-
-  def self.position(key, value)
-    value = client.zrank(normalize_key(key), value)
-    value += 1 unless value.nil?
-    value
   end
-
-  def self.position_reverse(key, value)
-    value = client.zrevrank(normalize_key(key), value)
-    value += 1 unless value.nil?
-    value
-  end
-
-  def self.score(key, value)
-    client.zscore(normalize_key(key), value)
-  end
-
-  def self.count(key)
-    client.zcard(normalize_key(key))
-  end
-
-  def self.count_between(key, min, max)
-    client.zcount(normalize_key(key), min, max)
-  end
-
-  def self.create(key, *args)
-    client.zadd(normalize_key(key), args)
-  end
-
-  def self.create_intersection(key, keys, opts = {})
-    client.zinterstore(normalize_key(key), keys, opts)
-  end
-
-  def self.create_combination(key, keys, opts = {})
-    client.zunionstore(normalize_key(key), keys, opts)
-  end
-
-  def self.increment(key, value, count)
-    client.zincrby(normalize_key(key), count, value)
-  end
-
-  def self.destroy(key, at)
-    client.zrem(normalize_key(key), at)
-  end
-
-  def self.destroy_between(key, start, finish)
-    client.zremrangebyrank(normalize_key(key), (start - 1), (finish - 1))
-  end
-
-  def self.destroy_scores(key, min, max)
-    client.zremrangebyscore(normalize_key(key), min, max)
-  end
-
-  def self.destroy_lex(key, min, max, opts = {})
-    client.zrevrangebylex(normalize_key(key), max, min, opts)
-  end
-
-  def self.scan(key, cursor, opts = {})
-    client.zscan(normalize_key(key), cursor, opts)
-  end
-
 end