remq 0.0.1a → 0.0.3

data/vendor/bundle/gems/hiredis-0.4.5/lib/hiredis/ext/connection.rb

@@ -0,0 +1,29 @@
+require "hiredis/ext/hiredis_ext"
+require "hiredis/version"
+require "socket"
+
+module Hiredis
+  module Ext
+    class Connection
+      alias :_disconnect :disconnect
+
+      def disconnect
+        _disconnect
+      ensure
+        @sock = nil
+      end
+
+      alias :_read :read
+
+      def read
+        _read
+      rescue ::EOFError
+        raise Errno::ECONNRESET
+      end
+
+      def sock
+        @sock ||= Socket.for_fd(fileno)
+      end
+    end
+  end
+end

data/vendor/bundle/gems/hiredis-0.4.5/lib/hiredis/ext/reader.rb

@@ -0,0 +1,2 @@
+require "hiredis/ext/hiredis_ext"
+require "hiredis/version"

data/vendor/bundle/gems/hiredis-0.4.5/lib/hiredis/reader.rb

@@ -0,0 +1,10 @@
+module Hiredis
+  begin
+    require "hiredis/ext/reader"
+    Reader = Ext::Reader
+  rescue LoadError
+    warn "WARNING: could not load hiredis extension, using (slower) pure Ruby implementation."
+    require "hiredis/ruby/reader"
+    Reader = Ruby::Reader
+  end
+end

data/vendor/bundle/gems/hiredis-0.4.5/lib/hiredis/ruby/connection.rb

