llt-morphologizer 0.0.1

data/lib/llt/morphologizer/stem_lookup_statement_builder/declinable.rb

@@ -0,0 +1,214 @@
+module LLT::Morphologizer::StemLookupStatementBuilder::Declinable
+
+  DECL_COMPONENTS = %w{ issim errim illim ior} # nd, nt, s, bindevokale
+  NOMINATIVE_ENDING = [:ending, [ /(?<=us|er|es|u|e|al|ar|is|or|os|o|(?<=[^aeio])s|x|as|ur|men)$/]] # no a, um anymore                           # because of comparison (?<!i)
+  OTHER_CASE_ENDING = [:ending, [ /(?<=ior|ius|nter|iter)$|ae$|am$|arum$|as$|is$|(?<!aeo)i$|o$|orum$|os$|(?<!aeiou)e$|ei$|erum$|ebus$|es$|em$|(?<!i)us$|u$|uum$|ua$|ibus$|im$|ia$|ium$|(?<=n)s$|(?<=nt)er$|iter$/]] # ubus
+  UM_ENDING         = [:ending, [ /um$/, /ui$/ ]]   # i erased - filium, u erased - suum
+  IUS_ENDING        = [:ending, [ /(?<=i)us$/ ]] # 2013-10-08 solely for filius, Gaius...
+  A_ENDING          = [:ending, [ /(?<=[^ao])a$/ ]]  # removed u => sua
+  PRONOMINAL_ENDING = [:ending, [ /(?<=ali)u[sd]$/, /ius$/ ]]   # alius aliud
+  COMPARISON        = [:comparison_sign, [/ior$|ius$|issim$|lim$|rim$/]]    # ior, ius... ne ending at all...
+  PPA_OR_GERUND     = [:extension, [/n$|nt$|nd$/]]
+  THEMATIC_VOWEL    = [:thematic, [/[ue]$/]]
+  THEMATIC_I_OF_M   = [:thematic, [/i$/]]
+  FUTURE_PARTICIPLE = [:extension, [/ur$/]]
+
+
+  def create_declinables
+    setup(:declinable)
+
+    nominative
+    other_case
+    um_ending
+    ius_ending
+    a_ending
+    pronominal
+    contracted_vocative
+  end
+
+  private
+
+  def nominative
+    if has NOMINATIVE_ENDING
+      look_for :noun, :nom
+      look_for :adjective, :nom
+      reset :ending # ending would be overwritten by prepend otherwise!
+    end
+  end
+
+  def other_case
+    if has OTHER_CASE_ENDING
+      look_for :noun, :stem
+      look_for :adjective, :stem
+      look_for :verb, :ppp
+      comparison_or_verbal_extension
+      reset all
+    end
+  end
+
+  def um_ending
+    if has UM_ENDING
+      look_for :noun, :stem
+      look_for :adjective, :stem
+      look_for :verb, :ppp
+      comparison_or_verbal_extension
+      reset all
+    end
+  end
+
+  def ius_ending
+    # only filius is looked up here
+    if has IUS_ENDING
+      look_for :noun, :stem
+      reset all
+    end
+  end
+
+  def a_ending
+    if has A_ENDING
+      look_for :noun, :stem
+      look_for :adjective, :stem
+      look_for :verb, :ppp
+      comparison_or_verbal_extension
+      reset all
+    end
+  end
+
+  def pronominal
+    if has PRONOMINAL_ENDING
+      look_for :adjective, :stem
+      reset all
+    end
+
+  end
+
+  def contracted_vocative
+    if stem =~ /i$/
+      look_for :noun, :stem
+    end
+  end
+
+  def comparison_or_verbal_extension
+    if has COMPARISON then look_for :adjective, :stem; end
+    if has PPA_OR_GERUND  then look_for :verb, :pr
+      if has THEMATIC_VOWEL then look_for :same
+        if has THEMATIC_I_OF_M then look_for :same; end
+      end
+    end
+    if has FUTURE_PARTICIPLE then look_for :verb, :ppp; end
+  end
+
+  def valid_itypes_for_declinable
+    case table
+    when :noun      then valid_noun_classes
+    when :adjective then valid_adjective_classes
+    when :verb      then valid_verb_classes
+    end
+  end
+
+  def valid_noun_classes
+    if column == :nom
+      case stem              # 3 is consonantic stem, 31 vocalic stem - group 1 and so forth
+      #when /(?<=a)$/         then itype << 1 # disabled in new morphologizer
+      #when /(?<=um)$/        then itype << 2 # disabled in new morphologizer
+      when /(?<=us)$/        then itype << 3 << 4 # 2 disabled in new morphologizer     # [^i] for comparison. cf ior here and both in Adjective nom ### erased. filius. gaius
+      when /(?<=er)$/        then itype << 2 << 3
+      when /(?<=es)$/        then itype << 3 # 5 disabled in new morphologizer
+      when /(?<=u)$/         then itype << 4
+      when /(?<=ar)$/        then itype << 3 << 31 # added for Caesar, who is 3. could be done better, but performance won't count here.
+      when /(?<=e|al|ar)$/   then itype << 31
+      when /(?<=is)$/        then itype << 3 << 32 << 33
+      when /(?<=[^aeiou]s)$/ then itype << 3 << 33          # ns was excluded before. we don't know why.
+      when /(?<=x)$/         then itype << 3 << 33 # nox! 2013-10-07 20:51
+      when /(?<=[^i]or|os|o||as|ur|men)$/ then itype << 3
+      end
+    end
+
+    if column == :stem && ending.empty? && stem =~ /i$/ then itype << 2; end      # fili vocative
+
+    if column == :stem && !ending.empty?    #  nouns that end like a comparison?!
+      case stem + ending   # watch out: regexps musst be redefined... stem+ending doesn't work. check corporum.
+      when /[^aeou]a$/            then itype << 1 << 2 << 3 << 31 # a decl word whos stem ends with a vowel?
+      when /ae$|am$|arum$|as$/    then itype << 1
+      when /is$/                  then itype << 1 << 2 << 3 << 31 << 32 << 33
+      when /ui$/                  then itype << 2 << 4
+      when /[^aeou]i$/            then itype << 2 << 3 << 31 << 32 << 33
+      when /um$/                  then itype << 2 << 3 << 4 << 31 << 32 << 33       # [^i] erased. filius
+      when /o$|orum$|os$/         then itype << 2
+      when /ei$|erum$|ebus$/      then itype << 5
+      when /[^aeou]e$/            then itype << 2 << 3 << 33 << 5 # i allowed, acie
+      when /es$/                  then itype << 3 << 32 << 33 << 5
+      when /em$/                  then itype << 3 << 33 << 5
+      when /ibus$/                then itype << 3 << 31 << 32 << 33 << 4
+      when /us$|u$|ua$/           then itype << 2 << 4 # adds 2 in new morphologizer - evaluated through stem now
+      when /im$/                  then itype << 32
+      when /ia$/                  then itype << 31  # ineffective here, searched together with a now
+      #when /ium$/                 then itype << 31 << 32 << 33
+      end
+
+      itype << 5 if ending == "erum"   # rerum is missed
+    end
+  end
+
+  def valid_adjective_classes
+    if column == :nom
+      case stem
+      when "maior"                     then itype << 3
+      when /(?<=us|er|is|[^i]or)$/     then itype << 1 << 3 << 5
+      when /(?<=ar|s|x)$/              then itype << 3
+      end
+    end
+
+    if column == :stem && ! ending.empty?
+      # vacui - 2013-10-07 23:42 - well this is weird.
+      # Might account for vacui - but certainly not for exercitui,
+      # which will arrive here, even if it's not needed in any event.
+      # So do it only for vacu - and god knows what else...
+      stem << ending.slice!("u") if stem == "vacu" && ending == "ui"
+
+      case stem + ending
+      when /ius$/   then itype << 5
+      when /ter$/   then itype << 3 << 5 # 5? not sure. 2013-10-07 20:35
+      when /[a-z]$/ then itype << 1 << 3 << 5
+      end
+    end
+
+    if column == :stem && ! comparison_sign.empty? && ending.empty?
+      case stem
+      when /$/ then itype << 1 << 3
+      end
+    end
+  end
+
+  def valid_verb_classes
+    if column == :ppp && !ending.empty? && (extension.empty? || extension == "ur")
+      case stem
+      when /(?<=t|s|x)$/ then itype << 1 << 2 << 3 << 4 << 5
+      end
+    end
+
+    if column == :pr || column == :ppp && !extension.empty?
+      unless extension == "n" && ending != "s"
+        case stem
+        when /a$/      then itype << 1
+        when /i$/      then itype << 4
+        when /e$/      then itype << 2
+        when /[^aie]$/
+          itype << 3 if thematic == "e"
+          itype << 5 if thematic == "ie" || ending == "re"
+        end
+      end
+    end
+
+    if column == :pr && ending == "i" && extension.empty?
+      case stem
+      when /[^aie]$/ then itype << 3 << 5
+      end
+    end
+
+    if column == :pf
+      # perfect composition
+      itype << 1 << 2 << 3 << 4 << 5
+    end
+  end
+end

