latinverb 0.9.2 → 0.9.3

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

@@ -7,7 +7,7 @@ module Linguistics
 
         class << self
 
-          ## 
+          ##
           #
           # Deponent verbs can be conceived as being the <em>the passive</em> results of
           # a regular verb where the passive form's result is then applied to the active
@@ -37,10 +37,10 @@ module Linguistics
           #
           ##
           def create_pseudo_active_mask_for_deponent(s)
-            parts = s.split /\s+/
+            parts = s.split( /\s+/ )
 
             # Turn the passive form into something that looks active
-            parts[0].sub! /or$/, 'ō'
+            parts[0].sub!( /or$/, 'ō' )
 
             # Turn the passive infinitive into something that looks active.
             # There's a subtle difference between:
@@ -49,160 +49,79 @@ module Linguistics
             #  Applying the first's rule to the second results in 'seque' not
             #  'sequere'.  Ergo the conditional.
             #
-            parts[1].sub! /ī$/, 'e'
+            parts[1].sub!( /ī$/, 'e' )
 
             # Fixes sequī -> sequere
             parts[1] += 're' unless parts[1] =~ /[āīē]re/
 
             # Set the 4th part to the value in the 3rd slot
             parts[3] = parts[2]
-             
+
             # Another modification for third conjugation deponents
-            parts[3].sub! /us$/, 'um'
+            parts[3].sub!( /us$/, 'um' )
 
-            # This value shouldn't be used...(I don't think...)
-            parts[2] = "JUNK" # 
+            # This value shouldn't be used
+            parts[2] = "PreventDeponentInfiniteRegress"
 
             parts.join(' ')
           end
