rdf 0.2.0.1 → 0.2.1

data/CONTRIBUTORS

@@ -1,3 +1,4 @@
+* Gregg Kellogg <gregg@kellogg-assoc.com>
 * Hellekin O. Wolf <hellekin@cepheide.org>
 * John Fieber <jrf@ursamaris.org>
 * Pius Uzamere <pius@alum.mit.edu>

data/README

@@ -189,6 +189,7 @@ Authors
 Contributors
 ------------
 
+* [Gregg Kellogg](mailto:gregg@kellogg-assoc.com) - <http://kellogg-assoc.com/>
 * [Hellekin O. Wolf](mailto:hellekin@cepheide.org) - <http://hellekin.cepheide.org/>
 * [John Fieber](mailto:jrf@ursamaris.org) - <http://github.com/jfieber>
 * [Pius Uzamere](mailto:pius@alum.mit.edu) - <http://pius.me/>

data/VERSION

@@ -1 +1 @@
-0.2.0.1
+0.2.1

data/lib/rdf.rb

@@ -1,5 +1,8 @@
 require 'enumerator'
 require 'open-uri'
+require 'bigdecimal'
+require 'date'
+require 'time'
 
 if RUBY_VERSION < '1.8.7'
   # @see http://rubygems.org/gems/backports
@@ -92,7 +95,13 @@ module RDF
   #
   # @return [RDF::URI]
   def self.URI(*args, &block)
