zenlish 0.2.02 → 0.2.06

data/spec/zenlish/wclasses/lexical_verb_spec.rb

@@ -3,10 +3,17 @@
 require_relative '../../spec_helper' # Use the RSpec framework
 
 # Load the class under test
-require_relative '../../../lib/zenlish/wclasses/lexical_verb' 
+require_relative '../../../lib/zenlish/wclasses/lexical_verb'
 
 module Zenlish
   module WClasses
+    class LexicalVerb
+      # Do limited monkeypatching, just for testing purposes
+      def init_paradigms
+        # Empty method
+      end
+    end
+
     describe LexicalVerb do
       subject { LexicalVerb.new }
 
@@ -20,7 +27,7 @@ module Zenlish
         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')           
+          expect(subject['PARADIGM'].default.val).to eq('Regular_inflection')
         end
       end # context
     end # describe

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)
+          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
+          expectations1 = [
+            [:present,     'can'],
+            [:past_simple, 'could']
+          ]
+          test_inflection_of('can', expectations1)
+        end
+      end # context
+    end # describe
+  end # module
+end # module

data/spec/zenlish/wclasses/personal_pronoun_spec.rb

@@ -0,0 +1,66 @@
+# 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/feature/feature_struct_def_bearer'
+require_relative '../../../lib/zenlish/wclasses/personal_pronoun' # Load the class under test
+
+module Zenlish
+  module WClasses
+    describe PersonalPronoun do
+      include Feature::FeatureStructDefBearer
+      subject { PersonalPronoun.new }
+
+      context 'Initialization:' do
+        it 'should be initialized without argument' do
+          expect { PersonalPronoun.new }.not_to raise_error
+        end
+
+        it 'should know that it is inflectable' do
+          expect(subject).not_to be_invariable
+        end
+      end # context
+
+      context 'Provided services:' do
+        def build_ppn(aBaseForm, aFeatureHash)
+          entry = Zenlish::Lex::LexicalEntry.new(aBaseForm)
+          Zenlish::Lex::Lexeme.new(subject, entry, aFeatureHash)
+        end
+
+        def test_all_inflections(det_form, aFeatureHash, wforms)
+          pronoun = build_ppn(det_form, aFeatureHash)
+          inflected = pronoun.all_inflections
+          expect(inflected.sort).to eq(wforms.sort)
+        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['GENDER']).to be_kind_of(Feature::FeatureDef)
+          expect(subject['CASE']).to be_kind_of(Feature::FeatureDef)
+          expect(subject['PARADIGM'].default.val).to eq('ppn_1st_paradigm')
+        end
+
+        it 'should give all word forms for the first person' do
+          feature_defs = { 'PERSON' => enumeration(:first),
+            'GENDER' => enumeration(:feminine, :masculine) }
+          test_all_inflections('I', feature_defs, %w[I we me us])
+        end
+
+        it 'should give all word forms for the second person' do
+          feature_defs = { 'PERSON' => enumeration(:second),
+            'GENDER' => enumeration(:feminine, :masculine),
+            'PARADIGM' => [identifier, 'ppn_2nd_paradigm'] }
+          test_all_inflections('you', feature_defs, ['you'])
+        end
+
+        it 'should give all word forms for the third person' do
+          feature_defs = { 'PERSON' => enumeration(:third),
+            'PARADIGM' => [identifier, 'ppn_3rd_paradigm'] }
+          test_all_inflections('it', feature_defs, %w[she he it they her him them])
+        end
+      end # context
+    end # describe
+  end # module
+end # module

data/spec/zenlish/wclasses/possessive_determiner_spec.rb

