zenlish 0.2.05 → 0.2.07

data/spec/zenlish/parser/zparser_spec.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 require_relative '../../spec_helper' # Use the RSpec framework
 require_relative '../support/var2word'
 require_relative '../../../lib/zenlish/parser/zparser' # Load the class under test
@@ -7,12 +8,12 @@ module Zenlish
   module Parser
     describe ZParser do
       include Var2Word
-      
-      subject { ZParser.new }
+
+      subject(:parser) { described_class.new }
 
       context 'Initialization:' do
-        it 'should be initialized without argument' do
-          expect { ZParser.new }.not_to raise_error
+        it 'is initialized without argument' do
+          expect { described_class.new }.not_to raise_error
         end
       end # context
 
@@ -21,14 +22,14 @@ module Zenlish
           # # OK, non-ambiguous sentence: "Lisa sees Tony."
           # literals = [lisa, sees, tony, dot]
           # result_type = Rley::PTree::ParseTree
-          # expect(subject.to_pforest(literals)).to be_kind_of(result_type)
+          # expect(parser.to_pforest(literals)).to be_a(result_type)
         # end
 
-        it 'should produce forest' do
+        it 'produces forest' do
           # Sentence: "Lisa sees Tony."
           literals = [lisa, sees, tony, dot]
           result_type = Rley::SPPF::ParseForest
-          expect(subject.to_pforest(literals)).to be_kind_of(result_type)
+          expect(parser.to_pforest(literals)).to be_a(result_type)
         end
       end # context
     end # describe

data/spec/zenlish/support/minimal_lexicon.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require_relative '../../../lib/zenlish/lang/dictionary'
 
 # Add a few words to dictionary for testing purposes...

data/spec/zenlish/support/var2word.rb

@@ -1,7 +1,12 @@
+# frozen_string_literal: true
+
 require_relative 'minimal_lexicon'
 require_relative '../../../lib/zenlish/lex/literal'
 
 module Zenlish
+  # rubocop: disable Layout/SpaceBeforeSemicolon
+  # rubocop: disable Style/SingleLineMethods
+
   # Utility module. It defines variables that each are assgned a
   # Literal object.
   module Var2Word
@@ -106,8 +111,8 @@ module Zenlish
     literal2var('hear', 'hear')
     literal2var('hear', 'heard')
     literal2var('hear', 'hears')
-    def here ;     Lex::Literal.new('here', get_lexeme('here', WClasses::Adverb), 0) ; end
-    def here_as_noun ;  Lex::Literal.new('here', get_lexeme('here', WClasses::CommonNoun), 0) ; end
+    def here ; Lex::Literal.new('here', get_lexeme('here', WClasses::Adverb), 0) ; end
+    def here_as_noun ; Lex::Literal.new('here', get_lexeme('here', WClasses::CommonNoun), 0) ; end
     def i_pronoun ; Lex::Literal.new('I', get_lexeme('I'), 0) ; end
     literal2var('if', 'if', '_')
     literal2var('in', 'in', '_')
@@ -115,7 +120,7 @@ module Zenlish
     literal2var('it', 'it', '_')
     literal2var('its', 'its')
     literal2var('J', 'j', '_')
-    def is ;     Lex::Literal.new('is', get_lexeme('be', WClasses::IrregularVerbBe), 0) ; end
+    def is ; Lex::Literal.new('is', get_lexeme('be', WClasses::IrregularVerbBe), 0) ; end
     def is_aux ; Lex::Literal.new('is', get_lexeme('be', WClasses::AuxiliaryBe), 0) ; end
     literal2var('K', 'k', '_')
     literal2var('kind', 'kind')
@@ -216,7 +221,7 @@ module Zenlish
     literal2var('want', 'want')
     literal2var('want', 'wants')
     def was ; Lex::Literal.new('was', get_lexeme('be', WClasses::IrregularVerbBe), 0) ; end
-    def were ;     Lex::Literal.new('were', get_lexeme('be', WClasses::IrregularVerbBe), 0) ; end
+    def were ; Lex::Literal.new('were', get_lexeme('be', WClasses::IrregularVerbBe), 0) ; end
     literal2var('what', 'what')
     literal2var('when', 'when', '_')
     def where ; Lex::Literal.new('where', get_lexeme('where', WClasses::Adverb), 0) ; end
@@ -228,9 +233,11 @@ module Zenlish
     literal2var('you', 'you')
     literal2var('you', 'your')
 
