weakling 0.0.1

data/README.txt

@@ -0,0 +1,58 @@
+weakling: a collection of weakref utilities for Ruby
+
+== Summary ==
+
+This library provides:
+
+* a modified WeakRef implementation for JRuby that supports a reference queue
+* a WeakRef::RefQueue class
+* a weak-valued ID map to replace typical uses of _id2ref
+
+In the future it may provide additional features like a generic WeakHash or other
+reference types like soft and phantom references.
+
+== Usage ==
+
+Just require 'weakling'. It will require 'weakref' along with the refqueue JRuby
+extension and the weakling/collections library containing the weak id hash.
+
+== RefQueue Example ==
+
+require 'weakling'
+require 'java'
+
+q = WeakRef::RefQueue.new
+wr = WeakRef.new(Object.new, q)
+puts "weakref object: #{wr.__id__}"
+
+puts "running GC"
+java.lang.System.gc
+
+puts "weakref alive?: #{wr.weakref_alive?}"
+puts "weakref object from queue: #{q.poll.__id__}"
+
+== WeakRef::IdHash Example ==
+
+require 'weakling'
+ 
+wh = WeakRef::IdHash.new
+ 
+ary = (1..10).to_a.map {Object.new}
+ids = ary.map {|o| wh.add(o)}
+ 
+puts "all items in weak_id_hash:"
+ids.each {|i| puts "#{i} = #{wh[i]}"}
+ 
+puts "dereferencing objects"
+ary = nil
+ 
+puts "forcing GC"
+begin
+  require 'java'
+  java.lang.System.gc
+rescue
+  GC.start
+end
+ 
+puts "all items in weak id hash:"
+ids.each {|i| puts "#{i} = #{wh[i]}"}

data/Rakefile

@@ -0,0 +1,20 @@
+require 'ant'
+
+directory "pkg/classes"
+
+task :clean do
+  rm_rf "pkg/classes"
+  rm_rf "lib/refqueue.jar"
+end
+
+task :compile => "pkg/classes" do |t|
+  ant.javac :srcdir => "ext", :destdir => t.prerequisites.first,
+    :source => "1.5", :target => "1.5", :debug => true,
+    :classpath => "${java.class.path}:${sun.boot.class.path}"
+end
+
+task :jar => :compile do
+  ant.jar :basedir => "pkg/classes", :destfile => "lib/refqueue.jar", :includes => "**/*.class"
+end
+ 
+task :package => :jar

data/examples/id_hash.rb

@@ -0,0 +1,24 @@
+require 'weakling'
+
+wh = WeakRef::IdHash.new
+
+ary = (1..10).to_a.map {Object.new}
+ids = ary.map {|o| wh.add(o)}
+
+puts "all items in weak_id_hash:"
+ids.each {|i| puts "#{i} = #{wh[i]}"}
+
+puts "dereferencing objects"
+ary = nil
+
+puts "forcing GC"
+begin
+  require 'java'
+  java.lang.System.gc
+rescue LoadError
+  # not on JRuby, use GC.start
+  GC.start
+end
+
+puts "all items in weak id hash:"
+ids.each {|i| puts "#{i} = #{wh[i]}"}

data/examples/refqueue_use.rb

@@ -0,0 +1,13 @@
+require 'weakling'
+require 'java'
+
+q = WeakRef::RefQueue.new
+wr = WeakRef.new(Object.new, q)
+puts "weakref object: #{wr.__id__}"
+
+puts "running GC"
+java.lang.System.gc
+
+puts "weakref alive?: #{wr.weakref_alive?}"
+puts "weakref object from queue: #{q.poll.__id__}"
+

data/ext/RefqueueService.java

@@ -0,0 +1,12 @@
+import java.io.IOException;
+        
+import org.jruby.Ruby;
+import org.jruby.runtime.load.BasicLibraryService;
+
+public class RefqueueService implements BasicLibraryService {
+    public boolean basicLoad(final Ruby runtime) throws IOException {
+        new org.jruby.ext.RefQueueLibrary().load(runtime, false);
+        return true;
+    }
+}
+

data/ext/org/jruby/ext/RefQueueLibrary.java

