lib/rediska/driver.rb in rediska-0.0.11 vs lib/rediska/driver.rb in rediska-0.1.0

@@ -1,8 +1,8 @@
 module Rediska
   module Driver
-    attr_accessor :buffer, :database_id
+    attr_accessor :database_id
     attr_writer :replies
 
     def replies
       @replies ||= []
     end
@@ -18,39 +18,18 @@
     end
 
     def timeout=(usecs)
     end
 
-    def write(command)
-      meffod = command.shift.to_s.downcase.to_sym
-      if respond_to?(meffod)
-        reply = send(meffod, *command)
-      else
-        raise Redis::CommandError, "ERR unknown command #{meffod.upcase}"
-      end
-
-      if reply == true
-        reply = 1
-      elsif reply == false
-        reply = 0
-      end
-
-      replies << reply
-      buffer << reply if buffer && meffod != :multi
-      nil
-    end
-
     def read
       replies.shift
     end
 
     # NOT IMPLEMENTED:
     # * blpop
     # * brpop
     # * brpoplpush
-    # * discard
-    # * sort
     # * subscribe
     # * psubscribe
     # * publish
 
     def flushdb
@@ -157,12 +136,13 @@
     end
 
     def hdel(key, field)
       field = field.to_s
       data_type_check(key, Hash)
-      data[key] && data[key].delete(field)
+      deleted = data[key] && data[key].delete(field)
       remove_key_for_empty_collection(key)
+      deleted ? 1 : 0
     end
 
     def hkeys(key)
       data_type_check(key, Hash)
       return [] if data[key].nil?
@@ -305,11 +285,11 @@
     end
 
     def rpoplpush(key1, key2)
       data_type_check(key1, Array)
       rpop(key1).tap do |elem|
-        lpush(key2, elem)
+        lpush(key2, elem) unless elem.nil?
       end
     end
 
     def lpop(key)
       data_type_check(key, Array)
@@ -588,13 +568,27 @@
 
     def []=(key, value)
       set(key, value)
     end
 
-    def set(key, value)
+    def set(key, value, *array_options)
+      option_nx = array_options.delete('NX')
+      option_xx = array_options.delete('XX')
+
+      return false if option_nx && option_xx
+
+      return false if option_nx && exists(key)
+      return false if option_xx && !exists(key)
+
       data[key] = value.to_s
 
+      options = Hash[array_options.each_slice(2).to_a]
+      ttl_in_seconds = options['EX'] if options['EX']
+      ttl_in_seconds = options['PX'] / 1000.0 if options['PX']
+
+      expire(key, ttl_in_seconds) if ttl_in_seconds
+
       'OK'
     end
 
     def setbit(key, offset, bit)
       old_val = data[key] ? data[key].unpack('B*')[0].split('') : []
@@ -644,14 +638,10 @@
       return false if keys.any?{|key| data.key?(key) }
       mset(*pairs)
       true
     end
 
-    def sort(key)
-      # TODO: Implement
-    end
-
     def incr(key)
       data.merge!({ key => (data[key].to_i + 1).to_s || '1'})
       data[key].to_i
     end
 
@@ -688,29 +678,10 @@
     end
 
     def slaveof(host, port)
     end
 
-    def exec
-      buffer.tap {|x| self.buffer = nil }
-    end
-
-    def multi
-      self.buffer = []
-      yield if block_given?
-
-      'OK'
-    end
-
-    def watch(_)
-      'OK'
-    end
-
-    def unwatch
-      'OK'
-    end
-
     def scan(start_cursor, *args)
       match = '*'
       count = 10
 
       if args.size.odd?
@@ -894,10 +865,21 @@
       range = data[key].select_by_score(min, max)
       range.each {|k,_| data[key].delete(k) }
       range.size
     end
 
+    def zremrangebyrank(key, start, stop)
+      data_type_check(key, ZSet)
+      return 0 unless data[key]
+
+      sorted_elements = data[key].sort_by { |k, v| v }
+      start = sorted_elements.length if start > sorted_elements.length
+      elements_to_delete = sorted_elements[start..stop]
+      elements_to_delete.each { |elem, rank| data[key].delete(elem) }
+      elements_to_delete.size
+    end
+
     def zinterstore(out, *args)
       data_type_check(out, ZSet)
       args_handler = SortedSetArgumentHandler.new(args)
       data[out] = SortedSetIntersectStore.new(args_handler, data).call
       data[out].size
@@ -906,17 +888,9 @@
     def zunionstore(out, *args)
       data_type_check(out, ZSet)
       args_handler = SortedSetArgumentHandler.new(args)
       data[out] = SortedSetUnionStore.new(args_handler, data).call
       data[out].size
-    end
-
-    def zremrangebyrank(key, start, stop)
-      sorted_elements = data[key].sort_by { |k, v| v }
-      start = sorted_elements.length if start > sorted_elements.length
-      elements_to_delete = sorted_elements[start..stop]
-      elements_to_delete.each { |elem, rank| data[key].delete(elem) }
-      elements_to_delete.size
     end
 
     private
     def raise_argument_error(command, match_string = command)
       error_message = if %w(hmset mset_odd).include?(match_string.downcase)