@@ -0,0 +1,298 @@
+require "socket"
+require "hiredis/ruby/reader"
+require "hiredis/version"
+
+module Hiredis
+  module Ruby
+    class Connection
+
+      if defined?(RUBY_ENGINE) && RUBY_ENGINE == "rbx"
+
+        def self.errno_to_class
+          Errno::Mapping
+        end
+
+      else
+
+        def self.errno_to_class
+          @mapping ||= Hash[Errno.constants.map do |name|
+            klass = Errno.const_get(name)
+            [klass.const_get("Errno"), klass]
+          end]
+        end
+
+      end
+
+      if defined?(RUBY_ENGINE) && RUBY_ENGINE == "jruby"
+
+        require "timeout"
+
+        def _connect(host, port, timeout)
+          sock = nil
+
+          begin
+            Timeout.timeout(timeout) do
+              sock = TCPSocket.new(host, port)
+            end
+          rescue SocketError => se
+            raise se.message
+          rescue Timeout::Error
+            raise Errno::ETIMEDOUT
+          end
+
+          sock
+        end
+
+        def _connect_unix(path, timeout)
+          sock = nil
+
+          begin
+            Timeout.timeout(timeout) do
+              sock = UNIXSocket.new(path)
+            end
+          rescue SocketError => se
+            raise se.message
+          rescue Timeout::Error
+            raise Errno::ETIMEDOUT
+          end
+
+          sock
+        end
+
+        def _write(sock, data, timeout)
+          begin
+            Timeout.timeout(timeout) do
+              sock.write(data)
+            end
+          rescue Timeout::Error
+            raise Errno::EAGAIN
+          end
+        end
+
+      else
+
+        def _connect(host, port, timeout)
+          error = nil
+          sock = nil
+
+          # Resolve address
+          begin
+            addrinfo = Socket.getaddrinfo(host, port, Socket::AF_UNSPEC, Socket::SOCK_STREAM)
+          rescue SocketError => se
+            raise se.message
+          end
+
+          addrinfo.each do |_, port, name, addr, af|
+            begin
+              sockaddr = Socket.pack_sockaddr_in(port, addr)
+              sock = _connect_sockaddr(af, sockaddr, timeout)
+            rescue => aux
+              case aux
+              when Errno::EAFNOSUPPORT, Errno::ECONNREFUSED
+                error = aux
+                next
+              else
+                # Re-raise
+                raise
+              end
+            else
+              # No errors, awesome!
+              break
+            end
+          end
+
+          unless sock
+            # Re-raise last error since the last try obviously failed
+            raise error if error
+
+            # This code path should not happen: getaddrinfo should always return
+            # at least one record, which should either succeed or fail and leave
+            # and error to raise.
+            raise
+          end
+
+          sock
+        end
+
+        def _connect_unix(path, timeout)
+          sockaddr = Socket.pack_sockaddr_un(path)
+          _connect_sockaddr(Socket::AF_UNIX, sockaddr, timeout)
+        end
+
+        def _write(sock, data, timeout)
+          data.force_encoding("binary") if data.respond_to?(:force_encoding)
+
+          begin
+            nwritten = @sock.write_nonblock(data)
+
+            while nwritten < string_size(data)
+              data = data[nwritten..-1]
+              nwritten = @sock.write_nonblock(data)
+            end
+          rescue Errno::EAGAIN
+            if IO.select([], [@sock], [], timeout)
+              # Writable, try again
+              retry
+            else
+              # Timed out, raise
+              raise Errno::EAGAIN
+            end
+          end
+        end
+
+        def _connect_sockaddr(af, sockaddr, timeout)
+          sock = Socket.new(af, Socket::SOCK_STREAM, 0)
+
+          begin
+            sock.connect_nonblock(sockaddr)
+          rescue Errno::EINPROGRESS
+            if IO.select(nil, [sock], nil, timeout)
+              # Writable, check for errors
+              optval = sock.getsockopt(Socket::SOL_SOCKET, Socket::SO_ERROR)
+              errno = optval.unpack("i").first
+
+              # Raise socket error if there is any
+              raise self.class.errno_to_class[errno] if errno > 0
+            else
+              # Timeout (TODO: replace with own Timeout class)
+              raise Errno::ETIMEDOUT
+            end
+          end
+
+          sock
+        rescue
+          sock.close if sock
+
+          # Re-raise
+          raise
+        end
+
+        private :_connect_sockaddr
+
+      end
+
+      attr_reader :sock
+
+      def initialize
+        @sock = nil
+        @timeout = nil
+      end
+
+      def connected?
+        !! @sock
+      end
+
+      def connect(host, port, usecs = nil)
+        # Temporarily override timeout on #connect
+        timeout = usecs ? (usecs / 1_000_000.0) : @timeout
+
+        # Optionally disconnect current socket
+        disconnect if connected?
+
+        sock = _connect(host, port, timeout)
+        sock.setsockopt Socket::IPPROTO_TCP, Socket::TCP_NODELAY, 1
+
+        @reader = ::Hiredis::Ruby::Reader.new
+        @sock = sock
+
+        nil
+      end
+
+      def connect_unix(path, usecs = 0)
+        # Temporarily override timeout on #connect
+        timeout = usecs ? (usecs / 1_000_000.0) : @timeout
+
+        # Optionally disconnect current socket
+        disconnect if connected?
+
+        sock = _connect_unix(path, timeout)
+
+        @reader = ::Hiredis::Ruby::Reader.new
+        @sock = sock
+
+        nil
+      end
+
+      def disconnect
+        @sock.close
+      rescue
+      ensure
+        @sock = nil
+      end
+
+      def timeout=(usecs)
+        raise ArgumentError.new("timeout cannot be negative") if usecs < 0
+
+        if usecs == 0
+          @timeout = nil
+        else
+          @timeout = usecs / 1_000_000.0
+        end
+
+        nil
+      end
+
+      def fileno
+        raise "not connected" unless connected?
+
+        @sock.fileno
+      end
+
+      COMMAND_DELIMITER = "\r\n".freeze
+
+      def write(args)
+        command = []
+        command << "*#{args.size}"
+        args.each do |arg|
+          arg = arg.to_s
+          command << "$#{string_size arg}"
+          command << arg
+        end
+
+        data = command.join(COMMAND_DELIMITER) + COMMAND_DELIMITER
+
+        _write(@sock, data, @timeout)
+
+        nil
+      end
+
+      # No-op for now..
+      def flush
+      end
+
+      def read
+        raise "not connected" unless connected?
+
+        while (reply = @reader.gets) == false
+          begin
+            @reader.feed @sock.read_nonblock(1024)
+          rescue Errno::EAGAIN
+            if IO.select([@sock], [], [], @timeout)
+              # Readable, try again
+              retry
+            else
+              # Timed out, raise
+              raise Errno::EAGAIN
+            end
+          end
+        end
+
+        reply
+      rescue ::EOFError
+        raise Errno::ECONNRESET
+      end
+
+    protected
+
+      if "".respond_to?(:bytesize)
+        def string_size(string)
+          string.to_s.bytesize
+        end
+      else
+        def string_size(string)
+          string.to_s.size
+        end
+      end
+    end
+  end
+end

data/vendor/bundle/gems/hiredis-0.4.5/lib/hiredis/ruby/reader.rb

@@ -0,0 +1,183 @@
+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_reader :parent
+        attr_reader :depth
+        attr_accessor :multi_bulk
+
+        def initialize(buffer, parent = nil, depth = 0)
+          @buffer, @parent, @depth = buffer, parent, depth
+        end
+
+        # Note: task depth is not checked.
+        def child
+          @child ||= Task.new(@buffer, self, depth + 1)
+        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
+          force_encoding @buffer[start, bytes]
+        end
+
+        def read_line
+          start = @pos
+          stop = @buffer.index(CRLF, @pos)
+          return false unless stop
+
+          @pos = stop + 2 # include CRLF
+          force_encoding @buffer[start, stop - start]
+        end
+
+        private
+
+        if "".respond_to?(:force_encoding)
+
+          def force_encoding(str)
+            str.force_encoding(Encoding.default_external)
+          end
+
+        else
+
+          def force_encoding(str)
+            str
+          end
+
+        end
+      end
+    end
+  end
+end

