zenlish 0.1.02 → 0.1.03

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 33ea0d4f4ce6b47acec5b160c5f83e8149f23572fdb5a20a254ad1c191b49f3a
-  data.tar.gz: b6ebbc91c0e75e3ff55e42e4955e15a63fa16804447a0c5c50c5b9e7761e2410
+  metadata.gz: 303e2acef033aed91d93a33892c22bf003940b47ee7acf53e77530d04a7b720d
+  data.tar.gz: f7593cd6c3610aff0e37aa2b2671540a466e01f5a20134d65e671dc7b8d8ad3f
 SHA512:
-  metadata.gz: 54332bc6951d015fcb1697efe5f3415e04e34de6e703b460ecedb7a16e4639d999ab007105e8f70b20f992dc31937a2ab5332c50d677aa3e426c7ab646fc5b0c
-  data.tar.gz: 0fbd311e26da2a6b024da6cc150f7a86fe0cd40c7736c7a0c7e1b700836aee04bb89a0b3946b42b75e070adc5444889bfdecb9d8236a23dcd2a261ed93c4ce09
+  metadata.gz: 63d9af886477840162a302b7cbd03cfadba340f9795af9f53d65278860518196c6ecec9eb576b35f3135cb86faac1a5ece827e6988530f3b6d4245cde46b5d1b
+  data.tar.gz: 4c40e0909145729bd671b179bc62831209c6bd2fa8dc598c58be097af7c64b343e6695bf01e438a6a2069496e45ac9e57826b873473006d35f41dbf46f8766e2

data/CHANGELOG.md

@@ -1,5 +1,20 @@
 # CHANGELOG
 
