zenlish 0.1.25 → 0.2.00

data/lib/zenlish/wclasses/word_class.rb

@@ -1,20 +1,35 @@
 require 'rley'
+require_relative '../feature/feature_struct_def_bearer'
 
 module Zenlish
   module WClasses
     # Also known as: part of speech, syntactic category or word category.
     # A word class represents a group of word which have similar functions.
     # Word classes are divided into:
-    # - Lexical words (?? same as content words??) such as nouns, verbs, adjectives, adverbs
-    #   Content words carry the meaning of a sentence
-    # - Function words (?? same as structure words??) such as pronouns, determiners, modal verbs, 
-    #  auxiliary verbs,
-    #   Structure words structure a sentence
+    # - Lexical words (?? same as content words??) such as nouns, verbs, adjectives,
+    #   adverbs. Content words carry the meaning of a sentence for the chosen discourse
+    #   universe.
+    #
+    # - Function words (?? same as structure words??) such as pronouns, determiners,
+    #   modal verbs, auxiliary verbs. Structure words helpt to structure a sentence.
+    #   They working is independent of the chosen discourse universe.
     #   conjunctions and prepositions
     class WordClass < Rley::Syntax::Terminal
+      include Feature::FeatureStructDefBearer
+      # @return [Hash] pair of the kind: String => InflectionTable
+      attr_reader :paradigms
+
       def initialize
         super(self.class.name.split('::').last)
+        init_struct_def(nil, {})
+        @paradigms = {}
+      end
+
+      # Indicates whether all words from the word class have a single (uninflected)
+      # form.
+      def invariable?
+        raise NotImplementedError, "Missing implementation for #{self.class}."
       end
     end # class
-  end # module    
+  end # module
 end # module

data/spec/spec_helper.rb

@@ -1,16 +1,15 @@
 require 'bundler/setup'
 require 'rspec' # Use the RSpec framework
-# require_relative '../lib/zenlish'
 
 RSpec.configure do |config|
   # Enable flags like --only-failures and --next-failure
   config.example_status_persistence_file_path = ".rspec_status"
-  
+
   config.expect_with :rspec do |c|
     # Disable the `should` syntax
     c.syntax = :expect
   end
 
   # Display stack trace in case of failure
-  config.full_backtrace = true  
+  config.full_backtrace = true
 end

data/spec/zenlish/feature/boolean_domain_spec.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require_relative '../../../lib/zenlish/feature/boolean_domain' # Load the class under test
+
+module Zenlish
+  module Feature
+    describe BooleanDomain do
+      subject { BooleanDomain.instance }
+
+      context 'Initialization:' do
+        it 'should be initialized without argument' do
+          expect { BooleanDomain.instance }.not_to raise_error
+        end
+      end # context
+
+      context 'Provided services:' do
+        it 'should know whether a value is in domain' do
+          expect(subject.include?('invalid')).to be_falsey
+          expect(subject.include?(true)).to be_truthy
+          expect(subject.include?(false)).to be_truthy
+        end      
+        it 'should provide a factory method for boolean values' do
+          expect(subject.build_value(true)).to be_kind_of(BooleanValue)
+          expect(subject.build_value(false)).to be_kind_of(BooleanValue)
+        end
+
+        it 'should complain when asked to build a non-boolean value' do
+          err = StandardError
+          err_msg = 'Expected a boolean instead of String.'
+          expect { subject.build_value('?') }.to raise_error(err, err_msg)
+        end
+      end # context
+    end # describe
+  end # module
+end # module

data/spec/zenlish/feature/boolean_value_spec.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require_relative '../../../lib/zenlish/feature/boolean_domain'
+require_relative '../../../lib/zenlish/feature/boolean_value' # Load the class under test
+
+module Zenlish
+  module Feature
+    describe BooleanValue do
+      let(:its_value) { false }
+      subject { BooleanValue.new(its_value) }
+
+      context 'Initialization:' do
+        it 'should be initialized with a value argument' do
+          expect { BooleanValue.new(its_value) }.not_to raise_error
+        end
+        
+        it 'should know its internal value' do
+          expect(subject.val.class).to eq(FalseClass)
+        end
+      end # context
+
+      context 'Provided services:' do
+      end # context
+    end # describe
+  end # module
+end # module

