Code coverage and remove dead code.

Author: gkellogg

lib/shex.rb

@@ -24,7 +24,7 @@ module ShEx
   # @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, ShEx::OperandError] on structural problems with schema
+  # @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
@@ -49,10 +49,10 @@ def self.parse(expression, format: 'shexc', **options)
   # @yieldreturn [void] ignored
   # @return [ShEx::Algebra::Schema] The executable parsed expression.
   # @raise [ShEx::ParseError] when a syntax error is detected
-  # @raise [ShEx::StructureError, ShEx::OperandError] on structural problems with schema
+  # @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)
+      self.parse(file, options.merge(format: format))
     end
   end
 
@@ -71,9 +71,9 @@ def self.open(filename, format: 'shexc', **options, &block)
   # @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, ShEx::OperandError] on structural problems with schema
-  def self.execute(expression, queryable, focus, shape, format: 'shexc', **options, &block)
-    shex = self.parse(expression, options)
+  # @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)
@@ -102,9 +102,6 @@ class StructureError < Error; end
   # Shape expectation not satisfied
   class NotSatisfied < Error; end
 
-  # An error found on an operand
-  class OperandError < Error; end
-
   # Indicates bad syntax found in LD Patch document
   class ParseError < Error
     ##

lib/shex/algebra/and.rb

@@ -7,22 +7,26 @@ class And < Operator
     def initialize(*args, **options)
       case
       when args.length <= 1