+## [0.1.03] - 2019-10-13
+__Zenlish__ can parse all the sentences in lessons 1-A ... 1-D from
+ [Learn These Words First](http://learnthesewordsfirst.com/).
+
+ ### Added
+- Class `AdverbNot` to represent adverb `not` (for negative sentences).
+- Class `AdverbThere` to represent the adverb `there` (for `there is`, `there are`).
+- Class `AuxiliaryDo` to represent the auxiliary `do` verb.
+- Class `IrregularVerbBe` to represent the verb `be` when used as a lexical verb.
+- Class `PrepositionThan` to use with comparative clauses.
+
+### Changed
+- File `zparser_spec.rb`: tests include all sentences from lesson 1-C.
+- `ZenlishGrammar`: new rules (i.e. negative_sentence, ...).
+
 ## [0.1.02] - 2019-10-11
 __Zenlish__ can parse all the sentences in lessons 1-A, 1-B, 1-C from
  [Learn These Words First](http://learnthesewordsfirst.com/).

data/lib/zenlish/lex/empty_lexicon_factory.rb

@@ -16,7 +16,11 @@ module Zenlish
 
       def add_word_classes(aLexicon)
         aLexicon.add_terminal(WClasses::Adjective.new.freeze)
-        aLexicon.add_terminal(WClasses::Adverb.new.freeze)        
+        aLexicon.add_terminal(WClasses::Adverb.new.freeze)
+        aLexicon.add_terminal(WClasses::AdverbNot.new.freeze)
+        aLexicon.add_terminal(WClasses::AdverbThere.new.freeze)        
+        # aLexicon.add_terminal(WClasses::AuxiliaryBe.new.freeze)
+        aLexicon.add_terminal(WClasses::AuxiliaryDo.new.freeze)        
         aLexicon.add_terminal(WClasses::Cardinal.new.freeze)
         aLexicon.add_terminal(WClasses::CommonNoun.new.freeze)
         aLexicon.add_terminal(WClasses::ComparativeParticle.new.freeze)
@@ -24,7 +28,9 @@ module Zenlish
         aLexicon.add_terminal(WClasses::DemonstrativeDeterminer.new.freeze)
         aLexicon.add_terminal(WClasses::IndefinitePronoun.new.freeze)
         aLexicon.add_terminal(WClasses::IrregularVerb.new.freeze)
-        aLexicon.add_terminal(WClasses::Preposition.new.freeze)        
+        aLexicon.add_terminal(WClasses::IrregularVerbBe.new.freeze)        
+        aLexicon.add_terminal(WClasses::Preposition.new.freeze)
+        aLexicon.add_terminal(WClasses::PrepositionThan.new.freeze)        
         aLexicon.add_terminal(WClasses::ProperNoun.new.freeze)
         aLexicon.add_terminal(WClasses::IndefiniteQuantifier.new.freeze)
       end

data/lib/zenlish/lex/lexeme.rb

@@ -2,7 +2,10 @@ module Zenlish
   module Lex
     # TODO: document
     class Lexeme
+      # @return Zenlish::WClasses::WordClass
       attr_reader :wclass
+      
+      # @return Zenlish::Lex::LexicalEntry
       attr_reader :entry
 
       def initialize(aWordClass, anEntry)

data/lib/zenlish/lex/lexicon.rb

@@ -19,8 +19,27 @@ module Zenlish
         @name2terminal = {}
       end
 
-      def get_lexeme(aLemma)
-        lemma2entry.fetch(aLemma).lexemes.first
+      def get_lexeme(aLemma, aWordClass = nil)
+        if aWordClass
+          lexeme = nil
+          candidate = nil
+
+          entries = lemma2entry.fetch(aLemma)
+          if entries.kind_of?(Array)
+            entries.each do |e|
+              candidate = e.lexemes.first
+              break if candidate.wclass.kind_of?(aWordClass)
+            end
+            lexeme = candidate
+          else
+            candidate = entries.lexemes.first
+            lexeme = candidate if candidate.wclass.kind_of?(aWordClass)
+          end
+
+          lexeme
+        else
+          lemma2entry.fetch(aLemma).lexemes.first
+        end
       end
 
       def add_terminal(aTerminal)

data/lib/zenlish/parser/zenlish_grammar.rb

@@ -13,11 +13,22 @@ builder = Rley::Syntax::GrammarBuilder.new do
   rule 'language' => 'sentence'
   rule 'sentence' => 'simple_sentence'
   rule 'simple_sentence' => 'declarative_simple_sentence Period'
-  rule 'declarative_simple_sentence' => 'noun_phrase verb_phrase'
+  rule 'declarative_simple_sentence' => 'affirmative_sentence'  
+  rule 'declarative_simple_sentence' => 'negative_sentence'
+  rule 'affirmative_sentence' => 'noun_phrase verb_phrase'
+  rule 'affirmative_sentence' => 'AdverbThere IrregularVerbBe verb_complement'  
+  rule 'negative_sentence' => 'noun_phrase negative_verb_phrase'
+  rule 'negative_sentence' => 'AdverbThere negative_verb_phrase'  
   rule 'noun_phrase' => 'nominal'
   rule 'noun_phrase' => 'determiner nominal'
-  rule 'noun_phrase' => 'numeral nominal'  
-  rule 'noun_phrase' => 'determiner numeral nominal'
+  rule 'noun_phrase' => 'numeral nominal'
+  
+  # Case: ... one of these things.
+  rule 'noun_phrase' => 'numeral Preposition DemonstrativeDeterminer noun_phrase'   
+  rule 'noun_phrase' => 'determiner numeral nominal' 
+  
+  # CGE p.359, 360: of + definite noun phrase
+  rule 'noun_phrase' => 'determiner Preposition DemonstrativeDeterminer noun_phrase'
   rule 'noun_phrase' => 'ProperNoun' 
   rule 'noun_phrase' => 'IndefinitePronoun'  
   rule 'nominal' => 'CommonNoun'
@@ -28,15 +39,21 @@ builder = Rley::Syntax::GrammarBuilder.new do
   rule 'single_determiner' => 'DemonstrativeDeterminer'
   rule 'single_determiner' => 'DefiniteArticle'
   rule 'single_determiner' => 'IndefiniteQuantifier'
-  rule 'verb_phrase' => 'lexical_verb'  
-  rule 'verb_phrase' => 'lexical_verb noun_phrase'
-  rule 'verb_phrase' => 'lexical_verb adverb_phrase'  
-  rule 'verb_phrase' => 'lexical_verb propositional_phrase'
-  rule 'verb_phrase' => 'lexical_verb noun_phrase adverb_phrase'
-  rule 'verb_phrase' => 'lexical_verb noun_phrase propositional_phrase'  
+  rule 'verb_phrase' => 'lexical_verb'
+  rule 'verb_phrase' => 'lexical_verb verb_complement'  
+  rule 'verb_complement' => 'noun_phrase'
+  rule 'verb_complement' => 'adverb_phrase'   
+  rule 'verb_complement' => 'propositional_phrase'
+  rule 'verb_complement' => 'noun_phrase adverb_phrase'
+  rule 'verb_complement' => 'noun_phrase propositional_phrase'
+  rule 'negative_verb_phrase' => 'IrregularVerbBe AdverbNot verb_complement'
+  rule 'negative_verb_phrase' => 'AuxiliaryDo AdverbNot verb_phrase'
   rule 'lexical_verb' => 'IrregularVerb'
+  rule 'lexical_verb' => 'IrregularVerbBe'
   rule 'numeral' => 'Cardinal'
-  rule 'comparative_clause' => 'comparative_start noun_phrase verb_phrase'
+  rule 'comparative_clause' => 'comparative_start noun_phrase'  
+  rule 'comparative_clause' => 'comparative_start affirmative_sentence'
+  rule 'comparative_start' => 'PrepositionThan'  
   rule 'comparative_start' => 'ComparativeParticle'
   rule 'adverb_phrase' => 'Adverb'
   rule 'adverb_phrase' => 'Adverb propositional_phrase'

data/lib/zenlish/version.rb

@@ -1,3 +1,3 @@
 module Zenlish
-  VERSION = '0.1.02'
+  VERSION = '0.1.03'
 end

data/lib/zenlish/wclasses/adverb_not.rb

@@ -0,0 +1,9 @@
+require_relative 'adverb'
+
+module Zenlish
+  module WClasses
+    # TODO: document
+    class AdverbNot < Adverb
+    end # class
+  end # module
+end # module

data/lib/zenlish/wclasses/adverb_there.rb

@@ -0,0 +1,9 @@
+require_relative 'adverb'
+
+module Zenlish
+  module WClasses
+    # TODO: document
+    class AdverbThere < Adverb
+    end # class
+  end # module
+end # module

data/lib/zenlish/wclasses/all_word_classes.rb

@@ -3,14 +3,20 @@
 
 require_relative 'adjective'
 require_relative 'adverb'
+require_relative 'adverb_not'
+require_relative 'adverb_there'
+require_relative 'auxiliary_be'
+require_relative 'auxiliary_do'
 require_relative 'cardinal'
 require_relative 'comparative_particle'
 require_relative 'common_noun'
 require_relative 'pronoun'
 require_relative 'proper_noun'
 require_relative 'irregular_verb'
+require_relative 'irregular_verb_be'
 require_relative 'definite_article'
 require_relative 'demonstrative_determiner'
 require_relative 'indefinite_pronoun'
 require_relative 'indefinite_quantifier'
-require_relative 'preposition'
+require_relative 'preposition'
+require_relative 'preposition_than'

data/lib/zenlish/wclasses/auxiliary.rb

@@ -0,0 +1,11 @@
+require_relative 'verb'
+
+module Zenlish
+  module WClasses
+    # The verbs: be, have, do
+    # As they are so important to the English language, they deserve
+    # their own class
+    class Auxiliary < Verb
+    end # class
+  end # module
+end # module

data/lib/zenlish/wclasses/auxiliary_be.rb

@@ -0,0 +1,9 @@
+require_relative 'auxiliary'
+
+module Zenlish
+  module WClasses
+    # TODO: document
+    class AuxiliaryBe < Auxiliary
+    end # class
+  end # module
+end # module

data/lib/zenlish/wclasses/auxiliary_do.rb

@@ -0,0 +1,9 @@
+require_relative 'auxiliary'
+
+module Zenlish
+  module WClasses
+    # TODO: document
+    class AuxiliaryDo < Auxiliary
+    end # class
+  end # module
+end # module

data/lib/zenlish/wclasses/irregular_verb_be.rb

@@ -0,0 +1,9 @@
+require_relative 'irregular_verb'
+
+module Zenlish
+  module WClasses
+    # TODO: document
+    class IrregularVerbBe < IrregularVerb
+    end # class
+  end # module
+end # module

data/lib/zenlish/wclasses/preposition_than.rb

@@ -0,0 +1,9 @@
+require_relative 'preposition_than'
+
+module Zenlish
+  module WClasses
+    # the 'than' preposition
+    class PrepositionThan < Preposition
+    end # class
+  end # module
+end # module

data/spec/zenlish/lex/lexicon_spec.rb

@@ -6,22 +6,6 @@ require_relative '../../../lib/zenlish/lex/lexical_entry'
 require_relative '../../../lib/zenlish/lex/lexeme'
 require_relative '../../../lib/zenlish/lex/lexicon' # Load the class under test
 
-=begin
-
-minimal_lexicon = Zenlish::Lex::Lexicon.new
-ent = Zenlish::Lex::LexicalEntry.new('Lisa')
-lexeme = Zenlish::Lex::Lexeme.new(o_proper_noun, ent)
-minimal_lexicon.add_entry(ent)
-
-ent = Zenlish::Lex::LexicalEntry.new('see')
-lexeme = Zenlish::Lex::Lexeme.new(o_irregular_verb, ent)
-minimal_lexicon.add_entry(ent)
-
-ent = Zenlish::Lex::LexicalEntry.new('Tony')
-lexeme = Zenlish::Lex::Lexeme.new(o_proper_noun, ent)
-minimal_lexicon.add_entry(ent)
-=end
-
 
 module Zenlish
   module Lex
@@ -33,16 +17,12 @@ module Zenlish
       end
 
       let(:adjective) { Zenlish::WClasses::Adjective.new }
-      let(:proper_noun) { Zenlish::WClasses::ProperNoun.new }
       let(:pronoun) { Zenlish::WClasses::Pronoun.new }
       let(:irregular_verb) { Zenlish::WClasses::IrregularVerb.new }
 
-      let(:sample_lexeme) { double('other-as-adjective') }
-      let(:sample_entry) { LexicalEntry.new('other', sample_lexeme) }
-      let(:other_lexeme) { double('other-as-pronoun') }
-      let(:similar_entry) { LexicalEntry.new('other', other_lexeme) }
-      let(:verb_lexeme) { double('hope-as-verb') }
-      let(:distinct_entry) {LexicalEntry.new('hope', verb_lexeme) }
+      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 }
 
       context 'Initialization:' do
@@ -62,7 +42,7 @@ module Zenlish
 
       context 'Provided services:' do
         it 'should accept the addition of terminals' do
-          terminal1 = proper_noun
+          terminal1 = pronoun
           terminal2 = irregular_verb
           terminal3 = adjective
 
@@ -72,7 +52,7 @@ module Zenlish
           expect(subject.terminals).to eq([terminal1, terminal2])
           subject.add_terminal(terminal3)
           expect(subject.terminals).to eq([terminal1, terminal2, terminal3])
-          expect(subject.name2terminal['ProperNoun']).to eq(terminal1)
+          expect(subject.name2terminal['Pronoun']).to eq(terminal1)
           expect(subject.name2terminal['IrregularVerb']).to eq(terminal2)
           expect(subject.name2terminal['Adjective']).to eq(terminal3)
         end
@@ -92,6 +72,24 @@ module Zenlish
           expect(subject.entries).to eq([sample_entry, distinct_entry, similar_entry])
           expect(subject.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)
+        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)

