zenlish 0.1.25 → 0.2.00

data/spec/zenlish/inflect/inflection_rule_spec.rb

@@ -0,0 +1,102 @@
+# 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/method_heading'
+require_relative '../../../lib/zenlish/inflect/literal_asis'
+require_relative '../../../lib/zenlish/inflect/input_asis'
+require_relative '../../../lib/zenlish/inflect/equals_literal'
+require_relative '../../../lib/zenlish/inflect/formal_argument'
+require_relative '../../../lib/zenlish/inflect/matches_pattern'
+require_relative '../../../lib/zenlish/inflect/substitution'
+
+# Load the class under test
+require_relative '../../../lib/zenlish/inflect/inflection_rule'
+
+module Zenlish
+  module Inflect
+    describe InflectionRule do
+      # One rule in row representation:
+      # | plural   | ~ /[^aeiouy]y$/ | sub(base_form, /y$/, "ies")|
+      # Heading part
+      let(:feature_name) { 'NUMBER' }
+      let(:heading0) { FeatureHeading.new(feature_name) }
+      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) }
+      let(:cond_0) { EqualsLiteral.new(arg_0, feature_value) }
+      let(:arg_1) { FormalArgument.new(1) }
+      let(:patt) { /[^aeiouy]y$/ }
+      let(:cond_1) { MatchesPattern.new(arg_1, patt) }
+      let(:conditions) { [cond_0, cond_1] }
+
+      # Consequent part
+      let(:suffix) { LiteralAsIs.new('ies') }
+      let(:base) { InputAsIs.new(arg_1) }
+      let(:pattern) { /y$/ }
+      let(:consequent) { Substitution.new(base, pattern, suffix) }
+
+      subject { InflectionRule.new(conditions, consequent) }
+
+      context 'Initialization:' do
+        it 'should be initialized with condition and consequent parts' do
+          expect { InflectionRule.new(conditions, consequent)
+            }.not_to raise_error
+        end
+
+        it 'should know its condition part' do
+          expect(subject.conditions).to eq(conditions)
+        end
+
+        it 'should know its consequent part' do
+          expect(subject.consequent).to eq(consequent)
+        end
+      end # context
+
+      context 'Provided services:' do
+        let(:fake_lexeme) { double('dummy-fake_lexeme') }
+        let(:c_noun) { WClasses::CommonNoun.new }
+        let(:an_entry) { Lex::LexicalEntry.new('cherry') }
+        let(:lexeme) { Lex::Lexeme.new(c_noun, an_entry) }
+
+        it 'should succeed when all conditions succeed with actuals' do
+          actuals = [:plural, 'cherry']
+          expect(subject.success?(headings, fake_lexeme, actuals)).to be_truthy
+        end
+
+        it 'should fail when one condition fails with actuals' do
+          actuals = [:singular, 'cherry']
+          expect(subject.success?(headings, fake_lexeme, actuals)).to be_falsy
+
+          actuals = [:plural, 'girl']
+          expect(subject.success?(headings, fake_lexeme, actuals)).to be_falsy
+        end
+
+        it 'should generate inflected form when rule iworks for actuals' do
+          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
+
+        it 'should fail when one condition fails with given lexeme' do
+          entry_2 = Lex::LexicalEntry.new('animal')
+          lex_m2 = Lex::Lexeme.new(c_noun, entry_2)
+          expect(subject.success?(headings, lex_m2, [])).to be_falsy
+        end
+
+        it 'should generate inflected form when rule works for given lexeme' do
+          expect(subject.apply(headings, lexeme, [])).to eq('cherries')
+        end        
+      end # context
+    end # describe
+  end # module
+end # module

data/spec/zenlish/inflect/inflection_table_builder_spec.rb

