latinverb 0.9.5 → 1.0.0.pre

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

@@ -1,19 +0,0 @@
-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

@@ -1,19 +0,0 @@
-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

@@ -1,31 +0,0 @@
-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

@@ -1,20 +0,0 @@
-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

@@ -1,76 +0,0 @@
-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

@@ -1,40 +0,0 @@
-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

@@ -1,50 +0,0 @@
-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

@@ -1,58 +0,0 @@
-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

@@ -1,42 +0,0 @@
-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

@@ -1,32 +0,0 @@
-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

data/lib/latinverb/components/principal_parts_extractor.rb

@@ -1,35 +0,0 @@
-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

@@ -1,81 +0,0 @@
-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

@@ -1,35 +0,0 @@
-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.rb

@@ -1,9 +0,0 @@
-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

@@ -1,41 +0,0 @@
-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

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

data/lib/latinverb/serialization/hash.rb

@@ -1,17 +0,0 @@
-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

@@ -1,41 +0,0 @@
-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

@@ -1,15 +0,0 @@
-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