zenlish 0.2.05 → 0.2.07

data/lib/zenlish/wclasses/regular_verb_want.rb

@@ -1,10 +1,12 @@
+# frozen_string_literal: true
+
 require_relative 'regular_verb'
 
 module Zenlish
   module WClasses
     # The `want` verb like `need` allow the construct:
     # want + to + infinitive or progressive.
-    class RegularVerbWant < IrregularVerb
+    class RegularVerbWant < RegularVerb
     end # class
   end # module
-end # module
+end # module

data/lib/zenlish/wclasses/relative_pronoun.rb

@@ -1,12 +1,14 @@
+# frozen_string_literal: true
+
 require_relative 'pronoun'
 
 module Zenlish
   module WClasses
     # A relative pronoun refers to a noun that has already been mentionned,
-    # and gives more information about that noun: who, whom, whose 
+    # and gives more information about that noun: who, whom, whose
     # (for people) and which, what, that for things (and animals).
     # A relative pronoun introduces a relative clause.
     class RelativePronoun < Pronoun
     end # class
   end # module
-end # module
+end # module

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,3 +1,5 @@
+# frozen_string_literal: true
+
 require_relative 'word_class'
 require_relative '../inflect/inflection_table_builder'
 
@@ -24,12 +26,12 @@ 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 'PARADIGM' => [identifier, 'Regular_inflection'] # 2nd item is default value
-        }
+        end
       end
 
       def init_paradigms
@@ -37,4 +39,4 @@ module Zenlish
       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,19 +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
     end # class
   end # module
-end # module
+end # module

data/lib/zenlish.rb

@@ -3,8 +3,8 @@
 # This file acts as a jumping-off point for loading dependencies expected
 # for a Zenlish client.
 
-require_relative './zenlish/version'
-require_relative './zenlish/lang/dictionary'
-require_relative './zenlish/parser/zparser'
+require_relative 'zenlish/version'
+require_relative 'zenlish/lang/dictionary'
+require_relative 'zenlish/parser/zparser'
 
 # End of file

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

@@ -5,34 +5,34 @@ require_relative '../../../lib/zenlish/feature/boolean_domain' # Load the class
 module Zenlish
   module Feature
     describe BooleanDomain do
-      subject { BooleanDomain.instance }
+      subject(:bool_dom) { described_class.instance }
 
       context 'Initialization:' do
-        it 'should be initialized without argument' do
-          expect { BooleanDomain.instance }.not_to raise_error
+        it 'is initialized without argument' do
+          expect { described_class.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
+        it 'knows whether a value is in domain' do
+          expect(bool_dom).not_to include('invalid')
+          expect(bool_dom).to include(true)
+          expect(bool_dom).to include(false)
         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)
