hiredis 0.2.0 → 0.3.0

data/lib/hiredis/ruby/reader.rb

@@ -0,0 +1,164 @@
+require "hiredis/version"
+
+module Hiredis
+  module Ruby
+    class Reader
+
+      def initialize
+        @buffer = Buffer.new
+        @task = Task.new(@buffer)
+      end
+
+      def feed(data)
+        @buffer << data
+      end
+
+      def gets
+        reply = @task.process
+        @buffer.discard!
+        reply
+      end
+
+    protected
+
+      class Task
+
+        # Use lookup table to map reply types to methods
+        method_index = {}
+        method_index[?-] = :process_error_reply
+        method_index[?+] = :process_status_reply
+        method_index[?:] = :process_integer_reply
+        method_index[?$] = :process_bulk_reply
+        method_index[?*] = :process_multi_bulk_reply
+        METHOD_INDEX = method_index.freeze
+
+        attr_accessor :parent, :child
+        attr_accessor :multi_bulk
+
+        def initialize(buffer, parent = nil, depth = 0)
+          @buffer, @parent = buffer, parent
+
+          # Require 3 nested tasks
+          @child = Task.new(@buffer, self, depth + 1) if depth < 2
+        end
+
+        def root
+          parent ? parent.root : self
+        end
+
+        def reset!
+          @line = @type = @multi_bulk = nil
+        end
+
+        def process_error_reply
+          RuntimeError.new(@line)
+        end
+
+        def process_status_reply
+          @line
+        end
+
+        def process_integer_reply
+          @line.to_i
+        end
+
+        def process_bulk_reply
+          bulk_length = @line.to_i
+          return nil if bulk_length < 0
+
+          # Caught by caller function when false
+          @buffer.read(bulk_length, 2)
+        end
+
+        def process_multi_bulk_reply
+          multi_bulk_length = @line.to_i
+
+          if multi_bulk_length > 0
+            @multi_bulk ||= []
+
+            # We know the multi bulk is not complete when this path is taken.
+            while (element = child.process) != false
+              @multi_bulk << element
+              return @multi_bulk if @multi_bulk.length == multi_bulk_length
+            end
+
+            false
+          elsif multi_bulk_length == 0
+            []
+          else
+            nil
+          end
+        end
+
+        def process_protocol_error
+          raise "Protocol error"
+        end
+
+        def process
+          @line ||= @buffer.read_line
+          return false if @line == false
+
+          @type ||= @line.slice!(0)
+          reply = send(METHOD_INDEX[@type] || :process_protocol_error)
+
+          reset! if reply != false
+          reply
+        end
+      end
+
+      class Buffer
+
+        CRLF = "\r\n".freeze
+
+        def initialize
+          @buffer = ""
+          @length = @pos = 0
+        end
+
+        def <<(data)
+          @length += data.length
+          @buffer << data
+        end
+
+        def length
+          @length
+        end
+
+        def empty?
+          @length == 0
+        end
+
+        def discard!
+          if @length == 0
+            @buffer = ""
+            @length = @pos = 0
+          else
+            if @pos >= 1024
+              @buffer.slice!(0, @pos)
+              @length -= @pos
+              @pos = 0
+            end
+          end
+        end
+
+        def read(bytes, skip = 0)
+          start = @pos
+          stop = start + bytes + skip
+          return false if @length < stop
+
+          @pos = stop
+          @buffer[start, bytes]
+        end
+
+        def read_line
+          start = @pos
+          stop = @buffer.index(CRLF, @pos)
+          return false unless stop
+
+          @pos = stop + 2 # include CRLF
+          @buffer[start, stop - start]
+        end
+      end
+    end
+  end
+end

data/lib/hiredis/version.rb

@@ -1,3 +1,3 @@
 module Hiredis
-  VERSION = "0.2.0"
+  VERSION = "0.3.0"
 end

data/vendor/hiredis/Makefile

@@ -2,7 +2,7 @@
 # Copyright (C) 2010 Salvatore Sanfilippo <antirez at gmail dot com>
 # This file is released under the BSD license, see the COPYING file
 
-OBJ = net.o hiredis.o sds.o async.o dict.o
+OBJ = net.o hiredis.o sds.o async.o
 BINS = hiredis-example hiredis-test
 
 uname_S := $(shell sh -c 'uname -s 2>/dev/null || echo not')
@@ -16,7 +16,7 @@ ifeq ($(uname_S),SunOS)
   STLIBNAME?=libhiredis.a
   STLIB_MAKE_CMD?=ar rcs ${STLIBNAME} ${OBJ}
 else ifeq ($(uname_S),Darwin)
-  CFLAGS?=-std=c99 -pedantic $(OPTIMIZATION) -fPIC -Wall -W -Wwrite-strings $(ARCH) $(PROF)
+  CFLAGS?=-std=c99 -pedantic $(OPTIMIZATION) -fPIC -Wall -W -Wstrict-prototypes -Wwrite-strings $(ARCH) $(PROF)
   CCLINK?=-lm -pthread
   LDFLAGS?=-L. -Wl,-rpath,.
   OBJARCH?=-arch i386 -arch x86_64
