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

Returns a new instance of Node.

Parameters:

  • id (#to_s) (defaults to: nil) 


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

Returns:

  • (String) 


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

def id
  @id
end

#original ⇒ RDF::Node

Originally instantiated node, if any

Returns:



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

Parameters:

  • format (:default, :compact) (defaults to: :default) —

    (:default)

Returns:



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

Parameters:

  • other (Object)

Returns:

  • (Boolean)

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.

Returns:

  • (Boolean) 


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.

Returns:



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

Parameters:

Returns:

  • (Boolean) 


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.

Returns:

  • (Integer) 


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

def hash
  @id.hash
end

#labeled? ⇒ Boolean

Returns false.

Returns:

  • (Boolean) 


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

Returns:

  • (self) 


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.

Returns:

  • (Boolean) 


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.

Returns:

  • (String) 


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.

Returns:

  • (Symbol)

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

Returns:

  • (String) 


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