latinverb 0.9.2 → 0.9.3

data/lib/linguistics/latin/verb/phonographia.rb

@@ -1,7 +1,7 @@
 # encoding: UTF-8
 
-module Linguistics 
-  module Latin 
+module Linguistics
+  module Latin
     ##
     #
     # The Phonographia module handles the phonography of written Latin:  how
@@ -17,7 +17,7 @@ module Linguistics
     # phonology, must be made to bear a short sound in the ultimate vowel.
     # This state is _phonographically_ notes as "amat."  This module
     # implements the appropriate rules for proper phonetic compliance.
-    # 
+    #
     ##
     module Phonographia
       class << self
@@ -49,61 +49,61 @@ module Linguistics
        # fix_macrons(cāīō)  #=> caiō  ( Rule 1, Rule 2 )
        #
        ##
-       def fix_macrons(s)
-         raise if s.nil?
-         return "" if s.empty?
-         macron_table = {"\xc4\x81" => 'a', 
-                         "\xc4\x93" => 'e',
-                         "\xc4\xab" => 'i',
-                         "\xc5\x8d" => 'o',
-                         "\xc5\xab" => 'u',
-                         "\xc4\x80" => 'A',
-                         "\xc4\x92" => 'E',
-                         "\xc4\xaa" => 'I',
-                         "\xc5\x8c" => 'O',
-                         "\xc5\xaa" => 'U',
-                                "ā" => 'a',
-                                "ē" => 'e',
-                                "ī" => 'i',
-                                "ō" => 'o',
-                                "ū" => 'u',
-                                "Ā" => 'A',
-                                "Ē" => 'E',
-                                "Ī" => 'I',
-                                "Ō" => 'O',
-                                "Ū" => 'U',
-                        }
+        def fix_macrons(s)
+          raise if s.nil?
+          return "" if s.empty?
+          macron_table = {"\xc4\x81" => 'a',
+                          "\xc4\x93" => 'e',
+                          "\xc4\xab" => 'i',
+                          "\xc5\x8d" => 'o',
+                          "\xc5\xab" => 'u',
+                          "\xc4\x80" => 'A',
+                          "\xc4\x92" => 'E',
+                          "\xc4\xaa" => 'I',
+                          "\xc5\x8c" => 'O',
+                          "\xc5\xaa" => 'U',
+                          "ā" => 'a',
+                          "ē" => 'e',
+                          "ī" => 'i',
+                          "ō" => 'o',
+                          "ū" => 'u',
+                          "Ā" => 'A',
+                          "Ē" => 'E',
+                          "Ī" => 'I',
+                          "Ō" => 'O',
+                          "Ū" => 'U',
+          }
 
 
-       # m/r/t at end of line shortens preceding vowel
-       if s =~ /^(.*)([āēīōūĀĒĪŌŪ])([mrt])$/i
-         s = $1 + macron_table[$2] + $3
-       end
+          # m/r/t at end of line shortens preceding vowel
+          if s =~ /^(.*)([āēīōūĀĒĪŌŪ])([mrt])$/i
+            s = $1 + macron_table[$2] + $3
+          end
 
-       # macron before vowel
-       if s =~ /(.*)([āēīōūĀĒĪŌŪ])([āēīōūĀĒĪŌŪaeiouAEIOU])(.*)/i
-        s = self.fix_macrons $1 + macron_table[$2] + $3 + $4
-       end
+          # macron before vowel
+          if s =~ /(.*)([āēīōūĀĒĪŌŪ])([āēīōūĀĒĪŌŪaeiouAEIOU])(.*)/i
+            s = self.fix_macrons $1 + macron_table[$2] + $3 + $4
+          end
 
