zenlish 0.2.03 → 0.2.04

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5525de088c625d91774e9f3e33898026f720c697f8901a0dce1764f28137194e
-  data.tar.gz: 4c7be3992f7fa3535a7cba502ad34cf43ecbecb0925a85824dea9682452a4ed4
+  metadata.gz: c2f8eb416dfdcb38d3018bfb7f8e3e86de27e38cf98b20c38313da455bcc100d
+  data.tar.gz: c6b2d420e07336d2e5b56293d244859817aca51f460917acc7fa281ec1444af8
 SHA512:
-  metadata.gz: 3a729cc73a70e8ea628a02ed3133e16c7bb6bedacc70650d205562ee42cd367e1ebeab403c5699b6390649c8d78721f619e258c8540659a3e83963e688f6d274
-  data.tar.gz: ee8a24b35b41f87fab98c8d441a1a9051fafa07c44e1e8af5c7133a59f268440b883073cfd1cec2151856d23a8f8ae65c8bd0014eb178b8fbe92b19f138b4f1e
+  metadata.gz: d35e61322d51d9251aa4c8a68b96fb9f274cefc51144744996f07fca21169a1bc000667255b8c5e970cd132485a38fa6694f33d2160a7ebea2383dd7fee1fc6e
+  data.tar.gz: eb4be7dcc83750107d0a9b76b50eaf82a2d22153f4f1d5056115cace60e94ddeb1b0b6141fa0be1f3f1d6890e9e6c3cb15b1ac616263de95dcfa0b51384cd944

data/CHANGELOG.md

@@ -1,11 +1,29 @@
+# CHANGELOG
+## [0.2.04] - 2020-02-09
+Zenlish can now inflect all the verbs in its lexicon.
+
+### Added
+- Module `WordClasses::IrregularVerbCan` for cases where `can` isn't used as a modal verb.
+
+## Changed
+- File `dictionary.rb`: .
+- Class `Lex::Lexicon`: more explicit error message in case of ambiguous lexeme search.
+- Class `WClass::AuxiliaryBe`: added specific inflection table.
+- Class `WClass::AuxiliaryDo`: added specific inflection table.
+- Class `WClass::ModalVerbCan`: added specific inflection table.
+
+### Fixed
+- Class `WordClass::IrregularVerb` fixed rule for gerund spelling for verbs ending with 'oe' or 'ye'.
+- Class `WordClass::RegularVerb` fixed rule for gerund spelling for verbs ending with 'oe' or 'ye'.
+
 # CHANGELOG
 ## [0.2.03] - 2020-02-07
 Zenlish can now inflect the irregular verbs `be`, `do`, and `have`.
 
 ## Changed
-- Class `WClass::IrreglarVerbBe`: added specific inflection table.
-- Class `WClass::IrreglarVerbDo`: added specific inflection table.
-- Class `WClass::IrreglarVerbHave`: added specific inflection table.
+- Class `WClass::IrregularVerbBe`: added specific inflection table.
+- Class `WClass::IrregularVerbDo`: added specific inflection table.
+- Class `WClass::IrregularVerbHave`: added specific inflection table.
 
 ## [0.2.02] - 2020-02-06
 Extending the inflection model to irregular verbs. Zenlish can inflect all irregular verbs in its dictionary (except modals and be).

data/lib/zenlish/lang/dictionary.rb

@@ -56,7 +56,7 @@ unless defined?(Zenlish::Lang::Dictionary)
       add_entry('big', 'Adjective')
       add_entry('body', 'CommonNoun')
       add_entry('but', 'Coordinator')
-      add_entry('can', 'IrregularVerb')      
+      add_entry('can', 'IrregularVerbCan')
       add_entry('can', 'ModalVerbCan')
       add_entry('cause', 'RegularVerb')
       add_entry('change', 'RegularVerb')
@@ -65,7 +65,6 @@ unless defined?(Zenlish::Lang::Dictionary)
       end
       add_entry('contain', 'RegularVerb')
       add_entry('container', 'CommonNoun')
