penguin_queue 0.1.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
checksums.yaml ADDED
@@ -0,0 +1,7 @@
1
+ ---
2
+ SHA1:
3
+ metadata.gz: f65e549283761f28cc27557bf240cec2af939de8
4
+ data.tar.gz: addaa9864d8e81e27b6e343c0a3369eca80c2676
5
+ SHA512:
6
+ metadata.gz: e9849295843bd1822f9fed629cb9ecef7bfbed28fae71397c8aad19f27088e08e9f02c80e1dec43d20ddeca9b1621e7ced1dc87e8188af6632dcef94d3babd3d
7
+ data.tar.gz: cedd93953d40ef6bab937840e2eeec5521b0fd0ed0cee2412a6748512441a4cb2460fb72c13706cf15cca588365af08a676f607a4e39bf6786d626b1a50bf1ee
data/.gitignore ADDED
@@ -0,0 +1,4 @@
1
+ Makefile
2
+ *.bundle
3
+ *.o
4
+ *.gem
data/Gemfile ADDED
@@ -0,0 +1,4 @@
1
+ source 'https://rubygems.org'
2
+
3
+ # Specify your gem's dependencies in penguin_queue.gemspec
4
+ gemspec
data/Gemfile.lock ADDED
@@ -0,0 +1,25 @@
1
+ PATH
2
+ remote: .
3
+ specs:
4
+ penguin_queue (0.1.0)
5
+
6
+ GEM
7
+ remote: https://rubygems.org/
8
+ specs:
9
+ minitest (5.10.1)
10
+ rake (10.5.0)
11
+ rake-compiler (1.0.3)
12
+ rake
13
+
14
+ PLATFORMS
15
+ ruby
16
+
17
+ DEPENDENCIES
18
+ bundler (~> 1.13)
19
+ minitest (~> 5.0)
20
+ penguin_queue!
21
+ rake (~> 10.0)
22
+ rake-compiler
23
+
24
+ BUNDLED WITH
25
+ 1.13.7
data/LICENSE.txt ADDED
@@ -0,0 +1,21 @@
1
+ The MIT License (MIT)
2
+
3
+ Copyright (c) 2017 tompng
4
+
5
+ Permission is hereby granted, free of charge, to any person obtaining a copy
6
+ of this software and associated documentation files (the "Software"), to deal
7
+ in the Software without restriction, including without limitation the rights
8
+ to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
9
+ copies of the Software, and to permit persons to whom the Software is
10
+ furnished to do so, subject to the following conditions:
11
+
12
+ The above copyright notice and this permission notice shall be included in
13
+ all copies or substantial portions of the Software.
14
+
15
+ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16
+ IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17
+ FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18
+ AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19
+ LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20
+ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
21
+ THE SOFTWARE.
data/README.md ADDED
@@ -0,0 +1,56 @@
1
+ # Priority Queue
2
+ ```ruby
3
+ 10000.times { array << rand; array.delete(array.min) } #=> slow when array.size is large
4
+ 10000.times { pq << rand; pq.deq } #=> fast even if pq.size is large
5
+ ```
6
+
7
+ # Install
8
+ ```ruby
9
+ # Gemfile
10
+ gem 'penguin_queue', git: 'https://github.com/tompng/penguin_queue'
11
+ ```
12
+
13
+ # Usage
14
+ ```ruby
15
+ require 'penguin_queue'
16
+ pq = PenguinQueue.new
17
+ 10.times.to_a.shuffle.each { |i| pq << i }
18
+ 10.times.map { pq.deq } #=> [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
19
+
20
+ # custom priority
21
+ pq.enq 'hello', priority: 0
22
+ pq.first #=> "hello"
23
+ pq.first_with_priority #=> ["hello", 0]
24
+ pq.deq_with_priority #=> ["hello", 0]
25
+
26
+ # update priority, remove node
27
+ nodes = 10.times.to_a.shuffle.map { |i| pq << i }
28
+ nodes.each { |n| n.priority = -n.priority }
29
+ nodes.each_with_index{ |n| n.remove if n.value.odd? }
30
+ pq.size.times.map { pq.deq } #=> [8, 6, 4, 2, 0]
31
+ ```
32
+
33
+ # Methods
34
+ ```ruby
35
+ # PenguinQueue
36
+ PenguinQueue.new PenguinQueue.new(&calc_priority_from_element_proc)
37
+ # enqueue multiple
38
+ push(e1, e2, ...) unshift(e1, e2, ...)
39
+ # enqueue
40
+ <<(e) enq(e)
41
+ # enqueue with custom priority
42
+ enq(e, priority: p)
43
+ # dequeue
44
+ deq shift pop deque_with_priority
45
+ # dequeue multiple
46
+ deq(n) shift(n) pop(n)
47
+ # fetch
48
+ first first_with_priority first_node
49
+ # remove
50
+ remove(node) delete(node)
51
+ # other
52
+ to_s inspect size empty?
53
+
54
+ # PenguinQueue::Node
55
+ remove delete value value= priority priority=
56
+ ```
data/Rakefile ADDED
@@ -0,0 +1,18 @@
1
+ require "bundler/gem_tasks"
2
+ require "rake/testtask"
3
+
4
+ Rake::TestTask.new(:test) do |t|
5
+ t.libs << "test"
6
+ t.libs << "lib"
7
+ t.test_files = FileList['test/**/*_test.rb']
8
+ end
9
+
10
+ require "rake/extensiontask"
11
+
12
+ task :build => :compile
13
+
14
+ Rake::ExtensionTask.new("penguin_queue") do |ext|
15
+ ext.lib_dir = "lib/penguin_queue"
16
+ end
17
+
18
+ task :default => [:clobber, :compile, :test]
data/bin/console ADDED
@@ -0,0 +1,14 @@
1
+ #!/usr/bin/env ruby
2
+
3
+ require "bundler/setup"
4
+ require "penguin_queue"
5
+
6
+ # You can add fixtures and/or initialization code here to make experimenting
7
+ # with your gem easier. You can also use a different console, if you like.
8
+
9
+ # (If you use this, don't forget to add pry to your Gemfile!)
10
+ # require "pry"
11
+ # Pry.start
12
+
13
+ require "irb"
14
+ IRB.start
data/bin/setup ADDED
@@ -0,0 +1,8 @@
1
+ #!/usr/bin/env bash
2
+ set -euo pipefail
3
+ IFS=$'\n\t'
4
+ set -vx
5
+
6
+ bundle install
7
+
8
+ # Do any other automated setup that you need to do here
@@ -0,0 +1,3 @@
1
+ require "mkmf"
2
+
3
+ create_makefile("penguin_queue/penguin_queue")
@@ -0,0 +1,340 @@
1
+ #include <ruby.h>
2
+
3
+ static ID id_priority, id_cmp, id_call;
4
+ #define RB_STR_BUF_CAT(rstr, cstr) rb_str_buf_cat((rstr), (cstr), sizeof(cstr)-1);
5
+ struct node {
6
+ long index, id;
7
+ VALUE heap, priority, value;
8
+ };
9
+ VALUE node_class;
10
+ void node_mark(struct node *ptr){
11
+ rb_gc_mark(ptr->heap);
12
+ rb_gc_mark(ptr->priority);
13
+ rb_gc_mark(ptr->value);
14
+ }
15
+ VALUE node_alloc_internal(long index, long id, VALUE heap, VALUE priority, VALUE value){
16
+ struct node *ptr = ALLOC(struct node);
17
+ ptr->index = index;
18
+ ptr->id = id;
19
+ ptr->heap = heap;
20
+ ptr->priority = priority;
21
+ ptr->value = value;
22
+ return Data_Wrap_Struct(node_class, node_mark, -1, ptr);
23
+ }
24
+ #define NODE_PREPARE(self, name) struct node *name;Data_Get_Struct(self, struct node, name);
25
+ VALUE node_pri(VALUE self){
26
+ NODE_PREPARE(self, ptr);
27
+ return ptr->priority;
28
+ }
29
+ VALUE node_val(VALUE self){
30
+ NODE_PREPARE(self, ptr);
31
+ return ptr->value;
32
+ }
33
+ VALUE node_val_set(VALUE self, VALUE val){
34
+ NODE_PREPARE(self, ptr);
35
+ return ptr->value = val;
36
+ }
37
+ VALUE node_inspect(VALUE self){
38
+ NODE_PREPARE(self, nptr);
39
+ VALUE str = rb_str_buf_new(0);
40
+ rb_str_buf_append(str, rb_class_name(CLASS_OF(self)));
41
+ RB_STR_BUF_CAT(str, "{priority: ");
42
+ rb_str_buf_append(str, rb_inspect(nptr->priority));
43
+ RB_STR_BUF_CAT(str, ", value: ");
44
+ rb_str_buf_append(str, rb_inspect(nptr->value));
45
+ RB_STR_BUF_CAT(str, "}");
46
+ return str;
47
+ }
48
+
49
+ struct queue_data{
50
+ long counter;
51
+ VALUE heap, compare_by;
52
+ };
53
+
54
+ long compare(VALUE a, VALUE b){
55
+ if(RB_FIXNUM_P(a)&&RB_FIXNUM_P(b))
56
+ return (long)a > (long)b ? 1 : (long)a < (long)b ? -1 : 0;
57
+ if(RB_FLOAT_TYPE_P(a)&&RB_FLOAT_TYPE_P(b)){
58
+ double fa=RFLOAT_VALUE(a),fb=RFLOAT_VALUE(b);
59
+ return fa>fb?1:fa<fb?-1:0;
60
+ }
61
+ if(RB_TYPE_P(a, T_STRING)&&RB_TYPE_P(b, T_STRING))
62
+ return rb_str_cmp(a, b);
63
+ return rb_fix2long(rb_funcall(a, id_cmp, 1, b));
64
+ }
65
+ long compare_id(long a, long b){return a>b?1:a<b?-1:0;}
66
+ void heap_mark(struct queue_data *st){
67
+ rb_gc_mark(st->heap);
68
+ rb_gc_mark(st->compare_by);
69
+ }
70
+ void heap_free(struct queue_data *st){free(st);}
71
+ VALUE heap_alloc(VALUE klass){
72
+ struct queue_data *ptr=ALLOC(struct queue_data);
73
+ ptr->counter = 0;
74
+ ptr->heap = rb_ary_new_capa(1);
75
+ rb_ary_push(ptr->heap, Qnil);
76
+ if(rb_block_given_p()){
77
+ ptr->compare_by = rb_block_proc();
78
+ }else{
79
+ ptr->compare_by = Qnil;
80
+ }
81
+ return Data_Wrap_Struct(klass, heap_mark, heap_free, ptr);
82
+ }
83
+
84
+ #define QUEUE_PREPARE(self, name) struct queue_data *name;Data_Get_Struct(self, struct queue_data, name);
85
+
86
+ void heap_up(VALUE self, VALUE node){
87
+ QUEUE_PREPARE(self, ptr);
88
+ RARRAY_PTR_USE(ptr->heap, heap, {
89
+ NODE_PREPARE(node, nptr);
90
+ long index = nptr->index;
91
+ while(index > 1){
92
+ long pindex = index/2;
93
+ VALUE pnode = heap[pindex];
94
+ NODE_PREPARE(pnode, pptr);
95
+ long cmp = compare(pptr->priority, nptr->priority);
96
+ if(!cmp)cmp=compare_id(pptr->id, nptr->id);
97
+ if(cmp<0)break;
98
+ pptr->index = index;
99
+ heap[index] = pnode;
100
+ index = pindex;
101
+ }
102
+ nptr->index = index;
103
+ heap[index] = node;
104
+ });
105
+ }
106
+
107
+ void heap_down(VALUE self, VALUE node){
108
+ QUEUE_PREPARE(self, ptr);
109
+ long length = RARRAY_LEN(ptr->heap);
110
+ RARRAY_PTR_USE(ptr->heap, heap, {
111
+ NODE_PREPARE(node, nptr);
112
+ long index = nptr->index;
113
+ while(2*index < length){
114
+ long lindex = 2*index;
115
+ VALUE lnode = heap[lindex];
116
+ NODE_PREPARE(lnode, lptr);
117
+ if(lindex+1 < length){
118
+ VALUE rnode = heap[lindex+1];
119
+ NODE_PREPARE(rnode, rptr);
120
+ long cmp = compare(lptr->priority, rptr->priority);
121
+ if(!cmp)cmp=compare_id(lptr->id, rptr->id);
122
+ if(cmp >= 0){
123
+ lindex += 1;
124
+ lnode = rnode;
125
+ lptr = rptr;
126
+ }
127
+ }
128
+ long cmp = compare(nptr->priority, lptr->priority);
129
+ if(!cmp)cmp=compare_id(nptr->id, lptr->id);
130
+ if(cmp <= 0)break;
131
+ lptr->index = index;
132
+ heap[index] = lnode;
133
+ index = lindex;
134
+ }
135
+ nptr->index = index;
136
+ heap[index] = node;
137
+ });
138
+ }
139
+
140
+ VALUE heap_remove_node(VALUE self, VALUE node){
141
+ if(!rb_obj_is_kind_of(node, node_class))return Qnil;
142
+ QUEUE_PREPARE(self, ptr);
143
+ NODE_PREPARE(node, nptr);
144
+ long length = RARRAY_LEN(ptr->heap);
145
+ if(nptr->index >= length || RARRAY_AREF(ptr->heap, nptr->index) != node)return Qnil;
146
+ RARRAY_PTR_USE(ptr->heap, heap, {
147
+ VALUE replace_node = rb_ary_pop(ptr->heap);
148
+ if(replace_node == node)return Qnil;
149
+ NODE_PREPARE(replace_node, rptr);
150
+ heap[nptr->index] = replace_node;
151
+ rptr->index = nptr->index;
152
+ long cmp = compare(rptr->priority, nptr->priority);
153
+ if(!cmp)cmp = compare_id(rptr->id, nptr->id);
154
+ if(cmp > 0){
155
+ heap_down(nptr->heap, replace_node);
156
+ }else{
157
+ heap_up(nptr->heap, replace_node);
158
+ }
159
+ });
160
+ return Qnil;
161
+ }
162
+
163
+ VALUE node_remove(VALUE self){
164
+ NODE_PREPARE(self, nptr);
165
+ heap_remove_node(nptr->heap, self);
166
+ return Qnil;
167
+ }
168
+
169
+ VALUE node_update_priority(VALUE node, VALUE priority){
170
+ NODE_PREPARE(node, nptr);
171
+ QUEUE_PREPARE(nptr->heap, ptr);
172
+ VALUE priority_was = nptr->priority;
173
+ nptr->priority = priority;
174
+ long cmp = compare(priority, priority_was);
175
+ if(cmp == 0)return Qnil;
176
+ RARRAY_PTR_USE(ptr->heap, heap, {
177
+ if(heap[nptr->index] != node)return Qnil;
178
+ });
179
+ if(cmp < 0){
180
+ heap_up(nptr->heap, node);
181
+ }else{
182
+ heap_down(nptr->heap, node);
183
+ }
184
+ return Qnil;
185
+ }
186
+
187
+ VALUE heap_enq_vp(VALUE self, VALUE value, VALUE priority){
188
+ QUEUE_PREPARE(self, ptr);
189
+ if(ptr->compare_by != Qnil){
190
+ priority = rb_funcall(ptr->compare_by, id_call, 1, value);
191
+ }
192
+ long length = RARRAY_LEN(ptr->heap);
193
+ VALUE node = node_alloc_internal(length, ptr->counter, self, priority, value);
194
+ ptr->counter++;
195
+ rb_ary_push(ptr->heap, node);
196
+ heap_up(self, node);
197
+ return node;
198
+ }
199
+
200
+ #define OPTHASH_GIVEN_P(opts) \
201
+ (argc > 0 && !NIL_P((opts) = rb_check_hash_type(argv[argc-1])) && (--argc, 1))
202
+
203
+ VALUE heap_enq(int argc, VALUE *argv, VALUE self){
204
+ VALUE value, opts, priority, pri = Qundef;
205
+ if (OPTHASH_GIVEN_P(opts)) {
206
+ ID keyword_ids[] = {id_priority};
207
+ rb_get_kwargs(opts, keyword_ids, 0, 1, &pri);
208
+ }
209
+ rb_scan_args(argc, argv, "1", &value);
210
+ priority = (pri == Qundef) ? value : pri;
211
+ return heap_enq_vp(self, value, priority);
212
+ }
213
+ VALUE heap_push(VALUE self, VALUE value){
214
+ return heap_enq_vp(self, value, value);
215
+ }
216
+ VALUE heap_push_multiple(int argc, VALUE *argv, VALUE self){
217
+ VALUE nodes = rb_ary_new_capa(argc);
218
+ for(int i=0;i<argc;i++)rb_ary_push(nodes, heap_push(self, argv[i]));
219
+ return nodes;
220
+ }
221
+
222
+ VALUE heap_first_node(VALUE self){
223
+ QUEUE_PREPARE(self, ptr);
224
+ long length = RARRAY_LEN(ptr->heap);
225
+ if(length == 1)return Qnil;
226
+ RARRAY_PTR_USE(ptr->heap, heap, {
227
+ return heap[1];
228
+ });
229
+ }
230
+ VALUE heap_first(VALUE self){
231
+ VALUE node = heap_first_node(self);
232
+ if(node == Qnil)return Qnil;
233
+ NODE_PREPARE(node, nptr);
234
+ return nptr->value;
235
+ }
236
+ VALUE heap_first_with_priority(VALUE self){
237
+ VALUE node = heap_first_node(self);
238
+ if(node == Qnil)return Qnil;
239
+ NODE_PREPARE(node, nptr);
240
+ return rb_ary_new_from_args(2, nptr->value, nptr->priority);
241
+ }
242
+
243
+ VALUE heap_deq_node(VALUE self){
244
+ QUEUE_PREPARE(self, ptr);
245
+ long length = RARRAY_LEN(ptr->heap);
246
+ if(length == 1)return Qnil;
247
+ RARRAY_PTR_USE(ptr->heap, heap, {
248
+ VALUE first = heap[1];
249
+ VALUE node = rb_ary_pop(ptr->heap);
250
+ NODE_PREPARE(node, nptr);
251
+ if(length > 1){
252
+ nptr->index = 1;
253
+ heap_down(self, node);
254
+ }
255
+ return first;
256
+ });
257
+ }
258
+ VALUE heap_deq(int argc, VALUE *argv, VALUE self){
259
+ if(argc == 0){
260
+ VALUE node = heap_deq_node(self);
261
+ if(node == Qnil)return Qnil;
262
+ NODE_PREPARE(node, nptr);
263
+ return nptr->value;
264
+ }else{
265
+ VALUE nv;
266
+ rb_scan_args(argc, argv, "1", &nv);
267
+ long n = NUM2LONG(nv);
268
+ if(n<0)rb_raise(rb_eArgError, "negative array size");
269
+ QUEUE_PREPARE(self, ptr);
270
+ long length = RARRAY_LEN(ptr->heap)-1;
271
+ if(n>length)n=length;
272
+ VALUE result = rb_ary_new_capa(n);
273
+ for(int i=0;i<n;i++){
274
+ VALUE node = heap_deq_node(self);
275
+ NODE_PREPARE(node, nptr);
276
+ rb_ary_push(result, nptr->value);
277
+ }
278
+ return result;
279
+ }
280
+ }
281
+ VALUE heap_deq_with_priority(VALUE self){
282
+ VALUE node = heap_deq_node(self);
283
+ if(node == Qnil)return Qnil;
284
+ NODE_PREPARE(node, nptr);
285
+ return rb_ary_new_from_args(2, nptr->value, nptr->priority);
286
+ }
287
+
288
+ VALUE heap_size(VALUE self){
289
+ QUEUE_PREPARE(self, ptr);
290
+ return LONG2FIX(RARRAY_LEN(ptr->heap)-1);
291
+ }
292
+ VALUE heap_is_empty(VALUE self){
293
+ QUEUE_PREPARE(self, ptr);
294
+ return RARRAY_LEN(ptr->heap) == 1 ? Qtrue : Qfalse;
295
+ }
296
+ VALUE heap_inspect(VALUE self){
297
+ VALUE str = rb_str_buf_new(0);
298
+ rb_str_buf_append(str, rb_class_name(CLASS_OF(self)));
299
+ RB_STR_BUF_CAT(str, "{size: ");
300
+ rb_str_buf_append(str, rb_inspect(heap_size(self)));
301
+ RB_STR_BUF_CAT(str, "}");
302
+ return str;
303
+ }
304
+
305
+ void Init_penguin_queue(void){
306
+ id_priority = rb_intern("priority");
307
+ id_call = rb_intern("call");
308
+ id_cmp = rb_intern("<=>");
309
+
310
+ VALUE heap_class = rb_define_class("PenguinQueue", rb_cObject);
311
+ rb_define_alloc_func(heap_class, heap_alloc);
312
+ rb_define_method(heap_class, "size", heap_size, 0);
313
+ rb_define_method(heap_class, "empty?", heap_is_empty, 0);
314
+ rb_define_method(heap_class, "inspect", heap_inspect, 0);
315
+ rb_define_method(heap_class, "first", heap_first, 0);
316
+ rb_define_method(heap_class, "first_node", heap_first_node, 0);
317
+ rb_define_method(heap_class, "first_with_priority", heap_first_with_priority, 0);
318
+ rb_define_method(heap_class, "to_s", heap_inspect, 0);
319
+ rb_define_method(heap_class, "push", heap_push_multiple, -1);
320
+ rb_define_method(heap_class, "<<", heap_push, 1);
321
+ rb_define_method(heap_class, "enq", heap_enq, -1);
322
+ rb_define_method(heap_class, "unshift", heap_push_multiple, -1);
323
+ rb_define_method(heap_class, "pop", heap_deq, -1);
324
+ rb_define_method(heap_class, "shift", heap_deq, -1);
325
+ rb_define_method(heap_class, "deq", heap_deq, -1);
326
+ rb_define_method(heap_class, "deq_with_priority", heap_deq_with_priority, 0);
327
+ rb_define_method(heap_class, "delete", heap_remove_node, 1);
328
+ rb_define_method(heap_class, "remove", heap_remove_node, 1);
329
+
330
+ node_class = rb_define_class_under(heap_class, "Node", rb_cObject);
331
+ rb_undef_alloc_func(node_class);
332
+ rb_define_method(node_class, "priority", node_pri, 0);
333
+ rb_define_method(node_class, "priority=", node_update_priority, 1);
334
+ rb_define_method(node_class, "value", node_val, 0);
335
+ rb_define_method(node_class, "value=", node_val_set, 1);
336
+ rb_define_method(node_class, "inspect", node_inspect, 0);
337
+ rb_define_method(node_class, "to_s", node_inspect, 0);
338
+ rb_define_method(node_class, "remove", node_remove, 0);
339
+ rb_define_method(node_class, "delete", node_remove, 0);
340
+ }
@@ -0,0 +1,3 @@
1
+ class PenguinQueue
2
+ VERSION = "0.1.0"
3
+ end
@@ -0,0 +1,2 @@
1
+ require "penguin_queue/penguin_queue"
2
+ require "penguin_queue/version"
@@ -0,0 +1,29 @@
1
+ # coding: utf-8
2
+ lib = File.expand_path('../lib', __FILE__)
3
+ $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
4
+ require 'penguin_queue/version'
5
+
6
+ Gem::Specification.new do |spec|
7
+ spec.name = "penguin_queue"
8
+ spec.version = PenguinQueue::VERSION
9
+ spec.authors = ["tompng"]
10
+ spec.email = ["tomoyapenguin@gmail.com"]
11
+
12
+ spec.summary = %q{C Ext Priority Queue}
13
+ spec.description = %q{C Ext Priority Queue (binary heap)}
14
+ spec.homepage = "https://github.com/tompng/penguin_queue"
15
+ spec.license = "MIT"
16
+ spec.extensions = %w[ext/penguin_queue/extconf.rb]
17
+
18
+ spec.files = `git ls-files -z`.split("\x0").reject do |f|
19
+ f.match(%r{^(test|spec|features)/})
20
+ end
21
+ spec.bindir = "exe"
22
+ spec.executables = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
23
+ spec.require_paths = ["lib"]
24
+
25
+ spec.add_development_dependency "bundler", "~> 1.13"
26
+ spec.add_development_dependency "rake", "~> 10.0"
27
+ spec.add_development_dependency "minitest", "~> 5.0"
28
+ spec.add_development_dependency "rake-compiler"
29
+ end
metadata ADDED
@@ -0,0 +1,114 @@
1
+ --- !ruby/object:Gem::Specification
2
+ name: penguin_queue
3
+ version: !ruby/object:Gem::Version
4
+ version: 0.1.0
5
+ platform: ruby
6
+ authors:
7
+ - tompng
8
+ autorequire:
9
+ bindir: exe
10
+ cert_chain: []
11
+ date: 2017-02-19 00:00:00.000000000 Z
12
+ dependencies:
13
+ - !ruby/object:Gem::Dependency
14
+ name: bundler
15
+ requirement: !ruby/object:Gem::Requirement
16
+ requirements:
17
+ - - "~>"
18
+ - !ruby/object:Gem::Version
19
+ version: '1.13'
20
+ type: :development
21
+ prerelease: false
22
+ version_requirements: !ruby/object:Gem::Requirement
23
+ requirements:
24
+ - - "~>"
25
+ - !ruby/object:Gem::Version
26
+ version: '1.13'
27
+ - !ruby/object:Gem::Dependency
28
+ name: rake
29
+ requirement: !ruby/object:Gem::Requirement
30
+ requirements:
31
+ - - "~>"
32
+ - !ruby/object:Gem::Version
33
+ version: '10.0'
34
+ type: :development
35
+ prerelease: false
36
+ version_requirements: !ruby/object:Gem::Requirement
37
+ requirements:
38
+ - - "~>"
39
+ - !ruby/object:Gem::Version
40
+ version: '10.0'
41
+ - !ruby/object:Gem::Dependency
42
+ name: minitest
43
+ requirement: !ruby/object:Gem::Requirement
44
+ requirements:
45
+ - - "~>"
46
+ - !ruby/object:Gem::Version
47
+ version: '5.0'
48
+ type: :development
49
+ prerelease: false
50
+ version_requirements: !ruby/object:Gem::Requirement
51
+ requirements:
52
+ - - "~>"
53
+ - !ruby/object:Gem::Version
54
+ version: '5.0'
55
+ - !ruby/object:Gem::Dependency
56
+ name: rake-compiler
57
+ requirement: !ruby/object:Gem::Requirement
58
+ requirements:
59
+ - - ">="
60
+ - !ruby/object:Gem::Version
61
+ version: '0'
62
+ type: :development
63
+ prerelease: false
64
+ version_requirements: !ruby/object:Gem::Requirement
65
+ requirements:
66
+ - - ">="
67
+ - !ruby/object:Gem::Version
68
+ version: '0'
69
+ description: C Ext Priority Queue (binary heap)
70
+ email:
71
+ - tomoyapenguin@gmail.com
72
+ executables: []
73
+ extensions:
74
+ - ext/penguin_queue/extconf.rb
75
+ extra_rdoc_files: []
76
+ files:
77
+ - ".gitignore"
78
+ - Gemfile
79
+ - Gemfile.lock
80
+ - LICENSE.txt
81
+ - README.md
82
+ - Rakefile
83
+ - bin/console
84
+ - bin/setup
85
+ - ext/penguin_queue/extconf.rb
86
+ - ext/penguin_queue/penguin_queue.c
87
+ - lib/penguin_queue.rb
88
+ - lib/penguin_queue/version.rb
89
+ - penguin_queue.gemspec
90
+ homepage: https://github.com/tompng/penguin_queue
91
+ licenses:
92
+ - MIT
93
+ metadata: {}
94
+ post_install_message:
95
+ rdoc_options: []
96
+ require_paths:
97
+ - lib
98
+ required_ruby_version: !ruby/object:Gem::Requirement
99
+ requirements:
100
+ - - ">="
101
+ - !ruby/object:Gem::Version
102
+ version: '0'
103
+ required_rubygems_version: !ruby/object:Gem::Requirement
104
+ requirements:
105
+ - - ">="
106
+ - !ruby/object:Gem::Version
107
+ version: '0'
108
+ requirements: []
109
+ rubyforge_project:
110
+ rubygems_version: 2.6.8
111
+ signing_key:
112
+ specification_version: 4
113
+ summary: C Ext Priority Queue
114
+ test_files: []