eldritch 0.1.0 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 421afdae683a86e47b2138e1c5b22ff833a7ef7a
-  data.tar.gz: e364c1a1030cf95dc5a3aa38efac6cf5a44111e2
+  metadata.gz: 1cbab97dd7492c7c19829d608f555e6cd1660901
+  data.tar.gz: a05f7a551bc3c73736f86846b2fced0f51000e67
 SHA512:
-  metadata.gz: 0b558a3aa5e75a0a84f7d58dc292ea9afb49a8991442056d0e8afccbbd321d964d825d3fbab53d2e721a90fbee6722342f360948cf1440e82c9b674de5eb9e97
-  data.tar.gz: b7faec1e5ad653d78669e60a6ba0e11f4c9e16f029fd129b88575da4193edf5af1773ad98d7881d85d05d372bee941b7ed6fa20fded7f277be8b3a263293f569
+  metadata.gz: 679b8be6668f63dbd2b688e94b64f30f58ec858d0d6179ddc06ccc3e434ddd4973214bf7af41846849d970888494d2c8788d07ae11e859f46949416ebedb1351
+  data.tar.gz: 4478f50cf4c09996245b2407007287a03368731818bdaeb466e7cd6ee6602ff321e6fc7083023f622deee32fe521e6d3a16d766809455f31fda2eef8afd7f452

data/.travis.yml

@@ -1,3 +1,4 @@
 language: ruby
 rvm:
+  - 2.1.0
   - 2.1.1

data/README.md

@@ -3,9 +3,14 @@ Eldritch
 
 _The dark arts of concurrent programming._
 
-**This gem is in development and in no way shape or form production ready.**
+A DSL that adds parallel programming constructs to make your life a little easier.
 
