sinatra-rocketio-linda 0.0.3 → 0.0.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 22a5549a8d89eeae678b0f22d44dae2afad0473f
-  data.tar.gz: aa42150b15eb7393de375740260e094c60e8ce00
+  metadata.gz: 0bd0f0169cf2d5ffbd3ddb33d57c714f2c4cc60c
+  data.tar.gz: 009f53e47103bc7f183cc73c8e957467e097ca61
 SHA512:
-  metadata.gz: 5ce242560eb393dd968e79199708a6a7c5f1cce9a8593015d1f89b88286ee26ecb9f3d7f4aea5efc9856386ca5cdf39c255b2fe3f0a00793ca6940a369259111
-  data.tar.gz: 8f71b0aefc032cd9b2020a365b6633a95e7307817417ba4df96d2304a70a4b120d75544e43293f0e5a6fedd1418e5c646e16c655d6b1fa286088933665f6cab5
+  metadata.gz: 8d6d37b957f7a54c21ce502c157c507cbb22f47954b290463784996c72bae67bc72ed3662d94bb7c923c8bba0faad0d3e7a6e1993acb343115f877d5519f6807
+  data.tar.gz: 2081757894b6210a146fbd42b0b997664076b4cd2d04ce26e76fb1cbcdda6405cf88e04e560cbb05ed1b61d7930701cf3a2b9daeeb516c809b4a6bdbf83e48b4

data/History.txt

@@ -1,3 +1,7 @@
+=== 0.0.4 2013-05-19
+
+* move Tuple/TupleSpace code to linda gem (https://rubygems.org/gems/linda)
+
 === 0.0.3 2013-05-16
 
 * remove read/take/watch listener on client disconnect

data/README.md

@@ -26,6 +26,7 @@ Linda is a coordination launguage for parallel programming.
 
 * http://en.wikipedia.org/wiki/Linda_(coordination_language)
 * http://ja.wikipedia.org/wiki/Linda
+* https://github.com/shokai/linda-ruby#usage
 
 
 ### TupleSpace
@@ -42,6 +43,8 @@ Shared memory on Sinatra.
 - watch( tuple, callback(tuple) )
   - overwatch written Tuples in the TupleSpace
 
+see details on https://github.com/shokai/linda-ruby#usage
+
 
 Usage
 -----
@@ -163,7 +166,6 @@ run 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'`)

data/lib/sinatra-rocketio-linda/tuple.rb

@@ -1,43 +1,11 @@
+require "linda"
+
 module Sinatra
   module RocketIO
     module Linda
-
-      class Tuple
-        attr_reader :data, :type, :expire_at
-        def initialize(data, opts={})
-          unless [Array, Hash].include? data.class
-            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)
-          raise ArgumentError, 'argument must be instance of Tuple' 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
+      # use linda gem (https://rubygems.org/gems/linda)
+      class Tuple < ::Linda::Tuple
       end
-
     end
   end
 end

data/lib/sinatra-rocketio-linda/tuplespace.rb

@@ -1,122 +1,11 @@
+require "linda"
+
 module Sinatra
   module RocketIO
     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
+      # use on-memory TupleSpace from linda gem (https://rubygems.org/gems/linda)
+      class TupleSpace < ::Linda::TupleSpace
       end
-
     end
   end
 end

data/lib/sinatra/rocketio/linda.rb

@@ -1,3 +1,5 @@
+require "rubygems"
+require "linda"
 require "sinatra/rocketio/linda/version"
 require "sinatra-rocketio-linda/helper"
 require "sinatra-rocketio-linda/options"

data/lib/sinatra/rocketio/linda/version.rb

@@ -1,7 +1,7 @@
 module Sinatra
   module RocketIO
     module Linda
-      VERSION = "0.0.3"
+      VERSION = "0.0.4"
     end
   end
 end

data/sinatra-rocketio-linda.gemspec

@@ -24,6 +24,7 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency "thin"
   spec.add_development_dependency "haml"
 
