vinted-thread 0.1.1

data/lib/thread/process.rb

@@ -0,0 +1,72 @@
+#--
+#            DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE
+#                    Version 2, December 2004
+#
+#            DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE
+#   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
+#
+#  0. You just DO WHAT THE FUCK YOU WANT TO.
+#++
+
+require 'thread/channel'
+
+# A process should only interact with the outside the outside through messages,
+# it still uses a thread, but it should make it safer to use than sharing and
+# locks.
+class Thread::Process
+	def self.all
+		@@processes ||= {}
+	end
+
+	def self.register (name, process)
+		all[name] = process
+	end
+
+	def self.unregister (name)
+		all.delete(name)
+	end
+
+	def self.[] (name)
+		all[name]
+	end
+
+	# Create a new process executing the block.
+	def initialize (&block)
+		@channel = Thread::Channel.new
+
+		Thread.new {
+			instance_eval(&block)
+
+			@channel = nil
+		}
+	end
+
+	# Send a message to the process.
+	def send (what)
+		unless @channel
+			raise RuntimeError, 'the process has terminated'
+		end
+
+		@channel.send(what)
+
+		self
+	end
+
+	alias << send
+
+private
+	def receive
+		@channel.receive
+	end
+
+	def receive!
+		@channel.receive!
+	end
+end
+
+class Thread
+	# Helper to create a process.
+	def self.process (&block)
+		Thread::Process.new(&block)
+	end
+end

data/lib/thread/promise.rb

@@ -0,0 +1,83 @@
+#--
+#            DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE
+#                    Version 2, December 2004
+#
+#            DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE
+#   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
+#
+#  0. You just DO WHAT THE FUCK YOU WANT TO.
+#++
+
+require 'thread'
+
+# A promise is an object that lets you wait for a value to be delivered to it.
+class Thread::Promise
+	# Create a promise.
+	def initialize
+		@mutex = Mutex.new
+	end
+
+	# Check if a value has been delivered.
+	def delivered?
+		@mutex.synchronize {
+			instance_variable_defined? :@value
+		}
+	end
+
+	alias realized? delivered?
+
+	# Deliver a value.
+	def deliver (value)
+		return self if delivered?
+
+		@mutex.synchronize {
+			@value = value
+
+			cond.broadcast if cond?
+		}
+
+		self
+	end
+
+	alias << deliver
+
+	# Get the value that's been delivered, if none has been delivered yet the call
+	# will block until one is delivered.
+	#
+	# An optional timeout can be passed which will return nil if nothing has been
+	# delivered.
+	def value (timeout = nil)
+		return @value if delivered?
+
+		@mutex.synchronize {
+			cond.wait(@mutex, *timeout)
+		}
+
+		return @value if delivered?
+	end
+
+	alias ~ value
+
+private
+	def cond?
+		instance_variable_defined? :@cond
+	end
+
+	def cond
+		@cond ||= ConditionVariable.new
+	end
+end
+
+class Thread
+	# Helper method to create a promise.
+	def self.promise
+		Thread::Promise.new
+	end
+end
+
+module Kernel
+	# Helper method to create a promise.
+	def promise
+		Thread::Promise.new
+	end
+end

data/lib/thread/recursive_mutex.rb

@@ -0,0 +1,38 @@
+#--
+#           DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE
+#                   Version 2, December 2004
+#
+#           DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE
+#  TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
+#
+#  0. You just DO WHAT THE FUCK YOU WANT TO.
+#++
+
+require 'thread'
+
+# A recursive mutex lets you lock in various threads recursively, allowing
+# you to do multiple locks one inside another.
+#
+# You really shouldn't use this, but in some cases it makes your life easier.
+class RecursiveMutex < Mutex
+	def initialize
+		@threads_lock = Mutex.new
+		@threads = Hash.new { |h, k| h[k] = 0 }
+
+		super
+	end
+
+	# Lock the mutex.
+	def lock
+		super if @threads_lock.synchronize{ (@threads[Thread.current] += 1) == 1 }
+	end
+
+	# Unlock the mutex.
+	def unlock
+		if @threads_lock.synchronize{ (@threads[Thread.current] -= 1) == 0 }
+			@threads.delete(Thread.current)
+
+			super
+		end
+	end
+end

data/tests/channel_spec.rb

@@ -0,0 +1,41 @@
+#! /usr/bin/env ruby
+require 'rubygems'
+require 'thread/channel'
+
+describe Thread::Channel do
+	it 'receives in the proper order' do
+		ch = Thread.channel
+		ch.send 'lol'
+		ch.send 'wut'
+
+		ch.receive.should == 'lol'
+		ch.receive.should == 'wut'
+	end
+
+	it 'receives with constraints properly' do
+		ch = Thread.channel
+		ch.send 'lol'
+		ch.send 'wut'
+
+		ch.receive { |v| v == 'wut' }.should == 'wut'
+		ch.receive.should == 'lol'
+	end
+
+	it 'receives nil when using non blocking mode and the channel is empty' do
+		ch = Thread.channel
+
+		ch.receive!.should == nil
+	end
+
+	it 'guards sending properly' do
+		ch = Thread.channel { |v| v.is_a? Integer }
+
+		expect {
+			ch.send 23
+		}.to_not raise_error
+
+		expect {
+			ch.send 'lol'
+		}.to raise_error
+	end
+end

