Class: RDF::Vocab::SH

Inherits:
StrictVocabulary show all
Defined in:
vendor/bundler/ruby/2.7.0/bundler/gems/rdf-vocab-ebdabd34582e/lib/rdf/vocab/sh.rb

Overview

Vocabulary for http://www.w3.org/ns/shacl#

W3C Shapes Constraint Language (SHACL) Vocabulary

This vocabulary defines terms used in SHACL, the W3C Shapes Constraint Language.

Instance Attribute Summary collapse

Method Summary

Methods inherited from StrictVocabulary

[], strict?

Methods inherited from RDF::Vocabulary

[], #[], __prefix__, _orig_each, _orig_from_sym, camelize, each, each_statement, enum_for, expand_pname, find, find_term, from_graph, from_sym, imported_from, imports, #initialize, #inspect, inspect, limit_vocabs, list, method_missing, #method_missing, ontology, properties, property, register, strict?, to_html, to_iri, to_jsonld, #to_s, to_s, to_ttl, #to_uri, to_uri, value_to_html, vocab_map

Constructor Details

This class inherits a constructor from RDF::Vocabulary

Dynamic Method Handling

This class handles dynamic methods through the method_missing method in the class RDF::Vocabulary

Instance Attribute Details

#AbstractResultRDF::Vocabulary::Term (readonly)

The base class of validation results, typically not instantiated directly.



9
10
11
# File 'vendor/bundler/ruby/2.7.0/bundler/gems/rdf-vocab-ebdabd34582e/lib/rdf/vocab/sh.rb', line 9

def AbstractResult
  @AbstractResult
end

#alternativePathRDF::Vocabulary::Term (readonly)

The (single) value of this property must be a list of path elements, representing the elements of alternative paths.



168
169
170
# File 'vendor/bundler/ruby/2.7.0/bundler/gems/rdf-vocab-ebdabd34582e/lib/rdf/vocab/sh.rb', line 168

def alternativePath
  @alternativePath
end

#andRDF::Vocabulary::Term (readonly)

RDF list of shapes to validate the value nodes against.



172
173
174
# File 'vendor/bundler/ruby/2.7.0/bundler/gems/rdf-vocab-ebdabd34582e/lib/rdf/vocab/sh.rb', line 172

def and
  @and
end

#AndConstraintComponentRDF::Vocabulary::Term (readonly)

A constraint component that can be used to test whether a value node conforms to all members of a provided list of shapes.



572
573
574
# File 'vendor/bundler/ruby/2.7.0/bundler/gems/rdf-vocab-ebdabd34582e/lib/rdf/vocab/sh.rb', line 572

def AndConstraintComponent
  @AndConstraintComponent
end

#annotationPropertyRDF::Vocabulary::Term (readonly)

The annotation property that shall be set.



176
177
178
# File 'vendor/bundler/ruby/2.7.0/bundler/gems/rdf-vocab-ebdabd34582e/lib/rdf/vocab/sh.rb', line 176

def annotationProperty
  @annotationProperty
end

#annotationValueRDF::Vocabulary::Term (readonly)

The (default) values of the annotation property.



180
181
182
# File 'vendor/bundler/ruby/2.7.0/bundler/gems/rdf-vocab-ebdabd34582e/lib/rdf/vocab/sh.rb', line 180

def annotationValue
  @annotationValue
end

#annotationVarNameRDF::Vocabulary::Term (readonly)

The name of the SPARQL variable from the SELECT clause that shall be used for the values.



184
185
186
# File 'vendor/bundler/ruby/2.7.0/bundler/gems/rdf-vocab-ebdabd34582e/lib/rdf/vocab/sh.rb', line 184

def annotationVarName
  @annotationVarName
end

#askRDF::Vocabulary::Term (readonly)

The SPARQL ASK query to execute.



188
189
190
# File 'vendor/bundler/ruby/2.7.0/bundler/gems/rdf-vocab-ebdabd34582e/lib/rdf/vocab/sh.rb', line 188

def ask
  @ask
end

#BlankNodeRDF::Vocabulary::Term (readonly)

The node kind of all blank nodes.



576
577
578
# File 'vendor/bundler/ruby/2.7.0/bundler/gems/rdf-vocab-ebdabd34582e/lib/rdf/vocab/sh.rb', line 576

def BlankNode
  @BlankNode
end

#BlankNodeOrIRIRDF::Vocabulary::Term (readonly)

The node kind of all blank nodes or IRIs.



580
581
582
# File 'vendor/bundler/ruby/2.7.0/bundler/gems/rdf-vocab-ebdabd34582e/lib/rdf/vocab/sh.rb', line 580

def BlankNodeOrIRI
  @BlankNodeOrIRI
end

#BlankNodeOrLiteralRDF::Vocabulary::Term (readonly)

The node kind of all blank nodes or literals.



584
585
586
# File 'vendor/bundler/ruby/2.7.0/bundler/gems/rdf-vocab-ebdabd34582e/lib/rdf/vocab/sh.rb', line 584

def BlankNodeOrLiteral
  @BlankNodeOrLiteral
end

#classRDF::Vocabulary::Term (readonly)

The type that all value nodes must have.



192
193
194
# File 'vendor/bundler/ruby/2.7.0/bundler/gems/rdf-vocab-ebdabd34582e/lib/rdf/vocab/sh.rb', line 192

def class
  @class
end

#ClassConstraintComponentRDF::Vocabulary::Term (readonly)

A constraint component that can be used to verify that each value node is an instance of a given type.



588
589
590
# File 'vendor/bundler/ruby/2.7.0/bundler/gems/rdf-vocab-ebdabd34582e/lib/rdf/vocab/sh.rb', line 588

def ClassConstraintComponent
  @ClassConstraintComponent
end

#closedRDF::Vocabulary::Term (readonly)

If set to true then the shape is closed.



196
197
198
# File 'vendor/bundler/ruby/2.7.0/bundler/gems/rdf-vocab-ebdabd34582e/lib/rdf/vocab/sh.rb', line 196

def closed
  @closed
end

#ClosedConstraintComponentRDF::Vocabulary::Term (readonly)

A constraint component that can be used to indicate that focus nodes must only have values for those properties that have been explicitly enumerated via sh:property/sh:path.



592
593
594
# File 'vendor/bundler/ruby/2.7.0/bundler/gems/rdf-vocab-ebdabd34582e/lib/rdf/vocab/sh.rb', line 592

def ClosedConstraintComponent
  @ClosedConstraintComponent
end

#conditionRDF::Vocabulary::Term (readonly)

The shapes that the focus nodes need to conform to before a rule is executed on them.



200
201
202
# File 'vendor/bundler/ruby/2.7.0/bundler/gems/rdf-vocab-ebdabd34582e/lib/rdf/vocab/sh.rb', line 200

def condition
  @condition
end

#conformsRDF::Vocabulary::Term (readonly)

True if the validation did not produce any validation results, and false otherwise.



204
205
206
# File 'vendor/bundler/ruby/2.7.0/bundler/gems/rdf-vocab-ebdabd34582e/lib/rdf/vocab/sh.rb', line 204

def conforms
  @conforms
end

#ConstraintComponentRDF::Vocabulary::Term (readonly)

The class of constraint components.



13
14
15
# File 'vendor/bundler/ruby/2.7.0/bundler/gems/rdf-vocab-ebdabd34582e/lib/rdf/vocab/sh.rb', line 13

def ConstraintComponent
  @ConstraintComponent
end

#constructRDF::Vocabulary::Term (readonly)

The SPARQL CONSTRUCT query to execute.



208
209
210
# File 'vendor/bundler/ruby/2.7.0/bundler/gems/rdf-vocab-ebdabd34582e/lib/rdf/vocab/sh.rb', line 208

def construct
  @construct
end

#datatypeRDF::Vocabulary::Term (readonly)

Specifies an RDF datatype that all value nodes must have.



212
213
214
# File 'vendor/bundler/ruby/2.7.0/bundler/gems/rdf-vocab-ebdabd34582e/lib/rdf/vocab/sh.rb', line 212

def datatype
  @datatype
end

#DatatypeConstraintComponentRDF::Vocabulary::Term (readonly)

A constraint component that can be used to restrict the datatype of all value nodes.



596
597
598
# File 'vendor/bundler/ruby/2.7.0/bundler/gems/rdf-vocab-ebdabd34582e/lib/rdf/vocab/sh.rb', line 596

