Class: RDF::Literal

Inherits:

Object

• Object
• RDF::Literal

show all

Includes:

Term

Defined in:

lib/rdf/model/literal.rb,
lib/rdf/model/literal/xml.rb,
lib/rdf/model/literal/time.rb,
lib/rdf/model/literal/date.rb,
lib/rdf/model/literal/token.rb,
lib/rdf/model/literal/double.rb,
lib/rdf/model/literal/integer.rb,
lib/rdf/model/literal/boolean.rb,
lib/rdf/model/literal/numeric.rb,
lib/rdf/model/literal/decimal.rb,
lib/rdf/model/literal/datetime.rb

Overview

value = RDF::Literal.new("Hello, world!")
value.plain?                                   #=> true`

value = RDF::Literal.new("Hello!", :language => :en)
value.has_language?                            #=> true
value.language                                 #=> :en

RDF::Literal.new("Wazup?", :language => :en-US")
RDF::Literal.new("Hej!",   :language => :sv)
RDF::Literal.new("¡Hola!", :language => :es)

value = RDF::Literal.new("2009-12-31", :datatype => RDF::XSD.date)
value.has_datatype?                            #=> true
value.datatype                                 #=> RDF::XSD.date

value = RDF::Literal.new(Date.today)
value.has_datatype?                            #=> true
value.datatype                                 #=> RDF::XSD.date

RDF::Literal.new(false).datatype               #=> XSD.boolean
RDF::Literal.new(true).datatype                #=> XSD.boolean
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.dateTime
RDF::Literal.new(Date.new(2010)).datatype      #=> XSD.date
RDF::Literal.new(DateTime.new(2010)).datatype  #=> XSD.dateTime

Defined Under Namespace

Classes: Boolean, Date, DateTime, Decimal, Double, Integer, Numeric, Time, Token, XML

Constant Summary

TRUE =

RDF::Literal.new(true).freeze

FALSE =

RDF::Literal.new(false).freeze

ZERO =

RDF::Literal.new(0).freeze

Instance Attribute Summary (collapse)

• - (URI) datatype

  The XML Schema datatype URI (optional).

• - (Symbol) language

  The language tag (optional).

Instance Method Summary (collapse)

• - (Boolean) ==(other) (also: #===)

  Returns true if this literal is equivalent to other (with type check).

• - (Boolean) anonymous?

  Returns false.

• - (RDF::Literal) canonicalize

  Returns a copy of this literal converted into its canonical lexical representation.

• - (RDF::Literal) canonicalize!

  Converts this literal into its canonical lexical representation.

• - (Boolean) comperable_datatype?(other)

  Returns true if the literal has a datatype and the comparison should return false instead of raise a type error.

• - (Boolean) eql?(other)

  Determins if self is the same term as other.

• - (Boolean) has_datatype? (also: #datatype?, #typed?, #datatyped?)

  Returns true if this is a datatyped literal.

• - (Boolean) has_language? (also: #language?)

  Returns true if this is a language-tagged literal.

• - (Fixnum) hash

  Returns a hash code for this literal.

• - (Literal) initialize(value, options = {}) constructor

  A new instance of Literal.

• - (String) inspect

  Returns a developer-friendly representation of self.

• - (Boolean) invalid?

  Returns true if the value does not adhere to the defined grammar of the datatype.

• - (Boolean) literal?

  Returns true.

• - (Object) object
• - (Boolean) plain? (also: #simple?)

  Returns true if this is a plain literal.

• - (String) to_s

  Returns the value as a string.

• - (Boolean) valid?

  Returns true if the value adheres to the defined grammar of the datatype.

• - (RDF::Literal) validate! (also: #validate)

  Validates the value using #valid?, raising an error if the value is invalid.

• - (String) value

  Returns the value as a string.

Methods included from Term

#<=>, #constant?, #variable?

Methods included from Value

#graph?, #inspect!, #iri?, #node?, #resource?, #statement?, #to_ntriples, #to_quad, #to_rdf, #type_error, #uri?, #variable?

139
140
141
142
143
144
145
146

# File 'lib/rdf/model/literal.rb', line 139

def initialize(value, options = {})
  @object   = value
  @string   = options[:lexical] if options[:lexical]
  @string   = value if !defined?(@string) && value.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)
end

133
134
135

# File 'lib/rdf/model/literal.rb', line 133

def datatype
  @datatype
end

130
131
132

# File 'lib/rdf/model/literal.rb', line 130

def language
  @language
end

RDF::Literal(1) == RDF::Literal(1.0)     #=> true

213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235

# File 'lib/rdf/model/literal.rb', line 213

def ==(other)
  case other
  when Literal
    case
    when self.eql?(other)
      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 == other.value
    when (self.simple? || self.datatype == XSD.string) && (other.simple? || other.datatype == XSD.string)
      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
      # 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.plain? && self.value.eql?(other)
  else false
  end
end

174
175
176

# File 'lib/rdf/model/literal.rb', line 174

def anonymous?
  false
end

341
342
343

# File 'lib/rdf/model/literal.rb', line 341

def canonicalize
  self.dup.canonicalize!
end

352
353
354
355

# File 'lib/rdf/model/literal.rb', line 352

def canonicalize!
  @language = @language.to_s.downcase.to_sym if @language
  self
end

297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317

# File 'lib/rdf/model/literal.rb', line 297

def comperable_datatype?(other)
  return false unless self.plain? || self.has_language?

  case other
  when RDF::Literal::Numeric, RDF::Literal::Boolean,
       RDF::Literal::Date, RDF::Literal::Time, RDF::Literal::DateTime
    # 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
  end
end

RDF::Literal(1).eql?(RDF::Literal(1.0))  #=> false

194
195
196
197
198
199
200

# File 'lib/rdf/model/literal.rb', line 194

def eql?(other)
  self.equal?(other) ||
    (self.class.eql?(other.class) &&
     self.value.eql?(other.value) &&
     self.language.to_s.downcase.eql?(other.language.to_s.downcase) &&
     self.datatype.eql?(other.datatype))
end

263
264
265

# File 'lib/rdf/model/literal.rb', line 263

def has_datatype?
  !datatype.nil?
end

253
254
255

# File 'lib/rdf/model/literal.rb', line 253

def has_language?
  !language.nil?
end

182
183
184

# File 'lib/rdf/model/literal.rb', line 182

def hash
  to_s.hash
end

369
370
371

# File 'lib/rdf/model/literal.rb', line 369

def inspect
  sprintf("#<%s:%#0x(%s)>", self.class.name, __id__, RDF::NTriples.serialize(self))
end

287
288
289

# File 'lib/rdf/model/literal.rb', line 287

def invalid?
  !valid?
end

166
167
168

# File 'lib/rdf/model/literal.rb', line 166

def literal?
  true
end

158
159
160

# File 'lib/rdf/model/literal.rb', line 158

def object
  defined?(@object) ? @object : value
end

243
244
245

# File 'lib/rdf/model/literal.rb', line 243

def plain?
  language.nil? && datatype.nil?
end

361
362
363

# File 'lib/rdf/model/literal.rb', line 361

def to_s
  @object.to_s
end

276
277
278
279

# File 'lib/rdf/model/literal.rb', line 276

def valid?
  grammar = self.class.const_get(:GRAMMAR) rescue nil
  grammar.nil? || !!(value =~ grammar)
end

326
327
328
329

# File 'lib/rdf/model/literal.rb', line 326

def validate!
  raise ArgumentError, "#{to_s.inspect} is not a valid <#{datatype.to_s}> literal" if invalid?
  self
end

152
153
154

# File 'lib/rdf/model/literal.rb', line 152

def value
  @string || to_s
end