latinverb 0.9.3 → 0.9.4

data/lib/latinverb/components/principal_parts_extractor.rb

@@ -0,0 +1,35 @@
+module Linguistics
+  module Latin
+    module Verb
+      class LatinVerb
+        class LatinVerbPrincipalPartsExtractor
+          def initialize(input_string, classification)
+            @data_string = input_string
+            @classification = classification
+          end
+
+          def principal_parts
+            @data_string.split(/\s+/)
+          end
+
+          def first_person_singular
+            principal_parts[0]
+          end
+
+          def present_active_infinitive
+            principal_parts[1]
+          end
+
+          def first_person_perfect
+            principal_parts[2]
+          end
+
+          def passive_perfect_participle
+            principal_parts[3]
+          end
+
+        end
+      end
+    end
+  end
+end

data/lib/latinverb/components/stem_deriver.rb

@@ -0,0 +1,81 @@
+module Linguistics
+  module Latin
+    module Verb
+      class LatinVerb
+        class LatinverbStemDeriver
+          def initialize(verb)
+            @verb = verb
+          end
+
+          def stem
+            verb_is_regular? ?  calculate_stem : calculate_deponent_proxy_stem
+          end
+
+          def participial_stem
+            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
+
+          private
+
+          def calculate_deponent_proxy_stem
+            DeponentStringDeriver.new(@verb.original_string).proxy_string.split(/\s+/)[1]
+          end
+
+          def verb_is_regular?
+            @verb.classifier.regular?
+          end
+
+          def present_active_infinitive
+            @verb.present_active_infinitive
+          end
+
+          def first_person_singular
+            @verb.first_person_singular
+          end
+
+          def deponent_or_impersonal?
+            @verb.classifier.deponent? or @verb.classifier.semideponent? or @verb.classifier.impersonal?
+          end
+
+          def calculate_stem
+            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
+        end
+      end
+    end
+  end
+end

data/lib/latinverb/components/type_evaluator.rb

@@ -0,0 +1,35 @@
+module Linguistics
+  module Latin
+    module Verb
+      class LatinVerb
+        class LatinVerbTypeEvaluator
+          extend Forwardable
+          # "Type" is key stem associated with the verb versus the
+          # classification.  i.e. a verb might be "classified" as "Deponent"
+          # but has a "type" of first conjugation e.g. miror / mirari
+          def_delegators :@verb, :first_person_singular, :present_active_infinitive
+
+          def initialize(verb)
+            @verb = verb
+          end
+
+          def type
+            if present_active_infinitive =~ /āre$/
+              Linguistics::Latin::Verb::VerbTypes::First
+            elsif present_active_infinitive =~ /ēre$/
+              Linguistics::Latin::Verb::VerbTypes::Second
+            elsif present_active_infinitive =~ /ere$/
+              first_person_singular =~ /i.$/ ? Linguistics::Latin::Verb::VerbTypes::ThirdIO : Linguistics::Latin::Verb::VerbTypes::Third
+            elsif present_active_infinitive =~ /.+īre$/
+              Linguistics::Latin::Verb::VerbTypes::Fourth
+            elsif (present_active_infinitive =~ /ī$/  and first_person_singular =~ /r$/)
+              LatinVerb.new(DeponentStringDeriver.new(@verb.original_string).proxy_string).verb_type
+            else
+              Linguistics::Latin::Verb::VerbTypes::Irregular
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/latinverb/components/validator.rb

@@ -0,0 +1,33 @@
+module Linguistics
+  module Latin
+    module Verb
+      class LatinVerb
+        class Validator
+          def initialize(verb)
+            @verb = verb
+          end
+
+          def valid?
+            has_original_string? && has_classification? && has_stem?
+          end
+
+          private
+
+          def has_original_string?
+            !@verb.original_string.nil?
+          end
+
+          def has_classification?
+            !@verb.classification.nil?
+          end
+
+          def has_stem?
+            return true if @verb.irregular?
+            !@verb.stem.nil?
+          end
+        end
+      end
+    end
+  end
+end
+