-      add_entry('could', 'ModalVerbCould')
       add_entry('damage', 'RegularVerb')      
       add_entry('die', 'RegularVerb')
       add_entry('difficult', 'Adjective')      

data/lib/zenlish/lang/zenlish_grammar.rb

@@ -137,7 +137,7 @@ builder = Rley::Syntax::GrammarBuilder.new do
   rule 'tense' => 'AuxiliaryBe'
   rule 'tense' => 'AuxiliaryDo'
   rule 'tense' => 'ModalVerbCan'
-  rule 'tense' => 'ModalVerbCould'
+
 
   #############
   # NOUN PHRASE
@@ -232,6 +232,7 @@ builder = Rley::Syntax::GrammarBuilder.new do
   rule 'lexical_verb' => 'IrregularVerb'
   rule 'lexical_verb' => 'IrregularLinkingVerb'
   rule 'lexical_verb' => 'IrregularVerbBe'
+  rule 'lexical_verb' => 'IrregularVerbCan'
   rule 'lexical_verb' => 'IrregularVerbDo'
   rule 'lexical_verb' => 'IrregularVerbHave'
   rule 'lexical_verb' => 'IrregularVerbKnow'

data/lib/zenlish/lex/empty_lexicon_factory.rb

@@ -41,6 +41,7 @@ module Zenlish
         add_wclass(aLexicon, WClasses::IrregularLinkingVerb)
         add_wclass(aLexicon, WClasses::IrregularVerb)
         add_wclass(aLexicon, WClasses::IrregularVerbBe)
+        add_wclass(aLexicon, WClasses::IrregularVerbCan)        
         add_wclass(aLexicon, WClasses::IrregularVerbDo)
         add_wclass(aLexicon, WClasses::IrregularVerbHave)
         add_wclass(aLexicon, WClasses::IrregularVerbKnow)
@@ -48,7 +49,6 @@ module Zenlish
         add_wclass(aLexicon, WClasses::IrregularVerbThink)
         add_wclass(aLexicon, WClasses::LinkingAdverb)
         add_wclass(aLexicon, WClasses::ModalVerbCan)
-        add_wclass(aLexicon, WClasses::ModalVerbCould)
         add_wclass(aLexicon, WClasses::PersonalPronoun)
         add_wclass(aLexicon, WClasses::PossessiveDeterminer)
         add_wclass(aLexicon, WClasses::Preposition)

data/lib/zenlish/lex/lexicon.rb

@@ -45,11 +45,12 @@ module Zenlish
 
           lexeme
         else
-          begin
-            lemma2entry.fetch(aLemma).lexemes.first
-          rescue NoMethodError => exc
-            $stderr.puts "Multiple lexemes for #{aLemma}"
-            raise exc
+          entry = lemma2entry.fetch(aLemma)
+          if entry.kind_of?(Array)
+            err_msg = "Multiple lexemes for #{aLemma}"
+            raise StandardError, err_msg
+          else
+            entry.lexemes.first
           end
         end
       end

data/lib/zenlish/version.rb

@@ -1,3 +1,3 @@
 module Zenlish
-  VERSION = '0.2.03'.freeze
+  VERSION = '0.2.04'.freeze
 end

data/lib/zenlish/wclasses/all_word_classes.rb

@@ -20,6 +20,7 @@ require_relative 'proper_noun'
 require_relative 'irregular_linking_verb'
 require_relative 'irregular_verb'
 require_relative 'irregular_verb_be'
+require_relative 'irregular_verb_can'
 require_relative 'irregular_verb_do'
 require_relative 'irregular_verb_have'
 require_relative 'irregular_verb_know'
@@ -32,7 +33,6 @@ require_relative 'indefinite_article'
 require_relative 'indefinite_pronoun'
 require_relative 'linking_adverb'
 require_relative 'modal_verb_can'
-require_relative 'modal_verb_could'
 require_relative 'personal_pronoun'
 require_relative 'possessive_determiner'
 require_relative 'preposition'

data/lib/zenlish/wclasses/auxiliary.rb

@@ -2,9 +2,10 @@ require_relative 'verb'
 
 module Zenlish
   module WClasses
