zenlish 0.2.05 → 0.2.07

data/spec/zenlish/feature/symbol_value_spec.rb

@@ -2,22 +2,23 @@
 
 require_relative '../../../lib/zenlish/feature/enumeration_domain'
 # Load the class under test
-require_relative '../../../lib/zenlish/feature/symbol_value' 
+require_relative '../../../lib/zenlish/feature/symbol_value'
 
 module Zenlish
   module Feature
     describe SymbolValue do
       let(:its_value) { :plural }
-      subject { SymbolValue.new(its_value) }
+
+      subject(:symbolic) { described_class.new(its_value) }
 
       context 'Initialization:' do
-        it 'should be initialized with a value argument' do
-          expect { SymbolValue.new(its_value) }.not_to raise_error
+        it 'is initialized with a value argument' do
+          expect { described_class.new(its_value) }.not_to raise_error
+        end
+
+        it 'knows its internal value' do
+          expect(symbolic.val).to eq(its_value)
         end
-        
-        it 'should know its internal value' do
-          expect(subject.val).to eq(its_value)
-        end        
       end # context
 
       context 'Provided services:' do

data/spec/zenlish/inflect/concatenation_spec.rb

@@ -11,30 +11,30 @@ module Zenlish
       let(:suffix) { LiteralAsIs.new('s') }
       let(:sample_argument) { FormalArgument.new(2) }
       let(:base_form) { InputAsIs.new(sample_argument) }
-      
-      subject { Concatenation.new(base_form, suffix) }
+
+      subject(:concatenation) { described_class.new(base_form, suffix) }
 
       context 'Initialization:' do
-        it 'should be initialized with two arguments' do
-          expect { Concatenation.new(base_form, suffix) }.not_to raise_error
+        it 'is initialized with two arguments' do
+          expect { described_class.new(base_form, suffix) }.not_to raise_error
         end
-        
-        it 'should know its arguments' do
-          expect(subject.children.first).to eq(base_form)
-          expect(subject.children.last).to eq(suffix)          
+
+        it 'knows its arguments' do
+          expect(concatenation.children.first).to eq(base_form)
+          expect(concatenation.children.last).to eq(suffix)
         end
       end # context
 
       context 'Provided services:' do
-        let(:sample_values) { [nil, nil, 'place', nil] } 
-        
-        it 'should do the concatenation of children results' do
+        let(:sample_values) { [nil, nil, 'place', nil] }
+
+        it 'concatenates children results' do
           headings = double('fake-headings')
           lexeme = double('fake-lexeme')
-          
-          expect(subject.generate(headings, lexeme, sample_values)).to eq('places')
+
+          expect(concatenation.generate(headings, lexeme, sample_values)).to eq('places')
         end
       end # context
     end # describe
   end # module
-end # module
+end # module

data/spec/zenlish/inflect/equals_literal_spec.rb

@@ -13,44 +13,45 @@ module Zenlish
     describe EqualsLiteral do
       let(:an_argument) { FormalArgument.new(1) }
       let(:feat_val) { :plural }
-      subject { EqualsLiteral.new(an_argument, feat_val) }
+
+      subject(:literal) { described_class.new(an_argument, feat_val) }
 
       context 'Initialization:' do
-        it 'should be initialized with a formal argument and a literal' do
-          expect { EqualsLiteral.new(an_argument, feat_val) }.not_to raise_error
+        it 'is initialized with a formal argument and a literal' do
+          expect { described_class.new(an_argument, feat_val) }.not_to raise_error
         end
 
-        it 'should know its argument' do
-          expect(subject.argument).to eq(an_argument)
+        it 'knows its argument' do
+          expect(literal.argument).to eq(an_argument)
         end
 
-        it 'should know the literal' do
-          expect(subject.literal).to eq(feat_val)
+        it 'knows the literal' do
+          expect(literal.literal).to eq(feat_val)
         end
       end # context
 
       context 'Provided services:' do
-        it 'should test the actual argument' do
+        it 'tests the actual argument' do
           lexeme = double('dummy-lexeme')
           headings = double('fake-headings')
           actual_args = [nil, :plural, nil]
-          expect(subject.success?(headings, lexeme, actual_args)).to be_truthy
+          expect(literal).to be_success(headings, lexeme, actual_args)
           actual_args[1] = :singular
