zenlish 0.2.05 → 0.2.07

data/spec/zenlish/lang/lemmatizer_spec.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require_relative '../../spec_helper' # Use the RSpec framework
+require_relative '../../../lib/zenlish/lang/dictionary'
+
+# Load the class under test
+require_relative '../../../lib/zenlish/lang/lemmatizer'
+
+module Zenlish
+  module Lang
+    describe Lemmatizer do
+      subject { described_class.new(Dictionary) }
+
+      context 'Initialization:' do
+        # 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 '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
+end # module

data/spec/zenlish/lang/zenlish_grammar_spec.rb

@@ -4,13 +4,13 @@ require_relative '../../spec_helper' # Use the RSpec framework
 require_relative '../../../lib/zenlish/lang/zenlish_grammar' # Load the class under test
 
 module Zenlish
-  module Parser
+  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
 
@@ -18,4 +18,4 @@ module Zenlish
       end # context
     end # describe
   end # module
-end # module
+end # module

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

@@ -10,55 +10,54 @@ module Zenlish
   module Lex
     describe Lexeme do
       include Feature::FeatureStructDefBearer
-      
+
       let(:a_wclass) { WClasses::CommonNoun.new }
       let(:a_lemma) { 'people' }
       let(:an_entry) { LexicalEntry.new(a_lemma) }
-      let(:a_feat_struct_def) {
+      let(:a_feat_struct_def) do
              { 'NUMBER' => enumeration(:plural),
                '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 '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 '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
-        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 'knows all its inflections' do
+          expect(a_lexeme.all_inflections).to eq(['people'])
         end
-        
-        it 'should know all its inflections' do
-          expect(subject.all_inflections).to eq(['people'])
-        end       
       end # context
     end # describe
   end # module
 end # module
-

data/spec/zenlish/lex/lexical_entry_spec.rb

@@ -9,38 +9,38 @@ 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 'accepts links with lexeme(s)' do
+          lex_entry.add_lexeme(sample_lexeme1)
+          expect(lex_entry.lexemes).to eq([sample_lexeme1])
 
-        it 'should accept links with lexeme(s)' do
-          subject.add_lexeme(sample_lexeme1)
-          expect(subject.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
   end # module
-end # module
+end # module

data/spec/zenlish/lex/lexicon_spec.rb

@@ -12,7 +12,8 @@ module Zenlish
     describe Lexicon do
       def create_entry(aLemma, aWordClass)
         entry = Zenlish::Lex::LexicalEntry.new(aLemma)
-        lexeme = Zenlish::Lex::Lexeme.new(aWordClass, entry)
+        # lexeme =
+        Zenlish::Lex::Lexeme.new(aWordClass, entry)
         entry
       end
 
@@ -23,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)
-          
-          lexeme = subject.get_lexeme('hope')
-          expect(lexeme.wclass).to be_kind_of(Zenlish::WClasses::IrregularVerb)
+
+        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 = 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)
-          
-          lexeme = subject.get_lexeme('other', Zenlish::WClasses::Pronoun)
-          expect(lexeme).to be_kind_of(Zenlish::Lex::Lexeme)
-        end        
-
-        it 'should complain when retrieving an non-existing entry' do
-          subject.add_entry(sample_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 = lexicon.get_lexeme('other', Zenlish::WClasses::Pronoun)
+          expect(lexeme).to be_a(Zenlish::Lex::Lexeme)
+        end
+
+        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

@@ -8,24 +8,24 @@ require_relative '../../../lib/zenlish/lex/literal' # Load the class under test
 
 module Zenlish
   module Lex
-    describe Lexeme do
+    describe Literal do
       let(:sample_wclass) { WClasses::CommonNoun.new }
       let(:sample_lemma) { 'thing' }
       let(:sample_entry) { LexicalEntry.new(sample_lemma) }
-      let(:sample_position) { double('position') }
-      let(:sample_lexeme) { Lexeme.new(sample_wclass, sample_entry)  }
+      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

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require_relative '../../spec_helper' # Use the RSpec framework
+require_relative '../../../lib/zenlish/wclasses/all_word_classes'
+require_relative '../../../lib/zenlish/lex/lexical_entry'
+require_relative '../../../lib/zenlish/lex/lexeme'
+
+# Load the class under test
+require_relative '../../../lib/zenlish/lexer/lexer'
+
+module Zenlish
+  module Lexer
+    describe Lexer do
+      # let(:sample_wclass) { WClasses::CommonNoun.new }
+      # let(:sample_lemma) { 'thing' }
+      # let(:sample_entry) { LexicalEntry.new(sample_lemma) }
+      # let(:sample_position) { double('position') }
+      # let(:sample_lexeme) { Lexeme.new(sample_wclass, sample_entry)  }
+      let(:sample_sentence) { 'Tony sees Lisa.' }
+
+      subject(:lexer) { described_class.new(sample_sentence) }
+
+      context 'Initialization:' do
+        it 'is initialized with Zenlish text' do
+          expect { described_class.new(sample_sentence) }.not_to raise_error
+        end
+
+        it 'knows its scanner object' do
+          expect(lexer.scanner).not_to be_nil
+        end
+
+        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 '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')
+          expect(tokens[1].lexeme).to eq('sees')
+          expect(tokens[2].lexeme).to eq('Lisa')
+          expect(tokens[3].lexeme).to eq('.')
+          expect(tokens[3].terminal).to eq('Period')
+        end
+      end # context
+    end # describe
+  end # module
+end # module