rdf 0.1.10 → 0.2.0

data/lib/rdf/util/cache.rb

@@ -0,0 +1,131 @@
+module RDF; module Util
+  ##
+  # A `Hash`-like cache that holds only weak references to the values it
+  # caches, meaning that values contained in the cache can be garbage
+  # collected. This allows the cache to dynamically adjust to changing
+  # memory conditions, caching more objects when memory is plentiful, but
+  # evicting most objects if memory pressure increases to the point of
+  # scarcity.
+  #
+  # @see   RDF::URI.intern
+  # @see   http://en.wikipedia.org/wiki/Weak_reference
+  # @since 0.2.0
+  class Cache
+    ##
+    # @private
+    def self.new(*args)
+      # JRuby doesn't support `ObjectSpace#_id2ref` unless the `-X+O`
+      # startup option is given, so on that platform we'll default to using
+      # the WeakRef-based cache:
+      klass = case RUBY_PLATFORM
+        when /java/ then WeakRefCache
+        else ObjectSpaceCache
+      end
+      cache = klass.allocate
+      cache.send(:initialize, *args)
+      cache
+    end
+
+    ##
+    # @param  [Integer] capacity
+    def initialize(capacity = -1)
+      @capacity = capacity
+      @cache  ||= {}
+      @index  ||= {}
+    end
+
+    ##
+    # @return [Integer]
+    def size
+      @cache.size
+    end
+
+    ##
+    # @return [Boolean]
+    def has_capacity?
+      @capacity == -1 || @capacity > @cache.size
+    end
+
+    ##
+    # @param  [Object] value
+    # @return [void]
+    def define_finalizer!(value)
+      ObjectSpace.define_finalizer(value, finalizer)
+    end
+
+    ##
+    # @return [Proc]
+    def finalizer
+      lambda { |object_id| @cache.delete(@index.delete(object_id)) }
+    end
+
+    ##
+    # This implementation relies on `ObjectSpace#_id2ref` and performs
+    # optimally on Ruby 1.8.x and 1.9.x; however, it does not work on JRuby
+    # by default since much `ObjectSpace` functionality on that platform is
+    # disabled unless the `-X+O` startup option is given.
+    #
+    # @see http://ruby-doc.org/ruby-1.9/classes/ObjectSpace.html
+    # @see http://eigenclass.org/hiki/weakhash+and+weakref
+    class ObjectSpaceCache < Cache
+      ##
+      # @param  [Object] key
+      # @return [Object]
+      def [](key)
+        if value_id = @cache[key]
+          value = ObjectSpace._id2ref(value_id)
+        end
+      end
+
+      ##
+      # @param  [Object] key
+      # @param  [Object] value
+      # @return [Object]
+      def []=(key, value)
+        if has_capacity?
+          @cache[key] = value.object_id
+          @index[value.object_id] = key
+          define_finalizer!(value)
+        end
+        value
+      end
+    end # class ObjectSpaceCache
+
+    ##
+    # This implementation uses the `WeakRef` class from Ruby's standard
+    # library, and provides adequate performance on JRuby and on Ruby 1.9.x;
+    # however, it performs very suboptimally on Ruby 1.8.x.
+    #
+    # @see http://ruby-doc.org/ruby-1.9/classes/WeakRef.html
+    class WeakRefCache < Cache
+      ##
+      # @param  [Integer] capacity
+      def initialize(capacity = -1)
+        require 'weakref' unless defined?(::WeakRef)
+        super
+      end
+
+      ##
+      # @param  [Object] key
+      # @return [Object]
+      def [](key)
+        if (ref = @cache[key]) && ref.weakref_alive?
+          value = ref.__getobj__
+        end
+      end
+
+      ##
+      # @param  [Object] key
+      # @param  [Object] value
+      # @return [Object]
+      def []=(key, value)
+        if has_capacity?
+          @cache[key] = WeakRef.new(value)
+          @index[value.object_id] = key
+          define_finalizer!(value)
+        end
+        value
+      end
+    end # class WeakRefCache
+  end # class Cache
+end; end # module RDF::Util

data/lib/rdf/version.rb

@@ -1,12 +1,11 @@
 module RDF
   module VERSION
     MAJOR = 0
-    MINOR = 1
-    TINY  = 10
+    MINOR = 2
+    TINY  = 0
     EXTRA = nil
 
-    STRING = [MAJOR, MINOR, TINY].join('.')
-    STRING << ".#{EXTRA}" if EXTRA
+    STRING = [MAJOR, MINOR, TINY, EXTRA].compact.join('.')
 
     ##
     # @return [String]

data/lib/rdf/vocab.rb

@@ -7,14 +7,17 @@ module RDF
   # The following vocabularies are pre-defined for your convenience:
   #
   # * {RDF::CC}    - Creative Commons (CC)
