srl_ruby 0.4.13 → 0.4.15

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a1aca92632a6d6009140d3df47adbacc96ec7237b665c8c7677192134b0dbffa
-  data.tar.gz: 4d9b6f2143a4d37b2092a179406aec2a5bfacff28e67383ce933a9f533cd1666
+  metadata.gz: af00786c71ac6736bb80041630395c02bf7e86a8a15c4601b3010edefadc7d21
+  data.tar.gz: ac70e3dc3bdd7ce80e84e9d2c5c72b3f45d4664fb1d47d4e12e85d57b24c3aa7
 SHA512:
-  metadata.gz: f154f7efc63ee2130369cc1f95e7d02d9883f13f747001c612851e2cc7cda964062a908015f5e2a852912587f35443ccbaef7163667644acd7bbf67de4d8835b
-  data.tar.gz: 4cfe10c6fcabe4b04ebb12da4e91eef6e416539dc6f54a9e590b8e1458fae3be284ca1c5d2d58be0dfa9d22ec8cbd4720674d1eb637ee8c3861781e7490cdd6d
+  metadata.gz: 42229711b0814750b89ed47ff893defbc51ae40463613f85c3c3d82afff577984452eb8039439ebec6813708f892cf657ed338df6170d0ab0acc411a96cc471f
+  data.tar.gz: dd628a6cdd006763a00a5c82950bc5721bf4f9ee6a065b88f29f0dda9a0161bd7e5613dc3379f30479b3866fbca77b454afe2919084a633cc326a5195b3082f4

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,14 @@
+## [0.4.15] - 2025-03-20
+- Tested against rley  0.9.02 and rubocop 1.74.0
+### Changed
+- File `srl_ruby.gemspec`: make dependencies more lenient
+
+## [0.4.14] - 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/regex/character.rb

@@ -41,13 +41,13 @@ module Regex # This module is used as a namespace
     # codepoint value.
     # Examples:
     # Initializing with codepoint value...
-    # RegAn::Character.new(0x3a3) # Represents: Σ
+    # Regex::Character.new(0x3a3) # Represents: Σ
     # (Unicode GREEK CAPITAL LETTER SIGMA)
-    # RegAn::Character.new(931)   # Also represents: Σ (931 dec == 3a3 hex)
+    # Regex::Character.new(931)   # Also represents: Σ (931 dec == 3a3 hex)
     #
     # Initializing with a single character string
-    # RegAn::Character.new(?\u03a3) # Also represents: Σ
-    # RegAn::Character.new('Σ')   # Obviously, represents a Σ
+    # Regex::Character.new(?\u03a3) # Also represents: Σ
+    # Regex::Character.new('Σ')   # Obviously, represents a Σ
     #
     # Initializing with an escape sequence string
     # Recognized escaped characters are: \a (alarm, 0x07), \n (newline, 0xA),
@@ -56,8 +56,8 @@ module Regex # This module is used as a namespace
     # \uXXXX where XXXX is a 4 hex digits integer value, \u{X...}, \ooo (octal)
     # \xXX (hex)
     # Any other escaped character will be treated as a literal character
-    # RegAn::Character.new('\n')    # Represents a newline
-    # RegAn::Character.new('\u03a3')  # Represents a Σ
+    # Regex::Character.new('\n')    # Represents a newline
+    # Regex::Character.new('\u03a3')  # Represents a Σ
     def initialize(aValue)
       super()
       case aValue
@@ -80,7 +80,7 @@ module Regex # This module is used as a namespace
 
     # Convertion method that returns a character given a codepoint (integer) value.
     # Example:
-    # RegAn::Character::codepoint2char(0x3a3) # Returns: Σ (
+    # Regex::Character::codepoint2char(0x3a3) # Returns: Σ (
     # The Unicode GREEK CAPITAL LETTER SIGMA)
     def self.codepoint2char(aCodepoint)
       [aCodepoint].pack('U') # Remark: chr() fails with codepoints > 256
@@ -88,7 +88,7 @@ module Regex # This module is used as a namespace
 
     # Convertion method that returns the codepoint for the given single character.
     # Example:
-    # RegAn::Character::char2codepoint('Σ') # Returns: 0x3a3
+    # Regex::Character::char2codepoint('Σ') # Returns: 0x3a3
     def self.char2codepoint(aChar)
       aChar.ord
     end
@@ -102,7 +102,7 @@ module Regex # This module is used as a namespace
     # \xXX (hex)
     # Any other escaped character will be treated as a literal character
     # Example:
-    # RegAn::Character::esc2codepoint('\n') # Returns: 0xd
+    # Regex::Character::esc2codepoint('\n') # Returns: 0xd
     def self.esc2codepoint(esc_seq)
       msg = "Escape sequence #{esc_seq} does not begin with a backslash (\\)."
       raise StandardError, msg unless esc_seq[0] == '\\'

data/lib/regex/multiplicity.rb

@@ -70,6 +70,7 @@ module Regex # This module is used as a namespace
     end
 
     # Validation method. Return the validated lower bound value
+    # @param anUpperBound [Integer, Symbol] integer or :more symbol
     def valid_upper_bound(anUpperBound)
       err_msg = "Invalid upper bound of repetition count #{anUpperBound}"
       unless anUpperBound.kind_of?(Integer) || (anUpperBound == :more)

data/lib/srl_ruby/ast_builder.rb

@@ -12,8 +12,10 @@ module SrlRuby
   # (say, a parse tree) from simpler objects (terminal and non-terminal
   # nodes) and using a step by step approach.
   class ASTBuilder < Rley::ParseRep::ASTBaseBuilder