data/spec/zenlish/parser/zparser_spec.rb

@@ -16,15 +16,20 @@ module Zenlish
         end
       end # context
 
-      def get_lexeme(aLemma)
-        $ZenlishLexicon.get_lexeme(aLemma)
+      def get_lexeme(aLemma, aWordClass = nil)
+        $ZenlishLexicon.get_lexeme(aLemma, aWordClass)
       end
 
+      def all ; Lex::Literal.new('all', get_lexeme('all'), 0) ; end      
+      def are ; Lex::Literal.new('are', get_lexeme('be'), 0) ; end
       def as ; Lex::Literal.new('as', get_lexeme('as'), 0) ; end
+      def of ; Lex::Literal.new('of', get_lexeme('of'), 0) ; end
+      def does ; Lex::Literal.new('does', get_lexeme('do'), 0) ; end
       def inside ; Lex::Literal.new('inside', get_lexeme('inside'), 0) ; end
-      def is ; Lex::Literal.new('is', get_lexeme('be'), 0) ; end      
+      def is ; Lex::Literal.new('is', get_lexeme('be', WClasses::IrregularVerbBe), 0) ; end
       def lisa ; Lex::Literal.new('Lisa', get_lexeme('Lisa'), 0) ; end
       def many ; Lex::Literal.new('many', get_lexeme('many'), 0) ; end
