zenlish 0.2.05 → 0.2.07

data/spec/zenlish/inflect/inflection_table_spec.rb

@@ -19,27 +19,30 @@ require_relative '../../../lib/zenlish/inflect/inflection_table'
 
 module Zenlish
   module Inflect
+    # rubocop: disable Naming/VariableNumber
+
     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      
+      end # context
 
       context 'Provided services:' do
         # DecisionTable: Common_form
@@ -77,32 +80,31 @@ module Zenlish
         let(:a_wclass) { WClasses::CommonNoun.new }
         let(:a_lemma) { 'body' }
         let(:an_entry) { Lex::LexicalEntry.new(a_lemma) }
-        let(:lexm_body) { Lex::Lexeme.new(a_wclass, an_entry) }       
-        
-        MockFeatureBearer = 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)
+        let(:lexm_body) { Lex::Lexeme.new(a_wclass, an_entry) }
+        let(:mock_feature_bearer) { Struct.new(:NUMBER, :base_form) }
+
+        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)
           aTable.add_heading(heading0)
           aTable.add_heading(heading1)
           aTable.add_rule(rule_a)
           aTable.add_rule(rule_b)
-          aTable.add_rule(rule_c)        
+          aTable.add_rule(rule_c)
         end
 
         # DecisionTable: Common_form
