srl_ruby 0.4.13 → 0.4.14

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a1aca92632a6d6009140d3df47adbacc96ec7237b665c8c7677192134b0dbffa
-  data.tar.gz: 4d9b6f2143a4d37b2092a179406aec2a5bfacff28e67383ce933a9f533cd1666
+  metadata.gz: aa7a9699a1a4f26e820e1523d4f6d3fa186cd814afeb5b41e164ea191df7303b
+  data.tar.gz: 0f4b1c7de0da2ed0a1acf1f2a700271d35afc383b5d9eeec0d790993f9d8928b
 SHA512:
-  metadata.gz: f154f7efc63ee2130369cc1f95e7d02d9883f13f747001c612851e2cc7cda964062a908015f5e2a852912587f35443ccbaef7163667644acd7bbf67de4d8835b
-  data.tar.gz: 4cfe10c6fcabe4b04ebb12da4e91eef6e416539dc6f54a9e590b8e1458fae3be284ca1c5d2d58be0dfa9d22ec8cbd4720674d1eb637ee8c3861781e7490cdd6d
+  metadata.gz: 972f392c2817101f0bffcc688b867060f19da7c258e5b0bd2fb2061a602df6d0c8f00df85be855bc6bb2cc24b8bd1c1994fac00d06a7ca9b1fe353277acbd21f
+  data.tar.gz: 7b8e2065d771a5ae84051bc7633d09ea6ed7dcb781b277fd47118b3796cf5a2f7f4d1fe44e29b5acf65303902e8c9a1b9b4f7692b8c9b4079c47115258450870

data/.rubocop.yml

@@ -184,3 +184,20 @@ Style/TernaryParentheses:
 
 Style/UnlessElse:
   Enabled: false
+
+#RSpec/ContextWording:
+#  Enabled: false
+#
+#RSpec/ExampleLength:
+#  Max: 40
+#
+#RSpec/MultipleExpectations:
+#  Max: 15
+#
+#RSpec/NoExpectationExample:
+#  Enabled: false
+#
+#RSpec/RepeatedDescription:
+#  Enabled: false
+
+

data/CHANGELOG.md

@@ -1,3 +1,9 @@
+## [0.4.13] - 2025-02-22
+- Tested against rubocop-rspec 3.5.0
+
+### Fixed
+- Fixed most "offences" reported by rubocop-rspec 
+
 ## [0.4.13] - 2025-02-22
 - Tested against MRI Ruby 3.4.1
 

data/bin/srl2ruby

@@ -62,7 +62,7 @@ class Srl2RubyProg
       t_filepath = "#{def_template_dir}/#{DefTemplate}"
     end
     path = Pathname.new(t_filepath)
-    ERB.new(path.read, nil, '<>')
+    ERB.new(path.read, trim_mode: '<>')
   end
 
   def validate_filename(raw_fname)

data/lib/srl_ruby/tokenizer.rb

@@ -17,15 +17,15 @@ module SrlRuby
   # Delimiters: parentheses '(' and ')'
   # Separators: comma (optional)
   class Tokenizer
