Class: RDF::Statement

Inherits:
Object
  • Object
show all
Includes:
Resource
Defined in:
lib/rdf/model/statement.rb

Overview

An RDF statement.

Examples:

Creating an RDF statement

s = RDF::URI.new("https://rubygems.org/gems/rdf")
p = RDF::Vocab::DC.creator
o = RDF::URI.new("http://ar.to/#self")
RDF::Statement(s, p, o)

Creating an RDF statement with a graph_name

uri = RDF::URI("http://example/")
RDF::Statement(s, p, o, graph_name: uri)

Creating an RDF statement from a ‘Hash`

RDF::Statement({
  subject:   RDF::URI.new("https://rubygems.org/gems/rdf"),
  predicate: RDF::Vocab::DC.creator,
  object:    RDF::URI.new("http://ar.to/#self"),
})

Creating an RDF statement with interned nodes

RDF::Statement(:s, p, :o)

Creating an RDF statement with a string

RDF::Statement(s, p, "o")

Direct Known Subclasses

Query::Pattern

Instance Attribute Summary collapse

Class Method Summary collapse

Instance Method Summary collapse

Methods included from Resource

new, #resource?

Methods included from Term

#<=>, #compatible?, #term?, #to_base, #to_term

Methods included from Value

#anonymous?, #constant?, #inspect, #inspect!, #iri?, #list?, #literal?, #resource?, #start_with?, #term?, #to_nquads, #to_ntriples, #to_rdf, #to_term, #type_error, #uri?, #validate!

Constructor Details

#initialize(**options) ⇒ RDF::Statement #initialize(subject, predicate, object, **options) ⇒ RDF::Statement

Returns a new instance of Statement.

Overloads:

  • #initialize(**options) ⇒ RDF::Statement

    Parameters:

    • options (Hash{Symbol => Object})

    Options Hash (**options):

    • :subject (RDF::Term) — default: nil —

      A symbol is converted to an interned Node.

    • :predicate (RDF::URI) — default: nil
    • :object (RDF::Resource) — default: nil —

      if not a Resource, it is coerced to Literal or Node depending on if it is a symbol or something other than a Term.

    • :graph_name (RDF::Term) — default: nil —

      Note, in RDF 1.1, a graph name MUST be an Resource.

    • :inferred (Boolean) —

      used as a marker to record that this statement was inferred based on semantic relationships (T-Box).

    • :quoted (Boolean) —

      used as a marker to record that this statement quoted and appears as the subject or object of another RDF::Statement.

  • #initialize(subject, predicate, object, **options) ⇒ RDF::Statement

    Parameters:

    Options Hash (**options):

    • :graph_name (RDF::Term) — default: nil —

      Note, in RDF 1.1, a graph name MUST be an Resource.

    • :inferred (Boolean) —

      used as a marker to record that this statement was inferred based on semantic relationships (T-Box).

    • :quoted (Boolean) —

      used as a marker to record that this statement quoted and appears as the subject or object of another RDF::Statement.



89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
 
# File 'lib/rdf/model/statement.rb', line 89

def initialize(subject = nil, predicate = nil, object = nil, options = {})
  if subject.is_a?(Hash)
    @options   = Hash[subject] # faster subject.dup
    @subject   = @options.delete(:subject)
    @predicate = @options.delete(:predicate)
    @object    = @options.delete(:object)
  else
    @options   = !options.empty? ? Hash[options] : {}
    @subject   = subject
    @predicate = predicate
    @object    = object
  end
  @id          = @options.delete(:id) if @options.key?(:id)
  @graph_name  = @options.delete(:graph_name)
  initialize!
end

Instance Attribute Details

#graph_name ⇒ RDF::Resource

Returns:



49
50
51
 
# File 'lib/rdf/model/statement.rb', line 49

def graph_name
  @graph_name
end

#id ⇒ Object

Returns:

  • (Object) 


46
47
48
 
# File 'lib/rdf/model/statement.rb', line 46

def id
  @id
end

#object ⇒ RDF::Term

Returns:



58
59
60
 
# File 'lib/rdf/model/statement.rb', line 58

def object
  @object
end

#options ⇒ Hash{Symbol => Object}

Returns:

  • (Hash{Symbol => Object}) 


61
62
63
 
# File 'lib/rdf/model/statement.rb', line 61

def options
  @options
end

#predicate ⇒ RDF::URI

Returns:



55
56
57
 
# File 'lib/rdf/model/statement.rb', line 55

def predicate
  @predicate
end

#subject ⇒ RDF::Resource

Returns:



52
53
54
 
# File 'lib/rdf/model/statement.rb', line 52

def subject
  @subject
end

Class Method Details

.from(statement, graph_name: nil, **options) ⇒ Object

Since:

  • 0.2.2



34
35
36
37
38
39
40
41
42
43
 
# File 'lib/rdf/model/statement.rb', line 34

def self.from(statement, graph_name: nil, **options)
  case statement
    when Array, Query::Pattern
      graph_name ||= statement[3] == false ? nil : statement[3]
      self.new(statement[0], statement[1], statement[2], graph_name: graph_name, **options)
    when Statement then statement
    when Hash      then self.new(options.merge(statement))
    else raise ArgumentError, "expected RDF::Statement, Hash, or Array, but got #{statement.inspect}"
  end
end

Instance Method Details

#==(other) ⇒ Boolean

Checks statement equality as a triple.

Parameters:

  • other (Object)

Returns:

  • (Boolean)

See Also:



325
326
327
328
 
# File 'lib/rdf/model/statement.rb', line 325

def ==(other)
  to_a == Array(other) &&
    !(other.is_a?(RDF::Value) && other.list?)
end

#===(other) ⇒ Boolean

Checks statement equality with patterns.

Uses ‘#eql?` to compare each of `#subject`, `#predicate`, `#object`, and `#graph_name` to those of `other`. Any statement part which is not present in `self` is ignored.