def DatatypeConstraintComponent
  @DatatypeConstraintComponent
end

#deactivatedRDF::Vocabulary::Term (readonly)

If set to true then all nodes conform to this.



216
217
218
# File 'vendor/bundler/ruby/2.7.0/bundler/gems/rdf-vocab-ebdabd34582e/lib/rdf/vocab/sh.rb', line 216

def deactivated
  @deactivated
end

#declareRDF::Vocabulary::Term (readonly)

Links a resource with its namespace prefix declarations.



220
221
222
# File 'vendor/bundler/ruby/2.7.0/bundler/gems/rdf-vocab-ebdabd34582e/lib/rdf/vocab/sh.rb', line 220

def declare
  @declare
end

#defaultValueRDF::Vocabulary::Term (readonly)

A default value for a property, for example for user interface tools to pre-populate input fields.



224
225
226
# File 'vendor/bundler/ruby/2.7.0/bundler/gems/rdf-vocab-ebdabd34582e/lib/rdf/vocab/sh.rb', line 224

def defaultValue
  @defaultValue
end

#descriptionRDF::Vocabulary::Term (readonly)

Human-readable descriptions for the property in the context of the surrounding shape.



228
229
230
# File 'vendor/bundler/ruby/2.7.0/bundler/gems/rdf-vocab-ebdabd34582e/lib/rdf/vocab/sh.rb', line 228

def description
  @description
end

#detailRDF::Vocabulary::Term (readonly)

Links a result with other results that provide more details, for example to describe violations against nested shapes.



232
233
234
# File 'vendor/bundler/ruby/2.7.0/bundler/gems/rdf-vocab-ebdabd34582e/lib/rdf/vocab/sh.rb', line 232

def detail
  @detail
end

#disjointRDF::Vocabulary::Term (readonly)

Specifies a property where the set of values must be disjoint with the value nodes.



236
237
238
# File 'vendor/bundler/ruby/2.7.0/bundler/gems/rdf-vocab-ebdabd34582e/lib/rdf/vocab/sh.rb', line 236

def disjoint
  @disjoint
end

#DisjointConstraintComponentRDF::Vocabulary::Term (readonly)

A constraint component that can be used to verify that the set of value nodes is disjoint with the the set of nodes that have the focus node as subject and the value of a given property as predicate.



600
601
602
# File 'vendor/bundler/ruby/2.7.0/bundler/gems/rdf-vocab-ebdabd34582e/lib/rdf/vocab/sh.rb', line 600

def DisjointConstraintComponent
  @DisjointConstraintComponent
end

#entailmentRDF::Vocabulary::Term (readonly)

An entailment regime that indicates what kind of inferencing is required by a shapes graph.



240
241
242
# File 'vendor/bundler/ruby/2.7.0/bundler/gems/rdf-vocab-ebdabd34582e/lib/rdf/vocab/sh.rb', line 240

def entailment
  @entailment
end

#equalsRDF::Vocabulary::Term (readonly)

Specifies a property that must have the same values as the value nodes.



244
245
246
# File 'vendor/bundler/ruby/2.7.0/bundler/gems/rdf-vocab-ebdabd34582e/lib/rdf/vocab/sh.rb', line 244

def equals
  @equals
end

#EqualsConstraintComponentRDF::Vocabulary::Term (readonly)

A constraint component that can be used to verify that the set of value nodes is equal to the set of nodes that have the focus node as subject and the value of a given property as predicate.



604
605
606
# File 'vendor/bundler/ruby/2.7.0/bundler/gems/rdf-vocab-ebdabd34582e/lib/rdf/vocab/sh.rb', line 604

def EqualsConstraintComponent
  @EqualsConstraintComponent
end

#expressionRDF::Vocabulary::Term (readonly)

The node expression that must return true for the value nodes.



248
249
250
# File 'vendor/bundler/ruby/2.7.0/bundler/gems/rdf-vocab-ebdabd34582e/lib/rdf/vocab/sh.rb', line 248

def expression
  @expression
end

#ExpressionConstraintComponentRDF::Vocabulary::Term (readonly)

A constraint component that can be used to verify that a given node expression produces true for all value nodes.



608
609
610
# File 'vendor/bundler/ruby/2.7.0/bundler/gems/rdf-vocab-ebdabd34582e/lib/rdf/vocab/sh.rb', line 608

def ExpressionConstraintComponent
  @ExpressionConstraintComponent
end

#filterShapeRDF::Vocabulary::Term (readonly)

The shape that all input nodes of the expression need to conform to.



252
253
254
# File 'vendor/bundler/ruby/2.7.0/bundler/gems/rdf-vocab-ebdabd34582e/lib/rdf/vocab/sh.rb', line 252

def filterShape
  @filterShape
end

#flagsRDF::Vocabulary::Term (readonly)

An optional flag to be used with regular expression pattern matching.



256
257
258
# File 'vendor/bundler/ruby/2.7.0/bundler/gems/rdf-vocab-ebdabd34582e/lib/rdf/vocab/sh.rb', line 256

def flags
  @flags
end

#focusNodeRDF::Vocabulary::Term (readonly)

The focus node that was validated when the result was produced.



260
261
262
# File 'vendor/bundler/ruby/2.7.0/bundler/gems/rdf-vocab-ebdabd34582e/lib/rdf/vocab/sh.rb', line 260

def focusNode
  @focusNode
end

#FunctionRDF::Vocabulary::Term (readonly)

The class of SHACL functions.



17
18
19
# File 'vendor/bundler/ruby/2.7.0/bundler/gems/rdf-vocab-ebdabd34582e/lib/rdf/vocab/sh.rb', line 17

def Function
  @Function
end

#groupRDF::Vocabulary::Term (readonly)

Can be used to link to a property group to indicate that a property shape belongs to a group of related property shapes.



264
265
266
# File 'vendor/bundler/ruby/2.7.0/bundler/gems/rdf-vocab-ebdabd34582e/lib/rdf/vocab/sh.rb', line 264

def group
  @group
end

#hasValueRDF::Vocabulary::Term (readonly)

Specifies a value that must be among the value nodes.



268
269
270
# File 'vendor/bundler/ruby/2.7.0/bundler/gems/rdf-vocab-ebdabd34582e/lib/rdf/vocab/sh.rb', line 268

def hasValue
  @hasValue
end

#HasValueConstraintComponentRDF::Vocabulary::Term (readonly)

A constraint component that can be used to verify that one of the value nodes is a given RDF node.



612
613
614
# File 'vendor/bundler/ruby/2.7.0/bundler/gems/rdf-vocab-ebdabd34582e/lib/rdf/vocab/sh.rb', line 612

def HasValueConstraintComponent
  @HasValueConstraintComponent
end

#ignoredPropertiesRDF::Vocabulary::Term (readonly)

An optional RDF list of properties that are also permitted in addition to those explicitly enumerated via sh:property/sh:path.



272
273
274
# File 'vendor/bundler/ruby/2.7.0/bundler/gems/rdf-vocab-ebdabd34582e/lib/rdf/vocab/sh.rb', line 272

def ignoredProperties
  @ignoredProperties
end

#inRDF::Vocabulary::Term (readonly)

Specifies a list of allowed values so that each value node must be among the members of the given list.



276
277
278
# File 'vendor/bundler/ruby/2.7.0/bundler/gems/rdf-vocab-ebdabd34582e/lib/rdf/vocab/sh.rb', line 276

def in
  @in
end

#InConstraintComponentRDF::Vocabulary::Term (readonly)

A constraint component that can be used to exclusively enumerate the permitted value nodes.



624
625
626
# File 'vendor/bundler/ruby/2.7.0/bundler/gems/rdf-vocab-ebdabd34582e/lib/rdf/vocab/sh.rb', line 624

def InConstraintComponent
  @InConstraintComponent
end

#InfoRDF::Vocabulary::Term (readonly)

The severity for an informational validation result.



628
629
630
# File 'vendor/bundler/ruby/2.7.0/bundler/gems/rdf-vocab-ebdabd34582e/lib/rdf/vocab/sh.rb', line 628

def Info
  @Info
end

#intersectionRDF::Vocabulary::Term (readonly)

A list of node expressions that shall be intersected.



