seekingalpha_thread 1.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 34ba9568e012ba79315091c9d17d3ddca949a78a
+  data.tar.gz: 45a64a3d8f0979fac3713da7970aafc40af9e752
+SHA512:
+  metadata.gz: 90170a1870d4be263ac93a69526334951201c7cedc52dd8e91a37cdaeab0859429715d45f9bdddf6fb3f6bbc41f4cb39c192279870acfb5529db4f2bc3b18c52
+  data.tar.gz: 9d01b958cf27490c341ec917e67691ab2bb3813866981a96fc47b4ba04268570098c9d30077a3562e5f819c13c3f83cd772e19325fe7a9c975b3b5199093502b

data/.gitignore

@@ -0,0 +1,3 @@
+*.gem
+Gemfile.lock
+pkg

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--format documentation

data/.travis.yml

@@ -0,0 +1,11 @@
+language: ruby
+
+rvm:
+  - 1.9.2
+  - 1.9.3
+  - 2.0.0
+  - 2.1.0
+  - 2.2.1
+  - ruby-head
+  - jruby
+  - rbx

data/Gemfile

@@ -0,0 +1,3 @@
+source 'https://rubygems.org'
+
+gemspec

data/LICENSE.txt

@@ -0,0 +1,13 @@
+            DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE
+                    Version 2, December 2004
+
+ Copyright (C) 2004 Sam Hocevar <sam@hocevar.net>
+
+ Everyone is permitted to copy and distribute verbatim or modified
+ copies of this license document, and changing it is allowed as long
+ as the name is changed.
+
+            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.

data/README.md

@@ -0,0 +1,229 @@
+# thread
+
+[![Build Status](https://travis-ci.org/meh/ruby-thread.svg?branch=master)](https://travis-ci.org/meh/ruby-thread)
+
+Various extensions to the thread library in ruby.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'thread'
+
+Or install it yourself as:
+
+    $ gem install thread
+
+## Usage
+
+### 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.
+
+```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.
+
+```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.
+
+```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.
+
+```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.
+
+```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.
+
+By default, `Thread.future` executes the block in a newly-created thread.
+
+`Thread.future` accepts an optional argument of type `Thread.pool` if you want
+the block executed in an existing thread-pool.
+
+You can also use the `Thread::Pool` helper `#future`
+
+```ruby
+require 'thread/future'
+
+f = Thread.future {
+  sleep 5
+
+  42
+}
+
+puts ~f # => 42
+```
+
+```ruby
+require 'thread/pool'
+require 'thread/future'
+
+pool = Thread.pool 4
+f    = Thread.future pool do
+  sleep 5
+  42
+end
+
+puts ~f # => 42
+```
+
+```ruby
+require 'thread/pool'
+require 'thread/future'
+
+pool = Thread.pool 4
+f    = pool.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.
+
+```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.
+
+```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
+```
+
+## Contributing
+
+1. Fork it ( https://github.com/meh/ruby-thread/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Verify new and old specs are green (`rake`)
+4. Commit your changes (`git commit -am 'Add some feature'`)
+5. Push to the branch (`git push origin my-new-feature`)
+6. Create a new Pull Request

data/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/lib/thread/channel.rb

@@ -0,0 +1,109 @@
+#--
+#            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
+		found   = false
+
+		if block
+			until found
+				@mutex.synchronize {
+					if index = @messages.find_index(&block)
+						message = @messages.delete_at(index)
+						found   = true
+					else
+						cond.wait @mutex
+					end
+				}
+			end
+		else
+			until found
+				@mutex.synchronize {
+					if @messages.empty?
+						cond.wait @mutex
+					end
+
+					unless @messages.empty?
+						message = @messages.shift
+						found   = true
+					end
+				}
+			end
+		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