zenlish 0.2.02 → 0.2.06

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,7 +8,7 @@ module Zenlish
   module Parser
     describe ZParser do
       include Var2Word
-      
+
       subject { ZParser.new }
 
       context 'Initialization:' do

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,13 @@
+# frozen_string_literal: true
+
 require_relative 'minimal_lexicon'
 require_relative '../../../lib/zenlish/lex/literal'
 
 module Zenlish
+  # rubocop: disable Layout/EmptyLineBetweenDefs
+  # rubocop: disable Layout/SpaceBeforeSemicolon
+  # rubocop: disable Style/SingleLineMethods
+
   # Utility module. It defines variables that each are assgned a
   # Literal object.
   module Var2Word
@@ -56,7 +62,7 @@ module Zenlish
     literal2var('body', 'body')
     literal2var('but', 'but')
     def can ; Lex::Literal.new('can', get_lexeme('can', WClasses::ModalVerbCan), 0) ; end
-    def can_irregular ; Lex::Literal.new('can', get_lexeme('can', WClasses::IrregularVerb), 0) ; end     
+    def can_irregular ; Lex::Literal.new('can', get_lexeme('can', WClasses::IrregularVerbCan), 0) ; end
     literal2var('cause', 'cause')
     literal2var('cause', 'caused')
     literal2var('cause', 'causes')
@@ -69,19 +75,19 @@ module Zenlish
     literal2var('contain', 'contains')
     literal2var('container', 'container')
     literal2var('container', 'containers')
-    literal2var('could', 'could')
-    literal2var('damage', 'damaged')    
+    def could ; Lex::Literal.new('could', get_lexeme('can', WClasses::ModalVerbCan), 0) ; end
+    literal2var('damage', 'damaged')
     def did ; Lex::Literal.new('did', get_lexeme('do', WClasses::IrregularVerbDo), 0) ; end
     literal2var('die', 'die')
     literal2var('die', 'died')
     literal2var('die', 'dies')
     literal2var('different', 'different')
-    literal2var('difficult', 'difficult')    
+    literal2var('difficult', 'difficult')
     def do_ ; Lex::Literal.new('do', get_lexeme('do', WClasses::IrregularVerbDo), 0) ; end
     def do_aux ; Lex::Literal.new('do', get_lexeme('do', WClasses::AuxiliaryDo), 0) ; end
     def does ; Lex::Literal.new('does', get_lexeme('do', WClasses::IrregularVerbDo), 0) ; end
     def does_aux ; Lex::Literal.new('does', get_lexeme('do', WClasses::AuxiliaryDo), 0) ; end
-    def doing ; Lex::Literal.new('doing', get_lexeme('do', WClasses::IrregularVerbDo), 0) ; end    
+    def doing ; Lex::Literal.new('doing', get_lexeme('do', WClasses::IrregularVerbDo), 0) ; end
     literal2var('each', 'each', '_')
     def each_ ; Lex::Literal.new('each', get_lexeme('each', WClasses::DistributiveDeterminer), 0) ; end
     def each_as_pronoun ; Lex::Literal.new('each', get_lexeme('each', WClasses::Pronoun), 0) ; end
@@ -106,8 +112,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 +121,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')
@@ -134,7 +140,7 @@ module Zenlish
     literal2var('make', 'make')
     literal2var('many', 'many')
     literal2var('maybe', 'maybe')
-    literal2var('me', 'me')
+    literal2var('I', 'me')
     literal2var('moment', 'moment')
     def more ; Lex::Literal.new('more', get_lexeme('more', WClasses::Adjective), 0) ; end
     def more_as_adverb ; Lex::Literal.new('more', get_lexeme('more', WClasses::Adverb), 0) ; end
@@ -179,10 +185,10 @@ module Zenlish
     literal2var('something', 'something')
     literal2var('surface', 'surface')
     literal2var('the', 'the')
-    literal2var('their', 'their')
-    literal2var('them', 'them')
+    literal2var('its', 'their')
+    literal2var('it', 'them')
     literal2var('then', 'then', '_')
-    literal2var('they', 'they')
+    literal2var('it', 'they')
     literal2var('than', 'than')
     literal2var('that', 'that')
     literal2var('there', 'there')
