Module: RDF::Enumerable

Extended by:
Util::Aliasing::LateBound
Includes:
Enumerable, Countable, Isomorphic
Included in:
JSON::LD::Resource, Dataset, Enumerator, Graph, List, MergeGraph, N3::Algebra::Builtin, N3::Algebra::Formula, N3::Reasoner, Normalize::Carroll2001, Normalize::URDNA2015, Query, Query::Solution, Queryable::Enumerator, Reader, Transaction, SHACL::ValidationReport, SHACL::ValidationResult
Defined in:
vendor/bundler/ruby/3.0.0/bundler/gems/rdf-237066655558/lib/rdf/mixin/enumerable.rb,
vendor/bundler/ruby/3.0.0/bundler/gems/rdf-237066655558/lib/rdf/mixin/enumerator.rb,
vendor/bundler/ruby/3.0.0/bundler/gems/rdf-isomorphic-7565b54588b0/lib/rdf/isomorphic.rb,
vendor/bundler/ruby/3.0.0/bundler/gems/rdf-n3-7f928f0a0762/lib/rdf/n3/extensions.rb,
vendor/bundler/ruby/3.0.0/bundler/gems/rdf-reasoner-bfa7ce119263/lib/rdf/reasoner/extensions.rb

Overview

Extend RDF::Enumerables with these functions.

Defined Under Namespace

Classes: Enumerator

Constant Summary collapse

@@entailments =
{}

Instance Attribute Summary collapse

Class Method Summary collapse

Instance Method Summary collapse

Methods included from Util::Aliasing::LateBound

alias_method

Methods included from Isomorphic

#bijection_to, #isomorphic_with?

Methods included from Countable

#count, #empty?

Dynamic Method Handling

This class handles dynamic methods through the method_missing method

#String (protected)

Implements #to_writer for each available instance of Writer, based on the writer symbol.

Returns:

See Also:

  • RDF::Enumerable.{RDF{RDF::Writer{RDF::Writer.sym}


784
785
786
787
788
789
790
791
# File 'vendor/bundler/ruby/3.0.0/bundler/gems/rdf-237066655558/lib/rdf/mixin/enumerable.rb', line 784

def method_missing(meth, *args)
  writer = RDF::Writer.for(meth.to_s[3..-1].to_sym) if meth.to_s[0,3] == "to_"
  if writer
    writer.buffer(standard_prefixes: true) {|w| w << self}
  else
    super
  end
end

Instance Attribute Details

#existentialsArray<RDF::Query::Variable>

Existential quantifiers defined on this enumerable



10
11
12
# File 'vendor/bundler/ruby/3.0.0/bundler/gems/rdf-n3-7f928f0a0762/lib/rdf/n3/extensions.rb', line 10

def existentials
  @existentials
end

#universalsArray<RDF::Query::Variable>

Universal quantifiers defined on this enumerable



14
15
16
# File 'vendor/bundler/ruby/3.0.0/bundler/gems/rdf-n3-7f928f0a0762/lib/rdf/n3/extensions.rb', line 14

def universals
  @universals
end

Class Method Details

.add_entailment(method, proc) ⇒ Object

Add an entailment method. The method accepts no arguments, and returns or yields an array of values associated with the particular entailment method

Parameters:



148
149
150
# File 'vendor/bundler/ruby/3.0.0/bundler/gems/rdf-reasoner-bfa7ce119263/lib/rdf/reasoner/extensions.rb', line 148

def add_entailment(method, proc)
  @@entailments[method] = proc
end

Instance Method Details

#dump(*args, **options) ⇒ String

Returns a serialized string representation of self.

Before calling this method you may need to explicitly require a serialization extension for the specified format.

Examples:

Serializing into N-Triples format

require 'rdf/ntriples'
ntriples = enumerable.dump(:ntriples)

Parameters:

Returns:

Raises:

See Also:

Since:

  • 0.2.0



769
770
771
772
773
# File 'vendor/bundler/ruby/3.0.0/bundler/gems/rdf-237066655558/lib/rdf/mixin/enumerable.rb', line 769

def dump(*args, **options)
  writer = RDF::Writer.for(*args)
  raise RDF::WriterError, "No writer found using #{args.inspect}" unless writer
  writer.dump(self, nil, **options)
end

#each_graph {|graph| ... } #each_graphEnumerator<RDF::Graph>

Iterates the given block for each RDF graph in self.

If no block was given, returns an enumerator.

The order in which graphs are yielded is undefined.

Overloads:

See Also:

Since:

  • 0.1.9



687
688
689
690
691
692
693
694
695
696
697
698
# File 'vendor/bundler/ruby/3.0.0/bundler/gems/rdf-237066655558/lib/rdf/mixin/enumerable.rb', line 687

def each_graph
  if block_given?
    yield RDF::Graph.new(graph_name: nil, data: self)
    # FIXME: brute force, repositories should override behavior
    if supports?(:graph_name)
      enum_statement.map(&:graph_name).uniq.compact.each do |graph_name|
        yield RDF::Graph.new(graph_name: graph_name, data: self)
      end
    end
  end
  enum_graph
end

#each_object {|object| ... } #each_objectEnumerator<RDF::Term>

Iterates the given block for each unique RDF object term.

If no block was given, returns an enumerator.

The order in which values are yielded is undefined.

Overloads:

  • #each_object {|object| ... }

    This method returns an undefined value.

    Yields:

    • (object)

      each object term

    Yield Parameters:

    Yield Returns:

    • (void)

      ignored

  • #each_objectEnumerator<RDF::Term>

    Returns:

See Also:



492
493
494
495
496
497
498
499
500
501
502
503
504
# File 'vendor/bundler/ruby/3.0.0/bundler/gems/rdf-237066655558/lib/rdf/mixin/enumerable.rb', line 492

def each_object # FIXME: deduplication
  if block_given?
    values = {}
    each_statement do |statement|
      value = statement.object
      unless value.nil? || values.include?(value)
        values[value] = true
        yield value
      end
    end
  end
  enum_object
end

#each_predicate {|predicate| ... } #each_predicateEnumerator<RDF::URI>

Iterates the given block for each unique RDF predicate term.

If no block was given, returns an enumerator.

The order in which values are yielded is undefined.

Overloads:

  • #each_predicate {|predicate| ... }

    This method returns an undefined value.

    Yields:

    • (predicate)

      each predicate term

    Yield Parameters:

    Yield Returns:

    • (void)

      ignored

  • #each_predicateEnumerator<RDF::URI>

    Returns:

See Also:



425
426
427
428
429
430
431
432
433
434
435
436
437
# File 'vendor/bundler/ruby/3.0.0/bundler/gems/rdf-237066655558/lib/rdf/mixin/enumerable.rb', line 425

def each_predicate
  if block_given?
    values = {}
    each_statement do |statement|
      value = statement.predicate
      unless value.nil? || values.include?(value.to_s)
        values[value.to_s] = true
        yield value
      end
    end
  end
  enum_predicate
end

#each_quad {|subject, predicate, object, graph_name| ... } #each_quadEnumerator<Array(RDF::Resource, RDF::URI, RDF::Term, RDF::Resource)>

Iterates the given block for each RDF quad.

If no block was given, returns an enumerator.

The order in which quads are yielded is undefined.

Overloads:

See Also:



296
297
298
299
300
301
302
303
# File 'vendor/bundler/ruby/3.0.0/bundler/gems/rdf-237066655558/lib/rdf/mixin/enumerable.rb', line 296

def each_quad
  if block_given?
    each_statement do |statement|
      yield(*statement.to_quad)
    end
  end
  enum_quad
end

#each_statement {|statement| ... } #each_statementEnumerator<RDF::Statement>

Iterates the given block for each RDF statement.

If no block was given, returns an enumerator.

The order in which statements are yielded is undefined.

Overloads:

See Also:



168
169
170
171
172
173
174
# File 'vendor/bundler/ruby/3.0.0/bundler/gems/rdf-237066655558/lib/rdf/mixin/enumerable.rb', line 168

def each_statement(&block)
  if block_given?
    # Invoke {#each} in the containing class:
    each(&block)
  end
  enum_statement
end

#each_subject {|subject| ... } #each_subjectEnumerator<RDF::Resource>

Iterates the given block for each unique RDF subject term.

If no block was given, returns an enumerator.

The order in which values are yielded is undefined.

Overloads:

See Also:



359
360
361
362
363
364
365
366
367
368
369
370
371
# File 'vendor/bundler/ruby/3.0.0/bundler/gems/rdf-237066655558/lib/rdf/mixin/enumerable.rb', line 359

def each_subject
  if block_given?
    values = {}
    each_statement do |statement|
      value = statement.subject
      unless value.nil? || values.include?(value.to_s)
        values[value.to_s] = true
        yield value
      end
    end
  end
  enum_subject
end

#each_term {|term| ... } #each_termEnumerator<RDF::Term>

Iterates the given block for each unique RDF term (subject, predicate, object, or graph_name).

If no block was given, returns an enumerator.

The order in which values are yielded is undefined.

Overloads:

See Also:

Since:

  • 2.0



576
577
578
579
580
581
582
583
584
585
586
587
588
589
# File 'vendor/bundler/ruby/3.0.0/bundler/gems/rdf-237066655558/lib/rdf/mixin/enumerable.rb', line 576

def each_term
  if block_given?
    values = {}
    each_statement do |statement|
      statement.terms.each do |value|
        unless values.include?(value.hash)
          values[value.hash] = true
          yield value
        end
      end
    end
  end
  enum_term
end

#each_triple {|subject, predicate, object| ... } #each_tripleEnumerator<Array(RDF::Resource, RDF::URI, RDF::Term)>

Iterates the given block for each RDF triple.

If no block was given, returns an enumerator.

The order in which triples are yielded is undefined.

Overloads:

See Also:



233
234
235
236
237
238
239
240
# File 'vendor/bundler/ruby/3.0.0/bundler/gems/rdf-237066655558/lib/rdf/mixin/enumerable.rb', line 233

def each_triple
  if block_given?
    each_statement do |statement|
      yield(*statement.to_triple)
    end
  end
  enum_triple
end

#entail {|statement| ... } #entailEnumerator

Perform entailments on this enumerable in a single pass, yielding entailed statements.

For best results, either run rules separately expanding the enumberated graph, or run repeatedly until no new statements are added to the enumerable containing both original and entailed statements. As :subClassOf and :subPropertyOf entailments are implicitly recursive, this may not be necessary except for extreme cases.

Overloads:

  • #entail {|statement| ... }

    This method returns an undefined value.

    Parameters:

    • *rules (Array<Symbol>)

      Registered entailment method(s).

    Yields:

    • statement

    Yield Parameters:

  • #entailEnumerator

    Parameters:

    • *rules (Array<Symbol>)

      Registered entailment method(s)

    Returns:



169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
# File 'vendor/bundler/ruby/3.0.0/bundler/gems/rdf-reasoner-bfa7ce119263/lib/rdf/reasoner/extensions.rb', line 169

def entail(*rules, &block)
  if block_given?
    rules = %w(subClassOf subPropertyOf domain range).map(&:to_sym) if rules.empty?

    self.each do |statement|
      rules.each {|rule| statement.entail(rule, &block)}
    end
  else
    # Otherwise, return an Enumerator with the entailed statements
    this = self
    RDF::Queryable::Enumerator.new do |yielder|
      this.entail(*rules) {|y| yielder << y}
    end
  end
end

#enum_graphEnumerator<RDF::Graph> Also known as: enum_graphs

Returns an enumerator for #each_graph.

Returns:

See Also:

Since:

  • 0.1.9



706
707
708
# File 'vendor/bundler/ruby/3.0.0/bundler/gems/rdf-237066655558/lib/rdf/mixin/enumerable.rb', line 706

def enum_graph
  enum_for(:each_graph)
end

#enum_objectEnumerator<RDF::Term> Also known as: enum_objects

Returns an enumerator for #each_object.

Returns:

See Also:



511
512
513
# File 'vendor/bundler/ruby/3.0.0/bundler/gems/rdf-237066655558/lib/rdf/mixin/enumerable.rb', line 511

def enum_object
  enum_for(:each_object)
end

#enum_predicateEnumerator<RDF::URI> Also known as: enum_predicates

Returns an enumerator for #each_predicate.

Returns:

See Also:



444
445
446
# File 'vendor/bundler/ruby/3.0.0/bundler/gems/rdf-237066655558/lib/rdf/mixin/enumerable.rb', line 444

def enum_predicate
  enum_for(:each_predicate)
end

#enum_quadEnumerator<Array(RDF::Resource, RDF::URI, RDF::Term, RDF::Resource)> Also known as: enum_quads

Returns an enumerator for #each_quad.



310
311
312
313
314
# File 'vendor/bundler/ruby/3.0.0/bundler/gems/rdf-237066655558/lib/rdf/mixin/enumerable.rb', line 310

def enum_quad
  Countable::Enumerator.new do |yielder|
    each_quad {|s, p, o, c| yielder << [s, p, o, c]}
  end
end

#enum_statementEnumerator<RDF::Statement> Also known as: enum_statements

Returns an enumerator for #each_statement. FIXME: enum_for doesn't seem to be working properly in JRuby 1.7, so specs are marked pending

Returns:

See Also:



183
184
185
186
187
188
189
# File 'vendor/bundler/ruby/3.0.0/bundler/gems/rdf-237066655558/lib/rdf/mixin/enumerable.rb', line 183

def enum_statement
  # Ensure that statements are queryable, countable and enumerable
  this = self
  Queryable::Enumerator.new do |yielder|
    this.send(:each_statement) {|y| yielder << y}
  end
end

#enum_subjectEnumerator<RDF::Resource> Also known as: enum_subjects

Returns an enumerator for #each_subject.

Returns:

See Also:



378
379
380
# File 'vendor/bundler/ruby/3.0.0/bundler/gems/rdf-237066655558/lib/rdf/mixin/enumerable.rb', line 378

def enum_subject
  enum_for(:each_subject)
end

#enum_termEnumerator<RDF::Term> Also known as: enum_terms

Returns an enumerator for #each_term.

Returns:

See Also:

Since:

  • 2.0



597
598
599
# File 'vendor/bundler/ruby/3.0.0/bundler/gems/rdf-237066655558/lib/rdf/mixin/enumerable.rb', line 597

def enum_term
  enum_for(:each_term)
end

#enum_tripleEnumerator<Array(RDF::Resource, RDF::URI, RDF::Term)> Also known as: enum_triples

Returns an enumerator for #each_triple.



247
248
249
250
251
# File 'vendor/bundler/ruby/3.0.0/bundler/gems/rdf-237066655558/lib/rdf/mixin/enumerable.rb', line 247

def enum_triple
  Countable::Enumerator.new do |yielder|
    each_triple {|s, p, o| yielder << [s, p, o]}
  end
end

#graph?(graph_name) ⇒ Boolean Also known as: has_graph?

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)


624
625
626
# File 'vendor/bundler/ruby/3.0.0/bundler/gems/rdf-237066655558/lib/rdf/mixin/enumerable.rb', line 624

def graph?(graph_name)
  enum_statement.any? {|s| s.graph_name == graph_name}
end

#graph_names(unique: true) ⇒ Array<RDF::Resource>

Returns all unique RDF graph names, other than the default graph.

Parameters:

  • unique (true) (defaults to: true)

Returns:

See Also:

Since:

  • 2.0



610
611
612
613
614
615
616
# File 'vendor/bundler/ruby/3.0.0/bundler/gems/rdf-237066655558/lib/rdf/mixin/enumerable.rb', line 610

def graph_names(unique: true)
  unless unique
    enum_statement.map(&:graph_name).compact # TODO: optimize
  else
    enum_graph.map(&:graph_name).compact
  end
end

#invalid?Boolean

Returns true if value is not valid

Returns:

  • (Boolean)

    true or false

Raises:

  • (NotImplementedError)

    unless enumerable supports validation

Since:

  • 0.2.1



103
104
105
# File 'vendor/bundler/ruby/3.0.0/bundler/gems/rdf-237066655558/lib/rdf/mixin/enumerable.rb', line 103

def invalid?
  !valid?
end

#object?(value) ⇒ Boolean Also known as: has_object?

Returns true if self contains the given RDF object term.

Parameters:

Returns:

  • (Boolean)


469
470
471
# File 'vendor/bundler/ruby/3.0.0/bundler/gems/rdf-237066655558/lib/rdf/mixin/enumerable.rb', line 469

def object?(value)
  enum_object.include?(value)
end

#objects(unique: true) ⇒ Array<RDF::Term>

Returns all unique RDF object terms.

Parameters:

  • unique (true) (defaults to: true)

Returns:

See Also:



456
457
458
459
460
461
462
# File 'vendor/bundler/ruby/3.0.0/bundler/gems/rdf-237066655558/lib/rdf/mixin/enumerable.rb', line 456

def objects(unique: true)
  unless unique
    enum_statement.map(&:object) # TODO: optimize
  else
    enum_object.to_a
  end
end

#predicate?(value) ⇒ Boolean Also known as: has_predicate?

Returns true if self contains the given RDF predicate term.

Parameters:

Returns:

  • (Boolean)


403
404
405
# File 'vendor/bundler/ruby/3.0.0/bundler/gems/rdf-237066655558/lib/rdf/mixin/enumerable.rb', line 403

def predicate?(value)
  enum_predicate.include?(value)
end

#predicates(unique: true) ⇒ Array<RDF::URI>

Returns all unique RDF predicate terms.

Parameters:

  • unique (true) (defaults to: true)

Returns:

See Also:



390
391
392
393
394
395
396
# File 'vendor/bundler/ruby/3.0.0/bundler/gems/rdf-237066655558/lib/rdf/mixin/enumerable.rb', line 390

def predicates(unique: true)
  unless unique
    enum_statement.map(&:predicate) # TODO: optimize
  else
    enum_predicate.to_a
  end
end

#project_graph(graph_name) {|statement| ... } #project_graph(graph_name) ⇒ Enumerable

Limits statements to be from a specific graph.

If no block was given, returns an enumerator.

The order in which statements are yielded is undefined.

Overloads:

  • #project_graph(graph_name) {|statement| ... }

    This method returns an undefined value.

    Parameters:

    • graph_name (RDF::Resource, nil)

      The name of the graph from which statements are taken. Use nil for the default graph.

    Yields:

    • (statement)

      each statement

    Yield Parameters:

    Yield Returns:

    • (void)

      ignored

  • #project_graph(graph_name) ⇒ Enumerable

    Parameters:

    • graph_name (RDF::Resource, false)

      The name of the graph from which statements are taken. Use false for the default graph.

    Returns:

See Also:

Since:

  • 3.0



654
655
656
657
658
659
660
661
662
663
664
665
666
# File 'vendor/bundler/ruby/3.0.0/bundler/gems/rdf-237066655558/lib/rdf/mixin/enumerable.rb', line 654

def project_graph(graph_name)
  if block_given?
    self.each do |statement|
      yield statement if statement.graph_name == graph_name
    end
  else
    # Ensure that statements are queryable, countable and enumerable
    this = self
    Queryable::Enumerator.new do |yielder|
      this.send(:project_graph, graph_name) {|y| yielder << y}
    end
  end
end

#quad?(quad) ⇒ Boolean Also known as: has_quad?

Returns true if self contains the given RDF quad.

Parameters:

Returns:

  • (Boolean)


270
271
272
# File 'vendor/bundler/ruby/3.0.0/bundler/gems/rdf-237066655558/lib/rdf/mixin/enumerable.rb', line 270

def quad?(quad)
  quads.include?(quad)
end

#quads(**options) ⇒ Array<Array(RDF::Resource, RDF::URI, RDF::Term, RDF::Resource)>

Returns all RDF quads.

Parameters:

Returns:

See Also:



261
262
263
# File 'vendor/bundler/ruby/3.0.0/bundler/gems/rdf-237066655558/lib/rdf/mixin/enumerable.rb', line 261

def quads(**options)
  enum_statement.map(&:to_quad) # TODO: optimize
end

#respond_to_missing?(name, include_private = false) ⇒ Boolean (protected)

Note:

this instantiates an writer; it could probably be done more efficiently by refactoring RDF::Reader and/or RDF::Format to expose a list of valid format symbols.

Returns:

  • (Boolean)


797
798
799
800
# File 'vendor/bundler/ruby/3.0.0/bundler/gems/rdf-237066655558/lib/rdf/mixin/enumerable.rb', line 797

def respond_to_missing?(name, include_private = false)
  return RDF::Writer.for(name.to_s[3..-1].to_sym) if name.to_s[0,3] == 'to_'
  super
end

#statement?Boolean #statement?(statement) ⇒ Boolean Also known as: has_statement?, include?

Overloads:

  • #statement?Boolean

    Returns false indicating this is not an RDF::Statemenet.

    Returns:

    • (Boolean)

    See Also:

  • #statement?(statement) ⇒ Boolean

    Returns true if self contains the given RDF statement.

    Parameters:

    Returns:

    • (Boolean)


139
140
141
142
143
144
145
146
# File 'vendor/bundler/ruby/3.0.0/bundler/gems/rdf-237066655558/lib/rdf/mixin/enumerable.rb', line 139

def statement?(*args)
  case args.length
  when 0 then false
  when 1
    args.first && !enum_statement.find { |s| s.eql?(args.first) }.nil?        
  else raise ArgumentError("wrong number of arguments (given #{args.length}, expected 0 or 1)")
  end
end

#statements(**options) ⇒ Array<RDF::Statement>

Returns all RDF statements.

Parameters:

Returns:

See Also:



125
126
127
# File 'vendor/bundler/ruby/3.0.0/bundler/gems/rdf-237066655558/lib/rdf/mixin/enumerable.rb', line 125

def statements(**options)
  enum_statement.to_a
end

#subject?(value) ⇒ Boolean Also known as: has_subject?

Returns true if self contains the given RDF subject term.

Parameters:

Returns:

  • (Boolean)


337
338
339
# File 'vendor/bundler/ruby/3.0.0/bundler/gems/rdf-237066655558/lib/rdf/mixin/enumerable.rb', line 337

def subject?(value)
  enum_subject.include?(value)
end

#subjects(unique: true) ⇒ Array<RDF::Resource>

Returns all unique RDF subject terms.

Parameters:

  • unique (true) (defaults to: true)

Returns:

See Also:



324
325
326
327
328
329
330
# File 'vendor/bundler/ruby/3.0.0/bundler/gems/rdf-237066655558/lib/rdf/mixin/enumerable.rb', line 324

def subjects(unique: true)
  unless unique
    enum_statement.map(&:subject) # TODO: optimize
  else
    enum_subject.to_a
  end
end

#supports?(feature) ⇒ Boolean

Returns true if this enumerable supports the given feature.

Supported features include:

  • :graph_name supports statements with a graph_name, allowing multiple named graphs
  • :inference supports RDFS inferrence of queryable contents.
  • :literal_equality' preserves [term-equality](https://www.w3.org/TR/rdf11-concepts/#dfn-literal-term-equality) for literals. Literals are equal only if their lexical values and datatypes are equal, character by character. Literals may be "inlined" to value-space for efficiency only if:literal_equalityisfalse`.
  • :validity allows a concrete Enumerable implementation to indicate that it does or does not support valididty checking. By default implementations are assumed to support validity checking.
  • :skolemize supports Skolemization of an Enumerable. Implementations supporting this feature must implement a #skolemize method, taking a base URI used for minting URIs for BNodes as stable identifiers and a #deskolemize method, also taking a base URI used for turning URIs having that prefix back into the same BNodes which were originally skolemized.
  • :rdfstar supports RDF* where statements may be subjects or objects of other statements.

Parameters:

Returns:

  • (Boolean)

Since:

  • 0.3.5



79
80
81
# File 'vendor/bundler/ruby/3.0.0/bundler/gems/rdf-237066655558/lib/rdf/mixin/enumerable.rb', line 79

def supports?(feature)
  feature == :validity || feature == :literal_equality
end

#term?Boolean #term?(value) ⇒ Boolean Also known as: has_term?

Overloads:

  • #term?Boolean

    Returns false indicating this is not an RDF::Statemenet.

    Returns:

    • (Boolean)

    See Also:

  • #term?(value) ⇒ Boolean

    Returns true if self contains the given RDF subject term.

    Parameters:

    Returns:

    • (Boolean)

    Since:

    • 2.0



549
550
551
552
553
554
555
# File 'vendor/bundler/ruby/3.0.0/bundler/gems/rdf-237066655558/lib/rdf/mixin/enumerable.rb', line 549

def term?(*args)
  case args.length
  when 0 then super
  when 1 then args.first && enum_term.include?(args.first)
  else raise ArgumentError("wrong number of arguments (given #{args.length}, expected 0 or 1)")
  end
end

#terms(unique: true) ⇒ Array<RDF::Resource>

Returns all unique RDF terms (subjects, predicates, objects, and graph_names).

Examples:

finding all Blank Nodes used within an enumerable

enumberable.terms.select(&:node?)

Parameters:

  • unique (true) (defaults to: true)

Returns:

See Also:

  • #each_resource
  • #enum_resource

Since:

  • 2.0



527
528
529
530
531
532
533
534
535
536
# File 'vendor/bundler/ruby/3.0.0/bundler/gems/rdf-237066655558/lib/rdf/mixin/enumerable.rb', line 527

def terms(unique: true)
  unless unique
    enum_statement.
      map(&:terms).
      flatten.
      compact
  else
    enum_term.to_a
  end
end

#to_aArray

Returns all RDF statements in self as an array.

Mixes in RDF::Enumerable into the returned object.

Returns:

Since:

  • 0.2.0



718
719
720
# File 'vendor/bundler/ruby/3.0.0/bundler/gems/rdf-237066655558/lib/rdf/mixin/enumerable.rb', line 718

def to_a
  super.extend(RDF::Enumerable)
end

#to_hHash

Returns all RDF object terms indexed by their subject and predicate terms.

The return value is a Hash instance that has the structure: {subject => {predicate => [*objects]}}.

Returns:



742
743
744
745
746
747
748
749
750
# File 'vendor/bundler/ruby/3.0.0/bundler/gems/rdf-237066655558/lib/rdf/mixin/enumerable.rb', line 742

def to_h
  result = {}
  each_statement do |statement|
    result[statement.subject] ||= {}
    values = (result[statement.subject][statement.predicate] ||= [])
    values << statement.object unless values.include?(statement.object)
  end
  result
end

#to_setSet

Returns all RDF statements in self as a set.

Mixes in RDF::Enumerable into the returned object.

Returns:

  • (Set)

Since:

  • 0.2.0



729
730
731
732
# File 'vendor/bundler/ruby/3.0.0/bundler/gems/rdf-237066655558/lib/rdf/mixin/enumerable.rb', line 729

def to_set
  require 'set' unless defined?(::Set)
  super.extend(RDF::Enumerable)
end

#triple?(triple) ⇒ Boolean Also known as: has_triple?

Returns true if self contains the given RDF triple.

Parameters:

Returns:

  • (Boolean)


208
209
210
# File 'vendor/bundler/ruby/3.0.0/bundler/gems/rdf-237066655558/lib/rdf/mixin/enumerable.rb', line 208

def triple?(triple)
  triples.include?(triple)
end

#triples(**options) ⇒ Array<Array(RDF::Resource, RDF::URI, RDF::Term)>

Returns all RDF triples.

Parameters:

Returns:

See Also:



199
200
201
# File 'vendor/bundler/ruby/3.0.0/bundler/gems/rdf-237066655558/lib/rdf/mixin/enumerable.rb', line 199

def triples(**options)
  enum_statement.map(&:to_triple) # TODO: optimize
end

#valid?Boolean

Returns true if all statements are valid

Returns:

  • (Boolean)

    true or false

Raises:

  • (NotImplementedError)

    unless enumerable supports validation

Since:

  • 0.3.11



89
90
91
92
93
94
95
# File 'vendor/bundler/ruby/3.0.0/bundler/gems/rdf-237066655558/lib/rdf/mixin/enumerable.rb', line 89

def valid?
  raise NotImplementedError, "#{self.class} does not support validation" unless supports?(:validity)
  each_statement do |s|
    return false if s.invalid?
  end
  true
end

#validate!RDF::Enumerable Also known as: validate

Default validate! implementation, overridden in concrete classes

Returns:

Raises:

  • (ArgumentError)

    if the value is invalid

Since:

  • 0.3.9



112
113
114
115
# File 'vendor/bundler/ruby/3.0.0/bundler/gems/rdf-237066655558/lib/rdf/mixin/enumerable.rb', line 112

def validate!
  raise ArgumentError if supports?(:validity) && invalid?
  self
end