zenlish 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 026405b993a2736b1e5c5341308aa1ffab8e77ba07dfc38d2e2344e183c466a7
+  data.tar.gz: 795d56d6e9b9c5204678912833c5817d04fef64e56e2128ac6ad6962b349b676
+SHA512:
+  metadata.gz: 1bc6680bbd7f6da39d795903c4ec9b67061bfbbc409289669f37a3fa97d50f176bc634f0b6c10a6f2de54b81e5595d38fbddad0dffb9a97b555c2bd83eb68d86
+  data.tar.gz: a3772e8100491357a0776a4a83cf039ca17d7ba01792284ad4e92d96c4666b2394815199e9681853f4b796cea6f533cab81da65b6b6756b79a5559183f22d2db

data/.rspec

@@ -0,0 +1,3 @@
+--format documentation
+--color
+--require spec_helper

data/.yardopts

@@ -0,0 +1,6 @@
+--exclude examples --exclude features --exclude spec
+--no-private
+--markup markdown
+-
+Changelog.md
+License.txt

data/Gemfile

@@ -0,0 +1,6 @@
+source "https://rubygems.org"
+
+git_source(:github) {|repo_name| "https://github.com/#{repo_name}" }
+
+# Specify your gem's dependencies in skimplish.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2018 TODO: Write your name
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,95 @@
+# Zenlish
+
+### What is __Zenlish__ ?  
+
+Zenlish = Zen + English  
+
+
+The goal of this project is to implement a toolkit subset of the English language, called ... Zenlish.  
+A [Controlled Natural Language]([https://en.wikipedia.org/wiki/Controlled_natural_language) defines a subset of a natural language -English, for instance-  with a restricted syntax and restricted semantics.
+
+### Design of Zenlish language
+#### Minimalism
+The name of the language is a combination of 'Zen' and 'English'.  
+It reflects a desire to make Zenlish a simple language:  
+- The focus is put on a simplified syntax,
+- A limited lexicon. Priority on most commonly used words.
+
+#### Expressiveness
+Zenlish should be rich enough to express ideas, facts in a fluid way (vs. contrived, artificial way). Litmus test: a Zenlish text should be easy to read to an English speaking person.
+
+### Zenlish as a library (gem)
+Over time, the zenlish gem will contain:
+- A tokenizer (tagging, lemmatizer)
+- A lexicon [STARTED]
+- A context-free grammar [STARTED]
+- A parser [STARTED]
+- Feature unification (for number, gender agreement)
+- A simplified ontology
+
+### What is the purpose of __Zenlish__ ?
+With __Zenlish__ it should be possible for a Ruby application to interact with
+users with a language that is close enough to English.
+
+### Roadmap
+The project is still in inception.  
+Here a tentative roadmap:
+
+#### A) Support vocabulary and sentences from [Learn These Words First](http://learnthesewordsfirst.com/)
+This website advocates the idea of a multi-layered dictionary.
+At the core, there are about 300 essential words.  
+The choice of these words is inspired by the semantic primitives of [NSM
+(Natural Semantic Metalanguage)](https://en.wikipedia.org/wiki/Natural_semantic_metalanguage).  
+The essential words are introduced in twelve lessons. Each lesson put the Words
+in examplar sentences and pictures.
+
+The project sub-goals are:
+- To inject the 300 core words into Zenlish lexicon,
+- Zenlish should be able to parse all the example sentences
+- Also Zenlish should determine the semantics (i.e. meaning) of the sentences
+
+#### B) Capability to read a complete book
+A good candidate book is "The Edge of the Sky" by Roberto Trotta (ISBN 978-0-465-04471-9 : hardcover, ISBN 978-0-465-04490-0 : ebook).  
+Professor Trotta challenged himself by writing a book on Cosmology with the 1000 most used words. More details [here](http://robertotrotta.com/the-edge-of-the-sky/).
+
+In order to achieve this goal, Zenlish should:
+- Incorporate the 1000 words in its lexicon
+- Have a grammar that allows the parsing of the sentences in the book.
+
+#### C) Capability to interpret the meaning of a complete book
+Probably, far-fetched. But it will be nice to launch query to Zenlish to check if
+it has some understanding of the text it reads (i.e. has a semantic representation).
+
+
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'zenlish'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install zenlish
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/famished-tiger/Zenlish. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [Contributor Covenant](http://contributor-covenant.org) code of conduct.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).
+
+## Code of Conduct
+
+Everyone interacting in the Zenlish project’s codebases, issue trackers, chat rooms and mailing lists is expected to follow the [code of conduct](https://github.com/famished-tiger/Zenlish/blob/master/CODE_OF_CONDUCT.md).

data/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/lib/zenlish.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+# This file acts as a jumping-off point for loading dependencies expected
+# for a Zenlish client.
+
+require_relative './zenlish/version'
+require_relative './zenlish/wclasses/all_word_classes'
+
+# End of file

data/lib/zenlish/lex/empty_lexicon.rb

@@ -0,0 +1,7 @@
+unless defined?($ZenlishLexicon)
+  require_relative 'empty_lexicon_factory'
+
+  sandbox = Object.new
+  sandbox.extend(Zenlish::Lex::EmptyLexiconFactory)
+  $ZenlishLexicon = sandbox.create_empty_lexicon
+end

data/lib/zenlish/lex/empty_lexicon_factory.rb

@@ -0,0 +1,32 @@
+require_relative '../wclasses/all_word_classes'
+require_relative 'lexicon'
+
+module Zenlish
+  module Lex
+    module EmptyLexiconFactory
+      def create_empty_lexicon()
+        lexicon = Lexicon.new
+
+        add_word_classes(lexicon)
+        add_punctuation(lexicon)
+        lexicon
+      end
+
+      private
+
+      def add_word_classes(aLexicon)
+        aLexicon.add_terminal(WClasses::CommonNoun.new)
+        aLexicon.add_terminal(WClasses::ProperNoun.new)
+        aLexicon.add_terminal(WClasses::IrregularVerb.new)
+        aLexicon.add_terminal(WClasses::Adjective.new)
+        aLexicon.add_terminal(WClasses::DefiniteArticle.new)
+        aLexicon.add_terminal(WClasses::DemonstrativeDeterminer.new)
+        aLexicon.add_terminal(WClasses::IndefinitePronoun.new)
+      end
+
+      def add_punctuation(aLexicon)
+        aLexicon.add_terminal(Rley::Syntax::Terminal.new('Period'))
+      end
+    end # module
+  end # module
+end # module

data/lib/zenlish/lex/lexeme.rb

@@ -0,0 +1,19 @@
+module Zenlish
+  module Lex
+    # TODO: document
+    class Lexeme
+      attr_reader :wclass
+      attr_reader :entry
+
+      def initialize(aWordClass, anEntry)
+        @wclass = aWordClass
+        @entry = anEntry
+        @entry.add_lexeme(self)
+      end
+
+      def lemma
+        entry.lemma
+      end
+    end # class
+  end # module
+end # module

data/lib/zenlish/lex/lexical_entry.rb

@@ -0,0 +1,19 @@
+module Zenlish
+  module Lex
+    # TODO: document
+    class LexicalEntry
+      attr_reader :lemma
+      attr_reader :lexemes
+      
+      def initialize(theLemma, aLexeme = nil)
+        @lemma = theLemma.dup
+        @lexemes = []
+        add_lexeme(aLexeme)
+      end
+      
+      def add_lexeme(aLexeme)
+        lexemes << aLexeme if aLexeme
+      end
+    end # class
+  end # module    
+end # module

data/lib/zenlish/lex/lexicon.rb

@@ -0,0 +1,55 @@
+module Zenlish
+  module Lex
+    # A lexicon is a collection of lexical entries.
+    # Every entry is associated with one one more lexemes.
+    class Lexicon
+      attr_reader :entries
+      attr_reader :lemma2entry
+
+      # The list of terminal symbols. Examples of terminal symbols:
+      # - word classes,
+      # - punctuation signs,...
+      attr_reader :terminals
+      attr_reader :name2terminal
+
+      def initialize
+        @entries = []
+        @lemma2entry = {}
+        @terminals = []
+        @name2terminal = {}
+      end
+
+      def get_lexeme(aLemma)
+        lemma2entry.fetch(aLemma).lexemes.first
+      end
+
+      def add_terminal(aTerminal)
+        terminals << aTerminal
+        name2terminal[aTerminal.name] = aTerminal
+      end
+
+      def add_entry(anEntry)
+        entries << anEntry
+        lemma = anEntry.lemma
+
+        update_mapping(lemma2entry, lemma, anEntry)
+      end
+
+      private
+
+      def update_mapping(aHash, aKey, aValue)
+        if aHash.include?(aKey)
+          hit = aHash[aKey]
+          if hit.is_a?(Array)
+            hit << aValue
+          else
+            aHash[aKey] = [hit, aValue]
+          end
+        else
+          aHash[aKey] = aValue
+        end
+      end
+
+    end # class
+  end # module
+end # module

data/lib/zenlish/lex/literal.rb

@@ -0,0 +1,16 @@
+require 'rley'
+
+module Zenlish
+  module Lex
+    # TODO: document
+    class Literal < Rley::Lexical::Token
+      attr_reader :zlexeme
+
+      # initialize(theLexeme, aTerminal, aPosition) ⇒ Token
+      def initialize(literalText, aLexeme, aPosition)
+        super(literalText, aLexeme.wclass.name, aPosition)
+        @zlexeme = aLexeme
+      end
+    end # class
+  end # module
+end # module

data/lib/zenlish/parser/zenlish_grammar.rb

@@ -0,0 +1,29 @@
+# Grammar for a simple subset of English language
+# It is called Zenlish
+
+require 'rley' # Load the Rley parsing library
+require_relative '../lex/empty_lexicon'
+
+########################################
+# Define a grammar for a highly English-like language
+builder = Rley::Syntax::GrammarBuilder.new do
+  add_terminals(*$ZenlishLexicon.terminals)
+  # add_terminals('Period')
+
+  rule 'language' => 'sentence'
+  rule 'sentence' => 'simple_sentence'
+  rule 'simple_sentence' => 'declarative_simple_sentence'
+  rule 'declarative_simple_sentence' => 'noun_phrase verb_phrase Period'
+  rule 'noun_phrase' => 'noun'
+  rule 'noun' => 'ProperNoun'
+  rule 'noun' => 'CommonNoun'
+  rule 'verb_phrase' => 'lexical_verb complement'
+  rule 'lexical_verb' => 'IrregularVerb'
+  rule 'complement' => 'ProperNoun'
+  rule 'complement' => 'IndefinitePronoun'
+  rule 'complement' => 'DemonstrativeDeterminer noun'
+  rule 'complement' => 'DefiniteArticle Adjective CommonNoun'
+end
+
+# And now build the grammar...
+ZenlishGrammar = builder.grammar

data/lib/zenlish/parser/zparser.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require_relative 'zenlish_grammar'
+
+module Zenlish
+  class ZParser
+    attr_reader(:engine)
+
+    def initialize
+      # Create a Rley facade object
+      @engine = Rley::Engine.new
+
+      # Step 1. Load Zenlish grammar
+      @engine.use_grammar(ZenlishGrammar)
+    end
+
+    def parse(tokenSeq)
+      result = engine.parse(tokenSeq)
+
+      unless result.success?
+        # Stop if the parse failed...
+        line1 = "Parsing failed\n"
+        line2 = "Reason: #{result.failure_reason.message}"
+        raise StandardError, line1 + line2
+      end
+
+      return engine.to_ptree(result)
+    end
+  end # class
+end # module

data/lib/zenlish/version.rb

@@ -0,0 +1,3 @@
+module Zenlish
+  VERSION = "0.1.0"
+end

data/lib/zenlish/wclasses/adjective.rb

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

data/lib/zenlish/wclasses/all_word_classes.rb

@@ -0,0 +1,11 @@
+# Load the WordClass class hierarchy
+# Algorithm: load the leaf classes from hierarchy
+
+require_relative 'adjective'
+require_relative 'common_noun'
+require_relative 'pronoun'
+require_relative 'proper_noun'
+require_relative 'irregular_verb'
+require_relative 'definite_article'
+require_relative 'demonstrative_determiner'
+require_relative 'indefinite_pronoun'

data/lib/zenlish/wclasses/article.rb

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

data/lib/zenlish/wclasses/common_noun.rb

@@ -0,0 +1,9 @@
+require_relative 'noun'
+
+module Zenlish
+  module WClasses
+    # Common nouns refer to general entities. Most have a singular and plural form.
+    class CommonNoun < Noun
+    end # class
+  end # module
+end # module

data/lib/zenlish/wclasses/definite_article.rb

@@ -0,0 +1,9 @@
+require_relative 'article'
+
+module Zenlish
+  module WClasses
+    # TODO: document
+    class DefiniteArticle < Article
+    end # class
+  end # module
+end # module