shex 0.6.2 → 0.7.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0d91d9cf7282456c7a61fba4c17609eda22851232c5bfe7be75518c0bb1ea354
-  data.tar.gz: b465b287f74cd1efaa8788ad80a9a0e4ee78e89d6a8ea061445de526f8b78edf
+  metadata.gz: f23772b66ae1d2d65f82803ebc661051084b62bab305781945c3d36a1c9ff1c1
+  data.tar.gz: c5cba5902f5c6b2dd0bdf446ec9625dc9baa94682f5375fb3c3b89d1bd76cc91
 SHA512:
-  metadata.gz: 695c099ae0fb5899086f50296293610c3f6f1a82a361ed5da953fd1495cc38a538a26048fcdf8b329a6313e7e81abd1e102883523ad12c3b5e360cdcee0686df
-  data.tar.gz: 7dd2fe93e6cf93b1afca58d09d79ea318d71314759e0b790b524fe58fdee7bd5954d2950ea67cee69b1953b25bc612d54a9a6bcb0b7ef74c0061555f61f68700
+  metadata.gz: a9ad30899338103d06b8b2d89070990c81215e3bfe0ab0d649bcbb3290e5981fe7aadf15e6456358786fc4f5f68c8a28aafd44d6e440f42130f1778622ebd0dc
+  data.tar.gz: 7107749beac51786c8778a1f2ea8a733caf49d8b01d323d0437eecc5d17e873bc1ad083fbc146133cde250dd8705a25105c5f7522afc0eb2773f50ef996b86f5

data/README.md