@@ -0,0 +1,69 @@
+# 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/feature/feature_struct_def_bearer'
+require_relative '../../../lib/zenlish/wclasses/possessive_determiner' # Load the class under test
+
+module Zenlish
+  module WClasses
+    describe PossessiveDeterminer do
+      include Feature::FeatureStructDefBearer
+      subject { PossessiveDeterminer.new }
+
+      context 'Initialization:' do
+        it 'should be initialized without argument' do
+          expect { PossessiveDeterminer.new }.not_to raise_error
+        end
+      end # context
+
+      context 'Provided services:' do
+        def build_det(aBaseForm, aFeatureHash)
+          entry = Zenlish::Lex::LexicalEntry.new(aBaseForm)
+          Zenlish::Lex::Lexeme.new(subject, entry, aFeatureHash)
+        end
+
+        def test_all_inflections(det_form, aFeatureHash, wforms)
+          pronoun = build_det(det_form, aFeatureHash)
+          inflected = pronoun.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['PERSON']).to be_kind_of(Feature::FeatureDef)
+          expect(subject['GENDER']).to be_kind_of(Feature::FeatureDef)
+          expect(subject['PARADIGM'].default.val).to eq('possdet_1st_paradigm')
+        end
+
+        it 'should give all word forms for the first person' do
+          feature_defs = { 'PERSON' => enumeration(:first),
+            'GENDER' => enumeration(:feminine, :masculine) }
+          test_all_inflections('my', feature_defs, %w[my our])
+        end
+
+        it 'should give all word forms for the second person' do
+          feature_defs = { 'PERSON' => enumeration(:second),
+            'GENDER' => enumeration(:feminine, :masculine),
+            'PARADIGM' => [identifier, 'possdet_2nd_paradigm'] }
+          test_all_inflections('your', feature_defs, ['your'])
+        end
+
+        it 'should give all word forms for the third person' do
+          feature_defs = { 'PERSON' => enumeration(:third),
+            'PARADIGM' => [identifier, 'possdet_3rd_paradigm'] }
+          test_all_inflections('its', feature_defs, %w[its her his their])
+        end
+
+        # it 'should give all word forms' do
+          # test_all_inflections('this', ['this', 'that', 'these', 'those'])
+        # end
+      end # context
+    end # describe
+  end # module
+end # module

data/spec/zenlish/wclasses/regular_verb_spec.rb

@@ -24,17 +24,17 @@ module Zenlish
           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] }        
-        
+        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)
+          Zenlish::Lex::Lexeme.new(subject, entry)
         end
 
         def test_inflection_of(verb_form, pairs)
@@ -44,8 +44,14 @@ module Zenlish
           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 regular verbs' do