-    URI.new(*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
 
   ##

data/lib/rdf/model/literal.rb

@@ -39,10 +39,67 @@ module RDF
   # @see http://www.w3.org/TR/rdf-concepts/#section-Literals
   # @see http://www.w3.org/TR/rdf-concepts/#section-Datatypes-intro
   class Literal
+    autoload :Boolean,  'rdf/model/literal/boolean'
+    autoload :Integer,  'rdf/model/literal/integer'
+    autoload :Double,   'rdf/model/literal/double'
+    autoload :Decimal,  'rdf/model/literal/decimal'
+    autoload :Date,     'rdf/model/literal/date'
+    autoload :DateTime, 'rdf/model/literal/datetime'
+    autoload :Time,     'rdf/model/literal/time'
+    autoload :XML,      'rdf/model/literal/xml'
+
     include RDF::Value
 
-    # @return [String] The normalized string representation of the value.
-    attr_accessor :value
+    ##
+    # @private
+    def self.new(value, options = {})
+      klass = case
+        when !self.equal?(RDF::Literal)
+          self # subclasses can be directly constructed without type dispatch
+        when datatype = options[:datatype]
+          case RDF::URI(datatype)
+            when XSD.boolean
+              RDF::Literal::Boolean
+            when XSD.integer, XSD.long, XSD.int, XSD.short, XSD.byte
+              RDF::Literal::Integer
+            when XSD.double, XSD.float
+              RDF::Literal::Double
+            when XSD.decimal
+              RDF::Literal::Decimal
+            when XSD.date
+              RDF::Literal::Date
+            when XSD.dateTime
+              RDF::Literal::DateTime
+            when XSD.time
+              RDF::Literal::Time
+            when XSD.nonPositiveInteger, XSD.negativeInteger
+              RDF::Literal::Integer
+            when XSD.nonNegativeInteger, XSD.positiveInteger
+              RDF::Literal::Integer
+            when XSD.unsignedLong, XSD.unsignedInt, XSD.unsignedShort, XSD.unsignedByte
+              RDF::Literal::Integer
+            when RDF.XMLLiteral
+              RDF::Literal::XML
+            else self
+          end
+        else case value
+          when ::TrueClass  then RDF::Literal::Boolean
+          when ::FalseClass then RDF::Literal::Boolean
+          when ::Integer    then RDF::Literal::Integer
+          when ::Float      then RDF::Literal::Double
+          when ::BigDecimal then RDF::Literal::Decimal
+          when ::DateTime   then RDF::Literal::DateTime
+          when ::Date       then RDF::Literal::Date
+          when ::Time       then RDF::Literal::Time
+          else self
+        end
+      end
+      literal = klass.allocate
+      literal.send(:initialize, value, options)
+      literal.validate if options[:validate]
+      literal.canonicalize if options[:canonicalize]
+      literal
+    end
 
     # @return [Symbol] The language tag (optional).
     attr_accessor :language
@@ -51,77 +108,44 @@ module RDF
     attr_accessor :datatype
 
     ##
-    # @param  [Object]
+    # @param  [Object] value
     # @option options [Symbol] :language (nil)
     # @option options [URI]    :datatype (nil)
     def initialize(value, options = {})
-      @value = value
-      @language = options[:language] ? options[:language].to_s.to_sym : nil
-
-      if datatype = options[:datatype]
-        @datatype = datatype.respond_to?(:to_uri) ? datatype.to_uri : URI.intern(datatype.to_s)
-      else
-        @datatype = case value
-          when String     then nil # implicit XSD.string
-          when TrueClass  then XSD.boolean
-          when FalseClass then XSD.boolean
-          when Fixnum     then XSD.integer
-          when Integer    then XSD.integer
-          when Float
-            @value = case
-              when value.nan? then 'NaN'
-              when value.infinite? then value.to_s[0...-'inity'.length].upcase
-              else value.to_f
-            end
-            XSD.double
-          when Time, Date, DateTime
-            require 'time'
-            @value = value.respond_to?(:xmlschema) ? value.xmlschema : value.to_s
-            case value
-              when DateTime then XSD.dateTime
-              when Date     then XSD.date
-              when Time     then XSD.dateTime
-            end
-          else
-            require 'bigdecimal' unless defined?(BigDecimal)
-            case value
-              when BigDecimal
-                case
-                  when value.nan?      then 'NaN'
-                  when value.infinite? then value.to_s[0...-'inity'.length].upcase
-                  when value.finite?   then value.to_s('F')
-              end
-            end
-        end
-      end
+      @object   = value
+      @string   = options[:lexical] if options.has_key?(:lexical)
+      @language = options[:language].to_s.to_sym if options[:language]
+      @datatype = RDF::URI(options[:datatype]) if options[:datatype]
+    end
 
-      @value = @value.to_s
+    ##
+    # Returns the value as a string.
+    #
+    # @return [String]
+    def value
+      @string || to_s
     end
 
     ##
     # @return [Object]
     def object
-      case datatype
+      @object || case datatype
         when XSD.string, nil
           value
         when XSD.boolean
           %w(true 1).include?(value)
-        when XSD.double, XSD.float
-          value.to_f
         when XSD.integer, XSD.long, XSD.int, XSD.short, XSD.byte
           value.to_i
+        when XSD.double, XSD.float
+          value.to_f
         when XSD.decimal
-          require 'bigdecimal' unless defined?(BigDecimal)
-          BigDecimal.new(value)
+          ::BigDecimal.new(value)
         when XSD.date
-          require 'date' unless defined?(Date)
-          Date.parse(value)
+          ::Date.parse(value)
         when XSD.dateTime
-          require 'date' unless defined?(DateTime)
-          DateTime.parse(value)
+          ::DateTime.parse(value)
         when XSD.time
-          require 'time'
-          Time.parse(value)
+          ::Time.parse(value)
         when XSD.nonPositiveInteger, XSD.negativeInteger
           value.to_i
         when XSD.nonNegativeInteger, XSD.positiveInteger
@@ -203,15 +227,65 @@ module RDF
     alias_method :datatyped?, :has_datatype?
 
     ##
-    # Returns a string representation of this literal.
+    # Returns `true` if the value adheres to the defined grammar of the
+    # datatype.
+    #
+    # @return [Boolean]
+    # @since  0.2.1
+    def valid?
+      grammar = self.class.const_get(:GRAMMAR) rescue nil
+      grammar.nil? || !!(value =~ grammar)
+    end
+
+    ##
+    # Returns `true` if the value does not adhere to the defined grammar of
+    # the datatype.
+    #
+    # @return [Boolean]
+    # @since  0.2.1
+    def invalid?
+      !valid?
+    end
+
+    ##
+    # Validates the value using {#valid?}, raising an error if the value is
+    # invalid.
+    #
+    # @raise  [ArgumentError] if the value is invalid
+    # @return [Literal]
+    # @since  0.2.1
+    def validate
+      raise ArgumentError.new("#{to_s.inspect} is not a valid <#{datatype.to_s}> literal") if invalid?
+      self
+    end
+    alias_method :validate!, :validate
+
+    ##
+    # Converts the literal into its canonical lexical representation.
+    #
+    # Subclasses should override this as needed and appropriate.
+    #
+    # @return [Literal]
+    # @since  0.2.1
+    def canonicalize
+      @language = @language.to_s.downcase.to_sym if @language
+      self
+    end
+
+    ##
+    # Returns the value as a string.
     #
     # @return [String]
     def to_s
-      quoted = value # FIXME
-      output = "\"#{quoted}\""
-      output << "@#{language}" if language
-      output << "^^<#{datatype}>" if datatype
-      output
+      @object.to_s
+    end
+
+    ##
+    # Returns a developer-friendly representation of `self`.
+    #
+    # @return [String]
+    def inspect
+      sprintf("#<%s:%#0x(%s)>", self.class.name, __id__, RDF::NTriples.serialize(self))
     end
   end
 end

data/lib/rdf/model/literal/boolean.rb

@@ -0,0 +1,63 @@
+module RDF; class Literal
+  ##
+  # A boolean literal.
+  #
+  # @see   http://www.w3.org/TR/xmlschema-2/#boolean
+  # @since 0.2.1
+  class Boolean < Literal
+    DATATYPE = XSD.boolean
+    GRAMMAR  = /^(true|false|1|0)$/i.freeze
+    TRUES    = %w(true  1).freeze
+    FALSES   = %w(false 0).freeze
+
+    ##
+    # @param  [Boolean] value
+    # @option options [String] :lexical (nil)
+    def initialize(value, options = {})
+      @datatype = options[:datatype] || DATATYPE
+      @string   = options[:lexical] if options.has_key?(:lexical)
+      @string   = value if !defined?(@string) && value.is_a?(String)
+      @object   = case
+        when true.equal?(value)  then true
+        when false.equal?(value) then false
+        when TRUES.include?(value.to_s.downcase)  then true
+        when FALSES.include?(value.to_s.downcase) then false
+        else value
+      end
+    end
+
+    ##
+    # Converts the literal into its canonical lexical representation.
+    #
+    # @return [Literal]
+    # @see    http://www.w3.org/TR/xmlschema-2/#boolean
+    def canonicalize
+      @string = (@object ? :true : :false).to_s
+      self
+    end
+
+    ##
+    # Returns the value as a string.
+    #
+    # @return [String]
+    def to_s
+      @string || @object.to_s
+    end
+
+    ##
+    # Returns `true` if this value is `true`.
+    #
+    # @return [Boolean]
+    def true?
+      @object.equal?(true)
+    end
+
+    ##
+    # Returns `true` if this value is `false`.
+    #
+    # @return [Boolean]
+    def false?
+      @object.equal?(false)
+    end
+  end # class Boolean
+end; end # class RDF::Literal

data/lib/rdf/model/literal/date.rb

@@ -0,0 +1,43 @@
+module RDF; class Literal
+  ##
+  # A date literal.
+  #
+  # @see   http://www.w3.org/TR/xmlschema-2/#date
+  # @since 0.2.1
+  class Date < Literal
+    DATATYPE = XSD.date
+    GRAMMAR  = %r(\A-?\d{4}-\d{2}-\d{2}(([\+\-]\d{2}:\d{2})|UTC|Z)?\Z).freeze
+
+    ##
+    # @param  [Date] value
+    # @option options [String] :lexical (nil)
+    def initialize(value, options = {})
+      @datatype = options[:datatype] || DATATYPE
+      @string   = options[:lexical] if options.has_key?(:lexical)
+      @string   = value if !defined?(@string) && value.is_a?(String)
+      @object   = case
+        when value.is_a?(::Date)         then value
+        when value.respond_to?(:to_date) then value.to_date # Ruby 1.9+
+        else ::Date.parse(value.to_s)
+      end
+    end
+
+    ##
+    # Converts the literal into its canonical lexical representation.
+    #
+    # @return [Literal]
+    # @see    http://www.w3.org/TR/xmlschema-2/#date
+    def canonicalize
+      @string = @object.strftime('%Y-%m-%d%Z').sub(/\+00:00|UTC/, 'Z')
+      self
+    end
+
+    ##
+    # Returns the value as a string.
+    #
+    # @return [String]
+    def to_s
+      @string || @object.strftime('%Y-%m-%d%Z').sub(/\+00:00|UTC/, 'Z')
+    end
+  end # class Date
+end; end # class RDF::Literal

data/lib/rdf/model/literal/datetime.rb

@@ -0,0 +1,43 @@
+module RDF; class Literal
+  ##
+  # A date/time literal.
+  #
+  # @see   http://www.w3.org/TR/xmlschema-2/#dateTime
+  # @since 0.2.1
+  class DateTime < Literal
+    DATATYPE = XSD.dateTime
+    GRAMMAR  = %r(\A-?\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\.\d+)?(([\+\-]\d{2}:\d{2})|UTC|Z)?\Z).freeze
+
+    ##
+    # @param  [DateTime] value
+    # @option options [String] :lexical (nil)
+    def initialize(value, options = {})
+      @datatype = options[:datatype] || DATATYPE
+      @string   = options[:lexical] if options.has_key?(:lexical)
+      @string   = value if !defined?(@string) && value.is_a?(String)
+      @object   = case
+        when value.is_a?(::DateTime)         then value
+        when value.respond_to?(:to_datetime) then value.to_datetime # Ruby 1.9+
+        else ::DateTime.parse(value.to_s)
+      end
+    end
+
+    ##
+    # Converts the literal into its canonical lexical representation.
+    #
+    # @return [Literal]
+    # @see    http://www.w3.org/TR/xmlschema-2/#dateTime
+    def canonicalize
+      @string = @object.strftime('%Y-%m-%dT%H:%M:%S%Z').sub(/\+00:00|UTC/, 'Z')
+      self
+    end
+
+    ##
+    # Returns the value as a string.
+    #
+    # @return [String]
+    def to_s
+      @string || @object.strftime('%Y-%m-%dT%H:%M:%S%Z').sub(/\+00:00|UTC/, 'Z')
+    end
+  end # class DateTime
+end; end # class RDF::Literal