-    PATT_CHAR_CLASS = /[^,"\s]{2,}/.freeze
-    PATT_DIGIT_LIT = /[0-9]((?=\s|,|\))|$)/.freeze
-    PATT_IDENTIFIER = /[a-zA-Z_][a-zA-Z0-9_]+/.freeze
-    PATT_INTEGER = /[0-9]{2,}((?=\s|,|\))|$)/.freeze # An integer has 2..* digits
-    PATT_LETTER_LIT = /[a-zA-Z]((?=\s|,|\))|$)/.freeze
-    PATT_NEWLINE = /(?:\r\n)|\r|\n/.freeze
-    PATT_STR_DBL_QUOTE = /"(?:\\"|[^"])*"/.freeze # Double quotes literal?
-    PATT_STR_SNGL_QUOTE = /'(?:\\'|[^'])*'/.freeze # Single quotes literal?
-    PATT_WHITESPACE = /[ \t\f]+/.freeze
+    PATT_CHAR_CLASS = /[^,"\s]{2,}/
+    PATT_DIGIT_LIT = /[0-9]((?=\s|,|\))|$)/
+    PATT_IDENTIFIER = /[a-zA-Z_][a-zA-Z0-9_]+/
+    PATT_INTEGER = /[0-9]{2,}((?=\s|,|\))|$)/ # An integer has 2..* digits
+    PATT_LETTER_LIT = /[a-zA-Z]((?=\s|,|\))|$)/
+    PATT_NEWLINE = /(?:\r\n)|\r|\n/
+    PATT_STR_DBL_QUOTE = /"(?:\\"|[^"])*"/ # Double quotes literal?
+    PATT_STR_SNGL_QUOTE = /'(?:\\'|[^'])*'/ # Single quotes literal?
+    PATT_WHITESPACE = /[ \t\f]+/
 
     # @return [StringScanner]
     attr_reader(:scanner)
@@ -100,7 +100,7 @@ module SrlRuby
       WHITESPACE
       WITH
       WORD
-    ].map { |x| [x, x] }.to_h
+    ].to_h { |x| [x, x] }
 
     class ScanError < StandardError; end
 

data/lib/srl_ruby/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module SrlRuby
-  VERSION = '0.4.13'
+  VERSION = '0.4.14'
 end

data/spec/acceptance/srl_test_suite_spec.rb

@@ -24,7 +24,7 @@ RSpec.describe SrlRuby do
   def test_rule_file(aRuleFileRepr)
     regex = SrlRuby::parse(aRuleFileRepr.srl.value)
     # puts regex.source
-    expect(regex).to be_kind_of(Regexp)
+    expect(regex).to be_a(Regexp)
 
     aRuleFileRepr.match_tests.each do |test|
       expect(test.test_string.value).to match(regex)
@@ -47,7 +47,7 @@ RSpec.describe SrlRuby do
       cp_test.expectations.each do |expec|
         expected_name = expec.var_name.value.to_s
         unless actual_names.empty?
-          expect(actual_names).to be_include(expected_name)
+          expect(actual_names).to include(expected_name)
         end
       end
 
@@ -68,77 +68,77 @@ RSpec.describe SrlRuby do
     end
   end
 
-  it 'should match a backslash' do
+  it 'matches a backslash' do
     rule_file_repr = load_file('backslash.rule')
     test_rule_file(rule_file_repr)
   end
 
-  it 'should support named capture group' do
+  it 'supports named capture group' do
     rule_file_repr = load_file('basename_capture_group.rule')
     test_rule_file(rule_file_repr)
   end
 
-  it 'should match uppercase letter(s)' do
+  it 'matches uppercase letter(s)' do
     rule_file_repr = load_file('issue_17_uppercase_letter.rule')
     test_rule_file(rule_file_repr)
   end
 
-  it 'should not trim literal strings' do
+  it "doesn't trim literal strings" do
     rule_file_repr = load_file('literally_spaces.rule')
     test_rule_file(rule_file_repr)
   end
 
-  it 'should support non word boundary' do
+  it 'supports non word boundary' do
     rule_file_repr = load_file('no_word.rule')
     test_rule_file(rule_file_repr)
   end
 
-  it 'should match non digit pattern' do
+  it 'matches non digit pattern' do
     rule_file_repr = load_file('nondigit.rule')
     test_rule_file(rule_file_repr)
   end
 
-  it 'should support negative character class' do
+  it 'supports negative character class' do
     rule_file_repr = load_file('none_of.rule')
     test_rule_file(rule_file_repr)
   end
 
-  it 'should support negative character class' do
+  it 'supports negative character class' do
     rule_file_repr = load_file('sample_capture.rule')
     test_rule_file(rule_file_repr)
   end
 
