ref 1.0.5 → 2.0.0

data/lib/ref/soft_reference.rb

@@ -19,12 +19,12 @@ module Ref
   class SoftReference < Reference
     @@strong_references = [{}]
     @@gc_flag_set = false
-    
+
     # Number of garbage collection cycles after an object is used before a reference to it can be reclaimed.
     MIN_GC_CYCLES = 10
-    
-    @@lock = SafeMonitor.new
-    
+
+    @@lock = Monitor.new
+
     @@finalizer = lambda do |object_id|
       @@lock.synchronize do
         while @@strong_references.size >= MIN_GC_CYCLES do
@@ -34,14 +34,14 @@ module Ref
         @@gc_flag_set = false
       end
     end
-    
+
     # Create a new soft reference to an object.
     def initialize(obj)
       @referenced_object_id = obj.__id__
       @weak_reference = WeakReference.new(obj)
       add_strong_reference(obj)
     end
-    
+
     # Get the referenced object. If the object has been reclaimed by the
     # garbage collector, then this will return nil.
     def object
@@ -50,7 +50,7 @@ module Ref
       add_strong_reference(obj) if obj
       obj
     end
-    
+
     private
       # Create a strong reference to the object. This reference will live
       # for three passes of the garbage collector.

data/lib/ref/version.rb

@@ -0,0 +1,3 @@
+module Ref
+  VERSION = '2.0.0'
+end

data/lib/ref/weak_reference/pure_ruby.rb

@@ -4,25 +4,25 @@ module Ref
   # subclass Delegator which is very heavy to instantiate and utilizes a
   # because it does not fair amount of memory under Ruby 1.8.
   class WeakReference < Reference
-    
+
     class ReferencePointer
       def initialize(object)
         @referenced_object_id = object.__id__
         add_backreference(object)
       end
-      
+
       def cleanup
         obj = ObjectSpace._id2ref(@referenced_object_id) rescue nil
         remove_backreference(obj) if obj
       end
-      
+
       def object
         obj = ObjectSpace._id2ref(@referenced_object_id)
         obj if verify_backreferences(obj)
       rescue RangeError
         nil
       end
-      
+
       private
         # Verify that the object is the same one originally set for the weak reference.
         def verify_backreferences(obj) #:nodoc:
@@ -30,7 +30,7 @@ module Ref
           backreferences = obj.instance_variable_get(:@__weak_backreferences__) if obj.instance_variable_defined?(:@__weak_backreferences__)
           backreferences && backreferences.include?(object_id)
         end
-      
+
         # Add a backreference to the object.
         def add_backreference(obj) #:nodoc:
           return unless supports_backreference?(obj)
@@ -41,7 +41,7 @@ module Ref
           end
           backreferences << object_id
         end
-      
+
         # Remove backreferences from the object.
         def remove_backreference(obj) #:nodoc:
           return unless supports_backreference?(obj)
@@ -51,16 +51,16 @@ module Ref
             obj.send(:remove_instance_variable, :@__weak_backreferences__) if backreferences.empty?
           end
         end
-        
+
         def supports_backreference?(obj)
           obj.respond_to?(:instance_variable_get) && obj.respond_to?(:instance_variable_defined?)
         rescue NoMethodError
           false
         end
     end
-    
+
     @@weak_references = {}
-    @@lock = SafeMonitor.new
+    @@lock = Monitor.new
 
     # Finalizer that cleans up weak references when references are destroyed.
     @@reference_finalizer = lambda do |object_id|

metadata

@@ -1,98 +1,72 @@
 --- !ruby/object:Gem::Specification
 name: ref
 version: !ruby/object:Gem::Version
-  version: 1.0.5
+  version: 2.0.0
 platform: ruby
 authors:
 - Brian Durand
-autorequire: 
+- The Ruby Concurrency Team
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2013-05-20 00:00:00.000000000 Z
+date: 2015-07-10 00:00:00.000000000 Z
 dependencies: []