-          expect(subject.success?(headings, lexeme, actual_args)).to be_falsy
+          expect(literal).not_to be_success(headings, lexeme, actual_args)
         end
 
-        it 'should test the lexeme' do
+        it 'tests the lexeme' do
           c_noun = WClasses::CommonNoun.new
           entry = Lex::LexicalEntry.new('animal')
           lexeme = Lex::Lexeme.new(c_noun, entry)
           headings = [nil, FeatureHeading.new('NUMBER'), nil]
-          expect(subject.success?(headings, lexeme, [])).to be_truthy
+          expect(literal).to be_success(headings, lexeme, [])
 
-          instance = EqualsLiteral.new(an_argument, :singular)
-          expect(instance.success?(headings, lexeme, [])).to be_truthy
+          instance = described_class.new(an_argument, :singular)
+          expect(instance).to be_success(headings, lexeme, [])
 
-          instance = EqualsLiteral.new(an_argument, :irregular)
-          expect(instance.success?(headings, lexeme, [])).to be_falsey
+          instance = described_class.new(an_argument, :irregular)
+          expect(instance).not_to be_success(headings, lexeme, [])
         end
       end # context
     end # describe

data/spec/zenlish/inflect/feature_heading_spec.rb

@@ -6,45 +6,46 @@ require_relative '../../../lib/zenlish/inflect/feature_heading'
 module Zenlish
   module Inflect
     describe FeatureHeading do
-      let(:feature_name) { 'NUMBER' }     
-      subject { FeatureHeading.new(feature_name) }
+      let(:feature_name) { 'NUMBER' }
+
+      subject(:ft_heading) { described_class.new(feature_name) }
 
       context 'Initialization:' do
-        it 'should be initialized with a feature name' do
-          expect { FeatureHeading.new(feature_name) }.not_to raise_error
+        it 'is initialized with a feature name' do
+          expect { described_class.new(feature_name) }.not_to raise_error
         end
-        
-        it 'should know its label' do
-          expect(subject.label).to eq(feature_name)
+
+        it 'knows its label' do
+          expect(ft_heading.label).to eq(feature_name)
         end
       end # context
 
       context 'Provided services:' do
         let(:a_domain) { Feature::EnumerationDomain.new(:singular, :plural) }
         let(:enum_def) { Feature::FeatureDef.new(feature_name, a_domain) }
-        let(:b_domain) { Feature::BooleanDomain.instance }        
+        let(:b_domain) { Feature::BooleanDomain.instance }
         let(:bool_def) { Feature::FeatureDef.new(feature_name, b_domain) }
-        
-        it 'should obtain the value of a feature' do
+
+        it 'obtains the value of a feature' do
           mocked = { 'NUMBER' => :plural }
-          expect(subject.evaluate_for(mocked)).to eq(:plural)
+          expect(ft_heading.evaluate_for(mocked)).to eq(:plural)
         end
-        
-        it 'should obtain all possible values of a feature' do
+
+        it 'obtains all possible values of a feature' do
           mocked = { 'NUMBER' => :plural }
-          expect(subject.all_matches(mocked)).to eq([:plural])
+          expect(ft_heading.all_matches(mocked)).to eq([:plural])
         end
 
-        it 'should obtain all possible values of a enumeration domain' do
+        it 'obtains all possible values of a enumeration domain' do
           mocked = { 'NUMBER' => enum_def }
-          expect(subject.all_matches(mocked)).to eq([:singular, :plural])
-        end 
+          expect(ft_heading.all_matches(mocked)).to eq(%i[singular plural])
+        end
 
-        it 'should obtain all possible values of a enumeration domain' do
+        it 'obtains all possible values of a enumeration domain' do
           mocked = { 'NUMBER' => bool_def }
-          expect(subject.all_matches(mocked)).to eq([false, true])
-        end        
+          expect(ft_heading.all_matches(mocked)).to eq([false, true])
+        end
       end # context
     end # describe
   end # module
-end # module
+end # module

data/spec/zenlish/inflect/formal_argument_spec.rb

@@ -6,15 +6,15 @@ require_relative '../../../lib/zenlish/inflect/formal_argument'
 module Zenlish
   module Inflect
     describe FormalArgument do
