zenlish 0.2.06 → 0.2.07

data/spec/zenlish/trie/trie_spec.rb

@@ -6,100 +6,100 @@ require_relative '../../../lib/zenlish/trie/trie' # Load the class under test
 module Zenlish
   module Trie
     describe Trie do
-      subject { Trie.new }
+      subject(:trie) { described_class.new }
 
       context 'Initialization:' do
-        it 'should be initialized without argument' do
-          expect { Trie.new }.not_to raise_error
+        it 'is initialized without argument' do
+          expect { described_class.new }.not_to raise_error
         end
 
-        it 'should be a leaf node at start' do
-          expect(subject.root).to be_kind_of(TrieRoot)
+        it 'is a leaf node at start' do
+          expect(trie.root).to be_a(TrieRoot)
         end
       end # context
 
       context 'Provided services:' do
-        it 'should accept the addition of one single node' do
-          expect { subject.add('a', 'OK') }.not_to raise_error
-          expect(subject.root.include?('a')).to be_truthy
-          expect(subject.root.succ['a']).to be_kind_of(TrieNode)
-          expect(subject.root.succ['a'].value).to eq('OK')
+        it 'accepts the addition of one single node' do
+          expect { trie.add('a', 'OK') }.not_to raise_error
+          expect(trie.root).to include('a')
+          expect(trie.root.succ['a']).to be_a(TrieNode)
+          expect(trie.root.succ['a'].value).to eq('OK')
         end
 
-        it 'should accept the addition of a node string' do
-          expect { subject.add('abc', 'OK') }.not_to raise_error
-          expect(subject.root.include?('a')).to be_truthy
-          expect(subject.root.include?('b')).to be_falsy
+        it 'accepts the addition of a node string' do
+          expect { trie.add('abc', 'OK') }.not_to raise_error
+          expect(trie.root).to include('a')
+          expect(trie.root).not_to include('b')
 
-          node_a = subject.root.succ['a']
-          expect(node_a).to be_kind_of(TrieNode)
+          node_a = trie.root.succ['a']
+          expect(node_a).to be_a(TrieNode)
           expect(node_a.value).to be_nil
-          expect(node_a.include?('b')).to be_truthy
-          expect(node_a.include?('c')).to be_falsy
+          expect(node_a).to include('b')
+          expect(node_a).not_to include('c')
 
           node_b = node_a.succ['b']
-          expect(node_b).to be_kind_of(TrieNode)
+          expect(node_b).to be_a(TrieNode)
           expect(node_b.value).to be_nil
-          expect(node_b.include?('c')).to be_truthy
+          expect(node_b).to include('c')
 
           node_c = node_b.succ['c']
-          expect(node_c).to be_kind_of(TrieNode)
+          expect(node_c).to be_a(TrieNode)
           expect(node_c.value).to eq('OK')
           expect(node_c).to be_leaf
         end
 
-        it 'should accept the addition of multiple node strings' do
-          subject.add('abc', 'ABC')
-          expect { subject.add('abe', 'ABE') }.not_to raise_error
-          root = subject.root
-          expect(root.include?('a')).to be_truthy
-          expect(root.include?('b')).to be_falsy
+        it 'accepts the addition of multiple node strings' do
+          trie.add('abc', 'ABC')
+          expect { trie.add('abe', 'ABE') }.not_to raise_error
+          root = trie.root
+          expect(root).to include('a')
+          expect(root).not_to include('b')
 
           node_a = root.succ['a']
 
           node_b = node_a.succ['b']
-          expect(node_b).to be_kind_of(TrieNode)
+          expect(node_b).to be_a(TrieNode)
           expect(node_b.value).to be_nil
-          expect(node_b.include?('c')).to be_truthy
-          expect(node_b.include?('e')).to be_truthy
+          expect(node_b).to include('c')
+          expect(node_b).to include('e')
 
           node_c = node_b.succ['c']
-          expect(node_c).to be_kind_of(TrieNode)
+          expect(node_c).to be_a(TrieNode)
           expect(node_c.value).to eq('ABC')
           expect(node_c).to be_leaf
 
           node_e = node_b.succ['e']
-          expect(node_e).to be_kind_of(TrieNode)
+          expect(node_e).to be_a(TrieNode)
           expect(node_e.value).to eq('ABE')
           expect(node_e).to be_leaf
         end
 
