zenlish 0.1.25 → 0.2.00

data/lib/zenlish/inflect/inflection_table_builder.rb

@@ -0,0 +1,120 @@
+require_relative 'feature_heading'
+require_relative 'method_heading'
+require_relative 'formal_argument'
+require_relative 'equals_literal'
+require_relative 'unconditionally_true'
+require_relative 'matches_pattern'
+require_relative 'input_asis'
+require_relative 'concatenation'
+require_relative 'substitution'
+require_relative 'inflection_rule'
+require_relative 'inflection_table'
+
+        # DecisionTable: Common_form
+        # | NUMBER   | .base_form      | Common_form                |
+        # | singular | X               | base_form                  |
+        # | plural   | ~ /[^aeiouy]y$/ | sub(base_form, /y$/, "ies")|
+        # | plural   | X               | base_form + "s"            |
+        # build('Common_form') do
+        #   feature_heading 'NUMBER'
+        #   method_heading  'base_form'
+        #       | NUMBER          | base_form             | Common_form               |
+        #   rule [equals(:singular), dont_care             ], col('base_form')
+        #   rule [equals(:plural)  , matches(/[^aeiouy]y$/)], sub(col('base_form'), /y$/, 'ies')
+        #   rule [equals(:plural)  , dont_care             ], concat(col('base_form'), 's')
+        # end
+
+module Zenlish
+  module Inflect
+    class InflectionTableBuilder
+      # Name of decision table
+      attr_reader :table
+      attr_reader :headings
+      attr_reader :conds
+      attr_reader :rules
+
+      def initialize
+        reset
+      end
+
+      def build(aTableName, &aBlock)
+        reset
+        @table = InflectionTable.new(aTableName)
+        instance_exec(&aBlock) if block_given?
+        @table
+      end
+
+      def feature_heading(aFeatureName)
+        hd = FeatureHeading.new(aFeatureName)
+        headings << hd
+        table.add_heading(hd) if table
+      end
+
+      def method_heading(aMethodName)
+        hd = MethodHeading.new(aMethodName)
+        headings << hd
+        table.add_heading(hd) if table
+      end
+
+      def rule(conditions, consequent)
+        @conds = []
+        rl = InflectionRule.new(conditions.dup, consequent)
+        rules << rl
+        table.add_rule(rl) if table
+
+        rl
+      end
+
+      def equals(aValue)
+        arg = FormalArgument.new(conds.size)
+        equality_cond = EqualsLiteral.new(arg, aValue)
+        conds << equality_cond
+
+        equality_cond
+      end
+
+      def dont_care
+        item = UnconditionallyTrue.new
+        conds << item
+
+        item
+      end
+
+      def col(aColName)
+        col_index = headings.find_index { |hd| hd.label == aColName }
+        err_msg = "Cannot find heading named '#{aColName}'."
+        raise StandardError, err_msg if col_index.nil?
+        formal = FormalArgument.new(col_index)
+        InputAsIs.new(formal)
+      end
+
+      def matches(aPattern)
+        arg = FormalArgument.new(conds.size)
+        match_cond = MatchesPattern.new(arg, aPattern)
+        conds << match_cond
+        match_cond
+      end
+
+      def sub(original, pattern, replacement)
+        Substitution.new(original, pattern, replacement)
+      end
+
+      def concat(arg1, arg2)
+        Concatenation.new(arg1, arg2)
+      end
+
+      private
+
+      def reset()
+        @table = nil
+        @headings = []
+        @conds = []
+        @rules = []
+      end
+
+      # def do_it
+        # @headings
+      # end
+    end # class
+  end # module
+end # module

data/lib/zenlish/inflect/input_asis.rb

@@ -0,0 +1,22 @@
+require_relative 'atomic_o_expression'
+
+module Zenlish
+  module Inflect
+    class InputAsIs < AtomicOExpression
+      attr_reader :formal
+
+      def initialize(anArgument)
+        @formal = anArgument
+      end
+
+      def generate(headings, lexeme, actuals)
+        if actuals.empty?
+          hd = headings[formal.index]
+          hd.evaluate_for(lexeme)
+        else
+          actuals[formal.index]
+        end
+      end
+    end # class
+  end # module
+end # module

data/lib/zenlish/inflect/input_expression.rb

@@ -0,0 +1,9 @@
+module Zenlish
+  module Inflect
+    class InputExpression
+      def success?(_lexeme, _heading_values)
+        raise NotImplementedError, 'Method must be implemented in subclass(es).'
+      end    
+    end # class
+  end # module
+end # module