-  it 'should match a tab' do
+  it 'matches a tab' do
     rule_file_repr = load_file('tab.rule')
     test_rule_file(rule_file_repr)
   end
 
-  it 'should match mail address' do
+  it 'matches mail address' do
     rule_file_repr = load_file('website_example_email.rule')
     test_rule_file(rule_file_repr)
   end
 
-  it 'should match mail address' do
+  it 'matches mail address' do
     rule_file_repr = load_file('website_example_email_capture.rule')
     test_rule_file(rule_file_repr)
   end
 
-  it 'should support lookahead' do
+  it 'supports lookahead' do
     rule_file_repr = load_file('website_example_lookahead.rule')
     test_rule_file(rule_file_repr)
   end
 
-  it 'should not trim literal strings' do
+  it "doesn't trim literal strings" do
     rule_file_repr = load_file('website_example_password.rule')
     test_rule_file(rule_file_repr)
   end
 
-  it 'should process an URL' do
+  it 'processes an URL' do
     rule_file_repr = load_file('website_example_url.rule')
     test_rule_file(rule_file_repr)
   end
 
-  it 'should match a word boundary' do
+  it 'matches a word boundary' do
     rule_file_repr = load_file('word.rule')
     test_rule_file(rule_file_repr)
   end

data/spec/acceptance/support/rule_file_tokenizer.rb

@@ -39,7 +39,7 @@ module Acceptance
       match:
       no
       srl:
-    ].map { |x| [x, x.upcase] }.to_h
+    ].to_h { |x| [x, x.upcase] }
 
     class ScanError < StandardError; end
 

data/spec/regex/atomic_expression_spec.rb

@@ -7,30 +7,30 @@ require_relative '../../lib/regex/atomic_expression'
 # Reopen the module, in order to get rid of fully qualified names
 module Regex # This module is used as a namespace
   describe AtomicExpression do
-    subject { AtomicExpression.new }
+    subject(:atomic_expr) { described_class.new }
 
     context 'Creation & initialisation' do
-      it 'should be created without argument' do
-        expect { AtomicExpression.new }.not_to raise_error
+      it 'is created without argument' do
+        expect { described_class.new }.not_to raise_error
       end
 
-      it 'should know that it is atomic' do
-        expect(subject).to be_atomic
+      it 'knows that it is atomic' do
+        expect(atomic_expr).to be_atomic
       end
     end # context
 
     context 'Provided services' do
-      it 'should be unchanged by a done! notification' do
-        pre_snapshot = Marshal.dump(subject)
-        expect { subject.done! }.not_to raise_error
-        post_snapshot = Marshal.dump(subject)
+      it 'is unchanged by a done! notification' do
+        pre_snapshot = Marshal.dump(atomic_expr)
+        expect { atomic_expr.done! }.not_to raise_error
+        post_snapshot = Marshal.dump(atomic_expr)
         expect(post_snapshot).to eq(pre_snapshot)
       end
 
-      it 'should be unchanged by a lazy! notification' do
-        pre_snapshot = Marshal.dump(subject)
-        expect { subject.lazy! }.not_to raise_error
-        post_snapshot = Marshal.dump(subject)
+      it 'is unchanged by a lazy! notification' do
+        pre_snapshot = Marshal.dump(atomic_expr)
+        expect { atomic_expr.lazy! }.not_to raise_error
+        post_snapshot = Marshal.dump(atomic_expr)
         expect(post_snapshot).to eq(pre_snapshot)
       end
     end # context

data/spec/regex/character_spec.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-# File: character_spec.rb
+# File: described_class_spec.rb
 require_relative '../spec_helper' # Use the RSpec test framework
 require_relative '../../lib/regex/character'
 
@@ -8,13 +8,13 @@ module Regex # Open this namespace, to get rid of scope qualifiers
   describe Character do
   # rubocop: disable Lint/ConstantDefinitionInBlock
 