+      def more ; Lex::Literal.new('more', get_lexeme('more'), 0) ; end      
       def not_ ; Lex::Literal.new('not', get_lexeme('not'), 0) ; end
       def one ;  Lex::Literal.new('one', get_lexeme('one'), 0) ; end
       def two ;  Lex::Literal.new('two', get_lexeme('two'), 0) ; end
@@ -32,9 +37,14 @@ module Zenlish
       def people ;  Lex::Literal.new('people', get_lexeme('people'), 0) ; end
       def person ;  Lex::Literal.new('person', get_lexeme('person'), 0) ; end
       def same ;  Lex::Literal.new('same', get_lexeme('same'), 0) ; end
+      def some_ ;  Lex::Literal.new('some', get_lexeme('some'), 0) ; end
+      def see ; Lex::Literal.new('see', get_lexeme('see'), 0) ; end
       def sees ; Lex::Literal.new('sees', get_lexeme('see'), 0) ; end
       def something ;  Lex::Literal.new('something', get_lexeme('something'), 0) ; end
       def the ;  Lex::Literal.new('the', get_lexeme('the'), 0) ; end
+      def than ;  Lex::Literal.new('than', get_lexeme('than'), 0) ; end      
+      def there ;  Lex::Literal.new('there', get_lexeme('there'), 0) ; end      
+      def these ;  Lex::Literal.new('these', get_lexeme('this'), 0) ; end
       def thing ;  Lex::Literal.new('thing', get_lexeme('thing'), 0) ; end
       def things ;  Lex::Literal.new('things', get_lexeme('thing'), 0) ; end
       def this ;  Lex::Literal.new('this', get_lexeme('this'), 0) ; end