@@ -216,7 +222,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 +234,12 @@ 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
+  # rubocop: enable Layout/EmptyLineBetweenDefs
+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 { BaseTrieNode.new }
+
+      context 'Initialization:' do
+        it 'should be initialized without argument' do
+          expect { BaseTrieNode.new }.not_to raise_error
+        end
+
+        it 'should be a leaf node at start' do
+          expect(subject).to be_leaf
+        end
+      end # context
+
+      context 'Provided services:' do
+        it 'should accept the addition of a successor' do
+          some_node = BaseTrieNode.new
+
+          expect(subject.include?('f')).to be_falsy
+          expect { subject.add_succ('f', some_node) }.not_to raise_error
+          expect(subject.include?('f')).to be_truthy
+          expect(subject.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.new }
+
+      context 'Initialization:' do
+        it 'should be initialized without argument' do
+          expect { Trie.new }.not_to raise_error
+        end
+
+        it 'should be a leaf node at start' do
+          expect(subject.root).to be_kind_of(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')
+        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
+
+          node_a = subject.root.succ['a']
+          expect(node_a).to be_kind_of(TrieNode)
+          expect(node_a.value).to be_nil
+          expect(node_a.include?('b')).to be_truthy
+          expect(node_a.include?('c')).to be_falsy
+
+          node_b = node_a.succ['b']
+          expect(node_b).to be_kind_of(TrieNode)
+          expect(node_b.value).to be_nil
+          expect(node_b.include?('c')).to be_truthy
+
+          node_c = node_b.succ['c']
+          expect(node_c).to be_kind_of(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
+
+          node_a = root.succ['a']
+
+          node_b = node_a.succ['b']
+          expect(node_b).to be_kind_of(TrieNode)
+          expect(node_b.value).to be_nil
+          expect(node_b.include?('c')).to be_truthy
+          expect(node_b.include?('e')).to be_truthy
+
+          node_c = node_b.succ['c']
+          expect(node_c).to be_kind_of(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.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')
+
+          hello_node = subject.search('hello')
+          expect(hello_node.key).to eq('o')
+          expect(hello_node.value).to eq('WORLD')
+          hellish = subject.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(hellene_node.key).to eq('e')
+          expect(hellene_node.value).to eq('GREEK')
+          expect(subject.search('hellenes')).to be_nil
+        end
+
+        it 'should accept the addition of "synonyms"' do
+          subject.add('abd', 'first')
+          subject.add('abduce', 'ABDUCE')
+
+          abd_node = subject.search('abd')
+          expect(abd_node.value).to eq('first')
+
+          subject.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

@@ -21,23 +21,35 @@ module Zenlish
         end
 
         it 'should support 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) }
-            lexemes.concat(lexm) if lexm
+            if lexm && samples.include?(ent.lemma)
+              lexemes.concat(lexm)
+            end
           end
-          samples = %w[ animal body people]
           plural_sample = { 'animal' => 'animals',
             'body' => 'bodies',
-            'people' => 'people'}
-          selection = lexemes.select { |lx| samples.include?(lx.entry.lemma) }
-
-          selection.map do |lx|
+            '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]
+          lexemes = []
+          Lang::Dictionary.entries.each do |ent|
+            lexm = ent.lexemes.select { |lx| lx.wclass.kind_of?(Zenlish::WClasses::CommonNoun) }
+            if lexm && samples.include?(ent.lemma)
+              lexemes.concat(lexm)
+            end
+          end
+          lexemes.map(&:all_inflections)
+        end
       end # context
     end # describe
   end # module
-end # module
+end # module

data/spec/zenlish/wclasses/demonstrative_determiner_spec.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require_relative '../../spec_helper' # Use the RSpec framework
+require_relative '../../../lib/zenlish/lex/lexical_entry'
+require_relative '../../../lib/zenlish/lex/lexeme'
+require_relative '../../../lib/zenlish/wclasses/demonstrative_determiner' # Load the class under test
+
+module Zenlish
+  module WClasses
+    describe DemonstrativeDeterminer do
+      subject { DemonstrativeDeterminer.new }
+
+      context 'Initialization:' do
+        it 'should be initialized without argument' do
+          expect { DemonstrativeDeterminer.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)
+        end
+
+        def test_all_inflections(det_form, wforms)
+          determiner = build_det(det_form)
+          inflected = determiner.all_inflections
+          expect(inflected.sort).to eq(wforms.sort)
+        end
+
+        it 'should know that it is inflectable' do
+          expect(subject).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')
+        end
+
+        it 'should give all word forms' do
+          test_all_inflections('this', %w[this that these those])
+        end
+      end # context
+    end # describe
+  end # module
+end # module

data/spec/zenlish/wclasses/irregular_verb_can_spec.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+require_relative '../../spec_helper' # Use the RSpec framework
+require_relative '../../../lib/zenlish/lex/lexical_entry'
+require_relative '../../../lib/zenlish/lex/lexeme'
+
+# Load the class under test
+require_relative '../../../lib/zenlish/wclasses/irregular_verb_can'
+
+module Zenlish
+  module WClasses
+    describe IrregularVerbCan do
+      subject { IrregularVerbCan.new }
+
+      context 'Initialization:' do
+        it 'should be initialized without argument' do
+          expect { IrregularVerbCan.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')
+        end
+
+        def build_verb(aBaseForm)
+          entry = Zenlish::Lex::LexicalEntry.new(aBaseForm)
+          Zenlish::Lex::Lexeme.new(subject, entry)
+        end
+
+        def test_inflection_of(verb_form, pairs)
+          verb = build_verb(verb_form)
+          pairs.each do |(time, expected_form)|
+            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
+
+        it 'should know how to inflect modal verb can' do
+          expectations1 = [
+            [:present,     'can'],
+            [:past_simple, 'could']
+          ]
+          test_inflection_of('can', expectations1)
+        end
+
+        it 'should give all word forms of a given verb' do
+          test_all_inflections('can', %w[can could])
+        end
+      end # context
+    end # describe
+  end # module
+end # module

data/spec/zenlish/wclasses/irregular_verb_spec.rb

@@ -46,8 +46,14 @@ module Zenlish
           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
+
         it 'should know how to inflect irregular verbs' do
-          expectations_1 = [
+          expectations1 = [
             [present_1sg,     'see'],
             [present_3sg,     'sees'],
             [present_1pl,     'see'],
@@ -55,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'],
@@ -65,7 +71,11 @@ 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 'should give all word forms of a given verb' do
+          test_all_inflections('see', 'saw', 'seen', %w[see sees seeing saw seen])
         end
       end # context
     end # describe