data/lib/rdf/model/literal/decimal.rb

@@ -0,0 +1,90 @@
+module RDF; class Literal
+  ##
+  # A decimal literal.
+  #
+  # @see   http://www.w3.org/TR/xmlschema-2/#decimal
+  # @since 0.2.1
+  class Decimal < Literal
+    DATATYPE = XSD.decimal
+    GRAMMAR  = /^[\+\-]?\d+(\.\d*)?$/.freeze
+
+    ##
+    # @param  [BigDecimal] value
+    # @option options [String] :lexical (nil)
+    def initialize(value, options = {})
+      @datatype = options[:datatype] || DATATYPE
+      @string   = options[:lexical] if options.has_key?(:lexical)
+      @string   = value if !defined?(@string) && value.is_a?(String)
+      @object   = case
+        when value.is_a?(BigDecimal) then value
+        else BigDecimal(value.to_s)
+      end
+    end
+
+    ##
+    # Converts the literal into its canonical lexical representation.
+    #
+    # @return [Literal]
+    # @see    http://www.w3.org/TR/xmlschema-2/#decimal
+    def canonicalize
+      # Can't use simple %f transformation due to special requirements from
+      # N3 tests in representation
+      @string = begin
+        i, f = @object.to_s('F').split('.')
+        i.sub!(/^\+?0+(\d)$/, '\1') # remove the optional leading '+' sign and any extra leading zeroes
+        f = f[0, 16]                # truncate the fractional part after 15 decimal places
+        f.sub!(/0*$/, '')           # remove any trailing zeroes
+        f = '0' if f.empty?         # ...but there must be a digit to the right of the decimal point
+        "#{i}.#{f}"
+      end
+      self
+    end
+
+    ##
+    # Returns the value as a string.
+    #
+    # @return [String]
+    # @see    BigDecimal#to_s
+    def to_s
+      @string || @object.to_s('F')
+    end
+
+    ##
+    # Returns the value as an integer.
+    #
+    # @return [Integer]
+    # @see    BigDecimal#to_i
+    def to_i
+      @object.to_i
+    end
+
+    ##
+    # Returns the value as a floating point number.
+    #
+    # The usual accuracy limits and errors of binary float arithmetic apply.
+    #
+    # @return [Float]
+    # @see    BigDecimal#to_f
+    def to_f
+      @object.to_f
+    end
+
+    ##
+    # Returns the value as a decimal number.
+    #
+    # @return [BigDecimal]
+    # @see    BigDecimal#to_d
+    def to_d
+      @object.respond_to?(:to_d) ? @object.to_d : BigDecimal(@object.to_s)
+    end
+
+    ##
+    # Returns the value as a rational number.
+    #
+    # @return [Rational]
+    # @see    BigDecimal#to_r
+    def to_r
+      @object.to_r # only available on Ruby 1.9+
+    end
+  end # class Decimal
+end; end # class RDF::Literal

