zenlish 0.2.02 → 0.2.06

data/lib/zenlish/wclasses/subordinating_conjunction.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require_relative 'conjunction'
 
 module Zenlish
@@ -5,12 +7,12 @@ module Zenlish
     # A subordinating conjunction is a word or phrase that connects a dependent
     # clause to a main clause. The subordinating conjunction indicates how the
     # dependent clause adds informative value to the main clause. For instance,
-    # by signaling a cause-and-effect relation, a shift in time or place between 
-    # the two clauses. 
-    # Common subordinating conjunctions: after, although, as, because, before, 
-    # how, if, once, since, than, that, though, till, until, when, where, 
+    # by signaling a cause-and-effect relation, a shift in time or place between
+    # the two clauses.
+    # Common subordinating conjunctions: after, although, as, because, before,
+    # how, if, once, since, than, that, though, till, until, when, where,
     # whether, while
-    class SubordinatingConjunction < WordClass     
+    class SubordinatingConjunction < WordClass
     end # class
   end # module
 end # module

data/lib/zenlish/wclasses/verb.rb

@@ -1,17 +1,21 @@
+# frozen_string_literal: true
+
 require_relative 'word_class'
 require_relative '../inflect/inflection_table_builder'
 
 module Zenlish
   module WClasses
-    # Abstract class. In traditional grammar, the verb is often defined 
+    # Abstract class. In traditional grammar, the verb is often defined
     # notionally as a 'doing' word (i.e. a word that describes the action
     # in a clause).
     class Verb < WordClass
       def initialize
         super()
+        @paradigms = {}
         init_feature_defs
-      end    
-    
+        init_paradigms
+      end
+
       # As all verbs inflect, or change form, to reflect changes in tense,
       # person, number, and voice, they are, by definition, variable.
       def invariable?
@@ -22,13 +26,17 @@ module Zenlish
 
       def init_feature_defs
         # Create standard feature definitions for lexical verbs.
-        feature_def_dsl {
+        feature_def_dsl do
           feature_def 'NUMBER' => enumeration(:singular, :plural)
           feature_def 'PERSON' => enumeration(:first, :second, :third)
-          feature_def 'TIME' => enumeration(:present, :progressive, :past_simple, :past_participle)          
+          feature_def 'TIME' => enumeration(:present, :progressive, :past_simple, :past_participle)
           feature_def 'PARADIGM' => [identifier, 'Regular_inflection'] # 2nd item is default value
-        }
-      end       
+        end
+      end
+
+      def init_paradigms
+        raise NotImplementedError, "Method #{__callee__} must implemented for #{self.class}."
+      end
     end # class
   end # module
-end # module
+end # module

data/lib/zenlish/wclasses/word_class.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'rley'
 require_relative '../feature/feature_struct_def_bearer'
 
@@ -29,13 +31,19 @@ module Zenlish
       # form.
       # @return [FalseClass, TrueClass] true iff the words in the class are invariable.
       def invariable?
-        return true
+        true
       end
-      
+
       # @return [Module, NilClass]
       def extension
         nil
       end
+
+      protected
+
+      def add_paradigm(anInflectionTable)
+        @paradigms[anInflectionTable.name] = anInflectionTable
+      end
     end # class
   end # module
-end # module
+end # module

data/spec/spec_helper.rb

@@ -1,9 +1,11 @@
+# frozen_string_literal: true
+
 require 'bundler/setup'
 require 'rspec' # Use the RSpec framework
 
 RSpec.configure do |config|
   # Enable flags like --only-failures and --next-failure
-  config.example_status_persistence_file_path = ".rspec_status"
+  config.example_status_persistence_file_path = '.rspec_status'
 
   config.expect_with :rspec do |c|
     # Disable the `should` syntax

data/spec/zenlish/feature/boolean_domain_spec.rb

@@ -18,12 +18,17 @@ module Zenlish
           expect(subject.include?('invalid')).to be_falsey
           expect(subject.include?(true)).to be_truthy
           expect(subject.include?(false)).to be_truthy
-        end      
+        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 return all valid values in domain when requested' do
+          expect(subject.to_a).to eq([false, true])
+        end
+
         it 'should complain when asked to build a non-boolean value' do
           err = StandardError
           err_msg = 'Expected a boolean instead of String.'

data/spec/zenlish/feature/boolean_value_spec.rb

@@ -13,7 +13,7 @@ module Zenlish
         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

data/spec/zenlish/feature/enumeration_domain_spec.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 # Load the class under test
-require_relative '../../../lib/zenlish/feature/enumeration_domain' 
+require_relative '../../../lib/zenlish/feature/enumeration_domain'
 
 module Zenlish
   module Feature
@@ -12,9 +12,9 @@ module Zenlish
         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])
+          expect(subject.enum).to eq(%i[singular plural])
         end
       end # context
 
@@ -24,18 +24,22 @@ module Zenlish
           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 return all valid values in domain when requested' do