data/lib/latinverb/components.rb

@@ -0,0 +1,9 @@
+require_relative './components/chart_presenter'
+require_relative './components/infinitivizer'
+require_relative './components/classifier'
+require_relative './components/principal_parts_extractor'
+require_relative './components/type_evaluator'
+require_relative './components/participler'
+require_relative './components/validator'
+require_relative './components/imperatives_handler'
+require_relative './components/stem_deriver'

data/lib/latinverb/dynamic_method_resolver.rb

@@ -0,0 +1,41 @@
+module Linguistics
+  module Latin
+    module Verb
+      class LatinVerb
+        class DynamicMethodResolver
+          def initialize(verb, method_name)
+            @verb = verb
+            @method_name = method_name.to_s
+          end
+
+          def components
+            @method_name.split('_')
+          end
+
+          def tense_method
+            Array(components[0..5]).join('_')
+          end
+
+          def vector_specifier
+            Array(components[6..-1]).join('_')
+          end
+
+          def supported_method?
+            !(tense_method.nil? || vector_specifier.nil?) && @method_name.match(/_/)
+          end
+
+          def apply!
+            if @verb.respond_to?(tense_method.to_sym)
+              tense_block = @verb.send(tense_method.to_sym)
+              return false if tense_block.nil?
+              tense_block.send(vector_specifier.to_sym)
+            else
+              false
+            end
+          end
+
+        end
+      end
+    end
+  end
+end

data/lib/latinverb/errors.rb

@@ -0,0 +1,10 @@
+module Linguistics
+  module Latin
+    module Verb
+      class LatinVerb
+        class LatinVerbInitializationError
+        end
+      end
+    end
+  end
+end

data/lib/latinverb/imperative_block/imperative_rule_factory.rb

@@ -0,0 +1,35 @@
+module Linguistics
+  module Latin
+    module Verb
+      class ImperativeBlock
+        class ImperativeRuleFactory
+          MAPPING = {
+            First: ->(stem, plural_present_imperative){ [stem, stem+"te"] },
+            Second: ->(stem, plural_present_imperative){ [stem, stem+"te"] },
+            ThirdIO: ->(stem, plural_present_imperative){ [stem+"e", stem+"ite"] },
+            Third: ->(stem, plural_present_imperative){ [stem+"e", stem+"ite"] },
+            Fourth: ->(stem, plural_present_imperative){ [stem+"ī", stem+"īte"] }
+          }
+
+          def initialize(verb)
+            @verb = verb
+          end
+
+          def present_tense_rule
+            MAPPING[type_key] || raise("Could not find mapping for #{type_key}")
+          end
+
+          private
+
+          def verb_type
+            @verb.verb_type
+          end
+
+          def type_key
+            verb_type.ordinal_name_key
+          end
+        end
+      end
+    end
+  end
+end

data/lib/latinverb/imperative_block.rb