data/lib/llt/morphologizer/version.rb

@@ -0,0 +1,5 @@
+module LLT
+  class Morphologizer
+    VERSION = "0.0.1"
+  end
+end

data/llt-morphologizer.gemspec

@@ -0,0 +1,34 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'llt/morphologizer/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "llt-morphologizer"
+  spec.version       = LLT::Morphologizer::VERSION
+  spec.authors       = ["LFDM"]
+  spec.email         = ["1986gh@gmail.com"]
+  spec.summary       = %q{Morphological parsing of Latin forms}
+  spec.description   = spec.summary
+  spec.homepage      = "http://www.latin-language-toolkit.net"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.5"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "rspec"
+  spec.add_development_dependency "simplecov", "~> 0.7"
+  spec.add_development_dependency "llt-db_handler-stub"
+
+  spec.add_dependency "llt-constants"
+  spec.add_dependency "llt-core"
+  spec.add_dependency "llt-core_extensions"
+  spec.add_dependency "llt-db_handler"
+  spec.add_dependency "llt-form_builder"
+  spec.add_dependency "llt-helpers"
+  spec.add_dependency "llt-logger"
+end

data/spec/lib/llt/morphologizer/lookup_statement_spec.rb

@@ -0,0 +1,29 @@
+require 'spec_helper'
+
+describe LLT::Morphologizer::LookupStatement do
+  let(:ls) { LLT::Morphologizer::LookupStatement }
+  let(:rosam) { ls.new("ros", :noun, :stem, [1], { ending: "am" }) }
+
+  describe "#stem_type" do
+    it "returns the stem type" do
+      rosam.stem_type.should == :stem
+    end
+  end
+
+  describe "#type" do
+    it "returns the type" do
+      rosam.type.should == :noun
+    end
+  end
+
+  describe "#to_query" do
+    it "builds a query in a hash format, that corresponds with the db handler interface" do
+      rosam.to_query.should == { type: :noun, stem_type: :stem, stem: "ros", restrictions: { type: :inflection_class, values: [1] } }
+    end
+
+    it "build a query for laudavit" do
+      ros = ls.new("laudav", :verb, :pf, ["v"], { ending: "it" })
+      ros.to_query.should == { type: :verb, stem_type: :pf, stem: "laudav", restrictions: { type: :pf_composition, values: ["v"] } }
+    end
+  end
+end

