rley 0.8.14 → 0.8.15

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: cf803f55dde48af888bfb7e0be524e66b8d2357aa85ae6292cf8c70d7a521273
-  data.tar.gz: f9cf09dffb9939c03b2c301c4669600d6d8f3bcefac20313fd54406456ed800a
+  metadata.gz: 7e2ff00bd9b05a972b081dbcde3e9b6ff36f639fc9a9b2ae3bd22a494dd991d8
+  data.tar.gz: 17cc2cd1544312b3781a9015de83df250519f9dc39353d172cdcfa70597af181
 SHA512:
-  metadata.gz: fa9e22773d7679b615d9119be340aac8ad91890dab9e1fe79c240883cb8059bed11dc48be011649ba068db7c62de23d25f3637acd2c3112b92f057e8319bae9e
-  data.tar.gz: 892e9fdb184f4ab33de790fe998504b8ab9fbacdcd19f1ce389ca39cdddc4c28634742cef281036a67a4e8cdb1b7d301df15a6846386f279eb971def3d083820
+  metadata.gz: 2f90be1939b2698dfb830b765e2857693b55b3626c610c220d2abb8beecf0e67e23c02ebb65da3dd57fbcb6e08e5170ac0847d8677b370bcdd9b119c3f59346a
+  data.tar.gz: 7c689384cc04ec1dd61b098a2280b8814611ba220ef7f745f55872b2e03ecdd7bc6f62de527a47a04e432ead8346a411c49995a429a5677320217abe7a30d1e4

data/.rubocop.yml

@@ -438,6 +438,9 @@ Lint/TopLevelReturnWithArgument:
 Lint/UnreachableLoop:
   Enabled: true
 
+Naming/BlockForwarding:
+  EnforcedStyle: explicit
+
 Style/AccessorGrouping:
   Enabled: true
 
@@ -505,7 +508,22 @@ Style/StringConcatenation:
 #  Enabled: false
 #
 #RSpec/ExampleLength:
-#  Max: 50
+#  Max: 350
+#
+#RSpec/IndexedLet:
+#  Enabled: false
+#
+#RSpec/MultipleDescribes:
+#  Enabled: false
 #
 #RSpec/MultipleExpectations:
-#  Max: 15
+#  Max: 55
+#
+#RSpec/MultipleMemoizedHelpers:
+#  Max: 30
+#
+#RSpec/NoExpectationExample:
+#  Enabled: false
+#
+#RSpec/VerifiedDoubles:
+#  Enabled: false

data/CHANGELOG.md

@@ -1,3 +1,6 @@
+### 0.8.15 / 2025-02-28
+- [FIX] Re-styled spec files
+
 ### 0.8.14 / 2025-02-26
 - [FIX] Re-styled spec files of tutorial/iter4 folder
 

data/examples/general/calc_iter1/spec/calculator_spec.rb

@@ -33,39 +33,39 @@ describe 'Calculator' do
     return result
   end
 
-  it 'should evaluate simple number literals' do
+  it 'evaluates simple number literals' do
     expect_expr('2').to eq(2)
   end
 
-  it 'should evaluate addition' do
+  it 'evaluates addition' do
     expect_expr('2 + 2').to eq(4)
   end
 
-  it 'should evaluate subtraction' do
+  it 'evaluates subtraction' do
     expect_expr('2.1 - 2').to be_within(0.000000000000001).of(0.1)
   end
 
-  it 'should evaluate division' do
+  it 'evaluates division' do
     expect_expr('10.5 / 5').to eq(2.1)
   end
 
-  it 'should evaluate multiplication' do
+  it 'evaluates multiplication' do
     expect_expr('2 * 3.1').to eq(6.2)
   end
 
-  it 'should evaluate parentheses' do
+  it 'evaluates parentheses' do
     expect_expr('2 * (2.1 + 1)').to eq(6.2)
   end
 
