linda 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 146404ba1cf1f376a8754616b292b0ff61e31bad
+  data.tar.gz: d1a42ff0cd3844a5c284651535f92b6ae1db37df
+SHA512:
+  metadata.gz: 155875330105acc2169853d1a52a8c2f7847997a0e0249d246e4df97f9950a26371ebfe90d8db05272146e46e2d703b65e6cbf9b1c48c6bd60ac32f07dad37e1
+  data.tar.gz: 3f7fa331981194463618bb2c9df007e6ea57727efc59da57d46d8cd39232408bc3bbb98df2e7fd82b3e45b42c55d04b97286f102d9bc85bb660b0068d7d00ffd

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+.ruby-version
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in linda.gemspec
+gemspec

data/History.txt

@@ -0,0 +1,3 @@
+=== 0.0.1 2013-05-18
+
+* implements tuple and tuplespace / tests

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Sho Hashimoto
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,115 @@
+Linda
+=====
+Tuple and TupleSpace implementation of Linda
+
+- https://github.com/shokai/linda-ruby
+- https://rubygems.org/gems/linda
+
+
+Installation
+------------
+
+    % gem install linda
+
+
+Linda
+-----
+Linda is a coordination launguage for parallel programming.
+
+- http://en.wikipedia.org/wiki/Linda_(coordination_language)
+- http://ja.wikipedia.org/wiki/Linda
+
+
+Usage
+-----
+Linda rubygem provides
+
+- on-memory Tuple/TupleSpace implementation
+- common tests for your Linda implementation, such as using KVS or RDB
+
+[Sinatra::RocketIO::Linda](http://rubygems.org/gems/sinatra-rocketio-linda) is using Linda rubygem inside.
+
+
+Tuple Matching
+--------------
+Array Tuple `[1, 2, 3]`
+
+- matches `[1, 2, 3]`
+- matches `[1, 2, 3, 4]`
+- matches `[1, 2, 3, "a"]`
+- NOT matches `[1, 2, "a"]`
+- NOT matches `[2, 1, 3]`
+
+```ruby
+Linda::Tuple.new([1, 2]).match? [1, 2, 3]  # => true
+Linda::Tuple.new([1, 2]).match? [1, "a"]   # => false
+```
+
+Hash Tuple {:a => 1, :b => 2}
+
+- matches `{:a => 1, :b => 2}`
+- matches `{:a => 1, :b => 2, :c => 3}`
+- matches `{:a => 1, :b => 2, :name => "shokai"}`
+- NOT matches `{:a => 1, :b => 5}`
+
+```ruby
+Linda::Tuple.new(:a => 1, :b => 2).match?(:a => 1, :b => 2, :name => "shokai")  # => true
+Linda::Tuple.new(:a => 1, :b => 2).match?(:a => 1, :b => 5)  # => false
+```
+
+Tuple/TupleSpace Functions
+--------------------------
+
+### TupleSpace#write( tuple, options={} )
+
+- write a Tuple into TupleSpace.
+- default : options = {:expire => 300}
+  - expire 300(sec) after.
+- similar to `out` function in C-Linda.
+
+### TupleSpace#read( tuple )
+
+- return a Tuple which matches in TupleSpace. return `nil` if not exists.
+- similar to `rdp` function in C-Linda.
+
+
+### TupleSpace#read( tuple, &callback(tuple) )
+
+- callback a Tuple which matches in TupleSpace. wait until available.
+- async function : it does not return a value.
+- similar to `rd` function in C-Linda.
+
+
+### TupleSpace#take( tuple )
+
+- delete a Tuple, then return it which matches in TupleSpace. return `nil` if not exists.
+- similar to `inp` function in C-Linda.
+
+
+### TupleSpace#take( tuple, &callback(tuple) )
+
+- delete a Tuple, then callback it which matches in TupleSpace. wait until available.
+- async function : it does not return a value.
+- similar to `in` function in C-Linda.
+
+
+### TupleSpace#watch( tuple, &callback(tuple) )
+
+- callback Tuples which matches when TupleSpace#write(tuple) is called.
+
+
+Test
+----
+
+    % gem install bundler
+    % bundle install
+    % rake test
+
+
+Contributing
+------------
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1,8 @@
+require "bundler/gem_tasks"
+require "rake/testtask"
+
+Rake::TestTask.new do |t|
+  t.pattern = "test/test_*.rb"
+end
+
+task :default => :test

data/lib/linda/tuple.rb

@@ -0,0 +1,39 @@
+module Linda
+
+  class Tuple
+    attr_reader :data, :type, :expire_at
+    def initialize(data, opts={})
+      unless data.kind_of? Array or data.kind_of? Hash
+        raise ArgumentError, 'argument must be instance of Array or Hash'
+      end
+      @data = data
+      @type = data.class
+      if opts[:expire].class == Fixnum and opts[:expire] > 0
+        @expire_at = Time.now + opts[:expire]
+      end
+    end
+
+    def match?(target)
+      target = self.class.new target unless target.kind_of? self.class
+      return false if @type != target.type
+      if @type == Array
+        return false if @data.length > target.data.length
+        @data.each_with_index do |v,i|
+          return false if target.data[i] != v
+        end
+        return true
+      elsif @type == Hash
+        @data.each do |k,v|
+          return false if target.data[k] != v
+        end
+        return true
+      end
+      false
+    end
+
+    def to_s
+      @data.to_s
+    end
+  end
+
+end

data/lib/linda/tuplespace.rb

@@ -0,0 +1,119 @@
+module Linda
+
+  class TupleSpace
+    include Enumerable
+    attr_reader :name
+
+    def initialize(name="__default__")
+      @name = name
+      @tuples = Array.new
+      @callbacks = Array.new
+    end
+
+    def each(&block)
+      @tuples.each do |tp|
+        yield tp
+      end
+    end
+
+    def remove_callback(callback)
+      @callbacks.delete callback
+    end
+
+    def size
+      @tuples.size
+    end
+
+    DEFAULT_WRITE_OPTIONS = {
+      :expire => 300
+    }
+
+    def write(tuple, opts={})
+      raise ArgumentError, "options must be Hash" unless opts.kind_of? Hash
+      DEFAULT_WRITE_OPTIONS.each do |k,v|
+        opts[k] = v unless opts.include? k
+      end
+      tuple = Tuple.new tuple, opts unless tuple.kind_of? Tuple
+      calleds = []
+      taked = nil
+      @callbacks.each do |callback|
+        next unless callback[:tuple].match? tuple
+        callback[:callback].call tuple
+        calleds.push callback unless callback[:type] == :watch
+        if callback[:type] == :take
+          taked = tuple
+          break
+        end
+      end
+      calleds.each do |called|
+        @callbacks.delete called
+      end
+      @tuples.unshift tuple unless taked
+      tuple
+    end
+
+    def read(tuple, &block)
+      tuple = Tuple.new tuple unless tuple.kind_of? Tuple
+      @tuples.each do |t|
+        if tuple.match? t
+          if block_given?
+            block.call t
+            return
+          else
+            return t
+          end
+        end
+      end
+      if block_given?
+        callback = {:type => :read, :callback => block, :tuple => tuple}
+        @callbacks.push callback
+        return callback
+      end
+    end
+
+    def take(tuple, &block)
+      tuple = Tuple.new tuple unless tuple.kind_of? Tuple
+      matched_tuple = nil
+      @tuples.each do |t|
+        if tuple.match? t
+          matched_tuple = t
+          break
+        end
+      end
+      if matched_tuple
+        @tuples.delete matched_tuple
+        if block_given?
+          block.call matched_tuple
+        else
+          return matched_tuple
+        end
+      else
+        if block_given?
+          callback = {:type => :take, :callback => block, :tuple => tuple}
+          @callbacks.push callback
+          return callback
+        end
+      end
+    end
+
+    def watch(tuple, &block)
+      raise ArgumentError, "block not given" unless block_given?
+      tuple = Tuple.new tuple unless tuple.kind_of? Tuple
+      callback = {:type => :watch, :callback => block, :tuple => tuple}
+      @callbacks.unshift callback
+      callback
+    end
+
+    def check_expire
+      expires = []
+      self.each do |tuple|
+        expires.push(tuple) if tuple.expire_at and tuple.expire_at < Time.now
+      end
+      expires.each do |tuple|
+        @tuples.delete tuple
+      end
+    end
+  end
+
+end
+

data/lib/linda/version.rb

@@ -0,0 +1,3 @@
+module Linda
+  VERSION = "0.0.1"
+end

data/lib/linda.rb

@@ -0,0 +1,6 @@
+require "linda/version"
+require "linda/tuple"
+require "linda/tuplespace"
+
+module Linda
+end

data/linda.gemspec

@@ -0,0 +1,24 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'linda/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "linda"
+  spec.version       = Linda::VERSION
+  spec.authors       = ["Sho Hashimoto"]
+  spec.email         = ["hashimoto@shokai.org"]
+  spec.description   = %q{Tuple and TupleSpace implementation of Linda - coordinational language for parallel processing}
+  spec.summary       = spec.description
+  spec.homepage      = "https://github.com/shokai/linda-ruby"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/).reject{|i| i == "Gemfile.lock" }
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "minitest"
+end

