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.1.0/bundler/gems/rdf-4f45c0ed29ed/lib/rdf/mixin/enumerable.rb,
vendor/bundler/ruby/3.1.0/bundler/gems/rdf-isomorphic-2f7c8aa9c15d/lib/rdf/isomorphic.rb,
vendor/bundler/ruby/3.1.0/bundler/gems/rdf-n3-a55d2ffecc58/lib/rdf/n3/extensions.rb,
vendor/bundler/ruby/3.1.0/bundler/gems/rdf-reasoner-be0d84e6547b/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}


796
797
798
799
800
801
802
803
# File 'vendor/bundler/ruby/3.1.0/bundler/gems/rdf-4f45c0ed29ed/lib/rdf/mixin/enumerable.rb', line 796

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.1.0/bundler/gems/rdf-n3-a55d2ffecc58/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.1.0/bundler/gems/rdf-n3-a55d2ffecc58/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.1.0/bundler/gems/rdf-reasoner-be0d84e6547b/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



781
782
783
784
785
# File 'vendor/bundler/ruby/3.1.0/bundler/gems/rdf-4f45c0ed29ed/lib/rdf/mixin/enumerable.rb', line 781

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



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

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:



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

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:



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

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:



308
309
310
311
312
313
314
315
# File 'vendor/bundler/ruby/3.1.0/bundler/gems/rdf-4f45c0ed29ed/lib/rdf/mixin/enumerable.rb', line 308

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:



180
181
182
183
184
185
186
# File 'vendor/bundler/ruby/3.1.0/bundler/gems/rdf-4f45c0ed29ed/lib/rdf/mixin/enumerable.rb', line 180

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:



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

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



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

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:



245
246
247
248
249
250
251
252
# File 'vendor/bundler/ruby/3.1.0/bundler/gems/rdf-4f45c0ed29ed/lib/rdf/mixin/enumerable.rb', line 245

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.1.0/bundler/gems/rdf-reasoner-be0d84e6547b/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



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

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:



523
524
525
# File 'vendor/bundler/ruby/3.1.0/bundler/gems/rdf-4f45c0ed29ed/lib/rdf/mixin/enumerable.rb', line 523

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:



456
457
458
# File 'vendor/bundler/ruby/3.1.0/bundler/gems/rdf-4f45c0ed29ed/lib/rdf/mixin/enumerable.rb', line 456

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.



322
323
324
325
326
# File 'vendor/bundler/ruby/3.1.0/bundler/gems/rdf-4f45c0ed29ed/lib/rdf/mixin/enumerable.rb', line 322

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:



195
196
197
198
199
200
201
# File 'vendor/bundler/ruby/3.1.0/bundler/gems/rdf-4f45c0ed29ed/lib/rdf/mixin/enumerable.rb', line 195

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:



390
391
392
# File 'vendor/bundler/ruby/3.1.0/bundler/gems/rdf-4f45c0ed29ed/lib/rdf/mixin/enumerable.rb', line 390

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



609
610
611
# File 'vendor/bundler/ruby/3.1.0/bundler/gems/rdf-4f45c0ed29ed/lib/rdf/mixin/enumerable.rb', line 609

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.



259
260
261
262
263
# File 'vendor/bundler/ruby/3.1.0/bundler/gems/rdf-4f45c0ed29ed/lib/rdf/mixin/enumerable.rb', line 259

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)


636
637
638
# File 'vendor/bundler/ruby/3.1.0/bundler/gems/rdf-4f45c0ed29ed/lib/rdf/mixin/enumerable.rb', line 636

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



622
623
624
625
626
627
628
# File 'vendor/bundler/ruby/3.1.0/bundler/gems/rdf-4f45c0ed29ed/lib/rdf/mixin/enumerable.rb', line 622

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



115
116
117
# File 'vendor/bundler/ruby/3.1.0/bundler/gems/rdf-4f45c0ed29ed/lib/rdf/mixin/enumerable.rb', line 115

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)


481
482
483
# File 'vendor/bundler/ruby/3.1.0/bundler/gems/rdf-4f45c0ed29ed/lib/rdf/mixin/enumerable.rb', line 481

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:



468
469
470
471
472
473
474
# File 'vendor/bundler/ruby/3.1.0/bundler/gems/rdf-4f45c0ed29ed/lib/rdf/mixin/enumerable.rb', line 468

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)


415
416
417
# File 'vendor/bundler/ruby/3.1.0/bundler/gems/rdf-4f45c0ed29ed/lib/rdf/mixin/enumerable.rb', line 415

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:



402
403
404
405
406
407
408
# File 'vendor/bundler/ruby/3.1.0/bundler/gems/rdf-4f45c0ed29ed/lib/rdf/mixin/enumerable.rb', line 402

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



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

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)


282
283
284
# File 'vendor/bundler/ruby/3.1.0/bundler/gems/rdf-4f45c0ed29ed/lib/rdf/mixin/enumerable.rb', line 282

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:



273
274
275
# File 'vendor/bundler/ruby/3.1.0/bundler/gems/rdf-4f45c0ed29ed/lib/rdf/mixin/enumerable.rb', line 273

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)


809
810
811
812
# File 'vendor/bundler/ruby/3.1.0/bundler/gems/rdf-4f45c0ed29ed/lib/rdf/mixin/enumerable.rb', line 809

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)


151
152
153
154
155
156
157
158
# File 'vendor/bundler/ruby/3.1.0/bundler/gems/rdf-4f45c0ed29ed/lib/rdf/mixin/enumerable.rb', line 151

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:



137
138
139
# File 'vendor/bundler/ruby/3.1.0/bundler/gems/rdf-4f45c0ed29ed/lib/rdf/mixin/enumerable.rb', line 137

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)


349
350
351
# File 'vendor/bundler/ruby/3.1.0/bundler/gems/rdf-4f45c0ed29ed/lib/rdf/mixin/enumerable.rb', line 349

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:



336
337
338
339
340
341
342
# File 'vendor/bundler/ruby/3.1.0/bundler/gems/rdf-4f45c0ed29ed/lib/rdf/mixin/enumerable.rb', line 336

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



91
92
93
# File 'vendor/bundler/ruby/3.1.0/bundler/gems/rdf-4f45c0ed29ed/lib/rdf/mixin/enumerable.rb', line 91

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



561
562
563
564
565
566
567
# File 'vendor/bundler/ruby/3.1.0/bundler/gems/rdf-4f45c0ed29ed/lib/rdf/mixin/enumerable.rb', line 561

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



539
540
541
542
543
544
545
546
547
548
# File 'vendor/bundler/ruby/3.1.0/bundler/gems/rdf-4f45c0ed29ed/lib/rdf/mixin/enumerable.rb', line 539

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



730
731
732
# File 'vendor/bundler/ruby/3.1.0/bundler/gems/rdf-4f45c0ed29ed/lib/rdf/mixin/enumerable.rb', line 730

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:



754
755
756
757
758
759
760
761
762
# File 'vendor/bundler/ruby/3.1.0/bundler/gems/rdf-4f45c0ed29ed/lib/rdf/mixin/enumerable.rb', line 754

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



741
742
743
744
# File 'vendor/bundler/ruby/3.1.0/bundler/gems/rdf-4f45c0ed29ed/lib/rdf/mixin/enumerable.rb', line 741

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)


220
221
222
# File 'vendor/bundler/ruby/3.1.0/bundler/gems/rdf-4f45c0ed29ed/lib/rdf/mixin/enumerable.rb', line 220

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:



211
212
213
# File 'vendor/bundler/ruby/3.1.0/bundler/gems/rdf-4f45c0ed29ed/lib/rdf/mixin/enumerable.rb', line 211

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



101
102
103
104
105
106
107
# File 'vendor/bundler/ruby/3.1.0/bundler/gems/rdf-4f45c0ed29ed/lib/rdf/mixin/enumerable.rb', line 101

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



124
125
126
127
# File 'vendor/bundler/ruby/3.1.0/bundler/gems/rdf-4f45c0ed29ed/lib/rdf/mixin/enumerable.rb', line 124

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