openlogic-rdf 0.3.6

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

@@ -0,0 +1,121 @@
+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 = 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 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 this literal into its canonical lexical representation.
+    #
+    # @return [RDF::Literal] `self`
+    # @see    http://www.w3.org/TR/xmlschema-2/#boolean-canonical-representation
+    def canonicalize!
+      @string = (@object ? :true : :false).to_s
+      self
+    end
+
+    ##
+    # 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 TrueClass, FalseClass
+          to_i <=> (other ? 1 : 0)
+        when RDF::Literal::Boolean
+          to_i <=> other.to_i
+        else super
+      end
+    end
+
+    ##
+    # Returns `true` if this literal is equivalent 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?
+
+      other = Literal::Boolean.new(other) if other.class == TrueClass || other.class == FalseClass
+
+      case other
+      when Literal::Boolean
+        return super unless other.valid?
+        (cmp = (self <=> other)) ? cmp.zero? : false
+      else
+        super
+      end
+    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] `0` or `1`
+    # @since  0.3.0
+    def to_i
+      @object ? 1 : 0
+    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
+
+    ##
+    # Returns a developer-friendly representation of `self`.
+    #
+    # @return [String]
+    def inspect
+      case
+        when self.equal?(RDF::Literal::TRUE)  then 'RDF::Literal::TRUE'
+        when self.equal?(RDF::Literal::FALSE) then 'RDF::Literal::FALSE'
+        else super
+      end
+    end
+  end # Boolean
+end; end # RDF::Literal

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

@@ -0,0 +1,73 @@
+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
+    FORMAT   = '%Y-%m-%d%Z'.freeze
+
+    ##
+    # @param  [Date] 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?(::Date)         then value
+        when value.respond_to?(:to_date) then value.to_date # Ruby 1.9+
+        else ::Date.parse(value.to_s)
+      end rescue nil
+    end
+
+    ##
+    # Converts this literal into its canonical lexical representation.
+    #
+    # @return [RDF::Literal] `self`
+    # @see    http://www.w3.org/TR/xmlschema-2/#date
+    def canonicalize!
+      @string = @object.strftime(FORMAT).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 && value !~ %r(\A0000)
+    end
+
+    ##
+    # Returns the value as a string.
+    #
+    # @return [String]
+    def to_s
+      @string || @object.strftime(FORMAT).sub(/\+00:00|UTC/, 'Z')
+    end
+
+    ##
+    # Equal compares as Date objects
+    def ==(other)
+      # If lexically invalid, use regular literal testing
+      return super unless self.valid?
+
+      case other
+      when Literal::Date
+        return super unless other.valid?
+        self.object == other.object
+      when Literal::Time, Literal::DateTime
+        false
+      else
+        super
+      end
+    end
+  end # Date
+end; end # RDF::Literal

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

@@ -0,0 +1,72 @@
+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 = 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?(::DateTime)         then value
+        when value.respond_to?(:to_datetime) then value.to_datetime # Ruby 1.9+
+        else ::DateTime.parse(value.to_s)
+      end rescue nil
+    end
+
+    ##
+    # Converts this literal into its canonical lexical representation.
+    #
+    # @return [RDF::Literal] `self`
+    # @see    http://www.w3.org/TR/xmlschema-2/#dateTime
+    def canonicalize!
+      @string = @object.new_offset(0).strftime('%Y-%m-%dT%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 && value !~ %r(\A0000)
+    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
+
+    ##
+    # Equal compares as DateTime objects
+    def ==(other)
+      # If lexically invalid, use regular literal testing
+      return super unless self.valid?
+
+      case other
+      when Literal::DateTime
+        return super unless other.valid?
+        self.object == other.object
+      when Literal::Time, Literal::Date
+        false
+      else
+        super
+      end
+    end
+  end # DateTime
+end; end # RDF::Literal

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

@@ -0,0 +1,86 @@
+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 < Numeric
+    DATATYPE = XSD.decimal
+    GRAMMAR  = /^[\+\-]?\d+(\.\d*)?$/.freeze
+
+    ##
+    # @param  [BigDecimal] 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?(BigDecimal) then value
+        else BigDecimal(value.to_s)
+      end
+    end
+
+    ##
+    # Converts this literal into its canonical lexical representation.
+    #
+    # @return [RDF::Literal] `self`
+    # @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
+      @object = BigDecimal(@string) unless @object.nil?
+      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 the value as a string.
+    #
+    # @return [String]
+    # @see    BigDecimal#to_s
+    def to_s
+      @string || @object.to_s('F')
+    end
+  end # Decimal
+end; end # RDF::Literal

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

@@ -0,0 +1,189 @@
+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 < Numeric
+    DATATYPE = XSD.double
+    GRAMMAR  = /^NaN|(?:[\+\-]?(?:INF|(?:\d+(\.\d*)?([eE][\+\-]?\d+)?)))$/.freeze
+
+    ##
+    # @param  [Float, #to_f] 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?(::String) then case value
+          when 'INF'  then 1/0.0
+          when '-INF' then -1/0.0
+          when 'NaN'  then 0/0.0
+          else Float(value) rescue nil
+        end
+        when value.is_a?(::Float)     then value
+        when value.respond_to?(:to_f) then value.to_f
+        else Float(value.to_s) rescue nil # FIXME
+      end
+    end
+
+    ##
+    # Converts this literal into its canonical lexical representation.
+    #
+    # @return [RDF::Literal] `self`
+    # @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
+      @object = Float(@string) unless @object.nil?
+      self
+    end
+
+    ##
+    # 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 RDF::Literal::Decimal, RDF::Literal::Double
+          to_d <=> other.to_d
+        else super
+      end
+    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 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
+  end # Double
+end; end # RDF::Literal

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

@@ -0,0 +1,126 @@
+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
+  # @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
+
+    ##
+    # @param  [Integer, #to_i] 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?(::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 this literal into its canonical lexical representation.
+    #
+    # @return [RDF::Literal] `self`
+    # @see    http://www.w3.org/TR/xmlschema-2/#integer
+    def canonicalize!
+      @string = @object.to_s if @object
+      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 the value as a string.
+    #
+    # @return [String]
+    def to_s
+      @string || @object.to_s
+    end
+
+    ##
+    # Returns the value as an `OpenSSL::BN` instance.
+    #
+    # @return [OpenSSL::BN]
+    # @see    http://ruby-doc.org/stdlib/libdoc/openssl/rdoc/classes/OpenSSL/BN.html
+    # @since  0.2.4
+    def to_bn
+      require 'openssl' unless defined?(OpenSSL::BN)
+      OpenSSL::BN.new(to_s)
+    end
+  end # Integer
+end; end # RDF::Literal