jruby-stdin-channel 0.1.0-java

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: a28a8e1211996e36c03df35752494e098a5e0cce
+  data.tar.gz: 338f1d8ad70d88df8a8f94579acf8943799a7592
+SHA512:
+  metadata.gz: 7e4f0a8b6ba5c8ff73990732b70d97313b9529377470e3d6a3549065c3cd5cd99cd0e10bae80bd6336063cb6c047d6c1656f37613b55a1463f2c04a08c8e1990
+  data.tar.gz: 3893950157ba0128fbd23797de78df31854ed851cd7d0f3c935999bbe173161a136d6c961f25e3e0c8da04836084e62cee6aa6319da894e15e28df092ec65dc1

data/jruby-stdin-channel.gemspec

@@ -0,0 +1,26 @@
+# encoding: utf-8
+
+raise("JRuby required") unless defined?(JRUBY_VERSION)
+
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'jruby_stdin_channel/version'
+
+Gem::Specification.new do |s|
+  s.name = "jruby-stdin-channel"
+  s.version = StdinChannel::VERSION
+  s.authors = ["Colin Surprenant"]
+  s.date = Time.now.strftime('%Y-%m-%d')
+  s.summary = "JRuby extension to expose an interruptible NIO FileChannel for STDIN"
+  s.description = s.summary
+  s.email = ["colin.surprenant@gmail.com"]
+  s.homepage = "http://github.com/colinsurprenant/jruby-stdin-channel"
+  s.require_paths = ["lib"]
+  s.licenses = ["Apache-2.0"]
+  s.platform = "java"
+
+  s.files = Dir.glob(["jruby-stdin-channel.gemspec", "lib/**/*.{rb,jar}", "src/**/*.java"])
+
+  s.add_development_dependency "rspec", ">= 2.0.0"
+  s.add_development_dependency "rake", ">= 10.0.0"
+end

data/lib/jruby-stdin-channel.rb

@@ -0,0 +1,3 @@
+# encoding: utf-8
+
+require "jruby_stdin_channel/jruby_stdin_channel"

data/lib/jruby_stdin_channel.rb

@@ -0,0 +1,3 @@
+# encoding: utf-8
+
+require "jruby_stdin_channel/jruby_stdin_channel"

data/lib/jruby_stdin_channel/jruby_stdin_channel.rb

@@ -0,0 +1,17 @@
+# encoding: utf-8
+
+require "java"
+
+# local dev setup
+classes_dir = File.expand_path("../../../out/production/main", __FILE__)
+
+if File.directory?(classes_dir)
+  # if in local dev setup, add to classpath
+  $CLASSPATH << classes_dir unless $CLASSPATH.include?(classes_dir)
+else
+  # otherwise use included jar
+  require "jruby_stdin_channel/jruby_stdin_channel.jar"
+end
+
+require "stdin_channel"
+require "jruby_stdin_channel/version"

data/lib/jruby_stdin_channel/version.rb

@@ -0,0 +1,5 @@
+# encoding: utf-8
+
+module StdinChannel
+  VERSION = "0.1.0"
+end

data/src/main/java/StdinChannelService.java

@@ -0,0 +1,10 @@
+import java.io.IOException;
+import org.jruby.Ruby;
+import org.jruby.runtime.load.BasicLibraryService;
+
+public class StdinChannelService implements BasicLibraryService {
+    public boolean basicLoad(final Ruby runtime) throws IOException {
+        new com.jrubystdinchannel.StdinChannelLibrary().load(runtime, false);
+        return true;
+    }
+}

data/src/main/java/com/jrubystdinchannel/StdinChannelLibrary.java