-    def colon ;  Lex::Literal.new(':', get_lexeme(':'), 0) ; end
-    def comma ;  Lex::Literal.new(',', get_lexeme(','), 0) ; end
-    def dot ;  Lex::Literal.new('.', get_lexeme('.'), 0) ; end
-    def quote ;  Lex::Literal.new('"', get_lexeme('"'), 0) ; end
+    def colon ; Lex::Literal.new(':', get_lexeme(':'), 0) ; end
+    def comma ; Lex::Literal.new(',', get_lexeme(','), 0) ; end
+    def dot ; Lex::Literal.new('.', get_lexeme('.'), 0) ; end
+    def quote ; Lex::Literal.new('"', get_lexeme('"'), 0) ; end
   end # module
-end # module
+  # rubocop: enable Style/SingleLineMethods
+  # rubocop: enable Layout/SpaceBeforeSemicolon
+end # module

data/spec/zenlish/trie/base_trie_node_spec.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require_relative '../../spec_helper' # Use the RSpec framework
+require_relative '../../../lib/zenlish/trie/base_trie_node' # Load the class under test
+
+module Zenlish
+  module Trie
+    describe BaseTrieNode do
+      subject(:node) { described_class.new }
+
+      context 'Initialization:' do
+        it 'is initialized without argument' do
+          expect { described_class.new }.not_to raise_error
+        end
+
+        it 'is a leaf node at start' do
+          expect(node).to be_leaf
+        end
+      end # context
+
+      context 'Provided services:' do
+        it 'accepts the addition of a successor' do
+          some_node = described_class.new
+
+          expect(node).not_to include('f')
+          expect { node.add_succ('f', some_node) }.not_to raise_error
+          expect(node).to include('f')
+          expect(node.succ['f']).to eq(some_node)
+        end
+      end # context
+    end # describe
+  end # module
+end # module

data/spec/zenlish/trie/trie_spec.rb

@@ -0,0 +1,108 @@
+# frozen_string_literal: true
+
+require_relative '../../spec_helper' # Use the RSpec framework
+require_relative '../../../lib/zenlish/trie/trie' # Load the class under test
+
+module Zenlish
+  module Trie
+    describe Trie do
+      subject(:trie) { described_class.new }
+
+      context 'Initialization:' do
+        it 'is initialized without argument' do
+          expect { described_class.new }.not_to raise_error
+        end
+
+        it 'is a leaf node at start' do
+          expect(trie.root).to be_a(TrieRoot)
+        end
+      end # context
+
+      context 'Provided services:' do
+        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 '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 = trie.root.succ['a']
+          expect(node_a).to be_a(TrieNode)
+          expect(node_a.value).to be_nil
+          expect(node_a).to include('b')
+          expect(node_a).not_to include('c')
+
+          node_b = node_a.succ['b']
+          expect(node_b).to be_a(TrieNode)
+          expect(node_b.value).to be_nil
+          expect(node_b).to include('c')
+
+          node_c = node_b.succ['c']
+          expect(node_c).to be_a(TrieNode)
+          expect(node_c.value).to eq('OK')
+          expect(node_c).to be_leaf
+        end
+
+        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_a(TrieNode)
+          expect(node_b.value).to be_nil
+          expect(node_b).to include('c')
+          expect(node_b).to include('e')
+
+          node_c = node_b.succ['c']
+          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_a(TrieNode)
+          expect(node_e.value).to eq('ABE')
+          expect(node_e).to be_leaf
+        end
+
+        it 'retrieves the node matching a given string' do
+          trie.add('abc', 'ABC')
+          trie.add('hello', 'WORLD')
+          trie.add('hellene', 'GREEK')
+
+          hello_node = trie.search('hello')
+          expect(hello_node.key).to eq('o')
+          expect(hello_node.value).to eq('WORLD')
+          hellish = trie.search('hell')
+          expect(hellish.key).to eq('l')
+          expect(hellish.value).to be_nil
+          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(trie.search('hellenes')).to be_nil
+        end
+
+        it 'accepts the addition of "synonyms"' do
+          trie.add('abd', 'first')
+          trie.add('abduce', 'ABDUCE')
+
+          abd_node = trie.search('abd')
+          expect(abd_node.value).to eq('first')
+
+          trie.add('abd', 'second')
+          expect(abd_node.value).to eq(%w[first second])
+        end
+      end # context
+    end # describe
+  end # module
+end # module

data/spec/zenlish/wclasses/common_noun_spec.rb

