jo 0.1-java

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 344c02dfbdb2d8a82c5c49113764feb5536fe15f
+  data.tar.gz: d61d7fcff30a498de944e32f045e5b28a8ad3951
+SHA512:
+  metadata.gz: 4faa2fdfa74959edc33a8e9a1c42b5491e9d71d534e6c088774af72d94c8f4312232dade20f8a89317b92f280da9e19c3ee0ce90924a2293a5efab4933f82beb
+  data.tar.gz: 89a87749068b2a3544444a1cb32aaaf4b2a5ce07f0ad140f3cf017394895eef55cb3d44cdfd203d0809e0559a296331c3ecdb38b25cc01ecdfc183ef4be01ce7

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Charles Oliver Nutter
+
+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,58 @@
+# Jo
+
+A library to provide "goroutines", "channels", and "select" as in Go.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'jo'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install jo
+
+## Usage
+
+require 'jo'
+
+include Jo
+
+# pinger ponger printer
+def pinger(c)
+  20.times do
+    c << 'ping'
+  end
+end
+
+def ponger(c)
+  20.times do
+    c << 'pong'
+  end
+end
+
+def printer(c)
+  40.times do
+    puts c.take
+    sleep 1
+  end
+end
+
+c = chan
+jo {pinger(c)}
+jo {ponger(c)}
+jo {printer(c)}
+
+gets # prevent exit
+
+## 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 @@
+require "bundler/gem_tasks"

data/examples/pingpong.rb

@@ -0,0 +1,30 @@
+require 'jo'
+
+include Jo
+
+# pinger ponger printer
+def pinger(c)
+  20.times do
+    c << 'ping'
+  end
+end
+
+def ponger(c)
+  20.times do
+    c << 'pong'
+  end
+end
+
+def printer(c)
+  40.times do
+    puts c.take
+    sleep 1
+  end
+end
+
+c = chan
+jo {pinger(c)}
+jo {ponger(c)}
+jo {printer(c)}
+
+gets

data/examples/randsleep.rb

@@ -0,0 +1,15 @@
+require 'jo'
+
+include Jo
+
+# print out 1-10 in ten joroutines with 0-250ms delay
+def f(n)
+  10.times do |i|
+    puts "#{n}:#{i}"
+    sleep rand(250)/1000.0
+  end
+end
+
+10.times do |n|
+  jo {f(n)}
+end

data/examples/selection.rb

@@ -0,0 +1,27 @@
+require 'jo'
+
+include Jo
+
+c1 = chan
+c2 = chan
+
+jo do
+  loop do
+    c1 << "from 1"
+    sleep 2
+  end
+end
+
+jo do
+  loop do
+    c2 << "from 2"
+    sleep 3
+  end
+end
+
+loop do
+  select(
+    c1 => proc{|n| puts "even: #{n}"},
+    c2 => proc{|n| puts "odd: #{n}"}
+  )
+end

data/jo.gemspec

@@ -0,0 +1,24 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'jo/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "jo"
+  spec.version       = Jo::VERSION
+  spec.authors       = ["Charles Oliver Nutter"]
+  spec.email         = ["headius@headius.com"]
+  spec.description   = "An implementation of goroutines and channels for Ruby"
+  spec.summary       = "An implementation of goroutines and channels (from the Go language) for Ruby"
+  spec.homepage      = "https://github.com/headius/jo"
+  spec.license       = "MIT"
+  spec.platform      = "java"
+
+  spec.files         = `git ls-files`.split($/) + ["target/jo-#{Jo::VERSION}.jar"]
+  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", "target"]
+
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake"
+end

data/lib/jo.rb

@@ -0,0 +1,4 @@
+require "jo/version"
+require "jo-#{Jo::VERSION}.jar"
+
+com.headius.jo.JoLibrary.new.load(JRuby.runtime, false)

data/lib/jo/version.rb

@@ -0,0 +1,3 @@
+module Jo
+  VERSION = "0.1"
+end

data/pom.xml

