shex 0.5.0 → 0.5.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: d66489982d96aa02cd6be18354daaa81934af243
-  data.tar.gz: 7385a3e9933b1c81e09b7d0a126a1760de9aa4c2
+  metadata.gz: 51c304bc780f271fc54404ac8becb3553504e17f
+  data.tar.gz: 15d2a5d06d9830be1071ec8fa8a98b64806e2459
 SHA512:
-  metadata.gz: d060ca866830927b3342352249337b6c06b25060677a8fe46e3a017d9c7a269749e5e1e792928eb6c4324bbaffb3bab91da1fb560d5e97ef33df57847df281e7
-  data.tar.gz: 7bf7a3fb6bd9d121a00ba837a5b0725cb5b2732d04dc8c959a8ee37ff3a311340dd9ebdf4496254dc450c39ee139e92800773990a133d922ffb98e5e7f602160
+  metadata.gz: 41c3c2aff0ba9f453d72c1a7a940de48f4826d0657f6e6cafeb4c5154e98ff45ce7c1ea6b26bc8a3d8a86f65d49449a42415217b4238724b4c08a33ddfb4c778
+  data.tar.gz: 3efdbda75cf115e4babeec86838d49790a89673109f0c19ae2d00527b1bb048a3dbc51fd1114445cd9669efecd91ece885c32571e2fe13351686630b30e58566

data/README.md

@@ -164,6 +164,20 @@ 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 http://rubygems.org/gems/shex
+
 ## Documentation
 
 <http://rubydoc.info/github/ruby-rdf/shex>

data/VERSION

@@ -1 +1 @@
-0.5.0
+0.5.1

data/etc/doap.ttl

@@ -1,3 +1,4 @@
+@base <http://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/> .

data/lib/shex.rb

@@ -3,6 +3,7 @@
 #
 # @see http://shex.io/shex-semantics/#shexc
 module ShEx
+  require               'shex/format'
   autoload :Algebra,    'shex/algebra'
   autoload :Meta,       'shex/meta'
   autoload :Parser,     'shex/parser'

data/lib/shex/algebra.rb

@@ -13,6 +13,7 @@ module ShEx
     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'
@@ -56,6 +57,7 @@ module ShEx
       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

data/lib/shex/algebra/language.rb

@@ -0,0 +1,22 @@
+module ShEx::Algebra
+  ##
+  class Language < Operator::Unary
+    NAME = :language
+
+    ##
+    # matches any literal having a language tag that matches value
+    def match?(value, depth: 0)
+      status "", depth: depth
+      if case expr = operands.first
+        when RDF::Literal then value.language == expr.to_s.to_sym
+        else false
+        end
+        status "matched #{value}", depth: depth
+        true
+      else
+        status "not matched #{value}", depth: depth
+        false
+      end
+    end
+  end
+end

data/lib/shex/algebra/operator.rb

@@ -269,11 +269,12 @@ module ShEx::Algebra
         case k
         when /length|clusive|digits/           then operands << [k.to_sym, RDF::Literal(v)]
         when 'id'                              then id = iri(v, options)
-        when 'flags'                            then ; # consumed in pattern below
+        when 'flags'                           then ; # consumed in pattern below
         when 'min', 'max'                      then operands << [k.to_sym, (v == -1 ? '*' : v)]
         when 'inverse', 'closed'               then operands << k.to_sym
         when 'nodeKind'                        then operands << v.to_sym
         when 'object'                          then operands << value(v, options)
+        when 'languageTag'                     then operands << v
         when 'pattern'
           # Include flags as well
           operands << [:pattern, RDF::Literal(v), operator['flags']].compact
@@ -295,7 +296,11 @@ module ShEx::Algebra
           end
         when 'stem', 'name'
           # Value may be :wildcard for stem
-          operands << (v.is_a?(Symbol) ? v : value(v, options))
+          if [IriStem, IriStemRange, SemAct].include?(self)
+            operands << (v.is_a?(Symbol) ? v : value(v, options))
+          else
+            operands << v
+          end
         when 'predicate' then operands << [:predicate, iri(v, options)]
         when 'extra', 'datatype'
           v = [v] unless v.is_a?(Array)
