zenlish 0.2.02 → 0.2.06

data/spec/zenlish/inflect/function_call_spec.rb

@@ -13,7 +13,7 @@ module Zenlish
         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
@@ -21,12 +21,12 @@ module Zenlish
 
       context 'Provided services:' do
         it 'should return the affix during word form generation' do
-          headings = double('fake-headings')        
-          lexeme = OpenStruct.new(:greet => 'Hello, world')
+          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
+end # module

data/spec/zenlish/inflect/inflection_rule_spec.rb

@@ -17,6 +17,8 @@ require_relative '../../../lib/zenlish/inflect/inflection_rule'
 
 module Zenlish
   module Inflect
+    # rubocop: disable Naming/VariableNumber
+
     describe InflectionRule do
       # One rule in row representation:
       # | plural   | ~ /[^aeiouy]y$/ | sub(base_form, /y$/, "ies")|
@@ -26,7 +28,7 @@ module Zenlish
       let(:method_name) { 'base_form' }
       let(:heading1) { MethodHeading.new(method_name) }
       let(:headings) { [heading0, heading1] }
-      
+
       # Condition part
       let(:feature_value) { :plural }
       let(:arg_0) { FormalArgument.new(0) }
@@ -46,8 +48,9 @@ module Zenlish
 
       context 'Initialization:' do
         it 'should be initialized with condition and consequent parts' do
-          expect { InflectionRule.new(conditions, consequent)
-            }.not_to raise_error
+          expect do
+            InflectionRule.new(conditions, consequent)
+          end.not_to raise_error
         end
 
         it 'should know its condition part' do
@@ -82,7 +85,7 @@ module Zenlish
           actuals = [:plural, 'cherry']
           expect(subject.apply(headings, fake_lexeme, actuals)).to eq('cherries')
         end
-        
+
         it 'should succeed when all conditions succeed for given lexeme' do
           expect(subject.success?(headings, lexeme, [])).to be_truthy
         end
@@ -95,8 +98,9 @@ module Zenlish
 
         it 'should generate inflected form when rule works for given lexeme' do
           expect(subject.apply(headings, lexeme, [])).to eq('cherries')
-        end        
+        end
       end # context
     end # describe
+    # rubocop: enable Naming/VariableNumber
   end # module
 end # module

data/spec/zenlish/inflect/inflection_table_builder_spec.rb

@@ -5,6 +5,9 @@ require_relative '../../../lib/zenlish/inflect/inflection_table_builder'
 
 module Zenlish
   module Inflect
+    # rubocop: disable Layout/SpaceInsideParens
+    # rubocop: disable Naming/VariableNumber
+
     describe InflectionTableBuilder do
       subject { InflectionTableBuilder.new }
 
@@ -95,7 +98,7 @@ module Zenlish
           expect(conds_2[1]).to be_kind_of(UnconditionallyTrue)
         end
 
-        MockFeatureBearer = Struct.new(:NUMBER, :base_form)
+        let(:mock_feature_bearer) { Struct.new(:NUMBER, :base_form) }
 
         it 'should build default paradigm for common nouns' do
           table = subject.build('Common_form') do
@@ -106,22 +109,22 @@ module Zenlish
             rule([equals(:plural), dont_care], concat(col('base_form'), 's'))
           end
 
-          mck_1 = MockFeatureBearer.new(:singular, 'animal')
+          mck_1 = mock_feature_bearer.new(:singular, 'animal')
           expect(table.inflect(mck_1, [nil, nil])).to eq('animal')
           mck_1['NUMBER'] = :plural
           expect(table.inflect(mck_1, [nil, nil])).to eq('animals')
 
-          mck_2 = MockFeatureBearer.new(:singular, 'boy')
+          mck_2 = mock_feature_bearer.new(:singular, 'boy')
           expect(table.inflect(mck_2, [nil, nil])).to eq('boy')
           mck_2['NUMBER'] = :plural
           expect(table.inflect(mck_2, [nil, nil])).to eq('boys')
 
-          mck_3 = MockFeatureBearer.new(:singular, 'body')
+          mck_3 = mock_feature_bearer.new(:singular, 'body')
           expect(table.inflect(mck_3, [nil, nil])).to eq('body')
           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
