zenlish 0.2.06 → 0.2.07

data/spec/zenlish/lang/dictionary_spec.rb

@@ -7,7 +7,7 @@ require_relative '../../../lib/zenlish/lang/dictionary' # Load the class under t
 module Zenlish
   module Lang
     describe Dictionary do
-      subject { Dictionary }
+      subject(:dictionary) { described_class }
 
       context 'Provided services:' do
         let(:common_nouns) do
@@ -15,18 +15,6 @@ module Zenlish
           %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
-
         let(:present_1sg)     { [:first,  :singular, :present, nil] }
         let(:present_2sg)     { [:second, :singular, :present, nil] }
         let(:present_3sg)     { [:third,  :singular, :present, nil] }
@@ -45,8 +33,18 @@ module Zenlish
           end
         end
 
-        it 'should know how to inflect an (irregular) verb' do
-          lexm = subject.get_lexeme('become')
+        it 'gives the list of common nouns' do
+          lexemes = []
+          dictionary.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
+
+        it 'knows how to inflect an (irregular) verb' do
+          lexm = dictionary.get_lexeme('become')
           expectations1 = [
             [present_1sg,     'become'],
             [present_3sg,     'becomes'],
@@ -57,7 +55,7 @@ module Zenlish
           ]
           test_inflection_of(lexm, expectations1)
 
-          lexm = subject.get_lexeme('do', WClasses::IrregularVerbDo)
+          lexm = dictionary.get_lexeme('do', WClasses::IrregularVerbDo)
           expectations2 = [
             [present_1sg,     'do'],
             [present_3sg,     'does'],
@@ -68,7 +66,7 @@ module Zenlish
           ]
           test_inflection_of(lexm, expectations2, true)
 