@@ -0,0 +1,127 @@
+# frozen_string_literal: true
+
+# Load the class under test
+require_relative '../../../lib/zenlish/inflect/inflection_table_builder'
+
+module Zenlish
+  module Inflect
+    describe InflectionTableBuilder do
+      subject { InflectionTableBuilder.new }
+
+      context 'Initialization:' do
+        it 'should be initialized without argument' do
+          expect { InflectionTableBuilder.new }.not_to raise_error
+        end
+
+        it 'should not have headings after initialization' do
+          expect(subject.headings).to be_empty
+        end
+      end # context
+
+      context 'Basic services:' do
+        it 'should retain the table name' do
+          subject.build('Common_form')
+          expect(subject.table.name).to eq('Common_form')
+        end
+
+        it 'should accept heading creation' do
+          # First way
+          subject.feature_heading 'NUMBER'
+          expect(subject.headings.size).to eq(1)
+          expect(subject.headings.last.label).to eq('NUMBER')
+          subject.method_heading 'base_form'
+          expect(subject.headings.last).to be_kind_of(MethodHeading)
+          expect(subject.headings.last.label).to eq('base_form')
+
+          # Second way
+          table = subject.build('Common_form') do
+            feature_heading 'NUMBER'
+            method_heading 'base_form'
+          end
+          expect(table.name).to eq('Common_form')
+          expect(table.headings.last.label).to eq('base_form')
+        end
+      end # context
+
+      context 'Table building:' do
+        it 'should be able to build consequents' do
+          table = subject.build('Common_form') do
+            feature_heading 'NUMBER'
+            method_heading 'base_form'
+            rule([], col('base_form'))
+            rule([], sub(col('base_form'), /y$/, 'ies'))
+            rule([], concat(col('base_form'), 's'))
+          end
+          expect(table.rules).not_to be_empty
+          consequent_0 = table.rules[0].consequent
+          expect(consequent_0).to be_kind_of(InputAsIs)
+          expect(consequent_0.formal.index).to eq(1)
+
+          consequent_1 = table.rules[1].consequent
+          expect(consequent_1).to be_kind_of(Substitution)
+          expect(consequent_1.children[0].formal.index).to eq(1)
+          expect(consequent_1.pattern).to eq(/y$/)
+          expect(consequent_1.children[-1].text).to eq('ies')
+
+          consequent_2 = table.rules[2].consequent
+          expect(consequent_2.children[0].formal.index).to eq(1)
+          expect(consequent_2).to be_kind_of(Concatenation)
+          expect(consequent_2.children[-1].text).to eq('s')
+        end
+
+        it 'should be able to build conditions' do
+          table = subject.build('Common_form') do
+            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'))
+          end
+
+          conds_0 = table.rules[0].conditions
+          expect(conds_0[0]).to be_kind_of(EqualsLiteral)
+          expect(conds_0[0].literal).to eq(:singular)
+          expect(conds_0[1]).to be_kind_of(UnconditionallyTrue)
+
+          conds_1 = table.rules[1].conditions
+          expect(conds_1[0]).to be_kind_of(EqualsLiteral)
+          expect(conds_1[0].literal).to eq(:plural)
+          expect(conds_1[1]).to be_kind_of(MatchesPattern)
+          expect(conds_1[1].pattern).to eq(/[^aeiouy]y$/)
+
+          conds_2 = table.rules[2].conditions
+          expect(conds_2[0]).to be_kind_of(EqualsLiteral)
+          expect(conds_2[0].literal).to eq(:plural)
+          expect(conds_2[1]).to be_kind_of(UnconditionallyTrue)
+        end
+
+        MockFeatureBearer = Struct.new(:NUMBER, :base_form)
+
+        it 'should build tables conform to specs' do
+          table = subject.build('Common_form') do
+            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'))
+          end
+
+          mck_1 = MockFeatureBearer.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')
+          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')
+          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
+      end # context
+    end # describe
+  end # module
+end # module

data/spec/zenlish/inflect/inflection_table_spec.rb