+  # * {RDF::CERT}  - W3 Authentication Certificate (CERT)
   # * {RDF::DC}    - Dublin Core (DC)
   # * {RDF::DC11}  - Dublin Core 1.1 (DC11) _deprecated_
   # * {RDF::DOAP}  - Description of a Project (DOAP)
   # * {RDF::EXIF}  - Exchangeable Image File Format (EXIF)
   # * {RDF::FOAF}  - Friend of a Friend (FOAF)
+  # * {RDF::GEO}   - WGS84 Geo Positioning (GEO)
   # * {RDF::HTTP}  - Hypertext Transfer Protocol (HTTP)
   # * {RDF::OWL}   - Web Ontology Language (OWL)
   # * {RDF::RDFS}  - RDF Schema (RDFS)
+  # * {RDF::RSA}   - W3 RSA Keys (RSA)
   # * {RDF::RSS}   - RDF Site Summary (RSS)
   # * {RDF::SIOC}  - Semantically-Interlinked Online Communities (SIOC)
   # * {RDF::SKOS}  - Simple Knowledge Organization System (SKOS)
@@ -52,11 +55,9 @@ module RDF
     def self.each(&block)
       if self.equal?(Vocabulary)
         # This is needed since all vocabulary classes are defined using
-        # Ruby's autoloading facility, meaning that `@@subclasses` will
-        # be empty until each subclass has been touched or require'd.
-        %w(cc dc dc11 doap exif foaf http owl rdfs rss sioc skos wot xhtml xsd).each do |prefix|
-          require "rdf/vocab/#{prefix}"
-        end
+        # Ruby's autoloading facility, meaning that `@@subclasses` will be
+        # empty until each subclass has been touched or require'd.
+        RDF::VOCABS.each { |v| require "rdf/vocab/#{v}" unless v == :rdf }
         @@subclasses.each(&block)
       else
         # TODO: should enumerate vocabulary-specific defined properties.
@@ -79,7 +80,7 @@ module RDF
     # @param  [#to_s] property
     # @return [URI]
     def self.[](property)
-      RDF::URI.new([to_s, property.to_s].join(''))
+      RDF::URI.intern([to_s, property.to_s].join(''))
     end
 
     ##
@@ -87,7 +88,7 @@ module RDF
     #
     # @return [URI]
     def self.to_uri
-      RDF::URI.new(to_s)
+      RDF::URI.intern(to_s)
     end
 
     ##
@@ -117,7 +118,7 @@ module RDF
     end
 
     # Undefine all superfluous instance methods:
-    undef_method *(instance_methods.map { |s| s.to_sym } - [:__id__, :__send__, :__class__, :__eval__, :object_id, :instance_eval, :inspect, :class, :is_a?])
+    undef_method(*(instance_methods.map(&:to_sym) - [:__id__, :__send__, :__class__, :__eval__, :object_id, :instance_eval, :inspect, :class, :is_a?]))
 
     ##
     # @param  [URI, String, #to_s]
@@ -134,7 +135,7 @@ module RDF
     # @param  [#to_s] property
     # @return [URI]
     def [](property)
-      RDF::URI.new([to_s, property.to_s].join(''))
+      RDF::URI.intern([to_s, property.to_s].join(''))
     end
 
     ##
@@ -142,7 +143,7 @@ module RDF
     #
     # @return [URI]
     def to_uri
-      RDF::URI.new(to_s)
+      RDF::URI.intern(to_s)
     end
 
     ##

data/lib/rdf/vocab/cert.rb

@@ -0,0 +1,13 @@
+module RDF
+  ##
+  # W3 Authentication Certificates (CERT) vocabulary.
+  #
+  # @see   http://www.w3.org/ns/auth/cert#
+  # @since 0.2.0
+  class CERT < Vocabulary("http://www.w3.org/ns/auth/cert#")
+    property :decimal
+    property :hex
+    property :identity
+    property :public_key
+  end
+end

data/lib/rdf/vocab/geo.rb

@@ -0,0 +1,13 @@
+module RDF
+  ##
+  # WGS84 Geo Positioning (GEO) vocabulary.
+  #
+  # @see   http://www.w3.org/2003/01/geo/wgs84_pos#
+  # @since 0.2.0
+  class GEO < Vocabulary("http://www.w3.org/2003/01/geo/wgs84_pos#")
+    property :lat
+    property :location
+    property :long
+    property :lat_long
+  end
+end

data/lib/rdf/vocab/rsa.rb

@@ -0,0 +1,12 @@
+module RDF
+  ##
+  # W3 RSA Keys (RSA) vocabulary.
+  #
+  # @see   http://www.w3.org/ns/auth/rsa#
+  # @since 0.2.0
+  class RSA < Vocabulary("http://www.w3.org/ns/auth/rsa#")
+    property :modulus
+    property :private_exponent
+    property :public_exponent
+  end
+end