-    # The verbs: be, have, do
+    # The verbs: be, have, do and the modal verbs can, could, may, must, shall,
+    #   should, will, would
     # As they are so important to the English language, they deserve
-    # their own class
+    # their own class(es)
     class Auxiliary < Verb
     end # class
   end # module

data/lib/zenlish/wclasses/auxiliary_be.rb

@@ -2,8 +2,40 @@ require_relative 'auxiliary'
 
 module Zenlish
   module WClasses
-    # TODO: document
     class AuxiliaryBe < Auxiliary
+      def initialize
+        super()
+      end
+
+      private
+
+      def init_feature_defs
+        super
+        # Create standard feature definitions for modal verb can.
+        feature_def_dsl {
+          feature_def 'PARADIGM' => [identifier, 'Verb_be_inflection'] # 2nd item is default value
+        }
+      end
+
+      def init_paradigms
+        builder = Inflect::InflectionTableBuilder.new
+        table = builder.build('Verb_be_inflection') do
+          feature_heading 'PERSON'
+          feature_heading 'NUMBER'
+          feature_heading 'TIME'
+          #     PERSON               NUMBER             TIME
+          rule([equals(:first),      equals(:singular), equals(:present)        ], literal('am'))
+          rule([equals(:second),     equals(:singular), equals(:present)        ], literal('are'))
+          rule([equals(:third),      equals(:singular), equals(:present)        ], literal('is'))
+          rule([dont_care,           equals(:plural),   equals(:present)        ], literal('are'))
+          rule([dont_care,           dont_care,         equals(:progressive)    ], literal('being'))
+          rule([in?(:first, :third), equals(:singular), equals(:past_simple)    ], literal('was'))
+          rule([equals(:second),     equals(:singular), equals(:past_simple)    ], literal('were'))
+          rule([dont_care,           equals(:plural),   equals(:past_simple)    ], literal('were'))
+          rule([dont_care,           dont_care,         equals(:past_participle)], literal('been'))
+        end
+        add_paradigm(table)
+      end    
     end # class
   end # module
 end # module

data/lib/zenlish/wclasses/auxiliary_do.rb

@@ -4,6 +4,36 @@ module Zenlish
   module WClasses
     # TODO: document
     class AuxiliaryDo < Auxiliary
+      def initialize
+        super()
+      end
+
+      private
+
+      def init_feature_defs
+        super
+        # Create standard feature definitions for modal verb can.
+        feature_def_dsl {
+          feature_def 'PARADIGM' => [identifier, 'Verb_do_inflection'] # 2nd item is default value
+        }
+      end
+
+      def init_paradigms
+        builder = Inflect::InflectionTableBuilder.new
+        table = builder.build('Verb_do_inflection') do
+          feature_heading 'PERSON'
+          feature_heading 'NUMBER'
+          feature_heading 'TIME'
+          #     PERSON              NUMBER             TIME
+          rule([not_equal(:third), equals(:singular), equals(:present)        ], literal('do'))
+          rule([equals(:third),    equals(:singular), equals(:present)        ], literal('does'))
+          rule([dont_care,         equals(:plural),   equals(:present)        ], literal('do'))
+          rule([dont_care,         dont_care,         equals(:progressive)    ], literal('doing'))
+          rule([dont_care,         dont_care,         equals(:past_simple)    ], literal('did'))
+          rule([dont_care,         dont_care,         equals(:past_participle)], literal('done'))
+        end
+        add_paradigm(table)
+      end
     end # class
   end # module
 end # module

data/lib/zenlish/wclasses/irregular_verb.rb

@@ -9,9 +9,6 @@ module Zenlish
 
       def initialize
         super()
-        @paradigms = {}
-        init_feature_defs
-        init_paradigms
       end
       
       # The mix-in module used to extend the lexeme
@@ -43,16 +40,12 @@ module Zenlish
           rule([equals(:third),    equals(:singular), equals(:present),         matches(/(?:[osxz]|ch|sh)$/)], concat(col('base_form'), 'es'))             
           rule([equals(:third),    equals(:singular), equals(:present),         dont_care], concat(col('base_form'), 's'))         
           rule([dont_care,         dont_care,         equals(:progressive),     matches(/ie$/)], sub(col('base_form'), /ie$/, 'ying'))          
