rdkit 0.0.1 → 0.1.4

data/lib/rdkit/configuration.rb

@@ -0,0 +1,31 @@
+module RDKit
+  class Configuration
+    attr_reader :config
+
+    def initialize
+      @config = {}
+    end
+
+    module ClassMethods
+      @@instance = Configuration.new
+
+      def reset
+        @@instance = Configuration.new
+      end
+
+      def get(key)
+        @@instance.config[key]
+      end
+
+      def get_i(key)
+        @@instance.config[key] ? @@instance.config[key].to_i : -1
+      end
+
+      def set(key, value)
+        @@instance.config[key] = value
+      end
+    end
+
+    class << self; include ClassMethods; end
+  end
+end

data/lib/rdkit/core.rb

@@ -1,13 +1,11 @@
 module RDKit
   class Core
-    include Inheritable
-
     def tick!
       raise ShouldOverrideError
     end
 
-    def introspection
-      raise ShouldOverrideError
+    def server
+      Server.instance
     end
   end
 end

data/lib/rdkit/core_ext.rb

@@ -0,0 +1,7 @@
+class Object
+  unless self.respond_to?(:try)
+    def try(method, *args)
+      __send__(method, *args) rescue nil
+    end
+  end
+end

data/lib/rdkit/db.rb

@@ -0,0 +1,257 @@
+module RDKit
+  class DB
+    attr_reader :index
+
+    def initialize(index=0)
+      @index = index
+
+      flush!
+    end
+
+    def flush!
+      @objects = {}
+    end
+
+    module StringMethods
+      def get(key)
+        if object = get_typed_object(key, :string)
+          object.value
+        end
+      end
+
+      def set(key, value)
+        objects[key] = RDObject.string(value)
+      end
+
+      def getset(key, new_value)
+        objects[key].try(:value).tap { set(key, new_value) }
+      end
+
+      def setnx(key, value)
+        if objects[key]
+          false
+        else
+          set(key, value)
+          true
+        end
+      end
+    end
+    include StringMethods
+
+    module KeyMethods
+      def del(keys)
+        keys.select { |key| objects.delete(key) }.count
+      end
+
+      def filter_keys(pattern)
+        objects.keys
+      end
+
+      def exists?(key)
+        objects.include?(key)
+      end
+
+      def type(key)
+        objects[key].type.to_s rescue 'none'
+      end
+    end
+    include KeyMethods
+
+    module ListMethods
+      def lpush(key, elements)
+        if list = get_typed_object(key, :list)
+          list.unshift(*elements)
+
+          list.length
+        else
+          # key not exist
+          objects[key] = RDObject.list(elements)
+
+          objects[key].length
+        end
+      end
+
+      def llen(key)
+        if list = get_typed_object(key, :list)
+
+          list.length
+        else
+          0
+        end
+      end
+
+      def lrange(key, start, stop)
+        if list = get_typed_object(key, :list)
+
+          list[start..stop]
+        else
+          []
+        end
+      end
+
+      def lpop(key)
+        if list = get_typed_object(key, :list)
+
+          result = list.shift
+
+          del([key]) if list.empty?
+
+          result
+        else
+          nil
+        end
+      end
+
+      def rpop(key)
+        if list = get_typed_object(key, :list)
+
+          result = list.pop
+
+          del([key]) if list.empty?
+
+          result
+        else
+          nil
+        end
+      end
+    end
+    include ListMethods
+
+    module SetMethods
+      def sadd(key, elements)
+        if set = get_typed_object(key, :set)
+          size0 = set.size
+
+          elements.each { |e| set.add(e) }
+
+          set.size - size0
+        else
+          objects[key] = RDObject.set(elements)
+
+          objects[key].size
+        end
+      end
+
+      def scard(key)
+        if set = get_typed_object(key, :set)
+
+          set.size
+        else
+          0
+        end
+      end
+
+      def smembers(key)
+        if set = get_typed_object(key, :set)
+
+          set.to_a
+        else
+          []
+        end
+      end
+
+      def sismember(key, value)
+        if set = get_typed_object(key, :set)
+
+          set.include?(value) ? 1 : 0
+        else
+          0
+        end
+      end
+
+      def srem(key, elements)
+        if set = get_typed_object(key, :set)
+          size0 = set.size
+
+          elements.each { |e| set.delete(e) }
+
+          size0 - set.size
+        else
+          0
+        end
+      end
+    end
+    include SetMethods
+
+    module HashMethods
+      def hset(key, field, value)
+        if hash = get_typed_object(key, :hash)
+          existed = hash.has_key?(field) ? 0 : 1
+
+          hash[field] = value
+
+          existed
+        else
+          objects[key] = RDObject.create_hash(field, value)
+
+          1
+        end
+      end
+
+      def hget(key, field)
+        if hash = get_typed_object(key, :hash)
+          hash[field]
+        end
+      end
+
+      def hexists?(key, field)
+        if hash = get_typed_object(key, :hash)
+          hash.has_key?(field)
+        else
+          false
+        end
+      end
+
+      def hlen(key)
+        if hash = get_typed_object(key, :hash)
+          hash.size
+        else
+          0
+        end
+      end
+
+      def hdel(key, fields)
+        if hash = get_typed_object(key, :hash)
+          size0 = hash.size
+
+          fields.each { |f| hash.delete(f) }
+
+          size0 - hash.size
+        else
+          0
+        end
+      end
+
+      def hkeys(key)
+        if hash = get_typed_object(key, :hash)
+          hash.keys
+        else
+          []
+        end
+      end
+
+      def hvals(key)
+        if hash = get_typed_object(key, :hash)
+          hash.values
+        else
+          []
+        end
+      end
+    end
+    include HashMethods
+
+    private
+
+    def objects
+      @objects
+    end
+
+    def get_typed_object(key, type)
+      if object = objects[key]
+        raise WrongTypeError unless object.type == type
+
+        object
+      end
+    end
+  end
+end