@@ -25,7 +25,7 @@ else ifeq ($(uname_S),Darwin)
   STLIBNAME?=libhiredis.a
   STLIB_MAKE_CMD?=libtool -static -o ${STLIBNAME} - ${OBJ}
 else
-  CFLAGS?=-std=c99 -pedantic $(OPTIMIZATION) -fPIC -Wall -W -Wwrite-strings $(ARCH) $(PROF)
+  CFLAGS?=-std=c99 -pedantic $(OPTIMIZATION) -fPIC -Wall -W -Wstrict-prototypes -Wwrite-strings $(ARCH) $(PROF)
   CCLINK?=-lm -pthread
   LDFLAGS?=-L. -Wl,-rpath,.
   DYLIBNAME?=libhiredis.so
@@ -45,11 +45,10 @@ all: ${DYLIBNAME} ${BINS}
 
 # Deps (use make dep to generate this)
 net.o: net.c fmacros.h net.h
-async.o: async.c async.h hiredis.h sds.h util.h
+async.o: async.c async.h hiredis.h sds.h util.h dict.c dict.h
 example.o: example.c hiredis.h
 hiredis.o: hiredis.c hiredis.h net.h sds.h util.h
 sds.o: sds.c sds.h
-dict.o: dict.c dict.h
 test.o: test.c hiredis.h
 
 ${DYLIBNAME}: ${OBJ}

data/vendor/hiredis/async.c

@@ -30,9 +30,11 @@
  */
 
 #include <string.h>
+#include <strings.h>
 #include <assert.h>
 #include <ctype.h>
 #include "async.h"
+#include "dict.c"
 #include "sds.h"
 #include "util.h"
 

data/vendor/hiredis/async.h

@@ -32,13 +32,13 @@
 #ifndef __HIREDIS_ASYNC_H
 #define __HIREDIS_ASYNC_H
 #include "hiredis.h"
