latinverb 0.2.0 → 0.9.2

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

@@ -0,0 +1,208 @@
+# encoding: UTF-8
+
+require 'linguistics/latin/verb/phonographia'
+require 'yaml'
+
+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.class == 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
+
+
+#-------------------------------------------------------------------------------
+#-------------------------------------------------------------------------------
+      ##
+      #
+      # The InfinitiveBlock holds the infinitives associated with a given
+      # verb.  The known infinitives are the following:
+      #
+      # * 
+      class InfinitiveBlock
+        attr_reader :infinitive_methods
+        def initialize(s)
+          if s.class == Hash
+            @infinitive_methods = s.keys
+          end
+
+          @infinitive_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
+
+      class ImperativeBlock
+        def initialize(stem,ppi)
+          # In case we get an Array, for JSON revivification
+          if stem.class == Array
+            @results = stem
+          end
+
+          r = case
+              when ppi =~ /āre$/
+                [stem, stem+"te"]
+              when ppi =~ /ēre$/           
+                [stem, stem+"te"]
+              when ppi =~ /ere$/
+                [stem+"e", stem+"ite"]
+              when ppi =~ /īre$/
+                [stem+"ī", stem+"īte"]
+              end 
+
+          r << stem + "tō"
+          r << stem + "tōte"
+
+          r << stem + "tō"
+          r << stem + "ntō"
+ 
+          @results = r.map{|v| Linguistics::Latin::Phonographia.fix_macrons v}
+        end
+
+        def to_s
+          return @results
+        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 self.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
+
+        ##
+        #
+        # Returns the two, second person imperatives
+        #
+        ##
+        def present(qualifier=nil)
+          j=@results[0,2]
+          return j if qualifier.nil?
+          qualifier = qualifier.to_s
+          return j[0] if qualifier =~ /singular/
+          return j[1] if qualifier =~ /plural/
+        end
+
+        ##
+        #
+        # Returns the four, second and third person future imperatives
+        #
+        ##
+        def future(qualifier=nil)
+          return j=@results[2,4] if qualifier.nil?
+
+          # case
+          #   when qualifier =~ /second_person/
+          #     if qualifier =~ /singular/
+          #       return j[0]
+          #     elsif qualifier =~ /plural/
+          #       return j[2]
+          #     else
+          #       return [ j[0], j[2] ]
+          #     end
+          #   when qualifier =~ /third_person/
+          #     if qualifier =~ /singular/
+          #       return j[1]
+          #     elsif qualifier =~ /plural/
+          #       return j[3]
+          #     else
+          #       return [ j[1], j[3] ]
+          #     end
+          #   else
+          #     raise "[future] could not parse this imperative"
+          #   end
+          # end
+        end
+
+        def method_missing(sym,*args)
+           if (sym =~ /^(present|future)_tense_(.*)/)
+             self.send($1.to_sym, $2) 
+           else
+             super
+           end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,215 @@
+# encoding:  UTF-8
+
+module Linguistics
+  module Latin
+    module Verb
+      class LatinVerb
+
+        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
+          # vector specification.  Ergo the dictum "passive in form but active in
+          # meaning."  As such, when we realize we have a deponent verb, we will create
+          # its standard four principal part string sibling.  This, in turn, could be
+          # used to create a LatinVerb.  Then through some method deletion or aliasing,
+          # the active vector can be used to point to the (in fact) passive result
+          #
+          # For example:
+          #
+          # <pre>
+          # j = LatinVerb.new conor conārī conatus
+          # # create_pseudo_active_mask_for_deponent creates (conō, conāre, conāvī
+          # conatus)
+          # # Do magic so that active_voice_indicative_mood_present_tense points to
+          # passive_voice_indicative_mood_present_tense
+          # </pre>
+          #
+          # ===ARGUMENTS
+          #
+          # s :: A deponent description string to be pesudo-mapped
+          #
+          # ===RETURNS
+          #
+          # A pseudo-mapped, four principal-part string
+          #
+          ##
+          def create_pseudo_active_mask_for_deponent(s)
+            parts = s.split /\s+/
+
+            # Turn the passive form into something that looks active
+            parts[0].sub! /or$/, 'ō'
+
+            # Turn the passive infinitive into something that looks active.
+            # There's a subtle difference between:
+            # 'vereor verērī veritum'
+            # 'sequor sequī secūtus'
+            #  Applying the first's rule to the second results in 'seque' not
+            #  'sequere'.  Ergo the conditional.
+            #
+            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'
+
+            # This value shouldn't be used...(I don't think...)
+            parts[2] = "JUNK" # 
+
+            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      
+          # 
+          # The “stem” of a Latin Verb
+          # 
+          # == 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      
+          # 
+          # The participial “stem” of a Latin Verb, used for participle
+          # formation
+          # 
+          # == 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?
+
+             if pres_act_inf.to_s =~ /(.*ā)re$/
+              return $1
+            end
+
+            if pres_act_inf.to_s =~ /(.*ē)re$/
+              return $1
+            end
+
+            if pres_act_inf.to_s =~ /(.*)ere$/
+              match=$1
+              if first_pers_singular =~ /iō/
+                return match + "iē"
+              else
+                return match + "e"
+              end
+            end
+
+            if pres_act_inf.to_s =~ /(.*)īre$/
+              return $1 + "iē"
+            end
+          end
+
+        end
+      end
+    end
+  end
+end
+

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