@@ -132,15 +135,15 @@ module Zenlish
             #     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([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), 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')
@@ -148,7 +151,7 @@ module Zenlish
           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')
@@ -158,7 +161,7 @@ module Zenlish
           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, [: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')
@@ -171,9 +174,9 @@ module Zenlish
           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')          
+          expect(table.inflect(verb_4, [nil,    nil,     :past_participle, nil])).to eq('caused')
         end
-        
+
         MockIrregularVerb = Struct.new(:base_form, :PERSON, :NUMBER, :TIME, :past_simple, :past_participle)
         it 'should build default paradigm for irregular verbs' do
           table = subject.build('Irregular_inflection') do
@@ -184,12 +187,12 @@ module Zenlish
             #     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([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,         equals(:past_simple),     dont_care], func('past_simple'))             
-            rule([dont_care,         dont_care,         equals(:past_participle), dont_care], func('past_participle'))                       
+            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
 
           verb_1 = MockIrregularVerb.new('choose', :first, :singular, :present, 'chose', 'chosen')
@@ -202,5 +205,7 @@ module Zenlish
         end
       end # context
     end # describe
+    # rubocop: enable Naming/VariableNumber
+    # rubocop: enable  Layout/SpaceInsideParens
   end # module
-end # module
+end # module

data/spec/zenlish/inflect/inflection_table_spec.rb

@@ -1,5 +1,8 @@
 # frozen_string_literal: true
 
+require_relative '../../../lib/zenlish/lex/lexical_entry'
+require_relative '../../../lib/zenlish/lex/lexeme'
+require_relative '../../../lib/zenlish/wclasses/common_noun'
 require_relative '../../../lib/zenlish/inflect/feature_heading'
 require_relative '../../../lib/zenlish/inflect/method_heading'
 require_relative '../../../lib/zenlish/inflect/unconditionally_true'
@@ -16,6 +19,8 @@ require_relative '../../../lib/zenlish/inflect/inflection_table'
 
 module Zenlish
   module Inflect
+    # rubocop: disable Naming/VariableNumber
+
     describe InflectionTable do
       let(:table_name) { 'Common_form' }
       subject { InflectionTable.new(table_name) }
@@ -50,9 +55,9 @@ module Zenlish
         let(:heading1) { MethodHeading.new(method_name) }
         let(:arg_0) { FormalArgument.new(0) }
         let(:arg_1) { FormalArgument.new(1) }
-        let(:feat_val_a) { 'singular' }
-        let(:feat_val_b) { 'plural' }
-        let(:feat_val_c) { 'plural' }
+        let(:feat_val_a) { :singular }
+        let(:feat_val_b) { :plural }
+        let(:feat_val_c) { :plural }
         let(:cond_a_0) { EqualsLiteral.new(arg_0, feat_val_a) }
         let(:cond_b_0) { EqualsLiteral.new(arg_0, feat_val_b) }
         let(:cond_c_0) { EqualsLiteral.new(arg_0, feat_val_c) }
@@ -71,7 +76,11 @@ module Zenlish
         let(:rule_a) { InflectionRule.new([cond_a_0, cond_a_1], cons_a) }
         let(:rule_b) { InflectionRule.new([cond_b_0, cond_b_1], cons_b) }
         let(:rule_c) { InflectionRule.new([cond_c_0, cond_c_1], cons_c) }
-        MockFeatureBearer = Struct.new(:NUMBER, :base_form)
+        let(:a_wclass) { WClasses::CommonNoun.new }
+        let(:a_lemma) { 'body' }
+        let(:an_entry) { Lex::LexicalEntry.new(a_lemma) }
+        let(:lexm_body) { Lex::Lexeme.new(a_wclass, an_entry) }
+        let(:mock_feature_bearer) { Struct.new(:NUMBER, :base_form) }
 
         it 'should accept the addition of heading(s)' do
           expect { subject.add_heading(heading0) }.not_to raise_error
@@ -89,6 +98,14 @@ module Zenlish
           expect(subject.rules.last).to eq(rule_c)
         end
 
+        def init_table(aTable)
+          aTable.add_heading(heading0)
+          aTable.add_heading(heading1)
+          aTable.add_rule(rule_a)
+          aTable.add_rule(rule_b)
+          aTable.add_rule(rule_c)
+        end
+
         # DecisionTable: Common_form
         # | NUMBER   | .base_form      | Common_form                |
         # | singular | X               | base_form                  |
@@ -103,27 +120,27 @@ module Zenlish
         #   rule(equals(:plural)  , dont_care             , concat(col(1), 's'))
         # end
         it 'should determine the word form given input entries' do
-          subject.add_heading(heading0)
-          subject.add_heading(heading1)
-          subject.add_rule(rule_a)
-          subject.add_rule(rule_b)
-          subject.add_rule(rule_c)
-          mck_1 = MockFeatureBearer.new('singular', 'animal')
-          expect(subject.inflect(mck_1, [nil, nil])).to eq('animal')
-          mck_1['NUMBER'] = 'plural'
-          expect(subject.inflect(mck_1, [nil, nil])).to eq('animals')
+          init_table(subject)
+          mck1 = mock_feature_bearer.new(:singular, 'animal')
+          expect(subject.inflect(mck1, [nil, nil])).to eq('animal')
+          mck1['NUMBER'] = :plural
+          expect(subject.inflect(mck1, [nil, nil])).to eq('animals')
 
-          mck_2 = MockFeatureBearer.new('singular', 'boy')
-          expect(subject.inflect(mck_2, [nil, nil])).to eq('boy')
-          mck_2['NUMBER'] = 'plural'
-          expect(subject.inflect(mck_2, [nil, nil])).to eq('boys')
+          mck2 = mock_feature_bearer.new(:singular, 'boy')
+          expect(subject.inflect(mck2, [nil, nil])).to eq('boy')
+          mck2['NUMBER'] = :plural
+          expect(subject.inflect(mck2, [nil, nil])).to eq('boys')
+
+          expect(subject.inflect(lexm_body, [:singular, nil])).to eq('body')
+          expect(subject.inflect(lexm_body, [:plural, nil])).to eq('bodies')
+        end
 
-          mck_3 = MockFeatureBearer.new('singular', 'body')
-          expect(subject.inflect(mck_3, [nil, nil])).to eq('body')
-          mck_3['NUMBER'] = 'plural'
-          expect(subject.inflect(mck_3, [nil, nil])).to eq('bodies')
+        it 'should know all the word forms of a given lexeme' do
+          init_table(subject)
+          expect(subject.all_inflections(lexm_body)).to eq(%w[body bodies])
         end
       end # context
     end # describe
+    # rubocop: enable Naming/VariableNumber
   end # module
-end # module
+end # module

data/spec/zenlish/inflect/input_asis_spec.rb

@@ -31,7 +31,7 @@ module Zenlish
           headings = double('fake-headings')
           expect(subject.generate(headings, lexeme, sample_values)).to eq('Hello, world.')
         end
-        
+
         it 'should return the text of given lexeme during generation' do
           c_noun = WClasses::CommonNoun.new
           an_entry = Lex::LexicalEntry.new('cherry')
@@ -40,11 +40,7 @@ module Zenlish
           headings = [nil, nil, heading, nil]
           expect(subject.generate(headings, lexeme, [])).to eq('cherry')
         end
-        
-=begin
-
-=end        
       end # context
     end # describe
   end # module
-end # module
+end # module

data/spec/zenlish/inflect/literal_asis_spec.rb

@@ -12,7 +12,7 @@ module Zenlish
         it 'should be initialized with a text literal' do
           expect { LiteralAsIs.new('s') }.not_to raise_error
         end
-        
+
         it 'should know its text value' do
           expect(subject.text).to eq('s')
         end
@@ -20,7 +20,7 @@ module Zenlish
 
       context 'Provided services:' do
         it 'should return the affix during word form generation' do
-          headings = double('fake-headings')        
+          headings = double('fake-headings')
           lexeme = double('fake-lexeme')
           values = double('fake-values')
           expect(subject.generate(headings, lexeme, values)).to eq('s')
@@ -28,4 +28,4 @@ module Zenlish
       end # context
     end # describe
   end # module
-end # module
+end # module

data/spec/zenlish/inflect/matches_pattern_spec.rb

@@ -58,4 +58,4 @@ module Zenlish
       end # context
     end # describe
   end # module
-end # module
+end # module

data/spec/zenlish/inflect/membership_spec.rb

@@ -12,7 +12,7 @@ module Zenlish
   module Inflect
     describe Membership do
       let(:an_argument) { FormalArgument.new(1) }
-      let(:feat_val) { [:singular, :plural] }
+      let(:feat_val) { %i[singular plural] }
       subject { Membership.new(an_argument, feat_val) }
 
       context 'Initialization:' do
@@ -38,7 +38,7 @@ module Zenlish
           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          
+          expect(subject.success?(headings, lexeme, actual_args)).to be_falsy
         end
 
         # it 'should test the lexeme' do

data/spec/zenlish/inflect/method_heading_spec.rb

@@ -25,7 +25,13 @@ module Zenlish
           expect(mocked).to receive(:base_form).and_return('cherry')
           expect(subject.evaluate_for(mocked)).to eq('cherry')
         end
+
+        it 'should obtain the method result as an array' do
+          mocked = double('dummy-lexeme')
+          expect(mocked).to receive(:base_form).and_return('cherry')
+          expect(subject.all_matches(mocked)).to eq(['cherry'])
+        end
       end # context
     end # describe
   end # module
-end # module
+end # module

data/spec/zenlish/inflect/substitution_spec.rb

@@ -40,4 +40,4 @@ module Zenlish
       end # context
     end # describe
   end # module
-end # module
+end # module

data/spec/zenlish/inflect/unconditionally_true_spec.rb

@@ -11,7 +11,7 @@ module Zenlish
 
       context 'Initialization:' do
         it 'should be initialized without argument' do
-          expect { UnconditionallyTrue.new}.not_to raise_error
+          expect { UnconditionallyTrue.new }.not_to raise_error
         end
       end # context
 
@@ -25,4 +25,4 @@ module Zenlish
       end # context
     end # describe
   end # module
-end # module
+end # module

data/spec/zenlish/lang/dictionary_spec.rb

@@ -12,8 +12,8 @@ module Zenlish
       context 'Provided services:' do
         let(:common_nouns) do
           # Some Zenlish common nouns
-          %w( animal body container here kind machine moment now part people
-              person place side surface thing time word)
+          %w(animal body container here kind machine moment now part people
+            person place side surface thing time word)
         end
 
         it 'should give the list of common nouns' do
@@ -27,22 +27,27 @@ 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
 
         it 'should know how to inflect an (irregular) verb' do
           lexm = subject.get_lexeme('become')
-          expectations_1 = [
+          expectations1 = [
             [present_1sg,     'become'],
             [present_3sg,     'becomes'],
             [present_1pl,     'become'],
@@ -50,10 +55,10 @@ module Zenlish
             [past_simple,     'became'],
             [past_participle, 'become']
           ]
-          test_inflection_of(lexm, expectations_1)
-          
+          test_inflection_of(lexm, expectations1)
+
           lexm = subject.get_lexeme('do', WClasses::IrregularVerbDo)
-          expectations_2 = [
+          expectations2 = [
             [present_1sg,     'do'],
             [present_3sg,     'does'],
             [present_1pl,     'do'],
@@ -61,9 +66,39 @@ module Zenlish
             [past_simple,     'did'],
             [past_participle, 'done']
           ]
-          test_inflection_of(lexm, expectations_2)          
+          test_inflection_of(lexm, expectations2, true)
+
+          lexm = subject.get_lexeme('have', WClasses::IrregularVerbHave)
+          expectations3 = [
+            [present_1sg,     'have'],
+            [present_3sg,     'has'],
+            [present_1pl,     'have'],
+            [progressive,     'having'],
+            [past_simple,     'had'],
+            [past_participle, 'had']
+          ]
+          test_inflection_of(lexm, expectations3, true)
+        end
+
+        it 'should know how to inflect the verb be' do
+          [WClasses::IrregularVerbBe, WClasses::AuxiliaryBe].each do |wclass|
+            lexm = subject.get_lexeme('be', wclass)
+            expectations1 = [
+              [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, expectations1, true)
+          end
         end
       end # context
     end # describe
   end # module
-end # module
+end # module