data/lib/rdf/writer.rb

@@ -34,7 +34,7 @@ module RDF
   # @see RDF::Reader
   class Writer
     extend  ::Enumerable
-    include ::Enumerable
+    include RDF::Writable
 
     ##
     # Enumerates known RDF writer classes.
@@ -96,24 +96,34 @@ module RDF
       alias_method :format_class, :format
     end
 
+    ##
+    # @param  [Object]                 data
+    # @param  [IO, File]               io
+    # @param  [Hash{Symbol => Object}] options
+    # @return [void]
     def self.dump(data, io = nil, options = {})
       io = File.open(io, 'w') if io.is_a?(String)
+      method = data.respond_to?(:each_statement) ? :each_statement : :each
       if io
         new(io) do |writer|
-          data.each_statement do |statement|
+          data.send(method) do |statement|
             writer << statement
           end
           writer.flush
         end
       else
         buffer do |writer|
-          data.each_statement do |statement|
+          data.send(method) do |statement|
             writer << statement
           end
         end
       end
     end
 
+    ##
+    # @yield  [writer]
+    # @yieldparam [Writer] writer
+    # @return [String]
     def self.buffer(*args, &block)
       require 'stringio' unless defined?(StringIO)
 
@@ -123,6 +133,10 @@ module RDF
       end
     end
 
+    ##
+    # @param  [String]                 filename
+    # @param  [Hash{Symbol => Object}] options
+    # @return [Writer]
     def self.open(filename, options = {}, &block)
       File.open(filename, 'wb') do |file|
         self.for(options[:format] || filename).new(file, options, &block)
@@ -135,16 +149,29 @@ module RDF
     # @yield  [writer]
     # @yieldparam [RDF::Writer] writer
     def initialize(output = $stdout, options = {}, &block)
-      @output, @options = output, options
-      @nodes, @node_id = {}, 0
+      @output, @options = output, options.dup
+      @nodes, @node_id  = {}, 0
 
       if block_given?
         write_prologue
-        block.call(self)
+        case block.arity
+          when 1 then block.call(self)
+          else instance_eval(&block)
+        end
         write_epilogue
       end
     end
 
+    ##
+    # Flushes the underlying output buffer.
+    #
+    # @return [void]
+    def flush
+      @output.flush if @output.respond_to?(:flush)
+    end
+
+    alias_method :flush!, :flush
+
     ##
     # @return [void]
     # @abstract
@@ -156,84 +183,57 @@ module RDF
     def write_epilogue() end
 
     ##
+    # @param  [String] text
     # @return [void]
     # @abstract
     def write_comment(text) end
 
     ##
-    # @raise [ArgumentError]
-    def <<(data)
-      case data # TODO
-        #when Graph
-        #  write_graph(data)
-        #when Resource
-        #  #register!(resource) && write_node(resource)
-        #  write_resource(data)
-        when Statement
-          write_statement(data)
-        else
-          if data.respond_to?(:to_a)
-            write_triple(*data.to_a)
-          else
-            raise ArgumentError.new("expected RDF::Statement or RDF::Resource, got #{data.inspect}")
-          end
-      end
-    end
-
-    ##
-    # @param  [Graph] graph
+    # @param  [RDF::Graph] graph
     # @return [void]
     def write_graph(graph)
-      write_triples(*graph.triples)
+      graph.each_triple { |*triple| write_triple(*triple) }
     end
 
     ##
-    # @return [void]
-    def write_resource(subject) # FIXME
-      edge_nodes = []
-      subject.each do |predicate, objects|
-        [objects].flatten.each do |object|
-          edge_nodes << object if register!(object)
-          write_triple subject, predicate, object
-        end
-      end
-      edge_nodes.each { |node| write_resource node }
-    end
-
-    ##
-    # @param  [Array<Statement>] statements
+    # @param  [Array<RDF::Statement>] statements
     # @return [void]
     def write_statements(*statements)
-      statements.flatten.each { |stmt| write_statement(stmt) }
+      statements.flatten.each { |statement| write_statement(statement) }
     end
 
     ##
-    # @param  [Statement] statement
+    # @param  [RDF::Statement] statement
     # @return [void]
     def write_statement(statement)
-      write_triple(*statement.to_a)
+      write_triple(*statement.to_triple)
     end
 
     ##
-    # @param  [Array<Array(Value)>] triples
+    # @param  [Array<Array(RDF::Resource, RDF::URI, RDF::Value)>] triples
     # @return [void]
     def write_triples(*triples)
       triples.each { |triple| write_triple(*triple) }
     end
 
     ##
