shex 0.1.0

data/lib/shex/algebra/external.rb

@@ -0,0 +1,24 @@
+module ShEx::Algebra
+  ##
+  class External < Operator
+    include Satisfiable
+    NAME = :external
+
+    #
+    # S is a ShapeRef and the Schema's shapes maps reference to a shape expression se2 and satisfies(n, se2, G, m).
+    def satisfies?(n)
+      extern_shape = nil
+
+      # Find the label for this external
+      label = schema.shapes.key(self)
+      not_satisfied("Can't find label for this extern") unless label
+
+      schema.external_schemas.each do |schema|
+        extern_shape ||= schema.shapes[label]
+      end
+
+      not_satisfied("External not configured for this shape") unless extern_shape
+      extern_shape.satisfies?(n)
+    end
+  end
+end

data/lib/shex/algebra/inclusion.rb

@@ -0,0 +1,59 @@
+module ShEx::Algebra
+  ##
+  class Inclusion < Operator
+    include TripleExpression
+    NAME = :inclusion
+
+    def initialize(arg, **options)
+      raise ArgumentError, "Shape inclusion must be an IRI or BNode: #{arg}" unless arg.is_a?(RDF::Resource)
+      super
+    end
+
+    ##
+    # In this case, we accept an array of statements, and match based on cardinality.
+    #
+    # @param [Array<RDF::Statement>] t
+    # @return [Array<RDF::Statement>]
+    # @raise NotMatched, ShEx::NotSatisfied
+    def matches(t)
+      status "referenced_shape: #{operands.first}"
+      expression = referenced_shape.triple_expressions.first
+      max = maximum
+      results = expression.matches(t)
+
+      # Max violations handled in Shape
+      not_matched "Minimum Cardinality Violation: #{results.length} < #{minimum}" if
+        results.length < minimum
+
+      results
+    end
+
+    ##
+    # Returns the referenced shape
+    #
+    # @return [Operand]
+    def referenced_shape
+      schema.shapes[operands.first.to_s]
+    end
+
+    ##
+    # A Inclusion is valid if it's ancestor schema has any shape with a lable
+    # the same as it's reference.
+    #
+    # An Inclusion object's include property must appear in the schema's shapes map and the corresponding triple expression must be a Shape with a tripleExpr. The function dereference(include) returns the shape's tripleExpr.
+    def validate!
+      structure_error("Missing included shape: #{operands.first}") if referenced_shape.nil?
+      structure_error("Self included shape: #{operands.first}") if referenced_shape == first_ancestor(Shape)
+
+      triple_expressions = referenced_shape.triple_expressions
+      case triple_expressions.length
+      when 0
+        structure_error("Includes shape with no triple expressions")
+      when 1
+      else
+        structure_error("Includes shape with multiple triple expressions")
+      end
+      super
+    end
+  end
+end

data/lib/shex/algebra/node_constraint.rb