-      subject { FormalArgument.new(3) }
+      subject(:arg) { described_class.new(3) }
 
       context 'Initialization:' do
-        it 'should be initialized with a text literal' do
-          expect { FormalArgument.new(1) }.not_to raise_error
+        it 'is initialized with a text literal' do
+          expect { described_class.new(1) }.not_to raise_error
         end
-        
-        it 'should know its index value' do
-          expect(subject.index).to eq(3)
+
+        it 'knows its index value' do
+          expect(arg.index).to eq(3)
         end
       end # context
 
@@ -22,4 +22,4 @@ module Zenlish
       end # context
     end # describe
   end # module
-end # module
+end # module

data/spec/zenlish/inflect/function_call_spec.rb

@@ -1,32 +1,31 @@
 # frozen_string_literal: true
 
-require 'ostruct'
 # Load the class under test
 require_relative '../../../lib/zenlish/inflect/function_call'
 
 module Zenlish
   module Inflect
     describe FunctionCall do
-      subject { FunctionCall.new('greet') }
+      subject(:func_call) { described_class.new('greet') }
 
       context 'Initialization:' do
-        it 'should be initialized with a text literal' do
-          expect { FunctionCall.new('greet') }.not_to raise_error
+        it 'is initialized with a text literal' do
+          expect { described_class.new('greet') }.not_to raise_error
         end
-        
-        it 'should know its method name' do
-          expect(subject.mth_name).to eq('greet')
+
+        it 'knows its method name' do
+          expect(func_call.mth_name).to eq('greet')
         end
       end # context
 
       context 'Provided services:' do
-        it 'should return the affix during word form generation' do
-          headings = double('fake-headings')        
-          lexeme = OpenStruct.new(:greet => 'Hello, world')
+        it 'returns the affix during word form generation' do
+          headings = double('fake-headings')
+          lexeme = double('fake-lexeme', greet: 'Hello, world')
           values = double('fake-values')
-          expect(subject.generate(headings, lexeme, values)).to eq('Hello, world')
+          expect(func_call.generate(headings, lexeme, values)).to eq('Hello, world')
         end
       end # context
     end # describe
   end # module
-end # module
+end # module

data/spec/zenlish/inflect/inflection_rule_spec.rb

@@ -17,6 +17,8 @@ require_relative '../../../lib/zenlish/inflect/inflection_rule'
 
 module Zenlish
   module Inflect
+    # rubocop: disable Naming/VariableNumber
+
     describe InflectionRule do
       # One rule in row representation:
       # | plural   | ~ /[^aeiouy]y$/ | sub(base_form, /y$/, "ies")|
@@ -26,7 +28,7 @@ module Zenlish
       let(:method_name) { 'base_form' }
       let(:heading1) { MethodHeading.new(method_name) }
       let(:headings) { [heading0, heading1] }
-      
+
       # Condition part
       let(:feature_value) { :plural }
       let(:arg_0) { FormalArgument.new(0) }
@@ -42,20 +44,21 @@ module Zenlish
       let(:pattern) { /y$/ }
       let(:consequent) { Substitution.new(base, pattern, suffix) }
 
-      subject { InflectionRule.new(conditions, consequent) }
+      subject(:i_rule) { described_class.new(conditions, consequent) }
 
       context 'Initialization:' do
-        it 'should be initialized with condition and consequent parts' do
-          expect { InflectionRule.new(conditions, consequent)
-            }.not_to raise_error
+        it 'is initialized with condition and consequent parts' do
+          expect do
+            described_class.new(conditions, consequent)
+          end.not_to raise_error
         end
 
-        it 'should know its condition part' do
-          expect(subject.conditions).to eq(conditions)
+        it 'knows its condition part' do
+          expect(i_rule.conditions).to eq(conditions)
         end
 
-        it 'should know its consequent part' do
-          expect(subject.consequent).to eq(consequent)
+        it 'knows its consequent part' do
+          expect(i_rule.consequent).to eq(consequent)
         end
       end # context
 
@@ -65,38 +68,39 @@ module Zenlish
         let(:an_entry) { Lex::LexicalEntry.new('cherry') }
         let(:lexeme) { Lex::Lexeme.new(c_noun, an_entry) }
 