-  it 'should evaluate regardless of whitespace' do
+  it 'evaluates regardless of whitespace' do
     expect_expr("2*(1+\t1)").to eq(4)
   end
 
-  it 'should evaluate order of operations' do
+  it 'evaluates order of operations' do
     expect_expr('2 * 2.1 + 1 / 2').to eq 4.7
   end
 
-  it 'should evaluate multiple levels of parentheses' do
+  it 'evaluates multiple levels of parentheses' do
     expect_expr('2*(1/(1+3))').to eq(0.5)
   end
 end # describe

data/examples/general/calc_iter2/spec/calculator_spec.rb

@@ -41,152 +41,152 @@ describe 'Calculator' do
   context 'Parsing valid expressions' do
     let(:epsilon) { 0.0000000001 }
 
-    it 'should evaluate simple integer literals' do
+    it 'evaluates simple integer literals' do
       expect_expr('2').to eq(2)
     end
 
-    it 'should evaluate simple floating-point literals' do
+    it 'evaluates simple floating-point literals' do
       expect_expr('3.1').to eq(3.1)
     end
 
-    it 'should evaluate positive integer literals' do
+    it 'evaluates positive integer literals' do
       expect_expr('+2').to eq(2)
       expect_expr('+ 2').to eq(2)
     end
 
-    it 'should evaluate positive floating-point literals' do
+    it 'evaluates positive floating-point literals' do
       expect_expr('+3.1').to eq(3.1)
       expect_expr('+ 3.1').to eq(3.1)
     end
 
-    it 'should evaluate negative integer literals' do
+    it 'evaluates negative integer literals' do
       expect_expr('-2').to eq(-2)
       expect_expr('- 2').to eq(-2)
     end
 
-    it 'should evaluate negative floating-point literals' do
+    it 'evaluates negative floating-point literals' do
       expect_expr('-3.1').to eq(-3.1)
       expect_expr('- 3.1').to eq(-3.1)
     end
 
-    it 'should evaluate the pi constant' do
+    it 'evaluates the pi constant' do
       expect_expr('PI').to eq(3.141592653589793)
     end
 
-    it 'should evaluate the negated pi constant' do
+    it 'evaluates the negated pi constant' do
       expect_expr('-PI').to eq(-3.141592653589793)
     end
 
-    it "should evaluate Neper's e constant" do
+    it "evaluates Neper's e constant" do
       expect_expr('E').to eq(2.718281828459045)
     end
 
-    it "should evaluate negated Neper's e constant" do
+    it "evaluates negated Neper's e constant" do
       expect_expr('-E').to eq(-2.718281828459045)
     end
 
-    it 'should evaluate integer addition' do
+    it 'evaluates integer addition' do
       expect_expr('2 + 2').to eq(4)
     end
 
-    it 'should evaluate floating-point addition' do
+    it 'evaluates floating-point addition' do
       expect_expr('2.0 + 3.1').to eq(5.1)
     end
 
-    it 'should evaluate integer subtraction' do
+    it 'evaluates integer subtraction' do
       expect_expr('2 - 3').to eq(-1)
     end
 
-    it 'should evaluate floating-point subtraction' do
+    it 'evaluates floating-point subtraction' do
       expect_expr('3.1 - 2').to eq(1.1)
     end
 
-    it 'should handle negation of negative numbers' do
+    it 'handles negation of negative numbers' do
        expect_expr('3--2').to eq(5)
     end
 
-    it 'should evaluate integer multiplication' do
+    it 'evaluates integer multiplication' do
       expect_expr('2 * 3').to eq(6)
     end
 
-    it 'should evaluate floating-point multiplication' do
+    it 'evaluates floating-point multiplication' do
       expect_expr('2 * 3.1').to eq(6.2)
     end
 
-    it 'should evaluate division of integers' do
+    it 'evaluates division of integers' do
       expect_expr('5 / 2').to eq(2.5)
     end
 
