rdf 0.1.10 → 0.2.0

data/lib/rdf/model/resource.rb

@@ -1,22 +1,19 @@
 module RDF
   ##
   # An RDF resource.
-  #
-  # @abstract
-  class Resource < Value
+  module Resource
+    include RDF::Value
+
     ##
     # Instantiates an {RDF::Node} or an {RDF::URI}, depending on the given
     # argument.
     #
     # @return [RDF::Resource]
     def self.new(*args, &block)
-      if self == Resource
-        case arg = args.shift
-          when /^_:(.*)$/ then Node.new($1, *args, &block)
-          else URI.new(arg, *args, &block)
-        end
-      else
-        super
+      case arg = args.shift
+        when Symbol     then Node.intern(arg, *args, &block)
+        when /^_:(.*)$/ then Node.new($1, *args, &block)
+        else URI.new(arg, *args, &block)
       end
     end
 

data/lib/rdf/model/statement.rb

@@ -18,56 +18,67 @@ module RDF
   #     :object    => RDF::URI.new("http://ar.to/#self"),
   #   })
   #
-  class Statement < Value
+  class Statement
+    include RDF::Value
+
     # @return [Object]
     attr_accessor :id
 
-    # @return [Resource]
+    # @return [RDF::Resource]
     attr_accessor :context
 
-    # @return [Resource]
+    # @return [RDF::Resource]
     attr_accessor :subject
 
-    # @return [URI]
+    # @return [RDF::URI]
     attr_accessor :predicate
 
-    # @return [Value]
+    # @return [RDF::Value]
     attr_accessor :object
 
     ##
     # @overload initialize(options = {})
     #   @param  [Hash{Symbol => Object}] options
-    #   @option options [Resource]       :subject   (nil)
-    #   @option options [URI]            :predicate (nil)
-    #   @option options [Value]          :object    (nil)
-    #   @option options [Resource]       :context   (nil)
+    #   @option options [RDF::Resource]  :subject   (nil)
+    #   @option options [RDF::URI]       :predicate (nil)
+    #   @option options [RDF::Value]     :object    (nil)
+    #   @option options [RDF::Resource]  :context   (nil)
     #
     # @overload initialize(subject, predicate, object, options = {})
-    #   @param  [Resource]               subject
-    #   @param  [URI]                    predicate
-    #   @param  [Value]                  object
+    #   @param  [RDF::Resource]          subject
+    #   @param  [RDF::URI]               predicate
+    #   @param  [RDF::Value]             object
     #   @param  [Hash{Symbol => Object}] options
-    #   @option options [Resource]       :context   (nil)
+    #   @option options [RDF::Resource]  :context   (nil)
     def initialize(subject = nil, predicate = nil, object = nil, options = {})
-      options = options.dup unless options.empty?
       case subject
         when Hash
-          options    = subject.dup
-          subject    = options.delete(:subject)
-          predicate  = options.delete(:predicate)
-          object     = options.delete(:object)
-          initialize(subject, predicate, object, options)
+          @options   = subject.dup
+          @subject   = @options.delete(:subject)
+          @predicate = @options.delete(:predicate)
+          @object    = @options.delete(:object)
         else
-          @id        = options.delete(:id) if options.has_key?(:id)
-          @context   = options.delete(:context) || options.delete(:graph)
-          @options   = options
+          @options   = !options.empty? ? options.dup : {}
           @subject   = subject
           @predicate = predicate
-          @object    = case object
-            when nil        then nil
-            when RDF::Value then object
-            else RDF::Literal.new(object)
-          end
+          @object    = object
+      end
+      @id      = @options.delete(:id) if @options.has_key?(:id)
+      @context = @options.delete(:context) || @options.delete(:graph)
+      initialize!
+    end
+
+    ##
+    # @private
+    def initialize!
+      @context   = Node.intern(@context)   if @context.is_a?(Symbol)
+      @subject   = Node.intern(@subject)   if @subject.is_a?(Symbol)
+      @predicate = Node.intern(@predicate) if @predicate.is_a?(Symbol)
+      @object    = case @object
+        when nil    then nil
+        when Symbol then Node.intern(@object)
+        when Value  then @object
+        else Literal.new(@object)
       end
     end
 
