iobuffer 1.1.1 → 1.1.2

data/ext/extconf.rb

@@ -6,4 +6,4 @@ if have_macro("HAVE_RB_IO_T", "rubyio.h")
   have_struct_member("rb_io_t", "fd", "rubyio.h")
 end
 
-create_makefile("iobuffer/iobuffer_ext")
+create_makefile("iobuffer_ext")

data/ext/iobuffer.c

@@ -29,16 +29,16 @@
 static unsigned default_node_size = DEFAULT_NODE_SIZE;
 
 struct buffer {
-	unsigned size, node_size;
-	struct buffer_node *head, *tail;
-	struct buffer_node *pool_head, *pool_tail;
+    unsigned size, node_size;
+    struct buffer_node *head, *tail;
+    struct buffer_node *pool_head, *pool_tail;
 
 };
 
 struct buffer_node {
-	unsigned start, end;
-	struct buffer_node *next;
-	unsigned char   data[0];
+    unsigned start, end;
+    struct buffer_node *next;
+    unsigned char   data[0];
 };
 
 static VALUE    cIO_Buffer = Qnil;
@@ -83,48 +83,48 @@ static int      buffer_write_to(struct buffer * buf, int fd);
 void
 Init_iobuffer_ext()
 {
-	cIO_Buffer = rb_define_class_under(rb_cIO, "Buffer", rb_cObject);
-	rb_define_alloc_func(cIO_Buffer, IO_Buffer_allocate);
-
-	rb_define_singleton_method(cIO_Buffer, "default_node_size",
-				   IO_Buffer_default_node_size, 0);
-	rb_define_singleton_method(cIO_Buffer, "default_node_size=",
-				   IO_Buffer_set_default_node_size, 1);
-
-	rb_define_method(cIO_Buffer, "initialize", IO_Buffer_initialize, -1);
-	rb_define_method(cIO_Buffer, "clear", IO_Buffer_clear, 0);
-	rb_define_method(cIO_Buffer, "size", IO_Buffer_size, 0);
-	rb_define_method(cIO_Buffer, "empty?", IO_Buffer_empty, 0);
-	rb_define_method(cIO_Buffer, "<<", IO_Buffer_append, 1);
-	rb_define_method(cIO_Buffer, "append", IO_Buffer_append, 1);
-	rb_define_method(cIO_Buffer, "write", IO_Buffer_append, 1);
-	rb_define_method(cIO_Buffer, "prepend", IO_Buffer_prepend, 1);
-	rb_define_method(cIO_Buffer, "read", IO_Buffer_read, -1);
-	rb_define_method(cIO_Buffer, "read_frame", IO_Buffer_read_frame, 2);
-	rb_define_method(cIO_Buffer, "to_str", IO_Buffer_to_str, 0);
-	rb_define_method(cIO_Buffer, "read_from", IO_Buffer_read_from, 1);
-	rb_define_method(cIO_Buffer, "write_to", IO_Buffer_write_to, 1);
-
-	rb_define_const(cIO_Buffer, "MAX_SIZE", INT2NUM(MAX_BUFFER_SIZE));
+    cIO_Buffer = rb_define_class_under(rb_cIO, "Buffer", rb_cObject);
+    rb_define_alloc_func(cIO_Buffer, IO_Buffer_allocate);
+
+    rb_define_singleton_method(cIO_Buffer, "default_node_size",
+                   IO_Buffer_default_node_size, 0);
+    rb_define_singleton_method(cIO_Buffer, "default_node_size=",
+                   IO_Buffer_set_default_node_size, 1);
+
+    rb_define_method(cIO_Buffer, "initialize", IO_Buffer_initialize, -1);
+    rb_define_method(cIO_Buffer, "clear", IO_Buffer_clear, 0);
+    rb_define_method(cIO_Buffer, "size", IO_Buffer_size, 0);
+    rb_define_method(cIO_Buffer, "empty?", IO_Buffer_empty, 0);
+    rb_define_method(cIO_Buffer, "<<", IO_Buffer_append, 1);
+    rb_define_method(cIO_Buffer, "append", IO_Buffer_append, 1);
+    rb_define_method(cIO_Buffer, "write", IO_Buffer_append, 1);
+    rb_define_method(cIO_Buffer, "prepend", IO_Buffer_prepend, 1);
+    rb_define_method(cIO_Buffer, "read", IO_Buffer_read, -1);
+    rb_define_method(cIO_Buffer, "read_frame", IO_Buffer_read_frame, 2);
+    rb_define_method(cIO_Buffer, "to_str", IO_Buffer_to_str, 0);
+    rb_define_method(cIO_Buffer, "read_from", IO_Buffer_read_from, 1);
+    rb_define_method(cIO_Buffer, "write_to", IO_Buffer_write_to, 1);
+
+    rb_define_const(cIO_Buffer, "MAX_SIZE", INT2NUM(MAX_BUFFER_SIZE));
 }
 
 static VALUE
 IO_Buffer_allocate(VALUE klass)
 {
-	return Data_Wrap_Struct(klass, IO_Buffer_mark, IO_Buffer_free, buffer_new());
+    return Data_Wrap_Struct(klass, IO_Buffer_mark, IO_Buffer_free, buffer_new());
 }
 
 static void
 IO_Buffer_mark(struct buffer * buf)
 {
-	/* Naively discard the memory pool whenever Ruby garbage collects */
-	buffer_free_pool(buf);
+    /* Naively discard the memory pool whenever Ruby garbage collects */
+    buffer_free_pool(buf);
 }
 
 static void
 IO_Buffer_free(struct buffer * buf)
 {
-	buffer_free(buf);
+    buffer_free(buf);
 }
 
 /**
@@ -136,7 +136,7 @@ IO_Buffer_free(struct buffer * buf)
 static VALUE
 IO_Buffer_default_node_size(VALUE klass)
 {
-	return UINT2NUM(default_node_size);
+    return UINT2NUM(default_node_size);
 }
 
 /*
@@ -146,13 +146,13 @@ IO_Buffer_default_node_size(VALUE klass)
 static unsigned
 convert_node_size(VALUE size)
 {
-	if (
-	    rb_funcall(size, rb_intern("<"), 1, INT2NUM(1)) == Qtrue ||
-	    rb_funcall(size, rb_intern(">"), 1, INT2NUM(MAX_BUFFER_SIZE)) == Qtrue
-	)
-		rb_raise(rb_eArgError, "invalid buffer size");
+    if (
+        rb_funcall(size, rb_intern("<"), 1, INT2NUM(1)) == Qtrue ||
+        rb_funcall(size, rb_intern(">"), 1, INT2NUM(MAX_BUFFER_SIZE)) == Qtrue
+    )
+        rb_raise(rb_eArgError, "invalid buffer size");
 
-	return (unsigned) NUM2INT(size);
+    return (unsigned) NUM2INT(size);
 }
 
 /**
@@ -164,9 +164,9 @@ convert_node_size(VALUE size)
 static VALUE
 IO_Buffer_set_default_node_size(VALUE klass, VALUE size)
 {
-	default_node_size = convert_node_size(size);
+    default_node_size = convert_node_size(size);
 
-	return size;
+    return size;
 }
 
 /**
@@ -178,22 +178,22 @@ IO_Buffer_set_default_node_size(VALUE klass, VALUE size)
 static VALUE
 IO_Buffer_initialize(int argc, VALUE * argv, VALUE self)
 {
-	VALUE           node_size_obj;
-	struct buffer *buf;
-
-	if (rb_scan_args(argc, argv, "01", &node_size_obj) == 1) {
-		Data_Get_Struct(self, struct buffer, buf);
-
-		/*
-		 * Make sure we're not changing the buffer size after data
-		 * has been allocated
-		 */
-		assert(!buf->head);
-		assert(!buf->pool_head);
-
-		buf->node_size = convert_node_size(node_size_obj);
-	}
-	return Qnil;
+    VALUE           node_size_obj;
+    struct buffer *buf;
+
+    if (rb_scan_args(argc, argv, "01", &node_size_obj) == 1) {
+        Data_Get_Struct(self, struct buffer, buf);
+
+        /*
+         * Make sure we're not changing the buffer size after data
+         * has been allocated
+         */
+        assert(!buf->head);
+        assert(!buf->pool_head);
+
+        buf->node_size = convert_node_size(node_size_obj);
+    }
+    return Qnil;
 }
 
 /**
@@ -205,12 +205,12 @@ IO_Buffer_initialize(int argc, VALUE * argv, VALUE self)
 static VALUE
 IO_Buffer_clear(VALUE self)
 {
-	struct buffer *buf;
-	Data_Get_Struct(self, struct buffer, buf);
+    struct buffer *buf;
+    Data_Get_Struct(self, struct buffer, buf);
 
-	buffer_clear(buf);
+    buffer_clear(buf);
 
-	return Qnil;
+    return Qnil;
 }
 
 /**
@@ -222,10 +222,10 @@ IO_Buffer_clear(VALUE self)
 static VALUE
 IO_Buffer_size(VALUE self)
 {
-	struct buffer *buf;
-	Data_Get_Struct(self, struct buffer, buf);
+    struct buffer *buf;
+    Data_Get_Struct(self, struct buffer, buf);
 
-	return INT2NUM(buf->size);
+    return INT2NUM(buf->size);
 }
 
 /**
@@ -237,10 +237,10 @@ IO_Buffer_size(VALUE self)
 static VALUE
 IO_Buffer_empty(VALUE self)
 {
-	struct buffer *buf;
-	Data_Get_Struct(self, struct buffer, buf);
+    struct buffer *buf;
+    Data_Get_Struct(self, struct buffer, buf);
 
-	return buf->size > 0 ? Qfalse : Qtrue;
+    return buf->size > 0 ? Qfalse : Qtrue;
 }
 
 /**
@@ -252,14 +252,14 @@ IO_Buffer_empty(VALUE self)
 static VALUE
 IO_Buffer_append(VALUE self, VALUE data)
 {
-	struct buffer *buf;
-	Data_Get_Struct(self, struct buffer, buf);
+    struct buffer *buf;
+    Data_Get_Struct(self, struct buffer, buf);
 
-	/* Is this needed?  Never seen anyone else do it... */
-	data = rb_convert_type(data, T_STRING, "String", "to_str");
-	buffer_append(buf, RSTRING_PTR(data), RSTRING_LEN(data));
+    /* Is this needed?  Never seen anyone else do it... */
+    data = rb_convert_type(data, T_STRING, "String", "to_str");
+    buffer_append(buf, RSTRING_PTR(data), RSTRING_LEN(data));
 
