rdf 0.3.3 → 0.3.4

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

@@ -9,20 +9,19 @@ module RDF; class Literal
   #   RDF::Literal(84) / 2                    #=> RDF::Literal(42)
   #
   # @see   http://www.w3.org/TR/xmlschema-2/#integer
+  # @see   http://www.w3.org/TR/2004/REC-xmlschema-2-20041028/#integer
   # @since 0.2.1
   class Integer < Decimal
     DATATYPE = XSD.integer
     GRAMMAR  = /^[\+\-]?\d+$/.freeze
 
-    include RDF::Literal::Numeric
-
     ##
     # @param  [Integer, #to_i] value
     # @option options [String] :lexical (nil)
     def initialize(value, options = {})
-      @datatype = RDF::URI(options[:datatype] || DATATYPE)
+      @datatype = RDF::URI(options[:datatype] || self.class.const_get(:DATATYPE))
       @string   = options[:lexical] if options.has_key?(:lexical)
-      @string   = value if !defined?(@string) && value.is_a?(String)
+      @string   ||= value if value.is_a?(String)
       @object   = case
         when value.is_a?(::String)    then Integer(value) rescue nil
         when value.is_a?(::Integer)   then value
@@ -105,65 +104,6 @@ module RDF; class Literal
       to_i.nonzero? ? self : nil
     end
 
-    ##
-    # Returns `self`.
-    #
-    # @return [RDF::Literal]
-    # @since  0.2.3
-    def +@
-      self # unary plus
-    end
-
-    ##
-    # Returns `self` negated.
-    #
-    # @return [RDF::Literal]
-    # @since  0.2.3
-    def -@
-      RDF::Literal(-to_i) # unary minus
-    end
-
-    ##
-    # Returns the sum of `self` plus `other`.
-    #
-    # @param  [#to_i] other
-    # @return [RDF::Literal]
-    # @since  0.2.3
-    def +(other)
-      RDF::Literal(to_i + other.to_i)
-    end
-
-    ##
-    # Returns the difference of `self` minus `other`.
-    #
-    # @param  [#to_i] other
-    # @return [RDF::Literal]
-    # @since  0.2.3
-    def -(other)
-      RDF::Literal(to_i - other.to_i)
-    end
-
-    ##
-    # Returns the product of `self` times `other`.
-    #
-    # @param  [#to_i] other
-    # @return [RDF::Literal]
-    # @since  0.2.3
-    def *(other)
-      RDF::Literal(to_i * other.to_i)
-    end
-
-    ##
-    # Returns the quotient of `self` divided by `other`.
-    #
-    # @param  [#to_i] other
-    # @return [RDF::Literal]
-    # @raise  [ZeroDivisionError] if divided by zero
-    # @since  0.2.3
-    def /(other)
-      RDF::Literal(to_i / other.to_i)
-    end
-
     ##
     # Returns the value as a string.
     #
@@ -172,40 +112,6 @@ module RDF; class Literal
       @string || @object.to_s
     end
 
-    ##
-    # Returns the value as an integer.
-    #
-    # @return [Integer]
-    def to_i
-      @object.to_i
-    end
-    alias_method :to_int, :to_i
-    alias_method :ord,    :to_i
-
-    ##
-    # 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
-
     ##
     # Returns the value as an `OpenSSL::BN` instance.
     #

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

@@ -1,9 +1,184 @@
 module RDF; class Literal
   ##
-  # Shared methods for numeric literal classes.
+  # Shared methods and class ancestry for numeric literal classes.
   #
   # @since 0.3.0
