latinirb 0.3.1 → 0.3.3

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 33a4eb72ec314b4bf5d1675a36249098b3a94b8e
+  data.tar.gz: d9211cd70e5f8ed8d06700d3470d12f21db7d2d0
+SHA512:
+  metadata.gz: 2a7a7c9863e7990fe8ba045022c475273930fa172bcec99c28d950eb5f5006f0fe742ef95630a30454ac8c004d92af070282d04b2f94ac27fdba97fdfc98337b
+  data.tar.gz: eeb287faed0fc71ebefb8a1058db91717e8d050676eee4b5319517233f330a89b1c3413dfb0c4263720504ca795e76071bea06e807a1dc9399102250aeaffb8e

data/Gemfile.lock

@@ -0,0 +1,47 @@
+PATH
+  remote: .
+  specs:
+    latinirb (0.3.1)
+      activesupport (>= 4)
+      latinverb (~> 0.9.4)
+
+GEM
+  remote: http://rubygems.org/
+  specs:
+    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)
+    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)
+    latinverb (0.9.4)
+      activesupport
+      linguistics_latin
+      macronconversions
+      rake
+      rdoc
+    linguistics_latin (0.0.1)
+    macronconversions (0.0.1)
+    minitest (4.7.5)
+    multi_json (1.8.2)
+    rake (10.1.0)
+    rdoc (4.0.1)
+      json (~> 1.4)
+    thread_safe (0.1.3)
+      atomic
+    tzinfo (0.3.38)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  byebug
+  latinirb!

data/README.markdown

@@ -4,7 +4,8 @@
 
 LatinIRB is an IRB session in which a user can interact with paradigmatic
 Latin verbs (`@aFirst`, `@aSecond`, `@aThird`, `@aThirdIO`, `@aFourth`) as
