vinted-thread 0.1.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 5135a4b3c6ef3c2396b06b34c7040d39b52fbe3f
+  data.tar.gz: 445e9bec68c67f6597c037844b90b5c41cc29f8c
+SHA512:
+  metadata.gz: 3822c43a01c8f8d29652b46917be0827a4c83f061e7b159222d202c16fe86d293468991e7342cd092f8ba0065fddbc7d62796d9c31ac6b0a49c83adfc3a58942
+  data.tar.gz: f257a9d93c9e63b8e8708b5cfffb37be3a7abd929342d9f16cfbbde5b6ed2b493cfe63212f8f8dd37e14c8710a6e7a3321b024717090007c7bdad9dd700b99dd

data/.travis.yml

@@ -0,0 +1,7 @@
+language: ruby
+rvm:
+  - "1.9.2"
+  - "1.9.3"
+  - "2.0.0"
+  - jruby-19mode # JRuby in 1.9 mode
+  - rbx-19mode

data/README.md

@@ -0,0 +1,195 @@
+thread - various extensions to the thread library
+=================================================
+
+Pool
+====
+All the implementations I looked at were either buggy or wasted CPU resources
+for no apparent reason, for example used a sleep of 0.01 seconds to then check for
+readiness and stuff like this.
+
+This implementation uses standard locking functions to work properly across multiple Ruby
+implementations.
+
+Example
+-------
+
+```ruby
+require 'thread/pool'
+
+pool = Thread.pool(4)
+
+10.times {
+  pool.process {
+    sleep 2
+
+    puts 'lol'
+  }
+}
+
+pool.shutdown
+```
+
+You should get 4 lols every 2 seconds and it should exit after 10 of them.
+
+Channel
+=======
+This implements a channel where you can write messages and receive messages.
+
+Example
+-------
+
+```ruby
+require 'thread/channel'
+
+channel = Thread.channel
+channel.send 'wat'
+channel.receive # => 'wat'
+
+channel = Thread.channel { |o| o.is_a?(Integer) }
+channel.send 'wat' # => ArgumentError: guard mismatch
+
+Thread.new {
+  while num = channel.receive(&:even?)
+    puts 'Aye!'
+  end
+}
+
+Thread.new {
+  while num = channel.receive(&:odd?)
+    puts 'Arrr!'
+  end
+}
+
+loop {
+  channel.send rand(1_000_000_000)
+
+  sleep 0.5
+}
+```
+
+Pipe
+====
+A pipe allows you to execute various tasks on a set of data in parallel,
+each datum inserted in the pipe is passed along through queues to the various
+functions composing the pipe, the final result is inserted in the final queue.
+
+Example
+-------
+
+```ruby
+require 'thread/pipe'
+
+p = Thread |-> d { d * 2 } |-> d { d * 4 }
+p << 2
+
+puts ~p # => 16
+```
+
+Process
+=======
+A process helps reducing programming errors coming from race conditions and the
+like, the only way to interact with a process is through messages.
+
+Multiple processes should talk with eachother through messages.
+
+Example
+-------
+
+```ruby
+require 'thread/process'
+
+p = Thread.process {
+  loop {
+    puts receive.inspect
+  }
+}
+
+p << 42
+p << 23
+```
+
+Promise
+=======
+This implements the promise pattern, allowing you to pass around an object
+where you can send a value and extract a value, in a thread-safe way, accessing
+the value will wait for the value to be delivered.
+
+Example
+-------
+
+```ruby
+require 'thread/promise'
+
+p = Thread.promise
+
+Thread.new {
+  sleep 5
+  p << 42
+}
+
+puts ~p # => 42
+```
+
+Future
+======
+A future is somewhat a promise, except you pass it a block to execute in
+another thread.
+
+The value returned by the block will be the value of the promise.
+
+Example
+-------
+
+```ruby
+require 'thread/future'
+
+f = Thread.future {
+  sleep 5
+
+  42
+}
+
+puts ~f # => 42
+```
+
+Delay
+=====
+A delay is kind of a promise, except the block is called when the value is
+being accessed and the result is cached.
+
+Example
+-------
+
+```ruby
+require 'thread/delay'
+
+d = Thread.delay {
+  42
+}
+
+puts ~d # => 42
+```
+
+Every
+=====
+An every executes the block every given seconds and yields the value to the
+every object, you can then check if the current value is old or how much time
+is left until the second call is done.
+
+Example
+-------
+
+```ruby
+require 'net/http'
+require 'thread/every'
+
+e = Thread.every(5) {
+	Net::HTTP.get(URI.parse('http://www.whattimeisit.com/')).match %r{<B>(.*?)<BR>\s+(.*?)</B>}m do |m|
+		{ date: m[1], time: m[2] }
+	end
+}
+
+loop do
+	puts ~e
+end
+```