data/lib/rdf/model/literal/double.rb

@@ -0,0 +1,92 @@
+module RDF; class Literal
+  ##
+  # An floating point number literal.
+  #
+  # @see   http://www.w3.org/TR/xmlschema-2/#double
+  # @since 0.2.1
+  class Double < Literal
+    DATATYPE = XSD.double
+    GRAMMAR  = /^[\+\-]?\d+(\.\d*([eE][\+\-]?\d+)?)?$/.freeze # FIXME: support 'INF', '-INF' and 'NaN'
+
+    ##
+    # @param  [Float, #to_f] value
+    # @option options [String] :lexical (nil)
+    def initialize(value, options = {})
+      @datatype = options[:datatype] || DATATYPE
+      @string   = options[:lexical] if options.has_key?(:lexical)
+      @string   = value if !defined?(@string) && value.is_a?(String)
+      @object   = case
+        when value.is_a?(::String)    then Float(value) rescue nil
+        when value.is_a?(::Float)     then value
+        when value.respond_to?(:to_f) then value.to_f
+        else Float(value.to_s) rescue nil
+      end
+    end
+
+    ##
+    # Converts the literal into its canonical lexical representation.
+    #
+    # @return [Literal]
+    # @see    http://www.w3.org/TR/xmlschema-2/#double
+    def canonicalize
+      # Can't use simple %f transformation due to special requirements from
+      # N3 tests in representation
+      @string = case
+        when @object.nan?      then 'NaN'
+        when @object.infinite? then @object.to_s[0...-'inity'.length].upcase
+        when @object.zero?     then '0.0E0'
+        else
+          i, f, e = ('%.16E' % @object.to_f).split(/[\.E]/)
+          f.sub!(/0*$/, '')           # remove any trailing zeroes
+          f = '0' if f.empty?         # ...but there must be a digit to the right of the decimal point
+          e.sub!(/^\+?0+(\d)$/, '\1') # remove the optional leading '+' sign and any extra leading zeroes
+          "#{i}.#{f}E#{e}"
+      end unless @object.nil?
+      self
+    end
+
+    ##
+    # Returns the value as a string.
+    #
+    # @return [String]
+    def to_s
+      @string || case
+        when @object.nan?      then 'NaN'
+        when @object.infinite? then @object.to_s[0...-'inity'.length].upcase
+        else @object.to_s
+      end
+    end
+
+    ##
+    # Returns the value as an integer.
+    #
+    # @return [Integer]
+    def to_i
+      @object.to_i
+    end
+
+    ##
+    # Returns the value as a floating point number.
+    #
+    # @return [Float]
+    def to_f
+      @object.to_f
+    end
+
+    ##
+    # Returns the value as a decimal number.
+    #
+    # @return [BigDecimal]
+    def to_d
+      @object.respond_to?(:to_d) ? @object.to_d : BigDecimal(@object.to_s)
+    end
+
+    ##
+    # Returns the value as a rational number.
+    #
+    # @return [Rational]
+    def to_r
+      @object.to_r # only available on Ruby 1.9+
+    end
+  end # class Double
+end; end # class RDF::Literal