-    it 'should evaluate floating-point division' do
+    it 'evaluates floating-point division' do
       expect_expr('10.5 / 5').to eq(2.1)
     end
 
-    it 'should evaluate integer exponent' do
+    it 'evaluates integer exponent' do
       expect_expr('5 ** (3 - 1)').to eq(25)
     end
 
-    it 'should evaluate floating-point exponent' do
+    it 'evaluates floating-point exponent' do
       expect_expr('25 ** 0.5').to eq(5)
     end
 
-    it 'should evaluate negative exponent' do
+    it 'evaluates negative exponent' do
       expect_expr('5 ** -2').to eq(0.04)
     end
 
-    it 'should handle nested exponentiations' do
+    it 'handles nested exponentiations' do
       expect_expr('2 ** 2**2').to eq(16)
     end
 
-    it 'should change sign of expression in parentheses' do
+    it 'changes sign of expression in parentheses' do
       expect_expr('- (2 * 5)').to eq(-10)
     end
 
-    it 'should evaluate parentheses' do
+    it 'evaluates parentheses' do
       expect_expr('2 * (2.1 + 1)').to eq(6.2)
     end
 
-    it 'should evaluate regardless of whitespace' do
+    it 'evaluates regardless of whitespace' do
       expect_expr("2*(1+\t1)").to eq(4)
     end
 
-    it 'should evaluate order of operations' do
+    it 'evaluates order of operations' do
       expect_expr('2 * 2.1 + 1 / 2').to eq 4.7
     end
 
-    it 'should evaluate multiple levels of parentheses' do
+    it 'evaluates multiple levels of parentheses' do
       expect_expr('2*(1/(1+3))').to eq(0.5)
     end
 
     # Some special functions
-    it 'should evaluate square root of expressions' do
+    it 'evaluates square root of expressions' do
       expect_expr('sqrt(0)').to eq(0)
       expect_expr('sqrt(1)').to eq(1)
       expect_expr('sqrt(1 + 1)').to eq(Math.sqrt(2))
       expect_expr('sqrt(5 * 5)').to eq(5)
     end
 
-    it 'should evaluate cubic root of expressions' do
+    it 'evaluates cubic root of expressions' do
       expect_expr('cbrt(0)').to eq(0)
       expect_expr('cbrt(1)').to eq(1)
       expect_expr('cbrt(1 + 1)').to eq(Math.cbrt(2))
       expect_expr('cbrt(5 * 5 * 5)').to eq(5)
     end
 
-    it 'should evaluate exponential of expressions' do
+    it 'evaluates exponential of expressions' do
       expect_expr('exp(-1)').to eq(1 / Math::E)
       expect_expr('exp(0)').to eq(1)
       expect_expr('exp(1)').to eq(Math::E)
       expect_expr('exp(2)').to be_within(epsilon).of(Math::E * Math::E)
     end
 
-    it 'should evaluate natural logarithm of expressions' do
+    it 'evaluates natural logarithm of expressions' do
       expect_expr('ln(1/E)').to eq(-1)
       expect_expr('ln(1)').to eq(0)
       expect_expr('ln(E)').to eq(1)
       expect_expr('ln(E * E)').to eq(2)
     end
 
-    it 'should evaluate the logarithm base 10 of expressions' do
+    it 'evaluates the logarithm base 10 of expressions' do
       expect_expr('log(1/10)').to eq(-1)
       expect_expr('log(1)').to eq(0)
       expect_expr('log(10)').to eq(1)
@@ -195,19 +195,19 @@ describe 'Calculator' do
 
     # Trigonometric functions
 
-    it 'should compute the sinus of an expression' do
+    it 'computes the sinus of an expression' do
       expect_expr('sin(0)').to eq(0)
       expect_expr('sin(PI/6)').to be_within(epsilon).of(0.5)
       expect_expr('sin(PI/2)').to eq(1)
     end
 