-          rule([dont_care,         dont_care,         equals(:progressive),     matches(/[^e]e$/)], sub(col('base_form'), /e$/, 'ing'))            
+          rule([dont_care,         dont_care,         equals(:progressive),     matches(/[^eoy]e$/)], sub(col('base_form'), /e$/, 'ing'))            
           rule([dont_care,         dont_care,         equals(:progressive),     dont_care], concat(col('base_form'), 'ing'))
           rule([dont_care,         dont_care,         equals(:past_simple),     dont_care], func('past_simple'))             
           rule([dont_care,         dont_care,         equals(:past_participle), dont_care], func('past_participle'))
         end
         add_paradigm(table)
-      end
-
-      def add_paradigm(anInflectionTable)
-        @paradigms[anInflectionTable.name] = anInflectionTable
       end      
     end # class
   end # module

data/lib/zenlish/wclasses/irregular_verb_be.rb

@@ -43,20 +43,6 @@ module Zenlish
         end
         add_paradigm(table)
       end
-
-      def add_paradigm(anInflectionTable)
-        @paradigms[anInflectionTable.name] = anInflectionTable
-      end
     end # class
-=begin
-
-
-
-      private
-
-
-
-
-=end
   end # module
 end # module

data/lib/zenlish/wclasses/irregular_verb_can.rb

@@ -0,0 +1,34 @@
+require_relative 'irregular_verb'
+
+module Zenlish
+  module WClasses
+    # Irregular verb can
+    class IrregularVerbCan < IrregularVerb
+      def initialize
+        super()
+      end
+
+      private
+
+      def init_feature_defs
+        super
+        # Create standard feature definitions for modal verb can.
+        feature_def_dsl {
+          feature_def 'TIME' => enumeration(:present, :past_simple)
+          feature_def 'PARADIGM' => [identifier, 'Verb_can_inflection'] # 2nd item is default value
+        }
+      end
+
+      def init_paradigms
+        builder = Inflect::InflectionTableBuilder.new
+        table = builder.build('Verb_can_inflection') do
+          feature_heading 'TIME'
+          #     TIME
+          rule([equals(:present)     ], literal('can'))
+          rule([equals(:past_simple) ], literal('could'))
+        end
+        add_paradigm(table)
+      end    
+    end # class
+  end # module
+end # module

data/lib/zenlish/wclasses/irregular_verb_do.rb

@@ -7,12 +7,12 @@ module Zenlish
       def initialize
         super()
       end
-      
+
       # The mix-in module used to extend the lexeme
       # @return [Module, NilClass]
       def extension
         nil
-      end      
+      end
 
       private
 
@@ -31,19 +31,15 @@ module Zenlish
           feature_heading 'NUMBER'
           feature_heading 'TIME'
           #     PERSON              NUMBER             TIME
-          rule([not_equal(:third), equals(:singular), equals(:present)         ], literal('do'))
+          rule([not_equal(:third), equals(:singular), equals(:present)        ], literal('do'))
           rule([equals(:third),    equals(:singular), equals(:present)        ], literal('does'))
           rule([dont_care,         equals(:plural),   equals(:present)        ], literal('do'))
           rule([dont_care,         dont_care,         equals(:progressive)    ], literal('doing'))
-          rule([dont_care,         dont_care,         equals(:past_simple)    ], literal('did'))          
+          rule([dont_care,         dont_care,         equals(:past_simple)    ], literal('did'))
           rule([dont_care,         dont_care,         equals(:past_participle)], literal('done'))
         end
         add_paradigm(table)
       end
-
-      def add_paradigm(anInflectionTable)
-        @paradigms[anInflectionTable.name] = anInflectionTable
-      end    
     end # class
   end # module
 end # module

data/lib/zenlish/wclasses/irregular_verb_have.rb

@@ -39,10 +39,6 @@ module Zenlish
           rule([dont_care,         dont_care,         equals(:past_participle)], literal('had'))
         end
         add_paradigm(table)