-          ##
-          # 
-          # == 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
-          # 
-          # 
-          ##
-          def classify(s)
-
-            if s.class == String
-              divided_string = s.split /\s+/
-
-              first_pres = divided_string[0]
-              infinitive = divided_string[1]
-
-              return Linguistics::Latin::Verb::VerbTypes::Defective if
-                Linguistics::Latin::Verb::LatinVerb::DEFECTIVE_VERBS.member? first_pres
-
-              return Linguistics::Latin::Verb::VerbTypes::Irregular if
-                Linguistics::Latin::Verb::LatinVerb::IRREGULAR_VERBS.member? first_pres
-
-              return Linguistics::Latin::Verb::VerbTypes::Semideponent if
-                ( Linguistics::Latin::Verb::LatinVerb::SEMI_DEPONENTS.keys.any?{ |k| first_pres=~/#{k}$/} and
-                  s !~ /JUNK/ )  
-
-              return Linguistics::Latin::Verb::VerbTypes::Impersonal if
-                Linguistics::Latin::Verb::LatinVerb::IMPERSONAL_VERBS.member? s
-
-              if    infinitive =~ /āre$/
-                return Linguistics::Latin::Verb::VerbTypes::First
-              elsif infinitive =~ /ēre$/
-                return Linguistics::Latin::Verb::VerbTypes::Second
-              elsif infinitive =~ /ere$/
-                 if first_pres =~ /i.$/
-                   return Linguistics::Latin::Verb::VerbTypes::ThirdIO
-                 else
-                   return Linguistics::Latin::Verb::VerbTypes::Third
-                 end
-              elsif infinitive =~ /.+īre$/
-                return Linguistics::Latin::Verb::VerbTypes::Fourth
-              elsif (infinitive =~ /ī$/  and first_pres =~ /r$/)
-                return Linguistics::Latin::Verb::VerbTypes::Deponent
-              # Very irregular irregulars, A&G206, e/f
-              elsif s =~ %r'^(aiō|quaesō|ovāre)$'
-                return Linguistics::Latin::Verb::VerbTypes::Irregular
-              else
-                raise "Could not find a verb type for this verb #{infinitive} and #{first_pres}"
-              end
-            end
-          end
 
           ##
-          # 
+          #
           # == ARGUMENTS
-          # 
-          #    * pres_act_inf
-          # 
-          # == RETURNS      
-          # 
+          #
+          #    * present_active_infinitive
+          #
+          # == RETURNS
+          #
           # The “stem” of a Latin Verb
-          # 
-          # == PURPOSE      
-          # 
+          #
+          # == PURPOSE
+          #
           # Based on the present active infinitive, identify the “stem” and set the +@stem+
           # iVar.  The method also returns the stem value.
-          # 
+          #
           ##
-          def calculate_stem(pres_act_inf)
-            # TODO: For efficiency, if the iVar @stem is defined, don't go through this structure?
-            if pres_act_inf =~ /āre$/
-              return pres_act_inf.gsub(/(.*)āre$/,'\\1ā')
-            end
-            if pres_act_inf =~ /ēre$/
-              return pres_act_inf.gsub(/(.*)ēre$/,'\\1ē')
-            end
-            if pres_act_inf =~ /ere$/
-              if @first_pers_singular =~ /iō$/
-                return pres_act_inf.gsub(/(.*)ere$/,'\\1')
-              else
-                return pres_act_inf.gsub(/(.*)ere$/,'\\1')
-              end
-            end
-            if pres_act_inf =~ /īre$/
-              return pres_act_inf.gsub(/(.*)īre$/,'\\1')
-            end
-          end
 
           ##
-          # 
+          #
           # == ARGUMENTS
-          # 
+          #
           #     * first_person_singular
-          #     * pres_act_inf
-          # 
-          # == RETURNS      
-          # 
+          #     * present_active_infinitive
+          #
+          # == RETURNS
+          #
           # The participial “stem” of a Latin Verb, used for participle
           # formation
-          # 
-          # == PURPOSE      
-          # 
+          #
+          # == PURPOSE
+          #
           # Calculate the participial stem, used in forming participles.
-          # 
+          #
           ##
-          def calculate_participial_stem(first_pers_singular, pres_act_inf)
-             raise("pres_act_inf was nil![#{first_pers_singular} and #{pres_act_inf}]") if
-               pres_act_inf.empty? or first_pers_singular.empty?
+          def calculate_participial_stem(first_person_singular, present_active_infinitive)
+             raise("present_active_infinitive was nil![#{first_person_singular} and #{present_active_infinitive}]") if
+               present_active_infinitive.empty? or first_person_singular.empty?
 
-             if pres_act_inf.to_s =~ /(.*ā)re$/
+             if present_active_infinitive.to_s =~ /(.*ā)re$/
               return $1
             end
 
-            if pres_act_inf.to_s =~ /(.*ē)re$/
+            if present_active_infinitive.to_s =~ /(.*ē)re$/
               return $1
             end
 
-            if pres_act_inf.to_s =~ /(.*)ere$/
+            if present_active_infinitive.to_s =~ /(.*)ere$/
               match=$1
-              if first_pers_singular =~ /iō/
+              if first_person_singular =~ /iō/
                 return match + "iē"
               else
                 return match + "e"
               end
             end
 
-            if pres_act_inf.to_s =~ /(.*)īre$/
+            if present_active_infinitive.to_s =~ /(.*)īre$/
               return $1 + "iē"
             end
           end

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

@@ -1,6 +1,4 @@
 # encoding: UTF-8
-require 'json'
-
 module Linguistics
   module Latin
     module Verb
@@ -13,21 +11,22 @@ module Linguistics
         def self.json_create(o)
           new( o )
         end
-        
-        ##  
+
+        ##
         #
         # Presents the LatinVerb expressed as a hash with the names of the TenseBlock
         # specifiers as keys, and corresponding TenseBlock objects, converted to
         # Arrays, as the values.  It also contains the +original_string+.
         #
         ##
-        def to_hash 
+        def to_hash
+          data_structure = {}
           @tense_list.each do |t|
             ts = t.to_sym
-            @data_structure[ts]=self.send ts
+            data_structure[ts]=self.send ts
           end
-          @data_structure['original_string'] = @original_string
-          return @data_structure
+          data_structure['original_string'] = @original_string
+          return data_structure
         end
 
         alias_method :to_h, :to_hash
@@ -37,11 +36,9 @@ module Linguistics
         # Takes the hash that results from to_hash and then converts it to
         # YAML.
         #
-        ## 
+        ##
         def to_yaml
-          @data_structure.empty? ?
-            to_hash.to_yaml:
-            @data_structure.to_yaml
+          to_hash.to_yaml
         end
 
         alias_method :to_y, :to_yaml
@@ -53,7 +50,7 @@ module Linguistics
         ##
         def to_json(*a)
           json_hash = {'json_class' => self.class.name}
-          
+
           # In the case that we're working with a regular verb, the only thing
           # we need to save is the original string, since everything can be
           # re-derived from it easily.
@@ -68,7 +65,7 @@ module Linguistics
             end
             json_hash['tense_list' ]  = {}
             @tense_list.each do |t|
-              json_hash['tense_list'][t.to_s] = self.send t.to_sym 
+              json_hash['tense_list'][t.to_s] = self.send t.to_sym
             end
             json_hash['irregular']    = irregular?
             return json_hash.to_json(*a)
@@ -81,7 +78,7 @@ module Linguistics
         #
         ##
         def pretty_generate
-          JSON.pretty_generate(@data_structure.keys.length < 1 ? to_hash : @data_structure)
+          JSON.pretty_generate( self.to_h )
         end
 
       end

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

@@ -0,0 +1,17 @@
+module Linguistics
+  module Latin
+    module Verb
+      class LatinVerb
+        module DefectiveChecker
+          def self.is_it_defective?(instance)
+            first_person_present_tense = instance.first_person_singular
+            present_active_infinitive  = instance.present_active_infinitive
+            found = Linguistics::Latin::Verb::LatinVerb::PRESENT_ONLY.member?( first_person_present_tense ) ||
+                    Linguistics::Latin::Verb::LatinVerb::PRESENT_ONLY.member?( present_active_infinitive )
+            return Linguistics::Latin::Verb::Classification::PresentOnly if found
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,159 @@
+# encoding: UTF-8
+
+module Linguistics
+  module Latin
+    module Verb
+      class LatinVerb
+        module Deponent
+          # In a bit of cleverness, if the verb is deponent, we have built out
+          # this verb as if it were regular, but we have also created a
+          # @proxyVerb which is the active 'pseudo verb' corresponding to this
+          # verb.  We should be able to take this verb's active formulations
+          # and set their results to the @proxyVerb's passive formulations
+          #
+          # Ergo:  miror/mirari/miratus =~
+          # miro/mirare/PreventDeponentInfiniteRegress/miratus Therefore make a
+          # LatinVerb.new(miro/mirare/PreventDeponentInfiniteRegress/miratus).
+          # Take its passives and set them to this verb's actives.  This is
+          # actually what students do heuristically in Latin classes.
+
+          def self.included(including_class)
+            debugger
+            puts 'hi'
+          end
+
+          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_deponent_masking
+            end
+          end
+          ##
+          #
+          # Top-level method used to call the sub-methods which create a facade so that
+          # active_ vectors can be called on a deponent which actually forwards that
+          # call to a "fake" non-deponent (+@proxyVerb+) whose passives fit the correct
+          # morphology
+          #
+          # It calls the following methods, each of which applies the masking to a
+          # certain collection of vectors:
+          #
+          # * +deponent_swap+ :: active_voice* remaps "standard" calls like
+          # +active_voice_indicative_mood_present_tense...+
+          # * +deponent_imperative_mutations+ :: masks the imperatives
+          # * +deponent_participle_mutations+ :: masks the participles
+          # * +deponent_infinitive_mutations+ :: masks the infinitives
+          #
+          ##
+
+          def apply_deponent_masking
+            deponent_swap
+            deponent_imperative_mutations
+            deponent_participle_mutations
+            deponent_infinitive_mutations
+          end
+
+          ##
+          #
+          # The deponent's imperatives require a bit of consideration.  They don't
+          # follow the stem/stem+'ite' format.
+          #
+          ##
+
+          def deponent_imperative_mutations # :nodoc:
+            self.singleton_class.class_eval do
+              def active_voice_imperative_mood_present_tense_second_person_singular_number
+                return @proxyVerb.instance_variable_get '@present_active_infinitive'
+              end
+              def active_voice_imperative_mood_present_tense_second_person_plural_number
+                return @proxyVerb.send :passive_voice_indicative_mood_present_tense_second_person_plural_number
+              end
+              def active_voice_imperative_mood_future_tense_second_person_singular_number
+                k=@proxyVerb.send :passive_voice_indicative_mood_present_tense_second_person_plural_number
+                k.sub!(/minī$/, '')
+                k += 'tor'
+                Linguistics::Latin::Phonographia.fix_macrons k
+              end
+            end
+          end
+
+          def deponent_participle_mutations # :nodoc:
+            self.singleton_class.class_eval do
+              def present_active_participle
+                return @proxyVerb.present_active_participle
+              end
+
+              def future_active_participle
+                return @proxyVerb.future_active_participle
+              end
+
+              def perfect_active_participle
+                return @proxyVerb.perfect_passive_participle
+              end
+
+              def future_passive_participle
+                return @proxyVerb.future_passive_participle
+              end
+
+              # Mask the supine
+              def supine
+                return @proxyVerb.supine
+              end
+            end
+          end
+
+          def deponent_infinitive_mutations # :nodoc:
+            self.singleton_class.class_eval do
+              def present_active_infinitive
+                return @proxyVerb.send :present_passive_infinitive
+              end
+              def perfect_active_infinitive
+                return @proxyVerb.send :perfect_passive_infinitive
+              end
+              def future_active_infinitive
+                return @proxyVerb.send :future_active_infinitive
+              end
+            end
+          end
+
+          ##
+          #
+          # Swaps this verb's active_ vectors and replaces them with
+          # @proxyVerb's passive_ vectors.  This is pretty darned sneaky. See
+          # Also deponent_swap
+          #
+          ##
+
+          def deponent_swap
+            # First, get the methods that were defined in the proxy as passive
+
+            storage = {}
+
+            @tense_list.grep(/^passive/).each do |pass|
+              # Find the active correlate
+              active_corr = pass.to_s.sub( /^passive(.*)/, "active\\1" )
+
+              #  Keep @proxyVerb in the binding scope
+              pV = @proxyVerb
+
+              # In self, find the passive and save it's resultant object into a
+              # hash for future use.
+              self.singleton_class.class_eval do
+                storage[active_corr.to_sym] = pV.send(pass)
+              end
+            end
+
+            # Take the stored hashes and define instance methods on self such
+            # that we intercept the mixed-in methods ( C-c-c-combo breaker! ).
+            storage.each_pair do |k,v|
+              self.singleton_class.class_eval do
+                define_method k, lambda { return v }
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -1,4 +1,3 @@
-# encoding: UTF-8
 module Linguistics
   module Latin
     module Verb
@@ -14,7 +13,7 @@ module Linguistics
         # by more view-oriented libraries or applications.
         ##
         def display
-          STDERR.puts "You should not be going much displaying here as this is a LIBRARY.  Implement this elsewhere."
+          STDERR.puts "You should not be doing much displaying here as this is a LIBRARY.  Implement this elsewhere."
           pretty_generate
         end
       end

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

@@ -0,0 +1,34 @@
+module Linguistics
+  module Latin
+    module Verb
+      class LatinVerb
+        ##
+        #
+        # Some verbs only take a active/indic/pres/3rd/sg ("it rains").  For
+        # these we will not add the full vectors of methods, but will only
+        # respond to THAT vector.
+        #
+        ##
+        module Impersonal
+          def self.extended(extending_instance)
+            extending_instance.instance_eval do
+              prepare_present_only
+            end
+          end
+
+          def prepare_present_only
+            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

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

@@ -0,0 +1,83 @@
+# encoding: UTF-8
+module Linguistics
+  module Latin
+    module Verb
+      class LatinVerb
+        module Irregular
+          def self.extended(extending_instance)
+            extending_instance.instance_eval do
+              begin
+                os_sym = symbolize_original_string
+                json_string = Linguistics::Latin::Verb.const_get os_sym
+
+                raise "Found a JSON string with an absurdly small length!" if json_string.length <= 10
+                revivified_data_structure = JSON.parse( json_string )
+              rescue JSON::ParserError => e
+                puts "We were unable to parse JSON for #{@original_string} [o:#{o}] [o_sym:#{o_upcase_and_symbolic}].  Please verify your syntax."
+                raise e
+              rescue NameError => e
+                puts "We were unable to find a definition for #{@original_string}"
+                raise e
+              rescue => error
+                warn "#{@original_string} was identified as irregular but did not have a definition provided."
+                raise error
+              end
+
+              revivified_data_structure['tense_blocks'].each_pair do |k,v|
+                singleton_class.class_eval do
+                  define_method k.to_sym do
+                    TenseBlock.new v, { :meaning => MEANINGS[k.to_sym] }
+                  end
+                end
+              end
+
+              @irregular_infinitives = revivified_data_structure['infinitives']
+              @irregular_participles = revivified_data_structure['participles']
+
+              return if @irregular_infinitives.nil?
+              return if @irregular_participles.nil?
+
+              self.instance_eval do
+                def present_active_infinitive; return @irregular_infinitives.present_active_infinitive; end
+                def present_passive_infinitive; return @irregular_infinitives.present_passive_infinitive; end
+                def perfect_active_infinitive; return @irregular_infinitives.perfect_active_infinitive; end
+                def perfect_passive_infinitive; return @irregular_infinitives.perfect_passive_infinitive; end
+                def future_passive_infinitive; return @irregular_infinitives.future_passive_infinitive; end
+                def future_active_infinitive; return @irregular_infinitives.future_active_infinitive; end
+              end
+
+              self.instance_eval do
+                def present_active_participle; return @irregular_participles.present_active_participle; end
+                def future_active_participle; return @irregular_participles.future_active_participle; end
+                def perfect_passive_participle; return @irregular_participles.perfect_passive_participle; end
+                def future_passive_participle; return @irregular_participles.future_passive_participle; end
+                def gerundive; return @irregular_participles.gerundive; end
+                def gerund; return @irregular_participles.d; end
+              end
+            end
+          end
+
+          def symbolize_original_string
+            # Translation added to account for Ruby not liking constants /^/
+            # with a multibyte.  Probably a bug.
+            #
+            # This bug can be discovered by running #constants on
+            # Linguistics::Latin::Verb and seeing that Ōxxx is not found.  To
+            # fix this i had to store it as ODI_.  To make /that/ hack work, I
+            # had to add this bit beginning two lines below :-/
+            o = ActiveSupport::Multibyte::Chars.new( @original_string.gsub(/\s+/,'_') ).upcase
+
+            if o.match(/^([ĀĒĪŌŪ])(.*)/)
+              x=o[0,1].tr 'ĀĒĪŌŪ', 'AEIOU'
+              y=o[1,o.length]
+              o= x+y
+            end
+
+            o.to_sym
+          end
+
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,32 @@
+# encoding: UTF-8
+module Linguistics
+  module Latin
+    module Verb
+      class LatinVerb
+        class LatinVerbTypeEvaluator
+          def initialize(first_pres, infinitive, classifier)
+            return unless classifier.classification.to_s.split('::').last.eql?("Regular")
+            @type = if  infinitive =~ /āre$/
+              Linguistics::Latin::Verb::VerbTypes::First
+            elsif infinitive =~ /ēre$/
+              Linguistics::Latin::Verb::VerbTypes::Second
+            elsif infinitive =~ /ere$/
+              first_pres =~ /i.$/ ? Linguistics::Latin::Verb::VerbTypes::ThirdIO : Linguistics::Latin::Verb::VerbTypes::Third
+            elsif infinitive =~ /.+īre$/
+              Linguistics::Latin::Verb::VerbTypes::Fourth
+            elsif (infinitive =~ /ī$/  and first_pres =~ /r$/)
+              Linguistics::Latin::Verb::VerbTypes::Deponent
+            else
+              raise "Could not find a verb type for this verb #{infinitive} and #{first_pres}"
+            end
+          end
+
+          def inspect
+            return @type
+          end
+        end
+      end
+    end
+  end
+end
+