+  spec.add_dependency "linda"
   spec.add_dependency "sinatra-rocketio"
   spec.add_dependency "event_emitter"
   spec.add_dependency "sinatra"

data/test/test_tuple.rb

@@ -1,29 +1,11 @@
 require File.expand_path 'test_helper', File.dirname(__FILE__)
 require 'sinatra-rocketio-linda/tuple'
+require 'linda/test/tuple'
 
 class TestTuple < MiniTest::Test
-  def test_match_array
-    tuple = Sinatra::RocketIO::Linda::Tuple.new [1,2,3]
-    assert tuple.match? Sinatra::RocketIO::Linda::Tuple.new [1,2,3]
-    assert tuple.match? Sinatra::RocketIO::Linda::Tuple.new [1,2,3,4]
-    assert !tuple.match?(Sinatra::RocketIO::Linda::Tuple.new [1,2])
-    assert !tuple.match?(Sinatra::RocketIO::Linda::Tuple.new [1,"a",3])
-    assert !tuple.match?(Sinatra::RocketIO::Linda::Tuple.new :a => 1, :b => 2)
-    tuple = Sinatra::RocketIO::Linda::Tuple.new ["a","b","c"]
-    assert tuple.match? Sinatra::RocketIO::Linda::Tuple.new ["a","b","c"]
-    assert tuple.match? Sinatra::RocketIO::Linda::Tuple.new ["a","b","c","d","efg",123,"h"]
-    assert !tuple.match?(Sinatra::RocketIO::Linda::Tuple.new ["a","b"])
-    assert !tuple.match?(Sinatra::RocketIO::Linda::Tuple.new ["a","b",789])
-    assert !tuple.match?(Sinatra::RocketIO::Linda::Tuple.new :foo => 1, :bar => 2)
-  end
+  include Linda::Test::Tuple
 
-  def test_match_hash
-    tuple = Sinatra::RocketIO::Linda::Tuple.new :a => 1, :b => 2
-    assert tuple.match? Sinatra::RocketIO::Linda::Tuple.new :a => 1, :b => 2
-    assert tuple.match? Sinatra::RocketIO::Linda::Tuple.new :a => 1, :b => 2, :c => 3
-    assert tuple.match? Sinatra::RocketIO::Linda::Tuple.new :a => 1, :b => 2, :c => {:foo => "bar"}
-    assert !tuple.match?(Sinatra::RocketIO::Linda::Tuple.new :a => 0, :b => 2)
-    assert !tuple.match?(Sinatra::RocketIO::Linda::Tuple.new :b => 2, :c => 3)
-    assert !tuple.match?(Sinatra::RocketIO::Linda::Tuple.new [1,2,3])
+  def target_tuple
+    Sinatra::RocketIO::Linda::Tuple
   end
 end

data/test/test_tuplespace.rb

@@ -1,134 +1,16 @@
 require File.expand_path 'test_helper', File.dirname(__FILE__)
 require 'sinatra-rocketio-linda/tuple'
 require 'sinatra-rocketio-linda/tuplespace'
+require 'linda/test/tuplespace'
 
 class TestTupleSpace < MiniTest::Test
+  include Linda::Test::TupleSpace
 
-  def setup
-    @space = Sinatra::RocketIO::Linda::TupleSpace.new
+  def target_tuple
+    Sinatra::RocketIO::Linda::Tuple
   end
 
-  def test_write_read
-    assert_equal @space.size, 0
-    @space.write Sinatra::RocketIO::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}
+  def target_tuplespace
+    Sinatra::RocketIO::Linda::TupleSpace
   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

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: sinatra-rocketio-linda
 version: !ruby/object:Gem::Version
-  version: 0.0.3
+  version: 0.0.4
 platform: ruby
 authors:
 - Sho Hashimoto
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-05-16 00:00:00.000000000 Z
+date: 2013-05-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -80,6 +80,20 @@ dependencies:
     - - '>='
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: linda
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: sinatra-rocketio
   requirement: !ruby/object:Gem::Requirement