shex 0.6.3 → 0.6.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f2a6bb3da7f7e92a1a168e6390cbd1d41406df0baf7b5d76f358843b6e3fb071
-  data.tar.gz: 34a49a33ec8d8208cef666e913d9dd33fe02355caf7cff8ce2b54c2c9e65a4c5
+  metadata.gz: e45bfef778f047d77b25295bf5c41cfc1ed69d040a1ea76dd145734a755faffd
+  data.tar.gz: 91b81f28e0db8a507924627fd94bfc8265301588346715a9102dbf9cea091ab1
 SHA512:
-  metadata.gz: da5cefbf0b4831c741b3bad56091077b60ea178acaac3e4c5fc0a554a87f97c26dc1086fdbd9a6e84427e3db8d1df188b849106dc85b29de789e6caff34d6544
-  data.tar.gz: 65d6123a33922a51061865181bdcf98a76b150442f641652e88f93b0c3939e47229f7bf66ca65d1a4380935f0453f5c78601299113b9dfcdd509605c6f28687c
+  metadata.gz: e6e9ecf3bbb822070f1d870233eed17ac5ac3a353fca09f8a782b3d31c3538f27d2c4ff2f53336fbcade2b65460c9598309c7bbb2cdb790f90edbc229fab2a17
+  data.tar.gz: 83fa124c1fb95b385ff86fdf707c2a0778261c4f92fce32becca03d7cd29b1e73b7fc56c86746a1dff2d6ba60306d55aa7c81918952142b60f80197bc1edf032

data/README.md

@@ -25,27 +25,31 @@ The ShEx gem implements a [ShEx][ShExSpec] Shape Expression engine version 2.0.
 ## 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

data/VERSION

@@ -1 +1 @@
-0.6.3
+0.6.4

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.
     #
@@ -243,11 +250,6 @@ module ShEx::Algebra
     #
     # @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
       require 'sparql/algebra/sxp_extensions'
 
       to_sxp_bin.to_sxp
@@ -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

data/lib/shex/algebra/stem_range.rb

@@ -102,7 +102,9 @@ module ShEx::Algebra
     def match?(value, depth: 0)
       initial_match = case operands.first
       when :wildcard then true
-      when RDF::Literal then value.language.to_s.start_with?(operands.first)
+      when RDF::Literal
+        value.language? &&
+        (operands.first.to_s.empty? || value.language.to_s.match?(%r(^#{operands.first}((-.*)?)$)))
       else false
       end
 

data/lib/shex/algebra/triple_constraint.rb

@@ -97,7 +97,7 @@ module ShEx::Algebra
         ref.is_a?(ShapeExpression) ||
         structure_error("#{json_type} must reference a ShapeExpression: #{ref}")
       else
-        structure_error("#{json_type} must reference a ShapeExpression: #{ref}")
+        structure_error("#{json_type} must be a ShapeExpression or reference: #{expresson.to_sxp}")
       end
       super
     end

data/lib/shex/algebra/triple_expression.rb

@@ -16,6 +16,24 @@ module ShEx::Algebra
       raise NotImplementedError, "#matches Not implemented in #{self.class}"
     end
 
+    ##
+    # expressions must be TripleExpressions or references to TripleExpressions
+    #
+    # @raise  [ShEx::StructureError] if the value is invalid
+    def validate_expressions!
+      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 be a TripleExpression or reference: #{op.to_sxp}")
+        end
+      end
+    end
+
     ##
     # Included TripleConstraints
     # @return [Array<TripleConstraints>]

data/lib/shex/algebra.rb

@@ -1,6 +1,5 @@
 $:.unshift(File.expand_path("../..", __FILE__))
 require 'sparql/algebra'
-require 'sxp'
 
 module ShEx
   # Based on the SPARQL Algebra, operators for executing a patch