data/test/test_helper.rb

@@ -0,0 +1,5 @@
+require 'rubygems'
+require 'bundler/setup'
+require 'minitest/autorun'
+$:.unshift File.expand_path '../lib', File.dirname(__FILE__)
+require 'linda'

data/test/test_tuple.rb

@@ -0,0 +1,53 @@
+require File.expand_path 'test_helper', File.dirname(__FILE__)
+
+class TestTuple < MiniTest::Test
+  def test_match_array_tuple
+    tuple = Linda::Tuple.new [1,2,3]
+    assert tuple.match? Linda::Tuple.new [1,2,3]
+    assert tuple.match? Linda::Tuple.new [1,2,3,4]
+    assert !tuple.match?(Linda::Tuple.new [1,2])
+    assert !tuple.match?(Linda::Tuple.new [1,"a",3])
+    assert !tuple.match?(Linda::Tuple.new :a => 1, :b => 2)
+    tuple = Linda::Tuple.new ["a","b","c"]
+    assert tuple.match? Linda::Tuple.new ["a","b","c"]
+    assert tuple.match? Linda::Tuple.new ["a","b","c","d","efg",123,"h"]
+    assert !tuple.match?(Linda::Tuple.new ["a","b"])
+    assert !tuple.match?(Linda::Tuple.new ["a","b",789])
+    assert !tuple.match?(Linda::Tuple.new :foo => 1, :bar => 2)
+  end
+
+  def test_match_array
+    tuple = Linda::Tuple.new [1,2,3]
+    assert tuple.match? [1,2,3]
+    assert tuple.match? [1,2,3,4]
+    assert !tuple.match?([1,2])
+    assert !tuple.match?([1,"a",3])
+    assert !tuple.match?(:a => 1, :b => 2)
+    tuple = Linda::Tuple.new ["a","b","c"]
+    assert tuple.match? ["a","b","c"]
+    assert tuple.match? ["a","b","c","d","efg",123,"h"]
+    assert !tuple.match?(["a","b"])
+    assert !tuple.match?(["a","b",789])
+    assert !tuple.match?(:foo => 1, :bar => 2)
+  end
+
+  def test_match_hash_tuple
+    tuple = Linda::Tuple.new :a => 1, :b => 2
+    assert tuple.match? Linda::Tuple.new :a => 1, :b => 2
+    assert tuple.match? Linda::Tuple.new :a => 1, :b => 2, :c => 3
+    assert tuple.match? Linda::Tuple.new :a => 1, :b => 2, :c => {:foo => "bar"}
+    assert !tuple.match?(Linda::Tuple.new :a => 0, :b => 2)
+    assert !tuple.match?(Linda::Tuple.new :b => 2, :c => 3)
+    assert !tuple.match?(Linda::Tuple.new [1,2,3])
+  end
+
+  def test_match_hash
+    tuple = Linda::Tuple.new :a => 1, :b => 2
+    assert tuple.match? :a => 1, :b => 2
+    assert tuple.match? :a => 1, :b => 2, :c => 3
+    assert tuple.match? :a => 1, :b => 2, :c => {:foo => "bar"}
+    assert !tuple.match?(:a => 0, :b => 2)
+    assert !tuple.match?(:b => 2, :c => 3)
+    assert !tuple.match?([1,2,3])
+  end
+end

