weakling 0.0.4-java

data/HISTORY.txt

@@ -0,0 +1,16 @@
+== 0.0.3 ==
+
+* Moved all classes under Weakling module
+* WeakRef no longer extends Delegate
+* WeakRef#__getobj__ is now just #get
+* IdHash now includes Enumerable
+* Added specs for most behavior
+
+== 0.0.2 ==
+
+* Minor compatibility tweak for the WeakRef replacement impl, to match JRuby
+
+== 0.0.1 ==
+
+* Initial release
+* RefQueue and IdHash support

data/README.txt

@@ -0,0 +1,60 @@
+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.
+
+The weakling repository is at http://github.com/headius/weakling.
+
+== 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,28 @@
+require 'ant'
+
+directory "pkg/classes"
+
+desc "Clean up build artifacts"
+task :clean do
+  rm_rf "pkg/classes"
+  rm_rf "lib/refqueue.jar"
+end
+
+desc "Compile the extension"
+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
+
+desc "Build the jar"
+task :jar => :compile do
+  ant.jar :basedir => "pkg/classes", :destfile => "lib/refqueue.jar", :includes => "**/*.class"
+end
+ 
+task :package => :jar
+
+desc "Run the specs"
+task :spec => :jar do
+  ruby "-S", "spec", "spec"
+end

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,164 @@
+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.RubyModule;
+import org.jruby.RubyObject;
+import org.jruby.anno.JRubyMethod;
+import org.jruby.anno.JRubyClass;
+import org.jruby.exceptions.RaiseException;
+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 {
+        // only used for RefError
+        RubyKernel.require(runtime.getKernel(), runtime.newString("weakref"), Block.NULL_BLOCK);
+
+        RubyModule weaklingModule = runtime.getOrCreateModule("Weakling");
+        RubyClass weakrefClass = runtime.defineClassUnder("WeakRef", runtime.getObject(), WEAKREF_ALLOCATOR, weaklingModule);
+        weakrefClass.setAllocator(WEAKREF_ALLOCATOR);
+        weakrefClass.defineAnnotatedMethods(WeakRef.class);
+
+        RubyClass refQueueClass = runtime.defineClassUnder("RefQueue", runtime.getObject(), REFQUEUE_ALLOCATOR, weaklingModule);
+        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 = "get")
+        public IRubyObject get() {
+            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;
+        }
+
+        @JRubyMethod(name = "initialize", frame = true, visibility = Visibility.PRIVATE)
+        public IRubyObject initialize(ThreadContext context, IRubyObject obj) {
+            ref = new RubyWeakReference(obj, this);
+
+            return context.getRuntime().getNil();
+        }
+
+        @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 context.getRuntime().getNil();
+        }
+
+        @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,2 @@
+require 'refqueue'
+require 'weakling/collections.rb'

data/lib/weakling/collections.rb

@@ -0,0 +1,48 @@
+require 'refqueue'
+
+module Weakling
+  class IdHash
+    include Enumerable
+    
+    def initialize
+      @hash = Hash.new
+      @queue = Weakling::RefQueue.new
+    end
+
+    class IdWeakRef < Weakling::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.get 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
+
+    def each
+      @hash.each {|id, wr| obj = wr.get rescue nil; yield [id,obj] if obj}
+    end
+  end
+end

data/weakling.gemspec

@@ -0,0 +1,16 @@
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{weakling}
+  s.version = "0.0.4"
+  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"]
+  s.platform = "java"
+end

metadata

@@ -0,0 +1,75 @@
+--- !ruby/object:Gem::Specification 
+name: weakling
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+    - 0
+    - 0
+    - 4
+  version: 0.0.4
+platform: java
+authors: 
+  - Charles Oliver Nutter
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-06-03 18:51:00.994000 -05: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
+  - HISTORY.txt
+  - 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 
+  none: false
+  requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+          - 0
+        version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+          - 0
+        version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: A modified WeakRef impl for JRuby plus some weakref-related tools
+test_files: []
+