@@ -107,13 +117,13 @@ module Zenlish
           # Sentence 1-08b: "Lisa sees two people."
           literals = [lisa, sees, two, people, dot]
           expect { subject.parse(literals) }.not_to raise_error
-          
+
           # Sentence 1-05b: "Tony sees the same person as Lisa sees."
           literals = [tony, sees, the, same, person, as, lisa, sees, dot]
           # same is an adjective of equality comparison
           # as is part of same ... as combination
           # it introduces a comparative clause
-          expect { subject.parse(literals) }.not_to raise_error          
+          expect { subject.parse(literals) }.not_to raise_error
         end
 
         it 'should parse sample sentences from lesson 1-C' do
@@ -124,14 +134,52 @@ module Zenlish
           # Sentence 1-09b: "Lisa sees many people."
           literals = [lisa, sees, many, people, dot]
           expect { subject.parse(literals) }.not_to raise_error
-          
+
           # Sentence 1-10: "Tony is inside this thing."
           literals = [tony, is, inside, this, thing, dot]
-          expect { subject.parse(literals) }.not_to raise_error  
+          expect { subject.parse(literals) }.not_to raise_error
 
           # Sentence 1-11: "Lisa is not inside this thing."
           literals = [lisa, is, not_, inside, this, thing, dot]
