rdf-threadsafe 0.3.1

data/README

@@ -0,0 +1,14 @@
+RDF/Threadsafe: An attempt to make RDF.rb work safely in JRuby Threads
+==============================
+
+RDF.rb makes extensive use of autoload, in fact it advertises that very fact.  This is great for almost everything you would want to use RDF.rb for, unless you happen to want to use it in a multithreaded JRuby environment (see: <http://jira.codehaus.org/browse/JRUBY-3194>).  RDF/Threadsafe is an attempt to undo autoload's mischief (at the expense of requiring all of RDF.rb to be loaded).
+
+Note, this should *only* matter for JRuby (and, possibly, Rubinius) and will be necessary until JRuby can get along with autoload (which, unfortunately, might be a while, if ever).  Ruby 1.9 now works with autoload.
+
+Changes from RDF.rb:
+
+* Overrides Method#autoload, which calls require for any autoload in the RDF module namespace (and defaults to regular autoload to anything outside).
+* Because of a problem with RDF::Util::Cache and frozen objects (namely the RDF Vocabulary object), there is a modified version of #define_finalizer! that adds exception handling.
+* All of the class methods in rdf.rb had to be included in threadsafe.rb because they are needed when the other files are required, but autoload fires before the methods are interpreted.  Because of this, RDF/Threadsafe will need to be pegged to specific versions of RDF.rb
+
+This should work for everything that falls under the RDF Module namespace (assuming there are no dependency errors based on the autoload order).

data/VERSION

@@ -0,0 +1 @@
+0.3.1

data/lib/rdf/threadsafe/module.rb

@@ -0,0 +1,23 @@
+class Module
+  ##
+  # Take Module#autoload, unbind it and rebind it as #regular_autoload
+  #
+  define_method(:regular_autoload, self.instance_method(:autoload).unbind)
+  
+  ##
+  # For any autoload call from a caller in the RDF module namespace, use require instead.
+  # All other callers use the normal autoload
+  #
+  def rdf_autoload(sym, path)
+    if self.name =~ /^RDF(\:\:|$)/
+      require path
+    else
+      regular_autoload(sym, path)
+    end
+  end
+  
+  ##
+  # Alias rdf_autoload to autoload
+  #
+  alias_method :autoload, :rdf_autoload
+end

data/lib/rdf/threadsafe/util/cache.rb

@@ -0,0 +1,15 @@
+module RDF; module Util
+  class Cache
+    ##
+    # @param  [Object] value
+    # @return [void]
+    def define_finalizer!(value)
+      # We need to catch when we try to pass a frozen object (namely the RDF vocabulary)
+      begin
+        ObjectSpace.define_finalizer(value, finalizer) 
+      rescue  TypeError
+        return
+      end
+    end
+  end
+end; end

data/lib/rdf/threadsafe.rb

@@ -0,0 +1,146 @@
+require File.dirname(__FILE__) + '/threadsafe/module'
+module RDF
+  ##
+  # Alias for `RDF::Resource.new`.
+  #
+  # @return [RDF::Resource]
+  def self.Resource(*args, &block)
+    Resource.new(*args, &block)
+  end
+  
+  ##
+  # Alias for `RDF::Node.new`.
+  #
+  # @return [RDF::Node]
+  def self.Node(*args, &block)
+    Node.new(*args, &block)
+  end
+  
+  ##
+  # Alias for `RDF::URI.new`.
+  #
+  # @overload URI(uri)
+  #   @param  [URI, String, #to_s]    uri
+  #
+  # @overload URI(options = {})
+  #   @param  [Hash{Symbol => Object} options
+  #
+  # @return [RDF::URI]
+  def self.URI(*args, &block)
+    case uri = args.first
+      when RDF::URI then uri
+      else case
+        when uri.respond_to?(:to_uri) then uri.to_uri
+        else URI.new(*args, &block)
+      end
+    end
+  end
+  
+  ##
+  # Alias for `RDF::Literal.new`.
+  #
+  # @return [RDF::Literal]
+  def self.Literal(*args, &block)
+    case literal = args.first
+      when RDF::Literal then literal
+      else Literal.new(*args, &block)
+    end
+  end
+  
+  ##
+  # Alias for `RDF::Graph.new`.
+  #
+  # @return [RDF::Graph]
+  def self.Graph(*args, &block)
+    Graph.new(*args, &block)
+  end
+  
+  ##
+  # Alias for `RDF::Statement.new`.
+  #
+  # @return [RDF::Statement]
+  def self.Statement(*args, &block)
+    Statement.new(*args, &block)
+  end
+  
+  ##
+  # Alias for `RDF::Vocabulary.create`.
+  #
+  # @param  [String] uri
+  # @return [Class]
+  def self.Vocabulary(uri)
+    Vocabulary.create(uri)
+  end
+  
+  ##
+  # @return [URI]
+  def self.type
+    self[:type]
+  end
+  
+  ##
+  # @return [#to_s] property
+  # @return [URI]
+  def self.[](property)
+    RDF::URI.intern([to_uri.to_s, property.to_s].join)
+  end
+  
+  ##
+  # @param  [Symbol] property
+  # @return [URI]
+  # @raise  [NoMethodError]
+  def self.method_missing(property, *args, &block)
+    if args.empty?
+      self[property]
+    else
+      super
+    end
+  end
+  
+  ##
+  # @return [URI]
+  def self.to_rdf
+    to_uri
+  end
+  
+  ##
+  # @return [URI]
+  def self.to_uri
+    RDF::URI.intern("http://www.w3.org/1999/02/22-rdf-syntax-ns#")
+  end
+  
+  class << self
+    # For compatibility with `RDF::Vocabulary.__name__`:
+    alias_method :__name__, :name
+  end
+  
+  # Load order matters, this needs to be tweaked if JRuby throws NameErrors.
+  
+  require 'rdf/util'
+  require 'rdf/util/cache'  
+  require 'rdf/mixin/readable'
+  require 'rdf/mixin/writable'  
+  require 'rdf/mixin/countable'    
+  require 'rdf/mixin/enumerable'  
+  require 'rdf/mixin/queryable'        
+  require 'rdf/mixin/mutable'    
+  require 'rdf/mixin/durable'  
+  require 'rdf/vocab.rb'
+  
+  require 'rdf/model/value'  
+  require 'rdf/model/term'  
+  require 'rdf/vocab/xsd'
+  require 'rdf/vocab/foaf'
+  require 'rdf/model/resource' 
+  require 'rdf/model/uri'
+  require 'rdf/model/literal/boolean'
+  require 'rdf/model/literal/numeric'  
+  require 'rdf/model/literal/decimal'    
+  require 'rdf/model/statement'
+  require 'rdf/repository'
+  require 'rdf/query'
+  require 'rdf/query/pattern'     
+end
+
+require 'rdf'
+require File.dirname(__FILE__) + '/threadsafe/util/cache'

metadata

@@ -0,0 +1,88 @@
+--- !ruby/object:Gem::Specification 
+name: rdf-threadsafe
+version: !ruby/object:Gem::Version 
+  hash: 17
+  prerelease: false
+  segments: 
+  - 0
+  - 3
+  - 1
+  version: 0.3.1
+platform: ruby
+authors: 
+- Ross Singer
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-02-08 00:00:00 -05:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rdf
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - "="
+      - !ruby/object:Gem::Version 
+        hash: 17
+        segments: 
+        - 0
+        - 3
+        - 1
+        version: 0.3.1
+  type: :runtime
+  version_requirements: *id001
+description: A hack to RDF.rb to override its autoloading feature to allow it to work in JRuby threads.
+email: rossfsinger@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- README
+- VERSION
+- lib/rdf/threadsafe/module.rb
+- lib/rdf/threadsafe/util/cache.rb
+- lib/rdf/threadsafe.rb
+has_rdoc: false
+homepage: http://github.com/rsinger/rdf-threadsafe
+licenses: 
+- Public Domain
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 53
+      segments: 
+      - 1
+      - 8
+      - 1
+      version: 1.8.1
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: A hack to RDF.rb to override its autoloading feature to allow it to work in JRuby threads.
+test_files: []
+