penguin_queue 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: f65e549283761f28cc27557bf240cec2af939de8
+  data.tar.gz: addaa9864d8e81e27b6e343c0a3369eca80c2676
+SHA512:
+  metadata.gz: e9849295843bd1822f9fed629cb9ecef7bfbed28fae71397c8aad19f27088e08e9f02c80e1dec43d20ddeca9b1621e7ced1dc87e8188af6632dcef94d3babd3d
+  data.tar.gz: cedd93953d40ef6bab937840e2eeec5521b0fd0ed0cee2412a6748512441a4cb2460fb72c13706cf15cca588365af08a676f607a4e39bf6786d626b1a50bf1ee

data/.gitignore

@@ -0,0 +1,4 @@
+Makefile
+*.bundle
+*.o
+*.gem

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in penguin_queue.gemspec
+gemspec

data/Gemfile.lock

@@ -0,0 +1,25 @@
+PATH
+  remote: .
+  specs:
+    penguin_queue (0.1.0)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    minitest (5.10.1)
+    rake (10.5.0)
+    rake-compiler (1.0.3)
+      rake
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler (~> 1.13)
+  minitest (~> 5.0)
+  penguin_queue!
+  rake (~> 10.0)
+  rake-compiler
+
+BUNDLED WITH
+   1.13.7

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2017 tompng
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,56 @@
+# Priority Queue
+```ruby
+10000.times { array << rand; array.delete(array.min) } #=> slow when array.size is large
+10000.times { pq << rand; pq.deq } #=> fast even if pq.size is large
+```
+
+# Install
+```ruby
+# Gemfile
+gem 'penguin_queue', git: 'https://github.com/tompng/penguin_queue'
+```
+
+# Usage
+```ruby
+require 'penguin_queue'
+pq = PenguinQueue.new
+10.times.to_a.shuffle.each { |i| pq << i }
+10.times.map { pq.deq }  #=> [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
+
+# custom priority
+pq.enq 'hello', priority: 0
+pq.first #=> "hello"
+pq.first_with_priority #=> ["hello", 0]
+pq.deq_with_priority #=> ["hello", 0]
+
+# update priority, remove node
+nodes = 10.times.to_a.shuffle.map { |i| pq << i }
+nodes.each { |n| n.priority = -n.priority }
+nodes.each_with_index{ |n| n.remove if n.value.odd? }
+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, ...)
+# enqueue
+<<(e) enq(e)
+# enqueue with custom priority
+enq(e, priority: p)
+# dequeue
+deq shift pop deque_with_priority
+# dequeue multiple
+deq(n) shift(n) pop(n)
+# fetch
+first first_with_priority first_node
+# remove
+remove(node) delete(node)
+# other
+to_s inspect size empty?
+
+# PenguinQueue::Node
+remove delete value value= priority priority=
+```

data/Rakefile

@@ -0,0 +1,18 @@
+require "bundler/gem_tasks"
+require "rake/testtask"
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << "test"
+  t.libs << "lib"
+  t.test_files = FileList['test/**/*_test.rb']
+end
+
+require "rake/extensiontask"
+
+task :build => :compile
+
+Rake::ExtensionTask.new("penguin_queue") do |ext|
+  ext.lib_dir = "lib/penguin_queue"
+end
+
+task :default => [:clobber, :compile, :test]

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "penguin_queue"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/ext/penguin_queue/extconf.rb

@@ -0,0 +1,3 @@
+require "mkmf"
+
+create_makefile("penguin_queue/penguin_queue")

data/ext/penguin_queue/penguin_queue.c