-          expectations_1 = [
+          expectations1 = [
             [present_1sg,     'exist'],
             [present_3sg,     'exists'],
             [present_1pl,     'exist'],
@@ -53,9 +59,9 @@ module Zenlish
             [past_simple,     'existed'],
             [past_participle, 'existed']
           ]
-          test_inflection_of('exist', expectations_1)
+          test_inflection_of('exist', expectations1)
 
-          expectations_2 = [
+          expectations2 = [
             [present_1sg, 'move'],
             [present_3sg, 'moves'],
             [present_1pl, 'move'],
@@ -63,9 +69,9 @@ module Zenlish
             [past_simple, 'moved'],
             [past_participle, 'moved']
           ]
-          test_inflection_of('move', expectations_2)
+          test_inflection_of('move', expectations2)
 
-          expectations_3 = [
+          expectations3 = [
             [present_1sg, 'try'],
             [present_3sg, 'tries'],
             [present_1pl, 'try'],
@@ -73,9 +79,9 @@ module Zenlish
             [past_simple, 'tried'],
             [past_participle, 'tried']
           ]
-          test_inflection_of('try', expectations_3)
+          test_inflection_of('try', expectations3)
 
-          expectations_4 = [
+          expectations4 = [
             [present_1sg, 'touch'],
             [present_3sg, 'touches'],
             [present_1pl, 'touch'],
@@ -83,9 +89,9 @@ module Zenlish
             [past_simple, 'touched'],
             [past_participle, 'touched']
           ]
-          test_inflection_of('touch', expectations_4)
+          test_inflection_of('touch', expectations4)
 
-          expectations_5 = [
+          expectations5 = [
             [present_1sg, 'die'],
             [present_3sg, 'dies'],
             [present_1pl, 'die'],
@@ -93,9 +99,23 @@ module Zenlish
             [past_simple, 'died'],
             [past_participle, 'died']
           ]
-          test_inflection_of('die', expectations_5)            
+          test_inflection_of('die', expectations5)
+
+          expectations6 = [
+            [present_1sg, 'want'],
+            [present_3sg, 'wants'],
+            [present_1pl, 'want'],
+            [progressive, 'wanting'],
+            [past_simple, 'wanted'],
+            [past_participle, 'wanted']
+          ]
+          test_inflection_of('want', expectations6)
+        end
+
+        it 'should give all word forms of a given verb' do
+          test_all_inflections('die', %w[die dies dying died])
         end
       end # context
     end # describe
   end # module
-end # module
+end # module

data/spec/zenlish/wclasses/regular_verb_want_spec.rb

@@ -0,0 +1,30 @@
+# 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_want'
+
+module Zenlish
+  module WClasses
+    describe RegularVerbWant do
+      subject { RegularVerbWant.new }
+
+      context 'Initialization:' do
+        it 'should be initialized without argument' do
+          expect { RegularVerbWant.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/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

data/spec/zenlish_spec.rb

@@ -1,5 +1,7 @@
+# frozen_string_literal: true
+
 RSpec.describe Zenlish do
-  it "has a version number" do
+  it 'has a version number' do
     expect(Zenlish::VERSION).not_to be nil
   end
 end

data/zenlish.gemspec

@@ -1,6 +1,8 @@
-lib = File.expand_path("../lib", __FILE__)
+# frozen_string_literal: true
+
+lib = File.expand_path('../lib', __FILE__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
-require "zenlish/version"
+require 'zenlish/version'
 
 # Implementation module
 module PkgExtending
@@ -14,7 +16,7 @@ module PkgExtending
       'Gemfile',
       'Rakefile',
       'CHANGELOG.md',
-      'CODE_OF_CONDUCT.md',      
+      'CODE_OF_CONDUCT.md',
       'LICENSE.txt',
       'README.md',
       'zenlish.gemspec',
@@ -34,29 +36,30 @@ module PkgExtending
   end
 end # module
 
-
 Gem::Specification.new do |spec|
   spec.name          = 'zenlish'
   spec.version       = Zenlish::VERSION
   spec.authors       = ['Dimitri Geshef']
   spec.email         = ['famished.tiger@yahoo.com']
 
-  spec.summary       = %q{A toolkit for the Zenlish language (a simplified English language).}
-  spec.description   = %q{A toolkit for the Zenlish language (a simplified English language).}
-  spec.homepage      = "https://github.com/famished-tiger/zenlish"
+  spec.summary       = 'A toolkit for the Zenlish language (a simplified English language).'
+  spec.description   = 'A toolkit for the Zenlish language (a simplified English language).'
+  spec.homepage      = 'https://github.com/famished-tiger/zenlish'
   spec.license       = 'MIT'
 
   spec.bindir        = 'exe'
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
-  spec.require_paths = ["lib"]
-  
+  spec.require_paths = ['lib']
+
   PkgExtending.pkg_files(spec)
   PkgExtending.pkg_documentation(spec)
-  
+
+  spec.required_ruby_version = '>= 2.5.0'
+
   # Runtime dependencies
-  spec.add_dependency 'rley', '~> 0.7.06'  
+  spec.add_dependency 'rley', '~> 0.8.03'
 
-  spec.add_development_dependency "bundler", "~> 2.0"
-  spec.add_development_dependency "rake", "~> 12.0"
-  spec.add_development_dependency "rspec", "~> 3.0"
+  spec.add_development_dependency 'bundler', '~> 2.0'
+  spec.add_development_dependency 'rake', '~> 12.0'
+  spec.add_development_dependency 'rspec', '~> 3.0'
 end