@@ -0,0 +1,173 @@
+package org.jruby.ext;
+
+import java.io.IOException;
+import java.lang.ref.ReferenceQueue;
+import java.lang.ref.WeakReference;
+import org.jruby.Ruby;
+import org.jruby.RubyClass;
+import org.jruby.RubyException;
+import org.jruby.RubyKernel;
+import org.jruby.RubyObject;
+import org.jruby.anno.JRubyMethod;
+import org.jruby.anno.JRubyClass;
+import org.jruby.exceptions.RaiseException;
+import org.jruby.javasupport.util.RuntimeHelpers;
+import org.jruby.runtime.Block;
+import org.jruby.runtime.ObjectAllocator;
+import org.jruby.runtime.ThreadContext;
+import org.jruby.runtime.Visibility;
+import org.jruby.runtime.builtin.IRubyObject;
+import org.jruby.runtime.load.Library;
+
+/**
+ * This library adds reference queue support to JRuby's weakrefs by adding a
+ * RefQueue class that wraps a Java ReferenceQueue and replacing the built-in
+ * WeakRef impl with a new one that's aware of RefQueue.
+ * 
+ * @author headius
+ */
+public class RefQueueLibrary implements Library {
+    public void load(Ruby runtime, boolean wrap) throws IOException {
+        RubyKernel.require(runtime.getKernel(), runtime.newString("weakref"), Block.NULL_BLOCK);
+
+        RubyClass weakrefClass = (RubyClass)runtime.getClassFromPath("WeakRef");
+        weakrefClass.setAllocator(WEAKREF_ALLOCATOR);
+        weakrefClass.defineAnnotatedMethods(WeakRef.class);
+
+        RubyClass refQueueClass = runtime.defineClassUnder("RefQueue", runtime.getObject(), REFQUEUE_ALLOCATOR, weakrefClass);
+        refQueueClass.defineAnnotatedMethods(RefQueue.class);
+    }
+    
+    private static final ObjectAllocator WEAKREF_ALLOCATOR = new ObjectAllocator() {
+        public IRubyObject allocate(Ruby runtime, RubyClass klazz) {
+            return new WeakRef(runtime, klazz);
+        }
+    };
+
+    private static final ObjectAllocator REFQUEUE_ALLOCATOR = new ObjectAllocator() {
+        public IRubyObject allocate(Ruby runtime, RubyClass klazz) {
+            return new RefQueue(runtime, klazz);
+        }
+    };
+
+    @JRubyClass(name="RefQueue", parent="Object")
+    public static class RefQueue extends RubyObject {
+        private final ReferenceQueue queue;
+
+        public RefQueue(Ruby runtime, RubyClass klass) {
+            super(runtime, klass);
+            queue = new ReferenceQueue();
+        }
+
+        public ReferenceQueue getQueue() {
+            return queue;
+        }
+
+        @JRubyMethod
+        public IRubyObject poll() {
+            return returnable(queue.poll());
+        }
+
+        @JRubyMethod
+        public IRubyObject remove() {
+            try {
+                return returnable(queue.remove());
+            } catch (InterruptedException ie) {
+                // ignore
+                return getRuntime().getNil();
+            }
+        }
+
+        @JRubyMethod
+        public IRubyObject remove(IRubyObject timeout) {
+            try {
+                return returnable(queue.remove(timeout.convertToInteger().getLongValue()));
+            } catch (InterruptedException ie) {
+                // ignore
+                return getRuntime().getNil();
+            }
+        }
+
+        private IRubyObject returnable(Object result) {
+            RubyWeakReference ref = (RubyWeakReference)result;
+            if (ref == null) return getRuntime().getNil();
+            return ref.getWeakRef();
+        }
+    }
+
+    public static class RubyWeakReference extends WeakReference<IRubyObject> {
+        private final WeakRef ref;
+        public RubyWeakReference(IRubyObject obj, WeakRef ref) {
+            super(obj);
+            this.ref = ref;
+        }
+        public RubyWeakReference(IRubyObject obj, WeakRef ref, ReferenceQueue queue) {
+            super(obj, queue);
+            this.ref = ref;
+        }
+        public WeakRef getWeakRef() {
+            return ref;
+        }
+    }
+
+    public static class WeakRef extends RubyObject {
+        private RubyWeakReference ref;
+
+        public WeakRef(Ruby runtime, RubyClass klazz) {
+            super(runtime, klazz);
+        }
+
+        @JRubyMethod(name = "__getobj__")
+        public IRubyObject getobj() {
+            IRubyObject obj = ref.get();
+
+            if (obj == null) {
+                // FIXME weakref.rb also does caller(2) here for the backtrace
+                throw newRefError("Illegal Reference - probably recycled");
+            }
+
+            return obj;
+        }
+
+        // This is only here to replace the "new" in JRuby's weakref, which
+        // doesn't really need to be there.
+        @JRubyMethod(name = "new", required = 1, optional = 1, meta = true)
+        public static IRubyObject newInstance(IRubyObject clazz, IRubyObject[] args) {
+            WeakRef weakRef = (WeakRef)((RubyClass)clazz).allocate();
+
+            weakRef.callInit(args, Block.NULL_BLOCK);
+
+            return weakRef;
+        }
+
+        @JRubyMethod(name = "initialize", frame = true, visibility = Visibility.PRIVATE)
+        public IRubyObject initialize(ThreadContext context, IRubyObject obj) {
+            ref = new RubyWeakReference(obj, this);
+
+            return RuntimeHelpers.invokeSuper(context, this, obj, Block.NULL_BLOCK);
+        }
+
+        @JRubyMethod(name = "initialize", frame = true, visibility = Visibility.PRIVATE)
+        public IRubyObject initialize(ThreadContext context, IRubyObject obj, IRubyObject queue) {
+            if (!(queue instanceof RefQueue)) {
+                throw getRuntime().newTypeError("WeakRef can only queue into a RefQueue");
+            }
+            ref = new RubyWeakReference(obj, this, ((RefQueue)queue).getQueue());
+
+            return RuntimeHelpers.invokeSuper(context, this, obj, Block.NULL_BLOCK);
+        }
+
+        @JRubyMethod(name = "weakref_alive?")
+        public IRubyObject weakref_alive_p() {
+            return ref.get() != null ? getRuntime().getTrue() : getRuntime().getFalse();
+        }
+
+        private RaiseException newRefError(String message) {
+            RubyException exception =
+                    (RubyException)getRuntime().getClass("RefError").newInstance(getRuntime().getCurrentContext(),
+                    new IRubyObject[] {getRuntime().newString(message)}, Block.NULL_BLOCK);
+
+            return new RaiseException(exception);
+        }
+    }
+}

