llt-morphologizer 0.0.1

data/lib/llt/morphologizer/lookup_statement.rb

@@ -0,0 +1,66 @@
+module LLT
+  class Morphologizer
+    class LookupStatement
+      attr_reader :components
+      alias :options :components
+
+      def initialize(*args)
+        @stem, @table, @column, @itypes, @components = args
+        safety_clones
+      end
+
+      def stem_type
+        @column
+      end
+
+      def type
+        @table
+      end
+
+      def to_query
+        {
+          type: @table,
+          stem: @stem,
+          stem_type: @column,
+          restrictions: build_restrictions
+        }
+      end
+
+      def to_s
+        "Looking up #{@stem.light_green} as #{@table}, #{@column} #{"with #{components_to_s}" if @components.any? } (classes: #{@itypes * ", "})"
+      end
+
+      private
+
+      # The methods that help in the creation of such instances are
+      # prepending and appending strings - especially the thematic.
+      # Just to be safe, clones this value.
+      def safety_clones
+        if thematic = @components[:thematic]
+          @components[:thematic] = thematic.clone
+        end
+      end
+
+      def components_to_s
+        @components.map do |k, v|
+          val = (v.empty? ? '""' : v)
+          "#{k} #{val.to_s.cyan}"
+        end.compact * ", "
+      end
+
+
+      def build_restrictions
+        kw = if @itypes.all? { |x| x.kind_of? Fixnum }
+               :inflection_class
+             else
+               :pf_composition
+             end
+
+        {
+          type: kw,
+          values: @itypes
+        }
+      end
+    end
+  end
+end

data/lib/llt/morphologizer/stem_lookup_statement_builder.rb

