seekingalpha_thread 1.0.1

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

data/lib/thread/future.rb

@@ -0,0 +1,164 @@
+#--
+#            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 future is an object that incapsulates a block which is called in a
+# different thread, upon retrieval the caller gets blocked until the block has
+# finished running, and its result is returned and cached.
+class Thread::Future
+	Cancel = Class.new(Exception)
+
+	# Create a future with the passed block and optionally using the passed pool.
+	def initialize(pool = nil, &block)
+		raise ArgumentError, 'no block given' unless block
+
+		@mutex = Mutex.new
+
+		task = proc {
+			begin
+				deliver block.call
+			rescue Exception => e
+				@exception = e
+
+				deliver nil
+			end
+		}
+
+		@thread = pool ? pool.process(&task) : Thread.new(&task)
+
+		ObjectSpace.define_finalizer self, self.class.finalizer(@thread)
+	end
+
+	# @private
+	def self.finalizer(thread)
+		proc {
+			thread.raise Cancel.new
+		}
+	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 future has been called.
+	def delivered?
+		@mutex.synchronize {
+			instance_variable_defined? :@value
+		}
+	end
+
+	alias realized? delivered?
+
+	# Cancel the future, {#value} will yield a Cancel exception
+	def cancel
+		return self if delivered?
+
+		@mutex.synchronize {
+			@thread.raise Cancel.new('future cancelled')
+		}
+
+		self
+	end
+
+	# Check if the future has been cancelled
+	def cancelled?
+		@mutex.synchronize {
+			@exception.is_a? Cancel
+		}
+	end
+
+	# Get the value of the future, if it's not finished running this call will block.
+	#
+	# 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.
+	#
+	# An optional timeout can be passed which will return nil if nothing has been
+	# delivered.
+	def value(timeout = nil)
+		raise @exception if exception?
+
+		return @value if delivered?
+
+		@mutex.synchronize {
+			cond.wait(@mutex, *timeout)
+		}
+
+		if exception?
+			raise @exception
+		elsif delivered?
+			return @value
+		end
+	end
+
+	alias ~ value
+
+	# Do the same as {#value}, but return nil in case of exception.
+	def value!(timeout = nil)
+		begin
+			value(timeout)
+		rescue Exception
+			nil
+		end
+	end
+
+	alias ! value!
+
+private
+	def cond?
+		instance_variable_defined? :@cond
+	end
+
+	def cond
+		@cond ||= ConditionVariable.new
+	end
+
+	def deliver (value)
+		return if delivered?
+
+		@mutex.synchronize {
+			@value = value
+
+			cond.broadcast if cond?
+		}
+
+		self
+	end
+end
+
+class Thread
+	# Helper to create a future
+	def self.future(pool = nil, &block)
+		Thread::Future.new(pool, &block)
+	end
+end
+
+module Kernel
+	# Helper to create a future.
+	def future(pool = nil, &block)
+		Thread::Future.new(pool, &block)
+	end
+end
+
+class Thread::Pool
+	def future(&block)
+		Thread.future self, &block
+	end
+end

data/lib/thread/pipe.rb

@@ -0,0 +1,119 @@
+#--
+#            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 pipe lets you 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.
+class Thread::Pipe
+	# A task encapsulates a part of the pipe.
+	class Task
+		attr_accessor :input, :output
+
+		# Create a Task which will call the passed function and get input
+		# from the optional parameter and put output in the optional parameter.
+		def initialize(func, input = Queue.new, output = Queue.new)
+			@input    = input
+			@output   = output
+			@handling = false
+
+			@thread = Thread.new {
+				while true
+					value = @input.deq
+
+					@handling = true
+					begin
+						value = func.call(value)
+						@output.enq value
+					rescue Exception; end
+					@handling = false
+				end
+			}
+		end
+
+		# Check if the task has nothing to do.
+		def empty?
+			!@handling && @input.empty? && @output.empty?
+		end
+
+		# Stop the task.
+		def kill
+			@thread.raise
+		end
+	end
+
+	# Create a pipe using the optionally passed objects as input and
+	# output queue.
+	#
+	# The objects must respond to #enq and #deq, and block on #deq.
+	def initialize(input = Queue.new, output = Queue.new)
+		@tasks = []
+
+		@input  = input
+		@output = output
+
+		ObjectSpace.define_finalizer self, self.class.finalizer(@tasks)
+	end
+
+	# @private
+	def self.finalizer(tasks)
+		proc {
+			tasks.each(&:kill)
+		}
+	end
+
+	# Add a task to the pipe, it must respond to #call and #arity,
+	# and #arity must return 1.
+	def |(func)
+		if func.arity != 1
+			raise ArgumentError, 'wrong arity'
+		end
+
+		Task.new(func, (@tasks.empty? ? @input : Queue.new), @output).tap {|t|
+			@tasks.last.output = t.input unless @tasks.empty?
+			@tasks << t
+		}
+
+		self
+	end
+
+	# Check if the pipe is empty.
+	def empty?
+		@input.empty? && @output.empty? && @tasks.all?(&:empty?)
+	end
+
+	# Insert data in the pipe.
+	def enq(data)
+		return if @tasks.empty?
+
+		@input.enq data
+
+		self
+	end
+
+	alias push enq
+	alias <<   enq
+
+	# Get an element from the output queue.
+	def deq(non_block = false)
+		@output.deq(non_block)
+	end
+
+	alias pop deq
+	alias ~   deq
+end
+
+class Thread
+	# Helper to create a pipe.
+	def self.|(func)
+		Pipe.new | func
+	end
+end