llt-form_builder 0.0.1

data/lib/llt/form_builder/personal_pronoun_builder.rb

@@ -0,0 +1,107 @@
+module LLT
+  class PersonalPronounBuilder < DeclinableBuilder
+    endings_defined_through :inflection_class
+
+    validate :suffix
+
+    def indices
+      {
+        casus: [0, 1, 2, 3, nil, 5],
+        numerus: [0, 6],
+      }
+    end
+
+    def compute
+      (regular_forms + forms_with_suffix + additional_genetives).sort_by(&:index)
+    end
+
+    def forms
+      endings
+    end
+
+    def forms_with_suffix
+      suffixeds = SUFFIXED_FORMS[@inflection_class]
+      res = []
+      return res unless suffixeds
+      suffixeds.each do |i, suffixes|
+        if @lookup_indices.include?(i)
+          suffixes.each do |suffix|
+            f = forms[i]
+            res << new_form_through_index(f, i, suffix)
+          end
+        end
+      end
+      res.flatten.compact
+    end
+
+    def additional_genetives
+      if nos_or_vos && @lookup_indices.include?(7) # gen.pl
+        [new_form_through_index("#{@inflection_class}trum", 7)]
+      else
+        []
+      end
+    end
+
+    def nos_or_vos
+      @inflection_class == :nos || @inflection_class == :vos
+    end
+
+    def new_form_through_index(form, i, suffix = "")
+      # nil values in ending == form present, vocatives f.e., or se in nom.
+      return unless form
+      c, n = casus_numerus_sexus_by_index(i)
+      new_form(stem: form, casus: c, numerus: n, suffix: suffix, index: i)
+    end
+
+    def default_args
+      # need to override, because we want to use our custom "stem", which is actually the form itself
+      { inflection_class: @inflection_class }
+    end
+
+
+    private
+
+    def self.compute_suffixed_forms
+      hash = container
+      # arrays are styled as casus, numerus, suffix
+      # 0: cum, 1: met, 2: te, 3: se
+      suffixes = %w{ cum met te se }
+      # -cum
+      hash[:ego] << [6,1,0]
+      hash[:tu] << [6,1,0]
+      hash[:se] << [6,1,0] << [6,2,0]
+      hash[:nos] << [6,2,0]
+      hash[:vos] << [6,2,0]
+      # -met
+      hash[:ego] << [1,1,1] << [2,1,1] << [3,1,1] << [4,1,1] << [6,1,1]
+      hash[:nos] << [1,2,1] << [3,2,1] << [4,2,1] << [6,2,1]
+      hash[:vos] << [1,2,1] << [3,2,1] << [4,2,1] << [6,2,1]
+      hash[:tu] << [3,1,1]
+      # -te
+      hash[:tu] << [1,1,2] << [4,1,2] << [6,1,2]
+      # -se
+      hash[:se] << [4,1,3] << [6,1,3] << [4,2,3] << [6,2,3]
+
+
+      res = {}
+      hash.each do |key, values|
+        h = container
+        values.each do |casus, numerus, suffix|
+          h[ioe(casus, numerus)] << suffixes[suffix]
+        end
+        res[key] = h
+      end
+      res
+    end
+
+    def self.ioe(casus, numerus)
+      casus + (numerus == 1 ? -1 : 5)
+    end
+
+    def self.container
+      Hash.new { |h, k| h[k] = [] }
+    end
+
+    SUFFIXED_FORMS = compute_suffixed_forms
+  end
+end

data/lib/llt/form_builder/ppa_builder.rb

@@ -0,0 +1,20 @@
+module LLT
+  class PpaBuilder < DeclinableBuilder
+    builds_like_an :adjective
+    builds_with :modus, :tempus, :extension, :genus
+
+    has_extension "nt"
+    has_modus  t.participium
+    has_tempus t.praesens
+    has_genus  t.activum
+
+    look_up :thematic
+    validate :extension
+
+    def corrections(args)
+      if args[:ending] == "s"
+        args[:extension] = args[:extension].chop
+      end
+    end
+  end
+end

data/lib/llt/form_builder/ppp_builder.rb

@@ -0,0 +1,10 @@
+module LLT
+  class PppBuilder < DeclinableBuilder
+    builds_like_an :adjective
+    builds_with :modus, :tempus, :genus, :prefix
+
+    has_modus  t.participium
+    has_tempus t.perfectum
+    has_genus  t.passivum
+  end
+end

data/lib/llt/form_builder/praesens_builder.rb

@@ -0,0 +1,41 @@
+module LLT
+  class PraesensBuilder < VerbBuilder
+    endings_defined_through :inflection_class
+
+    look_up :thematic, :extension
+
+    def indices
+      { persona: persona_index,
+        numerus: [0, 3],
+        genus:   genus_index,
+        modus:   [0, 12, 24],
+        tempus:  [0, 36, 72]
+      }
+    end
+
+    def indices_by_ending(ending)
+      indices = super
+      if @deponens
+        PASSIVE_INDICES & indices
+      else
+        indices
+      end
+    end
+
+
+    def self.passive_indices
+      # build all possible indices, slice them according to their genus, select only even ones,
+      # i.e. the passive endings
+      (0..107).each_slice(6).each_with_index.each_with_object([]) { |(e, i), r| r << e if i.odd? }.flatten
+    end
+    PASSIVE_INDICES = passive_indices
+
+    def corrections(args)
+      if args[:inflection_class] == 1
+        if args[:tempus] == t.pr && (args[:modus] == t.con || args[:ending].match(/or?$/))
+          args[:stem] = args[:stem].chop
+        end
+      end
+    end
+  end
+end

data/lib/llt/form_builder/praesens_infinitivum_builder.rb