-	return data;
+    return data;
 }
 
 /**
@@ -271,13 +271,13 @@ IO_Buffer_append(VALUE self, VALUE data)
 static VALUE
 IO_Buffer_prepend(VALUE self, VALUE data)
 {
-	struct buffer *buf;
-	Data_Get_Struct(self, struct buffer, buf);
+    struct buffer *buf;
+    Data_Get_Struct(self, struct buffer, buf);
 
-	data = rb_convert_type(data, T_STRING, "String", "to_str");
-	buffer_prepend(buf, RSTRING_PTR(data), RSTRING_LEN(data));
+    data = rb_convert_type(data, T_STRING, "String", "to_str");
+    buffer_prepend(buf, RSTRING_PTR(data), RSTRING_LEN(data));
 
-	return data;
+    return data;
 }
 
 /**
@@ -294,28 +294,28 @@ IO_Buffer_prepend(VALUE self, VALUE data)
 static VALUE
 IO_Buffer_read(int argc, VALUE * argv, VALUE self)
 {
-	VALUE  length_obj, str;
-	int    length;
-	struct buffer *buf;
+    VALUE  length_obj, str;
+    int    length;
+    struct buffer *buf;
 
-	Data_Get_Struct(self, struct buffer, buf);
+    Data_Get_Struct(self, struct buffer, buf);
 
-	if (rb_scan_args(argc, argv, "01", &length_obj) == 1) {
-		length = NUM2INT(length_obj);
-		if(length < 1)
-		  rb_raise(rb_eArgError, "length must be greater than zero");
-		if(length > buf->size)
-		  length = buf->size;
-	} else
-		length = buf->size;
+    if (rb_scan_args(argc, argv, "01", &length_obj) == 1) {
+        length = NUM2INT(length_obj);
+        if(length < 1)
+          rb_raise(rb_eArgError, "length must be greater than zero");
+        if(length > buf->size)
+          length = buf->size;
+    } else
+        length = buf->size;
 
-	if(buf->size == 0)
-		return rb_str_new2("");
+    if(buf->size == 0)
+        return rb_str_new2("");
 
-	str = rb_str_new(0, length);
-	buffer_read(buf, RSTRING_PTR(str), length);
+    str = rb_str_new(0, length);
+    buffer_read(buf, RSTRING_PTR(str), length);
 
-	return str;
+    return str;
 }
 
 /**
@@ -331,16 +331,16 @@ IO_Buffer_read(int argc, VALUE * argv, VALUE self)
 static VALUE
 IO_Buffer_read_frame(VALUE self, VALUE data, VALUE mark)
 {
-	char mark_c = (char) NUM2INT(mark);
-	struct buffer *buf;
+    char mark_c = (char) NUM2INT(mark);
+    struct buffer *buf;
 
-	Data_Get_Struct(self, struct buffer, buf);
+    Data_Get_Struct(self, struct buffer, buf);
 
-	if (buffer_read_frame(buf, data, mark_c)) {
-		return Qtrue;
-	} else {
-		return Qfalse;
-	}
+    if (buffer_read_frame(buf, data, mark_c)) {
+        return Qtrue;
+    } else {
+        return Qfalse;
+    }
 }
 
 /**
@@ -352,15 +352,15 @@ IO_Buffer_read_frame(VALUE self, VALUE data, VALUE mark)
 static VALUE
 IO_Buffer_to_str(VALUE self)
 {
-	VALUE          str;
-	struct buffer *buf;
+    VALUE          str;
+    struct buffer *buf;
 
-	Data_Get_Struct(self, struct buffer, buf);
+    Data_Get_Struct(self, struct buffer, buf);
 
-	str = rb_str_new(0, buf->size);
-	buffer_copy(buf, RSTRING_PTR(str), buf->size);
+    str = rb_str_new(0, buf->size);
+    buffer_copy(buf, RSTRING_PTR(str), buf->size);
 
-	return str;
+    return str;
 }
 
 /**
@@ -374,20 +374,20 @@ IO_Buffer_to_str(VALUE self)
 static VALUE
 IO_Buffer_read_from(VALUE self, VALUE io)
 {
-	struct buffer  *buf;
-	int             ret;
+    struct buffer  *buf;
+    int             ret;
 #if HAVE_RB_IO_T
-	rb_io_t        *fptr;
+    rb_io_t        *fptr;
 #else
-	OpenFile       *fptr;
+    OpenFile       *fptr;
 #endif
 
-	Data_Get_Struct(self, struct buffer, buf);
-	GetOpenFile(rb_convert_type(io, T_FILE, "IO", "to_io"), fptr);
-	rb_io_set_nonblock(fptr);
+    Data_Get_Struct(self, struct buffer, buf);
+    GetOpenFile(rb_convert_type(io, T_FILE, "IO", "to_io"), fptr);
+    rb_io_set_nonblock(fptr);
 
-	ret = buffer_read_from(buf, FPTR_TO_FD(fptr));
-	return ret == -1 ? Qnil : INT2NUM(ret);
+    ret = buffer_read_from(buf, FPTR_TO_FD(fptr));
+    return ret == -1 ? Qnil : INT2NUM(ret);
 }
 
 /**
@@ -401,18 +401,18 @@ IO_Buffer_read_from(VALUE self, VALUE io)
 static VALUE
 IO_Buffer_write_to(VALUE self, VALUE io)
 {
-	struct buffer  *buf;
+    struct buffer  *buf;
 #if HAVE_RB_IO_T
-	rb_io_t        *fptr;
+    rb_io_t        *fptr;
 #else
-	OpenFile       *fptr;
+    OpenFile       *fptr;
 #endif
 
-	Data_Get_Struct(self, struct buffer, buf);
-	GetOpenFile(rb_convert_type(io, T_FILE, "IO", "to_io"), fptr);
-	rb_io_set_nonblock(fptr);
+    Data_Get_Struct(self, struct buffer, buf);
+    GetOpenFile(rb_convert_type(io, T_FILE, "IO", "to_io"), fptr);
+    rb_io_set_nonblock(fptr);
 
-	return INT2NUM(buffer_write_to(buf, FPTR_TO_FD(fptr)));
+    return INT2NUM(buffer_write_to(buf, FPTR_TO_FD(fptr)));
 }
 
 /*
@@ -424,198 +424,198 @@ IO_Buffer_write_to(VALUE self, VALUE io)
 static struct buffer *
 buffer_new(void)
 {
-	struct buffer *buf;
+    struct buffer *buf;
 
-	buf = (struct buffer *) xmalloc(sizeof(struct buffer));
-	buf->head = buf->tail = buf->pool_head = buf->pool_tail = 0;
-	buf->size = 0;
-	buf->node_size = default_node_size;
+    buf = (struct buffer *) xmalloc(sizeof(struct buffer));
+    buf->head = buf->tail = buf->pool_head = buf->pool_tail = 0;
+    buf->size = 0;
+    buf->node_size = default_node_size;
 
-	return buf;
+    return buf;
 }
 
 /* Clear all data from a buffer */
 static void
 buffer_clear(struct buffer * buf)
 {
-	/* Move everything into the buffer pool */
-	if (!buf->pool_tail) {
-		buf->pool_head = buf->pool_tail = buf->head;
-	} else {
-		buf->pool_tail->next = buf->head;
-	}
-
-	buf->head = buf->tail = 0;
-	buf->size = 0;
+    /* Move everything into the buffer pool */
+    if (!buf->pool_tail) {
+        buf->pool_head = buf->pool_tail = buf->head;
+    } else {
+        buf->pool_tail->next = buf->head;
+    }
+
+    buf->head = buf->tail = 0;
+    buf->size = 0;
 }
 
 /* Free a buffer */
 static void
 buffer_free(struct buffer * buf)
 {
-	buffer_clear(buf);
-	buffer_free_pool(buf);
+    buffer_clear(buf);
+    buffer_free_pool(buf);
 
-	free(buf);
+    free(buf);
 }
 
 /* Free the memory pool */
 static void
 buffer_free_pool(struct buffer * buf)
 {
-	struct buffer_node *tmp;
+    struct buffer_node *tmp;
 
-	while (buf->pool_head) {
-		tmp = buf->pool_head;
-		buf->pool_head = tmp->next;
-		free(tmp);
-	}
+    while (buf->pool_head) {
+        tmp = buf->pool_head;
+        buf->pool_head = tmp->next;
+        free(tmp);
+    }
 
-	buf->pool_tail = 0;
+    buf->pool_tail = 0;
 }
 
 /* Create a new buffer_node (or pull one from the memory pool) */
 static struct buffer_node *
 buffer_node_new(struct buffer * buf)
 {
-	struct buffer_node *node;
-
-	/* Pull from the memory pool if available */
-	if (buf->pool_head) {
-		node = buf->pool_head;
-		buf->pool_head = node->next;
-
-		if (node->next)
-			node->next = 0;
-		else
-			buf->pool_tail = 0;
-	} else {
-		node = (struct buffer_node *) xmalloc(sizeof(struct buffer_node) + buf->node_size);
-		node->next = 0;
-	}
-
-	node->start = node->end = 0;
-	return node;
+    struct buffer_node *node;
+
+    /* Pull from the memory pool if available */
+    if (buf->pool_head) {
+        node = buf->pool_head;
+        buf->pool_head = node->next;
+
+        if (node->next)
+            node->next = 0;
+        else
+            buf->pool_tail = 0;
+    } else {
+        node = (struct buffer_node *) xmalloc(sizeof(struct buffer_node) + buf->node_size);
+        node->next = 0;
+    }
+
+    node->start = node->end = 0;
+    return node;
 }
 
 /* Free a buffer node (i.e. return it to the memory pool) */
 static void
 buffer_node_free(struct buffer * buf, struct buffer_node * node)
 {
-	node->next = buf->pool_head;
-	buf->pool_head = node;
+    node->next = buf->pool_head;
+    buf->pool_head = node;
 
-	if (!buf->pool_tail) {
-		buf->pool_tail = node;
-	}
+    if (!buf->pool_tail) {
+        buf->pool_tail = node;
+    }
 }
 
 /* Prepend data to the front of the buffer */
 static void
 buffer_prepend(struct buffer * buf, char *str, unsigned len)
 {
-	struct buffer_node *node, *tmp;
-	buf->size += len;
-
-	/* If it fits in the beginning of the head */
-	if (buf->head && buf->head->start >= len) {
-		buf->head->start -= len;
-		memcpy(buf->head->data + buf->head->start, str, len);
-	} else {
-		node = buffer_node_new(buf);
-		node->next = buf->head;
-		buf->head = node;
-		if (!buf->tail)
-			buf->tail = node;
-
-		while (len > buf->node_size) {
-			memcpy(node->data, str, buf->node_size);
-			node->end = buf->node_size;
-
-			tmp = buffer_node_new(buf);
-			tmp->next = node->next;
-			node->next = tmp;
-
-			if (buf->tail == node)
-				buf->tail = tmp;
-			node = tmp;
-
-			str += buf->node_size;
-			len -= buf->node_size;
-		}
-
-		if (len > 0) {
-			memcpy(node->data, str, len);
-			node->end = len;
-		}
-	}
+    struct buffer_node *node, *tmp;
+    buf->size += len;
+
+    /* If it fits in the beginning of the head */
+    if (buf->head && buf->head->start >= len) {
+        buf->head->start -= len;
+        memcpy(buf->head->data + buf->head->start, str, len);
+    } else {
+        node = buffer_node_new(buf);
+        node->next = buf->head;
+        buf->head = node;
+        if (!buf->tail)
+            buf->tail = node;
+
+        while (len > buf->node_size) {
+            memcpy(node->data, str, buf->node_size);
+            node->end = buf->node_size;
+
+            tmp = buffer_node_new(buf);
+            tmp->next = node->next;
+            node->next = tmp;
+
+            if (buf->tail == node)
+                buf->tail = tmp;
+            node = tmp;
+
+            str += buf->node_size;
+            len -= buf->node_size;
+        }
+
+        if (len > 0) {
+            memcpy(node->data, str, len);
+            node->end = len;
+        }
+    }
 }
 
 /* Append data to the front of the buffer */
 static void
 buffer_append(struct buffer * buf, char *str, unsigned len)
 {
-	unsigned nbytes;
-	buf->size += len;
-
-	/* If it fits in the remaining space in the tail */
-	if (buf->tail && len <= buf->node_size - buf->tail->end) {
-		memcpy(buf->tail->data + buf->tail->end, str, len);
-		buf->tail->end += len;
-		return;
-	}
-	/* Empty list needs initialized */
-	if (!buf->head) {
-		buf->head = buffer_node_new(buf);
-		buf->tail = buf->head;
-	}
-	/* Build links out of the data */
-	while (len > 0) {
-		nbytes = buf->node_size - buf->tail->end;
-		if (len < nbytes)
-			nbytes = len;
-
-		memcpy(buf->tail->data + buf->tail->end, str, nbytes);
-		str += nbytes;
-		len -= nbytes;
-
-		buf->tail->end += nbytes;
-
-		if (len > 0) {
-			buf->tail->next = buffer_node_new(buf);
-			buf->tail = buf->tail->next;
-		}
-	}
+    unsigned nbytes;
+    buf->size += len;
+
+    /* If it fits in the remaining space in the tail */
+    if (buf->tail && len <= buf->node_size - buf->tail->end) {
+        memcpy(buf->tail->data + buf->tail->end, str, len);
+        buf->tail->end += len;
+        return;
+    }
+    /* Empty list needs initialized */
+    if (!buf->head) {
+        buf->head = buffer_node_new(buf);
+        buf->tail = buf->head;
+    }
+    /* Build links out of the data */
+    while (len > 0) {
+        nbytes = buf->node_size - buf->tail->end;
+        if (len < nbytes)
+            nbytes = len;
+
+        memcpy(buf->tail->data + buf->tail->end, str, nbytes);
+        str += nbytes;
+        len -= nbytes;
+
+        buf->tail->end += nbytes;
+
+        if (len > 0) {
+            buf->tail->next = buffer_node_new(buf);
+            buf->tail = buf->tail->next;
+        }
+    }
 }
 
 /* Read data from the buffer (and clear what we've read) */
 static void
 buffer_read(struct buffer * buf, char *str, unsigned len)
 {
-	unsigned nbytes;
-	struct buffer_node *tmp;
-
-	while (buf->size > 0 && len > 0) {
-		nbytes = buf->head->end - buf->head->start;
-		if (len < nbytes)
-			nbytes = len;
-
-		memcpy(str, buf->head->data + buf->head->start, nbytes);
-		str += nbytes;
-		len -= nbytes;
-
-		buf->head->start += nbytes;
-		buf->size -= nbytes;
-
-		if (buf->head->start == buf->head->end) {
-			tmp = buf->head;
-			buf->head = tmp->next;
-			buffer_node_free(buf, tmp);
-
-			if (!buf->head)
-				buf->tail = 0;
-		}
-	}
+    unsigned nbytes;
+    struct buffer_node *tmp;
+
+    while (buf->size > 0 && len > 0) {
+        nbytes = buf->head->end - buf->head->start;
+        if (len < nbytes)
+            nbytes = len;
+
+        memcpy(str, buf->head->data + buf->head->start, nbytes);
+        str += nbytes;
+        len -= nbytes;
+
+        buf->head->start += nbytes;
+        buf->size -= nbytes;
+
+        if (buf->head->start == buf->head->end) {
+            tmp = buf->head;
+            buf->head = tmp->next;
+            buffer_node_free(buf, tmp);
+
+            if (!buf->head)
+                buf->tail = 0;
+        }
+    }
 }
 
 /*
@@ -626,101 +626,101 @@ buffer_read(struct buffer * buf, char *str, unsigned len)
 static int
 buffer_read_frame(struct buffer * buf, VALUE str, char frame_mark)
 {
-	unsigned nbytes = 0;
-	struct buffer_node *tmp;
+    unsigned nbytes = 0;
+    struct buffer_node *tmp;
 
-	while (buf->size > 0) {
-		struct buffer_node *head = buf->head;
-		char           *loc, *s = head->data + head->start, *e = head->data + head->end;
-		nbytes = e - s;
+    while (buf->size > 0) {
+        struct buffer_node *head = buf->head;
+        char           *loc, *s = head->data + head->start, *e = head->data + head->end;
+        nbytes = e - s;
 
-		loc = memchr(s, frame_mark, nbytes);
+        loc = memchr(s, frame_mark, nbytes);
 
-		if (loc) {
-			nbytes = loc - s + 1;
-		}
+        if (loc) {
+            nbytes = loc - s + 1;
+        }
 
-	    /* Copy less than everything if we found a frame byte */
-		rb_str_cat(str, s, nbytes);
+        /* Copy less than everything if we found a frame byte */
+        rb_str_cat(str, s, nbytes);
 