-      end
-
-      def add_paradigm(anInflectionTable)
-        @paradigms[anInflectionTable.name] = anInflectionTable
       end    
     end # class
   end # module

data/lib/zenlish/wclasses/modal_verb_can.rb

@@ -4,6 +4,31 @@ module Zenlish
   module WClasses
     # The modal verb `can`
     class ModalVerbCan < Auxiliary
+      def initialize
+        super()
+      end
+
+      private
+
+      def init_feature_defs
+        super
+        # Create standard feature definitions for modal verb can.
+        feature_def_dsl {
+          feature_def 'TIME' => enumeration(:present, :past_simple)
+          feature_def 'PARADIGM' => [identifier, 'Verb_can_inflection'] # 2nd item is default value
+        }
+      end
+
+      def init_paradigms
+        builder = Inflect::InflectionTableBuilder.new
+        table = builder.build('Verb_can_inflection') do
+          feature_heading 'TIME'
+          #     TIME
+          rule([equals(:present)     ], literal('can'))
+          rule([equals(:past_simple) ], literal('could'))
+        end
+        add_paradigm(table)
+      end
     end # class
   end # module
 end # module

data/lib/zenlish/wclasses/regular_verb.rb

@@ -5,8 +5,6 @@ module Zenlish
     class RegularVerb < LexicalVerb
       def initialize
         super
-        @paradigms = {}
-        init_paradigms
       end
 
       private
@@ -23,19 +21,15 @@ module Zenlish
           rule([equals(:third),    equals(:singular), equals(:present),            matches(/[^aeiouy]y$/)], sub(col('base_form'), /y$/, 'ies'))
           rule([equals(:third),    equals(:singular), equals(:present),            matches(/(?:[osxz]|ch|sh)$/)], concat(col('base_form'), 'es'))             
           rule([equals(:third),    equals(:singular), equals(:present),            dont_care], concat(col('base_form'), 's'))         
-          rule([dont_care,         dont_care,         equals(:progressive),     matches(/ie$/)], sub(col('base_form'), /ie$/, 'ying'))          
-          rule([dont_care,         dont_care,         equals(:progressive),     matches(/[^e]e$/)], sub(col('base_form'), /e$/, 'ing'))            
-          rule([dont_care,         dont_care,         equals(:progressive),     dont_care], concat(col('base_form'), 'ing'))
+          rule([dont_care,         dont_care,         equals(:progressive),        matches(/ie$/)], sub(col('base_form'), /ie$/, 'ying'))          
+          rule([dont_care,         dont_care,         equals(:progressive),        matches(/[^eoy]e$/)], sub(col('base_form'), /e$/, 'ing'))            
+          rule([dont_care,         dont_care,         equals(:progressive),        dont_care], concat(col('base_form'), 'ing'))
           rule([dont_care,         dont_care, in?(:past_simple, :past_participle), matches(/e$/)], concat(col('base_form'), 'd'))             
           rule([dont_care,         dont_care, in?(:past_simple, :past_participle), matches(/[^aeiouy]y$/)], sub(col('base_form'), /y$/, 'ied'))            
           rule([dont_care,         dont_care, in?(:past_simple, :past_participle), dont_care], concat(col('base_form'), 'ed'))
         end
         add_paradigm(table)
       end
-
-      def add_paradigm(anInflectionTable)
-        @paradigms[anInflectionTable.name] = anInflectionTable
-      end
     end # class
   end # module
 end # module

data/lib/zenlish/wclasses/verb.rb

@@ -3,21 +3,29 @@ require_relative '../inflect/inflection_table_builder'
 
 module Zenlish
   module WClasses
-    # Abstract class. In traditional grammar, the verb is often defined 
+    # Abstract class. In traditional grammar, the verb is often defined
     # notionally as a 'doing' word (i.e. a word that describes the action
     # in a clause).
     class Verb < WordClass
       def initialize
         super()
+        @paradigms = {}
         init_feature_defs
-      end    
-    
+        init_paradigms
+      end
+
       # As all verbs inflect, or change form, to reflect changes in tense,
       # person, number, and voice, they are, by definition, variable.
       def invariable?
         false
       end
 
