rdf 1.0.10.2 → 1.1.0.p0

data/lib/rdf/model/literal.rb

@@ -1,20 +1,14 @@
-# -*- encoding: utf-8 -*-
 module RDF
   ##
   # An RDF literal.
   #
-  # Subclasses of {RDF::Literal} should define DATATYPE and GRAMMAR constants, which are used
-  # for identifying the appropriate class to use for a datatype URI and to perform lexical
-  # matching on the value.
+  # Subclasses of {RDF::Literal} should define DATATYPE and GRAMMAR constants, which are used for identifying the appropriate class to use for a datatype URI and to perform lexical matching on the value.
   #
-  # Literal comparison with other {RDF::Value} instances call {RDF::Value#type_error},
-  # which, returns false. Implementations wishing to have {RDF::TypeError} raised
-  # should mix-in {RDF::TypeCheck}. This is required for strict SPARQL conformance.
+  # Literal comparison with other {RDF::Value} instances call {RDF::Value#type_error}, which, returns false. Implementations wishing to have {RDF::TypeError} raised should mix-in {RDF::TypeCheck}. This is required for strict SPARQL conformance.
   #
-  # Specific typed literals may have behavior different from the default implementation. See
-  # the following defined sub-classes for specific documentation. Additional sub-classes may
-  # be defined, and will interoperate by defining `DATATYPE` and `GRAMMAR` constants, in addition
-  # other required overrides of RDF::Literal behavior.
+  # Specific typed literals may have behavior different from the default implementation. See the following defined sub-classes for specific documentation. Additional sub-classes may be defined, and will interoperate by defining `DATATYPE` and `GRAMMAR` constants, in addition other required overrides of RDF::Literal behavior.
+  #
+  # In RDF 1.1, all literals are typed, including plain literals and language tagged literals. Internally, plain literals are given the `xsd:string` datatype and language tagged literals are given the `rdf:langString` datatype. Creating a plain literal, without a datatype or language, will automatically provide the `xsd:string` datatype; similar for language tagged literals. Note that most serialization formats will remove this datatype. Code which depends on a literal having the `xsd:string` datatype being different from a plain literal (formally, without a datatype) may break. However note that the `#has\_datatype?` will continue to return `false` for plain or language-tagged literals.
   #
   # * {RDF::Literal::Boolean}
   # * {RDF::Literal::Date}
@@ -54,24 +48,22 @@ module RDF
   #   RDF::Literal.new(123).datatype                 #=> XSD.integer
   #   RDF::Literal.new(9223372036854775807).datatype #=> XSD.integer
   #   RDF::Literal.new(3.1415).datatype              #=> XSD.double
-  #   RDF::Literal.new(Time.now).datatype            #=> XSD.time
+  #   RDF::Literal.new(Time.now).datatype            #=> XSD.dateTime
   #   RDF::Literal.new(Date.new(2010)).datatype      #=> XSD.date
   #   RDF::Literal.new(DateTime.new(2010)).datatype  #=> XSD.dateTime
   #
-  # @see http://www.w3.org/TR/rdf-concepts/#section-Literals
-  # @see http://www.w3.org/TR/rdf-concepts/#section-Datatypes-intro
+  # @see http://www.w3.org/TR/rdf11-concepts/#section-Graph-Literal
+  # @see http://www.w3.org/TR/rdf11-concepts/#section-Datatypes
   class Literal
 
   private
     @@subclasses       = [] # @private
-    @@datatype_map     = nil # @private
 
     ##
     # @private
     # @return [void]
     def self.inherited(child)
       @@subclasses << child
-      @@datatype_map = nil
       super
     end
   
@@ -90,33 +82,20 @@ module RDF
 
     include RDF::Term
 
-    ##
-    # @private
-    # Return Hash mapping from datatype URI to class
-    def self.datatype_map
-      @@datatype_map ||= Hash[
-        @@subclasses
-          .select {|klass| klass.const_defined?(:DATATYPE)}
-          .map {|klass| [klass.const_get(:DATATYPE).to_s, klass]}
-      ]
-    end
-
     ##
     # @private
     # Return datatype class for uri, or nil if none is found
     def self.datatyped_class(uri)
-      datatype_map[uri]
+      @@subclasses.detect {|klass| klass.const_defined?(:DATATYPE) && klass.const_get(:DATATYPE) == uri}
     end
 
     ##
     # @private
     def self.new(value, options = {})
-      raise ArgumentError, "datatype with language" if options[:language] && (options[:datatype] || RDF.langString).to_s != RDF.langString.to_s
-
       klass = case
         when !self.equal?(RDF::Literal)
           self # subclasses can be directly constructed without type dispatch
