zenlish 0.1.0

data/lib/zenlish/wclasses/demonstrative_determiner.rb

@@ -0,0 +1,9 @@
+require_relative 'determiner'
+
+module Zenlish
+  module WClasses
+    # TODO: document
+    class DemonstrativeDeterminer < Determiner
+    end # class
+  end # module
+end # module

data/lib/zenlish/wclasses/determiner.rb

@@ -0,0 +1,9 @@
+require_relative 'word_class'
+
+module Zenlish
+  module WClasses
+    # TODO: document
+    class Determiner < WordClass
+    end # class
+  end # module
+end # module

data/lib/zenlish/wclasses/indefinite_pronoun.rb

@@ -0,0 +1,9 @@
+require_relative 'pronoun'
+
+module Zenlish
+  module WClasses
+    # TODO: document
+    class IndefinitePronoun < Pronoun
+    end # class
+  end # module
+end # module

data/lib/zenlish/wclasses/irregular_verb.rb

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

data/lib/zenlish/wclasses/lexical_verb.rb

@@ -0,0 +1,9 @@
+require_relative 'verb'
+
+module Zenlish
+  module WClasses
+    # TODO: document
+    class LexicalVerb < Verb
+    end # class
+  end # module
+end # module

data/lib/zenlish/wclasses/noun.rb

@@ -0,0 +1,11 @@
+require_relative 'word_class'
+
+module Zenlish
+  module WClasses
+    # A noun denotes classes and categories of things in the unverse of discourse.
+    # Nouns denote people, animals, inanimate things, places, events, qualities
+    # and states.
+    class Noun < WordClass
+    end # class
+  end # module
+end # module

data/lib/zenlish/wclasses/pronoun.rb

@@ -0,0 +1,9 @@
+require_relative 'word_class'
+
+module Zenlish
+  module WClasses
+    # TODO: document
+    class Pronoun < WordClass
+    end # class
+  end # module
+end # module

data/lib/zenlish/wclasses/proper_noun.rb

@@ -0,0 +1,10 @@
+require_relative 'noun'
+
+module Zenlish
+  module WClasses
+    # Proper nouns refer to persons, places, geographical features, planets, or various
+    # period of time.
+    class ProperNoun < Noun
+    end # class
+  end # module    
+end # module

data/lib/zenlish/wclasses/test_hierarchy.rb

@@ -0,0 +1,3 @@
+require_relative 'all_word_classes'
+
+puts 'Hello, world'

data/lib/zenlish/wclasses/verb.rb

@@ -0,0 +1,9 @@
+require_relative 'word_class'
+
+module Zenlish
+  module WClasses
+    # TODO: document
+    class Verb < WordClass
+    end # class
+  end # module
+end # module

data/lib/zenlish/wclasses/word_class.rb

@@ -0,0 +1,20 @@
+require 'rley'
+
+module Zenlish
+  module WClasses
+    # Also known as: part of speech, syntactic category or word category.
+    # A word class represents a group of word which have similar functions.
+    # Word classes are divided into:
+    # - Lexical words (?? same as content words??) such as nouns, verbs, adjectives, adverbs
+    #   Content words carry the meaning of a sentence
+    # - Function words (?? same as structure words??) such as pronouns, determiners, modal verbs, 
+    #  auxiliary verbs,
+    #   Structure words structure a sentence
+    #   conjunctions and prepositions
+    class WordClass < Rley::Syntax::Terminal
+      def initialize
+        super(self.class.name.split('::').last)
+      end
+    end # class
+  end # module    
+end # module

data/spec/spec_helper.rb

@@ -0,0 +1,12 @@
+require 'bundler/setup'
+require 'rspec' # Use the RSpec framework
+# require_relative '../lib/zenlish'
+
+RSpec.configure do |config|
+  # Enable flags like --only-failures and --next-failure
+  config.example_status_persistence_file_path = ".rspec_status"
+
+  config.expect_with :rspec do |c|
+    c.syntax = :expect
+  end
+end