@@ -167,32 +178,39 @@ module RDF
 
     ##
     # @param  [Integer] index
-    # @return [Value]
+    # @return [RDF::Value]
     def [](index)
-      to_a[index]
+      case index
+        when 0 then self.subject
+        when 1 then self.predicate
+        when 2 then self.object
+        when 3 then self.context
+        else nil
+      end
     end
 
     ##
-    # @param  [Integer] index
-    # @param  [Value]   value
-    # @return [Value]
+    # @param  [Integer]    index
+    # @param  [RDF::Value] value
+    # @return [RDF::Value]
     def []=(index, value)
       case index
-        when 0 then subject   = value
-        when 1 then predicate = value
-        when 2 then object    = value
-        when 3 then context   = value
+        when 0 then self.subject   = value
+        when 1 then self.predicate = value
+        when 2 then self.object    = value
+        when 3 then self.context   = value
+        else nil
       end
     end
 
     ##
-    # @return [Array(Value)]
+    # @return [Array(RDF::Value)]
     def to_quad
       [subject, predicate, object, context]
     end
 
     ##
-    # @return [Array(Value)]
+    # @return [Array(RDF::Value)]
     def to_triple
       [subject, predicate, object]
     end
@@ -206,9 +224,9 @@ module RDF
     # @param  [Symbol] subject_key
     # @param  [Symbol] predicate_key
     # @param  [Symbol] object_key
-    # @return [Hash{Symbol => Value}]
-    def to_hash(subject_key = :subject, predicate_key = :predicate, object_key = :object)
-      {subject_key => subject, predicate_key => predicate, object_key => object}
+    # @return [Hash{Symbol => RDF::Value}]
+    def to_hash(subject_key = :subject, predicate_key = :predicate, object_key = :object, context_key = :context)
+      {subject_key => subject, predicate_key => predicate, object_key => object, context_key => context}
     end
 
     ##

data/lib/rdf/model/uri.rb

@@ -12,22 +12,61 @@ module RDF
   # @example Creating a URI reference (2)
   #   uri = RDF::URI.new(:scheme => 'http', :host => 'rdf.rubyforge.org', :path => '/')
   #
+  # @example Creating an interned URI reference
+  #   uri = RDF::URI.intern("http://rdf.rubyforge.org/")
+  #
   # @example Getting the string representation of a URI
   #   uri.to_s #=> "http://rdf.rubyforge.org/"
   #
   # @see http://en.wikipedia.org/wiki/Uniform_Resource_Identifier
   # @see http://addressable.rubyforge.org/
-  class URI < Resource
+  class URI
+    include RDF::Resource
+
+    ##
+    # Defines the maximum number of interned URI references that can be held
+    # cached in memory at any one time.
+    CACHE_SIZE = -1 # unlimited by default
+
+    ##
+    # @return [RDF::Util::Cache]
+    # @private
+    def self.cache
+      require 'rdf/util/cache' unless defined?(::RDF::Util::Cache)
+      @cache ||= RDF::Util::Cache.new(CACHE_SIZE)
+    end
+
+    ##
+    # Returns an interned `RDF::URI` instance based on the given `uri`
+    # string.
+    #
+    # The maximum number of cached interned URI references is given by the
+    # `CACHE_SIZE` constant. This value is unlimited by default, in which
+    # case an interned URI object will be purged only when the last strong
+    # reference to it is garbage collection (i.e., when its finalizer runs).
+    #
+    # Excepting special memory-limited circumstances, it should always be
+    # safe and preferred to construct new URI references using
+    # `RDF::URI.intern` instead of `RDF::URI.new`, since if an interned
+    # object can't be returned for some reason, this method will fall back
+    # to returning a freshly-allocated one.
+    #
+    # @param  [String, #to_s] str
+    # @return [RDF::URI]
+    def self.intern(str)
+      cache[str = str.to_s] ||= self.new(str)
+    end
+
     ##
     # Creates a new `RDF::URI` instance based on the given `uri` string.
     #
     # This is just an alias for {#initialize RDF::URI.new} for compatibity
     # with `Addressable::URI.parse`.
     #