@@ -7,53 +7,49 @@ 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
-          samples = %w[animal body people]          
+        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
           end
           plural_sample = { 'animal' => 'animals',
             'body' => 'bodies',
-            'people' => 'people'
-          }
-
+            'people' => 'people' }
           lexemes.map do |lx|
             pluralized = lx.inflect([:plural, nil])
             expect(pluralized).to eq(plural_sample[lx.base_form])
           end
         end
-        
-        it 'should know all its inflections' do
-          samples = %w[animal body people]          
+
+        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
           end
-          lexemes.map do |lxm|
-            lxm.all_inflections
-          end
+          lexemes.map(&:all_inflections)
         end
       end # context
     end # describe
   end # module
-end # module
+end # module

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)
-          lexeme = Zenlish::Lex::Lexeme.new(subject, entry)
+          Zenlish::Lex::Lexeme.new(determiner, entry)
         end
 
         def test_all_inflections(det_form, wforms)
@@ -28,18 +28,18 @@ 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
-          test_all_inflections('this', ['this', 'that', 'these', 'those'])
+        it 'gives all word forms' do
+          test_all_inflections('this', %w[this that these those])
         end
       end # context
     end # describe

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)
-          lexeme = Zenlish::Lex::Lexeme.new(subject, entry)
+          Zenlish::Lex::Lexeme.new(irreg_can, entry)
         end
 
         def test_inflection_of(verb_form, pairs)
@@ -36,25 +36,25 @@ module Zenlish
             expect(verb.inflect([time])).to eq(expected_form)
           end
         end
-        
+
         def test_all_inflections(verb_form, wforms)
           verb = build_verb(verb_form)
           inflected = verb.all_inflections
           expect(inflected.sort).to eq(wforms.sort)
-        end        
+        end
 
-        it 'should know how to inflect modal verb can' do
-          expectations_1 = [
+        it 'knows how to inflect modal verb can' do
+          expectations1 = [
             [:present,     'can'],
             [:past_simple, 'could']
           ]
-          test_inflection_of('can', expectations_1)
+          test_inflection_of('can', expectations1)
+        end
+
+        it 'gives all word forms of a given verb' do
+          test_all_inflections('can', %w[can could])
         end
-        
-        it 'should give all word forms of a given verb' do
-          test_all_inflections('can', ['can', 'could'])
-        end        
       end # context
     end # describe
   end # module
-end # module
+end # module

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
@@ -45,15 +32,28 @@ module Zenlish
             expect(verb.inflect(constraints)).to eq(expected_form)
           end
         end
-        
+
         def test_all_inflections(verb_form, p_simple, p_participle, wforms)
           verb = build_verb(verb_form, p_simple, p_participle)
           inflected = verb.all_inflections
           expect(inflected.sort).to eq(wforms.sort)
-        end        
+        end
 
-        it 'should know how to inflect irregular verbs' do
-          expectations_1 = [
+        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'],
             [present_1pl,     'see'],
@@ -61,9 +61,9 @@ module Zenlish
             [past_simple,     'saw'],
             [past_participle, 'seen']
           ]
-          test_inflection_of('see', 'saw', 'seen', expectations_1)
+          test_inflection_of('see', 'saw', 'seen', expectations1)
 
-          expectations_2 = [
+          expectations2 = [
             [present_1sg, 'make'],
             [present_3sg, 'makes'],
             [present_1pl, 'make'],
@@ -71,12 +71,12 @@ module Zenlish
             [past_simple, 'made'],
             [past_participle, 'made']
           ]
-          test_inflection_of('make', 'made', 'made', expectations_2)
+          test_inflection_of('make', 'made', 'made', expectations2)
+        end
+
+        it 'gives all word forms of a given verb' do
+          test_all_inflections('see', 'saw', 'seen', %w[see sees seeing saw seen])
         end
-        
-        it 'should give all word forms of a given verb' do
-          test_all_inflections('see', 'saw', 'seen', ['see', 'sees', 'seeing', 'saw', 'seen'])
-        end        
       end # context
     end # describe
   end # module

data/spec/zenlish/wclasses/lexical_verb_spec.rb

@@ -3,7 +3,7 @@
 require_relative '../../spec_helper' # Use the RSpec framework
 
 # Load the class under test
-require_relative '../../../lib/zenlish/wclasses/lexical_verb' 
+require_relative '../../../lib/zenlish/wclasses/lexical_verb'
 
 module Zenlish
   module WClasses
@@ -13,21 +13,21 @@ module Zenlish
         # Empty method
       end
     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