zenlish 0.1.25 → 0.2.00

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d2f0746a4aeb453208667a3e6eed3f97ffda61a31bb9b551f3f80a09e04881bd
-  data.tar.gz: 958188827568032a3a71cc8021c3b6bdbaab6ddcd56508c2e13b93773b073631
+  metadata.gz: 68fb4d0914b284ffab37ba5f91c325918bcfaa4948adea0a747297e325c93fe6
+  data.tar.gz: e83dd3b97f088defef045fb01d5d6a7be202f02d4c45e85cdce3f2f718cf9ef2
 SHA512:
-  metadata.gz: 738bbeefbef76458d197b0dc5e7de3d9f0994304500933532da3a7935070a1981d8456e32e945c0d4f6e7e51f2f55389e9eb6debf7f945a2b441531a829e4963
-  data.tar.gz: 83237e8124d9d57ecd8d572b69ed88d26970c348ca2c2cef8b52a02a11a19d813eb867c1c44b56e9014a2e8f3bc5218e1ddf422cc08e42287f0b053bfdf9af7d
+  metadata.gz: 3de436eaced4062aade3ca3dc2d94915c284c2b38a5775ba3d6880d676cc8d0e3773a244eb1086ddca93f71c265f494b548fb114e7c30ea3b52ad1dbb8694a19
+  data.tar.gz: 7f55f80aad57993fcd1cadf75721f5f53fbd91fa8de6f620fb39fecd70892373dc69fe66fc3d13f43b272096aaf1c5afed60453ac126fb7c03fe9f0a1e435beb

data/CHANGELOG.md

@@ -1,10 +1,26 @@
 # CHANGELOG
 