-  module Numeric
-    # TODO
+  class Numeric < Literal
+    ##
+    # Compares this literal to `other` for sorting purposes.
+    #
+    # @param  [Object] other
+    # @return [Integer] `-1`, `0`, or `1`
+    # @since  0.3.0
+    def <=>(other)
+      case other
+        when ::Numeric
+          to_d <=> other
+        when Numeric
+          to_d <=> other.to_d
+        else super
+      end
+    end
+
+    ##
+    # Returns `true` if this literal is equal to `other`.
+    #
+    # @param  [Object] other
+    # @return [Boolean] `true` or `false`
+    # @since  0.3.0
+    def ==(other)
+      # If lexically invalid, use regular literal testing
+      return super unless self.valid?
+
+      case other
+      when Literal::Numeric
+        return super unless other.valid?
+        (cmp = (self <=> other)) ? cmp.zero? : false
+      when RDF::URI, RDF::Node
+        # Interpreting SPARQL data-r2/expr-equal/eq-2-2, numeric can't be compared with other types
+        type_error("unable to determine whether #{self.inspect} and #{other.inspect} are equivalent")
+      else
+        super
+      end
+    end
+
+    ##
+    # Returns `self`.
+    #
+    # @return [RDF::Literal::Numeric]
+    # @since  0.2.3
+    def +@
+      self # unary plus
+    end
+
+    ##
+    # Returns `self` negated.
+    #
+    # @return [RDF::Literal::Numeric]
+    # @since  0.2.3
+    def -@
+      self.class.new(-self.object)
+    end
+
+    ##
+    # Returns the sum of `self` plus `other`.
+    #
+    # For xs:float or xs:double values, if one of the operands is a zero or a finite number
+    # and the other is INF or -INF, INF or -INF is returned. If both operands are INF, INF is returned.
+    # If both operands are -INF, -INF is returned. If one of the operands is INF
+    # and the other is -INF, NaN is returned.
+    # @param  [Literal::Numeric, #to_i, #to_f, #to_d] other
+    # @return [RDF::Literal::Numeric]
+    # @since  0.2.3
+    # @see http://www.w3.org/TR/xpath-functions/#func-numeric-add
+    def +(other)
+      if self.class == Double || other.class == Double
+        RDF::Literal::Double.new(to_f + other.to_f)
+      elsif self.class == Float || other.class == Float
+        RDF::Literal::Float.new(to_f + other.to_f)
+      elsif self.class == Decimal || other.class == Decimal
+        RDF::Literal::Decimal.new(to_d + (other.respond_to?(:to_d) ? other.to_d : BigDecimal(other.to_s)))
+      else
+        RDF::Literal::Integer.new(to_i + other.to_i)
+      end
+    end
+
+    ##
+    # Returns the difference of `self` minus `other`.
+    #
+    # @param  [Literal::Numeric, #to_i, #to_f, #to_d] other
+    # @return [RDF::Literal::Numeric]
+    # @since  0.2.3
+    # @see http://www.w3.org/TR/xpath-functions/#func-numeric-subtract
+    def -(other)
+      if self.class == Double || other.class == Double
+        RDF::Literal::Double.new(to_f - other.to_f)
+      elsif self.class == Float || other.class == Float
+        RDF::Literal::Float.new(to_f - other.to_f)
+      elsif self.class == Decimal || other.class == Decimal
+        RDF::Literal::Decimal.new(to_d - (other.respond_to?(:to_d) ? other.to_d : BigDecimal(other.to_s)))
+      else
+        RDF::Literal::Integer.new(to_i - other.to_i)
+      end
+    end
+
+    ##
+    # Returns the product of `self` times `other`.
+    #
+    # @param  [Literal::Numeric, #to_i, #to_f, #to_d] other
+    # @return [RDF::Literal::Numeric]
+    # @since  0.2.3
+    # @see http://www.w3.org/TR/xpath-functions/#func-numeric-multiply
+    def *(other)
+      if self.class == Double || other.class == Double
+        RDF::Literal::Double.new(to_f * other.to_f)
+      elsif self.class == Float || other.class == Float
+        RDF::Literal::Float.new(to_f * other.to_f)
+      elsif self.class == Decimal || other.class == Decimal
+        RDF::Literal::Decimal.new(to_d * (other.respond_to?(:to_d) ? other.to_d : BigDecimal(other.to_s)))
+      else
+        RDF::Literal::Integer.new(to_i * other.to_i)
+      end
+    end
+
+    ##
+    # Returns the quotient of `self` divided by `other`.
+    #
+    # As a special case, if the types of both $arg1 and $arg2 are xs:integer,
+    # then the return type is xs:decimal.
+    #
+    # @param  [Literal::Numeric, #to_i, #to_f, #to_d] other
+    # @return [RDF::Literal::Numeric]
+    # @raise  [ZeroDivisionError] if divided by zero
+    # @since  0.2.3
+    # @see http://www.w3.org/TR/xpath-functions/#func-numeric-divide
+    def /(other)
+      if self.class == Double || other.class == Double
+        RDF::Literal::Double.new(to_f / other.to_f)
+      elsif self.class == Float || other.class == Float
+        RDF::Literal::Float.new(to_f / other.to_f)
+      elsif self.class == Decimal || other.class == Decimal
+        RDF::Literal::Decimal.new(to_d / (other.respond_to?(:to_d) ? other.to_d : BigDecimal(other.to_s)))
+      else
+        RDF::Literal::Integer.new(to_i / other.to_i)
+      end
+    end
+
+    ##
+    # Returns the value as an integer.
+    #
+    # @return [Integer]
+    def to_i
+      @object.to_i
+    end
+    alias_method :to_int, :to_i
+    alias_method :ord,    :to_i
+
+    ##
+    # 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]
+    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 # Numeric
 end; end # RDF::Literal

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

@@ -1,3 +1,4 @@
+# coding: utf-8
 module RDF; class Literal
   ##
   # A time literal.
@@ -16,14 +17,14 @@ module RDF; class Literal
     # @param  [Time] value
     # @option options [String] :lexical (nil)
     def initialize(value, options = {})
-      @datatype = RDF::URI(options[:datatype] || DATATYPE)
+      @datatype = RDF::URI(options[:datatype] || self.class.const_get(:DATATYPE))
       @string   = options[:lexical] if options.has_key?(:lexical)
-      @string   = value if !defined?(@string) && value.is_a?(String)
+      @string   ||= value if 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 rescue nil
     end
 
     ##
@@ -51,5 +52,24 @@ module RDF; class Literal
     def to_s
       @string || @object.strftime('%H:%M:%S%Z').sub(/\+00:00|UTC/, 'Z')
     end
+
+    ##
+    # Equal compares as Time objects
+    def ==(other)
+      # If lexically invalid, use regular literal testing
+      return super unless self.valid?
+
+      case other
+      when Literal::Time
+        return super unless other.valid?
+        # Compare as strings, as time includes a date portion, and adjusting for UTC
+        # can create a mismatch in the date portion.
+        self.object.utc.strftime('%H%M%S') == other.object.utc.strftime('%H%M%S')
+      when Literal::DateTime, Literal::Date
+        false
+      else
+        super
+      end
+    end
   end # Time
 end; end # RDF::Literal

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

@@ -12,9 +12,9 @@ module RDF; class Literal
     # @param  [Symbol, #to_s]  value
     # @option options [String] :lexical (nil)
     def initialize(value, options = {})
-      @datatype = RDF::URI(options[:datatype] || DATATYPE)
+      @datatype = RDF::URI(options[:datatype] || self.class.const_get(:DATATYPE))
       @string   = options[:lexical] if options.has_key?(:lexical)
-      @string   = value if !defined?(@string) && value.is_a?(String)
+      @string   ||= value if value.is_a?(String)
       @object   = value.is_a?(Symbol) ? value : value.to_s
     end
 

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

@@ -13,7 +13,7 @@ module RDF; class Literal
     # @param  [Object] value
     # @option options [String] :lexical (nil)
     def initialize(value, options = {})
-      @datatype = options[:datatype] || DATATYPE
+      @datatype = options[:datatype] || self.class.const_get(:DATATYPE)
       @string   = options[:lexical] if options.has_key?(:lexical)
       @object   = value # TODO: parse XML string using REXML
     end

data/lib/rdf/model/node.rb

@@ -44,6 +44,23 @@ module RDF
       self.new(id)
     end
 
+    ##
+    # Override #dup to remember original object.
+    # This allows .eql? to determine that two nodes
+    # are the same thing, and not different nodes
+    # instantiated with the same identifier.
+    # @return [RDF::Node]
+    def dup
+      node = super
+      node.original = self.original || self
+      node
+    end
+
+    ##
+    # Originally instantiated node, if any
+    # @return [RDF::Node]
+    attr_accessor :original
+
     # @return [String]
     attr_accessor :id
 
@@ -88,23 +105,36 @@ module RDF
     end
 
     ##
-    # Checks whether this blank node is equal to `other`.
+    # Determins if `self` is the same term as `other`.
+    #
+    # In this case, nodes must be the same object
     #
     # @param  [Node] other
     # @return [Boolean]
     def eql?(other)
-      other.is_a?(Node) && self == other
+      other.is_a?(RDF::Node) && (self.original || self).equal?(other.original || other)
     end
 
     ##
-    # Checks whether this blank node is equal to `other`.
+    # Checks whether this blank node is equal to `other` (type checking).
+    #
+    # In this case, different nodes having the same id are considered the same.
+    #
+    # Per SPARQL data-r2/expr-equal/eq-2-2, numeric can't be compared with other types
     #
     # @param  [Object] other
     # @return [Boolean]
+    # @see http://www.w3.org/TR/rdf-sparql-query/#func-RDFterm-equal
     def ==(other)
-      other.respond_to?(:node?) && other.node? &&
-        other.respond_to?(:id) && @id == other.id
+      case other
+      when Literal
+        # If other is a Literal, reverse test to consolodate complex type checking logic
+        other == self
+      else 
+        other.respond_to?(:node?) && other.node? && other.respond_to?(:id) && @id == other.id
+      end
     end
+    alias_method :===, :==
 
     ##
     # Returns a string representation of this blank node.