shex 0.5.2 → 0.6.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: fdc22fc0cbd72f02a6a807fb42af927c8b775a50
-  data.tar.gz: 28cf889e643e7132959045b03142efd0a20397f7
+SHA256:
+  metadata.gz: f2a6bb3da7f7e92a1a168e6390cbd1d41406df0baf7b5d76f358843b6e3fb071
+  data.tar.gz: 34a49a33ec8d8208cef666e913d9dd33fe02355caf7cff8ce2b54c2c9e65a4c5
 SHA512:
-  metadata.gz: e54c857b51c4ac594df2809b97e358bb2bd2fe4e83a1ad7ec91da1022ef9b2293f71de5cb2d88f1b3a529dd053bda53d65961ab9bab20f07f756c22947fe26a3
-  data.tar.gz: '058b65943bf484559158f249abbbdce55ce725759ac9312a06f8e56ed86eb3170e5a3a941388f38260e982cec18d02b592e89cafe96e2c1df133e97b7e908736'
+  metadata.gz: da5cefbf0b4831c741b3bad56091077b60ea178acaac3e4c5fc0a554a87f97c26dc1086fdbd9a6e84427e3db8d1df188b849106dc85b29de789e6caff34d6544
+  data.tar.gz: 65d6123a33922a51061865181bdcf98a76b150442f641652e88f93b0c3939e47229f7bf66ca65d1a4380935f0453f5c78601299113b9dfcdd509605c6f28687c

data/AUTHORS

@@ -1 +1 @@
-* Gregg Kellogg <gregg@kellogg-assoc.com>
+* Gregg Kellogg <gregg@greggkellogg.net>

data/LICENSE

@@ -21,4 +21,4 @@ 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>
+For more information, please refer to <https://unlicense.org>

data/README.md

@@ -2,24 +2,23 @@
 
 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)