-#include "dict.h"
 
 #ifdef __cplusplus
 extern "C" {
 #endif
 
 struct redisAsyncContext; /* need forward declaration of redisAsyncContext */
+struct dict; /* dictionary header is included in async.c */
 
 /* Reply callback prototype and container */
 typedef void (redisCallbackFn)(struct redisAsyncContext*, void*, void*);
@@ -95,8 +95,8 @@ typedef struct redisAsyncContext {
     /* Subscription callbacks */
     struct {
         redisCallbackList invalid;
-        dict *channels;
-        dict *patterns;
+        struct dict *channels;
+        struct dict *patterns;
     } sub;
 } redisAsyncContext;
 

data/vendor/hiredis/dict.c

@@ -50,7 +50,7 @@ static int _dictInit(dict *ht, dictType *type, void *privDataPtr);
 
 /* Generic hash function (a popular one from Bernstein).
  * I tested a few and this was the best. */
-unsigned int dictGenHashFunction(const unsigned char *buf, int len) {
+static unsigned int dictGenHashFunction(const unsigned char *buf, int len) {
     unsigned int hash = 5381;
 
     while (len--)
@@ -70,31 +70,22 @@ static void _dictReset(dict *ht) {
 }
 
 /* Create a new hash table */
-dict *dictCreate(dictType *type, void *privDataPtr) {
+static dict *dictCreate(dictType *type, void *privDataPtr) {
     dict *ht = malloc(sizeof(*ht));
     _dictInit(ht,type,privDataPtr);
     return ht;
 }
 
 /* Initialize the hash table */
-int _dictInit(dict *ht, dictType *type, void *privDataPtr) {
+static int _dictInit(dict *ht, dictType *type, void *privDataPtr) {
     _dictReset(ht);
     ht->type = type;
     ht->privdata = privDataPtr;
     return DICT_OK;
 }
 
-/* Resize the table to the minimal size that contains all the elements,
- * but with the invariant of a USER/BUCKETS ration near to <= 1 */
-int dictResize(dict *ht) {
-    int minimal = ht->used;
-    if (minimal < DICT_HT_INITIAL_SIZE)
-        minimal = DICT_HT_INITIAL_SIZE;
-    return dictExpand(ht, minimal);
-}
-
 /* Expand or create the hashtable */
-int dictExpand(dict *ht, unsigned long size) {
+static int dictExpand(dict *ht, unsigned long size) {
     dict n; /* the new hashtable */
     unsigned long realsize = _dictNextPower(size), i;
 
@@ -141,7 +132,7 @@ int dictExpand(dict *ht, unsigned long size) {
 }
 
 /* Add an element to the target hash table */
-int dictAdd(dict *ht, void *key, void *val) {
+static int dictAdd(dict *ht, void *key, void *val) {
     int index;
     dictEntry *entry;
 
@@ -166,7 +157,7 @@ int dictAdd(dict *ht, void *key, void *val) {
  * Return 1 if the key was added from scratch, 0 if there was already an
  * element with such key and dictReplace() just performed a value update
  * operation. */
-int dictReplace(dict *ht, void *key, void *val) {
+static int dictReplace(dict *ht, void *key, void *val) {
     dictEntry *entry, auxentry;
 
     /* Try to add the element. If the key
@@ -188,47 +179,38 @@ int dictReplace(dict *ht, void *key, void *val) {
 }
 
 /* Search and remove an element */
-static int dictGenericDelete(dict *ht, const void *key, int nofree) {
+static int dictDelete(dict *ht, const void *key) {
     unsigned int h;
-    dictEntry *he, *prevHe;
+    dictEntry *de, *prevde;
 
     if (ht->size == 0)
         return DICT_ERR;
     h = dictHashKey(ht, key) & ht->sizemask;
-    he = ht->table[h];
+    de = ht->table[h];
 
-    prevHe = NULL;
-    while(he) {
-        if (dictCompareHashKeys(ht, key, he->key)) {
+    prevde = NULL;
+    while(de) {
+        if (dictCompareHashKeys(ht,key,de->key)) {
             /* Unlink the element from the list */
-            if (prevHe)
-                prevHe->next = he->next;
+            if (prevde)
+                prevde->next = de->next;
             else
-                ht->table[h] = he->next;
-            if (!nofree) {
-                dictFreeEntryKey(ht, he);
-                dictFreeEntryVal(ht, he);
-            }
-            free(he);
+                ht->table[h] = de->next;
+
+            dictFreeEntryKey(ht,de);
+            dictFreeEntryVal(ht,de);
+            free(de);
             ht->used--;
             return DICT_OK;
         }
-        prevHe = he;
-        he = he->next;
+        prevde = de;
+        de = de->next;
     }
     return DICT_ERR; /* not found */
 }
 
-int dictDelete(dict *ht, const void *key) {
-    return dictGenericDelete(ht,key,0);
-}
-
-int dictDeleteNoFree(dict *ht, const void *key) {
-    return dictGenericDelete(ht,key,1);
-}
-
 /* Destroy an entire hash table */
-int _dictClear(dict *ht) {
+static int _dictClear(dict *ht) {
     unsigned long i;
 
     /* Free all the elements */
@@ -253,12 +235,12 @@ int _dictClear(dict *ht) {
 }
 
 /* Clear & Release the hash table */
-void dictRelease(dict *ht) {
+static void dictRelease(dict *ht) {
     _dictClear(ht);
     free(ht);
 }
 
-dictEntry *dictFind(dict *ht, const void *key) {
+static dictEntry *dictFind(dict *ht, const void *key) {
     dictEntry *he;
     unsigned int h;
 
@@ -273,7 +255,7 @@ dictEntry *dictFind(dict *ht, const void *key) {
     return NULL;
 }
 
-dictIterator *dictGetIterator(dict *ht) {
+static dictIterator *dictGetIterator(dict *ht) {
     dictIterator *iter = malloc(sizeof(*iter));
 
     iter->ht = ht;
@@ -283,7 +265,7 @@ dictIterator *dictGetIterator(dict *ht) {
     return iter;
 }
 
-dictEntry *dictNext(dictIterator *iter) {
+static dictEntry *dictNext(dictIterator *iter) {
     while (1) {
         if (iter->entry == NULL) {
             iter->index++;
@@ -303,38 +285,10 @@ dictEntry *dictNext(dictIterator *iter) {
     return NULL;
 }
 
-void dictReleaseIterator(dictIterator *iter) {
+static void dictReleaseIterator(dictIterator *iter) {
     free(iter);
 }
 
-/* Return a random entry from the hash table. Useful to
- * implement randomized algorithms */
-dictEntry *dictGetRandomKey(dict *ht) {
-    dictEntry *he;
-    unsigned int h;
-    int listlen, listele;
-
-    if (ht->used == 0) return NULL;
-    do {
-        h = random() & ht->sizemask;
-        he = ht->table[h];
-    } while(he == NULL);
-
-    /* Now we found a non empty bucket, but it is a linked
-     * list and we need to get a random element from the list.
-     * The only sane way to do so is to count the element and
-     * select a random index. */
-    listlen = 0;
-    while(he) {
-        he = he->next;
-        listlen++;
-    }
-    listele = random() % listlen;
-    he = ht->table[h];
-    while(listele--) he = he->next;
-    return he;
-}
-
 /* ------------------------- private functions ------------------------------ */
 
 /* Expand the hash table if needed */
@@ -382,7 +336,3 @@ static int _dictKeyIndex(dict *ht, const void *key) {
     return h;
 }
 
-void dictEmpty(dict *ht) {
-    _dictClear(ht);
-}
-