data/spec/lib/llt/morphologizer/stem_lookup_statement_builder_spec.rb

@@ -0,0 +1,39 @@
+require 'spec_helper'
+
+describe LLT::Morphologizer::StemLookupStatementBuilder do
+
+  def slsb(word)
+    LLT::Morphologizer::StemLookupStatementBuilder.new(word, LLT::Logger.new)
+  end
+
+  describe "#statements" do
+    it "creates no separate nominative lookup request for a, um, es and us endings - different from old implementation" do
+      slsb("rosa").statements.map(&:to_query).count { |h| h[:stem_type] == :nom }.should == 0
+      slsb("templum").statements.map(&:to_query).count { |h| h[:stem_type] == :nom }.should == 0
+      slsb("res").statements.map(&:to_query).count { |h| h[:stem_type] == :nom && h[:restrictions][:values].include?(5) }.should == 0
+      slsb("hortus").statements.map(&:to_query).count { |h| h[:stem_type] == :nom && h[:restrictions][:values].include?(2)}.should == 0
+    end
+
+    it "searches in persona, place and ethnic table when a word is capitalized" do
+      plato_queries = slsb("Plato").statements.map(&:to_query)
+      plato_queries.select { |h| h[:type] == :persona }.should_not be_empty
+      plato_queries.select { |h| h[:type] == :place }.should_not be_empty
+      plato_queries.select { |h| h[:type] == :ethnic }.should_not be_empty
+    end
+
+    it "only stems are searched in the ethnic table" do
+      queries = slsb("Haeduus").statements.map(&:to_query)
+      queries.none? { |h| h[:type] == :ethnic && h[:stem_type] == :nom }.should be_true
+      queries.any?  { |h| h[:type] == :ethnic && h[:stem_type] == :stem }.should be_true
+    end
+
+    it "searches for capitalized words in downcase, expect for names, places and ethnics" do
+      plato_queries = slsb("Plato").statements.map(&:to_query)
+      plato_queries.any? { |h| h[:type] == :noun && h[:stem] =~ /^[a-z].*/ }.should be_true
+      plato_queries.none? { |h| h[:type] == :noun && h[:stem] =~ /^[A-Z].*/ }.should be_true
+
+      plato_queries.any? { |h| h[:type] == :persona && h[:stem] =~ /^[A-Z].*/ }.should be_true
+      plato_queries.none? { |h| h[:type] == :persona && h[:stem] =~ /^[a-z].*/ }.should be_true
+    end
+  end
+end