-        it 'should succeed when all conditions succeed with actuals' do
+        it 'succeeds when all conditions succeed with actuals' do
           actuals = [:plural, 'cherry']
-          expect(subject.success?(headings, fake_lexeme, actuals)).to be_truthy
+          expect(i_rule).to be_success(headings, fake_lexeme, actuals)
         end
 
-        it 'should fail when one condition fails with actuals' do
+        it 'fails when one condition fails with actuals' do
           actuals = [:singular, 'cherry']
-          expect(subject.success?(headings, fake_lexeme, actuals)).to be_falsy
+          expect(i_rule).not_to be_success(headings, fake_lexeme, actuals)
 
           actuals = [:plural, 'girl']
-          expect(subject.success?(headings, fake_lexeme, actuals)).to be_falsy
+          expect(i_rule).not_to be_success(headings, fake_lexeme, actuals)
         end
 
-        it 'should generate inflected form when rule iworks for actuals' do
+        it 'generates inflected form when rule iworks for actuals' do
           actuals = [:plural, 'cherry']
-          expect(subject.apply(headings, fake_lexeme, actuals)).to eq('cherries')
+          expect(i_rule.apply(headings, fake_lexeme, actuals)).to eq('cherries')
         end
-        
-        it 'should succeed when all conditions succeed for given lexeme' do
-          expect(subject.success?(headings, lexeme, [])).to be_truthy
+
+        it 'succeeds when all conditions succeed for given lexeme' do
+          expect(i_rule).to be_success(headings, lexeme, [])
         end
 
-        it 'should fail when one condition fails with given lexeme' do
+        it 'fails when one condition fails with given lexeme' do
           entry_2 = Lex::LexicalEntry.new('animal')
           lex_m2 = Lex::Lexeme.new(c_noun, entry_2)
-          expect(subject.success?(headings, lex_m2, [])).to be_falsy
+          expect(i_rule).not_to be_success(headings, lex_m2, [])
         end
 
-        it 'should generate inflected form when rule works for given lexeme' do
-          expect(subject.apply(headings, lexeme, [])).to eq('cherries')
-        end        
+        it 'generates inflected form when rule works for given lexeme' do
+          expect(i_rule.apply(headings, lexeme, [])).to eq('cherries')
+        end
       end # context
     end # describe
+    # rubocop: enable Naming/VariableNumber
   end # module
 end # module

data/spec/zenlish/inflect/inflection_table_builder_spec.rb

@@ -5,36 +5,39 @@ require_relative '../../../lib/zenlish/inflect/inflection_table_builder'
 
 module Zenlish
   module Inflect
+    # rubocop: disable Layout/SpaceInsideParens
+    # rubocop: disable Naming/VariableNumber
+
     describe InflectionTableBuilder do
-      subject { InflectionTableBuilder.new }
+      subject(:builder) { described_class.new }
 
       context 'Initialization:' do
-        it 'should be initialized without argument' do
-          expect { InflectionTableBuilder.new }.not_to raise_error
+        it 'is initialized without argument' do
+          expect { described_class.new }.not_to raise_error
         end
 
-        it 'should not have headings after initialization' do
-          expect(subject.headings).to be_empty
+        it "doesn't not have headings after initialization" do
+          expect(builder.headings).to be_empty
         end
       end # context
 
       context 'Basic services:' do
-        it 'should retain the table name' do
-          subject.build('Common_form')
-          expect(subject.table.name).to eq('Common_form')
+        it 'retains the table name' do
+          builder.build('Common_form')
+          expect(builder.table.name).to eq('Common_form')
         end
 
-        it 'should accept heading creation' do
+        it 'accepts heading creation' do
           # First way
-          subject.feature_heading 'NUMBER'
-          expect(subject.headings.size).to eq(1)
-          expect(subject.headings.last.label).to eq('NUMBER')
-          subject.method_heading 'base_form'
-          expect(subject.headings.last).to be_kind_of(MethodHeading)
-          expect(subject.headings.last.label).to eq('base_form')
+          builder.feature_heading 'NUMBER'
+          expect(builder.headings.size).to eq(1)
+          expect(builder.headings.last.label).to eq('NUMBER')
+          builder.method_heading 'base_form'
+          expect(builder.headings.last).to be_a(MethodHeading)
+          expect(builder.headings.last.label).to eq('base_form')
 
           # Second way
