Class: RDF::Node

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

Overview

An RDF blank node, also known as an anonymous or unlabeled node.

Examples:

Creating a blank node with an implicit identifier

bnode = RDF::Node.new

Creating a blank node with an UUID identifier

bnode = RDF::Node.uuid
bnode.to_s #=> "_:504c0a30-0d11-012d-3f50-001b63cac539"

Instance Attribute Summary collapse

Class Method Summary collapse

Instance Method Summary collapse

Methods included from Resource

new, #resource?

Methods included from Term

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

Methods included from Value

#canonicalize, #canonicalize!, #constant?, #graph?, #inspect, #inspect!, #invalid?, #iri?, #list?, #literal?, #resource?, #start_with?, #statement?, #term?, #to_nquads, #to_ntriples, #to_rdf, #to_term, #type_error, #uri?, #valid?, #validate!, #variable?

Constructor Details

#initialize(id = nil) ⇒ Node 



77
78
79
80
 
# File 'lib/rdf/model/node.rb', line 77

def initialize(id = nil)
  id = nil if id.to_s.empty?
  @id = (id || "g#{__id__.to_i.abs}").to_s.freeze
end

Instance Attribute Details

#id ⇒ String 



73
74
75
 
# File 'lib/rdf/model/node.rb', line 73

def id
  @id
end

#original ⇒ RDF::Node

Originally instantiated node, if any



70
71
72
 
# File 'lib/rdf/model/node.rb', line 70

def original
  @original
end

Class Method Details

.uuid(format: :default) ⇒ RDF::Node

Returns a blank node with a random UUID-based identifier.

(Depends on availability of either uuid or uuidtools gems).

Formats supported by the UUID generator:

  • :default Produces 36 characters, including hyphens separating the UUID value parts
  • :compact Produces a 32 digits (hexadecimal) value with no hyphens
  • :urn Adds the prefix urn:uuid: to the default format

Requires that the uuid gem be loadable to use format



39
40
41
42
 
# File 'lib/rdf/model/node.rb', line 39

def self.uuid(format: :default)
  uuid = RDF::Util::UUID.generate(format: format)
  self.new(uuid)
end

Instance Method Details

#==(other) ⇒ Boolean Also known as: ===

Checks whether this blank node is equal to other (type checking).

In this case, different nodes having the same id are considered the same.

Per SPARQL data-r2/expr-equal/eq-2-2, numeric can't be compared with other types

See Also:



137
138
139
140
141
142
143
144
145
146
 
# File 'lib/rdf/model/node.rb', line 137

def ==(other)
  if other.is_a?(Literal)
    # If other is a Literal, reverse test to consolodate complex type checking logic
    other == self
  else
    other.respond_to?(:node?) && other.node? &&
      self.hash == other.to_term.hash &&
      other.respond_to?(:id) && @id == other.to_term.id
  end
end

#anonymous? ⇒ Boolean Also known as: unlabeled?

Returns true.



94
95
96
 
# File 'lib/rdf/model/node.rb', line 94

def anonymous?
  true
end

#dup ⇒ RDF::Node

Override #dup to remember original object. This allows .eql? to determine that two nodes are the same thing, and not different nodes instantiated with the same identifier.



61
62
63
64
65
 
# File 'lib/rdf/model/node.rb', line 61

def dup
  node = super
  node.original = self.original || self
  node
end

#eql?(other) ⇒ Boolean

Determines if self is the same term as other.

In this case, nodes must be the same object



123
124
125
 
# File 'lib/rdf/model/node.rb', line 123

def eql?(other)
  other.is_a?(RDF::Node) && (self.original || self).equal?(other.original || other)
end

#hash ⇒ Integer

Returns a hash code for this blank node.



112
113
114
 
# File 'lib/rdf/model/node.rb', line 112

def hash
  @id.hash
end

#labeled? ⇒ Boolean

Returns false.



104
105
106
 
# File 'lib/rdf/model/node.rb', line 104

def labeled?
  !unlabeled?
end

#make_unique! ⇒ self

Make this term identifier unique, if it is found to be shared with another node having the same identifier



160
161
162
163
 
# File 'lib/rdf/model/node.rb', line 160

def make_unique!
  @id = to_unique_base[2..-1]
  self
end

#node? ⇒ Boolean

Returns true.



86
87
88
 
# File 'lib/rdf/model/node.rb', line 86

def node?
  true
end

#to_s ⇒ String

Returns a string representation of this blank node.



169
170
171
 
# File 'lib/rdf/model/node.rb', line 169

def to_s
  "_:%s" % @id.to_s
end

#to_sym ⇒ Symbol

Returns a symbol representation of this blank node.

Since:

  • 0.2.0



178
179
180
 
# File 'lib/rdf/model/node.rb', line 178

def to_sym
  @id.to_s.to_sym
end

#to_unique_base ⇒ String

Returns a representation of this node independent of any identifier used to initialize it



153
154
155
 
# File 'lib/rdf/model/node.rb', line 153

def to_unique_base
  original ? original.to_unique_base :  "_:g#{__id__.to_i.abs}"
end