zenlish 0.2.02 → 0.2.03

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5a4f38ce593249cf97998ec7d51977400b6bb1445a368823b3c8db0f779aec41
-  data.tar.gz: 30e519af42ccf67586f3314892d63a8150200e671a4c42e5185154746ea2218d
+  metadata.gz: 5525de088c625d91774e9f3e33898026f720c697f8901a0dce1764f28137194e
+  data.tar.gz: 4c7be3992f7fa3535a7cba502ad34cf43ecbecb0925a85824dea9682452a4ed4
 SHA512:
-  metadata.gz: 007460f06685b5a84c239b70f14503d1420deffd8291b087bea657a966292e3c04be01f3dd973cbd7e6f543ba1e0daf86afad73d2085da2b7c23ad5c3e3e7624
-  data.tar.gz: 9a3a5904dfd78edbb50a7886d1d830e400619039bc736760356381c9845dd9ec2919089c0803c64ffef89b2d9d55fe0b061b4542e25a1371550c6863a7d4aafa
+  metadata.gz: 3a729cc73a70e8ea628a02ed3133e16c7bb6bedacc70650d205562ee42cd367e1ebeab403c5699b6390649c8d78721f619e258c8540659a3e83963e688f6d274
+  data.tar.gz: ee8a24b35b41f87fab98c8d441a1a9051fafa07c44e1e8af5c7133a59f268440b883073cfd1cec2151856d23a8f8ae65c8bd0014eb178b8fbe92b19f138b4f1e

data/CHANGELOG.md

@@ -1,4 +1,12 @@
 # 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.
+
 ## [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).
 
@@ -23,7 +31,6 @@ Extending the inflection model to regular verbs. Zenlish can inflect all regular
 - 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.
 This is WIP.

data/lib/zenlish/inflect/inflection_table.rb

@@ -26,7 +26,7 @@ module Zenlish
         else
           theConstraints
         end
-        err_msg = "Table has #{headings.size} headings."
+        err_msg = "Table has #{headings.size} headings, instead of #{constraints.size}"
         raise StandardError, err_msg if constraints.size != headings.size
         actuals = []
         headings.each_with_index do |hd, idx|

data/lib/zenlish/inflect/inflection_table_builder.rb

@@ -83,13 +83,13 @@ module Zenlish
 
         inequality_cond
       end
-      
+
       def in?(*theMembers)
         arg = FormalArgument.new(conds.size)
         membership_cond = Membership.new(arg, theMembers)
         conds << membership_cond
 
-        membership_cond      
+        membership_cond
       end
 
       def dont_care
@@ -99,6 +99,10 @@ module Zenlish
         item
       end
 
+      def literal(aLiteral)
+        LiteralAsIs.new(aLiteral)
+      end
+
       def col(aColName)
         col_index = headings.find_index { |hd| hd.label == aColName }
         err_msg = "Cannot find heading named '#{aColName}'."

data/lib/zenlish/lang/dictionary.rb

@@ -71,9 +71,7 @@ unless defined?(Zenlish::Lang::Dictionary)
       add_entry('difficult', 'Adjective')      
       add_entry('different', 'Adjective')
       add_entry('do', 'AuxiliaryDo')
-      add_entry('do', 'IrregularVerbDo') do
-        forms past_simple: 'did', past_participle: 'done'
-      end
+      add_entry('do', 'IrregularVerbDo')
       add_entry('each', 'DistributiveDeterminer')
       add_entry('each', 'Pronoun')
       add_entry('exist', 'RegularVerb')
@@ -88,7 +86,9 @@ unless defined?(Zenlish::Lang::Dictionary)
       add_entry('good', 'Adjective')
       add_entry('have', 'IrregularVerbHave')
       add_entry('happen', 'RegularVerb')
