wref 0.0.6 → 0.0.7

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: e9470b819c7b11a7787df0b977af91b0d1a20af2
+  data.tar.gz: 1abbd729851f77a36f5ebe0f8def73d73b5bd8d3
+SHA512:
+  metadata.gz: 5c6fb6e08a0822a3d8a09b73f1390040b73af795dee23a2921e6600f28be809d6d05c9b321bb7f9b11b715e2f30dbca964b23269ee357da9ec85f447e6096a57
+  data.tar.gz: d5fa295fd268ee4e1f995384ff1c1e850b8c702d23804dd816b646d6775bf8f482e3a694f4ef652281468482813bfca3654050977ab41c0d6ed4f15898ba9f90

data/Gemfile

@@ -6,8 +6,12 @@ source "http://rubygems.org"
 # Add dependencies to develop your gem here.
 # Include everything needed to run rake, tests, features, etc.
 group :development do
-  gem "rspec", "~> 2.8.0"
-  gem "rdoc", "~> 3.12"
-  gem "bundler", ">= 1.0.0"
-  gem "jeweler", "~> 1.8.3"
+  gem "rspec", "~> 3.2.0"
+  gem "bundler", "~> 1.9.2"
+  gem "jeweler", "~> 1.8.8"
+  gem "highline", "~> 1.6.21"
+  gem "weakling"
+  gem "ref"
 end
+
+gem "codeclimate-test-reporter", group: :test, require: nil

data/Gemfile.lock

@@ -1,31 +1,81 @@
 GEM
   remote: http://rubygems.org/
   specs:
-    diff-lcs (1.1.3)
-    git (1.2.5)
-    jeweler (1.8.4)
+    addressable (2.3.8)
+    builder (3.2.2)
+    codeclimate-test-reporter (0.4.7)
+      simplecov (>= 0.7.1, < 1.0.0)
+    diff-lcs (1.2.5)
+    docile (1.1.5)
+    faraday (0.8.9)
+      multipart-post (~> 1.2.0)
+    git (1.2.9.1)
+    github_api (0.10.1)
+      addressable
+      faraday (~> 0.8.1)
+      hashie (>= 1.2)
+      multi_json (~> 1.4)
+      nokogiri (~> 1.5.2)
+      oauth2
+    hashie (3.4.1)
+    highline (1.6.21)
+    jeweler (1.8.8)
+      builder
       bundler (~> 1.0)
       git (>= 1.2.5)
+      github_api (= 0.10.1)
+      highline (>= 1.6.15)
+      nokogiri (= 1.5.10)
       rake
       rdoc
-    json (1.7.7)
-    rake (10.0.3)
-    rdoc (3.12.1)
+    json (1.8.2)
+    json (1.8.2-java)
+    jwt (1.4.1)
+    multi_json (1.11.0)
+    multi_xml (0.5.5)
+    multipart-post (1.2.0)
+    nokogiri (1.5.10)
+    nokogiri (1.5.10-java)
+    oauth2 (1.0.0)
+      faraday (>= 0.8, < 0.10)
+      jwt (~> 1.0)
+      multi_json (~> 1.3)
+      multi_xml (~> 0.5)
+      rack (~> 1.2)
+    rack (1.6.0)
+    rake (10.4.2)
+    rdoc (4.2.0)
       json (~> 1.4)
-    rspec (2.8.0)
-      rspec-core (~> 2.8.0)
-      rspec-expectations (~> 2.8.0)
-      rspec-mocks (~> 2.8.0)
-    rspec-core (2.8.0)
-    rspec-expectations (2.8.0)
-      diff-lcs (~> 1.1.2)
-    rspec-mocks (2.8.0)
+    ref (1.0.5)
+    rspec (3.2.0)
+      rspec-core (~> 3.2.0)
+      rspec-expectations (~> 3.2.0)
+      rspec-mocks (~> 3.2.0)
+    rspec-core (3.2.2)
+      rspec-support (~> 3.2.0)
+    rspec-expectations (3.2.0)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.2.0)
+    rspec-mocks (3.2.1)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.2.0)
+    rspec-support (3.2.2)
+    simplecov (0.9.2)
+      docile (~> 1.1.0)
+      multi_json (~> 1.0)
+      simplecov-html (~> 0.9.0)
+    simplecov-html (0.9.0)
+    weakling (0.0.3)
 
 PLATFORMS