-A ruby gem that adds parallel programming constructs to make your life a little easier.
+Code quality
+------------
+
+[![Build Status](http://travis-ci.org/beraboris/eldritch.svg?branch=master)](http://travis-ci.org/beraboris/eldritch)
+[![Coverage Status](http://coveralls.io/repos/beraboris/eldritch/badge.png)](http://coveralls.io/r/beraboris/eldritch)
+[![Code Climate](http://codeclimate.com/github/beraboris/eldritch.png)](http://codeclimate.com/github/beraboris/eldritch)
 
 Features
 --------
@@ -60,16 +65,16 @@ end
 res = 2 + task.value # waits for the task to finish
 ```
 
-### together
+### together blocks
 
-Together blocks are used to control all async blocks and methods within them as a group. Right now, the together block
-waits for all async calls be de done before exiting.
+Together blocks are used to control all async blocks and methods within them as a group. Before exiting, together blocks
+wait for all their async calls to be done before returning.
 
 ```ruby
 require 'eldritch'
 
 together do
-  1000.each do
+  1000.times do
     async do
       # do some work
     end
@@ -78,6 +83,22 @@ end
 # all 1000 tasks are done
 ```
 
+These blocks can also take an argument. This argument is a group that can be used to control the async calls in the
+block. See the documentation for Eldritch::Group for more information.
+
+```ruby
+require 'eldritch'
+
+together do |group|
+  5.times do
+    async do
+      # do something
+      group.interrupt if some_condition  # stops all other tasks
+    end
+  end
+end
+```
+
 Installation
 ------------
 
@@ -92,12 +113,3 @@ And then execute:
 Or install it yourself as:
 
     $ gem install eldritch
-
-Code quality
-------------
-
-[![Build Status](http://travis-ci.org/beraboris/eldritch.svg?branch=master)](http://travis-ci.org/beraboris/eldritch)
-
-[![Coverage Status](http://coveralls.io/repos/beraboris/eldritch/badge.png)](http://coveralls.io/r/beraboris/eldritch)
-
-[![Code Climate](http://codeclimate.com/github/beraboris/eldritch.png)](http://codeclimate.com/github/beraboris/eldritch)

data/Rakefile

@@ -1,6 +1,8 @@
 require 'bundler/gem_tasks'
 require 'rspec/core/rake_task'
+require 'yard'
 
 RSpec::Core::RakeTask.new(:spec)
+YARD::Rake::YardocTask.new(:doc)
 
 task :default => :spec

data/eldritch.gemspec

@@ -8,11 +8,14 @@ Gem::Specification.new do |spec|
   spec.version       = Eldritch::VERSION
   spec.authors       = ['Boris Bera', 'François Genois']
   spec.email         = %w(bboris@rsoft.ca frankgenerated@gmail.com)
-  spec.summary       = %q{Adds tools to make parallelism easier.}
+  spec.summary       = %q{DSL that adds concurrent programming concepts to make your life easier.}
   spec.description   = %q{Adds support for async methods and async blocks. Adds a together block that allows async methods/blocks to be controlled as a group.}
   spec.homepage      = 'https://github.com/beraboris/eldritch'
   spec.license       = 'MIT'
 
+  # need refinements
+  spec.required_ruby_version = '>= 2.1'
+
   spec.files         = `git ls-files -z`.split("\x0")
   spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
   spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
@@ -21,4 +24,5 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency 'bundler', '~> 1.5'
   spec.add_development_dependency 'rake'
   spec.add_development_dependency 'rspec', '~> 2.14'
+  spec.add_development_dependency 'yard', '~> 0.8.7.4'
 end

data/examples/matrix_multiplication.rb

@@ -0,0 +1,37 @@
+#!/usr/bin/env ruby
+require 'eldritch'
+
+def print_matrix(matrix)
+  matrix.each {|line| puts line.inspect}
+end
+
+a = [[1, 2, 3],
+     [4, 5, 6]]
+
+b = [[5, 6],
+     [7, 8],
+     [9, 10]]
+b_t = b.transpose
+
+puts 'matrix A:'
+print_matrix(a)
+
+puts 'matrix B:'
+print_matrix(b)
+
+c = [[0, 0],
+     [0, 0]]
+
+together do
+  a.each_with_index do |row, y|
+    b_t.each_with_index do |col, x|
+      async do
+        # scalar product
+        c[y][x] = row.zip(col).map{|i, j| i*j}.reduce(:+)
+      end
+    end
+  end
+end
+
+puts 'A x B = '
+print_matrix(c)

data/examples/password_cracker.rb

@@ -0,0 +1,39 @@
+#!/usr/bin/env ruby
+require 'eldritch'
+require 'digest/md5'
+
+if ARGV.size < 2
+  puts 'Cracks 4 lowercase letter password hashed using MD5'
+  puts
+  puts 'usage: password_cracker.rb <threads> <hash>'
+  puts '  threads: the number of threads to run'
+  puts '  hash: MD5 hash to crack'
+  puts
+  puts 'example:'
+  puts '  password_cracker.rb 4 31d7c3e829be03400641f80b821ef728'
+  puts '  prints "butts"'
+  exit 1
+end
+
+threads = ARGV.shift.to_i
+hash = ARGV.shift
+
+# generate all possible 4 lowercase letter passwords
+passwords = ('a'..'z').to_a.repeated_permutation(4).lazy.map &:join
+
+together do |group|
+  # cut the passwords into slices
+  passwords.each_slice(passwords.size/threads) do |slice|
+    async do
+      slice.each do |password|
+        if hash == Digest::MD5.hexdigest(password)
+          group.synchronize { puts password }
+
+          # stop all the other threads
+          group.interrupt
+          break
+        end
+      end
+    end
+  end
+end

data/lib/eldritch/dsl.rb

@@ -1,5 +1,36 @@
 module Eldritch
+  # Provides DSL for:
+  # - {#async async methods}
+  # - {#async async blocks}
+  # - {#together together blocks}
+  # - {#sync sync keyword}
   module DSL
+    using Eldritch::Refinements
+
+    # Creates an asynchronous method or starts an async block
+    #
+    # If a block is passed, this will be an async block.
+    # Otherwise this method will create an async method.
+    #
+    # When an async block is called, it will yield the block in a new thread.
+    #
+    #   async do
+    #     # will run in parallel
+    #   end
+    #   #=> <Task>
+    #
+    # When called, async methods behave exactly like async blocks.
+    #
+    #   async def foo
+    #     # will run in parallel
+    #   end
+    #
+    #   foo
+    #   #=> <Task>
+    #
+    # @param [Symbol] method the name of the async method.
+    # @return [Task] a task representing the async method or block
+    #   (only for async block and async method call)
     def async(method=nil, &block)
       if block
         async_block(&block)
@@ -8,24 +39,64 @@ module Eldritch
       end
     end
 
+    # Allows async methods to be called like synchronous methods
+    #
+    #   sync send_email(42) # send_mail is async
+    #
+    # @param [Task] task a task returned by {#async}
+    # @return whatever the method has returned
     def sync(task)
       task.value
     end
 
+    # Creates a group of async call and blocks
+    #
+    # When async blocks and calls are inside a together block, they can act as a group.
+    #
+    # A together block waits for all the async call/blocks that were started within itself to stop before continuing.
+    #
+    #   together do
+    #     5.times do
+    #       async { sleep(1) }
+    #     end
+    #   end
+    #   # waits for all 5 async blocks to complete
+    #
+    # A together block will also yield a {Group}. This can be used to interact with the other async calls/blocks.
+    #
+    #   together do |group|
+    #     5.times do
+    #       async do
+    #         # stop everyone else
+    #         group.interrupt if something?
+    #       end
+    #     end
+    #   end
+    #
+    # @yield [Group] group of async blocks/calls
+    # @see Group Group class
     def together
-      t = Together.new
-      Thread.current.together = t
-      yield
-      t.wait_all
-      Thread.current.together = nil
+      old = Thread.current.group
+
+      group = Group.new
+      Thread.current.group = group
+
+      yield group
+
+      group.wait_all
+      Thread.current.group = old
     end
 
     private
 
     def async_block(&block)
-      task = Task.new {|t| t.value = block.call }
-      Thread.current.together << task if Thread.current.together?
-      task.start
+      task = Task.new do |t|
+        begin
+          t.value = block.call
+        rescue InterruptedError
+        end
+      end
+      Thread.current.group << task
       task
     end
 

data/lib/eldritch/group.rb

@@ -0,0 +1,77 @@
+require 'thread'
+
+module Eldritch
+  # Represents a group of {Task tasks} or {DSL#async async calls/block}.
+  # It is used to act upon all the tasks in the group.
+  class Group
+    using Eldritch::Refinements
+
+    def initialize
+      @tasks = []
+      @mutex = Mutex.new
+      @accept = true
+    end
+
+    # @return [Array<Task>] the other async calls/blocks in the group
+    def others
+      @tasks - [Thread.current.task]
+    end
+
+    def <<(task)
+      accept = nil
+
+      @mutex.synchronize do
+        # copy accept for the task.start condition
+        accept = @accept
+        @tasks << task if accept
+      end
+
+      task.start if accept
+    end
+
+    # Yields the block in mutual exclusion with all the async calls/tasks
+    #
+    # @yield
+    def synchronize(&block)
+      @mutex.synchronize { block.call }
+    end
+
+    def wait_all
+      @tasks.each {|t| t.wait}
+    end
+
+    # Aborts the other async calls/blocks in the group
+    #
+    # *Warning*: This call will directly kill underlying threads. This isn't very safe.
+    #
+    # @see Task#abort
+    def abort
+      @mutex.synchronize do
+        @accept = false
+        others.each &:abort
+      end
+    end
+
+    # Interrupts the other async calls/blocks in the group
+    #
+    # Interruptions are done using exceptions that can be caught by the async calls/blocks to perform cleanup.
+    #
+    # @see Task#interrupt
+    def interrupt
+      @mutex.synchronize do
+        @accept = false
+        others.each &:interrupt
+      end
+    end
+  end
+
+  class NilGroup
+    def <<(task)
+      task.start
+    end
+
+    def nil?
+      true
+    end
+  end
+end

data/lib/eldritch/interrupted_error.rb

@@ -0,0 +1,4 @@
+module Eldritch
+  class InterruptedError < RuntimeError
+  end
+end

data/lib/eldritch/refinements/thread.rb

@@ -0,0 +1,16 @@
+module Eldritch
+  module Refinements
+    refine Thread do
+      attr_writer :group
+      attr_accessor :task
+
+      def group
+        @group ||= Eldritch::NilGroup.new
+      end
+
+      def in_group?
+        !group.nil?
+      end
+    end
+  end
+end

data/lib/eldritch/safe.rb

@@ -1,10 +1,24 @@
 require 'eldritch/version'
+require 'eldritch/refinements/thread'
 require 'eldritch/task'
 require 'eldritch/dsl'
-require 'eldritch/ext_core/thread'
-require 'eldritch/together'
+require 'eldritch/group'
+require 'eldritch/interrupted_error'
 
 module Eldritch
+  # Injects the DSL in the main
+  #
+  # This is automatically called when you call
+  #   require 'eldritch'
+  #
+  # If you do not want to contaminate the main you can require +eldritch/safe+ and
+  # include or extend Eldricth::DSL yourself.
+  #
+  #   require 'eldritch/safe'
+  #   module Sandbox
+  #     include Eldritch::DSL  # for async blocks, together and sync
+  #     extend Eldritch::DSL   # for async method declaration
+  #   end
   def self.inject_dsl
     Object.include Eldritch::DSL
   end

data/lib/eldritch/task.rb

@@ -1,23 +1,65 @@
 module Eldritch
+  # Runs a block in parallel and allows for interaction with said block
   class Task
+    using Eldritch::Refinements
+
     attr_writer :value
+
+    # @return [Thread] underlying ruby thread
     attr_reader :thread
 
+    # Creates a new Task instance
+    #
+    # _Note_: this method does not yield the block directly this is done by {#start}
+    #
+    # @yield [Task] the task itself
     def initialize(&block)
       @block = block
     end
 
+    # Starts the task
+    #
+    # This will yield the task to the block passed in the constructor.
+    #
+    #   task = Eldritch::Task.new do |task|
+    #     # do something
+    #   end
+    #   task.start  # calls the block in parallel
     def start
       @thread = Thread.new self, &@block
+      @thread.task = self
     end
 
+    # Waits for the task to complete
     def wait
       @thread.join
     end
 
+    # The return value of the task
+    #
+    # If the task is still running, it will block until it is done and then fetch the return value.
+    #
+    # @return whatever the block returns
     def value
       wait
       @value
     end
+
+    # Forces the task to end
+    #
+    # This kills the underlying thread. This is a dangerous call.
+    def abort
+      @thread.kill
+    end
+
+    # Interrupts the task
+    #
+    # This is done by raising an {InterruptedError} in the task block.
+    # This can be caught to perform cleanup before exiting.
+    # Tasks started with {DSL#async} will automatically handle the exception and stop cleanly.
+    # You can still handle the exception yourself.
+    def interrupt
+      @thread.raise InterruptedError.new
+    end
   end
 end

data/lib/eldritch/version.rb

@@ -1,3 +1,3 @@
 module Eldritch
-  VERSION = '0.1.0'
+  VERSION = '1.0.0'
 end

data/spec/dsl_spec.rb

@@ -1,7 +1,7 @@
 require 'spec_helper'
 require 'eldritch/dsl'
 require 'eldritch/task'
-require 'eldritch/together'
+require 'eldritch/group'
 
 describe Eldritch::DSL do
   let(:klass) do Class.new do
@@ -19,73 +19,90 @@ describe Eldritch::DSL do
   end
 
   describe '#together' do
-    it 'should create a new together' do
-      expect(Eldritch::Together).to receive(:new).and_return(double('together').as_null_object)
+    it 'should create a new group' do
+      expect(Eldritch::Group).to receive(:new).and_return(double('group').as_null_object)
 
       klass.together {}
     end
 
-    it 'should set the current thread together' do
-      together = double('together').as_null_object
-      allow(Eldritch::Together).to receive(:new).and_return(together)
-      allow(Thread.current).to receive(:together=).with(nil)
+    it 'should set the current thread group' do
+      group = double('group').as_null_object
+      allow(Eldritch::Group).to receive(:new).and_return(group)
+      allow(Thread.current).to receive(:group=).with(anything)
 
-      expect(Thread.current).to receive(:together=).with(together)
+      expect(Thread.current).to receive(:group=).with(group)
 
       klass.together {}
     end
 
     it 'should wait on all tasks' do
-      together = double('together').as_null_object
-      allow(Eldritch::Together).to receive(:new).and_return(together)
+      group = double('group').as_null_object
+      allow(Eldritch::Group).to receive(:new).and_return(group)
 
-      expect(together).to receive(:wait_all)
+      expect(group).to receive(:wait_all)
 
       klass.together {}
     end
 
-    it 'should leave current thread together nil' do
-      together = double('together').as_null_object
-      allow(Eldritch::Together).to receive(:new).and_return(together)
+    it 'should reset the previous group when it is done' do
+      group = double('group').as_null_object
+      old_group = double('old group').as_null_object
+      allow(Eldritch::Group).to receive(:new).and_return(group)
+      allow(Thread.current).to receive(:group).and_return(old_group)
 
       klass.together {}
 
-      expect(Thread.current.together).to be_nil
+      expect(Thread.current.group).to eql(old_group)
+    end
+
+    it 'should yield it the new group' do
+      group = double('group').as_null_object
+      allow(Eldritch::Group).to receive(:new).and_return(group)
+
+      expect{ |b| klass.together &b }.to yield_with_args(group)
     end
   end
 
   describe '#async' do
-    context 'with 0 arguments' do
+    let(:task) { double('task').as_null_object }
+    let(:group) { double('group').as_null_object }
+
+    before do
+      call_me = nil
+      allow(Eldritch::Task).to receive(:new) do |&block|
+        call_me = block
+        task
+      end
 
-      it 'should add itself to the together block if together?' do
-        together = double('together')
-        allow(Thread.current).to receive(:together?).and_return(true)
-        allow(Thread.current).to receive(:together).and_return(together)
+      allow(group).to receive(:<<) do
+        call_me.call(task)
+      end
 
-        expect(together).to receive(:<<).with(kind_of(Eldritch::Task))
+      allow(Thread.current).to receive(:group).and_return(group)
+    end
+
+    context 'with 0 arguments' do
+      it 'should add itself to the group' do
+        expect(group).to receive(:<<).with(task)
 
         klass.async {}
       end
 
       it 'should return a task' do
-        expect(klass.async {}).to be_a(Eldritch::Task)
-      end
-
-      it 'should start a task' do
-        task = double(:task)
-        allow(Eldritch::Task).to receive(:new).and_return(task)
-        expect(task).to receive(:start)
-
-        klass.async {}
+        expect(klass.async {}).to eql(task)
       end
 
       it 'should set the task value' do
-        task = double(:task)
-        allow(Thread).to receive(:new).and_yield(task)
         expect(task).to receive(:value=).with('something')
 
         klass.async { 'something' }
       end
+
+      it 'should eat any interrupted errors' do
+        block = proc { raise Eldritch::InterruptedError }
+
+        expect{klass.async &block}.not_to raise_error
+      end
     end
 
     context 'with 1 argument' do
@@ -109,8 +126,6 @@ describe Eldritch::DSL do
 
       describe 'async method' do
         it 'should call the original' do
-          allow(Thread).to receive(:new).and_yield(double(:task).as_null_object)
-
           instance = klass.new
           expect(instance).to receive(:__async_foo)
 
@@ -118,8 +133,6 @@ describe Eldritch::DSL do
         end
 
         it 'should pass all arguments' do
-          allow(Thread).to receive(:new).and_yield(double(:task).as_null_object)
-
           klass.class_eval do
             async def foo(_,_,_); end
           end
@@ -130,9 +143,7 @@ describe Eldritch::DSL do
         end
 
         it 'should set the task value' do
-          task = double(:task)
           expect(task).to receive(:value=).with(42)
-          allow(Thread).to receive(:new).and_yield(task)
 
           klass.class_eval do
             async def foo; 42; end
@@ -141,24 +152,6 @@ describe Eldritch::DSL do
 
           instance.foo
         end
-
-        it 'should return a task' do
-          allow(Eldritch::DSL).to receive(:new).and_return(double(:task).as_null_object)
-
-          instance = klass.new
-
-          expect(instance.foo).to be_a(Eldritch::Task)
-        end
-
-        it 'should start the task' do
-          task = double(:task)
-          expect(task).to receive(:start).once
-          allow(Eldritch::Task).to receive(:new).and_return(task)
-
-          instance = klass.new
-
-          instance.foo
-        end
       end
     end
   end

data/spec/group_spec.rb

@@ -0,0 +1,143 @@
+require 'spec_helper'
+require 'eldritch/group'
+
+describe Eldritch::Group do
+  let(:group) { Eldritch::Group.new }
+
+  describe '#<<' do
+    it 'should start the task' do
+      task = double('task')
+      expect(task).to receive(:start)
+
+      group << task
+    end
+
+    it 'should add the task to the list' do
+      task = double('task').as_null_object
+
+      group << task
+
+      expect(group.others).to include(task)
+    end
+
+    context 'after it is aborted or interrupted' do
+      before do
+        group.abort
+      end
+
+      it 'should not start the task' do
+        task = double('task')
+
+        expect(task).not_to receive(:start)
+
+        group << task
+      end
+
+      it 'should not add the task to the list' do
+        task = double('task')
+
+        group << task
+
+        expect(group.others).not_to include(task)
+      end
+    end
+  end
+
+  describe '#others' do
+    it 'should return an empty array when there is only one task' do
+      task = double('task').as_null_object
+      allow(Thread.current).to receive(:task).and_return(task)
+
+      group << task
+
+      expect(group.others).to be_kind_of(Array)
+      expect(group.others).to be_empty
+    end
+
+    it 'should return all the task except the current one' do
+      task = double('task').as_null_object
+      allow(Thread.current).to receive(:task).and_return(task)
+      other_task = double('other task').as_null_object
+
+      group << task
+      group << other_task
+
+      expect(group.others).to eql([other_task])
+    end
+  end
+
+  describe '#wait_all' do
+    it 'should call wait on all tasks' do
+      task = double('task')
+      allow(task).to receive(:start)
+      group << task
+
+      expect(task).to receive(:wait)
+
+      group.wait_all
+    end
+  end
+
+  describe '#synchronize' do
+    it 'should yield' do
+      expect{|b| group.synchronize &b}.to yield_control
+    end
+  end
+
+  describe '#abort' do
+    it 'should call abort on all tasks' do
+      task = double('task').as_null_object
+      expect(task).to receive(:abort)
+
+      group << task
+      group.abort
+    end
+
+    it 'should not call abort on current task' do
+      task = double('task').as_null_object
+      expect(task).not_to receive(:abort)
+      allow(Thread.current).to receive(:task).and_return(task)
+
+      group << task
+      group.abort
+    end
+  end
+
+  describe '#interrupt' do
+    it 'should call interrupt on all tasks' do
+      task = double('task').as_null_object
+      expect(task).to receive(:interrupt)
+
+      group << task
+      group.interrupt
+    end
+
+    it 'should not call interrupt on current task' do
+      task = double('task').as_null_object
+      expect(task).not_to receive(:interrupt)
+      allow(Thread.current).to receive(:task).and_return(task)
+
+      group << task
+      group.interrupt
+    end
+  end
+end
+
+describe Eldritch::NilGroup do
+  let(:group) { Eldritch::NilGroup.new }
+
+  describe '#<<' do
+    it 'should call the task' do
+      task = double('task')
+      expect(task).to receive(:start)
+
+      group << task
+    end
+  end
+
+  describe '#nil?' do
+    it 'should be true' do
+      expect(group.nil?).to be_true
+    end
+  end
+end

data/spec/task_spec.rb

@@ -3,6 +3,10 @@ require 'eldritch/task'
 
 describe Eldritch::Task do
   let(:task) { Eldritch::Task.new {} }
+  let(:thread) { double(:thread).as_null_object }
+  before do
+    allow(Thread).to receive(:new).and_yield.and_return(thread)
+  end
 
   it 'should not start a thread on init' do
     expect(task.thread).to be_nil
@@ -16,7 +20,6 @@ describe Eldritch::Task do
     end
 
     it 'should call the block' do
-      allow(Thread).to receive(:new).and_yield
       expect do |b|
         task = Eldritch::Task.new &b
         task.start
@@ -28,6 +31,12 @@ describe Eldritch::Task do
 
       task.start
     end
+
+    it 'should set the thread task' do
+      expect(thread).to receive(:task=).with(task)
+
+      task.start
+    end
   end
 
   describe '#wait' do
@@ -53,4 +62,23 @@ describe Eldritch::Task do
       expect(task.value).to eql(42)
     end
   end
+
+  describe '#abort' do
+    it 'should kill the thread' do
+      expect(thread).to receive(:kill)
+
+      task.start
+      task.abort
+    end
+  end
+
+  describe '#interrupt' do
+    it 'should raise an interrupted error on the thread' do
+      expect(thread).to receive(:raise).with(kind_of(Eldritch::InterruptedError))
+
+      task.start
+
+      task.interrupt
+    end
+  end
 end

data/spec/thread_spec.rb

@@ -1,24 +1,49 @@
 require 'spec_helper'
-require 'eldritch/ext_core/thread'
+require 'eldritch/refinements/thread'
+
+using Eldritch::Refinements
 
 describe Thread do
-  it 'should have together accessor' do
-    t = Thread.new {}
-    expect(t).to respond_to(:together)
-    expect(t).to respond_to(:together=)
+  let(:thread) { Thread.new {} }
+
+  it 'should have group accessor' do
+    # refinements don't work with #respond_to? and send, we have to check for errors
+    expect{thread.group}.not_to raise_error
+    expect{thread.group = nil}.not_to raise_error
+  end
+
+  it 'should have a task accessor' do
+    # refinements don't work with #respond_to? and send, we have to check for errors
+    expect{thread.task}.not_to raise_error
+    expect{thread.task = nil}.not_to raise_error
   end
 
-  describe '#together?' do
-    it 'should be false when together is nil' do
-      t = Thread.new {}
-      t.together = nil
-      expect(t.together?).to be_false
+  describe '#group' do
+    it 'should return the togther previously set' do
+      group = double('group')
+      thread.group = group
+      expect(thread.group).to eql(group)
+    end
+
+    it 'should return a NilGroup when none are set' do
+      expect(thread.group).to be_a Eldritch::NilGroup
+    end
+  end
+
+  describe '#in_group?' do
+    it 'should be false when group is nil' do
+      thread.group = nil
+      expect(thread.in_group?).to be_false
+    end
+
+    it 'should be false when group is a NilGroup' do
+      thread.group = Eldritch::NilGroup.new
+      expect(thread.in_group?).to be_false
     end
 
-    it 'should be true when together is set' do
-      t = Thread.new {}
-      t.together = 2
-      expect(t.together?).to be_true
+    it 'should be true when group is set' do
+      thread.group = 2
+      expect(thread.in_group?).to be_true
     end
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: eldritch
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 1.0.0
 platform: ruby
 authors:
 - Boris Bera
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-04-11 00:00:00.000000000 Z
+date: 2014-04-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -53,6 +53,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '2.14'
+- !ruby/object:Gem::Dependency
+  name: yard
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.8.7.4
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.8.7.4
 description: Adds support for async methods and async blocks. Adds a together block
   that allows async methods/blocks to be controlled as a group.
 email:
@@ -72,21 +86,24 @@ files:
 - eldritch.gemspec
 - examples/async_block.rb
 - examples/async_method_with_class.rb
+- examples/matrix_multiplication.rb
+- examples/password_cracker.rb
 - examples/simple_async_method.rb
 - examples/together_simple.rb
 - lib/eldritch.rb
 - lib/eldritch/dsl.rb
-- lib/eldritch/ext_core/thread.rb
+- lib/eldritch/group.rb
+- lib/eldritch/interrupted_error.rb
+- lib/eldritch/refinements/thread.rb
 - lib/eldritch/safe.rb
 - lib/eldritch/task.rb
-- lib/eldritch/together.rb
 - lib/eldritch/version.rb
 - spec/dsl_spec.rb
 - spec/eldritch_spec.rb
+- spec/group_spec.rb
 - spec/spec_helper.rb
 - spec/task_spec.rb
 - spec/thread_spec.rb
-- spec/together_spec.rb
 homepage: https://github.com/beraboris/eldritch
 licenses:
 - MIT
@@ -99,7 +116,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '0'
+      version: '2.1'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
@@ -110,11 +127,12 @@ rubyforge_project:
 rubygems_version: 2.2.2
 signing_key: 
 specification_version: 4
-summary: Adds tools to make parallelism easier.
+summary: DSL that adds concurrent programming concepts to make your life easier.
 test_files:
 - spec/dsl_spec.rb
 - spec/eldritch_spec.rb
+- spec/group_spec.rb
 - spec/spec_helper.rb
 - spec/task_spec.rb
 - spec/thread_spec.rb
-- spec/together_spec.rb
+has_rdoc: 

data/lib/eldritch/ext_core/thread.rb

@@ -1,7 +0,0 @@
-class Thread
-  attr_accessor :together
-
-  def together?
-    !together.nil?
-  end
-end

data/lib/eldritch/together.rb

@@ -1,15 +0,0 @@
-module Eldritch
-  class Together
-    def initialize
-      @tasks = []
-    end
-
-    def <<(task)
-      @tasks << task
-    end
-
-    def wait_all
-      @tasks.each {|t| t.wait}
-    end
-  end
-end

data/spec/together_spec.rb

@@ -1,16 +0,0 @@
-require 'spec_helper'
-require 'eldritch/together'
-
-describe Eldritch::Together do
-  describe '#wait_all' do
-    it 'should call wait on all tasks' do
-      together = Eldritch::Together.new
-      task = double('task')
-      together << task
-
-      expect(task).to receive(:wait)
-
-      together.wait_all
-    end
-  end
-end