data/test/test_tuplespace.rb

@@ -0,0 +1,132 @@
+require File.expand_path 'test_helper', File.dirname(__FILE__)
+
+class TestTupleSpace < MiniTest::Test
+
+  def setup
+    @space = Linda::TupleSpace.new
+  end
+
+  def test_write_read
+    assert_equal @space.size, 0
+    @space.write Linda::Tuple.new [1,2,3]
+    assert_equal @space.size, 1
+    assert_equal @space.read([1,2]).data, [1,2,3]
+    @space.write :a => 1, :b => 2, :c => 999
+    @space.write :a => 1, :b => 2, :c => 3
+    assert_equal @space.size, 3
+    assert_equal @space.read(:a => 1, :c => 999).data, {:a => 1, :b => 2, :c => 999}
+    assert_equal @space.read(:a => 1, :c => 999).data, {:a => 1, :b => 2, :c => 999}
+    assert_equal @space.read(:a => 1).data, {:a => 1, :b => 2, :c => 3}
+  end
+
+  def test_write_read_callback
+    assert_equal @space.size, 0
+    _tuple1 = nil
+    @space.read [1,2] do |tuple|
+      _tuple1 = tuple
+    end
+    _tuple2 = nil
+    @space.read [1,"a"] do |tuple|
+      _tuple2 = tuple
+    end
+    _tuple3 = nil
+    @space.read [1,2,3] do |tuple|
+      _tuple3 = tuple
+    end
+    @space.write [1,2,3]
+    assert_equal _tuple1.data, [1,2,3]
+    assert_equal _tuple2, nil
+    assert_equal _tuple3.data, [1,2,3]
+    assert_equal @space.read([1]).data, [1,2,3]
+    assert_equal @space.size, 1
+    @space.write [1,2,4]
+    assert_equal _tuple1.data, [1,2,3]
+    assert_equal @space.size, 2
+  end
+
+  def test_take
+    assert_equal @space.size, 0
+    1.upto(3) do |i|
+      @space.write [1,2,3,"a"*i]
+    end
+    assert_equal @space.size, 3
+    assert_equal @space.take([1,2,3]).data, [1,2,3,"aaa"]
+    assert_equal @space.size, 2
+    @space.write :a => 1, :b => 2, :c => 3
+    assert_equal @space.size, 3
+    assert_equal @space.take([1,3]), nil
+    assert_equal @space.take(:a => 1, :b => 2, :c => 4), nil
+    assert_equal @space.take([1,2,3]).data, [1,2,3,"aa"]
+    assert_equal @space.size, 2
+    assert_equal @space.take([1,2,3]).data, [1,2,3,"a"]
+    assert_equal @space.size, 1
+    assert_equal @space.take(:b => 2, :a => 1).data, {:a => 1, :b => 2, :c => 3}
+    assert_equal @space.size, 0
+  end
+
+  def test_take_callback
+    assert_equal @space.size, 0
+    _tuple1 = nil
+    @space.take [1,2] do |tuple|
+      _tuple1 = tuple
+    end
+    _tuple2 = nil
+    @space.take [1,"a"] do |tuple|
+      _tuple2 = tuple
+    end
+    _tuple3 = nil
+    @space.read [1,2,3] do |tuple|
+      _tuple3 = tuple
+    end
+    _tuple4 = nil
+    @space.take [1,2,3] do |tuple|
+      _tuple4 = tuple
+    end
+    1.upto(3) do |i|
+      @space.write [1,2,3,"a"*i]
+    end
+    assert_equal @space.size, 1
+    assert_equal _tuple1.data, [1,2,3,"a"]
+    assert_equal _tuple2, nil
+    assert_equal _tuple3.data, [1,2,3,"aa"]
+    assert_equal _tuple4.data, [1,2,3,"aa"]
+    assert_equal @space.take([1]).data, [1,2,3,"aaa"]
+    assert_equal @space.size, 0
+  end
+
+  def test_watch
+    assert_equal @space.size, 0
+    _tuple1 = nil
+    @space.take [1] do |tuple|
+      _tuple1 = tuple
+    end
+    results = []
+    @space.watch [1,2] do |tuple|
+      results << tuple
+    end
+    @space.write [1,2,3]
+    @space.write [1,2,"aa"]
+    @space.write [1,"a",3]
+    assert_equal _tuple1.data, [1,2,3]
+    assert_equal @space.size, 2
+    assert_equal results.size, 2
+    assert_equal results[0].data, [1,2,3]
+    assert_equal results[1].data, [1,2,"aa"]
+  end
+
+  def test_tuple_expire
+    @space.write [1,2,999], :expire => false
+    @space.write [1,2,3], :expire => 3
+    @space.write [1,2,"a","b"], :expire => 2
+    assert_equal @space.size, 3
+    sleep 2
+    @space.check_expire
+    assert_equal @space.size, 2
+    assert_equal @space.take([1,2]).data, [1,2,3]
+    assert_equal @space.size, 1
+    sleep 1
+    assert_equal @space.take([1,2]).data, [1,2,999]
+    assert_equal @space.size, 0
+  end
+
+end

metadata

@@ -0,0 +1,105 @@
+--- !ruby/object:Gem::Specification
+name: linda
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Sho Hashimoto
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-05-18 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Tuple and TupleSpace implementation of Linda - coordinational language
+  for parallel processing
+email:
+- hashimoto@shokai.org
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- History.txt
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/linda.rb
+- lib/linda/tuple.rb
+- lib/linda/tuplespace.rb
+- lib/linda/version.rb
+- linda.gemspec
+- test/test_helper.rb
+- test/test_tuple.rb
+- test/test_tuplespace.rb
+homepage: https://github.com/shokai/linda-ruby
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.0.3
+signing_key: 
+specification_version: 4
+summary: Tuple and TupleSpace implementation of Linda - coordinational language for
+  parallel processing
+test_files:
+- test/test_helper.rb
+- test/test_tuple.rb
+- test/test_tuplespace.rb