+    # @return [Hash]
     Terminal2NodeClass = {}.freeze
 
+    # @return [Array<Symbol>] Options for the regular expression
     attr_reader :options
 
     # Create a new AST builder instance.
@@ -24,6 +26,7 @@ module SrlRuby
     end
 
     # Notification that the parse tree construction is complete.
+    # @return [void]
     def done!
       apply_options
       super
@@ -31,10 +34,12 @@ module SrlRuby
 
     protected
 
+    # @return [Hash]
     def terminal2node
       Terminal2NodeClass
     end
 
+    # @return [void]
     def apply_options
       tree_root = result.root
       regexp_opts = []
@@ -62,12 +67,17 @@ module SrlRuby
       Rley::PTree::TerminalNode.new(aToken, aTokenPosition)
     end
 
+    # @param lowerBound [Integer]
+    # @param upperBound [Integer, Symbol]
+    # @return [Regex::Multiplicity]
     def multiplicity(lowerBound, upperBound)
       Regex::Multiplicity.new(lowerBound, upperBound, :greedy)
     end
 
     # rubocop: disable Style/OptionalBooleanParameter
 
+    # @param aString [String]
+    # @param [Array<Regex::Character>, Regex::Concatenation, Regex::Character]
     def string_literal(aString, to_escape = true)
       if aString.size > 1
         chars = []
@@ -90,6 +100,8 @@ module SrlRuby
     end
     # rubocop: enable Style/OptionalBooleanParameter
 
+    # @param lowerBound [Integer]
+    # @param upperBound [Integer]
     def char_range(lowerBound, upperBound)
       lower = Regex::Character.new(lowerBound)
       upper = Regex::Character.new(upperBound)

data/lib/srl_ruby/grammar.rb

@@ -111,6 +111,6 @@ module SrlRuby
   end
 
   # And now build the grammar and make it accessible via a global constant
-  # [Rley::Syntax::Grammar]
+  # @return [Rley::Syntax::Grammar]
   Grammar = builder.grammar
 end # module

data/lib/srl_ruby/tokenizer.rb

@@ -17,15 +17,32 @@ 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
+    # @return [Regexp] Matches a SRL character class
+    PATT_CHAR_CLASS = /[^,"\s]{2,}/
+
+    # @return [Regexp] Matches single digit
+    PATT_DIGIT_LIT = /[0-9]((?=\s|,|\))|$)/
+
+    # @return [Regexp] Matches a SRL identifier
+    PATT_IDENTIFIER = /[a-zA-Z_][a-zA-Z0-9_]+/
+
+    # @return [Regexp] Matches a decimal integer. An integer has 2..* digits
+    PATT_INTEGER = /[0-9]{2,}((?=\s|,|\))|$)/
+
+    # @return [Regexp] Matches a single letter.
+    PATT_LETTER_LIT = /[a-zA-Z]((?=\s|,|\))|$)/
+
+    # @return [Regexp] Matches a new line (cross-platform)
+    PATT_NEWLINE = /(?:\r\n)|\r|\n/
+
+    # @return [Regexp] Matches a text enclosed in double quotes
+    PATT_STR_DBL_QUOTE = /"(?:\\"|[^"])*"/
+
+    # @return [Regexp] Matches a text enclosed in single quotes
+    PATT_STR_SNGL_QUOTE = /'(?:\\'|[^'])*'/
+
+    # @return [Regexp] Matches SRL blank(s)
+    PATT_WHITESPACE = /[ \t\f]+/
 
     # @return [StringScanner]
     attr_reader(:scanner)
@@ -36,6 +53,7 @@ module SrlRuby
     # @return [Integer] offset of start of current line within input
     attr_reader(:line_start)
 
+    # @return [{String => String}] Mapping special single characters to symbolic names.
     Lexeme2name = {
       '(' => 'LPAREN',
       ')' => 'RPAREN',
@@ -43,6 +61,7 @@ module SrlRuby
     }.freeze
 
     # Here are all the SRL keywords (in uppercase)
+    # @return [{String => String}]
     Keywords = %w[
       ALL
       ALREADY
@@ -100,8 +119,9 @@ module SrlRuby
       WHITESPACE
       WITH
       WORD
-    ].map { |x| [x, x] }.to_h
+    ].to_h { |x| [x, x] }
 
+    # Exception class for scanner/tokenizer failures.
     class ScanError < StandardError; end
 
     # Constructor. Initialize a tokenizer for SRL.
@@ -112,6 +132,8 @@ module SrlRuby
       @line_start = 0
     end
 
+    # Returns the sequence of tokens recognized from the input text given at initialization.
+    # @return [Array<Rley::Lexical::Token>]
     def tokens
       tok_sequence = []
       until @scanner.eos?
@@ -124,6 +146,7 @@ module SrlRuby
 
     private
 
+    # @return [Rley::Lexical::Token]
     def _next_token
       token = nil
 
@@ -170,6 +193,9 @@ module SrlRuby
       token
     end
 
+    # @param aSymbolName [String]
+    # @param aLexeme [String]
+    # @return [Rley::Lexical::Token]
     def build_token(aSymbolName, aLexeme)
       begin
         col = scanner.pos - aLexeme.size - @line_start + 1
@@ -184,6 +210,7 @@ module SrlRuby
     end
 
     # Event: next line detected.
+    # @return [Integer] Current scanning position (offset)
     def next_line_scanned
       @lineno += 1
       @line_start = scanner.pos

data/lib/srl_ruby/version.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
 module SrlRuby
-  VERSION = '0.4.13'
+  # @return [String] Version number of the Gem
+  VERSION = '0.4.15'
 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