@@ -303,9 +308,13 @@ module ShEx::Algebra
         when 'exclusions'
           v = [v] unless v.is_a?(Array)
           operands << v.map do |op|
-            op.is_a?(Hash) && op.has_key?('type') ?
-              ShEx::Algebra.from_shexj(op, options) :
+            if op.is_a?(Hash) && op.has_key?('type')
+              ShEx::Algebra.from_shexj(op, options)
+            elsif [IriStem, IriStemRange].include?(self)
               value(op, options)
+            else
+              RDF::Literal(op)
+            end
           end.unshift(:exclusions)
         when 'semActs', 'startActs', 'annotations'
           v = [v] unless v.is_a?(Array)
@@ -350,7 +359,13 @@ module ShEx::Algebra
           # First element should be a symbol
           case sym = op.first
           when :datatype        then obj['datatype'] = op.last.to_s
-          when :exclusions      then obj['exclusions'] = Array(op[1..-1]).map {|v| serialize_value(v)}
+          when :exclusions
+            obj['exclusions'] = Array(op[1..-1]).map do |v|
+              case v
+              when Operator then v.to_h
+              else v.to_s
+              end
+            end
           when :extra           then (obj['extra'] ||= []).concat Array(op[1..-1]).map(&:to_s)
           when :pattern
             obj['pattern'] = op[1]
@@ -383,13 +398,18 @@ module ShEx::Algebra
           end
         when RDF::Value
           case self
-          when Stem, StemRange  then obj['stem'] = serialize_value(op)
+          when Stem, StemRange
+            obj['stem'] =  case op
+            when Operator then op.to_h
+            else op.to_s
+            end
           when SemAct           then obj[op.is_a?(RDF::URI) ? 'name' : 'code'] = op.to_s
           when TripleConstraint then obj['valueExpr'] = op.to_s
           when Shape            then obj['expression'] = op.to_s
           when EachOf, OneOf    then (obj['expressions'] ||= []) << op.to_s
           when And, Or          then (obj['shapeExprs'] ||= []) << op.to_s
           when Not              then obj['shapeExpr'] = op.to_s
+          when Language         then obj['languageTag'] = op.to_s
           else
             raise "How to serialize Value #{op.inspect} to json for #{self}"
           end

data/lib/shex/algebra/stem.rb

@@ -30,7 +30,7 @@ module ShEx::Algebra
     def json_type
       # FIXME: This is funky, due to oddities in normative shexj
       t = self.class.name.split('::').last
-      parent.is_a?(Value) ? "#{t}Range" : t
+      #parent.is_a?(Value) ? "#{t}Range" : t
     end
   end
 

data/lib/shex/algebra/value.rb

@@ -14,7 +14,7 @@ module ShEx::Algebra
       status "", depth: depth
       if case expr = operands.first
         when RDF::Value then value.eql?(expr)
-        when Stem, StemRange then expr.match?(value, depth: depth + 1)
+        when Language, Stem, StemRange then expr.match?(value, depth: depth + 1)
         else false
         end
         status "matched #{value}", depth: depth

data/lib/shex/format.rb

