future_proof 0.0.1

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/Gemfile

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

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Nikita Cernovs
+
+MIT License
+
+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,47 @@
+# FutureProof
+
+FutureProof provides concurrency extensions for Ruby.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'future_proof'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install future_proof
+
+## Usage
+
+### Future
+
+    f = FutureProof::Future.new { |a, b| a + b }
+
+    f.call # => executing in a thread
+
+    f.value # => returning value when ready
+
+### ThreadPool
+
+    tp = FutureProof::ThreadPool.new(5)
+
+    10.times do |i|
+      tp.submit(Proc.new { |a, b| a + b }, i, i + 1)
+    end
+
+    tp.perform # executing 10 procs in 5 threads
+
+    tp.values # releasing threads and returning values
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/future_proof.gemspec

@@ -0,0 +1,24 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'future_proof/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "future_proof"
+  spec.version       = FutureProof::VERSION
+  spec.authors       = ["Nikita Cernovs"]
+  spec.email         = ["nikita.cernovs@gmail.com"]
+  spec.description   = %q{Ruby concurrency extenstions}
+  spec.summary       = %q{Ruby concurrency extenstions}
+  spec.homepage      = ""
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rspec"
+  spec.add_development_dependency "rake"
+end

data/lib/future_proof/future.rb

@@ -0,0 +1,23 @@
+class FutureProof::Future
+  def initialize(&block)
+    @block = block
+  end
+
+  def call(*args)
+    thread(*args)
+  end
+
+  def value(*args)
+    thread(*args).value
+  end
+
+  def complete?
+    !thread.alive?
+  end
+
+private
+
+  def thread(*args)
+    @thread ||= Thread.new { @block.call *args }
+  end
+end

data/lib/future_proof/thread_pool.rb

@@ -0,0 +1,58 @@
+require 'thread'
+
+class FutureProof::ThreadPool
+  def initialize(size)
+    @size    = size
+    @threads = []
+    @queue   = Queue.new
+    @values  = Queue.new
+  end
+
+  def submit(job, *args)
+    @queue.push [job, args]
+  end
+
+  def perform
+    unless @threads.any? { |t| t.alive? }
+      @size.times do
+        @threads << Thread.new do
+          while job = @queue.pop
+            if job == :END_OF_WORK
+              break
+            else
+              result = begin
+                job[0].call(*job[1])
+              rescue => e
+                e.to_s
+              end
+              @values.push result
+            end
+          end
+        end
+      end
+    end
+  end
+
+  def finalize
+    @size.times { @queue.push :END_OF_WORK }
+  end
+
+  def wait
+    finalize
+    @threads.map &:join
+  end
+
+  def values
+    wait
+    @values.instance_variable_get(:@que)
+  end
+
+  def finalize
+    @size.times { @queue.push :END_OF_WORK }
+  end
+
+  def finalize!
+    @queue.clear
+    finalize
+  end
+end

data/lib/future_proof/version.rb

@@ -0,0 +1,3 @@
+module FutureProof
+  VERSION = "0.0.1"
+end

data/lib/future_proof.rb

@@ -0,0 +1,3 @@
+require "future_proof/version"
+require 'future_proof/future'
+require 'future_proof/thread_pool'

data/spec/future_proof/future_spec.rb

