shex 0.2.0 → 0.3.0

data/lib/shex/extensions/test.rb

@@ -0,0 +1,26 @@
+##
+# Test extension.
+#
+# Default implementation of http://shex.io/extensions/Test/
+#
+# @see http://shex.io/extensions/Test/
+require 'shex'
+
+class ShEx::Test < ShEx::Extension("http://shex.io/extensions/Test/")
+  # (see ShEx::Extension#visit)
+  def visit(code: nil, matched: nil, depth: 0, **options)
+    str = if md = /^ *(fail|print) *\( *(?:(\"(?:[^\\"]|\\")*\")|([spo])) *\) *$/.match(code.to_s)
+      md[2] || case md[3]
+      when 's' then matched.subject
+      when 'p' then matched.predicate
+      when 'o' then matched.object
+      else          matched.to_sxp
+      end.to_s
+    else
+      matched ? matched.to_sxp : 'no statement'
+    end
+
+    $stdout.puts str
+    return !md || md[1] == 'print'
+  end
+end

data/lib/shex/parser.rb

@@ -79,7 +79,7 @@ module ShEx
     terminal(:PNAME_LN,             PNAME_LN, unescape: true) do |prod, token, input|
       prefix, suffix = token.value.split(":", 2)
       input[:iri] = ns(prefix, suffix)
-      error(nil, "Compact IRI missing prefix definition: #{token.value}", production: :PNAME_LN) unless input[:iri].absolute?
+      error(nil, "Compact IRI missing prefix definition: #{token.value}", production: :PNAME_LN) unless prefix(prefix)
     end
     terminal(:PNAME_NS,             PNAME_NS) do |prod, token, input|
       prefix = token.value[0..-2]
@@ -156,19 +156,11 @@ module ShEx
     production(:shexDoc) do |input, data, callback|
       data[:start] = data[:start] if data[:start]
 
-      expressions = []
-      expressions << [:base, data[:baseDecl]] if data[:baseDecl]
-      expressions << [:prefix, data[:prefixDecl]] if data[:prefixDecl]
-      expressions += Array(data[:codeDecl])
+      expressions = Array(data[:codeDecl])
       expressions << Algebra::Start.new(data[:start]) if data[:start]
-      expressions << [:shapes, data[:shapes]] if data[:shapes]
+      expressions << data[:shapes].unshift(:shapes) if data[:shapes]
 
       input[:schema] = Algebra::Schema.new(*expressions, options)
-
-      # Set schema accessor for all included expressions
-      input[:schema].each_descendant do |op|
-        op.schema = input[:schema] if op.respond_to?(:schema=)
-      end
       self
     end
 
@@ -176,14 +168,13 @@ module ShEx
 
     # [3]     baseDecl              ::= "BASE" IRIREF
     production(:baseDecl) do |input, data, callback|
-      input[:baseDecl] = self.base_uri = iri(data[:iri])
+      self.base_uri = iri(data[:iri])
     end
 
     # [4]     prefixDecl            ::= "PREFIX" PNAME_NS IRIREF
     production(:prefixDecl) do |input, data, callback|
       pfx = data[:prefix]
       self.prefix(pfx, data[:iri])
-      (input[:prefixDecl] ||= []) << [pfx.to_s, data[:iri]]
     end
 
     # [5]     notStartAction        ::= start | shapeExprDecl
@@ -204,8 +195,9 @@ module ShEx
       else
         data[:external] ? Algebra::External.new() : Algebra::Shape.new()
       end
+      expression.label = label
 
-      (input[:shapes] ||= {})[label] = expression
+      (input[:shapes] ||= []) << expression
     end
 
     # [10]    shapeExpression       ::= shapeOr
@@ -337,7 +329,7 @@ module ShEx
       end
 
       attrs = []
-      attrs += [:datatype, data[:datatype]] if data [:datatype]
+      attrs << [:datatype, data[:datatype]] if data [:datatype]
       attrs += [data[:shapeAtomLiteral], data[:nonLiteralKind]]
       attrs += Array(data[:valueSetValue])
       attrs += Array(data[:numericFacet])
@@ -394,10 +386,11 @@ module ShEx
       expression = data[:tripleExpression]
       attrs = Array(data[:extraPropertySet])
       attrs << :closed if data[:closed]
+      attrs << expression
       attrs += Array(data[:annotation])
       attrs += Array(data[:codeDecl])
 
-      input[:shape] = Algebra::Shape.new(expression, *attrs) if expression
+      input[:shape] = Algebra::Shape.new(*attrs) if expression
     end
     private :shape_definition
 
@@ -430,7 +423,7 @@ module ShEx
     # [40]    unaryTripleExpr            ::= productionLabel? (tripleConstraint | bracketedTripleExpr) | include
     production(:unaryTripleExpr) do |input, data, callback|
       expression = data[:tripleExpression]
-      expression.operands << data[:productionLabel] if expression && data[:productionLabel]
+      expression.label = data[:productionLabel] if expression && data[:productionLabel]
 
       (input[:tripleExpression] ||= []) << expression if expression
     end
@@ -568,10 +561,6 @@ module ShEx
     #   the base URI to use when resolving relative URIs (for acessing intermediate parser productions)
     # @option options [#to_s]    :anon_base     ("b0")
     #   Basis for generating anonymous Nodes
-    # @option options [Boolean] :resolve_iris (false)
-    #   Resolve prefix and relative IRIs, otherwise, when serializing the parsed SXP
-    #   as S-Expressions, use the original prefixed and relative URIs along with `base` and `prefix`
-    #   definitions.
     # @option options [Boolean]  :validate     (false)
     #   whether to validate the parsed statements and values
     # @option options [Boolean] :progress
@@ -735,7 +724,7 @@ module ShEx
     #
     # @return [HRDF::URI]
     def base_uri
-      RDF::URI(@options[:base_uri]) if @options[:base_uri]
+      @options[:base_uri]
     end
 
     ##
@@ -762,9 +751,7 @@ module ShEx
 
     # Generate a BNode identifier
     def bnode(id)
-      @bnode_cache ||= {}
-      raise Error, "Illegal attempt to reuse a BNode" if @bnode_cache[id] && @bnode_cache[id].frozen?
-      @bnode_cache[id] ||= RDF::Node.new(id)
+      RDF::Node.intern(id)
     end
 
     # Create URIs

data/lib/shex/shex_context.rb

@@ -0,0 +1,85 @@
+# -*- encoding: utf-8 -*-
+# frozen_string_literal: true
+# This file generated automatically from https://shexspec.github.io/context.jsonld
+require 'json/ld'
+class JSON::LD::Context
+  add_preloaded("https://shexspec.github.io/context.jsonld") do
+    new(term_definitions: {
+      "Annotation" => TermDefinition.new("Annotation", id: "http://shex.io/ns/shex#Annotation", simple: true),
+      "EachOf" => TermDefinition.new("EachOf", id: "http://shex.io/ns/shex#EachOf", simple: true),
+      "Inclusion" => TermDefinition.new("Inclusion", id: "http://shex.io/ns/shex#Inclusion", simple: true),
+      "NodeConstraint" => TermDefinition.new("NodeConstraint", id: "http://shex.io/ns/shex#NodeConstraint", simple: true),
+      "NodeKind" => TermDefinition.new("NodeKind", id: "http://shex.io/ns/shex#NodeKind", simple: true),
+      "OneOf" => TermDefinition.new("OneOf", id: "http://shex.io/ns/shex#OneOf", simple: true),
+      "Schema" => TermDefinition.new("Schema", id: "http://shex.io/ns/shex#Schema", simple: true),
+      "SemAct" => TermDefinition.new("SemAct", id: "http://shex.io/ns/shex#SemAct", simple: true),
+      "Shape" => TermDefinition.new("Shape", id: "http://shex.io/ns/shex#Shape", simple: true),
+      "ShapeAnd" => TermDefinition.new("ShapeAnd", id: "http://shex.io/ns/shex#ShapeAnd", simple: true),
+      "ShapeExpression" => TermDefinition.new("ShapeExpression", id: "http://shex.io/ns/shex#ShapeExpression", simple: true),
+      "ShapeExternal" => TermDefinition.new("ShapeExternal", id: "http://shex.io/ns/shex#ShapeExternal", simple: true),
+      "ShapeNot" => TermDefinition.new("ShapeNot", id: "http://shex.io/ns/shex#ShapeNot", simple: true),
+      "ShapeOr" => TermDefinition.new("ShapeOr", id: "http://shex.io/ns/shex#ShapeOr", simple: true),
+      "ShapeRef" => TermDefinition.new("ShapeRef", id: "http://shex.io/ns/shex#ShapeRef", simple: true),
+      "Stem" => TermDefinition.new("Stem", id: "http://shex.io/ns/shex#Stem", simple: true),
+      "StemRange" => TermDefinition.new("StemRange", id: "http://shex.io/ns/shex#StemRange", simple: true),
+      "TripleConstraint" => TermDefinition.new("TripleConstraint", id: "http://shex.io/ns/shex#TripleConstraint", simple: true),
+      "TripleExpression" => TermDefinition.new("TripleExpression", id: "http://shex.io/ns/shex#TripleExpression", simple: true),
+      "Wildcard" => TermDefinition.new("Wildcard", id: "http://shex.io/ns/shex#Wildcard", simple: true),
+      "annotation" => TermDefinition.new("annotation", id: "http://shex.io/ns/shex#annotation", type_mapping: "@id"),
+      "annotations" => TermDefinition.new("annotations", id: "http://shex.io/ns/shex#annotation", type_mapping: "@id"),
+      "bnode" => TermDefinition.new("bnode", id: "http://shex.io/ns/shex#bnode", simple: true),
+      "closed" => TermDefinition.new("closed", id: "http://shex.io/ns/shex#closed", type_mapping: "http://www.w3.org/2001/XMLSchema#boolean"),
+      "code" => TermDefinition.new("code", id: "http://shex.io/ns/shex#code"),
+      "datatype" => TermDefinition.new("datatype", id: "http://shex.io/ns/shex#datatype", type_mapping: "@id"),
+      "exclusion" => TermDefinition.new("exclusion", id: "http://shex.io/ns/shex#exclusion", type_mapping: "@id"),
+      "exclusions" => TermDefinition.new("exclusions", id: "http://shex.io/ns/shex#exclusion", type_mapping: "@id"),
+      "expression" => TermDefinition.new("expression", id: "http://shex.io/ns/shex#expression", type_mapping: "@id"),
+      "expressions" => TermDefinition.new("expressions", id: "http://shex.io/ns/shex#expressions", type_mapping: "@id", container_mapping: "@list"),
+      "extra" => TermDefinition.new("extra", id: "http://shex.io/ns/shex#extra", type_mapping: "@id"),
+      "fractiondigits" => TermDefinition.new("fractiondigits", id: "http://shex.io/ns/shex#fractiondigits", type_mapping: "http://www.w3.org/2001/XMLSchema#integer"),
+      "id" => TermDefinition.new("id", id: "@id", simple: true),
+      "include" => TermDefinition.new("include", id: "http://shex.io/ns/shex#include", type_mapping: "@id"),
+      "inverse" => TermDefinition.new("inverse", id: "http://shex.io/ns/shex#inverse", type_mapping: "http://www.w3.org/2001/XMLSchema#boolean"),
+      "iri" => TermDefinition.new("iri", id: "http://shex.io/ns/shex#iri", simple: true),
+      "label" => TermDefinition.new("label", id: "@id", simple: true),
+      "language" => TermDefinition.new("language", id: "@language", simple: true),
+      "length" => TermDefinition.new("length", id: "http://shex.io/ns/shex#length", type_mapping: "http://www.w3.org/2001/XMLSchema#integer"),
+      "literal" => TermDefinition.new("literal", id: "http://shex.io/ns/shex#literal", simple: true),
+      "max" => TermDefinition.new("max", id: "http://shex.io/ns/shex#max"),
+      "maxexclusive" => TermDefinition.new("maxexclusive", id: "http://shex.io/ns/shex#maxexclusive", type_mapping: "http://www.w3.org/2001/XMLSchema#integer"),
+      "maxinclusive" => TermDefinition.new("maxinclusive", id: "http://shex.io/ns/shex#maxinclusive", type_mapping: "http://www.w3.org/2001/XMLSchema#integer"),
+      "maxlength" => TermDefinition.new("maxlength", id: "http://shex.io/ns/shex#maxlength", type_mapping: "http://www.w3.org/2001/XMLSchema#integer"),
+      "min" => TermDefinition.new("min", id: "http://shex.io/ns/shex#min", type_mapping: "http://www.w3.org/2001/XMLSchema#integer"),
+      "minexclusive" => TermDefinition.new("minexclusive", id: "http://shex.io/ns/shex#minexclusive", type_mapping: "http://www.w3.org/2001/XMLSchema#integer"),
+      "mininclusive" => TermDefinition.new("mininclusive", id: "http://shex.io/ns/shex#mininclusive", type_mapping: "http://www.w3.org/2001/XMLSchema#integer"),
+      "minlength" => TermDefinition.new("minlength", id: "http://shex.io/ns/shex#minlength", type_mapping: "http://www.w3.org/2001/XMLSchema#integer"),
+      "name" => TermDefinition.new("name", id: "http://shex.io/ns/shex#name", type_mapping: "@id"),
+      "nodeKind" => TermDefinition.new("nodeKind", id: "http://shex.io/ns/shex#nodeKind", type_mapping: "@vocab"),
+      "nonliteral" => TermDefinition.new("nonliteral", id: "http://shex.io/ns/shex#nonliteral", simple: true),
+      "numericFacet" => TermDefinition.new("numericFacet", id: "http://shex.io/ns/shex#numericFacet"),
+      "object" => TermDefinition.new("object", id: "http://shex.io/ns/shex#object", type_mapping: "@id"),
+      "pattern" => TermDefinition.new("pattern", id: "http://shex.io/ns/shex#pattern"),
+      "predicate" => TermDefinition.new("predicate", id: "http://shex.io/ns/shex#predicate", type_mapping: "@id"),
+      "rdf" => TermDefinition.new("rdf", id: "http://www.w3.org/1999/02/22-rdf-syntax-ns#", simple: true),
+      "rdfs" => TermDefinition.new("rdfs", id: "http://www.w3.org/2000/01/rdf-schema#", simple: true),
+      "reference" => TermDefinition.new("reference", id: "http://shex.io/ns/shex#reference", type_mapping: "@id"),
+      "semActs" => TermDefinition.new("semActs", id: "http://shex.io/ns/shex#semActs", type_mapping: "@id", container_mapping: "@list"),
+      "shapeExpr" => TermDefinition.new("shapeExpr", id: "http://shex.io/ns/shex#shapeExpr", type_mapping: "@id"),
+      "shapeExprs" => TermDefinition.new("shapeExprs", id: "http://shex.io/ns/shex#shapeExprs", type_mapping: "@id", container_mapping: "@list"),
+      "shapes" => TermDefinition.new("shapes", id: "http://shex.io/ns/shex#shapes", type_mapping: "@id"),
+      "shex" => TermDefinition.new("shex", id: "http://shex.io/ns/shex#", simple: true),
+      "start" => TermDefinition.new("start", id: "http://shex.io/ns/shex#start", type_mapping: "@id"),
+      "startActs" => TermDefinition.new("startActs", id: "http://shex.io/ns/shex#startActs", type_mapping: "@id", container_mapping: "@list"),
+      "stem" => TermDefinition.new("stem", id: "http://shex.io/ns/shex#stem", type_mapping: "http://www.w3.org/2001/XMLSchema#anyUri"),
+      "stringFacet" => TermDefinition.new("stringFacet", id: "http://shex.io/ns/shex#stringFacet"),
+      "totaldigits" => TermDefinition.new("totaldigits", id: "http://shex.io/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://shex.io/ns/shex#valueExpr", type_mapping: "@id"),
+      "values" => TermDefinition.new("values", id: "http://shex.io/ns/shex#values", type_mapping: "@id", container_mapping: "@list"),
+      "xsFacet" => TermDefinition.new("xsFacet", id: "http://shex.io/ns/shex#xsFacet"),
+      "xsd" => TermDefinition.new("xsd", id: "http://www.w3.org/2001/XMLSchema#", simple: true)
+    })
+  end
+end

data/lib/shex/version.rb

@@ -0,0 +1,19 @@
+module ShEx
+  module VERSION
+    FILE = File.expand_path('../../../VERSION', __FILE__)
+    MAJOR, MINOR, TINY, EXTRA = File.read(FILE).chomp.split('.')
+    STRING = [MAJOR, MINOR, TINY, EXTRA].compact.join('.').freeze
+
+    ##
+    # @return [String]
+    def self.to_s() STRING end
+
+    ##
+    # @return [String]
+    def self.to_str() STRING end
+
+    ##
+    # @return [Array(String, String, String, String)]
+    def self.to_a() [MAJOR, MINOR, TINY, EXTRA].compact end
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: shex
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.3.0
 platform: ruby
 authors:
 - Gregg Kellogg
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-12-16 00:00:00.000000000 Z
+date: 2017-01-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rdf
@@ -16,10 +16,21 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.1'
-    - - ">="
+        version: '2.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.2'
+- !ruby/object:Gem::Dependency
+  name: json-ld
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: 2.1.1
+        version: '2.1'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -27,9 +38,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '2.1'
-    - - ">="
+- !ruby/object:Gem::Dependency
+  name: json-ld-preloaded
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: 2.1.1
+        version: '0.0'
 - !ruby/object:Gem::Dependency
   name: ebnf
   requirement: !ruby/object:Gem::Requirement
@@ -172,7 +194,6 @@ files:
 - lib/shex/algebra.rb
 - lib/shex/algebra/and.rb
 - lib/shex/algebra/annotation.rb
-- lib/shex/algebra/base.rb
 - lib/shex/algebra/each_of.rb
 - lib/shex/algebra/external.rb
 - lib/shex/algebra/inclusion.rb
@@ -181,7 +202,6 @@ files:
 - lib/shex/algebra/one_of.rb
 - lib/shex/algebra/operator.rb
 - lib/shex/algebra/or.rb
-- lib/shex/algebra/prefix.rb
 - lib/shex/algebra/satisfiable.rb
 - lib/shex/algebra/schema.rb
 - lib/shex/algebra/semact.rb
@@ -192,15 +212,19 @@ files:
 - lib/shex/algebra/stem_range.rb
 - lib/shex/algebra/triple_constraint.rb
 - lib/shex/algebra/triple_expression.rb
-- lib/shex/algebra/unary_shape.rb
 - lib/shex/algebra/value.rb
+- lib/shex/extensions/extension.rb
+- lib/shex/extensions/test.rb
 - lib/shex/meta.rb
 - lib/shex/parser.rb
+- lib/shex/shex_context.rb
 - lib/shex/terminals.rb
+- lib/shex/version.rb
 homepage: http://ruby-rdf.github.com/shex
 licenses:
 - Unlicense
-metadata: {}
+metadata:
+  yard.run: yri
 post_install_message: 
 rdoc_options: []
 require_paths:

data/lib/shex/algebra/base.rb

@@ -1,6 +0,0 @@
-module ShEx::Algebra
-  ##
-  class Base < Operator::Binary
-    NAME = :base
-  end
-end

data/lib/shex/algebra/prefix.rb

@@ -1,6 +0,0 @@
-module ShEx::Algebra
-  ##
-  class Prefix < Operator::Binary
-    NAME = :prefix
-  end
-end

data/lib/shex/algebra/unary_shape.rb

@@ -1,6 +0,0 @@
-module ShEx::Algebra
-  ##
-  class UnaryShape < Operator
-    NAME = :unaryShape
-  end
-end