sinatra-rocketio-linda 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 523bf63e3fe852d759d5e75b62e82d8b5900ffa9
+  data.tar.gz: ca656ff542d98f73c942542ddeaf5654566f5b60
+SHA512:
+  metadata.gz: 6328614db8c10c14410d515d7aad2a0885335165e4aaeae081852fae8dd13cf45687cf4ae30e6caf571a8b2d5cca7b08434d8387b962bf30f350c3a83290792f
+  data.tar.gz: 0f41f574bbcace16a210b0f4e3a93f29d0aca235ae1dd3e9b85b52f1dd0ffe548a123e125f6cdd87c9d1d3590af7e723c7fe6a2de837c995847f50e1ef3b50c6

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 sinatra-rocketio-linda.gemspec
+gemspec

data/History.txt

@@ -0,0 +1,8 @@
+=== 0.0.1 2013-05-15
+
+* JavaScript Linda Client for WebBrowser
+* Ruby Linda Client
+* TupleSpace#write(tuple)
+* TupleSpace#take(tuple, callback(tuple))
+* TupleSpace#read(tuple, callback(tuple))
+* sinatra config - set :linda, :expire_check => 60 (sec)

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,117 @@
+sinatra-rocketio-linda
+======================
+
+* Linda implementation on Sinatra::RocketIO
+* https://github.com/shokai/sinatra-rocketio-linda
+
+
+Linda
+-----
+
+* http://en.wikipedia.org/wiki/Linda_(coordination_language)
+* http://ja.wikipedia.org/wiki/Linda
+
+
+Installation
+------------
+
+    % gem install sinatra-rocketio-linda
+
+
+Requirements
+------------
+* Ruby 1.8.7 or 1.9.2 or 1.9.3 or 2.0.0
+* Sinatra 1.3.0+
+* [Sinatra RocketIO](https://github.com/shokai/sinatra-rocketio)
+* [EventMachine](http://rubyeventmachine.com)
+* [jQuery](http://jquery.com)
+
+
+Usage
+-----
+
+### Setup
+
+Server Side
+
+```ruby
+require 'sinatra'
+require 'sinatra/rocketio'
+require 'sinatra/rocketio/linda'
+set :linda, :check_expire => 60
+
+run Sinatra::Application
+```
+
+Client Side
+
+```html
+<script src="//ajax.googleapis.com/ajax/libs/jquery/1.9.1/jquery.min.js"></script>
+<script src="<%= rocketio_js %>"></script>
+<script src="<%= linda_js %>"></script>
+```
+
+```javascript
+var io = new RocketIO().connect();
+var linda = new Linda(io);
+```
+
+### client / worker
+
+client side
+
+```javascript
+// create tuplespace
+var ts = new linda.TupleSpace("calc");
+
+// request
+$("#btn_request").click(function(){
+  ts.write(["calc_request", "1-2+3*4"]);
+});
+
+// wait result
+var take_result = function(){
+  ts.take(["calc_result"], function(tuple){
+    var result = tuple[1]; // from 'worker' side
+    console.log(result);
+    take_result(); // recursive call
+  });
+};
+io.on("connect", take_result); // RocketIO's "connect" event
+```
+
+worker side
+
+```javascript
+// create tuplespace
+var ts = new linda.TupleSpace("calc");
+
+// calculate
+var calc = function(){
+  ts.take(["calc_request"], function(tuple){
+    var query = tuple[1]; // => "1-2+3*4"
+    var result = eval(query);
+    console.log(query+" = "+result); // => "1-2+3*4 = 11"
+    ts.write(["calc_result", result]); // return to 'client' side
+    calc(); // recursive call
+  });
+};
+io.on("connect", calc); // RocketIO's "connect" event
+```
+
+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/js/linda.js

@@ -0,0 +1,36 @@
+var Linda = function(io, opts){
+  var self = this;
+  this.io = null;
+  if(io === null || typeof io === "undefined"){
+    this.io = new RocketIO().connect();
+  }
+  else{
+    this.io = io;
+  }
+  this.opts = opts || {};
+  this.TupleSpace = function(name){
+    if(name === null || typeof name !== "string") name = "__default__";
+    this.name = name;
+    this.linda = self;
+    var space = this;
+    this.write = function(tuple, opts){
+      if(tuple === null || typeof tuple !== "object") return;
+      if(opts === null || typeof opts === "undefined") opts = {};
+      self.io.push("__linda_write", [space.name, tuple, opts]);
+    };
+    this.read = function(tuple, callback){
+      if(tuple === null || typeof tuple !== "object") return;
+      if(typeof callback !== "function") return;
+      var callback_id = new Date()-0+"";
+      self.io.once("__linda_read_callback_"+callback_id, callback);
+      self.io.push("__linda_read", [space.name, tuple, callback_id]);
+    };
+    this.take = function(tuple, callback){
+      if(tuple === null || typeof tuple !== "object") return;
+      if(typeof callback !== "function") return;
+      var callback_id = new Date()-0+"";
+      self.io.once("__linda_take_callback_"+callback_id, callback);
+      self.io.push("__linda_take", [space.name, tuple, callback_id]);
+    };
+  };
+};

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

@@ -0,0 +1,16 @@
+module Sinatra
+  module RocketIO
+    module Linda
+
+      def self.registered(app)
+        app.helpers Sinatra::RocketIO::Linda::Helper
+
+        app.get '/rocketio/linda.js' do
+          content_type 'application/javascript'
+          @js ||= ERB.new(::Sinatra::RocketIO::Linda.javascript).result(binding)
+        end
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,13 @@
+module Sinatra
+  module RocketIO
+    module Linda
+      module Helper
+
+        def linda_js
+          "#{env['rack.url_scheme']}://#{env['HTTP_HOST']}#{env['SCRIPT_NAME']}/rocketio/linda.js"
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,18 @@
+module Sinatra
+  module RocketIO
+    module Linda
+
+      def self.javascript(*js_file_names)
+        js_file_names = ['linda.js']
+        js = ''
+        js_file_names.each do |i|
+          File.open(File.expand_path "../js/#{i}", File.dirname(__FILE__)) do |f|
+            js += f.read+"\n"
+          end
+        end
+        js
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,76 @@
+module Sinatra
+  module RocketIO
+    module Linda
+
+      def self.tuplespaces
+        @@spaces ||= Hash.new{|h,k| h[k] = TupleSpace.new }
+      end
+
+      def self.[](name)
+        self.tuplespaces[name]
+      end
+
+    end
+  end
+end
+
+Sinatra::RocketIO.on :start do
+  EM::add_periodic_timer Sinatra::RocketIO::Linda.options[:expire_check] do
+    Sinatra::RocketIO::Linda::tuplespaces.values.each do |ts|
+      ts.check_expire
+    end
+  end
+end
+
+EventEmitter.apply Sinatra::RocketIO::Linda
+
+Sinatra::RocketIO.on :__linda_write do |data, client|
+  space, tuple, opts = data
+  space = "__default__" if !space or !space.kind_of? String or space.empty?
+  unless [Hash, Array].include? tuple.class
+    Sinatra::RocketIO::Linda.emit :error, "received Tuple is not Hash or Array at :__linda_write"
+    next
+  end
+  unless opts.kind_of? Hash
+    opts = {}
+  else
+    opts_ = {}
+    opts.each do |k,v|
+      opts_[k.to_sym] = v
+    end
+    opts = opts_
+  end
+  Sinatra::RocketIO::Linda[space].write tuple, opts
+end
+
+Sinatra::RocketIO.on :__linda_read do |data, client|
+  space, tuple, callback = data
+  space = "__default__" if !space or !space.kind_of? String or space.empty?
+  unless [Hash, Array].include? tuple.class
+    Sinatra::RocketIO::Linda.emit :error, "received Tuple is not Hash or Array at :__linda_read"
+    next
+  end
+  if !callback or !callback.kind_of? String or callback.empty?
+    Sinatra::RocketIO::Linda.emit :error, "received Callback ID is not valid at :__linda_read"
+    next
+  end
+  Sinatra::RocketIO::Linda[space].read tuple do |tuple|
+    Sinatra::RocketIO.push "__linda_read_callback_#{callback}", tuple.data, :to => client.session
+  end
+end
+
+Sinatra::RocketIO.on :__linda_take do |data, client|
+  space, tuple, callback = data
+  space = "__default__" if !space or !space.kind_of? String or space.empty?
+  unless [Hash, Array].include? tuple.class
+    Sinatra::RocketIO::Linda.emit :error, "received Tuple is not Hash or Array at :__linda_take"
+    next
+  end
+  if !callback or !callback.kind_of? String or callback.empty?
+    Sinatra::RocketIO::Linda.emit :error, "received Callback ID is not valid at :__linda_take"
+    next
+  end
+  Sinatra::RocketIO::Linda[space].take tuple do |tuple|
+    Sinatra::RocketIO.push "__linda_take_callback_#{callback}", tuple.data, :to => client.session
+  end
+end

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

@@ -0,0 +1,53 @@
+module Sinatra
+  module RocketIO
+    module Linda
+
+      def linda=(options)
+        Linda.options = options
+      end
+
+      def linda
+        Linda.options
+      end
+
+      def self.default_options
+        {
+          :expire_check => [60, lambda{|v| v.kind_of? Fixnum and v > 0 }]
+        }
+      end
+
+      def self.options
+        @@options ||= (
+                       opts = {}
+                       default_options.each do |k,v|
+                         opts[k] = v[0]
+                       end
+                       opts
+                       )
+      end
+
+      def self.options=(opts)
+        @@options = {}
+        opts.each do |k,v|
+          k = k.to_sym
+          unless default_options.include? k
+            STDERR.puts "!! Sinatra::RocketIO::Linda setting - \"#{k}\" is not valid key"
+          else
+            unless default_options[k][1].call(v)
+              default = default_options[k][0]
+              STDERR.puts "!! Sinatra::RocketIO::Linda setting - \"#{k} => #{v}\" is not valid. set default \"#{k} => #{default}\""
+              @@options[k] = default
+            else
+              @@options[k] = v
+            end
+          end
+        end
+        default_options.each do |k, v|
+          @@options[k] = v[0] unless @@options.include? k
+        end
+        @@options
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,41 @@
+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
+          @expire_at = Time.now+(opts[:expire] || 300)
+        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
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,100 @@
+module Sinatra
+  module RocketIO
+    module Linda
+
+      class TupleSpace
+        include Enumerable
+
+        def initialize
+          @tuples = Array.new
+          @callbacks = Array.new
+        end
+
+        def each(&block)
+          @tuples.each do |tp|
+            yield tp
+          end
+        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
+            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
+          @callbacks.push(:type => :read, :callback => block, :tuple => tuple) if block_given?
+        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
+            @callbacks.push(:type => :take, :callback => block, :tuple => tuple) if block_given?
+          end
+        end
+
+        def check_expire
+          expires = []
+          each do |tuple|
+            expires.push tuple unless tuple.expire_at > Time.now
+          end
+          expires.each do |tuple|
+            @tuples.delete tuple
+          end
+        end
+      end
+
+    end
+  end
+end

data/lib/sinatra/rocketio/linda.rb

@@ -0,0 +1,16 @@
+require "sinatra/rocketio/linda/version"
+require "sinatra-rocketio-linda/helper"
+require "sinatra-rocketio-linda/options"
+require "sinatra-rocketio-linda/javascript"
+require "sinatra-rocketio-linda/tuple"
+require "sinatra-rocketio-linda/tuplespace"
+require "sinatra-rocketio-linda/linda"
+require "sinatra-rocketio-linda/application"
+
+module Sinatra
+  module RocketIO
+    module Linda
+    end
+  end
+  register Sinatra::RocketIO::Linda
+end

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

@@ -0,0 +1,60 @@
+require 'event_emitter'
+require 'sinatra/rocketio/client'
+
+module Sinatra
+  module RocketIO
+    module Linda
+
+      class Client
+        attr_reader :io, :tuplespace
+        def initialize(io)
+          if io.kind_of? String and io =~ /^https?:\/\/.+$/
+            @io = Sinatra::RocketIO::Client.new(io).connect
+          elsif io.kind_of? Sinatra::RocketIO::Client
+            @io = io
+          else
+            raise ArgumentError, "argument must be URL or RocketIO::Client"
+          end
+          @tuplespace = Hash.new{|h,k|
+            h[k] = Sinatra::RocketIO::Linda::Client::TupleSpace.new(k, self)
+          }
+        end
+
+        class TupleSpace
+          attr_reader :name, :linda
+          def initialize(name, linda)
+            @name = name
+            @linda = linda
+          end
+
+          def write(tuple, opts={})
+            unless [Hash, Array].include? tuple.class
+              raise ArgumentError, "tuple must be Array or Hash"
+            end
+            @linda.io.push "__linda_write", [@name, tuple, opts]
+          end
+
+          def read(tuple, &block)
+            unless [Hash, Array].include? tuple.class
+              raise ArgumentError, "tuple must be Array or Hash"
+            end
+            callback_id = "#{Time.now.to_i}#{Time.now.usec}"
+            @linda.io.once "__linda_read_callback_#{callback_id}", &block
+            @linda.io.push "__linda_read", [@name, tuple, callback_id]
+          end
+
+          def take(tuple, &block)
+            unless [Hash, Array].include? tuple.class
+              raise ArgumentError, "tuple must be Array or Hash"
+            end
+            callback_id = "#{Time.now.to_i}#{Time.now.usec}"
+            @linda.io.once "__linda_take_callback_#{callback_id}", &block
+            @linda.io.push "__linda_take", [@name, tuple, callback_id]
+          end
+        end
+
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,7 @@
+module Sinatra
+  module RocketIO
+    module Linda
+      VERSION = "0.0.1"
+    end
+  end
+end

data/sample/bin/cui_calc_worker.rb

@@ -0,0 +1,29 @@
+$:.unshift File.expand_path '../../lib', File.dirname(__FILE__)
+require 'rubygems'
+require 'bundler/setup'
+require 'sinatra/rocketio/linda/client'
+
+linda = Sinatra::RocketIO::Linda::Client.new 'http://localhost:5000'
+ts = linda.tuplespace["calc"]
+
+calc = lambda{
+  ts.take ["calc_request"] do |tuple|
+    query = tuple[1]
+    result = eval(query)
+    puts "calc: #{query} = #{result}"
+    ts.write ["calc_result", result]
+    calc.call
+  end
+}
+
+linda.io.on :connect do
+  puts "connect #{io.session}"
+  calc.call
+end
+
+linda.io.on :disconnect do
+  puts "disconnect #{io.session}"
+end
+
+loop do
+end

data/sample/config.ru

@@ -0,0 +1,14 @@
+$:.unshift File.expand_path '../lib', File.dirname(__FILE__)
+require 'rubygems'
+require 'bundler/setup'
+require 'thin'
+require 'sinatra'
+require 'sinatra/rocketio'
+require 'sinatra/reloader' if development?
+require 'sinatra/rocketio/linda'
+require 'haml'
+require File.expand_path 'main', File.dirname(__FILE__)
+
+set :linda, :expire_check => 20
+
+run Sinatra::Application

data/sample/main.rb

@@ -0,0 +1,26 @@
+io = Sinatra::RocketIO
+linda = Sinatra::RocketIO::Linda
+
+io.on :connect do |client|
+  puts "new client connect <#{client}>"
+end
+
+io.on :disconnect do |client|
+  puts "bye <#{client}>"
+end
+
+linda.on :error do |err|
+  STDERR.puts err
+end
+
+get '/' do
+  haml :index
+end
+
+get '/worker' do
+  haml :worker
+end
+
+get '/client' do
+  haml :client
+end

data/sample/public/client.js

@@ -0,0 +1,20 @@
+var io = new RocketIO().connect();
+var linda = new Linda(io);
+var ts = new linda.TupleSpace("calc");
+
+$(function(){
+  $("#btn_request").click(function(){
+    var query = $("#txt_request").val();
+    ts.write(["calc_request", query]);
+  });
+});
+
+var take_result = function(){
+  ts.take(["calc_result"], function(tuple){
+    var result = tuple[1];
+    $("#log").prepend( $("<p>").text(result) );
+    take_result();
+  });
+};
+
+io.on("connect", take_result);

data/sample/public/worker.js

@@ -0,0 +1,14 @@
+var linda = new Linda();
+var ts = new linda.TupleSpace("calc");
+
+var calc = function(){
+  ts.take(["calc_request"], function(tuple){
+    var query = tuple[1];
+    var result = eval(query);
+    $("#log").prepend( $("<p>").text(query+" = "+result).prepend("calc: ") );
+    ts.write(["calc_result", result]);
+    calc();
+  });
+};
+
+linda.io.on("connect", calc);

data/sample/views/client.haml

@@ -0,0 +1,16 @@
+!!!XHTML
+%html
+  %head
+    %meta{'http-equiv' => 'Content-Type', :content => 'text/html', :charset => 'UTF-8'}
+    %title Linda Client on RocketIO
+    %script{:src => "//ajax.googleapis.com/ajax/libs/jquery/1.9.1/jquery.min.js"}
+    %script{:src => rocketio_js}
+    %script{:src => linda_js}
+    %script{:src => "/client.js"}
+  %body
+    %h1 Calc Client
+    %div#main
+      %div#calc
+        %input#txt_request{:type => :text, :value => "1+2*3*4-5"}
+        %input#btn_request{:type => :button, :value => "request!"}
+      %div#log

data/sample/views/index.haml

@@ -0,0 +1,12 @@
+!!!XHTML
+%html
+  %head
+    %meta{'http-equiv' => 'Content-Type', :content => 'text/html', :charset => 'UTF-8'}
+    %title Linda on RocketIO
+  %body
+    %h1 Linda on RocketIO
+    %ul
+      %li
+        %a{:href => "/worker"} calc worker
+      %li
+        %a{:href => "/client"} calc client

data/sample/views/worker.haml

@@ -0,0 +1,13 @@
+!!!XHTML
+%html
+  %head
+    %meta{'http-equiv' => 'Content-Type', :content => 'text/html', :charset => 'UTF-8'}
+    %title Linda Worker on RocketIO
+    %script{:src => "//ajax.googleapis.com/ajax/libs/jquery/1.9.1/jquery.min.js"}
+    %script{:src => rocketio_js}
+    %script{:src => linda_js}
+    %script{:src => "/worker.js"}
+  %body
+    %h1 Calc Worker
+    %div#main
+      %div#log

data/sinatra-rocketio-linda.gemspec

@@ -0,0 +1,30 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'sinatra/rocketio/linda/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "sinatra-rocketio-linda"
+  spec.version       = Sinatra::RocketIO::Linda::VERSION
+  spec.authors       = ["Sho Hashimoto"]
+  spec.email         = ["hashimoto@shokai.org"]
+  spec.description   = %q{Linda implementation on Sinatra RocketIO}
+  spec.summary       = spec.description
+  spec.homepage      = "https://github.com/shokai/sinatra-rocketio-linda"
+  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"
+  spec.add_development_dependency "thin"
+  spec.add_development_dependency "haml"
+
+  spec.add_dependency "sinatra-rocketio"
+  spec.add_dependency "event_emitter"
+  spec.add_dependency "sinatra"
+end

data/test/test_helper.rb

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

data/test/test_tuple.rb

@@ -0,0 +1,29 @@
+require File.expand_path 'test_helper', File.dirname(__FILE__)
+require 'sinatra-rocketio-linda/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
+
+  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])
+  end
+end

data/test/test_tuplespace.rb

@@ -0,0 +1,110 @@
+require File.expand_path 'test_helper', File.dirname(__FILE__)
+require 'sinatra-rocketio-linda/tuple'
+require 'sinatra-rocketio-linda/tuplespace'
+
+class TestTupleSpace < MiniTest::Test
+
+  def setup
+    @space = Sinatra::RocketIO::Linda::TupleSpace.new
+  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}
+  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_tuple_expire
+    @space.write [1,2,3], :expire => 3
+    @space.write [1,2,"a","b"], :expire => 2
+    assert_equal @space.size, 2
+    sleep 2
+    @space.check_expire
+    assert_equal @space.size, 1
+    assert_equal @space.take([1,2]).data, [1,2,3]
+    assert_equal @space.size, 0
+  end
+
+end