@@ -0,0 +1,130 @@
+package com.jrubystdinchannel;
+
+import java.io.*;
+import java.lang.reflect.Field;
+import java.nio.ByteBuffer;
+import java.nio.channels.FileChannel;
+
+import org.jruby.Ruby;
+import org.jruby.RubyClass;
+import org.jruby.RubyModule;
+import org.jruby.RubyNumeric;
+import org.jruby.RubyObject;
+import org.jruby.RubyString;
+import org.jruby.exceptions.RaiseException;
+import org.jruby.anno.JRubyClass;
+import org.jruby.anno.JRubyMethod;
+import org.jruby.javasupport.JavaObject;
+import org.jruby.runtime.ObjectAllocator;
+import org.jruby.runtime.ThreadContext;
+import org.jruby.runtime.builtin.IRubyObject;
+import org.jruby.runtime.load.Library;
+import org.jruby.javasupport.JavaUtil;
+
+public class StdinChannelLibrary implements Library {
+    public void load(Ruby runtime, boolean wrap) throws IOException {
+        RubyModule mmapModule = runtime.defineModule("StdinChannel");
+        RubyClass byteBufferClass = runtime.defineClassUnder("Reader", runtime.getObject(),  new ObjectAllocator() {
+            public IRubyObject allocate(Ruby runtime, RubyClass rubyClass) {
+                return new Reader(runtime, rubyClass);
+            }
+        }, mmapModule);
+        byteBufferClass.defineAnnotatedMethods(Reader.class);
+    }
+
+    @JRubyClass(name = "Reader", parent = "Object")
+    public static class Reader extends RubyObject {
+
+        private FileInputStream in;
+        private FileChannel channel;
+
+        public Reader(Ruby runtime, RubyClass klass) {
+            super(runtime, klass);
+        }
+
+        // def initialize
+        @JRubyMethod(name = "initialize")
+        public IRubyObject initialize(ThreadContext context)
+        {
+            this.in = interruptibleStdin(context);
+            this.channel = in.getChannel();
+            return context.nil;
+        }
+
+
+        private static FileInputStream interruptibleStdin(ThreadContext context)
+        {
+            final RaiseException EXTRACT_ERROR = context.runtime.newRuntimeError("cannot find underlying FileInputStream in System.in");
+
+            try {
+                InputStream stdin = System.in;
+
+                // we expect System.in to be a FilterInputStream, let's setup access to its "in" field
+                Field inField = FilterInputStream.class.getDeclaredField("in");
+                inField.setAccessible(true);
+
+                // normally the underlying FileInputStream is directly in the "in" field but
+                // let's make sure it's not hidden in another inner FilterInputStream
+                while (stdin instanceof FilterInputStream) {
+                    stdin = (InputStream) inField.get(stdin);
+                }
+
+                // no luck discovering inner FileInputStream ?
+                if (!(stdin instanceof FileInputStream)) {
+                    throw EXTRACT_ERROR;
+                }
+
+                return (FileInputStream) stdin;
+            } catch (NoSuchFieldException|IllegalAccessException e) {
+                throw EXTRACT_ERROR;
+            }
+        }
+
+
+        // def read(size)
+        @JRubyMethod(name = "read", required = 1)
+            public IRubyObject read(ThreadContext context, IRubyObject _size)
+                throws IOException
+        {
+            int size = RubyNumeric.num2int(_size);
+
+            // not sure if we should not reuse a global ByteBuffer here instead of
+            // reallocating a new one at each read call
+            ByteBuffer data = ByteBuffer.allocate(size);
+            int n;
+
+            try {
+                n = this.channel.read(data);
+            } catch (IOException e) {
+                throw context.runtime.newIOErrorFromException(e);
+            }
+
+            if (n > 0) {
+                byte[] bytes = new byte[n];
+                // what is the difference with using data.array() ?
+                data.position(0);
+                data.get(bytes, 0, n);
+                return RubyString.newString(context.runtime, bytes);
+            } else if (n == 0) {
+                // return new empty String
+                return new RubyString(context.runtime, context.runtime.getString());
+            } else {
+                throw context.runtime.newEOFError();
+            }
+        }
+
+        // @return [FileChannel] retrieve native Java FileChannel
+        @JRubyMethod(name = "channel")
+        public IRubyObject channel(ThreadContext context)
+        {
+            return JavaUtil.convertJavaToUsableRubyObject(context.runtime, this.channel);
+        }
+
+        @JRubyMethod(name = "close")
+        public void close()
+                throws IOException
+        {
+            this.channel.close();
+        }
+    }
+}

metadata

@@ -0,0 +1,80 @@
+--- !ruby/object:Gem::Specification
+name: jruby-stdin-channel
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: java
+authors:
+- Colin Surprenant
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2015-05-15 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: 2.0.0
+  name: rspec
+  prerelease: false
+  type: :development
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: 2.0.0
+- !ruby/object:Gem::Dependency
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: 10.0.0
+  name: rake
+  prerelease: false
+  type: :development
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: 10.0.0
+description: JRuby extension to expose an interruptible NIO FileChannel for STDIN
+email:
+- colin.surprenant@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- jruby-stdin-channel.gemspec
+- lib/jruby-stdin-channel.rb
+- lib/jruby_stdin_channel.rb
+- lib/jruby_stdin_channel/jruby_stdin_channel.jar
+- lib/jruby_stdin_channel/jruby_stdin_channel.rb
+- lib/jruby_stdin_channel/version.rb
+- src/main/java/StdinChannelService.java
+- src/main/java/com/jrubystdinchannel/StdinChannelLibrary.java
+homepage: http://github.com/colinsurprenant/jruby-stdin-channel
+licenses:
+- Apache-2.0
+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.4.6
+signing_key:
+specification_version: 4
+summary: JRuby extension to expose an interruptible NIO FileChannel for STDIN
+test_files: []