Examples:

statement = RDF::Statement.new(RDF::URI('s'), RDF::URI('p'), RDF::URI('o'))
pattern   = RDF::Statement.new(RDF::URI('s'), RDF::URI('p'), RDF::Query::Variable.new)

# true
statement === statement
pattern   === statement
RDF::Statement.new(nil, nil, nil) === statement

# false
statement === pattern
statement === RDF::Statement.new(nil, nil, nil)

Parameters:

Returns:

  • (Boolean)

See Also:



357
358
359
360
361
362
363
 
# File 'lib/rdf/model/statement.rb', line 357

def ===(other)
  return false if object?    && !object.eql?(other.object)
  return false if predicate? && !predicate.eql?(other.predicate)
  return false if subject?   && !subject.eql?(other.subject)
  return false if graph?     && !graph_name.eql?(other.graph_name)
  return true
end

#[](index) ⇒ RDF::Term

Parameters:

  • index (Integer)

Returns:



368
369
370
371
372
373
374
375
376
 
# File 'lib/rdf/model/statement.rb', line 368

def [](index)
  case index
    when 0 then self.subject
    when 1 then self.predicate
    when 2 then self.object
    when 3 then self.graph_name
    else nil
  end
end

#[]=(index, value) ⇒ RDF::Term

Parameters:

Returns:



382
383
384
385
386
387
388
389
390
 
# File 'lib/rdf/model/statement.rb', line 382

def []=(index, value)
  case index
    when 0 then self.subject   = value
    when 1 then self.predicate = value
    when 2 then self.object    = value
    when 3 then self.graph_name   = value
    else nil
  end
end

#asserted? ⇒ Boolean

Returns:

  • (Boolean) 


207
208
209
 
# File 'lib/rdf/model/statement.rb', line 207

def asserted?
  !quoted?
end

#canonicalize ⇒ RDF::Statement

Returns a version of the statement with each position in canonical form

Returns:

  • (RDF::Statement) —

    ‘self` or nil if statement cannot be canonicalized

Since:

  • 1.0.8



433
434
435
436
437
 
# File 'lib/rdf/model/statement.rb', line 433

def canonicalize
  self.dup.canonicalize!
rescue ArgumentError
  nil
end

#canonicalize! ⇒ RDF::Statement

Canonicalizes each unfrozen term in the statement

Returns:

Raises:

  • (ArgumentError) —

    if any element cannot be canonicalized.

Since:

  • 1.0.8



418
419
420
421
422
423
424
425
426
 
# File 'lib/rdf/model/statement.rb', line 418

def canonicalize!
  self.subject.canonicalize!    if subject? && !self.subject.frozen?
  self.predicate.canonicalize!  if predicate? && !self.predicate.frozen?
  self.object.canonicalize!     if object? && !self.object.frozen?
  self.graph_name.canonicalize! if graph? && !self.graph_name.frozen?
  self.validate!
  @hash = nil
  self
end

#complete? ⇒ Boolean

Determines if the statement is complete, vs. invalid. A complete statement is one in which none of ‘subject`, `predicate`, or `object`, are nil.

Returns:

  • (Boolean)

Since:

  • 3.0



237
238
239
 
# File 'lib/rdf/model/statement.rb', line 237

def complete?
  !incomplete?
end

#embedded? ⇒ Boolean