-        when typed_literal = datatyped_class(options[:datatype].to_s)
+        when typed_literal = datatyped_class(RDF::URI(options[:datatype]))
           typed_literal
         else case value
           when ::TrueClass  then RDF::Literal::Boolean
@@ -138,9 +117,9 @@ module RDF
       literal
     end
 
-    TRUE  = RDF::Literal.new(true)
-    FALSE = RDF::Literal.new(false)
-    ZERO  = RDF::Literal.new(0)
+    TRUE  = RDF::Literal.new(true).freeze
+    FALSE = RDF::Literal.new(false).freeze
+    ZERO  = RDF::Literal.new(0).freeze
 
     # @return [Symbol] The language tag (optional).
     attr_accessor :language
@@ -149,32 +128,25 @@ module RDF
     attr_accessor :datatype
 
     ##
+    # Literals without a datatype are given either xsd:string or rdf:langString
+    # depending on if there is language
+    #
     # @param  [Object] value
-    # @option options [Symbol]  :language (nil)
-    # @option options [String]  :lexical (nil)
-    #   Supplied lexical representation of this literal,
-    #   otherwise it comes from transforming `value` to a string form
-    #   See {#to_s}.
-    # @option options [URI]     :datatype (nil)
-    # @option options [Boolean] :validate (false)
-    # @option options [Boolean] :canonicalize (false)
+    # @option options [Symbol] :language (nil)
+    # @option options [URI]    :datatype (nil)
     # @raise [ArgumentError]
     #   if there is a language and datatype is no rdf:langString
-    #   or datatype is rdf:langString and there is no language
     # @see http://www.w3.org/TR/rdf11-concepts/#section-Graph-Literal
     # @see http://www.w3.org/TR/rdf11-concepts/#section-Datatypes
     def initialize(value, options = {})
       @object   = value
       @string   = options[:lexical] if options[:lexical]
       @string   = value if !defined?(@string) && value.is_a?(String)
-      @string   = @string.encode(Encoding::UTF_8) if @string && @string.respond_to?(:encode)
-      @object   = @string if @string && @object.is_a?(String)
       @language = options[:language].to_s.to_sym if options[:language]
       @datatype = RDF::URI(options[:datatype]) if options[:datatype]
       @datatype ||= self.class.const_get(:DATATYPE) if self.class.const_defined?(:DATATYPE)
-
-      # Ignore rdf:langString if there is a language
-      @datatype = nil if @language && @datatype == RDF.langString
+      @datatype ||= @language ? RDF.langString : RDF::XSD.string
+      raise ArgumentError, "datatype with language must be rdf:langString" if @language && @datatype != RDF::langString
       raise ArgumentError, "datatype of rdf:langString requires a language" if !@language && @datatype == RDF::langString
     end
 
@@ -213,24 +185,7 @@ module RDF
     #
     # @return [Fixnum]
     def hash
-      @hash ||= to_s.hash
-    end
-
-
-    ##
-    # Returns a hash code for the value.
-    #
-    # @return [Fixnum]
-    def value_hash
-      @value_hash ||= value.hash
-    end
-
-    ##
-    # @private
-    def freeze
-      hash.freeze
-      value_hash.freeze
-      super
+      to_s.hash
     end
 
     ##
@@ -268,46 +223,32 @@ module RDF
           true
         when self.has_language? && self.language.to_s.downcase == other.language.to_s.downcase
           # Literals with languages can compare if languages are identical
-          self.value_hash == other.value_hash && self.value == other.value
-        when (self.simple? || self.datatype == XSD.string) && (other.simple? || other.datatype == XSD.string)
-          self.value_hash == other.value_hash && self.value == other.value
+          self.value == other.value
+        when self.simple? && other.simple?
+          self.value == other.value
         when other.comperable_datatype?(self) || self.comperable_datatype?(other)
-          # Comoparing plain with undefined datatypes does not generate an error, but returns false
+          # Comparing plain with undefined datatypes does not generate an error, but returns false
           # From data-r2/expr-equal/eq-2-2.
           false
         else
           type_error("unable to determine whether #{self.inspect} and #{other.inspect} are equivalent")
         end
       when String
-        self.simple? && self.value.eql?(other)
+        self.plain? && self.value.eql?(other)
       else false
       end
     end
     alias_method :===, :==
 
     ##
-    # Returns `true` if this is a plain literal. A plain literal
-    # may have a language, but may not have a datatype. For
-    # all practical purposes, this includes xsd:string literals
-    # too.
+    # Returns `true` if this is a plain literal.
     #
     # @return [Boolean] `true` or `false`
     # @see http://www.w3.org/TR/rdf-concepts/#dfn-plain-literal
     def plain?