-    it 'should compute the cosinus of an expression' do
+    it 'computes the cosinus of an expression' do
       expect_expr('cos(0)').to eq(1)
       expect_expr('cos(PI/3)').to be_within(epsilon).of(0.5)
       expect_expr('cos(PI/2)').to be_within(epsilon).of(0)
     end
 
-    it 'should compute the tangent of an expression' do
+    it 'computes the tangent of an expression' do
       expect_expr('tan(0)').to eq(0)
       expect_expr('tan(PI/4)').to be_within(epsilon).of(1)
       expect_expr('tan(5*PI/12)').to be_within(epsilon).of(2 + Math.sqrt(3))
@@ -215,19 +215,19 @@ describe 'Calculator' do
 
     # Inverse trigonometric functions
 
-    it 'should compute the arcsinus of an expression' do
+    it 'computes the arcsinus of an expression' do
       expect_expr('asin(0)').to eq(0)
       expect_expr('asin(0.5)').to be_within(epsilon).of(Math::PI / 6)
       expect_expr('asin(1)').to eq(Math::PI / 2)
     end
 
-    it 'should compute the arccosinus of an expression' do
+    it 'computes the arccosinus of an expression' do
       expect_expr('acos(1)').to eq(0)
       expect_expr('acos(0.5)').to be_within(epsilon).of(Math::PI / 3)
       expect_expr('acos(0)').to be_within(epsilon).of(Math::PI / 2)
     end
 
-    it 'should compute the tangent of an expression' do
+    it 'computes the arctangent of an expression' do
       expect_expr('atan(0)').to eq(0)
       pi = Math::PI
       expect_expr('atan(1)').to be_within(epsilon).of(pi / 4)

data/examples/general/recursive_right.rb

@@ -143,7 +143,7 @@ find every scan edge
 def build_gfg(aGrammar)
   items_builder = Object.new.extend(Rley::Base::GrmItemsBuilder)
   items = items_builder.build_dotted_items(aGrammar)
-  gfg = Rley::GFG::GrmFlowGraph.new(items)
+  Rley::GFG::GrmFlowGraph.new(items)
 end
 
 graph = build_gfg(right_recursive_grammar)
@@ -326,7 +326,7 @@ module GraphMixin
 
   # visit_action takes two arguments: a vertex and an edge
   # return true/false if false stop traversal
-  def df_traversal(aVertex, &visit_action)
+  def df_traversal(aVertex, &_visit_action)
     visit = [aVertex]
     vtx2count = { aVertex => 0 }
 

data/lib/rley/constants.rb

@@ -5,7 +5,7 @@
 
 module Rley # Module used as a namespace
   # The version number of the gem.
-  Version = '0.8.14'
+  Version = '0.8.15'
 
   # Brief description of the gem.
   Description = "Ruby implementation of the Earley's parsing algorithm"

data/lib/rley/gfg/grm_flow_graph.rb

@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 
-require 'set'
 require_relative 'start_vertex'
 require_relative 'end_vertex'
 require_relative 'item_vertex'

data/lib/rley/parser/parse_entry_set.rb

@@ -1,7 +1,6 @@
 # frozen_string_literal: true
 
 require 'forwardable' # For the Delegation pattern
-require 'set'
 
 require_relative '../syntax/terminal'
 require_relative '../syntax/non_terminal'

data/lib/rley/parser/parse_walker_factory.rb

@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 
-require 'set'
 require_relative '../gfg/call_edge'
 require_relative '../gfg/scan_edge'
 require_relative '../gfg/epsilon_edge'

data/lib/rley/rgn/grammar_builder.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require 'set'
-
 require_relative 'parser'
 require_relative 'ast_visitor'
 require_relative '../syntax/match_closest'

data/lib/rley/rgn/tokenizer.rb

@@ -41,7 +41,7 @@ module Rley
         '?' => 'QUESTION_MARK',
         '*' => 'STAR',
         '..' => 'ELLIPSIS'