-      add_entry('hear', 'IrregularLinkingVerb')
+      add_entry('hear', 'IrregularLinkingVerb') do
+        forms past_simple: 'heard', past_participle: 'heard'
+      end
       add_entry('here', 'Adverb')
       # example: ...from here (works as a pronoun of a place)
       add_entry('here', 'CommonNoun', {'NUMBER' => enumeration(:singular),

data/lib/zenlish/version.rb

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

data/lib/zenlish/wclasses/irregular_verb_be.rb

@@ -4,6 +4,59 @@ module Zenlish
   module WClasses
     # The `be` verb used as a lexical verb (as opposed auxiliary verb).
     class IrregularVerbBe < IrregularVerb
+      def initialize
+        super()
+      end
+
+      # The mix-in module used to extend the lexeme
+      # @return [Module, NilClass]
+      def extension
+        nil
+      end
+
+      private
+
+      def init_feature_defs
+        super
+        # Create standard feature definitions for irregular verbs.
+        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
+
+      def add_paradigm(anInflectionTable)
+        @paradigms[anInflectionTable.name] = anInflectionTable
+      end
     end # class
+=begin
+
+
+
+      private
+
+
+
+
+=end
   end # module
 end # module

data/lib/zenlish/wclasses/irregular_verb_do.rb

@@ -4,6 +4,46 @@ module Zenlish
   module WClasses
     # The `do` verb used as a lexical verb (as opposed auxiliary verb).
     class IrregularVerbDo < IrregularVerb
+      def initialize
+        super()
+      end
+      
+      # The mix-in module used to extend the lexeme
+      # @return [Module, NilClass]
+      def extension
+        nil
+      end      
+
+      private
+
+      def init_feature_defs
+        super
+        # Create standard feature definitions for irregular verbs.
+        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
+
+      def add_paradigm(anInflectionTable)
+        @paradigms[anInflectionTable.name] = anInflectionTable
+      end    
     end # class
   end # module
 end # module

data/lib/zenlish/wclasses/irregular_verb_have.rb

@@ -4,6 +4,46 @@ module Zenlish
   module WClasses
     # The `have` verb used as a lexical verb (as opposed auxiliary verb).
     class IrregularVerbHave < IrregularVerb
+      def initialize
+        super()
+      end
+      
+      # The mix-in module used to extend the lexeme
+      # @return [Module, NilClass]
+      def extension
+        nil
+      end      
+
+      private
+
+      def init_feature_defs
+        super
+        # Create standard feature definitions for irregular verbs.
+        feature_def_dsl {
+          feature_def 'PARADIGM' => [identifier, 'Verb_have_inflection'] # 2nd item is default value
+        }
+      end
+
+      def init_paradigms
+        builder = Inflect::InflectionTableBuilder.new
+        table = builder.build('Verb_have_inflection') do
+          feature_heading 'PERSON'
+          feature_heading 'NUMBER'
+          feature_heading 'TIME'
+          #     PERSON              NUMBER             TIME
+          rule([not_equal(:third), equals(:singular), equals(:present)         ], literal('have'))
+          rule([equals(:third),    equals(:singular), equals(:present)        ], literal('has'))
+          rule([dont_care,         equals(:plural),   equals(:present)        ], literal('have'))
+          rule([dont_care,         dont_care,         equals(:progressive)    ], literal('having'))
+          rule([dont_care,         dont_care,         equals(:past_simple)    ], literal('had'))          
+          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
 end # module

data/spec/zenlish/lang/dictionary_spec.rb

@@ -27,16 +27,21 @@ module Zenlish
           expect(common_nouns.all? { |c_n| lemmas.include?(c_n) }).to be_truthy
         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] }
+        let(:present_1sg)     { [:first,  :singular, :present, nil] }
+        let(:present_2sg)     { [:second, :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)     { [:first,  :singular, :past_simple, nil] }
+        let(:past_simple_2sg) { [:second, :singular, :past_simple, nil] }
+        let(:past_simple_3sg) { [:third,  :singular, :past_simple, nil] }
+        let(:past_simple_1pl) { [:first,  :plural,   :past_simple, nil] }         
+        let(:past_participle) { [nil,     nil,       :past_participle, nil] }
 
-        def test_inflection_of(verb_lexeme, pairs)
+        def test_inflection_of(verb_lexeme, pairs, drop_last_column = false)
           pairs.each do |(constraints, expected_form)|
-            expect(verb_lexeme.inflect(constraints)).to eq(expected_form)
+            restriction = drop_last_column ? constraints.slice(0..-2) : constraints
+            expect(verb_lexeme.inflect(restriction)).to eq(expected_form)
           end
         end
 
@@ -61,8 +66,37 @@ module Zenlish
             [past_simple,     'did'],
             [past_participle, 'done']
           ]
-          test_inflection_of(lexm, expectations_2)          
+          test_inflection_of(lexm, expectations_2, true)
+
+          lexm = subject.get_lexeme('have', WClasses::IrregularVerbHave)
+          expectations_3 = [
+            [present_1sg,     'have'],
+            [present_3sg,     'has'],
+            [present_1pl,     'have'],
+            [progressive,     'having'],
+            [past_simple,     'had'],
+            [past_participle, 'had']
+          ]
+          test_inflection_of(lexm, expectations_3, true)           
+        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)        
         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.02
+  version: 0.2.03
 platform: ruby
 authors:
 - Dimitri Geshef
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2020-02-06 00:00:00.000000000 Z
+date: 2020-02-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rley