llt-form_builder 0.0.1

data/lib/llt/form_builder/adverb_builder.rb

@@ -0,0 +1,25 @@
+module LLT
+  class AdverbBuilder < AdjectiveBuilder
+    endings_defined_through :inflection_class, :stem, :comparatio
+    validate :ending, :comparison_sign
+
+    def initialize(stem)
+      extract_normalized_args!(stem)
+      @options = stem[:options] || {}
+      @validate = @options.any?
+      downcase_all_stems
+    end
+
+    def compute
+      # endings is not an array in this case, just a plain string
+      new_form(ending: endings)
+    end
+
+    def comparativus_extraction(stem, args)
+      stem.match(/(#{marker(:IUS)})$/)
+      new_stem = stem.chomp($1) # do not use chomp! as other forms will get severed
+      raise "No comparison sign for comparative present" if new_stem == stem
+      [new_stem, $1]
+    end
+  end
+end

data/lib/llt/form_builder/declinable_builder.rb

@@ -0,0 +1,164 @@
+module LLT
+  class DeclinableBuilder < FormBuilder
+    attr_reader :sexus, :comparatio
+
+    def initialize(stem)
+      super
+      @irregular_forms = extended_special_forms(irregulars_with_nominative(stem))
+      @additional_forms = extended_special_forms(stem[:additional_forms])
+    end
+
+    def compute
+      with_replacements(regular_forms) + additional_forms
+    end
+
+    def indices
+      { casus:   [0, 1, 2, 3, 4, 5],
+        numerus: [0, 6],
+        sexus:   [0, 12, 24] }
+    end
+
+    def index_of_ending(casus, numerus, sexus = nil)
+      casus + (numerus == 1 ? -1 : 5)
+    end
+    alias :ioe :index_of_ending
+
+    def casus_numerus_sexus_by_index(index, sexus = @sexus)
+      # superflous method - could be solved through
+      # attributes_by_index, however this is noticably faster and thus stays
+
+      if index < 6
+        [index + 1, 1, sexus]
+      else
+        [index - 5, 2, sexus]
+      end
+    end
+
+    def regular_forms
+      endings.each_with_index.map do |ending, i|
+        next unless @lookup_indices.include?(i)
+        new_form_through_index(ending, i)
+      end.compact # compact because of next steps
+    end
+
+    def new_form_through_index(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)
+    end
+
+    def extended_special_forms(specials)
+      specials = specials || []
+      specials + specials.each_with_object([]) do |(string, *attr), arr|
+        new_attributes(*attr).each { |new_attr| arr << [string,  *new_attr] }
+      end
+    end
+
+    def irregulars_with_nominative(stem)
+      i = if @nom
+            irreg = nominatives
+            if irregs = stem[:irregular_forms]
+              irregs + irreg
+            else
+              irreg
+            end
+          else
+            stem[:irregular_forms] || []
+          end
+
+      i + proper_vocative
+    end
+
+    def new_attributes(*attrs)
+      casus, numerus, sexus = *attrs
+      sexus = sexus || @sexus
+      new_attrs = []
+
+      if ioe(casus, numerus) == 0
+        new_attrs << [5, 1, sexus] unless regular_o_declension? || pronominal_declension?
+        if sexus == :n
+          new_attrs << [4, 1, sexus]
+        end
+      end
+
+      new_attrs
+    end
+
+    def proper_vocative
+      o_declension_on_ius? ? [[@stem, 5, 1]] : []
+    end
+
+    def regular_o_declension?
+      @inflection_class == 2 && @nom.to_s =~ /us$/ # to_s because it might be nil
+    end
+
+    def pronominal_declension?
+    end
+
+    def o_declension_on_ius?
+      @inflection_class == 2 && @stem.end_with?("i") && @sexus == :m # is there a neutrum like that?
+    end
+
+    def additional_forms
+      @additional_forms.map do |string, *attrs|
+        casus, numerus, sexus = *attrs
+        i = ioe(casus, numerus, sexus)
+        if @lookup_indices.include?(i)
+          new_special_form(string: string, casus: casus, numerus: numerus, sexus: sexus, index: i)
+        end
+      end.compact
+    end
+
+    def with_replacements(regular_forms)
+      @irregular_forms.each do |string, *attrs|
+        casus, numerus, sexus = *attrs
+        i = ioe(casus, numerus, sexus)
+        if @lookup_indices.include?(i)
+          next unless ri = regular_forms.find_index { |f| f.index == i }
+          regular_forms[ri] = new_special_form(string: string, casus: casus, numerus: numerus, sexus: sexus, index: i)
+        end
+      end
+      regular_forms
+    end
+
+    def new_special_form(args)
+      args = args.merge(default_args)
+      string = args[:string]
+      i = index_of_ending(args[:casus], args[:numerus], args[:sexus])
+      ending = special_ending(string, i).to_s
+      form_class.new(args.merge(stem: string.chomp(ending), ending: ending))
+    end
+
+    def special_ending(word, index)
+      endings_path.constants.each do |const|
+        ending = endings_path.const_get(const)[index]
+        return ending if word.end_with?(ending.to_s)
+      end
+      nil
+    end
+
+    def er_nominative_possible?
+      # only Noun and Adjective override this, as they can have a nominative on er.
+      # other Declinables like Gerundives don't need this
+      false
+    end
+
+    # this is a slight hack to handle O Declension on er.
+    # the Endings constants for noun has US at its first position,
+    # this guarantees a match even when the ending is empty (which means that the passsed along
+    # nominative value shall be used.
+    # similar conditions will need to be written for A decl on as.
+    def endings_lookup(ending, x)
+      if ending.empty?
+        if er_nominative_possible?
+          # not sure if this needs further safeties - asking explicitly for er?
+          # well it does! 2013-10-08 - fili!
+          return x.to_s =~ /^(us|e)$/
+        elsif o_declension_on_ius?
+          return x.to_s =~ /^e$/
+        end
+      end
+      super
+    end
+  end
+end

data/lib/llt/form_builder/ethnic_builder.rb

@@ -0,0 +1,17 @@
+module LLT
+  class EthnicBuilder < DeclinableBuilder
+    builds_like_an :adjective
+    uses_endings_of :adjective
+
+    endings_defined_through :inflection_class, :number_of_endings
+
+    def initialize(stem)
+      @number_of_endings = (stem[:inflection_class] == 1 ? 3 : 2)
+      super
+    end
+
+    def stays_capitalized
+      true
+    end
+  end
+end

data/lib/llt/form_builder/fp_builder.rb

@@ -0,0 +1,13 @@
+module LLT
+  class FpBuilder < DeclinableBuilder
+    builds_like_an :adjective
+    builds_with :tempus, :modus, :genus, :extension
+
+    validate :extension
+
+    has_modus  t.participium
+    has_genus  t.activum
+    has_tempus t.futurum
+    has_extension "ur"
+  end
+end

data/lib/llt/form_builder/gerund_builder.rb

@@ -0,0 +1,37 @@
+module LLT
+  class GerundBuilder < DeclinableBuilder
+    builds_with :modus, :extension, :prefix
+
+    has_extension "nd"
+    has_modus t.gerundium
+
+    look_up :thematic
+
+    validate :extension
+
+    def indices
+      { casus:   [nil, 0, 1, 2, nil, 3],
+        numerus: [0],
+        sexus:   [0] }
+    end
+
+    def index_of_ending(casus, numerus, sexus = nil)
+      case casus
+      when  2 then 0
+      when  3 then 1
+      when  4 then 2
+      when  6 then 3
+      end
+    end
+    alias :ioe :index_of_ending
+
+    def casus_numerus_sexus_by_index(index, sexus = nil)
+      case index
+      when 0 then [2, 1, :n]
+      when 1 then [3, 1, :n]
+      when 2 then [4, 1, :n]
+      when 3 then [6, 1, :n]
+      end
+    end
+  end
+end

data/lib/llt/form_builder/gerundive_builder.rb

@@ -0,0 +1,24 @@
+module LLT
+  class GerundiveBuilder < DeclinableBuilder
+    builds_like_an :adjective
+    builds_with :modus, :extension, :prefix
+
+    has_extension "nd"
+    has_modus t.gerundivum
+
+    look_up :thematic
+
+    validate :extension
+
+    # Allows archaic forms like audiundi
+    def validation_rule(args, validator)
+      if args[:inflection_class] == 4 && validator == :thematic
+        if args[validator] == "e" && @options[validator] =~ /^[eu]$/
+          keep_given_value(args, validator, :archaic)
+        end
+      else
+        super
+      end
+    end
+  end
+end

data/lib/llt/form_builder/helpers/adjective_like_building.rb

@@ -0,0 +1,29 @@
+module LLT
+  class FormBuilder
+    module AdjectiveLikeBuilding
+      def casus_numerus_sexus_by_index(i, sexus = nil)
+        # superflous method - code be solved through attributes_by_index,
+        # however this is noticably faster and thus stays
+
+        mod, sexus = case i
+                     when  0..11 then [ 0, :m]
+                     when 12..23 then [12, :f]
+                     else             [24, :n]
+                     end
+        i -= mod
+
+        super(i, sexus)
+      end
+
+      def index_of_ending(casus, numerus, sexus = nil)
+        i = super
+        case sexus
+        when :f then i + 12
+        when :n then i + 24
+        else i
+        end
+      end
+      alias :ioe :index_of_ending
+    end
+  end
+end

data/lib/llt/form_builder/helpers/pronoun_segments.rb

@@ -0,0 +1,226 @@
+require 'llt/helpers'
+require 'llt/constants/particles'
+
+module LLT
+  class FormBuilder
+    class PronounSegments
+      extend Helpers::Constantize
+      include Helpers::Initialize
+
+      class << self
+        def get(request, args)
+          cl = constant_by_type(args[:inflection_class], prefix: "pronoun", namespace: self)
+          cl.new(args).send(request)
+        end
+
+        def particle(arg)
+          define_method(:particle) { arg }
+        end
+
+        def stem(arg)
+          define_method(:stem) { arg }
+        end
+
+        def prefixed_particle(arg)
+          define_method(:prefixed_particle) { arg }
+        end
+
+        def n(const)
+          LLT::Constants::Particles.const_get(const)
+        end
+      end
+
+      def initialize(args)
+        extract_args!(args)
+      end
+
+      def init_keys
+        %i{ casus numerus sexus }
+      end
+
+      def n(const)
+        self.class.n(const)
+      end
+
+      def particle
+        ""
+      end
+
+      def prefixed_particle
+        ""
+      end
+
+      class PronounHic < PronounSegments
+        def particle
+          if (@numerus == 1 && @casus != 2) || (@sexus == :n && @numerus == 2 && (@casus == 1 || @casus == 4))
+            n(:C)
+          else
+            ""
+          end
+        end
+
+        def stem
+          if @numerus == 1 && (@casus == 2 || @casus == 3)
+            "hu"
+          else
+            "h"
+          end
+        end
+      end
+
+      class PronounIlle < PronounSegments
+        stem "ill"
+      end
+
+      class PronounIpse < PronounSegments
+        stem "ips"
+      end
+
+      class PronounIste < PronounSegments
+        stem "ist"
+      end
+
+      class PronounIs < PronounSegments
+        def stem
+          if @numerus == 1 && ((@casus == 1 && (@sexus == :m || @sexus == :n)) || (@casus == 4 && @sexus == :n)) || @numerus == 2 && @casus == 1 && @sexus == :m
+            "i"
+          else
+            "e"
+          end
+        end
+      end
+
+      class PronounQui < PronounSegments
+        def stem
+          if cuius_and_cui
+            "cu"
+          else
+            "qu"
+          end
+        end
+
+        def cuius_and_cui
+          @numerus == 1 && (@casus == 2 || @casus == 3)
+        end
+      end
+
+      class PronounIs < PronounSegments
+        def stem
+          if @numerus == 1 && ((@casus == 1 && (@sexus == :m || @sexus == :n)) || (@casus == 4 && @sexus == :n)) || @numerus == 2 && @casus == 1 && @sexus == :m
+            "i"
+          else
+            "e"
+          end
+        end
+      end
+
+      class PronounIdem < PronounIs
+        particle n(:DEM)
+      end
+
+      class PronounQui < PronounSegments
+        def stem
+          if cuius_and_cui
+            "cu"
+          else
+            "qu"
+          end
+        end
+
+        def cuius_and_cui
+          @numerus == 1 && (@casus == 2 || @casus == 3)
+        end
+      end
+
+      PronounQuis = PronounQui
+
+      class PronounQuidam < PronounQui
+        particle n(:DAM)
+      end
+
+      class PronounQuicumque < PronounQui
+        particle n(:CUMQUE)
+      end
+
+      class PronounQuinam < PronounQui
+        particle n(:NAM)
+      end
+
+      class PronounQuispiam < PronounQui
+        particle n(:PIAM)
+      end
+
+      class PronounQuilibet < PronounQui
+        particle n(:LIBET)
+      end
+
+      class PronounQuivis < PronounQui
+        particle n(:VIS)
+      end
+
+      class PronounQuisqueS < PronounQui
+        particle n(:QUE)
+      end
+      PronounQuisque = PronounQuisqueS
+
+      class PronounQuisquam < PronounQui
+        particle n(:QUAM)
+      end
+
+      class PronounUnusquisque < PronounQui
+        particle n(:QUE)
+
+        def prefixed_particle
+          opts = { casus: @casus, numerus: @numerus, sexus: @sexus, validate: true }
+          args = { type: :adjective, stem: "un", inflection_class: 5,
+                   noe: 3, comparatio: :positivus, options: opts }
+          FormBuilder.build(args).first.to_s
+        end
+      end
+      class PronounUnusquisqueS < PronounUnusquisque
+        def prefixed_particle
+          # unaquisque does not exist - unusquisque is for m and f
+          if @casus == 1 && @numerus == 1 && @sexus != :n
+            "unus"
+          else
+            super
+          end
+        end
+      end
+
+      class PronounQuisquis < PronounQui
+        def init_keys
+          super << :ending
+        end
+
+        def particle
+          stem + @ending
+        end
+      end
+
+      class PronounAliqui < PronounQui
+        prefixed_particle n(:ALI)
+      end
+      PronounAliquis = PronounAliqui
+
+      class PronounUter < PronounSegments
+        def stem
+          if uter
+            "uter"
+          else
+            "utr"
+          end
+        end
+
+        def uter
+          @casus == 1 && @numerus == 1 && @sexus == :m
+        end
+      end
+
+      class PronounUterque < PronounUter
+        particle n(:QUE)
+      end
+
+    end
+  end
+end