280
281
282
# File 'vendor/bundler/ruby/2.7.0/bundler/gems/rdf-vocab-ebdabd34582e/lib/rdf/vocab/sh.rb', line 280

def intersection
  @intersection
end

#inversePathRDF::Vocabulary::Term (readonly)

The (single) value of this property represents an inverse path (object to subject).



284
285
286
# File 'vendor/bundler/ruby/2.7.0/bundler/gems/rdf-vocab-ebdabd34582e/lib/rdf/vocab/sh.rb', line 284

def inversePath
  @inversePath
end

#IRIRDF::Vocabulary::Term (readonly)

The node kind of all IRIs.



616
617
618
# File 'vendor/bundler/ruby/2.7.0/bundler/gems/rdf-vocab-ebdabd34582e/lib/rdf/vocab/sh.rb', line 616

def IRI
  @IRI
end

#IRIOrLiteralRDF::Vocabulary::Term (readonly)

The node kind of all IRIs or literals.



620
621
622
# File 'vendor/bundler/ruby/2.7.0/bundler/gems/rdf-vocab-ebdabd34582e/lib/rdf/vocab/sh.rb', line 620

def IRIOrLiteral
  @IRIOrLiteral
end

#jsRDF::Vocabulary::Term (readonly)

Constraints expressed in JavaScript.



288
289
290
# File 'vendor/bundler/ruby/2.7.0/bundler/gems/rdf-vocab-ebdabd34582e/lib/rdf/vocab/sh.rb', line 288

def js
  @js
end

#JSConstraintRDF::Vocabulary::Term (readonly)

The class of constraints backed by a JavaScript function.



21
22
23
# File 'vendor/bundler/ruby/2.7.0/bundler/gems/rdf-vocab-ebdabd34582e/lib/rdf/vocab/sh.rb', line 21

def JSConstraint
  @JSConstraint
end

#JSConstraintComponentRDF::Vocabulary::Term (readonly)

A constraint component with the parameter sh:js linking to a sh:JSConstraint containing a sh:script.



632
633
634
# File 'vendor/bundler/ruby/2.7.0/bundler/gems/rdf-vocab-ebdabd34582e/lib/rdf/vocab/sh.rb', line 632

def JSConstraintComponent
  @JSConstraintComponent
end

#JSExecutableRDF::Vocabulary::Term (readonly)

Abstract base class of resources that declare an executable JavaScript.



25
26
27
# File 'vendor/bundler/ruby/2.7.0/bundler/gems/rdf-vocab-ebdabd34582e/lib/rdf/vocab/sh.rb', line 25

def JSExecutable
  @JSExecutable
end

#JSFunctionRDF::Vocabulary::Term (readonly)

The class of SHACL functions that execute a JavaScript function when called.



29
30
31
# File 'vendor/bundler/ruby/2.7.0/bundler/gems/rdf-vocab-ebdabd34582e/lib/rdf/vocab/sh.rb', line 29

def JSFunction
  @JSFunction
end

#jsFunctionNameRDF::Vocabulary::Term (readonly)

The name of the JavaScript function to execute.



292
293
294
# File 'vendor/bundler/ruby/2.7.0/bundler/gems/rdf-vocab-ebdabd34582e/lib/rdf/vocab/sh.rb', line 292

def jsFunctionName
  @jsFunctionName
end

#jsLibraryRDF::Vocabulary::Term (readonly)

Declares which JavaScript libraries are needed to execute this.



296
297
298
# File 'vendor/bundler/ruby/2.7.0/bundler/gems/rdf-vocab-ebdabd34582e/lib/rdf/vocab/sh.rb', line 296

def jsLibrary
  @jsLibrary
end

#JSLibraryRDF::Vocabulary::Term (readonly)

Represents a JavaScript library, typically identified by one or more URLs of files to include.



33
34
35
# File 'vendor/bundler/ruby/2.7.0/bundler/gems/rdf-vocab-ebdabd34582e/lib/rdf/vocab/sh.rb', line 33

def JSLibrary
  @JSLibrary
end

#jsLibraryURLRDF::Vocabulary::Term (readonly)

Declares the URLs of a JavaScript library. This should be the absolute URL of a JavaScript file. Implementations may redirect those to local files.



300
301
302
# File 'vendor/bundler/ruby/2.7.0/bundler/gems/rdf-vocab-ebdabd34582e/lib/rdf/vocab/sh.rb', line 300

def jsLibraryURL
  @jsLibraryURL
end

#JSRuleRDF::Vocabulary::Term (readonly)

The class of SHACL rules expressed using JavaScript.



37
38
39
# File 'vendor/bundler/ruby/2.7.0/bundler/gems/rdf-vocab-ebdabd34582e/lib/rdf/vocab/sh.rb', line 37

def JSRule
  @JSRule
end

#JSTargetRDF::Vocabulary::Term (readonly)

The class of targets that are based on JavaScript functions.



41
42
43
# File 'vendor/bundler/ruby/2.7.0/bundler/gems/rdf-vocab-ebdabd34582e/lib/rdf/vocab/sh.rb', line 41

def JSTarget
  @JSTarget
end

#JSTargetTypeRDF::Vocabulary::Term (readonly)

The (meta) class for parameterizable targets that are based on JavaScript functions.



45
46
47
# File 'vendor/bundler/ruby/2.7.0/bundler/gems/rdf-vocab-ebdabd34582e/lib/rdf/vocab/sh.rb', line 45

def JSTargetType
  @JSTargetType
end

#JSValidatorRDF::Vocabulary::Term (readonly)

A SHACL validator based on JavaScript. This can be used to declare SHACL constraint components that perform JavaScript-based validation when used.



49
50
51
# File 'vendor/bundler/ruby/2.7.0/bundler/gems/rdf-vocab-ebdabd34582e/lib/rdf/vocab/sh.rb', line 49

def JSValidator
  @JSValidator
end

#labelTemplateRDF::Vocabulary::Term (readonly)

Outlines how human-readable labels of instances of the associated Parameterizable shall be produced. The values can contain {?paramName} as placeholders for the actual values of the given parameter.



304
305
306
# File 'vendor/bundler/ruby/2.7.0/bundler/gems/rdf-vocab-ebdabd34582e/lib/rdf/vocab/sh.rb', line 304

def labelTemplate
  @labelTemplate
end

#languageInRDF::Vocabulary::Term (readonly)

Specifies a list of language tags that all value nodes must have.



308
309
310
# File 'vendor/bundler/ruby/2.7.0/bundler/gems/rdf-vocab-ebdabd34582e/lib/rdf/vocab/sh.rb', line 308

def languageIn
  @languageIn
end

#LanguageInConstraintComponentRDF::Vocabulary::Term (readonly)

A constraint component that can be used to enumerate language tags that all value nodes must have.



636
637
638
# File 'vendor/bundler/ruby/2.7.0/bundler/gems/rdf-vocab-ebdabd34582e/lib/rdf/vocab/sh.rb', line 636

def LanguageInConstraintComponent
  @LanguageInConstraintComponent
end

#lessThanRDF::Vocabulary::Term (readonly)

Specifies a property that must have smaller values than the value nodes.



312
313
314
# File 'vendor/bundler/ruby/2.7.0/bundler/gems/rdf-vocab-ebdabd34582e/lib/rdf/vocab/sh.rb', line 312

def lessThan
  @lessThan
end

#LessThanConstraintComponentRDF::Vocabulary::Term (readonly)

A constraint component that can be used to verify that each value node is smaller than all the nodes that have the focus node as subject and the value of a given property as predicate.



640
641
642
# File 'vendor/bundler/ruby/2.7.0/bundler/gems/rdf-vocab-ebdabd34582e/lib/rdf/vocab/sh.rb', line 640

def LessThanConstraintComponent
  @LessThanConstraintComponent
end

#lessThanOrEqualsRDF::Vocabulary::Term (readonly)

Specifies a property that must have smaller or equal values than the value nodes.



316
317
318
# File 'vendor/bundler/ruby/2.7.0/bundler/gems/rdf-vocab-ebdabd34582e/lib/rdf/vocab/sh.rb', line 316

def lessThanOrEquals
  @lessThanOrEquals
end

#LessThanOrEqualsConstraintComponentRDF::Vocabulary::Term (readonly)

A constraint component that can be used to verify that every value node is smaller than all the nodes that have the focus node as subject and the value of a given property as predicate.