@@ -0,0 +1,112 @@
+require 'rdf/format'
+
+module ShEx
+  ##
+  # ShEx format specification. Note that this format does not define any readers or writers.
+  #
+  # @example Obtaining an LD Patch format class
+  #     RDF::Format.for(:shex)           #=> LD::Patch::Format
+  #     RDF::Format.for("etc/foaf.shex")
+  #     RDF::Format.for(file_name:      "etc/foaf.shex")
+  #     RDF::Format.for(file_extension: "shex")
+  #     RDF::Format.for(content_type:   "application/shex")
+  #
+  # @see http://www.w3.org/TR/ldpatch/
+  class Format < RDF::Format
+    content_type     'application/shex', extension: :shex
+    content_encoding 'utf-8'
+
+    ##
+    # Hash of CLI commands appropriate for this format
+    # @return [Hash{Symbol => Lambda(Array, Hash)}]
+    def self.cli_commands
+      {
+        shex: {
+          description: "Validate repository given shape",
+          help: "shex [--shape Resource] [--focus Resource] [--schema-input STRING] [--schema STRING] file",
+          parse: true,
+          lambda: -> (argv, options) do
+            options[:schema_input] ||= case options[:schema]
+            when IO, StringIO then options[:schema]
+            else RDF::Util::File.open_file(options[:schema]) {|f| f.read}
+            end
+            raise ArgumentError, "Shape matching requires a schema or reference to schema resource" unless options[:schema_input]
+            raise ArgumentError, "Shape matching requires a focus node" unless options[:focus]
+            format = options[:schema].to_s.end_with?('json') ? 'shexj' : 'shexc'
+            shex = ShEx.parse(options[:schema_input], format: format, **options)
+
+            if options[:to_sxp] || options[:to_json]
+              options[:messages][:shex] = {}
+              options[:messages][:shex].merge!({"S-Expression": [SXP::Generator.string(shex.to_sxp_bin)]}) if options[:to_sxp]
+              options[:messages][:shex].merge!({ShExJ: [shex.to_json(JSON::LD::JSON_STATE)]}) if options[:to_json]
+            else
+              focus = options.delete(:focus)
+              shape = options.delete(:shape)
+              map = shape ? {focus => shape} : {}
+              begin
+                res = shex.execute(RDF::CLI.repository, map, options.merge(focus: focus))
+                options[:messages][:shex] = {
+                  result: ["Satisfied shape."],
+                  detail: [SXP::Generator.string(res.to_sxp_bin)]
+                }
+              rescue ShEx::NotSatisfied => e
+                options[:logger].error e.to_s
+                options[:messages][:shex] = {
+                  result: ["Did not satisfied shape."],
+                  detail: [SXP::Generator.stringe.expression]
+                }
+                raise
+              end
+            end
+          end,
+          options: [
+            RDF::CLI::Option.new(
+              symbol: :focus,
+              datatype: String,
+              control: :text,
+              use: :required,
+              on: ["--focus Resource"],
+              description: "Focus node within repository"
+            ) {|v| RDF::URI(v)},
+            RDF::CLI::Option.new(
+              symbol: :shape,
+              datatype: String,
+              control: :text,
+              use: :optional,
+              on: ["--shape URI"],
+              description: "Shape identifier within ShEx schema"
+            ) {|v| RDF::URI(v)},
+            RDF::CLI::Option.new(
+              symbol: :schema_input,
+              datatype: String,
+              control: :none,
+              on: ["--schema-input STRING"],
+              description: "ShEx schema in URI encoded format"
+            ) {|v| URI.decode(v)},
+            RDF::CLI::Option.new(
+              symbol: :schema,
+              datatype: String,
+              control: :url2,
+              on: ["--schema URI"],
+              description: "ShEx schema location"
+            ) {|v| RDF::URI(v)},
+            RDF::CLI::Option.new(
+              symbol: :to_json,
+              datatype: String,
+              control: :checkbox,
+              on: ["--to-json"],
+              description: "Display parsed schema as ShExJ"
+            ),
+            RDF::CLI::Option.new(
+              symbol: :to_sxp,
+              datatype: String,
+              control: :checkbox,
+              on: ["--to-sxp"],
+              description: "Display parsed schema as an S-Expression"
+            ),
+          ]
+        }
+      }
+    end
+  end
+end

data/lib/shex/parser.rb

@@ -277,8 +277,10 @@ module ShEx
     def shape_and(input, data)
       input.merge!(data.dup.keep_if {|k, v| [:closed, :extraPropertySet, :codeDecl].include?(k)})
       expressions = Array(data[:shapeExpression]).inject([]) do |memo, expr|
-        memo.concat(expr.is_a?(Algebra::And) ? expr.operands : [expr])
+        #memo.concat(expr.is_a?(Algebra::And) ? expr.operands : [expr])
+        memo.concat([expr])
       end
