thread 0.0.7 → 0.0.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: ccee102c708a6f45b30e88830ed170d244be7036
-  data.tar.gz: e2ff57960a623ab11f82aefe7372900f589602ac
+  metadata.gz: b8caeb122b45ef1fbfce75eae1c2f313ff356060
+  data.tar.gz: 5e851cb4ac1a270cf461fe4e4658168aac1bdb0b
 SHA512:
-  metadata.gz: ed75e1af05833e2860b345a988f75cb985edd06564f78289a69a5bac1243609db45788c6682b55b1c2c313fd32d847ffda72e4b835fca506356b113c4fa06ef8
-  data.tar.gz: e0308daa7693621bdf0dd753ec329989c448a61e29e09645db50432db3367e07ce4ae2a0e2c1d5c72fcd2c608271df541fe56f32f8feadbe99a149bcc56b7413
+  metadata.gz: e54a7cab6bfbb3144a2aa506804d5f9a4ea7b38c42f2e9ff2a55ace0dc0fce6a8554fa0de251041fa8fad8e481f70daf037076a9f9ef15d09fcd3394dd124739
+  data.tar.gz: 64b5e21bff244a09cd7fa5696d87533a7cfe0bd5622de3143c6b53a4d9c396abd43c0e0a5fdea8172dc64419419a4bf8b7fde93a11f7e7f7ee2be9aec6ddbcfe

data/README.md

@@ -169,3 +169,27 @@ d = Thread.delay {
 
 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

@@ -16,5 +16,6 @@ task :test do
 		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/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

@@ -33,6 +33,15 @@ class Thread::Future
 		}
 
 		@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.
@@ -60,11 +69,13 @@ class Thread::Future
 
 	# Cancel the future, {#value} will yield a Cancel exception
 	def cancel
-		return if delivered?
+		return self if delivered?
 
 		@mutex.synchronize {
 			@thread.raise Cancel.new('future cancelled')
 		}
+
+		self
 	end
 
 	# Check if the future has been cancelled

data/lib/thread/pipe.rb

@@ -60,11 +60,11 @@ class Thread::Pipe
 		@input  = input
 		@output = output
 
-		ObjectSpace.define_finalizer(self, self.class.finalize(@tasks))
+		ObjectSpace.define_finalizer self, self.class.finalizer(@tasks)
 	end
 
 	# @private
-	def self.finalize (tasks)
+	def self.finalizer (tasks)
 		proc {
 			tasks.each(&:kill)
 		}

data/lib/thread/promise.rb

@@ -28,7 +28,7 @@ class Thread::Promise
 
 	# Deliver a value.
 	def deliver (value)
-		return if delivered?
+		return self if delivered?
 
 		@mutex.synchronize {
 			@value = value

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/thread.gemspec

@@ -1,6 +1,6 @@
 Gem::Specification.new {|s|
 	s.name         = 'thread'
-	s.version      = '0.0.7'
+	s.version      = '0.0.8'
 	s.author       = 'meh.'
 	s.email        = 'meh@schizofreni.co'
 	s.homepage     = 'http://github.com/meh/ruby-thread'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: thread
 version: !ruby/object:Gem::Version
-  version: 0.0.7
+  version: 0.0.8
 platform: ruby
 authors:
 - meh.
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-04-24 00:00:00.000000000 Z
+date: 2013-05-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
@@ -50,6 +50,7 @@ files:
 - 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
@@ -58,6 +59,7 @@ files:
 - 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