-        it 'should retrieve the node matching a given string' do
-          subject.add('abc', 'ABC')
-          subject.add('hello', 'WORLD')
-          subject.add('hellene', 'GREEK')
+        it 'retrieves the node matching a given string' do
+          trie.add('abc', 'ABC')
+          trie.add('hello', 'WORLD')
+          trie.add('hellene', 'GREEK')
 
-          hello_node = subject.search('hello')
+          hello_node = trie.search('hello')
           expect(hello_node.key).to eq('o')
           expect(hello_node.value).to eq('WORLD')
-          hellish = subject.search('hell')
+          hellish = trie.search('hell')
           expect(hellish.key).to eq('l')
           expect(hellish.value).to be_nil
-          expect(subject.search('greeting')).to be_nil
-          hellene_node = subject.search('hellene')
+          expect(trie.search('greeting')).to be_nil
+          hellene_node = trie.search('hellene')
           expect(hellene_node.key).to eq('e')
           expect(hellene_node.value).to eq('GREEK')
-          expect(subject.search('hellenes')).to be_nil
+          expect(trie.search('hellenes')).to be_nil
         end
 
-        it 'should accept the addition of "synonyms"' do
-          subject.add('abd', 'first')
-          subject.add('abduce', 'ABDUCE')
+        it 'accepts the addition of "synonyms"' do
+          trie.add('abd', 'first')
+          trie.add('abduce', 'ABDUCE')
 
-          abd_node = subject.search('abd')
+          abd_node = trie.search('abd')
           expect(abd_node.value).to eq('first')
 
-          subject.add('abd', 'second')
+          trie.add('abd', 'second')
           expect(abd_node.value).to eq(%w[first second])
         end
       end # context

data/spec/zenlish/wclasses/common_noun_spec.rb

@@ -7,24 +7,24 @@ require_relative '../../../lib/zenlish/wclasses/common_noun' # Load the class un
 module Zenlish
   module WClasses
     describe CommonNoun do
-      subject { CommonNoun.new }
+      subject(:noun) { described_class.new }
 
       context 'Initialization:' do