@@ -0,0 +1,130 @@
+module LLT
+  class Morphologizer
+    class StemLookupStatementBuilder
+
+      require 'llt/morphologizer/stem_lookup_statement_builder/contracted_forms'
+      require 'llt/morphologizer/stem_lookup_statement_builder/declinable'
+      require 'llt/morphologizer/stem_lookup_statement_builder/conjugable'
+      require 'llt/morphologizer/lookup_statement'
+
+      include Declinable
+      include Conjugable
+
+      def initialize(word, log)
+        @word = word.clone # clone! because this will get sliced and reset continuously in this class
+        @log  = log
+
+        @components = Hash.new { |h, k| h[k] = "" }
+        @lookup     = {}
+      end
+
+      def stem
+        # a semantic help
+        @word
+      end
+
+      GETTER_METHODS = { components: %w{ thematic extension comparison_sign ending contraction },
+                         lookup:     %w{ table column itype } }
+
+      GETTER_METHODS.each do |inst_var, methods|
+        methods.each do |method|
+          class_eval <<-STR
+            def #{method}
+              @#{inst_var}[:#{method}]
+            end
+          STR
+        end
+      end
+
+      def statements
+        @statements = []
+        create_declinables
+        create_conjugables
+
+        @statements
+      end
+
+      def setup(operator)
+        @components.clear
+        @lookup     = { table: "", column: "", itype: [] }
+        @operator   = operator
+      end
+
+      def reset(*args)
+        args.flatten.each do |comp|
+          @word << @components.delete(comp).to_s
+        end
+      end
+
+      def all
+        @all_memo ||= %i{ thematic extension comparison_sign ending }
+      end
+
+      def has(arr)
+        type, components = arr
+        if result = scan(components, type)
+          slice_and_stash(type, result)
+        end
+      end
+
+      def scan(components, type)
+        # look what that's doing, it's a bit weird
+        components.flat_map {|x| @word.scan(x) }.first   # that's brutally ugly
+      end
+
+      def slice_and_stash(type, result)
+        @components[type].prepend(@word.slice!(/#{result}$/))
+      end
+
+      def look_for the_table = :same, the_column = :same
+        unless the_table == :same
+          @lookup[:table]  = the_table
+          @lookup[:column] = the_column
+        end
+
+        send("valid_itypes_for_#{@operator}")
+        add_statement!
+        add_additional_persona_place_or_ethnic_statement!
+        itype.clear
+      end
+
+      def add_statement!
+        if itype.empty?
+          @log.warning("#{stem} with #{@components[:ending]} has no searchable infl classes.")
+        else
+          # 2013-09-27 19:23 @components.clone substituted with rejection of empty strings - observe if this leads to trouble.
+          st = LookupStatement.new(cloned_stem, table, column, itype.clone, unemptied_components)
+          @statements << st
+        end
+      end
+
+      def unemptied_components
+        # leave ending always in - otherwise some words trigger build all forms (cf ita)
+        @components.reject { |k, v| v.empty? unless k == :ending }
+      end
+
+
+      def cloned_stem
+        s = stem.clone
+        s.downcase! unless persona_place_or_ethnic?
+        s
+      end
+
+      def persona_place_or_ethnic?
+        table == :persona || table == :place || table == :ethnic
+      end
+
+      def add_additional_persona_place_or_ethnic_statement!
+        if stem.match(/^[A-Z].*/)
+          case table
+          when :noun
+            @lookup[:table] = :persona and add_statement!
+            @lookup[:table] = :place   and add_statement!
+          when :adjective
+            @lookup[:table] = :ethnic  and add_statement! if column == :stem
+          end
+        end
+      end
+    end
+  end
+end

data/lib/llt/morphologizer/stem_lookup_statement_builder/conjugable.rb

@@ -0,0 +1,221 @@
+module LLT::Morphologizer::StemLookupStatementBuilder::Conjugable
+  include LLT::Morphologizer::StemLookupStatementBuilder::ContractedForms
+
+  class << self
+    def sg_1_active
+      [/(?<!tud|[^nu][st]i|ment|[bc]ul|[ao]ri|\Apr)o$/, /(?<![^s]u)m$/]
+    end
+
+    def sg_2_active
+      /(?<=[aer]|[^tr]i|[^aeirsl]ti|[^ai]ri|[^t][sft]eri|quiri|quaeri|\A[a-z]peri|[^a-z]geri|[^a-z]pari|[^a-z]meti)s$/
+    end
+
+    def sg_3_active
+      /(?<=\S[ae]|[is])t$/
+    end
+
+    def pl_1_active
+       /(?<!illi|erri|ssi|[^aeiu])mus$/
+    end
+
+    def pl_2_active
+      /(?<=[aei])tis$/
+    end
+
+    def pl_3_active
+      /(?<=[aeiu])nt$/
+    end
+
+    def sg_1_passive
+      [/(?<!u)or$/, /(?<!u)r$/]
+    end
+
+    def sg_2_passive
+      /(?<=[^p]a|[^afgtpsx]e|[^(qu)]i|[cr][uia]pe|[a-z][tg]e)ris$/
+    end
+
+    def sg_3_passive
+      /(?<=[aei])tur$/
+    end
+
+    def pl_1_passive
+      /mur$/
+    end
+
+    def pl_2_passive
+      /(?<=[aei])mini$/
+    end
+
+    def pl_3_passive
+      /(?<=[aeiu])ntur$/
+    end
+  end
+
+  PRIMARY_ENDING    = [:ending, [ *sg_1_active, sg_2_active, sg_3_active, pl_1_active, pl_2_active, pl_3_active,
+                                  *sg_1_passive, sg_3_passive, pl_1_passive, pl_2_passive, pl_3_passive]]
+  PRIMARY_ENDING_SG_2_PASSIVE = [:ending, [sg_2_passive]]
+
+  SECONDARY_ENDING  = [:ending, [ /isti$/, /(?<=[^rnt])i$/, /it$/, /imus$/, /istis$/, /erunt$/, /ere$/ ]]
+  IMPERATIVE_ENDING = [:ending, [ /(?<=[aei])te$/, /tote$/, /(?<=[^ieu]a$|e$|[^min][^uv]i$)/, /(?<=[^n])to$/, /nto$/,
+                                 /(?<=[^n])tor$/, /ntor$/]]
+  DEP_IMP_ENDING    = [:ending, [ /(?<=[aei])re$/ ]]
+
+  PERFECT_EXTENSIONS           = [:extension, [/er$|er[ai]$|isse$/]]
+  IMPERFECT_BA                 = [:extension, [/ba$/]]
+  FUTURE_B                     = [:extension, [/[b]$/]]
+  FUTURE_OR_SUBJUNCTIVE_A_OR_E = [:extension, [/[ae]$/]]
+  SUBJUNCTIVE_IMPERFECT        = [:extension, [/re$/]]
+
+  THEMATIC_VOWEL                      = [:thematic, [/[eiu]$/]]
+  THEMATIC_I_OF_M                     = [:thematic, [/[i]$/]]
+  THEMATIC_E_OF_SUBJUNCTIVE_IMPERFECT = [:thematic, [/e$/]]
+
+  # (?<=[aei])re not needed here as inf pr, - the dep_imp_ending finds it
+  # anyway, the FormBuilder cares for the rest.
+  INFINITIVE_PR     = [:ending, [/(?<=[aei])ri$|(?<=[^aeior])i$|r?ier$/]]
+  INFINITIVE_PF     = [:ending, [/isse$/]]
+
+  def create_conjugables
+    setup(:conjugable)
+    search_for_contracted_form(:conjugable_search)
+
+    setup(:conjugable)
+    conjugable_search
+  end
+
+
+  def conjugable_search
+    secondary_ending
+    primary_ending(PRIMARY_ENDING)
+    primary_ending(PRIMARY_ENDING_SG_2_PASSIVE)
+    imperative
+    infinitive
+  end
+
+  private
+
+  def secondary_ending
+    if has SECONDARY_ENDING
+      look_for :verb, :pf
+      reset all
+    end
+  end
+
+  def primary_ending(const)
+    if has const then look_for :verb, :pr
+
+      if has IMPERFECT_BA       then look_for :verb, :pr
+        if has THEMATIC_VOWEL   then look_for :same; end
+        if has THEMATIC_I_OF_M  then look_for :same; end
+        reset :thematic, :extension
+      end
+
+      if has THEMATIC_VOWEL then look_for :same
+        if has THEMATIC_I_OF_M then look_for :same; end
+        if has FUTURE_B
+          look_for :same
+          reset :extension, :thematic
+        else reset :thematic, :extension
+        end
+      end
+
+      if has FUTURE_B then look_for :same
+        reset :thematic, :extension
+      end
+
+      if has FUTURE_OR_SUBJUNCTIVE_A_OR_E then look_for :same
+        subjunctive_present_of_A_conjugation
+        if has THEMATIC_I_OF_M then look_for :same; end
+        reset :thematic, :extension
+      end
+
+      if has SUBJUNCTIVE_IMPERFECT then look_for :same
+        if  has THEMATIC_E_OF_SUBJUNCTIVE_IMPERFECT then look_for :same; end
+      end
+
+      first_person_present_of_A_conjugation
+
+      reset :thematic, :extension
+
+      if has PERFECT_EXTENSIONS
+        look_for :verb, :pf
+      end
+
+      reset all
+    end
+  end
+
+  def imperative
+    unless short_imperative
+      if has IMPERATIVE_ENDING then look_for :verb, :pr
+        if has THEMATIC_VOWEL  then look_for :same
+          if has THEMATIC_I_OF_M  then look_for :same; end
+        end
+        reset all
+      end
+
+      if has DEP_IMP_ENDING then look_for :verb, :pr
+        if has THEMATIC_VOWEL  then look_for :same
+          if has THEMATIC_I_OF_M  then look_for :same; end
+        end
+        reset all
+      end
+    end
+  end
+
+  def infinitive
+    if has INFINITIVE_PR
+      look_for :verb, :pr
+      if has THEMATIC_VOWEL
+        look_for :same
+      end
+      reset all
+    end
+
+    if has INFINITIVE_PF
+      look_for :verb, :pf
+      reset all
+    end
+  end
+
+  def subjunctive_present_of_A_conjugation
+    append_a_search_and_chop_it if extension == "e" && stem !~ /i$/
+  end
+
+  def first_person_present_of_A_conjugation
+    append_a_search_and_chop_it if ending =~ /(o|or)$/ && extension.empty? # laudavero
+  end
+
+  def append_a_search_and_chop_it
+    stem << "a"
+    look_for :same
+    stem.chop!
+  end
+
+  def short_imperative
+    if stem =~ /dic$|duc$|fac$|fer$/
+      look_for :verb, :pr # had return true before, but look_for should return true anyway
+    end
+  end
+
+  def valid_itypes_for_conjugable
+    if column == :pr
+      itype << 1 if stem =~ /a$/
+      itype << 2 if stem =~ /e$/
+      itype << 3 if stem =~ /[^aeio]$/ && thematic != "iu"
+      itype << 4 if stem =~ /i$/
+      itype << 5 if stem =~ /[^aeio]$/ && thematic != "u"
+    end
+
+    if column == :pf
+      itype << "v"      if stem =~ /v$/
+      itype << "u"      if stem =~ /u$/
+      itype << "s"      if stem =~ /s$|x$/
+      itype << "else"   if stem !~ /v$|u$|s$|x$/
+      itype << "ablaut" if stem !~ /v$|u$|s$|x$/
+      # regexps needed
+      itype << "reduplication" if stem
+    end
+  end
+end
+

data/lib/llt/morphologizer/stem_lookup_statement_builder/contracted_forms.rb

@@ -0,0 +1,38 @@
+module LLT::Morphologizer::StemLookupStatementBuilder::ContractedForms
+
+  CONTRACTED_FORMS = {
+    "v"  => /(?<=[^v]i)(er[aiu]nt|er[ia][mst]|er[ia]mus|er[ia]tis|ero)$/,
+    "vi" => /(?<=[^v][aeio])(stis?|sse[mst]|ssemus|ssetis|ssent|sse)$/,
+    "ve" => /(?<=[^v][aeo])(r[aiu]nt|r[ia][mst]|r[ia]mus|r[ia]tis|ro)$/
+  }
+
+
+  def search_for_contracted_form(method)
+    CONTRACTED_FORMS.each do |missing_piece, regexp|
+      index = @word =~ regexp
+      unless index.nil?
+        @word.insert(index, missing_piece)
+        @components[:contraction] = Contraction.new(index, missing_piece)
+
+        send(method)
+        @word.slice!(index, 2)
+      end
+    end
+  end
+
+  class Contraction
+    def initialize(position, contraction)
+      @position    = position
+      @contraction = contraction
+    end
+
+    def empty?
+      # duck type, fulfilling the contract of the other component strings
+      false
+    end
+
+    def to_s
+      "#{@contraction} contracted at #{@position}"
+    end
+  end
+end