-      has_language? ?
-        (datatype || RDF.langString) == RDF.langString :
-        (datatype || XSD.string) == XSD.string
-    end
-
-    ##
-    # Returns `true` if this is a simple literal.
-    # A simple literal has no datatype or language.
-    #
-    # @return [Boolean] `true` or `false`
-    # @see http://www.w3.org/TR/sparql11-query/#simple_literal
-    def simple?
-      !has_language? && !has_datatype?
+      datatype == RDF::XSD.string
     end
+    alias_method :simple?, :plain?
 
     ##
     # Returns `true` if this is a language-tagged literal.
@@ -315,17 +256,19 @@ module RDF
     # @return [Boolean] `true` or `false`
     # @see http://www.w3.org/TR/rdf-concepts/#dfn-plain-literal
     def has_language?
-      !language.nil?
+      datatype == RDF.langString
     end
     alias_method :language?, :has_language?
 
     ##
     # Returns `true` if this is a datatyped literal.
     #
+    # For historical reasons, this excludes xsd:string and rdf:langString
+    #
     # @return [Boolean] `true` or `false`
     # @see http://www.w3.org/TR/rdf-concepts/#dfn-typed-literal
     def has_datatype?
-      !datatype.nil?
+      !plain? && !language?
     end
     alias_method :datatype?,  :has_datatype?
     alias_method :typed?,     :has_datatype?
@@ -369,19 +312,24 @@ module RDF
         # Invald types can be compared without raising a TypeError if literal has a language (open-eq-08)
         !other.valid? && self.has_language?
       else
-        case other.datatype
-        when XSD.string
-          true
-        when nil
-          # A different language will not generate a type error
-          other.has_language?
-        else
-          # An unknown datatype may not be used for comparison, unless it has a language? (open-eq-8)
-          self.has_language?
-        end
+        # An unknown datatype may not be used for comparison, unless it has a language? (open-eq-8)
+        self.has_language?
       end
     end
 
+    ##
+    # Returns a copy of this literal converted into its canonical lexical
+    # representation.
+    #
+    # Subclasses should override `#canonicalize!` as needed and appropriate,
+    # not this method.
+    #
+    # @return [RDF::Literal]
+    # @since  0.2.1
+    def canonicalize
+      self.dup.canonicalize!
+    end
+
     ##
     # Converts this literal into its canonical lexical representation.
     #

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

@@ -18,7 +18,7 @@ module RDF; class Literal
       @string   ||= value if 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+
+        when value.respond_to?(:to_date) then value.to_date
         else ::Date.parse(value.to_s)
       end rescue nil
     end

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

@@ -15,12 +15,9 @@ module RDF; class Literal
       @datatype = RDF::URI(options[:datatype] || self.class.const_get(:DATATYPE))
       @string   = options[:lexical] if options.has_key?(:lexical)
       @string   ||= value if value.is_a?(String)
-      @has_timezone = @string.nil? || if md = @string.match(GRAMMAR)
-        !!md[2] # If lexical value contains timezone
-      end
       @object   = case
         when value.is_a?(::DateTime)         then value
-        when value.respond_to?(:to_datetime) then value.to_datetime # Ruby 1.9+
+        when value.respond_to?(:to_datetime) then value.to_datetime
         else ::DateTime.parse(value.to_s)
       end rescue nil
     end
@@ -36,35 +33,6 @@ module RDF; class Literal
       self
     end
 
-    ##
-    # Returns the timezone part of arg as a simple literal. Returns the empty string if there is no timezone.
-    #
-    # @return [RDF::Literal]
-    # @see http://www.w3.org/TR/sparql11-query/#func-tz
-    def tz
-      zone =  @has_timezone ? object.zone : ""
-      zone = "Z" if zone == "+00:00"
-      RDF::Literal(zone)
-    end
-
-    ##
-    # Returns the timezone part of arg as an xsd:dayTimeDuration, or `nil`
-    # if lexical form of literal does not include a timezone.
-    #
-    # @return [RDF::Literal]
-    def timezone
-      if tz == 'Z'
-        RDF::Literal("PT0S", :datatype => RDF::XSD.dayTimeDuration)
-      elsif md = tz.to_s.match(/^([+-])?(\d+):(\d+)?$/)
-        plus_minus, hour, min = md[1,3]
-        plus_minus = nil unless plus_minus == "-"
-        hour = hour.to_i
-        min = min.to_i
-        res = "#{plus_minus}PT#{hour}H#{"#{min}M" if min > 0}"
-        RDF::Literal(res, :datatype => RDF::XSD.dayTimeDuration)
-      end
-    end
-
     ##
     # Returns `true` if the value adheres to the defined grammar of the
     # datatype.