-        raise ShEx::OperandError, "Expected at least one operand, found #{args.length}"
+        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` if satisfied, `false` if it does not apply
+    # @return [Boolean] `true` when satisfied
     # @raise [ShEx::NotSatisfied] if not satisfied
     def satisfies?(n)
       status ""
-      unless operands.select {|o| o.is_a?(Satisfiable)}.all? {|op| op.satisfies?(n)}
-        not_satisfied "Expected all to match"
-      end
+
+      # 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

lib/shex/algebra/each_of.rb

@@ -39,7 +39,7 @@ def matches(t)
         num_iters < minimum
 
       # Last, evaluate semantic acts
-      operands.select {|o| o.is_a?(SemAct)}.all? do |op|
+      semantic_actions.all? do |op|
         op.satisfies?(results)
       end unless results.empty?
 

lib/shex/algebra/inclusion.rb

@@ -5,7 +5,7 @@ class Inclusion < Operator
     NAME = :inclusion
 
     def initialize(arg, **options)
-      raise ShEx::OperandError, "Shape inclusion must be an IRI or BNode: #{arg}" unless arg.is_a?(RDF::Resource)
+      raise ArgumentError, "Shape inclusion must be an IRI or BNode: #{arg}" unless arg.is_a?(RDF::Resource)
       super
     end
 
@@ -25,11 +25,6 @@ def matches(t)
       not_matched "Minimum Cardinality Violation: #{results.length} < #{minimum}" if
         results.length < minimum
 
-      # Last, evaluate semantic acts
-      operands.select {|o| o.is_a?(SemAct)}.all? do |op|
-        op.satisfies?(results)
-      end unless results.empty?
-
       results
     end
 

lib/shex/algebra/not.rb

@@ -7,11 +7,13 @@ class Not < Operator::Unary
     #
     # S is a ShapeNot and for the shape expression se2 at shapeExpr, notSatisfies(n, se2, G, m).
     # @param [RDF::Resource] n
-    # @return [Boolean]
+    # @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

lib/shex/algebra/one_of.rb

@@ -39,7 +39,7 @@ def matches(t)
         num_iters < minimum
 
       # Last, evaluate semantic acts
-      operands.select {|o| o.is_a?(SemAct)}.all? do |op|
+      semantic_actions.all? do |op|
         op.satisfies?(results)
       end unless results.empty?
 

lib/shex/algebra/operator.rb

@@ -17,52 +17,6 @@ class Operator
     # Initialization options
     attr_accessor :options
 
-    ##
-    # Returns an operator class for the given operator `name`.
-    #
-    # @param  [Symbol, #to_s]  name
-    # @param  [Integer] arity
-    # @return [Class] an operator class, or `nil` if an operator was not found
-    def self.for(name, arity = nil)
-      {
-        and: And,
-        annotation: Annotation,
-        base: Base,
-        each_of: EachOf,
-        inclusion: Inclusion,
-        nodeConstraint: NodeConstraint,
-        not: Not,
-        one_of: OneOf,
-        or: Or,
-        prefix: Prefix,
-        schema: Schema,
-        semact: SemAct,
-        external: External,
-        shape_ref: ShapeRef,
-        shape: Shape,
-        start: Start,
-        stem: Stem,
-        stemRange: StemRange,
-        tripleConstraint: TripleConstraint,
-        value: Value,
-      }.fetch(name.to_s.downcase.to_sym)
-    end
-
-    ##
-    # Returns the arity of this operator class.
-    #
-    # @example
-    #   Operator.arity           #=> -1
-    #   Operator::Nullary.arity  #=> 0
-    #   Operator::Unary.arity    #=> 1
-    #   Operator::Binary.arity   #=> 2
-    #   Operator::Ternary.arity  #=> 3
-    #
-    # @return [Integer] an integer in the range `(-1..3)`
-    def self.arity
-      self.const_get(:ARITY)
-    end
-
     ARITY = -1 # variable arity
 
     ##
@@ -93,9 +47,8 @@ def initialize(*operands)
           when TrueClass, FalseClass, Numeric, String, DateTime, Date, Time
             RDF::Literal(operand)
           when NilClass
-            raise ShEx::OperandError, "Found nil operand for #{self.class.name}"
-            nil
-          else raise TypeError, "invalid SPARQL::Algebra::Operator operand: #{operand.inspect}"
+            raise ArgumentError, "Found nil operand for #{self.class.name}"
+          else raise TypeError, "invalid ShEx::Algebra::Operator operand: #{operand.inspect}"
         end
       end
 
@@ -110,67 +63,13 @@ def initialize(*operands)
       end
     end
 
-    ##
-    # Base URI used for reading data sources with relative URIs
-    #
-    # @return [RDF::URI]
-    def base_uri
-      Operator.base_uri
-    end
-
-    ##
-    # Base URI used for reading data sources with relative URIs
-    #
-    # @return [RDF::URI]
-    def self.base_uri
-      @base_uri
-    end
-
     ##
     # Is this shape closed?
     # @return [Boolean]
     def closed?
       operands.include?(:closed)
     end
 
-    ##
-    # Set Base URI associated with SPARQL document, typically done
-    # when reading SPARQL from a URI
-    #
-    # @param [RDF::URI] uri
-    # @return [RDF::URI]
-    def self.base_uri=(uri)
-      @base_uri = RDF::URI(uri)
-    end
-
-    ##
-    # Prefixes useful for future serialization
-    #
-    # @return [Hash{Symbol => RDF::URI}]
-    #   Prefix definitions
-    def prefixes
-      Operator.prefixes
-    end
-
-    ##
-    # Prefixes useful for future serialization
-    #
-    # @return [Hash{Symbol => RDF::URI}]
-    #   Prefix definitions
-    def self.prefixes
-      @prefixes
-    end
-
-    ##
-    # Prefixes useful for future serialization
-    #
-    # @param [Hash{Symbol => RDF::URI}] hash
-    #   Prefix definitions
-    # @return [Hash{Symbol => RDF::URI}]
-    def self.prefixes=(hash)
-      @prefixes = hash
-    end
-
     ##
     # Semantic Actions
     # @return [Array<SemAct>]
@@ -344,6 +243,7 @@ class Unary < Operator
       # @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
@@ -365,6 +265,7 @@ class Binary < Operator
       # @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

lib/shex/algebra/or.rb

@@ -7,7 +7,7 @@ class Or < Operator
     def initialize(*args, **options)
       case
       when args.length <= 1
-        structure_error("Expected at least one operand, found #{args.length}", exception: ShEx::OperandError)
+        raise ArgumentError, "wrong number of arguments (given #{args.length}, expected 1..)"
       end
       super
     end
@@ -32,7 +32,6 @@ def satisfies?(n)
       end
 
       not_satisfied "Expected some expression to be satisfied"
-      true
     end
   end
 end

lib/shex/algebra/schema.rb

@@ -30,7 +30,7 @@ def satisfies?(n, g, m, shapeExterns: [], **options)
       @map = m.inject({}) {|memo, (k,v)| memo.merge(k.to_s => v.to_s)}
 
       # First, evaluate semantic acts
-      operands.select {|o| o.is_a?(SemAct)}.all? do |op|
+      semantic_actions.all? do |op|
         op.satisfies?([])
       end
 

lib/shex/algebra/semact.rb

@@ -25,10 +25,11 @@ def satisfies?(statements)
         $stdout.puts str
         status str
         not_satisfied "fail" if md && md[1] == 'fail'
+        true
       else
         status("unknown SemAct name #{operands.first}") {"expression: #{self.to_sxp}"}
+        false
       end
-      true
     end
 
     # Does This operator is SemAct