openlogic-rdf 0.3.6

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

@@ -0,0 +1,184 @@
+module RDF; class Literal
+  ##
+  # Shared methods and class ancestry for numeric literal classes.
+  #
+  # @since 0.3.0
+  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

@@ -0,0 +1,87 @@
+# coding: utf-8
+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 = RDF::URI(options[:datatype] || self.class.const_get(:DATATYPE))
+      @string   = options[:lexical] if options.has_key?(:lexical)
+      @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 rescue nil
+    end
+
+    ##
+    # Converts this 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 [RDF::Literal] `self`
+    # @see    http://www.w3.org/TR/xmlschema-2/#time
+    def canonicalize!
+      @string = @object.utc.strftime('%H:%M:%S%Z').sub(/\+00:00|UTC/, 'Z') if self.valid?
+      self
+    end
+
+    ##
+    # Returns `true` if the value adheres to the defined grammar of the
+    # datatype.
+    #
+    # Special case for date and dateTime, for which '0000' is not a valid year
+    #
+    # @return [Boolean]
+    # @since  0.2.1
+    def valid?
+      super && object
+    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
+
+    ##
+    # 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

@@ -0,0 +1,47 @@
+module RDF; class Literal
+  ##
+  # A token literal.
+  #
+  # @see   http://www.w3.org/TR/xmlschema-2/#token
+  # @since 0.2.3
+  class Token < Literal
+    DATATYPE = XSD.token
+    GRAMMAR  = /\A[^\x0D\x0A\x09]+\z/i.freeze # FIXME
+
+    ##
+    # @param  [Symbol, #to_s]  value
+    # @option options [String] :lexical (nil)
+    def initialize(value, options = {})
+      @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)
+      @object   = value.is_a?(Symbol) ? value : value.to_s
+    end
+
+    ##
+    # Converts this literal into its canonical lexical representation.
+    #
+    # @return [RDF::Literal] `self`
+    # @see    http://www.w3.org/TR/xmlschema-2/#boolean
+    def canonicalize!
+      @string = @object.to_s if @object
+      self
+    end
+
+    ##
+    # Returns the value as a symbol.
+    #
+    # @return [Symbol]
+    def to_sym
+      @object.to_sym
+    end
+
+    ##
+    # Returns the value as a string.
+    #
+    # @return [String]
+    def to_s
+      @string || @object.to_s
+    end
+  end # Token
+end; end # 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] || self.class.const_get(:DATATYPE)
+      @string   = options[:lexical] if options.has_key?(:lexical)
+      @object   = value # TODO: parse XML string using REXML
+    end
+
+    ##
+    # Converts this literal into its canonical lexical representation.
+    #
+    # @return [RDF::Literal] `self`
+    # @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 # XML
+end; end # RDF::Literal