+      protected
+
+      def add_paradigm(anInflectionTable)
+        @paradigms[anInflectionTable.name] = anInflectionTable
+      end
+
       private
 
       def init_feature_defs
@@ -25,10 +33,14 @@ module Zenlish
         feature_def_dsl {
           feature_def 'NUMBER' => enumeration(:singular, :plural)
           feature_def 'PERSON' => enumeration(:first, :second, :third)
-          feature_def 'TIME' => enumeration(:present, :progressive, :past_simple, :past_participle)          
+          feature_def 'TIME' => enumeration(:present, :progressive, :past_simple, :past_participle)
           feature_def 'PARADIGM' => [identifier, 'Regular_inflection'] # 2nd item is default value
         }
-      end       
+      end
+
+      def init_paradigms
+        raise NotImplementedError, "Method #{__callee__} must implemented for #{self.class}."
+      end
     end # class
   end # module
 end # module

data/spec/zenlish/lang/dictionary_spec.rb

@@ -81,20 +81,22 @@ module Zenlish
         end
         
         it 'should know how to inflect the verb be' do
-          lexm = subject.get_lexeme('be', WClasses::IrregularVerbBe)
-          expectations_1 = [
-            [present_1sg,     'am'],
-            [present_2sg,     'are'],
-            [present_3sg,     'is'],
-            [present_1pl,     'are'],
-            [progressive,     'being'],
-            [past_simple,     'was'],
-            [past_simple_2sg, 'were'],
-            [past_simple_3sg, 'was'],
-            [past_simple_1pl, 'were'],
-            [past_participle, 'been']           
-          ]
-          test_inflection_of(lexm, expectations_1, true)        
+          [WClasses::IrregularVerbBe, WClasses::AuxiliaryBe].each do |wclass|
+            lexm = subject.get_lexeme('be', wclass)
+            expectations_1 = [
+              [present_1sg,     'am'],
+              [present_2sg,     'are'],
+              [present_3sg,     'is'],
+              [present_1pl,     'are'],
+              [progressive,     'being'],
+              [past_simple,     'was'],
+              [past_simple_2sg, 'were'],
+              [past_simple_3sg, 'was'],
+              [past_simple_1pl, 'were'],
+              [past_participle, 'been']           
+            ]
+            test_inflection_of(lexm, expectations_1, true)
+          end
         end
         
       end # context

data/spec/zenlish/support/var2word.rb

@@ -56,7 +56,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,7 +69,7 @@ module Zenlish
     literal2var('contain', 'contains')
     literal2var('container', 'container')
     literal2var('container', 'containers')
-    literal2var('could', 'could')
+    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')

data/spec/zenlish/wclasses/irregular_verb_can_spec.rb

@@ -0,0 +1,50 @@
+# 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)
+          lexeme = 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
+
+        it 'should know how to inflect modal verb can' do
+          expectations_1 = [
+            [:present,     'can'],
+            [:past_simple, 'could']
+          ]
+          test_inflection_of('can', expectations_1)
+        end
+      end # context
+    end # describe
+  end # module
+end # module

data/spec/zenlish/wclasses/lexical_verb_spec.rb

@@ -7,6 +7,13 @@ require_relative '../../../lib/zenlish/wclasses/lexical_verb'
 
 module Zenlish
   module WClasses
+    class LexicalVerb
+      # Do limited monkeypatching, just for testing purposes
+      def init_paradigms
+        # Empty method
+      end
+    end
+    
     describe LexicalVerb do
       subject { LexicalVerb.new }
 

data/spec/zenlish/wclasses/modal_verb_can_spec.rb

@@ -0,0 +1,50 @@
+# 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/modal_verb_can'
+
+module Zenlish
+  module WClasses
+    describe ModalVerbCan do
+      subject { ModalVerbCan.new }
+
+      context 'Initialization:' do
+        it 'should be initialized without argument' do
+          expect { ModalVerbCan.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)
+          lexeme = 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
+
+        it 'should know how to inflect modal verb can' do
+          expectations_1 = [
+            [:present,     'can'],
+            [:past_simple, 'could']
+          ]
+          test_inflection_of('can', expectations_1)
+        end
+      end # context
+    end # describe
+  end # module
+end # module