data/lib/zenlish/inflect/literal_asis.rb

@@ -0,0 +1,17 @@
+require_relative 'atomic_o_expression'
+
+module Zenlish
+  module Inflect
+    class LiteralAsIs < AtomicOExpression
+      attr_reader :text
+
+      def initialize(aLiteralValue)
+        @text = aLiteralValue
+      end
+
+      def generate(_headings, _lexeme, _values)
+        text
+      end
+    end # class
+  end # module
+end # module

data/lib/zenlish/inflect/matches_pattern.rb

@@ -0,0 +1,26 @@
+require_relative 'unary_input_expression'
+
+module Zenlish
+  module Inflect
+    class MatchesPattern < UnaryInputExpression
+      attr_reader :pattern
+
+      def initialize(anArgument, aPattern)
+        super(anArgument)
+        @pattern = aPattern
+      end
+
+      def success?(headings, lexeme, actuals)
+        val = nil
+        if actuals.empty?
+          # require 'debug'
+          hd = headings[argument.index]
+          val = hd.evaluate_for(lexeme)
+        else
+          val = actuals[argument.index]
+        end
+        val =~ pattern
+      end
+    end # class
+  end # module
+end # module

data/lib/zenlish/inflect/method_heading.rb

@@ -0,0 +1,16 @@
+require_relative 'heading'
+
+module Zenlish
+  module Inflect
+    class MethodHeading < Heading
+
+      def initialize(aLabel)
+        super(aLabel)
+      end
+      
+      def evaluate_for(aFeatureBearer)
+        aFeatureBearer.send(label)
+      end      
+    end # class
+  end # module
+end # module

data/lib/zenlish/inflect/nullary_input_expression.rb

@@ -0,0 +1,8 @@
+require_relative 'input_expression'
+
+module Zenlish
+  module Inflect
+    class NullaryInputExpression < InputExpression
+    end # class
+  end # module
+end # module

data/lib/zenlish/inflect/output_expression.rb

@@ -0,0 +1,6 @@
+module Zenlish
+  module Inflect
+    class OutputExpression
+    end # class
+  end # module
+end # module

data/lib/zenlish/inflect/substitution.rb

@@ -0,0 +1,65 @@
+require_relative 'literal_asis'
+require_relative 'composite_o_expression'
+
+module Zenlish
+  module Inflect
+    class Substitution < CompositeOExpression
+      def initialize(theOriginal, aPattern, theReplacement)
+        valid_original = validated_argument(theOriginal)
+        valid_pattern = validated_pattern(aPattern)
+        valid_replac = validated_argument(theReplacement)
+        super([valid_original, valid_pattern, valid_replac])
+      end
+
+      def generate(headings, lexeme, values)
+        original = children[0].generate(headings, lexeme, values)
+        replacement = children[-1].generate(headings, lexeme, values)
+
+        original.sub(pattern, replacement)
+      end
+
+      def pattern
+        children[1]
+      end
+
+      private
+
+      def validated_original(theOriginal)
+        arg = nil
+        if theOriginal.kind_of?(String)
+          arg = LiteralAsIs.new(theOriginal)
+        elsif theOriginal.kind_of?(OutputExpression)
+          arg = theOriginal
+        else
+          err_msg = "Expected an OutputExpression, found '#{theOriginal.inspect}' instead."
+          raise StandardError, err_msg
+        end
+
+        arg
+      end
+
+      def validated_pattern(aPattern)
+        unless aPattern.kind_of?(Regexp)
+          err_msg = "Expected a Regexp, found #{aPattern.inspect}."
+          raise StandardError, err_msg
+        end
+
+        aPattern
+      end
+
+      def validated_argument(anArgument)
+        arg = nil
+        if anArgument.kind_of?(String)
+          arg = LiteralAsIs.new(anArgument)
+        elsif anArgument.kind_of?(OutputExpression)
+          arg = anArgument
+        else
+          err_msg = "Expected an OutputExpression, found #{anArgument.inspect}."
+          raise StandardError, err_msg
+        end
+
+        arg
+      end
+    end # class
+  end # module
+end # module

data/lib/zenlish/inflect/unary_input_expression.rb

@@ -0,0 +1,13 @@
+require_relative 'input_expression'
+
+module Zenlish
+  module Inflect
+    class UnaryInputExpression < InputExpression
+      attr_reader :argument
+      
+      def initialize(anArgument)
+        @argument = anArgument
+      end
+    end # class
+  end # module
+end # module