-        it 'should be initialized without argument' do
-          expect { CommonNoun.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 provide a default inflection paradigm' do
-          expect(subject.paradigm).not_to be_nil
+        it 'provides a default inflection paradigm' do
+          expect(noun.paradigm).not_to be_nil
         end
 
-        it 'should support the pluralization of common nouns' do
+        it 'supports the pluralization of common nouns' do
           samples = %w[animal body people]
           lexemes = []
           Lang::Dictionary.entries.each do |ent|
-            lexm = ent.lexemes.select { |lx| lx.wclass.kind_of?(Zenlish::WClasses::CommonNoun) }
+            lexm = ent.lexemes.select { |lx| lx.wclass.kind_of?(described_class) }
             if lexm && samples.include?(ent.lemma)
               lexemes.concat(lexm)
             end
@@ -38,11 +38,11 @@ module Zenlish
           end
         end
 
-        it 'should know all its inflections' do
+        it 'knows all its inflections' do
           samples = %w[animal body people]
           lexemes = []
           Lang::Dictionary.entries.each do |ent|
-            lexm = ent.lexemes.select { |lx| lx.wclass.kind_of?(Zenlish::WClasses::CommonNoun) }
+            lexm = ent.lexemes.select { |lx| lx.wclass.kind_of?(described_class) }
             if lexm && samples.include?(ent.lemma)
               lexemes.concat(lexm)
             end

data/spec/zenlish/wclasses/demonstrative_determiner_spec.rb

@@ -8,18 +8,18 @@ require_relative '../../../lib/zenlish/wclasses/demonstrative_determiner' # Load
 module Zenlish
   module WClasses
     describe DemonstrativeDeterminer do
-      subject { DemonstrativeDeterminer.new }
+      subject(:determiner) { described_class.new }
 
       context 'Initialization:' do
-        it 'should be initialized without argument' do
-          expect { DemonstrativeDeterminer.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
         def build_det(aBaseForm)
           entry = Zenlish::Lex::LexicalEntry.new(aBaseForm)
-          Zenlish::Lex::Lexeme.new(subject, entry)
+          Zenlish::Lex::Lexeme.new(determiner, entry)
         end
 
         def test_all_inflections(det_form, wforms)
@@ -28,17 +28,17 @@ module Zenlish
           expect(inflected.sort).to eq(wforms.sort)
         end
 
-        it 'should know that it is inflectable' do
-          expect(subject).not_to be_invariable
+        it 'knows that it is inflectable' do
+          expect(determiner).not_to be_invariable
         end
 
-        it 'should know its feature definitions' do
-          expect(subject['NUMBER']).to be_kind_of(Feature::FeatureDef)
-          expect(subject['DISTANCE']).to be_kind_of(Feature::FeatureDef)
-          expect(subject['PARADIGM'].default.val).to eq('Demonstrative_det_paradigm')
+        it 'knows its feature definitions' do
+          expect(determiner['NUMBER']).to be_a(Feature::FeatureDef)
+          expect(determiner['DISTANCE']).to be_a(Feature::FeatureDef)
+          expect(determiner['PARADIGM'].default.val).to eq('Demonstrative_det_paradigm')
         end
 
-        it 'should give all word forms' do
+        it 'gives all word forms' do
           test_all_inflections('this', %w[this that these those])
         end
       end # context

data/spec/zenlish/wclasses/irregular_verb_can_spec.rb

@@ -10,24 +10,24 @@ require_relative '../../../lib/zenlish/wclasses/irregular_verb_can'
 module Zenlish
   module WClasses
     describe IrregularVerbCan do
-      subject { IrregularVerbCan.new }
+      subject(:irreg_can) { described_class.new }
 
       context 'Initialization:' do
-        it 'should be initialized without argument' do
-          expect { IrregularVerbCan.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 know its inherited feature definitions' do
-          expect(subject['NUMBER']).to be_kind_of(Feature::FeatureDef)
-          expect(subject['PERSON']).to be_kind_of(Feature::FeatureDef)
-          expect(subject['PARADIGM'].default.val).to eq('Verb_can_inflection')
+        it 'knows its inherited feature definitions' do
+          expect(irreg_can['NUMBER']).to be_a(Feature::FeatureDef)
+          expect(irreg_can['PERSON']).to be_a(Feature::FeatureDef)
+          expect(irreg_can['PARADIGM'].default.val).to eq('Verb_can_inflection')
         end
 
         def build_verb(aBaseForm)
           entry = Zenlish::Lex::LexicalEntry.new(aBaseForm)
-          Zenlish::Lex::Lexeme.new(subject, entry)
+          Zenlish::Lex::Lexeme.new(irreg_can, entry)
         end
 
         def test_inflection_of(verb_form, pairs)
@@ -43,7 +43,7 @@ module Zenlish
           expect(inflected.sort).to eq(wforms.sort)
         end
 
-        it 'should know how to inflect modal verb can' do
+        it 'knows how to inflect modal verb can' do
           expectations1 = [
             [:present,     'can'],
             [:past_simple, 'could']
@@ -51,7 +51,7 @@ module Zenlish
           test_inflection_of('can', expectations1)
         end
 
-        it 'should give all word forms of a given verb' do
+        it 'gives all word forms of a given verb' do
           test_all_inflections('can', %w[can could])
         end
       end # context

data/spec/zenlish/wclasses/irregular_verb_extension_spec.rb

@@ -8,28 +8,28 @@ require_relative '../../../lib/zenlish/wclasses/irregular_verb_extension'
 module Zenlish
   module WClasses
     describe IrregularVerbExtension do
-      subject do
+      subject(:verb) do
         obj = Object.new
-        obj.extend(IrregularVerbExtension)
+        obj.extend(described_class)
         obj.init_extension(obj)
         obj
       end
 
       context 'Initialization:' do
-        it 'should mix-in with a host object' do
-          expect { Object.new.extend(IrregularVerbExtension) }.not_to raise_error
+        it 'allows mix-in with a host object' do
+          expect { Object.new.extend(described_class) }.not_to raise_error
         end
 
-        it 'should inject an instance variable' do
-          expect(subject.instance_variable_get(:@forms)).to be_kind_of(Array)
+        it 'injects an instance variable' do
+          expect(verb.instance_variable_get(:@forms)).to be_a(Array)
         end
       end # context
 
       context 'Provided services:' do
-        it 'should provide a write accessor' do
-          subject.forms past_simple: 'chose', past_participle: 'chosen'
-          expect(subject.past_simple).to eq('chose')
-          expect(subject.past_participle).to eq('chosen')
+        it 'provides a write accessor' do
+          verb.forms past_simple: 'chose', past_participle: 'chosen'
+          expect(verb.past_simple).to eq('chose')
+          expect(verb.past_participle).to eq('chosen')
         end
       end # context
     end # describe

data/spec/zenlish/wclasses/irregular_verb_spec.rb

@@ -10,31 +10,18 @@ require_relative '../../../lib/zenlish/wclasses/irregular_verb'
 module Zenlish
   module WClasses
     describe IrregularVerb do
-      subject { IrregularVerb.new }
+      subject(:verb) { described_class.new }
 
       context 'Initialization:' do
-        it 'should be initialized without argument' do
-          expect { IrregularVerb.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 know its inherited feature definitions' do
-          expect(subject['NUMBER']).to be_kind_of(Feature::FeatureDef)
-          expect(subject['PERSON']).to be_kind_of(Feature::FeatureDef)
-          expect(subject['PARADIGM'].default.val).to eq('Irregular_inflection')
-        end
-
-        let(:present_1sg) { [:first, :singular, :present, nil] }
-        let(:present_3sg) { [:third, :singular, :present, nil] }
-        let(:present_1pl) { [:first, :plural,   :present, nil] }
-        let(:progressive) { [nil,    nil,       :progressive, nil] }
-        let(:past_simple) { [nil,    nil,       :past_simple, nil] }
-        let(:past_participle) { [nil, nil,      :past_participle, nil] }
-
         def build_verb(aBaseForm, p_simple, p_participle)
           entry = Zenlish::Lex::LexicalEntry.new(aBaseForm)
-          lexeme = Zenlish::Lex::Lexeme.new(subject, entry)
+          lexeme = Zenlish::Lex::Lexeme.new(verb, entry)
           lexeme.forms past_simple: p_simple, past_participle: p_participle
           lexeme
         end
@@ -52,7 +39,20 @@ module Zenlish
           expect(inflected.sort).to eq(wforms.sort)
         end
 
-        it 'should know how to inflect irregular verbs' do
+        let(:present_1sg) { [:first, :singular, :present, nil] }
+        let(:present_3sg) { [:third, :singular, :present, nil] }
+        let(:present_1pl) { [:first, :plural,   :present, nil] }
+        let(:progressive) { [nil,    nil,       :progressive, nil] }
+        let(:past_simple) { [nil,    nil,       :past_simple, nil] }
+        let(:past_participle) { [nil, nil,      :past_participle, nil] }
+
+        it 'knows its inherited feature definitions' do
+          expect(verb['NUMBER']).to be_a(Feature::FeatureDef)
+          expect(verb['PERSON']).to be_a(Feature::FeatureDef)
+          expect(verb['PARADIGM'].default.val).to eq('Irregular_inflection')
+        end
+
+        it 'knows how to inflect irregular verbs' do
           expectations1 = [
             [present_1sg,     'see'],
             [present_3sg,     'sees'],
@@ -74,7 +74,7 @@ module Zenlish
           test_inflection_of('make', 'made', 'made', expectations2)
         end
 
-        it 'should give all word forms of a given verb' do
+        it 'gives all word forms of a given verb' do
           test_all_inflections('see', 'saw', 'seen', %w[see sees seeing saw seen])
         end
       end # context

data/spec/zenlish/wclasses/lexical_verb_spec.rb

@@ -15,19 +15,19 @@ module Zenlish
     end
 
     describe LexicalVerb do
-      subject { LexicalVerb.new }
+      subject(:verb) { described_class.new }
 
       context 'Initialization:' do
-        it 'should be initialized without argument' do
-          expect { LexicalVerb.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 know its inherited feature definitions' do
-          expect(subject['NUMBER']).to be_kind_of(Feature::FeatureDef)
-          expect(subject['PERSON']).to be_kind_of(Feature::FeatureDef)
-          expect(subject['PARADIGM'].default.val).to eq('Regular_inflection')
+        it 'knows its inherited feature definitions' do
+          expect(verb['NUMBER']).to be_a(Feature::FeatureDef)
+          expect(verb['PERSON']).to be_a(Feature::FeatureDef)
+          expect(verb['PARADIGM'].default.val).to eq('Regular_inflection')
         end
       end # context
     end # describe

data/spec/zenlish/wclasses/modal_verb_can_spec.rb

@@ -10,24 +10,24 @@ require_relative '../../../lib/zenlish/wclasses/modal_verb_can'
 module Zenlish
   module WClasses
     describe ModalVerbCan do
-      subject { ModalVerbCan.new }
+      subject(:modal_can) { described_class.new }
 
       context 'Initialization:' do
-        it 'should be initialized without argument' do
-          expect { ModalVerbCan.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 know its inherited feature definitions' do
-          expect(subject['NUMBER']).to be_kind_of(Feature::FeatureDef)
-          expect(subject['PERSON']).to be_kind_of(Feature::FeatureDef)
-          expect(subject['PARADIGM'].default.val).to eq('Verb_can_inflection')
+        it 'knows its inherited feature definitions' do
+          expect(modal_can['NUMBER']).to be_a(Feature::FeatureDef)
+          expect(modal_can['PERSON']).to be_a(Feature::FeatureDef)
+          expect(modal_can['PARADIGM'].default.val).to eq('Verb_can_inflection')
         end
 
         def build_verb(aBaseForm)
           entry = Zenlish::Lex::LexicalEntry.new(aBaseForm)
-          Zenlish::Lex::Lexeme.new(subject, entry)
+          Zenlish::Lex::Lexeme.new(modal_can, entry)
         end
 
         def test_inflection_of(verb_form, pairs)
@@ -37,7 +37,7 @@ module Zenlish
           end
         end
 
-        it 'should know how to inflect modal verb can' do
+        it 'knows how to inflect modal verb can' do
           expectations1 = [
             [:present,     'can'],
             [:past_simple, 'could']

data/spec/zenlish/wclasses/noun_spec.rb

@@ -6,23 +6,23 @@ require_relative '../../../lib/zenlish/wclasses/noun' # Load the class under tes
 module Zenlish
   module WClasses
     describe Noun do
-      subject { Noun.new }
+      subject(:noun) { described_class.new }
 
       context 'Initialization:' do
-        it 'should be initialized without argument' do
-          expect { Noun.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 know that it is variable (has inflected forms)' do
-          expect(subject).not_to be_invariable
+        it 'knows that it is variable (has inflected forms)' do
+          expect(noun).not_to be_invariable
         end
 
-        it 'should know its feature names' do
+        it 'knows its feature names' do
           expectations = %w(NUMBER COUNTABILITY)
           expectations.each do |name|
-            expect(subject[name]).not_to be_nil
+            expect(noun[name]).not_to be_nil
           end
         end
       end # context

data/spec/zenlish/wclasses/personal_pronoun_spec.rb

@@ -10,22 +10,22 @@ module Zenlish
   module WClasses
     describe PersonalPronoun do
       include Feature::FeatureStructDefBearer
-      subject { PersonalPronoun.new }
+      subject(:pronoun) { described_class.new }
 
       context 'Initialization:' do
-        it 'should be initialized without argument' do
-          expect { PersonalPronoun.new }.not_to raise_error
+        it 'is initialized without argument' do
+          expect { described_class.new }.not_to raise_error
         end
 
-        it 'should know that it is inflectable' do
-          expect(subject).not_to be_invariable
+        it 'knows that it is inflectable' do
+          expect(pronoun).not_to be_invariable
         end
       end # context
 
       context 'Provided services:' do
         def build_ppn(aBaseForm, aFeatureHash)
           entry = Zenlish::Lex::LexicalEntry.new(aBaseForm)
-          Zenlish::Lex::Lexeme.new(subject, entry, aFeatureHash)
+          Zenlish::Lex::Lexeme.new(pronoun, entry, aFeatureHash)
         end
 
         def test_all_inflections(det_form, aFeatureHash, wforms)
@@ -34,28 +34,28 @@ module Zenlish
           expect(inflected.sort).to eq(wforms.sort)
         end
 
-        it 'should know its feature definitions' do
-          expect(subject['NUMBER']).to be_kind_of(Feature::FeatureDef)
-          expect(subject['PERSON']).to be_kind_of(Feature::FeatureDef)
-          expect(subject['GENDER']).to be_kind_of(Feature::FeatureDef)
-          expect(subject['CASE']).to be_kind_of(Feature::FeatureDef)
-          expect(subject['PARADIGM'].default.val).to eq('ppn_1st_paradigm')
+        it 'knows its feature definitions' do
+          expect(pronoun['NUMBER']).to be_a(Feature::FeatureDef)
+          expect(pronoun['PERSON']).to be_a(Feature::FeatureDef)
+          expect(pronoun['GENDER']).to be_a(Feature::FeatureDef)
+          expect(pronoun['CASE']).to be_a(Feature::FeatureDef)
+          expect(pronoun['PARADIGM'].default.val).to eq('ppn_1st_paradigm')
         end
 
-        it 'should give all word forms for the first person' do
+        it 'gives all word forms for the first person' do
           feature_defs = { 'PERSON' => enumeration(:first),
             'GENDER' => enumeration(:feminine, :masculine) }
           test_all_inflections('I', feature_defs, %w[I we me us])
         end
 
-        it 'should give all word forms for the second person' do
+        it 'gives all word forms for the second person' do
           feature_defs = { 'PERSON' => enumeration(:second),
             'GENDER' => enumeration(:feminine, :masculine),
             'PARADIGM' => [identifier, 'ppn_2nd_paradigm'] }
           test_all_inflections('you', feature_defs, ['you'])
         end
 
-        it 'should give all word forms for the third person' do
+        it 'gives all word forms for the third person' do
           feature_defs = { 'PERSON' => enumeration(:third),
             'PARADIGM' => [identifier, 'ppn_3rd_paradigm'] }
           test_all_inflections('it', feature_defs, %w[she he it they her him them])

data/spec/zenlish/wclasses/possessive_determiner_spec.rb

@@ -10,18 +10,18 @@ module Zenlish
   module WClasses
     describe PossessiveDeterminer do
       include Feature::FeatureStructDefBearer
-      subject { PossessiveDeterminer.new }
+      subject(:determiner) { described_class.new }
 
       context 'Initialization:' do
-        it 'should be initialized without argument' do
-          expect { PossessiveDeterminer.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
         def build_det(aBaseForm, aFeatureHash)
           entry = Zenlish::Lex::LexicalEntry.new(aBaseForm)
-          Zenlish::Lex::Lexeme.new(subject, entry, aFeatureHash)
+          Zenlish::Lex::Lexeme.new(determiner, entry, aFeatureHash)
         end
 
         def test_all_inflections(det_form, aFeatureHash, wforms)
@@ -30,37 +30,37 @@ module Zenlish
           expect(inflected.sort).to eq(wforms.sort)
         end
 
-        it 'should know that it is inflectable' do
-          expect(subject).not_to be_invariable
+        it 'knows that it is inflectable' do
+          expect(determiner).not_to be_invariable
         end
 
-        it 'should know its feature definitions' do
-          expect(subject['NUMBER']).to be_kind_of(Feature::FeatureDef)
-          expect(subject['PERSON']).to be_kind_of(Feature::FeatureDef)
-          expect(subject['GENDER']).to be_kind_of(Feature::FeatureDef)
-          expect(subject['PARADIGM'].default.val).to eq('possdet_1st_paradigm')
+        it 'knows its feature definitions' do
+          expect(determiner['NUMBER']).to be_a(Feature::FeatureDef)
+          expect(determiner['PERSON']).to be_a(Feature::FeatureDef)
+          expect(determiner['GENDER']).to be_a(Feature::FeatureDef)
+          expect(determiner['PARADIGM'].default.val).to eq('possdet_1st_paradigm')
         end
 
-        it 'should give all word forms for the first person' do
+        it 'gives all word forms for the first person' do
           feature_defs = { 'PERSON' => enumeration(:first),
             'GENDER' => enumeration(:feminine, :masculine) }
           test_all_inflections('my', feature_defs, %w[my our])
         end
 
-        it 'should give all word forms for the second person' do
+        it 'gives all word forms for the second person' do
           feature_defs = { 'PERSON' => enumeration(:second),
             'GENDER' => enumeration(:feminine, :masculine),
             'PARADIGM' => [identifier, 'possdet_2nd_paradigm'] }
           test_all_inflections('your', feature_defs, ['your'])
         end
 
-        it 'should give all word forms for the third person' do
+        it 'gives all word forms for the third person' do
           feature_defs = { 'PERSON' => enumeration(:third),
             'PARADIGM' => [identifier, 'possdet_3rd_paradigm'] }
           test_all_inflections('its', feature_defs, %w[its her his their])
         end
 
-        # it 'should give all word forms' do
+        # it 'gives all word forms' do
           # test_all_inflections('this', ['this', 'that', 'these', 'those'])
         # end
       end # context