-    # @param  [String] uri
-    # @return [URI]
-    def self.parse(uri)
-      self.new(uri)
+    # @param  [String, #to_s] str
+    # @return [RDF::URI]
+    def self.parse(str)
+      self.new(str)
     end
 
     ##
@@ -47,20 +86,41 @@ module RDF
       end
     end
 
+    ##
+    # Returns `false`.
+    #
+    # @return [Boolean]
+    def anonymous?
+      false
+    end
+
     ##
     # Returns `true`.
     #
     # @return [Boolean]
+    # @see    http://en.wikipedia.org/wiki/Uniform_Resource_Identifier
     def uri?
       true
     end
 
     ##
-    # Returns `false`.
+    # Returns `true` if this URI is a URN.
     #
     # @return [Boolean]
-    def anonymous?
-      false
+    # @see    http://en.wikipedia.org/wiki/Uniform_Resource_Name
+    # @since  0.2.0
+    def urn?
+      to_s.index('urn:') == 0
+    end
+
+    ##
+    # Returns `true` if this URI is a URL.
+    #
+    # @return [Boolean]
+    # @see    http://en.wikipedia.org/wiki/Uniform_Resource_Locator
+    # @since  0.2.0
+    def url?
+      !urn?
     end
 
     ##

data/lib/rdf/model/value.rb

@@ -2,9 +2,9 @@ module RDF
   ##
   # An RDF value.
   #
-  # This is the base class for the RDF.rb class hierarchy. The class of
-  # every object that can be a term of {RDF::Statement statements} is a
-  # subclass of this class.
+  # This is the basis for the RDF.rb class hierarchy. Anything that can be a
+  # term of {RDF::Statement RDF statements} should directly or indirectly
+  # include this module.
   #
   # @example Checking if a value is a resource (blank node or URI reference)
   #   value.resource?
@@ -19,18 +19,17 @@ module RDF
   # @example Checking if a value is a literal
   #   value.literal?
   #
-  # @abstract
   # @see RDF::Graph
   # @see RDF::Literal
   # @see RDF::Node
   # @see RDF::Resource
   # @see RDF::Statement
   # @see RDF::URI
-  class Value
+  module Value
     include Comparable
 
     ##
-    # Returns `true` if this value is a graph.
+    # Returns `true` if `self` is a graph.
     #
     # @return [Boolean]
     def graph?
@@ -38,7 +37,7 @@ module RDF
     end
 
     ##
-    # Returns `true` if this value is a literal.
+    # Returns `true` if `self` is a literal.
     #
     # @return [Boolean]
     def literal?
@@ -46,7 +45,7 @@ module RDF
     end
 
     ##
-    # Returns `true` if this value is a blank node.
+    # Returns `true` if `self` is a blank node.
     #
     # @return [Boolean]
     def node?
@@ -54,7 +53,7 @@ module RDF
     end
 
     ##
-    # Returns `true` if this value is a resource.
+    # Returns `true` if `self` is a resource.
     #
     # @return [Boolean]
     def resource?
@@ -62,7 +61,7 @@ module RDF
     end
 
     ##
-    # Returns `true` if this value is a statement.
+    # Returns `true` if `self` is a statement.
     #
     # @return [Boolean]
     def statement?
@@ -70,17 +69,25 @@ module RDF
     end
 
     ##
