latinverb 0.9.2 → 0.9.3

data/lib/linguistics/latin/verb/latinverb/latinverb_classifier.rb

@@ -0,0 +1,100 @@
+# encoding: UTF-8
+# vim:  set fdm=marker tw=80 sw=2:
+
+module Linguistics
+  # Generalized module for handling lingustics related to Latin
+  module Latin
+    # Generalized module for handling lingustics related to Latin's verbal aspects
+    module Verb
+      class LatinVerb
+        ### {{{
+        #
+        # == ARGUMENTS
+        #
+        #    * s :: a "four principal parts" string whence can be derived
+        #  the first person singular present indicative as well as the
+        #  infinitive
+        #
+        # == RETURNS
+        #
+        # The classification, a subclass of VerbType
+        #
+        # == PURPOSE
+        #
+        # Given the principal parts as a string, decide which conjuation is
+        # in play
+        #
+        #
+        ### }}}
+        class LatinVerbClassifier# {{{
+          attr_reader :classification
+
+          def initialize(input)
+            @classification = self.classify input
+          end
+
+          def classify(s)
+
+            divided_string = s.split( /\s+/ )
+
+            first_pres = divided_string[0] || ''
+            infinitive = divided_string[1] || ''
+
+            return Linguistics::Latin::Verb::Classification::Defective if
+              Linguistics::Latin::Verb::LatinVerb::DEFECTIVE_VERBS.member? first_pres
+
+            return Linguistics::Latin::Verb::Classification::Irregular if
+              Linguistics::Latin::Verb::LatinVerb::IRREGULAR_VERBS.member? first_pres
+
+            return Linguistics::Latin::Verb::Classification::Semideponent if
+              Linguistics::Latin::Verb::LatinVerb::SEMI_DEPONENTS.keys.any?{ |k| first_pres=~/#{k}$/} &&
+              s !~ /PreventDeponentInfiniteRegress/
+
+            return Linguistics::Latin::Verb::Classification::Impersonal if
+              Linguistics::Latin::Verb::LatinVerb::IMPERSONAL_VERBS.member? s
+
+            # Very irregular irregulars, A&G206, e/f
+            return Linguistics::Latin::Verb::Classification::Irregular if
+              s =~ %r'^(aiō|quaesō|ovāre)$'
+
+            return Linguistics::Latin::Verb::Classification::Deponent if
+              (infinitive =~ /ī$/  and first_pres =~ /r$/)
+
+            return Linguistics::Latin::Verb::Classification::Regular
+
+          end
+
+          def set_as_defective
+            unless @classification == Linguistics::Latin::Verb::Classification::Impersonal
+              @classification = Linguistics::Latin::Verb::Classification::PresentOnly
+            end
+          end
+
+          def present_only?
+            @present_only ||= ( @classification ==  Linguistics::Latin::Verb::Classification::PresentOnly )
+          end
+
+          def deponent?
+            @deponent ||= (@classification == Linguistics::Latin::Verb::Classification::Deponent)
+          end
+
+          def semideponent?
+            @semideponent ||= (@classification == Linguistics::Latin::Verb::Classification::Semideponent)
+          end
+
+          def impersonal?
+            @impersonal ||= (@classification == Linguistics::Latin::Verb::Classification::Impersonal)
+          end
+
+          def irregular?
+            @irregular = @classification == Linguistics::Latin::Verb::Classification::Irregular
+          end
+
+          def regular?
+            @regular = @classification == Linguistics::Latin::Verb::Classification::Regular
+          end
+        end# }}}
+      end
+    end
+  end
+end

data/lib/linguistics/latin/verb/latinverb/latinverb_input_sanitizer.rb

@@ -0,0 +1,32 @@
+# encoding: UTF-8
+# vim:  set fdm=marker tw=80 sw=2:
+
+module Linguistics
+  # Generalized module for handling lingustics related to Latin
+  module Latin
+    # Generalized module for handling lingustics related to Latin's verbal aspects
+    module Verb
+      class LatinVerb
+        class LatinVerbInitializationError < Exception; end
+        class LatinVerbInputSanitizer# {{{
+          def initialize(raw_data)
+            @raw_data = raw_data.dup
+
+            unless ( raw_data.is_a? String )
+              raw_data_type    = raw_data.class.to_s.downcase
+              method_prefix    = 'construct_original_string_for_'
+              mutator          = ( method_prefix + raw_data_type ).to_sym
+              raw_data = send(mutator, raw_data)
+            end
+
+            @sanitized_data = raw_data
+          end
+
+          def to_s
+            return @sanitized_data
+          end
+        end# }}}
+      end
+    end
+  end
+end

data/lib/linguistics/latin/verb/latinverb/latinverb_pp_extractor.rb

@@ -0,0 +1,106 @@
+# encoding: UTF-8
+# vim:  set fdm=marker tw=80 sw=2:
+
+module Linguistics
+  # Generalized module for handling lingustics related to Latin
+  module Latin
+    # Generalized module for handling lingustics related to Latin's verbal aspects
+    module Verb
+      class LatinVerb
+        class LatinVerbPPExtractor# {{{
+          attr_reader :passive_perfect_participle, :first_person_perfect, :present_active_infinitive, :first_person_singular
+
+          class << self# {{{
+
+            def calculate_stem(present_active_infinitive, first_person_singular)# {{{
+              if present_active_infinitive =~ /āre$/
+                return present_active_infinitive.gsub(/(.*)āre$/,'\\1ā')
+              end
+              if present_active_infinitive =~ /ēre$/
+                return present_active_infinitive.gsub(/(.*)ēre$/,'\\1ē')
+              end
+              if present_active_infinitive =~ /ere$/
+                if first_person_singular =~ /iō$/
+                  return present_active_infinitive.gsub(/(.*)ere$/,'\\1')
+                else
+                  return present_active_infinitive.gsub(/(.*)ere$/,'\\1')
+                end
+              end
+              if present_active_infinitive =~ /īre$/
+                return present_active_infinitive.gsub(/(.*)īre$/,'\\1')
+              end
+            end# }}}
+
+            def derive_parts_from_given_string(s)# {{{
+              s.split(/\s+/)
+            end# }}}
+
+            def calculate_participial_stem(present_active_infinitive, first_person_singular)
+              if present_active_infinitive.to_s =~ /(.*ā)re$/
+                return $1
+              end
+
+              if present_active_infinitive.to_s =~ /(.*ē)re$/
+                return $1
+              end
+
+              if present_active_infinitive.to_s =~ /(.*)ere$/
+                match=$1
+                if first_person_singular =~ /iō/
+                  return match + "iē"
+                else
+                  return match + "e"
+                end
+              end
+
+              if present_active_infinitive.to_s =~ /(.*)īre$/
+                return $1 + "iē"
+              end
+            end
+          end# }}}
+
+          def initialize(input_string, classification)# {{{
+            @data_string = input_string
+            @_classification = classification
+
+            non_defective = ( classified_as.deponent? or
+                              classified_as.semideponent? or
+                              classified_as.impersonal? )
+            unless non_defective
+              @principal_parts = self.class.derive_parts_from_given_string input_string
+              @first_person_singular, @present_active_infinitive,
+              @first_person_perfect, @passive_perfect_participle = @principal_parts
+            else
+              unless classified_as.impersonal?
+                @deponent_proxy = Linguistics::Latin::Verb::LatinVerb.create_pseudo_active_mask_for_deponent(input_string)
+              end
+            end
+          end# }}}
+
+          def participial_stem
+            @participial_stem ||= self.class.calculate_participial_stem(@present_active_infinitive, @first_person_singular)
+          end
+
+          def principal_parts
+            @principal_parts
+          end
+
+          def stem
+            @stem ||= self.class.calculate_stem(present_active_infinitive, first_person_singular)
+          end
+
+          def classification
+            @_classification
+          end
+          alias :classified_as :classification
+
+
+        end
+
+        def to_a
+          @principal_parts
+        end
+      end
+    end
+  end
+end

data/lib/linguistics/latin/verb/latinverb/metaprogramming.rb

@@ -1,5 +1,7 @@
-# encoding: UTF-8
-
+module Linguistics
+  module Latin
+    module Verb
+      class LatinVerb
 =begin rdoc
 #--
 # The purpose of this module is to contain the metaprogramming modules
@@ -7,10 +9,6 @@
 # ++
 =end
 
-module Linguistics
-  module Latin
-    module Verb 
-      class LatinVerb
 
 =begin rdoc
 
@@ -38,25 +36,21 @@ specifier, thus all 5/5 components of the fully-qualified vector can result in
 unique match.
 
 =end
-        def method_missing(symbol, *args )  # :nodoc:
-          super if @tense_list.nil?
-          @tense_list.find do |e|
-            if symbol.to_s.match /^(#{e})_(.*)/
-              tense_method, vector_specifier = $1, $2
-              # This is added to prevent stack-level too deep errors
-              begin
-                # Handle the base case
-                if self.respond_to?(tense_method.to_sym)
-                  return send(tense_method.to_sym).send(vector_specifier.to_sym)
-                end
-              rescue SystemStackError => e
-                STDERR.puts "We encountered a SystemStackError when calling #{tense_method}"
-                STDERR.puts "WARNING:  Failed to resolve [#{tense_method}] with [#{vector_specifier}].  \n\nMake sure #{tense_method} is defined."
-                super
-              end
-            end
+        def method_missing(method_name, *args )  # :nodoc:
+          method_name_components = method_name.to_s.split('_')
+
+          tense_method = Array(method_name_components[0..5]).join('_')
+          vector_specifier = Array(method_name_components[6..-1]).join('_')
+
+          raise RuntimeError, "Lookup on #{method_name} failed" if tense_method.nil? || vector_specifier.nil?
+
+          if self.respond_to?(tense_method.to_sym)
+            tense_block = send(tense_method.to_sym)
+            raise RuntimeError, "Call for #{tense_method} failed" if tense_block.nil?
+            tense_block.send(vector_specifier.to_sym)
+          else
+            super
           end
-          super
         end
 
         ##
@@ -66,11 +60,18 @@ unique match.
         # If it's in +respondable_methods+, we return true.
         #
         ##
-        def respond_to?(symbol, include_private=false) 
-          super if respondable_methods.nil?
-          super if respondable_methods.empty?
-          self.respondable_methods.grep(Regexp.new %Q/^#{symbol}$/).empty? ?
-            super : true
+        def respond_to_missing?(method_name, include_private = false) #:nodoc:
+          components     = method_name.to_s.split('_')
+          tense_method   = components[0..5].join('_').to_sym
+
+          return false unless @tense_list.nil? || @tense_list.include?( tense_method.to_s )
+
+          if components.length > 6
+            tb           = self.send(tense_method)
+            vector_call  = components[6..-1].join('_').to_sym
+            tb.class.instance_method(vector_call)
+          end
+
         end
       end
     end

data/lib/linguistics/latin/verb/latinverb/semideponent.rb

@@ -0,0 +1,28 @@
+# encoding: UTF-8
+module Linguistics
+  module Latin
+    module Verb
+      class LatinVerb
+        module Semideponent
+          def self.extended(extending_instance)
+            extending_instance.instance_eval do
+              @proxy_verb_string = Linguistics::Latin::Verb::LatinVerb.create_pseudo_active_mask_for_deponent @original_string
+              @proxyVerb = Linguistics::Latin::Verb::LatinVerb.new @proxy_verb_string
+              apply_semi_deponent_masking
+            end
+          end
+          # Previously @deponent and @semideponent followed the same paths,
+          # but in semideponents, the "present system" is handled as normal
+          # (completed by _add_vector_methods, supra).  We need only mask, as
+          # A&G #192 says: "the completed methods" i.e. the perfect system.
+          def apply_semi_deponent_masking
+            self.singleton_class.class_eval do
+              include Linguistics::Latin::Verb::DeponentTenseMethods
+            end
+          end
+        end
+      end
+    end
+  end
+end
+

data/lib/linguistics/latin/verb/latinverb/validation.rb

@@ -4,7 +4,7 @@ module Linguistics
   module Latin
     module Verb
       ##
-      # == NAME 
+      # == NAME
       #
       # Validation
       #
@@ -15,7 +15,6 @@ module Linguistics
       #
       ##
       module Validation
-
         ##
         #
         # == DESCRIPTION
@@ -24,7 +23,7 @@ module Linguistics
         # LatinVerb.initialize) for basic sanity.
         #
         # Here are its basic truths
-        # 
+        #
         # 1.  Get +@original_string+ as an iVar
         # 1.  Derive a classification (+@classification+) from the string
         # 1.  Determine whether the string qualifies the verb as irregular
@@ -32,32 +31,9 @@ module Linguistics
         #
         ##
         def valid?
-          os = @original_string
-          instance_eval do
-            begin
-              @classification = Linguistics::Latin::Verb::LatinVerb.classify(os)
-              @irregular = 
-                @classification == Linguistics::Latin::Verb::VerbTypes::Irregular ?
-                true : false
-              unless @irregular
-                @stem ||= self.class.calculate_stem os.split(/\s+/)[1]
-              @deponent = (@classification == Linguistics::Latin::Verb::VerbTypes::Deponent) ?
-                true : false
-              @semideponent = (@classification == Linguistics::Latin::Verb::VerbTypes::Semideponent) ?
-                true : false
-              @impersonal= (@classification == Linguistics::Latin::Verb::VerbTypes::Impersonal) ?
-                true : false
-              end
-            rescue RuntimeError => detail
-              STDERR.puts "WARNING:  Improper use of rescue for decision structure in latinverb_validation"
-              @irregular = true 
-            rescue Exception => e
-              @classification_error = lambda do
-                raise e
-              end
-            end
-          end
-          return true
+          !@original_string.nil? &&
+          !classification.nil? &&
+          ( irregular? ? true : !stem.nil? )
         end
       end
     end

data/lib/linguistics/latin/verb/latinverb/verbvector_description.rb

@@ -0,0 +1,50 @@
+# encoding: UTF-8
+#
+
+module Linguistics
+  # Generalized module for handling linguistics related to Latin
+  module Latin
+    # Generalized module for handling linguistics related to Latin's verbal aspects
+    module Verb
+      class LatinVerb
+        LATIN_VERBVECTOR_DESCRIPTION = Proc.new do
+          language :Latin do
+            all_vectors :start_with do
+               {
+                :voice =>  %w(active passive),
+                :mood  =>  %w(indicative subjunctive imperative)
+               }
+            end
+            vectors_that(/.*_indicative_mood/) do
+              {
+                :tense  => %w(present imperfect future
+                              perfect pastperfect futureperfect)
+              }
+            end
+            vectors_that(/.*_subjunctive_mood/) do
+              {
+                :tense => %w(present imperfect
+                              perfect pastperfect)
+              }
+            end
+            vectors_that(/.*_imperative_mood/) do
+              {
+                :tense => %w(present future)
+              }
+            end
+            all_vectors :end_with do
+              {
+                :person => %w(first second third),
+                :number => %w(singular plural)
+              }
+            end
+            exception :remove, :passive_voice_imperative_mood_present_tense
+            exception :remove, :passive_voice_imperative_mood_future_tense
+            cluster_on :tense, "as method", :tense_list
+          end
+        end
+      end
+    end
+  end
+end
+

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

@@ -0,0 +1,36 @@
+module Linguistics
+  module Latin
+    module Verb
+      class ParticipleBlock
+        attr_reader :participle_methods
+
+        def initialize(s)
+          raise "ParticipleBlock instantiation argument was nil!" if s.nil?
+
+          if s.is_a? Hash
+            @participle_methods = s.keys
+          end
+
+          @participle_methods.each do |k|
+            v=s[k]
+            singleton_class.class_eval do
+              define_method k.to_sym do
+                return v
+              end
+            end
+          end
+        end
+
+        ##
+        #
+        # Required for deserialization
+        #
+        ##
+        def self.json_create(o)
+          new(o['data'])
+        end
+      end
+    end
+  end
+end
+

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

@@ -3,9 +3,9 @@
 require 'latinverb'
 require 'linguistics/latin/verb/phonographia'
 
-module Linguistics 
-  module Latin 
-    module Verb 
+module Linguistics
+  module Latin
+    module Verb
       ##
       # == NAME
       #
@@ -31,7 +31,7 @@ module Linguistics
       #    declension used only in the oblique cases of hte singular.
       #    c.  The Supine:  this is in form a verbal noun of the fourth
       #    declension in the accusative (-um) and dative or ablative (-ū)
-      #    singular      
+      #    singular
       #    ...
       #
       ##
@@ -59,9 +59,9 @@ module Linguistics
      #
      ###
      def present_active_participle
-       raise "Participial stem was nil" if  @participial_stem.nil?
+       raise "Participial stem was nil" if  participial_stem.nil?
        endings=%w(ns ntis)
-       return endings.collect{ |x| Linguistics::Latin::Phonographia.fix_macrons(@participial_stem+x.chomp)}.join(', ')
+       return endings.collect{ |x| Linguistics::Latin::Phonographia.fix_macrons(participial_stem+x.chomp)}.join(', ')
      end
 
      ##
@@ -83,10 +83,10 @@ module Linguistics
      ###
      def future_active_participle
        # In case we have an irregular, or somehow already have a /ūrus$/ we shouldn't do this
-       mybase = (@pass_perf_part =~ /ūru.$/) ?
-         @pass_perf_part.gsub(/u[sm]$/,'')
+       mybase = (@passive_perfect_participle =~ /ūru.$/) ?
+         @passive_perfect_participle.gsub(/u[sm]$/,'')
        :
-         @pass_perf_part.gsub(/u[sm]$/, "ūr")
+         @passive_perfect_participle.gsub(/u[sm]$/, "ūr")
 
        singular_endings=%w(us a um)
        return singular_endings.collect{|x| mybase+"#{x}".chomp}.join(', ')
@@ -117,7 +117,7 @@ module Linguistics
      #
      ###
      def perfect_passive_participle
-       mybase=@pass_perf_part.sub(/u[sm]$/,'')
+       mybase=@passive_perfect_participle.sub(/u[sm]$/,'')
        singular_endings=%w(us a um)
        return singular_endings.collect{|x| mybase+"#{x}".chomp}.join(', ')
      end
@@ -138,7 +138,7 @@ module Linguistics
      #
      ###
      def future_passive_participle
-       mybase = @participial_stem+"nd"
+       mybase = participial_stem+"nd"
        singular_endings=%w(us a um)
        return singular_endings.collect{|x|Linguistics::Latin::Phonographia.fix_macrons( mybase+"#{x}".chomp)}.join(', ')
      end
@@ -147,11 +147,11 @@ module Linguistics
      #
      # === GRAMMATICAL FUNCTION
      #
-     # A&G, 158,d. 
+     # A&G, 158,d.
      #
-     # The Gerundive (ending in -ndus) has two uses:  
+     # The Gerundive (ending in -ndus) has two uses:
      #
-     # 1.  ...an adjective implying obligation...  
+     # 1.  ...an adjective implying obligation...
      #
      # 2.  In the oblique cases the Gerundive commonly has the same meaning as
      # the Gerund ... for examples see sec. 503
@@ -179,10 +179,10 @@ module Linguistics
      #
      # Gerundive:  verbal achective
      # gerund:  verbal noun
-     # 
+     #
      # gerund only has oblique
      # gerundive is passive in meaning, gerund is active:
-     # 
+     #
      # A FUNNY THING I ALWAYS FORGET:
      #  studium legeni libros ==>  studium librorum legendorum
      #  discimus legendo libros ==>  discimus libris legendis
@@ -190,13 +190,13 @@ module Linguistics
      #  -- Source, Wheelock
      #++
      ##
-     #alias_method :gerund, :gerundive 
-     def gerund
-       b = gerundive.sub /.*\s+(.*)um.*$/, "\\1"
-       b += "ī, ō, etc."
-       return b
-     end
-   end
- end
-end
+     #alias_method :gerund, :gerundive
+       def gerund
+         b = gerundive.sub( /.*\s+(.*)um.*$/, "\\1" )
+         b += "ī, ō, etc."
+         return b
+       end
+      end
+    end
+  end
 end