zenlish 0.2.00 → 0.2.01

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 68fb4d0914b284ffab37ba5f91c325918bcfaa4948adea0a747297e325c93fe6
-  data.tar.gz: e83dd3b97f088defef045fb01d5d6a7be202f02d4c45e85cdce3f2f718cf9ef2
+  metadata.gz: 18b53b01ebe8e3f9a895026ae2b63c7753081ed12572a16d75dc35f943b479e9
+  data.tar.gz: 74def3a1abe88f1fa457ee151bd2420c682aedbeecf36a62a857b5e0327e43ab
 SHA512:
-  metadata.gz: 3de436eaced4062aade3ca3dc2d94915c284c2b38a5775ba3d6880d676cc8d0e3773a244eb1086ddca93f71c265f494b548fb114e7c30ea3b52ad1dbb8694a19
-  data.tar.gz: 7f55f80aad57993fcd1cadf75721f5f53fbd91fa8de6f620fb39fecd70892373dc69fe66fc3d13f43b272096aaf1c5afed60453ac126fb7c03fe9f0a1e435beb
+  metadata.gz: a7d8a33af3c91ab977a7f7ca9addd6ba0929e662c599dd0e5d3d5bbb3c3eb4ced11f765ce7e62c59e152600cccc94122e33066416faaab66c2893a207d89de6c
+  data.tar.gz: 9649988e311bfaccd0ed8ca12b1c648eddec01b27f4b3549c7518cb62e725ed03ecfb1c2de1459434b0a481aaa68bff1a4f978cf4ae33f7a3983e35b3614efe7

data/CHANGELOG.md

@@ -1,4 +1,13 @@
 # CHANGELOG
+## [0.2.01] - 2020-02-02
+Extending the inflection table capabilities.
+Extending the inflection model to regular verbs. Zenlish can inflect all regular verbs in its dictionary.
+
+### Added
+- Class `Inflect::FunctionCall` Now an inflection table can invoke a method of the lexeme argument.
+- Class `Inflect::Membership` Now an inflection table can test whether a value is included in a set of values.
+- Class `Inflect::NotEquals` Now an inflection table can test for inequality
+
 
 ## [0.2.00] - 2020-01-30
 A lot of internal additions, such an initial feature model, embryonic inflection model.
@@ -14,8 +23,6 @@ This is WIP.
 - Class `WordClass` ca have its own set of feature definitions.
 - Class `Noun` has the feature definitions for: `NUMBER`, `COUNTABILITY` and `PARADIGM`
 