-          table = subject.build('Common_form') do
+          table = builder.build('Common_form') do
             feature_heading 'NUMBER'
             method_heading 'base_form'
           end
@@ -44,8 +47,10 @@ module Zenlish
       end # context
 
       context 'Table building:' do
-        it 'should be able to build consequents' do
-          table = subject.build('Common_form') do
+        let(:mock_feature_bearer) { Struct.new(:NUMBER, :base_form) }
+
+        it 'is able to build consequents' do
+          table = builder.build('Common_form') do
             feature_heading 'NUMBER'
             method_heading 'base_form'
             rule([], col('base_form'))
@@ -54,23 +59,23 @@ module Zenlish
           end
           expect(table.rules).not_to be_empty
           consequent_0 = table.rules[0].consequent
-          expect(consequent_0).to be_kind_of(InputAsIs)
+          expect(consequent_0).to be_a(InputAsIs)
           expect(consequent_0.formal.index).to eq(1)
 
           consequent_1 = table.rules[1].consequent
-          expect(consequent_1).to be_kind_of(Substitution)
+          expect(consequent_1).to be_a(Substitution)
           expect(consequent_1.children[0].formal.index).to eq(1)
           expect(consequent_1.pattern).to eq(/y$/)
           expect(consequent_1.children[-1].text).to eq('ies')
 
           consequent_2 = table.rules[2].consequent
           expect(consequent_2.children[0].formal.index).to eq(1)
-          expect(consequent_2).to be_kind_of(Concatenation)
+          expect(consequent_2).to be_a(Concatenation)
           expect(consequent_2.children[-1].text).to eq('s')
         end
 
-        it 'should be able to build conditions' do
-          table = subject.build('Common_form') do
+        it 'is able to build conditions' do
+          table = builder.build('Common_form') do
             feature_heading 'NUMBER'
             method_heading 'base_form'
             rule([equals(:singular), dont_care], col('base_form'))
@@ -79,26 +84,24 @@ module Zenlish
           end
 
           conds_0 = table.rules[0].conditions
-          expect(conds_0[0]).to be_kind_of(EqualsLiteral)
+          expect(conds_0[0]).to be_a(EqualsLiteral)
           expect(conds_0[0].literal).to eq(:singular)
-          expect(conds_0[1]).to be_kind_of(UnconditionallyTrue)
+          expect(conds_0[1]).to be_a(UnconditionallyTrue)
 
           conds_1 = table.rules[1].conditions
-          expect(conds_1[0]).to be_kind_of(EqualsLiteral)
+          expect(conds_1[0]).to be_a(EqualsLiteral)
           expect(conds_1[0].literal).to eq(:plural)
-          expect(conds_1[1]).to be_kind_of(MatchesPattern)
+          expect(conds_1[1]).to be_a(MatchesPattern)
           expect(conds_1[1].pattern).to eq(/[^aeiouy]y$/)
 
           conds_2 = table.rules[2].conditions
-          expect(conds_2[0]).to be_kind_of(EqualsLiteral)
+          expect(conds_2[0]).to be_a(EqualsLiteral)
           expect(conds_2[0].literal).to eq(:plural)
-          expect(conds_2[1]).to be_kind_of(UnconditionallyTrue)
+          expect(conds_2[1]).to be_a(UnconditionallyTrue)
         end
 
-        MockFeatureBearer = Struct.new(:NUMBER, :base_form)
-
-        it 'should build default paradigm for common nouns' do
-          table = subject.build('Common_form') do
+        it 'builds default paradigm for common nouns' do
+          table = builder.build('Common_form') do
             feature_heading 'NUMBER'
             method_heading 'base_form'
             rule([equals(:singular), dont_care], col('base_form'))
@@ -106,25 +109,25 @@ module Zenlish
             rule([equals(:plural), dont_care], concat(col('base_form'), 's'))
           end
 