+
       expression = if expressions.length > 1
         Algebra::And.new(*expressions, {})
       else
@@ -463,11 +465,11 @@ module ShEx
       expression = data[:tripleExpression]
       attrs = Array(data[:extraPropertySet])
       attrs << :closed if data[:closed]
-      attrs << expression
+      attrs << expression if expression
       attrs += Array(data[:annotation])
       attrs += Array(data[:codeDecl])
 
-      input[:shape] = Algebra::Shape.new(*attrs, {}) if expression
+      input[:shape] = Algebra::Shape.new(*attrs, {})
     end
     private :shape_definition
 
@@ -639,7 +641,7 @@ module ShEx
       elsif data[:dot]
         Algebra::LanguageStemRange.new(:wildcard, exclusions)
       else
-        data[:language]
+        Algebra::Language.new(data[:language])
       end
     end
 

data/lib/shex/shex_context.rb

@@ -4,39 +4,38 @@
 require 'json/ld'
 class JSON::LD::Context
   add_preloaded("http://www.w3.org/ns/shex.jsonld") do
-    new(term_definitions: {
+    new(processingMode: "json-ld-1.0", term_definitions: {
       "Annotation" => TermDefinition.new("Annotation", id: "http://www.w3.org/ns/shex#Annotation", simple: true),
       "EachOf" => TermDefinition.new("EachOf", id: "http://www.w3.org/ns/shex#EachOf", simple: true),
       "IriStem" => TermDefinition.new("IriStem", id: "http://www.w3.org/ns/shex#IriStem", simple: true),
+      "IriStemRange" => TermDefinition.new("IriStemRange", id: "http://www.w3.org/ns/shex#IriStemRange", simple: true),
       "LanguageStem" => TermDefinition.new("LanguageStem", id: "http://www.w3.org/ns/shex#LanguageStem", simple: true),
+      "LanguageStemRange" => TermDefinition.new("LanguageStemRange", id: "http://www.w3.org/ns/shex#LanguageStemRange", simple: true),
       "LiteralStem" => TermDefinition.new("LiteralStem", id: "http://www.w3.org/ns/shex#LiteralStem", simple: true),
+      "LiteralStemRange" => TermDefinition.new("LiteralStemRange", id: "http://www.w3.org/ns/shex#LiteralStemRange", simple: true),
       "NodeConstraint" => TermDefinition.new("NodeConstraint", id: "http://www.w3.org/ns/shex#NodeConstraint", simple: true),
-      "NodeKind" => TermDefinition.new("NodeKind", id: "http://www.w3.org/ns/shex#NodeKind", simple: true),
       "OneOf" => TermDefinition.new("OneOf", id: "http://www.w3.org/ns/shex#OneOf", simple: true),
       "Schema" => TermDefinition.new("Schema", id: "http://www.w3.org/ns/shex#Schema", simple: true),
       "SemAct" => TermDefinition.new("SemAct", id: "http://www.w3.org/ns/shex#SemAct", simple: true),
       "Shape" => TermDefinition.new("Shape", id: "http://www.w3.org/ns/shex#Shape", simple: true),
       "ShapeAnd" => TermDefinition.new("ShapeAnd", id: "http://www.w3.org/ns/shex#ShapeAnd", simple: true),
-      "ShapeExpression" => TermDefinition.new("ShapeExpression", id: "http://www.w3.org/ns/shex#ShapeExpression", simple: true),
       "ShapeExternal" => TermDefinition.new("ShapeExternal", id: "http://www.w3.org/ns/shex#ShapeExternal", simple: true),
       "ShapeNot" => TermDefinition.new("ShapeNot", id: "http://www.w3.org/ns/shex#ShapeNot", simple: true),
       "ShapeOr" => TermDefinition.new("ShapeOr", id: "http://www.w3.org/ns/shex#ShapeOr", simple: true),
       "Stem" => TermDefinition.new("Stem", id: "http://www.w3.org/ns/shex#Stem", simple: true),
       "StemRange" => TermDefinition.new("StemRange", id: "http://www.w3.org/ns/shex#StemRange", simple: true),
       "TripleConstraint" => TermDefinition.new("TripleConstraint", id: "http://www.w3.org/ns/shex#TripleConstraint", simple: true),
-      "TripleExpression" => TermDefinition.new("TripleExpression", id: "http://www.w3.org/ns/shex#TripleExpression", simple: true),
       "Wildcard" => TermDefinition.new("Wildcard", id: "http://www.w3.org/ns/shex#Wildcard", simple: true),
-      "annotation" => TermDefinition.new("annotation", id: "http://www.w3.org/ns/shex#annotation", type_mapping: "@id"),
-      "annotations" => TermDefinition.new("annotations", id: "http://www.w3.org/ns/shex#annotation", type_mapping: "@id"),
+      "annotations" => TermDefinition.new("annotations", id: "http://www.w3.org/ns/shex#annotation", type_mapping: "@id", container_mapping: "@list"),
       "bnode" => TermDefinition.new("bnode", id: "http://www.w3.org/ns/shex#bnode", simple: true),
       "closed" => TermDefinition.new("closed", id: "http://www.w3.org/ns/shex#closed", type_mapping: "http://www.w3.org/2001/XMLSchema#boolean"),
       "code" => TermDefinition.new("code", id: "http://www.w3.org/ns/shex#code"),
       "datatype" => TermDefinition.new("datatype", id: "http://www.w3.org/ns/shex#datatype", type_mapping: "@id"),
-      "exclusion" => TermDefinition.new("exclusion", id: "http://www.w3.org/ns/shex#exclusion", type_mapping: "@id"),
-      "exclusions" => TermDefinition.new("exclusions", id: "http://www.w3.org/ns/shex#exclusion", type_mapping: "@id"),
+      "exclusions" => TermDefinition.new("exclusions", id: "http://www.w3.org/ns/shex#exclusion", type_mapping: "@id", container_mapping: "@list"),
       "expression" => TermDefinition.new("expression", id: "http://www.w3.org/ns/shex#expression", type_mapping: "@id"),
       "expressions" => TermDefinition.new("expressions", id: "http://www.w3.org/ns/shex#expressions", type_mapping: "@id", container_mapping: "@list"),
       "extra" => TermDefinition.new("extra", id: "http://www.w3.org/ns/shex#extra", type_mapping: "@id"),
+      "flags" => TermDefinition.new("flags", id: "http://www.w3.org/ns/shex#flags"),
       "fractiondigits" => TermDefinition.new("fractiondigits", id: "http://www.w3.org/ns/shex#fractiondigits", type_mapping: "http://www.w3.org/2001/XMLSchema#integer"),
       "id" => TermDefinition.new("id", id: "@id", simple: true),
       "inverse" => TermDefinition.new("inverse", id: "http://www.w3.org/ns/shex#inverse", type_mapping: "http://www.w3.org/2001/XMLSchema#boolean"),
@@ -55,7 +54,6 @@ class JSON::LD::Context
       "name" => TermDefinition.new("name", id: "http://www.w3.org/ns/shex#name", type_mapping: "@id"),
       "nodeKind" => TermDefinition.new("nodeKind", id: "http://www.w3.org/ns/shex#nodeKind", type_mapping: "@vocab"),
       "nonliteral" => TermDefinition.new("nonliteral", id: "http://www.w3.org/ns/shex#nonliteral", simple: true),
-      "numericFacet" => TermDefinition.new("numericFacet", id: "http://www.w3.org/ns/shex#numericFacet"),
       "object" => TermDefinition.new("object", id: "http://www.w3.org/ns/shex#object", type_mapping: "@id"),
       "pattern" => TermDefinition.new("pattern", id: "http://www.w3.org/ns/shex#pattern"),
       "predicate" => TermDefinition.new("predicate", id: "http://www.w3.org/ns/shex#predicate", type_mapping: "@id"),
@@ -68,15 +66,12 @@ class JSON::LD::Context
       "shex" => TermDefinition.new("shex", id: "http://www.w3.org/ns/shex#", simple: true),
       "start" => TermDefinition.new("start", id: "http://www.w3.org/ns/shex#start", type_mapping: "@id"),
       "startActs" => TermDefinition.new("startActs", id: "http://www.w3.org/ns/shex#startActs", type_mapping: "@id", container_mapping: "@list"),
-      "stem" => TermDefinition.new("stem", id: "http://www.w3.org/ns/shex#stem", type_mapping: "http://www.w3.org/2001/XMLSchema#anyUri"),
-      "stringFacet" => TermDefinition.new("stringFacet", id: "http://www.w3.org/ns/shex#stringFacet"),
+      "stem" => TermDefinition.new("stem", id: "http://www.w3.org/ns/shex#stem", type_mapping: "http://www.w3.org/2001/XMLSchema#string"),
       "totaldigits" => TermDefinition.new("totaldigits", id: "http://www.w3.org/ns/shex#totaldigits", type_mapping: "http://www.w3.org/2001/XMLSchema#integer"),
       "type" => TermDefinition.new("type", id: "@type", simple: true),
-      "uri" => TermDefinition.new("uri", id: "@id", simple: true),
       "value" => TermDefinition.new("value", id: "@value", simple: true),
       "valueExpr" => TermDefinition.new("valueExpr", id: "http://www.w3.org/ns/shex#valueExpr", type_mapping: "@id"),
       "values" => TermDefinition.new("values", id: "http://www.w3.org/ns/shex#values", type_mapping: "@id", container_mapping: "@list"),
-      "xsFacet" => TermDefinition.new("xsFacet", id: "http://www.w3.org/ns/shex#xsFacet"),
       "xsd" => TermDefinition.new("xsd", id: "http://www.w3.org/2001/XMLSchema#", simple: true)
     })
   end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: shex
 version: !ruby/object:Gem::Version
-  version: 0.5.0
+  version: 0.5.1
 platform: ruby
 authors:
 - Gregg Kellogg
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-03-30 00:00:00.000000000 Z
+date: 2017-08-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rdf
@@ -44,14 +44,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.0'
+        version: '2.1'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.0'
+        version: '2.1'
 - !ruby/object:Gem::Dependency
   name: ebnf
   requirement: !ruby/object:Gem::Requirement
@@ -86,70 +86,70 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.0'
+        version: '2.2'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.0'
+        version: '2.2'
 - !ruby/object:Gem::Dependency
   name: sparql
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.0'
+        version: '2.2'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.0'
+        version: '2.2'
 - !ruby/object:Gem::Dependency
   name: rdf-spec
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.0'
+        version: '2.2'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.0'
+        version: '2.2'
 - !ruby/object:Gem::Dependency
   name: rdf-turtle
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.0'
+        version: '2.2'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.0'
+        version: '2.2'
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.5'
+        version: '3.6'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.5'
+        version: '3.6'
 - !ruby/object:Gem::Dependency
   name: rspec-its
   requirement: !ruby/object:Gem::Requirement
@@ -196,6 +196,7 @@ files:
 - lib/shex/algebra/annotation.rb
 - lib/shex/algebra/each_of.rb
 - lib/shex/algebra/external.rb
+- lib/shex/algebra/language.rb
 - lib/shex/algebra/node_constraint.rb
 - lib/shex/algebra/not.rb
 - lib/shex/algebra/one_of.rb
@@ -213,6 +214,7 @@ files:
 - lib/shex/algebra/value.rb
 - lib/shex/extensions/extension.rb
 - lib/shex/extensions/test.rb
+- lib/shex/format.rb
 - lib/shex/meta.rb
 - lib/shex/parser.rb
 - lib/shex/shex_context.rb
@@ -239,7 +241,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: rdf
-rubygems_version: 2.6.8
+rubygems_version: 2.6.12
 signing_key: 
 specification_version: 4
 summary: Implementation of Shape Expressions (ShEx) for RDF.rb