latinverb 0.9.3 → 0.9.4

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: c7d01401c1e463c6685484ef6aed12e2ddb89f57
+  data.tar.gz: 90d118e985a430efb4f1b9c78c6c32224e5a3ade
+SHA512:
+  metadata.gz: d0bd88ebc7d39429081475d0bc6491b2bb009edd706db40c3bc1670d41739e0428ec8fc920396cd7fd9d5637dc3beaf9ea21812506bc1abb3c6db910345a6c4e
+  data.tar.gz: a8515ecbadfbd60bd5148830997c8377219ae57b884cf3966e15f5d680e5f6598664510d726738f54320ccb3fa50baf594351b8d2d93fe5bf8d6024b1ab19d44

data/Gemfile

@@ -5,4 +5,5 @@ gemspec
 
 group :development do
   gem 'autotest-standalone'
+  gem 'byebug'
 end

data/Gemfile.lock

@@ -1,24 +1,46 @@
 PATH
   remote: .
   specs:
-    latinverb (0.9.2)
+    latinverb (0.9.3)
+      activesupport
+      linguistics_latin
       macronconversions
+      rake
       rdoc
-      verbvector
 
 GEM
   remote: http://rubygems.org/
   specs:
-    autotest-standalone (4.5.10)
-    json (1.7.5)
+    activesupport (4.0.0)
+      i18n (~> 0.6, >= 0.6.4)
+      minitest (~> 4.2)
+      multi_json (~> 1.3)
+      thread_safe (~> 0.1)
+      tzinfo (~> 0.3.37)
+    atomic (1.1.14)
+    autotest-standalone (4.5.11)
+    byebug (2.2.2)
+      columnize (~> 0.3.6)
+      debugger-linecache (~> 1.2.0)
+    columnize (0.3.6)
+    debugger-linecache (1.2.0)
+    i18n (0.6.5)
+    json (1.8.1)
+    linguistics_latin (0.0.1)
     macronconversions (0.0.1)
-    rdoc (3.12)
+    minitest (4.7.5)
+    multi_json (1.8.2)
+    rake (10.1.0)
+    rdoc (4.0.1)
       json (~> 1.4)
-    verbvector (0.0.1)
+    thread_safe (0.1.3)
+      atomic
+    tzinfo (0.3.38)
 
 PLATFORMS
   ruby
 
 DEPENDENCIES
   autotest-standalone
+  byebug
   latinverb!

data/README.markdown

@@ -14,7 +14,7 @@ and get back `amaretur`.
 ### HANDLING AMBIGUITY
 
 LatinVerb also has tolerances for ambiguity.  Where
-passive\_voice\_subjunctive\_mood\_imperfect\_tense\_third\_person\_singular\_number
+`passive_voice_subjunctive_mood_imperfect_tense_third_person_singular_number`
 is considered a "full" vector that uniquely identifies one value, it is
 possible to pass "incomplete" vectors such as
 `passive_voice_subjunctive_mood_imperfect_tense_third_person` which

data/Rakefile

@@ -13,5 +13,6 @@ end
 
 Rake::TestTask.new do  |t|
   t.ruby_opts = [ '-rminitest/pride' ]
+  t.test_files = FileList['test/**/*test*.rb']
   t.verbose = true
 end

data/latinverb.gemspec

@@ -20,7 +20,9 @@ Gem::Specification.new do |s|
   s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
   s.require_paths = ["lib"]
 
-  s.add_dependency("macronconversions")
-  s.add_dependency("verbvector")
-  s.add_dependency("rdoc")
+  s.add_runtime_dependency("macronconversions")
+  s.add_runtime_dependency("linguistics_latin")
+  s.add_runtime_dependency("rdoc")
+  s.add_runtime_dependency("rake")
+  s.add_runtime_dependency("activesupport")
 end

data/lib/latinverb/components/chart_presenter.rb

