Add language operator for matching lanugage tags. JSON-LD predicate is languageTag.

Author: gkellogg

examples/lang_stem.shex

@@ -0,0 +1,5 @@
+PREFIX my: <http://my.example/>
+
+my:IssueShape {
+ my:status [@en~ @fr];
+}

lib/shex/algebra.rb

@@ -13,6 +13,7 @@ module Algebra
     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 @@ def self.from_shexj(operator, options = {})
       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

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.lanuage == expr.to_sym
+        else false
+        end
+        status "matched #{value}", depth: depth
+        true
+      else
+        status "not matched #{value}", depth: depth
+        false
+      end
+    end
+  end
+end

lib/shex/algebra/operator.rb

@@ -269,11 +269,12 @@ def self.from_shexj(operator, options = {})
         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
@@ -408,6 +409,7 @@ def to_h
           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

lib/shex/parser.rb

@@ -641,7 +641,7 @@ def shape_definition(input, data)
       elsif data[:dot]
         Algebra::LanguageStemRange.new(:wildcard, exclusions)
       else
-        data[:language]
+        Algebra::Language.new(data[:language])
       end
     end
 

spec/parser_spec.rb

@@ -1153,6 +1153,50 @@
              (min 0)
              (max 1)) ))))}
       },
+      "Language Stems" => {
+        shexc: %(
+          PREFIX my: <http://my.example/>
+
+          my:IssueShape {
+           my:status [@en~ @fr];
+          }
+        ),
+        sxp: %{(schema
+         (prefix (("my" <http://my.example/>)))
+         (shapes
+          (shape
+           (id <http://my.example/IssueShape>)
+           (tripleConstraint
+            (predicate <http://my.example/status>)
+            (nodeConstraint (value (languageStem "en")) (value (language "fr")))) )) )},
+        shexj: %({
+          "@context": "http://www.w3.org/ns/shex.jsonld",
+          "type": "Schema",
+          "shapes": [
+            {
+              "id": "http://my.example/IssueShape",
+              "type": "Shape",
+              "expression": {
+                "type": "TripleConstraint",
+                "predicate": "http://my.example/status",
+                "valueExpr": {
+                  "type": "NodeConstraint",
+                  "values": [
+                    {
+                      "type": "LanguageStem",
+                      "stem": "en"
+                    },
+                    {
+                      "type": "Language",
+                      "languageTag": "fr"
+                    }
+                  ]
+                }
+              }
+            }
+          ]
+        })
+      },
     }.each do |name, params|
       it "#{name} (shexc)" do
         expect(params[:shexc]).to generate(params[:sxp].gsub(/^        /m, ''), progress: true, logger: RDF::Spec.logger)