data/spec/zenlish/feature/enumeration_domain_spec.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+# Load the class under test
+require_relative '../../../lib/zenlish/feature/enumeration_domain' 
+
+module Zenlish
+  module Feature
+    describe EnumerationDomain do
+      subject { EnumerationDomain.new(:singular, :plural) }
+
+      context 'Initialization:' do
+        it 'should be initialized with arguments' do
+          expect { EnumerationDomain.new(:singular, :plural) }.not_to raise_error
+        end
+        
+        it 'should know the values of enumeration' do
+          expect(subject.enum).to eq([:singular, :plural])
+        end
+      end # context
+
+      context 'Provided services:' do
+        it 'should know whether a value is in domain' do
+          expect(subject.include?(:dual)).to be_falsey
+          expect(subject.include?(:singular)).to be_truthy
+          expect(subject.include?(:plural)).to be_truthy
+        end
+        
+        it 'should provide a factory method for enumerated value' do
+          expect(subject.build_value(:plural)).to be_kind_of(SymbolValue)
+          value = subject.build_value(:plural)
+          expect(value.val).to eq(:plural)
+        end
+
+        it 'should complain when asked to build a non-member value' do
+          err = StandardError
+          err_msg = "dual isn't part of enumeration [singular, plural]."
+          expect { subject.build_value(:dual) }.to raise_error(err, err_msg)
+        end      
+      end # context
+    end # describe
+  end # module
+end # module

data/spec/zenlish/feature/feature_def_spec.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require_relative '../../../lib/zenlish/feature/enumeration_domain'
+# Load the class under test
+require_relative '../../../lib/zenlish/feature/feature_def'
+
+module Zenlish
+  module Feature
+    describe FeatureDef do
+      let(:a_name) { 'NUMBER' }
+      let(:a_domain) { EnumerationDomain.new(:singular, :plural) }
+      subject { FeatureDef.new(a_name, a_domain) }
+
+      context 'Initialization:' do
+        it 'should be initialized with at least two arguments' do
+          expect { FeatureDef.new(a_name, a_domain) }.not_to raise_error
+        end
+
+        it 'could be initialized with a default value argument' do
+          deflt = double('dummy')
+          expect { FeatureDef.new(a_name, a_domain, deflt) }.not_to raise_error
+        end
+
+        it 'should know its name' do
+          expect(subject.name).to eq(a_name)
+        end
+
+        it 'should know the domain of its values' do
+          expect(subject.domain).to eq(a_domain)
+        end
+
+        it 'should know the domain of its default value' do
+          expect(subject.default).to be_nil
+          deflt = double('dummy')
+          instance = FeatureDef.new(a_name, a_domain, deflt)
+          expect(instance.default).to eq(deflt)
+        end
+
+        it 'should guess its default if enumeration has a single member' do
+          basic_domain = EnumerationDomain.new(:plural)
+          instance = FeatureDef.new(a_name, basic_domain)
+          expect(instance.default.val).to eq(:plural)
+        end
+      end # context
+
+      context 'Provided services:' do
+      end # context
+    end # describe
+  end # module
+end # module

data/spec/zenlish/feature/feature_spec.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+require_relative '../../../lib/zenlish/feature/enumeration_domain'
+require_relative '../../../lib/zenlish/feature/feature_def'
+# Load the class under test
+require_relative '../../../lib/zenlish/feature/feature'
+
+
+module Zenlish
+  module Feature
+    describe Feature do
+      let(:a_name) { 'NUMBER' }
+      let(:a_domain) { EnumerationDomain.new(:singular, :plural) }
+      let(:feat_def) { FeatureDef.new(a_name, a_domain) }
+      let(:plural_value) { a_domain.build_value(:plural) }
+
+      subject { Feature.new(feat_def) }
+
+      context 'Initialization:' do
+        it 'should be initialized with one definition argument' do
+          expect { Feature.new(feat_def) }.not_to raise_error
+        end
+
+        it 'should know its definition' do
+          expect(subject.definition).to eq(feat_def)
+        end
+
+        it "should'nt be bound yet to a value" do
+          expect(subject.binding).to be_nil
+          expect(subject).not_to be_bound
+        end
+      end # context
+
+      context 'Provided services:' do
+        it "should know the definition's name" do
+          expect(subject.name).to eq(feat_def.name)
+        end
+
+        it "should know the domain of its values" do
+          expect(subject.domain).to eq(a_domain)
+        end
+
+        it 'should accept a value binding' do
+          expect { subject.bind_to(plural_value) }.not_to raise_error
+          expect(subject).to be_bound
+           expect(subject.binding).to eq(plural_value)
+        end
+      end # context
+    end # describe
+  end # module
+end # module