-calculated heuristically by the LatinVerb library.  
+calculated heuristically by the
+[LatinVerb](https://github.com/sgharms/LatinVerb) library.
 
 The methods of chief interest will be those that are _vectors_ within the
 LatinVerb parlance i.e. methods that uniquely identify a specific conjugated
@@ -14,9 +15,9 @@ An primary use case would be:
   
   @aFirst.active\_voice\_indicative\_mood\_present\_tense\_first\_person\_singular\_number #=> amō
 
-Upon opening the script, the student may play with verbs offered for
+Upon opening the session, the student may play with verbs offered for
 exploration.  These are the standard paradigmatics verbs presented in
-Wheelock:
+Wheelock as well as three core irregular verbs:
 
 <table>
   <tr><th>Varible  </th> <th>Parts                      </th> <th> Meaning</th></tr>
@@ -25,6 +26,9 @@ Wheelock:
   <tr><td>@aThird  </td> <td>agō   agere  ēgī    actum  </td> <td> to do / lead / undertake</td></tr>
   <tr><td>@aThirdIO</td> <td>capiō capere cēpī   captum </td> <td> to grab / seize</td></tr>
   <tr><td>@aFourth </td> <td>audiō audīre audīvī auditum</td> <td> to hear</td></tr>
+  <tr><td>@toBe    </td> <td>sum   esse   fuī    futūrus</td> <td> to be </td></tr>
+  <tr><td>@toCarry </td> <td>ferō  ferre  tulī   lātum</td>   <td> to carry </td></tr>
+  <tr><td>@toCome  </td> <td>eō    īre    īvī    itum</td>    <td> to come </td></tr>
 </table>
 
 ## INSTANTIATING
@@ -51,33 +55,30 @@ both understand it.
 
   LatinVerb.new %w(amō   amāre  amāvī  amatum)
 
-## EXECUTING METHODS  
-
-Every verb in latin is a "vector" comprised of the voice / mood / tense /
-number / and person
-
 ### CHART VIEW
 
-*Currently Unimplemented:  1 June 2011:  Implementation underway*
-
-To view the chart of a verb, use LatinVerb.chart\_display.  This is a basic
+To view the chart of a verb, use LatinVerb.chart.  This is a basic
 chart that will look familiar to students.  
 
+## EXECUTING METHODS
+
+Every verb in latin is a "vector" comprised of the voice / mood / tense /
+number / and person.
+
 ### SINGULAR VECTOR
 
-As such methods are of the form 
+As such methods are of the form:
 
-  (active|passive)\_voice\_(indicative|subjunctive)\_mood\_(present|imperfect|perfect|pastperfect|futureperfect|etc.)tense\_first\_person\_singular\_number
+  (active|passive)\_voice\_(indicative|subjunctive)\_mood\_(present|imperfect|perfect|pastperfect|futureperfect|etc.)tense\_(first|second|third)\_person\_(singular|plural)\_number
 
-This will return a single value.  Where the result is ambiguous (e.g. 'number' is not provided) multiple values are returned.
-an exhaustive list of options follows below.
+This will return a single value.  Where the result is ambiguous (e.g. 'number'
+is not provided) multiple values are returned.  an exhaustive list of options
+follows below.
 
 ### MULTIPLEX VECTORS
 
-Several convenience methods exist which load multiple tenses at the same time such as "present system" or "perfect system".  These
-methods load the tenses into the @collections iVar associated with the LatinVerb.  This value can be accessed as @collections
-is shared per attr\_reader
-
+Several convenience methods exist which load multiple vectors at the same time
+such as "present tense."  For their invocation, see below
 
 ### Comprehensive List of Singular Vectors
 
@@ -222,19 +223,59 @@ is shared per attr\_reader
   * LatinVerb.passive\_voice\_subjunctive\_mood\_pastperfect\_tense\_second\_person\_plural\_number
   * LatinVerb.passive\_voice\_subjunctive\_mood\_pastperfect\_tense\_third\_person\_plural\_number
              
-  * LatinVerb.imperatives[0]
-  * LatinVerb.imperatives[1]
-             
+  * LatinVerb.active\_voice\_imperative\_mood\_future\_tense
+  * LatinVerb.active\_voice\_imperative\_mood\_present\_tense
+  * LatinVerb.imperatives (_aggregator method_)
+
   * LatinVerb.present\_active\_participle 
   * LatinVerb.future\_active\_participle
   * LatinVerb.perfect\_passive\_participle
   * LatinVerb.future\_passive\_participle
              
-  * LatinVerb.present\_active\_infinitive
-  * LatinVerb.perfect\_active\_infinitive
+  * LatinVerb.infinitives (_aggregator method_ : returns a keyed hash)
   * LatinVerb.future\_active\_infinitive
+  * LatinVerb.future\_passive\_infinitive
+  * LatinVerb.perfect\_active\_infinitive
+  * LatinVerb.perfect\_passive\_infinitive
+  * LatinVerb.present\_active\_infinitive
   * LatinVerb.present\_passive\_infinitive
-  * LatinVerb.perfect\_passive\_infinitive)
+
+### Ambiguous Methods
+  A voice, mood, and tense are all required for resolution of answers.
+  LatinVerb does not repsect ambiguity in those vectors.  It _does_ respect
+  ambiguity in the person and number specifiers.  Thus, you *may* say:
+
+
+  * LatinVerb.active\_voice\_indicative\_mood\_present\_tense\_first\_person
+  * LatinVerb.active\_voice\_indicative\_mood\_present\_tense\_singular\_number
+
+  This will return an array containing all possible candidates.  Thus, for
+  each of the items below <em>(first|second|third)_person</em> or
+  <em>(singular|plural)_number</em> may be postpended.
+
+  * LatinVerb.active\_voice\_imperative\_mood\_future\_tense
+  * LatinVerb.active\_voice\_imperative\_mood\_present\_tense
+  * LatinVerb.active\_voice\_indicative\_mood\_future\_tense
+  * LatinVerb.active\_voice\_indicative\_mood\_futureperfect\_tense
+  * LatinVerb.active\_voice\_indicative\_mood\_imperfect\_tense
+  * LatinVerb.active\_voice\_indicative\_mood\_pastperfect\_tense
+  * LatinVerb.active\_voice\_indicative\_mood\_perfect\_tense
+  * LatinVerb.active\_voice\_indicative\_mood\_present\_tense
+  * LatinVerb.active\_voice\_subjunctive\_mood\_imperfect\_tense
+  * LatinVerb.active\_voice\_subjunctive\_mood\_pastperfect\_tense
+  * LatinVerb.active\_voice\_subjunctive\_mood\_perfect\_tense
+  * LatinVerb.active\_voice\_subjunctive\_mood\_present\_tense
+  * LatinVerb.passive\_voice\_indicative\_mood\_future\_tense
+  * LatinVerb.passive\_voice\_indicative\_mood\_futureperfect\_tense
+  * LatinVerb.passive\_voice\_indicative\_mood\_imperfect\_tense
+  * LatinVerb.passive\_voice\_indicative\_mood\_pastperfect\_tense
+  * LatinVerb.passive\_voice\_indicative\_mood\_perfect\_tense
+  * LatinVerb.passive\_voice\_indicative\_mood\_present\_tense
+  * LatinVerb.passive\_voice\_subjunctive\_mood\_imperfect\_tense
+  * LatinVerb.passive\_voice\_subjunctive\_mood\_pastperfect\_tense
+  * LatinVerb.passive\_voice\_subjunctive\_mood\_perfect\_tense
+  * LatinVerb.passive\_voice\_subjunctive\_mood\_present\_tense
+
 
 ## AUTHOR
 