data/lib/zenlish/inflect/unconditionally_true.rb

@@ -0,0 +1,11 @@
+require_relative 'nullary_input_expression'
+
+module Zenlish
+  module Inflect
+    class UnconditionallyTrue < NullaryInputExpression
+      def success?(_headings, _lexeme, _heading_values)
+        true
+      end     
+    end # class
+  end # module
+end # module

data/lib/zenlish/lang/dictionary.rb

@@ -1,4 +1,5 @@
 unless defined?(Zenlish::Lang::Dictionary)
+  require_relative '../feature/feature_struct_def_bearer'
   module Zenlish
     module Lang
       require_relative '../lex/empty_lexicon_factory'
@@ -8,12 +9,16 @@ unless defined?(Zenlish::Lang::Dictionary)
       sandbox = Object.new
       sandbox.extend(Zenlish::Lex::EmptyLexiconFactory)
       Dictionary = sandbox.create_empty_lexicon
+      self.extend(Feature::FeatureStructDefBearer)
 
-      def self.add_entry(aLemma, aWClassName)
+      # @param aLemma [String] is the canonical form, dictionary form, 
+      #   or citation form of a headword.
+      # @param aWClassName [String] the name of a word class.
+      def self.add_entry(aLemma, aWClassName, aFeatureHash = nil)
         entry = Zenlish::Lex::LexicalEntry.new(aLemma)
         wclass = Dictionary.name2terminal[aWClassName]
         raise StandardError, "Undefined word class for '#{aLemma}'" unless wclass
-        lexeme = Zenlish::Lex::Lexeme.new(wclass, entry).freeze
+        lexeme = Zenlish::Lex::Lexeme.new(wclass, entry, aFeatureHash).freeze
         Dictionary.add_entry(entry.freeze)
       end
 
@@ -47,6 +52,7 @@ unless defined?(Zenlish::Lang::Dictionary)
       add_entry('big', 'Adjective')
       add_entry('body', 'CommonNoun')
       add_entry('but', 'Coordinator')
+      add_entry('can', 'IrregularVerb')      
       add_entry('can', 'ModalVerbCan')
       add_entry('cause', 'RegularVerb')
       add_entry('change', 'RegularVerb')
@@ -54,7 +60,9 @@ unless defined?(Zenlish::Lang::Dictionary)
       add_entry('contain', 'RegularVerb')
       add_entry('container', 'CommonNoun')
       add_entry('could', 'ModalVerbCould')
+      add_entry('damage', 'RegularVerb')      
       add_entry('die', 'RegularVerb')
+      add_entry('difficult', 'Adjective')      
       add_entry('different', 'Adjective')
       add_entry('do', 'AuxiliaryDo')
       add_entry('do', 'IrregularVerbDo')
@@ -72,7 +80,9 @@ unless defined?(Zenlish::Lang::Dictionary)
       add_entry('happen', 'RegularVerb')
       add_entry('hear', 'IrregularLinkingVerb')
       add_entry('here', 'Adverb')
-      add_entry('here', 'CommonNoun') # from here (works as a pronoun of a place)
+      # example: ...from here (works as a pronoun of a place)
+      add_entry('here', 'CommonNoun', {'NUMBER' => enumeration(:singular),
+        'PARADIGM' => [identifier, 'Singular_only']})
       add_entry('I', 'PersonalPronoun')
       add_entry('if', 'SubordinatingConjunction')
       add_entry('in', 'Preposition')
@@ -99,7 +109,8 @@ unless defined?(Zenlish::Lang::Dictionary)
       add_entry('near', 'Preposition')
       add_entry('near to', 'Preposition')
       add_entry('now', 'Adverb')
-      add_entry('now', 'CommonNoun')
+      add_entry('now', 'CommonNoun', {'NUMBER' => enumeration(:singular),
+        'PARADIGM' => [identifier, 'Singular_only']})
       add_entry('not', 'AdverbNot')
       add_entry('of', 'PrepositionOf')
       add_entry('on', 'Preposition')
@@ -109,8 +120,10 @@ unless defined?(Zenlish::Lang::Dictionary)
       add_entry('or', 'Coordinator')
       add_entry('other', 'Adjective')
       add_entry('part', 'CommonNoun')
-      add_entry('people', 'CommonNoun')
-      add_entry('person', 'CommonNoun')
+      add_entry('people', 'CommonNoun', {'NUMBER' => enumeration(:plural), 
+        'PARADIGM' => [identifier, 'Plural_only']})
+      add_entry('person', 'CommonNoun', {'NUMBER' => enumeration(:singular),
+        'PARADIGM' => [identifier, 'Singular_only']})
       add_entry('place', 'CommonNoun')
       add_entry('same', 'Adjective')
       add_entry('same', 'Pronoun')