-description: Library that implements weak, soft, and strong references in Ruby that
-  work across multiple runtimes (MRI, REE, YARV, Jruby, Rubinius, and IronRuby). Also
-  includes implementation of maps/hashes that use references and a reference queue.
+description: Library that implements weak, soft, and strong references in Ruby that work across multiple runtimes (MRI,Jruby and Rubinius). Also includes implementation of maps/hashes that use references and a reference queue.
 email:
 - bbdurand@gmail.com
+- concurrent-ruby@googlegroups.com
 executables: []
 extensions: []
 extra_rdoc_files:
-- README.rdoc
+- README.md
 files:
-- README.rdoc
-- VERSION
 - MIT_LICENSE
-- lib/org/jruby/ext/ref/references.jar
+- README.md
+- ext/java/org/jruby/ext/ref/ReferencesService.java
+- ext/java/org/jruby/ext/ref/RubySoftReference.java
+- ext/java/org/jruby/ext/ref/RubyWeakReference.java
+- lib/ref.rb
 - lib/ref/abstract_reference_key_map.rb
 - lib/ref/abstract_reference_value_map.rb
-- lib/ref/mock.rb
 - lib/ref/reference.rb
 - lib/ref/reference_queue.rb
-- lib/ref/safe_monitor.rb
 - lib/ref/soft_key_map.rb
 - lib/ref/soft_reference.rb
 - lib/ref/soft_value_map.rb
 - lib/ref/strong_reference.rb
+- lib/ref/version.rb
 - lib/ref/weak_key_map.rb
-- lib/ref/weak_reference/iron_ruby.rb
+- lib/ref/weak_reference.rb
 - lib/ref/weak_reference/pure_ruby.rb
 - lib/ref/weak_reference/weak_ref.rb
-- lib/ref/weak_reference.rb
 - lib/ref/weak_value_map.rb
-- lib/ref.rb
-- test/mock_test.rb
-- test/mock_test.rbc
-- test/reference_key_map_behavior.rb
-- test/reference_key_map_behavior.rbc
-- test/reference_queue_test.rb
-- test/reference_queue_test.rbc
-- test/reference_value_map_behavior.rb
-- test/reference_value_map_behavior.rbc
-- test/soft_key_map_test.rb
-- test/soft_key_map_test.rbc
-- test/soft_reference_test.rb
-- test/soft_reference_test.rbc
-- test/soft_value_map_test.rb
-- test/soft_value_map_test.rbc
-- test/strong_reference_test.rb
-- test/strong_reference_test.rbc
-- test/test_helper.rb
-- test/test_helper.rbc
-- test/weak_key_map_test.rb
-- test/weak_key_map_test.rbc
-- test/weak_reference_test.rb
-- test/weak_reference_test.rbc
-- test/weak_value_map_test.rb
-- test/weak_value_map_test.rbc
-- ext/java/org/jruby/ext/ref/ReferencesService.java
-- ext/java/org/jruby/ext/ref/RubySoftReference.java
-- ext/java/org/jruby/ext/ref/RubyWeakReference.java
-homepage: http://github.com/bdurand/ref
+- lib/ref_ext.jar
+homepage: http://github.com/ruby-concurrency/ref
 licenses:
 - MIT
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options:
 - --charset=UTF-8
 - --main
-- README.rdoc
+- README.md
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - '>='
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.9.3
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - '>='
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.0.0
-signing_key: 
+rubyforge_project:
+rubygems_version: 2.4.5
+signing_key:
 specification_version: 4
 summary: Library that implements weak, soft, and strong references in Ruby.
 test_files: []
+has_rdoc: true

data/README.rdoc