metadata

@@ -0,0 +1,188 @@
+--- !ruby/object:Gem::Specification
+name: sinatra-rocketio-linda
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Sho Hashimoto
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-05-14 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'
+- !ruby/object:Gem::Dependency
+  name: thin
+  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: haml
+  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: sinatra-rocketio
+  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: event_emitter
+  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
+  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'
+description: Linda implementation on Sinatra RocketIO
+email:
+- hashimoto@shokai.org
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- History.txt
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/js/linda.js
+- lib/sinatra-rocketio-linda/application.rb
+- lib/sinatra-rocketio-linda/helper.rb
+- lib/sinatra-rocketio-linda/javascript.rb
+- lib/sinatra-rocketio-linda/linda.rb
+- lib/sinatra-rocketio-linda/options.rb
+- lib/sinatra-rocketio-linda/tuple.rb
+- lib/sinatra-rocketio-linda/tuplespace.rb
+- lib/sinatra/rocketio/linda.rb
+- lib/sinatra/rocketio/linda/client.rb
+- lib/sinatra/rocketio/linda/version.rb
+- sample/bin/cui_calc_worker.rb
+- sample/config.ru
+- sample/main.rb
+- sample/public/client.js
+- sample/public/worker.js
+- sample/views/client.haml
+- sample/views/index.haml
+- sample/views/worker.haml
+- sinatra-rocketio-linda.gemspec
+- test/test_helper.rb
+- test/test_tuple.rb
+- test/test_tuplespace.rb
+homepage: https://github.com/shokai/sinatra-rocketio-linda
+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: Linda implementation on Sinatra RocketIO
+test_files:
+- test/test_helper.rb
+- test/test_tuple.rb
+- test/test_tuplespace.rb