penguin_queue 0.1.0 → 0.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: f65e549283761f28cc27557bf240cec2af939de8
-  data.tar.gz: addaa9864d8e81e27b6e343c0a3369eca80c2676
+  metadata.gz: a4fd3cc82db722d18ca04d5041814b763bb57b2c
+  data.tar.gz: ef46be32133f2656159e46f7adf8ddf7960386ee
 SHA512:
-  metadata.gz: e9849295843bd1822f9fed629cb9ecef7bfbed28fae71397c8aad19f27088e08e9f02c80e1dec43d20ddeca9b1621e7ced1dc87e8188af6632dcef94d3babd3d
-  data.tar.gz: cedd93953d40ef6bab937840e2eeec5521b0fd0ed0cee2412a6748512441a4cb2460fb72c13706cf15cca588365af08a676f607a4e39bf6786d626b1a50bf1ee
+  metadata.gz: f23b0a538c39f318e66a28e37d5182d619182070ad71db09599f6d0dc286b1426c6d10a631708e93803dd5ee517ba65c3d163d4734496e5c86c85754965df064
+  data.tar.gz: 7e75329a8025a5d5090b40d053b23d884831d35d68b29f297a88e2fd6fa2d08c67474670a3aabe6dbefdd79c03124adf2eb7cefb90106775621e7527c57cb8d0

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    penguin_queue (0.1.0)
+    penguin_queue (0.1.1)
 
 GEM
   remote: https://rubygems.org/

data/README.md

@@ -5,9 +5,13 @@
 ```
 
 # Install
+```
+gem install penguin_queue
+```
+
 ```ruby
 # Gemfile
-gem 'penguin_queue', git: 'https://github.com/tompng/penguin_queue'
+gem 'penguin_queue'
 ```
 
 # Usage
@@ -32,25 +36,25 @@ pq.size.times.map { pq.deq } #=> [8, 6, 4, 2, 0]
 
 # Methods
 ```ruby
-# PenguinQueue
-PenguinQueue.new PenguinQueue.new(&calc_priority_from_element_proc)
-# enqueue multiple
-push(e1, e2, ...) unshift(e1, e2, ...)
+# initialize
+PenguinQueue.new
+PenguinQueue.new(order: :max) # min(default) or max
+PenguinQueue.new(&calc_priority_from_element_proc)
 # enqueue
-<<(e) enq(e)
+<<(e) enq(e) push(e) unshift(e)
 # enqueue with custom priority
-enq(e, priority: p)
+enq(e, priority: p) push(e, priority: p) unshift(e, priority: e)
 # dequeue
-deq shift pop deque_with_priority
+deq shift pop poll deq_with_priority
 # dequeue multiple
-deq(n) shift(n) pop(n)
+deq(n) shift(n) pop(n) poll(n)
 # fetch
-first first_with_priority first_node
+first peek top first_with_priority first_node
 # remove
 remove(node) delete(node)
 # other
-to_s inspect size empty?
+to_s inspect clear size empty? min? max?
 
 # PenguinQueue::Node
