latinverb 0.9.3 → 0.9.4

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

@@ -1,87 +0,0 @@
-# encoding: UTF-8
-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
-          data_structure = {}
-          @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
-          to_hash.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( self.to_h )
-        end
-
-      end
-    end
-  end
-end

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

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

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

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

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

@@ -1,22 +0,0 @@
-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 doing much displaying here as this is a LIBRARY.  Implement this elsewhere."
-          pretty_generate
-        end
-      end
-    end
-  end
-end

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

@@ -1,34 +0,0 @@
-module Linguistics
-  module Latin
-    module Verb
-      class LatinVerb
-        ##
-        #
-        # Some verbs only take a active/indic/pres/3rd/sg ("it rains").  For
-        # these we will not add the full vectors of methods, but will only
-        # respond to THAT vector.
-        #
-        ##
-        module Impersonal
-          def self.extended(extending_instance)
-            extending_instance.instance_eval do
-              prepare_present_only
-            end
-          end
-
-          def prepare_present_only
-            singleton_class.class_eval do
-              def active_voice_indicative_mood_present_tense
-                TenseBlock.new ["", "", @original_string,
-                                "", "", ""]
-              end
-              def active_voice_indicative_mood_present_tense_third_person_singular_number
-                return active_voice_indicative_mood_present_tense[2]
-              end
-            end
-          end
-        end
-      end
-    end
-  end
-end

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

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

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

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

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

@@ -1,100 +0,0 @@
-# encoding: UTF-8
-# vim:  set fdm=marker tw=80 sw=2:
-
-module Linguistics
-  # Generalized module for handling lingustics related to Latin
-  module Latin
-    # Generalized module for handling lingustics related to Latin's verbal aspects
-    module Verb
-      class LatinVerb
-        ### {{{
-        #
-        # == 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
-        #
-        #
-        ### }}}
-        class LatinVerbClassifier# {{{
-          attr_reader :classification
-
-          def initialize(input)
-            @classification = self.classify input
-          end
-
-          def classify(s)
-
-            divided_string = s.split( /\s+/ )
-
-            first_pres = divided_string[0] || ''
-            infinitive = divided_string[1] || ''
-
-            return Linguistics::Latin::Verb::Classification::Defective if
-              Linguistics::Latin::Verb::LatinVerb::DEFECTIVE_VERBS.member? first_pres
-
-            return Linguistics::Latin::Verb::Classification::Irregular if
-              Linguistics::Latin::Verb::LatinVerb::IRREGULAR_VERBS.member? first_pres
-
-            return Linguistics::Latin::Verb::Classification::Semideponent if
-              Linguistics::Latin::Verb::LatinVerb::SEMI_DEPONENTS.keys.any?{ |k| first_pres=~/#{k}$/} &&
-              s !~ /PreventDeponentInfiniteRegress/
-
-            return Linguistics::Latin::Verb::Classification::Impersonal if
-              Linguistics::Latin::Verb::LatinVerb::IMPERSONAL_VERBS.member? s
-
-            # Very irregular irregulars, A&G206, e/f
-            return Linguistics::Latin::Verb::Classification::Irregular if
-              s =~ %r'^(aiō|quaesō|ovāre)$'
-
-            return Linguistics::Latin::Verb::Classification::Deponent if
-              (infinitive =~ /ī$/  and first_pres =~ /r$/)
-
-            return Linguistics::Latin::Verb::Classification::Regular
-
-          end
-
-          def set_as_defective
-            unless @classification == Linguistics::Latin::Verb::Classification::Impersonal
-              @classification = Linguistics::Latin::Verb::Classification::PresentOnly
-            end
-          end
-
-          def present_only?
-            @present_only ||= ( @classification ==  Linguistics::Latin::Verb::Classification::PresentOnly )
-          end
-
-          def deponent?
-            @deponent ||= (@classification == Linguistics::Latin::Verb::Classification::Deponent)
-          end
-
-          def semideponent?
-            @semideponent ||= (@classification == Linguistics::Latin::Verb::Classification::Semideponent)
-          end
-
-          def impersonal?
-            @impersonal ||= (@classification == Linguistics::Latin::Verb::Classification::Impersonal)
-          end
-
-          def irregular?
-            @irregular = @classification == Linguistics::Latin::Verb::Classification::Irregular
-          end
-
-          def regular?
-            @regular = @classification == Linguistics::Latin::Verb::Classification::Regular
-          end
-        end# }}}
-      end
-    end
-  end
-end

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

@@ -1,32 +0,0 @@
-# encoding: UTF-8
-# vim:  set fdm=marker tw=80 sw=2:
-
-module Linguistics
-  # Generalized module for handling lingustics related to Latin
-  module Latin
-    # Generalized module for handling lingustics related to Latin's verbal aspects
-    module Verb
-      class LatinVerb
-        class LatinVerbInitializationError < Exception; end
-        class LatinVerbInputSanitizer# {{{
-          def initialize(raw_data)
-            @raw_data = raw_data.dup
-
-            unless ( raw_data.is_a? String )
-              raw_data_type    = raw_data.class.to_s.downcase
-              method_prefix    = 'construct_original_string_for_'
-              mutator          = ( method_prefix + raw_data_type ).to_sym
-              raw_data = send(mutator, raw_data)
-            end
-
-            @sanitized_data = raw_data
-          end
-
-          def to_s
-            return @sanitized_data
-          end
-        end# }}}
-      end
-    end
-  end
-end

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

@@ -1,106 +0,0 @@
-# encoding: UTF-8
-# vim:  set fdm=marker tw=80 sw=2:
-
-module Linguistics
-  # Generalized module for handling lingustics related to Latin
-  module Latin
-    # Generalized module for handling lingustics related to Latin's verbal aspects
-    module Verb
-      class LatinVerb
-        class LatinVerbPPExtractor# {{{
-          attr_reader :passive_perfect_participle, :first_person_perfect, :present_active_infinitive, :first_person_singular
-
-          class << self# {{{
-
-            def calculate_stem(present_active_infinitive, first_person_singular)# {{{
-              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# }}}
-
-            def derive_parts_from_given_string(s)# {{{
-              s.split(/\s+/)
-            end# }}}
-
-            def calculate_participial_stem(present_active_infinitive, first_person_singular)
-              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
-          end# }}}
-
-          def initialize(input_string, classification)# {{{
-            @data_string = input_string
-            @_classification = classification
-
-            non_defective = ( classified_as.deponent? or
-                              classified_as.semideponent? or
-                              classified_as.impersonal? )
-            unless non_defective
-              @principal_parts = self.class.derive_parts_from_given_string input_string
-              @first_person_singular, @present_active_infinitive,
-              @first_person_perfect, @passive_perfect_participle = @principal_parts
-            else
-              unless classified_as.impersonal?
-                @deponent_proxy = Linguistics::Latin::Verb::LatinVerb.create_pseudo_active_mask_for_deponent(input_string)
-              end
-            end
-          end# }}}
-
-          def participial_stem
-            @participial_stem ||= self.class.calculate_participial_stem(@present_active_infinitive, @first_person_singular)
-          end
-
-          def principal_parts
-            @principal_parts
-          end
-
-          def stem
-            @stem ||= self.class.calculate_stem(present_active_infinitive, first_person_singular)
-          end
-
-          def classification
-            @_classification
-          end
-          alias :classified_as :classification
-
-
-        end
-
-        def to_a
-          @principal_parts
-        end
-      end
-    end
-  end
-end