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"

Constant Summary collapse

CACHE_SIZE =
Note:

caching interned nodes means that two different invocations using the same symbol will result in the same node, which may not be appropriate depending on the graph from which it is used. RDF requires that bnodes with the same label are, in fact, different bnodes, unless they are used within the same document.

Defines the maximum number of interned Node references that can be held cached in memory at any one time.

-1 # unlimited by default

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

#canonicalize, #canonicalize!, #constant?, #graph?, #inspect, #inspect!, #invalid?, #iri?, #list?, #literal?, #resource?, #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) 


83
84
85
86
 
# File 'lib/rdf/model/node.rb', line 83

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) 


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

def id
  @id
end

#original ⇒ RDF::Node

Originally instantiated node, if any

Returns:



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

def original
  @original
end

Class Method Details

.cache ⇒ RDF::Util::Cache

Returns:



25
26
27
28
 
# File 'lib/rdf/model/node.rb', line 25

def self.cache
  require 'rdf/util/cache' unless defined?(::RDF::Util::Cache)
  @cache ||= RDF::Util::Cache.new(CACHE_SIZE)
end

.intern(id) ⇒ RDF::Node

Alias for ‘RDF::Node.new`, at the moment.

Parameters:

Returns:

Since:

  • 0.2.0



57
58
59
 
# File 'lib/rdf/model/node.rb', line 57

def self.intern(id)
  (cache[(id = id.to_s).to_sym] ||= self.new(id)).freeze
end

.uuid(grammar: nil) ⇒ RDF::Node

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

Parameters:

  • grammar (Regexp) (defaults to: nil) —

    (nil) a grammar specification that the generated UUID must match

Returns:



36
37
38
39
40
41
42
43
44
45
46
47
48
 
# File 'lib/rdf/model/node.rb', line 36

def self.uuid(grammar: nil)
  case
    when grammar
      # The UUID is generated such that its initial part is guaranteed
      # to match the given `grammar`, e.g. `/^[A-Za-z][A-Za-z0-9]*/`.
      # Some RDF storage systems (e.g. AllegroGraph) require this.
      # @see http://github.com/bendiken/rdf/pull/43
      uuid = RDF::Util::UUID.generate(options) until uuid =~ grammar
    else
      uuid = RDF::Util::UUID.generate(options)
  end
  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:



143
144
145
146
147
148
149
150
151
152
 
# File 'lib/rdf/model/node.rb', line 143

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) 


100
101
102
 
# File 'lib/rdf/model/node.rb', line 100

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:



67
68
69
70
71
 
# File 'lib/rdf/model/node.rb', line 67

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) 


129
130
131
 
# File 'lib/rdf/model/node.rb', line 129

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

#hash ⇒ Fixnum

Returns a hash code for this blank node.

Returns:

  • (Fixnum) 


118
119
120
 
# File 'lib/rdf/model/node.rb', line 118

def hash
  @id.hash
end

#labeled? ⇒ Boolean

Returns ‘false`.

Returns:

  • (Boolean) 


110
111
112
 
# File 'lib/rdf/model/node.rb', line 110

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) 


166
167
168
169
 
# File 'lib/rdf/model/node.rb', line 166

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

#node? ⇒ Boolean

Returns ‘true`.

Returns:

  • (Boolean) 


92
93
94
 
# File 'lib/rdf/model/node.rb', line 92

def node?
  true
end

#to_s ⇒ String

Returns a string representation of this blank node.

Returns:

  • (String) 


175
176
177
 
# File 'lib/rdf/model/node.rb', line 175

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



184
185
186
 
# File 'lib/rdf/model/node.rb', line 184

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) 


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

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