-    # This constant holds an arbitrary selection of characters
+    # This constant holds an arbitrary selection of described_classs
     SampleChars = [?a, ?\0, ?\u0107].freeze
 
-    # This constant holds the codepoints of the character selection
+    # This constant holds the codepoints of the described_class selection
     SampleInts = [0x61, 0, 0x0107].freeze
 
-    # This constant holds an arbitrary selection of two characters (digrams)
+    # This constant holds an arbitrary selection of two described_classs (digrams)
     # escape sequences
     SampleDigrams = %w[\n \e \0 \6 \k].freeze
 
@@ -28,63 +28,63 @@ module Regex # Open this namespace, to get rid of scope qualifiers
     end
 
     context 'Creation & initialization' do
-      it 'should be created with a with an integer value (codepoint) or...' do
+      it 'is created with a with an integer value (codepoint) or...' do
         SampleInts.each do |codepoint|
-          expect { Character.new(codepoint) }.not_to raise_error
+          expect { described_class.new(codepoint) }.not_to raise_error
         end
       end
 
-      it '...could be created with a single character String or...' do
+      it '... is created with a single described_class String or...' do
         SampleChars.each do |ch|
-          expect { Character.new(ch) }.not_to raise_error
+          expect { described_class.new(ch) }.not_to raise_error
         end
       end
 
-      it '...could be created with an escape sequence' do
+      it '... is created with an escape sequence' do
         # Case 1: escape sequence is a digram
         SampleDigrams.each do |escape_seq|
-          expect { Character.new(escape_seq) }.not_to raise_error
+          expect { described_class.new(escape_seq) }.not_to raise_error
         end
 
         # Case 2: escape sequence is an escaped octal or hexadecimal literal
         SampleNumEscs.each do |escape_seq|
-          expect { Character.new(escape_seq) }.not_to raise_error
+          expect { described_class.new(escape_seq) }.not_to raise_error
         end
       end
     end # context
 
     # rubocop: disable Style/DocumentDynamicEvalDefinition
     context 'Provided services' do
-      it 'Should know its lexeme if created from a string' do
-        # Lexeme is defined when the character was initialised from a text
+      it 'knows its lexeme if created from a string' do
+        # Lexeme is defined when the described_class was initialised from a text
         SampleChars.each do |ch|
-          ch = Character.new(ch)
+          ch = described_class.new(ch)
           expect(ch.lexeme).to eq(ch)
         end
       end
 
-      it 'Should not know its lexeme representation from a codepoint' do
+      it 'does not know its lexeme representation from a codepoint' do
         SampleInts.each do |ch|
-          ch = Character.new(ch)
+          ch = described_class.new(ch)
           expect(ch.lexeme).to be_nil
         end
       end
 
-      it 'should know its String representation' do
-        # Try for one character
-        newOne = Character.new(?\u03a3)
+      it 'knows its String representation' do
+        # Try for one described_class
+        newOne = described_class.new(?\u03a3)
         expect(newOne.char).to eq('Σ')
         expect(newOne.to_str).to eq("\u03A3")
 
         # Try with our chars sample
         SampleChars.each do |ch|
-          new_ch = Character.new(ch).to_str
+          new_ch = described_class.new(ch).to_str
           new_ch == ch
         end
 
         # Try with our codepoint sample
         mapped_chars = SampleInts.map do |codepoint|
-          Character.new(codepoint).char
+          described_class.new(codepoint).char
         end
         expect(mapped_chars).to eq(SampleChars)
 
@@ -92,32 +92,32 @@ module Regex # Open this namespace, to get rid of scope qualifiers
         (SampleDigrams + SampleNumEscs).each do |escape_seq|
           # Build a string from escape sequence literal
           expectation = String.class_eval(%Q|"#{escape_seq}"|, __FILE__, __LINE__)