data/lib/zenlish/lang/zenlish_grammar.rb

@@ -237,6 +237,7 @@ builder = Rley::Syntax::GrammarBuilder.new do
   rule 'lexical_verb' => 'IrregularVerbKnow'
   rule 'lexical_verb' => 'IrregularVerbSay'
   rule 'lexical_verb' => 'IrregularVerbThink'
+ 
 
   rule 'linking_verb' => 'IrregularLinkingVerb'
 

data/lib/zenlish/lex/empty_lexicon_factory.rb

@@ -4,6 +4,9 @@ require_relative 'lexicon'
 module Zenlish
   module Lex
     module EmptyLexiconFactory
+      # Factory method. Helps in creating an "empty" lexicon.
+      # It just contains the word classes of Zenlish but no headwords.
+      # @return [Lexicon] the created lexicon object
       def create_empty_lexicon()
         lexicon = Lexicon.new
 

data/lib/zenlish/lex/lexeme.rb

@@ -1,3 +1,4 @@
+require_relative '../feature/feature_struct_def_bearer'
 module Zenlish
   module Lex
     # A word in the abstract sense; an individual, distinct item of a lexicon
@@ -5,23 +6,45 @@ module Zenlish
     # may exist. For instance, the word forms: 'hide', 'hides', 'hid', 'hidden'
     # relate to the lexeme for verb 'hide'. Also called 'dictionary word'.
     class Lexeme
-      # @return Zenlish::WClasses::WordClass
+      include Feature::FeatureStructDefBearer
+      
+      # @return [Zenlish::WClasses::WordClass]
       attr_reader :wclass
 
-      def initialize(aWordClass, anEntry)
-        @wclass = aWordClass
+      # @param aWClass [WClasses::WordClass, Rley::Syntax::Terminal]
+      # @param anEntry [Zenlish::LexicalEntry]
+      # @param aFeatureHash [Hash, NilClass]
+      def initialize(aWClass, anEntry, aFeatureHash = nil)
+        @wclass = aWClass
         @entry = anEntry.object_id
         anEntry.add_lexeme(self)
+        
+        p_struct = aWClass.kind_of?(WClasses::WordClass) ? aWClass.struct : nil
+        overriding_struct_defs = aFeatureHash.nil? ? {} : aFeatureHash
+        init_struct_def(p_struct, overriding_struct_defs)
       end
 
-      # @return Zenlish::Lex::LexicalEntry
+      # @return [Zenlish::Lex::LexicalEntry]
       def entry
         ObjectSpace._id2ref(@entry)
       end
+      
+      def inflect(constraints)
+        table = paradigm
+        table.inflect(self, constraints)
+      end
 
+      # @return [String]
       def lemma
         entry.lemma
       end
+
+      def paradigm
+        paradigm_feat_def = self['PARADIGM']
+        wclass.paradigms[paradigm_feat_def.default.val]      
+      end
+      
+      alias base_form lemma
     end # class
   end # module
 end # module

data/lib/zenlish/lex/lexicon.rb

@@ -3,6 +3,7 @@ module Zenlish
     # A lexicon is a collection of lexical entries.
     # Every entry is associated with one one more lexemes.
     class Lexicon
+      # @return [Array<Lex::LexicalEntry>] entries in the lexicon
       attr_reader :entries
       attr_reader :lemma2entry
 
@@ -20,6 +21,8 @@ module Zenlish
       end
 
       # @param aLemma[String] retrieve the lexeme form the given "head word".
+      # @param aWordClass [WordClasses::WordClass, NilClass] the word class of 
+      #   the lexeme.
       def get_lexeme(aLemma, aWordClass = nil)
         if aWordClass
           lexeme = nil

data/lib/zenlish/lex/literal.rb

@@ -2,11 +2,15 @@ require 'rley'
 
 module Zenlish
   module Lex
-    # TODO: document
+    # An occurrence of a grammar terminal symbol that occurs in the input text.
     class Literal < Rley::Lexical::Token
       attr_reader :zlexeme
 
       # initialize(theLexeme, aTerminal, aPosition) ⇒ Token