data/lib/rdf/model/literal/integer.rb

@@ -0,0 +1,76 @@
+module RDF; class Literal
+  ##
+  # An integer literal.
+  #
+  # @see   http://www.w3.org/TR/xmlschema-2/#integer
+  # @since 0.2.1
+  class Integer < Decimal
+    DATATYPE = XSD.integer
+    GRAMMAR  = /^[\+\-]?\d+$/.freeze
+
+    ##
+    # @param  [Integer, #to_i] value
+    # @option options [String] :lexical (nil)
+    def initialize(value, options = {})
+      @datatype = options[:datatype] || DATATYPE
+      @string   = options[:lexical] if options.has_key?(:lexical)
+      @string   = value if !defined?(@string) && value.is_a?(String)
+      @object   = case
+        when value.is_a?(::String)    then Integer(value) rescue nil
+        when value.is_a?(::Integer)   then value
+        when value.respond_to?(:to_i) then value.to_i
+        else Integer(value.to_s) rescue nil
+      end
+    end
+
+    ##
+    # Converts the literal into its canonical lexical representation.
+    #
+    # @return [Literal]
+    # @see    http://www.w3.org/TR/xmlschema-2/#integer
+    def canonicalize
+      @string = @object.to_s if @object
+      self
+    end
+
+    ##
+    # Returns the value as a string.
+    #
+    # @return [String]
+    def to_s
+      @string || @object.to_s
+    end
+
+    ##
+    # Returns the value as an integer.
+    #
+    # @return [Integer]
+    def to_i
+      @object.to_i
+    end
+
+    ##
+    # Returns the value as a floating point number.
+    #
+    # @return [Float]
+    def to_f
+      @object.to_f
+    end
+
+    ##
+    # Returns the value as a decimal number.
+    #
+    # @return [BigDecimal]
+    def to_d
+      @object.respond_to?(:to_d) ? @object.to_d : BigDecimal(@object.to_s)
+    end
+
+    ##
+    # Returns the value as a rational number.
+    #
+    # @return [Rational]
+    def to_r
+      @object.to_r
+    end
+  end # class Integer
+end; end # class RDF::Literal