-          mck_1 = MockFeatureBearer.new(:singular, 'animal')
+          mck_1 = mock_feature_bearer.new(:singular, 'animal')
           expect(table.inflect(mck_1, [nil, nil])).to eq('animal')
           mck_1['NUMBER'] = :plural
           expect(table.inflect(mck_1, [nil, nil])).to eq('animals')
 
-          mck_2 = MockFeatureBearer.new(:singular, 'boy')
+          mck_2 = mock_feature_bearer.new(:singular, 'boy')
           expect(table.inflect(mck_2, [nil, nil])).to eq('boy')
           mck_2['NUMBER'] = :plural
           expect(table.inflect(mck_2, [nil, nil])).to eq('boys')
 
-          mck_3 = MockFeatureBearer.new(:singular, 'body')
+          mck_3 = mock_feature_bearer.new(:singular, 'body')
           expect(table.inflect(mck_3, [nil, nil])).to eq('body')
           mck_3['NUMBER'] = :plural
           expect(table.inflect(mck_3, [nil, nil])).to eq('bodies')
         end
-        
+
         MockRegularVerb = Struct.new(:base_form, :PERSON, :NUMBER, :TIME)
-        it 'should build default paradigm for regular verbs' do
-          table = subject.build('Regular_form') do
+        it 'builds default paradigm for regular verbs' do
+          table = builder.build('Regular_form') do
             feature_heading 'PERSON'
             feature_heading 'NUMBER'
             feature_heading 'TIME'
@@ -132,15 +135,15 @@ module Zenlish
             #     PERSON             NUMBER             TIME                         base_form
             rule([not_equal(:third), dont_care,         equals(:present),            dont_care], col('base_form'))
             rule([equals(:third),    equals(:singular), equals(:present),            matches(/[^aeiouy]y$/)], sub(col('base_form'), /y$/, 'ies'))
-            rule([equals(:third),    equals(:singular), equals(:present),            matches(/(?:[osxz]|ch|sh)$/)], concat(col('base_form'), 'es'))             
-            rule([equals(:third),    equals(:singular), equals(:present),            dont_care], concat(col('base_form'), 's'))         
-            rule([dont_care,         dont_care, equals(:progressive),                matches(/e$/)], sub(col('base_form'), /e$/, 'ing'))            
+            rule([equals(:third),    equals(:singular), equals(:present),            matches(/(?:[osxz]|ch|sh)$/)], concat(col('base_form'), 'es'))
+            rule([equals(:third),    equals(:singular), equals(:present),            dont_care], concat(col('base_form'), 's'))
+            rule([dont_care,         dont_care, equals(:progressive),                matches(/e$/)], sub(col('base_form'), /e$/, 'ing'))
             rule([dont_care,         dont_care, equals(:progressive),                dont_care], concat(col('base_form'), 'ing'))
-            rule([dont_care,         dont_care, in?(:past_simple, :past_participle), matches(/e$/)], concat(col('base_form'), 'd'))             
-            rule([dont_care,         dont_care, in?(:past_simple, :past_participle), matches(/[^aeiouy]y$/)], sub(col('base_form'), /y$/, 'ied'))            
+            rule([dont_care,         dont_care, in?(:past_simple, :past_participle), matches(/e$/)], concat(col('base_form'), 'd'))
+            rule([dont_care,         dont_care, in?(:past_simple, :past_participle), matches(/[^aeiouy]y$/)], sub(col('base_form'), /y$/, 'ied'))
             rule([dont_care,         dont_care, in?(:past_simple, :past_participle), dont_care], concat(col('base_form'), 'ed'))
           end
-          
+
           verb_1 = MockRegularVerb.new('belong', :first, :singular, :present)
           expect(table.inflect(verb_1, [nil,    nil,     nil, nil]             )).to eq('belong')
           expect(table.inflect(verb_1, [:third, nil,     nil, nil]             )).to eq('belongs')
@@ -148,7 +151,7 @@ module Zenlish
           expect(table.inflect(verb_1, [nil,    nil,     :progressive, nil]    )).to eq('belonging')
           expect(table.inflect(verb_1, [nil,    nil,     :past_simple, nil]    )).to eq('belonged')
           expect(table.inflect(verb_1, [nil,    nil,     :past_participle, nil])).to eq('belonged')