+        it 'provides a factory method for boolean values' do
+          expect(bool_dom.build_value(true)).to be_a(BooleanValue)
+          expect(bool_dom.build_value(false)).to be_a(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
+        it 'returns all valid values in domain when requested' do
+          expect(bool_dom.to_a).to eq([false, true])
+        end
+
+        it 'complains 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)
+          expect { bool_dom.build_value('?') }.to raise_error(err, err_msg)
         end
       end # context
     end # describe

data/spec/zenlish/feature/boolean_value_spec.rb

@@ -7,15 +7,16 @@ module Zenlish
   module Feature
     describe BooleanValue do
       let(:its_value) { false }
-      subject { BooleanValue.new(its_value) }
+
+      subject(:boolean) { described_class.new(its_value) }
 
       context 'Initialization:' do
-        it 'should be initialized with a value argument' do
-          expect { BooleanValue.new(its_value) }.not_to raise_error
+        it 'is initialized with a value argument' do
+          expect { described_class.new(its_value) }.not_to raise_error
         end
-        
-        it 'should know its internal value' do
-          expect(subject.val.class).to eq(FalseClass)
+
+        it 'knows its internal value' do
+          expect(boolean.val.class).to eq(FalseClass)
         end
       end # context
 

data/spec/zenlish/feature/enumeration_domain_spec.rb

@@ -1,44 +1,44 @@
 # 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
     describe EnumerationDomain do
-      subject { EnumerationDomain.new(:singular, :plural) }
+      subject(:enumeration) { described_class.new(:singular, :plural) }
 
       context 'Initialization:' do
-        it 'should be initialized with arguments' do
-          expect { EnumerationDomain.new(:singular, :plural) }.not_to raise_error
+        it 'is initialized with arguments' do
+          expect { described_class.new(:singular, :plural) }.not_to raise_error
         end
-        
-        it 'should know the values of enumeration' do
-          expect(subject.enum).to eq([:singular, :plural])
+
+        it 'knows the values of enumeration' do
+          expect(enumeration.enum).to eq(%i[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
+        it 'knows whether a value is in domain' do
+          expect(enumeration).not_to include(:dual)
+          expect(enumeration).to include(:singular)
+          expect(enumeration).to include(:plural)
         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)
+
+        it 'provides a factory method for enumerated value' do
+          expect(enumeration.build_value(:plural)).to be_a(SymbolValue)
+          value = enumeration.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([:singular, :plural])
-        end        
 
-        it 'should complain when asked to build a non-member value' do
+        it 'returns all valid values in domain when requested' do
+          expect(enumeration.to_a).to eq(%i[singular plural])
+        end
+
+        it 'complains 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)
+          expect { enumeration.build_value(:dual) }.to raise_error(err, err_msg)
         end
       end # context
     end # describe

data/spec/zenlish/feature/feature_def_spec.rb

@@ -9,36 +9,37 @@ module Zenlish
     describe FeatureDef do
       let(:a_name) { 'NUMBER' }
       let(:a_domain) { EnumerationDomain.new(:singular, :plural) }
-      subject { FeatureDef.new(a_name, a_domain) }
+
+      subject(:ft_def) { described_class.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
+        it 'is initialized with at least two arguments' do
+          expect { described_class.new(a_name, a_domain) }.not_to raise_error
         end
 
-        it 'could be initialized with a default value argument' do
+        it 'can be initialized with a default value argument' do
           deflt = double('dummy')
-          expect { FeatureDef.new(a_name, a_domain, deflt) }.not_to raise_error
+          expect { described_class.new(a_name, a_domain, deflt) }.not_to raise_error
         end
 
-        it 'should know its name' do
-          expect(subject.name).to eq(a_name)
+        it 'knows its name' do
+          expect(ft_def.name).to eq(a_name)
         end
 
-        it 'should know the domain of its values' do
-          expect(subject.domain).to eq(a_domain)
+        it 'knows the domain of its values' do
+          expect(ft_def.domain).to eq(a_domain)
         end
 
-        it 'should know the domain of its default value' do
-          expect(subject.default).to be_nil
+        it 'knows the domain of its default value' do
+          expect(ft_def.default).to be_nil
           deflt = double('dummy')
-          instance = FeatureDef.new(a_name, a_domain, deflt)
+          instance = described_class.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
+        it 'guesses its default if enumeration has a single member' do
           basic_domain = EnumerationDomain.new(:plural)
-          instance = FeatureDef.new(a_name, basic_domain)
+          instance = described_class.new(a_name, basic_domain)
           expect(instance.default.val).to eq(:plural)
         end
       end # context

data/spec/zenlish/feature/feature_spec.rb

@@ -14,38 +14,38 @@ module Zenlish
       let(:feat_def) { FeatureDef.new(a_name, a_domain) }
       let(:plural_value) { a_domain.build_value(:plural) }
 
-      subject { Feature.new(feat_def) }
+      subject(:a_feature) { described_class.new(feat_def) }
 
       context 'Initialization:' do
-        it 'should be initialized with one definition argument' do
-          expect { Feature.new(feat_def) }.not_to raise_error
+        it 'is initialized with one definition argument' do
+          expect { described_class.new(feat_def) }.not_to raise_error
         end
 
-        it 'should know its definition' do
-          expect(subject.definition).to eq(feat_def)
+        it 'knows its definition' do
+          expect(a_feature.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
+        it "isn't bound yet to a value" do
+          expect(a_feature.binding).to be_nil
+          expect(a_feature).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)
+        it "knows the definition's name" do
+          expect(a_feature.name).to eq(feat_def.name)
         end
 
-        it "should know the domain of its values" do
-          expect(subject.domain).to eq(a_domain)
+        it 'knows the domain of its values' do
+          expect(a_feature.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)
+        it 'accepts a value binding' do
+          expect { a_feature.bind_to(plural_value) }.not_to raise_error
+          expect(a_feature).to be_bound
+          expect(a_feature.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,35 +21,36 @@ module Zenlish
           init_struct_def(aParent, feature_hash)
         end
       end # class
+      # rubocop: enable Lint/ConstantDefinitionInBlock
 
-      subject { Dummy.new (nil) }
+      subject(:bearer) { Dummy.new(nil) }
 
       context 'Mix-in initialization' do
-        it 'should have initialized properly the injected data' do
+        it 'has initialized properly the injected data' do
           expect { Dummy.new(nil) }.not_to raise_error
-          expect(subject.struct).to be_kind_of(FeatureStructDef)
+          expect(bearer.struct).to be_a(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)          
+        it 'has the feature definitions created' do
+          expect(bearer['NUMBER']).not_to be_nil
+          expect(bearer['NUMBER']).to be_a(FeatureDef)
+          ft = bearer['NUMBER']
+          expect(ft.domain.enum).to eq(%i[singular plural])
+
+          expect(bearer['COUNTABILITY']).to be_a(FeatureDef)
+          expect(bearer['COUNTABILITY'].domain).to be_a(BooleanDomain)
+          expect(bearer['PARADIGM']).to be_a(FeatureDef)
+          expect(bearer['PARADIGM'].domain).to be_a(IdentifierDomain)
+          expect(bearer['PARADIGM'].default).to be_a(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)          
+
+        it 'supports the addition of feature def' do
+          bearer.feature_def_dsl { feature_def 'CASE' => boolean }
+
+          expect(bearer['CASE']).to be_a(FeatureDef)
+          expect(bearer['CASE'].domain).to be_a(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'
@@ -13,55 +14,55 @@ module Zenlish
       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(:sample_parent) { described_class.new }
       let(:case_domain) { EnumerationDomain.new(:common, :genitive) }
       let(:ft_case) { FeatureDef.new('CASE', case_domain) }
 
-      subject { FeatureStructDef.new(sample_parent) }
+      subject(:struct_def) { described_class.new(sample_parent) }
 
       context 'Initialization:' do
-        it 'could be initialized without argument' do
-          expect { FeatureStructDef.new }.not_to raise_error
+        it 'can be initialized without argument' do
+          expect { described_class.new }.not_to raise_error
         end
 
-        it 'could be initialized with a parent struct' do
-          expect { FeatureStructDef.new(sample_parent) }.not_to raise_error
+        it 'can be initialized with a parent struct' do
+          expect { described_class.new(sample_parent) }.not_to raise_error
         end
 
-        it 'should have an empty structure at initialization' do
-          expect(subject.struct).to be_empty
+        it 'has an empty structure at initialization' do
+          expect(struct_def.struct).to be_empty
         end
 
-        it 'should know its parent (if any)' do
-          expect(subject.parent).to eq(sample_parent)
-          instance = FeatureStructDef.new
+        it 'knows its parent (if any)' do
+          expect(struct_def.parent).to eq(sample_parent)
+          instance = described_class.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)
+        it 'accepts the addition of a feature definition' do
+          expect { struct_def.add_feature_def(ft_number) }.not_to raise_error
+          expect(struct_def.struct.size).to eq(1)
+          expect(struct_def['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)
+          expect { struct_def.add_feature_def(ft_countability) }.not_to raise_error
+          expect(struct_def.struct.size).to eq(2)
+          expect(struct_def['COUNTABILITY']).to eq(ft_countability)
         end
 
-        it 'should inherit the feature definition of its parent' do
+        it 'inherits the feature definition of its parent' do
           sample_parent.add_feature_def(ft_case)
-          expect(subject['CASE']).to eq(ft_case)
+          expect(struct_def['CASE']).to eq(ft_case)
         end
-        
-        it "should be able to override parent's feature def" do
+
+        it "is 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)
+          struct_def.add_feature_def(other_ft_case)
+          expect(struct_def['CASE']).to eq(other_ft_case)
         end
       end # context
     end # describe

data/spec/zenlish/feature/identifier_domain_spec.rb

@@ -5,32 +5,32 @@ require_relative '../../../lib/zenlish/feature/identifier_domain' # Load the cla
 module Zenlish
   module Feature
     describe IdentifierDomain do
-      subject { IdentifierDomain.instance }
+      subject(:domain) { described_class.instance }
 
       context 'Initialization:' do
-        it 'should be instantiated without argument' do
-          expect { IdentifierDomain.instance }.not_to raise_error
+        it 'is instantiated without argument' do
+          expect { described_class.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)
+        it 'knows whether a value is in domain' do
+          expect(domain).to include('CommonForm')
+          expect(domain).not_to include('Common Form')
+          expect(domain).not_to include('+123')
         end
 
-        it 'should complain when asked to build an invalid identifier' do
+        it 'provides a factory method for identifier values' do
+          expect(domain.build_value('CommonForm')).to be_a(IdentifierValue)
+          expect(domain.build_value('Common_Form')).to be_a(IdentifierValue)
+        end
+
+        it 'complains 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)
+          expect { domain.build_value('?1234') }.to raise_error(err, err_msg)
         end
       end # context
     end # describe
   end # module
-end # module
+end # module

data/spec/zenlish/feature/identifier_value_spec.rb

@@ -1,26 +1,27 @@
 # 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
     describe IdentifierValue do
       let(:its_value) { 'CommonForm' }
-      subject { IdentifierValue.new(its_value) }
+
+      subject(:identifier) { described_class.new(its_value) }
 
       context 'Initialization:' do
-        it 'should be initialized with a value argument' do
-          expect { IdentifierValue.new(its_value) }.not_to raise_error
+        it 'is initialized with a value argument' do
+          expect { described_class.new(its_value) }.not_to raise_error
+        end
+
+        it 'knows its internal value' do
+          expect(identifier.val).to eq(its_value)
         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
+end # module