data/spec/zenlish/lex/empty_lexicon_factory_spec.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require_relative '../../spec_helper' # Use the RSpec framework
+
+# Load module under test
+require_relative '../../../lib/zenlish/lex/empty_lexicon_factory'
+
+module Zenlish
+  module Lex
+    describe EmptyLexiconFactory do
+      subject do
+        obj = Object.new
+        obj.extend(EmptyLexiconFactory)
+      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
+        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)
+        end
+
+        it 'should initialize lexicon with terminal symbols of the language' do
+          lexicon = subject.create_empty_lexicon
+          found = lexicon.terminals.find { |symb| symb.kind_of?(WClasses::CommonNoun) }
+          expect(found).to be_truthy
+        end
+      end # context
+    end # describe
+  end # module
+end # module

data/spec/zenlish/lex/lexeme_spec.rb

@@ -0,0 +1,39 @@
+# 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
+
+module Zenlish
+  module Lex
+    describe Lexeme do
+      let(:sample_wclass) { WClasses::CommonNoun.new }
+      let(:sample_lemma) { 'thing' }
+      let(:sample_entry) { LexicalEntry.new(sample_lemma) }
+
+      subject { Lexeme.new(sample_wclass, sample_entry)  }
+
+      context 'Initialization:' do
+        it 'should be initialized with a word class and a lexical entry' do
+          expect { Lexeme.new(sample_wclass, sample_entry) }.not_to raise_error
+        end
+
+        it 'should know its word class' do
+          expect(subject.wclass).to eq(sample_wclass)
+        end
+
+        it 'should know its lexical entry' do
+          expect(subject.entry).to eq(sample_entry)
+        end
+      end # context
+
+      context 'Provided services:' do
+        it 'should know its lemma' do
+          expect(subject.lemma).to eq(sample_lemma)
+        end
+      end # context
+    end # describe
+  end # module
+end # module
+

data/spec/zenlish/lex/lexical_entry_spec.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require_relative '../../spec_helper' # Use the RSpec framework'
+require_relative '../../../lib/zenlish/lex/lexical_entry' # Load the class under test
+
+module Zenlish
+  module Lex
+    describe LexicalEntry do
+      let(:sample_lemma) { 'other' }
+      let(:sample_lexeme1) { double('other-as-adjective') }
+      let(:sample_lexeme2) { double('other-as-pronoun') }
+      subject { LexicalEntry.new(sample_lemma) }
+
+      context 'Initialization:' do
+        it 'can be initialized with a lemma only' do
+          expect { LexicalEntry.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
+        end
+
+        it 'should know its lemma' do
+          expect(subject.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)
+          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])
+
+          subject.add_lexeme(sample_lexeme2)
+          expect(subject.lexemes).to eq([sample_lexeme1, sample_lexeme2])
+        end
+      end # context
+    end # describe
+  end # module
+end # module

data/spec/zenlish/lex/lexicon_spec.rb

@@ -0,0 +1,104 @@
+# 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'
+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
+    describe Lexicon do
+      def create_entry(aLemma, aWordClass)
+        entry = Zenlish::Lex::LexicalEntry.new(aLemma)
+        lexeme = Zenlish::Lex::Lexeme.new(aWordClass, entry)
+        entry
+      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) }
+      subject { Lexicon.new }
+
+      context 'Initialization:' do
+        it 'should be initialized without parameter' do
+          expect { Lexicon.new }.not_to raise_error
+        end
+
+        it 'should have no registered terminals at initialization' do
+          expect(subject.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
+        end
+      end # context
+
+      context 'Provided services:' do
+        it 'should accept the addition of terminals' do
+          terminal1 = proper_noun
+          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['ProperNoun']).to eq(terminal1)
+          expect(subject.name2terminal['IrregularVerb']).to eq(terminal2)
+          expect(subject.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)
+
+          # 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)
+
+          # 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])
+        end
+
+        it 'should complain when retrieving an non-existing entry' do
+          subject.add_entry(sample_entry)
+          err_msg = 'key not found: "hapax"'
+          expect { subject.get_lexeme('hapax') }.to raise_error(KeyError, err_msg)
+        end
+      end # context
+    end # describe
+  end # module
+end # module

data/spec/zenlish/lex/literal_spec.rb