-          new_ch = Character.new(escape_seq).to_str
+          new_ch = described_class.new(escape_seq).to_str
           new_ch == expectation
         end
       end
 
-      it 'should know its codepoint' do
-        # Try for one character
-        newOne = Character.new(?\u03a3)
+      it 'knows its codepoint' do
+        # Try for one described_class
+        newOne = described_class.new(?\u03a3)
         expect(newOne.codepoint).to eq(0x03a3)
 
         # Try with our chars sample
         allCodepoints = SampleChars.map do |ch|
-          Character.new(ch).codepoint
+          described_class.new(ch).codepoint
         end
         expect(allCodepoints).to eq(SampleInts)
 
         # Try with our codepoint sample
         SampleInts.each do |codepoint|
-          expect(Character.new(codepoint).codepoint).to eq(codepoint)
+          expect(described_class.new(codepoint).codepoint).to eq(codepoint)
         end
 
         # Try with our escape sequence samples
         (SampleDigrams + SampleNumEscs).each do |escape_seq|
           # Get ordinal value of given escape sequence
           expectation = String.class_eval(%Q|"#{escape_seq}".ord()|, __FILE__, __LINE__)
-          expect(Character.new(escape_seq).codepoint).to eq(expectation)
+          expect(described_class.new(escape_seq).codepoint).to eq(expectation)
         end
       end
 
@@ -128,26 +128,26 @@ module Regex # Open this namespace, to get rid of scope qualifiers
         end
       end # module
 
-      it 'should known whether it is equal to another Object' do
-        newOne = Character.new(?\u03a3)
+      it 'knows whether it is equal to another Object' do
+        newOne = described_class.new(?\u03a3)
 
         # Case 1: test equality with itself
         expect(newOne).to eq(newOne)
 
-        # Case 2: test equality with another Character
-        expect(newOne).to eq(Character.new(?\u03a3))
-        expect(newOne).not_to eq(Character.new(?\u0333))
+        # Case 2: test equality with another described_class
+        expect(newOne).to eq(described_class.new(?\u03a3))
+        expect(newOne).not_to eq(described_class.new(?\u0333))
 
         # Case 3: test equality with an integer value
         # (equality based on codepoint value)
         expect(newOne).to eq(0x03a3)
         expect(newOne).not_to eq(0x0333)
 
-        # Case 4: test equality with a single-character String
+        # Case 4: test equality with a single-described_class String
         expect(newOne).to eq(?\u03a3)
         expect(newOne).not_to eq(?\u0333)
 
-        # Case 5: test fails with multiple character strings
+        # Case 5: test fails with multiple described_class strings
         expect(newOne).not_to eq('03a3')
 
         # Case 6: equality testing with arbitrary object
@@ -156,7 +156,7 @@ module Regex # Open this namespace, to get rid of scope qualifiers
 
         # In case 6, equality is based on to_s method.
         simulator = double('fake')
-        expect(simulator).to receive(:to_s).and_return(?\u03a3)
+        allow(simulator).to receive(:to_s).and_return(?\u03a3)
         expect(newOne).to eq(simulator)
 
         weird = Object.new
@@ -164,11 +164,11 @@ module Regex # Open this namespace, to get rid of scope qualifiers
         expect(newOne).to eq(weird)
       end
 
-      it 'should know its readable description' do
-        ch1 = Character.new('a')
+      it 'knows its readable description' do
+        ch1 = described_class.new('a')
         expect(ch1.explain).to eq("the character 'a'")
 
-        ch2 = Character.new(?\u03a3)
+        ch2 = described_class.new(?\u03a3)
         expect(ch2.explain).to eq("the character '\u03a3'")
       end
     end # context

data/spec/regex/match_option_spec.rb

@@ -9,25 +9,26 @@ require_relative '../../lib/regex/match_option'
 module Regex # This module is used as a namespace
   describe MatchOption do
     let(:sample_child) { double('fake-child') }