data/spec/lib/llt/morphologizer_spec.rb

@@ -0,0 +1,524 @@
+require 'spec_helper'
+
+describe LLT::Morphologizer do
+  it 'should have a version number' do
+    LLT::Morphologizer::VERSION.should_not be_nil
+  end
+
+  let(:stub_db) { LLT::DbHandler::Stub.new }
+  let(:morphologizer) { LLT::Morphologizer.new(db: stub_db) }
+
+  def morph_stub(word)
+    m = LLT::Morphologizer.new(db: LLT::DbHandler::Stub.new)
+    m.send(:setup, word)
+    m
+  end
+
+  before(:all) { LLT::DbHandler::Stub.setup }
+
+  describe "#personal_pronons" do
+    # this tests some private methods just to be safe
+    context "morphologizes pronouns" do
+      it "with se" do
+        se = morph_stub("se")
+        se.send(:clook_up, :personal_pronouns).should have(4).items
+        se.send(:unique_pers_pron?).should be_true
+      end
+
+      it "with Se" do
+        se = morph_stub("Se")
+        se.send(:clook_up, :personal_pronouns).should have(4).items
+        se.send(:unique_pers_pron?).should be_true
+      end
+
+      it "with secum" do
+        secum = morph_stub("secum")
+        forms = secum.send(:clook_up, :personal_pronouns)
+        secum.send(:unique_pers_pron?).should be_true
+        forms.should have(2).items
+        forms.first.to_s(:segmentized).should == "se-cum"
+      end
+
+      it "with nosmet" do
+        nosmet = morph_stub("nosmet")
+        forms = nosmet.send(:clook_up, :personal_pronouns)
+        nosmet.send(:unique_pers_pron?).should be_true
+        forms.should have(2).items
+        forms.first.to_s(:segmentized).should == "nos-met"
+      end
+    end
+  end
+
+  describe "#other_pronouns" do
+     context "morphologizes pronouns" do
+       it "with hic" do
+         morph_stub("hic").send(:other_pronouns).should have(1).item
+         morph_stub("hunc").send(:other_pronouns).should have(1).item
+         morph_stub("huic").send(:other_pronouns).should have(3).item
+       end
+
+       it "with aliqui" do
+         morph_stub("alicuius").send(:other_pronouns).should have(3).items
+       end
+
+       it "with quicumque" do
+         morph_stub("quibuscumque").send(:other_pronouns).should have(6).items
+       end
+
+       it "with quilibet" do
+         morph_stub("quaelibet").send(:other_pronouns).should have(4).items
+       end
+
+       it "with quivis" do
+         morph_stub("quodvis").send(:other_pronouns).should have(2).items
+       end
+
+       it "with quidam" do
+         morph_stub("quibusdam").send(:other_pronouns).should have(6).items
+       end
+
+       it "with is" do
+         morph_stub("eas").send(:other_pronouns).should have(1).item
+         morph_stub("is").send(:other_pronouns).should have(7).item # sadly - eis...
+         morph_stub("ii").send(:other_pronouns).should have(1).item
+       end
+
+       it "with idem" do
+         morph_stub("eorundem").send(:other_pronouns).should have(2).items
+         morph_stub("eisdem").send(:other_pronouns).should have(6).items
+         morph_stub("iisdem").send(:other_pronouns).should have(6).items
+       end
+
+       it "with uter" do
+         morph_stub("utrum").send(:other_pronouns).should have(3).items
+       end
+
+       it "with uterque" do
+         morph_stub("utrumque").send(:other_pronouns).should have(3).items
+         morph_stub("utriusque").send(:other_pronouns).should have(3).items
+       end
+
+       it "with quisque" do
+         morph_stub("cuiusque").send(:other_pronouns).should have(3).items
+       end
+
+       it "with quisquam"do
+         morph_stub("quisquam").send(:other_pronouns).should have(2).items
+       end
+
+       it "with quisquam"do
+         morph_stub("quemquam").send(:other_pronouns).should have(2).items
+       end
+
+       it "with quispiam" do
+         morph_stub("quempiam").send(:other_pronouns).should have(2).items
+       end
+
+       it "with quispiam" do
+         morph_stub("quispiam").send(:other_pronouns).should have(2).items
+       end
+
+       it "with quibuscum" do
+         morph_stub("quibuscum").send(:other_pronouns).should have(3).items
+       end
+
+       it "with quonam" do
+         morph_stub("quonam").send(:other_pronouns).should have(2).items
+       end
+
+      # Might be solved through an exceptional form
+      #m = morph("i")
+      #m.pronouns.should have(1).item
+    end
+
+    it "returns when a unique pronoun like huius is found" do
+      morphologizer.should_not receive(:direct_lookup)
+      morphologizer.morphologize("huius")
+    end
+
+    it "continues when a homographic pronoun like his is found" do
+      morphologizer.should receive(:direct_lookup)
+      morphologizer.morphologize("hic")
+    end
+  end
+
+  describe "#prepositions" do
+    it "returns when a unique preposition like in is found" do
+      morphologizer.should_not receive(:direct_lookup)
+      morphologizer.morphologize("in")
+    end
+
+    it "goes on when a not uniq prep like cum is found - another entry should be present and then returned" do
+      morphologizer.should_not receive(:direct_lookup)
+      morphologizer.morphologize("cum").should have(2).items
+    end
+  end
+
+  describe "#numerals" do
+    it "returns when a roman numeral is found" do
+      morphologizer.should_not receive(:direct_lookup)
+      morphologizer.morphologize("MD").should have(1).item
+    end
+  end
+
+  describe "#look_up" do
+    context "with conjunctions" do
+      it "returns when a unique conjunction like et is found" do
+        morphologizer.should_not receive(:direct_lookup)
+        morphologizer.morphologize("et")
+      end
+    end
+
+    #context "with subjunctions" do
+    #  it "returns when a unique conjunction like et is found" do
+    #  end
+    #end
+  end
+
+  describe "#morphologize" do
+    LLT::DbHandler::Stub.setup
+
+    describe "returns morphologized forms" do
+      context "with nouns" do
+        it "ratio" do
+          f = morphologizer.morphologize("ratio")
+          f.should have(2).item
+          f1, f2 = f
+          f1.casus.should == 1
+          f2.casus.should == 5
+        end
+
+        it "homine" do
+          f = morphologizer.morphologize("homine")
+          f.should have(1).item
+          f.first.casus.should == 6
+          f.first.to_s(:segmentized).should == "homin-e"
+        end
+
+        it "nox" do
+          f = morphologizer.morphologize("nox")
+          f.should have(2).items
+        end
+
+        it "serve" do
+          f = morphologizer.morphologize("serve")
+          f.should have(1).item
+        end
+
+        it "fili - contracted vocative" do
+          f = morphologizer.morphologize("fili")
+          f.should have(1).item
+        end
+
+        it "filius - ius o declension" do
+          f = morphologizer.morphologize("filius")
+          f.should have(1).item
+        end
+      end
+
+      context "with verbs" do
+        it "miserunt" do
+          f = morphologizer.morphologize("miserunt")
+          f.should have(1).item
+        end
+
+        it "hortant" do
+          f = morphologizer.morphologize("hortant")
+          f.should have(0).items # no active forms
+        end
+
+        it "hortatur" do
+          f = morphologizer.morphologize("hortatur")
+          f.should have(1).item
+        end
+
+        context "and infinitives" do
+          # the active one all bring the stupid pass inf...
+          it "audire" do
+            f = morphologizer.morphologize("audire")
+            f.should have(2).items
+          end
+
+          it "audiri" do
+            f = morphologizer.morphologize("audiri")
+            f.should have(1).item
+          end
+
+          it "canare" do
+            f = morphologizer.morphologize("canare")
+            f.should have(2).items
+          end
+
+          it "canari" do
+            f = morphologizer.morphologize("canari")
+            f.should have(1).items
+          end
+
+          it "monere" do
+            f = morphologizer.morphologize("monere")
+            f.should have(2).items
+          end
+
+          it "hortari" do
+            f = morphologizer.morphologize("hortari")
+            f.should have(1).items
+          end
+        end
+      end
+
+      context "with plain adverbs" do
+        it "iam" do
+          f = morphologizer.morphologize("iam")
+          f.should have(1).item
+        end
+      end
+
+      context "with adverbs from adjectives" do
+        it "diligenter" do
+          f = morphologizer.morphologize("diligenter")
+          f.should have(1).item
+        end
+
+        it "laete" do
+          # the real world has a noun as well, will never be
+          # in the stub db I guess.
+          f = morphologizer.morphologize("laete")
+          f.should have(2).item # there's actually a vocative as well...
+          f.first.casus.should == 5
+          f.map(&:to_s).should == %w{ laete laete }
+        end
+      end
+
+      context "with adjectives" do
+        it "feri" do
+          f = morphologizer.morphologize("feri")
+          f.should have(4).items # all from ferus3
+        end
+      end
+
+      context "with cardinals" do
+        it "duo" do
+          f = morphologizer.morphologize("duo")
+          f.should have(4).items
+        end
+
+        it "sex" do
+          f = morphologizer.morphologize("sex")
+          f.should have(1).item
+        end
+      end
+
+      context "with ethnics" do
+        it "Haeduorum" do
+          f = morphologizer.morphologize("Haeduorum")
+          f.should have(2).items
+          f.first.to_s.should == "Haeduorum"
+        end
+      end
+
+      context "with pronouns" do
+        it "quis" do
+          f = morphologizer.morphologize("quis")
+          f.should have(2).items # m && f?
+        end
+
+        it "quid" do
+          f = morphologizer.morphologize("quid")
+          f.should have(2).items # nom and acc
+        end
+
+        it "aliquis" do
+          f = morphologizer.morphologize("aliquis")
+          f.should have(2).items
+        end
+
+        it "quidque" do
+          f = morphologizer.morphologize("quidque")
+          f.should have(2).items
+        end
+
+        it "quodque" do
+          f = morphologizer.morphologize("quodque")
+          f.should have(2).items
+        end
+
+        it "quisque" do
+          f = morphologizer.morphologize("quisque")
+          f.should have(3).items
+        end
+
+        it "quicquam" do
+          f = morphologizer.morphologize("quicquam")
+          f.should have(2).items
+        end
+
+        it "quisquis" do
+          f = morphologizer.morphologize("quisquis")
+          f.should have(2).items
+        end
+
+        it "quidquid" do
+          f = morphologizer.morphologize("quidquid")
+          f.should have(2).items
+        end
+
+        it "quoquo" do
+          f = morphologizer.morphologize("quoquo")
+          f.should have(3).item # m f n, it's substantivic!
+        end
+
+        it "quicquid" do
+          f = morphologizer.morphologize("quicquid")
+          f.should have(2).items
+        end
+
+        it "unusquisque" do
+          f = morphologizer.morphologize("unusquisque")
+          f.map(&:to_s).should == %w{ unusquisque } * 3
+        end
+
+        it "uniuscuiusque" do
+          f = morphologizer.morphologize("uniuscuiusque")
+          f.map(&:to_s).should == %w{ uniuscuiusque } * 3
+        end
+
+      end
+
+      context "with mixed forms" do
+        it "ita - adverb and ppp of ire" do
+          f = morphologizer.morphologize("ita")
+          f.should have(2).item
+        end
+
+        it "fero - ferre and ferus3" do
+          f = morphologizer.morphologize("fero")
+          f.should have(5).items # 1 from ferre, 4 from ferus3
+        end
+
+        it "subito - adverb and ppp of ire" do
+          f = morphologizer.morphologize("subito")
+          f.should have(5).items # 1 adv, 4 ppp
+        end
+      end
+    end
+
+    describe "handles irregular verbs" do
+      it "fiebat" do
+        f = morphologizer.morphologize("fiebat")
+        f.should have(1).item
+      end
+
+      it "fio" do
+        f = morphologizer.morphologize("fio")
+        f.should have(1).item
+      end
+
+      it "posse" do
+        f = morphologizer.morphologize("posse")
+        f.should have(1).item
+      end
+
+      it "ferri" do
+        f = morphologizer.morphologize("ferri")
+        f.should have(1).item
+      end
+    end
+
+    describe "handles prefixed irregular verbs" do
+      it "desum" do
+        f = morphologizer.morphologize("desum")
+        f.should have(1).item
+        f.first.to_s(:segmentized).should == "de-s-u-m"
+      end
+
+      it "maluit" do
+        f = morphologizer.morphologize("maluit")
+        f.should have(1).item
+        f.first.to_s(:segmentized).should == "malu-it"
+        f.first.tempus.should == :pf
+      end
+
+      it "mavult" do
+        f = morphologizer.morphologize("mavult")
+        f.should have(1).item
+        f.first.to_s(:segmentized).should == "mavul-t"
+      end
+
+      it "it" do
+        f = morphologizer.morphologize("it")
+        f.should have(1).item
+        f.first.to_s(:segmentized).should == "i-t"
+      end
+
+      it "vult" do
+        f = morphologizer.morphologize("vult")
+        f.should have(1).item
+        f.first.to_s(:segmentized).should == "vul-t"
+      end
+
+      it "nolumus" do
+        f = morphologizer.morphologize("nolumus")
+        f.should have(1).item
+        f.first.to_s(:segmentized).should == "nol-u-mus"
+      end
+
+      it "contulissent" do
+        f = morphologizer.morphologize("contulissent")
+        f.should have(1).item
+        f.first.to_s(:segmentized).should == "con-tul-isse-nt"
+      end
+
+      it "intulisset" do
+        f = morphologizer.morphologize("intulisset")
+        f.should have(1).item
+        f.first.to_s(:segmentized).should == "in-tul-isse-t"
+      end
+
+      it "inito" do
+        f = morphologizer.morphologize("inito")
+        f.should have(4).item
+      end
+    end
+
+    describe "takes an optional keyword argument add_to" do
+      let(:token_dummy) do
+        Class.new do
+          attr_reader :forms
+          def initialize; @forms = []; end
+          def <<(forms); @forms += forms; end
+        end.new
+      end
+
+      it "adds the result to the given object if is #<< implemented" do
+        forms = morphologizer.morphologize("est", add_to: token_dummy)
+        token_dummy.forms.should == forms
+      end
+
+      it "does nothing to the given object when #<< it does not respond to" do
+        token = double(respond_to?: false)
+        token.should_not receive(:<<)
+        morphologizer.morphologize("est", add_to: token)
+      end
+    end
+
+    it "writes stem pack objects to morphologized forms" do
+      forms = morphologizer.morphologize('homo')
+      homo = forms.first
+      homo.stems.should_not be_nil
+
+      forms = morphologizer.morphologize('est')
+      est = forms.first
+      est.stems.should_not be_nil
+    end
+
+    it "one instance handles multiple requests" do
+      tokens = %w{ homo ratio }
+      forms = tokens.map { |t| morphologizer.morphologize(t) }
+      forms.should have(2).items
+      h = forms[0]
+      r = forms[1]
+      (h.any? && h.all? { |f| f.to_s == "homo"}) .should be_true
+      (r.any? && r.all? { |f| f.to_s == "ratio"}).should be_true
+    end
+  end
+end