@@ -0,0 +1,71 @@
+require_relative './imperative_block/imperative_rule_factory'
+
+module Linguistics
+  module Latin
+    module Verb
+      class ImperativeBlock
+        extend Forwardable
+        def_delegators :@results, :[], :to_a, :length
+
+        include Linguistics::Latin::Phonographia
+        def initialize(stem, plural_present_imperative, verb)
+          @stem = stem
+          @plural_present_imperative = plural_present_imperative
+          @verb = verb
+
+          if @verb.classification == Linguistics::Latin::Verb::Classification::Deponent
+            @results = form_imperative_base_for_deponent
+            add_additional_imperative_forms_for_deponent
+          else
+            @results = form_imperative_base
+            add_additional_imperative_forms
+          end
+
+          @results.map{|v| fix_macrons v}
+        end
+
+        def form_imperative_base_for_deponent
+          [@verb.stem, @verb.active_voice_indicative_mood_present_tense.plural_number_second_person, @verb.active_voice_indicative_mood_present_tense_third_person_singular_number.sub(/tur\z/, 'tor')]
+        end
+
+        def add_additional_imperative_forms_for_deponent
+        end
+
+        def present_tense_singular_number
+          present('singular')
+        end
+
+        def present_tense_plural_number
+          present('plural')
+        end
+
+        def future(qualifier=nil)
+          return @results[2,4] if qualifier.nil?
+        end
+
+        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
+
+        private
+
+        def add_additional_imperative_forms
+          stem = @stem || @verb.instance_variable_get(:@proxyVerb).stem
+          @results << stem + "tō"
+          @results << stem + "tōte"
+
+          @results << stem + "tō"
+          @results << stem + "ntō"
+        end
+
+        def form_imperative_base
+          ImperativeRuleFactory.new(@verb).present_tense_rule.call(@stem, @plural_present_imperative)
+        end
+      end
+    end
+  end
+end

data/lib/latinverb/paradigmatic_verbs.rb

@@ -0,0 +1,21 @@
+module Linguistics
+  module Latin
+    module Verb
+      class LatinVerb
+        ::AFIRST = new('amō amāre amāvī amatum')
+        ::ASECOND = LatinVerb.new('moneō monēre monuī monitum')
+        ::ATHIRD = LatinVerb.new('agō agere ēgī actum')
+        ::ATHIRDIO = LatinVerb.new('capiō capere cēpī captum')
+        ::AFOURTH = LatinVerb.new('audiō audīre audīvī auditum')
+
+        ::AFIRST_DEP =  LatinVerb.new('mīror mīrārī mīrātum')
+        ::ASECOND_DEP =  LatinVerb.new('vereor verērī veritum')
+        ::ATHIRD_DEP = LatinVerb.new('sequor sequī secūtum')
+        ::ATHIRDIO_DEP = LatinVerb.new('patior patī passum')
+        ::AFOURTH_DEP = LatinVerb.new('partior partīrī partītum')
+
+        ::SUM = LatinVerb.new('sum esse fuī futūrus')
+      end
+    end
+  end
+end

data/lib/latinverb/serialization/hash.rb

@@ -0,0 +1,17 @@
+module Linguistics
+  module Latin
+    module Verb
+      class LatinVerb
+        def to_hash
+          methods.grep(/tense\z/).inject({'original_string' => @original_string}) do |memo, tense_block_identifier|
+            ts = tense_block_identifier.to_sym
+            memo[ts] = self.send(ts)
+            memo
+          end
+        end
+
+        alias_method :to_h, :to_hash
+      end
+    end
+  end
+end

data/lib/latinverb/serialization/json.rb

@@ -0,0 +1,41 @@
+require 'json'
+
+module Linguistics
+  module Latin
+    module Verb
+      class LatinVerb
+        def self.json_create(o)
+          new(o)
+        end
+
+        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' ]  = {}
+            methods.grep(/tense\z/).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
+
+        def pretty_generate
+          JSON.pretty_generate(self.to_h)
+        end
+      end
+    end
+  end
+end

data/lib/latinverb/serialization/yaml.rb

@@ -0,0 +1,15 @@
+require 'yaml'
+
+module Linguistics
+  module Latin
+    module Verb
+      class LatinVerb
+        def to_yaml
+          to_hash.to_yaml
+        end
+
+        alias_method :to_y, :to_yaml
+      end
+    end
+  end
+end

data/lib/latinverb/serialization.rb

@@ -0,0 +1,3 @@
+require_relative './serialization/json'
+require_relative './serialization/yaml'
+require_relative './serialization/hash'

data/lib/latinverb/tense_block/null_tense_block.rb

@@ -0,0 +1,12 @@
+
+module Linguistics
+  module Latin
+    module Verb
+      class NullTenseBlock < TenseBlock
+        def initialize
+          super [ '', '', '', '', '', '']
+        end
+      end
+    end
+  end
+end

