zenlish 0.2.05 → 0.2.07

data/spec/zenlish/wclasses/modal_verb_can_spec.rb

@@ -10,24 +10,24 @@ require_relative '../../../lib/zenlish/wclasses/modal_verb_can'
 module Zenlish
   module WClasses
     describe ModalVerbCan do
-      subject { ModalVerbCan.new }
+      subject(:modal_can) { described_class.new }
 
       context 'Initialization:' do
-        it 'should be initialized without argument' do
-          expect { ModalVerbCan.new }.not_to raise_error
+        it 'is initialized without argument' do
+          expect { described_class.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')
+        it 'knows its inherited feature definitions' do
+          expect(modal_can['NUMBER']).to be_a(Feature::FeatureDef)
+          expect(modal_can['PERSON']).to be_a(Feature::FeatureDef)
+          expect(modal_can['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)
+          Zenlish::Lex::Lexeme.new(modal_can, entry)
         end
 
         def test_inflection_of(verb_form, pairs)
@@ -37,14 +37,14 @@ module Zenlish
           end
         end
 
-        it 'should know how to inflect modal verb can' do
-          expectations_1 = [
+        it 'knows how to inflect modal verb can' do
+          expectations1 = [
             [:present,     'can'],
             [:past_simple, 'could']
           ]
-          test_inflection_of('can', expectations_1)
+          test_inflection_of('can', expectations1)
         end
       end # context
     end # describe
   end # module
-end # module
+end # module

data/spec/zenlish/wclasses/noun_spec.rb

@@ -6,23 +6,23 @@ require_relative '../../../lib/zenlish/wclasses/noun' # Load the class under tes
 module Zenlish
   module WClasses
     describe Noun do
-      subject { Noun.new }
+      subject(:noun) { described_class.new }
 
       context 'Initialization:' do
-        it 'should be initialized without argument' do
-          expect { Noun.new }.not_to raise_error
+        it 'is initialized without argument' do
+          expect { described_class.new }.not_to raise_error
         end
       end # context
 
       context 'Provided services:' do
-        it 'should know that it is variable (has inflected forms)' do
-          expect(subject).not_to be_invariable
+        it 'knows that it is variable (has inflected forms)' do
+          expect(noun).not_to be_invariable
         end
 
-        it 'should know its feature names' do
+        it 'knows its feature names' do
           expectations = %w(NUMBER COUNTABILITY)
           expectations.each do |name|
-            expect(subject[name]).not_to be_nil
+            expect(noun[name]).not_to be_nil
           end
         end
       end # context

data/spec/zenlish/wclasses/personal_pronoun_spec.rb

@@ -10,22 +10,22 @@ module Zenlish
   module WClasses
     describe PersonalPronoun do
       include Feature::FeatureStructDefBearer
-      subject { PersonalPronoun.new }
+      subject(:pronoun) { described_class.new }
 
       context 'Initialization:' do
-        it 'should be initialized without argument' do
-          expect { PersonalPronoun.new }.not_to raise_error
+        it 'is initialized without argument' do
+          expect { described_class.new }.not_to raise_error
         end
 
-        it 'should know that it is inflectable' do
-          expect(subject).not_to be_invariable
+        it 'knows that it is inflectable' do
+          expect(pronoun).not_to be_invariable
         end
       end # context
 
       context 'Provided services:' do
         def build_ppn(aBaseForm, aFeatureHash)
           entry = Zenlish::Lex::LexicalEntry.new(aBaseForm)
-          lexeme = Zenlish::Lex::Lexeme.new(subject, entry, aFeatureHash)
+          Zenlish::Lex::Lexeme.new(pronoun, entry, aFeatureHash)
         end
 
         def test_all_inflections(det_form, aFeatureHash, wforms)
@@ -34,34 +34,31 @@ module Zenlish
           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')
+        it 'knows its feature definitions' do
+          expect(pronoun['NUMBER']).to be_a(Feature::FeatureDef)
+          expect(pronoun['PERSON']).to be_a(Feature::FeatureDef)
+          expect(pronoun['GENDER']).to be_a(Feature::FeatureDef)
+          expect(pronoun['CASE']).to be_a(Feature::FeatureDef)
+          expect(pronoun['PARADIGM'].default.val).to eq('ppn_1st_paradigm')
         end
 
-        it 'should give all word forms for the first person' do
+        it 'gives all word forms for the first person' do
           feature_defs = { 'PERSON' => enumeration(:first),
-            'GENDER' => enumeration(:feminine, :masculine)
-          }
-          test_all_inflections('I', feature_defs, ['I', 'we', 'me', 'us'])
+            '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
+        it 'gives all word forms for the second person' do
           feature_defs = { 'PERSON' => enumeration(:second),
             'GENDER' => enumeration(:feminine, :masculine),
-            'PARADIGM' => [identifier, 'ppn_2nd_paradigm']
-          }
+            'PARADIGM' => [identifier, 'ppn_2nd_paradigm'] }
           test_all_inflections('you', feature_defs, ['you'])
         end
 
-        it 'should give all word forms for the third person' do
+        it 'gives all word forms for the third person' do
           feature_defs = { 'PERSON' => enumeration(:third),
-            'PARADIGM' => [identifier, 'ppn_3rd_paradigm']
-          }
-          test_all_inflections('it', feature_defs, ['she', 'he', 'it', 'they', 'her', 'him', 'them'])
+            'PARADIGM' => [identifier, 'ppn_3rd_paradigm'] }
+          test_all_inflections('it', feature_defs, %w[she he it they her him them])
         end
       end # context
     end # describe

data/spec/zenlish/wclasses/possessive_determiner_spec.rb

@@ -10,60 +10,57 @@ module Zenlish
   module WClasses
     describe PossessiveDeterminer do
       include Feature::FeatureStructDefBearer
-      subject { PossessiveDeterminer.new }
+      subject(:determiner) { described_class.new }
 
       context 'Initialization:' do
-        it 'should be initialized without argument' do
-          expect { PossessiveDeterminer.new }.not_to raise_error
+        it 'is initialized without argument' do
+          expect { described_class.new }.not_to raise_error
         end
       end # context
 
-      context 'Provided services:' do       
+      context 'Provided services:' do
         def build_det(aBaseForm, aFeatureHash)
           entry = Zenlish::Lex::LexicalEntry.new(aBaseForm)
-          lexeme = Zenlish::Lex::Lexeme.new(subject, entry, aFeatureHash)
+          Zenlish::Lex::Lexeme.new(determiner, 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        
+        end
 
-        it 'should know that it is inflectable' do
-          expect(subject).not_to be_invariable
+        it 'knows that it is inflectable' do
+          expect(determiner).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')       
+        it 'knows its feature definitions' do
+          expect(determiner['NUMBER']).to be_a(Feature::FeatureDef)
+          expect(determiner['PERSON']).to be_a(Feature::FeatureDef)
+          expect(determiner['GENDER']).to be_a(Feature::FeatureDef)
+          expect(determiner['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, ['my', 'our'])
+
+        it 'gives 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), 
+
+        it 'gives all word forms for the second person' do
+          feature_defs = { 'PERSON' => enumeration(:second),
             'GENDER' => enumeration(:feminine, :masculine),
-            'PARADIGM' => [identifier, 'possdet_2nd_paradigm']            
-          }
+            '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, ['its', 'her', 'his', 'their'])
-        end        
+        it 'gives 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
+        # it 'gives all word forms' do
           # test_all_inflections('this', ['this', 'that', 'these', 'those'])
         # end
       end # context

data/spec/zenlish/wclasses/preposition_spec.rb

@@ -6,17 +6,17 @@ require_relative '../../../lib/zenlish/wclasses/preposition' # Load the class un
 module Zenlish
   module WClasses
     describe Preposition do
-      subject { Preposition.new }
+      subject(:preposition) { described_class.new }
 
       context 'Initialization:' do
-        it 'should be initialized without argument' do
-          expect { Preposition.new }.not_to raise_error
+        it 'is initialized without argument' do
+          expect { described_class.new }.not_to raise_error
         end
       end # context
 
       context 'Provided services:' do
-        it 'should know that it is invariable' do
-          expect(subject).to be_invariable
+        it 'is invariable' do
+          expect(preposition).to be_invariable
         end
       end # context
     end # describe

data/spec/zenlish/wclasses/proper_noun_spec.rb

@@ -6,11 +6,11 @@ require_relative '../../../lib/zenlish/wclasses/proper_noun' # Load the class un
 module Zenlish
   module WClasses
     describe ProperNoun do
-      subject { ProperNoun.new }
+      subject { described_class.new }
 
       context 'Initialization:' do
-        it 'should be initialized without argument' do
-          expect { ProperNoun.new }.not_to raise_error
+        it 'is initialized without argument' do
+          expect { described_class.new }.not_to raise_error
         end
       end # context
 

data/spec/zenlish/wclasses/regular_verb_spec.rb

@@ -10,31 +10,25 @@ require_relative '../../../lib/zenlish/wclasses/regular_verb'
 module Zenlish
   module WClasses
     describe RegularVerb do
-      subject { RegularVerb.new }
+      subject(:regular_verb) { described_class.new }
 
       context 'Initialization:' do
-        it 'should be initialized without argument' do
-          expect { RegularVerb.new }.not_to raise_error
+        it 'is initialized without argument' do
+          expect { described_class.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] }        
-        
+        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(regular_verb, entry)
         end
 
         def test_inflection_of(verb_form, pairs)
@@ -43,15 +37,21 @@ module Zenlish
             expect(verb.inflect(constraints)).to eq(expected_form)
           end
         end
-        
+
         def test_all_inflections(verb_form, wforms)
           verb = build_verb(verb_form)
           inflected = verb.all_inflections
           expect(inflected.sort).to eq(wforms.sort)
         end
 
-        it 'should know how to inflect regular verbs' do
-          expectations_1 = [
+        it 'knows its inherited feature definitions' do
+          expect(regular_verb['NUMBER']).to be_a(Feature::FeatureDef)
+          expect(regular_verb['PERSON']).to be_a(Feature::FeatureDef)
+          expect(regular_verb['PARADIGM'].default.val).to eq('Regular_inflection')
+        end
+
+        it 'knows how to inflect regular verbs' do
+          expectations1 = [
             [present_1sg,     'exist'],
             [present_3sg,     'exists'],
             [present_1pl,     'exist'],
@@ -59,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'],
@@ -69,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'],
@@ -79,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'],
@@ -89,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'],
@@ -99,9 +99,9 @@ module Zenlish
             [past_simple, 'died'],
             [past_participle, 'died']
           ]
-          test_inflection_of('die', expectations_5)
+          test_inflection_of('die', expectations5)
 
-          expectations_6 = [
+          expectations6 = [
             [present_1sg, 'want'],
             [present_3sg, 'wants'],
             [present_1pl, 'want'],
@@ -109,13 +109,13 @@ module Zenlish
             [past_simple, 'wanted'],
             [past_participle, 'wanted']
           ]
-          test_inflection_of('want', expectations_6)          
+          test_inflection_of('want', expectations6)
         end
-        
-        it 'should give all word forms of a given verb' do
-          test_all_inflections('die', ['die', 'dies', 'dying', 'died'])
+
+        it 'gives 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(:the_verb) { described_class.new }
+
+      context 'Initialization:' do
+        it 'is initialized without argument' do
+          expect { described_class.new }.not_to raise_error
+        end
+      end # context
+
+      context 'Provided services:' do
+        it 'knows its inherited feature definitions' do
+          expect(the_verb['NUMBER']).to be_a(Feature::FeatureDef)
+          expect(the_verb['PERSON']).to be_a(Feature::FeatureDef)
+          expect(the_verb['PARADIGM'].default.val).to eq('Regular_inflection')
+        end
+      end # context
+    end # describe
+  end # module
+end # module

data/spec/zenlish/wclasses/verb_spec.rb

@@ -13,23 +13,23 @@ module Zenlish
     end
 
     describe Verb do
-      subject { Verb.new }
+      subject(:a_verb) { described_class.new }
 
       context 'Initialization:' do
-        it 'should be initialized without argument' do
-          expect { Verb.new }.not_to raise_error
+        it 'is initialized without argument' do
+          expect { described_class.new }.not_to raise_error
         end
       end # context
 
       context 'Provided services:' do
-        it 'should know that it has inflected forms' do
-          expect(subject).not_to be_invariable
+        it 'knows that it has inflected forms' do
+          expect(a_verb).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')
+        it 'knows its feature definitions' do
+          expect(a_verb['NUMBER']).to be_a(Feature::FeatureDef)
+          expect(a_verb['PERSON']).to be_a(Feature::FeatureDef)
+          expect(a_verb['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
-    expect(Zenlish::VERSION).not_to be nil
+  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,31 @@ 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 = '>= 3.1.0'
+  spec.metadata = { 'rubygems_mfa_required' => 'true' }
+
   # Runtime dependencies
-  spec.add_dependency 'rley', '~> 0.7.06'  
+  spec.add_dependency 'rley', '~> 0.9', '>= 0.9.02'
 
-  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.4', '>= 2.4.1'
+  spec.add_development_dependency 'rake', '~> 13'
+  spec.add_development_dependency 'rspec', '~> 3', '>= 3.10.0'
 end