@@ -0,0 +1,340 @@
+#include <ruby.h>
+
+static ID id_priority, id_cmp, id_call;
+#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 node_class;
+void node_mark(struct node *ptr){
+  rb_gc_mark(ptr->heap);
+  rb_gc_mark(ptr->priority);
+  rb_gc_mark(ptr->value);
+}
+VALUE node_alloc_internal(long index, long id, VALUE heap, VALUE priority, VALUE value){
+  struct node *ptr = ALLOC(struct node);
+  ptr->index = index;
+  ptr->id = id;
+  ptr->heap = heap;
+  ptr->priority = priority;
+  ptr->value = value;
+  return Data_Wrap_Struct(node_class, node_mark, -1, ptr);
+}
+#define NODE_PREPARE(self, name) struct node *name;Data_Get_Struct(self, struct node, name);
+VALUE node_pri(VALUE self){
+  NODE_PREPARE(self, ptr);
+  return ptr->priority;
+}
+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);
+  rb_str_buf_append(str, rb_class_name(CLASS_OF(self)));
+  RB_STR_BUF_CAT(str, "{priority: ");
+  rb_str_buf_append(str, rb_inspect(nptr->priority));
+  RB_STR_BUF_CAT(str, ", value: ");
+  rb_str_buf_append(str, rb_inspect(nptr->value));
+  RB_STR_BUF_CAT(str, "}");
+  return str;
+}
+
+struct queue_data{
+  long counter;
+  VALUE heap, compare_by;
+};
+
+long compare(VALUE a, VALUE b){
+  if(RB_FIXNUM_P(a)&&RB_FIXNUM_P(b))
+    return (long)a > (long)b ? 1 : (long)a < (long)b ? -1 : 0;
+  if(RB_FLOAT_TYPE_P(a)&&RB_FLOAT_TYPE_P(b)){
+    double fa=RFLOAT_VALUE(a),fb=RFLOAT_VALUE(b);
+    return fa>fb?1:fa<fb?-1:0;
+  }
+  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));
+}
+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);
+}
+void heap_free(struct queue_data *st){free(st);}
+VALUE heap_alloc(VALUE klass){
+  struct queue_data *ptr=ALLOC(struct queue_data);
+  ptr->counter = 0;
+  ptr->heap = rb_ary_new_capa(1);
+  rb_ary_push(ptr->heap, Qnil);
+  if(rb_block_given_p()){
+    ptr->compare_by = rb_block_proc();
+  }else{
+    ptr->compare_by = Qnil;
+  }
+  return Data_Wrap_Struct(klass, heap_mark, heap_free, ptr);
+}
+
+#define QUEUE_PREPARE(self, name) struct queue_data *name;Data_Get_Struct(self, struct queue_data, name);
+
+void heap_up(VALUE self, VALUE node){
+  QUEUE_PREPARE(self, ptr);
+  RARRAY_PTR_USE(ptr->heap, heap, {
+    NODE_PREPARE(node, nptr);
+    long index = nptr->index;
+    while(index > 1){
+      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);
+      if(cmp<0)break;
+      pptr->index = index;
+      heap[index] = pnode;
+      index = pindex;
+    }
+    nptr->index = index;
+    heap[index] = node;
+  });
+}
+
+void heap_down(VALUE self, VALUE node){
+  QUEUE_PREPARE(self, ptr);
+  long length = RARRAY_LEN(ptr->heap);
+  RARRAY_PTR_USE(ptr->heap, heap, {
+    NODE_PREPARE(node, nptr);
+    long index = nptr->index;
+    while(2*index < length){
+      long lindex = 2*index;
+      VALUE lnode = heap[lindex];
+      NODE_PREPARE(lnode, lptr);
+      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);
+        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);
+      if(cmp <= 0)break;
+      lptr->index = index;
+      heap[index] = lnode;
+      index = lindex;
+    }
+    nptr->index = index;
+    heap[index] = node;
+  });
+}
+
+VALUE heap_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);
+  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, {
+    VALUE replace_node = rb_ary_pop(ptr->heap);
+    if(replace_node == node)return Qnil;
+    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);
+    if(cmp > 0){
+      heap_down(nptr->heap, replace_node);
+    }else{
+      heap_up(nptr->heap, replace_node);
+    }
+  });
+  return Qnil;
+}
+
+VALUE node_remove(VALUE self){
+  NODE_PREPARE(self, nptr);
+  heap_remove_node(nptr->heap, self);
+  return Qnil;
+}
+
+VALUE node_update_priority(VALUE node, VALUE priority){
+  NODE_PREPARE(node, nptr);
+  QUEUE_PREPARE(nptr->heap, ptr);
+  VALUE priority_was = nptr->priority;
+  nptr->priority = priority;
+  long cmp = compare(priority, priority_was);
+  if(cmp == 0)return Qnil;
+  RARRAY_PTR_USE(ptr->heap, heap, {
+    if(heap[nptr->index] != node)return Qnil;
+  });
+  if(cmp < 0){
+    heap_up(nptr->heap, node);
+  }else{
+    heap_down(nptr->heap, node);
+  }
+  return Qnil;
+}
+
+VALUE heap_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);
+  }
+  long length = RARRAY_LEN(ptr->heap);
+  VALUE node = node_alloc_internal(length, ptr->counter, self, priority, value);
+  ptr->counter++;
+  rb_ary_push(ptr->heap, node);
+  heap_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 value, opts, priority, pri  = Qundef;
+  if (OPTHASH_GIVEN_P(opts)) {
+    ID keyword_ids[] = {id_priority};
+  	rb_get_kwargs(opts, keyword_ids, 0, 1, &pri);
+  }
+  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);
+}
+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 heap_first_node(VALUE self){
+  QUEUE_PREPARE(self, ptr);
+  long length = RARRAY_LEN(ptr->heap);
+  if(length == 1)return Qnil;
+  RARRAY_PTR_USE(ptr->heap, heap, {
+    return heap[1];
+  });
+}
+VALUE heap_first(VALUE self){
+  VALUE node = heap_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);
+  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){
+  QUEUE_PREPARE(self, ptr);
+  long length = RARRAY_LEN(ptr->heap);
+  if(length == 1)return Qnil;
+  RARRAY_PTR_USE(ptr->heap, heap, {
+    VALUE first = heap[1];
+    VALUE node = rb_ary_pop(ptr->heap);
+    NODE_PREPARE(node, nptr);
+    if(length > 1){
+      nptr->index = 1;
+      heap_down(self, node);
+    }
+    return first;
+  });
+}
+VALUE heap_deq(int argc, VALUE *argv, VALUE self){
+  if(argc == 0){
+    VALUE node = heap_deq_node(self);
+    if(node == Qnil)return Qnil;
+    NODE_PREPARE(node, nptr);
+    return nptr->value;
+  }else{
+    VALUE nv;
+    rb_scan_args(argc, argv, "1", &nv);
+    long n = NUM2LONG(nv);
+    if(n<0)rb_raise(rb_eArgError, "negative array size");
+    QUEUE_PREPARE(self, ptr);
+    long length = RARRAY_LEN(ptr->heap)-1;
+    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);
+      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);
+  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){
+  QUEUE_PREPARE(self, ptr);
+  return LONG2FIX(RARRAY_LEN(ptr->heap)-1);
+}
+VALUE heap_is_empty(VALUE self){
+  QUEUE_PREPARE(self, ptr);
+  return RARRAY_LEN(ptr->heap) == 1 ? Qtrue : Qfalse;
+}
+VALUE heap_inspect(VALUE self){
+  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, "}");
+  return str;
+}
+
+void Init_penguin_queue(void){
+  id_priority = rb_intern("priority");
+  id_call = rb_intern("call");
+  id_cmp = rb_intern("<=>");
+
+  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);
+
+  node_class = rb_define_class_under(heap_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, "inspect", node_inspect, 0);
+  rb_define_method(node_class, "to_s", node_inspect, 0);
+  rb_define_method(node_class, "remove", node_remove, 0);
+  rb_define_method(node_class, "delete", node_remove, 0);
+}