@@ -118,27 +120,28 @@ 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)
-          mck_1 = MockFeatureBearer.new(:singular, 'animal')
-          expect(subject.inflect(mck_1, [nil, nil])).to eq('animal')
-          mck_1['NUMBER'] = :plural
-          expect(subject.inflect(mck_1, [nil, nil])).to eq('animals')
-
-          mck_2 = MockFeatureBearer.new(:singular, 'boy')
-          expect(subject.inflect(mck_2, [nil, nil])).to eq('boy')
-          mck_2['NUMBER'] = :plural
-          expect(subject.inflect(mck_2, [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')
+        it 'determines the word form given input entries' do
+          init_table(inflection)
+          mck1 = mock_feature_bearer.new(:singular, 'animal')
+          expect(inflection.inflect(mck1, [nil, nil])).to eq('animal')
+          mck1['NUMBER'] = :plural
+          expect(inflection.inflect(mck1, [nil, nil])).to eq('animals')
+
+          mck2 = mock_feature_bearer.new(:singular, 'boy')
+          expect(inflection.inflect(mck2, [nil, nil])).to eq('boy')
+          mck2['NUMBER'] = :plural
+          expect(inflection.inflect(mck2, [nil, nil])).to eq('boys')
+
+          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(['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
+    # rubocop: enable Naming/VariableNumber
   end # module
-end # module
+end # module

data/spec/zenlish/inflect/input_asis_spec.rb

@@ -13,38 +13,35 @@ 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
-        
-=begin
-
-=end        
       end # context
     end # describe
   end # module
-end # module
+end # module

data/spec/zenlish/inflect/literal_asis_spec.rb

@@ -6,26 +6,26 @@ 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
-          headings = double('fake-headings')        
+        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
   end # module
-end # module
+end # module

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
@@ -58,4 +59,4 @@ module Zenlish
       end # context
     end # describe
   end # module
-end # module
+end # module

data/spec/zenlish/inflect/membership_spec.rb

@@ -12,46 +12,47 @@ module Zenlish
   module Inflect
     describe Membership do
       let(:an_argument) { FormalArgument.new(1) }
-      let(:feat_val) { [:singular, :plural] }
-      subject { Membership.new(an_argument, feat_val) }
+      let(:feat_val) { %i[singular plural] }
+
+      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,31 +7,32 @@ 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'])
-        end        
+          allow(mocked).to receive(:base_form).and_return('cherry')
+          expect(heading.all_matches(mocked)).to eq(['cherry'])
+        end
       end # context
     end # describe
   end # module
-end # module
+end # module

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,12 +31,12 @@ 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
   end # module
-end # module
+end # module

data/spec/zenlish/inflect/unconditionally_true_spec.rb

@@ -7,22 +7,24 @@ 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
   end # module
-end # module
+end # module

data/spec/zenlish/lang/dictionary_spec.rb

@@ -7,26 +7,14 @@ require_relative '../../../lib/zenlish/lang/dictionary' # Load the class under t
 module Zenlish
   module Lang
     describe Dictionary do
-      subject { Dictionary }
+      subject(:dictionary) { described_class }
 
       context 'Provided services:' do
         let(:common_nouns) do
           # Some Zenlish common nouns
-          %w( animal body container here kind machine moment now part people
-              person place side surface thing time word)
+          %w(animal body container here kind machine moment now part people
+            person place side surface thing time word)
         end
-
-        it 'should give the list of common nouns' do
-          lexemes = []
-          subject.entries.each do |ent|
-            lexm = ent.lexemes.select { |lx| lx.wclass.kind_of?(Zenlish::WClasses::CommonNoun) }
-            lexemes.concat(lexm) if lexm
-          end
-          lemmas = lexemes.map { |lx| lx.entry.lemma }
-
-          expect(common_nouns.all? { |c_n| lemmas.include?(c_n) }).to be_truthy
-        end
-
         let(:present_1sg)     { [:first,  :singular, :present, nil] }
         let(:present_2sg)     { [:second, :singular, :present, nil] }
         let(:present_3sg)     { [:third,  :singular, :present, nil] }
@@ -45,9 +33,19 @@ module Zenlish
           end
         end
 
-        it 'should know how to inflect an (irregular) verb' do
-          lexm = subject.get_lexeme('become')
-          expectations_1 = [
+        it 'gives the list of common nouns' do
+          lexemes = []
+          dictionary.entries.each do |ent|
+            lexm = ent.lexemes.select { |lx| lx.wclass.kind_of?(Zenlish::WClasses::CommonNoun) }
+            lexemes.concat(lexm) if lexm
+          end
+          lemmas = lexemes.map { |lx| lx.entry.lemma }
+          expect(common_nouns.all? { |c_n| lemmas.include?(c_n) }).to be_truthy
+        end
+
+        it 'knows how to inflect an (irregular) verb' do
+          lexm = dictionary.get_lexeme('become')
+          expectations1 = [
             [present_1sg,     'become'],
             [present_3sg,     'becomes'],
             [present_1pl,     'become'],
@@ -55,10 +53,10 @@ module Zenlish
             [past_simple,     'became'],
             [past_participle, 'become']
           ]
-          test_inflection_of(lexm, expectations_1)
+          test_inflection_of(lexm, expectations1)
 
-          lexm = subject.get_lexeme('do', WClasses::IrregularVerbDo)
-          expectations_2 = [
+          lexm = dictionary.get_lexeme('do', WClasses::IrregularVerbDo)
+          expectations2 = [
             [present_1sg,     'do'],
             [present_3sg,     'does'],
             [present_1pl,     'do'],
@@ -66,10 +64,10 @@ module Zenlish
             [past_simple,     'did'],
             [past_participle, 'done']
           ]
-          test_inflection_of(lexm, expectations_2, true)
+          test_inflection_of(lexm, expectations2, true)
 
-          lexm = subject.get_lexeme('have', WClasses::IrregularVerbHave)
-          expectations_3 = [
+          lexm = dictionary.get_lexeme('have', WClasses::IrregularVerbHave)
+          expectations3 = [
             [present_1sg,     'have'],
             [present_3sg,     'has'],
             [present_1pl,     'have'],
@@ -77,13 +75,13 @@ module Zenlish
             [past_simple,     'had'],
             [past_participle, 'had']
           ]
-          test_inflection_of(lexm, expectations_3, true)
+          test_inflection_of(lexm, expectations3, true)
         end
 
-        it 'should know how to inflect the verb be' do
+        it 'knows how to inflect the verb be' do
           [WClasses::IrregularVerbBe, WClasses::AuxiliaryBe].each do |wclass|
-            lexm = subject.get_lexeme('be', wclass)
-            expectations_1 = [
+            lexm = dictionary.get_lexeme('be', wclass)
+            expectations1 = [
               [present_1sg,     'am'],
               [present_2sg,     'are'],
               [present_3sg,     'is'],
@@ -95,11 +93,10 @@ module Zenlish
               [past_simple_1pl, 'were'],
               [past_participle, 'been']
             ]
-            test_inflection_of(lexm, expectations_1, true)
+            test_inflection_of(lexm, expectations1, true)
           end
         end
-
       end # context
     end # describe
   end # module
-end # module
+end # module