-remove delete value value= priority priority=
+remove delete value value= priority priority= to_s inspect
 ```

data/ext/penguin_queue/penguin_queue.c

@@ -1,25 +1,25 @@
 #include <ruby.h>
 
-static ID id_priority, id_cmp, id_call;
+static ID id_priority, id_cmp, id_call, id_order, id_max, id_min;
 #define RB_STR_BUF_CAT(rstr, cstr) rb_str_buf_cat((rstr), (cstr), sizeof(cstr)-1);
 struct node {
   long index, id;
-  VALUE heap, priority, value;
+  VALUE queue, priority, value;
 };
 VALUE node_class;
 void node_mark(struct node *ptr){
-  rb_gc_mark(ptr->heap);
+  rb_gc_mark(ptr->queue);
   rb_gc_mark(ptr->priority);
   rb_gc_mark(ptr->value);
 }
-VALUE node_alloc_internal(long index, long id, VALUE heap, VALUE priority, VALUE value){
+VALUE node_alloc_internal(long index, long id, VALUE queue, VALUE priority, VALUE value){
   struct node *ptr = ALLOC(struct node);
   ptr->index = index;
   ptr->id = id;
-  ptr->heap = heap;
+  ptr->queue = queue;
   ptr->priority = priority;
   ptr->value = value;
-  return Data_Wrap_Struct(node_class, node_mark, -1, ptr);
+  return Data_Wrap_Struct(node_class, node_mark, RUBY_DEFAULT_FREE, ptr);
 }
 #define NODE_PREPARE(self, name) struct node *name;Data_Get_Struct(self, struct node, name);
 VALUE node_pri(VALUE self){
@@ -30,10 +30,6 @@ VALUE node_val(VALUE self){
   NODE_PREPARE(self, ptr);
   return ptr->value;
 }
-VALUE node_val_set(VALUE self, VALUE val){
-  NODE_PREPARE(self, ptr);
-  return ptr->value = val;
-}
 VALUE node_inspect(VALUE self){
   NODE_PREPARE(self, nptr);
   VALUE str = rb_str_buf_new(0);
@@ -48,6 +44,7 @@ VALUE node_inspect(VALUE self){
 
 struct queue_data{
   long counter;
+  int compare_sgn;
   VALUE heap, compare_by;
 };
 
@@ -60,17 +57,25 @@ long compare(VALUE a, VALUE b){
   }
   if(RB_TYPE_P(a, T_STRING)&&RB_TYPE_P(b, T_STRING))
     return rb_str_cmp(a, b);
-  return rb_fix2long(rb_funcall(a, id_cmp, 1, b));
+  VALUE cmp = rb_funcall(a, id_cmp, 1, b);
+  if(NIL_P(cmp))rb_cmperr(a,b);
+  return rb_fix2long(cmp);
 }
+
 long compare_id(long a, long b){return a>b?1:a<b?-1:0;}
-void heap_mark(struct queue_data *st){
-  rb_gc_mark(st->heap);
-  rb_gc_mark(st->compare_by);
+
+#define QUEUE_PREPARE(self, name) struct queue_data *name;Data_Get_Struct(self, struct queue_data, name);
+#define OPTHASH_GIVEN_P(opts) (argc > 0 && !NIL_P((opts) = rb_check_hash_type(argv[argc-1])) && (--argc, 1))
+
+void queue_mark(struct queue_data *self){
+  rb_gc_mark(self->heap);
+  rb_gc_mark(self->compare_by);
 }
-void heap_free(struct queue_data *st){free(st);}
-VALUE heap_alloc(VALUE klass){
+
+VALUE queue_alloc(VALUE klass){
   struct queue_data *ptr=ALLOC(struct queue_data);
   ptr->counter = 0;
+  ptr->compare_sgn = 1;
   ptr->heap = rb_ary_new_capa(1);
   rb_ary_push(ptr->heap, Qnil);
   if(rb_block_given_p()){
@@ -78,13 +83,35 @@ VALUE heap_alloc(VALUE klass){
   }else{
     ptr->compare_by = Qnil;
   }
-  return Data_Wrap_Struct(klass, heap_mark, heap_free, ptr);
+  return Data_Wrap_Struct(klass, queue_mark, RUBY_DEFAULT_FREE, ptr);
 }
 
-#define QUEUE_PREPARE(self, name) struct queue_data *name;Data_Get_Struct(self, struct queue_data, name);
+VALUE queue_initialize(int argc, VALUE *argv, VALUE self){
+  QUEUE_PREPARE(self, ptr);
+  VALUE opts, order;
+  if(!OPTHASH_GIVEN_P(opts))return self;
+  ID keyword_ids[] = {id_order};
+	rb_get_kwargs(opts, keyword_ids, 0, 1, &order);
+  if(order == Qundef)return self;
+  if(order == ID2SYM(id_max)){
+    ptr->compare_sgn = -1;
+  }else if(order != ID2SYM(id_min)){
+    rb_raise(rb_eArgError, "order should be :min or :max");
+  }
+  return self;
+}
 
-void heap_up(VALUE self, VALUE node){
+VALUE queue_clear(VALUE self){
   QUEUE_PREPARE(self, ptr);
+  ptr->counter = 0;
+  rb_ary_clear(ptr->heap);
+  rb_ary_push(ptr->heap, Qnil);
+  return self;
+}
+
+void queue_up(VALUE self, VALUE node){
+  QUEUE_PREPARE(self, ptr);
+  int sgn = ptr->compare_sgn;
   RARRAY_PTR_USE(ptr->heap, heap, {
     NODE_PREPARE(node, nptr);
     long index = nptr->index;
@@ -92,8 +119,8 @@ void heap_up(VALUE self, VALUE node){
       long pindex = index/2;
       VALUE pnode = heap[pindex];
       NODE_PREPARE(pnode, pptr);
-      long cmp = compare(pptr->priority, nptr->priority);
-      if(!cmp)cmp=compare_id(pptr->id, nptr->id);
+      long cmp = compare(pptr->priority, nptr->priority)*sgn;
+      if(!cmp)cmp=compare_id(pptr->id, nptr->id)*sgn;
       if(cmp<0)break;
       pptr->index = index;
       heap[index] = pnode;
@@ -104,8 +131,9 @@ void heap_up(VALUE self, VALUE node){
   });
 }
 
-void heap_down(VALUE self, VALUE node){
+void queue_down(VALUE self, VALUE node){
   QUEUE_PREPARE(self, ptr);
+  int sgn = ptr->compare_sgn;
   long length = RARRAY_LEN(ptr->heap);
   RARRAY_PTR_USE(ptr->heap, heap, {
     NODE_PREPARE(node, nptr);
@@ -117,16 +145,16 @@ void heap_down(VALUE self, VALUE node){
       if(lindex+1 < length){
         VALUE rnode = heap[lindex+1];
         NODE_PREPARE(rnode, rptr);
-        long cmp = compare(lptr->priority, rptr->priority);
-        if(!cmp)cmp=compare_id(lptr->id, rptr->id);
+        long cmp = compare(lptr->priority, rptr->priority)*sgn;
+        if(!cmp)cmp=compare_id(lptr->id, rptr->id)*sgn;
         if(cmp >= 0){
           lindex += 1;
           lnode = rnode;
           lptr = rptr;
         }
       }
-      long cmp = compare(nptr->priority, lptr->priority);
-      if(!cmp)cmp=compare_id(nptr->id, lptr->id);
+      long cmp = compare(nptr->priority, lptr->priority)*sgn;
+      if(!cmp)cmp=compare_id(nptr->id, lptr->id)*sgn;
       if(cmp <= 0)break;
       lptr->index = index;
       heap[index] = lnode;
@@ -137,10 +165,11 @@ void heap_down(VALUE self, VALUE node){
   });
 }
 
-VALUE heap_remove_node(VALUE self, VALUE node){
+VALUE queue_remove_node(VALUE self, VALUE node){
   if(!rb_obj_is_kind_of(node, node_class))return Qnil;
   QUEUE_PREPARE(self, ptr);
   NODE_PREPARE(node, nptr);
+  int sgn = ptr->compare_sgn;
   long length = RARRAY_LEN(ptr->heap);
   if(nptr->index >= length || RARRAY_AREF(ptr->heap, nptr->index) != node)return Qnil;
   RARRAY_PTR_USE(ptr->heap, heap, {
@@ -149,12 +178,12 @@ VALUE heap_remove_node(VALUE self, VALUE node){
     NODE_PREPARE(replace_node, rptr);
     heap[nptr->index] = replace_node;
     rptr->index = nptr->index;
-    long cmp = compare(rptr->priority, nptr->priority);
-    if(!cmp)cmp = compare_id(rptr->id, nptr->id);
+    long cmp = compare(rptr->priority, nptr->priority)*sgn;
+    if(!cmp)cmp = compare_id(rptr->id, nptr->id)*sgn;
     if(cmp > 0){
-      heap_down(nptr->heap, replace_node);
+      queue_down(nptr->queue, replace_node);
     }else{
-      heap_up(nptr->heap, replace_node);
+      queue_up(nptr->queue, replace_node);
     }
   });
   return Qnil;
@@ -162,29 +191,48 @@ VALUE heap_remove_node(VALUE self, VALUE node){
 
 VALUE node_remove(VALUE self){
   NODE_PREPARE(self, nptr);
-  heap_remove_node(nptr->heap, self);
+  queue_remove_node(nptr->queue, self);
   return Qnil;
 }
 
-VALUE node_update_priority(VALUE node, VALUE priority){
+void node_update_priority_internal(VALUE node, VALUE priority){
   NODE_PREPARE(node, nptr);
-  QUEUE_PREPARE(nptr->heap, ptr);
+  QUEUE_PREPARE(nptr->queue, ptr);
+  int sgn = ptr->compare_sgn;
   VALUE priority_was = nptr->priority;
   nptr->priority = priority;
-  long cmp = compare(priority, priority_was);
-  if(cmp == 0)return Qnil;
+  long cmp = compare(priority, priority_was)*sgn;
+  if(cmp == 0)return;
   RARRAY_PTR_USE(ptr->heap, heap, {
-    if(heap[nptr->index] != node)return Qnil;
+    if(heap[nptr->index] != node)return;
   });
   if(cmp < 0){
-    heap_up(nptr->heap, node);
+    queue_up(nptr->queue, node);
   }else{
-    heap_down(nptr->heap, node);
+    queue_down(nptr->queue, node);
   }
-  return Qnil;
 }
 
-VALUE heap_enq_vp(VALUE self, VALUE value, VALUE priority){
+VALUE node_update_priority(VALUE node, VALUE priority){
+  NODE_PREPARE(node, nptr);
+  QUEUE_PREPARE(nptr->queue, ptr);
+  if(ptr->compare_by != Qnil)rb_raise(rb_eRuntimeError, "priority update not supported on queue initialized with block");
+  node_update_priority_internal(node, priority);
+  return priority;
+}
+
+VALUE node_update_value(VALUE node, VALUE value){
+  NODE_PREPARE(node, nptr);
+  QUEUE_PREPARE(nptr->queue, ptr);
+  nptr->value = value;
+  if(ptr->compare_by != Qnil){
+    VALUE priority = rb_funcall(ptr->compare_by, id_call, 1, value);
+    node_update_priority_internal(node, priority);
+  }
+  return value;
+}
+
+VALUE queue_enq_vp(VALUE self, VALUE value, VALUE priority){
   QUEUE_PREPARE(self, ptr);
   if(ptr->compare_by != Qnil){
     priority = rb_funcall(ptr->compare_by, id_call, 1, value);
@@ -193,14 +241,11 @@ VALUE heap_enq_vp(VALUE self, VALUE value, VALUE priority){
   VALUE node = node_alloc_internal(length, ptr->counter, self, priority, value);
   ptr->counter++;
   rb_ary_push(ptr->heap, node);
-  heap_up(self, node);
+  queue_up(self, node);
   return node;
 }
 
-#define OPTHASH_GIVEN_P(opts) \
-    (argc > 0 && !NIL_P((opts) = rb_check_hash_type(argv[argc-1])) && (--argc, 1))
-
-VALUE heap_enq(int argc, VALUE *argv, VALUE self){
+VALUE queue_enq(int argc, VALUE *argv, VALUE self){
   VALUE value, opts, priority, pri  = Qundef;
   if (OPTHASH_GIVEN_P(opts)) {
     ID keyword_ids[] = {id_priority};
@@ -208,18 +253,13 @@ VALUE heap_enq(int argc, VALUE *argv, VALUE self){
   }
   rb_scan_args(argc, argv, "1", &value);
   priority = (pri == Qundef) ? value : pri;
-  return heap_enq_vp(self, value, priority);
-}
-VALUE heap_push(VALUE self, VALUE value){
-  return heap_enq_vp(self, value, value);
+  return queue_enq_vp(self, value, priority);
 }
-VALUE heap_push_multiple(int argc, VALUE *argv, VALUE self){
-  VALUE nodes = rb_ary_new_capa(argc);
-  for(int i=0;i<argc;i++)rb_ary_push(nodes, heap_push(self, argv[i]));
-  return nodes;
+VALUE queue_push(VALUE self, VALUE value){
+  return queue_enq_vp(self, value, value);
 }
 
-VALUE heap_first_node(VALUE self){
+VALUE queue_first_node(VALUE self){
   QUEUE_PREPARE(self, ptr);
   long length = RARRAY_LEN(ptr->heap);
   if(length == 1)return Qnil;
@@ -227,20 +267,20 @@ VALUE heap_first_node(VALUE self){
     return heap[1];
   });
 }
-VALUE heap_first(VALUE self){
-  VALUE node = heap_first_node(self);
+VALUE queue_first(VALUE self){
+  VALUE node = queue_first_node(self);
   if(node == Qnil)return Qnil;
   NODE_PREPARE(node, nptr);
   return nptr->value;
 }
-VALUE heap_first_with_priority(VALUE self){
-  VALUE node = heap_first_node(self);
+VALUE queue_first_with_priority(VALUE self){
+  VALUE node = queue_first_node(self);
   if(node == Qnil)return Qnil;
   NODE_PREPARE(node, nptr);
   return rb_ary_new_from_args(2, nptr->value, nptr->priority);
 }
 
-VALUE heap_deq_node(VALUE self){
+VALUE queue_deq_node(VALUE self){
   QUEUE_PREPARE(self, ptr);
   long length = RARRAY_LEN(ptr->heap);
   if(length == 1)return Qnil;
@@ -250,14 +290,14 @@ VALUE heap_deq_node(VALUE self){
     NODE_PREPARE(node, nptr);
     if(length > 1){
       nptr->index = 1;
-      heap_down(self, node);
+      queue_down(self, node);
     }
     return first;
   });
 }
-VALUE heap_deq(int argc, VALUE *argv, VALUE self){
+VALUE queue_deq(int argc, VALUE *argv, VALUE self){
   if(argc == 0){
-    VALUE node = heap_deq_node(self);
+    VALUE node = queue_deq_node(self);
     if(node == Qnil)return Qnil;
     NODE_PREPARE(node, nptr);
     return nptr->value;
@@ -271,33 +311,49 @@ VALUE heap_deq(int argc, VALUE *argv, VALUE self){
     if(n>length)n=length;
     VALUE result = rb_ary_new_capa(n);
     for(int i=0;i<n;i++){
-      VALUE node = heap_deq_node(self);
+      VALUE node = queue_deq_node(self);
       NODE_PREPARE(node, nptr);
       rb_ary_push(result, nptr->value);
     }
     return result;
   }
 }
-VALUE heap_deq_with_priority(VALUE self){
-  VALUE node = heap_deq_node(self);
+VALUE queue_deq_with_priority(VALUE self){
+  VALUE node = queue_deq_node(self);
   if(node == Qnil)return Qnil;
   NODE_PREPARE(node, nptr);
   return rb_ary_new_from_args(2, nptr->value, nptr->priority);
 }
 
-VALUE heap_size(VALUE self){
+VALUE queue_size(VALUE self){
   QUEUE_PREPARE(self, ptr);
   return LONG2FIX(RARRAY_LEN(ptr->heap)-1);
 }
-VALUE heap_is_empty(VALUE self){
+VALUE queue_is_empty(VALUE self){
   QUEUE_PREPARE(self, ptr);
   return RARRAY_LEN(ptr->heap) == 1 ? Qtrue : Qfalse;
 }
-VALUE heap_inspect(VALUE self){
+#define QUEUE_PTR_IS_MIN(ptr) ((ptr)->compare_sgn==1)
+VALUE queue_is_min(VALUE self){
+  QUEUE_PREPARE(self, ptr);
+  return QUEUE_PTR_IS_MIN(ptr) ? Qtrue : Qfalse;
+}
+VALUE queue_is_max(VALUE self){
+  QUEUE_PREPARE(self, ptr);
+  return QUEUE_PTR_IS_MIN(ptr) ? Qfalse : Qtrue;
+}
+VALUE queue_inspect(VALUE self){
+  QUEUE_PREPARE(self, ptr);
   VALUE str = rb_str_buf_new(0);
   rb_str_buf_append(str, rb_class_name(CLASS_OF(self)));
-  RB_STR_BUF_CAT(str, "{size: ");
-  rb_str_buf_append(str, rb_inspect(heap_size(self)));
+  RB_STR_BUF_CAT(str, "{order: ");
+  if(QUEUE_PTR_IS_MIN(ptr)){
+    RB_STR_BUF_CAT(str, ":min");
+  }else{
+    RB_STR_BUF_CAT(str, ":max");
+  }
+  RB_STR_BUF_CAT(str, ", size: ");
+  rb_str_buf_append(str, rb_inspect(queue_size(self)));
   RB_STR_BUF_CAT(str, "}");
   return str;
 }
@@ -306,33 +362,43 @@ void Init_penguin_queue(void){
   id_priority = rb_intern("priority");
   id_call = rb_intern("call");
   id_cmp = rb_intern("<=>");
+  id_max = rb_intern("max");
+  id_min = rb_intern("min");
+  id_order = rb_intern("order");
 
-  VALUE heap_class = rb_define_class("PenguinQueue", rb_cObject);
-  rb_define_alloc_func(heap_class, heap_alloc);
-  rb_define_method(heap_class, "size", heap_size, 0);
-  rb_define_method(heap_class, "empty?", heap_is_empty, 0);
-  rb_define_method(heap_class, "inspect", heap_inspect, 0);
-  rb_define_method(heap_class, "first", heap_first, 0);
-  rb_define_method(heap_class, "first_node", heap_first_node, 0);
-  rb_define_method(heap_class, "first_with_priority", heap_first_with_priority, 0);
-  rb_define_method(heap_class, "to_s", heap_inspect, 0);
-  rb_define_method(heap_class, "push", heap_push_multiple, -1);
-  rb_define_method(heap_class, "<<", heap_push, 1);
-  rb_define_method(heap_class, "enq", heap_enq, -1);
-  rb_define_method(heap_class, "unshift", heap_push_multiple, -1);
-  rb_define_method(heap_class, "pop", heap_deq, -1);
-  rb_define_method(heap_class, "shift", heap_deq, -1);
-  rb_define_method(heap_class, "deq", heap_deq, -1);
-  rb_define_method(heap_class, "deq_with_priority", heap_deq_with_priority, 0);
-  rb_define_method(heap_class, "delete", heap_remove_node, 1);
-  rb_define_method(heap_class, "remove", heap_remove_node, 1);
+  VALUE queue_class = rb_define_class("PenguinQueue", rb_cObject);
+  rb_define_alloc_func(queue_class, queue_alloc);
+  rb_define_method(queue_class, "initialize", queue_initialize, -1);
+  rb_define_method(queue_class, "size", queue_size, 0);
+  rb_define_method(queue_class, "empty?", queue_is_empty, 0);
+  rb_define_method(queue_class, "clear", queue_clear, 0);
+  rb_define_method(queue_class, "inspect", queue_inspect, 0);
+  rb_define_method(queue_class, "top", queue_first, 0);
+  rb_define_method(queue_class, "peek", queue_first, 0);
+  rb_define_method(queue_class, "first", queue_first, 0);
+  rb_define_method(queue_class, "first_node", queue_first_node, 0);
+  rb_define_method(queue_class, "first_with_priority", queue_first_with_priority, 0);
+  rb_define_method(queue_class, "to_s", queue_inspect, 0);
+  rb_define_method(queue_class, "push", queue_enq, -1);
+  rb_define_method(queue_class, "<<", queue_push, 1);
+  rb_define_method(queue_class, "enq", queue_enq, -1);
+  rb_define_method(queue_class, "unshift", queue_enq, -1);
+  rb_define_method(queue_class, "pop", queue_deq, -1);
+  rb_define_method(queue_class, "shift", queue_deq, -1);
+  rb_define_method(queue_class, "deq", queue_deq, -1);
+  rb_define_method(queue_class, "poll", queue_deq, -1);
+  rb_define_method(queue_class, "deq_with_priority", queue_deq_with_priority, 0);
+  rb_define_method(queue_class, "delete", queue_remove_node, 1);
+  rb_define_method(queue_class, "remove", queue_remove_node, 1);
+  rb_define_method(queue_class, "min?", queue_is_min, 0);
+  rb_define_method(queue_class, "max?", queue_is_max, 0);
 
-  node_class = rb_define_class_under(heap_class, "Node", rb_cObject);
+  node_class = rb_define_class_under(queue_class, "Node", rb_cObject);
   rb_undef_alloc_func(node_class);
   rb_define_method(node_class, "priority", node_pri, 0);
   rb_define_method(node_class, "priority=", node_update_priority, 1);
   rb_define_method(node_class, "value", node_val, 0);
-  rb_define_method(node_class, "value=", node_val_set, 1);
+  rb_define_method(node_class, "value=", node_update_value, 1);
   rb_define_method(node_class, "inspect", node_inspect, 0);
   rb_define_method(node_class, "to_s", node_inspect, 0);
   rb_define_method(node_class, "remove", node_remove, 0);

data/lib/penguin_queue/version.rb

@@ -1,3 +1,3 @@
 class PenguinQueue
-  VERSION = "0.1.0"
+  VERSION = "0.1.1"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: penguin_queue
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.1
 platform: ruby
 authors:
 - tompng
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2017-02-19 00:00:00.000000000 Z
+date: 2017-02-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler