rdf 0.2.2 → 0.2.3

data/lib/rdf/model/literal.rb

@@ -46,6 +46,7 @@ module RDF
     autoload :Date,     'rdf/model/literal/date'
     autoload :DateTime, 'rdf/model/literal/datetime'
     autoload :Time,     'rdf/model/literal/time'
+    autoload :Token,    'rdf/model/literal/token'
     autoload :XML,      'rdf/model/literal/xml'
 
     include RDF::Value
@@ -78,6 +79,8 @@ module RDF
               RDF::Literal::Integer
             when XSD.unsignedLong, XSD.unsignedInt, XSD.unsignedShort, XSD.unsignedByte
               RDF::Literal::Integer
+            when XSD.token, XSD.language
+              RDF::Literal::Token
             when RDF.XMLLiteral
               RDF::Literal::XML
             else self
@@ -90,7 +93,8 @@ module RDF
           when ::BigDecimal then RDF::Literal::Decimal
           when ::DateTime   then RDF::Literal::DateTime
           when ::Date       then RDF::Literal::Date
-          when ::Time       then RDF::Literal::Time
+          when ::Time       then RDF::Literal::Time # FIXME: Ruby's Time class can represent datetimes as well
+          when ::Symbol     then RDF::Literal::Token
           else self
         end
       end
@@ -171,6 +175,14 @@ module RDF
       false
     end
 
+    ##
+    # Returns a hash code for this literal.
+    #
+    # @return [Fixnum]
+    def hash
+      to_s.hash
+    end
+
     ##
     # @return [Boolean]
     def eql?(other)

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

@@ -2,6 +2,12 @@ module RDF; class Literal
   ##
   # A decimal literal.
   #
+  # @example Arithmetic with decimal literals
+  #   RDF::Literal(BigDecimal('1.0')) + 0.5   #=> RDF::Literal(BigDecimal('1.5'))
+  #   RDF::Literal(BigDecimal('1.0')) - 0.5   #=> RDF::Literal(BigDecimal('0.5'))
+  #   RDF::Literal(BigDecimal('1.0')) * 0.5   #=> RDF::Literal(BigDecimal('0.5'))
+  #   RDF::Literal(BigDecimal('1.0')) / 0.5   #=> RDF::Literal(BigDecimal('2.0'))
+  #
   # @see   http://www.w3.org/TR/xmlschema-2/#decimal
   # @since 0.2.1
   class Decimal < Literal
@@ -40,6 +46,91 @@ module RDF; class Literal
       self
     end
 
+    ##
+    # Returns the absolute value of `self`.
+    #
+    # @return [RDF::Literal]
+    # @since  0.2.3
+    def abs
+      (d = to_d) && d > 0 ? self : RDF::Literal(d.abs)
+    end
+
+    ##
+    # Returns `true` if the value is zero.
+    #
+    # @return [Boolean]
+    # @since  0.2.3
+    def zero?
+      to_d.zero?
+    end
+
+    ##
+    # Returns `self` if the value is not zero, `nil` otherwise.
+    #
+    # @return [Boolean]
+    # @since  0.2.3
+    def nonzero?
+      to_d.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_d) # unary minus
+    end
+
+    ##
+    # Returns the sum of `self` plus `other`.
+    #
+    # @param  [#to_d] other
+    # @return [RDF::Literal]
+    # @since  0.2.3
+    def +(other)
+      RDF::Literal(to_d + (other.respond_to?(:to_d) ? other.to_d : BigDecimal(other.to_s)))
+    end
+
+    ##
+    # Returns the difference of `self` minus `other`.
+    #
+    # @param  [#to_d] other
+    # @return [RDF::Literal]
+    # @since  0.2.3
+    def -(other)
+      RDF::Literal(to_d - (other.respond_to?(:to_d) ? other.to_d : BigDecimal(other.to_s)))
+    end
+
+    ##
+    # Returns the product of `self` times `other`.
+    #
+    # @param  [#to_d] other
+    # @return [RDF::Literal]
+    # @since  0.2.3
+    def *(other)
+      RDF::Literal(to_d * (other.respond_to?(:to_d) ? other.to_d : BigDecimal(other.to_s)))
+    end
+
+    ##
+    # Returns the quotient of `self` divided by `other`.
+    #
+    # @param  [#to_d] other
+    # @return [RDF::Literal]
+    # @since  0.2.3
+    def /(other)
+      RDF::Literal(to_d / (other.respond_to?(:to_d) ? other.to_d : BigDecimal(other.to_s)))
+    end
+
     ##
     # Returns the value as a string.
     #

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

@@ -2,6 +2,12 @@ module RDF; class Literal
   ##
   # An floating point number literal.
   #
+  # @example Arithmetic with floating point literals
+  #   RDF::Literal(1.0) + 0.5                 #=> RDF::Literal(1.5)
+  #   RDF::Literal(3.0) - 6                   #=> RDF::Literal(-3.0)
+  #   RDF::Literal(Math::PI) * 2              #=> RDF::Literal(Math::PI * 2)
+  #   RDF::Literal(Math::PI) / 2              #=> RDF::Literal(Math::PI / 2)
+  #
   # @see   http://www.w3.org/TR/xmlschema-2/#double
   # @since 0.2.1
   class Double < Literal
@@ -45,6 +51,165 @@ module RDF; class Literal
       self
     end
 
+    ##
+    # Returns `true` if the value is an invalid IEEE floating point number.
+    #
+    # @example
+    #   RDF::Literal(-1.0).nan?           #=> false
+    #   RDF::Literal(1.0/0.0).nan?        #=> false
+    #   RDF::Literal(0.0/0.0).nan?        #=> true
+    #
+    # @return [Boolean]
+    # @since  0.2.3
+    def nan?
+      to_f.nan?
+    end
+
+    ##
+    # Returns `true` if the value is a valid IEEE floating point number (it
+    # is not infinite, and `nan?` is `false`).
+    #
+    # @example
+    #   RDF::Literal(-1.0).finite?        #=> true
+    #   RDF::Literal(1.0/0.0).finite?     #=> false
+    #   RDF::Literal(0.0/0.0).finite?     #=> false
+    #
+    # @return [Boolean]
+    # @since  0.2.3
+    def finite?
+      to_f.finite?
+    end
+
+    ##
+    # Returns `nil`, `-1`, or `+1` depending on whether the value is finite,
+    # `-INF`, or `+INF`.
+    #
+    # @example
+    #   RDF::Literal(0.0/0.0).infinite?   #=> nil
+    #   RDF::Literal(-1.0/0.0).infinite?  #=> -1
+    #   RDF::Literal(+1.0/0.0).infinite?  #=> 1
+    #
+    # @return [Integer]
+    # @since  0.2.3
+    def infinite?
+      to_f.infinite?
+    end
+
+    ##
+    # Returns the smallest integer greater than or equal to `self`.
+    #
+    # @example
+    #   RDF::Literal(1.2).ceil            #=> RDF::Literal(2)
+    #   RDF::Literal(-1.2).ceil           #=> RDF::Literal(-1)
+    #   RDF::Literal(2.0).ceil            #=> RDF::Literal(2)
+    #   RDF::Literal(-2.0).ceil           #=> RDF::Literal(-2)
+    #
+    # @return [RDF::Literal]
+    # @since  0.2.3
+    def ceil
+      RDF::Literal(to_f.ceil)
+    end
+
+    ##
+    # Returns the largest integer less than or equal to `self`.
+    #
+    # @example
+    #   RDF::Literal(1.2).floor           #=> RDF::Literal(1)
+    #   RDF::Literal(-1.2).floor          #=> RDF::Literal(-2)
+    #   RDF::Literal(2.0).floor           #=> RDF::Literal(2)
+    #   RDF::Literal(-2.0).floor          #=> RDF::Literal(-2)
+    #
+    # @return [RDF::Literal]
+    # @since  0.2.3
+    def floor
+      RDF::Literal(to_f.floor)
+    end
+
+    ##
+    # Returns the absolute value of `self`.
+    #
+    # @return [RDF::Literal]
+    # @since  0.2.3
+    def abs
+      (f = to_f) && f > 0 ? self : RDF::Literal(f.abs)
+    end
+
+    ##
+    # Returns `true` if the value is zero.
+    #
+    # @return [Boolean]
+    # @since  0.2.3
+    def zero?
+      to_f.zero?
+    end
+
+    ##
+    # Returns `self` if the value is not zero, `nil` otherwise.
+    #
+    # @return [Boolean]
+    # @since  0.2.3
+    def nonzero?
+      to_f.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_f) # unary minus
+    end
+
+    ##
+    # Returns the sum of `self` plus `other`.
+    #
+    # @param  [#to_f] other
+    # @return [RDF::Literal]
+    # @since  0.2.3
+    def +(other)
+      RDF::Literal(to_f + other.to_f)
+    end
+
+    ##
+    # Returns the difference of `self` minus `other`.
+    #
+    # @param  [#to_f] other
+    # @return [RDF::Literal]
+    # @since  0.2.3
+    def -(other)
+      RDF::Literal(to_f - other.to_f)
+    end
+
+    ##
+    # Returns the product of `self` times `other`.
+    #
+    # @param  [#to_f] other
+    # @return [RDF::Literal]
+    # @since  0.2.3
+    def *(other)
+      RDF::Literal(to_f * other.to_f)
+    end
+
+    ##
+    # Returns the quotient of `self` divided by `other`.
+    #
+    # @param  [#to_f] other
+    # @return [RDF::Literal]
+    # @since  0.2.3
+    def /(other)
+      RDF::Literal(to_f / other.to_f)
+    end
+
     ##
     # Returns the value as a string.
     #

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

@@ -2,6 +2,12 @@ module RDF; class Literal
   ##
   # An integer literal.
   #
+  # @example Arithmetic with integer literals
+  #   RDF::Literal(40) + 2                    #=> RDF::Literal(42)
+  #   RDF::Literal(45) - 3                    #=> RDF::Literal(42)
+  #   RDF::Literal(6) * 7                     #=> RDF::Literal(42)
+  #   RDF::Literal(84) / 2                    #=> RDF::Literal(42)
+  #
   # @see   http://www.w3.org/TR/xmlschema-2/#integer
   # @since 0.2.1
   class Integer < Decimal
@@ -33,6 +39,129 @@ module RDF; class Literal
       self
     end
 
+    ##
+    # Returns the successor value of `self`.
+    #
+    # @return [RDF::Literal]
+    # @since  0.2.3
+    def pred
+      RDF::Literal(to_i.pred)
+    end
+
+    ##
+    # Returns the predecessor value of `self`.
+    #
+    # @return [RDF::Literal]
+    # @since  0.2.3
+    def succ
+      RDF::Literal(to_i.succ)
+    end
+    alias_method :next, :succ
+
+    ##
+    # Returns `true` if the value is even.
+    #
+    # @return [Boolean]
+    # @since  0.2.3
+    def even?
+      to_i.even?
+    end
+
+    ##
+    # Returns `true` if the value is odd.
+    #
+    # @return [Boolean]
+    # @since  0.2.3
+    def odd?
+      to_i.odd?
+    end
+
+    ##
+    # Returns the absolute value of `self`.
+    #
+    # @return [RDF::Literal]
+    # @since  0.2.3
+    def abs
+      (n = to_i) && n > 0 ? self : RDF::Literal(n.abs)
+    end
+
+    ##
+    # Returns `true` if the value is zero.
+    #
+    # @return [Boolean]
+    # @since  0.2.3
+    def zero?
+      to_i.zero?
+    end
+
+    ##
+    # Returns `self` if the value is not zero, `nil` otherwise.
+    #
+    # @return [Boolean]
+    # @since  0.2.3
+    def nonzero?
+      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.
     #
@@ -48,6 +177,8 @@ module RDF; class Literal
     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.