data/Rakefile

@@ -0,0 +1,21 @@
+#! /usr/bin/env ruby
+require 'rake'
+
+task :default => [:install, :test]
+
+task :install do
+	sh 'gem install --no-force rspec'
+	sh 'gem build *.gemspec'
+	sh 'gem install *.gem'
+end
+
+task :test do
+	FileUtils.cd 'tests' do
+		sh 'rspec channel_spec.rb --backtrace --color --format doc'
+		sh 'rspec promise_spec.rb --backtrace --color --format doc'
+		sh 'rspec future_spec.rb --backtrace --color --format doc'
+		sh 'rspec delay_spec.rb --backtrace --color --format doc'
+		sh 'rspec pipe_spec.rb --backtrace --color --format doc'
+		sh 'rspec every_spec.rb --backtrace --color --format doc'
+	end
+end

data/lib/thread/channel.rb

@@ -0,0 +1,105 @@
+#--
+#            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 channel lets you send and receive various messages in a thread-safe way.
+#
+# It also allows for guards upon sending and retrieval, to ensure the passed
+# messages are safe to be consumed.
+class Thread::Channel
+	# Create a channel with optional initial messages and optional channel guard.
+	def initialize (messages = [], &block)
+		@messages = []
+		@mutex    = Mutex.new
+		@check    = block
+
+		messages.each {|o|
+			send o
+		}
+	end
+
+	# Send a message to the channel.
+	#
+	# If there's a guard, the value is passed to it, if the guard returns a falsy value
+	# an ArgumentError exception is raised and the message is not sent.
+	def send (what)
+		if @check && !@check.call(what)
+			raise ArgumentError, 'guard mismatch'
+		end
+
+		@mutex.synchronize {
+			@messages << what
+
+			cond.broadcast if cond?
+		}
+
+		self
+	end
+
+	# Receive a message, if there are none the call blocks until there's one.
+	#
+	# If a block is passed, it's used as guard to match to a message.
+	def receive (&block)
+		message = nil
+
+		if block
+			found = false
+
+			until found
+				@mutex.synchronize {
+					if index = @messages.find_index(&block)
+						message = @messages.delete_at(index)
+						found   = true
+					else
+						cond.wait @mutex
+					end
+				}
+			end
+		else
+			@mutex.synchronize {
+				if @messages.empty?
+					cond.wait @mutex
+				end
+
+				message = @messages.shift
+			}
+		end
+
+		message
+	end
+
+	# Receive a message, if there are none the call returns nil.
+	#
+	# If a block is passed, it's used as guard to match to a message.
+	def receive! (&block)
+		if block
+			@messages.delete_at(@messages.find_index(&block))
+		else
+			@messages.shift
+		end
+	end
+
+private
+	def cond?
+		instance_variable_defined? :@cond
+	end
+
+	def cond
+		@cond ||= ConditionVariable.new
+	end
+end
+
+class Thread
+	# Helper to create a channel.
+	def self.channel (*args, &block)
+		Thread::Channel.new(*args, &block)
+	end
+end

data/lib/thread/delay.rb

@@ -0,0 +1,94 @@
+#--
+#            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 delay is an object that incapsulates a block which is called upon
+# value retrieval, and its result cached.
+class Thread::Delay
+	# Create a delay with the passed block.
+	def initialize (&block)
+		raise ArgumentError, 'no block given' unless block
+
+		@mutex = Mutex.new
+		@block = block
+	end
+
+	# Check if an exception has been raised.
+	def exception?
+		@mutex.synchronize {
+			instance_variable_defined? :@exception
+		}
+	end
+
+	# Return the raised exception.
+	def exception
+		@mutex.synchronize {
+			@exception
+		}
+	end
+
+	# Check if the delay has been called.
+	def delivered?
+		@mutex.synchronize {
+			instance_variable_defined? :@value
+		}
+	end
+
+	alias realized? delivered?
+
+	# Get the value of the delay, if it's already been executed, return the
+	# cached result, otherwise execute the block and return the value.
+	#
+	# In case the block raises an exception, it will be raised, the exception is
+	# cached and will be raised every time you access the value.
+	def value
+		@mutex.synchronize {
+			raise @exception if instance_variable_defined? :@exception
+
+			return @value if instance_variable_defined? :@value
+
+			begin
+				@value = @block.call
+			rescue Exception => e
+				@exception = e
+
+				raise
+			end
+		}
+	end
+
+	alias ~ value
+
+	# Do the same as {#value}, but return nil in case of exception.
+	def value!
+		begin
+			value
+		rescue Exception
+			nil
+		end
+	end
+
+	alias ! value!
+end
+
+class Thread
+	# Helper to create Thread::Delay
+	def self.delay (&block)
+		Thread::Delay.new(&block)
+	end
+end
+
+module Kernel
+	# Helper to create a Thread::Delay
+	def delay (&block)
+		Thread::Delay.new(&block)
+	end
+end