data/spec/zenlish/feature/feature_struct_def_bearer_spec.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+# Load the class under test
+require_relative '../../../lib/zenlish/feature/feature_struct_def_bearer'
+
+module Zenlish
+  module Feature
+    describe FeatureStructDefBearer do
+      # @nodoc Class created just for testing purposes.
+      class Dummy
+        include FeatureStructDefBearer
+
+        def initialize(aParent)
+          feature_hash = {
+            'NUMBER' => enumeration(:singular, :plural),
+            'COUNTABILITY' => boolean,
+            'PARADIGM' => [identifier, 'CommonForm']
+          }
+
+          init_struct_def(aParent, feature_hash)
+        end
+      end # class
+
+      subject { Dummy.new (nil) }
+
+      context 'Mix-in initialization' do
+        it 'should have initialized properly the injected data' do
+          expect { Dummy.new(nil) }.not_to raise_error
+          expect(subject.struct).to be_kind_of(FeatureStructDef)
+        end
+
+        it 'should have the feature definitions created' do
+          expect(subject['NUMBER']).not_to be_nil
+          expect(subject['NUMBER']).to be_kind_of(FeatureDef)
+          ft = subject['NUMBER']
+          expect(ft.domain.enum).to eq([:singular, :plural])
+          
+          expect(subject['COUNTABILITY']).to be_kind_of(FeatureDef)
+          expect(subject['COUNTABILITY'].domain).to be_kind_of(BooleanDomain)
+          expect(subject['PARADIGM']).to be_kind_of(FeatureDef)
+          expect(subject['PARADIGM'].domain).to be_kind_of(IdentifierDomain)
+          expect(subject['PARADIGM'].default).to be_kind_of(IdentifierValue)          
+        end
+        
+        it 'should support the addition of feature def' do
+          subject.feature_def_dsl { feature_def 'CASE' => boolean }
+          
+          expect(subject['CASE']).to be_kind_of(FeatureDef)
+          expect(subject['CASE'].domain).to be_kind_of(BooleanDomain)          
+        end
+      end # context
+    end # describe
+  end # module
+end # module

data/spec/zenlish/feature/feature_struct_def_spec.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+require_relative '../../../lib/zenlish/feature/boolean_domain'
+require_relative '../../../lib/zenlish/feature/enumeration_domain'
+require_relative '../../../lib/zenlish/feature/feature_def'
+# Load the class under test
+require_relative '../../../lib/zenlish/feature/feature_struct_def'
+
+
+module Zenlish
+  module Feature
+    describe FeatureStructDef do
+      let(:enum_number) { EnumerationDomain.new(:singular, :plural) }
+      let(:ft_number) { FeatureDef.new('NUMBER', enum_number) }
+      let(:countable_domain) { BooleanDomain.instance }
+      let(:ft_countability) { FeatureDef.new('COUNTABILITY', countable_domain) }
+      let(:sample_parent) { FeatureStructDef.new }
+      let(:case_domain) { EnumerationDomain.new(:common, :genitive) }
+      let(:ft_case) { FeatureDef.new('CASE', case_domain) }
+
+      subject { FeatureStructDef.new(sample_parent) }
+
+      context 'Initialization:' do
+        it 'could be initialized without argument' do
+          expect { FeatureStructDef.new }.not_to raise_error
+        end
+
+        it 'could be initialized with a parent struct' do
+          expect { FeatureStructDef.new(sample_parent) }.not_to raise_error
+        end
+
+        it 'should have an empty structure at initialization' do
+          expect(subject.struct).to be_empty
+        end
+
+        it 'should know its parent (if any)' do
+          expect(subject.parent).to eq(sample_parent)
+          instance = FeatureStructDef.new
+          expect(instance.parent).to be_nil
+        end
+      end # context
+
+      context 'Provided services:' do
+        it 'should accept the addition of a feature definition' do
+          expect { subject.add_feature_def(ft_number) }.not_to raise_error
+          expect(subject.struct.size).to eq(1)
+          expect(subject['NUMBER']).to eq(ft_number)
+
+          expect { subject.add_feature_def(ft_countability) }.not_to raise_error
+          expect(subject.struct.size).to eq(2)
+          expect(subject['COUNTABILITY']).to eq(ft_countability)
+        end
+
+        it 'should inherit the feature definition of its parent' do
+          sample_parent.add_feature_def(ft_case)
+          expect(subject['CASE']).to eq(ft_case)
+        end
+        
+        it "should be able to override parent's feature def" do
+          sample_parent.add_feature_def(ft_case)
+          
+          other_case_domain = BooleanDomain.instance
+          other_ft_case = FeatureDef.new('CASE', other_case_domain)
+          subject.add_feature_def(other_ft_case)
+          expect(subject['CASE']).to eq(other_ft_case)
+        end
+      end # context
+    end # describe
+  end # module
+end # module