data/lib/rdf/model/literal/time.rb

@@ -0,0 +1,55 @@
+module RDF; class Literal
+  ##
+  # A time literal.
+  #
+  # The lexical representation for time is the left truncated lexical
+  # representation for `xsd:dateTime`: "hh:mm:ss.sss" with an optional
+  # following time zone indicator.
+  #
+  # @see   http://www.w3.org/TR/xmlschema-2/#time
+  # @since 0.2.1
+  class Time < Literal
+    DATATYPE = XSD.time
+    GRAMMAR  = %r(\A\d{2}:\d{2}:\d{2}(\.\d+)?(([\+\-]\d{2}:\d{2})|UTC|Z)?\Z).freeze
+
+    ##
+    # @param  [Time] value
+    # @option options [String] :lexical (nil)
+    def initialize(value, options = {})
+      @datatype = options[:datatype] || DATATYPE
+      @string   = options[:lexical] if options.has_key?(:lexical)
+      @string   = value if !defined?(@string) && value.is_a?(String)
+      @object   = case
+        when value.is_a?(::Time)         then value
+        when value.respond_to?(:to_time) then value.to_time # Ruby 1.9+
+        else ::Time.parse(value.to_s)
+      end
+    end
+
+    ##
+    # Converts the literal into its canonical lexical representation.
+    #
+    # §3.2.8.2 Canonical representation
+    #
+    # The canonical representation for time is defined by prohibiting
+    # certain options from the Lexical representation (§3.2.8.1).
+    # Specifically, either the time zone must be omitted or, if present, the
+    # time zone must be Coordinated Universal Time (UTC) indicated by a "Z".
+    # Additionally, the canonical representation for midnight is 00:00:00.
+    #
+    # @return [Literal]
+    # @see    http://www.w3.org/TR/xmlschema-2/#time
+    def canonicalize
+      @string = @object.strftime('%H:%M:%S%Z').sub(/\+00:00|UTC/, 'Z')
+      self
+    end
+
+    ##
+    # Returns the value as a string.
+    #
+    # @return [String]
+    def to_s
+      @string || @object.strftime('%H:%M:%S%Z').sub(/\+00:00|UTC/, 'Z')
+    end
+  end # class Time
+end; end # class RDF::Literal