-          expect { subject.parse(literals) }.not_to raise_error                 
+          expect { subject.parse(literals) }.not_to raise_error
+
+          # Sentence: "Lisa does not see people inside the other thing."
+          literals = [lisa, does, not_, see, people, inside, the, other, thing, dot]
+          expect { subject.parse(literals) }.not_to raise_error
+        end
+
+        it 'should parse sample sentences from lesson 1-D' do
+          # Sentence 1-12a: "Some of these people are inside this thing."
+          literals = [some_, of, these, people, are, inside, this, thing, dot]
+          expect { subject.parse(literals) }.not_to raise_error
+          
+          # Sentence 1-12b: "Some of these people are not inside this thing."
+          literals = [some_, of, these, people, are, not_, inside, this, thing, dot]
+          expect { subject.parse(literals) }.not_to raise_error
+          
+          # Sentence 1-13: "All of these people are inside this thing."
+          literals = [all, of, these, people, are, not_, inside, this, thing, dot]
+          expect { subject.parse(literals) }.not_to raise_error
+          
+          # Sentence 1-14a: "There are two people inside one of these things."
+          literals = [there, are, two, people, inside, one, of, these, things, dot]
+          expect { subject.parse(literals) }.not_to raise_error  
+
+          # Sentence 1-14b: "There are not people inside the other thing."
+          literals = [there, are, not_, people, inside, the, other, thing, dot]
+          expect { subject.parse(literals) }.not_to raise_error
+
+          # Sentence 1-15a: "There are many people inside this thing."
+          literals = [there, are, many, people, inside, this, thing, dot]
+          expect { subject.parse(literals) }.not_to raise_error
+
+          # Sentence 1-15b: "There are more people inside this thing."
+          literals = [there, are, more, people, inside, this, thing, dot]
+          expect { subject.parse(literals) }.not_to raise_error  
+
+          # Sentence 1-15c: "There are more people inside the other thing than there are inside this thing."
+          literals = [there, are, more, people, inside, the, other, thing, than, there, are, inside, this, thing, dot]
+          expect { subject.parse(literals) }.not_to raise_error                    
         end
       end # context
     end # describe

data/spec/zenlish/support/minimal_lexicon.rb

@@ -4,12 +4,19 @@ require_relative '../../../lib/zenlish/lex/lexeme'
 require_relative '../../../lib/zenlish/lex/lexicon'
 
 
-common_noun = $ZenlishLexicon.name2terminal['CommonNoun']
+
 adjective = $ZenlishLexicon.name2terminal['Adjective']
 adverb = $ZenlishLexicon.name2terminal['Adverb']
+adverb_not = $ZenlishLexicon.name2terminal['AdverbNot']
+adverb_there = $ZenlishLexicon.name2terminal['AdverbThere']
+# auxiliary_be = $ZenlishLexicon.name2terminal['AuxiliaryBe']
+auxiliary_do = $ZenlishLexicon.name2terminal['AuxiliaryDo']
+common_noun = $ZenlishLexicon.name2terminal['CommonNoun']
 proper_noun = $ZenlishLexicon.name2terminal['ProperNoun']
 preposition = $ZenlishLexicon.name2terminal['Preposition']
+preposition_than = $ZenlishLexicon.name2terminal['PrepositionThan']
 irregular_verb = $ZenlishLexicon.name2terminal['IrregularVerb']
