csp 0.0.1

data/.gitignore

@@ -0,0 +1 @@
+csp.gemspec

data/Rakefile

@@ -0,0 +1,21 @@
+
+require 'rake/testtask'
+
+Rake::TestTask.new do |t|
+  t.test_files = Dir.glob("test/*_test.rb")
+end
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gemspec|
+    gemspec.name = "csp"
+    gemspec.summary = "Concurrent Sequential Processes"
+    gemspec.description = "Massive concurrency with message-passing and stuff."
+    gemspec.email = "daniel.schierbeck@gmail.com"
+    gemspec.homepage = "http://github.com/dasch/ruby-csp"
+    gemspec.authors = ["Daniel Schierbeck"]
+  end
+  Jeweler::GemcutterTasks.new
+rescue LoadError
+  puts "Jeweler not available. Install it with: gem install jeweler"
+end

data/VERSION

@@ -0,0 +1 @@
+0.0.1

data/lib/csp.rb

@@ -0,0 +1,38 @@
+
+require "csp/scheduler"
+require "csp/channel"
+require "csp/process"
+require "csp/choice"
+require "csp/skip"
+
+module CSP
+
+  class << self
+
+    def scheduler
+      @scheduler ||= CSP::Scheduler.new
+    end
+
+    def start(*processes)
+      processes.each do |process|
+        process.start
+      end
+
+      CSP.run
+    end
+
+    def yield
+      scheduler.yield
+    end
+
+    def run
+      scheduler.run
+    end
+
+    def enqueue(cont)
+      scheduler.enqueue(cont)
+    end
+
+  end
+
+end

data/lib/csp/channel.rb

@@ -0,0 +1,60 @@
+
+module CSP
+
+  class Channel
+
+    include Enumerable
+
+    def initialize
+      @readers = []
+      @writers = []
+    end
+
+    def read(options = {})
+      message = callcc do |cont|
+        @readers << cont
+
+        if @writers.empty?
+          if options[:callback]
+            return
+          else
+            CSP.run
+          end
+        else
+          @writers.shift.call
+        end
+      end
+
+      if options[:callback]
+        options[:callback].call(message)
+      else
+        return message
+      end
+    end
+
+    def write(message)
+      if @readers.empty?
+        callcc do |cont|
+          @writers << cont
+          CSP.run
+        end
+      end
+
+      callcc do |cont|
+        CSP.enqueue(cont)
+        @readers.shift.call(message)
+      end
+    end
+
+    def << message
+      write(message)
+      return self
+    end
+
+    def each
+      yield read while true
+    end
+
+  end
+
+end

data/lib/csp/choice.rb

@@ -0,0 +1,13 @@
+
+module CSP
+
+  def self.select(*options)
+    callcc do |cont|
+      options.each do |option|
+        option.read(:callback => cont)
+      end
+      CSP.run
+    end
+  end
+
+end

data/lib/csp/process.rb

@@ -0,0 +1,24 @@
+
+
+module CSP
+
+  class Process
+
+    def initialize(&block)
+      @block = block
+    end
+
+    def call
+      @block.call
+    end
+
+    def start
+      callcc do |cont|
+        CSP.enqueue(cont)
+        @block.call
+      end
+    end
+
+  end
+
+end

data/lib/csp/scheduler.rb

@@ -0,0 +1,32 @@
+
+module CSP
+
+  class Scheduler
+
+    def initialize
+      @ready = []
+    end
+
+    def enqueue(cont)
+      @ready << cont
+    end
+
+    def run
+      schedule until @ready.empty?
+    end
+
+    def yield
+      callcc do |cont|
+        enqueue(cont)
+        run
+      end
+    end
+
+    def schedule
+      raise RuntimeError.new("Cannot yield; ready queue is empty") if @ready.empty?
+      @ready.shift.call
+    end
+
+  end
+
+end

data/lib/csp/skip.rb

@@ -0,0 +1,16 @@
+
+module CSP
+
+  class SKIP
+
+    class << self
+
+      def read(options = {})
+        options[:callback] && options[:callback].call
+      end
+
+    end
+
+  end
+
+end

data/test/channel_test.rb