@@ -0,0 +1,81 @@
+module Linguistics
+  module Latin
+    module Verb
+      class LatinVerb
+        class ChartPresenter
+          def initialize(verb)
+            @verb = verb
+          end
+
+          def chart
+            f="%9s%15s%15s%15s\n"
+            f_subjunctive="%9s%15s%15s%15s%15s\n"
+            c_prep "Present System", [
+                                      @verb.active_voice_indicative_mood_present_tense,
+                                      @verb.active_voice_indicative_mood_imperfect_tense,
+                                      @verb.active_voice_indicative_mood_future_tense
+                                     ], %w/Present Imperfect Future/,f
+            puts "\n"
+            c_prep "Perfect System", [ @verb.active_voice_indicative_mood_perfect_tense,
+                                       @verb.active_voice_indicative_mood_pastperfect_tense,
+                                       @verb.active_voice_indicative_mood_futureperfect_tense
+                                     ], %w/Perfect Past-Perfect Future-Perfect/,f
+            puts "\n"
+            c_prep "Passive Present System", [
+                                              @verb.passive_voice_indicative_mood_present_tense,
+                                              @verb.passive_voice_indicative_mood_imperfect_tense,
+                                              @verb.passive_voice_indicative_mood_future_tense
+                                             ], %w/Present Imperfect Future/,f
+            puts "\n"
+            c_prep "Passive Perfect System", [ @verb.passive_voice_indicative_mood_perfect_tense,
+                                               @verb.passive_voice_indicative_mood_pastperfect_tense,
+                                               @verb.passive_voice_indicative_mood_futureperfect_tense
+                                             ], %w/Perfect Past-Perfect Future-Perfect/,f
+            puts "\n"
+
+
+            c_prep "Subjunctives", [ @verb.active_voice_subjunctive_mood_present_tense,
+                                     @verb.active_voice_subjunctive_mood_imperfect_tense,
+                                     @verb.active_voice_subjunctive_mood_perfect_tense,
+                                     @verb.active_voice_subjunctive_mood_pastperfect_tense
+                                   ], %w/Present Imperfect Perfect Past-Perfect/,f_subjunctive
+            puts "\n"
+            c_prep "Passive Subjunctives", [ @verb.active_voice_subjunctive_mood_present_tense,
+                                             @verb.active_voice_subjunctive_mood_imperfect_tense,
+                                             @verb.active_voice_subjunctive_mood_perfect_tense,
+                                             @verb.active_voice_subjunctive_mood_pastperfect_tense
+                                           ], %w/Present Imperfect Perfect Past-Perfect/,f_subjunctive
+            puts "\n"
+            puts "Participles"
+            @verb.methods.grep(/_participle$/).each do |p|
+              printf "%42s %42s\n", p.to_s.gsub('_', ' ').gsub(/\b\w/){$&.upcase}, @verb.send(p)
+            end
+            puts "\n"
+            puts "Infinitives"
+            @verb.methods.grep(/infinitive$/).each do |p|
+              printf "%42s %42s\n", (p.to_s.gsub('_', ' ').gsub(/\b\w/){$&.upcase}), @verb.send(p)
+            end
+            return nil
+          end
+
+          alias_method :c, :chart
+          private
+
+          def c_prep(heading, rays, subtitles, format_string)
+            puts heading
+            puts '=' * heading.length + "\n"
+            printf format_string, '', *subtitles
+            underbars = subtitles.map{|j| j.gsub!(  /./, '=' )}
+            printf format_string, '', *underbars
+            vertical_transform( rays ).each{|a| printf format_string, *a}
+          end
+
+          def vertical_transform( opts = [] )
+            # Get the length of the first array to be verticalized
+            ['1st Sg.', '2nd Sg.', '3rd Sg.','1st Pl.', '2nd Pl.', '3rd Pl.'].zip(*opts)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/latinverb/components/classifier/strategies/defective_verb_classification_strategy.rb

@@ -0,0 +1,19 @@
+module Linguistics
+  module Latin
+    module Verb
+      class LatinVerb
+        class LatinVerbClassifier
+          class DefectiveVerbClassificationStrategy < VerbClassificationStrategy
+            def self.classification
+              Classification::Defective
+            end
+
+            def applicable?
+              Linguistics::Latin::Verb::DEFECTIVE_VERBS.member? first_pres
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/latinverb/components/classifier/strategies/deponent_verb_classification_strategy.rb