-    # Returns `true` if this value is a URI reference.
+    # Returns `true` if `self` is an IRI reference.
+    #
+    # By default this is simply an alias for {#uri?}.
+    #
+    # @return [Boolean]
+    def iri?
+      uri?
+    end
+
+    ##
+    # Returns `true` if `self` is a URI reference.
     #
     # @return [Boolean]
     def uri?
       false
     end
 
-    alias_method :iri?, :uri?
-
     ##
-    # Returns `true` if this value is a query variable.
+    # Returns `true` if `self` is a query variable.
     #
     # @return [Boolean]
     # @since  0.1.7
@@ -89,7 +96,7 @@ module RDF
     end
 
     ##
-    # Compares this value to `other` for sorting purposes.
+    # Compares `self` to `other` for sorting purposes.
     #
     # Subclasses should override this to provide a more meaningful
     # implementation than the default which simply performs a string
@@ -103,15 +110,15 @@ module RDF
     end
 
     ##
-    # Returns an RDF::Value representation of this object.
+    # Returns an `RDF::Value` representation of `self`.
     #
-    # @return [Value]
+    # @return [RDF::Value]
     def to_rdf
       self
     end
 
     ##
-    # Returns a developer-friendly representation of this value.
+    # Returns a developer-friendly representation of `self`.
     #
     # The result will be of the format `#<RDF::Value::0x12345678(...)>`,
     # where `...` is the string returned by `#to_s`.
@@ -122,23 +129,11 @@ module RDF
     end
 
     ##
-    # Outputs a developer-friendly representation of this value to `stderr`.
+    # Outputs a developer-friendly representation of `self` to `stderr`.
     #
     # @return [void]
     def inspect!
       warn(inspect)
     end
-
-    private
-
-      # Prevent the instantiation of this class:
-      private_class_method :new
-
-      def self.inherited(child) # @private
-        # Enable the instantiation of any subclasses:
-        child.send(:public_class_method, :new)
-        super
-      end
-
   end
 end

data/lib/rdf/ntriples/reader.rb

@@ -75,7 +75,7 @@ module RDF::NTriples
     # @param  [String] input
     # @return [RDF::URI]
     def self.parse_predicate(input)
-      parse_uri(input)
+      parse_uri(input, :intern => true)
     end
 
     ##
@@ -97,9 +97,9 @@ module RDF::NTriples
     ##
     # @param  [String] input
     # @return [RDF::URI]
-    def self.parse_uri(input)
+    def self.parse_uri(input, options = {})
       if input =~ URIREF
-        RDF::URI.new($1)
+        RDF::URI.send(options[:intern] ? :intern : :new, $1)
       end
     end
 
@@ -122,6 +122,7 @@ module RDF::NTriples
     # @return [String]
     # @see    http://www.w3.org/TR/rdf-testcases/#ntrip_strings
     # @see    http://blog.grayproductions.net/articles/understanding_m17n
+    # @see    http://yehudakatz.com/2010/05/17/encodings-unabridged/
     def self.unescape(string)
       string.force_encoding(Encoding::ASCII_8BIT) if string.respond_to?(:force_encoding)
 
@@ -174,7 +175,7 @@ module RDF::NTriples
         begin
           unless blank? || read_comment
             subject   = read_uriref || read_node || fail_subject
-            predicate = read_uriref || fail_predicate
+            predicate = read_uriref(:intern => true) || fail_predicate
             object    = read_uriref || read_node || read_literal || fail_object
             return [subject, predicate, object]
           end
@@ -195,9 +196,9 @@ module RDF::NTriples
     ##
     # @return [RDF::URI]
     # @see    http://www.w3.org/TR/rdf-testcases/#ntrip_grammar (uriref)
-    def read_uriref
+    def read_uriref(options = {})
       if uri = match(URIREF)
-        RDF::URI.new(uri)
+        RDF::URI.send(options[:intern] ? :intern : :new, uri)
       end
     end