-	    /* Fixup the buffer pointers to indicate the bytes were consumed */
-		head->start += nbytes;
-		buf->size -= nbytes;
+        /* Fixup the buffer pointers to indicate the bytes were consumed */
+        head->start += nbytes;
+        buf->size -= nbytes;
 
-		if (head->start == head->end) {
-			buf->head = head->next;
-			buffer_node_free(buf, head);
+        if (head->start == head->end) {
+            buf->head = head->next;
+            buffer_node_free(buf, head);
 
-			if (!buf->head)
-				buf->tail = 0;
-		}
+            if (!buf->head)
+                buf->tail = 0;
+        }
 
-		if (loc) {
-			return 1;
-		}
-	}
+        if (loc) {
+            return 1;
+        }
+    }
 
-	return 0;
+    return 0;
 }
 
 /* Copy data from the buffer without clearing it */
 static void
 buffer_copy(struct buffer * buf, char *str, unsigned len)
 {
-	unsigned nbytes;
-	struct buffer_node *node;
-
-	node = buf->head;
-	while (node && len > 0) {
-		nbytes = node->end - node->start;
-		if (len < nbytes)
-			nbytes = len;
-
-		memcpy(str, node->data + node->start, nbytes);
-		str += nbytes;
-		len -= nbytes;
-
-		if (node->start + nbytes == node->end)
-			node = node->next;
-	}
+    unsigned nbytes;
+    struct buffer_node *node;
+
+    node = buf->head;
+    while (node && len > 0) {
+        nbytes = node->end - node->start;
+        if (len < nbytes)
+            nbytes = len;
+
+        memcpy(str, node->data + node->start, nbytes);
+        str += nbytes;
+        len -= nbytes;
+
+        if (node->start + nbytes == node->end)
+            node = node->next;
+    }
 }
 
 /* Write data from the buffer to a file descriptor */
 static int
 buffer_write_to(struct buffer * buf, int fd)
 {
-	int bytes_written, total_bytes_written = 0;
-	struct buffer_node *tmp;
-
-	while (buf->head) {
-		bytes_written = write(fd, buf->head->data + buf->head->start, buf->head->end - buf->head->start);
-
-		/* If the write failed... */
-		if (bytes_written < 0) {
-			if (errno != EAGAIN)
-				rb_sys_fail("write");
-
-			return total_bytes_written;
-		}
-
-		total_bytes_written += bytes_written;
-		buf->size -= bytes_written;
-
-		/* If the write blocked... */
-		if (bytes_written < buf->head->end - buf->head->start) {
-			buf->head->start += bytes_written;
-			return total_bytes_written;
-		}
-		/* Otherwise we wrote the whole buffer */
-		tmp = buf->head;
-		buf->head = tmp->next;
-		buffer_node_free(buf, tmp);
-
-		if (!buf->head)
-			buf->tail = 0;
-	}
-
-	return total_bytes_written;
+    int bytes_written, total_bytes_written = 0;
+    struct buffer_node *tmp;
+
+    while (buf->head) {
+        bytes_written = write(fd, buf->head->data + buf->head->start, buf->head->end - buf->head->start);
+
+        /* If the write failed... */
+        if (bytes_written < 0) {
+            if (errno != EAGAIN)
+                rb_sys_fail("write");
+
+            return total_bytes_written;
+        }
+
+        total_bytes_written += bytes_written;
+        buf->size -= bytes_written;
+
+        /* If the write blocked... */
+        if (bytes_written < buf->head->end - buf->head->start) {
+            buf->head->start += bytes_written;
+            return total_bytes_written;
+        }
+        /* Otherwise we wrote the whole buffer */
+        tmp = buf->head;
+        buf->head = tmp->next;
+        buffer_node_free(buf, tmp);
+
+        if (!buf->head)
+            buf->tail = 0;
+    }
+
+    return total_bytes_written;
 }
 
 /* Read data from a file descriptor to a buffer */