@@ -1,40 +0,0 @@
-This library provides object references for Ruby as well as some common utilities for working with references. Object references are used to point to other objects and come in three distinct flavors that interact differently with the garbage collector.
-
-* Ref::StrongReference - This is a plain old pointer to another object.
-* Ref::WeakReference - This is a pointer to another object, but it is not seen by the garbage collector and the memory used by the object can be reclaimed at any time.
-* Ref::SoftReference - This is similar to a weak reference, but the garbage collector is not as eager to reclaim the referenced object.
-
-All of these classes extend from a common Ref::Reference class and have a common interface.
-
-Weak and soft references are useful when you have instantiated objects that you may want to use again but can recreate if necessary. Since the garbage collector determines when to reclaim the memory used by the objects, you don't need to worry about bloating the Ruby heap.
-
-= Example Usage
-
-  ref = Ref::WeakReference.new("hello")
-  ref.object # should be "hello"
-  ObjectSpace.garbage_collect
-  ref.object # should be nil (assuming the garbage collector reclaimed the reference)
-
-= Goodies
-
-This library also includes tools for some common uses of weak and soft references.
-
-* Ref::WeakKeyMap - A map of keys to values where the keys are weak references
-* Ref::WeakValueMap - A map of keys to values where the values are weak references
-* Ref::SoftKeyMap - A map of keys to values where the keys are soft references
-* Ref::SoftValueMap - A map of keys to values where the values are soft references
-* Ref::ReferenceQueue - A thread safe implementation of a queue that will add references to itself as their objects are garbage collected.
-
-= Problems with WeakRef
-
-Ruby does come with the WeakRef class in the standard library. However, there are issues with this class across several different Ruby runtimes. This gem provides a common interface to weak references that works across MRI, Ruby Enterprise Edition, YARV, Jruby, Rubinius, and IronRuby.
-
-1. MRI and REE 1.8 - WeakRef extends from Delegator which is a very heavy weight class under Ruby 1.8. Creating a WeakRef object will allocate thousands of other objects and use up hundreds of kilobytes of memory. This makes WeakRef all but unusable even if you only need several hundred of them.
-2. YARV 1.9 - WeakRef is unsafe to use because the garbage collector can run in a different system thread than a thread allocating memory. This exposes a bug where a WeakRef may end up pointing to a completely different object than it originally referenced.
-3. Jruby and IronRuby - Jruby and IronRuby using the Ruby 1.8 libraries suffers from the same performance issue with the Delegator class. Furthermore, these VM's don't implement the method used to load an object from the heap using an object id and so cannot use a pure Ruby method to implement weak references.
-4. Rubinius - Rubinius implements WeakRef with a lighter weight version of delegation and works very well.
-5. MRI Ruby 2.0 has a good implementation of WeakRef.
-
-= BasicObject
-
-Not that weak references will not work with MRI/REE 1.8 or YARV 1.9. References will be created, but the objects will never be stored so the reference object will always treat the object as if it is always garbage collected. BasicObject does not implement the necessary methods to maintain the reference.

data/VERSION

@@ -1 +0,0 @@
-1.0.5

data/lib/ref/mock.rb