-       if s=~ /n[td]/
-         # n[td]
-         mutaturum = s.split //
-         mutatum = []
-         mutaturum.each_with_index do |e, i|
-           if ( e == "n" and 
-               mutaturum[i+1] =~ /[td]/ and 
-               not macron_table[mutaturum[i-1]].nil? )
-              mutatum[i-1]=macron_table[mutaturum[i-1]]
-           end
-            mutatum << e
-         end
+          if s=~ /n[td]/
+            # n[td]
+            mutaturum = s.split(//)
+            mutatum = []
+            mutaturum.each_with_index do |e, i|
+              if ( e == "n" and
+                  mutaturum[i+1] =~ /[td]/ and
+                  not macron_table[mutaturum[i-1]].nil? )
+                mutatum[i-1]=macron_table[mutaturum[i-1]]
+              end
+              mutatum << e
+            end
 
-         return mutatum.join ''
-       end
+            return mutatum.join ''
+          end
 
-       return s
+          return s
+        end
       end
     end
-    end
   end
 end

data/lib/linguistics/latin/verb/supine.rb

@@ -1,8 +1,8 @@
 # encoding: UTF-8
 #
-module Linguistics 
-  module Latin 
-    module Verb 
+module Linguistics
+  module Latin
+    module Verb
       class LatinVerb
         ##
         #
@@ -12,7 +12,7 @@ module Linguistics
         #
         #   * 4th declension verbal noun
         #   * Formed on the same stem as the perfect passive participle
-        #   * Only two forms in common use:  accusative and ablative singular 
+        #   * Only two forms in common use:  accusative and ablative singular
         #
         # Ablative is used with the neuter of certain adjectives to indicate
         # what respect a particular quality is applicable: <em>mirabile
@@ -31,8 +31,8 @@ module Linguistics
         #
         ###
         def supine
-          acc = @pass_perf_part
-          abl = acc.sub /^(.*)um$/, "\\1"
+          acc = passive_perfect_participle
+          abl = acc.sub( /^(.*)um$/, "\\1" )
           abl += "ū"
           {:ablative => abl, :accusative => acc}
         end

data/lib/linguistics/latin/verb/tense_block.rb

@@ -0,0 +1,227 @@
+# encoding: UTF-8
+
+require 'linguistics/latin/verb/phonographia'
+
+module Linguistics
+  module Latin
+    module Verb
+    ##
+    # == NAME
+    #
+    # TenseBlock
+    #
+    # == DESCRIPTION
+    #
+    # As per the LatinVerb documentation, LatinVerbs decorate themselves with
+    # the method which loads up a voice/tense/mood black box.  That black box
+    # is a TenseBlock.  The TenseBlock, in turn, responds to getting the final
+    # two components of the fully-qualified vector back (person and number).
+    # It also has Array-like behaviors (e.g. +[]+) based on the 2 * 3 matrix.
+    #
+    # == INTERNALS
+    #
+    # Internally, a Tenseblock is effectively an Array of the arguments passed
+    # in during TenseBlock.initialize.  These are assumed to be
+    # first/singular, second/singular, third/singular and then
+    # first/plural, second/plural, third/plural.
+    #
+    # Syntactic sugar methods are added to access this array.  Thus, in a
+    # LatinVerb a fully-qualified vectors first 3/5 data resolve to a
+    # TenseBlock.  The last 2/5 of resolution occurs within the TenseBlock
+    # (effectively pulling the contents of the Array).  Therefore, when a
+    # LatinVerb is accessed with the quinpartite fully-qualified vector it can
+    # return the unique value.  The mechanics of this hook through (surprise!)
+    # method_missing.
+    #
+    #
+    ##
+
+      class TenseBlock
+        include  Linguistics::Latin::Phonographia
+        @tb_canonical_accessors = []
+        @tb_alias_accessors     = []
+        @tb_accessors           = []
+
+        class << self
+          def null_tense_block
+            return self.new [ '', '', '', '', '', '']
+          end
+        end
+
+        ##
+        #--
+        # TODO:  I dream of this being generated dynamically through the
+        # VerbvectorGenerator for more dynamicity.  This would require a richer DSL in
+        # VerbvectorGenerator, but would be totally awesome if we could describe this
+        # language in a DSL.
+        #++
+        ##
+
+        ##
+        # --
+        # This structure is used to define the methods that will be allowed to
+        # access the @results array.  The key is the "canonical" name:
+        # (person)(number).  This needs to be flexibly supported.  This key
+        # map to a hash that contains the keys :aliases (for aliases to that
+        # particular "canonical") method as well as a Proc that should return
+        # the proper value for the "canonical" method (and therefore, by means
+        # of alias, also to the "aliased" methods).  "Canonical" methods will
+        # be added to an array accessed by "tb_canonical_accessors."  Aliases
+        # will be accesed by "tb_noncanonical_accessors."  The aggregate is
+        # accesed by "tb_accessors."
+        #++
+        ##
+
+        # Describes the methods that are to be provided to instances as means
+        # for accessing the contents of the @results hash.
+        ACCESSOR_HASH = {
+          :first_person_singular_number => {
+            :aliases => [:singular_number_first_person],
+            :returns => lambda{ @results[0] }
+          },
+          :second_person_singular_number => {
+            :aliases => [:singular_number_second_person],
+            :returns => lambda{ @results[1] }
+          },
+          :third_person_singular_number => {
+            :aliases => [:singular_number_third_person],
+            :returns => lambda{ @results[2] }
+          },
+          :first_person_plural_number => {
+            :aliases => [:plural_number_first_person],
+            :returns => lambda{ @results[3] }
+          },
+          :second_person_plural_number => {
+            :aliases => [:plural_number_second_person],
+            :returns => lambda{ @results[4] }
+          },
+          :third_person_plural_number => {
+            :aliases => [:plural_number_third_person],
+            :returns => lambda{ @results[5] }
+          }
+        }
+
+        def self.add_acc_canonical(s); @tb_canonical_accessors << s; end # :nodoc:
+        def self.add_acc_alias(s); @tb_alias_accessors << s; end # :nodoc:
+
+        ACCESSOR_HASH.each_pair do |k,h|
+          define_method k, h[:returns]
+          self.add_acc_canonical k
+          h[:aliases].each{|a| alias_method a, k; self.add_acc_alias a}
+        end
+
+        @tb_accessors = @tb_canonical_accessors + @tb_alias_accessors
+
+
+        # Idea from Mike Perham (6/1/2011):  Add a way to leave a note that
+        # describes, in English, the signification of the given tense.  Good
+        # idea.
+
+        attr_reader :meaning
+
+        # === ARGUMENTS
+        #
+        # *r:* :: An Array (or something that can respond to to_a) containing 0-6
+        #         elements that will be mapped into the 2*3 matrix of Latin verb person /
+        #         number specifications.
+        # === RETURNS
+        #
+        #  Nothing
+        ##
+        def initialize(r, opts={})
+          begin
+            unless r.class.is_a?  Array
+              raise if r.nil?
+              r = r.to_a
+            end
+            @results = r.map{|v| Linguistics::Latin::Phonographia.fix_macrons v}
+            @meaning = opts[:meaning] if opts[:meaning]
+          rescue => e
+            raise e, "TenseBlock failed to initialize correctly. passed #{r.nil?}"
+          end
+        end
+
+        ##
+        #
+        # Required for serialization
+        #
+        ##
+        def to_json(*a)
+          {
+            'json_class'   => self.class.name,
+            'data'         => @results.map{|i| i.to_json}
+          }.to_json(*a)
+        end
+
+        ##
+        #
+        # Required for deserialization
+        #
+        ##
+        def TenseBlock.json_create(o)
+         new(o['data'])
+        end
+
+        ##
+        #
+        # Provides Array-like interface to the collection of results.
+        #
+        ##
+        def [](arg)
+          @results[arg]
+        end
+
+        ##
+        #
+        # To Array, useful in serialization
+        #
+        ##
+        def to_a
+          return @results
+        end
+
+        ##
+        #
+        # Add array compatibility support
+        #
+        ##
+        def length; return @results.length; end
+
+        ##
+        # Add array empty? compatibility
+        #
+        ##
+        def empty?; return @results.empty?; end
+
+        ##
+        #
+        # Add a sensible string display
+        #
+        ##
+        def to_s; return self.to_a.to_s; end
+
+        ##
+        # Return whether the result arrays is empty of words
+        ##
+        def wordless?
+          !@results.all?{ |r| r =~ /\w/ }
+        end
+
+        ##
+        #
+        # Provide a method_missing so that ambiguous cases can be resolved
+        #
+        ##
+        def method_missing(symbol, *args)
+          returnArray = []
+          self.class.class_eval{@tb_canonical_accessors}.grep(/#{symbol.to_s}/) do |s|
+           returnArray.push(send s)
+          end
+          return returnArray unless returnArray.empty?
+          raise
+        end
+      end
+    end
+  end
+end
+

data/lib/linguistics/latin/verb/tense_definitions/first.rb

@@ -0,0 +1,92 @@
+# encoding: UTF-8
+# vim:  set fdm=marker tw=80 sw=2 wrap:
+
+module Linguistics
+  module Latin
+    module Verb
+      module TenseDefinitions
+        module First
+          def active_voice_indicative_mood_future_tense
+            return TenseBlock.new(
+              [Linguistics::Latin::Verb::LatinVerb::AF_ONE_TWO_ENDINGS.collect{|x| stem + x}].flatten,
+              { :meaning => Linguistics::Latin::Verb::LatinVerb::MEANINGS[:active_voice_indicative_mood_future_tense] }
+            )
+          end
+
+          def active_voice_indicative_mood_imperfect_tense
+            return TenseBlock.new(
+              [Linguistics::Latin::Verb::LatinVerb::AI_FIRST_AND_SECOND_CONJUG_PERS_ENDINGS.collect{|x| stem + x}].flatten,
+              { :meaning => Linguistics::Latin::Verb::LatinVerb::MEANINGS[:active_voice_indicative_mood_imperfect_tense] }
+            )
+          end
+
+          def active_voice_indicative_mood_present_tense
+            return TenseBlock.new(
+                 [ first_person_singular,
+                        Linguistics::Latin::Verb::LatinVerb::AP_FIRST_AND_SECOND_CONJUG_PERS_ENDINGS.collect{ |ending| stem + ending}
+                 ].flatten!,
+              { :meaning => Linguistics::Latin::Verb::LatinVerb::MEANINGS[:active_voice_indicative_mood_present_tense] }
+              )
+          end
+
+          def active_voice_subjunctive_mood_present_tense
+            key          = verb_type.to_s.split(/::/).last.to_sym
+            asp_base     = Linguistics::Latin::Verb::LatinVerb::ACTIVE_PRESENT_SUBJUNCTIVE_ENDINGS[key].call(stem[0..-2])
+            endings_coll = ['m', Linguistics::Latin::Verb::LatinVerb::AP_FIRST_AND_SECOND_CONJUG_PERS_ENDINGS].flatten!
+            collection   = endings_coll.map{ |ending| asp_base + ending }
+            TenseBlock.new( collection ,
+              { :meaning => Linguistics::Latin::Verb::LatinVerb::MEANINGS[:active_voice_subjunctive_mood_present_tense] }
+              )
+          end
+
+          def passive_voice_indicative_mood_future_tense
+            fp_stem   = stem+"bi"
+            standards = Linguistics::Latin::Verb::LatinVerb::PASSIVE_ENDINGS_FIRST_AND_SECOND_CONJG[2..-1].map{|x| fp_stem + x}
+            standards.pop
+            fp_stem.sub!(/.$/,'u')
+            members =
+              [ stem + "b\xc5\x8dr",
+                stem + "beris",
+                standards,
+                fp_stem+Linguistics::Latin::Verb::LatinVerb::PASSIVE_ENDINGS_FIRST_AND_SECOND_CONJG.last].flatten!
+
+            TenseBlock.new(
+              members,
+              { :meaning => Linguistics::Latin::Verb::LatinVerb::MEANINGS[:passive_voice_indicative_mood_future_tense] }
+              )
+          end
+
+          def passive_voice_indicative_mood_imperfect_tense
+            imperfect_stem = stem + "b\xc4\x81"
+            members = Linguistics::Latin::Verb::LatinVerb::PASSIVE_ENDINGS_FIRST_AND_SECOND_CONJG.map{|x| imperfect_stem+x}
+            return TenseBlock.new(
+              members,
+              { :meaning => Linguistics::Latin::Verb::LatinVerb::MEANINGS[:passive_voice_indicative_mood_imperfect_tense] }
+              )
+          end
+
+          def passive_voice_indicative_mood_present_tense
+            local_pe = Linguistics::Latin::Verb::LatinVerb::PASSIVE_ENDINGS_FIRST_AND_SECOND_CONJG.clone
+            return TenseBlock.new(
+                [first_person_singular.to_s + "r",
+                  local_pe[1..-1].map{|x| @stem + x}].flatten!,
+              { :meaning => Linguistics::Latin::Verb::LatinVerb::MEANINGS[:passive_voice_indicative_mood_present_tense] }
+              )
+          end
+
+          def passive_voice_subjunctive_mood_present_tense
+            key = verb_type.to_s.split(/::/).last.to_sym
+            short_base =
+              Linguistics::Latin::Verb::LatinVerb::ACTIVE_PRESENT_SUBJUNCTIVE_ENDINGS[key].call(stem[0..-2])
+            members = Linguistics::Latin::Verb::LatinVerb::PASSIVE_ENDINGS_FIRST_AND_SECOND_CONJG.map { |ending| short_base + ending }
+            TenseBlock.new(
+              members,
+              { :meaning => Linguistics::Latin::Verb::LatinVerb::MEANINGS[:passive_voice_subjunctive_mood_present_tense] }
+              )
+          end
+        end
+      end
+    end
+  end
+end
+

data/lib/linguistics/latin/verb/tense_definitions/fourth.rb

@@ -0,0 +1,92 @@
+# encoding: UTF-8
+# vim:  set fdm=marker tw=80 sw=2 wrap:
+
+module Linguistics
+  module Latin
+    module Verb
+      module TenseDefinitions
+        module Fourth
+          def active_voice_indicative_mood_future_tense
+            return TenseBlock.new(
+              [Linguistics::Latin::Verb::LatinVerb::AF_OTHER_ENDINGS.collect{|x| stem + "i" + x}].flatten,
+              { :meaning => Linguistics::Latin::Verb::LatinVerb::MEANINGS[:active_voice_indicative_mood_future_tense] }
+              )
+          end
+
+          def active_voice_indicative_mood_imperfect_tense
+            return TenseBlock.new(
+              [Linguistics::Latin::Verb::LatinVerb::AI_THIRD_CONJUG_PERS_ENDINGS.collect do |x|
+                  stem + "i" + x end ].flatten!,
+              { :meaning => Linguistics::Latin::Verb::LatinVerb::MEANINGS[:active_voice_indicative_mood_imperfect_tense] }
+              )
+          end
+
+          def active_voice_indicative_mood_present_tense
+            return TenseBlock.new(
+              [ first_person_singular,
+                       Linguistics::Latin::Verb::LatinVerb::AP_THIRDIO_CONJG_PERS_ENDINGS.collect{ |ending| stem + ending }
+                     ].flatten!,
+              { :meaning => Linguistics::Latin::Verb::LatinVerb::MEANINGS[:active_voice_indicative_mood_present_tense] }
+              )
+          end
+
+          def active_voice_subjunctive_mood_present_tense
+            key = verb_type.to_s.split(/::/).last.to_sym
+            asp_base = Linguistics::Latin::Verb::LatinVerb::ACTIVE_PRESENT_SUBJUNCTIVE_ENDINGS[key].call(stem[0..-1])
+            elems = ['m',
+               Linguistics::Latin::Verb::LatinVerb::AP_FIRST_AND_SECOND_CONJUG_PERS_ENDINGS].flatten!.map do  |ending|
+                 asp_base + ending
+            end
+
+            TenseBlock.new(
+              elems,
+              { :meaning => Linguistics::Latin::Verb::LatinVerb::MEANINGS[:active_voice_subjunctive_mood_present_tense] }
+              )
+          end
+
+          def passive_voice_indicative_mood_future_tense
+            ie_base = stem+"iē"
+            elems =  [stem+"ia"+Linguistics::Latin::Verb::LatinVerb::PASSIVE_ENDINGS_FIRST_AND_SECOND_CONJG[0],
+              Linguistics::Latin::Verb::LatinVerb::PASSIVE_ENDINGS_FIRST_AND_SECOND_CONJG[1..-1].map{|x| ie_base + x}].flatten!
+            TenseBlock.new(
+              elems,
+              { :meaning => Linguistics::Latin::Verb::LatinVerb::MEANINGS[:passive_voice_indicative_mood_future_tense] }
+              )
+          end
+
+          def passive_voice_indicative_mood_imperfect_tense
+            base = stem+"iēbā"
+            elems = [Linguistics::Latin::Verb::LatinVerb::PASSIVE_ENDINGS_FIRST_AND_SECOND_CONJG.map{|x| base + x}].flatten!
+            return TenseBlock.new(
+              elems,
+              { :meaning => Linguistics::Latin::Verb::LatinVerb::MEANINGS[:passive_voice_indicative_mood_imperfect_tense] }
+              )
+          end
+
+          def passive_voice_indicative_mood_present_tense
+            base  = @stem+"ī"
+            elems = [first_person_singular+"r",
+              Linguistics::Latin::Verb::LatinVerb::PASSIVE_ENDINGS_FIRST_AND_SECOND_CONJG[1..-2].map{|x| base + x},
+              base+Linguistics::Latin::Verb::LatinVerb::PASSIVE_ENDINGS_OTHER[-1]].flatten!
+            return TenseBlock.new(
+              elems,
+              { :meaning => Linguistics::Latin::Verb::LatinVerb::MEANINGS[:passive_voice_indicative_mood_present_tense] }
+              )
+          end
+
+          def passive_voice_subjunctive_mood_present_tense
+            subjunctive_stem = stem + "iā"
+            elems = Linguistics::Latin::Verb::LatinVerb::PASSIVE_ENDINGS_FIRST_AND_SECOND_CONJG.map do |ending|
+              subjunctive_stem + ending
+            end
+            TenseBlock.new(
+              elems,
+              { :meaning => Linguistics::Latin::Verb::LatinVerb::MEANINGS[:passive_voice_subjunctive_mood_present_tense] }
+              )
+          end
+        end
+      end
+    end
+  end
+end
+

data/lib/linguistics/latin/verb/tense_definitions/impersonal.rb

@@ -0,0 +1,25 @@
+module Linguistics
+  module Latin
+    module Verb
+      module TenseDefinitions
+        module Impersonal
+          def self.included(inclusor)
+            impersonal_handler
+          end
+          def impersonal_handler
+            singleton_class.class_eval do
+              def active_voice_indicative_mood_present_tense
+                TenseBlock.new ["", "", @original_string,
+                                "", "", ""]
+              end
+              def active_voice_indicative_mood_present_tense_third_person_singular_number
+                return active_voice_indicative_mood_present_tense[2]
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end
+