+irregular_verb_be = $ZenlishLexicon.name2terminal['IrregularVerbBe']
 indefinite_pronoun = $ZenlishLexicon.name2terminal['IndefinitePronoun']
 demonstrative_determiner = $ZenlishLexicon.name2terminal['DemonstrativeDeterminer']
 definite_article = $ZenlishLexicon.name2terminal['DefiniteArticle']
@@ -20,26 +27,34 @@ dot = $ZenlishLexicon.name2terminal['Period']
 
 def add_entry(aLemma, aWordClass)
   entry = Zenlish::Lex::LexicalEntry.new(aLemma)
-  raise StandardError, 'Unregistered word class' unless aWordClass
+  raise StandardError, "Undefined word class for '#{aLemma}'" unless aWordClass
   lexeme = Zenlish::Lex::Lexeme.new(aWordClass, entry).freeze
   $ZenlishLexicon.add_entry(entry.freeze)
 end
 
 # Our minimalistic lexicon
+add_entry('all', indefinite_quantifier)
 add_entry('as', comparative_particle)
-add_entry('be', irregular_verb)
+# add_entry('be', auxiliary_be)
+add_entry('be', irregular_verb_be)
+add_entry('do', auxiliary_do)
 add_entry('inside', preposition)
 add_entry('Lisa', proper_noun)
 add_entry('many', indefinite_quantifier)
-add_entry('not', adverb)
+add_entry('more', adjective)
+add_entry('not', adverb_not)
+add_entry('of', preposition)
 add_entry('one', cardinal)
 add_entry('other', adjective)
 add_entry('people', common_noun)
 add_entry('person', common_noun)
 add_entry('same', adjective)
 add_entry('see', irregular_verb)
+add_entry('some', indefinite_quantifier)
 add_entry('something', indefinite_pronoun)
+add_entry('than', preposition_than)
 add_entry('the', definite_article)
+add_entry('there', adverb_there)
 add_entry('thing', common_noun)
 add_entry('this', demonstrative_determiner)
 add_entry('Tony', proper_noun)

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: zenlish
 version: !ruby/object:Gem::Version
-  version: 0.1.02
+  version: 0.1.03
 platform: ruby
 authors:
 - Dimitri Geshef
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2019-10-11 00:00:00.000000000 Z
+date: 2019-10-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rley
@@ -95,8 +95,13 @@ files:
 - lib/zenlish/version.rb
 - lib/zenlish/wclasses/adjective.rb
 - lib/zenlish/wclasses/adverb.rb
+- lib/zenlish/wclasses/adverb_not.rb
+- lib/zenlish/wclasses/adverb_there.rb
 - lib/zenlish/wclasses/all_word_classes.rb
 - lib/zenlish/wclasses/article.rb
+- lib/zenlish/wclasses/auxiliary.rb
+- lib/zenlish/wclasses/auxiliary_be.rb
+- lib/zenlish/wclasses/auxiliary_do.rb
 - lib/zenlish/wclasses/cardinal.rb
 - lib/zenlish/wclasses/common_noun.rb
 - lib/zenlish/wclasses/comparative_particle.rb
@@ -106,10 +111,12 @@ files:
 - lib/zenlish/wclasses/indefinite_pronoun.rb
 - lib/zenlish/wclasses/indefinite_quantifier.rb
 - lib/zenlish/wclasses/irregular_verb.rb
+- lib/zenlish/wclasses/irregular_verb_be.rb
 - lib/zenlish/wclasses/lexical_verb.rb
 - lib/zenlish/wclasses/noun.rb
 - lib/zenlish/wclasses/numeral.rb
 - lib/zenlish/wclasses/preposition.rb
+- lib/zenlish/wclasses/preposition_than.rb
 - lib/zenlish/wclasses/pronoun.rb
 - lib/zenlish/wclasses/proper_noun.rb
 - lib/zenlish/wclasses/test_hierarchy.rb