data/tests/delay_spec.rb

@@ -0,0 +1,13 @@
+#! /usr/bin/env ruby
+require 'rubygems'
+require 'thread/delay'
+
+describe Thread::Delay do
+	it 'delivers a value properly' do
+		d = Thread.delay {
+			42
+		}
+
+		d.value.should == 42
+	end
+end

data/tests/every_spec.rb

@@ -0,0 +1,11 @@
+#! /usr/bin/env ruby
+require 'rubygems'
+require 'thread/every'
+
+describe Thread::Every do
+	it 'delivers a value properly' do
+		e = Thread.every(5) { sleep 0.5; 42 }
+
+		e.value.should == 42
+	end
+end

data/tests/future_spec.rb

@@ -0,0 +1,37 @@
+#! /usr/bin/env ruby
+require 'rubygems'
+require 'thread/future'
+
+describe Thread::Future do
+	it 'delivers a value properly' do
+		f = Thread.future {
+			sleep 0.2
+			
+			42
+		}
+
+		f.value.should == 42
+	end
+
+	it 'properly checks if anything has been delivered' do
+		f = Thread.future {
+			sleep 0.2
+
+			42
+		}
+
+		f.delivered?.should == false
+		sleep 0.3
+		f.delivered?.should == true
+	end
+
+	it 'does not block when a timeout is passed' do
+		f = Thread.future {
+			sleep 0.2
+
+			42
+		}
+
+		f.value(0).should == nil
+	end
+end

data/tests/pipe_spec.rb

@@ -0,0 +1,25 @@
+#! /usr/bin/env ruby
+require 'rubygems'
+require 'thread/pipe'
+
+describe Thread::Pipe do
+	it 'handles passing properly' do
+		p = Thread |-> d { d * 2 } |-> d { d * 4 }
+
+		p << 2
+		p << 4
+
+		p.deq.should == 16
+		p.deq.should == 32
+	end
+
+	it 'empty works properly' do
+		p = Thread |-> d { sleep 0.2; d * 2 } |-> d { d * 4 }
+
+		p.empty?.should == true
+		p.enq 42
+		p.empty?.should == false
+		p.deq
+		p.empty?.should == true
+	end
+end

data/tests/promise_spec.rb

@@ -0,0 +1,37 @@
+#! /usr/bin/env ruby
+require 'rubygems'
+require 'thread/promise'
+
+describe Thread::Promise do
+	it 'delivers a value properly' do
+		p = Thread.promise
+
+		Thread.new {
+			sleep 0.2
+
+			p << 42
+		}
+
+		p.value.should == 42
+	end
+
+	it 'properly checks if anything has been delivered' do
+		p = Thread.promise
+
+		Thread.new {
+			sleep 0.2
+
+			p << 42
+		}
+
+		p.delivered?.should == false
+		sleep 0.3
+		p.delivered?.should == true
+	end
+
+	it 'does not block when a timeout is passed' do
+		p = Thread.promise
+
+		p.value(0).should == nil
+	end
+end

data/thread.gemspec

@@ -0,0 +1,18 @@
+Gem::Specification.new {|s|
+	s.name         = 'vinted-thread'
+	s.version      = '0.1.1'
+	s.author       = 'Justas Janauskas'
+	s.email        = 'jjanauskas@gmail.com'
+	s.homepage     = 'http://github.com/meh/ruby-thread'
+	s.platform     = Gem::Platform::RUBY
+	s.summary      = 'Various extensions to the base thread library.'
+	s.description  = 'Includes a thread pool, message passing capabilities, a recursive mutex, promise, future and delay.'
+
+	s.files         = `git ls-files`.split("\n")
+	s.executables   = `git ls-files -- bin/*`.split("\n").map { |f| File.basename(f) }
+	s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+	s.require_paths = ['lib']
+
+	s.add_development_dependency 'rspec'
+	s.add_development_dependency 'rake'
+}

metadata

@@ -0,0 +1,90 @@
+--- !ruby/object:Gem::Specification
+name: vinted-thread
+version: !ruby/object:Gem::Version
+  version: 0.1.1
+platform: ruby
+authors:
+- Justas Janauskas
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-11-10 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  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'
+- !ruby/object:Gem::Dependency
+  name: rake
+  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: Includes a thread pool, message passing capabilities, a recursive mutex,
+  promise, future and delay.
+email: jjanauskas@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .travis.yml
+- README.md
+- Rakefile
+- lib/thread/channel.rb
+- lib/thread/delay.rb
+- lib/thread/every.rb
+- lib/thread/future.rb
+- lib/thread/pipe.rb
+- lib/thread/pool.rb
+- lib/thread/process.rb
+- lib/thread/promise.rb
+- lib/thread/recursive_mutex.rb
+- tests/channel_spec.rb
+- tests/delay_spec.rb
+- tests/every_spec.rb
+- tests/future_spec.rb
+- tests/pipe_spec.rb
+- tests/promise_spec.rb
+- thread.gemspec
+homepage: http://github.com/meh/ruby-thread
+licenses: []
+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.0.3
+signing_key: 
+specification_version: 4
+summary: Various extensions to the base thread library.
+test_files: []