haystack_worker 0.0.1

data/README.md

@@ -0,0 +1,42 @@
+## Haystack Worker
+
+Works on behalf of a haystack server.
+
+## Concept
+
+A haystack worker's sole responsibility is to calculate surpluses of characters that satisfy self-enumerating pangrams. It does this as quickly as possible and therefore makes use of a C-extension for a ~200x speed increase over Ruby.
+
+It receives 'jobs' from a haystack server which come in the form:
+
+```ruby
+{ 'id' => 123, 'ranges' => [1..10, 3..4, 8..14, etc] }
+```
+
+The ranges represent the search space that this worker has been assigned to explore. The ID is used by the haystack worker to keep track of jobs.
+
+It posts data back to the haystack at /job/:id in the form:
+
+```ruby
+[[1,3,8,etc],[6,4,14,etc]]
+```
+
+It returns ```nil``` if the given search space doesn't contain any potential self-enumerating pangrams.
+
+## Usage
+
+```
+gem install haystack_worker
+haystack worker haystack.example.com
+```
+
+At present, I haven't built the haystack server. When I have, I'll update the gem to point to it by default.
+
+## Resources
+
+For more information or to gain some context, please see my pangram and frequency related projects.
+
+## Contribution
+
+Feel free to contribute. No commit is too small.
+
+You should follow me: [@cpatuzzo](https://twitter.com/cpatuzzo)

data/bin/haystack

@@ -0,0 +1,6 @@
+#!/usr/bin/ruby
+
+require 'haystack_worker'
+
+ARGV[1] ||= 'localhost:9292'
+HaystackWorker.work(ARGV[1])

data/ext/haystack_worker/extconf.rb

@@ -0,0 +1,3 @@
+require 'mkmf'
+
+create_makefile('haystack_worker/haystack_worker')

data/ext/haystack_worker/haystack_worker.c

@@ -0,0 +1,72 @@
+#include <ruby.h>
+#include "lookup.h"
+#include "macros.h"
+
+static VALUE surpluses(VALUE self, VALUE rb_ary) {
+  int i, j, ranges[26][2];
+  for (i = 0; i < 26; i++) {
+    for (j = 0; j < 2; j++) {
+      ranges[i][j] = FIX2INT(RARRAY_PTR(RARRAY_PTR(rb_ary)[i])[j]);
+    }
+  }
+
+  int blocks = 16, position = 0, *array = NULL, bytes;
+
+  YIELD_ATTEMPTS {
+    int total[26] = {};
+    for (i = 0; i < 26; i++) {
+      for (j = 0; j < 26; j++) {
+        total[j] += WORD_LOOKUP[attempt[i]][i][j];
+      }
+    }
+
+    int satisfiable = 1, surplus[26];
+    for (i = 0; i < 26; i++) {
+      surplus[i] = attempt[i] - total[i];
+      if (surplus[i] < 0) {
+        satisfiable = 0;
+        break;
+      }
+    }
+
+    if (satisfiable) {
+      if (position + 26 > blocks) {
+        blocks *= 2, bytes = blocks * sizeof(int);
+        array = realloc(array, bytes);
+
+        if (array == NULL) {
+          rb_raise(rb_eNoMemError, "Failed to allocate %d bytes", bytes);
+        }
+      }
+
+      for (i = 0; i < 26; i++) {
+        array[position + i] = attempt[i];
+      }
+
+      position += 26;
+    }
+  }
+
+  if (position == 0) {
+    return Qnil;
+  }
+  else {
+    VALUE rb_solutions = rb_ary_new(), rb_solution;
+
+    for (i = 0; i < position / 26; i++) {
+      rb_solution = rb_ary_new();
+      for (j = 0; j < 26; j++) {
+        rb_ary_push(rb_solution, INT2FIX(array[i * 26 + j]));
+      }
+      rb_ary_push(rb_solutions, rb_solution);
+    }
+
+    free(array);
+    return rb_solutions;
+  }
+}
+
+void Init_haystack_worker(void) {
+  VALUE klass = rb_define_class("HaystackWorker", rb_cObject);
+  rb_define_method(klass, "_surpluses", surpluses, 1);
+}