-      }
+      }.freeze
 
       # Here are all the implemented Rley notation keywords
       @@keywords = %w[

data/lib/rley/syntax/base_grammar_builder.rb

@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 
-require 'set'
 require_relative 'terminal'
 require_relative 'non_terminal'
 require_relative 'production'

data/lib/rley/syntax/grammar.rb

@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 
-require 'set'
 require_relative '../rley_error'
 
 module Rley # This module is used as a namespace

data/spec/rley/base/dotted_item_spec.rb

@@ -27,126 +27,126 @@ module Rley # Open this namespace to avoid module qualifier prefixes
       let(:empty_prod) { build_prod(nt_sentence) }
 
       # Default instantiation rule
-      subject { DottedItem.new(sample_prod, 1) }
+      subject(:an_item) { described_class.new(sample_prod, 1) }
 
       context 'Initialization:' do
-        it 'should be created with a production and an index' do
-          expect { DottedItem.new(sample_prod, 0) }.not_to raise_error
-          expect { DottedItem.new(sample_prod, 3) }.not_to raise_error
+        it 'is created with a production and an index' do
+          expect { described_class.new(sample_prod, 0) }.not_to raise_error
+          expect { described_class.new(sample_prod, 3) }.not_to raise_error
         end
 
-        it 'should complain when the index is out-of-bounds' do
+        it 'complains when the index is out-of-bounds' do
           err = StandardError
           msg = 'Out of bound index'
-          expect { DottedItem.new(sample_prod, 4) }.to raise_error(err, msg)
+          expect { described_class.new(sample_prod, 4) }.to raise_error(err, msg)
         end
 
-        it 'should know its production' do
-          expect(subject.production).to eq(sample_prod)
+        it 'knows its production' do
+          expect(an_item.production).to eq(sample_prod)
         end
 
-        it 'should know the lhs of the production' do
-          expect(subject.lhs).to eq(sample_prod.lhs)
+        it 'knows the lhs of the production' do
+          expect(an_item.lhs).to eq(sample_prod.lhs)
         end
 
-        it 'should know its position' do
+        it 'knows its position' do
           # At start position
-          instance1 = DottedItem.new(sample_prod, 0)
+          instance1 = described_class.new(sample_prod, 0)
           expect(instance1.position).to eq(0)
 
           # At (before) last symbol
-          instance2 = DottedItem.new(sample_prod, 2)
+          instance2 = described_class.new(sample_prod, 2)
           expect(instance2.position).to eq(2)
 
           # After all symbols in rhs
-          instance3 = DottedItem.new(sample_prod, 3)
+          instance3 = described_class.new(sample_prod, 3)
           expect(instance3.position).to eq(-1)
 
           # At start/end at the same time (production is empty)
-          instance4 = DottedItem.new(build_prod(nt_sentence), 0)
+          instance4 = described_class.new(build_prod(nt_sentence), 0)
           expect(instance4.position).to eq(-2)
         end
       end # context
 
       context 'Provided service:' do
-        it 'should whether its dot is at start position' do
-          expect(subject).not_to be_at_start
+        it 'knows whether its dot is at start position' do
+          expect(an_item).not_to be_at_start
 
           # At start position
-          instance1 = DottedItem.new(sample_prod, 0)
+          instance1 = described_class.new(sample_prod, 0)
           expect(instance1).to be_at_start
 
           # At start/end at the same time (production is empty)
-          instance2 = DottedItem.new(build_prod(nt_sentence), 0)
+          instance2 = described_class.new(build_prod(nt_sentence), 0)
           expect(instance2).to be_at_start
         end
 
-        it 'should whether it is a reduce item' do
-          expect(subject).not_to be_reduce_item
+        it 'knows whether it is a reduce item' do
+          expect(an_item).not_to be_reduce_item
 
-          first_instance = DottedItem.new(sample_prod, 3)
+          first_instance = described_class.new(sample_prod, 3)
           expect(first_instance).to be_reduce_item
 
-          second_instance = DottedItem.new(empty_prod, 0)
+          second_instance = described_class.new(empty_prod, 0)
           expect(second_instance).to be_reduce_item
         end
 
-        it 'should know the symbol before the dot' do
-          expect(subject.prev_symbol).to eq(t_a)
+        it 'knows the symbol before the dot' do
+          expect(an_item.prev_symbol).to eq(t_a)
 
           # Case of an empty production
-          instance = DottedItem.new(empty_prod, 0)
+          instance = described_class.new(empty_prod, 0)
           expect(instance.prev_symbol).to be_nil
 
           # Case of a dot at start position
-          instance = DottedItem.new(sample_prod, 0)
+          instance = described_class.new(sample_prod, 0)
           expect(instance.prev_symbol).to be_nil
         end
 
-        it 'should know the symbol after the dot' do
-          expect(subject.next_symbol).to eq(t_b)
+        it 'knows the symbol after the dot' do
+          expect(an_item.next_symbol).to eq(t_b)
         end
 
-        it 'should calculate the previous position of the dot' do
-          expect(subject.prev_position).to eq(0)
+        it 'calculates the previous position of the dot' do
+          expect(an_item.prev_position).to eq(0)
 
           # Case of an empty production
-          instance = DottedItem.new(empty_prod, 0)
+          instance = described_class.new(empty_prod, 0)
           expect(instance.prev_position).to be_nil
 
           # Case of a dot at start position
-          instance = DottedItem.new(sample_prod, 0)
+          instance = described_class.new(sample_prod, 0)
           expect(instance.prev_position).to be_nil
 
           # Case of single symbol production
-          instance = DottedItem.new(other_prod, 1)
+          instance = described_class.new(other_prod, 1)
           expect(instance.prev_position).to eq(0)
         end
 
-        it 'should determine if it is a successor of another dotted item' do
-          expect(subject).not_to be_successor_of(subject)
+        it 'determines if it is a successor of another dotted item' do
+          expect(an_item).not_to be_successor_of(an_item)
 
           # Case: different productions
-          instance = DottedItem.new(empty_prod, 0)
-          expect(subject).not_to be_successor_of(instance)
+          instance = described_class.new(empty_prod, 0)
+          expect(an_item).not_to be_successor_of(instance)
 
           # Case: one position difference
-          instance = DottedItem.new(sample_prod, 0)
-          expect(subject).to be_successor_of(instance)
-          expect(instance).not_to be_successor_of(subject)
+          instance = described_class.new(sample_prod, 0)
+          expect(an_item).to be_successor_of(instance)
+          expect(instance).not_to be_successor_of(an_item)
 
           # Case: more than one position difference
-          instance2 = DottedItem.new(sample_prod, 2)
+          instance2 = described_class.new(sample_prod, 2)
           expect(instance).not_to be_successor_of(instance2)
-          expect(subject).not_to be_successor_of(instance2)
-          expect(instance2).to be_successor_of(subject)
+          expect(an_item).not_to be_successor_of(instance2)
+          expect(instance2).to be_successor_of(an_item)
         end
 
 
 
-        it 'should give its text representation' do
+        it 'gives its text representation' do
           expectation = 'sentence => A . B C'
-          expect(subject.to_s).to eq(expectation)
+          expect(an_item.to_s).to eq(expectation)
         end
       end
     end # describe

data/spec/rley/base/grm_items_builder_spec.rb

@@ -21,7 +21,7 @@ module Rley # Open this namespace to avoid module qualifier prefixes
       end
 
       context 'Builder pattern behaviour' do
-        it 'should create dotted items for a grammar' do
+        it 'creates dotted items for a grammar' do
           # Next line calls method from mixin module under test
           items = build_dotted_items(grammar_abc)
           expect(items.size).to eq(8)