@@ -0,0 +1,69 @@
+require 'spec_helper'
+
+describe FutureProof::Future do
+
+  let(:future) do
+    FutureProof::Future.new do |a, b|
+      sleep 1
+      a / b
+    end
+  end
+
+  describe '#call' do
+    it 'should run a thread' do
+      future.call(24, 2).should be_an_instance_of Thread
+    end
+  end
+
+  describe '#value' do
+    context 'before #call' do
+      it 'should calculate value' do
+        future.value(24, 2).should eq 12
+      end
+    end
+
+    context 'after #call' do
+      before { @thread = future.call(24, 2) }
+
+      it 'should not require arguments' do
+        future.value.should eq 12
+      end
+
+      it 'should use the same thread' do
+        @thread.should_receive(:value)
+        future.value
+      end
+    end
+  end
+
+  describe '#comlete?' do
+    before { future.call(24, 2) }
+
+    context 'not finished' do
+      it 'should not be completed' do
+        future.should_not be_complete
+      end
+    end
+
+    context 'finished' do
+      it 'should be completed' do
+        sleep 2
+        future.should be_complete
+      end
+    end
+  end
+
+  describe 'exceptions' do
+    describe '#call' do
+      it 'should not raise exeptions' do
+        expect { future.call(24, 0); sleep 2 }.not_to raise_error
+      end
+    end
+
+    describe '#value' do
+      it 'should raise exeption' do
+        expect { future.value(24, 0) }.to raise_error ZeroDivisionError
+      end
+    end
+  end
+end

data/spec/future_proof/thread_pool_spec.rb

@@ -0,0 +1,76 @@
+require 'spec_helper'
+
+describe FutureProof::ThreadPool do
+
+  let(:pool_size)   { 3                                    }
+  let(:task)        { Proc.new { |a,b| sleep 1; a / b }    }
+  let(:thread_pool) { FutureProof::ThreadPool.new pool_size }
+
+  describe '#submit' do
+    before { thread_pool.submit(task, 24, 2) }
+
+    it 'task should be submitted to queue' do
+      thread_pool.instance_variable_get(:@queue).size.should eq 1
+    end
+
+    context 'before perform' do
+      it 'shold not have been started to execute' do
+        thread_pool.finalize!
+        thread_pool.perform
+        thread_pool.values.should be_empty
+      end
+    end
+
+    context 'after perform' do
+      before { thread_pool.perform }
+
+      describe 'first task' do
+        it 'should start executing' do
+          thread_pool.finalize
+          thread_pool.values.should eq [12]
+        end
+      end
+
+      describe 'rest tasks' do
+        it 'should start executing on #submit' do
+          thread_pool.submit task, 6, 3
+          sleep 3
+          thread_pool.instance_variable_get(:@values).instance_variable_get(:@que).size.should eq 2
+        end
+      end
+    end
+  end
+
+  describe '#finalize' do
+    it 'should allow all tasks to finish' do
+      5.times { thread_pool.submit(task, 24, 2) }
+      thread_pool.finalize
+      thread_pool.perform
+      thread_pool.values.should eq [12, 12, 12, 12, 12]
+    end
+  end
+
+
+  describe '#finalize!' do
+    it 'should not start executing not started tasks' do
+      5.times { thread_pool.submit(task, 24, 2) }
+      thread_pool.perform
+      sleep 0.5
+      thread_pool.finalize!
+      thread_pool.values.should eq [12, 12, 12]
+    end
+  end
+
+  describe 'exceptions' do
+    before { thread_pool.submit(task, 24, 0) }
+
+    it 'should not raise exceptions' do
+      expect { thread_pool.perform; thread_pool.wait }.not_to raise_error
+    end
+
+    it 'should return name of an exception' do
+      thread_pool.perform
+      thread_pool.values.should eq ['divided by 0']
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1 @@
+require 'future_proof'

metadata

@@ -0,0 +1,110 @@
+--- !ruby/object:Gem::Specification
+name: future_proof
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Nikita Cernovs
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-05-01 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Ruby concurrency extenstions
+email:
+- nikita.cernovs@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- future_proof.gemspec
+- lib/future_proof.rb
+- lib/future_proof/future.rb
+- lib/future_proof/thread_pool.rb
+- lib/future_proof/version.rb
+- spec/future_proof/future_spec.rb
+- spec/future_proof/thread_pool_spec.rb
+- spec/spec_helper.rb
+homepage: ''
+licenses:
+- MIT
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.25
+signing_key: 
+specification_version: 3
+summary: Ruby concurrency extenstions
+test_files:
+- spec/future_proof/future_spec.rb
+- spec/future_proof/thread_pool_spec.rb
+- spec/spec_helper.rb