data/spec/zenlish/feature/identifier_domain_spec.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require_relative '../../../lib/zenlish/feature/identifier_domain' # Load the class under test
+
+module Zenlish
+  module Feature
+    describe IdentifierDomain do
+      subject { IdentifierDomain.instance }
+
+      context 'Initialization:' do
+        it 'should be instantiated without argument' do
+          expect { IdentifierDomain.instance }.not_to raise_error
+        end
+      end # context
+
+      context 'Provided services:' do
+        it 'should know whether a value is in domain' do
+          expect(subject.include?('CommonForm')).to be_truthy
+          expect(subject.include?('Common Form')).to be_falsey
+          expect(subject.include?('+123')).to be_falsey
+        end 
+        
+        it 'should provide a factory method for identifier values' do
+          expect(subject.build_value('CommonForm')).to be_kind_of(IdentifierValue)
+          expect(subject.build_value('Common_Form')).to be_kind_of(IdentifierValue)
+        end
+
+        it 'should complain when asked to build an invalid identifier' do
+          err = StandardError
+          err_msg = "?1234 isn't a valid identifier."
+          expect { subject.build_value('?1234') }.to raise_error(err, err_msg)
+        end
+      end # context
+    end # describe
+  end # module
+end # module

data/spec/zenlish/feature/identifier_value_spec.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+# Load the class under test
+require_relative '../../../lib/zenlish/feature/identifier_value' 
+
+module Zenlish
+  module Feature
+    describe IdentifierValue do
+      let(:its_value) { 'CommonForm' }
+      subject { IdentifierValue.new(its_value) }
+
+      context 'Initialization:' do
+        it 'should be initialized with a value argument' do
+          expect { IdentifierValue.new(its_value) }.not_to raise_error
+        end
+        
+        it 'should know its internal value' do
+          expect(subject.val).to eq(its_value)
+        end        
+      end # context
+
+      context 'Provided services:' do
+      end # context
+    end # describe
+  end # module
+end # module

data/spec/zenlish/feature/symbol_value_spec.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require_relative '../../../lib/zenlish/feature/enumeration_domain'
+# Load the class under test
+require_relative '../../../lib/zenlish/feature/symbol_value' 
+
+module Zenlish
+  module Feature
+    describe SymbolValue do
+      let(:its_value) { :plural }
+      subject { SymbolValue.new(its_value) }
+
+      context 'Initialization:' do
+        it 'should be initialized with a value argument' do
+          expect { SymbolValue.new(its_value) }.not_to raise_error
+        end
+        
+        it 'should know its internal value' do
+          expect(subject.val).to eq(its_value)
+        end        
+      end # context
+
+      context 'Provided services:' do
+      end # context
+    end # describe
+  end # module
+end # module

data/spec/zenlish/inflect/concatenation_spec.rb