data/lib/weakling.rb

@@ -0,0 +1,4 @@
+require 'weakref'
+require 'refqueue'
+
+require 'weakling/collections.rb'

data/lib/weakling/collections.rb

@@ -0,0 +1,41 @@
+require 'weakref'
+require 'refqueue'
+
+class WeakRef::IdHash
+  def initialize
+    @hash = Hash.new
+    @queue = WeakRef::RefQueue.new
+  end
+
+  class IdWeakRef < WeakRef
+    attr_accessor :id
+    def initialize(obj, queue)
+      super(obj, queue)
+      @id = obj.__id__
+    end
+  end
+
+  def [](id)
+    _cleanup
+    if wr = @hash[id]
+      return wr.__getobj__ rescue nil
+    end
+
+    return nil
+  end
+
+  def add(object)
+    _cleanup
+    wr = IdWeakRef.new(object, @queue)
+
+    @hash[wr.id] = wr
+
+    return wr.id
+  end
+
+  def _cleanup
+    while ref = @queue.poll
+      @hash.delete(ref.id)
+    end
+  end
+end

data/weakling.gemspec

@@ -0,0 +1,15 @@
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{weakling}
+  s.version = "0.0.1"
+  s.authors = ["Charles Oliver Nutter"]
+  s.date = Time.now.strftime('YYYY-MM-DD')
+  s.description = "A modified WeakRef impl for JRuby plus some weakref-related tools"
+  s.email = ["headius@headius.com"]
+  s.files = Dir['{lib,ext,examples,test}/**/*'] + Dir['{*.txt,*.gemspec,Rakefile}']
+  s.homepage = "http://github.com/headius/weakling"
+  s.require_paths = ["lib"]
+  s.summary = "A modified WeakRef impl for JRuby plus some weakref-related tools"
+  s.test_files = Dir["test/test*.rb"]
+end

metadata

@@ -0,0 +1,72 @@
+--- !ruby/object:Gem::Specification 
+name: weakling
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+    - 0
+    - 0
+    - 1
+  version: 0.0.1
+platform: ruby
+authors: 
+  - Charles Oliver Nutter
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-03-11 18:25:16.468000 -06:00
+default_executable: 
+dependencies: []
+
+description: A modified WeakRef impl for JRuby plus some weakref-related tools
+email: 
+  - headius@headius.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+  - lib/refqueue.jar
+  - lib/weakling.rb
+  - lib/weakling/collections.rb
+  - ext/RefqueueService.java
+  - ext/org/jruby/ext/RefQueueLibrary.java
+  - examples/id_hash.rb
+  - examples/refqueue_use.rb
+  - README.txt
+  - weakling.gemspec
+  - Rakefile
+has_rdoc: true
+homepage: http://github.com/headius/weakling
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+  - lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+          - 0
+        version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+          - 0
+        version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.6
+signing_key: 
+specification_version: 3
+summary: A modified WeakRef impl for JRuby plus some weakref-related tools
+test_files: []
+