data/Rakefile

@@ -1,14 +1,14 @@
 require 'bundler'
-require "rake/rdoctask" 
+require "rdoc/task"
+require "rake/testtask"
 
 Bundler::GemHelper.install_tasks
 
-# Generate documentation
-Rake::RDocTask.new do |rd| 
-rd.rdoc_files.include("lib/**/*.rb")
-rd.rdoc_dir = "rdoc" 
-end   
+task :default => :test
+
+RDoc::Task.new do |rd|
+  rd.rdoc_dir = "rdoc"
+  rd.rdoc_files.include("lib/**/*.rb")
+end
 
-#Added to get testing working
-require 'rake/testtask'
 Rake::TestTask.new(:test)

data/bin/latinirb

@@ -1,7 +1,5 @@
 #!/usr/bin/env ruby
 
-# Add the gem libraries to the Ruby path
-$:.unshift File.join(File.dirname(__FILE__), *%w[.. lib])
-
-require 'latinirb'
+require 'active_support/all'
+require 'LatinIRB'
 Linguistics::Latin::Util::LatinIRB.begin

data/latinirb.gemspec

@@ -12,18 +12,13 @@ Gem::Specification.new do |s|
   s.summary     = %q{Gem designed to explore verbs created by LatinVerb}
   s.description = %q{This gem takes initial data describing a LatinVerb and allows this is be instantiated into an IRB session.  Here the verb can be queried or displayed.}
 
-
-  s.rubyforge_project = "latinverb"
-
   s.files         = `git ls-files`.split("\n")
   s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
   s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
   s.require_paths = ["lib"]
 
-  s.add_runtime_dependency 'latinverb', '>= 0.9.0'
-  s.add_runtime_dependency 'macronconversions'
-  s.add_runtime_dependency 'verbvector'
-  s.add_runtime_dependency 'active_support', '>= 3.0'
-
+  s.add_development_dependency 'byebug'
 
+  s.add_runtime_dependency 'latinverb', '~> 0.9.5'
+  s.add_runtime_dependency 'activesupport', '>= 4'
 end

data/lib/LatinIRB.rb

@@ -3,9 +3,6 @@
 require 'irb'
 require 'irb/completion'
 require 'latinverb'
-require 'latinirb/paradigmatic_verbs'
-require 'macronconversions'
-require 'pp'
 
 # Monkey-patch to change the gets behavior.  In the gem, the FileInputMethod
 # class's 'gets' method always prints out what was read.  This should be
@@ -37,7 +34,7 @@ module Linguistics
           # object's options and proceed.
           #
           #+++
-          
+
           IRB.setup(nil)
           @CONF = IRB.conf
 
@@ -58,14 +55,14 @@ module Linguistics
           # Create an irb object that is programmed to (silently, per above)
           # source a configuration file that ends with a call to 'irb' itself
           # after defining several instance variables