@@ -0,0 +1,41 @@
+# 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'
+require_relative '../../../lib/zenlish/lex/literal' # Load the class under test
+
+module Zenlish
+  module Lex
+    describe Lexeme 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)  }
+
+      subject { Literal.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
+        end
+
+        # it 'should know its word class' do
+          # expect(subject.wclass).to eq(sample_wclass)
+        # end
+
+        # it 'should know its lexical entry' do
+          # expect(subject.entry).to eq(sample_entry)
+        # end
+      end # context
+
+      context 'Provided services:' do
+        # it 'should know its lemma' do
+          # expect(subject.lemma).to eq(sample_lemma)
+        # end
+      end # context
+    end # describe
+  end # module
+end # module

data/spec/zenlish/parser/zenlish_grammar_spec.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require_relative '../../spec_helper' # Use the RSpec framework
+require_relative '../../../lib/zenlish/parser/zenlish_grammar' # Load the class under test
+
+module Zenlish
+  module Parser
+    describe ZenlishGrammar do
+      subject { ZenlishGrammar }
+
+      context 'Initialization:' do
+        it 'should know its terminal symbols' do
+          expect { subject.name2symbol['CommonNoun'] }.not_to raise_error
+        end
+      end # context
+
+      context 'Provided services:' do
+      end # context
+    end # describe
+  end # module
+end # module

data/spec/zenlish/parser/zparser_spec.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+require_relative '../../spec_helper' # Use the RSpec framework
+require_relative '../support/minimal_lexicon'
+require_relative '../../../lib/zenlish/lex/literal'
+require_relative '../../../lib/zenlish/parser/zparser' # Load the class under test
+
+module Zenlish
+  module Parser
+    describe ZParser do
+      subject { ZParser.new }
+
+      context 'Initialization:' do
+        it 'should be initialized without argument' do
+          expect { ZParser.new }.not_to raise_error
+        end
+      end # context
+
+      context 'Provided services:' do
+        def get_lexeme(aLemma)
+          $ZenlishLexicon.get_lexeme(aLemma)
+        end
+
+        let(:tony) do
+          Lex::Literal.new('Tony', $ZenlishLexicon.get_lexeme('Tony'), 0)
+        end
+        let(:lisa) do
+          Lex::Literal.new('Lisa', $ZenlishLexicon.get_lexeme('Lisa'), 0)
+        end
+        let(:the) do
+          Lex::Literal.new('the', $ZenlishLexicon.get_lexeme('the'), 0)
+        end
+        let(:other) do
+          Lex::Literal.new('other', $ZenlishLexicon.get_lexeme('other'), 0)
+        end
+        let(:sees) do
+          Lex::Literal.new('sees', $ZenlishLexicon.get_lexeme('see'), 0)
+        end
+        let(:dot) do
+          Lex::Literal.new('.', $ZenlishLexicon.get_lexeme('.'), 0)
+        end
+        let(:something) do
+          Lex::Literal.new('something', $ZenlishLexicon.get_lexeme('something'), 0)
+        end
+        let(:thing) do
+          Lex::Literal.new('thing', $ZenlishLexicon.get_lexeme('thing'), 0)
+        end
+        let(:this) do
+          Lex::Literal.new('this', $ZenlishLexicon.get_lexeme('this'), 0)
+        end
+
+        it 'should parse sample sentence 1-01' do
+          # Sentence is: "Tony sees Lisa."
+          # in absence of a tokenizer, we create a sequence of literals by hand...
+          literals = [tony, sees, lisa, dot]
+          expect { subject.parse(literals) }.not_to raise_error
+        end
+
+        it 'should parse sample sentence 1-02a' do
+          # Sentence is: "Tony sees something."
+          sentence_literals = [tony, sees, something, dot]
+          expect { subject.parse(sentence_literals) }.not_to raise_error
+        end
+
+        it 'should parse sample sentence 1-02b' do
+          # Sentence is: "Lisa sees something"
+          sentence_literals = [lisa, sees, something, dot]
+          expect { subject.parse(sentence_literals) }.not_to raise_error
+        end
+
+        it 'should parse sample sentence 1-03' do
+          # Sentence is: "Tony sees this thing."
+          sentence_literals = [tony, sees, this, thing, dot]
+          expect { subject.parse(sentence_literals) }.not_to raise_error
+        end
+
+        it 'should parse sample sentence 1-04' do
+          # Sentence is: "Lisa sees the other thing."
+          sentence_literals = [lisa, sees, the, other, thing, dot]
+          expect { subject.parse(sentence_literals) }.not_to raise_error
+        end
+      end # context
+    end # describe
+  end # module
+end # module
+