Finish 0.5.1

gkellogg · gkellogg · commit 4b8beafd802c · 2017-08-27T16:35:09.000-07:00
diff --git a/.travis.yml b/.travis.yml
@@ -11,14 +11,15 @@ before_install:
 env:
   - CI=true
 rvm:
-  - 2.2.6
-  - 2.3.3
-  - 2.4.0
-  - jruby
-  - rbx
+  - 2.2
+  - 2.3
+  - 2.4
+  - jruby-9
+  - rbx-3
 cache: bundler
 sudo: false
 matrix:
   allow_failures:
-    - rvm: jruby
-    - rvm: rbx
+    - rvm: jruby-9
+    - rvm: rbx-3
+dist: trusty
diff --git a/README.md b/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>
diff --git a/VERSION b/VERSION
@@ -1 +1 @@
-0.5.0
+0.5.1
diff --git a/etc/doap.json b/etc/doap.json
@@ -1,10 +1,11 @@
 {
   "@context": "http://www.w3.org/ns/shex.jsonld",
   "type": "Schema",
+  "start": "http://rubygems.org/gems/shex/DOAP",
   "shapes": [
     {
+      "id": "http://rubygems.org/gems/shex/DOAP",
       "type": "Shape",
-      "id": "TestShape",
       "extra": [
         "http://www.w3.org/1999/02/22-rdf-syntax-ns#type"
       ],
@@ -17,9 +18,7 @@
             "valueExpr": {
               "type": "NodeConstraint",
               "values": [
-                {
-                  "uri": "http://usefulinc.com/ns/doap#Project"
-                }
+                "http://usefulinc.com/ns/doap#Project"
               ]
             }
           },
@@ -98,15 +97,12 @@
             "valueExpr": {
               "type": "NodeConstraint",
               "values": [
-                {
-                  "uri": "http://shex.io/shex-semantics/"
-                }
+                "http://shex.io/shex-semantics/"
               ]
             }
           }
         ]
       }
     }
   ]
-}
-
+}
diff --git a/etc/doap.shex b/etc/doap.shex
@@ -1,6 +1,10 @@
+BASE <http://rubygems.org/gems/shex/>
 PREFIX doap:  <http://usefulinc.com/ns/doap#>
 PREFIX dc:    <http://purl.org/dc/terms/>
-<TestShape> EXTRA a {
+
+start=@<DOAP>
+
+<DOAP> EXTRA a {
   a [doap:Project];
 
   # May have either or both of doap:name/doap:description or dc:title/dc:description
diff --git a/etc/doap.ttl b/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/> .
diff --git a/examples/lang_stem.shex b/examples/lang_stem.shex
@@ -0,0 +1,5 @@
+PREFIX my: <http://my.example/>
+
+my:IssueShape {
+ my:status [@en~ @fr];
+}
diff --git a/lib/shex.rb b/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'
diff --git a/lib/shex/algebra.rb b/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
diff --git a/lib/shex/algebra/language.rb b/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
diff --git a/lib/shex/algebra/operator.rb b/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
@@ -295,17 +296,25 @@ def self.from_shexj(operator, options = {})
           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)
           operands << (v.map {|op| iri(op, options)}).unshift(k.to_sym)
         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 @@ def to_h
           # 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 @@ def to_h
           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
diff --git a/lib/shex/algebra/stem.rb b/lib/shex/algebra/stem.rb
@@ -30,7 +30,7 @@ def match?(value, depth: 0)
     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
 
diff --git a/lib/shex/algebra/value.rb b/lib/shex/algebra/value.rb
@@ -14,7 +14,7 @@ def match?(value, depth: 0)
       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
diff --git a/lib/shex/format.rb b/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
diff --git a/lib/shex/parser.rb b/lib/shex/parser.rb
diff --git a/lib/shex/shex_context.rb b/lib/shex/shex_context.rb
diff --git a/shex.gemspec b/shex.gemspec
diff --git a/spec/format_spec.rb b/spec/format_spec.rb
diff --git a/spec/parser_spec.rb b/spec/parser_spec.rb
diff --git a/spec/shexTest b/spec/shexTest
diff --git a/spec/shex_spec.rb b/spec/shex_spec.rb

Original file line number	Diff line number	Diff line change
`@@ -1,10 +1,11 @@`
`1`	`1`	`{`
`2`	`2`	`"@context": "http://www.w3.org/ns/shex.jsonld",`
`3`	`3`	`"type": "Schema",`
	`4`	`+ "start": "http://rubygems.org/gems/shex/DOAP",`
`4`	`5`	`"shapes": [`
`5`	`6`	`{`
	`7`	`+ "id": "http://rubygems.org/gems/shex/DOAP",`
`6`	`8`	`"type": "Shape",`
`7`		`- "id": "TestShape",`
`8`	`9`	`"extra": [`
`9`	`10`	`"http://www.w3.org/1999/02/22-rdf-syntax-ns#type"`
`10`	`11`	`],`
`@@ -17,9 +18,7 @@`
`17`	`18`	`"valueExpr": {`
`18`	`19`	`"type": "NodeConstraint",`
`19`	`20`	`"values": [`
`20`		`- {`
`21`		`- "uri": "http://usefulinc.com/ns/doap#Project"`
`22`		`- }`
	`21`	`+ "http://usefulinc.com/ns/doap#Project"`
`23`	`22`	`]`
`24`	`23`	`}`
`25`	`24`	`},`
`@@ -98,15 +97,12 @@`
`98`	`97`	`"valueExpr": {`
`99`	`98`	`"type": "NodeConstraint",`
`100`	`99`	`"values": [`
`101`		`- {`
`102`		`- "uri": "http://shex.io/shex-semantics/"`
`103`		`- }`
	`100`	`+ "http://shex.io/shex-semantics/"`
`104`	`101`	`]`
`105`	`102`	`}`
`106`	`103`	`}`
`107`	`104`	`]`
`108`	`105`	`}`
`109`	`106`	`}`
`110`	`107`	`]`
`111`		`-}`
`112`		`-`
	`108`	`+}`
Original file line number	Diff line number	Diff line change
`@@ -1,3 +1,4 @@`
	`1`	`+@base <http://rubygems.org/gems/shex> .`
`1`	`2`	`@prefix rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#> .`
`2`	`3`	`@prefix rdfs: <http://www.w3.org/2000/01/rdf-schema#> .`
`3`	`4`	`@prefix dc: <http://purl.org/dc/terms/> .`
Original file line number	Diff line number	Diff line change
`@@ -3,6 +3,7 @@`
`3`	`3`	`#`
`4`	`4`	`# @see http://shex.io/shex-semantics/#shexc`
`5`	`5`	`module ShEx`
	`6`	`+ require 'shex/format'`
`6`	`7`	`autoload :Algebra, 'shex/algebra'`
`7`	`8`	`autoload :Meta, 'shex/meta'`
`8`	`9`	`autoload :Parser, 'shex/parser'`