data/lib/rdf/model/literal/xml.rb

@@ -0,0 +1,39 @@
+module RDF; class Literal
+  ##
+  # An XML literal.
+  #
+  # @see   http://www.w3.org/TR/rdf-concepts/#section-XMLLiteral
+  # @see   http://www.w3.org/TR/rdfa-core/#s_xml_literals
+  # @since 0.2.1
+  class XML < Literal
+    DATATYPE = RDF.XMLLiteral
+    GRAMMAR  = nil
+
+    ##
+    # @param  [Object] value
+    # @option options [String] :lexical (nil)
+    def initialize(value, options = {})
+      @datatype = options[:datatype] || DATATYPE
+      @string   = options[:lexical] if options.has_key?(:lexical)
+      @object   = value # TODO: parse XML string using REXML
+    end
+
+    ##
+    # Converts the literal into its canonical lexical representation.
+    #
+    # @return [Literal]
+    # @see    http://www.w3.org/TR/xml-exc-c14n/
+    def canonicalize
+      # TODO: implement XML canonicalization
+      self
+    end
+
+    ##
+    # Returns the value as a string.
+    #
+    # @return [String]
+    def to_s
+      @string || @object.to_s # TODO
+    end
+  end # class XML
+end; end # class RDF::Literal

data/lib/rdf/model/node.rb

@@ -49,7 +49,7 @@ module RDF
     ##
     # @param  [#to_s] id
     def initialize(id = nil)
-      @id = (id || "g#{object_id}").to_s
+      @id = (id || "g#{__id__.to_i.abs}").to_s
     end
 
     ##

data/lib/rdf/model/value.rb

@@ -125,7 +125,7 @@ module RDF
     #
     # @return [String]
     def inspect
-      sprintf("#<%s:%#0x(%s)>", self.class.name, object_id, to_s)
+      sprintf("#<%s:%#0x(%s)>", self.class.name, __id__, to_s)
     end
 
     ##

data/lib/rdf/ntriples.rb

@@ -63,4 +63,20 @@ module RDF
       Writer.serialize(value)
     end
   end
+
+  ##
+  # Extensions for `RDF::Value`.
+  module Value
+    ##
+    # Returns the N-Triples representation of this value.
+    #
+    # This method is only available when the 'rdf/ntriples' serializer has
+    # been explicitly required.
+    #
+    # @return [String]
+    # @since  0.2.1
+    def to_ntriples
+      RDF::NTriples.serialize(self)
+    end
+  end
 end

data/lib/rdf/query/solution.rb