Returns ‘true` if any element of the statement is, itself, a statement.

Returns:

  • (Boolean) 


186
187
188
 
# File 'lib/rdf/model/statement.rb', line 186

def embedded?
  subject && subject.statement? || object && object.statement?
end

#eql?(other) ⇒ Boolean

Checks statement equality as a quad.

Parameters:

Returns:

  • (Boolean)

See Also:



305
306
307
 
# File 'lib/rdf/model/statement.rb', line 305

def eql?(other)
  other.is_a?(Statement) && self.to_a.eql?(other.to_a) && (self.graph_name || false) == (other.graph_name || false)
end

#graph? ⇒ Boolean #graph?(name) ⇒ Boolean Also known as: name?, has_graph?, has_name?

Overloads:

  • #graph? ⇒ Boolean

    Returns ‘true` if the statement has a graph name.

    Returns:

    • (Boolean)
  • #graph?(name) ⇒ Boolean

    Returns ‘true` if `self` contains the given RDF graph_name.

    Parameters:

    • graph_name (RDF::Resource, false) —

      Use value ‘false` to query for the default graph_name

    Returns:

    • (Boolean) 


252
253
254
255
256
257
258
 
# File 'lib/rdf/model/statement.rb', line 252

def graph?(*args)
  case args.length
  when 0 then !!graph_name
  when 1 then graph_name == args.first
  else raise ArgumentError("wrong number of arguments (given #{args.length}, expected 0 or 1)")
  end
end

#hash ⇒ Object

Generates a Integer hash value as a quad.



311
312
313
 
# File 'lib/rdf/model/statement.rb', line 311

def hash
  @hash ||= to_quad.hash
end

#incomplete? ⇒ Boolean

Determines if the statement is incomplete, vs. invalid. An incomplete statement is one in which any of ‘subject`, `predicate`, or `object`, are nil.

Returns:

  • (Boolean)

Since:

  • 3.0



228
229
230
 
# File 'lib/rdf/model/statement.rb', line 228

def incomplete?
  to_triple.any?(&:nil?)
end

#inferred? ⇒ Boolean

Returns:

  • (Boolean) 


219
220
221
 
# File 'lib/rdf/model/statement.rb', line 219

def inferred?
  !!@options[:inferred]
end

#initialize! ⇒ Object 



108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
 
# File 'lib/rdf/model/statement.rb', line 108

def initialize!
  @graph_name   = Node.intern(@graph_name)   if @graph_name.is_a?(Symbol)
  @subject   = if @subject.is_a?(Value)
    @subject.to_term
  elsif @subject.is_a?(Symbol)
    Node.intern(@subject)
  elsif @subject.nil?
    nil
  else
    raise ArgumentError, "expected subject to be nil or a resource, was #{@subject.inspect}"
  end
  @predicate = Node.intern(@predicate) if @predicate.is_a?(Symbol)
  @object    = if @object.is_a?(Value)
    @object.to_term
  elsif @object.is_a?(Symbol)
    Node.intern(@object)
  elsif @object.nil?
    nil
  else
    Literal.new(@object)
  end
  @graph_name = if @graph_name.is_a?(Value)
    @graph_name.to_term
  elsif @graph_name.is_a?(Symbol)
    Node.intern(@graph_name)
  elsif !@graph_name
    @graph_name
  else
    raise ArgumentError, "expected graph_name to be nil or a resource, was #{@graph_name.inspect}"
  end
end

#invalid? ⇒ Boolean

Returns:

  • (Boolean) 


192
193
194
 
# File 'lib/rdf/model/statement.rb', line 192

def invalid?
  !valid?
end

#node? ⇒ Boolean Also known as: has_blank_nodes?

Returns ‘true` if any resource of this statement is a blank node or has an embedded statement including a blank node.

Returns:

  • (Boolean)

Since:

  • 2.0



290
291
292
 
# File 'lib/rdf/model/statement.rb', line 290

def node?
  to_quad.compact.any?(&:node?)
end

#object? ⇒ Boolean Also known as: has_object?

Returns:

  • (Boolean) 


279
280
281
 
# File 'lib/rdf/model/statement.rb', line 279

def object?
  !!object
end

#predicate? ⇒ Boolean Also known as: has_predicate?

Returns:

  • (Boolean) 


272
273
274
 
# File 'lib/rdf/model/statement.rb', line 272

def predicate?
  !!predicate
end

#quoted? ⇒ Boolean

Returns:

  • (Boolean) 


213
214
215
 
# File 'lib/rdf/model/statement.rb', line 213

def quoted?
  !!@options[:quoted]
end

#reified(subject: nil, id: nil, graph_name: nil) ⇒ RDF::Graph

Returns a graph containing this statement in reified form.

Parameters:

  • subject (RDF::Term) (defaults to: nil) —

    (nil) Subject of reification.

  • id (RDF::Term) (defaults to: nil) —

    (nil) Node identifier, when subject is anonymous

  • graph_name (RDF::Term) (defaults to: nil) —

    (nil) Note, in RDF 1.1, a graph name MUST be an Resource.

Returns:

See Also:



477
478
479
480
481
482
483
484
485
 