@@ -0,0 +1,129 @@
+# frozen_string_literal: true
+
+require_relative '../../../lib/zenlish/inflect/feature_heading'
+require_relative '../../../lib/zenlish/inflect/method_heading'
+require_relative '../../../lib/zenlish/inflect/unconditionally_true'
+require_relative '../../../lib/zenlish/inflect/literal_asis'
+require_relative '../../../lib/zenlish/inflect/input_asis'
+require_relative '../../../lib/zenlish/inflect/equals_literal'
+require_relative '../../../lib/zenlish/inflect/formal_argument'
+require_relative '../../../lib/zenlish/inflect/matches_pattern'
+require_relative '../../../lib/zenlish/inflect/concatenation'
+require_relative '../../../lib/zenlish/inflect/substitution'
+require_relative '../../../lib/zenlish/inflect/inflection_rule'
+# Load the class under test
+require_relative '../../../lib/zenlish/inflect/inflection_table'
+
+module Zenlish
+  module Inflect
+    describe InflectionTable do
+      let(:table_name) { 'Common_form' }
+      subject { InflectionTable.new(table_name) }
+
+      context 'Initialization:' do
+        it 'should be initialized with a name' do
+          expect { InflectionTable.new(table_name) }.not_to raise_error
+        end
+
+        it 'should now its name' do
+          expect(subject.name).to eq(table_name)
+        end
+
+        it 'should not have headings at start' do
+          expect(subject.headings).to be_empty
+        end
+
+        it 'should not have rules at start' do
+          expect(subject.rules).to be_empty
+        end
+      end # context
+
+      context 'Provided services:' do
+        # DecisionTable: Common_form
+        # | NUMBER   | .base_form      | Common_form                |
+        # | singular | X               | base_form                  |
+        # | plural   | ~ /[^aeiouy]y$/ | sub(base_form, /y$/, "ies")|
+        # | plural   | X               | base_form + "s"            |
+        let(:feature_name) { 'NUMBER' }
+        let(:heading0) { FeatureHeading.new(feature_name) }
+        let(:method_name) { 'base_form' }
+        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(: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) }
+        let(:cond_a_1) { UnconditionallyTrue.new }
+        let(:patt_b_1) { /[^aeiouy]y$/ }
+        let(:cond_b_1) { MatchesPattern.new(arg_1, patt_b_1) }
+        let(:cond_c_1) { UnconditionallyTrue.new }
+        let(:cons_a) { InputAsIs.new(arg_1) }
+        let(:cons_b_arg) { InputAsIs.new(arg_1) }
+        let(:patt_b_2) { /y$/ }
+        let(:suffix_b) { LiteralAsIs.new('ies') }
+        let(:cons_b) { Substitution.new(cons_b_arg, patt_b_2, suffix_b) }
+        let(:cons_c_arg) { InputAsIs.new(arg_1) }
+        let(:suffix_c) { LiteralAsIs.new('s') }
+        let(:cons_c) { Concatenation.new(cons_c_arg, suffix_c) }
+        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)
+
+        it 'should accept the addition of heading(s)' do
+          expect { subject.add_heading(heading0) }.not_to raise_error
+          expect(subject.headings.size).to eq(1)
+          subject.add_heading(heading1)
+          expect(subject.headings.last).to eq(heading1)
+        end
+
+        it 'should accept the addition of rule(s)' do
+          expect { subject.add_rule(rule_a) }.not_to raise_error
+          expect(subject.rules.size).to eq(1)
+          subject.add_rule(rule_b)
+          expect(subject.rules.last).to eq(rule_b)
+          subject.add_rule(rule_c)
+          expect(subject.rules.last).to eq(rule_c)
+        end
+
+        # DecisionTable: Common_form
+        # | NUMBER   | .base_form      | Common_form                |
+        # | singular | X               | base_form                  |
+        # | plural   | ~ /[^aeiouy]y$/ | sub(base_form, /y$/, "ies")|
+        # | plural   | X               | base_form + "s"            |
+        # inflection_table('Common_form') do
+        #   feature_heading 'NUMBER'
+        #   method_heading  'base_form'
+        #       | NUMBER          | base_form             | Common_form               |
+        #   rule(equals(:singular), dont_care             , col(1))
+        #   rule(equals(:plural)  , matches(/[^aeiouy]y$/), sub(col(1), /y$/, 'ies'))
+        #   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')
+
+          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')
+
+          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')
+        end
+      end # context
+    end # describe
+  end # module
+end # module