-    # @param  [Resource] subject
-    # @param  [URI]      predicate
-    # @param  [Value]    object
+    # @param  [RDF::Resource] subject
+    # @param  [RDF::URI]      predicate
+    # @param  [RDF::Value]    object
     # @return [void]
     # @raise  [NotImplementedError] unless implemented in subclass
     # @abstract
     def write_triple(subject, predicate, object)
-      raise NotImplementedError # override in subclasses
+      raise NotImplementedError.new("#{self.class}#write_triple") # override in subclasses
     end
 
+    # Support the RDF::Writable interface:
+    alias_method :insert_graph,      :write_graph
+    alias_method :insert_statements, :write_statements
+    alias_method :insert_statement,  :write_statement
+
     ##
-    # @param  [Value] value
+    # @param  [RDF::Value] value
     # @return [String]
     def format_value(value, options = {})
       case value
@@ -252,7 +252,7 @@ module RDF
     # @raise  [NotImplementedError] unless implemented in subclass
     # @abstract
     def format_uri(value, options = {})
-      raise NotImplementedError # override in subclasses
+      raise NotImplementedError.new("#{self.class}#format_uri") # override in subclasses
     end
 
     ##
@@ -262,7 +262,7 @@ module RDF
     # @raise  [NotImplementedError] unless implemented in subclass
     # @abstract
     def format_node(value, options = {})
-      raise NotImplementedError # override in subclasses
+      raise NotImplementedError.new("#{self.class}#format_node") # override in subclasses
     end
 
     ##
@@ -272,78 +272,71 @@ module RDF
     # @raise  [NotImplementedError] unless implemented in subclass
     # @abstract
     def format_literal(value, options = {})
-      raise NotImplementedError # override in subclasses
+      raise NotImplementedError.new("#{self.class}#format_literal") # override in subclasses
     end
 
+  protected
+
     ##
-    # Flushes the underlying output buffer.
-    #
     # @return [void]
-    def flush
-      @output.flush if @output.respond_to?(:flush)
+    def puts(*args)
+      @output.puts(*args)
     end
 
-    alias_method :flush!, :flush
-
-    protected
-
-      def puts(*args)
-        @output.puts(*args)
-      end
-
-      ##
-      # @param  [Resource] uriref
-      # @return [String]
-      def uri_for(uriref)
-        case
-          when uriref.is_a?(RDF::Node)
-            @nodes[uriref]
-          when uriref.respond_to?(:to_uri)
-            uriref.to_uri.to_s
-          else
-            uriref.to_s
-        end
+    ##
+    # @param  [RDF::Resource] uriref
+    # @return [String]
+    def uri_for(uriref)
+      case
+        when uriref.is_a?(RDF::Node)
+          @nodes[uriref]
+        when uriref.respond_to?(:to_uri)
+          uriref.to_uri.to_s
+        else
+          uriref.to_s
       end
+    end
 
-      ##
-      # @return [String]
-      def node_id
-        "_:n#{@node_id += 1}"
-      end
+    ##
+    # @return [String]
+    def node_id
+      "_:n#{@node_id += 1}"
+    end
 
-      def register!(resource)
-        if resource.kind_of?(RDF::Resource)
-          unless @nodes[resource] # have we already seen it?
-            @nodes[resource] = resource.uri || node_id
-          end
+    ##
+    # @deprecated
+    def register!(resource)
+      if resource.kind_of?(RDF::Resource)
+        unless @nodes[resource] # have we already seen it?
+          @nodes[resource] = resource.uri || node_id
         end
       end
+    end
 
-      ##
-      # @param  [String] string
-      # @return [String]
-      def escaped(string)
-        string.gsub('\\', '\\\\').gsub("\t", '\\t').
-          gsub("\n", '\\n').gsub("\r", '\\r').gsub('"', '\\"')
-      end
-
-      ##
-      # @param  [String] string
-      # @return [String]
-      def quoted(string)
-        "\"#{string}\""
-      end
+    ##
+    # @param  [String] string
+    # @return [String]
+    def escaped(string)
+      string.gsub('\\', '\\\\').gsub("\t", '\\t').
+        gsub("\n", '\\n').gsub("\r", '\\r').gsub('"', '\\"')
+    end
 
-    private
+    ##
+    # @param  [String] string
+    # @return [String]
+    def quoted(string)
+      "\"#{string}\""
+    end
 
-      @@subclasses = [] # @private
+  private
 
-      def self.inherited(child) # @private
-        @@subclasses << child
-        super
-      end
+    @@subclasses = [] # @private
 
-  end
+    def self.inherited(child) # @private
+      @@subclasses << child
+      super
+    end
+  end # class Writer
 
   class WriterError < IOError; end
 end