data/lib/thread/every.rb

@@ -0,0 +1,197 @@
+#--
+#            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'
+
+# An every runs the given block every given seconds, you can then get the
+# value, check if the value is old and you can check how many seconds
+# until the next run.
+class Thread::Every
+	Cancel  = Class.new(Exception)
+	Restart = Class.new(Exception)
+
+	# Create an every with the given seconds and block.
+	def initialize (every, &block)
+		raise ArgumentError, 'no block given' unless block
+
+		@every  = every
+		@old    = true
+		@mutex  = Mutex.new
+		@thread = Thread.new {
+			loop do
+				begin
+					value = block.call
+
+					@mutex.synchronize {
+						@at        = Time.now
+  					@value     = value
+						@old       = false
+						@exception = nil
+					}
+				rescue Restart
+					next
+				rescue Exception => e
+					@mutex.synchronize {
+						@at        = Time.now
+						@exception = e
+					}
+
+					break if e.is_a? Cancel
+				end
+
+				cond.broadcast if cond?
+
+				begin
+					sleep @every
+				rescue Restart
+					next
+				rescue Cancel => e
+					@mutex.synchronize {
+						@at        = Time.now
+						@exception = e
+					}
+
+					break
+				end
+			end
+		}
+
+		ObjectSpace.define_finalizer self, self.class.finalizer(@thread)
+	end
+
+	# @private
+	def self.finalizer (thread)
+		proc {
+			thread.raise Cancel.new
+		}
+	end
+
+	# Change the number of seconds between each call.
+	def every (seconds)
+		@every = seconds
+
+		restart
+	end
+
+	# Cancel the every, {#value} will yield a Cancel exception.
+	def cancel
+		@mutex.synchronize {
+			@thread.raise Cancel.new('every cancelled')
+		}
+
+		self
+	end
+
+	# Check if the every has been cancelled.
+	def cancelled?
+		@mutex.synchronize {
+			@exception.is_a? Cancel
+		}
+	end
+
+	# Checks when the every was cancelled.
+	def cancelled_at
+		if cancelled?
+			@mutex.synchronize {
+				@at
+			}
+		end
+	end
+
+	# Restart the every.
+	def restart
+		@mutex.synchronize {
+			@thread.raise Restart.new
+		}
+
+		self
+	end
+
+	# Check if the every is running.
+	def running?
+		!cancelled?
+	end
+
+	# Check if the every is old, after the first #value call it becomes old,
+	# until another run of the block is gone)
+	def old?
+		@mutex.synchronize {
+			@old
+		}
+	end
+
+	# Gets the Time when the block was called.
+	def called_at
+		@mutex.synchronize {
+			@at
+		}
+	end
+
+	# Gets how many seconds are missing before another call.
+	def next_in
+		return if cancelled?
+
+		@mutex.synchronize {
+			@every - (Time.now - @at)
+		}
+	end
+
+	# Gets the current every value.
+	def value (timeout = nil)
+		@mutex.synchronize {
+			if @old
+				cond.wait(@mutex, *timeout)
+			end
+
+			@old = true
+
+			if @exception
+				raise @exception
+			else
+				@value
+			end
+		}
+	end
+
+	alias ~ value
+
+	# Gets the current every value, without blocking and waiting for the next
+	# call.
+	def value!
+		@mutex.synchronize {
+			@old = true
+
+			@value unless @exception
+		}
+	end
+
+private
+	def cond?
+		instance_variable_defined? :@cond
+	end
+
+	def cond
+		@cond ||= ConditionVariable.new
+	end
+end
+
+class Thread
+	# Helper to create an every
+	def self.every (every, &block)
+		Thread::Every.new(every, &block)
+	end
+end
+
+module Kernel
+	# Helper to create an every
+	def every (every, &block)
+		Thread::Every.new(every, &block)
+	end
+end