@@ -0,0 +1,30 @@
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+  <modelVersion>4.0.0</modelVersion>
+
+  <groupId>com.headius</groupId>
+  <artifactId>jo</artifactId>
+  <version>0.1</version>
+  <packaging>jar</packaging>
+
+  <name>jo</name>
+  <url>http://maven.apache.org</url>
+
+  <properties>
+    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
+  </properties>
+
+  <dependencies>
+    <dependency>
+      <groupId>junit</groupId>
+      <artifactId>junit</artifactId>
+      <version>3.8.1</version>
+      <scope>test</scope>
+    </dependency>
+    <dependency>
+      <groupId>org.jruby</groupId>
+      <artifactId>jruby</artifactId>
+      <version>1.7.4</version>
+    </dependency>
+  </dependencies>
+</project>

data/src/main/java/com/headius/jo/JoLibrary.java

@@ -0,0 +1,156 @@
+package com.headius.jo;
+
+import java.io.IOException;
+import java.util.Set;
+import java.util.concurrent.BlockingQueue;
+import java.util.concurrent.Callable;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.Future;
+import java.util.concurrent.SynchronousQueue;
+import java.util.concurrent.ThreadFactory;
+import org.jruby.Finalizable;
+import org.jruby.Ruby;
+import org.jruby.RubyClass;
+import org.jruby.RubyHash;
+import org.jruby.RubyKernel;
+import org.jruby.RubyModule;
+import org.jruby.RubyObject;
+import org.jruby.RubyString;
+import org.jruby.anno.JRubyMethod;
+import org.jruby.exceptions.RaiseException;
+import org.jruby.runtime.Block;
+import org.jruby.runtime.ObjectAllocator;
+import org.jruby.runtime.ThreadContext;
+import org.jruby.runtime.builtin.IRubyObject;
+import org.jruby.runtime.load.Library;
+
+public class JoLibrary implements Library{
+    public void load(Ruby runtime, boolean wrap) throws IOException {
+        RubyModule jo = runtime.defineModule("Jo");
+        final ExecutorService executor = Executors.newCachedThreadPool(new ThreadFactory() {
+            public Thread newThread(Runnable r) {
+                Thread t = new Thread(r);
+                t.setDaemon(true);
+                return t;
+            }
+        });
+        jo.setInternalVariable("executor", executor);
+        RubyClass joFuture = runtime.defineClass("Future", runtime.getObject(), ObjectAllocator.NOT_ALLOCATABLE_ALLOCATOR);
+        RubyClass joChannel = runtime.defineClass("Channel", runtime.getObject(), ObjectAllocator.NOT_ALLOCATABLE_ALLOCATOR);
+        
+        jo.defineAnnotatedMethods(JoMethods.class);
+        joFuture.defineAnnotatedMethods(JoFuture.class);
+        joChannel.defineAnnotatedMethods(JoChannel.class);
+        
+        runtime.addFinalizer(new Finalizable() {
+            public void finalize() {
+                executor.shutdown();
+            }
+        });
+    }
+    
+    public static class JoRoutine implements Callable<IRubyObject> {
+        public JoRoutine(Ruby runtime, Block body) {
+            this.runtime = runtime;
+            this.body = body;
+        }
+
+        public IRubyObject call() throws Exception {
+            ThreadContext context = runtime.getCurrentContext();
+            try {
+                return body.call(context);
+            } catch (RaiseException re) {
+                RubyKernel.puts(context, body.getBinding().getSelf(), new IRubyObject[] {
+                        RubyString.newString(runtime, "joroutine terminated with error: " + re.getMessage())});
+                RubyKernel.puts(context, body.getBinding().getSelf(), new IRubyObject[] {re.getException().backtrace()});
+                throw re;
+            }
+        }
+        
+        private final Ruby runtime;
+        private final Block body;
+    }
+    
+    public static class JoChannel extends RubyObject {
+        public JoChannel(Ruby runtime, RubyClass klass, BlockingQueue<IRubyObject> queue) {
+            super(runtime, klass);
+            this.queue = queue;
+        }
+        
+        @JRubyMethod(name = "<<")
+        public IRubyObject append(ThreadContext context, IRubyObject value) throws InterruptedException {
+            queue.put(value);
+            return this;
+        }
+        
+        @JRubyMethod
+        public IRubyObject take(ThreadContext context) throws InterruptedException {
+            return queue.take();
+        }
+        
+        private final BlockingQueue<IRubyObject> queue;
+    }
+    
+    public static class JoFuture extends RubyObject {
+        public JoFuture(Ruby runtime, RubyClass klass, Future<IRubyObject> future) {
+            super(runtime, klass);
+            
+            this.future = future;
+        }
+        
+        @JRubyMethod
+        public IRubyObject get(ThreadContext context) throws ExecutionException, InterruptedException {
+            return future.get();
+        }
+        
+        @JRubyMethod
+        public IRubyObject cancel(ThreadContext context) {
+            return context.runtime.newBoolean(future.cancel(true));
+        }
+        
+        private final Future<IRubyObject> future;
+    }
+    
+    public static class JoMethods {
+        @JRubyMethod(module = true)
+        public static IRubyObject jo(ThreadContext context, IRubyObject self, Block block) {
+            Ruby runtime = context.runtime;
+            RubyModule jo = runtime.getModule("Jo");
+            ExecutorService executor = (ExecutorService)jo.getInternalVariable("executor");
+            Future<IRubyObject> future = executor.submit(new JoRoutine(runtime, block));
+            return new JoFuture(runtime, jo.getClass("Future"), future);
+        }
+        
+        @JRubyMethod(module = true)
+        public static IRubyObject chan(ThreadContext context, IRubyObject self, Block block) {
+            Ruby runtime = context.runtime;
+            return new JoChannel(runtime, (RubyClass)runtime.getClassFromPath("Jo::Channel"), new SynchronousQueue<IRubyObject>(true));
+        }
+        
+        @JRubyMethod(module = true)
+        public static IRubyObject select(ThreadContext context, IRubyObject self, IRubyObject hash) {
+            Ruby runtime = context.runtime;
+            RubyHash cases = hash.convertToHash();
+            
+            Set<RubyHash.RubyHashEntry> entries = (Set<RubyHash.RubyHashEntry>)cases.directEntrySet();
+            Object[] entryArray = entries.toArray();
+            OUTER: while (true) {
+                for (Object _entry : entryArray) {
+                    RubyHash.RubyHashEntry entry = (RubyHash.RubyHashEntry)_entry;
+                    IRubyObject _channel = (IRubyObject)entry.getKey();
+                    if (!(_channel instanceof JoChannel)) throw runtime.newTypeError(_channel, runtime.getClassFromPath("Jo::Channel"));
+                    IRubyObject _proc = (IRubyObject)entry.getValue();
+                    IRubyObject value;
+                    if ((value = ((JoChannel)_channel).queue.poll()) != null) {
+                        _proc.callMethod(context, "call", value);
+                        break OUTER;
+                    }
+                    Thread.yield();
+                }
+            }
+            return context.nil;
+        }
+    }
+}

metadata

@@ -0,0 +1,85 @@
+--- !ruby/object:Gem::Specification
+name: jo
+version: !ruby/object:Gem::Version
+  version: '0.1'
+platform: java
+authors:
+- Charles Oliver Nutter
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2013-08-17 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  prerelease: false
+  name: bundler
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  prerelease: false
+  name: rake
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: An implementation of goroutines and channels for Ruby
+email:
+- headius@headius.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE.txt
+- README.md
+- Rakefile
+- examples/pingpong.rb
+- examples/randsleep.rb
+- examples/selection.rb
+- jo.gemspec
+- lib/jo.rb
+- lib/jo/version.rb
+- pom.xml
+- src/main/java/com/headius/jo/JoLibrary.java
+- target/jo-0.1.jar
+homepage: https://github.com/headius/jo
+licenses:
+- MIT
+metadata: {}
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+- target
+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: An implementation of goroutines and channels (from the Go language) for Ruby
+test_files: []