data/lib/penguin_queue/version.rb

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

data/lib/penguin_queue.rb

@@ -0,0 +1,2 @@
+require "penguin_queue/penguin_queue"
+require "penguin_queue/version"

data/penguin_queue.gemspec

@@ -0,0 +1,29 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'penguin_queue/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "penguin_queue"
+  spec.version       = PenguinQueue::VERSION
+  spec.authors       = ["tompng"]
+  spec.email         = ["tomoyapenguin@gmail.com"]
+
+  spec.summary       = %q{C Ext Priority Queue}
+  spec.description   = %q{C Ext Priority Queue (binary heap)}
+  spec.homepage      = "https://github.com/tompng/penguin_queue"
+  spec.license       = "MIT"
+  spec.extensions    = %w[ext/penguin_queue/extconf.rb]
+
+  spec.files         = `git ls-files -z`.split("\x0").reject do |f|
+    f.match(%r{^(test|spec|features)/})
+  end
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.13"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "minitest", "~> 5.0"
+  spec.add_development_dependency "rake-compiler"
+end

metadata

@@ -0,0 +1,114 @@
+--- !ruby/object:Gem::Specification
+name: penguin_queue
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- tompng
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2017-02-19 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.13'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.13'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+- !ruby/object:Gem::Dependency
+  name: rake-compiler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: C Ext Priority Queue (binary heap)
+email:
+- tomoyapenguin@gmail.com
+executables: []
+extensions:
+- ext/penguin_queue/extconf.rb
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- Gemfile.lock
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- ext/penguin_queue/extconf.rb
+- ext/penguin_queue/penguin_queue.c
+- lib/penguin_queue.rb
+- lib/penguin_queue/version.rb
+- penguin_queue.gemspec
+homepage: https://github.com/tompng/penguin_queue
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.6.8
+signing_key: 
+specification_version: 4
+summary: C Ext Priority Queue
+test_files: []