-    subject { MatchOption.new(sample_child, [Regexp::MULTILINE, Regexp::IGNORECASE]) }
+
+    subject(:option) { described_class.new(sample_child, [Regexp::MULTILINE, Regexp::IGNORECASE]) }
 
     context 'Creation & initialisation' do
-      it 'should be created with a child and flags' do
-        expect { MatchOption.new(sample_child, []) }.not_to raise_error
+      it 'is created with a child and flags' do
+        expect { described_class.new(sample_child, []) }.not_to raise_error
       end
 
-      it 'should know its child' do
-        expect(subject.child).to eq(sample_child)
+      it 'Knows its child' do
+        expect(option.child).to eq(sample_child)
       end
 
-      it 'should know its flags' do
-        expect(subject.flags).to eq([Regexp::MULTILINE, Regexp::IGNORECASE])
+      it 'Knows its flags' do
+        expect(option.flags).to eq([Regexp::MULTILINE, Regexp::IGNORECASE])
       end
     end # context
 
     context 'Provided services' do
-      it 'should combine the flag bits' do
-        expect(subject.combine_opts).to eq(Regexp::MULTILINE | Regexp::IGNORECASE)
+      it 'Combines the flag bits' do
+        expect(option.combine_opts).to eq(Regexp::MULTILINE | Regexp::IGNORECASE)
       end
     end # context
   end # describe

data/spec/regex/monadic_expression_spec.rb

@@ -8,31 +8,32 @@ require_relative '../../lib/regex/monadic_expression'
 module Regex # This module is used as a namespace
   describe MonadicExpression do
     let(:sample_child) { double('fake_regex') }
-    subject { MonadicExpression.new(sample_child) }
+
+    subject(:monadic_expr) { described_class.new(sample_child) }
 
     context 'Creation & initialisation' do
-      it 'should be created with a child expression' do
-        expect { MonadicExpression.new(sample_child) }.not_to raise_error
+      it 'is created with a child expression' do
+        expect { described_class.new(sample_child) }.not_to raise_error
       end
 
-      it 'should know its child' do
-         expect(subject.child).to eq(sample_child)
+      it 'Knows its child' do
+         expect(monadic_expr.child).to eq(sample_child)
       end
 
-      it 'should know that it is not atomic' do
-        expect(subject).not_to be_atomic
+      it 'Know that it is not atomic' do
+        expect(monadic_expr).not_to be_atomic
       end
     end # context
 
     context 'Provided services' do
-      it 'should propagate done! notification' do
-        expect(sample_child).to receive(:done!)
-        expect { subject.done! }.not_to raise_error
+      it 'Propagates done! notification' do
+        allow(sample_child).to receive(:done!)
+        expect { monadic_expr.done! }.not_to raise_error
       end
 
-      it 'should be unchanged by a lazy! notification' do
-        expect(sample_child).to receive(:lazy!)
-        expect { subject.lazy! }.not_to raise_error
+      it 'is unchanged by a lazy! notification' do
+        allow(sample_child).to receive(:lazy!)
+        expect { monadic_expr.lazy! }.not_to raise_error
       end
     end # context
   end # describe

data/spec/regex/multiplicity_spec.rb

@@ -9,39 +9,39 @@ require_relative '../../lib/regex/multiplicity'
 module Regex # This module is used as a namespace
   describe Multiplicity do
     context 'Creation & initialisation' do
-      it 'should be created with 3 arguments' do
+      it 'is created with 3 arguments' do
         # Valid cases: initialized with two integer values and a policy symbol
         %i[greedy lazy possessive].each do |policy|
-          expect { Multiplicity.new(0, 1, policy) }.not_to raise_error
+          expect { described_class.new(0, 1, policy) }.not_to raise_error
         end
 
         # Invalid case: initialized with invalid policy value
         err = StandardError
         msg = "Invalid repetition policy 'KO'."