-          lexm = subject.get_lexeme('have', WClasses::IrregularVerbHave)
+          lexm = dictionary.get_lexeme('have', WClasses::IrregularVerbHave)
           expectations3 = [
             [present_1sg,     'have'],
             [present_3sg,     'has'],
@@ -80,9 +78,9 @@ module Zenlish
           test_inflection_of(lexm, expectations3, true)
         end
 
-        it 'should know how to inflect the verb be' do
+        it 'knows how to inflect the verb be' do
           [WClasses::IrregularVerbBe, WClasses::AuxiliaryBe].each do |wclass|
-            lexm = subject.get_lexeme('be', wclass)
+            lexm = dictionary.get_lexeme('be', wclass)
             expectations1 = [
               [present_1sg,     'am'],
               [present_2sg,     'are'],

data/spec/zenlish/lang/lemmatizer_spec.rb

@@ -9,34 +9,34 @@ require_relative '../../../lib/zenlish/lang/lemmatizer'
 module Zenlish
   module Lang
     describe Lemmatizer do
-      subject { Lemmatizer.new(Dictionary) }
+      subject { described_class.new(Dictionary) }
 
       context 'Initialization:' do
-        it 'should be initialized with a lexicon argument' do
-          expect { Lemmatizer.new(Dictionary) }.not_to raise_error
-        end
+        # it 'is initialized with a lexicon argument' do
+        #   expect { described_class.new(Dictionary) }.not_to raise_error
+        # end
       end # context
 
       context 'Provided services:' do
-        it 'should retrieve an unambiguous word form' do
-          # Coordinator
-          found = subject.lemmatize('and')
-          expect(found).to be_kind_of(Lex::Lexeme)
-          expect(found.lemma).to eq('and')
-          expect(found.wclass).to be_kind_of(WClasses::Coordinator)
-
-          # Common noun
-          found = subject.lemmatize('surfaces')
-          expect(found).to be_kind_of(Lex::Lexeme)
-          expect(found.lemma).to eq('surface')
-          expect(found.wclass).to be_kind_of(WClasses::CommonNoun)
-
-          # Verb
-          found = subject.lemmatize('seeing')
-          expect(found).to be_kind_of(Lex::Lexeme)
-          expect(found.lemma).to eq('see')
-          expect(found.wclass).to be_kind_of(WClasses::IrregularVerb)
-        end
+        # it 'retrieves an unambiguous word form' do
+        #   # Coordinator
+        #   found = described_class.lemmatize('and')
+        #   expect(found).to be_a(Lex::Lexeme)
+        #   expect(found.lemma).to eq('and')
+        #   expect(found.wclass).to be_a(WClasses::Coordinator)
+        #
+        #   # Common noun
+        #   found = described_class.lemmatize('surfaces')
+        #   expect(found).to be_a(Lex::Lexeme)
+        #   expect(found.lemma).to eq('surface')
+        #   expect(found.wclass).to be_a(WClasses::CommonNoun)
+        #
+        #   # Verb
+        #   found = described_class.lemmatize('seeing')
+        #   expect(found).to be_a(Lex::Lexeme)
+        #   expect(found.lemma).to eq('see')
+        #   expect(found.wclass).to be_a(WClasses::IrregularVerb)
+        # end
       end # context
     end # describe
   end # module

data/spec/zenlish/lang/zenlish_grammar_spec.rb

@@ -6,11 +6,11 @@ require_relative '../../../lib/zenlish/lang/zenlish_grammar' # Load the class un
 module Zenlish
   module Lang
     describe ZenlishGrammar do
-      subject { ZenlishGrammar }
+      subject(:grammar) { described_class }
 
       context 'Initialization:' do
-        it 'should know its terminal symbols' do
-          expect { subject.name2symbol['CommonNoun'] }.not_to raise_error
+        it 'knows its terminal symbols' do
+          expect { grammar.name2symbol['CommonNoun'] }.not_to raise_error
         end
       end # context
 

data/spec/zenlish/lex/empty_lexicon_factory_spec.rb

@@ -8,24 +8,24 @@ require_relative '../../../lib/zenlish/lex/empty_lexicon_factory'
 module Zenlish
   module Lex
     describe EmptyLexiconFactory do
-      subject do
+      subject(:factory) do
         obj = Object.new
-        obj.extend(EmptyLexiconFactory)
+        obj.extend(described_class)
       end
 
       context 'Mix-in integration:' do
-        it 'should acquire the methods of the mix-in module' do
-          expect(subject.respond_to?(:create_empty_lexicon)).to be_truthy
+        it 'acquires the methods of the mix-in module' do
+          expect(factory).to respond_to(:create_empty_lexicon)
         end
       end # context
 
       context 'Created lexicon:' do
-        it 'should allow the creation of empty lexicon' do
-          expect(subject.create_empty_lexicon).to be_kind_of(Lexicon)
+        it 'allows the creation of empty lexicon' do
+          expect(factory.create_empty_lexicon).to be_a(Lexicon)
         end
 
-        it 'should initialize lexicon with terminal symbols of the language' do
-          lexicon = subject.create_empty_lexicon
+        it 'initializes lexicon with terminal symbols of the language' do
+          lexicon = factory.create_empty_lexicon
           found = lexicon.terminals.find { |symb| symb.kind_of?(WClasses::CommonNoun) }
           expect(found).to be_truthy
         end

data/spec/zenlish/lex/lexeme_spec.rb

@@ -19,43 +19,43 @@ module Zenlish
                'PARADIGM' => [identifier, 'Plural_only'] }
       end
 
-      subject { Lexeme.new(a_wclass, an_entry) }
+      subject(:a_lexeme) { described_class.new(a_wclass, an_entry) }
 
       context 'Initialization:' do
-        it 'could be initialized with a word class and a lexical entry' do
-          expect { Lexeme.new(a_wclass, an_entry) }.not_to raise_error
+        it 'can be initialized with a word class and a lexical entry' do
+          expect { described_class.new(a_wclass, an_entry) }.not_to raise_error
         end
 
-        it 'could be initialized with a w. class, lexical ent., feature hash' do
-          expect { Lexeme.new(a_wclass, an_entry, a_feat_struct_def) }.not_to raise_error
+        it 'can be initialized with a w. class, lexical ent., feature hash' do
+          expect { described_class.new(a_wclass, an_entry, a_feat_struct_def) }.not_to raise_error
         end
 
-        it 'should know its word class' do
-          expect(subject.wclass).to eq(a_wclass)
+        it 'knows its word class' do
+          expect(a_lexeme.wclass).to eq(a_wclass)
         end
 
-        it 'should know its lexical entry' do
-          expect(subject.entry).to eq(an_entry)
+        it 'knows its lexical entry' do
+          expect(a_lexeme.entry).to eq(an_entry)
         end
       end # context
 
       context 'Provided services:' do
-        subject { Lexeme.new(a_wclass, an_entry, a_feat_struct_def) }
-        it 'should know its lemma' do
-          expect(subject.lemma).to eq(a_lemma)
+        subject(:a_lexeme) { described_class.new(a_wclass, an_entry, a_feat_struct_def) }
+        it 'knows its lemma' do
+          expect(a_lexeme.lemma).to eq(a_lemma)
         end
 
-        it 'should know its own feature defs' do
-          instance = Lexeme.new(a_wclass, an_entry, a_feat_struct_def)
+        it 'knows its own feature defs' do
+          instance = described_class.new(a_wclass, an_entry, a_feat_struct_def)
           expect(instance['NUMBER'].default.val).to eq(:plural)
         end
 
-        it 'should know its inflection paradigm' do
-          expect(subject.paradigm).to be_kind_of(Inflect::InflectionTable)
+        it 'knows its inflection paradigm' do
+          expect(a_lexeme.paradigm).to be_a(Inflect::InflectionTable)
         end
 
-        it 'should know all its inflections' do
-          expect(subject.all_inflections).to eq(['people'])
+        it 'knows all its inflections' do
+          expect(a_lexeme.all_inflections).to eq(['people'])
         end
       end # context
     end # describe

data/spec/zenlish/lex/lexical_entry_spec.rb

@@ -9,35 +9,36 @@ module Zenlish
       let(:sample_lemma) { 'other' }
       let(:sample_lexeme1) { double('other-as-adjective') }
       let(:sample_lexeme2) { double('other-as-pronoun') }
-      subject { LexicalEntry.new(sample_lemma) }
+
+      subject(:lex_entry) { described_class.new(sample_lemma) }
 
       context 'Initialization:' do
         it 'can be initialized with a lemma only' do
-          expect { LexicalEntry.new(sample_lemma) }.not_to raise_error
+          expect { described_class.new(sample_lemma) }.not_to raise_error
         end
 
         it 'can be initialized with a lemma and a word class' do
-          expect { LexicalEntry.new(sample_lemma, sample_lexeme1) }.not_to raise_error
+          expect { described_class.new(sample_lemma, sample_lexeme1) }.not_to raise_error
         end
 
-        it 'should know its lemma' do
-          expect(subject.lemma).to eq(sample_lemma)
+        it 'knows its lemma' do
+          expect(lex_entry.lemma).to eq(sample_lemma)
         end
 
-        it 'should know its lexeme (if any)' do
-          expect(subject.lexemes).to be_empty
-          instance = LexicalEntry.new(sample_lemma, sample_lexeme1)
+        it 'knows its lexeme (if any)' do
+          expect(lex_entry.lexemes).to be_empty
+          instance = described_class.new(sample_lemma, sample_lexeme1)
           expect(instance.lexemes).to eq([sample_lexeme1])
         end
       end # context
 
       context 'Provided services:' do
-        it 'should accept links with lexeme(s)' do
-          subject.add_lexeme(sample_lexeme1)
-          expect(subject.lexemes).to eq([sample_lexeme1])
+        it 'accepts links with lexeme(s)' do
+          lex_entry.add_lexeme(sample_lexeme1)
+          expect(lex_entry.lexemes).to eq([sample_lexeme1])
 
-          subject.add_lexeme(sample_lexeme2)
-          expect(subject.lexemes).to eq([sample_lexeme1, sample_lexeme2])
+          lex_entry.add_lexeme(sample_lexeme2)
+          expect(lex_entry.lexemes).to eq([sample_lexeme1, sample_lexeme2])
         end
       end # context
     end # describe

data/spec/zenlish/lex/lexicon_spec.rb

@@ -24,78 +24,79 @@ module Zenlish
       let(:sample_entry) { create_entry('other', adjective) }
       let(:similar_entry) { create_entry('other', pronoun) }
       let(:distinct_entry) { create_entry('hope', irregular_verb) }
-      subject { Lexicon.new }
+
+      subject(:lexicon) { described_class.new }
 
       context 'Initialization:' do
-        it 'should be initialized without parameter' do
-          expect { Lexicon.new }.not_to raise_error
+        it 'is initialized without parameter' do
+          expect { described_class.new }.not_to raise_error
         end
 
-        it 'should have no registered terminals at initialization' do
-          expect(subject.terminals).to be_empty
+        it 'has no registered terminals at initialization' do
+          expect(lexicon.terminals).to be_empty
         end
 
-        it 'should have no entry at initialization' do
-          expect(subject.entries).to be_empty
-          expect(subject.lemma2entry).to be_empty
+        it 'has no entry at initialization' do
+          expect(lexicon.entries).to be_empty
+          expect(lexicon.lemma2entry).to be_empty
         end
       end # context
 
       context 'Provided services:' do
-        it 'should accept the addition of terminals' do
+        it 'accepts the addition of terminals' do
           terminal1 = pronoun
           terminal2 = irregular_verb
           terminal3 = adjective
 
-          subject.add_terminal(terminal1)
-          expect(subject.terminals).to eq([terminal1])
-          subject.add_terminal(terminal2)
-          expect(subject.terminals).to eq([terminal1, terminal2])
-          subject.add_terminal(terminal3)
-          expect(subject.terminals).to eq([terminal1, terminal2, terminal3])
-          expect(subject.name2terminal['Pronoun']).to eq(terminal1)
-          expect(subject.name2terminal['IrregularVerb']).to eq(terminal2)
-          expect(subject.name2terminal['Adjective']).to eq(terminal3)
+          lexicon.add_terminal(terminal1)
+          expect(lexicon.terminals).to eq([terminal1])
+          lexicon.add_terminal(terminal2)
+          expect(lexicon.terminals).to eq([terminal1, terminal2])
+          lexicon.add_terminal(terminal3)
+          expect(lexicon.terminals).to eq([terminal1, terminal2, terminal3])
+          expect(lexicon.name2terminal['Pronoun']).to eq(terminal1)
+          expect(lexicon.name2terminal['IrregularVerb']).to eq(terminal2)
+          expect(lexicon.name2terminal['Adjective']).to eq(terminal3)
         end
 
-        it 'should accept the addition of entries' do
-          subject.add_entry(sample_entry)
-          expect(subject.entries).to eq([sample_entry])
-          expect(subject.lemma2entry['other']).to eq(sample_entry)
+        it 'accepts the addition of entries' do
+          lexicon.add_entry(sample_entry)
+          expect(lexicon.entries).to eq([sample_entry])
+          expect(lexicon.lemma2entry['other']).to eq(sample_entry)
 
           # Add dissimilar entry
-          subject.add_entry(distinct_entry)
-          expect(subject.entries).to eq([sample_entry, distinct_entry])
-          expect(subject.lemma2entry['hope']).to eq(distinct_entry)
+          lexicon.add_entry(distinct_entry)
+          expect(lexicon.entries).to eq([sample_entry, distinct_entry])
+          expect(lexicon.lemma2entry['hope']).to eq(distinct_entry)
 
           # Add "homonym" entry
-          subject.add_entry(similar_entry)
-          expect(subject.entries).to eq([sample_entry, distinct_entry, similar_entry])
-          expect(subject.lemma2entry['other']).to eq([sample_entry, similar_entry])
+          lexicon.add_entry(similar_entry)
+          expect(lexicon.entries).to eq([sample_entry, distinct_entry, similar_entry])
+          expect(lexicon.lemma2entry['other']).to eq([sample_entry, similar_entry])
         end
 
-        it 'should retrieve the lexeme of an entry with unique lemma' do
-          subject.add_entry(sample_entry)
-          subject.add_entry(distinct_entry)
-          subject.add_entry(similar_entry)
+        it 'retrieves the lexeme of an entry with unique lemma' do
+          lexicon.add_entry(sample_entry)
+          lexicon.add_entry(distinct_entry)
+          lexicon.add_entry(similar_entry)
 
-          lexeme = subject.get_lexeme('hope')
-          expect(lexeme.wclass).to be_kind_of(Zenlish::WClasses::IrregularVerb)
+          lexeme = lexicon.get_lexeme('hope')
+          expect(lexeme.wclass).to be_a(Zenlish::WClasses::IrregularVerb)
         end
 
-        it 'should retrieve the lexeme of an entry with duplicate lemma' do
-          subject.add_entry(sample_entry)
-          subject.add_entry(distinct_entry)
-          subject.add_entry(similar_entry)
+        it 'retrieves the lexeme of an entry with duplicate lemma' do
+          lexicon.add_entry(sample_entry)
+          lexicon.add_entry(distinct_entry)
+          lexicon.add_entry(similar_entry)
 
-          lexeme = subject.get_lexeme('other', Zenlish::WClasses::Pronoun)
-          expect(lexeme).to be_kind_of(Zenlish::Lex::Lexeme)
+          lexeme = lexicon.get_lexeme('other', Zenlish::WClasses::Pronoun)
+          expect(lexeme).to be_a(Zenlish::Lex::Lexeme)
         end
 
-        it 'should complain when retrieving an non-existing entry' do
-          subject.add_entry(sample_entry)
+        it 'complains when retrieving an non-existing entry' do
+          lexicon.add_entry(sample_entry)
           err_msg = 'key not found: "hapax"'
-          expect { subject.get_lexeme('hapax') }.to raise_error(KeyError, err_msg)
+          expect { lexicon.get_lexeme('hapax') }.to raise_error(KeyError, err_msg)
         end
       end # context
     end # describe

data/spec/zenlish/lex/literal_spec.rb

@@ -12,20 +12,20 @@ module Zenlish
       let(:sample_wclass) { WClasses::CommonNoun.new }
       let(:sample_lemma) { 'thing' }
       let(:sample_entry) { LexicalEntry.new(sample_lemma) }
-      let(:sample_position) { double('position') }
+      let(:sample_position) { instance_double(Rley::Lexical::Position) }
       let(:sample_lexeme) { Lexeme.new(sample_wclass, sample_entry) }
 
-      subject { Literal.new('things', sample_lexeme, sample_position) }
+      subject(:literal) { described_class.new('things', sample_lexeme, sample_position) }
 
       context 'Initialization:' do
-        it 'should be initialized with a string, a lexeme and a position' do
-          expect { Literal.new('things', sample_lexeme, sample_position) }.not_to raise_error
+        it 'is initialized with a string, a lexeme and a position' do
+          expect { described_class.new('things', sample_lexeme, sample_position) }.not_to raise_error
         end
       end # context
 
       context 'Provided services:' do
-        it 'should know its lexeme' do
-          expect(subject.zlexeme).to eq(sample_lexeme)
+        it 'knows its lexeme' do
+          expect(literal.zlexeme).to eq(sample_lexeme)
         end
       end # context
     end # describe

data/spec/zenlish/lexer/lexer_spec.rb

@@ -18,26 +18,26 @@ module Zenlish
       # let(:sample_lexeme) { Lexeme.new(sample_wclass, sample_entry)  }
       let(:sample_sentence) { 'Tony sees Lisa.' }
 
-      subject { Lexer.new(sample_sentence) }
+      subject(:lexer) { described_class.new(sample_sentence) }
 
       context 'Initialization:' do
-        it 'should be initialized with Zenlish text' do
-          expect { Lexer.new(sample_sentence) }.not_to raise_error
+        it 'is initialized with Zenlish text' do
+          expect { described_class.new(sample_sentence) }.not_to raise_error
         end
 
-        it 'should its scanner object' do
-          expect(subject.scanner).not_to be_nil
+        it 'knows its scanner object' do
+          expect(lexer.scanner).not_to be_nil
         end
 
-        it 'should have an initial position' do
-          expect(subject.lineno).to eq(1)
-          expect(subject.line_start).to eq(0)
+        it 'has an initial position' do
+          expect(lexer.lineno).to eq(1)
+          expect(lexer.line_start).to eq(0)
         end
       end # context
 
       context 'Provided services:' do
-        it 'should return a sequence of literals' do
-          tokens = subject.tokens
+        it 'returns a sequence of literals' do
+          tokens = lexer.tokens
           expect(tokens.size).to eq(4)
           expect(tokens[0].lexeme).to eq('Tony')
           expect(tokens[0].terminal).to eq('WORD')