zenlish 0.2.06 → 0.2.07

data/spec/zenlish/feature/feature_spec.rb

@@ -14,36 +14,36 @@ 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

data/spec/zenlish/feature/feature_struct_def_bearer_spec.rb

@@ -23,32 +23,32 @@ module Zenlish
       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']
+        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(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(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 }
+        it 'supports the addition of feature def' do
+          bearer.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(bearer['CASE']).to be_a(FeatureDef)
+          expect(bearer['CASE'].domain).to be_a(BooleanDomain)
         end
       end # context
     end # describe

data/spec/zenlish/feature/feature_struct_def_spec.rb

@@ -14,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,30 +5,30 @@ 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
+        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 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 '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 'should complain when asked to build an invalid identifier' do
+        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

data/spec/zenlish/feature/identifier_value_spec.rb

@@ -7,15 +7,16 @@ 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 'should know its internal value' do
-          expect(subject.val).to eq(its_value)
+        it 'knows its internal value' do
+          expect(identifier.val).to eq(its_value)
         end
       end # context
 

data/spec/zenlish/feature/symbol_value_spec.rb

@@ -8,15 +8,16 @@ module Zenlish
   module Feature
     describe SymbolValue do
       let(:its_value) { :plural }
-      subject { SymbolValue.new(its_value) }
+
+      subject(:symbolic) { described_class.new(its_value) }
 
       context 'Initialization:' do
-        it 'should be initialized with a value argument' do
-          expect { SymbolValue.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).to eq(its_value)
+        it 'knows its internal value' do
+          expect(symbolic.val).to eq(its_value)
         end
       end # context
 

data/spec/zenlish/inflect/concatenation_spec.rb

@@ -12,27 +12,27 @@ module Zenlish
       let(:sample_argument) { FormalArgument.new(2) }
       let(:base_form) { InputAsIs.new(sample_argument) }
 
-      subject { Concatenation.new(base_form, suffix) }
+      subject(:concatenation) { described_class.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
+        it 'is initialized with two arguments' do
+          expect { described_class.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)
+        it 'knows its arguments' do
+          expect(concatenation.children.first).to eq(base_form)
+          expect(concatenation.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
+        it 'concatenates children results' do
           headings = double('fake-headings')
           lexeme = double('fake-lexeme')
 
-          expect(subject.generate(headings, lexeme, sample_values)).to eq('places')
+          expect(concatenation.generate(headings, lexeme, sample_values)).to eq('places')
         end
       end # context
     end # describe

data/spec/zenlish/inflect/equals_literal_spec.rb

@@ -13,44 +13,45 @@ module Zenlish
     describe EqualsLiteral do
       let(:an_argument) { FormalArgument.new(1) }
       let(:feat_val) { :plural }
-      subject { EqualsLiteral.new(an_argument, feat_val) }
+
+      subject(:literal) { described_class.new(an_argument, feat_val) }
 
       context 'Initialization:' do
-        it 'should be initialized with a formal argument and a literal' do
-          expect { EqualsLiteral.new(an_argument, feat_val) }.not_to raise_error
+        it 'is initialized with a formal argument and a literal' do
+          expect { described_class.new(an_argument, feat_val) }.not_to raise_error
         end
 
-        it 'should know its argument' do
-          expect(subject.argument).to eq(an_argument)
+        it 'knows its argument' do
+          expect(literal.argument).to eq(an_argument)
         end
 
-        it 'should know the literal' do
-          expect(subject.literal).to eq(feat_val)
+        it 'knows the literal' do
+          expect(literal.literal).to eq(feat_val)
         end
       end # context
 
       context 'Provided services:' do
-        it 'should test the actual argument' do
+        it 'tests 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
+          expect(literal).to be_success(headings, lexeme, actual_args)
           actual_args[1] = :singular
-          expect(subject.success?(headings, lexeme, actual_args)).to be_falsy
+          expect(literal).not_to be_success(headings, lexeme, actual_args)
         end
 
-        it 'should test the lexeme' do
+        it 'tests 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
+          expect(literal).to be_success(headings, lexeme, [])
 
-          instance = EqualsLiteral.new(an_argument, :singular)
-          expect(instance.success?(headings, lexeme, [])).to be_truthy
+          instance = described_class.new(an_argument, :singular)
+          expect(instance).to be_success(headings, lexeme, [])
 
-          instance = EqualsLiteral.new(an_argument, :irregular)
-          expect(instance.success?(headings, lexeme, [])).to be_falsey
+          instance = described_class.new(an_argument, :irregular)
+          expect(instance).not_to be_success(headings, lexeme, [])
         end
       end # context
     end # describe

data/spec/zenlish/inflect/feature_heading_spec.rb

@@ -7,15 +7,16 @@ module Zenlish
   module Inflect
     describe FeatureHeading do
       let(:feature_name) { 'NUMBER' }
-      subject { FeatureHeading.new(feature_name) }
+
+      subject(:ft_heading) { described_class.new(feature_name) }
 
       context 'Initialization:' do
-        it 'should be initialized with a feature name' do
-          expect { FeatureHeading.new(feature_name) }.not_to raise_error
+        it 'is initialized with a feature name' do
+          expect { described_class.new(feature_name) }.not_to raise_error
         end
 
-        it 'should know its label' do
-          expect(subject.label).to eq(feature_name)
+        it 'knows its label' do
+          expect(ft_heading.label).to eq(feature_name)
         end
       end # context
 
@@ -25,24 +26,24 @@ module Zenlish
         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
+        it 'obtains the value of a feature' do
           mocked = { 'NUMBER' => :plural }
-          expect(subject.evaluate_for(mocked)).to eq(:plural)
+          expect(ft_heading.evaluate_for(mocked)).to eq(:plural)
         end
 
-        it 'should obtain all possible values of a feature' do
+        it 'obtains all possible values of a feature' do
           mocked = { 'NUMBER' => :plural }
-          expect(subject.all_matches(mocked)).to eq([:plural])
+          expect(ft_heading.all_matches(mocked)).to eq([:plural])
         end
 
-        it 'should obtain all possible values of a enumeration domain' do
+        it 'obtains all possible values of a enumeration domain' do
           mocked = { 'NUMBER' => enum_def }
-          expect(subject.all_matches(mocked)).to eq(%i[singular plural])
+          expect(ft_heading.all_matches(mocked)).to eq(%i[singular plural])
         end
 
-        it 'should obtain all possible values of a enumeration domain' do
+        it 'obtains all possible values of a enumeration domain' do
           mocked = { 'NUMBER' => bool_def }
-          expect(subject.all_matches(mocked)).to eq([false, true])
+          expect(ft_heading.all_matches(mocked)).to eq([false, true])
         end
       end # context
     end # describe

data/spec/zenlish/inflect/formal_argument_spec.rb

@@ -6,15 +6,15 @@ require_relative '../../../lib/zenlish/inflect/formal_argument'
 module Zenlish
   module Inflect
     describe FormalArgument do
-      subject { FormalArgument.new(3) }
+      subject(:arg) { described_class.new(3) }
 
       context 'Initialization:' do
-        it 'should be initialized with a text literal' do
-          expect { FormalArgument.new(1) }.not_to raise_error
+        it 'is initialized with a text literal' do
+          expect { described_class.new(1) }.not_to raise_error
         end
 
-        it 'should know its index value' do
-          expect(subject.index).to eq(3)
+        it 'knows its index value' do
+          expect(arg.index).to eq(3)
         end
       end # context
 

data/spec/zenlish/inflect/function_call_spec.rb

@@ -1,30 +1,29 @@
 # frozen_string_literal: true
 
-require 'ostruct'
 # Load the class under test
 require_relative '../../../lib/zenlish/inflect/function_call'
 
 module Zenlish
   module Inflect
     describe FunctionCall do
-      subject { FunctionCall.new('greet') }
+      subject(:func_call) { described_class.new('greet') }
 
       context 'Initialization:' do
-        it 'should be initialized with a text literal' do
-          expect { FunctionCall.new('greet') }.not_to raise_error
+        it 'is initialized with a text literal' do
+          expect { described_class.new('greet') }.not_to raise_error
         end
 
-        it 'should know its method name' do
-          expect(subject.mth_name).to eq('greet')
+        it 'knows its method name' do
+          expect(func_call.mth_name).to eq('greet')
         end
       end # context
 
       context 'Provided services:' do
-        it 'should return the affix during word form generation' do
+        it 'returns the affix during word form generation' do
           headings = double('fake-headings')
-          lexeme = OpenStruct.new(greet: 'Hello, world')
+          lexeme = double('fake-lexeme', greet: 'Hello, world')
           values = double('fake-values')
-          expect(subject.generate(headings, lexeme, values)).to eq('Hello, world')
+          expect(func_call.generate(headings, lexeme, values)).to eq('Hello, world')
         end
       end # context
     end # describe

data/spec/zenlish/inflect/inflection_rule_spec.rb

@@ -44,21 +44,21 @@ module Zenlish
       let(:pattern) { /y$/ }
       let(:consequent) { Substitution.new(base, pattern, suffix) }
 
-      subject { InflectionRule.new(conditions, consequent) }
+      subject(:i_rule) { described_class.new(conditions, consequent) }
 
       context 'Initialization:' do
-        it 'should be initialized with condition and consequent parts' do
+        it 'is initialized with condition and consequent parts' do
           expect do
-            InflectionRule.new(conditions, consequent)
+            described_class.new(conditions, consequent)
           end.not_to raise_error
         end
 
-        it 'should know its condition part' do
-          expect(subject.conditions).to eq(conditions)
+        it 'knows its condition part' do
+          expect(i_rule.conditions).to eq(conditions)
         end
 
-        it 'should know its consequent part' do
-          expect(subject.consequent).to eq(consequent)
+        it 'knows its consequent part' do
+          expect(i_rule.consequent).to eq(consequent)
         end
       end # context
 
@@ -68,36 +68,36 @@ module Zenlish
         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
+        it 'succeeds when all conditions succeed with actuals' do
           actuals = [:plural, 'cherry']
-          expect(subject.success?(headings, fake_lexeme, actuals)).to be_truthy
+          expect(i_rule).to be_success(headings, fake_lexeme, actuals)
         end
 
-        it 'should fail when one condition fails with actuals' do
+        it 'fails when one condition fails with actuals' do
           actuals = [:singular, 'cherry']
-          expect(subject.success?(headings, fake_lexeme, actuals)).to be_falsy
+          expect(i_rule).not_to be_success(headings, fake_lexeme, actuals)
 
           actuals = [:plural, 'girl']
-          expect(subject.success?(headings, fake_lexeme, actuals)).to be_falsy
+          expect(i_rule).not_to be_success(headings, fake_lexeme, actuals)
         end
 
-        it 'should generate inflected form when rule iworks for actuals' do
+        it 'generates inflected form when rule iworks for actuals' do
           actuals = [:plural, 'cherry']
-          expect(subject.apply(headings, fake_lexeme, actuals)).to eq('cherries')
+          expect(i_rule.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
+        it 'succeeds when all conditions succeed for given lexeme' do
+          expect(i_rule).to be_success(headings, lexeme, [])
         end
 
-        it 'should fail when one condition fails with given lexeme' do
+        it 'fails 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
+          expect(i_rule).not_to be_success(headings, lex_m2, [])
         end
 
-        it 'should generate inflected form when rule works for given lexeme' do
-          expect(subject.apply(headings, lexeme, [])).to eq('cherries')
+        it 'generates inflected form when rule works for given lexeme' do
+          expect(i_rule.apply(headings, lexeme, [])).to eq('cherries')
         end
       end # context
     end # describe