644
645
646
# File 'vendor/bundler/ruby/2.7.0/bundler/gems/rdf-vocab-ebdabd34582e/lib/rdf/vocab/sh.rb', line 644

def LessThanOrEqualsConstraintComponent
  @LessThanOrEqualsConstraintComponent
end

#LiteralRDF::Vocabulary::Term (readonly)

The node kind of all literals.



648
649
650
# File 'vendor/bundler/ruby/2.7.0/bundler/gems/rdf-vocab-ebdabd34582e/lib/rdf/vocab/sh.rb', line 648

def Literal
  @Literal
end

#maxCountRDF::Vocabulary::Term (readonly)

Specifies the maximum number of values in the set of value nodes.



320
321
322
# File 'vendor/bundler/ruby/2.7.0/bundler/gems/rdf-vocab-ebdabd34582e/lib/rdf/vocab/sh.rb', line 320

def maxCount
  @maxCount
end

#MaxCountConstraintComponentRDF::Vocabulary::Term (readonly)

A constraint component that can be used to restrict the maximum number of value nodes.



652
653
654
# File 'vendor/bundler/ruby/2.7.0/bundler/gems/rdf-vocab-ebdabd34582e/lib/rdf/vocab/sh.rb', line 652

def MaxCountConstraintComponent
  @MaxCountConstraintComponent
end

#maxExclusiveRDF::Vocabulary::Term (readonly)

Specifies the maximum exclusive value of each value node.



324
325
326
# File 'vendor/bundler/ruby/2.7.0/bundler/gems/rdf-vocab-ebdabd34582e/lib/rdf/vocab/sh.rb', line 324

def maxExclusive
  @maxExclusive
end

#MaxExclusiveConstraintComponentRDF::Vocabulary::Term (readonly)

A constraint component that can be used to restrict the range of value nodes with a maximum exclusive value.



656
657
658
# File 'vendor/bundler/ruby/2.7.0/bundler/gems/rdf-vocab-ebdabd34582e/lib/rdf/vocab/sh.rb', line 656

def MaxExclusiveConstraintComponent
  @MaxExclusiveConstraintComponent
end

#maxInclusiveRDF::Vocabulary::Term (readonly)

Specifies the maximum inclusive value of each value node.



328
329
330
# File 'vendor/bundler/ruby/2.7.0/bundler/gems/rdf-vocab-ebdabd34582e/lib/rdf/vocab/sh.rb', line 328

def maxInclusive
  @maxInclusive
end

#MaxInclusiveConstraintComponentRDF::Vocabulary::Term (readonly)

A constraint component that can be used to restrict the range of value nodes with a maximum inclusive value.



660
661
662
# File 'vendor/bundler/ruby/2.7.0/bundler/gems/rdf-vocab-ebdabd34582e/lib/rdf/vocab/sh.rb', line 660

def MaxInclusiveConstraintComponent
  @MaxInclusiveConstraintComponent
end

#maxLengthRDF::Vocabulary::Term (readonly)

Specifies the maximum string length of each value node.



332
333
334
# File 'vendor/bundler/ruby/2.7.0/bundler/gems/rdf-vocab-ebdabd34582e/lib/rdf/vocab/sh.rb', line 332

def maxLength
  @maxLength
end

#MaxLengthConstraintComponentRDF::Vocabulary::Term (readonly)

A constraint component that can be used to restrict the maximum string length of value nodes.



664
665
666
# File 'vendor/bundler/ruby/2.7.0/bundler/gems/rdf-vocab-ebdabd34582e/lib/rdf/vocab/sh.rb', line 664

def MaxLengthConstraintComponent
  @MaxLengthConstraintComponent
end

#messageRDF::Vocabulary::Term (readonly)

A human-readable message (possibly with placeholders for variables) explaining the cause of the result.



336
337
338
# File 'vendor/bundler/ruby/2.7.0/bundler/gems/rdf-vocab-ebdabd34582e/lib/rdf/vocab/sh.rb', line 336

def message
  @message
end

#minCountRDF::Vocabulary::Term (readonly)

Specifies the minimum number of values in the set of value nodes.



340
341
342
# File 'vendor/bundler/ruby/2.7.0/bundler/gems/rdf-vocab-ebdabd34582e/lib/rdf/vocab/sh.rb', line 340

def minCount
  @minCount
end

#MinCountConstraintComponentRDF::Vocabulary::Term (readonly)

A constraint component that can be used to restrict the minimum number of value nodes.



668
669
670
# File 'vendor/bundler/ruby/2.7.0/bundler/gems/rdf-vocab-ebdabd34582e/lib/rdf/vocab/sh.rb', line 668

def MinCountConstraintComponent
  @MinCountConstraintComponent
end

#minExclusiveRDF::Vocabulary::Term (readonly)

Specifies the minimum exclusive value of each value node.



344
345
346
# File 'vendor/bundler/ruby/2.7.0/bundler/gems/rdf-vocab-ebdabd34582e/lib/rdf/vocab/sh.rb', line 344

def minExclusive
  @minExclusive
end

#MinExclusiveConstraintComponentRDF::Vocabulary::Term (readonly)

A constraint component that can be used to restrict the range of value nodes with a minimum exclusive value.



672
673
674
# File 'vendor/bundler/ruby/2.7.0/bundler/gems/rdf-vocab-ebdabd34582e/lib/rdf/vocab/sh.rb', line 672

def MinExclusiveConstraintComponent
  @MinExclusiveConstraintComponent
end

#minInclusiveRDF::Vocabulary::Term (readonly)

Specifies the minimum inclusive value of each value node.



348
349
350
# File 'vendor/bundler/ruby/2.7.0/bundler/gems/rdf-vocab-ebdabd34582e/lib/rdf/vocab/sh.rb', line 348

def minInclusive
  @minInclusive
end

#MinInclusiveConstraintComponentRDF::Vocabulary::Term (readonly)

A constraint component that can be used to restrict the range of value nodes with a minimum inclusive value.



676
677
678
# File 'vendor/bundler/ruby/2.7.0/bundler/gems/rdf-vocab-ebdabd34582e/lib/rdf/vocab/sh.rb', line 676

def MinInclusiveConstraintComponent
  @MinInclusiveConstraintComponent
end

#minLengthRDF::Vocabulary::Term (readonly)

Specifies the minimum string length of each value node.



352
353
354
# File 'vendor/bundler/ruby/2.7.0/bundler/gems/rdf-vocab-ebdabd34582e/lib/rdf/vocab/sh.rb', line 352

def minLength
  @minLength
end

#MinLengthConstraintComponentRDF::Vocabulary::Term (readonly)

A constraint component that can be used to restrict the minimum string length of value nodes.



680
681
682
# File 'vendor/bundler/ruby/2.7.0/bundler/gems/rdf-vocab-ebdabd34582e/lib/rdf/vocab/sh.rb', line 680

def MinLengthConstraintComponent
  @MinLengthConstraintComponent
end

#nameRDF::Vocabulary::Term (readonly)

Human-readable labels for the property in the context of the surrounding shape.



356
357
358
# File 'vendor/bundler/ruby/2.7.0/bundler/gems/rdf-vocab-ebdabd34582e/lib/rdf/vocab/sh.rb', line 356

def name
  @name
end

#namespaceRDF::Vocabulary::Term (readonly)

The namespace associated with a prefix in a prefix declaration.



360
361
362
# File 'vendor/bundler/ruby/2.7.0/bundler/gems/rdf-vocab-ebdabd34582e/lib/rdf/vocab/sh.rb', line 360

def namespace
  @namespace
end

#nodeRDF::Vocabulary::Term (readonly)

Specifies the node shape that all value nodes must conform to.



364
365
366
# File 'vendor/bundler/ruby/2.7.0/bundler/gems/rdf-vocab-ebdabd34582e/lib/rdf/vocab/sh.rb', line 364

def node
  @node
end

#NodeConstraintComponentRDF::Vocabulary::Term (readonly)

A constraint component that can be used to verify that all value nodes conform to the given node shape.



684
685
686
# File 'vendor/bundler/ruby/2.7.0/bundler/gems/rdf-vocab-ebdabd34582e/lib/rdf/vocab/sh.rb', line 684

def NodeConstraintComponent
  @NodeConstraintComponent
end

#nodeKindRDF::Vocabulary::Term (readonly)