-          
+
           verb_2 = MockRegularVerb.new('try', :first, :singular, :present)
           expect(table.inflect(verb_2, [nil,    nil,     nil, nil]             )).to eq('try')
           expect(table.inflect(verb_2, [:third, nil,     nil, nil]             )).to eq('tries')
@@ -158,7 +161,7 @@ module Zenlish
           expect(table.inflect(verb_2, [nil,    nil,     :past_participle, nil])).to eq('tried')
 
           verb_3 = MockRegularVerb.new('touch', :first, :singular, :present)
-          expect(table.inflect(verb_3, [:second,nil,     nil, nil]             )).to eq('touch')
+          expect(table.inflect(verb_3, [:second, nil,    nil, nil]             )).to eq('touch')
           expect(table.inflect(verb_3, [:third, nil,     nil, nil]             )).to eq('touches')
           expect(table.inflect(verb_3, [nil,    :plural, nil, nil]             )).to eq('touch')
           expect(table.inflect(verb_3, [nil,    nil,     :progressive, nil]    )).to eq('touching')
@@ -171,12 +174,12 @@ module Zenlish
           expect(table.inflect(verb_4, [nil,    :plural, nil, nil]             )).to eq('cause')
           expect(table.inflect(verb_4, [nil,    nil,     :progressive, nil]    )).to eq('causing')
           expect(table.inflect(verb_4, [nil,    nil,     :past_simple, nil]    )).to eq('caused')
-          expect(table.inflect(verb_4, [nil,    nil,     :past_participle, nil])).to eq('caused')          
+          expect(table.inflect(verb_4, [nil,    nil,     :past_participle, nil])).to eq('caused')
         end
-        
+
         MockIrregularVerb = Struct.new(:base_form, :PERSON, :NUMBER, :TIME, :past_simple, :past_participle)
-        it 'should build default paradigm for irregular verbs' do
-          table = subject.build('Irregular_inflection') do
+        it 'builds default paradigm for irregular verbs' do
+          table = builder.build('Irregular_inflection') do
             feature_heading 'PERSON'
             feature_heading 'NUMBER'
             feature_heading 'TIME'
@@ -184,12 +187,12 @@ module Zenlish
             #     PERSON             NUMBER             TIME                      base_form
             rule([not_equal(:third), dont_care,         equals(:present),         dont_care], col('base_form'))
             rule([equals(:third),    equals(:singular), equals(:present),         matches(/[^aeiouy]y$/)], sub(col('base_form'), /y$/, 'ies'))
-            rule([equals(:third),    equals(:singular), equals(:present),         matches(/(?:[osxz]|ch|sh)$/)], concat(col('base_form'), 'es'))             
-            rule([equals(:third),    equals(:singular), equals(:present),         dont_care], concat(col('base_form'), 's'))         
-            rule([dont_care,         dont_care,         equals(:progressive),     matches(/e$/)], sub(col('base_form'), /e$/, 'ing'))            
+            rule([equals(:third),    equals(:singular), equals(:present),         matches(/(?:[osxz]|ch|sh)$/)], concat(col('base_form'), 'es'))
+            rule([equals(:third),    equals(:singular), equals(:present),         dont_care], concat(col('base_form'), 's'))
+            rule([dont_care,         dont_care,         equals(:progressive),     matches(/e$/)], sub(col('base_form'), /e$/, 'ing'))
             rule([dont_care,         dont_care,         equals(:progressive),     dont_care], concat(col('base_form'), 'ing'))
-            rule([dont_care,         dont_care,         equals(:past_simple),     dont_care], func('past_simple'))             
-            rule([dont_care,         dont_care,         equals(:past_participle), dont_care], func('past_participle'))                       
+            rule([dont_care,         dont_care,         equals(:past_simple),     dont_care], func('past_simple'))
+            rule([dont_care,         dont_care,         equals(:past_participle), dont_care], func('past_participle'))
           end
 
           verb_1 = MockIrregularVerb.new('choose', :first, :singular, :present, 'chose', 'chosen')
@@ -202,5 +205,7 @@ module Zenlish
         end
       end # context
     end # describe
+    # rubocop: enable Naming/VariableNumber
+    # rubocop: enable  Layout/SpaceInsideParens
   end # module
-end # module
+end # module