zenlish 0.2.06 → 0.2.07

data/spec/zenlish/inflect/inflection_table_builder_spec.rb

@@ -9,35 +9,35 @@ module Zenlish
     # 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
@@ -47,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'))
@@ -57,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'))
@@ -82,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
 
-        let(:mock_feature_bearer) { 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'))
@@ -126,8 +126,8 @@ module Zenlish
         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'
@@ -178,8 +178,8 @@ module Zenlish
         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'

data/spec/zenlish/inflect/inflection_table_spec.rb

@@ -23,23 +23,24 @@ module Zenlish
 
     describe InflectionTable do
       let(:table_name) { 'Common_form' }
-      subject { InflectionTable.new(table_name) }
+
+      subject(:inflection) { described_class.new(table_name) }
 
       context 'Initialization:' do
-        it 'should be initialized with a name' do
-          expect { InflectionTable.new(table_name) }.not_to raise_error
+        it 'is initialized with a name' do
+          expect { described_class.new(table_name) }.not_to raise_error
         end
 
-        it 'should now its name' do
-          expect(subject.name).to eq(table_name)
+        it 'knows its name' do
+          expect(inflection.name).to eq(table_name)
         end
 
-        it 'should not have headings at start' do
-          expect(subject.headings).to be_empty
+        it "doesn't have headings at start" do
+          expect(inflection.headings).to be_empty
         end
 
-        it 'should not have rules at start' do
-          expect(subject.rules).to be_empty
+        it "doesn't not have rules at start" do
+          expect(inflection.rules).to be_empty
         end
       end # context
 
@@ -82,20 +83,20 @@ module Zenlish
         let(:lexm_body) { Lex::Lexeme.new(a_wclass, an_entry) }
         let(:mock_feature_bearer) { Struct.new(:NUMBER, :base_form) }
 
-        it 'should accept the addition of heading(s)' do
-          expect { subject.add_heading(heading0) }.not_to raise_error
-          expect(subject.headings.size).to eq(1)
-          subject.add_heading(heading1)
-          expect(subject.headings.last).to eq(heading1)
+        it 'accepts the addition of heading(s)' do
+          expect { inflection.add_heading(heading0) }.not_to raise_error
+          expect(inflection.headings.size).to eq(1)
+          inflection.add_heading(heading1)
+          expect(inflection.headings.last).to eq(heading1)
         end
 
-        it 'should accept the addition of rule(s)' do
-          expect { subject.add_rule(rule_a) }.not_to raise_error
-          expect(subject.rules.size).to eq(1)
-          subject.add_rule(rule_b)
-          expect(subject.rules.last).to eq(rule_b)
-          subject.add_rule(rule_c)
-          expect(subject.rules.last).to eq(rule_c)
+        it 'accepts the addition of rule(s)' do
+          expect { inflection.add_rule(rule_a) }.not_to raise_error
+          expect(inflection.rules.size).to eq(1)
+          inflection.add_rule(rule_b)
+          expect(inflection.rules.last).to eq(rule_b)
+          inflection.add_rule(rule_c)
+          expect(inflection.rules.last).to eq(rule_c)
         end
 
         def init_table(aTable)
@@ -119,25 +120,25 @@ module Zenlish
         #   rule(equals(:plural)  , matches(/[^aeiouy]y$/), sub(col(1), /y$/, 'ies'))
         #   rule(equals(:plural)  , dont_care             , concat(col(1), 's'))
         # end
-        it 'should determine the word form given input entries' do
-          init_table(subject)
+        it 'determines the word form given input entries' do
+          init_table(inflection)
           mck1 = mock_feature_bearer.new(:singular, 'animal')
-          expect(subject.inflect(mck1, [nil, nil])).to eq('animal')
+          expect(inflection.inflect(mck1, [nil, nil])).to eq('animal')
           mck1['NUMBER'] = :plural
-          expect(subject.inflect(mck1, [nil, nil])).to eq('animals')
+          expect(inflection.inflect(mck1, [nil, nil])).to eq('animals')
 
           mck2 = mock_feature_bearer.new(:singular, 'boy')
-          expect(subject.inflect(mck2, [nil, nil])).to eq('boy')
+          expect(inflection.inflect(mck2, [nil, nil])).to eq('boy')
           mck2['NUMBER'] = :plural
-          expect(subject.inflect(mck2, [nil, nil])).to eq('boys')
+          expect(inflection.inflect(mck2, [nil, nil])).to eq('boys')
 
-          expect(subject.inflect(lexm_body, [:singular, nil])).to eq('body')
-          expect(subject.inflect(lexm_body, [:plural, nil])).to eq('bodies')
+          expect(inflection.inflect(lexm_body, [:singular, nil])).to eq('body')
+          expect(inflection.inflect(lexm_body, [:plural, nil])).to eq('bodies')
         end
 
-        it 'should know all the word forms of a given lexeme' do
-          init_table(subject)
-          expect(subject.all_inflections(lexm_body)).to eq(%w[body bodies])
+        it 'knows all the word forms of a given lexeme' do
+          init_table(inflection)
+          expect(inflection.all_inflections(lexm_body)).to eq(%w[body bodies])
         end
       end # context
     end # describe

data/spec/zenlish/inflect/input_asis_spec.rb

@@ -13,32 +13,33 @@ module Zenlish
     describe InputAsIs do
       let(:sample_argument) { FormalArgument.new(2) }
       let(:sample_values) { [nil, nil, 'Hello, world.', nil] }
-      subject { InputAsIs.new(sample_argument) }
+
+      subject(:input) { described_class.new(sample_argument) }
 
       context 'Initialization:' do
-        it 'should be initialized with a formal rgument' do
-          expect { InputAsIs.new(sample_argument) }.not_to raise_error
+        it 'is initialized with a formal rgument' do
+          expect { described_class.new(sample_argument) }.not_to raise_error
         end
 
-        it 'should know its text value' do
-          expect(subject.formal).to eq(sample_argument)
+        it 'knows its text value' do
+          expect(input.formal).to eq(sample_argument)
         end
       end # context
 
       context 'Provided services:' do
-        it 'should return the text of given argument during generation' do
+        it 'returns the text of given argument during generation' do
           lexeme = double('fake-lexeme')
           headings = double('fake-headings')
-          expect(subject.generate(headings, lexeme, sample_values)).to eq('Hello, world.')
+          expect(input.generate(headings, lexeme, sample_values)).to eq('Hello, world.')
         end
 
-        it 'should return the text of given lexeme during generation' do
+        it 'returns the text of given lexeme during generation' do
           c_noun = WClasses::CommonNoun.new
           an_entry = Lex::LexicalEntry.new('cherry')
           lexeme = Lex::Lexeme.new(c_noun, an_entry)
           heading = MethodHeading.new('base_form')
           headings = [nil, nil, heading, nil]
-          expect(subject.generate(headings, lexeme, [])).to eq('cherry')
+          expect(input.generate(headings, lexeme, [])).to eq('cherry')
         end
       end # context
     end # describe

data/spec/zenlish/inflect/literal_asis_spec.rb

@@ -6,24 +6,24 @@ require_relative '../../../lib/zenlish/inflect/literal_asis'
 module Zenlish
   module Inflect
     describe LiteralAsIs do
-      subject { LiteralAsIs.new('s') }
+      subject(:literal) { described_class.new('s') }
 
       context 'Initialization:' do
-        it 'should be initialized with a text literal' do
-          expect { LiteralAsIs.new('s') }.not_to raise_error
+        it 'is initialized with a text literal' do
+          expect { described_class.new('s') }.not_to raise_error
         end
 
-        it 'should know its text value' do
-          expect(subject.text).to eq('s')
+        it 'knows its text value' do
+          expect(literal.text).to eq('s')
         end
       end # context
 
       context 'Provided services:' do
-        it 'should return the affix during word form generation' do
+        it 'returns the affix during word form generation' do
           headings = double('fake-headings')
           lexeme = double('fake-lexeme')
           values = double('fake-values')
-          expect(subject.generate(headings, lexeme, values)).to eq('s')
+          expect(literal.generate(headings, lexeme, values)).to eq('s')
         end
       end # context
     end # describe

data/spec/zenlish/inflect/matches_pattern_spec.rb

@@ -13,44 +13,45 @@ module Zenlish
     describe MatchesPattern do
       let(:an_argument) { FormalArgument.new(1) }
       let(:patt) { /[^aeiouy]y$/ }
-      subject { MatchesPattern.new(an_argument, patt) }
+
+      subject(:pattern) { described_class.new(an_argument, patt) }
 
       context 'Initialization:' do
-        it 'should be initialized with an argument and pattern' do
-          expect { MatchesPattern.new(an_argument, patt) }.not_to raise_error
+        it 'is initialized with an argument and pattern' do
+          expect { described_class.new(an_argument, patt) }.not_to raise_error
         end
 
-        it 'should know its argument' do
-          expect(subject.argument).to eq(an_argument)
+        it 'knows its argument' do
+          expect(pattern.argument).to eq(an_argument)
         end
 
-        it 'should know the pattern' do
-          expect(subject.pattern).to eq(patt)
+        it 'knows the pattern' do
+          expect(pattern.pattern).to eq(patt)
         end
       end # context
 
       context 'Provided services:' do
-        it 'should check the actual argument' do
+        it 'checks the actual argument' do
           lexeme = double('dummy-lexeme')
           headings = double('fake-headings')
           actual_args = [nil, 'cherry', nil]
-          expect(subject.success?(headings, lexeme, actual_args)).to be_truthy
+          expect(pattern).to be_success(headings, lexeme, actual_args)
           actual_args[1] = 'boy'
-          expect(subject.success?(headings, lexeme, actual_args)).to be_falsy
+          expect(pattern).not_to be_success(headings, lexeme, actual_args)
           actual_args[1] = 'girl'
-          expect(subject.success?(headings, lexeme, actual_args)).to be_falsy
+          expect(pattern).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('cherry')
           lexeme = Lex::Lexeme.new(c_noun, entry)
           headings = [nil, MethodHeading.new('lemma'), nil]
-          expect(subject.success?(headings, lexeme, [])).to be_truthy
+          expect(pattern).to be_success(headings, lexeme, [])
 
           entry2 = Lex::LexicalEntry.new('boy')
           lexeme2 = Lex::Lexeme.new(c_noun, entry2)
-          expect(subject.success?(headings, lexeme2, [])).to be_falsey
+          expect(pattern).not_to be_success(headings, lexeme2, [])
 
           # instance = EqualsLiteral.new(an_argument, :irregular)
           # expect(instance.success?(headings, lexeme, [])).to be_falsey

data/spec/zenlish/inflect/membership_spec.rb

@@ -13,45 +13,46 @@ module Zenlish
     describe Membership do
       let(:an_argument) { FormalArgument.new(1) }
       let(:feat_val) { %i[singular plural] }
-      subject { Membership.new(an_argument, feat_val) }
+
+      subject(:membership) { described_class.new(an_argument, feat_val) }
 
       context 'Initialization:' do
-        it 'should be initialized with a formal argument and an array' do
-          expect { Membership.new(an_argument, feat_val) }.not_to raise_error
+        it 'is initialized with a formal argument and an array' 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(membership.argument).to eq(an_argument)
         end
 
-        it 'should know the array of literals' do
-          expect(subject.members).to eq(feat_val)
+        it 'knows the array of literals' do
+          expect(membership.members).to eq(feat_val)
         end
       end # context
 
       context 'Provided services:' do
-        it 'should test the actual values' do
+        it 'tests the actual values' 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(membership).to be_success(headings, lexeme, actual_args)
           actual_args[1] = :singular
-          expect(subject.success?(headings, lexeme, actual_args)).to be_truthy
+          expect(membership).to be_success(headings, lexeme, actual_args)
           actual_args[1] = :dual
-          expect(subject.success?(headings, lexeme, actual_args)).to be_falsy
+          expect(membership).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(membership.success?(headings, lexeme, [])).to be_truthy
 
-          # instance = Membership.new(an_argument, :singular)
+          # instance = described_class.new(an_argument, :singular)
           # expect(instance.success?(headings, lexeme, [])).to be_truthy
 
-          # instance = Membership.new(an_argument, :irregular)
+          # instance = described_class.new(an_argument, :irregular)
           # expect(instance.success?(headings, lexeme, [])).to be_falsey
         # end
       end # context

data/spec/zenlish/inflect/method_heading_spec.rb

@@ -7,29 +7,30 @@ module Zenlish
   module Inflect
     describe MethodHeading do
       let(:method_name) { 'base_form' }
-      subject { MethodHeading.new(method_name) }
+
+      subject(:heading) { described_class.new(method_name) }
 
       context 'Initialization:' do
-        it 'should be initialized with a method name' do
-          expect { MethodHeading.new(method_name) }.not_to raise_error
+        it 'is initialized with a method name' do
+          expect { described_class.new(method_name) }.not_to raise_error
         end
 
-        it 'should know its label' do
-          expect(subject.label).to eq(method_name)
+        it 'knows its label' do
+          expect(heading.label).to eq(method_name)
         end
       end # context
 
       context 'Provided services:' do
-        it 'should obtain the method result from a word' do
+        it 'obtains the method result from a word' do
           mocked = double('dummy-lexeme')
-          expect(mocked).to receive(:base_form).and_return('cherry')
-          expect(subject.evaluate_for(mocked)).to eq('cherry')
+          allow(mocked).to receive(:base_form).and_return('cherry')
+          expect(heading.evaluate_for(mocked)).to eq('cherry')
         end
 
-        it 'should obtain the method result as an array' do
+        it 'obtains the method result as an array' do
           mocked = double('dummy-lexeme')
-          expect(mocked).to receive(:base_form).and_return('cherry')
-          expect(subject.all_matches(mocked)).to eq(['cherry'])
+          allow(mocked).to receive(:base_form).and_return('cherry')
+          expect(heading.all_matches(mocked)).to eq(['cherry'])
         end
       end # context
     end # describe

data/spec/zenlish/inflect/not_equals_literal_spec.rb

@@ -13,44 +13,45 @@ module Zenlish
     describe NotEqualsLiteral do
       let(:an_argument) { FormalArgument.new(1) }
       let(:feat_val) { :plural }
-      subject { NotEqualsLiteral.new(an_argument, feat_val) }
+
+      subject(:literal) { described_class.new(an_argument, feat_val) }
 
       context 'Initialization:' do
-        it 'should be initialized with formal argument and a literal' do
-          expect { NotEqualsLiteral.new(an_argument, feat_val) }.not_to raise_error
+        it 'is initialized with 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_falsy
+          expect(literal).not_to be_success(headings, lexeme, actual_args)
           actual_args[1] = :singular
-          expect(subject.success?(headings, lexeme, actual_args)).to be_truthy
+          expect(literal).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_falsy
+          expect(literal).not_to be_success(headings, lexeme, [])
 
-          instance = NotEqualsLiteral.new(an_argument, :singular)
-          expect(instance.success?(headings, lexeme, [])).to be_falsy
+          instance = described_class.new(an_argument, :singular)
+          expect(instance).not_to be_success(headings, lexeme, [])
 
-          instance = NotEqualsLiteral.new(an_argument, :irregular)
-          expect(instance.success?(headings, lexeme, [])).to be_truthy
+          instance = described_class.new(an_argument, :irregular)
+          expect(instance).to be_success(headings, lexeme, [])
         end
       end # context
     end # describe

data/spec/zenlish/inflect/substitution_spec.rb

@@ -13,18 +13,17 @@ module Zenlish
       let(:base) { InputAsIs.new(sample_argument) }
       let(:pattern) { /y$/ }
 
-
-      subject { Substitution.new(base, pattern, suffix) }
+      subject(:substitution) { described_class.new(base, pattern, suffix) }
 
       context 'Initialization:' do
-        it 'should be initialized with two arguments' do
-          expect { Substitution.new(base, pattern, suffix) }.not_to raise_error
+        it 'is initialized with two arguments' do
+          expect { described_class.new(base, pattern, suffix) }.not_to raise_error
         end
 
-        it 'should know its arguments' do
-          expect(subject.children.first).to eq(base)
-          expect(subject.children[1]).to eq(pattern)
-          expect(subject.children.last).to eq(suffix)
+        it 'knows its arguments' do
+          expect(substitution.children.first).to eq(base)
+          expect(substitution.children[1]).to eq(pattern)
+          expect(substitution.children.last).to eq(suffix)
         end
       end # context
 
@@ -32,10 +31,10 @@ module Zenlish
         let(:sample_heading) { double('fake-headings') }
         let(:sample_values) { [nil, 'cherry', nil] }
 
-        it 'should do the concatenation of children results' do
+        it 'concatenates children results' do
           lexeme = double('fake-lexeme')
 
-          expect(subject.generate(sample_heading, lexeme, sample_values)).to eq('cherries')
+          expect(substitution.generate(sample_heading, lexeme, sample_values)).to eq('cherries')
         end
       end # context
     end # describe

data/spec/zenlish/inflect/unconditionally_true_spec.rb

@@ -7,20 +7,22 @@ module Zenlish
   module Inflect
     describe UnconditionallyTrue do
       let(:method_name) { 'base_form' }
-      subject { UnconditionallyTrue.new }
+
+      subject(:u_true) { described_class.new }
 
       context 'Initialization:' do
-        it 'should be initialized without argument' do
-          expect { UnconditionallyTrue.new }.not_to raise_error
+        it 'is initialized without argument' do
+          expect { described_class.new }.not_to raise_error
         end
       end # context
 
       context 'Provided services:' do
-        it 'should always return true' do
+        it 'always return true' do
           headings = double('dummy-headings')
           lexeme = double('dummy-lexeme')
           values = double('dummy-heading-values')
-          expect(subject.success?(headings, lexeme, values)).to be_truthy
+          # expect(u_true.success?(headings, lexeme, values)).to be_truthy
+          expect(u_true).to be_success(headings, lexeme, values)
         end
       end # context
     end # describe