+[![Gem Version](https://badge.fury.io/rb/shex.png)](https://badge.fury.io/rb/shex)
+[![Build Status](https://github.com/ruby-rdf/shex/workflows/CI/badge.svg?branch=develop)](https://github.com/ruby-rdf/shex/actions?query=workflow%3ACI)
+[![Coverage Status](https://coveralls.io/repos/ruby-rdf/shex/badge.svg?branch=develop)](https://coveralls.io/github/ruby-rdf/shex?branch=develop)
+[![Gitter chat](https://badges.gitter.im/ruby-rdf/rdf.png)](https://gitter.im/ruby-rdf/rdf)
+[![DOI](https://zenodo.org/badge/74419330.svg)](https://zenodo.org/badge/latestdoi/74419330)
 
 ## 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.
+* 100% free and unencumbered [public domain](https://unlicense.org/) software.
 
 ## Description
 
-The ShEx gem implements a [ShEx][ShExSpec] Shape Expression engine.
+The ShEx gem implements a [ShEx][ShExSpec] Shape Expression engine version 2.0.
 
-* `ShEx::Parser` parses ShExC and ShExJ formatted documents generating executable operators which can be serialized as [S-Expressions](http://en.wikipedia.org/wiki/S-expression).
+* `ShEx::Parser` parses ShExC and ShExJ formatted documents generating executable operators which can be serialized as [S-Expressions][].
 * `ShEx::Algebra` executes operators against Any `RDF::Graph`, including compliant [RDF.rb][].
 * [Implementation Report](file.earl.html)
 
@@ -44,9 +43,9 @@ The ShEx gem implements a [ShEx][ShExSpec] Shape Expression engine.
     graph = RDF::Graph.load("etc/doap.ttl")
     schema = ShEx.parse(shexc)
     map = {
-      "http://rubygems.org/gems/shex" => "TestShape"
+      "https://rubygems.org/gems/shex" => "TestShape"
     }
-    schema.satisfies?("http://rubygems.org/gems/shex", graph, map)
+    schema.satisfies?("https://rubygems.org/gems/shex", graph, map)
     # => true
 ### Validating a node using ShExJ
 
@@ -138,8 +137,8 @@ The ShEx gem implements a [ShEx][ShExSpec] Shape Expression engine.
     })
     graph = RDF::Graph.load("etc/doap.ttl")
     schema = ShEx.parse(shexj, format: :shexj)
-    map = {"http://rubygems.org/gems/shex" => "TestShape"}
-    schema.satisfies?("http://rubygems.org/gems/shex", graph, map)
+    map = {"https://rubygems.org/gems/shex" => "TestShape"}
+    schema.satisfies?("https://rubygems.org/gems/shex", graph, map)
     # => true
 
 ## Extensions
@@ -176,28 +175,27 @@ 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
+      --focus https://rubygems.org/gems/shex
 
 ## Documentation
 
-<http://rubydoc.info/github/ruby-rdf/shex>
+<https://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}.
+The ShExC parser uses the [EBNF][] gem to generate a [PEG][] parser.
 
-The result of parsing either ShExC or ShExJ is the creation of a set of executable {ShEx::Algebra} Operators which are directly executed to perform shape validation.
+The parser uses the executable [S-Expressions][] generated from the EBNF ShExC grammar to create a set of executable {ShEx::Algebra} Operators which are directly executed to perform shape validation.
 
 ## Dependencies
 
-* [Ruby](http://ruby-lang.org/) (>= 2.2.2)
-* [RDF.rb](http://rubygems.org/gems/rdf) (~> 2.2)
+* [Ruby](https://ruby-lang.org/) (>= 2.4)
+* [RDF.rb](https://rubygems.org/gems/rdf) (~> 3.1)
+* [SPARQL gem](https://rubygems.org/gems/sparql) (~> 3.1)
 
 ## Installation
 
-The recommended installation method is via [RubyGems](http://rubygems.org/).
+The recommended installation method is via [RubyGems](https://rubygems.org/).
 To install the latest official release of RDF.rb, do:
 
     % [sudo] gem install shex
@@ -211,21 +209,21 @@ To get a local working copy of the development repository, do:
 Alternatively, download the latest development version as a tarball as
 follows:
 
-    % wget http://github.com/ruby-rdf/shex/tarball/master
+    % wget https://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>
+* <https://rubydoc.info/github/ruby-rdf/shex>
+* <https://github.com/ruby-rdf/shex>
+* <https://rubygems.org/gems/shex>
 
 ## Mailing List
 
-* <http://lists.w3.org/Archives/Public/public-rdf-ruby/>
+* <https://lists.w3.org/Archives/Public/public-rdf-ruby/>
 
 ## Author
 
-* [Gregg Kellogg](http://github.com/gkellogg) - <http://greggkellogg.net/>
+* [Gregg Kellogg](https://github.com/gkellogg) - <https://greggkellogg.net/>
 
 ## Contributing
 
@@ -244,14 +242,21 @@ This repository uses [Git Flow](https://github.com/nvie/gitflow) to mange develo
   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.
+  explicit [public domain dedication][PDD] on record from you,
+  which you will be asked to agree to on the first commit to a repo within the organization.
+  Note that the agreement applies to all repos in the [Ruby RDF](https://github.com/ruby-rdf/) organization.
 
 ## License
 
 This is free and unencumbered public domain software. For more information,
-see <http://unlicense.org/> or the accompanying {file:LICENSE} file.
-
-[ShExSpec]:     http://shex.io/shex-semantics/
-[RDF]:          http://www.w3.org/RDF/
-[RDF.rb]:       http://rubydoc.info/github/ruby-rdf/rdf
-[EBNF]:         http://rubygems.org/gems/ebnf
+see <https://unlicense.org/> or the accompanying {file:LICENSE} file.
+
+[ShExSpec]:     http://shex.io/shex-semantics-20170713/
+[RDF]:          https://www.w3.org/RDF/
+[RDF.rb]:       https://rubydoc.info/github/ruby-rdf/rdf
+[EBNF]:         https://rubygems.org/gems/ebnf
+[YARD]:         https://yardoc.org/
+[YARD-GS]:      https://rubydoc.info/docs/yard/file/docs/GettingStarted.md
+[PDD]:              https://unlicense.org/#unlicensing-contributions
+[PEG]:          https://en.wikipedia.org/wiki/Parsing_expression_grammar "Parsing Expression Grammar"
+[S-Expression]: https://en.wikipedia.org/wiki/S-expression

data/VERSION

@@ -1 +1 @@
-0.5.2
+0.6.3

data/etc/doap.ttl

@@ -1,4 +1,4 @@
-@base <http://rubygems.org/gems/shex> .
+@base <https://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/> .
@@ -8,27 +8,25 @@
 @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.rb" ;
-  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 ;
+<https://rubygems.org/gems/shex> a doap:Project, earl:TestSubject, earl:Software ;
+  doap:name          "ShEx" ;
+  doap:homepage      <https://ruby-rdf.github.com/shex> ;
+  doap:license       <https://unlicense.org/1.0/> ;
+  doap:shortdesc     "ShEx is a Shape Expression engine for Ruby RDF.rb."@en ;
+  doap:description   "ShEx is an Shape Expression engine for the Ruby RDF.rb library suite."@en ;
   doap:created       "2016-12-09"^^xsd:date ;
   doap:programming-language "Ruby" ;
   doap:implements    <http://shex.io/shex-semantics/> ;
   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.rb" ;
-  dc:description     "ShEx is an Shape Expression engine for the RDF.rb library suite."@en ;
+  doap:download-page <https://rubygems.org/gems/shex> ;
+  doap:mailing-list  <https://lists.w3.org/Archives/Public/public-rdf-ruby/> ;
+  doap:bug-database  <https://github.com/ruby-rdf/shex/issues> ;
+  doap:blog          <https://greggkellogg.net/> ;
+  doap:developer     <https://greggkellogg.net/foaf#me> ;
+  doap:maintainer    <https://greggkellogg.net/foaf#me> ;
+  doap:documenter    <https://greggkellogg.net/foaf#me> ;
+  foaf:maker         <https://greggkellogg.net/foaf#me> ;
   dc:date            "2016-12-09"^^xsd:date ;
-  dc:creator         <http://greggkellogg.net/foaf#me> ;
-  dc:isPartOf        <http://rubygems.org/gems/rdf> .
+  dc:creator         <https://greggkellogg.net/foaf#me> ;
+  dc:isPartOf        <https://rubygems.org/gems/rdf> .

data/lib/shex/algebra/and.rb

@@ -19,7 +19,7 @@ module ShEx::Algebra
     # Creates an operator instance from a parsed ShExJ representation
     # @param (see Operator#from_shexj)
     # @return [Operator]
-    def self.from_shexj(operator, options = {})
+    def self.from_shexj(operator, **options)
       raise ArgumentError unless operator.is_a?(Hash) && operator['type'] == 'ShapeAnd'
       raise ArgumentError, "missing shapeExprs in #{operator.inspect}" unless operator.has_key?('shapeExprs')
       super

data/lib/shex/algebra/annotation.rb

@@ -7,7 +7,7 @@ module ShEx::Algebra
     # Creates an operator instance from a parsed ShExJ representation
     # @param (see Operator#from_shexj)
     # @return [Operator]
-    def self.from_shexj(operator, options = {})
+    def self.from_shexj(operator, **options)
       raise ArgumentError unless operator.is_a?(Hash) && operator['type'] == "Annotation"
       raise ArgumentError, "missing predicate in #{operator.inspect}" unless operator.has_key?('predicate')
       raise ArgumentError, "missing object in #{operator.inspect}" unless operator.has_key?('object')

data/lib/shex/algebra/each_of.rb

@@ -8,7 +8,7 @@ module ShEx::Algebra
     # Creates an operator instance from a parsed ShExJ representation
     # @param (see Operator#from_shexj)
     # @return [Operator]
-    def self.from_shexj(operator, options = {})
+    def self.from_shexj(operator, **options)
       raise ArgumentError unless operator.is_a?(Hash) && operator['type'] == 'EachOf'
       raise ArgumentError, "missing expressions in #{operator.inspect}" unless operator.has_key?('expressions')
       super

data/lib/shex/algebra/node_constraint.rb

@@ -9,7 +9,7 @@ module ShEx::Algebra
     # Creates an operator instance from a parsed ShExJ representation
     # @param (see Operator#from_shexj)
     # @return [Operator]
-    def self.from_shexj(operator, options = {})
+    def self.from_shexj(operator, **options)
       raise ArgumentError unless operator.is_a?(Hash) && operator['type'] == 'NodeConstraint'
       super
     end

data/lib/shex/algebra/not.rb

@@ -8,7 +8,7 @@ module ShEx::Algebra
     # Creates an operator instance from a parsed ShExJ representation
     # @param (see Operator#from_shexj)
     # @return [Operator]
-    def self.from_shexj(operator, options = {})
+    def self.from_shexj(operator, **options)
       raise ArgumentError unless operator.is_a?(Hash) && operator['type'] == 'ShapeNot'
       raise ArgumentError, "missing shapeExpr in #{operator.inspect}" unless operator.has_key?('shapeExpr')
       super

data/lib/shex/algebra/one_of.rb

@@ -8,7 +8,7 @@ module ShEx::Algebra
     # Creates an operator instance from a parsed ShExJ representation
     # @param (see Operator#from_shexj)
     # @return [Operator]
-    def self.from_shexj(operator, options = {})
+    def self.from_shexj(operator, **options)
       raise ArgumentError unless operator.is_a?(Hash) && operator['type'] == 'OneOf'
       raise ArgumentError, "missing expressions in #{operator.inspect}" unless operator.has_key?('expressions')
       super

data/lib/shex/algebra/operator.rb

@@ -26,7 +26,7 @@ module ShEx::Algebra
     # @overload initialize(*operands)
     #   @param  [Array<RDF::Term>] operands
     #
-    # @overload initialize(*operands, options)
+    # @overload initialize(*operands, **options)
     #   @param  [Array<RDF::Term>] operands
     #   @param  [Hash{Symbol => Object}] options
     #     any additional options
@@ -244,7 +244,7 @@ module ShEx::Algebra
     # @return [String]
     def to_sxp
       begin
-        require 'sxp' # @see http://rubygems.org/gems/sxp
+        require 'sxp' # @see https://rubygems.org/gems/sxp
       rescue LoadError
         abort "SPARQL::Algebra::Operator#to_sxp requires the SXP gem (hint: `gem install sxp')."
       end
@@ -260,7 +260,7 @@ module ShEx::Algebra
     # @option options [RDF::URI] :base
     # @option options [Hash{String => RDF::URI}] :prefixes
     # @return [Operator]
-    def self.from_shexj(operator, options = {})
+    def self.from_shexj(operator, **options)
       options[:context] ||= JSON::LD::Context.parse(ShEx::CONTEXT)
       operands = []
       id = nil
@@ -268,21 +268,21 @@ module ShEx::Algebra
       operator.each do |k, v|
         case k
         when /length|clusive|digits/           then operands << [k.to_sym, RDF::Literal(v)]
-        when 'id'                              then id = iri(v, options)
+        when 'id'                              then id = iri(v, **options)
         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 '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
         when 'start'
           if v.is_a?(String)
-            operands << Start.new(iri(v, options))
+            operands << Start.new(iri(v, **options))
           else
-            operands << Start.new(ShEx::Algebra.from_shexj(v, options))
+            operands << Start.new(ShEx::Algebra.from_shexj(v, **options))
           end
         when '@context'                        then
           options[:context] = JSON::LD::Context.parse(v)
@@ -290,52 +290,52 @@ module ShEx::Algebra
         when 'shapes'
           operands << case v
           when Array
-            [:shapes] + v.map {|vv| ShEx::Algebra.from_shexj(vv, options)}
+            [:shapes] + v.map {|vv| ShEx::Algebra.from_shexj(vv, **options)}
           else
             raise "Expected value of shapes #{v.inspect}"
           end
         when 'stem', 'name'
           # Value may be :wildcard for stem
           if [IriStem, IriStemRange, SemAct].include?(self)
-            operands << (v.is_a?(Symbol) ? v : value(v, options))
+            operands << (v.is_a?(Symbol) ? v : value(v, **options))
           else
             operands << v
           end
-        when 'predicate' then operands << [:predicate, iri(v, options)]
+        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)
+          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|
             if op.is_a?(Hash) && op.has_key?('type')
-              ShEx::Algebra.from_shexj(op, options)
+              ShEx::Algebra.from_shexj(op, **options)
             elsif [IriStem, IriStemRange].include?(self)
-              value(op, options)
+              value(op, **options)
             else
               RDF::Literal(op)
             end
           end.unshift(:exclusions)
         when 'semActs', 'startActs', 'annotations'
           v = [v] unless v.is_a?(Array)
-          operands += v.map {|op| ShEx::Algebra.from_shexj(op, options)}
+          operands += v.map {|op| ShEx::Algebra.from_shexj(op, **options)}
         when 'expression', 'expressions', 'shapeExpr', 'shapeExprs', 'valueExpr'
           v = [v] unless v.is_a?(Array)
           operands += v.map do |op|
             # It's a URI reference to a Shape
-            op.is_a?(String) ? iri(op, options) : ShEx::Algebra.from_shexj(op, options) 
+            op.is_a?(String) ? iri(op, **options) : ShEx::Algebra.from_shexj(op, **options) 
           end
         when 'code'
           operands << v
         when 'values'
           v = [v] unless v.is_a?(Array)
           operands += v.map do |op|
-            Value.new(value(op, options))
+            Value.new(value(op, **options))
           end
         end
       end
 
-      new(*operands, options.merge(id: id))
+      new(*operands, **options.merge(id: id))
     end
 
     def json_type
@@ -476,14 +476,14 @@ module ShEx::Algebra
     # @option options [JSON::LD::Context] :context
     # @return [RDF::Value]
     def iri(value, options = @options)
-      self.class.iri(value, options)
+      self.class.iri(value, **options)
     end
 
     # Create URIs
     # @param  (see #iri)
     # @option (see #iri)
     # @return (see #iri)
-    def self.iri(value, options)
+    def self.iri(value, **options)
       # If we have a base URI, use that when constructing a new URI
       base_uri = options[:base_uri]
 
@@ -492,7 +492,7 @@ module ShEx::Algebra
         # A JSON-LD node reference
         v = options[:context].expand_value(value)
         raise "Expected #{value.inspect} to be a JSON-LD Node Reference" unless JSON::LD::Utils.node_reference?(v)
-        self.iri(v['@id'], options)
+        self.iri(v['@id'], **options)
       when RDF::URI
         if base_uri && value.relative?
           base_uri.join(value)
@@ -530,26 +530,26 @@ module ShEx::Algebra
     # @option options [Hash{String => RDF::URI}] :prefixes
     # @return [RDF::Value]
     def value(value, options = @options)
-      self.class.value(value, options)
+      self.class.value(value, **options)
     end
 
     # Create Values, with "clever" matching to see if it might be a value, IRI or BNode.
     # @param  (see #value)
     # @option (see #value)
     # @return (see #value)
-    def self.value(value, options)
+    def self.value(value, **options)
       # If we have a base URI, use that when constructing a new URI
       case value
       when Hash
         # Either a value object or a node reference
         if value['uri'] || value['@id']
-          iri(value['uri'] || value['@id'], options)
+          iri(value['uri'] || value['@id'], **options)
         elsif value['value'] || value['@value']
           RDF::Literal(value['value'] || value['@value'], datatype: value['type'] || value['@type'], language: value['language'] || value['@language'])
         else
-          ShEx::Algebra.from_shexj(value, options)
+          ShEx::Algebra.from_shexj(value, **options)
         end
-      else iri(value, options)
+      else iri(value, **options)
       end
     end
 
@@ -593,7 +593,6 @@ module ShEx::Algebra
 
     ##
     # 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]
@@ -661,12 +660,12 @@ module ShEx::Algebra
       self
     end
 
-  protected
-    def dup
-      operands = @operands.map {|o| o.dup rescue o}
-      self.class.new(*operands, id: @id)
-    end
+  def dup
+    operands = @operands.map {|o| o.dup rescue o}
+    self.class.new(*operands, id: @id)
+  end
 
+  protected
     ##
     # A unary operator.
     #
@@ -681,7 +680,7 @@ module ShEx::Algebra
       #   the first operand
       # @param  [Hash{Symbol => Object}] options
       #   any additional options (see {Operator#initialize})
-      def initialize(arg1, options = {})
+      def initialize(arg1, **options)
         raise ArgumentError, "wrong number of arguments (given 2, expected 1)" unless options.is_a?(Hash)
         super
       end
@@ -703,7 +702,7 @@ module ShEx::Algebra
       #   the second operand
       # @param  [Hash{Symbol => Object}] options
       #   any additional options (see {Operator#initialize})
-      def initialize(arg1, arg2, options = {})
+      def initialize(arg1, arg2, **options)
         raise ArgumentError, "wrong number of arguments (given 3, expected 2)" unless options.is_a?(Hash)
         super
       end