-          
+
           irb = IRB::Irb.new(nil, @CONF[:SCRIPT])
 
           # Create a LatinIRB prompt
           @CONF[:PROMPT][:LATINIRB] = {
-                                        :PROMPT_I    => "LatinIRB > ", 
+                                        :PROMPT_I    => "LatinIRB > ",
                                         :PROMPT_S    => "LatinIRB%l> ",
-                                        :PROMPT_C    => "LatinIRB > ", 
+                                        :PROMPT_C    => "LatinIRB > ",
                                         :PROMPT_N    => "LatinIRB ?> ",
                                         :RETURN      => " => %s \n",
                                         :AUTO_INDENT => true
@@ -82,16 +79,23 @@ module Linguistics
           # LatinVerb, the full complement of vectors should be provided as
           # complet-able.  IF NOT, then the pairing is passed to the standard
           # CompletionProc.
-          
+
           Readline.completion_proc = calculate_completion_proc
 
           # We have finished the configuration at this point, so now we need
           # to kick up the REPL after providing preliminary instruction.
           puts "Beginning a LatinVerb session."
 
-          puts "The following verbs have been made available to this session via latirb.rb:"
+          puts "The following verbs have been made available to this session:"
+
+          # Open the file and extract the names of the variables that can be
+          # used for autocompletion
+          @irb_ivars =
+            File::open(irb.context.io.file_name).readlines.grep(/^@/).map do |x|
+              x.sub(/(@\w+)\s.*\n/, "\\1")
+            end
+          @irb_ivars.each{|x| puts "  * #{x}\n"}
 
-          instance_variables.grep(/[a-z]/).each{|x| puts "  * #{x}"}
 
           puts "Tab-completion of the conjugation \"vectors\" is supported."
 
@@ -119,7 +123,7 @@ module Linguistics
         # based on the regex of "message."
         #
         ##
-        
+
         def self.select_message(receiver, message, candidates)
           candidates.grep(/^#{message}/).collect do |e|
             case e
@@ -144,14 +148,16 @@ module Linguistics
         ##
 
         def self.calculate_completion_proc
-          proc do |input| 
+          proc do |input|
             bind = IRB.conf[:MAIN_CONTEXT].workspace.binding
 
             input =~ /^([^."].*)\.([^.]*)$/
             begin
               receiver = $1
               message = Regexp.quote($2)
-              rObj = instance_variable_get(receiver.to_sym)
+
+              # Pull the object from the binding
+              rObj = eval("instance_variable_get(:#{receiver})", bind)
             rescue Exception
             end
 
@@ -159,13 +165,12 @@ module Linguistics
               IRB::InputCompletor::select_message(receiver, message, rObj.instance_methods.grep(/^#{message}/))
             elsif input =~ /^@/
               # This handles instance variables.  input is @someInstanceVariable's @aSomeIn<TAB>
-              self.select_message(input, input, eval("instance_variables", bind).grep(/^@a/))
+              self.select_message input, input, eval("instance_variables", bind).grep(/@[at]/)
             else
               IRB::InputCompletor::CompletionProc.call input
             end
           end
         end
-
       end
     end
   end

data/lib/latinirb/version.rb

@@ -1,9 +1,8 @@
-# encoding: UTF-8
 module Linguistics
   module Latin
     module Util
       class LatinIRB
-        VERSION = "0.3.1" # :nodoc:
+        VERSION = "0.3.3" # :nodoc:
       end
     end
   end

data/lib/latirb.rb

@@ -6,6 +6,11 @@
 @aThirdIO = Linguistics::Latin::Verb::LatinVerb.new %q(capiō capere cēpī   captum)
 @aFourth  = Linguistics::Latin::Verb::LatinVerb.new %q(audiō audīre audīvī auditum)
 
+# Popular Irregulars
+@toBe     = Linguistics::Latin::Verb::LatinVerb.new %q(sum esse fuī futūrus)
+@toCarry  = Linguistics::Latin::Verb::LatinVerb.new %q(ferō ferre tulī lātum)
+@toCome   = Linguistics::Latin::Verb::LatinVerb.new %q(eō īre ivī itum)
+
 # It's handy to have these two methods defined here for simple tests of the
 # code and demonstrations.
 

metadata

@@ -1,108 +1,97 @@
---- !ruby/object:Gem::Specification 
+--- !ruby/object:Gem::Specification
 name: latinirb
-version: !ruby/object:Gem::Version 
-  prerelease: 
-  version: 0.3.1
+version: !ruby/object:Gem::Version
+  version: 0.3.3
 platform: ruby
-authors: 
+authors:
 - Steven G. Harms
 autorequire: 
 bindir: bin
 cert_chain: []
-
-date: 2011-06-04 00:00:00 Z
-dependencies: 
-- !ruby/object:Gem::Dependency 
-  name: latinverb
-  prerelease: false
-  requirement: &id001 !ruby/object:Gem::Requirement 
-    none: false
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        version: 0.9.0
-  type: :runtime
-  version_requirements: *id001
-- !ruby/object:Gem::Dependency 
-  name: macronconversions
+date: 2013-10-22 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: byebug
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
   prerelease: false
-  requirement: &id002 !ruby/object:Gem::Requirement 
-    none: false
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        version: "0"
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: latinverb
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.9.5
   type: :runtime
-  version_requirements: *id002
-- !ruby/object:Gem::Dependency 
-  name: verbvector
   prerelease: false
-  requirement: &id003 !ruby/object:Gem::Requirement 
-    none: false
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        version: "0"
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.9.5
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '4'
   type: :runtime
-  version_requirements: *id003
-- !ruby/object:Gem::Dependency 
-  name: active_support
   prerelease: false
-  requirement: &id004 !ruby/object:Gem::Requirement 
-    none: false
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        version: "3.0"
-  type: :runtime
-  version_requirements: *id004
-description: This gem takes initial data describing a LatinVerb and allows this is be instantiated into an IRB session.  Here the verb can be queried or displayed.
-email: 
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '4'
+description: This gem takes initial data describing a LatinVerb and allows this is
+  be instantiated into an IRB session.  Here the verb can be queried or displayed.
+email:
 - steven.harms@gmail.com
-executables: 
+executables:
 - latinirb
 extensions: []
-
 extra_rdoc_files: []
-
-files: 
+files:
 - .gitignore
 - Gemfile
+- Gemfile.lock
 - README.markdown
 - Rakefile
 - bin/latinirb
 - latinirb.gemspec
-- latinverb.rb
 - lib/LatinIRB.rb
-- lib/latinirb/paradigmatic_verbs.rb
 - lib/latinirb/version.rb
 - lib/latirb.rb
 homepage: http://rubygems.org/gems/latinverb
 licenses: []
-
+metadata: {}
 post_install_message: 
 rdoc_options: []
-
-require_paths: 
+require_paths:
 - lib
-required_ruby_version: !ruby/object:Gem::Requirement 
-  none: false
-  requirements: 
-  - - ">="
-    - !ruby/object:Gem::Version 
-      version: "0"
-required_rubygems_version: !ruby/object:Gem::Requirement 
-  none: false
-  requirements: 
-  - - ">="
-    - !ruby/object:Gem::Version 
-      version: "0"
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
 requirements: []
-
-rubyforge_project: latinverb
-rubygems_version: 1.8.5
+rubyforge_project: 
+rubygems_version: 2.0.2
 signing_key: 
-specification_version: 3
+specification_version: 4
 summary: Gem designed to explore verbs created by LatinVerb
 test_files: []
-

data/latinverb.rb

@@ -1,544 +0,0 @@
-# encoding: utf-8
-
-module Latin
-
-=begin rdoc
-
-== Description
-  
-LatinVerb is a class for turning a given 4-part string of:
-
- * active voice, present, first person singular:   amō, or amo
- * present, active infinitive: amāre, or amare
- * present, perfect, first person singular: amāvī, or amavi
- * perfect passive participle: amatum, or amatus
-
-Into a fully-exploded, fully conjugated Latin verb ( like you would see in
-chart forms on Wikipedia et in locis alteriis.  
-
-These are traditionally given in Wheelock as:
-<tt>amō, amāre, amāvī, amatum</tt>
-
-Philosophically, in this class, we keep attributes and methods which are 
-used to define the meta-structure of the verb.  The specific verb calls 
-("Give me the present active participles" or "Give me the present tense
-active indicative class") are handled metaprogrammatically and held
-in Latin::LatinConjugation.
-
-=end
-
-
-  class LatinVerb < Latin::LatinWord
-    include Latin::Conjugation
-    include Latin::Display
-=begin    
-
-Scalar, created during initialization
-These are iVar's pointing to the “four principal parts” of a Latin
-verb.  
-
-=end
-    
-    attr_reader :first_pers_singular, :pres_act_inf, 
-                :first_pers_perf, :pass_perf_part, :conjugation
-
-=begin    
-
-Conjugation state, set by metapgrogrammatically handling the method
-call.  Latin verbs have voice, mood, tense, number, and person.  The
-:voice, :mood, etc. iVars will trap this.  The default mode
-use case is to return all number / person “nodes” in a given 
-tense.  As such, the number and person are not stored here as iVars.
-
-=end
-    
-    attr_reader :voice, :mood, :tense, :number, :person
-    
-=begin    
-
-Here are iVars that are used in calculation of nodes.
-
-Stem is a place to store the verb stem e.g. amare=>ama, dicere => dic
-Vector is the original method that's passed.  As mentioned above, we
-take a metaprogrammatic approach to handling method calls to the 
-object.  @vector records the method call that is trapped by
-method_missing?(id,*opts)
-
-Participal stem is used as the base for forming participles.
-
-Response   is stored.  It is a hash
-with only one pair: the name of the collection accessed, and the block
-of nodes ( or a single node, if it has been defined in such an 
-explicit fashion )
-
-Collections is is where the displayable payload is stored.  
-
-=end
-
-    attr_reader :stem, :participial_stem, :vector, :response,
-                :collections
-    
-=begin    
-
-Array
-
-Four_pp is an aray of the four principal parts ( headers on listings)
-
-=end
-    
-    attr_reader :four_pp
-
-=begin
-
-##############################################################################
-METHOD DECLARATION
-##############################################################################
-
-=end
-
-=begin rdoc
-
-<b>Arguments</b>:    Array containing 4 principal parts
-
-<b>Attribs Used</b>: N/A
-
-<b>Attribs Set</b>:  @four_pp, @first_pers_singular, @pres_act_inf, 
-@first_pers_perf, @pass_perf_part, @four_pp, 
-@voice_mood_matrix, @stem ( via #calculate_stem)
-
-*Returns*:      Instance of LatinVerb
-
-*Purpose*:  A LatinVerb is created by passing an array of the four principal 
-parts that define a Latin Verb.  Typically these are: They are defined in an array: 
-<tt>amō   amāre  amāvī  amatum</tt>.
-
-=end
-        
-    def initialize(*params)
-      
-      # Creates an array of LatinWords for each of the passed-in parameters
-      # Each principal part is given its own iVar
-      
-      @four_pp = params[0].map { |a_principal_part| Latin::LatinWord.new(a_principal_part) }    
-      
-      if @four_pp.length != 4 
-        deponent_handler if @four_pp[2] =~ /sum$/
-      end
-      
-      irregular_handler(@four_pp[1])
-      
-          
-      @first_pers_singular, @pres_act_inf, 
-      @first_pers_perf, @pass_perf_part = @four_pp
-
-      # Create a top-level matrix that defines active_indicative / 
-      # passive_indicative, etc.  
-      #
-      #                     ____________
-      #                    |   | X | Y |
-      #                    | 1 | a | b |
-      #                    | 2 | c | d |
-      #                    -------------
-      #
-      # In this case we have “voice by mood”
-      
-      @voice_mood_matrix = TenseBlock.new( {
-                          :boundaries => 'voice by mood',
-                          :voice      => %w(Active Passive),
-                          :mood       => %w(Indicative Subjunctive),
-                          :tense      => nil,
-                          :default_p  => lambda {
-                            |x,y| "#{x.downcase}_voice_#{y.downcase}_mood" 
-                          }
-                        } 
-                      )
-
-      # Given the 4 PP's, we can now derive the stem
-      @stem = Latin::LatinWord.new(calculate_stem)
-      
-      # Set my conjugation
-      @conjugation = evaluate_conjugation
-      
-      # Calculate participal stem
-      @participial_stem = Latin::LatinWord.new(calculate_participial_stem)
-      
-      # Where to store things to-be displayed
-      @collections = []
-
-      
-    end
-
-=begin rdoc
-
-*Arguments*:    Unrecognized method call, optional arguments
-
-<b>Attribs Used</b>: N/A
-
-<b>Attribs Set</b>:  @vector 
-
-*Returns*:      Instance of LatinVerb
-
-*Purpose*:  The method calls to a verb object can vary in over 100 ways, as such, coding that many methods seemed painful.  Accordingly, we trap the unknown method call, parse it, and set iVars.
-            
-Having identified the iVars, we are able to call a hash structure
-containing lambdas to do the appropriate processing based on the “vector”
-of voice, mood, tense, person, etc.
-
-=end
-    def method_missing(id, *args)    
-      # We expect that method calls will be made to the object in the form:
-      # V.active_voice_indicative_mood_present_tense.  Instead of having to 
-      # create all these methods, we will look for unknown methods containing 
-      # the pattern _voice_
-   
-      if id.to_s =~ /_voice_/
-        
-        @vector = id.to_s
-        
-        # This assignation needs to be done each call to the metaprog.
-        # method because of the event that a verb was called for
-        # a tense vector, and then a node vector.  The first instance's 
-        # filling in of @number, @person will cause the second call to do
-        # the wrong thing
-        
-        @number = @person = nil
-        evaluate_method(id)
-
-        # In the case that the instance has been used before to get 
-        # a specific vector, then we want to clear it out
-        @collections=[] if  not @person.nil? and not @collections.nil?
-        
-        generated_method = [@voice,@mood,@tense].join('_').to_sym
-        
-        raise("Method #{generated_method.to_} is not responded to!") unless 
-          self.respond_to?(generated_method)
-
-        raise ("FLAMING DETH:  pass to handler method returned nothing!") if 
-          self.send(generated_method.to_sym).nil?
-        
-          
-        @collections << 
-          conjoin_nodes_with_labels(
-            self.send(generated_method),
-            TenseBlock.new( {
-                                :boundaries => 'numbers by persons',
-                                :numbers    => %w(Singular Plural),
-                                :persons    => %w(First Second Third),
-                                :tense      => 'present',
-                              } 
-                            )
-          )
-      else
-        super(id)
-      end
-    end
-
-    def to_s
-      display!("\n")
-    end
-    
-    def definition_string
-      return @four_pp.join(', ').to_s
-    end
-=begin
-
-##############################################################################
-#   PRIVATE METHODS BELOW
-##############################################################################
-
-=end
-    private 
-
-=begin rdoc
-
-*Arguments*:    None
-
-*Attribs Used*: @pres_act_inf
-
-*Attribs Set*:  None
-
-*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.
-
-=end
-
-    def calculate_stem
-      # For efficiency, if the iVar @stem is defined, don't go through this structure
-
-      pres_act_inf = @pres_act_inf.to_s
-
-      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 =~ /io$/
-          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
-    
-=begin rdoc
-
-
-*Arguments*:    None
-
-*Attribs Used*: @pres_act_inf
-
-*Attribs Set*:  @conjugation
-
-*Returns*:      The “stem” of a Latin Verb
-
-*Purpose*:      Based on the present, active infinitive, decide on the conjugation.  This method requires that the endings be macron-ized in order to differentiate between _ere_ ( 2nd conjugation ) and _ere_ ( 4th conjugation).  It returns the value as a String: <tt>1</tt>, <tt>2</tt>, <tt>3</tt>, <tt>4</tt>, or <tt>3IO</tt> (e.g. <i>duco/ducere</i>)
-
-=end
-
-    def evaluate_conjugation
-      ending = @pres_act_inf.get_last_three_characters
-      returnValue = nil
-      
-      if ending =~ /āre$/
-        returnValue = "1"
-      end
-
-      if ending =~ /ēre$/
-        returnValue = "2"
-      end    
-
-      if ending =~ /ere$/
-        if @first_pers_singular.get_last_three_characters =~ /iō$/
-          returnValue = "3IO"
-        else     
-          returnValue = "3"
-        end
-      end
-
-      if ending =~ /īre$/
-        returnValue = "4"
-      end    
-      
-      return returnValue
-    end
-
-=begin rdoc
-
-Calculate the participial stem, used in forming participles.
-
-=end
-
-    def calculate_participial_stem
-       raise("@pres_act_inf was nil!") if 
-         @pres_act_inf.nil? or @first_pers_singular.nil?
-
-       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
-    
-    
-=begin
-
-This is used to print out a full vector's nodes.  The value
-of @vector is used as a title. The nodes that were produced
-by means of the lambda are then printed out.
-
-=end
-
-    def conjoin_nodes_with_labels(nodes,labels)
-      raise "conjoin_nodes failed to receieve a node or label set" if
-        nodes.nil? or labels.nil?        
-      paired_node_array=[]
-
-      0.upto(labels.length-1) do |i| 
-        paired_node_array.push(Latin::LatinNode.new(labels.matrix[i], 
-          nodes[i], {:displayable => 'valuesonly'}) )
-      end
-      
-      tense_label = @vector.capitalize!.split(/_/).join(' ')
-      
-      full_tense  =  Latin::LatinTense.new(tense_label, paired_node_array)
-      
-      if @person.nil? and @number.nil?     # For handling ...present_tense
-         return full_tense
-      elsif @number.nil? and not @person.nil? # number not defined; person yes
-        
-        # Find the methods that match the parameter that we were given
-        matching_methods = 
-         full_tense.verb_methods.map {|x|  x if x =~ /#{@person}/}.compact!
-
-        # Call those methods and store the result to an array
-        ambiguous_results = 
-        matching_methods.map{|aMethod| full_tense.send(aMethod.to_sym)}
-        
-        # Return it
-        return ambiguous_results.join(", ")
-      elsif not @number.nil? and @person.nil?
-        # This guy is really just the inverse of the above.
-
-        # Find the methods that match the parameter that we were given
-        matching_methods = 
-         full_tense.verb_methods.map {|x|  x if x =~ /#{@number}/}.compact!
-
-        # Call those methods and store the result to an array
-        ambiguous_results = 
-        matching_methods.map{|aMethod| full_tense.send(aMethod.to_sym)}
-        
-        # Return it
-        return ambiguous_results.join(", ")
-        
-      elsif not @number.nil? and not @person.nil? # fully specified node
-         locate_string = [@number,'number',@person,'person',].join('_')
-         return full_tense.send(locate_string.to_sym)
-      end
-
-    end
-    
-    # This method is used internally to evaluate a method call that looks like 
-    # a request for a conjugation.  The first descriptor pair is chopped off
-    # from the given 'name' and the rest is held.  The given is sent through 
-    # is recognized? where, if valid, an iVar is set.
-    #
-    # e.g. active_voice performs @voice=active
-    #
-    # Failure to successfully classify raises an exception
-    #
-    # If there is anything left in 'rest', then the function is recursively
-    # called with 'rest'.
-    #
-    
-    def evaluate_method(name)
-      command = name.to_s.match(/(\w+?_){2}/).to_s
-      rest    = name.to_s[command.to_s.length..name.to_s.length]
-      
-      # If you're at the last term, command does not get loaded
-      # but rest stays the same.  
-      if command !~ /\w/ and name == rest 
-        command = rest
-        rest    = nil 
-      end
-      
-      # We've reached the end
-      return if command !~ /\w/ and rest !~ /\w/
-
-      # Recurse  
-      evaluate_method(rest) if is_recognized?(command)  
-      
-    end
-     
-    # Given a string of the form "active_voice" ( or a "value/term" pair )
-    # test its validity by Object.send(term.to_sym, value).
-    
-    def is_recognized?(datum)
-      value, term = datum.split(/_/)
-      term = "calculate_" + term
-      send(term.to_sym, value)
-      
-      # Return true, because the 'send' call did not throw an exception
-      return true
-    end
-   
-    # Used to set the voice iVar OR raise an exception
-    def calculate_voice(param)
-      if param =~ /^(active|passive)$/i
-        @voice = param
-        return
-      end
-      raise "Unknown voice: #{param.to_s}, called."
-    end
-
-    # Used to set the voice iVar OR raise an exception    
-    def calculate_mood(param)
-      param.gsub!(/\W/, '')
-      if param =~ /(indicative|subjunctive)/i
-        @mood = param.downcase
-        return
-      end
-      raise "Unknown mood: #{param.to_s}, called"
-    end
-
-    # Used to set the voice iVar OR raise an exception    
-    def calculate_tense(param) 
-      param.downcase!
-      if @mood == "indicative"
-        # All the legitimate moods in the indicative
-        if param == "present"       or 
-           param == "imperfect"     or 
-           param == "future"        or 
-           param == "perfect"       or 
-           param == "pluperfect"    or 
-           param == "pastperfect"   or
-           param == "futureperfect" 
-           @tense = param
-         end 
-      elsif @mood == "subjunctive"
-        # All the legitimate moods in the subjunctive
-        if param == "present"    or 
-           param == "imperfect"  or 
-           param == "perfect"    or 
-           param == "pluperfect" or
-           param == "pastperfect"
-           @tense = param
-        end
-      else
-        raise "Tense [#{param}] was found to be invalid."
-      end
-    end
-    
-    def calculate_person(param)
-      @person = param.downcase
-    end
-  
-    def calculate_number(param)
-      @number = param.downcase
-    end
-    
-    def deponent_handler
-      raise "Sorry, we do not handle (semi-) deponent verbs at this time.  It's on the TODO list, thought!"
-    end
-    
-    def irregular_handler(test_infinitive)
-      if %w(esse nōlle).find{|irregular| test_infinitive.to_s == irregular}
-        raise "Sorry, we do not handle irregular verbs at this time.  It's on the TODO list, thought!"
-      end
-    end
-  end # ends the class
-  
-=begin rdoc
-
-  == Dependencies
-
-  None
-
-  == Author
-
-  Steven G. Harms, http://www.stevengharms.com
-
-=end
-end
-

data/lib/latinirb/paradigmatic_verbs.rb

@@ -1,17 +0,0 @@
-# encoding: utf-8
-
-require 'macronconversions'
-
-module Linguistics
-  module Latin
-    module Util
-      class LatinIRB
-        @aFirst   = Linguistics::Latin::Verb::LatinVerb.new Text::Latex::Util::Macronconversions.convert('am\={o} am\={a}re am\={a}v\={\i} amatum', 'mc')
-        @aSecond  = Linguistics::Latin::Verb::LatinVerb.new %q(moneō monēre monvī  monitum)
-        @aThird   = Linguistics::Latin::Verb::LatinVerb.new %q(agō   agere  ēgī    actum)
-        @aThirdIO = Linguistics::Latin::Verb::LatinVerb.new %q(capiō capere cēpī   captum)
-        @aFourth  = Linguistics::Latin::Verb::LatinVerb.new %q(audiō audīre audīvī auditum)
-      end
-    end
-  end
-end