data/vendor/bundle/gems/hiredis-0.4.5/lib/hiredis/version.rb

@@ -0,0 +1,3 @@
+module Hiredis
+  VERSION = "0.4.5"
+end

data/vendor/bundle/gems/hiredis-0.4.5/lib/hiredis.rb

@@ -0,0 +1,2 @@
+require "hiredis/version"
+require "hiredis/connection"

data/vendor/bundle/gems/hiredis-0.4.5/vendor/hiredis/COPYING

@@ -0,0 +1,29 @@
+Copyright (c) 2009-2011, Salvatore Sanfilippo <antirez at gmail dot com>
+Copyright (c) 2010-2011, Pieter Noordhuis <pcnoordhuis at gmail dot com>
+
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+* Redistributions of source code must retain the above copyright notice,
+  this list of conditions and the following disclaimer.
+
+* Redistributions in binary form must reproduce the above copyright notice,
+  this list of conditions and the following disclaimer in the documentation
+  and/or other materials provided with the distribution.
+
+* Neither the name of Redis nor the names of its contributors may be used
+  to endorse or promote products derived from this software without specific
+  prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

data/vendor/bundle/gems/hiredis-0.4.5/vendor/hiredis/Makefile

@@ -0,0 +1,148 @@
+# Hiredis Makefile
+# Copyright (C) 2010-2011 Salvatore Sanfilippo <antirez at gmail dot com>
+# Copyright (C) 2010-2011 Pieter Noordhuis <pcnoordhuis 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
+BINS=hiredis-example hiredis-test
+LIBNAME=libhiredis
+
+HIREDIS_MAJOR=0
+HIREDIS_MINOR=10
+
+# Fallback to gcc when $CC is not in $PATH.
+CC:=$(shell sh -c 'type $(CC) >/dev/null 2>/dev/null && echo $(CC) || echo gcc')
+OPTIMIZATION?=-O3
+WARNINGS=-Wall -W -Wstrict-prototypes -Wwrite-strings
+DEBUG?= -g -ggdb
+REAL_CFLAGS=$(OPTIMIZATION) -fPIC $(CFLAGS) $(WARNINGS) $(DEBUG)
+REAL_LDFLAGS=$(LDFLAGS)
+
+DYLIBSUFFIX=so
+STLIBSUFFIX=a
+DYLIB_MINOR_NAME=$(LIBNAME).$(DYLIBSUFFIX).$(HIREDIS_MAJOR).$(HIREDIS_MINOR)
+DYLIB_MAJOR_NAME=$(LIBNAME).$(DYLIBSUFFIX).$(HIREDIS_MAJOR)
+DYLIBNAME=$(LIBNAME).$(DYLIBSUFFIX)
+DYLIB_MAKE_CMD=$(CC) -shared -Wl,-soname,$(DYLIB_MINOR_NAME) -o $(DYLIBNAME) $(LDFLAGS)
+STLIBNAME=$(LIBNAME).$(STLIBSUFFIX)
+STLIB_MAKE_CMD=ar rcs $(STLIBNAME)
+
+# Platform-specific overrides
+uname_S := $(shell sh -c 'uname -s 2>/dev/null || echo not')
+ifeq ($(uname_S),SunOS)
+  REAL_LDFLAGS+= -ldl -lnsl -lsocket
+  DYLIB_MAKE_CMD=$(CC) -G -o $(DYLIBNAME) -h $(DYLIB_MINOR_NAME) $(LDFLAGS)
+  INSTALL= cp -r
+endif
+ifeq ($(uname_S),Darwin)
+  DYLIBSUFFIX=dylib
+  DYLIB_MINOR_NAME=$(LIBNAME).$(HIREDIS_MAJOR).$(HIREDIS_MINOR).$(DYLIBSUFFIX)
+  DYLIB_MAJOR_NAME=$(LIBNAME).$(HIREDIS_MAJOR).$(DYLIBSUFFIX)
+  DYLIB_MAKE_CMD=$(CC) -shared -Wl,-install_name,$(DYLIB_MINOR_NAME) -o $(DYLIBNAME) $(LDFLAGS)
+endif
+
+all: $(DYLIBNAME) $(BINS)
+
+# Deps (use make dep to generate this)
+net.o: net.c fmacros.h net.h hiredis.h
+async.o: async.c async.h hiredis.h sds.h dict.c dict.h
+example.o: example.c hiredis.h
+hiredis.o: hiredis.c fmacros.h hiredis.h net.h sds.h
+sds.o: sds.c sds.h
+test.o: test.c hiredis.h
+
+$(DYLIBNAME): $(OBJ)
+	$(DYLIB_MAKE_CMD) $(OBJ)
+
+$(STLIBNAME): $(OBJ)
+	$(STLIB_MAKE_CMD) $(OBJ)
+
+dynamic: $(DYLIBNAME)
+static: $(STLIBNAME)
+
+# Binaries:
+hiredis-example-libevent: example-libevent.c adapters/libevent.h $(STLIBNAME)
+	$(CC) -o $@ $(REAL_CFLAGS) $(REAL_LDFLAGS) -levent example-libevent.c $(STLIBNAME)
+
+hiredis-example-libev: example-libev.c adapters/libev.h $(STLIBNAME)
+	$(CC) -o $@ $(REAL_CFLAGS) $(REAL_LDFLAGS) -lev example-libev.c $(STLIBNAME)
+
+ifndef AE_DIR
+hiredis-example-ae:
+	@echo "Please specify AE_DIR (e.g. <redis repository>/src)"
+	@false
+else
+hiredis-example-ae: example-ae.c adapters/ae.h $(STLIBNAME)
+	$(CC) -o $@ $(REAL_CFLAGS) $(REAL_LDFLAGS) -I$(AE_DIR) $(AE_DIR)/ae.o $(AE_DIR)/zmalloc.o example-ae.c $(STLIBNAME)
+endif
+
+hiredis-%: %.o $(STLIBNAME)
+	$(CC) -o $@ $(REAL_LDFLAGS) $< $(STLIBNAME)
+
+test: hiredis-test
+	./hiredis-test
+
+check: hiredis-test
+	echo \
+		"daemonize yes\n" \
+		"pidfile /tmp/hiredis-test-redis.pid\n" \
+		"port 56379\n" \
+		"bind 127.0.0.1\n" \
+		"unixsocket /tmp/hiredis-test-redis.sock" \
+			| redis-server -
+	./hiredis-test -h 127.0.0.1 -p 56379 -s /tmp/hiredis-test-redis.sock || \
+			( kill `cat /tmp/hiredis-test-redis.pid` && false )
+	kill `cat /tmp/hiredis-test-redis.pid`
+
+.c.o:
+	$(CC) -std=c99 -pedantic -c $(REAL_CFLAGS) $<
+
+clean:
+	rm -rf $(DYLIBNAME) $(STLIBNAME) $(BINS) hiredis-example* *.o *.gcda *.gcno *.gcov
+
+dep:
+	$(CC) -MM *.c
+
+# Installation related variables and target
+PREFIX?=/usr/local
+INCLUDE_PATH?=include/hiredis
+LIBRARY_PATH?=lib
+INSTALL_INCLUDE_PATH= $(PREFIX)/$(INCLUDE_PATH)
+INSTALL_LIBRARY_PATH= $(PREFIX)/$(LIBRARY_PATH)
+
+ifeq ($(uname_S),SunOS)
+  INSTALL?= cp -r
+endif
+
+INSTALL?= cp -a
+
+install: $(DYLIBNAME) $(STLIBNAME)
+	mkdir -p $(INSTALL_INCLUDE_PATH) $(INSTALL_LIBRARY_PATH)
+	$(INSTALL) hiredis.h async.h adapters $(INSTALL_INCLUDE_PATH)
+	$(INSTALL) $(DYLIBNAME) $(INSTALL_LIBRARY_PATH)/$(DYLIB_MINOR_NAME)
+	cd $(INSTALL_LIBRARY_PATH) && ln -sf $(DYLIB_MINOR_NAME) $(DYLIB_MAJOR_NAME)
+	cd $(INSTALL_LIBRARY_PATH) && ln -sf $(DYLIB_MAJOR_NAME) $(DYLIBNAME)
+	$(INSTALL) $(STLIBNAME) $(INSTALL_LIBRARY_PATH)
+
+32bit:
+	@echo ""
+	@echo "WARNING: if this fails under Linux you probably need to install libc6-dev-i386"
+	@echo ""
+	$(MAKE) CFLAGS="-m32" LDFLAGS="-m32"
+
+gprof:
+	$(MAKE) CFLAGS="-pg" LDFLAGS="-pg"
+
+gcov:
+	$(MAKE) CFLAGS="-fprofile-arcs -ftest-coverage" LDFLAGS="-fprofile-arcs"
+
+coverage: gcov
+	make check
+	mkdir -p tmp/lcov
+	lcov -d . -c -o tmp/lcov/hiredis.info
+	genhtml --legend -o tmp/lcov/report tmp/lcov/hiredis.info
+
+noopt:
+	$(MAKE) OPTIMIZATION=""
+
+.PHONY: all test check clean dep install 32bit gprof gcov noopt