Specifies the node kind (e.g. IRI or literal) each value node.



368
369
370
# File 'vendor/bundler/ruby/2.7.0/bundler/gems/rdf-vocab-ebdabd34582e/lib/rdf/vocab/sh.rb', line 368

def nodeKind
  @nodeKind
end

#NodeKindRDF::Vocabulary::Term (readonly)

The class of all node kinds, including sh:BlankNode, sh:IRI, sh:Literal or the combinations of these: sh:BlankNodeOrIRI, sh:BlankNodeOrLiteral, sh:IRIOrLiteral.



53
54
55
# File 'vendor/bundler/ruby/2.7.0/bundler/gems/rdf-vocab-ebdabd34582e/lib/rdf/vocab/sh.rb', line 53

def NodeKind
  @NodeKind
end

#NodeKindConstraintComponentRDF::Vocabulary::Term (readonly)

A constraint component that can be used to restrict the RDF node kind of each value node.



688
689
690
# File 'vendor/bundler/ruby/2.7.0/bundler/gems/rdf-vocab-ebdabd34582e/lib/rdf/vocab/sh.rb', line 688

def NodeKindConstraintComponent
  @NodeKindConstraintComponent
end

#nodesRDF::Vocabulary::Term (readonly)

The node expression producing the input nodes of a filter shape expression.



376
377
378
# File 'vendor/bundler/ruby/2.7.0/bundler/gems/rdf-vocab-ebdabd34582e/lib/rdf/vocab/sh.rb', line 376

def nodes
  @nodes
end

#NodeShapeRDF::Vocabulary::Term (readonly)

A node shape is a shape that specifies constraint that need to be met with respect to focus nodes.



57
58
59
# File 'vendor/bundler/ruby/2.7.0/bundler/gems/rdf-vocab-ebdabd34582e/lib/rdf/vocab/sh.rb', line 57

def NodeShape
  @NodeShape
end

#nodeValidatorRDF::Vocabulary::Term (readonly)

The validator(s) used to evaluate a constraint in the context of a node shape.



372
373
374
# File 'vendor/bundler/ruby/2.7.0/bundler/gems/rdf-vocab-ebdabd34582e/lib/rdf/vocab/sh.rb', line 372

def nodeValidator
  @nodeValidator
end

#notRDF::Vocabulary::Term (readonly)

Specifies a shape that the value nodes must not conform to.



380
381
382
# File 'vendor/bundler/ruby/2.7.0/bundler/gems/rdf-vocab-ebdabd34582e/lib/rdf/vocab/sh.rb', line 380

def not
  @not
end

#NotConstraintComponentRDF::Vocabulary::Term (readonly)

A constraint component that can be used to verify that value nodes do not conform to a given shape.



692
693
694
# File 'vendor/bundler/ruby/2.7.0/bundler/gems/rdf-vocab-ebdabd34582e/lib/rdf/vocab/sh.rb', line 692

def NotConstraintComponent
  @NotConstraintComponent
end

#objectRDF::Vocabulary::Term (readonly)

An expression producing the nodes that shall be inferred as objects.



384
385
386
# File 'vendor/bundler/ruby/2.7.0/bundler/gems/rdf-vocab-ebdabd34582e/lib/rdf/vocab/sh.rb', line 384

def object
  @object
end

#oneOrMorePathRDF::Vocabulary::Term (readonly)

The (single) value of this property represents a path that is matched one or more times.



388
389
390
# File 'vendor/bundler/ruby/2.7.0/bundler/gems/rdf-vocab-ebdabd34582e/lib/rdf/vocab/sh.rb', line 388

def oneOrMorePath
  @oneOrMorePath
end

#optionalRDF::Vocabulary::Term (readonly)

Indicates whether a parameter is optional.



392
393
394
# File 'vendor/bundler/ruby/2.7.0/bundler/gems/rdf-vocab-ebdabd34582e/lib/rdf/vocab/sh.rb', line 392

def optional
  @optional
end

#orRDF::Vocabulary::Term (readonly)

Specifies a list of shapes so that the value nodes must conform to at least one of the shapes.



396
397
398
# File 'vendor/bundler/ruby/2.7.0/bundler/gems/rdf-vocab-ebdabd34582e/lib/rdf/vocab/sh.rb', line 396

def or
  @or
end

#OrConstraintComponentRDF::Vocabulary::Term (readonly)

A constraint component that can be used to restrict the value nodes so that they conform to at least one out of several provided shapes.



696
697
698
# File 'vendor/bundler/ruby/2.7.0/bundler/gems/rdf-vocab-ebdabd34582e/lib/rdf/vocab/sh.rb', line 696

def OrConstraintComponent
  @OrConstraintComponent
end

#orderRDF::Vocabulary::Term (readonly)

Specifies the relative order of this compared to its siblings. For example use 0 for the first, 1 for the second.



400
401
402
# File 'vendor/bundler/ruby/2.7.0/bundler/gems/rdf-vocab-ebdabd34582e/lib/rdf/vocab/sh.rb', line 400

def order
  @order
end

#parameterRDF::Vocabulary::Term (readonly)

The parameters of a function or constraint component.



404
405
406
# File 'vendor/bundler/ruby/2.7.0/bundler/gems/rdf-vocab-ebdabd34582e/lib/rdf/vocab/sh.rb', line 404

def parameter
  @parameter
end

#ParameterRDF::Vocabulary::Term (readonly)

The class of parameter declarations, consisting of a path predicate and (possibly) information about allowed value type, cardinality and other characteristics.



61
62
63
# File 'vendor/bundler/ruby/2.7.0/bundler/gems/rdf-vocab-ebdabd34582e/lib/rdf/vocab/sh.rb', line 61

def Parameter
  @Parameter
end

#ParameterizableRDF::Vocabulary::Term (readonly)

Superclass of components that can take parameters, especially functions and constraint components.



65
66
67
# File 'vendor/bundler/ruby/2.7.0/bundler/gems/rdf-vocab-ebdabd34582e/lib/rdf/vocab/sh.rb', line 65

def Parameterizable
  @Parameterizable
end

#pathRDF::Vocabulary::Term (readonly)

Specifies the property path of a property shape.



408
409
410
# File 'vendor/bundler/ruby/2.7.0/bundler/gems/rdf-vocab-ebdabd34582e/lib/rdf/vocab/sh.rb', line 408

def path
  @path
end

#patternRDF::Vocabulary::Term (readonly)

Specifies a regular expression pattern that the string representations of the value nodes must match.



412
413
414
# File 'vendor/bundler/ruby/2.7.0/bundler/gems/rdf-vocab-ebdabd34582e/lib/rdf/vocab/sh.rb', line 412

def pattern
  @pattern
end

#PatternConstraintComponentRDF::Vocabulary::Term (readonly)

A constraint component that can be used to verify that every value node matches a given regular expression.



700
701
702
# File 'vendor/bundler/ruby/2.7.0/bundler/gems/rdf-vocab-ebdabd34582e/lib/rdf/vocab/sh.rb', line 700

def PatternConstraintComponent
  @PatternConstraintComponent
end

#predicateRDF::Vocabulary::Term (readonly)

An expression producing the properties that shall be inferred as predicates.



416
417
418
# File 'vendor/bundler/ruby/2.7.0/bundler/gems/rdf-vocab-ebdabd34582e/lib/rdf/vocab/sh.rb', line 416

def predicate
  @predicate
end

#prefixRDF::Vocabulary::Term (readonly)

The prefix of a prefix declaration.



420
421
422
# File 'vendor/bundler/ruby/2.7.0/bundler/gems/rdf-vocab-ebdabd34582e/lib/rdf/vocab/sh.rb', line 420

def prefix
  @prefix
end

#PrefixDeclarationRDF::Vocabulary::Term (readonly)

The class of prefix declarations, consisting of pairs of a prefix with a namespace.



69
70
71
# File 'vendor/bundler/ruby/2.7.0/bundler/gems/rdf-vocab-ebdabd34582e/lib/rdf/vocab/sh.rb', line 69

def PrefixDeclaration
  @PrefixDeclaration
end

#prefixesRDF::Vocabulary::Term (readonly)

The prefixes that shall be applied before parsing the associated SPARQL query.



