shex 0.4.0 → 0.6.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 96423cdff8bd77f2573ab32cd954d5217b2dfe20
-  data.tar.gz: 510d72ce00605e864b37af848f39c54f19de96b8
+SHA256:
+  metadata.gz: e10c5d06f3b45a96dc3f2437680bde6eb406fad42c44efce5102d2d763da3281
+  data.tar.gz: 70afaf45c7d88efb782e85d3de232ec48484d2d69683070920ab1b905e94d790
 SHA512:
-  metadata.gz: 7af06418271fa283bf833b837b546a10870af1e6f60fea90099d8a75d8dc4097f1fce6c7800b0874b50efcddbafe97abe5e30888c51f1d97f62e46298b2c5e86
-  data.tar.gz: 5c9a7e9c9f7373a64a4c0722edefb6d2c9c20e5a9aaad8920f539641ddca97d5499dec2d3c2f1aa719122405b381a2d52bf536f4bcabb71ea41702eafeb4aabc
+  metadata.gz: c5b825dd6fe24fc3ceaee231942756eecb30883650dfb67aa8ae590e5a089a795211b51afac134f8e8ed62161b6a2de13dd2e787da810fd05c771bd29af77481
+  data.tar.gz: 1f6c4189937468a6c0e7505a16f7e8f432beb8f308645c6ef96609f9e570eef30504fd5eac969f156bfd9f5cd95b814f51940b514dc4e024e32d084228e6a28d

data/AUTHORS

@@ -1 +1 @@
-* Gregg Kellogg <gregg@kellogg-assoc.com>
+* Gregg Kellogg <gregg@greggkellogg.net>

data/LICENSE

@@ -21,4 +21,4 @@ OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
 ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
 OTHER DEALINGS IN THE SOFTWARE.
 
-For more information, please refer to <http://unlicense.org>
+For more information, please refer to <https://unlicense.org>

data/README.md

@@ -2,24 +2,25 @@
 
 This is a pure-Ruby library for working with the [Shape Expressions Language][ShExSpec] to validate the shape of [RDF][] graphs.
 
-<http://ruby-rdf.github.com/shex>
+<https://ruby-rdf.github.com/shex>
 