@@ -0,0 +1,90 @@
+# encoding: UTF-8
+require 'json'
+
+module Linguistics
+  module Latin
+    module Verb
+      class LatinVerb
+        ##
+        #
+        # Required method for JSON deserialization
+        #
+        ##
+        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 
+          @tense_list.each do |t|
+            ts = t.to_sym
+            @data_structure[ts]=self.send ts
+          end
+          @data_structure['original_string'] = @original_string
+          return @data_structure
+        end
+
+        alias_method :to_h, :to_hash
+
+        ##
+        #
+        # 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
+        end
+
+        alias_method :to_y, :to_yaml
+
+        ##
+        #
+        # Required method for JSON deserialization
+        #
+        ##
+        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.
+          unless self.irregular?
+            # While this single string is sufficient to freeze and revivifty
+            # the verb, it means that the JSON structure is rather vacuous.
+            # Given this, the hash is enriched so that the JSON data is
+            # useful.  Nevertheless, in the revivification process, only
+            # 'orig_string' is used.
+            %w{original_string classification stem}.each do |k|
+              json_hash[k] = self.send k.to_sym
+            end
+            json_hash['tense_list' ]  = {}
+            @tense_list.each do |t|
+              json_hash['tense_list'][t.to_s] = self.send t.to_sym 
+            end
+            json_hash['irregular']    = irregular?
+            return json_hash.to_json(*a)
+          end
+        end
+
+        ##
+        #
+        # Dumps the LatinVerb as pretty JSON
+        #
+        ##
+        def pretty_generate
+          JSON.pretty_generate(@data_structure.keys.length < 1 ? to_hash : @data_structure)
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,23 @@
+# encoding: UTF-8
+module Linguistics
+  module Latin
+    module Verb
+      class LatinVerb
+
+        ##
+        #
+        # <b>You should not be using this, probably</b>
+        #
+        # This is a a convenience method so that you can print out the
+        # contents in a human-readable fashion.  LatinVerb is a library that
+        # _should be implemented elsewhere_ where its results can be presented
+        # 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."
+          pretty_generate
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,79 @@
+# encoding: UTF-8
+
+=begin rdoc
+#--
+# The purpose of this module is to contain the metaprogramming modules
+# method_missing and respond_to? in a place that's nice and neat.
+# ++
+=end
+
+module Linguistics
+  module Latin
+    module Verb 
+      class LatinVerb
+
+=begin rdoc
+
+=== DESCRIPTION
+
+Override of the method_missing method.  A lot of the magic of LatinVerb
+happens here.  This method has deep interactoion with the Verbvector results
+called as part of the LatinVerb.initialize call path.
+
+=== INTERNALS
+
+Given a symbol that is undefined, we look to +@tense_list+ first.  The typical
+case would be a call on a 3/5ths vector identification.  Therefore if the call
+is pure nonsense, the symbol will not be found on the first evaluation and go
+to super.  Assuming that the symbol IS a partial vector call, it will match
+through the iteration of the values in +@tense_list+.  Based on the match, two
+Regexp values are derived:
+
+* the first 3/5ths (enough to get a TenseBlock), called a +tense_method+
+* the last 2/5ths  (enough to specify a value out of that TenseBlock), called a +vector_specifier+
+
+Given those two names, the tense_method is called on the LatinVerb with +send+
+and _that_ resultant value, a TenseBlock, undergoes a +send+ call to the
+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
+          end
+          super
+        end
+
+        ##
+        #
+        # We override respond_to so that we respond to the normal object
+        # models as well as accept the method_missing utilized names as well.
+        # 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
+        end
+      end
+    end
+  end
+end
+

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

@@ -0,0 +1,66 @@
+# encoding: UTF-8
+
+module Linguistics
+  module Latin
+    module Verb
+      ##
+      # == NAME 
+      #
+      # Validation
+      #
+      # == DESCRIPTION
+      #
+      # This module contains the validity testing methods, when mixed into a
+      # LatinVerb, will provide it the ability to ensure its own sanity.
+      #
+      ##
+      module Validation
+
+        ##
+        #
+        # == DESCRIPTION
+        #
+        # This performs the basic task of evaluating the given string (cf.
+        # 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
+        # 1.  Identify a stem (+@stem+), provided the verb is regular
+        #
+        ##
+        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
+        end
+      end
+    end
+  end
+end
+