-
-
 ## [0.1.25] - 2019-12-06
 __Zenlish__ can parse all sentences in lesson 1, 2 and 3-A .. 3-G (352 sentences in total) from
  [Learn These Words First](http://learnthesewordsfirst.com/).

data/README.md

@@ -136,7 +136,7 @@ The milestone sub-goals are:
 - Zenlish should be able to parse all the example sentences
 
 #### B) Associate lexical features to terms in lexicon
-The sub-goals are:
+*STARTED* The sub-goals are:
 - To enrich the lexicon entries with lexical and syntactical features.
 - Zenlish should be able to derive the declensions of nouns, conjugation of verbs,
 - Also Zenlish should detect agreement errors

data/lib/zenlish/inflect/function_call.rb

@@ -0,0 +1,17 @@
+require_relative 'atomic_o_expression'
+
+module Zenlish
+  module Inflect
+    class FunctionCall < AtomicOExpression
+      attr_reader :mth_name
+
+      def initialize(aMethodName)
+        @mth_name = aMethodName
+      end
+
+      def generate(_headings, lexeme, _values)
+        lexeme.send(mth_name)
+      end
+    end # class
+  end # module
+end # module

data/lib/zenlish/inflect/inflection_table.rb

@@ -21,12 +21,17 @@ module Zenlish
       end
 
       def inflect(aLexeme, theConstraints)
+        constraints = if theConstraints.nil? || theConstraints.empty?
+          Array.new(headings.size) { |_i| nil }
+        else
+          theConstraints
+        end
         err_msg = "Table has #{headings.size} headings."
-        raise StandardError, err_msg if theConstraints.size != headings.size
+        raise StandardError, err_msg if constraints.size != headings.size
         actuals = []
         headings.each_with_index do |hd, idx|
-          if theConstraints[idx]
-            actuals << theConstraints[idx]
+          if constraints[idx]
+            actuals << constraints[idx]
           else
             actuals << hd.evaluate_for(aLexeme)
           end

data/lib/zenlish/inflect/inflection_table_builder.rb

@@ -2,9 +2,12 @@ require_relative 'feature_heading'
 require_relative 'method_heading'
 require_relative 'formal_argument'
 require_relative 'equals_literal'
+require_relative 'not_equals_literal'
 require_relative 'unconditionally_true'
 require_relative 'matches_pattern'
+require_relative 'membership'
 require_relative 'input_asis'
+require_relative 'function_call'
 require_relative 'concatenation'
 require_relative 'substitution'
 require_relative 'inflection_rule'
@@ -73,6 +76,22 @@ module Zenlish
         equality_cond
       end
 
+      def not_equal(aValue)
+        arg = FormalArgument.new(conds.size)
+        inequality_cond = NotEqualsLiteral.new(arg, aValue)
+        conds << inequality_cond
+
+        inequality_cond
+      end
+      
+      def in?(*theMembers)
+        arg = FormalArgument.new(conds.size)
+        membership_cond = Membership.new(arg, theMembers)
+        conds << membership_cond
+
+        membership_cond      
+      end
+
       def dont_care
         item = UnconditionallyTrue.new
         conds << item
@@ -95,6 +114,10 @@ module Zenlish
         match_cond
       end
 
+      def func(aFuncName)
+        FunctionCall.new(aFuncName)
+      end
+
       def sub(original, pattern, replacement)
         Substitution.new(original, pattern, replacement)
       end

data/lib/zenlish/inflect/membership.rb

@@ -0,0 +1,25 @@
+require_relative 'unary_input_expression'
+
+module Zenlish
+  module Inflect
+    class Membership < UnaryInputExpression
+      attr_reader :members
+
+      def initialize(anArgument, theMembers)
+        super(anArgument)
+        @members = theMembers
+      end
+
+      def success?(headings, lexeme, actuals)
+        if actuals.empty?
+          hd = headings[argument.index]
+          feat_def = hd.evaluate_for(lexeme)
+          members.all? { |memb| feat_def.domain.include?(memb) }
+        else
+          val = actuals[argument.index]
+          members.include?(val)
+        end
+      end
+    end # class
+  end # module
+end # module

data/lib/zenlish/inflect/not_equals_literal.rb

@@ -0,0 +1,25 @@
+require_relative 'unary_input_expression'
+
+module Zenlish
+  module Inflect
+    class NotEqualsLiteral < UnaryInputExpression
+      attr_reader :literal
+
+      def initialize(anArgument, aLiteral)
+        super(anArgument)
+        @literal = aLiteral
+      end
+
+      def success?(headings, lexeme, actuals)
+        if actuals.empty?
+          hd = headings[argument.index]
+          feat_def = hd.evaluate_for(lexeme)
+          !feat_def.domain.include?(literal)
+        else
+          val = actuals[argument.index]
+          val != literal
+        end
+      end
+    end # class
+  end # module
+end # module

data/lib/zenlish/lang/dictionary.rb

@@ -14,11 +14,13 @@ unless defined?(Zenlish::Lang::Dictionary)
       # @param aLemma [String] is the canonical form, dictionary form, 
       #   or citation form of a headword.
       # @param aWClassName [String] the name of a word class.
-      def self.add_entry(aLemma, aWClassName, aFeatureHash = nil)
+      def self.add_entry(aLemma, aWClassName, aFeatureHash = nil, &aBlock)
         entry = Zenlish::Lex::LexicalEntry.new(aLemma)
         wclass = Dictionary.name2terminal[aWClassName]
         raise StandardError, "Undefined word class for '#{aLemma}'" unless wclass
-        lexeme = Zenlish::Lex::Lexeme.new(wclass, entry, aFeatureHash).freeze
+        lexeme = Zenlish::Lex::Lexeme.new(wclass, entry, aFeatureHash)
+        lexeme.instance_exec(&aBlock) if block_given?
+        lexeme.freeze
         Dictionary.add_entry(entry.freeze)
       end
 

data/lib/zenlish/lex/lexeme.rb

@@ -7,8 +7,8 @@ module Zenlish
     # relate to the lexeme for verb 'hide'. Also called 'dictionary word'.
     class Lexeme
       include Feature::FeatureStructDefBearer
-      
-      # @return [Zenlish::WClasses::WordClass]
+
+      # @return [Zenlish::WClasses::WordClass] the word class to which the lexeme belongs
       attr_reader :wclass
 
       # @param aWClass [WClasses::WordClass, Rley::Syntax::Terminal]
@@ -18,32 +18,37 @@ module Zenlish
         @wclass = aWClass
         @entry = anEntry.object_id
         anEntry.add_lexeme(self)
-        
+
         p_struct = aWClass.kind_of?(WClasses::WordClass) ? aWClass.struct : nil
         overriding_struct_defs = aFeatureHash.nil? ? {} : aFeatureHash
         init_struct_def(p_struct, overriding_struct_defs)
       end
 
-      # @return [Zenlish::Lex::LexicalEntry]
+      # @return [Zenlish::Lex::LexicalEntry] Link to its dictionary entry (headword)
       def entry
         ObjectSpace._id2ref(@entry)
       end
-      
+
+      # Inflect the lexeme according the default paradigm of the word class.
+      # @param constraints [Array] Array of values (for each heading of inflection table
+      # @return [String] The word form (spelling) inflected to the given contraints.
       def inflect(constraints)
         table = paradigm
         table.inflect(self, constraints)
       end
 
-      # @return [String]
+      # @return [String] the base (dictionary) form.
       def lemma
         entry.lemma
       end
 
+      # Return the inflection paradigm for the lexeme.
+      # @return [Inflect::InflectionTable]
       def paradigm
         paradigm_feat_def = self['PARADIGM']
-        wclass.paradigms[paradigm_feat_def.default.val]      
+        wclass.paradigms[paradigm_feat_def.default.val]
       end
-      
+
       alias base_form lemma
     end # class
   end # module

data/lib/zenlish/version.rb

@@ -1,3 +1,3 @@
 module Zenlish
-  VERSION = '0.2.00'.freeze
+  VERSION = '0.2.01'.freeze
 end

data/lib/zenlish/wclasses/common_noun.rb

@@ -26,8 +26,8 @@ module Zenlish
           feature_heading 'NUMBER'
           method_heading 'base_form'
           rule([equals(:singular), dont_care], col('base_form'))
-          rule([equals(:plural), matches(/[^aeiouy]y$/)], sub(col('base_form'), /y$/, 'ies'))
-          rule([equals(:plural), dont_care], concat(col('base_form'), 's'))
+          rule([equals(:plural),   matches(/[^aeiouy]y$/)], sub(col('base_form'), /y$/, 'ies'))
+          rule([equals(:plural),   dont_care], concat(col('base_form'), 's'))
         end
         add_paradigm(table)
 

data/lib/zenlish/wclasses/irregular_verb.rb

@@ -2,8 +2,32 @@ require_relative 'lexical_verb'
 
 module Zenlish
   module WClasses
-    # TODO: document
     class IrregularVerb < LexicalVerb
+      # @return [Array<String>]  [the past simple form, past participle form].
+      attr_writer :forms
+
+      def initialize
+        super()
+        init_feature_defs
+      end
+
+      def past_simple
+        raise StandardError
+      end
+
+      def past_participle
+        raise StandardError
+      end
+
+      private
+
+      def init_feature_defs
+        super()
+        # Define standard feature definitions for irregular verbs.
+        feature_def_dsl {
+          feature_def 'PARADIGM' => [identifier, 'Irregular_form'] # 2nd item is default value
+        }
+      end
     end # class
   end # module
 end # module

data/lib/zenlish/wclasses/lexical_verb.rb

@@ -2,8 +2,10 @@ require_relative 'verb'
 
 module Zenlish
   module WClasses
-    # TODO: document
     class LexicalVerb < Verb
+      def initialize
+        super
+      end
     end # class
   end # module
 end # module

data/lib/zenlish/wclasses/regular_verb.rb

@@ -4,6 +4,38 @@ module Zenlish
   module WClasses
     # TODO: document 'touch'
     class RegularVerb < LexicalVerb
+      def initialize
+        super
+        @paradigms = {}
+        init_paradigms
+      end
+
+      private
+
+      def init_paradigms
+        builder = Inflect::InflectionTableBuilder.new
+        table = builder.build('Regular_inflection') do
+          feature_heading 'PERSON'
+          feature_heading 'NUMBER'
+          feature_heading 'TIME'
+          method_heading  'base_form'
+          #     PERSON             NUMBER             TIME                         base_form
+          rule([not_equal(:third), dont_care,         equals(:present),            dont_care], col('base_form'))
+          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(/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

@@ -1,4 +1,5 @@
 require_relative 'word_class'
+require_relative '../inflect/inflection_table_builder'
 
 module Zenlish
   module WClasses
@@ -6,12 +7,28 @@ module Zenlish
     # notionally as a 'doing' word (i.e. a word that describes the action
     # in a clause).
     class Verb < WordClass
+      def initialize
+        super()
+        init_feature_defs
+      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
+
+      private
+
+      def init_feature_defs
+        # Create standard feature definitions for lexical verbs.
+        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 'PARADIGM' => [identifier, 'Regular_inflection'] # 2nd item is default value
+        }
+      end       
     end # class
   end # module
 end # module

data/spec/zenlish/inflect/equals_literal_spec.rb

@@ -16,7 +16,7 @@ module Zenlish
       subject { EqualsLiteral.new(an_argument, feat_val) }
 
       context 'Initialization:' do
-        it 'should be initialized with a method name' do
+        it 'should be initialized with a formal argument and a literal' do
           expect { EqualsLiteral.new(an_argument, feat_val) }.not_to raise_error
         end
 

data/spec/zenlish/inflect/function_call_spec.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require 'ostruct'
+# Load the class under test
+require_relative '../../../lib/zenlish/inflect/function_call'
+
+module Zenlish
+  module Inflect
+    describe FunctionCall do
+      subject { FunctionCall.new('greet') }
+
+      context 'Initialization:' do
+        it 'should be initialized with a text literal' do
+          expect { FunctionCall.new('greet') }.not_to raise_error
+        end
+        
+        it 'should know its method name' do
+          expect(subject.mth_name).to eq('greet')
+        end
+      end # context
+
+      context 'Provided services:' do
+        it 'should return the affix during word form generation' do
+          headings = double('fake-headings')        
+          lexeme = OpenStruct.new(:greet => 'Hello, world')
+          values = double('fake-values')
+          expect(subject.generate(headings, lexeme, values)).to eq('Hello, world')
+        end
+      end # context
+    end # describe
+  end # module
+end # module

data/spec/zenlish/inflect/inflection_table_builder_spec.rb

@@ -97,7 +97,7 @@ module Zenlish
 
         MockFeatureBearer = Struct.new(:NUMBER, :base_form)
 
-        it 'should build tables conform to specs' do
+        it 'should build default paradigm for common nouns' do
           table = subject.build('Common_form') do
             feature_heading 'NUMBER'
             method_heading 'base_form'
@@ -121,6 +121,86 @@ module Zenlish
           mck_3['NUMBER'] = :plural
           expect(table.inflect(mck_3, [nil, nil])).to eq('bodies')
         end
+        
+        MockRegularVerb = Struct.new(:base_form, :PERSON, :NUMBER, :TIME)
+        it 'should build default paradigm for regular verbs' do
+          table = subject.build('Regular_form') do
+            feature_heading 'PERSON'
+            feature_heading 'NUMBER'
+            feature_heading 'TIME'
+            method_heading  'base_form'
+            #     PERSON             NUMBER             TIME                         base_form
+            rule([not_equal(:third), dont_care,         equals(:present),            dont_care], col('base_form'))
+            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(/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
+          
+          verb_1 = MockRegularVerb.new('belong', :first, :singular, :present)
+          expect(table.inflect(verb_1, [nil,    nil,     nil, nil]             )).to eq('belong')
+          expect(table.inflect(verb_1, [:third, nil,     nil, nil]             )).to eq('belongs')
+          expect(table.inflect(verb_1, [nil,    :plural, nil, nil]             )).to eq('belong')
+          expect(table.inflect(verb_1, [nil,    nil,     :progressive, nil]    )).to eq('belonging')
+          expect(table.inflect(verb_1, [nil,    nil,     :past_simple, nil]    )).to eq('belonged')
+          expect(table.inflect(verb_1, [nil,    nil,     :past_participle, nil])).to eq('belonged')
+          
+          verb_2 = MockRegularVerb.new('try', :first, :singular, :present)
+          expect(table.inflect(verb_2, [nil,    nil,     nil, nil]             )).to eq('try')
+          expect(table.inflect(verb_2, [:third, nil,     nil, nil]             )).to eq('tries')
+          expect(table.inflect(verb_2, [nil,    :plural, nil, nil]             )).to eq('try')
+          expect(table.inflect(verb_2, [nil,    nil,     :progressive, nil]    )).to eq('trying')
+          expect(table.inflect(verb_2, [nil,    nil,     :past_simple, nil]    )).to eq('tried')
+          expect(table.inflect(verb_2, [nil,    nil,     :past_participle, nil])).to eq('tried')
+
+          verb_3 = MockRegularVerb.new('touch', :first, :singular, :present)
+          expect(table.inflect(verb_3, [:second,nil,     nil, nil]             )).to eq('touch')
+          expect(table.inflect(verb_3, [:third, nil,     nil, nil]             )).to eq('touches')
+          expect(table.inflect(verb_3, [nil,    :plural, nil, nil]             )).to eq('touch')
+          expect(table.inflect(verb_3, [nil,    nil,     :progressive, nil]    )).to eq('touching')
+          expect(table.inflect(verb_3, [nil,    nil,     :past_simple, nil]    )).to eq('touched')
+          expect(table.inflect(verb_3, [nil,    nil,     :past_participle, nil])).to eq('touched')
+
+          verb_4 = MockRegularVerb.new('cause', :first, :singular, :present)
+          expect(table.inflect(verb_4, [nil,    nil,     nil, nil]             )).to eq('cause')
+          expect(table.inflect(verb_4, [:third, nil,     nil, nil]             )).to eq('causes')
+          expect(table.inflect(verb_4, [nil,    :plural, nil, nil]             )).to eq('cause')
+          expect(table.inflect(verb_4, [nil,    nil,     :progressive, nil]    )).to eq('causing')
+          expect(table.inflect(verb_4, [nil,    nil,     :past_simple, nil]    )).to eq('caused')
+          expect(table.inflect(verb_4, [nil,    nil,     :past_participle, nil])).to eq('caused')          
+        end
+        
+        # MockIrregularVerb = Struct.new(:base_form, :PERSON, :NUMBER, :TIME)
+        # it 'should build default paradigm for irregular verbs' do
+          # table = subject.build('Irregular_form') do
+            # feature_heading 'PERSON'
+            # feature_heading 'NUMBER'
+            # feature_heading 'TIME'
+            # method_heading  'base_form'
+            # #     PERSON             NUMBER             TIME                         base_form
+            # rule([not_equal(:third), dont_care,         equals(:present),            dont_care], col('base_form'))
+            # 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(/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
+
+          # verb_1 = MockIrregularVerb.new('choose', :first, :singular, :present)
+          # expect(table.inflect(verb_1, [nil,    nil,     nil, nil]             )).to eq('choose')
+          # expect(table.inflect(verb_1, [:third, nil,     nil, nil]             )).to eq('chooses')
+          # expect(table.inflect(verb_1, [nil,    :plural, nil, nil]             )).to eq('choose')
+          # expect(table.inflect(verb_1, [nil,    nil,     :progressive, nil]    )).to eq('choosing')
+          # expect(table.inflect(verb_1, [nil,    nil,     :past_simple, nil]    )).to eq('chose')
+          # expect(table.inflect(verb_1, [nil,    nil,     :past_participle, nil])).to eq('chosen')
+        # end
       end # context
     end # describe
   end # module

data/spec/zenlish/inflect/membership_spec.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+require_relative '../../../lib/zenlish/wclasses/common_noun'
+require_relative '../../../lib/zenlish/lex/lexeme'
+require_relative '../../../lib/zenlish/lex/lexical_entry'
+require_relative '../../../lib/zenlish/inflect/feature_heading'
+require_relative '../../../lib/zenlish/inflect/formal_argument'
+# Load the class under test
+require_relative '../../../lib/zenlish/inflect/membership'
+
+module Zenlish
+  module Inflect
+    describe Membership do
+      let(:an_argument) { FormalArgument.new(1) }
+      let(:feat_val) { [:singular, :plural] }
+      subject { Membership.new(an_argument, feat_val) }
+
+      context 'Initialization:' do
+        it 'should be initialized with a formal argument and an array' do
+          expect { Membership.new(an_argument, feat_val) }.not_to raise_error
+        end
+
+        it 'should know its argument' do
+          expect(subject.argument).to eq(an_argument)
+        end
+
+        it 'should know the array of literals' do
+          expect(subject.members).to eq(feat_val)
+        end
+      end # context
+
+      context 'Provided services:' do
+        it 'should test the actual values' do
+          lexeme = double('dummy-lexeme')
+          headings = double('fake-headings')
+          actual_args = [nil, :plural, nil]
+          expect(subject.success?(headings, lexeme, actual_args)).to be_truthy
+          actual_args[1] = :singular
+          expect(subject.success?(headings, lexeme, actual_args)).to be_truthy
+          actual_args[1] = :dual
+          expect(subject.success?(headings, lexeme, actual_args)).to be_falsy          
+        end
+
+        # it 'should test the lexeme' do
+          # c_noun = WClasses::CommonNoun.new
+          # entry = Lex::LexicalEntry.new('animal')
+          # lexeme = Lex::Lexeme.new(c_noun, entry)
+          # headings = [nil, FeatureHeading.new('NUMBER'), nil]
+          # expect(subject.success?(headings, lexeme, [])).to be_truthy
+
+          # instance = Membership.new(an_argument, :singular)
+          # expect(instance.success?(headings, lexeme, [])).to be_truthy
+
+          # instance = Membership.new(an_argument, :irregular)
+          # expect(instance.success?(headings, lexeme, [])).to be_falsey
+        # end
+      end # context
+    end # describe
+  end # module
+end # module

data/spec/zenlish/inflect/not_equals_literal_spec.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+require_relative '../../../lib/zenlish/wclasses/common_noun'
+require_relative '../../../lib/zenlish/lex/lexeme'
+require_relative '../../../lib/zenlish/lex/lexical_entry'
+require_relative '../../../lib/zenlish/inflect/feature_heading'
+require_relative '../../../lib/zenlish/inflect/formal_argument'
+# Load the class under test
+require_relative '../../../lib/zenlish/inflect/not_equals_literal'
+
+module Zenlish
+  module Inflect
+    describe NotEqualsLiteral do
+      let(:an_argument) { FormalArgument.new(1) }
+      let(:feat_val) { :plural }
+      subject { NotEqualsLiteral.new(an_argument, feat_val) }
+
+      context 'Initialization:' do
+        it 'should be initialized with formal argument and a literal' do
+          expect { NotEqualsLiteral.new(an_argument, feat_val) }.not_to raise_error
+        end
+
+        it 'should know its argument' do
+          expect(subject.argument).to eq(an_argument)
+        end
+
+        it 'should know the literal' do
+          expect(subject.literal).to eq(feat_val)
+        end
+      end # context
+
+      context 'Provided services:' do
+        it 'should test the actual argument' do
+          lexeme = double('dummy-lexeme')
+          headings = double('fake-headings')
+          actual_args = [nil, :plural, nil]
+          expect(subject.success?(headings, lexeme, actual_args)).to be_falsy
+          actual_args[1] = :singular
+          expect(subject.success?(headings, lexeme, actual_args)).to be_truthy
+        end
+
+        it 'should test the lexeme' do
+          c_noun = WClasses::CommonNoun.new
+          entry = Lex::LexicalEntry.new('animal')
+          lexeme = Lex::Lexeme.new(c_noun, entry)
+          headings = [nil, FeatureHeading.new('NUMBER'), nil]
+          expect(subject.success?(headings, lexeme, [])).to be_falsy
+
+          instance = NotEqualsLiteral.new(an_argument, :singular)
+          expect(instance.success?(headings, lexeme, [])).to be_falsy
+
+          instance = NotEqualsLiteral.new(an_argument, :irregular)
+          expect(instance.success?(headings, lexeme, [])).to be_truthy
+        end
+      end # context
+    end # describe
+  end # module
+end # module

data/spec/zenlish/lex/lexeme_spec.rb

@@ -47,6 +47,10 @@ module Zenlish
           instance =  Lexeme.new(a_wclass, an_entry, a_feat_struct_def)
           expect(instance['NUMBER'].default.val).to eq(:plural)
         end
+        
+        it 'should know its inflection paradigm' do
+          expect(subject.paradigm).to be_kind_of(Inflect::InflectionTable)
+        end
       end # context
     end # describe
   end # module

data/spec/zenlish/wclasses/irregular_verb_spec.rb

@@ -14,8 +14,9 @@ module Zenlish
         end
       end # context
 
-      # context 'Provided services:' do
-      # end # context
+      context 'Provided services:' do
+        
+      end # context
     end # describe
   end # module
 end # module

data/spec/zenlish/wclasses/lexical_verb_spec.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require_relative '../../spec_helper' # Use the RSpec framework
+
+# Load the class under test
+require_relative '../../../lib/zenlish/wclasses/lexical_verb' 
+
+module Zenlish
+  module WClasses
+    describe LexicalVerb do
+      subject { LexicalVerb.new }
+
+      context 'Initialization:' do
+        it 'should be initialized without argument' do
+          expect { LexicalVerb.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')           
+        end
+      end # context
+    end # describe
+  end # module
+end # module

data/spec/zenlish/wclasses/regular_verb_spec.rb

@@ -0,0 +1,91 @@
+# 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/regular_verb'
+
+module Zenlish
+  module WClasses
+    describe RegularVerb do
+      subject { RegularVerb.new }
+
+      context 'Initialization:' do
+        it 'should be initialized without argument' do
+          expect { RegularVerb.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')
+        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)
+          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 |(constraints, expected_form)|
+            expect(verb.inflect(constraints)).to eq(expected_form)
+          end
+        end
+
+        it 'should how to inflect regular verbs' do
+          expectations_1 = [
+            [present_1sg,     'exist'],
+            [present_3sg,     'exists'],
+            [present_1pl,     'exist'],
+            [progressive,     'existing'],
+            [past_simple,     'existed'],
+            [past_participle, 'existed']
+          ]
+          test_inflection_of('exist', expectations_1)
+
+          expectations_2 = [
+            [present_1sg, 'move'],
+            [present_3sg, 'moves'],
+            [present_1pl, 'move'],
+            [progressive, 'moving'],
+            [past_simple, 'moved'],
+            [past_participle, 'moved']
+          ]
+          test_inflection_of('move', expectations_2)
+
+          expectations_3 = [
+            [present_1sg, 'try'],
+            [present_3sg, 'tries'],
+            [present_1pl, 'try'],
+            [progressive, 'trying'],
+            [past_simple, 'tried'],
+            [past_participle, 'tried']
+          ]
+          test_inflection_of('try', expectations_3)
+
+          expectations_4 = [
+            [present_1sg, 'touch'],
+            [present_3sg, 'touches'],
+            [present_1pl, 'touch'],
+            [progressive, 'touching'],
+            [past_simple, 'touched'],
+            [past_participle, 'touched']
+          ]
+          test_inflection_of('touch', expectations_4)          
+        end
+      end # context
+    end # describe
+  end # module
+end # module

data/spec/zenlish/wclasses/verb_spec.rb

@@ -15,9 +15,15 @@ module Zenlish
       end # context
 
       context 'Provided services:' do
-        it 'should know that it it is variable (has inflected forms)' do
+        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')           
+        end
       end # context
     end # describe
   end # module

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: zenlish
 version: !ruby/object:Gem::Version
-  version: 0.2.00
+  version: 0.2.01
 platform: ruby
 authors:
 - Dimitri Geshef
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2020-01-30 00:00:00.000000000 Z
+date: 2020-02-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rley
@@ -104,6 +104,7 @@ files:
 - lib/zenlish/inflect/equals_literal.rb
 - lib/zenlish/inflect/feature_heading.rb
 - lib/zenlish/inflect/formal_argument.rb
+- lib/zenlish/inflect/function_call.rb
 - lib/zenlish/inflect/heading.rb
 - lib/zenlish/inflect/inflection_rule.rb
 - lib/zenlish/inflect/inflection_table.rb
@@ -112,7 +113,9 @@ files:
 - lib/zenlish/inflect/input_expression.rb
 - lib/zenlish/inflect/literal_asis.rb
 - lib/zenlish/inflect/matches_pattern.rb
+- lib/zenlish/inflect/membership.rb
 - lib/zenlish/inflect/method_heading.rb
+- lib/zenlish/inflect/not_equals_literal.rb
 - lib/zenlish/inflect/nullary_input_expression.rb
 - lib/zenlish/inflect/output_expression.rb
 - lib/zenlish/inflect/substitution.rb
@@ -195,13 +198,16 @@ files:
 - spec/zenlish/inflect/equals_literal_spec.rb
 - spec/zenlish/inflect/feature_heading_spec.rb
 - spec/zenlish/inflect/formal_argument_spec.rb
+- spec/zenlish/inflect/function_call_spec.rb
 - spec/zenlish/inflect/inflection_rule_spec.rb
 - spec/zenlish/inflect/inflection_table_builder_spec.rb
 - spec/zenlish/inflect/inflection_table_spec.rb
 - spec/zenlish/inflect/input_asis_spec.rb
 - spec/zenlish/inflect/literal_asis_spec.rb
 - spec/zenlish/inflect/matches_pattern_spec.rb
+- spec/zenlish/inflect/membership_spec.rb
 - spec/zenlish/inflect/method_heading_spec.rb
+- spec/zenlish/inflect/not_equals_literal_spec.rb
 - spec/zenlish/inflect/substitution_spec.rb
 - spec/zenlish/inflect/unconditionally_true_spec.rb
 - spec/zenlish/lang/dictionary_spec.rb
@@ -219,9 +225,11 @@ files:
 - spec/zenlish/support/var2word.rb
 - spec/zenlish/wclasses/common_noun_spec.rb
 - spec/zenlish/wclasses/irregular_verb_spec.rb
+- spec/zenlish/wclasses/lexical_verb_spec.rb
 - spec/zenlish/wclasses/noun_spec.rb
 - spec/zenlish/wclasses/preposition_spec.rb
 - spec/zenlish/wclasses/proper_noun_spec.rb
+- spec/zenlish/wclasses/regular_verb_spec.rb
 - spec/zenlish/wclasses/verb_spec.rb
 - spec/zenlish_spec.rb
 - zenlish.gemspec
@@ -264,13 +272,16 @@ test_files:
 - spec/zenlish/inflect/equals_literal_spec.rb
 - spec/zenlish/inflect/feature_heading_spec.rb
 - spec/zenlish/inflect/formal_argument_spec.rb
+- spec/zenlish/inflect/function_call_spec.rb
 - spec/zenlish/inflect/inflection_rule_spec.rb
 - spec/zenlish/inflect/inflection_table_builder_spec.rb
 - spec/zenlish/inflect/inflection_table_spec.rb
 - spec/zenlish/inflect/input_asis_spec.rb
 - spec/zenlish/inflect/literal_asis_spec.rb
 - spec/zenlish/inflect/matches_pattern_spec.rb
+- spec/zenlish/inflect/membership_spec.rb
 - spec/zenlish/inflect/method_heading_spec.rb
+- spec/zenlish/inflect/not_equals_literal_spec.rb
 - spec/zenlish/inflect/substitution_spec.rb
 - spec/zenlish/inflect/unconditionally_true_spec.rb
 - spec/zenlish/lang/dictionary_spec.rb
@@ -286,8 +297,10 @@ test_files:
 - spec/zenlish/parser/zparser_spec.rb
 - spec/zenlish/wclasses/common_noun_spec.rb
 - spec/zenlish/wclasses/irregular_verb_spec.rb
+- spec/zenlish/wclasses/lexical_verb_spec.rb
 - spec/zenlish/wclasses/noun_spec.rb
 - spec/zenlish/wclasses/preposition_spec.rb
 - spec/zenlish/wclasses/proper_noun_spec.rb
+- spec/zenlish/wclasses/regular_verb_spec.rb
 - spec/zenlish/wclasses/verb_spec.rb
 - spec/zenlish_spec.rb