424
425
426
# File 'vendor/bundler/ruby/2.7.0/bundler/gems/rdf-vocab-ebdabd34582e/lib/rdf/vocab/sh.rb', line 424

def prefixes
  @prefixes
end

#propertyRDF::Vocabulary::Term (readonly)

Links a shape to its property shapes.



428
429
430
# File 'vendor/bundler/ruby/2.7.0/bundler/gems/rdf-vocab-ebdabd34582e/lib/rdf/vocab/sh.rb', line 428

def property
  @property
end

#PropertyConstraintComponentRDF::Vocabulary::Term (readonly)

A constraint component that can be used to verify that all value nodes conform to the given property shape.



704
705
706
# File 'vendor/bundler/ruby/2.7.0/bundler/gems/rdf-vocab-ebdabd34582e/lib/rdf/vocab/sh.rb', line 704

def PropertyConstraintComponent
  @PropertyConstraintComponent
end

#PropertyGroupRDF::Vocabulary::Term (readonly)

Instances of this class represent groups of property shapes that belong together.



73
74
75
# File 'vendor/bundler/ruby/2.7.0/bundler/gems/rdf-vocab-ebdabd34582e/lib/rdf/vocab/sh.rb', line 73

def PropertyGroup
  @PropertyGroup
end

#PropertyShapeRDF::Vocabulary::Term (readonly)

A property shape is a shape that specifies constraints on the values of a focus node for a given property or path.



77
78
79
# File 'vendor/bundler/ruby/2.7.0/bundler/gems/rdf-vocab-ebdabd34582e/lib/rdf/vocab/sh.rb', line 77

def PropertyShape
  @PropertyShape
end

#propertyValidatorRDF::Vocabulary::Term (readonly)

The validator(s) used to evaluate a constraint in the context of a property shape.



432
433
434
# File 'vendor/bundler/ruby/2.7.0/bundler/gems/rdf-vocab-ebdabd34582e/lib/rdf/vocab/sh.rb', line 432

def propertyValidator
  @propertyValidator
end

#qualifiedMaxCountRDF::Vocabulary::Term (readonly)

The maximum number of value nodes that can conform to the shape.



436
437
438
# File 'vendor/bundler/ruby/2.7.0/bundler/gems/rdf-vocab-ebdabd34582e/lib/rdf/vocab/sh.rb', line 436

def qualifiedMaxCount
  @qualifiedMaxCount
end

#QualifiedMaxCountConstraintComponentRDF::Vocabulary::Term (readonly)

A constraint component that can be used to verify that a specified maximum number of value nodes conforms to a given shape.



708
709
710
# File 'vendor/bundler/ruby/2.7.0/bundler/gems/rdf-vocab-ebdabd34582e/lib/rdf/vocab/sh.rb', line 708

def QualifiedMaxCountConstraintComponent
  @QualifiedMaxCountConstraintComponent
end

#qualifiedMinCountRDF::Vocabulary::Term (readonly)

The minimum number of value nodes that must conform to the shape.



440
441
442
# File 'vendor/bundler/ruby/2.7.0/bundler/gems/rdf-vocab-ebdabd34582e/lib/rdf/vocab/sh.rb', line 440

def qualifiedMinCount
  @qualifiedMinCount
end

#QualifiedMinCountConstraintComponentRDF::Vocabulary::Term (readonly)

A constraint component that can be used to verify that a specified minimum number of value nodes conforms to a given shape.



712
713
714
# File 'vendor/bundler/ruby/2.7.0/bundler/gems/rdf-vocab-ebdabd34582e/lib/rdf/vocab/sh.rb', line 712

def QualifiedMinCountConstraintComponent
  @QualifiedMinCountConstraintComponent
end

#qualifiedValueShapeRDF::Vocabulary::Term (readonly)

The shape that a specified number of values must conform to.



444
445
446
# File 'vendor/bundler/ruby/2.7.0/bundler/gems/rdf-vocab-ebdabd34582e/lib/rdf/vocab/sh.rb', line 444

def qualifiedValueShape
  @qualifiedValueShape
end

#qualifiedValueShapesDisjointRDF::Vocabulary::Term (readonly)

Can be used to mark the qualified value shape to be disjoint with its sibling shapes.



448
449
450
# File 'vendor/bundler/ruby/2.7.0/bundler/gems/rdf-vocab-ebdabd34582e/lib/rdf/vocab/sh.rb', line 448

def qualifiedValueShapesDisjoint
  @qualifiedValueShapesDisjoint
end

#resultRDF::Vocabulary::Term (readonly)

The validation results contained in a validation report.



452
453
454
# File 'vendor/bundler/ruby/2.7.0/bundler/gems/rdf-vocab-ebdabd34582e/lib/rdf/vocab/sh.rb', line 452

def result
  @result
end

#ResultAnnotationRDF::Vocabulary::Term (readonly)

A class of result annotations, which define the rules to derive the values of a given annotation property as extra values for a validation result.



81
82
83
# File 'vendor/bundler/ruby/2.7.0/bundler/gems/rdf-vocab-ebdabd34582e/lib/rdf/vocab/sh.rb', line 81

def ResultAnnotation
  @ResultAnnotation
end

#resultAnnotationRDF::Vocabulary::Term (readonly)

Links a SPARQL validator with zero or more sh:ResultAnnotation instances, defining how to derive additional result properties based on the variables of the SELECT query.



456
457
458
# File 'vendor/bundler/ruby/2.7.0/bundler/gems/rdf-vocab-ebdabd34582e/lib/rdf/vocab/sh.rb', line 456

def resultAnnotation
  @resultAnnotation
end

#resultMessageRDF::Vocabulary::Term (readonly)

Human-readable messages explaining the cause of the result.



460
461
462
# File 'vendor/bundler/ruby/2.7.0/bundler/gems/rdf-vocab-ebdabd34582e/lib/rdf/vocab/sh.rb', line 460

def resultMessage
  @resultMessage
end

#resultPathRDF::Vocabulary::Term (readonly)

The path of a validation result, based on the path of the validated property shape.



464
465
466
# File 'vendor/bundler/ruby/2.7.0/bundler/gems/rdf-vocab-ebdabd34582e/lib/rdf/vocab/sh.rb', line 464

def resultPath
  @resultPath
end

#resultSeverityRDF::Vocabulary::Term (readonly)

The severity of the result, e.g. warning.



468
469
470
# File 'vendor/bundler/ruby/2.7.0/bundler/gems/rdf-vocab-ebdabd34582e/lib/rdf/vocab/sh.rb', line 468

def resultSeverity
  @resultSeverity
end

#returnTypeRDF::Vocabulary::Term (readonly)

The expected type of values returned by the associated function.



472
473
474
# File 'vendor/bundler/ruby/2.7.0/bundler/gems/rdf-vocab-ebdabd34582e/lib/rdf/vocab/sh.rb', line 472

def returnType
  @returnType
end

#ruleRDF::Vocabulary::Term (readonly)

The rules linked to a shape.



476
477
478
# File 'vendor/bundler/ruby/2.7.0/bundler/gems/rdf-vocab-ebdabd34582e/lib/rdf/vocab/sh.rb', line 476

def rule
  @rule
end

#RuleRDF::Vocabulary::Term (readonly)

The class of SHACL rules. Never instantiated directly.



85
86
87
# File 'vendor/bundler/ruby/2.7.0/bundler/gems/rdf-vocab-ebdabd34582e/lib/rdf/vocab/sh.rb', line 85

def Rule
  @Rule
end

#selectRDF::Vocabulary::Term (readonly)

The SPARQL SELECT query to execute.



480
481
482
# File 'vendor/bundler/ruby/2.7.0/bundler/gems/rdf-vocab-ebdabd34582e/lib/rdf/vocab/sh.rb', line 480

def select
  @select
end

#SeverityRDF::Vocabulary::Term (readonly)

The class of validation result severity levels, including violation and warning levels.



137
138
139
# File 'vendor/bundler/ruby/2.7.0/bundler/gems/rdf-vocab-ebdabd34582e/lib/rdf/vocab/sh.rb', line 137

def Severity
  @Severity
end

#severityRDF::Vocabulary::Term (readonly)

Defines the severity that validation results produced by a shape must have. Defaults to sh:Violation.



484
485
486
# File 'vendor/bundler/ruby/2.7.0/bundler/gems/rdf-vocab-ebdabd34582e/lib/rdf/vocab/sh.rb', line 484

