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::RDFC10, Query, Query::Solution, Queryable::Enumerator, Reader, Transaction, SHACL::ValidationReport, SHACL::ValidationResult
Defined in:
vendor/bundler/ruby/3.2.0/bundler/gems/rdf-c2bcdc15aedf/lib/rdf/mixin/enumerable.rb,
vendor/bundler/ruby/3.2.0/bundler/gems/rdf-isomorphic-7221f7a1f11b/lib/rdf/isomorphic.rb,
vendor/bundler/ruby/3.2.0/bundler/gems/rdf-n3-2b45a55b147e/lib/rdf/n3/extensions.rb,
vendor/bundler/ruby/3.2.0/bundler/gems/rdf-normalize-7f3a953c511f/lib/rdf/normalize.rb,
vendor/bundler/ruby/3.2.0/bundler/gems/rdf-reasoner-b7c0131d69c2/lib/rdf/reasoner/extensions.rb

Overview

Change RDF::Enumerable#canonicalize

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}


817
818
819
820
821
822
823
824
# File 'vendor/bundler/ruby/3.2.0/bundler/gems/rdf-c2bcdc15aedf/lib/rdf/mixin/enumerable.rb', line 817

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.2.0/bundler/gems/rdf-n3-2b45a55b147e/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.2.0/bundler/gems/rdf-n3-2b45a55b147e/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.2.0/bundler/gems/rdf-reasoner-b7c0131d69c2/lib/rdf/reasoner/extensions.rb', line 148

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

Instance Method Details

#canonicalizeRDF::Enumerable

Returns the resulting Enumerable result from RDF::Normalize. This also canonicalizes URIs and Literals.

Returns:



730
731
732
733
734
735
# File 'vendor/bundler/ruby/3.2.0/bundler/gems/rdf-c2bcdc15aedf/lib/rdf/mixin/enumerable.rb', line 730

def canonicalize
  this = self
  Enumerable::Enumerator.new do |yielder|
    this.send(:each_statement) {|y| yielder << y.canonicalize}
  end
end

#canonicalize!Object

Mutating canonicalization not supported

Raises:

  • NotImplementedError



741
742
743
# File 'vendor/bundler/ruby/3.2.0/bundler/gems/rdf-c2bcdc15aedf/lib/rdf/mixin/enumerable.rb', line 741

def canonicalize!
  raise NotImplementedError, "Canonicalizing enumerables not supported"
end

#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



802
803
804
805
806
# File 'vendor/bundler/ruby/3.2.0/bundler/gems/rdf-c2bcdc15aedf/lib/rdf/mixin/enumerable.rb', line 802

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



700
701
702
703
704
705
706
707
708
709
710
711
# File 'vendor/bundler/ruby/3.2.0/bundler/gems/rdf-c2bcdc15aedf/lib/rdf/mixin/enumerable.rb', line 700

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:



505
506
507
508
509
510
511
512
513
514
515
516
517
# File 'vendor/bundler/ruby/3.2.0/bundler/gems/rdf-c2bcdc15aedf/lib/rdf/mixin/enumerable.rb', line 505

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:



438
439
440
441
442
443
444
445
446
447
448
449
450
# File 'vendor/bundler/ruby/3.2.0/bundler/gems/rdf-c2bcdc15aedf/lib/rdf/mixin/enumerable.rb', line 438

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:



309
310
311
312
313
314
315
316
# File 'vendor/bundler/ruby/3.2.0/bundler/gems/rdf-c2bcdc15aedf/lib/rdf/mixin/enumerable.rb', line 309

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:



181
182
183
184
185
186
187
# File 'vendor/bundler/ruby/3.2.0/bundler/gems/rdf-c2bcdc15aedf/lib/rdf/mixin/enumerable.rb', line 181

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:



372
373
374
375
376
377
378
379
380
381
382
383
384
# File 'vendor/bundler/ruby/3.2.0/bundler/gems/rdf-c2bcdc15aedf/lib/rdf/mixin/enumerable.rb', line 372

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



589
590
591
592
593
594
595
596
597
598
599
600
601
602
# File 'vendor/bundler/ruby/3.2.0/bundler/gems/rdf-c2bcdc15aedf/lib/rdf/mixin/enumerable.rb', line 589

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:



246
247
248
249
250
251
252
253
# File 'vendor/bundler/ruby/3.2.0/bundler/gems/rdf-c2bcdc15aedf/lib/rdf/mixin/enumerable.rb', line 246

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.2.0/bundler/gems/rdf-reasoner-b7c0131d69c2/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



719
720
721
# File 'vendor/bundler/ruby/3.2.0/bundler/gems/rdf-c2bcdc15aedf/lib/rdf/mixin/enumerable.rb', line 719

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:



524
525
526
# File 'vendor/bundler/ruby/3.2.0/bundler/gems/rdf-c2bcdc15aedf/lib/rdf/mixin/enumerable.rb', line 524

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:



457
458
459
# File 'vendor/bundler/ruby/3.2.0/bundler/gems/rdf-c2bcdc15aedf/lib/rdf/mixin/enumerable.rb', line 457

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.



323
324
325
326
327
# File 'vendor/bundler/ruby/3.2.0/bundler/gems/rdf-c2bcdc15aedf/lib/rdf/mixin/enumerable.rb', line 323

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:



196
197
198
199
200
201
202
# File 'vendor/bundler/ruby/3.2.0/bundler/gems/rdf-c2bcdc15aedf/lib/rdf/mixin/enumerable.rb', line 196

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:



391
392
393
# File 'vendor/bundler/ruby/3.2.0/bundler/gems/rdf-c2bcdc15aedf/lib/rdf/mixin/enumerable.rb', line 391

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



610
611
612
# File 'vendor/bundler/ruby/3.2.0/bundler/gems/rdf-c2bcdc15aedf/lib/rdf/mixin/enumerable.rb', line 610

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.



260
261
262
263
264
# File 'vendor/bundler/ruby/3.2.0/bundler/gems/rdf-c2bcdc15aedf/lib/rdf/mixin/enumerable.rb', line 260

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)


637
638
639
# File 'vendor/bundler/ruby/3.2.0/bundler/gems/rdf-c2bcdc15aedf/lib/rdf/mixin/enumerable.rb', line 637

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



623
624
625
626
627
628
629
# File 'vendor/bundler/ruby/3.2.0/bundler/gems/rdf-c2bcdc15aedf/lib/rdf/mixin/enumerable.rb', line 623

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



116
117
118
# File 'vendor/bundler/ruby/3.2.0/bundler/gems/rdf-c2bcdc15aedf/lib/rdf/mixin/enumerable.rb', line 116

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)


482
483
484
# File 'vendor/bundler/ruby/3.2.0/bundler/gems/rdf-c2bcdc15aedf/lib/rdf/mixin/enumerable.rb', line 482

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:



469
470
471
472
473
474
475
# File 'vendor/bundler/ruby/3.2.0/bundler/gems/rdf-c2bcdc15aedf/lib/rdf/mixin/enumerable.rb', line 469

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)


416
417
418
# File 'vendor/bundler/ruby/3.2.0/bundler/gems/rdf-c2bcdc15aedf/lib/rdf/mixin/enumerable.rb', line 416

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:



403
404
405
406
407
408
409
# File 'vendor/bundler/ruby/3.2.0/bundler/gems/rdf-c2bcdc15aedf/lib/rdf/mixin/enumerable.rb', line 403

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



667
668
669
670
671
672
673
674
675
676
677
678
679
# File 'vendor/bundler/ruby/3.2.0/bundler/gems/rdf-c2bcdc15aedf/lib/rdf/mixin/enumerable.rb', line 667

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)


283
284
285
# File 'vendor/bundler/ruby/3.2.0/bundler/gems/rdf-c2bcdc15aedf/lib/rdf/mixin/enumerable.rb', line 283

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:



274
275
276
# File 'vendor/bundler/ruby/3.2.0/bundler/gems/rdf-c2bcdc15aedf/lib/rdf/mixin/enumerable.rb', line 274

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)


830
831
832
833
# File 'vendor/bundler/ruby/3.2.0/bundler/gems/rdf-c2bcdc15aedf/lib/rdf/mixin/enumerable.rb', line 830

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)


152
153
154
155
156
157
158
159
# File 'vendor/bundler/ruby/3.2.0/bundler/gems/rdf-c2bcdc15aedf/lib/rdf/mixin/enumerable.rb', line 152

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:



138
139
140
# File 'vendor/bundler/ruby/3.2.0/bundler/gems/rdf-c2bcdc15aedf/lib/rdf/mixin/enumerable.rb', line 138

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)


350
351
352
# File 'vendor/bundler/ruby/3.2.0/bundler/gems/rdf-c2bcdc15aedf/lib/rdf/mixin/enumerable.rb', line 350

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:



337
338
339
340
341
342
343
# File 'vendor/bundler/ruby/3.2.0/bundler/gems/rdf-c2bcdc15aedf/lib/rdf/mixin/enumerable.rb', line 337

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.
  • :quoted_triples supports RDF 1.2 quoted triples.
  • :base_direction supports RDF 1.2 directional language-tagged strings.

Parameters:

Returns:

  • (Boolean)

Since:

  • 0.3.5



92
93
94
# File 'vendor/bundler/ruby/3.2.0/bundler/gems/rdf-c2bcdc15aedf/lib/rdf/mixin/enumerable.rb', line 92

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



562
563
564
565
566
567
568
# File 'vendor/bundler/ruby/3.2.0/bundler/gems/rdf-c2bcdc15aedf/lib/rdf/mixin/enumerable.rb', line 562

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



540
541
542
543
544
545
546
547
548
549
# File 'vendor/bundler/ruby/3.2.0/bundler/gems/rdf-c2bcdc15aedf/lib/rdf/mixin/enumerable.rb', line 540

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:



751
752
753
# File 'vendor/bundler/ruby/3.2.0/bundler/gems/rdf-c2bcdc15aedf/lib/rdf/mixin/enumerable.rb', line 751

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:



775
776
777
778
779
780
781
782
783
# File 'vendor/bundler/ruby/3.2.0/bundler/gems/rdf-c2bcdc15aedf/lib/rdf/mixin/enumerable.rb', line 775

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



762
763
764
765
# File 'vendor/bundler/ruby/3.2.0/bundler/gems/rdf-c2bcdc15aedf/lib/rdf/mixin/enumerable.rb', line 762

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)


221
222
223
# File 'vendor/bundler/ruby/3.2.0/bundler/gems/rdf-c2bcdc15aedf/lib/rdf/mixin/enumerable.rb', line 221

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:



212
213
214
# File 'vendor/bundler/ruby/3.2.0/bundler/gems/rdf-c2bcdc15aedf/lib/rdf/mixin/enumerable.rb', line 212

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



102
103
104
105
106
107
108
# File 'vendor/bundler/ruby/3.2.0/bundler/gems/rdf-c2bcdc15aedf/lib/rdf/mixin/enumerable.rb', line 102

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



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

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