data/lib/rdkit/db_commands.rb

@@ -0,0 +1,182 @@
+module RDKit
+  module DBCommands
+    def select(index)
+      raise InvalidDBIndexError unless (0..15).map(&:to_s).include?(index)
+
+      index = index.to_i
+
+      server.select_db!(index)
+
+      'OK'
+    end
+
+    module StringCommands
+      def get(key)
+        db.get(key)
+      end
+
+      def set(key, value)
+        db.set(key, value)
+
+        'OK'
+      end
+
+      def setnx(key, value)
+        db.setnx(key, value)
+      end
+
+      def getset(key, new_value)
+        db.getset(key, new_value)
+      end
+
+      def mget(key, *more_keys)
+        ([key] + more_keys).map { |k| db.get(k) rescue nil }
+      end
+
+      def mset(key, value, *more_pairs)
+        unless more_pairs.size % 2 == 0
+          raise WrongNumberOfArgumentError, "wrong number of arguments for 'mset' command"
+        end
+
+        db.set(key, value)
+        more_pairs.each_slice(2) { |key, value| db.set(key, value) }
+
+        'OK'
+      end
+
+      def strlen(key)
+        if str = db.get(key)
+          str.bytesize
+        else
+          0
+        end
+      end
+    end
+    include StringCommands
+
+    module ListCommands
+      def lpush(key, value, *more_values)
+        db.lpush(key, [value] + more_values)
+      end
+
+      def llen(key)
+        db.llen(key)
+      end
+
+      def lrange(key, start, stop)
+        db.lrange(key, start, stop)
+      end
+
+      def lpop(key)
+        db.lpop(key)
+      end
+
+      def rpop(key)
+        db.rpop(key)
+      end
+    end
+    include ListCommands
+
+    module SetCommands
+      def sadd(key, value, *more_values)
+        db.sadd(key, [value] + more_values)
+      end
+
+      def scard(key)
+        db.scard(key)
+      end
+
+      def smembers(key)
+        db.smembers(key)
+      end
+
+      def sismember(key, value)
+        db.sismember(key, value)
+      end
+
+      def srem(key, value, *more_values)
+        db.srem(key, [value] + more_values).tap { db.del([key]) if db.scard(key) == 0 }
+      end
+    end
+    include SetCommands
+
+    module HashCommands
+      def hset(key, field, value)
+        db.hset(key, field, value)
+      end
+
+      def hget(key, field)
+        db.hget(key, field)
+      end
+
+      def hexists(key, field)
+        db.hexists?(key, field)
+      end
+
+      def hlen(key)
+        db.hlen(key)
+      end
+
+      def hstrlen(key, field)
+        if str = db.hget(key, field)
+          str.bytesize
+        else
+          0
+        end
+      end
+
+      def hdel(key, field, *more_fields)
+        db.hdel(key, [field] + more_fields).tap { db.del([key]) if db.hlen(key) == 0 }
+      end
+
+      def hkeys(key)
+        db.hkeys(key)
+      end
+
+      def hvals(key)
+        db.hvals(key)
+      end
+    end
+    include HashCommands
+
+    module KeyCommands
+      def del(key, *more_keys)
+        db.del(more_keys.unshift(key))
+      end
+
+      def keys(pattern)
+        db.filter_keys(pattern)
+      end
+
+      def exists(key)
+        db.exists?(key)
+      end
+
+      def type(key)
+        db.type(key)
+      end
+    end
+    include KeyCommands
+
+    module ServerCommands
+      def flushdb
+        server.flushdb!
+
+        'OK'
+      end
+
+      def flushall
+        server.flushall!
+
+        'OK'
+      end
+    end
+    include ServerCommands
+
+    private
+
+    def db
+      server.current_db
+    end
+  end
+end