+## [0.2.00] - 2020-01-30
+A lot of internal additions, such an initial feature model, embryonic inflection model.
+This is WIP.
+
+### Added
+- New subfolder `feature` that hosts classes for implementing features (= properties that can be attached to words)
+- New subfolder `inflect` that hosts classes for implmenting inflection tables (kind of decision tables)
+### Changed
+- File `dictionary.rb`: new entries in lexicon `damage`, `difficult`
+- File `dictionary.rb`: common nouns with special inflection rules (e.g. pluralized form) have their paradigm specified
+- Class `Lexeme` can have its own set of feature definitions.
+- Class `WordClass` ca have its own set of feature definitions.
+- Class `Noun` has the feature definitions for: `NUMBER`, `COUNTABILITY` and `PARADIGM`
+
+
+
 ## [0.1.25] - 2019-12-06
 __Zenlish__ can parse all sentences in lesson 1, 2 and 3-A .. 3-G (352 sentences in total) from
  [Learn These Words First](http://learnthesewordsfirst.com/).
  
- ### Changed
+### Changed
  - File `lesson3_spec.rb`: tests include all sentences from lesson 3-A to 3-G.
  - `ZenlishGrammar`: refactoring of the predicative_sentence rules.
  - File `dictionary.rb`: new entries in lexicon `between`, `choose`, `machine`.

data/LICENSE.txt

@@ -1,6 +1,6 @@
 The MIT License (MIT)
 
-Copyright (c) 2019, Dimitri Geshef
+Copyright (c) 2019-2020, Dimitri Geshef
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

data/README.md

@@ -33,14 +33,14 @@ Over time, the zenlish gem will contain:
 - A lexicon [STARTED]
 - A context-free grammar [STARTED]
 - A parser [STARTED]
-- Feature unification (for number, gender agreement,...)[TODO]
+- Feature unification (for number, gender agreement,...)[STARTED]
 - A simplified ontology[TODO]
 
 
-#### Some project metrics (v. 0.1.25)
+#### Some project metrics (v. 0.2.00)
 |Metric|Value|  
 |:-:|:-:|
-| Number of lemmas in dictionary        | 138 |
+| Number of lemmas in dictionary        | 141 |
 | [Coverage 100 commonest English words](https://en.wikipedia.org/wiki/Most_common_words_in_English)  | 61% |
 | Number of production rules in grammar | 185 |
 | Number of lessons covered             | 23  |

data/lib/zenlish/feature/boolean_domain.rb

@@ -0,0 +1,29 @@
+require 'singleton'
+require_relative 'feature_domain'
+require_relative 'boolean_value'
+
+module Zenlish
+  module Feature
+    class BooleanDomain < FeatureDomain
+      include Singleton # Use the Singleton design patttern
+      
+      def build_value(aValue)
+        BooleanValue.new(validated_value(aValue))
+      end
+      
+      def include?(aValue)
+        aValue.kind_of?(TrueClass) || aValue.kind_of?(FalseClass)
+      end
+
+      private
+
+      def validated_value(aValue)
+        if not aValue.is_a?(FalseClass) and not aValue.is_a?(TrueClass)
+           raise StandardError, "Expected a boolean instead of #{aValue.class}."
+        end
+
+        aValue
+      end
+    end # class
+  end # module
+end # module

data/lib/zenlish/feature/boolean_value.rb

@@ -0,0 +1,9 @@
+require_relative 'feature_value'
+
+module Zenlish
+  module Feature
+    class BooleanValue < FeatureValue
+    
+    end # class
+  end # module
+end # module

data/lib/zenlish/feature/enumeration_domain.rb

@@ -0,0 +1,32 @@
+require_relative 'feature_domain'
+require_relative 'symbol_value'
+
+module Zenlish
+  module Feature
+    class EnumerationDomain < FeatureDomain
+      attr_reader :enum
+
+      def initialize(*symbols)
+        @enum = symbols
+      end
+
+      def build_value(aValue)
+        SymbolValue.new(validated_value(aValue))
+      end
+      
+      def include?(aValue)
+        enum.include?(aValue)
+      end
+
+      private
+
+      def validated_value(aValue)
+        unless include?(aValue)
+           raise StandardError, "#{aValue} isn't part of enumeration [#{enum.join(', ')}]."
+        end
+
+        aValue
+      end
+    end # class
+  end # module
+end # module

data/lib/zenlish/feature/feature.rb

@@ -0,0 +1,30 @@
+require 'forwardable'
+
+module Zenlish
+  module Feature
+    class Feature
+      # Forwardable mix-in module to implement delegation of specified methods.
+      extend Forwardable
+      
+      # The feature definition
+      attr_reader :definition
+      
+      attr_reader :binding
+
+      def_delegators :@definition, :name, :domain
+      
+      # @param aDefinition [FeatureDef]
+      def initialize(aDefinition)
+        @definition = aDefinition
+      end
+      
+      def bound?
+        not binding.nil?
+      end
+      
+      def bind_to(aFeatureValue)
+        @binding = aFeatureValue
+      end
+    end # class
+  end # module
+end # module

data/lib/zenlish/feature/feature_def.rb

@@ -0,0 +1,48 @@
+require_relative 'enumeration_domain'
+require_relative 'feature_value'
+
+module Zenlish
+  module Feature
+    class FeatureDef
+      # @return [String] the name of the feature
+      attr_reader :name
+
+      # @return [FeatureDomain] the set of potential values the feature can take
+      attr_reader :domain
+
+      # @return [FeatureValue] the default value for the feature.
+      attr_reader :default
+
+      # @param aName [String] the name of the feature
+      # @param aDomain [FeatureDomain]
+      # @param aDefault [FeatureValue, NilClass]
+      def initialize(aName, aDomain, aDefault = nil)
+        @name = validated_name(aName)
+        @domain = aDomain
+        @default = validated_default(domain, aDefault)
+      end
+
+      private
+
+      def validated_name(aName)
+        raise StandardError, 'feature name cannot be empty.' if aName.empty?
+        aName.dup
+      end
+
+      def validated_default(aDomain, aDefault)
+        if aDefault
+          default = aDefault
+        elsif aDomain.is_a?(BooleanDomain)
+          default = nil
+        else aDomain.is_a?(EnumerationDomain)
+          if aDomain.enum.size == 1
+            val = FeatureValue.new(aDomain.enum[0])
+            default = val
+          else
+            default = nil
+          end
+        end
+      end
+    end # class
+  end # module
+end # module

data/lib/zenlish/feature/feature_domain.rb

@@ -0,0 +1,9 @@
+module Zenlish
+  module Feature
+    class FeatureDomain
+      def include?(aValue)
+        raise NotImplementedError, 'Implemented this method in subclass(es).'
+      end
+    end # class
+  end # module
+end # module

data/lib/zenlish/feature/feature_struct.rb

@@ -0,0 +1,24 @@
+require_relative 'feature_value'
+require_relative 'feature'
+
+module Zenlish
+  module Feature
+    class FeatureStruct < FeatureValue
+      def initialize(aStructDef)
+        featrs = build_features(aStructDef)
+        super(aStructDef, featrs)
+      end
+
+      private
+
+      def build_features(aStructDef)
+        feats = []
+        aStructDef.struct.each_value do |feature_def|
+          feats << Feature.new(feature_def)
+        end
+
+        feats
+      end
+    end # class
+  end # module
+end # module

data/lib/zenlish/feature/feature_struct_def.rb

@@ -0,0 +1,44 @@
+require_relative 'feature_domain'
+
+module Zenlish
+  module Feature
+    class FeatureStructDef < FeatureDomain
+      attr_reader :parent
+      attr_reader :struct
+
+      # @param aParent [FeatureStructDef]
+      def initialize(aParent = nil)
+        @parent = validated_parent(aParent)
+        @struct = {}
+      end
+
+      # @param aFeatureName [String]
+      def [](aFeatureName)
+        return struct[aFeatureName] if struct.include? aFeatureName
+        if parent
+          p_struct = parent.struct
+          return p_struct[aFeatureName] if p_struct.include? aFeatureName
+        end
+
+        raise StandardError, "Unknown feature name #{aFeatureName}"
+      end
+
+      # @param aFeatureDef [Zenlish::Feature::FeatureDef]
+      def add_feature_def(aFeatureDef)
+        struct[aFeatureDef.name] = aFeatureDef
+      end
+
+      private
+
+      def validated_parent(aParent)
+        if aParent.kind_of?(FeatureStructDef)
+          aParent
+        elsif aParent
+          aParent.struct
+        else
+          nil
+        end
+      end
+    end # class
+  end # module
+end # module

data/lib/zenlish/feature/feature_struct_def_bearer.rb

@@ -0,0 +1,65 @@
+require_relative 'boolean_domain'
+require_relative 'identifier_domain'
+require_relative 'enumeration_domain'
+require_relative 'feature_def'
+require_relative 'feature_value'
+require_relative 'feature_struct_def'
+
+module Zenlish
+  module Feature
+    # Mix-in module. It adds a feature structure defintion to its host and
+    # also factory methods to ease feature definition manipulation.
+    module FeatureStructDefBearer
+      # @param aParentStruct [Feature::FeatureStructDef] parent structure
+      # @param aFeatureHash [Hash] hash with pairs of the form: String => FeatureDomain
+      def init_struct_def(aParentStruct, aFeatureHash)
+        @struct = FeatureStructDef.new(aParentStruct)
+        aFeatureHash.each_pair do |name, domain|
+          feature_def(name => domain)
+        end
+      end
+
+      # @return [Feature::FeatureStructDef]
+      def struct
+        @struct
+      end
+
+      # Retrieve feature definition with given name.
+      # @param aName [String] Name of feature def to search for.
+      # @return [Feature::FeatureDef, NilClass]
+      def [](aName)
+        struct[aName]
+      end
+
+      # @return [Feature::BooleanDomain]      
+      def boolean
+        BooleanDomain.instance
+      end
+
+      # @return [Feature::EnumerationDomain] 
+      def enumeration(*items)
+        EnumerationDomain.new(*items)
+      end
+      
+      def identifier(aDefaultValue = nil)
+        IdentifierDomain.instance
+      end
+
+      # @param aPair [Hash] hash with one pair { String => FeatureDomain }
+      def feature_def(aPair)
+        if aPair.values[0].is_a?(Array)
+          dom, val = aPair.values[0]
+          val = dom.build_value(val) unless val.kind_of?(FeatureValue)
+          featr_def = FeatureDef.new(aPair.keys[0], dom, val)
+        else
+          featr_def = FeatureDef.new(aPair.keys[0], aPair.values[0])
+        end
+        @struct.add_feature_def(featr_def)
+      end
+
+      def feature_def_dsl(&aBlock)
+        instance_eval(&aBlock)
+      end
+    end # module
+  end # module
+end # module

data/lib/zenlish/feature/feature_value.rb

@@ -0,0 +1,17 @@
+module Zenlish
+  module Feature
+    class FeatureValue
+      attr_reader :val
+
+      def initialize(aValue)
+        @val = aValue
+      end
+
+      protected
+
+      def valid_value()
+        raise NotImplementedError
+      end
+    end # class
+  end # module
+end # module

data/lib/zenlish/feature/identifier_domain.rb

@@ -0,0 +1,29 @@
+require 'singleton'
+require_relative 'feature_domain'
+require_relative 'identifier_value'
+
+module Zenlish
+  module Feature
+    class IdentifierDomain < FeatureDomain
+      include Singleton # Use the ingletion design pattern
+
+      def build_value(aValue)
+        IdentifierValue.new(validated_value(aValue))
+      end
+      
+      def include?(aValue)
+        aValue =~ /^[a-zA-Z\_][a-zA-Z0-9\_]*$/
+      end
+
+      private
+
+      def validated_value(aValue)
+        unless include?(aValue)
+           raise StandardError, "#{aValue} isn't a valid identifier."
+        end
+
+        aValue
+      end      
+    end # class
+  end # module
+end # module

data/lib/zenlish/feature/identifier_value.rb

@@ -0,0 +1,9 @@
+require_relative 'feature_value'
+
+module Zenlish
+  module Feature
+    class IdentifierValue < FeatureValue
+    
+    end # class
+  end # module
+end # module

data/lib/zenlish/feature/symbol_value.rb

@@ -0,0 +1,8 @@
+require_relative 'feature_value'
+
+module Zenlish
+  module Feature
+    class SymbolValue < FeatureValue
+    end # class
+  end # module
+end # module

data/lib/zenlish/inflect/atomic_o_expression.rb

@@ -0,0 +1,9 @@
+require_relative 'output_expression'
+
+module Zenlish
+  module Inflect
+    class AtomicOExpression < OutputExpression
+    end # class
+  end # module
+end # module
+

data/lib/zenlish/inflect/composite_o_expression.rb

@@ -0,0 +1,14 @@
+require_relative 'output_expression'
+
+module Zenlish
+  module Inflect
+    class CompositeOExpression < OutputExpression
+      attr_reader :children
+
+      def initialize(theChildren)
+        @children = theChildren.dup
+      end
+    end # class
+  end # module
+end # module
+

data/lib/zenlish/inflect/concatenation.rb

@@ -0,0 +1,36 @@
+require_relative 'literal_asis'
+require_relative 'composite_o_expression'
+
+module Zenlish
+  module Inflect
+    class Concatenation < CompositeOExpression
+
+      def initialize(argument1, argument2)
+        super([validated_argument(argument1), validated_argument(argument2)])
+      end
+
+      def generate(headings, lexeme, values)
+        part1 = children[0].generate(headings, lexeme, values)
+        part2 = children[-1].generate(headings, lexeme, values)
+
+        part1 + part2
+      end
+
+      private
+
+      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 = "Unexpected type of argument #{anArgument.inspect}."
+          raise StandardError, err_msg
+        end
+
+        arg
+      end
+    end # class
+  end # module
+end # module

data/lib/zenlish/inflect/equals_literal.rb

@@ -0,0 +1,25 @@
+require_relative 'unary_input_expression'
+
+module Zenlish
+  module Inflect
+    class EqualsLiteral < UnaryInputExpression
+      attr_reader :literal
+
+      def initialize(anArgument, aLiteral)
+        super(anArgument)
+        @literal = aLiteral
+      end
+
+      def success?(headings, lexeme, actuals)
+        if actuals.empty?
+          hd = headings[argument.index]
+          feat_def = hd.evaluate_for(lexeme)
+          feat_def.domain.include?(literal)
+        else
+          val = actuals[argument.index]
+          val == literal
+        end
+      end
+    end # class
+  end # module
+end # module

data/lib/zenlish/inflect/feature_heading.rb

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

data/lib/zenlish/inflect/formal_argument.rb

@@ -0,0 +1,11 @@
+module Zenlish
+  module Inflect
+    class FormalArgument
+      attr_reader :index
+      
+      def initialize(anIndex)
+        @index = anIndex
+      end
+    end # class
+  end # module
+end # module

data/lib/zenlish/inflect/heading.rb

@@ -0,0 +1,11 @@
+module Zenlish
+  module Inflect
+    class Heading
+      attr_reader :label
+
+      def initialize(aLabel)
+        @label = aLabel
+      end
+    end # class
+  end # module
+end # module

data/lib/zenlish/inflect/inflection_rule.rb

@@ -0,0 +1,28 @@
+module Zenlish
+  module Inflect
+    # An inflection rule has two-parts:
+    # - a set of input conditions
+    # - a consequent part which tells how to inflect a lexeme
+    class InflectionRule
+      attr_reader :conditions
+      attr_reader :consequent
+
+      def initialize(theConditions, aConsequentExpr)
+        @conditions = theConditions
+        @consequent = aConsequentExpr
+      end
+
+      def success?(theHeadings, aLexeme, actuals)
+        conditions.all? { |cond| cond.success?(theHeadings, aLexeme, actuals) }
+      end
+
+      def apply(theHeadings, aLexeme, actuals)
+        consequent.generate(theHeadings, aLexeme, actuals)
+      end
+
+      def force_apply(theHeadings, aLexeme)
+        consequent.generate(theHeadings, aLexeme)
+      end
+    end # class
+  end # module
+end # module

data/lib/zenlish/inflect/inflection_table.rb

@@ -0,0 +1,46 @@
+
+module Zenlish
+  module Inflect
+    class InflectionTable
+      attr_reader :name
+      attr_reader :headings
+      attr_reader :rules
+
+      def initialize(aName)
+        @name = aName
+        @headings = []
+        @rules = []
+      end
+
+      def add_heading(aHeading)
+        @headings << aHeading
+      end
+
+      def add_rule(aRule)
+        @rules << aRule
+      end
+
+      def inflect(aLexeme, theConstraints)
+        err_msg = "Table has #{headings.size} headings."
+        raise StandardError, err_msg if theConstraints.size != headings.size
+        actuals = []
+        headings.each_with_index do |hd, idx|
+          if theConstraints[idx]
+            actuals << theConstraints[idx]
+          else
+            actuals << hd.evaluate_for(aLexeme)
+          end
+        end
+        # Hit policy: first
+        matching_rule = rules.find do |rule| 
+          rule.success?(headings, aLexeme, actuals) 
+        end
+        unless matching_rule
+          err_msg = "No rule in table covers case: lexeme #{aLexeme}, actuals: #{p actuals}."
+          raise StandardError, err_msg
+        end
+        matching_rule.apply(headings, aLexeme, actuals)
+      end
+    end # class
+  end # module
+end # module