data/spec/zenlish/inflect/input_asis_spec.rb

@@ -0,0 +1,50 @@
+# 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/method_heading'
+require_relative '../../../lib/zenlish/inflect/formal_argument'
+# Load the class under test
+require_relative '../../../lib/zenlish/inflect/input_asis'
+
+module Zenlish
+  module Inflect
+    describe InputAsIs do
+      let(:sample_argument) { FormalArgument.new(2) }
+      let(:sample_values) { [nil, nil, 'Hello, world.', nil] }
+      subject { InputAsIs.new(sample_argument) }
+
+      context 'Initialization:' do
+        it 'should be initialized with a formal rgument' do
+          expect { InputAsIs.new(sample_argument) }.not_to raise_error
+        end
+
+        it 'should know its text value' do
+          expect(subject.formal).to eq(sample_argument)
+        end
+      end # context
+
+      context 'Provided services:' do
+        it 'should return the text of given argument during generation' do
+          lexeme = double('fake-lexeme')
+          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')
+          lexeme = Lex::Lexeme.new(c_noun, an_entry)
+          heading = MethodHeading.new('base_form')
+          headings = [nil, nil, heading, nil]
+          expect(subject.generate(headings, lexeme, [])).to eq('cherry')
+        end
+        
+=begin
+
+=end        
+      end # context
+    end # describe
+  end # module
+end # module

data/spec/zenlish/inflect/literal_asis_spec.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+# Load the class under test
+require_relative '../../../lib/zenlish/inflect/literal_asis'
+
+module Zenlish
+  module Inflect
+    describe LiteralAsIs do
+      subject { LiteralAsIs.new('s') }
+
+      context 'Initialization:' do
+        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
+      end # context
+
+      context 'Provided services:' do
+        it 'should return the affix during word form generation' do
+          headings = double('fake-headings')        
+          lexeme = double('fake-lexeme')
+          values = double('fake-values')
+          expect(subject.generate(headings, lexeme, values)).to eq('s')
+        end
+      end # context
+    end # describe
+  end # module
+end # module

data/spec/zenlish/inflect/matches_pattern_spec.rb

@@ -0,0 +1,61 @@
+# 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/method_heading'
+require_relative '../../../lib/zenlish/inflect/formal_argument'
+# Load the class under test
+require_relative '../../../lib/zenlish/inflect/matches_pattern'
+
+module Zenlish
+  module Inflect
+    describe MatchesPattern do
+      let(:an_argument) { FormalArgument.new(1) }
+      let(:patt) { /[^aeiouy]y$/ }
+      subject { MatchesPattern.new(an_argument, patt) }
+
+      context 'Initialization:' do
+        it 'should be initialized with an argument and pattern' do
+          expect { MatchesPattern.new(an_argument, patt) }.not_to raise_error
+        end
+
+        it 'should know its argument' do
+          expect(subject.argument).to eq(an_argument)
+        end
+
+        it 'should know the pattern' do
+          expect(subject.pattern).to eq(patt)
+        end
+      end # context
+
+      context 'Provided services:' do
+        it 'should check the actual argument' do
+          lexeme = double('dummy-lexeme')
+          headings = double('fake-headings')
+          actual_args = [nil, 'cherry', nil]
+          expect(subject.success?(headings, lexeme, actual_args)).to be_truthy
+          actual_args[1] = 'boy'
+          expect(subject.success?(headings, lexeme, actual_args)).to be_falsy
+          actual_args[1] = 'girl'
+          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('cherry')
+          lexeme = Lex::Lexeme.new(c_noun, entry)
+          headings = [nil, MethodHeading.new('lemma'), nil]
+          expect(subject.success?(headings, lexeme, [])).to be_truthy
+
+          entry2 = Lex::LexicalEntry.new('boy')
+          lexeme2 = Lex::Lexeme.new(c_noun, entry2)
+          expect(subject.success?(headings, lexeme2, [])).to be_falsey
+
+          # instance = EqualsLiteral.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/method_heading_spec.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+# Load the class under test
+require_relative '../../../lib/zenlish/inflect/method_heading'
+
+module Zenlish
+  module Inflect
+    describe MethodHeading do
+      let(:method_name) { 'base_form' }
+      subject { MethodHeading.new(method_name) }
+
+      context 'Initialization:' do
+        it 'should be initialized with a method name' do
+          expect { MethodHeading.new(method_name) }.not_to raise_error
+        end
+
+        it 'should know its label' do
+          expect(subject.label).to eq(method_name)
+        end
+      end # context
+
+      context 'Provided services:' do
+        it 'should obtain the method result from a word' do
+          mocked = double('dummy-lexeme')
+          expect(mocked).to receive(:base_form).and_return('cherry')
+          expect(subject.evaluate_for(mocked)).to eq('cherry')
+        end
+      end # context
+    end # describe
+  end # module
+end # module