def severity
  @severity
end

#ShapeRDF::Vocabulary::Term (readonly)

A shape is a collection of constraints that may be targeted for certain nodes.



141
142
143
# File 'vendor/bundler/ruby/2.7.0/bundler/gems/rdf-vocab-ebdabd34582e/lib/rdf/vocab/sh.rb', line 141

def Shape
  @Shape
end

#shapesGraphRDF::Vocabulary::Term (readonly)

Shapes graphs that should be used when validating this data graph.



488
489
490
# File 'vendor/bundler/ruby/2.7.0/bundler/gems/rdf-vocab-ebdabd34582e/lib/rdf/vocab/sh.rb', line 488

def shapesGraph
  @shapesGraph
end

#shapesGraphWellFormedRDF::Vocabulary::Term (readonly)

If true then the validation engine was certain that the shapes graph has passed all SHACL syntax requirements during the validation process.



492
493
494
# File 'vendor/bundler/ruby/2.7.0/bundler/gems/rdf-vocab-ebdabd34582e/lib/rdf/vocab/sh.rb', line 492

def shapesGraphWellFormed
  @shapesGraphWellFormed
end

#sourceConstraintRDF::Vocabulary::Term (readonly)

The constraint that was validated when the result was produced.



496
497
498
# File 'vendor/bundler/ruby/2.7.0/bundler/gems/rdf-vocab-ebdabd34582e/lib/rdf/vocab/sh.rb', line 496

def sourceConstraint
  @sourceConstraint
end

#sourceConstraintComponentRDF::Vocabulary::Term (readonly)

The constraint component that is the source of the result.



500
501
502
# File 'vendor/bundler/ruby/2.7.0/bundler/gems/rdf-vocab-ebdabd34582e/lib/rdf/vocab/sh.rb', line 500

def sourceConstraintComponent
  @sourceConstraintComponent
end

#sourceShapeRDF::Vocabulary::Term (readonly)

The shape that is was validated when the result was produced.



504
505
506
# File 'vendor/bundler/ruby/2.7.0/bundler/gems/rdf-vocab-ebdabd34582e/lib/rdf/vocab/sh.rb', line 504

def sourceShape
  @sourceShape
end

#sparqlRDF::Vocabulary::Term (readonly)

Links a shape with SPARQL constraints.



508
509
510
# File 'vendor/bundler/ruby/2.7.0/bundler/gems/rdf-vocab-ebdabd34582e/lib/rdf/vocab/sh.rb', line 508

def sparql
  @sparql
end

#SPARQLAskExecutableRDF::Vocabulary::Term (readonly)

The class of SPARQL executables that are based on an ASK query.



89
90
91
# File 'vendor/bundler/ruby/2.7.0/bundler/gems/rdf-vocab-ebdabd34582e/lib/rdf/vocab/sh.rb', line 89

def SPARQLAskExecutable
  @SPARQLAskExecutable
end

#SPARQLAskValidatorRDF::Vocabulary::Term (readonly)

The class of validators based on SPARQL ASK queries. The queries are evaluated for each value node and are supposed to return true if the given node conforms.



93
94
95
# File 'vendor/bundler/ruby/2.7.0/bundler/gems/rdf-vocab-ebdabd34582e/lib/rdf/vocab/sh.rb', line 93

def SPARQLAskValidator
  @SPARQLAskValidator
end

#SPARQLConstraintRDF::Vocabulary::Term (readonly)

The class of constraints based on SPARQL SELECT queries.



97
98
99
# File 'vendor/bundler/ruby/2.7.0/bundler/gems/rdf-vocab-ebdabd34582e/lib/rdf/vocab/sh.rb', line 97

def SPARQLConstraint
  @SPARQLConstraint
end

#SPARQLConstraintComponentRDF::Vocabulary::Term (readonly)

A constraint component that can be used to define constraints based on SPARQL queries.



716
717
718
# File 'vendor/bundler/ruby/2.7.0/bundler/gems/rdf-vocab-ebdabd34582e/lib/rdf/vocab/sh.rb', line 716

def SPARQLConstraintComponent
  @SPARQLConstraintComponent
end

#SPARQLConstructExecutableRDF::Vocabulary::Term (readonly)

The class of SPARQL executables that are based on a CONSTRUCT query.



101
102
103
# File 'vendor/bundler/ruby/2.7.0/bundler/gems/rdf-vocab-ebdabd34582e/lib/rdf/vocab/sh.rb', line 101

def SPARQLConstructExecutable
  @SPARQLConstructExecutable
end

#SPARQLExecutableRDF::Vocabulary::Term (readonly)

The class of resources that encapsulate a SPARQL query.



105
106
107
# File 'vendor/bundler/ruby/2.7.0/bundler/gems/rdf-vocab-ebdabd34582e/lib/rdf/vocab/sh.rb', line 105

def SPARQLExecutable
  @SPARQLExecutable
end

#SPARQLFunctionRDF::Vocabulary::Term (readonly)

A function backed by a SPARQL query - either ASK or SELECT.



109
110
111
# File 'vendor/bundler/ruby/2.7.0/bundler/gems/rdf-vocab-ebdabd34582e/lib/rdf/vocab/sh.rb', line 109

def SPARQLFunction
  @SPARQLFunction
end

#SPARQLRuleRDF::Vocabulary::Term (readonly)

The class of SHACL rules based on SPARQL CONSTRUCT queries.



113
114
115
# File 'vendor/bundler/ruby/2.7.0/bundler/gems/rdf-vocab-ebdabd34582e/lib/rdf/vocab/sh.rb', line 113

def SPARQLRule
  @SPARQLRule
end

#SPARQLSelectExecutableRDF::Vocabulary::Term (readonly)

The class of SPARQL executables based on a SELECT query.



117
118
119
# File 'vendor/bundler/ruby/2.7.0/bundler/gems/rdf-vocab-ebdabd34582e/lib/rdf/vocab/sh.rb', line 117

def SPARQLSelectExecutable
  @SPARQLSelectExecutable
end

#SPARQLSelectValidatorRDF::Vocabulary::Term (readonly)

The class of validators based on SPARQL SELECT queries. The queries are evaluated for each focus node and are supposed to produce bindings for all focus nodes that do not conform.



121
122
123
# File 'vendor/bundler/ruby/2.7.0/bundler/gems/rdf-vocab-ebdabd34582e/lib/rdf/vocab/sh.rb', line 121

def SPARQLSelectValidator
  @SPARQLSelectValidator
end

#SPARQLTargetRDF::Vocabulary::Term (readonly)

The class of targets that are based on SPARQL queries.



125
126
127
# File 'vendor/bundler/ruby/2.7.0/bundler/gems/rdf-vocab-ebdabd34582e/lib/rdf/vocab/sh.rb', line 125

def SPARQLTarget
  @SPARQLTarget
end

#SPARQLTargetTypeRDF::Vocabulary::Term (readonly)

The (meta) class for parameterizable targets that are based on SPARQL queries.



129
130
131
# File 'vendor/bundler/ruby/2.7.0/bundler/gems/rdf-vocab-ebdabd34582e/lib/rdf/vocab/sh.rb', line 129

def SPARQLTargetType
  @SPARQLTargetType
end

#SPARQLUpdateExecutableRDF::Vocabulary::Term (readonly)

The class of SPARQL executables based on a SPARQL UPDATE.



133
134
135
# File 'vendor/bundler/ruby/2.7.0/bundler/gems/rdf-vocab-ebdabd34582e/lib/rdf/vocab/sh.rb', line 133

def SPARQLUpdateExecutable
  @SPARQLUpdateExecutable
end

#subjectRDF::Vocabulary::Term (readonly)

An expression producing the resources that shall be inferred as subjects.



512
513
514
# File 'vendor/bundler/ruby/2.7.0/bundler/gems/rdf-vocab-ebdabd34582e/lib/rdf/vocab/sh.rb', line 512

def subject
  @subject
end

#suggestedShapesGraphRDF::Vocabulary::Term (readonly)

Suggested shapes graphs for this ontology. The values of this property may be used in the absence of specific sh:shapesGraph statements.



516
517
518
# File 'vendor/bundler/ruby/2.7.0/bundler/gems/rdf-vocab-ebdabd34582e/lib/rdf/vocab/sh.rb', line 516