-[![Gem Version](https://badge.fury.io/rb/shex.png)](http://badge.fury.io/rb/shex)
-[![Build Status](https://travis-ci.org/ruby-rdf/shex.png?branch=master)](http://travis-ci.org/ruby-rdf/shex)
+[![Gem Version](https://badge.fury.io/rb/shex.png)](https://badge.fury.io/rb/shex)
+[![Build Status](https://travis-ci.org/ruby-rdf/shex.png?branch=master)](https://travis-ci.org/ruby-rdf/shex)
 [![Coverage Status](https://coveralls.io/repos/ruby-rdf/shex/badge.svg)](https://coveralls.io/r/ruby-rdf/shex)
 [![Join the chat at https://gitter.im/ruby-rdf/rdf](https://badges.gitter.im/Join%20Chat.svg)](https://gitter.im/ruby-rdf/rdf?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
+[![DOI](https://zenodo.org/badge/74419330.svg)](https://zenodo.org/badge/latestdoi/74419330)
 
 ## Features
 
 * 100% pure Ruby with minimal dependencies and no bloat.
 * Fully compatible with [ShEx][ShExSpec] specifications.
-* 100% free and unencumbered [public domain](http://unlicense.org/) software.
+* 100% free and unencumbered [public domain](https://unlicense.org/) software.
 
 ## Description
 
 The ShEx gem implements a [ShEx][ShExSpec] Shape Expression engine.
 
-* `ShEx::Parser` parses ShExC and ShExJ formatted documents generating executable operators which can be serialized as [S-Expressions](http://en.wikipedia.org/wiki/S-expression).
+* `ShEx::Parser` parses ShExC and ShExJ formatted documents generating executable operators which can be serialized as [S-Expressions](https://en.wikipedia.org/wiki/S-expression).
 * `ShEx::Algebra` executes operators against Any `RDF::Graph`, including compliant [RDF.rb][].
 * [Implementation Report](file.earl.html)
 
@@ -38,15 +39,15 @@ The ShEx gem implements a [ShEx][ShExSpec] Shape Expression engine.
         (doap:name;doap:description|dc:title;dc:description)+;
         doap:category*;
         doap:developer IRI;
-        doap:implements    [<https://shexspec.github.io/spec/>]
+        doap:implements    [<http://shex.io/shex-semantics/>]
       }
     )
     graph = RDF::Graph.load("etc/doap.ttl")
     schema = ShEx.parse(shexc)
     map = {
-      "http://rubygems.org/gems/shex" => "TestShape"
+      "https://rubygems.org/gems/shex" => "TestShape"
     }
-    schema.satisfies?("http://rubygems.org/gems/shex", graph, map)
+    schema.satisfies?("https://rubygems.org/gems/shex", graph, map)
     # => true
 ### Validating a node using ShExJ
 
@@ -109,26 +110,26 @@ The ShEx gem implements a [ShEx][ShExSpec] Shape Expression engine.
                     ]
                   }
                 ],
-                "min": 1, "max": "*"
+                "min": 1, "max": -1
               },
               {
                 "type": "TripleConstraint",
                 "predicate": "http://usefulinc.com/ns/doap#category",
                 "valueExpr": {"type": "NodeConstraint", "nodeKind": "iri"},
-                "min": 0, "max": "*"
+                "min": 0, "max": -1
               },
               {
                 "type": "TripleConstraint",
                 "predicate": "http://usefulinc.com/ns/doap#developer",
                 "valueExpr": {"type": "NodeConstraint", "nodeKind": "iri"},
-                "min": 1, "max": "*"
+                "min": 1, "max": -1
               },
               {
                 "type": "TripleConstraint",
                 "predicate": "http://usefulinc.com/ns/doap#implements",
                 "valueExpr": {
                   "type": "NodeConstraint",
-                  "values": ["https://shexspec.github.io/spec/"]
+                  "values": ["http://shex.io/shex-semantics/"]
                 }
               }
             ]
@@ -138,12 +139,12 @@ The ShEx gem implements a [ShEx][ShExSpec] Shape Expression engine.
     })
     graph = RDF::Graph.load("etc/doap.ttl")
     schema = ShEx.parse(shexj, format: :shexj)
-    map = {"http://rubygems.org/gems/shex" => "TestShape"}
-    schema.satisfies?("http://rubygems.org/gems/shex", graph, map)
+    map = {"https://rubygems.org/gems/shex" => "TestShape"}
+    schema.satisfies?("https://rubygems.org/gems/shex", graph, map)
     # => true
 
 ## Extensions
-ShEx has an extension mechanism using [Semantic Actions](https://shexspec.github.io/spec/#semantic-actions). Extensions may be implemented in Ruby ShEx by sub-classing {ShEx::Extension} and implementing {ShEx::Extension#visit} and possibly {ShEx::Extension#initialize}, {ShEx::Extension#enter}, {ShEx::Extension#exit}, and {ShEx::Extension#close}. The `#visit` method will be called as part of the `#satisfies?` operation.
+ShEx has an extension mechanism using [Semantic Actions](http://shex.io/shex-semantics/#semantic-actions). Extensions may be implemented in Ruby ShEx by sub-classing {ShEx::Extension} and implementing {ShEx::Extension#visit} and possibly {ShEx::Extension#initialize}, {ShEx::Extension#enter}, {ShEx::Extension#exit}, and {ShEx::Extension#close}. The `#visit` method will be called as part of the `#satisfies?` operation.
 
     require 'shex'
     class ShEx::Test < ShEx::Extension("http://shex.io/extensions/Test/")
@@ -164,9 +165,23 @@ The `#initialize` method is called when {ShEx::Algebra::Schema#execute} starts a
 
 To make sure your extension is found, make sure to require it before the shape is executed.
 
+## Command Line
+When the `linkeddata` gem is installed, RDF.rb includes a `rdf` executable which acts as a wrapper to perform a number of different
+operations on RDF files, including ShEx. The commands specific to ShEx is 
+
+* `shex`: Validate repository given shape
+
+Using this command requires either a `shex-input` where the ShEx schema is URI encoded, or `shex`, which references a URI or file path to the schema. Other required options are `shape` and `focus`.
+
+Example usage:
+
+    rdf shex https://raw.githubusercontent.com/ruby-rdf/shex/develop/etc/doap.ttl \
+      --schema https://raw.githubusercontent.com/ruby-rdf/shex/develop/etc/doap.shex \
+      --focus https://rubygems.org/gems/shex
+
 ## Documentation
 
-<http://rubydoc.info/github/ruby-rdf/shex>
+<https://rubydoc.info/github/ruby-rdf/shex>
 
 
 ## Implementation Notes
@@ -178,12 +193,12 @@ The result of parsing either ShExC or ShExJ is the creation of a set of executab
 
 ## Dependencies
 
-* [Ruby](http://ruby-lang.org/) (>= 2.2.2)
-* [RDF.rb](http://rubygems.org/gems/rdf) (>= 2.2)
+* [Ruby](https://ruby-lang.org/) (>= 2.4)
+* [RDF.rb](https://rubygems.org/gems/rdf) (~> 3.1)
 
 ## Installation
 
-The recommended installation method is via [RubyGems](http://rubygems.org/).
+The recommended installation method is via [RubyGems](https://rubygems.org/).
 To install the latest official release of RDF.rb, do:
 
     % [sudo] gem install shex
@@ -197,21 +212,21 @@ To get a local working copy of the development repository, do:
 Alternatively, download the latest development version as a tarball as
 follows:
 
-    % wget http://github.com/ruby-rdf/shex/tarball/master
+    % wget https://github.com/ruby-rdf/shex/tarball/master
 
 ## Resources
 
-* <http://rubydoc.info/github/ruby-rdf/shex>
-* <http://github.com/ruby-rdf/shex>
-* <http://rubygems.org/gems/shex>
+* <https://rubydoc.info/github/ruby-rdf/shex>
+* <https://github.com/ruby-rdf/shex>
+* <https://rubygems.org/gems/shex>
 
 ## Mailing List
 
-* <http://lists.w3.org/Archives/Public/public-rdf-ruby/>
+* <https://lists.w3.org/Archives/Public/public-rdf-ruby/>
 
 ## Author
 
-* [Gregg Kellogg](http://github.com/gkellogg) - <http://greggkellogg.net/>
+* [Gregg Kellogg](https://github.com/gkellogg) - <https://greggkellogg.net/>
 
 ## Contributing
 
@@ -235,9 +250,9 @@ This repository uses [Git Flow](https://github.com/nvie/gitflow) to mange develo
 ## License
 
 This is free and unencumbered public domain software. For more information,
-see <http://unlicense.org/> or the accompanying {file:LICENSE} file.
+see <https://unlicense.org/> or the accompanying {file:LICENSE} file.
 
-[ShExSpec]:     https://shexspec.github.io/spec/
-[RDF]:          http://www.w3.org/RDF/
-[RDF.rb]:       http://rubydoc.info/github/ruby-rdf/rdf
-[EBNF]:         http://rubygems.org/gems/ebnf
+[ShExSpec]:     https://shex.io/shex-semantics/
+[RDF]:          https://www.w3.org/RDF/
+[RDF.rb]:       https://rubydoc.info/github/ruby-rdf/rdf
+[EBNF]:         https://rubygems.org/gems/ebnf

data/VERSION

@@ -1 +1 @@
-0.4.0
+0.6.1

data/etc/doap.ttl

@@ -1,3 +1,4 @@
+@base <https://rubygems.org/gems/shex> .
 @prefix rdf:  <http://www.w3.org/1999/02/22-rdf-syntax-ns#> .
 @prefix rdfs: <http://www.w3.org/2000/01/rdf-schema#> .
 @prefix dc:   <http://purl.org/dc/terms/> .
@@ -7,27 +8,27 @@
 @prefix ex:   <http://example.org/> .
 @prefix xsd:  <http://www.w3.org/2001/XMLSchema#> .
 
-<http://rubygems.org/gems/shex> a doap:Project, earl:TestSubject, earl:Software ;
+<https://rubygems.org/gems/shex> a doap:Project, earl:TestSubject, earl:Software ;
   doap:name          "ShEx.rb" ;
-  doap:homepage      <http://ruby-rdf.github.com/shex> ;
-  doap:license       <http://creativecommons.org/licenses/publicdomain/> ;
+  doap:homepage      <https://ruby-rdf.github.com/shex> ;
+  doap:license       <https://unlicense.org/1.0/> ;
   doap:shortdesc     "ShEx is a Shape Expression engine for Ruby."@en ;
   doap:description   "ShEx is an Shape Expression engine for the RDF.rb library suite."@en ;
   doap:created       "2016-12-09"^^xsd:date ;
   doap:programming-language "Ruby" ;
-  doap:implements    <https://shexspec.github.io/spec/> ;
+  doap:implements    <http://shex.io/shex-semantics/> ;
   doap:category      <http://dbpedia.org/resource/Resource_Description_Framework>,
                      <http://dbpedia.org/resource/Ruby_(programming_language)> ;
-  doap:download-page <http://rubygems.org/gems/shex> ;
-  doap:mailing-list  <http://lists.w3.org/Archives/Public/public-rdf-ruby/> ;
-  doap:bug-database  <http://github.com/ruby-rdf/shex/issues> ;
-  doap:blog          <http://greggkellogg.net/> ;
-  doap:developer     <http://greggkellogg.net/foaf#me> ;
-  doap:maintainer    <http://greggkellogg.net/foaf#me> ;
-  doap:documenter    <http://greggkellogg.net/foaf#me> ;
-  foaf:maker         <http://greggkellogg.net/foaf#me> ;
+  doap:download-page <https://rubygems.org/gems/shex> ;
+  doap:mailing-list  <https://lists.w3.org/Archives/Public/public-rdf-ruby/> ;
+  doap:bug-database  <https://github.com/ruby-rdf/shex/issues> ;
+  doap:blog          <https://greggkellogg.net/> ;
+  doap:developer     <https://greggkellogg.net/foaf#me> ;
+  doap:maintainer    <https://greggkellogg.net/foaf#me> ;
+  doap:documenter    <https://greggkellogg.net/foaf#me> ;
+  foaf:maker         <https://greggkellogg.net/foaf#me> ;
   dc:title           "ShEx.rb" ;
   dc:description     "ShEx is an Shape Expression engine for the RDF.rb library suite."@en ;
   dc:date            "2016-12-09"^^xsd:date ;
-  dc:creator         <http://greggkellogg.net/foaf#me> ;
-  dc:isPartOf        <http://rubygems.org/gems/rdf> .
+  dc:creator         <https://greggkellogg.net/foaf#me> ;
+  dc:isPartOf        <https://rubygems.org/gems/rdf> .

data/lib/shex.rb

@@ -1,8 +1,9 @@
 ##
 # A ShEx runtime for RDF.rb.
 #
-# @see https://shexspec.github.io/spec/#shexc
+# @see https://shex.io/shex-semantics/#shexc
 module ShEx
+  require               'shex/format'
   autoload :Algebra,    'shex/algebra'
   autoload :Meta,       'shex/meta'
   autoload :Parser,     'shex/parser'
@@ -11,7 +12,7 @@ module ShEx
   autoload :VERSION,    'shex/version'
 
   # Location of the ShEx JSON-LD context
-  CONTEXT = "https://shexspec.github.io/context.jsonld"
+  CONTEXT = "http://www.w3.org/ns/shex.jsonld"
 
   # Extensions defined in this gem
   EXTENSIONS = %w{test}
@@ -32,13 +33,13 @@ module ShEx
   # @raise  (see ShEx::Parser#parse)
   def self.parse(expression, format: 'shexc', **options)
     case format.to_s
-    when 'shexc' then Parser.new(expression, options).parse
+    when 'shexc' then Parser.new(expression, **options).parse
     when 'shexj'
       expression = expression.read if expression.respond_to?(:read)
-      Algebra.from_shexj(JSON.parse(expression), options)
+      Algebra.from_shexj(JSON.parse(expression), **options)
     when 'sxp'
       expression = expression.read if expression.respond_to?(:read)
-      Algebra.from_sxp(expression, options)
+      Algebra.from_sxp(expression, **options)
     else raise "Unknown expression format: #{format.inspect}"
     end
   end
@@ -55,8 +56,8 @@ module ShEx
   # @return (see ShEx::Parser#parse)
   # @raise  (see ShEx::Parser#parse)
   def self.open(filename, format: 'shexc', **options, &block)
-    RDF::Util::File.open_file(filename, options) do |file|
-      self.parse(file, options.merge(format: format))
+    RDF::Util::File.open_file(filename, **options) do |file|
+      self.parse(file, format: format, **options)
     end
   end
 
@@ -65,17 +66,17 @@ module ShEx
   #
   # @example executing a ShExC schema
   #   graph = RDF::Graph.load("etc/doap.ttl")
-  #   ShEx.execute('etc/doap.shex', graph, "http://rubygems.org/gems/shex", "")
+  #   ShEx.execute('etc/doap.shex', graph, "https://rubygems.org/gems/shex", "")
   #
   # @param [IO, StringIO, String, #to_s]  expression (ShExC or ShExJ)
   # @param (see ShEx::Algebra::Schema#execute)
   # @return (see ShEx::Algebra::Schema#execute)
   # @raise (see ShEx::Algebra::Schema#execute)
-  def self.execute(expression, queryable, focus, shape, format: 'shexc', **options)
-    shex = self.parse(expression, options.merge(format: format))
+  def self.execute(expression, queryable, map, format: 'shexc', **options)
+    shex = self.parse(expression, format: format, **options)
     queryable = queryable || RDF::Graph.new
 
-    shex.execute(focus, queryable, {focus => shape}, options)
+    shex.execute(queryable, map, **options)
   end
 
   ##
@@ -83,17 +84,17 @@ module ShEx
   #
   # @example executing a ShExC schema
   #   graph = RDF::Graph.load("etc/doap.ttl")
-  #   ShEx.execute('etc/doap.shex', graph, "http://rubygems.org/gems/shex", "")
+  #   ShEx.execute('etc/doap.shex', graph, "https://rubygems.org/gems/shex", "")
   #
   # @param [IO, StringIO, String, #to_s]  expression (ShExC or ShExJ)
   # @param (see ShEx::Algebra::Schema#satisfies?)
   # @return (see ShEx::Algebra::Schema#satisfies?)
   # @raise (see ShEx::Algebra::Schema#satisfies?)
-  def self.satisfies?(expression, queryable, focus, shape, format: 'shexc', **options)
-    shex = self.parse(expression, options.merge(format: format))
+  def self.satisfies?(expression, queryable, map, format: 'shexc', **options)
+    shex = self.parse(expression, format: format, **options)
     queryable = queryable || RDF::Graph.new
 
-    shex.satisfies?(focus, queryable, {focus => shape}, options)
+    shex.satisfies?(queryable, map, **options)
   end
 
   ##
@@ -115,7 +116,7 @@ module ShEx
     # @param  [String, #to_s]          message
     # @param  [Hash{Symbol => Object}] options
     # @option options [Integer]        :code (422)
-    def initialize(message, options = {})
+    def initialize(message, **options)
       @code = options.fetch(:status_code, 422)
       super(message.to_s)
     end
@@ -129,14 +130,14 @@ module ShEx
   class NotSatisfied < Error
     ##
     # The expression which was not satified
-    # @return [ShEx::Satisfiable]
+    # @return [ShEx::Algebra::ShapeExpression]
     attr_reader :expression
 
     ##
     # Initializes a new parser error instance.
     #
-    # @param  [String, #to_s]          message
-    # @param  [Satisfiable]            expression (self)
+    # @param  [String, #to_s]                   message
+    # @param  [ShEx::Algebra::ShapeExpression]  expression
     def initialize(message, expression: self)
       @expression = expression
       super(message.to_s)
@@ -157,8 +158,8 @@ module ShEx
     ##
     # Initializes a new parser error instance.
     #
-    # @param  [String, #to_s]          message
-    # @param  [Satisfiable]            expression (self)
+    # @param  [String, #to_s]                   message
+    # @param  [ShEx::Algebra::TripleExpression] expression
     def initialize(message, expression: self)
       @expression = expression
       super(message.to_s)

data/lib/shex/algebra.rb

@@ -5,27 +5,34 @@ require 'sxp'
 module ShEx
   # Based on the SPARQL Algebra, operators for executing a patch
   #
-  # @author [Gregg Kellogg](http://greggkellogg.net/)
+  # @author [Gregg Kellogg](https://greggkellogg.net/)
   module Algebra
-    autoload :And, 'shex/algebra/and'
-    autoload :Annotation, 'shex/algebra/annotation'
-    autoload :EachOf, 'shex/algebra/each_of'
-    autoload :External, 'shex/algebra/external'
-    autoload :Not, 'shex/algebra/not'
-    autoload :NodeConstraint, 'shex/algebra/node_constraint'
-    autoload :OneOf, 'shex/algebra/one_of'
-    autoload :Operator, 'shex/algebra/operator'
-    autoload :Or, 'shex/algebra/or'
-    autoload :Schema, 'shex/algebra/schema'
-    autoload :SemAct, 'shex/algebra/semact'
-    autoload :ShapeExpression, 'shex/algebra/shape_expression'
-    autoload :Shape, 'shex/algebra/shape'
-    autoload :Start, 'shex/algebra/start'
-    autoload :Stem, 'shex/algebra/stem'
-    autoload :StemRange, 'shex/algebra/stem_range'
+    autoload :And,              'shex/algebra/and'
+    autoload :Annotation,       'shex/algebra/annotation'
+    autoload :EachOf,           'shex/algebra/each_of'
+    autoload :External,         'shex/algebra/external'
+    autoload :IriStem,          'shex/algebra/stem'
+    autoload :IriStemRange,     'shex/algebra/stem_range'
+    autoload :Language,         'shex/algebra/language'
+    autoload :LanguageStem,     'shex/algebra/stem'
+    autoload :LanguageStemRange,'shex/algebra/stem_range'
+    autoload :LiteralStem,      'shex/algebra/stem'
+    autoload :LiteralStemRange, 'shex/algebra/stem_range'
+    autoload :NodeConstraint,   'shex/algebra/node_constraint'
+    autoload :Not,              'shex/algebra/not'
+    autoload :OneOf,            'shex/algebra/one_of'
+    autoload :Operator,         'shex/algebra/operator'
+    autoload :Or,               'shex/algebra/or'
+    autoload :Schema,           'shex/algebra/schema'
+    autoload :SemAct,           'shex/algebra/semact'
+    autoload :Shape,            'shex/algebra/shape'
+    autoload :ShapeExpression,  'shex/algebra/shape_expression'
+    autoload :Start,            'shex/algebra/start'
+    autoload :Stem,             'shex/algebra/stem'
+    autoload :StemRange,        'shex/algebra/stem_range'
     autoload :TripleConstraint, 'shex/algebra/triple_constraint'
     autoload :TripleExpression, 'shex/algebra/triple_expression'
-    autoload :Value, 'shex/algebra/value'
+    autoload :Value,            'shex/algebra/value'
 
 
     ##
@@ -43,28 +50,33 @@ module ShEx
     # @option options [RDF::URI] :base
     # @option options [Hash{String => RDF::URI}] :prefixes
     # @return [Operator]
-    def self.from_shexj(operator, options = {})
+    def self.from_shexj(operator, **options)
       raise ArgumentError unless operator.is_a?(Hash)
       klass = case operator['type']
-      when 'Annotation'       then Annotation
-      when 'EachOf'           then EachOf
-      when 'NodeConstraint'   then NodeConstraint
-      when 'OneOf'            then OneOf
-      when 'Schema'           then Schema
-      when 'SemAct'           then SemAct
-      when 'Shape'            then Shape
-      when 'ShapeAnd'         then And
-      when 'ShapeExternal'    then External
-      when 'ShapeNot'         then Not
-      when 'ShapeOr'          then Or
-      when 'Stem'             then Stem
-      when 'StemRange'        then StemRange
-      when 'TripleConstraint' then TripleConstraint
-      when 'Wildcard'         then StemRange
-      else raise ArgumentError, "unknown type #{operator['type']}"
+      when 'Annotation'         then Annotation
+      when 'EachOf'             then EachOf
+      when 'IriStem'            then IriStem
+      when 'IriStemRange'       then IriStemRange
+      when 'Language'           then Language
+      when 'LanguageStem'       then LanguageStem
+      when 'LanguageStemRange'  then LanguageStemRange
+      when 'LiteralStem'        then LiteralStem
+      when 'LiteralStemRange'   then LiteralStemRange
+      when 'NodeConstraint'     then NodeConstraint
+      when 'OneOf'              then OneOf
+      when 'Schema'             then Schema
+      when 'SemAct'             then SemAct
+      when 'Shape'              then Shape
+      when 'ShapeAnd'           then And
+      when 'ShapeExternal'      then External
+      when 'ShapeNot'           then Not
+      when 'ShapeOr'            then Or
+      when 'TripleConstraint'   then TripleConstraint
+      when 'Wildcard'           then StemRange
+      else raise ArgumentError, "unknown type #{operator['type'].inspect}"
       end
 
-      klass.from_shexj(operator, options)
+      klass.from_shexj(operator, **options)
     end
   end
 end