data/spec/zenlish/inflect/substitution_spec.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require_relative '../../../lib/zenlish/inflect/formal_argument'
+require_relative '../../../lib/zenlish/inflect/input_asis'
+# Load the class under test
+require_relative '../../../lib/zenlish/inflect/substitution'
+
+module Zenlish
+  module Inflect
+    describe Substitution do
+      let(:suffix) { LiteralAsIs.new('ies') }
+      let(:sample_argument) { FormalArgument.new(1) }
+      let(:base) { InputAsIs.new(sample_argument) }
+      let(:pattern) { /y$/ }
+
+
+      subject { Substitution.new(base, pattern, suffix) }
+
+      context 'Initialization:' do
+        it 'should be initialized with two arguments' do
+          expect { Substitution.new(base, pattern, suffix) }.not_to raise_error
+        end
+
+        it 'should know its arguments' do
+          expect(subject.children.first).to eq(base)
+          expect(subject.children[1]).to eq(pattern)
+          expect(subject.children.last).to eq(suffix)
+        end
+      end # context
+
+      context 'Provided services:' do
+        let(:sample_heading) { double('fake-headings') }
+        let(:sample_values) { [nil, 'cherry', nil] }
+
+        it 'should do the concatenation of children results' do
+          lexeme = double('fake-lexeme')
+
+          expect(subject.generate(sample_heading, lexeme, sample_values)).to eq('cherries')
+        end
+      end # context
+    end # describe
+  end # module
+end # module

data/spec/zenlish/inflect/unconditionally_true_spec.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+# Load the class under test
+require_relative '../../../lib/zenlish/inflect/unconditionally_true'
+
+module Zenlish
+  module Inflect
+    describe UnconditionallyTrue do
+      let(:method_name) { 'base_form' }
+      subject { UnconditionallyTrue.new }
+
+      context 'Initialization:' do
+        it 'should be initialized without argument' do
+          expect { UnconditionallyTrue.new}.not_to raise_error
+        end
+      end # context
+
+      context 'Provided services:' do
+        it 'should always return true' do
+          headings = double('dummy-headings')
+          lexeme = double('dummy-lexeme')
+          values = double('dummy-heading-values')
+          expect(subject.success?(headings, lexeme, values)).to be_truthy
+        end
+      end # context
+    end # describe
+  end # module
+end # module

data/spec/zenlish/lang/dictionary_spec.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require_relative '../../spec_helper' # Use the RSpec framework
+require_relative '../../../lib/zenlish/wclasses/common_noun'
+require_relative '../../../lib/zenlish/lang/dictionary' # Load the class under test
+
+module Zenlish
+  module Lang
+    describe Dictionary do
+      subject { Dictionary }
+
+      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)
+        end
+
+        it 'should give the list of common nouns' do
+          lexemes = []
+          subject.entries.each do |ent|
+            lexm = ent.lexemes.select { |lx| lx.wclass.kind_of?(Zenlish::WClasses::CommonNoun) }
+            lexemes.concat(lexm) if lexm
+          end
+          lemmas = lexemes.map { |lx| lx.entry.lemma }
+
+          expect(common_nouns.all? { |c_n| lemmas.include?(c_n) }).to be_truthy
+        end
+
+      end # context
+    end # describe
+  end # module
+end # module