+          expect(subject.to_a).to eq(%i[singular 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
       end # context
     end # describe
   end # module

data/spec/zenlish/feature/feature_spec.rb

@@ -36,16 +36,16 @@ module Zenlish
           expect(subject.name).to eq(feat_def.name)
         end
 
-        it "should know the domain of its values" do
+        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)
+          expect(subject.binding).to eq(plural_value)
         end
       end # context
     end # describe
   end # module
-end # module
+end # module

data/spec/zenlish/feature/feature_struct_def_bearer_spec.rb

@@ -7,6 +7,7 @@ module Zenlish
   module Feature
     describe FeatureStructDefBearer do
       # @nodoc Class created just for testing purposes.
+      # rubocop: disable Lint/ConstantDefinitionInBlock
       class Dummy
         include FeatureStructDefBearer
 
@@ -20,8 +21,9 @@ module Zenlish
           init_struct_def(aParent, feature_hash)
         end
       end # class
+      # rubocop: enable Lint/ConstantDefinitionInBlock
 
-      subject { Dummy.new (nil) }
+      subject { Dummy.new(nil) }
 
       context 'Mix-in initialization' do
         it 'should have initialized properly the injected data' do
@@ -33,22 +35,22 @@ module Zenlish
           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(ft.domain.enum).to eq(%i[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)          
+          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)          
+          expect(subject['CASE'].domain).to be_kind_of(BooleanDomain)
         end
       end # context
     end # describe
   end # module
-end # module
+end # module

data/spec/zenlish/feature/feature_struct_def_spec.rb

@@ -1,4 +1,5 @@
 # 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'
@@ -54,10 +55,10 @@ module Zenlish
           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)

data/spec/zenlish/feature/identifier_domain_spec.rb

@@ -18,8 +18,8 @@ module Zenlish
           expect(subject.include?('CommonForm')).to be_truthy
           expect(subject.include?('Common Form')).to be_falsey
           expect(subject.include?('+123')).to be_falsey
-        end 
-        
+        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)
@@ -33,4 +33,4 @@ module Zenlish
       end # context
     end # describe
   end # module
-end # module
+end # module

data/spec/zenlish/feature/identifier_value_spec.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 # Load the class under test
-require_relative '../../../lib/zenlish/feature/identifier_value' 
+require_relative '../../../lib/zenlish/feature/identifier_value'
 
 module Zenlish
   module Feature
@@ -13,14 +13,14 @@ module Zenlish
         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
       end # context
 
       context 'Provided services:' do
       end # context
     end # describe
   end # module
-end # module
+end # module

data/spec/zenlish/feature/symbol_value_spec.rb

@@ -2,7 +2,7 @@
 
 require_relative '../../../lib/zenlish/feature/enumeration_domain'
 # Load the class under test
-require_relative '../../../lib/zenlish/feature/symbol_value' 
+require_relative '../../../lib/zenlish/feature/symbol_value'
 
 module Zenlish
   module Feature
@@ -14,10 +14,10 @@ module Zenlish
         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
       end # context
 
       context 'Provided services:' do

data/spec/zenlish/inflect/concatenation_spec.rb

@@ -11,30 +11,30 @@ module Zenlish
       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)          
+          expect(subject.children.last).to eq(suffix)
         end
       end # context
 
       context 'Provided services:' do
-        let(:sample_values) { [nil, nil, 'place', nil] } 
-        
+        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
+end # module

data/spec/zenlish/inflect/feature_heading_spec.rb

@@ -13,18 +13,38 @@ module Zenlish
         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
+        let(:a_domain) { Feature::EnumerationDomain.new(:singular, :plural) }
+        let(:enum_def) { Feature::FeatureDef.new(feature_name, a_domain) }
+        let(:b_domain) { Feature::BooleanDomain.instance }
+        let(:bool_def) { Feature::FeatureDef.new(feature_name, b_domain) }
+
+        it 'should obtain the value of a feature' do
           mocked = { 'NUMBER' => :plural }
           expect(subject.evaluate_for(mocked)).to eq(:plural)
         end
+
+        it 'should obtain all possible values of a feature' do
+          mocked = { 'NUMBER' => :plural }
+          expect(subject.all_matches(mocked)).to eq([:plural])
+        end
+
+        it 'should obtain all possible values of a enumeration domain' do
+          mocked = { 'NUMBER' => enum_def }
+          expect(subject.all_matches(mocked)).to eq(%i[singular plural])
+        end
+
+        it 'should obtain all possible values of a enumeration domain' do
+          mocked = { 'NUMBER' => bool_def }
+          expect(subject.all_matches(mocked)).to eq([false, true])
+        end
       end # context
     end # describe
   end # module
-end # module
+end # module

data/spec/zenlish/inflect/formal_argument_spec.rb

@@ -12,7 +12,7 @@ module Zenlish
         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
@@ -22,4 +22,4 @@ module Zenlish
       end # context
     end # describe
   end # module
-end # module
+end # module