@@ -120,7 +120,7 @@ class RDF::Query
     ##
     # @return [String]
     def inspect
-      sprintf("#<%s:%#0x(%s)>", self.class.name, object_id, @bindings.inspect)
+      sprintf("#<%s:%#0x(%s)>", self.class.name, __id__, @bindings.inspect)
     end
 
     protected

data/lib/rdf/reader.rb

@@ -169,7 +169,7 @@ module RDF
       ##
       # @raise [NotImplementedError] unless implemented in subclass
       def read_triple
-        raise NotImplementedError
+        raise NotImplementedError.new("#{self.class}#read_triple") # override in subclasses
       end
 
       ##

data/lib/rdf/repository.rb

@@ -116,7 +116,7 @@ module RDF
     #
     # @return [String]
     def inspect
-      sprintf("#<%s:%#0x(%s)>", self.class.name, object_id, uri.to_s)
+      sprintf("#<%s:%#0x(%s)>", self.class.name, __id__, uri.to_s)
     end
 
     ##
@@ -135,7 +135,7 @@ module RDF
       ##
       # @private
       def self.extend_object(obj)
-        obj.instance_variable_set(:@data, {})
+        obj.instance_variable_set(:@data, obj.options.delete(:data) || {})
         super
       end
 

data/lib/rdf/util/cache.rb

@@ -83,8 +83,8 @@ module RDF; module Util
       # @return [Object]
       def []=(key, value)
         if has_capacity?
-          @cache[key] = value.object_id
-          @index[value.object_id] = key
+          @cache[key] = value.__id__
+          @index[value.__id__] = key
           define_finalizer!(value)
         end
         value
@@ -121,7 +121,7 @@ module RDF; module Util
       def []=(key, value)
         if has_capacity?
           @cache[key] = WeakRef.new(value)
-          @index[value.object_id] = key
+          @index[value.__id__] = key
           define_finalizer!(value)
         end
         value

data/lib/rdf/version.rb

@@ -2,8 +2,8 @@ module RDF
   module VERSION
     MAJOR = 0
     MINOR = 2
-    TINY  = 0
-    EXTRA = 1
+    TINY  = 1
+    EXTRA = nil
 
     STRING = [MAJOR, MINOR, TINY, EXTRA].compact.join('.')
 

metadata

@@ -5,9 +5,8 @@ version: !ruby/object:Gem::Version
   segments: 
   - 0
   - 2
-  - 0
   - 1
-  version: 0.2.0.1
+  version: 0.2.1
 platform: ruby
 authors: 
 - Arto Bendiken
@@ -16,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-06-19 00:00:00 +02:00
+date: 2010-06-28 00:00:00 +02:00
 default_executable: rdf
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -43,8 +42,8 @@ dependencies:
         segments: 
         - 0
         - 5
-        - 6
-        version: 0.5.6
+        - 8
+        version: 0.5.8
   type: :development
   version_requirements: *id002
 - !ruby/object:Gem::Dependency 
@@ -71,8 +70,8 @@ dependencies:
         segments: 
         - 0
         - 2
-        - 0
-        version: 0.2.0
+        - 1
+        version: 0.2.1
   type: :development
   version_requirements: *id004
 description: RDF.rb is a pure-Ruby library for working with Resource Description Framework (RDF) data.
@@ -103,6 +102,14 @@ files:
 - lib/rdf/mixin/readable.rb
 - lib/rdf/mixin/writable.rb
 - lib/rdf/model/graph.rb
+- lib/rdf/model/literal/boolean.rb
+- lib/rdf/model/literal/date.rb
+- lib/rdf/model/literal/datetime.rb
+- lib/rdf/model/literal/decimal.rb
+- lib/rdf/model/literal/double.rb
+- lib/rdf/model/literal/integer.rb
+- lib/rdf/model/literal/time.rb
+- lib/rdf/model/literal/xml.rb
 - lib/rdf/model/literal.rb
 - lib/rdf/model/node.rb
 - lib/rdf/model/resource.rb