@@ -0,0 +1,40 @@
+# 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/concatenation'
+
+module Zenlish
+  module Inflect
+    describe Concatenation do
+      let(:suffix) { LiteralAsIs.new('s') }
+      let(:sample_argument) { FormalArgument.new(2) }
+      let(:base_form) { InputAsIs.new(sample_argument) }
+      
+      subject { Concatenation.new(base_form, suffix) }
+
+      context 'Initialization:' do
+        it 'should be initialized with two arguments' do
+          expect { Concatenation.new(base_form, suffix) }.not_to raise_error
+        end
+        
+        it 'should know its arguments' do
+          expect(subject.children.first).to eq(base_form)
+          expect(subject.children.last).to eq(suffix)          
+        end
+      end # context
+
+      context 'Provided services:' do
+        let(:sample_values) { [nil, nil, 'place', nil] } 
+        
+        it 'should do the concatenation of children results' do
+          headings = double('fake-headings')
+          lexeme = double('fake-lexeme')
+          
+          expect(subject.generate(headings, lexeme, sample_values)).to eq('places')
+        end
+      end # context
+    end # describe
+  end # module
+end # module

data/spec/zenlish/inflect/equals_literal_spec.rb

@@ -0,0 +1,58 @@
+# 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/formal_argument'
+# Load the class under test
+require_relative '../../../lib/zenlish/inflect/equals_literal'
+
+module Zenlish
+  module Inflect
+    describe EqualsLiteral do
+      let(:an_argument) { FormalArgument.new(1) }
+      let(:feat_val) { :plural }
+      subject { EqualsLiteral.new(an_argument, feat_val) }
+
+      context 'Initialization:' do
+        it 'should be initialized with a method name' do
+          expect { EqualsLiteral.new(an_argument, feat_val) }.not_to raise_error
+        end
+
+        it 'should know its argument' do
+          expect(subject.argument).to eq(an_argument)
+        end
+
+        it 'should know the literal' do
+          expect(subject.literal).to eq(feat_val)
+        end
+      end # context
+
+      context 'Provided services:' do
+        it 'should test the actual argument' do
+          lexeme = double('dummy-lexeme')
+          headings = double('fake-headings')
+          actual_args = [nil, :plural, nil]
+          expect(subject.success?(headings, lexeme, actual_args)).to be_truthy
+          actual_args[1] = :singular
+          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('animal')
+          lexeme = Lex::Lexeme.new(c_noun, entry)
+          headings = [nil, FeatureHeading.new('NUMBER'), nil]
+          expect(subject.success?(headings, lexeme, [])).to be_truthy
+
+          instance = EqualsLiteral.new(an_argument, :singular)
+          expect(instance.success?(headings, lexeme, [])).to be_truthy
+
+          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/feature_heading_spec.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+# Load the class under test
+require_relative '../../../lib/zenlish/inflect/feature_heading'
+
+module Zenlish
+  module Inflect
+    describe FeatureHeading do
+      let(:feature_name) { 'NUMBER' }
+      subject { FeatureHeading.new(feature_name) }
+
+      context 'Initialization:' do
+        it 'should be initialized with a feature name' do
+          expect { FeatureHeading.new(feature_name) }.not_to raise_error
+        end
+        
+        it 'should know its label' do
+          expect(subject.label).to eq(feature_name)
+        end
+      end # context
+
+      context 'Provided services:' do
+        it 'should obtain the feature value from a word' do
+          mocked = { 'NUMBER' => :plural }
+          expect(subject.evaluate_for(mocked)).to eq(:plural)
+        end
+      end # context
+    end # describe
+  end # module
+end # module

data/spec/zenlish/inflect/formal_argument_spec.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+# Load the class under test
+require_relative '../../../lib/zenlish/inflect/formal_argument'
+
+module Zenlish
+  module Inflect
+    describe FormalArgument do
+      subject { FormalArgument.new(3) }
+
+      context 'Initialization:' do
+        it 'should be initialized with a text literal' do
+          expect { FormalArgument.new(1) }.not_to raise_error
+        end
+        
+        it 'should know its index value' do
+          expect(subject.index).to eq(3)
+        end
+      end # context
+
+      context 'Provided services:' do
+      end # context
+    end # describe
+  end # module
+end # module