@@ -0,0 +1,19 @@
+module Linguistics
+  module Latin
+    module Verb
+      class LatinVerb
+        class LatinVerbClassifier
+          class DeponentVerbClassificationStrategy < VerbClassificationStrategy
+            def self.classification
+              return Classification::Deponent
+            end
+
+            def applicable?
+              infinitive =~ /ī$/ && first_pres =~ /r$/
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/latinverb/components/classifier/strategies/impersonal_verb_classification_strategy.rb

@@ -0,0 +1,19 @@
+module Linguistics
+  module Latin
+    module Verb
+      class LatinVerb
+        class LatinVerbClassifier
+          class ImpersonalVerbClassificationStrategy < VerbClassificationStrategy
+            def self.classification
+              Classification::Impersonal
+            end
+
+            def applicable?
+              Linguistics::Latin::Verb::IMPERSONAL_VERBS.member?(input)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/latinverb/components/classifier/strategies/irregular_verb_classification_strategy.rb

@@ -0,0 +1,19 @@
+module Linguistics
+  module Latin
+    module Verb
+      class LatinVerb
+        class LatinVerbClassifier
+          class IrregularVerbClassificationStrategy < VerbClassificationStrategy
+            def self.classification
+              Classification::Irregular
+            end
+
+            def applicable?
+              Linguistics::Latin::Verb::IRREGULAR_VERBS.member? first_pres
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/latinverb/components/classifier/strategies/present_only_verb_classification_strategy.rb

@@ -0,0 +1,21 @@
+require 'latinverb/components/present_only_checker'
+
+module Linguistics
+  module Latin
+    module Verb
+      class LatinVerb
+        class LatinVerbClassifier
+          class PresentonlyVerbClassificationStrategy < VerbClassificationStrategy
+            def self.classification
+              Classification::PresentOnly
+            end
+
+            def applicable?
+              PresentOnlyChecker.new(input).present_only?
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/latinverb/components/classifier/strategies/regular_verb_classification_strategy.rb

@@ -0,0 +1,19 @@
+module Linguistics
+  module Latin
+    module Verb
+      class LatinVerb
+        class LatinVerbClassifier
+          class RegularVerbClassificationStrategy < VerbClassificationStrategy
+            def self.classification
+              Classification::Regular
+            end
+
+            def applicable?
+              true
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/latinverb/components/classifier/strategies/semideponent_verb_classification_strategy.rb

