llt-constants 0.0.3

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 9c05c8a5de8d0cba8b834dbb4094662e4da4e396
+  data.tar.gz: a0aedcaf8bd474dbbfc5d1eb38ce98fcc9679489
+SHA512:
+  metadata.gz: 48b5071dcc3a79f0d351794d3f0735ca70d202eb37570131d1f85ccd048c43554404f8a7255106b87f0e007c9802b01ca473a86df0d28861cebad8fabe557fa6
+  data.tar.gz: 3a6d70376ac0344fe1407b3d19046f970a3e51f80c95dfe05d200ed94a0c2e27fafae857b202aa03a12a9225c7b6636ea320a7acbf7e7789ca4dbcce03883c11

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/.rspec

@@ -0,0 +1,2 @@
+--format documentation
+--color

data/.travis.yml

@@ -0,0 +1,6 @@
+language: ruby
+before_script:
+  - "export JRUBY_OPTS=--2.0"
+rvm:
+  - 2.0.0
+  - jruby-20mode

data/Gemfile

@@ -0,0 +1,5 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in llt-constants.gemspec
+gemspec
+gem 'coveralls', require: false

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 LFDM
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,52 @@
+# LLT::Constants
+
+[![Version](http://allthebadges.io/latin-language-toolkit/llt-constants/badge_fury.png)](http://allthebadges.io/latin-language-toolkit/llt-constants/badge_fury)
+[![Build Status](https://travis-ci.org/latin-language-toolkit/llt-constants.png?branch=master)](https://travis-ci.org/latin-language-toolkit/llt-constants)
+[![Dependencies](http://gemnasium.com/latin-language-toolkit/llt-constants.png)](http://allthebadges.io/latin-language-toolkit/llt-constants/gemnasium)
+[![Coverage](https://coveralls.io/repos/latin-language-toolkit/llt-constants/badge.png?branch=master)](https://coveralls.io/r/latin-language-toolkit/llt-constants?branch=master)
+[![Code Climate](https://codeclimate.com/github/latin-language-toolkit/llt-constants.png)](https://codeclimate.com/github/latin-language-toolkit/llt-constants)
+
+LLT::Constants contains Latin infixes, inflectional endings and Latin
+phonemes.
+
+
+List of contents:
+ * **noun endings** for all declension types (e.g. amic - *us*)
+ * **adjective endings** for all declension types (e.g. laet - *um*,
+fort - *is*)
+ * **adjective comparison signs** (e.g. alt - *ior* - es, alt - *issim* - us)
+ * **verb endings** for all types of conjugation and tenses and moods (active, passive, primary, secondary, imperative)
+ * **verb tempus infixes** (e.g. ama - *ba* - t)
+ * **Latin phonemes** and their 'linguistic values' (e.g. phoneme *d* is a
+dental)
+
+Metrical values (encoded in UTF-8) available.
+
+list to be continued
+
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'llt-constants'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install llt-constants
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1,8 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec) do |t|
+  t.rspec_opts = '-f d --color --tty'
+end
+
+task :default => :spec

data/lib/llt/constants.rb

@@ -0,0 +1,13 @@
+require "llt/constants/version"
+require "llt/constants/abbreviations"
+require "llt/constants/cardinals"
+require "llt/constants/conjunctions"
+require "llt/constants/markers"
+require "llt/constants/endings"
+require "llt/constants/phonology"
+require "llt/constants/personal_pronouns"
+require "llt/constants/prepositions"
+require "llt/constants/regexps"
+require "llt/constants/subjunctions"
+require "llt/constants/verb_endings"
+require "llt/constants/verb_markers"

data/lib/llt/constants/abbreviations.rb

@@ -0,0 +1,13 @@
+module LLT
+  module Constants
+    module Abbreviations
+      NAMES = %w{ A D C K L M N P Q S T App Ap Cn Mam M Ser Sex Sp Tib Ti }
+      NAMES_PIPED = NAMES.join('|')
+
+      DATES = %w{ a d Kal Non Id Ian Feb Mar Apr Mai Iun Iul Aug Sep Oct Nov Dec }
+      DATES_PIPED = DATES.join('|')
+
+      ALL_ABBRS_PIPED = "#{NAMES_PIPED}|#{DATES_PIPED}"
+    end
+  end
+end

data/lib/llt/constants/cardinals.rb

@@ -0,0 +1,45 @@
+module LLT
+  module Constants
+    CARDINALS = {
+      "duo"           => [[2, 1, :m], [2, 4, :m], [2, 1, :n], [2, 4, :n]],
+      "duorum"        => [[2, 2, :m], [2, 2, :n]],
+      "duobus"        => [[2, 3, :m], [2, 6, :m], [2, 3, :n], [2, 6, :n]],
+      "duos"          => [[2, 4, :m]],
+      "duae"          => [[2, 1, :f]],
+      "duarum"        => [[2, 2, :f]],
+      "duabus"        => [[2, 3, :f], [2, 6, :f]],
+      "duas"          => [[2, 4, :f]],
+      "ambo"          => [[2, 1, :m], [2, 4, :m], [2, 1, :n], [2, 4, :n]],
+      "amborum"       => [[2, 2, :m], [2, 2, :n]],
+      "ambobus"       => [[2, 3, :m], [2, 6, :m], [2, 3, :n], [2, 6, :n]],
+      "ambos"         => [[2, 4, :m]],
+      "ambae"         => [[2, 1, :f]],
+      "ambarum"       => [[2, 2, :f]],
+      "ambabus"       => [[2, 3, :f], [2, 6, :f]],
+      "ambas"         => [[2, 4, :f]],
+      "tres"          => [[3, 1, :m], [3, 1, :f], [3, 4, :m], [3, 4, :f]],
+      "trium"         => [[3, 2, :m], [3, 2, :f], [3, 2, :n]],
+      "tribus"        => [[3, 3, :m], [3, 3, :f], [3, 3, :n], [3, 6, :m], [3, 6, :f], [3, 6, :n]],
+      "tria"          => [[3, 1, :n], [3, 4, :n]],
+      "milia"         => [[1000, 1, nil], [1000, 4, nil]],
+      "milium"        => [[1000, 2, nil]],
+      "milibus"       => [[1000, 3, nil], [1000, 6, nil]],
+      "quattuor"      => [[4, nil, nil]],
+      "quinque"       => [[5, nil, nil]],
+      "sex"           => [[6, nil, nil]],
+      "septem"        => [[7, nil, nil]],
+      "octo"          => [[8, nil, nil]],
+      "novem"         => [[9, nil, nil]],
+      "decem"         => [[10, nil, nil]],
+      "undecim"       => [[11, nil, nil]],
+      "duodecim"      => [[12, nil, nil]],
+      "tredecim"      => [[13, nil, nil]],
+      "quattuordecim" => [[14, nil, nil]],
+      "quindecim"     => [[15, nil, nil]],
+      "sedecim"       => [[16, nil, nil]],
+      "septendecim"   => [[17, nil, nil]],
+      "mille"         => [[1000, nil, nil]],
+      "duodeviginti"  => [[18, nil, nil]]
+    }
+  end
+end

data/lib/llt/constants/conjunctions.rb

@@ -0,0 +1,27 @@
+module LLT
+  module Constants
+    # word => homophonous_forms?
+
+    CONJUNCTIONS = {"et"     => false,
+                    "-que"   => false,
+                    "atque"  => false,
+                    "neque"  => false,
+                    "nec"    => false,
+                    "aut"    => false,
+                    "vel"    => false,
+                    "sive"   => false,
+                    "seu"    => false,
+                    "-ve"    => false,
+                    "sed"    => false,
+                    "verum"  => true,
+                    "at"     => false,
+                    "attamen"=> false,
+                    "tamen"  => false,
+                    "velut"  => false,
+                    "ac"     => false,
+                    "com"    => false,
+                    "an"     => false,
+                    "ergo"   => false,
+                    "atqui"  => false}
+  end
+end

data/lib/llt/constants/endings.rb

@@ -0,0 +1,338 @@
+require 'llt/constants/verb_endings'
+
+module LLT
+  module Constants
+    module Endings
+
+      class Noun
+        A  = [:a, :ae, :ae, :am, :a, :a, :ae, :arum, :is, :as, :ae, :is]
+        O  = [:us, :i, :o, :um, :e, :o, :i, :orum, :is, :os, :i, :is]
+        ON = [:um, :i, :o, :um, :um, :o, :a, :orum, :is, :a, :a, :is]
+        E  = [:es, :ei, :ei, :em, :es, :e, :es, :erum, :ebus, :es, :es, :ebus]
+        U  = [:us, :us, :ui, :um, :us, :u, :us, :uum, :ibus, :us, :us, :ibus]
+        UN = [:u, :us, :u, :u, :u, :u, :ua, :uum, :ibus, :ua, :ua, :ibus]
+        C  = [nil, :is, :i, :em, nil, :e, :es, :um, :ibus, :es, :es, :ibus]
+        CN = [nil, :is, :i, nil, nil, :e, :a, :um, :ibus, :a, :a, :ibus]
+        M  = [nil, :is, :i, :em, nil, :e, :es, :ium, :ibus, :es, :es, :ibus]
+        I  = [:is, :is, :i, :im, :is, :i, :es, :ium, :ibus, :es, :es, :ibus]
+        IN = [:e, :is, :i, :e, :e, :i, :ia, :ium, :ibus, :ia, :ia, :ibus]
+        IRREGULARS = [nil, nil, nil, nil, nil, nil, nil, nil, :bus, nil, nil, :bus]
+
+        class Metrical < Noun
+          A  = [:ă, :ae, :ae, :ăm, :ă, :ā, :ae, :ārŭm, :īs, :ās, :ae, :īs]
+          O  = [:ŭs, :ī, :ō, :ŭm, :ĕ, :ō, :ī, :ōrŭm, :īs, :ōs, :ī, :īs]
+          ON = [:ŭm, :ī, :ō, :ŭm, :ŭm, :ō, :ă, :ōrŭm, :īs, :ă, :ă, :īs]
+          #attention: if final sound of stem is vowel 2sg and 3sg e is long, else short: see diēī but rĕī
+          EL = [:ēs, :ēī, :ēī, :ĕm, :ēs, :ē, :ēs, :ērŭm, :ēbŭs, :ēs, :ēs, :ēbŭs]
+          ES = [:ēs, :ĕī, :ĕī, :ĕm, :ēs, :ē, :ēs, :ērŭm, :ēbŭs, :ēs, :ēs, :ēbŭs]
+          U  = [:ŭs, :ūs, :ŭī, :ŭm, :ŭs, :ū, :ūs, :ŭŭm, :ĭbŭs, :ūs, :ūs, :ĭbŭs]
+          UN = [:ū, :ūs, :ū, :ū, :ū, :ū, :ŭă, :ŭŭm, :ĭbŭs, :ŭă, :ŭă, :ĭbŭs]
+          C  = [nil, :ĭs, :ī, :ĕm, nil, :ĕ, :ēs, :ŭm, :ĭbŭs, :ēs, :ēs, :ĭbŭs]
+          CN = [nil, :ĭs, :ī, nil, nil, :ĕ, :ă, :ŭm, :ĭbŭs, :ă, :ă, :ĭbŭs]
+          M  = [nil, :ĭs, :ī, :ĕm, nil, :ĕ, :ēs, :ĭŭm, :ĭbŭs, :ēs, :ēs, :ĭbŭs]
+          I  = [:ĭs, :ĭs, :ī, :ĭm, :ĭs, :ī, :ēs, :ĭŭm, :ĭbŭs, :ēs, :ēs, :ĭbŭs]
+          IN = [:ĕ, :ĭs, :ī, :ĕ, :ĕ, :ī, :ĭă, :ĭŭm, :ĭbŭs, :ĭă, :ĭă, :ĭbŭs]
+          IRREGULARS = [nil, nil, nil, nil, nil, nil, nil, nil, :bŭs, nil, nil, :bŭs]
+        end
+
+        def self.get_ending_for_inflection_class(inflection_class)
+          case inflection_class
+          when 1  then  :A
+          when 2  then  :O
+          when 3  then  :C
+          when 32 then  :I
+          when 33 then  :M
+          when 4  then  :U
+          when 5  then  :E
+          end
+        end
+
+        def self.get_ending_for_inflection_class_as_neutrum(inflection_class)
+          case inflection_class
+          when 2  then :ON
+          when 3  then :CN
+          when 4  then :UN
+          when 31 then :IN
+          end
+        end
+
+        def self.get(inflection_class, sexus = nil)
+          ending = if sexus == :n
+                     get_ending_for_inflection_class_as_neutrum(inflection_class)
+                   else
+                     get_ending_for_inflection_class(inflection_class)
+                   end
+          const_get(ending)
+        end
+      end
+
+      class Adjective
+        A = Noun::A
+        O = Noun::O
+        ON = Noun::ON
+        CMF = Noun::C
+        CN  = Noun::CN
+        MMF = [nil, :is, :i, :em, nil, :i, :es, :ium, :ibus, :es, :es, :ibus]
+        MN  = [nil, :is, :i, nil, nil, :i, :ia, :ium, :ibus, :ia, :ia, :ibus]
+        PRM = [:us, :ius, :i, :um, :e, :o, :i, :orum, :is, :os, :i, :is]
+        PRF = [:a, :ius, :i, :am, :a, :a, :ae, :arum, :is, :as, :ae, :is]
+        PRN = [:um, :ius, :i, :um, :um, :o, :a, :orum, :is, :a, :a, :is]
+
+        AO = Noun::O + Noun::A + Noun::ON
+        MIXED = MMF + MMF + MN
+        MIXED_1 = MIXED
+        MIXED_2 = MIXED.each_with_index.map do |el, i|
+          case i.to_s
+          when /^(0|4|12|16)$/ then :is
+          when /^(24|27|28)$/  then :e
+          else el
+          end
+        end
+        MIXED_3 = MIXED_2.each_with_index.map do |el, i|
+          case i.to_s
+          when /^(0|4)$/ then nil
+          else el
+          end
+        end
+        CONSONANTIC = CMF + CMF + CN
+        PRONOMINAL = PRM + PRF + PRN
+
+        class Metrical < Adjective
+          A = Noun::Metrical::A
+          O = Noun::Metrical::O
+          ON = Noun::Metrical::ON
+          CMF = Noun::Metrical::C
+          CN  = Noun::Metrical::CN
+          MMF = [nil, :ĭs, :ī, :ĕm, nil, :ī, :ēs, :ĭŭm, :ĭbŭs, :ēs, :ēs, :ĭbŭs]
+          MN  = [nil, :ĭs, :ī, nil, nil, :ī, :ĭa, :ĭŭm, :ĭbŭs, :ĭa, :ĭa, :ĭbŭs]
+          PRM = [:ŭs, :īŭs, :ī, :ŭm, :ĕ, :ō, :ī, :ōrŭm, :īs, :ōs, :ī, :īs]
+          PRF = [:ă, :īŭs, :ī, :ăm, :ă, :ā, :ae, :ārum, :īs, :ās, :ae, :īs]
+          PRN = [:ŭm, :īŭs, :ī, :ŭm, :ŭm, :ō, :ă, :ōrŭm, :īs, :ă, :ă, :īs]
+
+          AO = Noun::Metrical::O + Noun::Metrical::A + Noun::Metrical::ON
+          MIXED = MMF + MMF + MN
+          MIXED_1 = MIXED
+          MIXED_2 = MIXED.each_with_index.map do |el, i|
+            case i.to_s
+            when /^(0|4|12|16)$/ then :ĭs
+            when /^(24|27|28)$/  then :ĕ
+            else el
+            end
+          end
+          MIXED_3 = MIXED_2.each_with_index.map do |el, i|
+            case i.to_s
+            when /^(0|4)$/ then nil
+            else el
+            end
+          end
+          CONSONANTIC = CMF + CMF + CN
+          PRONOMINAL = PRM + PRF + PRN
+        end
+
+        def self.get(inflection_class, number_of_endings, comparatio = :positivus)
+          const_get(case comparatio
+                      when :comparativus
+                        :CONSONANTIC
+                      when :superlativus
+                        :AO
+                      else # positivus - or nil if someone has forgotten to provide a value
+                        case [inflection_class, number_of_endings]
+                        when [1, 3] then :AO
+                        when [3, 1] then :MIXED_1
+                        when [3, 2] then :MIXED_2
+                        when [3, 3] then :MIXED_3
+                        when [5, 3] then :PRONOMINAL
+                        end
+                      end)
+        end
+      end
+
+      class Adverb
+        E    = "e"
+        ITER = "iter"
+        TER  = "ter"
+        ER   = "er"
+        EMPTY = ""
+
+        def self.get(inflection_class, stem, comparatio)
+          const_get(case comparatio
+                    when :comparativus then :EMPTY
+                    when :superlativus then :E
+                    else positivus_ending(inflection_class, stem)
+                    end)
+        end
+
+        def self.positivus_ending(inflection_class, stem)
+          if inflection_class == 3
+            case stem
+            when /nt$/     then :ER
+            when /^facil$/ then :E
+            else :ITER
+            # TER for audacter and sollerter, cf. RH 50
+            end
+          else
+            :E
+          end
+        end
+      end
+
+      class Pronoun
+        HIC  = [:i, :ius, :i, :un, nil, :o, :i, :orum, :is, :os, nil, :is]
+        HAEC = [:ae, :ius, :i, :an, nil, :a, :ae, :arum, :is, :as, nil, :is]
+        HOC  = [:o, :ius, :i, :o, nil, :o, :ae, :orum, :is, :ae, nil, :is]
+
+        #ille + iste
+        ILLE  = [:e, :ius, :i, :um, nil, :o, :i, :orum, :is, :os, nil, :is]
+        ILLA  = [:a, :ius, :i, :am, nil, :a, :ae, :arum, :is, :as, nil, :is]
+        ILLUD = [:ud, :ius, :i, :ud, nil, :o, :a, :orum, :is, :a, nil, :is]
+
+        #ipse
+        IPSE = ILLE
+        IPSA = ILLA
+        IPSUM = [:um, :ius, :i, :um, nil, :o, :a, :orum, :is, :a, nil, :is]
+
+        #is
+        IS  = [:s, :ius, :i, :um, nil, :o, :i, :orum, :is, :os, nil, :is]
+        EA  = ILLA
+        ID  = [:d, :ius, :i, :d, nil, :o, :a, :orum, :is, :a, nil, :is]
+
+        #idem
+        IDEM   = [nil, :ius, :i, :un, nil, :o, :i, :orun, :is, :os, nil, :is]
+        EADEM  = [:a, :ius, :i, :an, nil, :a, :ae, :arun, :is, :as, nil, :is]
+        IDEM_N = [nil, :ius, :i, nil, nil, :o, :a, :orun, :is, :a, nil, :is]
+
+        #qui
+        QUI  = [:i, :ius, :i, :em, nil, :o, :i, :orum, :ibus, :os, nil, :ibus]
+        QUAE = [:ae, :ius, :i, :am, nil, :a, :ae, :arum, :ibus, :as, nil, :ibus]
+        QUOD = [:od, :ius, :i, :od, nil, :o, :ae, :orum, :ibus, :ae, nil, :ibus]
+        QUA  = [:a, :ius, :i, :am, nil, :a, :ae, :arum, :ibus, :as, nil, :ibus]
+
+        #quidam - adj
+        QUIDAM  = [:i, :ius, :i, :en, nil, :o, :i, :orun, :ibus, :os, nil, :ibus]
+        QUAEDAM = [:ae, :ius, :i, :an, nil, :a, :ae, :arun, :ibus, :as, nil, :ibus]
+        QUODDAM = [:od, :ius, :i, :od, nil, :o, :ae, :orun, :ibus, :ae, nil, :ibus]
+
+        #quis
+        QUIS = [:is, :ius, :i, :em, nil, :o, :i, :orum, :ibus, :os, nil, :ibus]
+        #QUAE
+        QUID = [:id, :ius, :i, :id, nil, :o, :ae, :orum, :ibus, :ae, nil, :ibus]
+
+        #uter + uterque
+        UTER = [nil, :ius, :i, :um, nil, :o, :i, :orum, :is, :os, nil, :is]
+        UTRA = [:a, :ius, :i, :am, nil, :a, :ae, :arum, :is, :as, nil, :is]
+        UTRUM = [:um, :ius, :i, :um, nil, :o, :a, :orum, :is, :a, nil, :is]
+
+        def self.get(pronoun_type)
+          qui_adj = QUI + QUAE + QUOD
+          quis_adj = QUIS + QUAE + QUOD
+          qui_subst = QUIS + QUIS + QUID
+          uter_adj = UTER + UTRA + UTRUM
+          ille_iste = ILLE + ILLA + ILLUD
+          case pronoun_type
+          when :aliqui        then QUI + QUA + QUOD
+          when :aliquis       then qui_subst
+          when :hic           then HIC + HAEC + HOC
+          when :idem          then IDEM + EADEM + IDEM_N
+          when :ille          then ille_iste
+          when :ipse          then IPSE + IPSA + IPSUM
+          when :is            then IS + EA + ID
+          when :iste          then ille_iste
+          when :qui           then qui_adj
+          when :quicumque     then qui_adj
+          when :quidam        then QUIDAM + QUAEDAM + QUODDAM
+          when :quilibet      then qui_adj
+          when :quinam        then qui_adj
+          when :quis          then qui_subst
+          when :quisquam      then qui_subst
+          when :quispiam      then qui_subst
+          when :quisque       then quis_adj
+          when :quisque_s     then qui_subst
+          when :quisquis      then qui_subst
+          when :quivis        then qui_adj
+          when :unusquisque   then quis_adj
+          when :unusquisque_s then qui_subst
+          when :uter          then uter_adj
+          when :uterque       then uter_adj
+         #when :quilibet      then QUI + QUAE + QUID
+         #when :quivis        then QUI + QUAE + QUID
+          end
+        end
+      end
+      class PersonalPronoun
+        nils = [nil] * 6
+        EGO = ["ego", "mei", "mihi", "me", nil, "me"  ]
+        TU  = ["tu", "tui", "tibi", "te", nil, "te" ]
+        SE  = [nil, "sui", "sibi", "se", nil, "se"] * 2
+        NOS = nils + ["nos", "nostri", "nobis", "nos", nil, "nobis"] # handle nostrum and vestrum in the builder
+        VOS = nils + ["vos", "vestri", "vobis", "vos", nil, "vobis"]
+
+        def self.get(inflection_class)
+          const_get(inflection_class.upcase)
+        end
+      end
+
+
+      class Ppa
+        MMFE = [:s, :is, :i, :em, :s, :e, :es, :ium, :ibus, :es, :es, :ibus]
+        MNE  = [:s, :is, :i, :s, :s, :e, :ia, :ium, :ibus, :ia, :ia, :ibus]
+
+        def self.get(*args)
+          MMFE + MMFE + MNE
+        end
+
+        class Metrical < Ppa
+          MMFE = [:s, :ĭs, :ī, :ĕm, :s, :ĕ, :ēs, :ĭŭm, :ĭbŭs, :ēs, :ēs, :ĭbŭs]
+          MNE  = [:s, :ĭs, :ī, :s, :s, :ĕ, :ĭa, :ĭŭm, :ĭbŭs, :ĭa, :ĭa, :ĭbŭs]
+        end
+      end
+
+      class AoVerbalNoun
+        AO = Adjective::AO
+
+        def self.get(*args)
+          AO
+        end
+
+        class Metrical < AoVerbalNoun
+          AO = Adjective::Metrical::AO
+        end
+      end
+
+      class Gerundive < AoVerbalNoun
+        class Metrical < AoVerbalNoun; end
+      end
+
+      class Ppp < AoVerbalNoun
+        class Metrical < AoVerbalNoun; end
+      end
+
+      class Fp < AoVerbalNoun
+        class Metrical < AoVerbalNoun; end
+      end
+
+      class Gerund
+        GERUND = %i{ i o um o }
+
+        def self.get(*args)
+          GERUND
+        end
+
+        class Metrical < Gerund
+          GERUND  = [:ī, :ō, :ŭm, :ō]
+        end
+      end
+
+      class Supinum
+        SUPINUM = %i{ u um u }
+
+        def self.get(*args)
+          SUPINUM
+        end
+
+        class Metrical < Supinum
+          SUPINUM = %i{ ū ŭm ū }
+        end
+      end
+    end
+  end
+end