+  java
   ruby
 
 DEPENDENCIES
-  bundler (>= 1.0.0)
-  jeweler (~> 1.8.3)
-  rdoc (~> 3.12)
-  rspec (~> 2.8.0)
+  bundler (~> 1.9.2)
+  codeclimate-test-reporter
+  highline (~> 1.6.21)
+  jeweler (~> 1.8.8)
+  ref
+  rspec (~> 3.2.0)
+  weakling

data/README.md

@@ -0,0 +1,65 @@
+[![Build Status](https://api.shippable.com/projects/540e7b9f3479c5ea8f9ec25e/badge?branchName=master)](https://app.shippable.com/projects/540e7b9f3479c5ea8f9ec25e/builds/latest)
+[![Code Climate](https://codeclimate.com/github/kaspernj/wref/badges/gpa.svg)](https://codeclimate.com/github/kaspernj/wref)
+[![Test Coverage](https://codeclimate.com/github/kaspernj/wref/badges/coverage.svg)](https://codeclimate.com/github/kaspernj/wref)
+
+# Wref
+
+Weak references for Ruby
+
+## Install
+
+Add to your Gemfile and bundle
+
+```ruby
+gem "wref"
+```
+
+## Usage
+
+### Make a new weak reference
+
+```ruby
+str = "Test"
+weak_ref = Wref.new(str)
+```
+
+### Check if reference is still alive
+
+```ruby
+weak_ref.alive? #=> true | false
+```
+
+### Weak map
+
+```ruby
+weak_map = Wref::Map.new
+map[1] = str
+```
+
+### Check if key is valid in a weak map.
+
+```ruby
+weak_map.valid?(1) #=> true | false
+```
+
+### Get from a key
+
+```ruby
+weak_map.get(1) #=> "Test" | Error - Wref::Recycled
+```
+
+## Contributing to wref
+
+* Check out the latest master to make sure the feature hasn't been implemented or the bug hasn't been fixed yet.
+* Check out the issue tracker to make sure someone already hasn't requested it and/or contributed it.
+* Fork the project.
+* Start a feature/bugfix branch.
+* Commit and push until you are happy with your contribution.
+* Make sure to add tests for it. This is important so I don't break it in a future version unintentionally.
+* Please try not to mess with the Rakefile, version, or history. If you want to have your own version, or is otherwise necessary, that is fine, but please isolate to its own commit so I can cherry-pick around it.
+
+## Copyright
+
+Copyright (c) 2012 Kasper Johansen. See LICENSE.txt for
+further details.
+

data/VERSION

@@ -1 +1 @@
-0.0.6
+0.0.7

data/lib/wref.rb

@@ -1,4 +1,4 @@
-require "java" if RUBY_ENGINE == "jruby"
+require "weakref"
 
 #A simple weak-reference framework with mapping. Only handles the referencing of objects.
 #===Examples
@@ -15,292 +15,59 @@ require "java" if RUBY_ENGINE == "jruby"
 #   print "The user has been removed from memory."
 # end
 class Wref
-  #Returns the classname of the object.
-  attr_reader :class_name
-  
-  #Returns the object-ID which is used to look up the ObjectSpace (if not running JRuby).
-  attr_reader :id
-  
-  #This can be used to debug the behavior of the library.
-  USE_NATIVE_RUBY_IMPLEMENTATION = false
-  
+  #This error is raised when an object in a wref has been garbage-collected.
+  class Recycled < RuntimeError; end
+
+  autoload :Map, "#{File.dirname(__FILE__)}/wref/map"
+
+  class Implementations
+    dir = "#{File.dirname(__FILE__)}/wref/implementations"
+
+    autoload :IdClassUnique, "#{dir}/id_class_unique"
+    autoload :JavaWeakReference, "#{dir}/java_weak_reference"
+    autoload :Ref, "#{dir}/ref"
+    autoload :Weakling, "#{dir}/weakling"
+    autoload :WeakRef, "#{dir}/weak_ref"
+  end
+
+  attr_reader :implementation, :weak_ref
+
   #Initializes various variables.
-  def initialize(obj)
-    if USE_NATIVE_RUBY_IMPLEMENTATION
-      require "weakref"
-      @weakref = WeakRef.new(obj)
+  def initialize(object, args = {})
+    if args[:impl]
+      @implementation = args[:impl]
     elsif RUBY_ENGINE == "jruby"
-      @weakref = java.lang.ref.WeakReference.new(obj)
+      @implementation = :JavaWeakReference
     else
-      @id = obj.__id__
-      @class_name = obj.class.name.to_sym
-      ObjectSpace.define_finalizer(obj, self.method(:destroy))
-      
-      if obj.respond_to?(:__object_unique_id__)
-        @unique_id = obj.__object_unique_id__
-      end
+      @implementation = :IdClassUnique
     end
+
+    @weak_ref = Wref::Implementations.const_get(implementation).new(object)
   end
-  
-  #Destroyes most variables on the object, releasing memory and returning 'Wref::Recycled' all the time. It takes arguments because it can be called from destructor of the original object. It doesnt use the arguments for anything.
-  def destroy(*args)
-    @id = nil
-    @class_name = nil
-    @unique_id = nil
-    @weakref = nil
-  end
-  
+
   #Returns the object that this weak reference holds or raises Wref::Recycled.
   # begin
-  #   obj = wref.get
-  #   print "Object still exists in memory."
+  #   object = wref.get!
+  #   puts "Object still exists in memory."
   # rescue Wref::Recycled
-  #   print "Object has been garbage-collected."
+  #   puts "Object has been garbage-collected."
   # end
-  def get
-    begin
-      if USE_NATIVE_RUBY_IMPLEMENTATION
-        begin
-          return @weakref.__getobj__
-        rescue => e
-          raise Wref::Recycled if e.class.name == "RefError"
-          raise e
-        end
-      elsif RUBY_ENGINE == "jruby"
-        raise Wref::Recycled if !@weakref
-        obj = @weakref.get
-        
-        if obj == nil
-          raise Wref::Recycled
-        else
-          return obj
-        end
-      else
-        raise Wref::Recycled if !@class_name or !@id
-        obj = ObjectSpace._id2ref(@id)
-        
-        #Some times this class-name will be nil for some reason - knj
-        obj_class_name = obj.class.name
-        
-        if !obj_class_name or @class_name != obj_class_name.to_sym or @id != obj.__id__
-          raise Wref::Recycled
-        end
-        
-        if @unique_id
-          raise Wref::Recycled if !obj.respond_to?(:__object_unique_id__) or obj.__object_unique_id__ != @unique_id
-        end
-        
-        return obj
-      end
-    rescue RangeError, TypeError
-      raise Wref::Recycled
-    end
-  end
-  
-  #The same as the normal 'get' but returns nil instead of raising Wref::Cycled-error.
   def get!
-    begin
-      return self.get
-    rescue Wref::Recycled
-      return nil
-    end
+    @weak_ref.get!
+  end
+
+  #The same as the normal 'get!' but returns nil instead of raising Wref::Cycled-error.
+  def get
+    @weak_ref.get
   end
-  
+
   #Returns true if the reference is still alive.
   # print "The object still exists in memory." if wref.alive?
   def alive?
-    begin
-      self.get
-      return true
-    rescue Wref::Recycled
-      return false
-    end
+    @weak_ref.alive?
   end
-  
+
   #Makes Wref compatible with the normal WeakRef.
   alias weakref_alive? alive?
   alias __getobj__ get
 end
-
-#A weak hash-map.
-#===Examples
-# map = Wref_map.new
-# map[1] = obj
-# obj = nil
-# 
-# sleep 0.5
-# 
-# begin
-#   obj = map[1]
-#   print "Object still exists in memory."
-# rescue Wref::Recycled
-#   print "Object has been garbage-collected."
-# end
-#
-# obj = map.get!(1)
-# print "Object still exists in memory." if obj
-class Wref_map
-  def initialize(args = nil)
-    @map = {}
-    @ids = {}
-    @mutex = Mutex.new
-  end
-  
-  #Sets a new object in the map with a given ID.
-  def set(id, obj)
-    wref = Wref.new(obj)
-    
-    @mutex.synchronize do
-      @map[id] = wref
-      @ids[obj.__id__] = id
-    end
-    
-    #JRuby cant handle this atm... Dunno why...
-    if RUBY_ENGINE != "jruby"
-      ObjectSpace.define_finalizer(obj, self.method(:delete_by_id))
-    end
-    
-    return nil
-  end
-  
-  #Returns a object by ID or raises a RefError.
-  #===Examples
-  # begin
-  #   obj = map[1]
-  #   print "Object still exists in memory."
-  # rescue Wref::Recycled
-  #   print "Object has been garbage-collected."
-  # end
-  def get(id)
-    begin
-      wref = nil
-      @mutex.synchronize do
-        raise Wref::Recycled if !@map.key?(id)
-        wref = @map[id]
-      end
-      
-      return wref.get
-    rescue Wref::Recycled => e
-      self.delete(id)
-      raise e
-    end
-  end
-  
-  #The same as 'get' but returns nil instead of WeakRef-error. This can be used to avoid writing lots of code.
-  #===Examples
-  # obj = map.get!(1)
-  # print "Object still exists in memory." if obj
-  def get!(id)
-    begin
-      return self.get(id)
-    rescue Wref::Recycled
-      return nil
-    end
-  end
-  
-  #Scans the whole map and removes dead references. After the implementation of automatic clean-up by using ObjectSpace.define_finalizer, there should be no reason to call this method.
-  def clean
-    keys = nil
-    @mutex.synchronize do
-      keys = @map.keys
-    end
-    
-    keys.each do |key|
-      begin
-        self.get(key) #this will remove the key if the object no longer exists.
-      rescue Wref::Recycled
-        #ignore.
-      end
-    end
-    
-    return nil
-  end
-  
-  #Returns true if a given key exists and the object it holds is alive.
-  def valid?(key)
-    @mutex.synchronize do
-      return false if !@map.key?(key)
-    end
-    
-    begin
-      @map[key].get
-      return true
-    rescue Wref::Recycled
-      return false
-    end
-  end
-  
-  #Returns true if the given key exists in the hash.
-  #===Examples
-  # print "Key exists but we dont know if the value has been garbage-collected." if map.key?(1)
-  def key?(key)
-    @mutex.synchronize do
-      return @map.key?(key)
-    end
-  end
-  
-  #Returns the length of the hash. This may not be true since invalid objects is also counted.
-  def length
-    @mutex.synchronize do
-      return @map.length
-    end
-  end
-  
-  #Cleans the hash and returns the length. This is slower but more accurate than the ordinary length that just returns the hash-length.
-  def length_valid
-    self.clean
-    return self.length
-  end
-  
-  #Deletes a key in the hash.
-  def delete(key)
-    @mutex.synchronize do
-      wref = @map[key]
-      @ids.delete(wref.id) if wref
-      @map.delete(key)
-    end
-  end
-  
-  #This method is supposed to remove objects when finalizer is called by ObjectSpace.
-  def delete_by_id(object_id)
-    @mutex.synchronize do
-      id = @ids[object_id]
-      @map.delete(id)
-      @ids.delete(object_id)
-    end
-  end
-  
-  #Iterates over every valid object in the weak map.
-  #===Examples
-  # map.each do |obj|
-  #   puts "Object alive: #{obj}"
-  # end
-  def each(&block)
-    enum = Enumerator.new do |yielder|
-      ids = nil
-      @mutex.synchronize do
-        ids = @map.keys
-      end
-      
-      ids.each do |id|
-        if obj = self.get!(id)
-          yielder << [id, obj]
-        end
-      end
-    end
-    
-    if block
-      enum.each(&block)
-    else
-      return enum
-    end
-  end
-  
-  #Make it hash-compatible.
-  alias has_key? key?
-  alias [] get
-  alias []= set
-end
-
-#This error is raised when an object in a wref has been garbage-collected.
-class Wref::Recycled < RuntimeError; end