@@ -0,0 +1,9 @@
+module LLT
+  class PraesensInfinitivumBuilder < InfinitivumBuilder
+    endings_defined_through :inflection_class
+
+    def indices
+      super.merge(tempus: [0])
+    end
+  end
+end

data/lib/llt/form_builder/pronoun_builder.rb

@@ -0,0 +1,106 @@
+module LLT
+  class PronounBuilder < DeclinableBuilder
+    builds_like_an :adjective
+    lookup_class PronounSegments
+    look_up :stem, :particle, :prefixed_particle
+
+    endings_defined_through :inflection_class
+
+    validate :suffix # quibuscum etc.
+
+    def indices
+      { casus:   [0, 1, 2, 3, nil, 5],
+        numerus: [0, 6],
+        sexus:   [0, 12, 24] }
+    end
+
+    def compute
+      (regular_forms + forms_with_suffix).sort_by(&:index) # quibuscum etc.
+    end
+
+    def init_keys
+      %i{ type inflection_class }
+    end
+
+    def default_args
+      { inflection_class: @inflection_class }
+    end
+
+    def endings_lookup(ending, x)
+      if ending == "s" && is_or_idem
+        x.to_s =~ /^i?s$/
+      elsif ending == "ic"
+        x.to_s == "id"
+      else
+        super
+      end
+    end
+                         #quo quibus qua quibus quo quibus
+    INDICES_OF_CUM_WITH_QUI = [5, 11, 17, 23, 29, 35]
+    def forms_with_suffix
+      if @inflection_class == :qui
+        indices = INDICES_OF_CUM_WITH_QUI & @lookup_indices
+        indices.map { |i| [endings[i], i] }.map do |ending, i|
+          casus, numerus, sexus = casus_numerus_sexus_by_index(i)
+          ending = ending.to_s
+          new_form(ending: ending, casus: casus, numerus: numerus, sexus: sexus, index: i, suffix: "cum")
+        end.compact # for forms that don't make it through validation
+      else
+        []
+      end
+    end
+
+    def corrections(args)
+      if @options[:ending] == "ic"
+        keep_given_value(args, :ending)
+      end
+
+      super
+    end
+
+    # Allows i and e stem for specific forms like ii/ei.
+    # If such a form is detected return the validation,
+    # in every other case use the default rule.
+    def validation_rule(args, validator)
+      if is_or_idem
+        case validator
+        when :stem
+          c, n, s = %i{ casus numerus sexus }.map { |k| args[k] }
+
+          if n == 2 && ((c == 1 && s == :m) || (c == 3 || c == 6))
+            val_values = [args[validator], @options[validator]]
+            if val_values.all? { |stem| stem =~ /^[ei]$/ }
+              keep_given_value(args, validator)
+              # also keep the ending to catch is, iis and eis
+              keep_given_value(args, :ending)
+              return true # to prevent the super call
+            end
+          end
+        end
+      end
+
+      super
+    end
+
+    def is_or_idem
+      @inflection_class == :is || @inflection_class == :idem
+    end
+
+    pt = {
+           demonstrative_pronoun: %i{ hic is idem iste ipse ille },
+           relative_pronoun:      %i{ qui quicumque quisquis },
+           indefinite_pronoun:    %i{ aliqui quilibet quivis quis aliquis
+                                      quisquam quisque quisque_s quidam quinam
+                                      unusquisque unusquisque_s uterque quispiam },
+           interrogative_pronoun: %i{ uter }
+         }
+
+    PRON_TYPE = pt.each_with_object({}) do |(type, infl_classes), h|
+      infl_classes.each { |infl_cl| h[infl_cl] = type }
+    end
+
+    def form_class
+      constant_by_type(PRON_TYPE[@inflection_class], namespace: LLT::Form)
+    end
+  end
+end

data/lib/llt/form_builder/supinum_builder.rb

@@ -0,0 +1,23 @@
+module LLT
+  class SupinumBuilder < DeclinableBuilder
+    builds_with :modus
+    has_modus t.supinum
+
+    def index_of_ending(casus, numerus, sexus = nil)
+      case casus
+      when 3 then 0
+      when 4 then 1
+      when 6 then 2
+      end
+    end
+    alias :ioe :index_of_ending
+
+    def casus_numerus_sexus_by_index(index, sexus = nil)
+      case index
+      when  0 then [3, 1, :n]
+      when  1 then [4, 1, :n]
+      when  2 then [6, 1, :n]
+      end
+    end
+  end
+end

data/lib/llt/form_builder/verb_builder.rb

@@ -0,0 +1,37 @@
+module LLT
+  class VerbBuilder < FormBuilder
+    builds_with :impersonalium, :contraction, :prefix
+
+    form_class :verb
+
+    look_up :thematic, :extension
+
+    def persona_index
+      @impersonalium ? [nil, nil, 2] : [0, 1, 2]
+    end
+
+    def genus_index
+      @deponens ? [6] : [0, 6]
+    end
+
+    def regular_forms
+      endings.each_with_index.map do |ending, i|
+        next unless (@lookup_indices.include?(i) && ending) # nil values in verb endings are escaped
+        new_form_through_index(ending, i)
+      end.compact
+    end
+
+    def new_form_through_index(ending, i)
+      p, n, g, m, t = attributes_by_index(i)
+      new_form(ending: ending, persona: p, numerus: n, tempus: t, modus: m, genus: g, index: i)
+    end
+
+    def contraction
+      @options[:contraction]
+    end
+
+    def endings_namespace
+      super::Verb
+    end
+  end
+end

data/lib/llt/form_builder/version.rb

@@ -0,0 +1,5 @@
+module LLT
+  class FormBuilder
+    VERSION = "0.0.1"
+  end
+end