shex 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: a8b0ba57a643b21c61dc3ddb8a7b49323c39bc1f
+  data.tar.gz: 82bdcc8715f967354d09e1990f801806778c39b6
+SHA512:
+  metadata.gz: 6828f94a4e12c8d344ded59c69ec16e3c1f01990ea53110a1f21f1382eca27a2a1bdb53fa32e61e8c7095f2bdf0d74feb5c60f09e26b93b0626daad690171535
+  data.tar.gz: 6ad0d4ae5c64c2d8076b270f0861749410a983ba2525db7fcabef7b405394af1432fcb63f08f625c75114e8bc8bd11da335e563560aed84290327a0cfb938e37

data/AUTHORS

@@ -0,0 +1 @@
+* Gregg Kellogg <gregg@kellogg-assoc.com>

data/LICENSE

@@ -0,0 +1,24 @@
+This is free and unencumbered software released into the public domain.
+
+Anyone is free to copy, modify, publish, use, compile, sell, or
+distribute this software, either in source code form or as a compiled
+binary, for any purpose, commercial or non-commercial, and by any
+means.
+
+In jurisdictions that recognize copyright laws, the author or authors
+of this software dedicate any and all copyright interest in the
+software to the public domain. We make this dedication for the benefit
+of the public at large and to the detriment of our heirs and
+successors. We intend this dedication to be an overt act of
+relinquishment in perpetuity of all present and future rights to this
+software under copyright law.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR
+OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+OTHER DEALINGS IN THE SOFTWARE.
+
+For more information, please refer to <http://unlicense.org>

data/README.md