@@ -0,0 +1,51 @@
+
+require 'rubygems'
+require 'test/unit'
+require 'shoulda'
+require 'lib/csp'
+
+
+class ChannelTest < Test::Unit::TestCase
+
+  context "A CSP channel" do
+
+    setup do
+      @channel = CSP::Channel.new
+    end
+
+    should "send over channels" do
+      p1 = CSP::Process.new { @channel.write(42) }
+      p2 = CSP::Process.new { assert_equal 42, @channel.read }
+
+      CSP.start(p2, p1)
+      CSP.start(p1, p2)
+    end
+
+    should "send multiple values over channels" do
+      p1 = CSP::Process.new { [1, 2, 3].each {|i| @channel.write(i) } }
+      p2 = CSP::Process.new { [1, 2, 3].each {|i| assert_equal i, @channel.read } }
+
+      CSP.start(p2, p1)
+    end
+
+    should "iterate over received values" do
+      count = 0
+
+      p1 = CSP::Process.new { @channel.each {|msg| count += 1; assert_equal 42, msg } }
+      p2 = CSP::Process.new { 2.times { @channel.write(42) } }
+
+      CSP.start(p1, p2)
+
+      assert_equal 2, count
+    end
+
+    should "send multiple messages with the << operator" do
+      p1 = CSP::Process.new { @channel << 42 << 19 }
+      p2 = CSP::Process.new { [42, 19].each {|msg| assert_equal msg, @channel.read } }
+
+      CSP.start(p1, p2)
+    end
+
+  end
+
+end

data/test/choice_test.rb

@@ -0,0 +1,48 @@
+
+require 'rubygems'
+require 'test/unit'
+require 'shoulda'
+require 'lib/csp'
+
+
+class ProcessTest < Test::Unit::TestCase
+
+  context "A choice of guards" do
+
+    should "select between multiple channels" do
+      c1 = CSP::Channel.new
+      c2 = CSP::Channel.new
+
+      p1 = CSP::Process.new { c1.write(42) while true }
+
+      CSP.start(p1)
+
+      assert_equal 42, CSP.select(c1, c2)
+      assert_equal 42, CSP.select(c2, c1)
+    end
+
+    should "select between multiple channels with decreasing priority" do
+      c1 = CSP::Channel.new
+      c2 = CSP::Channel.new
+
+      p1 = CSP::Process.new { c1.write(42) while true }
+      p2 = CSP::Process.new { c2.write(19) while true }
+
+      CSP.start(p1, p2)
+
+      assert_equal 42, CSP.select(c1, c2)
+      assert_equal 19, CSP.select(c2, c1)
+    end
+
+    should "skip if no previous guards was ready" do
+      c1 = CSP::Channel.new
+      c2 = CSP::Channel.new
+
+      CSP.select(c1, c2, CSP::SKIP)
+
+      assert true
+    end
+
+  end
+
+end

data/test/process_test.rb

@@ -0,0 +1,19 @@
+
+require 'rubygems'
+require 'test/unit'
+require 'shoulda'
+require 'lib/csp'
+
+
+class ProcessTest < Test::Unit::TestCase
+
+  should "create a process" do
+    a = []
+    p = CSP::Process.new { a << 42 }
+
+    CSP.start(p)
+
+    assert_equal [42], a
+  end
+
+end

metadata

@@ -0,0 +1,68 @@
+--- !ruby/object:Gem::Specification 
+name: csp
+version: !ruby/object:Gem::Version 
+  version: 0.0.1
+platform: ruby
+authors: 
+- Daniel Schierbeck
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-01-31 00:00:00 +01:00
+default_executable: 
+dependencies: []
+
+description: Massive concurrency with message-passing and stuff.
+email: daniel.schierbeck@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- Rakefile
+- VERSION
+- lib/csp.rb
+- lib/csp/channel.rb
+- lib/csp/choice.rb
+- lib/csp/process.rb
+- lib/csp/scheduler.rb
+- lib/csp/skip.rb
+- test/channel_test.rb
+- test/choice_test.rb
+- test/process_test.rb
+has_rdoc: true
+homepage: http://github.com/dasch/ruby-csp
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: Concurrent Sequential Processes
+test_files: 
+- test/choice_test.rb
+- test/channel_test.rb
+- test/process_test.rb