@@ -0,0 +1,148 @@
+module ShEx::Algebra
+  ##
+  class NodeConstraint < Operator
+    include Satisfiable
+    NAME = :nodeConstraint
+
+    #
+    # S is a NodeConstraint and satisfies2(n, se) as described below in Node Constraints. Note that testing if a node satisfies a node constraint does not require a graph or shapeMap.
+    # @param [RDF::Resource] n
+    # @return [Boolean] `true` if satisfied, `false` if it does not apply
+    # @raise [ShEx::NotSatisfied] if not satisfied
+    def satisfies?(n)
+      status ""
+      satisfies_node_kind?(n) &&
+      satisfies_datatype?(n) &&
+      satisfies_string_facet?(n) &&
+      satisfies_numeric_facet?(n) &&
+      satisfies_values?(n)
+    end
+
+  private
+
+    ##
+    # Satisfies Node Kind Constraint
+    # @return [Boolean] `true` if satisfied, `false` if it does not apply
+    # @raise [ShEx::NotSatisfied] if not satisfied
+    def satisfies_node_kind?(value)
+      kind = case operands.first
+      when :iri         then RDF::URI
+      when :bnode       then RDF::Node
+      when :literal     then RDF::Literal
+      when :nonliteral  then RDF::Resource
+      else              return true
+      end
+
+      not_satisfied "Node was #{value.inspect} expected kind #{kind}" unless
+        value.is_a?(kind)
+      status "right kind: #{value}: #{kind}"
+      true
+    end
+
+    ##
+    # Datatype Constraint
+    # @return [Boolean] `true` if satisfied, `false` if it does not apply
+    # @raise [ShEx::NotSatisfied] if not satisfied
+    def satisfies_datatype?(value)      
+      dt = operands[1] if operands.first == :datatype
+      return true unless dt
+
+      not_satisfied "Node was #{value.inspect}, expected datatype #{dt}" unless
+        value.is_a?(RDF::Literal) && value.datatype == RDF::URI(dt)
+      status "right datatype: #{value}: #{dt}"
+      true
+    end
+
+    ##
+    # String Facet Constraint
+    # Checks all length/minlength/maxlength/pattern facets against the string representation of the value.
+    # @return [Boolean] `true` if satisfied, `false` if it does not apply
+    # @raise [ShEx::NotSatisfied] if not satisfied
+    def satisfies_string_facet?(value)
+      length    = op_fetch(:length)
+      minlength = op_fetch(:minlength)
+      maxlength = op_fetch(:maxlength)
+      pattern   = op_fetch(:pattern)
+
+      return true if (length || minlength || maxlength || pattern).nil?
+
+      v_s = case value
+      when RDF::Node then value.id
+      else value.to_s
+      end
+      not_satisfied "Node #{v_s.inspect} length not #{length}" if
+        length && v_s.length != length.to_i
+      not_satisfied"Node #{v_s.inspect} length < #{minlength}" if
+        minlength && v_s.length < minlength.to_i
+      not_satisfied "Node #{v_s.inspect} length > #{maxlength}" if
+        maxlength && v_s.length > maxlength.to_i
+      not_satisfied "Node #{v_s.inspect} does not match #{pattern}" if
+        pattern && !Regexp.new(pattern).match(v_s)
+      status "right string facet: #{value}"
+      true
+    end
+
+    ##
+    # Numeric Facet Constraint
+    # Checks all numeric facets against the value.
+    # @return [Boolean] `true` if satisfied, `false` if it does not apply
+    # @raise [ShEx::NotSatisfied] if not satisfied
+    def satisfies_numeric_facet?(value)
+      mininclusive   = op_fetch(:mininclusive)
+      minexclusive   = op_fetch(:minexclusive)
+      maxinclusive   = op_fetch(:maxinclusive)
+      maxexclusive   = op_fetch(:maxexclusive)
+      totaldigits    = op_fetch(:totaldigits)
+      fractiondigits = op_fetch(:fractiondigits)
+
+      return true if (mininclusive || minexclusive || maxinclusive || maxexclusive || totaldigits || fractiondigits).nil?
+
+      not_satisfied "Node #{value.inspect} not numeric" unless
+        value.is_a?(RDF::Literal::Numeric)
+
+      not_satisfied "Node #{value.inspect} not decimal" if
+        (totaldigits || fractiondigits) && (!value.is_a?(RDF::Literal::Decimal) || value.invalid?)
+
+      numeric_value = value.object
+      case
+      when !mininclusive.nil? && numeric_value < mininclusive.object then not_satisfied("Node #{value.inspect} < #{mininclusive.object}")
+      when !minexclusive.nil? && numeric_value <= minexclusive.object then not_satisfied("Node #{value.inspect} not <= #{minexclusive.object}")
+      when !maxinclusive.nil? && numeric_value > maxinclusive.object then not_satisfied("Node #{value.inspect} > #{maxinclusive.object}")
+      when !maxexclusive.nil? && numeric_value >= maxexclusive.object then not_satisfied("Node #{value.inspect} >= #{maxexclusive.object}")
+      when !totaldigits.nil?
+        md = value.canonicalize.to_s.match(/([1-9]\d*|0)?(?:\.(\d+)(?!0))?/)
+        digits = md ? (md[1].to_s + md[2].to_s) : ""
+        if digits.length > totaldigits.to_i
+          not_satisfied "Node #{value.inspect} total digits != #{totaldigits}"
+        end
+      when !fractiondigits.nil?
+        md = value.canonicalize.to_s.match(/\.(\d+)(?!0)?/)
+        num = md ? md[1].to_s : ""
+        if num.length > fractiondigits.to_i
+          not_satisfied "Node #{value.inspect} fractional digits != #{fractiondigits}"
+        end
+      end
+      status "right numeric facet: #{value}"
+      true
+    end
+
+    ##
+    # Value Constraint
+    # Checks all numeric facets against the value.
+    # @return [Boolean] `true` if satisfied, `false` if it does not apply
+    # @raise [ShEx::NotSatisfied] if not satisfied
+    def satisfies_values?(value)
+      values = operands.select {|op| op.is_a?(Value)}
+      return true if values.empty?
+      matched_value = values.detect {|v| v.match?(value)}
+      not_satisfied "Node #{value.inspect} not expected" unless matched_value
+      status "right value: #{value}"
+      true
+    end
+
+    # Returns the value of a particular facet
+    def op_fetch(which)
+      (operands.detect {|op| op.is_a?(Array) && op[0] == which} || [])[1]
+    end
+  end
+end