-        expect { Multiplicity.new(0, :more, 'KO') }.to raise_error(err, msg)
+        expect { described_class.new(0, :more, 'KO') }.to raise_error(err, msg)
       end
     end
 
     context 'Provided services' do
       # rubocop: disable Style/CombinableLoops
-      it 'should know its text representation' do
+      it 'Knows its text representation' do
         policy2text = { greedy: '', lazy: '?', possessive: '+' }
 
         # Case: zero or one
         policy2text.each_key do |policy|
-          multi = Multiplicity.new(0, 1, policy)
+          multi = described_class.new(0, 1, policy)
           expect(multi.to_str).to eq("?#{policy2text[policy]}")
         end
 
         # Case: zero or more
         policy2text.each_key do |policy|
-          multi = Multiplicity.new(0, :more, policy)
+          multi = described_class.new(0, :more, policy)
           expect(multi.to_str).to eq("*#{policy2text[policy]}")
         end
 
         # Case: one or more
         policy2text.each_key do |policy|
-          multi = Multiplicity.new(1, :more, policy)
+          multi = described_class.new(1, :more, policy)
           expect(multi.to_str).to eq("+#{policy2text[policy]}")
         end
 
@@ -49,7 +49,7 @@ module Regex # This module is used as a namespace
         policy2text.each_key do |policy|
           samples = [1, 2, 5, 100]
           samples.each do |count|
-            multi = Multiplicity.new(count, count, policy)
+            multi = described_class.new(count, count, policy)
             expect(multi.to_str).to eq("{#{count}}#{policy2text[policy]}")
           end
         end
@@ -59,7 +59,7 @@ module Regex # This module is used as a namespace
           samples = [1, 2, 5, 100]
           samples.each do |count|
             upper = count + 1 + rand(20)
-            multi = Multiplicity.new(count, upper, policy)
+            multi = described_class.new(count, upper, policy)
             expectation = "{#{count},#{upper}}#{policy2text[policy]}"
             expect(multi.to_str).to eq(expectation)
           end
@@ -69,7 +69,7 @@ module Regex # This module is used as a namespace
         policy2text.each_key do |policy|
           samples = [2, 3, 5, 100]
           samples.each do |count|
-            multi = Multiplicity.new(count, :more, policy)
+            multi = described_class.new(count, :more, policy)
             expect(multi.to_str).to eq("{#{count},}#{policy2text[policy]}")
           end
         end

data/spec/regex/repetition_spec.rb

@@ -9,23 +9,24 @@ module Regex # This module is used as a namespace
   describe Repetition do
     let(:optional) { Multiplicity.new(0, 1, :possessive) }
     let(:sample_child) { double('fake_regex') }
-    subject { Repetition.new(sample_child, optional) }
+
+    subject(:repetition) { described_class.new(sample_child, optional) }
 
     context 'Creation & initialisation' do
-      it 'should be created with a child expression and a multiplicity' do
-        expect { Repetition.new(sample_child, optional) }.not_to raise_error
+      it 'is created with a child expression and a multiplicity' do
+        expect { described_class.new(sample_child, optional) }.not_to raise_error
       end
 
-      it 'should its multiplicity' do
-        expect(subject.multiplicity).to eq(optional)
+      it 'Knows its multiplicity' do
+        expect(repetition.multiplicity).to eq(optional)
       end
     end # context
 
     context 'Provided services' do
-      it 'should change its policy with lazy! notification' do
-        expect(sample_child).to receive(:lazy!)
-        expect { subject.lazy! }.not_to raise_error
-        expect(subject.multiplicity.policy).to eq(:lazy)
+      it 'Changes its policy with lazy! notification' do
+        allow(sample_child).to receive(:lazy!)
+        expect { repetition.lazy! }.not_to raise_error
+        expect(repetition.multiplicity.policy).to eq(:lazy)
       end
     end # context
   end # describe