@@ -77,8 +45,6 @@ module RDF; class Literal
       super && object && value !~ %r(\A0000)
     end
 
-    ##
-    # Returns the `timezone` of the literal. If the
     ##
     # Returns the value as a string.
     #

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

@@ -56,36 +56,6 @@ module RDF; class Literal
       (d = to_d) && d > 0 ? self : RDF::Literal(d.abs)
     end
 
-    ##
-    # Returns the number with no fractional part that is closest to the argument. If there are two such numbers, then the one that is closest to positive infinity is returned. An error is raised if arg is not a numeric value.
-    #
-    # @return [RDF::Literal]
-    def round
-      self.class.new(to_d.round)
-    end
-
-    ##
-    # Returns the smallest integer greater than or equal to `self`.
-    #
-    # @example
-    #   RDF::Literal(1).ceil            #=> RDF::Literal(1)
-    #
-    # @return [RDF::Literal]
-    def ceil
-      self.class.new(to_d.ceil)
-    end
-
-    ##
-    # Returns the largest integer less than or equal to `self`.
-    #
-    # @example
-    #   RDF::Literal(1).floor            #=> RDF::Literal(1)
-    #
-    # @return [RDF::Literal]
-    def floor
-      self.class.new(to_d.floor)
-    end
-
     ##
     # Returns `true` if the value is zero.
     #

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

@@ -50,7 +50,7 @@ module RDF; class Literal
           i, f, e = ('%.15E' % @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\2') # remove the optional leading '+' sign and any extra leading zeroes
+          e.sub!(/^\+?0+(\d)$/, '\1') # remove the optional leading '+' sign and any extra leading zeroes
           "#{i}.#{f}E#{e}"
       end
       @object = Float(@string) unless @object.nil?
@@ -118,7 +118,7 @@ module RDF; class Literal
     end
 
     ##
-    # Returns the smallest number greater than or equal to `self`.
+    # Returns the smallest integer greater than or equal to `self`.
     #
     # @example
     #   RDF::Literal(1.2).ceil            #=> RDF::Literal(2)
@@ -129,11 +129,11 @@ module RDF; class Literal
     # @return [RDF::Literal]
     # @since  0.2.3
     def ceil
-      self.class.new(to_f.ceil)
+      RDF::Literal(to_f.ceil)
     end
 
     ##
-    # Returns the largest number less than or equal to `self`.
+    # Returns the largest integer less than or equal to `self`.
     #
     # @example
     #   RDF::Literal(1.2).floor           #=> RDF::Literal(1)
@@ -144,7 +144,7 @@ module RDF; class Literal
     # @return [RDF::Literal]
     # @since  0.2.3
     def floor
-      self.class.new(to_f.floor)
+      RDF::Literal(to_f.floor)
     end
 
     ##
@@ -153,15 +153,7 @@ module RDF; class Literal
     # @return [RDF::Literal]
     # @since  0.2.3
     def abs
-      (f = to_f) && f > 0 ? self : self.class.new(f.abs)
-    end
-
-    ##
-    # Returns the number with no fractional part that is closest to the argument. If there are two such numbers, then the one that is closest to positive infinity is returned. An error is raised if arg is not a numeric value.
-    #
-    # @return [RDF::Literal]
-    def round
-      self.class.new(to_f.round)
+      (f = to_f) && f > 0 ? self : RDF::Literal(f.abs)
     end
 
     ##

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

@@ -41,7 +41,7 @@ module RDF; class Literal
     end
 
     ##
-    # Returns the predecessor value of `self`.
+    # Returns the successor value of `self`.
     #
     # @return [RDF::Literal]
     # @since  0.2.3
@@ -50,7 +50,7 @@ module RDF; class Literal
     end
 
     ##
-    # Returns the successor value of `self`.
+    # Returns the predecessor value of `self`.
     #
     # @return [RDF::Literal]
     # @since  0.2.3
@@ -83,15 +83,7 @@ module RDF; class Literal
     # @return [RDF::Literal]
     # @since  0.2.3
     def abs
-      (n = to_i) && n > 0 ? self : self.class.new(n.abs)
-    end
-
-    ##
-    # Returns `self`.
-    #
-    # @return [RDF::Literal]
-    def round
-      self
+      (n = to_i) && n > 0 ? self : RDF::Literal(n.abs)
     end
 
     ##