data/lib/shex/algebra/not.rb

@@ -0,0 +1,19 @@
+module ShEx::Algebra
+  ##
+  class Not < Operator::Unary
+    include Satisfiable
+    NAME = :not
+
+    #
+    # S is a ShapeNot and for the shape expression se2 at shapeExpr, notSatisfies(n, se2, G, m).
+    # @param [RDF::Resource] n
+    # @return [Boolean] `true` when satisfied, meaning that the operand was not satisfied
+    # @raise [ShEx::NotSatisfied] if not satisfied, meaning that the operand was satisfied
+    def satisfies?(n)
+      status ""
+      operands.last.not_satisfies?(n)
+      status "not satisfied"
+      true
+    end
+  end
+end

data/lib/shex/algebra/one_of.rb

@@ -0,0 +1,50 @@
+module ShEx::Algebra
+  ##
+  class OneOf < Operator
+    include TripleExpression
+    NAME = :oneOf
+
+    ##
+    # `expr` is a OneOf and there is some shape expression `se2` in shapeExprs such that a `matches(T, se2, m)`...
+    #
+    # @param [Array<RDF::Statement>] t
+    # @return [Array<RDF::Statement]
+    def matches(t)
+      results = []
+      statements = t.dup
+      num_iters = 0
+      max = maximum
+
+      # OneOf is greedy, and consumes triples from every sub-expression, although only one is requred it succeed. Cardinality is somewhat complicated, as if two expressions match, this works for either a cardinality of one or two. Or two passes with just one match on each pass.
+      status ""
+      while num_iters < max
+        matched_something = operands.select {|o| o.is_a?(TripleExpression)}.any? do |op|
+          begin
+            matched = op.matches(statements)
+            results += matched
+            statements -= matched
+            status "matched #{t.first.to_sxp}"
+          rescue NotMatched => e
+            log_recover("oneOf: ignore error: #{e.message}", depth: options.fetch(:depth, 0))
+            false
+          end
+        end
+        break unless matched_something
+        num_iters += 1
+        status "matched #{results.length} statements after #{num_iters} iterations"
+      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 "one of satisfied"
+      results
+    end
+  end
+end

data/lib/shex/algebra/operator.rb