def suggestedShapesGraph
  @suggestedShapesGraph
end

#targetRDF::Vocabulary::Term (readonly)

Links a shape to a target specified by an extension language, for example instances of sh:SPARQLTarget.



520
521
522
# File 'vendor/bundler/ruby/2.7.0/bundler/gems/rdf-vocab-ebdabd34582e/lib/rdf/vocab/sh.rb', line 520

def target
  @target
end

#TargetRDF::Vocabulary::Term (readonly)

The base class of targets such as those based on SPARQL queries.



145
146
147
# File 'vendor/bundler/ruby/2.7.0/bundler/gems/rdf-vocab-ebdabd34582e/lib/rdf/vocab/sh.rb', line 145

def Target
  @Target
end

#targetClassRDF::Vocabulary::Term (readonly)

Links a shape to a class, indicating that all instances of the class must conform to the shape.



524
525
526
# File 'vendor/bundler/ruby/2.7.0/bundler/gems/rdf-vocab-ebdabd34582e/lib/rdf/vocab/sh.rb', line 524

def targetClass
  @targetClass
end

#targetNodeRDF::Vocabulary::Term (readonly)

Links a shape to individual nodes, indicating that these nodes must conform to the shape.



528
529
530
# File 'vendor/bundler/ruby/2.7.0/bundler/gems/rdf-vocab-ebdabd34582e/lib/rdf/vocab/sh.rb', line 528

def targetNode
  @targetNode
end

#targetObjectsOfRDF::Vocabulary::Term (readonly)

Links a shape to a property, indicating that all all objects of triples that have the given property as their predicate must conform to the shape.



532
533
534
# File 'vendor/bundler/ruby/2.7.0/bundler/gems/rdf-vocab-ebdabd34582e/lib/rdf/vocab/sh.rb', line 532

def targetObjectsOf
  @targetObjectsOf
end

#targetSubjectsOfRDF::Vocabulary::Term (readonly)

Links a shape to a property, indicating that all subjects of triples that have the given property as their predicate must conform to the shape.



536
537
538
# File 'vendor/bundler/ruby/2.7.0/bundler/gems/rdf-vocab-ebdabd34582e/lib/rdf/vocab/sh.rb', line 536

def targetSubjectsOf
  @targetSubjectsOf
end

#TargetTypeRDF::Vocabulary::Term (readonly)

The (meta) class for parameterizable targets. Instances of this are instantiated as values of the sh:target property.



149
150
151
# File 'vendor/bundler/ruby/2.7.0/bundler/gems/rdf-vocab-ebdabd34582e/lib/rdf/vocab/sh.rb', line 149

def TargetType
  @TargetType
end

#thisRDF::Vocabulary::Term (readonly)

A node expression that represents the current focus node.



736
737
738
# File 'vendor/bundler/ruby/2.7.0/bundler/gems/rdf-vocab-ebdabd34582e/lib/rdf/vocab/sh.rb', line 736

def this
  @this
end

#TripleRuleRDF::Vocabulary::Term (readonly)



152
153
154
# File 'vendor/bundler/ruby/2.7.0/bundler/gems/rdf-vocab-ebdabd34582e/lib/rdf/vocab/sh.rb', line 152

def TripleRule
  @TripleRule
end

#unionRDF::Vocabulary::Term (readonly)

A list of node expressions that shall be used together.



540
541
542
# File 'vendor/bundler/ruby/2.7.0/bundler/gems/rdf-vocab-ebdabd34582e/lib/rdf/vocab/sh.rb', line 540

def union
  @union
end

#uniqueLangRDF::Vocabulary::Term (readonly)

Specifies whether all node values must have a unique (or no) language tag.



544
545
546
# File 'vendor/bundler/ruby/2.7.0/bundler/gems/rdf-vocab-ebdabd34582e/lib/rdf/vocab/sh.rb', line 544

def uniqueLang
  @uniqueLang
end

#UniqueLangConstraintComponentRDF::Vocabulary::Term (readonly)

A constraint component that can be used to specify that no pair of value nodes may use the same language tag.



720
721
722
# File 'vendor/bundler/ruby/2.7.0/bundler/gems/rdf-vocab-ebdabd34582e/lib/rdf/vocab/sh.rb', line 720

def UniqueLangConstraintComponent
  @UniqueLangConstraintComponent
end

#updateRDF::Vocabulary::Term (readonly)

The SPARQL UPDATE to execute.



548
549
550
# File 'vendor/bundler/ruby/2.7.0/bundler/gems/rdf-vocab-ebdabd34582e/lib/rdf/vocab/sh.rb', line 548

def update
  @update
end

#ValidationReportRDF::Vocabulary::Term (readonly)

The class of SHACL validation reports.



156
157
158
# File 'vendor/bundler/ruby/2.7.0/bundler/gems/rdf-vocab-ebdabd34582e/lib/rdf/vocab/sh.rb', line 156

def ValidationReport
  @ValidationReport
end

#ValidationResultRDF::Vocabulary::Term (readonly)

The class of validation results.



160
161
162
# File 'vendor/bundler/ruby/2.7.0/bundler/gems/rdf-vocab-ebdabd34582e/lib/rdf/vocab/sh.rb', line 160

def ValidationResult
  @ValidationResult
end

#ValidatorRDF::Vocabulary::Term (readonly)

The class of validators, which provide instructions on how to process a constraint definition. This class serves as base class for the SPARQL-based validators and other possible implementations.



164
165
166
# File 'vendor/bundler/ruby/2.7.0/bundler/gems/rdf-vocab-ebdabd34582e/lib/rdf/vocab/sh.rb', line 164

def Validator
  @Validator
end

#validatorRDF::Vocabulary::Term (readonly)

The validator(s) used to evaluate constraints of either node or property shapes.



552
553
554
# File 'vendor/bundler/ruby/2.7.0/bundler/gems/rdf-vocab-ebdabd34582e/lib/rdf/vocab/sh.rb', line 552

def validator
  @validator
end

#valueRDF::Vocabulary::Term (readonly)

An RDF node that has caused the result.



556
557
558
# File 'vendor/bundler/ruby/2.7.0/bundler/gems/rdf-vocab-ebdabd34582e/lib/rdf/vocab/sh.rb', line 556

def value
  @value
end

#ViolationRDF::Vocabulary::Term (readonly)

The severity for a violation validation result.



724
725
726
# File 'vendor/bundler/ruby/2.7.0/bundler/gems/rdf-vocab-ebdabd34582e/lib/rdf/vocab/sh.rb', line 724

def Violation
  @Violation
end

#WarningRDF::Vocabulary::Term (readonly)

The severity for a warning validation result.



728
729
730
# File 'vendor/bundler/ruby/2.7.0/bundler/gems/rdf-vocab-ebdabd34582e/lib/rdf/vocab/sh.rb', line 728

def Warning
  @Warning
end

#xoneRDF::Vocabulary::Term (readonly)

Specifies a list of shapes so that the value nodes must conform to exactly one of the shapes.



560
561
562
# File 'vendor/bundler/ruby/2.7.0/bundler/gems/rdf-vocab-ebdabd34582e/lib/rdf/vocab/sh.rb', line 560

def xone
  @xone
end

#XoneConstraintComponentRDF::Vocabulary::Term (readonly)

A constraint component that can be used to restrict the value nodes so that they conform to exactly one out of several provided shapes.



732
733
734
# File 'vendor/bundler/ruby/2.7.0/bundler/gems/rdf-vocab-ebdabd34582e/lib/rdf/vocab/sh.rb', line 732

def XoneConstraintComponent
  @XoneConstraintComponent
end

#zeroOrMorePathRDF::Vocabulary::Term (readonly)

The (single) value of this property represents a path that is matched zero or more times.



564
565
566
# File 'vendor/bundler/ruby/2.7.0/bundler/gems/rdf-vocab-ebdabd34582e/lib/rdf/vocab/sh.rb', line 564

def zeroOrMorePath
  @zeroOrMorePath
end

#zeroOrOnePathRDF::Vocabulary::Term (readonly)

The (single) value of this property represents a path that is matched zero or one times.



568
569
570
# File 'vendor/bundler/ruby/2.7.0/bundler/gems/rdf-vocab-ebdabd34582e/lib/rdf/vocab/sh.rb', line 568

def zeroOrOnePath
  @zeroOrOnePath
end