@@ -728,37 +728,38 @@ buffer_write_to(struct buffer * buf, int fd)
 static int
 buffer_read_from(struct buffer * buf, int fd)
 {
-	int      bytes_read, total_bytes_read = 0;
-	unsigned nbytes;
-
-	/* Empty list needs initialized */
-	if (!buf->head) {
-		buf->head = buffer_node_new(buf);
-		buf->tail = buf->head;
-	}
-
-	do {
-		nbytes = buf->node_size - buf->tail->end;
-		bytes_read = read(fd, buf->tail->data + buf->tail->end, nbytes);
-
-		if (bytes_read == 0) {
-			return -1;
-			//When the file reaches EOF
-		} else if (bytes_read < 0) {
-			if (errno != EAGAIN)
-				rb_sys_fail("read");
-
-			return total_bytes_read;
-		}
-		total_bytes_read += bytes_read;
-		buf->tail->end += nbytes;
-		buf->size += nbytes;
-
-		if (buf->tail->end == buf->node_size) {
-			buf->tail->next = buffer_node_new(buf);
-			buf->tail = buf->tail->next;
-		}
-	} while (bytes_read == nbytes);
-
-	return total_bytes_read;
+    int      bytes_read, total_bytes_read = 0;
+    unsigned nbytes;
+
+    /* Empty list needs initialized */
+    if (!buf->head) {
+        buf->head = buffer_node_new(buf);
+        buf->tail = buf->head;
+    }
+
+    do {
+        nbytes = buf->node_size - buf->tail->end;
+        bytes_read = read(fd, buf->tail->data + buf->tail->end, nbytes);
+
+        if (bytes_read == 0) {
+            return -1;
+            //When the file reaches EOF
+        } else if (bytes_read < 0) {
+            if (errno != EAGAIN)
+                rb_sys_fail("read");
+
+            return total_bytes_read;
+        }
+
+        total_bytes_read += bytes_read;
+        buf->tail->end += bytes_read;
+        buf->size += bytes_read;
+
+        if (buf->tail->end == buf->node_size) {
+            buf->tail->next = buffer_node_new(buf);
+            buf->tail = buf->tail->next;
+        }
+    } while (bytes_read == nbytes);
+
+    return total_bytes_read;
 }