+      # @param literalText [String] the portion of input text that represents 
+      #   an occurence of the lexeme.
+      # @param aLexeme [Lex::Lexeme] the lexeme matched by the literal text.
+      # @param aPosition [Integer] the position of the literal in the input.
       def initialize(literalText, aLexeme, aPosition)
         super(literalText, aLexeme.wclass.name, aPosition)
         @zlexeme = aLexeme

data/lib/zenlish/version.rb

@@ -1,3 +1,3 @@
 module Zenlish
-  VERSION = '0.1.25'.freeze
+  VERSION = '0.2.00'.freeze
 end

data/lib/zenlish/wclasses/common_noun.rb

@@ -1,9 +1,54 @@
 require_relative 'noun'
+require_relative '../inflect/inflection_table_builder'
 
 module Zenlish
   module WClasses
     # Common nouns refer to general entities. Most have a singular and plural form.
     class CommonNoun < Noun
+      def initialize
+        super
+        @paradigms = {}
+        init_paradigms
+      end
+
+      # @return [Inflection::InflectionTable] Return default paradigm
+      def paradigm
+        paradigm_feat_def = self['PARADIGM']
+        paradigms[paradigm_feat_def.default.val]
+      end
+
+      private
+
+      def init_paradigms
+        builder = Inflect::InflectionTableBuilder.new
+
+        table = builder.build('Common_form') do
+          feature_heading 'NUMBER'
+          method_heading 'base_form'
+          rule([equals(:singular), dont_care], col('base_form'))
+          rule([equals(:plural), matches(/[^aeiouy]y$/)], sub(col('base_form'), /y$/, 'ies'))
+          rule([equals(:plural), dont_care], concat(col('base_form'), 's'))
+        end
+        add_paradigm(table)
+
+        table = builder.build('Plural_only') do
+          feature_heading 'NUMBER'
+          method_heading 'base_form'
+          rule([equals(:plural), dont_care], col('base_form'))
+        end
+        add_paradigm(table)
+
+        table = builder.build('Singular_only') do
+          feature_heading 'NUMBER'
+          method_heading 'base_form'
+          rule([equals(:singular), dont_care], col('base_form'))
+        end
+        add_paradigm(table)
+      end
+
+      def add_paradigm(anInflectionTable)
+        @paradigms[anInflectionTable.name] = anInflectionTable
+      end
     end # class
   end # module
 end # module

data/lib/zenlish/wclasses/noun.rb

@@ -6,6 +6,27 @@ module Zenlish
     # Nouns denote people, animals, inanimate things, places, events, qualities
     # and states.
     class Noun < WordClass
+      def initialize
+        super()
+        init_feature_defs
+      end
+
+      # Nouns inflect according to number, possessive. Therefore they are
+      # variable.
+      def invariable?
+        false
+      end
+
+      private
+
+      def init_feature_defs
+        # Create standard feature definitions for nouns.
+        feature_def_dsl {
+          feature_def 'NUMBER' => enumeration(:singular, :plural)
+          feature_def 'COUNTABILITY' => enumeration(:count, :non_count)
+          feature_def 'PARADIGM' => [identifier, 'Common_form'] # 2nd item is default value
+        }
+      end
     end # class
   end # module
 end # module

data/lib/zenlish/wclasses/preposition.rb

@@ -4,6 +4,11 @@ module Zenlish
   module WClasses
     # TODO: document
     class Preposition < WordClass
+    
+      # Prepositions do not inflect, so they're invariable.
+      def invariable?
+        true
+      end    
     end # class
   end # module
 end # module

data/lib/zenlish/wclasses/proper_noun.rb

@@ -5,6 +5,17 @@ module Zenlish
     # Proper nouns refer to persons, places, geographical features, planets, or various
     # period of time.
     class ProperNoun < Noun
+      def initialize
+        super()
+        init_feature_defs
+      end    
+    
+      def init_feature_defs
+        # Override standard feature definitions for proper nouns.
+        feature_def_dsl {
+          feature_def 'NUMBER' => enumeration(:singular)     
+        }
+      end    
     end # class
   end # module    
 end # module

data/lib/zenlish/wclasses/verb.rb

@@ -2,8 +2,16 @@ require_relative 'word_class'
 
 module Zenlish
   module WClasses
-    # TODO: document
+    # Abstract class. In traditional grammar, the verb is often defined 
+    # notionally as a 'doing' word (i.e. a word that describes the action
+    # in a clause).
     class Verb < WordClass
+    
+      # As all verbs inflect, or change form, to reflect changes in tense,
+      # person, number, and voice, they are, by definition, variable.
+      def invariable?
+        false
+      end
     end # class
   end # module
 end # module