Class: SHACL::Algebra::SPARQLConstraintComponent

Inherits:

Object
SPARQL::Algebra::Operator
Operator
ConstraintComponent
SHACL::Algebra::SPARQLConstraintComponent

show all

Defined in:: vendor/bundler/ruby/3.3.0/bundler/gems/shacl-e638b9acc6d8/lib/shacl/algebra/sparql_constraint.rb

Constant Summary collapse

NAME =

:sparql

UNSUPPORTED_SPARQL_OPERATORS = SPARQL Operators prohibited from being used in expression.

[
  SPARQL::Algebra::Operator::Minus,
  SPARQL::Algebra::Operator::Service,
  SPARQL::Algebra::Operator::Table,
]

PRE_BOUND = Potentially pre-bound variables.

%i(currentShape shapesGraph PATH this value)

BUILTIN_KEYS = All keys associated with shapes which are set in options Returns: (Array<Symbol>)

%i(
  type label name comment description deactivated severity
  message path
  ask select
  declare namespace prefix prefixes select ask
).freeze

Instance Attribute Summary

Attributes inherited from Operator

#graph, #options, #shapes_graph

Attributes inherited from SPARQL::Algebra::Operator

#operands

Class Method Summary collapse

.from_json(operator, **options) ⇒ Operator
Creates an operator instance from a parsed SHACL representation.

Instance Method Summary collapse

#conforms(node, path: nil, depth: 0, **options) ⇒ Array<SHACL::ValidationResult>
Validates the specified property within graph, a list of ValidationResult.

Methods inherited from ConstraintComponent

ncname

Methods inherited from Operator

add_component, apply_op, #comment, component_params, #deactivated?, from_expanded_value, #id, iri, #iri, #label, #not_satisfied, params, parse_path, #satisfy, to_rdf, #to_sxp_bin, #type

Methods included from JSON::LD::Utils

#add_value, #as_array, #as_resource, #blank_node?, #compare_values, #graph?, #has_value?, #index?, #list?, #node?, #node_or_ref?, #node_reference?, #property?, #simple_graph?, #value?

Methods included from RDF::Util::Logger

#log_debug, #log_depth, #log_error, #log_fatal, #log_info, #log_recover, #log_recovering?, #log_statistics, #log_warn, #logger

Methods inherited from SPARQL::Algebra::Operator

#aggregate?, arity, base_uri, #base_uri, base_uri=, #bind, #boolean, #constant?, #deep_dup, #each_descendant, #eql?, #evaluatable?, evaluate, #executable?, #first_ancestor, for, #formulae, #initialize, #inspect, #ndvars, #node?, #operand, #optimize, #optimize!, #parent, #parent=, prefixes, #prefixes, prefixes=, #rewrite, #to_binary, #to_sparql, to_sparql, #to_sxp, #to_sxp_bin, #validate!, #variable?, #variables, #vars

Methods included from SPARQL::Algebra::Expression

cast, #constant?, #evaluate, extension, extension?, extensions, for, #invalid?, new, #node?, open, #optimize, #optimize!, parse, register_extension, #to_sxp_bin, #valid?, #validate!, #variable?

Constructor Details

This class inherits a constructor from SPARQL::Algebra::Operator

Class Method Details

.from_json(operator, **options) ⇒ `Operator`

Creates an operator instance from a parsed SHACL representation.

Special case for SPARQLComponenet due to general recursion.

Parameters:

operator (Hash)
options (Hash) —
({})

Options Hash (**options):

:prefixes (Hash{String => RDF::URI})

Returns:

(Operator)

# File 'vendor/bundler/ruby/3.3.0/bundler/gems/shacl-e638b9acc6d8/lib/shacl/algebra/sparql_constraint.rb', line 92

def from_json(operator, **options)
  prefixes, query = [], ""
  operands = []
  node_opts = options.dup
  operator.each do |k, v|
    next if v.nil?
    case k
    # List properties
    when 'path'               then node_opts[:path] = parse_path(v, **options)
    when 'prefixes'
      prefixes = extract_prefixes(v)
    when 'severity'           then node_opts[:severity] = iri(v, **options)
    when 'type'               then node_opts[:type] = as_array(v).map {|vv| iri(vv, **options)} if v
    else
      node_opts[k.to_sym] = to_rdf(k.to_sym, v, **options) if BUILTIN_KEYS.include?(k.to_sym)
    end
  end

  query_string = prefixes.join("\n") + node_opts[:select] || node_opts[:ask]
  query = SPARQL.parse(query_string)

  options[:logger].info("#{NAME} SXP: #{query.to_sxp}") if options[:logger]

  # Queries have restrictions
  operators = query.descendants.to_a.unshift(query)

  if node_opts[:ask] && !operators.any? {|op| op.is_a?(SPARQL::Algebra::Operator::Ask)}
    raise SHACL::Error, "Ask query must have ask operator"
  elsif node_opts[:select] && !operators.any? {|op| op.is_a?(SPARQL::Algebra::Operator::Project)}
    raise SHACL::Error, "Select query must have project operator"
  end

  uh_oh = (operators.map(&:class) & UNSUPPORTED_SPARQL_OPERATORS).map {|c| c.const_get(:NAME)}

  unless uh_oh.empty?
    raise SHACL::Error, "Query must not include operators #{uh_oh.to_sxp}: #{query_string}"
  end

  # Additionally, queries must not bind to special variables
  operators.select {|op| op.is_a?(SPARQL::Algebra::Operator::Extend)}.each do |extend|
    if extend.operands.first.any? {|v, e| PRE_BOUND.include?(v.to_sym)}
      raise SHACL::Error, "Query must not bind pre-bound variables: #{query_string}"
    end
  end

  operands << query
  new(*operands, **node_opts)
end

Instance Method Details

#conforms(node, path: nil, depth: 0, **options) ⇒ `Array<SHACL::ValidationResult>`

Validates the specified property within graph, a list of ValidationResult.

A property conforms the nodes found by evaluating it's path all conform.

Last operand is the parsed query. Bound variables are added as a table entry joined to the query.