data/spec/zenlish/wclasses/verb_spec.rb

@@ -5,6 +5,13 @@ require_relative '../../../lib/zenlish/wclasses/verb' # Load the class under tes
 
 module Zenlish
   module WClasses
+    class Verb
+      # Do limited monkeypatching, just for testing purposes
+      def init_paradigms
+        # Empty method
+      end
+    end
+
     describe Verb do
       subject { Verb.new }
 
@@ -18,11 +25,11 @@ module Zenlish
         it 'should know that it has inflected forms' 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['PERSON']).to be_kind_of(Feature::FeatureDef)
-          expect(subject['PARADIGM'].default.val).to eq('Regular_inflection')           
+          expect(subject['PARADIGM'].default.val).to eq('Regular_inflection')
         end
       end # context
     end # describe

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: zenlish
 version: !ruby/object:Gem::Version
-  version: 0.2.03
+  version: 0.2.04
 platform: ruby
 authors:
 - Dimitri Geshef
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2020-02-07 00:00:00.000000000 Z
+date: 2020-02-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rley
@@ -158,6 +158,7 @@ files:
 - lib/zenlish/wclasses/irregular_linking_verb.rb
 - lib/zenlish/wclasses/irregular_verb.rb
 - lib/zenlish/wclasses/irregular_verb_be.rb
+- lib/zenlish/wclasses/irregular_verb_can.rb
 - lib/zenlish/wclasses/irregular_verb_do.rb
 - lib/zenlish/wclasses/irregular_verb_extension.rb
 - lib/zenlish/wclasses/irregular_verb_have.rb
@@ -167,7 +168,6 @@ files:
 - lib/zenlish/wclasses/lexical_verb.rb
 - lib/zenlish/wclasses/linking_adverb.rb
 - lib/zenlish/wclasses/modal_verb_can.rb
-- lib/zenlish/wclasses/modal_verb_could.rb
 - lib/zenlish/wclasses/noun.rb
 - lib/zenlish/wclasses/numeral.rb
 - lib/zenlish/wclasses/personal_pronoun.rb
@@ -225,9 +225,11 @@ files:
 - spec/zenlish/support/minimal_lexicon.rb
 - spec/zenlish/support/var2word.rb
 - spec/zenlish/wclasses/common_noun_spec.rb
+- spec/zenlish/wclasses/irregular_verb_can_spec.rb
 - spec/zenlish/wclasses/irregular_verb_extension_spec.rb
 - spec/zenlish/wclasses/irregular_verb_spec.rb
 - spec/zenlish/wclasses/lexical_verb_spec.rb
+- spec/zenlish/wclasses/modal_verb_can_spec.rb
 - spec/zenlish/wclasses/noun_spec.rb
 - spec/zenlish/wclasses/preposition_spec.rb
 - spec/zenlish/wclasses/proper_noun_spec.rb
@@ -298,9 +300,11 @@ test_files:
 - spec/zenlish/parser/lesson3_spec.rb
 - spec/zenlish/parser/zparser_spec.rb
 - spec/zenlish/wclasses/common_noun_spec.rb
+- spec/zenlish/wclasses/irregular_verb_can_spec.rb
 - spec/zenlish/wclasses/irregular_verb_extension_spec.rb
 - spec/zenlish/wclasses/irregular_verb_spec.rb
 - spec/zenlish/wclasses/lexical_verb_spec.rb
+- spec/zenlish/wclasses/modal_verb_can_spec.rb
 - spec/zenlish/wclasses/noun_spec.rb
 - spec/zenlish/wclasses/preposition_spec.rb
 - spec/zenlish/wclasses/proper_noun_spec.rb

data/lib/zenlish/wclasses/modal_verb_could.rb

@@ -1,9 +0,0 @@
-require_relative 'auxiliary'
-
-module Zenlish
-  module WClasses
-    # The modal verb `could`
-    class ModalVerbCould < Auxiliary
-    end # class
-  end # module
-end # module