data/lib/latinverb/tense_block/vector_resolution_delegate.rb

@@ -0,0 +1,89 @@
+module Linguistics
+  module Latin
+    module Verb
+      class TenseBlock
+        class VectorResolutionDelegate
+          def initialize(results)
+            @results = results
+          end
+
+          def first_person_singular_number
+            @results[0]
+          end
+
+          def singular_number_first_person
+            @results[0]
+          end
+
+          def second_person_singular_number
+            @results[1]
+          end
+
+          def singular_number_second_person
+            @results[1]
+          end
+
+          def third_person_singular_number
+            @results[2]
+          end
+
+          def third_person_singular_number
+            @results[2]
+          end
+
+          def singular_number_third_person
+            @results[2]
+          end
+
+          def first_person_plural_number
+            @results[3]
+          end
+
+          def plural_number_first_person
+            @results[3]
+          end
+
+          def second_person_plural_number
+            @results[4]
+          end
+
+          def plural_number_second_person
+            @results[4]
+          end
+
+          def third_person_plural_number
+            @results[5]
+          end
+
+          def plural_number_third_person
+            @results[5]
+          end
+
+          def first_person
+            [ @results[0], @results[3] ]
+          end
+
+          def second_person
+            [ @results[1], @results[4] ]
+          end
+
+          def third_person
+            [ @results[2], @results[5] ]
+          end
+
+          def singular_number
+            [ @results[0],
+              @results[1],
+              @results[2] ]
+          end
+
+          def plural_number
+            [ @results[3],
+              @results[4],
+              @results[5] ]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/latinverb/tense_block.rb

@@ -0,0 +1,52 @@
+require_relative './tense_block/vector_resolution_delegate'
+require_relative './tense_block/null_tense_block'
+
+module Linguistics
+  module Latin
+    module Verb
+      class TenseBlock
+        include Linguistics::Latin::Phonographia
+
+        extend Forwardable
+        def_delegators :@results, :[], :empty?, :length, :to_a
+        def_delegators :@resolver, :first_person_singular_number,
+          :singular_number_first_person, :second_person_singular_number,
+          :singular_number_second_person, :third_person_singular_number,
+          :third_person_singular_number, :singular_number_third_person,
+          :first_person_plural_number, :plural_number_first_person,
+          :second_person_plural_number, :plural_number_second_person,
+          :third_person_plural_number, :plural_number_third_person,
+          :first_person, :second_person, :third_person,
+          :singular_number, :plural_number
+
+        attr_reader :meaning, :results
+
+        def initialize(r, opts={})
+          @results = Array(r).map{ |v| fix_macrons(v) }
+          @meaning = opts[:meaning] || ""
+          @resolver = VectorResolutionDelegate.new(@results)
+        end
+
+        def to_s
+          to_a.to_s
+        end
+
+        def wordless?
+          !@results.find{ |r| r =~ /\w/ }
+        end
+
+        def to_json(*a)
+          {
+            'json_class'   => self.class.name,
+            'data'         => @results.map{|i| i.to_json}
+          }.to_json(*a)
+        end
+
+        def TenseBlock.json_create(o)
+         new(o['data'])
+        end
+      end
+    end
+  end
+end
+

data/lib/latinverb/tense_method_applicator/defective_checker.rb

@@ -0,0 +1,21 @@
+module Linguistics
+  module Latin
+    module Verb
+      class LatinVerb
+        class DefectiveChecker
+          extend Forwardable
+          def_delegators :@verb, :first_person_singular, :present_active_infinitive
+
+          def initialize(verb)
+            @verb = verb
+          end
+
+          def defective?
+            Linguistics::Latin::Verb::PRESENT_ONLY.member?(first_person_singular) ||
+              Linguistics::Latin::Verb::PRESENT_ONLY.member?(present_active_infinitive)
+          end
+        end
+      end
+    end
+  end
+end