@@ -18,34 +18,38 @@ This is a pure-Ruby library for working with the [Shape Expressions Language][Sh
 
 The ShEx gem implements a [ShEx][ShExSpec] Shape Expression engine version 2.0.
 
-* `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::Parser` parses ShExC and ShExJ formatted documents generating executable operators which can be serialized as [S-Expressions][].
 * `ShEx::Algebra` executes operators against Any `RDF::Graph`, including compliant [RDF.rb][].
 * [Implementation Report](file.earl.html)
 
 ## Examples
 ### Validating a node using ShExC
 
-    require 'rubygems'
     require 'rdf/turtle'
     require 'shex'
 
-    shexc: %(
+    shexc = %(
       PREFIX doap:  <http://usefulinc.com/ns/doap#>
       PREFIX dc:    <http://purl.org/dc/terms/>
-      <TestShape> EXTRA a {
-        a doap:Project;
-        (doap:name;doap:description|dc:title;dc:description)+;
-        doap:category*;
-        doap:developer IRI;
-        doap:implements    [<http://shex.io/shex-semantics/>]
+      PREFIX ex:    <http://example.com/>
+
+      ex:TestShape EXTRA a {
+        a [doap:Project];
+        ( doap:name Literal;
+          doap:description Literal
+        | dc:title Literal;
+          dc:description Literal)+;
+        doap:category    IRI*;
+        doap:developer   IRI+;
+        doap:implements [<http://shex.io/shex-semantics/>]
       }
     )
     graph = RDF::Graph.load("etc/doap.ttl")
     schema = ShEx.parse(shexc)
     map = {
-      "https://rubygems.org/gems/shex" => "TestShape"
+      RDF::URI("https://rubygems.org/gems/shex") => RDF::URI("http://example.com/TestShape")
     }
-    schema.satisfies?("https://rubygems.org/gems/shex", graph, map)
+    schema.satisfies?(graph, map)
     # => true
 ### Validating a node using ShExJ
 
@@ -53,92 +57,99 @@ The ShEx gem implements a [ShEx][ShExSpec] Shape Expression engine version 2.0.
     require 'rdf/turtle'
     require 'shex'
 
-    shexj: %({
+    shexj = %({
+      "@context": "http://www.w3.org/ns/shex.jsonld",
       "type": "Schema",
-      "prefixes": {
-        "doap": "http://usefulinc.com/ns/doap#",
-        "dc": "http://purl.org/dc/terms/"
-      },
-      "shapes": {
-        "TestShape": {
-          "type": "Shape",
-          "extra": ["http://www.w3.org/1999/02/22-rdf-syntax-ns#type"],
-          "expression": {
-            "type": "EachOf",
-            "expressions": [
-              {
-                "type": "TripleConstraint",
-                "predicate": "http://www.w3.org/1999/02/22-rdf-syntax-ns#type",
-                "valueExpr": {
-                  "type": "NodeConstraint",
-                  "values": ["http://usefulinc.com/ns/doap#Project"]
-                }
-              },
-              {
-                "type": "OneOf",
-                "expressions": [
-                  {
-                    "type": "EachOf",
-                    "expressions": [
-                      {
-                        "type": "TripleConstraint",
-                        "predicate": "http://usefulinc.com/ns/doap#name",
-                        "valueExpr": {"type": "NodeConstraint", "nodeKind": "literal"}
-                      },
-                      {
-                        "type": "TripleConstraint",
-                        "predicate": "http://usefulinc.com/ns/doap#description",
-                        "valueExpr": {"type": "NodeConstraint", "nodeKind": "literal"}
-                      }
-                    ]
-                  },
-                  {
-                    "type": "EachOf",
-                    "expressions": [
-                      {
-                        "type": "TripleConstraint",
-                        "predicate": "http://purl.org/dc/terms/title",
-                        "valueExpr": {"type": "NodeConstraint", "nodeKind": "literal"}
-                      },
-                      {
-                        "type": "TripleConstraint",
-                        "predicate": "http://purl.org/dc/terms/description",
-                        "valueExpr": {"type": "NodeConstraint", "nodeKind": "literal"}
-                      }
-                    ]
+      "shapes": [{
+        "id": "http://example.com/TestShape",
+        "type": "Shape",
+        "extra": ["http://www.w3.org/1999/02/22-rdf-syntax-ns#type"],
+        "expression": {
+          "type": "EachOf",
+          "expressions": [{
+            "type": "TripleConstraint",
+            "predicate": "http://www.w3.org/1999/02/22-rdf-syntax-ns#type",
+            "valueExpr": {
+              "type": "NodeConstraint",
+              "values": ["http://usefulinc.com/ns/doap#Project"]
+            }
+          }, {
+            "type": "OneOf",
+            "expressions": [{
+                "type": "EachOf",
+                "expressions": [{
+                  "type": "TripleConstraint",
+                  "predicate": "http://usefulinc.com/ns/doap#name",
+                  "valueExpr": {
+                    "type": "NodeConstraint",
+                    "nodeKind": "literal"
                   }
-                ],
-                "min": 1, "max": -1
-              },
-              {
-                "type": "TripleConstraint",
-                "predicate": "http://usefulinc.com/ns/doap#category",
-                "valueExpr": {"type": "NodeConstraint", "nodeKind": "iri"},
-                "min": 0, "max": -1
+                }, {
+                  "type": "TripleConstraint",
+                  "predicate": "http://usefulinc.com/ns/doap#description",
+                  "valueExpr": {
+                    "type": "NodeConstraint",
+                    "nodeKind": "literal"
+                  }
+                }]
+              }, {
+                "type": "EachOf",
+                "expressions": [{
+                  "type": "TripleConstraint",
+                  "predicate": "http://purl.org/dc/terms/title",
+                  "valueExpr": {
+                    "type": "NodeConstraint",
+                    "nodeKind": "literal"
+                  }
+                }, {
+                  "type": "TripleConstraint",
+                  "predicate": "http://purl.org/dc/terms/description",
+                  "valueExpr": {
+                    "type": "NodeConstraint",
+                    "nodeKind": "literal"
+                  }
+                }]
+              }],
+              "min": 1,
+              "max": -1
+            }, {
+              "type": "TripleConstraint",
+              "predicate": "http://usefulinc.com/ns/doap#category",
+              "valueExpr": {
+                "type": "NodeConstraint",
+                "nodeKind": "iri"
               },
-              {
-                "type": "TripleConstraint",
-                "predicate": "http://usefulinc.com/ns/doap#developer",
-                "valueExpr": {"type": "NodeConstraint", "nodeKind": "iri"},
-                "min": 1, "max": -1
+              "min": 0,
+              "max": -1
+            }, {
+              "type": "TripleConstraint",
+              "predicate": "http://usefulinc.com/ns/doap#developer",
+              "valueExpr": {
+                "type": "NodeConstraint",
+                "nodeKind": "iri"
               },
-              {
-                "type": "TripleConstraint",
-                "predicate": "http://usefulinc.com/ns/doap#implements",
-                "valueExpr": {
-                  "type": "NodeConstraint",
-                  "values": ["http://shex.io/shex-semantics/"]
-                }
+              "min": 1,
+              "max": -1
+            }, {
+              "type": "TripleConstraint",
+              "predicate": "http://usefulinc.com/ns/doap#implements",
+              "valueExpr": {
+                "type": "NodeConstraint",
+                "values": [
+                  "http://shex.io/shex-semantics/"
+                ]
               }
-            ]
-          }
+            }
+          ]
         }
       }
-    })
+    ]})
     graph = RDF::Graph.load("etc/doap.ttl")
     schema = ShEx.parse(shexj, format: :shexj)
-    map = {"https://rubygems.org/gems/shex" => "TestShape"}
-    schema.satisfies?("https://rubygems.org/gems/shex", graph, map)
+    map = {
+      RDF::URI("https://rubygems.org/gems/shex") => RDF::URI("http://example.com/TestShape")
+    }
+    schema.satisfies?(graph, map)
     # => true
 
 ## Extensions
@@ -179,20 +190,18 @@ Example usage:
 
 ## Documentation
 
-<https://rubydoc.info/github/ruby-rdf/shex>
+<https://ruby-rdf.github.io/shex>
 
 
 ## Implementation Notes
-The ShExC parser uses the [EBNF][] gem to generate first, follow and branch tables, and uses the `Parser` and `Lexer` modules to implement the ShExC parser.
-
-The parser takes branch and follow tables generated from the [ShEx Grammar](file.shex.html) described in the [specification][ShExSpec]. Branch and Follow tables are specified in the generated {ShEx::Meta}.
+The ShExC parser uses the [EBNF][] gem to generate a [PEG][] parser.
 
-The result of parsing either ShExC or ShExJ is the creation of a set of executable {ShEx::Algebra} Operators which are directly executed to perform shape validation.
+The parser uses the executable [S-Expressions][] generated from the EBNF ShExC grammar to create a set of executable {ShEx::Algebra} Operators which are directly executed to perform shape validation.
 
 ## Dependencies
 
-* [Ruby](https://ruby-lang.org/) (>= 2.4)
-* [RDF.rb](https://rubygems.org/gems/rdf) (~> 3.1)
+* [Ruby](https://ruby-lang.org/) (>= 2.6)
+* [RDF.rb](https://rubygems.org/gems/rdf) (~> 3.2)
 * [SPARQL gem](https://rubygems.org/gems/sparql) (~> 3.1)
 
 ## Installation
@@ -215,7 +224,7 @@ follows:
 
 ## Resources
 
-* <https://rubydoc.info/github/ruby-rdf/shex>
+* <https://ruby-rdf.github.io/shex>
 * <https://github.com/ruby-rdf/shex>
 * <https://rubygems.org/gems/shex>
 
@@ -255,8 +264,10 @@ see <https://unlicense.org/> or the accompanying {file:LICENSE} file.
 
 [ShExSpec]:     http://shex.io/shex-semantics-20170713/
 [RDF]:          https://www.w3.org/RDF/
-[RDF.rb]:       https://rubydoc.info/github/ruby-rdf/rdf
+[RDF.rb]:       https://ruby-rdf.github.io/rdf
 [EBNF]:         https://rubygems.org/gems/ebnf
 [YARD]:         https://yardoc.org/
 [YARD-GS]:      https://rubydoc.info/docs/yard/file/docs/GettingStarted.md
 [PDD]:              https://unlicense.org/#unlicensing-contributions
+[PEG]:          https://en.wikipedia.org/wiki/Parsing_expression_grammar "Parsing Expression Grammar"
+[S-Expression]: https://en.wikipedia.org/wiki/S-expression

data/VERSION

@@ -1 +1 @@
-0.6.2
+0.7.1

data/etc/doap.ttl

@@ -10,7 +10,7 @@
 
 <https://rubygems.org/gems/shex> a doap:Project, earl:TestSubject, earl:Software ;
   doap:name          "ShEx" ;
-  doap:homepage      <https://ruby-rdf.github.com/shex> ;
+  doap:homepage      <https://ruby-rdf.github.io/shex> ;
   doap:license       <https://unlicense.org/1.0/> ;
   doap:shortdesc     "ShEx is a Shape Expression engine for Ruby RDF.rb."@en ;
   doap:description   "ShEx is an Shape Expression engine for the Ruby RDF.rb library suite."@en ;

data/lib/shex/algebra/and.rb

@@ -61,22 +61,13 @@ module ShEx::Algebra
     end
 
     ##
-    # expressions must be ShapeExpressions
+    # expressions must be ShapeExpressions or references to ShapeExpressions
     #
     # @return [Operator] `self`
     # @raise  [ShEx::StructureError] if the value is invalid
     def validate!
-      expressions.each do |op|
-        case op
-        when ShapeExpression
-        when RDF::Resource
-          ref = schema.find(op)
-          ref.is_a?(ShapeExpression) ||
-          structure_error("#{json_type} must reference a ShapeExpression: #{ref}")
-        else
-          structure_error("#{json_type} must reference a ShapeExpression: #{ref}")
-        end
-      end
+      validate_expressions!
+      validate_self_references!
       super
     end
 

data/lib/shex/algebra/each_of.rb

@@ -73,22 +73,12 @@ module ShEx::Algebra
     end
 
     ##
-    # expressions must be TripleExpressions
+    # expressions must be TripleExpressions or references to TripleExpressions
     #
     # @return [Operator] `self`
     # @raise  [ShEx::StructureError] if the value is invalid
     def validate!
-      expressions.each do |op|
-        case op
-        when TripleExpression
-        when RDF::Resource
-          ref = schema.find(op)
-          ref.is_a?(TripleExpression) ||
-          structure_error("#{json_type} must reference a TripleExpression: #{ref}")
-        else
-          structure_error("#{json_type} must reference a TripleExpression: #{ref}")
-        end
-      end
+      validate_expressions!
       super
     end
   end

data/lib/shex/algebra/import.rb

@@ -0,0 +1,6 @@
+module ShEx::Algebra
+  ##
+  class Import < Operator::Unary
+    NAME = :import
+  end
+end

data/lib/shex/algebra/not.rb

@@ -45,20 +45,13 @@ module ShEx::Algebra
     end
 
     ##
-    # expression must be a ShapeExpression
+    # expressions must be ShapeExpressions or references to ShapeExpressions and must not reference itself recursively.
     #
     # @return [Operator] `self`
     # @raise  [ShEx::StructureError] if the value is invalid
     def validate!
-      case expression
-      when ShapeExpression
-      when RDF::Resource
-        ref = schema.find(expression)
-        ref.is_a?(ShapeExpression) ||
-        structure_error("#{json_type} must reference a ShapeExpression: #{ref}")
-      else
-        structure_error("#{json_type} must reference a ShapeExpression: #{ref}")
-      end
+      validate_expressions!
+      validate_self_references!
       super
     end
 

data/lib/shex/algebra/one_of.rb

@@ -65,22 +65,12 @@ module ShEx::Algebra
     end
 
     ##
-    # expressions must be TripleExpressions
+    # expressions must be TripleExpressions or references to TripleExpressions
     #
     # @return [Operator] `self`
     # @raise  [ShEx::StructureError] if the value is invalid
     def validate!
-      expressions.each do |op|
-        case op
-        when TripleExpression
-        when RDF::Resource
-          ref = schema.find(op)
-          ref.is_a?(TripleExpression) ||
-          structure_error("#{json_type} must reference a TripleExpression: #{ref}")
-        else
-          structure_error("#{json_type} must reference a TripleExpression: #{ref}")
-        end
-      end
+      validate_expressions!
       super
     end
   end

data/lib/shex/algebra/operator.rb

@@ -35,8 +35,8 @@ module ShEx::Algebra
     #   @option options [RDF::Resource] :id
     #     Identifier of the operator
     # @raise  [TypeError] if any operand is invalid
-    def initialize(*operands)
-      @options  = operands.last.is_a?(Hash) ? operands.pop.dup : {}
+    def initialize(*operands, **options)
+      @options  = options.dup
       @operands = operands.map! do |operand|
         case operand
           when Array
@@ -221,12 +221,19 @@ module ShEx::Algebra
     end
 
     ##
-    # The optional TripleExpression for this Shape.
-    # @return [TripleExpression]
+    # The first expression from {#expressions}.
+    # @return [RDF::Resource, Operand]
     def expression
       expressions.first
     end
 
+    ##
+    # References are all operands which are RDF::Resource
+    # @return [RDF::Resource, Operand]
+    def references
+      @references = operands.select {|op| op.is_a?(RDF::Resource)}
+    end
+
     ##
     # Returns the binary S-Expression (SXP) representation of this operator.
     #
@@ -242,15 +249,10 @@ module ShEx::Algebra
     # Returns an S-Expression (SXP) representation of this operator
     #
     # @return [String]
-    def to_sxp
-      begin
-        require 'sxp' # @see https://rubygems.org/gems/sxp
-      rescue LoadError
-        abort "SPARQL::Algebra::Operator#to_sxp requires the SXP gem (hint: `gem install sxp')."
-      end
+    def to_sxp(**options)
       require 'sparql/algebra/sxp_extensions'
 
-      to_sxp_bin.to_sxp
+      to_sxp_bin.to_sxp(**options)
     end
 
     ##
@@ -432,6 +434,8 @@ module ShEx::Algebra
           case self
           when And, Or
             (obj['shapeExprs'] ||= []) << op.to_h
+          when Not
+            obj['shapeExpr'] = op.to_h
           else
             obj['valueExpr'] = op.to_h
           end
@@ -593,22 +597,23 @@ module ShEx::Algebra
 
     ##
     # Enumerate via depth-first recursive descent over operands, yielding each operator
+    # @param [Boolean] include_self
     # @yield operator
     # @yieldparam [Object] operator
     # @return [Enumerator]
-    def each_descendant(&block)
+    def each_descendant(include_self = false, &block)
       if block_given?
 
-        block.call(self)
+        block.call(self) if include_self
 
         operands.each do |operand|
           case operand
           when Array
             operand.each do |op|
-              op.each_descendant(&block) if op.respond_to?(:each_descendant)
+              op.each_descendant(true, &block) if op.respond_to?(:each_descendant)
             end
           else
-            operand.each_descendant(&block) if operand.respond_to?(:each_descendant)
+            operand.each_descendant(true, &block) if operand.respond_to?(:each_descendant)
           end
         end
       end
@@ -631,6 +636,14 @@ module ShEx::Algebra
       @options[:parent]= operator
     end
 
+    ##
+    # Find a ShapeExpression or TripleExpression by identifier
+    # @param [#to_s] id
+    # @return [TripleExpression, ShapeExpression]
+    def find(id)
+      each_descendant(false).detect {|op| op.id == id}
+    end
+
     ##
     # Ancestors of this Operator
     # @return [Array<Operator>]

data/lib/shex/algebra/or.rb

@@ -67,22 +67,13 @@ module ShEx::Algebra
     end
 
     ##
-    # expressions must be ShapeExpressions
+    # expressions must be ShapeExpressions or references to ShapeExpressions
     #
     # @return [Operator] `self`
     # @raise  [ShEx::StructureError] if the value is invalid
     def validate!
-      expressions.each do |op|
-        case op
-        when ShapeExpression
-        when RDF::Resource
-          ref = schema.find(op)
-          ref.is_a?(ShapeExpression) ||
-          structure_error("#{json_type} must reference a ShapeExpression: #{ref}")
-        else
-          structure_error("#{json_type} must reference a ShapeExpression: #{ref}")
-        end
-      end
+      validate_expressions!
+      validate_self_references!
       super
     end
 

data/lib/shex/algebra/schema.rb

@@ -25,8 +25,9 @@ module ShEx::Algebra
     end
 
     # (see Operator#initialize)
-    def initialize(*operands)
+    def initialize(*operands, **options)
       super
+      schema = self
       each_descendant do |op|
         # Set schema everywhere
         op.schema = self
@@ -211,14 +212,6 @@ module ShEx::Algebra
       @start ||= operands.detect {|op| op.is_a?(Start)}
     end
 
-    ##
-    # Find a ShapeExpression or TripleExpression by identifier
-    # @param [#to_s] id
-    # @return [TripleExpression, ShapeExpression]
-    def find(id)
-      each_descendant.detect {|op| op.id == id}
-    end
-
     ##
     # Validate shapes, in addition to other operands
     # @return [Operator] `self`

data/lib/shex/algebra/shape.rb

@@ -106,7 +106,7 @@ module ShEx::Algebra
     end
 
     ##
-    # expression must be a TripleExpression
+    # expression must be a TripleExpression and must not reference itself recursively.
     #
     # @return [Operator] `self`
     # @raise  [ShEx::StructureError] if the value is invalid
@@ -118,8 +118,10 @@ module ShEx::Algebra
         ref.is_a?(TripleExpression) ||
         structure_error("#{json_type} must reference a TripleExpression: #{ref}")
       else
-        structure_error("#{json_type} must reference a TripleExpression: #{ref}")
+        structure_error("#{json_type} must be a TripleExpression or reference: #{expression.to_sxp}")
       end
+      # FIXME: this runs afoul of otherwise legitamate self-references, through a TripleExpression.
+      #!validate_self_references!
       super
     end
 

data/lib/shex/algebra/shape_expression.rb

@@ -15,5 +15,34 @@ module ShEx::Algebra
     def satisfies?(focus, depth: 0, **options)
       raise NotImplementedError, "#satisfies? Not implemented in #{self.class}"
     end
+
+    ##
+    # expressions must be ShapeExpressions or references.
+    #
+    # @raise  [ShEx::StructureError] if the value is invalid
+    def validate_expressions!
+      expressions.each do |op|
+        case op
+        when ShapeExpression
+        when RDF::Resource
+          ref = schema.find(op)
+          ref.is_a?(ShapeExpression) ||
+          structure_error("#{json_type} must reference a ShapeExpression: #{ref}")
+        else
+          structure_error("#{json_type} must be a ShapeExpression or reference: #{op.to_sxp}")
+        end
+      end
+    end
+
+    ##
+    # An Operator with a label must contain a reference to itself.
+    #
+    # @raise  [ShEx::StructureError] if the shape is invalid
+    def validate_self_references!
+      return # FIXME: needs to stop at a TripleConstraint
+      each_descendant do |op|
+        structure_error("#{json_type} must not reference itself (#{id}): #{op.to_sxp}") if op.references.include?(id)
+      end
+    end
   end
 end

data/lib/shex/algebra/start.rb

@@ -30,20 +30,12 @@ module ShEx::Algebra
     end
 
     ##
-    # expression must be a ShapeExpression
+    # expressions must be ShapeExpressions or references to ShapeExpressions
     #
     # @return [Operator] `self`
     # @raise  [ShEx::StructureError] if the value is invalid
     def validate!
-      case expression
-      when ShapeExpression
-      when RDF::Resource
-        ref = schema.find(expression)
-        ref.is_a?(ShapeExpression) ||
-        structure_error("#{json_type} must reference a ShapeExpression: #{ref}")
-      else
-        structure_error("#{json_type} must reference a ShapeExpression: #{ref}")
-      end
+      validate_expressions!
       super
     end
   end

data/lib/shex/algebra/stem.rb

@@ -66,8 +66,12 @@ module ShEx::Algebra
     NAME = :languageStem
 
     # (see Stem#match?)
+    # If the operand is empty, than any language will do,
+    # otherwise, it matches the substring up to that first '-', if any.
     def match?(value, depth: 0)
-      if value.literal? && value.language.to_s.start_with?(operands.first)
+      if value.literal? &&
+         value.language? &&
+         (operands.first.to_s.empty? || value.language.to_s.match?(%r(^#{operands.first}((-.*)?)$)))
         status "matched #{value}", depth: depth
         true
       else