@@ -0,0 +1,274 @@
+require 'sparql/algebra'
+require 'sparql/extensions'
+
+module ShEx::Algebra
+
+  ##
+  # The ShEx operator.
+  #
+  # @abstract
+  class Operator
+    extend SPARQL::Algebra::Expression
+    include RDF::Util::Logger
+
+    # Location of schema including this operator
+    attr_accessor :schema
+
+    # Initialization options
+    attr_accessor :options
+
+    ARITY = -1 # variable arity
+
+    ##
+    # Initializes a new operator instance.
+    #
+    # @overload initialize(*operands)
+    #   @param  [Array<RDF::Term>] operands
+    #
+    # @overload initialize(*operands, options)
+    #   @param  [Array<RDF::Term>] operands
+    #   @param  [Hash{Symbol => Object}] options
+    #     any additional options
+    #   @option options [Boolean] :memoize (false)
+    #     whether to memoize results for particular operands
+    # @raise  [TypeError] if any operand is invalid
+    def initialize(*operands)
+      @options  = operands.last.is_a?(Hash) ? operands.pop.dup : {}
+      @operands = operands.map! do |operand|
+        case operand
+          when Array
+            operand.each do |op|
+              op.parent = self if op.respond_to?(:parent=)
+            end
+            operand
+          when Operator, RDF::Term, RDF::Query, RDF::Query::Pattern, Array, Symbol
+            operand.parent = self if operand.respond_to?(:parent=)
+            operand
+          when TrueClass, FalseClass, Numeric, String, DateTime, Date, Time
+            RDF::Literal(operand)
+          when NilClass
+            raise ArgumentError, "Found nil operand for #{self.class.name}"
+          else raise TypeError, "invalid ShEx::Algebra::Operator operand: #{operand.inspect}"
+        end
+      end
+
+      if options[:logger]
+        options[:depth] = 0
+        each_descendant(1) do |depth, operand|
+          if operand.respond_to?(:options)
+            operand.options[:logger] = options[:logger]
+            operand.options[:depth] = depth
+          end
+        end
+      end
+    end
+
+    ##
+    # Is this shape closed?
+    # @return [Boolean]
+    def closed?
+      operands.include?(:closed)
+    end
+
+    ##
+    # Semantic Actions
+    # @return [Array<SemAct>]
+    def semantic_actions
+      operands.select {|o| o.is_a?(SemAct)}
+    end
+
+    # Does this operator include Satisfiable?
+    def satisfiable?; false; end
+
+    # Does this operator include TripleExpression?
+    def triple_expression?; false; end
+
+    # Does this operator a SemAct?
+    def semact?; false; end
+
+    ##
+    # Exception handling
+    def not_matched(message, **opts)
+      expression = opts.fetch(:expression, self)
+      exception = opts.fetch(:exception, NotMatched)
+      log_error(message, depth: options.fetch(:depth, 0), exception: exception) {"expression: #{expression.to_sxp}"}
+    end
+
+    def not_satisfied(message, **opts)
+      expression = opts.fetch(:expression, self)
+      exception = opts.fetch(:exception, ShEx::NotSatisfied)
+      log_error(message, depth: options.fetch(:depth, 0), exception: exception) {"expression: #{expression.to_sxp}"}
+    end
+
+    def structure_error(message, **opts)
+      expression = opts.fetch(:expression, self)
+      exception = opts.fetch(:exception, ShEx::StructureError)
+      log_error(message, depth: options.fetch(:depth, 0), exception: exception) {"expression: #{expression.to_sxp}"}
+    end
+
+    def status(message, &block)
+      log_info(self.class.const_get(:NAME), message, depth: options.fetch(:depth, 0), &block)
+      true
+    end
+
+    ##
+    # The operands to this operator.
+    #
+    # @return [Array]
+    attr_reader :operands
+
+    ##
+    # Returns the operand at the given `index`.
+    #
+    # @param  [Integer] index
+    #   an operand index in the range `(0...(operands.count))`
+    # @return [RDF::Term]
+    def operand(index = 0)
+      operands[index]
+    end
+
+    ##
+    # Returns the SPARQL S-Expression (SSE) representation of this operator.
+    #
+    # @return [Array]
+    # @see    http://openjena.org/wiki/SSE
+    def to_sxp_bin
+      operator = [self.class.const_get(:NAME)].flatten.first
+      [operator, *(operands || []).map(&:to_sxp_bin)]
+    end
+
+    ##
+    # Returns an S-Expression (SXP) representation of this operator
+    #
+    # @return [String]
+    def to_sxp
+      begin
+        require 'sxp' # @see http://rubygems.org/gems/sxp
+      rescue LoadError
+        abort "SPARQL::Algebra::Operator#to_sxp requires the SXP gem (hint: `gem install sxp')."
+      end
+      require 'sparql/algebra/sxp_extensions'
+
+      to_sxp_bin.to_sxp
+    end
+
+    ##
+    # Returns a developer-friendly representation of this operator.
+    #
+    # @return [String]
+    def inspect
+      sprintf("#<%s:%#0x(%s)>", self.class.name, __id__, operands.to_sse.gsub(/\s+/m, ' '))
+    end
+
+    ##
+    # @param  [Statement] other
+    # @return [Boolean]
+    def eql?(other)
+      other.class == self.class && other.operands == self.operands
+    end
+    alias_method :==, :eql?
+
+    ##
+    # Enumerate via depth-first recursive descent over operands, yielding each operator
+    # @param [Integer] depth incrementeded for each depth of operator, and provided to block if Arity is 2
+    # @yield operator
+    # @yieldparam [Object] operator
+    # @return [Enumerator]
+    def each_descendant(depth = 0, &block)
+      if block_given?
+        operands.each do |operand|
+          case operand
+          when Array
+            operand.each do |op|
+              op.each_descendant(depth + 1, &block) if op.respond_to?(:each_descendant)
+            end
+          else
+            operand.each_descendant(depth + 1, &block) if operand.respond_to?(:each_descendant)
+          end
+
+          case block.arity
+          when 1 then block.call(operand)
+          else block.call(depth, operand)
+          end
+        end
+      end
+      enum_for(:each_descendant)
+    end
+    alias_method :descendants, :each_descendant
+    alias_method :each, :each_descendant
+
+    ##
+    # Parent expression, if any
+    #
+    # @return [Operator]
+    def parent; @options[:parent]; end
+
+    ##
+    # Parent operator, if any
+    #
+    # @return [Operator]
+    def parent=(operator)
+      @options[:parent]= operator
+    end
+
+    ##
+    # First ancestor operator of type `klass`
+    #
+    # @param [Class] klass
+    # @return [Operator]
+    def first_ancestor(klass)
+      parent.is_a?(klass) ? parent : parent.first_ancestor(klass) if parent
+    end
+
+    ##
+    # Validate all operands, operator specific classes should override for operator-specific validation
+    # @return [SPARQL::Algebra::Expression] `self`
+    # @raise  [ShEx::StructureError] if the value is invalid
+    def validate!
+      operands.each {|op| op.validate! if op.respond_to?(:validate!)}
+      self
+    end
+
+    ##
+    # A unary operator.
+    #
+    # Operators of this kind take one operand.
+    #
+    # @abstract
+    class Unary < Operator
+      ARITY = 1
+
+      ##
+      # @param  [RDF::Term] arg1
+      #   the first operand
+      # @param  [Hash{Symbol => Object}] options
+      #   any additional options (see {Operator#initialize})
+      def initialize(arg1, options = {})
+        raise ArgumentError, "wrong number of arguments (given 2, expected 1)" unless options.is_a?(Hash)
+        super
+      end
+    end # Unary
+
+    ##
+    # A binary operator.
+    #
+    # Operators of this kind take two operands.
+    #
+    # @abstract
+    class Binary < Operator
+      ARITY = 2
+
+      ##
+      # @param  [RDF::Term] arg1
+      #   the first operand
+      # @param  [RDF::Term] arg2
+      #   the second operand
+      # @param  [Hash{Symbol => Object}] options
+      #   any additional options (see {Operator#initialize})
+      def initialize(arg1, arg2, options = {})
+        raise ArgumentError, "wrong number of arguments (given 3, expected 2)" unless options.is_a?(Hash)
+        super
+      end
+    end # Binary
+  end
+end