@@ -0,0 +1,19 @@
+module Linguistics
+  module Latin
+    module Verb
+      class LatinVerb
+        class LatinVerbClassifier
+          class SemideponentVerbClassificationStrategy < VerbClassificationStrategy
+            def self.classification
+              Classification::Semideponent
+            end
+
+            def applicable?
+              Linguistics::Latin::Verb::SEMI_DEPONENTS.keys.any?{ |k| first_pres=~/#{k}$/} && input !~ /PreventDeponentInfiniteRegress/
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/latinverb/components/classifier/strategies/verb_classification_strategy.rb

@@ -0,0 +1,31 @@
+module Linguistics
+  module Latin
+    module Verb
+      class LatinVerb
+        class LatinVerbClassifier
+          class VerbClassificationStrategy
+            def initialize(classifier)
+              @classifier = classifier
+            end
+
+            protected
+
+            def first_pres
+              return "" unless input
+              input.split(/\s+/)[0]
+            end
+
+            def infinitive
+              return "" unless input
+              input.split(/\s+/)[1]
+            end
+
+            def input
+              @classifier.input || ''
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/latinverb/components/classifier/strategies/very_irregular_verb_classification_strategy.rb

@@ -0,0 +1,20 @@
+module Linguistics
+  module Latin
+    module Verb
+      class LatinVerb
+        class LatinVerbClassifier
+          class VeryIrregularVerbClassificationStrategy < VerbClassificationStrategy
+            # Very irregular irregulars, A&G206, e/f
+            def self.classification
+              Classification::Irregular
+            end
+
+            def applicable?
+              input =~ %r'^(aiō|quaesō|ovāre)$'
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/latinverb/components/classifier.rb

@@ -0,0 +1,76 @@
+require_relative 'classifier/strategies/verb_classification_strategy'
+require_relative 'classifier/strategies/defective_verb_classification_strategy'
+require_relative 'classifier/strategies/irregular_verb_classification_strategy'
+require_relative 'classifier/strategies/semideponent_verb_classification_strategy'
+require_relative 'classifier/strategies/impersonal_verb_classification_strategy'
+require_relative 'classifier/strategies/very_irregular_verb_classification_strategy'
+require_relative 'classifier/strategies/deponent_verb_classification_strategy'
+require_relative 'classifier/strategies/present_only_verb_classification_strategy'
+require_relative 'classifier/strategies/regular_verb_classification_strategy'
+
+module Linguistics
+  module Latin
+    module Verb
+      class LatinVerb
+        class LatinVerbClassifier
+          attr_reader :classification, :input
+
+          def initialize(input, opts={})
+            @input = input
+            @strategies = opts[:strategies] || default_strategies
+          end
+
+          def classification
+            applicable_strategy = @strategies.detect do |strategy|
+              strategy.new(self).applicable?
+            end
+            applicable_strategy.classification
+          end
+
+          def present_only?
+            classification == Linguistics::Latin::Verb::Classification::PresentOnly
+          end
+
+          def deponent?
+            classification == Linguistics::Latin::Verb::Classification::Deponent
+          end
+
+          def semideponent?
+            classification == Linguistics::Latin::Verb::Classification::Semideponent
+          end
+
+          def impersonal?
+            classification == Linguistics::Latin::Verb::Classification::Impersonal
+          end
+
+          def irregular?
+            classification == Linguistics::Latin::Verb::Classification::Irregular
+          end
+
+          def regular?
+            classification == Linguistics::Latin::Verb::Classification::Regular
+          end
+
+          def short_class
+            classification.to_s.gsub(/.*::(\w+)$/,"\\1")
+          end
+
+          private
+
+          def default_strategies
+            [
+              DefectiveVerbClassificationStrategy,
+              IrregularVerbClassificationStrategy,
+              SemideponentVerbClassificationStrategy,
+              ImpersonalVerbClassificationStrategy,
+              VeryIrregularVerbClassificationStrategy,
+              PresentonlyVerbClassificationStrategy,
+              DeponentVerbClassificationStrategy,
+              RegularVerbClassificationStrategy
+            ]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/latinverb/components/imperatives_handler.rb

@@ -0,0 +1,40 @@
+module Linguistics
+  module Latin
+    module Verb
+      class LatinVerb
+        class ImperativesHandler
+          extend Forwardable
+
+          def_delegators :@verb, :stem, :present_active_infinitive
+
+          IMPERATIVE_EXCEPTIONS = {
+            "ducere"   => %w(duc ducite),
+            "dicere"   => %w(dic dicite),
+            "facere"   => %w(fac facite),
+            "ferre"    => %w(fer ferte),
+            "nolere"   => %w(nolo nolite)
+          }
+
+          def initialize(verb)
+            @verb = verb
+          end
+
+          def imperatives
+            args = exceptional_imperative? ? calculate_exceptional_imperatives : [stem, present_active_infinitive]
+            Linguistics::Latin::Verb::ImperativeBlock.new(*args, @verb)
+          end
+
+          private
+
+          def exceptional_imperative?
+            IMPERATIVE_EXCEPTIONS.has_key?(present_active_infinitive)
+          end
+
+          def calculate_exceptional_imperatives
+            IMPERATIVE_EXCEPTIONS[present_active_infinitive]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/latinverb/components/infinitivizer.rb

@@ -0,0 +1,50 @@
+require_relative './passive_infinitive_factory'
+
+module Linguistics
+  module Latin
+    module Verb
+      class LatinVerb
+        class Infinitivizer
+          extend Forwardable
+
+          def_delegators :@verb, :first_person_perfect, :future_active_participle, :verb_type, :present_active_infinitive, :perfect_passive_participle, :supine
+
+          def initialize(verb)
+            @verb = verb
+          end
+
+          def infinitives
+            {
+              :present_active_infinitive  => present_active_infinitive,
+              :perfect_active_infinitive  => perfect_active_infinitive,
+              :future_active_infinitive   => future_active_infinitive,
+              :present_passive_infinitive => present_passive_infinitive,
+              :perfect_passive_infinitive => perfect_passive_infinitive,
+              :future_passive_infinitive  => future_passive_infinitive
+            }
+          end
+
+          def perfect_active_infinitive
+            first_person_perfect + "sse"
+          end
+
+          def future_active_infinitive
+            future_active_participle.sub(/,.*/,'') + " esse"
+          end
+
+          def present_passive_infinitive
+            PassiveInfinitiveVactory.new(@verb).passive_infinitive
+          end
+
+          def perfect_passive_infinitive
+            perfect_passive_participle + " esse"
+          end
+
+          def future_passive_infinitive
+            supine[:accusative] + " īrī"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/latinverb/components/participler.rb

@@ -0,0 +1,58 @@
+module Linguistics
+  module Latin
+    module Verb
+      class LatinVerb
+        class Participler
+          include Linguistics::Latin::Phonographia
+          extend Forwardable
+
+          def_delegators :@verb, :passive_perfect_participle, :participial_stem
+
+          def initialize(verb)
+            @verb = verb
+          end
+
+          def present_active_participle
+            raise "Participial stem was nil" if  participial_stem.nil?
+            endings = %w(ns ntis)
+            endings.collect{ |x| fix_macrons(participial_stem + x.chomp) }.join(', ')
+          end
+
+          def future_active_participle
+            mybase = passive_perfect_participle.gsub(/u[sm]$/, "ūr")
+            singular_endings = %w(us a um)
+            singular_endings.collect{ |x| mybase + "#{x}".chomp }.join(', ')
+          end
+
+          def perfect_passive_participle
+            mybase = passive_perfect_participle.sub(/u[sm]$/,'')
+            singular_endings=%w(us a um)
+            singular_endings.collect{ |x| mybase + "#{x}".chomp }.join(', ')
+          end
+
+          def future_passive_participle
+            mybase = participial_stem + "nd"
+            singular_endings = %w(us a um)
+            singular_endings.collect{ |x| fix_macrons(mybase + "#{x}".chomp) }.join(', ')
+          end
+
+          def gerundive
+            @verb.future_passive_participle
+          end
+
+          def gerund
+            b = gerundive.sub( /.*\s+(.*)um.*$/, "\\1" )
+            b += "ī, ō, etc."
+          end
+
+          def supine
+            acc = passive_perfect_participle
+            abl = acc.sub( /^(.*)um$/, "\\1" )
+            abl += "ū"
+            {:ablative => abl, :accusative => acc}
+          end
+        end
+      end
+    end
+  end
+end

data/lib/latinverb/components/passive_infinitive_factory.rb

@@ -0,0 +1,42 @@
+module Linguistics
+  module Latin
+    module Verb
+      class LatinVerb
+        class Infinitivizer
+          class PassiveInfinitiveVactory
+            extend Forwardable
+            def_delegators :@verb, :present_active_infinitive, :verb_type
+
+            MAPPING = {
+              First: [/(.*)e$/,"\\1ī"],
+              Second: [/(.*)e$/,"\\1ī"],
+              ThirdIO: [/(.*)ere$/,"\\1ī"],
+              Third: [/(.*)ere$/,"\\1ī"],
+              Fourth: [/(.*)e$/,"\\1ī"],
+              Irregular: [/(.*)/,"\\1"]
+            }
+
+
+            def initialize(verb)
+              @verb = verb
+            end
+
+            def passive_infinitive
+              present_active_infinitive.gsub(*mutation_for_type)
+            end
+
+            private
+
+            def mutation_for_type
+              MAPPING[type_key]
+            end
+
+            def type_key
+              verb_type.ordinal_name_key
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/latinverb/components/present_only_checker.rb

@@ -0,0 +1,32 @@
+module Linguistics
+  module Latin
+    module Verb
+      class LatinVerb
+        class PresentOnlyChecker
+          def initialize(original_string)
+            @original_string = original_string
+          end
+
+          def present_only?
+            listed_as_present_only?
+          end
+
+          private
+
+          def listed_as_present_only?
+             Linguistics::Latin::Verb::PRESENT_ONLY.member?( first_person_present_tense ) ||
+               Linguistics::Latin::Verb::PRESENT_ONLY.member?( present_active_infinitive )
+          end
+
+          def first_person_present_tense
+            @original_string.split(/\s+/)[0]
+          end
+
+          def present_active_infinitive
+            @original_string.split(/\s+/)[1]
+          end
+        end
+      end
+    end
+  end
+end