data/lib/iobuffer/version.rb

@@ -1,5 +1,5 @@
 class IO
   class Buffer
-    VERSION = "1.1.1"
+    VERSION = "1.1.2"
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: iobuffer
 version: !ruby/object:Gem::Version
-  version: 1.1.1
+  version: 1.1.2
   prerelease: 
 platform: ruby
 authors:
@@ -9,11 +9,11 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-02-13 00:00:00.000000000 Z
+date: 2012-02-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake-compiler
-  requirement: &70314510650840 !ruby/object:Gem::Requirement
+  requirement: &70270228214060 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -21,10 +21,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *70314510650840
+  version_requirements: *70270228214060
 - !ruby/object:Gem::Dependency
   name: rake
-  requirement: &70314510650200 !ruby/object:Gem::Requirement
+  requirement: &70270228213600 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -32,10 +32,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *70314510650200
+  version_requirements: *70270228213600
 - !ruby/object:Gem::Dependency
   name: rspec
-  requirement: &70314510649400 !ruby/object:Gem::Requirement
+  requirement: &70270228213180 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -43,7 +43,7 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *70314510649400
+  version_requirements: *70270228213180
 description: fast buffers for non-blocking IO
 email:
 - tony.arcieri@gmail.com
@@ -55,7 +55,6 @@ files:
 - README.md
 - lib/iobuffer/version.rb
 - lib/iobuffer.rb
-- lib/iobuffer_ext.bundle
 - ext/iobuffer.c
 - ext/extconf.rb
 homepage: https://github.com/tarcieri/iobuffer