# File 'lib/rdf/model/statement.rb', line 477

def reified(subject: nil, id: nil, graph_name: nil)
  RDF::Graph.new(graph_name: graph_name) do |graph|
    subject = subject || RDF::Node.new(id)
    graph << [subject, RDF.type,      RDF[:Statement]]
    graph << [subject, RDF.subject,   self.subject]
    graph << [subject, RDF.predicate, self.predicate]
    graph << [subject, RDF.object,    self.object]
  end
end

#statement? ⇒ Boolean #statement?(statement) ⇒ Boolean

Overloads:

  • #statement? ⇒ Boolean

    Returns ‘true` if `self` is a RDF::Statement.

    Returns:

    • (Boolean)
  • #statement?(statement) ⇒ Boolean

    Returns ‘true` if `self` contains the given RDF::Statement.

    Parameters:

    Returns:

    • (Boolean) 


150
151
152
153
154
155
156
 
# File 'lib/rdf/model/statement.rb', line 150

def statement?(*args)
  case args.length
  when 0 then true
  when 1 then self == args.first || subject.statement?(*args) || object.statement?(*args)
  else raise ArgumentError("wrong number of arguments (given #{args.length}, expected 0 or 1)")
  end
end

#subject? ⇒ Boolean Also known as: has_subject?

Returns:

  • (Boolean) 


265
266
267
 
# File 'lib/rdf/model/statement.rb', line 265

def subject?
  !!subject
end

#terms ⇒ Array(RDF::Term)

Returns an array of all the non-nil non-statement terms.

Returns:



408
409
410
 
# File 'lib/rdf/model/statement.rb', line 408

def terms
  to_quad.map {|t| t.respond_to?(:terms) ? t.terms : t}.flatten.compact
end

#to_h(subject_key = :subject, predicate_key = :predicate, object_key = :object, graph_key = :graph_name) ⇒ Hash{Symbol => RDF::Term}

Returns the terms of this statement as a ‘Hash`.

Parameters:

  • subject_key (Symbol) (defaults to: :subject)
  • predicate_key (Symbol) (defaults to: :predicate)
  • object_key (Symbol) (defaults to: :object)

Returns:



446
447
448
 
# File 'lib/rdf/model/statement.rb', line 446

def to_h(subject_key = :subject, predicate_key = :predicate, object_key = :object, graph_key = :graph_name)
  {subject_key => subject, predicate_key => predicate, object_key => object, graph_key => graph_name}
end

#to_quad ⇒ Array(RDF::Term)

Returns:



394
395
396
 
# File 'lib/rdf/model/statement.rb', line 394

def to_quad
  [subject, predicate, object, graph_name]
end

#to_s ⇒ String

Returns a string representation of this statement.

Returns:



454
455
456
457
458
459
460
461
462
463
464
 
# File 'lib/rdf/model/statement.rb', line 454

def to_s
  (graph_name ? to_quad : to_triple).map do |term|
    if term.is_a?(Statement)
      "<<#{term.to_s[0..-3]}>>"
    elsif term.respond_to?(:to_base)
      term.to_base
    else
      term.inspect
    end
  end.join(" ") + " ."
end

#to_triple ⇒ Array(RDF::Term) Also known as: to_a

Returns:



400
401
402
 
# File 'lib/rdf/model/statement.rb', line 400

def to_triple
  [subject, predicate, object]
end

#valid? ⇒ Boolean

Returns:

  • (Boolean) 


198
199
200
201
202
203
 
# File 'lib/rdf/model/statement.rb', line 198

def valid?
  subject?    && subject.resource? && subject.valid? &&
  predicate?  && predicate.uri? && predicate.valid? &&
  object?     && object.term? && object.valid? &&
  (graph?      ? (graph_name.resource? && graph_name.valid?) : true)
end

#variable? ⇒ Object #variable?(variables) ⇒ Boolean

URI, Node or Literal.

@return [Boolean]

Overloads:

  • #variable? ⇒ Object

    Returns ‘true` if any element of the statement is not a

  • #variable?(variables) ⇒ Boolean

    Returns ‘true` if this statement contains any of the variables.

    Parameters:

    • variables (Array<Symbol, #to_sym>)

    Returns:

    • (Boolean) 


169
170
171
172
173
174
175
176
177
178
179
180
 
# File 'lib/rdf/model/statement.rb', line 169

def variable?(*args)
  case args.length
  when 0
    !(subject?    && subject.constant? &&
      predicate?  && predicate.constant? &&
      object?     && object.constant? &&
      (graph?     ? graph_name.constant? : true))
  when 1
    to_quad.any? {|t| t.respond_to?(:variable?) && t.variable?(*args)}
  else raise ArgumentError("wrong number of arguments (given #{args.length}, expected 0 or 1)")
  end
end