@@ -0,0 +1,124 @@
+# ShEx: Shape Expression language for Ruby
+
+This is a pure-Ruby library for working with the [Shape Expressions Language][ShExSpec] to validate the shape of [RDF][] graphs.
+
+<http://ruby-rdf.github.com/shex>
+
+[![Gem Version](https://badge.fury.io/rb/shex.png)](http://badge.fury.io/rb/shex)
+[![Build Status](https://travis-ci.org/ruby-rdf/shex.png?branch=master)](http://travis-ci.org/ruby-rdf/shex)
+[![Coverage Status](https://coveralls.io/repos/ruby-rdf/shex/badge.svg)](https://coveralls.io/r/ruby-rdf/shex)
+[![Join the chat at https://gitter.im/ruby-rdf/rdf](https://badges.gitter.im/Join%20Chat.svg)](https://gitter.im/ruby-rdf/rdf?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
+
+## Features
+
+* 100% pure Ruby with minimal dependencies and no bloat.
+* Fully compatible with [ShEx][ShExSpec] specifications.
+* 100% free and unencumbered [public domain](http://unlicense.org/) software.
+
+## Description
+
+The ShEx gem implements a [ShEx][ShExSpec] Shape Expression engine.
+
+* `ShEx::Parser` parses ShExC formatted documents generating executable operators which can be serialized as [S-Expressions](http://en.wikipedia.org/wiki/S-expression).
+* `ShEx::Algebra` executes operators against Any `RDF::Graph`, including compliant [RDF.rb][].
+
+## Example
+
+    require 'rubygems'
+    require 'rdf/turtle'
+    require 'shex'
+
+    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    [<https://shexspec.github.io/spec/>]
+      }
+    )
+    graph = RDF::Graph.load("etc/doap.ttl")
+    schema = ShEx.parse(shexc)
+    map = {
+      "http://rubygems.org/gems/shex" => "TestShape"
+    }
+    schema.satisfies?("http://rubygems.org/gems/shex", graph, map)
+    # => true
+
+## Documentation
+
+<http://rubydoc.info/github/ruby-rdf/shex>
+
+
+## Implementation Notes
+The ShExC parser uses the [EBNF][] gem to generate first, follow and branch tables, and uses the `Parser` and `Lexer` modules to implement the ShExC parser.
+
+The parser takes branch and follow tables generated from the [ShEx Grammar](file.shex.html) described in the [specification][ShExSpec]. Branch and Follow tables are specified in the generated {ShEx::Meta}.
+
+## Dependencies
+
+* [Ruby](http://ruby-lang.org/) (>= 2.0)
+* [RDF.rb](http://rubygems.org/gems/rdf) (>= 2.1)
+
+## Installation
+
+The recommended installation method is via [RubyGems](http://rubygems.org/).
+To install the latest official release of RDF.rb, do:
+
+    % [sudo] gem install shex
+
+## Download
+
+To get a local working copy of the development repository, do:
+
+    % git clone git://github.com/ruby-rdf/shex.git
+
+Alternatively, download the latest development version as a tarball as
+follows:
+
+    % wget http://github.com/ruby-rdf/shex/tarball/master
+
+## Resources
+
+* <http://rubydoc.info/github/ruby-rdf/shex>
+* <http://github.com/ruby-rdf/shex>
+* <http://rubygems.org/gems/shex>
+
+## Mailing List
+
+* <http://lists.w3.org/Archives/Public/public-rdf-ruby/>
+
+## Author
+
+* [Gregg Kellogg](http://github.com/gkellogg) - <http://greggkellogg.net/>
+
+## Contributing
+
+This repository uses [Git Flow](https://github.com/nvie/gitflow) to mange development and release activity. All submissions _must_ be on a feature branch based on the _develop_ branch to ease staging and integration.
+
+* Do your best to adhere to the existing coding conventions and idioms.
+* Don't use hard tabs, and don't leave trailing whitespace on any line.
+  Before committing, run `git diff --check` to make sure of this.
+* Do document every method you add using [YARD][] annotations. Read the
+  [tutorial][YARD-GS] or just look at the existing code for examples.
+* Don't touch the `.gemspec` or `VERSION` files. If you need to change them,
+  do so on your private branch only.
+* Do feel free to add yourself to the `CREDITS` file and the
+  corresponding list in the the `README`. Alphabetical order applies.
+* Don't touch the `AUTHORS` file. If your contributions are significant
+  enough, be assured we will eventually add you in there.
+* Do note that in order for us to merge any non-trivial changes (as a rule
+  of thumb, additions larger than about 15 lines of code), we need an
+  explicit [public domain dedication][PDD] on record from you.
+
+## License
+
+This is free and unencumbered public domain software. For more information,
+see <http://unlicense.org/> or the accompanying {file:LICENSE} file.
+
+[ShExSpec]:     https://shexspec.github.io/spec/
+[RDF]:          http://www.w3.org/RDF/
+[RDF.rb]:       http://rubydoc.info/github/ruby-rdf/rdf
+[EBNF]:         http://rubygems.org/gems/ebnf

data/VERSION

@@ -0,0 +1 @@
+0.1.0

data/etc/doap.ttl

@@ -0,0 +1,33 @@
+@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/> .
+@prefix earl: <http://www.w3.org/ns/earl#> .
+@prefix foaf: <http://xmlns.com/foaf/0.1/> .
+@prefix doap: <http://usefulinc.com/ns/doap#> .
+@prefix ex:   <http://example.org/> .
+@prefix xsd:  <http://www.w3.org/2001/XMLSchema#> .
+
+<http://rubygems.org/gems/shex> a doap:Project, earl:TestSubject, earl:Software ;
+  doap:name          "ShEx" ;
+  doap:homepage      <http://ruby-rdf.github.com/shex> ;
+  doap:license       <http://creativecommons.org/licenses/publicdomain/> ;
+  doap:shortdesc     "ShEx is a Shape Expression engine for Ruby."@en ;
+  doap:description   "ShEx is an Shape Expression engine for the RDF.rb library suite."@en ;
+  doap:created       "2016-12-09"^^xsd:date ;
+  doap:programming-language "Ruby" ;
+  doap:implements    <https://shexspec.github.io/spec/> ;
+  doap:category      <http://dbpedia.org/resource/Resource_Description_Framework>,
+                     <http://dbpedia.org/resource/Ruby_(programming_language)> ;
+  doap:download-page <http://rubygems.org/gems/shex> ;
+  doap:mailing-list  <http://lists.w3.org/Archives/Public/public-rdf-ruby/> ;
+  doap:bug-database  <http://github.com/ruby-rdf/shex/issues> ;
+  doap:blog          <http://greggkellogg.net/> ;
+  doap:developer     <http://greggkellogg.net/foaf#me> ;
+  doap:maintainer    <http://greggkellogg.net/foaf#me> ;
+  doap:documenter    <http://greggkellogg.net/foaf#me> ;
+  foaf:maker         <http://greggkellogg.net/foaf#me> ;
+  dc:title           "ShEx" ;
+  dc:description     "ShEx is an Shape Expression engine for the RDF.rb library suite."@en ;
+  dc:date            "2016-12-09"^^xsd:date ;
+  dc:creator         <http://greggkellogg.net/foaf#me> ;
+  dc:isPartOf        <http://rubygems.org/gems/rdf> .

data/lib/shex.rb

@@ -0,0 +1,133 @@
+require 'sparql/extensions'
+
+##
+# A ShEx runtime for RDF.rb.
+#
+# @see https://shexspec.github.io/spec/#shexc
+module ShEx
+  autoload :Algebra,    'shex/algebra'
+  autoload :Meta,       'shex/meta'
+  autoload :Parser,     'shex/parser'
+  autoload :Terminals,  'shex/terminals'
+  autoload :VERSION,    'shex/version'
+
+  ##
+  # Parse the given ShEx `query` string.
+  #
+  # @example parsing a ShExC schema
+  #   schema = ShEx.parse(%(
+  #     PREFIX ex: <http://schema.example/> ex:IssueShape {ex:state IRI}
+  #   ).parse
+  #
+  # @param  [IO, StringIO, String, #to_s]  expression (ShExC or ShExJ)
+  # @param  ['shexc', 'shexj', 'sse']  format ('shexc')
+  # @param  [Hash{Symbol => Object}] options
+  # @return [ShEx::Algebra::Schema] The executable parsed expression.
+  # @raise [ShEx::ParseError] when a syntax error is detected
+  # @raise [ShEx::StructureError, ArgumentError] on structural problems with schema
+  def self.parse(expression, format: 'shexc', **options)
+    case format
+    when 'shexc' then Parser.new(expression, options).parse
+    when 'shexj'
+    when 'sse'
+    else raise "Unknown expression format: #{format.inspect}"
+    end
+  end
+
+  ##
+  # Parses input from the given file name or URL.
+  #
+  # @example parsing a ShExC schema
+  #   schema = ShEx.parse('foo.shex').parse
+  #
+  # @param  [String, #to_s] filename
+  # @param  ['shexc', 'shexj', 'sse']  format ('shexc')
+  # @param  [Hash{Symbol => Object}] options
+  #   any additional options (see `RDF::Reader#initialize` and `RDF::Format.for`)
+  # @yield  [ShEx::Algebra::Schema]
+  # @yieldparam  [RDF::Reader] reader
+  # @yieldreturn [void] ignored
+  # @return [ShEx::Algebra::Schema] The executable parsed expression.
+  # @raise [ShEx::ParseError] when a syntax error is detected
+  # @raise [ShEx::StructureError, ArgumentError] on structural problems with schema
+  def self.open(filename, format: 'shexc', **options, &block)
+    RDF::Util::File.open_file(filename, options) do |file|
+      self.parse(file, options.merge(format: format))
+    end
+  end
+
+  ##
+  # Parse and validate the given ShEx `expression` string against `queriable`.
+  #
+  # @example executing a ShExC schema
+  #   graph = RDF::Graph.load("etc/doap.ttl")
+  #   ShEx.execute('etc/doap.shex', graph, "http://rubygems.org/gems/shex", "")
+  #
+  # @param [IO, StringIO, String, #to_s]  expression (ShExC or ShExJ)
+  # @param [RDF::Resource] focus
+  # @param [RDF::Resource] shape
+  # @param ['shexc', 'shexj', 'sse']  format ('shexc')
+  # @param [Hash{Symbol => Object}] options
+  # @return [Boolean] `true` if satisfied, `false` if it does not apply
+  # @raise [ShEx::NotSatisfied] if not satisfied
+  # @raise [ShEx::ParseError] when a syntax error is detected
+  # @raise [ShEx::StructureError, ArgumentError] on structural problems with schema
+  def self.execute(expression, queryable, focus, shape, format: 'shexc', **options)
+    shex = self.parse(expression, options.merge(format: format))
+    queryable = queryable || RDF::Graph.new
+
+    shex.satisfies?(focus, queryable, {focus => shape}, options)
+  end
+
+  class Error < StandardError
+    # The status code associated with this error
+    attr_reader :code
+
+    ##
+    # Initializes a new patch error instance.
+    #
+    # @param  [String, #to_s]          message
+    # @param  [Hash{Symbol => Object}] options
+    # @option options [Integer]        :code (422)
+    def initialize(message, options = {})
+      @code = options.fetch(:status_code, 422)
+      super(message.to_s)
+    end
+  end
+
+
+  # Shape expectation not satisfied
+  class StructureError < Error; end
+
+  # Shape expectation not satisfied
+  class NotSatisfied < Error; end
+
+  # Indicates bad syntax found in LD Patch document
+  class ParseError < Error
+    ##
+    # The invalid token which triggered the error.
+    #
+    # @return [String]
+    attr_reader :token
+
+    ##
+    # The line number where the error occurred.
+    #
+    # @return [Integer]
+    attr_reader :lineno
+
+    ##
+    # Initializes a new parser error instance.
+    #
+    # @param  [String, #to_s]          message
+    # @param  [Hash{Symbol => Object}] options
+    # @option options [String]         :token  (nil)
+    # @option options [Integer]        :lineno (nil)
+    # @option options [Integer]        :code (400)
+    def initialize(message, options = {})
+      @token      = options[:token]
+      @lineno     = options[:lineno] || (@token.lineno if @token.respond_to?(:lineno))
+      super(message.to_s, code: options.fetch(:code, 400))
+    end
+  end
+end

data/lib/shex/algebra.rb

@@ -0,0 +1,39 @@
+$:.unshift(File.expand_path("../..", __FILE__))
+require 'sparql/algebra'
+require 'sxp'
+
+module ShEx
+  # Based on the SPARQL Algebra, operators for executing a patch
+  #
+  # @author [Gregg Kellogg](http://greggkellogg.net/)
+  module Algebra
+    autoload :And, 'shex/algebra/and'
+    autoload :Annotation, 'shex/algebra/annotation'
+    autoload :Base, 'shex/algebra/base'
+    autoload :EachOf, 'shex/algebra/each_of'
+    autoload :Inclusion, 'shex/algebra/inclusion'
+    autoload :Not, 'shex/algebra/not'
+    autoload :NodeConstraint, 'shex/algebra/node_constraint'
+    autoload :OneOf, 'shex/algebra/one_of'
+    autoload :Operator, 'shex/algebra/operator'
+    autoload :Or, 'shex/algebra/or'
+    autoload :Prefix, 'shex/algebra/prefix'
+    autoload :Satisfiable, 'shex/algebra/satisfiable'
+    autoload :Schema, 'shex/algebra/schema'
+    autoload :SemAct, 'shex/algebra/semact'
+    autoload :External, 'shex/algebra/external'
+    autoload :ShapeRef, 'shex/algebra/shape_ref'
+    autoload :Shape, 'shex/algebra/shape'
+    autoload :Start, 'shex/algebra/start'
+    autoload :Stem, 'shex/algebra/stem'
+    autoload :StemRange, 'shex/algebra/stem_range'
+    autoload :TripleConstraint, 'shex/algebra/triple_constraint'
+    autoload :TripleExpression, 'shex/algebra/triple_expression'
+    autoload :UnaryShape, 'shex/algebra/unary_shape'
+    autoload :Value, 'shex/algebra/value'
+
+    class NotMatched < ShEx::Error; end
+  end
+end
+
+

data/lib/shex/algebra/and.rb

@@ -0,0 +1,32 @@
+module ShEx::Algebra
+  ##
+  class And < Operator
+    include Satisfiable
+    NAME = :and
+
+    def initialize(*args, **options)
+      case
+      when args.length <= 1
+        raise ArgumentError, "wrong number of arguments (given #{args.length}, expected 1..)"
+      end
+      super
+    end
+
+    #
+    # S is a ShapeAnd and for every shape expression se2 in shapeExprs, satisfies(n, se2, G, m).
+    # @param [RDF::Resource] n
+    # @return [Boolean] `true` when satisfied
+    # @raise [ShEx::NotSatisfied] if not satisfied
+    def satisfies?(n)
+      status ""
+
+      # Operand raises NotSatisfied, so no need to check here.
+      operands.select {|o| o.is_a?(Satisfiable)}.each {|op| op.satisfies?(n)}
+      status("satisfied")
+      true
+    rescue ShEx::NotSatisfied => e
+      not_satisfied(e.message)
+      raise
+    end
+  end
+end

data/lib/shex/algebra/annotation.rb

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

data/lib/shex/algebra/base.rb

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

data/lib/shex/algebra/each_of.rb

@@ -0,0 +1,53 @@
+module ShEx::Algebra
+  ##
+  class EachOf < Operator
+    include TripleExpression
+    NAME = :eachOf
+
+    ##
+    # expr is an EachOf and there is some partition of T into T1, T2,… such that for every expression expr1, expr2,… in shapeExprs, matches(Tn, exprn, m)...
+    #
+    # @param [Array<RDF::Statement>] t
+    # @return [Array<RDF::Statement>]
+    # @raise NotMatched, ShEx::NotSatisfied
+    def matches(t)
+      status ""
+      results = []
+      statements = t.dup
+      num_iters = 0
+      max = maximum
+
+      while num_iters < max
+        begin
+          matched_this_iter = []
+          operands.select {|o| o.is_a?(TripleExpression)}.all? do |op|
+            matched = op.matches(statements - matched_this_iter)
+            matched_this_iter += matched
+          end
+          results += matched_this_iter
+          statements -= matched_this_iter
+          num_iters += 1
+          status "matched #{results.length} statements after #{num_iters} iterations"
+        rescue NotMatched => e
+          log_recover("eachOf: ignore error: #{e.message}", depth: options.fetch(:depth, 0))
+          break
+        end
+      end
+
+      # Max violations handled in Shape
+      not_matched "Minimum Cardinality Violation: #{num_iters} < #{minimum}" if
+        num_iters < minimum
+
+      # Last, evaluate semantic acts
+      semantic_actions.all? do |op|
+        op.satisfies?(results)
+      end unless results.empty?
+
+      status "each of satisfied"
+      results
+    rescue NotMatched => e
+      not_matched(e.message)
+      raise
+    end
+  end
+end