@@ -1,150 +0,0 @@
-module Ref
-  # This module provides mock weak and strong references that are designed to be
-  # used in tests. You can define a block where all weak and soft references created
-  # will be mock references. You can then mimic running the garbage collector on
-  # the objects pointed to by the references.
-  #
-  # Example usage:
-  #
-  #   Ref::Mock.use do
-  #     obj = Object.new
-  #     ref = Ref::WeakReference.new(obj)
-  #     ref.object   # obj
-  #     Ref::Mock.gc(obj)  # mimics the garbage collector reclaiming the referenced object
-  #     ref.object   # nil
-  #   end
-  module Mock
-    class << self
-      # Use the mock implementation inside a block and then restore the original implementation.
-      def use
-        if object_space
-          yield
-        else
-          setup
-          begin
-            yield
-          ensure
-            cleanup
-          end
-        end
-      end
-      
-      # Start using mock references.
-      def setup
-        raise "Ref::Mock already setup" if object_space
-        
-        @object_space = {}
-        
-        class << ObjectSpace
-          unless method_defined?(:define_finalizer_with_mock_reference)
-            def define_finalizer_with_mock_reference(obj, finalizer)
-              if ::Ref::Mock.object_space.include?(obj.__id__)
-                ::Ref::Mock.object_space[obj.__id__] << finalizer
-              else
-                define_finalizer_without_mock_reference(obj, finalizer)
-              end
-            end
-          end
-          
-          alias_method :define_finalizer_without_mock_reference, :define_finalizer
-          alias_method :define_finalizer, :define_finalizer_with_mock_reference
-        end
-        
-        class << WeakReference
-          unless method_defined?(:new_with_mock_reference)
-            def new_with_mock_reference(obj)
-              if self == Mock::MockWeakReference
-                new_without_mock_reference(obj)
-              else
-                Mock::MockWeakReference.new(obj)
-              end
-            end
-          end
-          
-          alias_method :new_without_mock_reference, :new
-          alias_method :new, :new_with_mock_reference
-        end
-        
-        class << SoftReference
-          unless method_defined?(:new_with_mock_reference)
-            def new_with_mock_reference(obj)
-              if self == Mock::MockSoftReference
-                new_without_mock_reference(obj)
-              else
-                Mock::MockSoftReference.new(obj)
-              end
-            end
-          end
-          
-          alias_method :new_without_mock_reference, :new
-          alias_method :new, :new_with_mock_reference
-        end
-      end
-      
-      # Stop using mock references.
-      def cleanup
-        @object_space = nil
-        class << ObjectSpace
-          alias_method :define_finalizer_with_mock_reference, :define_finalizer
-          alias_method :define_finalizer, :define_finalizer_without_mock_reference
-        end
-        
-        class << WeakReference
-          alias_method :new_with_mock_reference, :new
-          alias_method :new, :new_without_mock_reference
-        end
-        
-        class << SoftReference
-          alias_method :new_with_mock_reference, :new
-          alias_method :new, :new_without_mock_reference
-        end
-      end
-
-      def object_space # :nodoc:
-        @object_space if instance_variable_defined?(:@object_space)
-      end
-
-      # Simulate garbage collection of the objects passed in as arguments. If no objects
-      # are specified, all objects will be reclaimed.
-      def gc(*objects)
-        objects = if objects.empty?
-          object_space.keys
-        else
-          objects.map { |obj| obj.__id__ }
-        end
-
-        objects.each do |id|
-          finalizers = object_space.delete(id)
-          if finalizers
-            finalizers.each{|finalizer| finalizer.call(id)}
-          end
-        end
-      end
-    end
-    
-    module MockReference #:nodoc:
-      def initialize(obj)
-        @object = obj
-        @referenced_object_id = obj.__id__
-        raise "Reference::Mock not setup yet" unless Mock.object_space
-        Mock.object_space[obj.__id__] ||= []
-      end
-    
-      def object
-        if @object && Mock.object_space.include?(@object.__id__)
-          @object
-        else
-          @object = nil
-        end
-      end
-    end
-  
-    class MockWeakReference < WeakReference #:nodoc:
-      include MockReference
-    end
-  
-    class MockSoftReference < SoftReference #:nodoc:
-      include MockReference
-    end
-  end  
-end

data/lib/ref/safe_monitor.rb

@@ -1,50 +0,0 @@
-begin
-  require 'thread'
-rescue LoadError
-  # Threads not available. Monitor will do nothing.
-end
-
-module Ref
-  # The Monitor class in Ruby 1.8 has some bugs and also threads may not be available on all
-  # runtimes. This class provides a simple, safe re-entrant mutex as an alternative.
-  class SafeMonitor
-    def initialize
-      @owner = nil
-      @count = 0
-      @mutex = defined?(Mutex) ? Mutex.new : nil
-    end
-  
-    # Acquire an exclusive lock.
-    def lock
-      if @mutex
-        if @owner != Thread.current.object_id
-          @mutex.lock
-          @owner = Thread.current.object_id
-        end
-        @count += 1
-      end
-      true
-    end
-    
-    # Release the exclusive lock.
-    def unlock
-      if @mutex
-        if @owner == Thread.current.object_id
-          @count -= 1
-          if @count == 0
-            @owner = nil
-            @mutex.unlock
-          end
-        end
-      end
-    end
-  
-    # Run a block of code with an exclusive lock.
-    def synchronize
-      lock
-      yield
-    ensure
-      unlock
-    end
-  end
-end